Integrate Anthropic client for dynamic plan generation (#421)

* feat: integrate Anthropic client for dynamic plan generation

- Replace static plan generation in `plan_issue.py` with `ChatAnthropic`.
- Implement `PlanModel` Pydantic model for structured output validation.
- Inject repository file context into the prompt to improve plan accuracy.
- Update `__init__.py` to export `plan_issue` and `execute_issue` from their respective modules.
- Add unit tests for `plan_issue`.

* fix: resolve type errors in langgraph_service and orchestrator

- Consolidate GraphState type in types.py with all required fields
- Add type: ignore comments for external package imports (pydantic, langchain)
- Fix variable redefinition in execute_issue.py
- Create separate create_pr.py node module
- Update pyproject.toml with correct package name (multiplai)
- Fix null vs undefined type mismatch in orchestrator.ts

* fix(ci): update langgraph_service path to packages/api/langgraph_service

* fix(ci): use pnpm for turborepo and fix Python lint issues

- Switch CI from bun to pnpm for turborepo compatibility
- Add missing newlines to Python __init__.py files
- Shorten long comment line in execute_issue.py

* fix(ci): remove pnpm version conflict and add missing newline

* fix(lint): sort imports in test_plan_issue.py

---------

Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>
Co-authored-by: Ronaldo Martins <ron@ldinho.com.br>

Author: google-labs-jules[bot]

.github/workflows/ci.yml

@@ -13,28 +13,38 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - uses: oven-sh/setup-bun@v2
+      - uses: pnpm/action-setup@v4
+
+      - uses: actions/setup-node@v4
         with:
-          bun-version: latest
+          node-version: "20"
+          cache: "pnpm"
 
       - name: Install dependencies
-        run: bun install
+        run: pnpm install
 
       - name: Type check
-        run: bun run typecheck
+        run: pnpm run typecheck
 
   test:
     name: Test
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
 
+      - uses: pnpm/action-setup@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          cache: "pnpm"
+
       - uses: oven-sh/setup-bun@v2
         with:
           bun-version: latest
 
       - name: Install dependencies
-        run: bun install
+        run: pnpm install
 
       - name: Run tests
         run: bun test || echo "No tests found"
@@ -44,7 +54,7 @@ jobs:
     runs-on: ubuntu-latest
     defaults:
       run:
-        working-directory: langgraph_service
+        working-directory: packages/api/langgraph_service
     steps:
       - uses: actions/checkout@v4
 
@@ -69,7 +79,7 @@ jobs:
     runs-on: ubuntu-latest
     defaults:
       run:
-        working-directory: langgraph_service
+        working-directory: packages/api/langgraph_service
     steps:
       - uses: actions/checkout@v4
 

packages/api/langgraph_service/pyproject.toml

@@ -1,5 +1,5 @@
 [project]
-name = "langgraph-service"
+name = "multiplai"
 version = "0.1.0"
 requires-python = ">=3.11"
 dependencies = [
@@ -10,6 +10,7 @@ dependencies = [
     "fastapi>=0.115.0",
     "uvicorn>=0.32.0",
     "pydantic>=2.9.0",
+    "pydantic-settings>=2.0.0",
     "httpx>=0.27.0",
     "python-dotenv>=1.0.0",
     "structlog>=24.0.0",
@@ -20,4 +21,23 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [tool.hatch.build.targets.wheel]
-packages = ["src/langgraph_service"]
+packages = ["src/multiplai"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+pythonpath = ["src"]
+
+[tool.mypy]
+python_version = "3.11"
+warn_return_any = true
+warn_unused_configs = true
+ignore_missing_imports = false
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "W"]
+ignore = []

packages/api/langgraph_service/src/multiplai/__init__.py

@@ -1,3 +1,3 @@
 """MultiplAI - Multi-agent AI system for automated software development."""
 
-__version__ = '0.1.0'
+__version__ = '0.1.0'

packages/api/langgraph_service/src/multiplai/config.py

@@ -6,7 +6,7 @@
 
 from functools import lru_cache
 
-from pydantic_settings import BaseSettings
+from pydantic_settings import BaseSettings  # type: ignore[import-not-found]
 
 
 class Settings(BaseSettings):

packages/api/langgraph_service/src/multiplai/graph.py

@@ -13,26 +13,13 @@
 import copy
 import inspect
 from dataclasses import dataclass
-from typing import Any, Awaitable, Callable, Dict, Optional, TypedDict
+from typing import Any, Awaitable, Callable, Dict, Optional
 
+from multiplai.types import GraphState
 
 END = "__end__"
 
 
-class GraphState(TypedDict, total=False):
-    """Shared graph state.
-
-    This is a pragmatic schema for tests and basic usage.
-    """
-
-    status: str
-    context: Dict[str, Any]
-    plan: Dict[str, Any]
-    execution_result: Dict[str, Any]
-    pr_url: str
-    trace: list[str]
-
-
 class MemorySaver:
     """A minimal in-memory checkpointer compatible with this module's graph."""
 
@@ -47,7 +34,10 @@ def put(self, thread_id: str, state: GraphState) -> None:
         self._store[thread_id] = copy.deepcopy(state)
 
 
-NodeFn = Callable[[GraphState], Dict[str, Any] | GraphState | None | Awaitable[Dict[str, Any] | GraphState | None]]
+NodeFn = Callable[
+    [GraphState],
+    Dict[str, Any] | GraphState | None | Awaitable[Dict[str, Any] | GraphState | None],
+]
 
 
 @dataclass(frozen=True)
@@ -57,7 +47,9 @@ class _CompiledGraph:
     entry_point: str
     checkpointer: MemorySaver
 
-    async def ainvoke(self, state: GraphState, config: Optional[Dict[str, Any]] = None) -> GraphState:
+    async def ainvoke(
+        self, state: GraphState, config: Optional[Dict[str, Any]] = None
+    ) -> GraphState:
         current = self.entry_point
         thread_id = "default"
         if config is not None:
@@ -77,7 +69,8 @@ async def ainvoke(self, state: GraphState, config: Optional[Dict[str, Any]] = No
                 result = await result
             if result:
                 # Treat the node output as a partial state update.
-                working_state.update(result)  # type: ignore[arg-type]
+                for key, value in result.items():
+                    working_state[key] = value  # type: ignore[literal-required]
             self.checkpointer.put(thread_id, working_state)
 
             current = self.edges.get(current, END)
@@ -92,7 +85,7 @@ class StateGraph:
     sufficient for wiring, compilation, and testing of node sequencing.
     """
 
-    def __init__(self, state_schema: type[GraphState]) -> None:
+    def __init__(self, state_schema: type) -> None:
         self._state_schema = state_schema
         self._nodes: Dict[str, NodeFn] = {}
         self._edges: Dict[str, str] = {}
@@ -138,7 +131,12 @@ async def plan_issue(state: GraphState) -> Dict[str, Any]:
     _append_trace(state, "plan_issue")
     return {
         "status": "planned",
-        "plan": {"steps": ["execute", "create_pr"]},
+        "plan": {
+            "steps": ["execute", "create_pr"],
+            "definition_of_done": [],
+            "target_files": [],
+            "estimated_complexity": "low",
+        },
     }
 
 
@@ -187,4 +185,4 @@ def build_graph() -> _CompiledGraph:
     return workflow.compile(checkpointer=MemorySaver())
 
 
-graph = build_graph()
+graph = build_graph()

packages/api/langgraph_service/src/multiplai/nodes/__init__.py

@@ -3,11 +3,14 @@
 This package exposes the node callables used by the graph runner.
 """
 
-from .load_context import create_pr, execute_issue, load_context, plan_issue
+from .create_pr import create_pr
+from .execute_issue import execute_issue
+from .load_context import load_context
+from .plan_issue import plan_issue
 
 __all__ = [
     "load_context",
     "plan_issue",
     "execute_issue",
     "create_pr",
-]
+]

packages/api/langgraph_service/src/multiplai/nodes/create_pr.py

@@ -0,0 +1,35 @@
+"""Create PR node for MultiplAI LangGraph workflows.
+
+This module contains the `create_pr` node, responsible for creating a
+pull request from the generated diff.
+"""
+
+from __future__ import annotations
+
+from multiplai.types import GraphState
+
+
+async def create_pr(state: GraphState) -> GraphState:
+    """Create a pull request from the generated diff.
+
+    Args:
+        state: Current graph state with diff.
+
+    Returns:
+        Updated graph state with:
+        - status set to 'pr_created'
+        - pr_url containing the PR URL
+        - pr_data containing PR metadata
+    """
+    # Placeholder implementation
+    # In the future, this will use GitHub API to create the PR
+
+    updated_state = GraphState(**state)
+    updated_state["status"] = "pr_created"
+    updated_state["pr_url"] = "https://github.com/example/repo/pull/1"
+    updated_state["pr_data"] = {
+        "number": 1,
+        "html_url": "https://github.com/example/repo/pull/1",
+        "state": "open",
+    }
+    return updated_state

packages/api/langgraph_service/src/multiplai/nodes/execute_issue.py

@@ -7,14 +7,14 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, TypeAlias
-
-from langchain_anthropic import ChatAnthropic
-from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_anthropic import ChatAnthropic  # type: ignore[import-not-found]
+from langchain_core.messages import (  # type: ignore[import-not-found]
+    HumanMessage,
+    SystemMessage,
+)
 
 from multiplai.config import get_settings
-
-GraphState: TypeAlias = Dict[str, Any]
+from multiplai.types import GraphState
 
 
 async def execute_issue(state: GraphState) -> GraphState:
@@ -41,10 +41,10 @@ async def execute_issue(state: GraphState) -> GraphState:
     target_files = state.get("target_files")
 
     if not target_files:
-        new_state: GraphState = dict(state)
-        new_state["status"] = "error"
-        new_state["error"] = "No target_files specified; unable to execute issue."
-        return new_state
+        error_state = GraphState(**state)
+        error_state["status"] = "error"
+        error_state["error"] = "No target_files specified; unable to execute issue."
+        return error_state
 
     # Read the content of the target files
     file_contents = {}
@@ -53,20 +53,18 @@ async def execute_issue(state: GraphState) -> GraphState:
             with open(file_path, "r", encoding="utf-8") as f:
                 file_contents[file_path] = f.read()
         except FileNotFoundError:
-            new_state: GraphState = dict(state)
-            new_state["status"] = "error"
-            new_state["error"] = f"File not found: {file_path}"
-            return new_state
+            error_state = GraphState(**state)
+            error_state["status"] = "error"
+            error_state["error"] = f"File not found: {file_path}"
+            return error_state
         except Exception as e:
-            new_state: GraphState = dict(state)
-            new_state["status"] = "error"
-            new_state["error"] = f"Error reading file {file_path}: {e}"
-            return new_state
+            error_state = GraphState(**state)
+            error_state["status"] = "error"
+            error_state["error"] = f"Error reading file {file_path}: {e}"
+            return error_state
 
     settings = get_settings()
-    llm = ChatAnthropic(
-        api_key=settings.anthropic_api_key, model="claude-3-5-sonnet-20240620"
-    )
+    llm = ChatAnthropic(api_key=settings.anthropic_api_key, model="claude-3-5-sonnet-20240620")
 
     system_prompt = (
         "You are an expert software engineer. Your task is to generate a unified diff "
@@ -88,7 +86,7 @@ async def execute_issue(state: GraphState) -> GraphState:
         response = await llm.ainvoke(messages)
         unified_diff = response.content
         if isinstance(unified_diff, list):
-            # Handle case where content might be list of blocks (though unlikely for text model without tools)
+            # Handle case where content might be list of blocks
             unified_diff = "\n".join(
                 [block.text for block in unified_diff if hasattr(block, "text")]
             )
@@ -105,12 +103,12 @@ async def execute_issue(state: GraphState) -> GraphState:
         unified_diff = unified_diff.strip()
 
     except Exception as e:
-        new_state: GraphState = dict(state)
-        new_state["status"] = "error"
-        new_state["error"] = f"Error generating patch: {e}"
-        return new_state
-
-    new_state: GraphState = dict(state)
-    new_state["diff"] = unified_diff
-    new_state["status"] = "executed"
-    return new_state
+        error_state = GraphState(**state)
+        error_state["status"] = "error"
+        error_state["error"] = f"Error generating patch: {e}"
+        return error_state
+
+    success_state = GraphState(**state)
+    success_state["diff"] = unified_diff
+    success_state["status"] = "executed"
+    return success_state