forgex-cli 0.1.5__tar.gz → 0.1.6__tar.gz

{forgex_cli-0.1.5 → forgex_cli-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: forgex-cli
-Version: 0.1.5
+Version: 0.1.6
 Summary: FORGEX — multi-agent AI software engineering. Plan. Build. Refine. Verify.
 Project-URL: Homepage, https://github.com/B-max12/Forgex
 Project-URL: Repository, https://github.com/B-max12/Forgex

{forgex_cli-0.1.5 → forgex_cli-0.1.6}/src/forgex/__init__.py

@@ -1,3 +1,3 @@
 """FORGEX — Plan. Build. Refine. Verify."""
 
-__version__ = "0.1.5"
+__version__ = "0.1.6"

{forgex_cli-0.1.5 → forgex_cli-0.1.6}/src/forgex/agents/architect.py

@@ -93,7 +93,11 @@ class ArchitectAgent(BaseAgent):
         stage1_msg = (
             f"<user_request>\n{user_request}\n</user_request>\n\n"
             f"<repository>\n{repo_context}\n</repository>\n\n"
-            "Analyze this request and repository. State the goal, requirements, candidate libraries, and research topics."
+            "Analyze this request and repository. State the goal, requirements, candidate libraries, and research topics.\n"
+            "IMPORTANT: candidate_libraries and research_topics MUST be concrete package identifiers with their registry prefix "
+            "(e.g. 'npm:react', 'npm:tailwindcss', 'pypi:flask', 'crates:serde', 'go:github.com/gin-gonic/gin'). "
+            "Do NOT output natural language conceptual phrases like 'Front-end frameworks' or 'Responsive web design' — "
+            "research checks official package registries (pypi, npm, crates, go) which only accept package names."
         )
         analysis: AnalysisResult = await self._generate_structured(
             [Message(role="user", content=stage1_msg)], AnalysisResult
@@ -102,7 +106,15 @@ class ArchitectAgent(BaseAgent):
         # Stage 2: Dependency research
         if on_stage:
             on_stage("researching")
-        notes = await self._research.research(analysis.research_topics)
+        # Combine candidate_libraries and research_topics, prioritizing candidates
+        raw_candidates = [lib.strip() for lib in analysis.candidate_libraries if lib and lib.strip()]
+        raw_topics = [t.strip() for t in analysis.research_topics if t and t.strip()]
+        combined_topics: list[str] = []
+        for item in raw_candidates + raw_topics:
+            if item not in combined_topics:
+                combined_topics.append(item)
+
+        notes = await self._research.research(combined_topics)
         if self._events:
             self._events.record(
                 EventType.RESEARCH_COMPLETED,

{forgex_cli-0.1.5 → forgex_cli-0.1.6}/src/forgex/agents/base.py

@@ -49,10 +49,10 @@ _SOFT_BUDGET_RATIO = 0.75
 PROTOCOL_MODE_DOC = """
 Tool protocol — this model does not support native tool calls.
 To call a tool, respond with ONLY:
-{"action": "tool", "tool": "<tool name>", "arguments": {<arguments>}}
+{{"action": "tool", "tool": "<tool name>", "arguments": {{<arguments>}}}}
 The tool result is returned to you as JSON in the next message.
 To finish, respond with ONLY:
-{"action": "done", "result": {<final report matching the schema>}}
+{{"action": "done", "result": {{<final report matching the schema>}}}}
 
 Available tools (JSON Schemas):
 {tool_schemas}
@@ -358,10 +358,25 @@ class BaseAgent(ABC):
                     messages.append(Message(role="user", content="Please reply with a valid JSON action: {\"action\": \"tool\", ...} or {\"action\": \"done\", ...}."))
                     continue
 
-                action = action_data.get("action")
+                if not isinstance(action_data, dict):
+                    protocol_errors += 1
+                    if protocol_errors >= MAX_PROTOCOL_ERRORS:
+                        raise AgentOutputError(f"{self.role.value} protocol errors exceeded: expected JSON object")
+                    messages.append(Message(role="assistant", content=raw))
+                    messages.append(Message(role="user", content="Please reply with a valid JSON object: {\"action\": \"tool\", ...} or {\"action\": \"done\", ...}."))
+                    continue
+
+                # Normalize keys (strip quotes, whitespace, lowercase)
+                normalized: dict[str, Any] = {}
+                for k, v in action_data.items():
+                    normalized[str(k).strip().strip('"\'').lower()] = v
+
+                action = str(normalized.get("action") or "").strip().lower()
                 if action == "tool":
-                    tool_name = action_data.get("tool")
-                    args = action_data.get("arguments") or {}
+                    tool_name = normalized.get("tool") or normalized.get("name")
+                    args = normalized.get("arguments") or normalized.get("args") or {}
+                    if not isinstance(args, dict):
+                        args = {}
                     total_tool_calls += 1
                     t_res = await tools.execute(SystemToolCall(name=tool_name, arguments=args))
                     out_text = t_res.output or (f"Error: {t_res.error}" if t_res.error else "done")
@@ -370,9 +385,23 @@ class BaseAgent(ABC):
                     messages.append(Message(role="assistant", content=raw))
                     messages.append(Message(role="user", content=json.dumps({"tool_result": out_text})))
                 elif action == "done":
-                    res_data = action_data.get("result") or {}
-                    report = target_schema.model_validate(res_data)
-                    return ToolLoopResult(report=report, rounds=rounds, tool_calls_count=total_tool_calls)
+                    res_data = normalized.get("result") or normalized.get("report")
+                    if res_data is None or not isinstance(res_data, dict):
+                        res_data = {k: v for k, v in normalized.items() if k not in ("action", "tool", "arguments", "args")}
+                    try:
+                        report = target_schema.model_validate(res_data)
+                        return ToolLoopResult(report=report, rounds=rounds, tool_calls_count=total_tool_calls)
+                    except (ValidationError, ValueError) as val_exc:
+                        protocol_errors += 1
+                        if protocol_errors >= MAX_PROTOCOL_ERRORS:
+                            raise AgentOutputError(f"{self.role.value} schema validation failed: {val_exc}") from val_exc
+                        messages.append(Message(role="assistant", content=raw))
+                        messages.append(
+                            Message(
+                                role="user",
+                                content=f"Your 'done' result did not match the JSON schema ({val_exc}). Please return valid JSON: {{\"action\": \"done\", \"result\": {{...}}}}.",
+                            )
+                        )
                 else:
                     protocol_errors += 1
                     messages.append(Message(role="assistant", content=raw))

{forgex_cli-0.1.5 → forgex_cli-0.1.6}/src/forgex/models/registry.py

@@ -52,6 +52,39 @@ _DEFAULT_CATALOG: dict[str, ModelCapabilities] = {
         supports_streaming=False,
         known=True,
     ),
+    # Meta Llama models (OpenRouter / Groq / Ollama)
+    "meta-llama/llama-3.3-70b-instruct": ModelCapabilities(
+        model="meta-llama/llama-3.3-70b-instruct",
+        context_window=131072,
+        supports_tools=True,
+        supports_json=True,
+        supports_streaming=True,
+        known=True,
+    ),
+    "meta-llama/llama-3.1-70b-instruct": ModelCapabilities(
+        model="meta-llama/llama-3.1-70b-instruct",
+        context_window=131072,
+        supports_tools=True,
+        supports_json=True,
+        supports_streaming=True,
+        known=True,
+    ),
+    "meta-llama/llama-3.1-8b-instruct": ModelCapabilities(
+        model="meta-llama/llama-3.1-8b-instruct",
+        context_window=131072,
+        supports_tools=True,
+        supports_json=True,
+        supports_streaming=True,
+        known=True,
+    ),
+    "qwen/qwen-2.5-coder-32b-instruct": ModelCapabilities(
+        model="qwen/qwen-2.5-coder-32b-instruct",
+        context_window=131072,
+        supports_tools=True,
+        supports_json=True,
+        supports_streaming=True,
+        known=True,
+    ),
 }
 
 
@@ -65,8 +98,11 @@ class ModelRegistry:
                 self._catalog[k] = cap
 
     def lookup(self, model: str) -> ModelCapabilities:
+        clean_model = model.split(":", 1)[-1] if ":" in model else model
         if model in self._catalog:
             return self._catalog[model]
+        if clean_model in self._catalog:
+            return self._catalog[clean_model]
         # Conservative defaults for unknown models
         return ModelCapabilities(
             model=model,

{forgex_cli-0.1.5 → forgex_cli-0.1.6}/src/forgex/prompts/architect.md

@@ -9,7 +9,7 @@ Principles:
 3. Respect the repository's existing languages, frameworks, conventions, and dependency choices. Prefer the smallest set of dependencies that satisfies the requirements. Avoid speculative features.
 4. Task ids use the TASK-001 format. depends_on may only reference other task ids in the same plan. Dependency cycles are forbidden.
 5. Include an explicit test strategy and project-level acceptance criteria.
-6. For library choices, emit research topics so versions can be verified against official registries. Prefix with the registry when you know it: "pypi:fastapi", "npm:express", "crates:serde", "go:github.com/gin-gonic/gin".
+6. For library choices and dependencies, emit concrete package names as research topics and candidate libraries so versions can be verified against official registries. Always prefix with the registry: "pypi:fastapi", "npm:react", "npm:tailwindcss", "crates:serde", "go:github.com/gin-gonic/gin". Never emit generic concepts or sentences as research topics (e.g. do not emit "Front-end frameworks" or "Responsive web design"). Every topic must be a queryable package name.
 
 Output rules:
 Respond with ONLY a single JSON object that validates against the provided JSON Schema. No prose, no markdown, no code fences.

{forgex_cli-0.1.5 → forgex_cli-0.1.6}/src/forgex/research/engine.py

@@ -49,25 +49,37 @@ class ResearchEngine:
         self._enabled = config.research.enabled if config is not None else True
 
     async def research(self, topics: list[str]) -> list[ResearchNote]:
-        topics = topics[:MAX_TOPICS]
-        if not topics:
+        cleaned = [t.strip() for t in topics if t and t.strip()]
+        # Prioritize package-like identifiers over long descriptive sentences
+        package_like = [t for t in cleaned if " " not in t]
+        phrase_like = [t for t in cleaned if " " in t]
+        selected = (package_like + phrase_like)[:MAX_TOPICS]
+
+        if not selected:
             return []
         if not self._enabled:
             return [
                 _unavailable(topic, "research disabled in configuration (offline mode)")
-                for topic in topics
+                for topic in selected
             ]
-        return [await self._lookup(topic) for topic in topics]
+        return [await self._lookup(topic) for topic in selected]
 
     async def _lookup(self, topic: str) -> ResearchNote:
-        ecosystem, sep, name = topic.partition(":")
+        clean = topic.strip()
+        ecosystem, sep, name = clean.partition(":")
         if sep and ecosystem in self._by_ecosystem:
-            return await self._safe_lookup(self._by_ecosystem[ecosystem], name, topic)
+            return await self._safe_lookup(self._by_ecosystem[ecosystem], name.strip(), clean)
+        # Plain multi-word phrases cannot be package names in any registry
+        if " " in clean:
+            return _unavailable(
+                clean,
+                "topic is a descriptive phrase; research queries package registries for package names",
+            )
         for source in self._sources:
-            note = await self._safe_lookup(source, topic, topic)
+            note = await self._safe_lookup(source, clean, clean)
             if note.available:
                 return note
-        return _unavailable(topic, "not found in any registry source (pypi, npm, crates, go)")
+        return _unavailable(clean, "not found in any registry source (pypi, npm, crates, go)")
 
     async def _safe_lookup(
         self, source: RegistrySource, name: str, topic: str

{forgex_cli-0.1.5 → forgex_cli-0.1.6}/src/forgex/research/sources.py

@@ -41,6 +41,7 @@ class RegistrySource(ABC):
         return bool(_VALID_NAME.match(name)) and ".." not in name
 
     async def lookup(self, name: str, client: httpx.AsyncClient) -> ResearchNote:
+        name = name.strip()
         if not self.validate_name(name):
             return ResearchNote(
                 topic=name,

{forgex_cli-0.1.5 → forgex_cli-0.1.6}/tests/unit/test_builder_agent.py

@@ -64,3 +64,33 @@ async def test_builder_executes_task_and_records_events(tmp_path):
         res = await execute_task(stores=stores, task=task, config=load_config(ws), builder=builder)
         assert res.status == "completed"
         assert (ws / "demo.py").exists()
+
+
+async def test_builder_json_protocol_mode(tmp_path):
+    ws = tmp_path / "ws"
+    ws.mkdir()
+    initialize_project(ws)
+    with open_stores(ws) as stores:
+        state = stores.state.load()
+        task = Task(id="TASK-001", description="create demo file", acceptance_criteria=["exists"])
+        stores.save_tasks([task], project_id=state.project_id)
+
+        router = FakeRouter([
+            ModelResponse(content=json.dumps({
+                "action": "tool",
+                "tool": "write_file",
+                "arguments": {"path": "proto.py", "content": "print('protocol')"},
+            })),
+            ModelResponse(content=json.dumps({
+                "action": "done",
+                "result": {"status": "completed", "summary": "done via protocol", "created_files": ["proto.py"], "modified_files": [], "tests_written": []},
+            })),
+        ], supports_tools=False)
+        ctx = create_context(ws, load_config(ws), agent=AgentRole.BUILDER, events=stores.recorder)
+        tools = ToolExecutor(build_tool_registry(), permission_set_for(AgentRole.BUILDER), ctx)
+        builder = BuilderAgent(router=router, tools=tools, events=stores.recorder)
+
+        res = await execute_task(stores=stores, task=task, config=load_config(ws), builder=builder)
+        assert res.status == "completed"
+        assert (ws / "proto.py").exists()
+

{forgex_cli-0.1.5 → forgex_cli-0.1.6}/tests/unit/test_registry.py

@@ -22,3 +22,10 @@ def test_user_override_is_authoritative():
 
 def test_catalog_lists_known_models():
     assert any(c.model == "llama-3.3-70b-versatile" for c in ModelRegistry().catalog())
+
+
+def test_provider_prefix_lookup():
+    reg = ModelRegistry()
+    caps = reg.lookup("openrouter:meta-llama/llama-3.3-70b-instruct")
+    assert caps.known and caps.supports_tools
+

{forgex_cli-0.1.5 → forgex_cli-0.1.6}/tests/unit/test_research.py

@@ -87,3 +87,26 @@ async def test_disabled_config_offline_notes():
     assert not notes[0].available
     assert "disabled" in notes[0].detail
 
+
+async def test_descriptive_phrases_marked_unavailable_with_clear_reason():
+    engine = make_engine(registry_handler)
+    notes = await engine.research(["Front-end frameworks for web development"])
+    assert not notes[0].available
+    assert "descriptive phrase" in notes[0].detail
+
+
+async def test_package_prioritization_over_phrases():
+    engine = make_engine(registry_handler)
+    topics = [
+        "Front-end frameworks for web development",
+        "pypi:fastapi",
+        "Responsive web design techniques",
+        "express",
+    ]
+    notes = await engine.research(topics)
+    # The two package-like topics should be researched first
+    assert notes[0].topic == "fastapi" and notes[0].available
+    assert notes[1].topic == "express" and notes[1].available
+    assert not notes[2].available
+
+