forgexa-cli 1.47.4__tar.gz → 1.48.0__tar.gz

{forgexa_cli-1.47.4 → forgexa_cli-1.48.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.47.4
+Version: 1.48.0
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License-Expression: MIT

{forgexa_cli-1.47.4 → forgexa_cli-1.48.0}/forgexa_cli/__init__.py

@@ -1,2 +1,2 @@
 """forgexa-cli — Forgexa command-line client."""
-__version__ = "1.47.4"
+__version__ = "1.48.0"

{forgexa_cli-1.47.4 → forgexa_cli-1.48.0}/forgexa_cli/agent_core.py

@@ -1616,14 +1616,74 @@ def build_opencode_command(
     return cmd
 
 
-def opencode_base_env(env: dict[str, str], *, data_home: str | Path) -> dict[str, str]:
-    """Isolate each opencode run in its own XDG data directory.
+def opencode_base_env(
+    env: dict[str, str], *, data_home: str | Path, require_windows_shell: bool = False,
+) -> dict[str, str]:
+    """Isolate each OpenCode run in its own XDG data directory.
 
     Prevents concurrent opencode processes from racing on the shared SQLite
     WAL file ('Failed to run the query PRAGMA wal_checkpoint(PASSIVE)').
     """
     env = dict(env)
     env["XDG_DATA_HOME"] = str(data_home)
+    return configure_opencode_windows_shell(env, required=require_windows_shell)
+
+
+def _find_opencode_windows_shell(env: dict[str, str]) -> str | None:
+    configured = env.get("OPENCODE_GIT_BASH_PATH", "").strip()
+    if configured and Path(configured).is_file():
+        return configured
+
+    git = shutil.which("git", path=env.get("PATH"))
+    if git:
+        git_path = Path(git)
+        for git_root in (git_path.parent.parent, git_path.parent.parent.parent):
+            git_bash = git_root / "bin" / "bash.exe"
+            if git_bash.is_file():
+                return str(git_bash)
+
+    return shutil.which("pwsh", path=env.get("PATH"))
+
+
+def configure_opencode_windows_shell(
+    env: dict[str, str], *, required: bool = False,
+) -> dict[str, str]:
+    """Force OpenCode off classic Windows PowerShell for agent tool calls."""
+    env = dict(env)
+    if sys.platform != "win32":
+        return env
+
+    shell = _find_opencode_windows_shell(env)
+    if not shell:
+        message = (
+            "OpenCode on Windows requires Git Bash or PowerShell 7 (pwsh) so "
+            "agent tool output is UTF-8. Install Git for Windows or PowerShell 7, "
+            "then retry or select another agent."
+        )
+        if required:
+            raise RuntimeError(message)
+        logger.warning(message)
+        return env
+
+    raw_config = env.get("OPENCODE_CONFIG_CONTENT", "").strip()
+    config: dict[str, Any] = {}
+    if raw_config:
+        try:
+            parsed = json.loads(raw_config)
+        except json.JSONDecodeError as exc:
+            raise RuntimeError(
+                "OPENCODE_CONFIG_CONTENT must be a JSON object to configure "
+                "OpenCode's Windows tool shell."
+            ) from exc
+        if not isinstance(parsed, dict):
+            raise RuntimeError(
+                "OPENCODE_CONFIG_CONTENT must be a JSON object to configure "
+                "OpenCode's Windows tool shell."
+            )
+        config = parsed
+
+    config["shell"] = shell
+    env["OPENCODE_CONFIG_CONTENT"] = json.dumps(config, ensure_ascii=False)
     return env
 
 

{forgexa_cli-1.47.4 → forgexa_cli-1.48.0}/forgexa_cli/daemon.py

@@ -1120,7 +1120,7 @@ except (ImportError, ModuleNotFoundError):
 # DAEMON_VERSION is the protocol/logic version of the daemon code.
 # Kept in sync with pyproject.toml version via bump-version.sh.
 # CLIENT_TYPE identifies which packaging/distribution this daemon runs in.
-DAEMON_VERSION = "1.47.4"
+DAEMON_VERSION = "1.48.0"
 
 
 def _detect_client_type() -> str:
@@ -1460,6 +1460,7 @@ class TaskInfo:
     execution_attempt_id: str | None = None
     runtime_evidence_plan: dict | None = None
     local_evidence_upload: bool = False
+    critic_review_required: bool = False
 
 
 @dataclass
@@ -1490,6 +1491,105 @@ class TaskResult:
     has_verified_completion: bool = False
     execution_attempt_id: str | None = None
     evidence_summary: dict | None = None
+    critic_review: dict | None = None
+
+
+_RUNTIME_CRITIC_TIMEOUT_SECONDS = 120
+_RUNTIME_CRITIC_DIFF_MAX_CHARS = 30_000
+_RUNTIME_CRITIC_OUTPUT_MAX_CHARS = 20_000
+_RUNTIME_CRITIC_SYSTEM_PROMPT = """You are the Critic Agent for a software delivery gate.
+Review only the supplied task context and code diff. You are running in an
+isolated review capsule, not the project workspace. Do not write or modify files,
+run mutating commands, create commits, or make network changes.
+
+Return exactly one JSON object with this schema:
+{
+  "verdict": "approve" | "request_changes" | "reject",
+  "score": 0.0 to 1.0,
+  "summary": "brief assessment",
+  "dimension_scores": {
+    "correctness": 0.0 to 1.0,
+    "security": 0.0 to 1.0,
+    "performance": 0.0 to 1.0,
+    "style": 0.0 to 1.0,
+    "testing": 0.0 to 1.0,
+    "error_handling": 0.0 to 1.0
+  },
+  "issues": [{
+    "severity": "critical" | "major" | "minor" | "info",
+    "category": "security" | "performance" | "correctness" | "style" | "testing" | "error_handling",
+    "title": "short title",
+    "file": "repository-relative changed file path",
+    "line": 1,
+    "end_line": 1,
+    "message": "actionable defect description",
+    "evidence": "concrete basis from the supplied diff",
+    "impact": "consequence if unresolved",
+    "suggestion": "minimal fix direction",
+    "verification": "focused verification step"
+  }]
+}
+
+Only report findings grounded in the supplied diff. Return an empty issues array
+when no actionable defects are found."""
+
+
+def _runtime_critic_test_summary(observations: list[dict]) -> str:
+    for observation in reversed(observations):
+        if not isinstance(observation, dict):
+            continue
+        payload = observation.get("content")
+        if not isinstance(payload, dict):
+            payload = observation
+        if payload.get("type") != "test_results":
+            continue
+        summary = payload.get("summary")
+        if isinstance(summary, str) and summary.strip():
+            return summary.strip()[:5000]
+    return ""
+
+
+def _build_runtime_critic_prompt(
+    task: TaskInfo,
+    *,
+    changed_files: list[str],
+    diff: str,
+    test_summary: str,
+) -> str:
+    work_item = task.work_item or {}
+    title = work_item.get("title") if isinstance(work_item, dict) else ""
+    title = title if isinstance(title, str) and title.strip() else "Unnamed task"
+    parts = [
+        _RUNTIME_CRITIC_SYSTEM_PROMPT,
+        "",
+        f"Task: {title[:500]}",
+        f"Task type: {task.node_type or 'coding'}",
+        "",
+        f"Changed files ({len(changed_files)}):",
+    ]
+    parts.extend(f"- {path}" for path in changed_files[:50])
+    parts.extend(("", "## Code Diff", "```diff", diff, "```"))
+    if test_summary:
+        parts.extend(("", "## Test Results", test_summary))
+    parts.append("\nReturn only the JSON review object.")
+    return "\n".join(parts)
+
+
+def _runtime_critic_attempt(agent_id: str, result: TaskResult) -> dict:
+    if result.status == "success":
+        outcome = "success"
+    elif result.failure_code == "agent_idle_timeout":
+        outcome = "timeout"
+    elif result.exit_code not in (0, None):
+        outcome = "exit_code"
+    else:
+        outcome = "agent_error"
+    attempt = {"agent": agent_id, "outcome": outcome}
+    duration_seconds = (result.metrics or {}).get("duration_seconds")
+    if isinstance(duration_seconds, (int, float)) and not isinstance(duration_seconds, bool):
+        if duration_seconds >= 0:
+            attempt["duration_ms"] = int(duration_seconds * 1000)
+    return attempt
 
 
 _ACTIONABLE_REFLECTION_KINDS = frozenset({
@@ -1561,6 +1661,23 @@ def _filter_local_bind_task_result(result: "TaskResult") -> None:
     result.stdout = ""
     result.stderr = ""
     result.observations = []
+    critic_review = result.critic_review
+    if isinstance(critic_review, dict) and isinstance(critic_review.get("result"), dict):
+        result.critic_review = {
+            "collection_status": "completed",
+            "result": critic_review["result"],
+        }
+        if isinstance(critic_review.get("agent_used"), str):
+            result.critic_review["agent_used"] = critic_review["agent_used"]
+        if isinstance(critic_review.get("agent_attempts"), list):
+            result.critic_review["agent_attempts"] = critic_review["agent_attempts"]
+    elif isinstance(critic_review, dict):
+        result.critic_review = {
+            "collection_status": "unavailable",
+            "failure_code": str(
+                critic_review.get("failure_code") or "runtime_critic_local_bind_private"
+            )[:64],
+        }
     if result.error:
         result.error = (
             "Local task failed. Review this task in Forgexa Desktop on the "
@@ -5291,6 +5408,8 @@ class ProcessManager:
         """Classify a fallback-eligible failure without conflating its cause."""
         if result.failure_code in {"all_agents_rate_limited", "all_agents_unavailable"}:
             return None
+        if result.failure_code == "agent_platform_unsupported":
+            return "agent_unavailable"
         error_text = ProcessManager._failure_pattern_channels(result).lower()
         if any(p in error_text for p in ProcessManager.RATE_LIMIT_PATTERNS):
             return "rate_limit"
@@ -5938,6 +6057,7 @@ class ProcessManager:
             "design": 50,
             "testing": 60,
             "review": 40,
+            "critic_review": 1,
             "fix": 60,
         }
         max_turns = int(os.environ.get(
@@ -6188,7 +6308,21 @@ class ProcessManager:
             auth_src = Path.home() / ".local" / "share" / "opencode" / "auth.json"
             if auth_src.exists():
                 shutil.copy2(auth_src, isolated_data_dir / "auth.json")
-            env = agent_core.opencode_base_env(os.environ.copy(), data_home=tmp_data_root)
+            try:
+                env = agent_core.opencode_base_env(
+                    os.environ.copy(),
+                    data_home=tmp_data_root,
+                    require_windows_shell=True,
+                )
+            except RuntimeError as exc:
+                return TaskResult(
+                    status="failed",
+                    exit_code=-1,
+                    stdout="",
+                    stderr="",
+                    error=str(exc),
+                    failure_code="agent_platform_unsupported",
+                )
             result = await self._run_cli(cmd, cwd, timeout, task_id, on_chunk=on_chunk, env=env)
             output = "\n".join(
                 part for part in (result.stdout, result.stderr, result.error) if part
@@ -7314,6 +7448,7 @@ class ProgressReporter:
             "artifacts": result.artifacts,
             "observations": result.observations,
             "evidence_summary": result.evidence_summary,
+            "critic_review": result.critic_review,
             "metrics": result.metrics,
             "git": result.git,
         }
@@ -7924,6 +8059,7 @@ class TaskPoller:
                         if isinstance(t.get("runtime_evidence_plan"), dict) else None
                     ),
                     local_evidence_upload=t.get("local_evidence_upload") is True,
+                    critic_review_required=t.get("critic_review_required") is True,
                 ))
             return tasks
         except Exception as e:
@@ -10703,6 +10839,16 @@ class RuntimeDaemon:
                         before_sha=node_before_sha,
                     )
 
+            if result.status == "success" and task.critic_review_required:
+                await reporter.report_progress(task.task_id, 95, "running_critic_review")
+                result.critic_review = await self._run_runtime_critic_review(
+                    task,
+                    agent,
+                    workspace_path,
+                    result,
+                    before_sha=node_before_sha,
+                )
+
             # 6. Report completion (include actual agent used if different from requested)
             result.metrics["actual_agent"] = agent.agent_id
             if agent.agent_id != task.agent_type:
@@ -10731,6 +10877,187 @@ class RuntimeDaemon:
             project_lock.release()
             _release_local_workspace_file_lock(local_bind_file_lock)
 
+    async def _collect_runtime_critic_diff(
+        self,
+        workspace_path: Path,
+        *,
+        before_sha: str,
+        after_sha: str,
+        changed_files: list[str],
+    ) -> str | None:
+        if not before_sha or not after_sha or not changed_files:
+            return None
+        try:
+            diff = await self.workspace_manager._git(
+                "diff",
+                "--no-ext-diff",
+                "--unified=3",
+                before_sha,
+                after_sha,
+                "--",
+                *changed_files,
+                cwd=workspace_path,
+                timeout=60,
+            )
+        except Exception:
+            logger.warning(
+                "Could not collect frozen diff for Runtime Critic review of commit %s",
+                after_sha[:12],
+                exc_info=True,
+            )
+            return None
+        return diff[:_RUNTIME_CRITIC_DIFF_MAX_CHARS]
+
+    async def _run_runtime_critic_review(
+        self,
+        task: TaskInfo,
+        agent: DiscoveredAgent,
+        workspace_path: Path,
+        result: TaskResult,
+        *,
+        before_sha: str,
+    ) -> dict:
+        """Run a one-turn Critic on the selected Runtime Agent in a temp capsule.
+
+        The agent receives only the frozen diff and metadata in its prompt. Its
+        cwd is an empty temporary directory, never the task workspace.
+        """
+        agent_id = str(getattr(agent, "agent_id", "")).strip().lower()
+        if not agent_id:
+            return {
+                "collection_status": "unavailable",
+                "failure_code": "runtime_critic_agent_unknown",
+            }
+        metadata = {"agent_used": agent_id}
+        is_local_bind = task.workspace_resolution == "local_bind"
+        if is_local_bind and not task.local_evidence_upload:
+            return {
+                "collection_status": "unavailable",
+                "failure_code": "runtime_critic_local_evidence_upload_disabled",
+                **metadata,
+            }
+
+        changed_files = [
+            path.replace("\\", "/").lstrip("./")
+            for path in result.files_changed
+            if isinstance(path, str) and path.strip()
+        ]
+        if not changed_files:
+            return {"collection_status": "not_applicable"}
+
+        after_sha = str((result.git or {}).get("commit_sha") or "").strip()
+        diff = await self._collect_runtime_critic_diff(
+            workspace_path,
+            before_sha=before_sha,
+            after_sha=after_sha,
+            changed_files=changed_files,
+        )
+        if not diff:
+            return {
+                "collection_status": "unavailable",
+                "failure_code": "runtime_critic_diff_unavailable",
+                **metadata,
+            }
+
+        review_task = TaskInfo(
+            task_id=f"{task.task_id}-critic",
+            graph_id=task.graph_id,
+            node_type="critic_review",
+            agent_type=agent_id,
+            input_prompt=_build_runtime_critic_prompt(
+                task,
+                changed_files=changed_files,
+                diff=diff,
+                test_summary=_runtime_critic_test_summary(result.observations),
+            ),
+            input_data={"critic_review": True},
+            timeout_seconds=_RUNTIME_CRITIC_TIMEOUT_SECONDS,
+            max_retries=0,
+            retry_count=0,
+            project={},
+            work_item={},
+        )
+        try:
+            with tempfile.TemporaryDirectory(
+                prefix=f"forgexa-critic-{task.task_id[:8]}-"
+            ) as review_dir:
+                review_result = await self.process_manager.run_agent(
+                    agent,
+                    review_task,
+                    Path(review_dir),
+                )
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            logger.warning(
+                "Runtime Critic execution failed for task %s",
+                task.task_id,
+                exc_info=True,
+            )
+            return {
+                "collection_status": "unavailable",
+                "failure_code": "runtime_critic_exception",
+                "agent_attempts": [{"agent": agent_id, "outcome": "agent_error"}],
+                **metadata,
+            }
+
+        attempt = _runtime_critic_attempt(agent_id, review_result)
+        if review_result.status != "success":
+            return {
+                "collection_status": "unavailable",
+                "failure_code": review_result.failure_code or "runtime_critic_agent_error",
+                "agent_attempts": [attempt],
+                **metadata,
+            }
+
+        review_output = _daemon_extract_agent_output(
+            agent_id,
+            review_result.stdout or "",
+        ).strip()
+        if not review_output:
+            attempt["outcome"] = "empty_output"
+            return {
+                "collection_status": "unavailable",
+                "failure_code": "runtime_critic_empty_output",
+                "agent_attempts": [attempt],
+                **metadata,
+            }
+        if is_local_bind:
+            structured_result = _daemon_extract_json(review_output)
+            if not isinstance(structured_result, dict):
+                attempt["outcome"] = "invalid_output"
+                return {
+                    "collection_status": "unavailable",
+                    "failure_code": "runtime_critic_invalid_output",
+                    "agent_attempts": [attempt],
+                    **metadata,
+                }
+            encoded_result = json.dumps(
+                structured_result,
+                ensure_ascii=True,
+                separators=(",", ":"),
+            )
+            if len(encoded_result) > _RUNTIME_CRITIC_OUTPUT_MAX_CHARS:
+                attempt["outcome"] = "output_too_large"
+                return {
+                    "collection_status": "unavailable",
+                    "failure_code": "runtime_critic_output_too_large",
+                    "agent_attempts": [attempt],
+                    **metadata,
+                }
+            return {
+                "collection_status": "completed",
+                "result": structured_result,
+                "agent_attempts": [attempt],
+                **metadata,
+            }
+        return {
+            "collection_status": "completed",
+            "output": review_output[:_RUNTIME_CRITIC_OUTPUT_MAX_CHARS],
+            "agent_attempts": [attempt],
+            **metadata,
+        }
+
     def _select_fallback_agent(
         self, current_agent_id: str, fallback_chain: list[str] | None, tried: set[str]
     ) -> DiscoveredAgent | None:

{forgexa_cli-1.47.4 → forgexa_cli-1.48.0}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.47.4
+Version: 1.48.0
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License-Expression: MIT

{forgexa_cli-1.47.4 → forgexa_cli-1.48.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "forgexa-cli"
-version = "1.47.4"
+version = "1.48.0"
 description = "Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform"
 requires-python = ">=3.9"
 license = "MIT"