forgexa-cli 1.7.6__tar.gz → 1.8.3__tar.gz

{forgexa_cli-1.7.6 → forgexa_cli-1.8.3}/PKG-INFO

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

{forgexa_cli-1.7.6 → forgexa_cli-1.8.3}/forgexa_cli/__init__.py

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

{forgexa_cli-1.7.6 → forgexa_cli-1.8.3}/forgexa_cli/daemon.py

@@ -332,7 +332,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.7.6"
+DAEMON_VERSION = "1.8.3"
 
 
 def _detect_client_type() -> str:
@@ -611,7 +611,7 @@ class AgentDiscovery:
     """Scans for locally installed Agent CLI tools."""
 
     AGENT_REGISTRY = {
-        "claude-code": {
+        "claude": {
             "commands": ["claude"],
             "detect": "claude --version",
             "invoke_modes": ["print", "app-server"],
@@ -642,19 +642,19 @@ class AgentDiscovery:
             "env_path_override": "FACTORY_GEMINI_PATH",
             "compatibility_level": "L1",
         },
-        "kimi-code": {
+        "kimi": {
             "commands": ["kimi"],
             "detect": "kimi --version",
             "invoke_modes": ["cli"],
             "env_path_override": "FACTORY_KIMI_PATH",
             "compatibility_level": "L2",
         },
-        "hermes": {
-            "commands": ["hermes"],
-            "detect": "hermes --version",
+        "copilot": {
+            "commands": ["copilot"],
+            "detect": "copilot --version",
             "invoke_modes": ["cli"],
-            "env_path_override": "FACTORY_HERMES_PATH",
-            "compatibility_level": "L1",
+            "env_path_override": "FACTORY_COPILOT_PATH",
+            "compatibility_level": "L3",
         },
     }
 
@@ -711,6 +711,24 @@ class AgentDiscovery:
                     Path("/usr/local/bin"),
                     Path("/opt/homebrew/bin"),
                 ]
+                # GitHub Copilot CLI — installed via VS Code extension into globalStorage
+                vscode_copilot = (
+                    home / "Library" / "Application Support" / "Code" / "User"
+                    / "globalStorage" / "github.copilot-chat" / "copilotCli"
+                )
+                extra_dirs.append(vscode_copilot)
+                for vs_variant in ("Code - Insiders", "VSCodium"):
+                    extra_dirs.append(
+                        home / "Library" / "Application Support" / vs_variant / "User"
+                        / "globalStorage" / "github.copilot-chat" / "copilotCli"
+                    )
+            if sys.platform == "linux":
+                # GitHub Copilot CLI on Linux VSCode
+                for config_dir in (
+                    home / ".config" / "Code" / "User" / "globalStorage" / "github.copilot-chat" / "copilotCli",
+                    home / ".config" / "Code - Insiders" / "User" / "globalStorage" / "github.copilot-chat" / "copilotCli",
+                ):
+                    extra_dirs.append(config_dir)
             # nvm (macOS + Linux)
             nvm_dir = os.environ.get("NVM_DIR", str(home / ".nvm"))
             nvm_path = Path(nvm_dir)
@@ -1732,24 +1750,49 @@ class ProcessManager:
                     error_messages.append(err.get("message", "turn failed"))
                 elif isinstance(err, str):
                     error_messages.append(err)
+            # ── GitHub Copilot CLI event types ──────────────────────────────
+            elif ev_type == "assistant.turn_end":
+                has_turn_completed = True
+            elif ev_type == "assistant.turn_start":
+                has_assistant_events = True
+            elif ev_type == "assistant.message":
+                has_meaningful_content = True
+                has_assistant_events = True
+                msg_data = data.get("data") or {}
+                if isinstance(msg_data.get("content"), str) and msg_data["content"].strip():
+                    has_result = True
+            elif ev_type == "assistant.message_delta":
+                has_meaningful_content = True
+            # ── Generic / Claude "result" event ────────────────────────────
             elif ev_type == "result":
-                result_text = str(data.get("result", "") or "")
-                if data.get("is_error"):
-                    err_text = result_text or str(data.get("error", "") or "result marked as error")
-                    error_messages.append(err_text)
-                else:
-                    # Structural check: if no tokens were consumed AND no assistant
-                    # events appeared, the CLI never made an API call. The result
-                    # text is a CLI-level error (e.g. "API Error: Connection error.")
-                    # rather than the agent's actual work output.
-                    tok_in = int(data.get("total_input_tokens", 0) or 0)
-                    tok_out = int(data.get("total_output_tokens", 0) or 0)
-                    no_api_call = (tok_in + tok_out == 0) and not has_assistant_events
-                    if no_api_call and result_text:
-                        error_messages.append(result_text)
-                    else:
+                # Copilot result format: {"type":"result","exitCode":0,"usage":{...}}
+                # Claude result format:  {"type":"result","result":"...","is_error":false,...}
+                if "exitCode" in data:
+                    # Copilot JSONL result
+                    exit_code = int(data.get("exitCode") or 0)
+                    if exit_code == 0:
                         has_result = True
                         has_meaningful_content = True
+                    else:
+                        error_messages.append(f"Copilot exited with code {exit_code}")
+                else:
+                    result_text = str(data.get("result", "") or "")
+                    if data.get("is_error"):
+                        err_text = result_text or str(data.get("error", "") or "result marked as error")
+                        error_messages.append(err_text)
+                    else:
+                        # Structural check: if no tokens were consumed AND no assistant
+                        # events appeared, the CLI never made an API call. The result
+                        # text is a CLI-level error (e.g. "API Error: Connection error.")
+                        # rather than the agent's actual work output.
+                        tok_in = int(data.get("total_input_tokens", 0) or 0)
+                        tok_out = int(data.get("total_output_tokens", 0) or 0)
+                        no_api_call = (tok_in + tok_out == 0) and not has_assistant_events
+                        if no_api_call and result_text:
+                            error_messages.append(result_text)
+                        else:
+                            has_result = True
+                            has_meaningful_content = True
             elif ev_type == "error":
                 msg = data.get("message", "")
                 if msg:
@@ -1895,10 +1938,15 @@ class ProcessManager:
             return f"Agent encountered errors without producing output: {error_messages[0]}"
 
         # ── Claude: JSON output mode but no result object and no content ──
-        if agent_id == "claude-code" and json_line_count > 0:
+        if agent_id == "claude" and json_line_count > 0:
             if not has_result and not has_meaningful_content:
                 return "Claude produced no result output"
 
+        # ── Copilot: JSONL mode but no turn completion and no content ──
+        if agent_id == "copilot" and json_line_count > 0:
+            if not has_result and not has_meaningful_content:
+                return "Copilot produced no result output (check GitHub authentication: run 'gh auth login')"
+
         return None
 
     async def run_agent(
@@ -1915,7 +1963,7 @@ class ProcessManager:
 
         start_time = time.monotonic()
 
-        if agent.agent_id == "claude-code":
+        if agent.agent_id == "claude":
             result = await self._run_claude(
                 agent, prompt, workspace_path, timeout, task.task_id, on_chunk,
                 node_type=task.node_type,
@@ -1926,8 +1974,10 @@ class ProcessManager:
             result = await self._run_opencode(agent, prompt, workspace_path, timeout, task.task_id, on_chunk)
         elif agent.agent_id == "gemini":
             result = await self._run_gemini(agent, prompt, workspace_path, timeout, task.task_id, on_chunk)
-        elif agent.agent_id == "kimi-code":
+        elif agent.agent_id == "kimi":
             result = await self._run_kimi_code(agent, prompt, workspace_path, timeout, task.task_id, on_chunk)
+        elif agent.agent_id == "copilot":
+            result = await self._run_copilot(agent, prompt, workspace_path, timeout, task.task_id, on_chunk)
         else:
             result = await self._run_generic(agent, prompt, workspace_path, timeout, task.task_id, on_chunk)
 
@@ -2386,6 +2436,101 @@ class ProcessManager:
         result.metrics.update(parsed_metrics)
         return result
 
+    async def _run_copilot(
+        self, agent: DiscoveredAgent, prompt: str, cwd: Path, timeout: int, task_id: str,
+        on_chunk: Any = None,
+    ) -> TaskResult:
+        """Run GitHub Copilot CLI in non-interactive JSON-streaming mode.
+
+        Uses TERM=dumb to suppress TTY-detection (copilot suspends when it
+        can't acquire a pseudo-terminal).  Requires GitHub login:
+        ``gh auth login`` or GITHUB_TOKEN env var must be set.
+
+        Flags:
+          -p / --prompt     Non-interactive prompt (exits after completion).
+          --output-format json   JSONL stream of session events.
+          --allow-all       Grant all tool + path + URL permissions required
+                            for autonomous file-editing tasks.
+          -C <dir>          Change working directory before execution.
+        """
+        env = os.environ.copy()
+        env["TERM"] = "dumb"  # suppress TTY-detection that suspends the process
+
+        model_override = os.environ.get("FACTORY_COPILOT_MODEL")
+        reasoning = os.environ.get("FACTORY_COPILOT_REASONING", "medium")
+
+        cmd = [
+            agent.command,
+            "--output-format", "json",
+            "--allow-all",
+            "--effort", reasoning,
+            "-C", str(cwd),
+            "-p", prompt,
+        ]
+        if model_override:
+            cmd = [agent.command, "--model", model_override] + cmd[1:]
+
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                cwd=str(cwd),
+                env=env,
+                limit=100 * 1024 * 1024,
+                start_new_session=True,
+            )
+            self.active_processes[task_id] = proc
+            stdout, stderr, returncode = await self._stream_process(
+                proc, None, timeout, task_id, on_chunk
+            )
+
+            # Parse copilot JSONL output for metrics
+            metrics = self._parse_copilot_output(stdout)
+
+            # Copilot always exits 0 on normal completion; check result.exitCode
+            # from the JSONL "result" event for a true success signal.
+            copilot_exit = self._extract_copilot_exit_code(stdout)
+            effective_rc = copilot_exit if copilot_exit is not None else returncode
+
+            if effective_rc == 0 and returncode == 0:
+                return TaskResult(
+                    status="success",
+                    exit_code=0,
+                    stdout=stdout[-settings.AGENT_MAX_OUTPUT_SIZE:],
+                    stderr=stderr[-10000:],
+                    metrics=metrics,
+                )
+            else:
+                return TaskResult(
+                    status="failed",
+                    exit_code=effective_rc,
+                    stdout=stdout[-settings.AGENT_MAX_OUTPUT_SIZE:],
+                    stderr=stderr[-10000:],
+                    error=f"Copilot exited with code {effective_rc}: {stderr[-500:]}",
+                    metrics=metrics,
+                )
+        except asyncio.TimeoutError:
+            if task_id in self.active_processes:
+                self.active_processes[task_id].kill()
+            return TaskResult(
+                status="failed", exit_code=-1, stdout="", stderr="",
+                error=f"Timed out after {timeout}s",
+            )
+        except Exception as exc:
+            logger.exception("Copilot stream error for task %s", task_id)
+            if task_id in self.active_processes:
+                try:
+                    self.active_processes[task_id].kill()
+                except Exception:
+                    pass
+            return TaskResult(
+                status="failed", exit_code=-1, stdout="", stderr="",
+                error=f"Stream processing error: {exc}",
+            )
+        finally:
+            self.active_processes.pop(task_id, None)
+
     async def _run_generic(
         self, agent: DiscoveredAgent, prompt: str, cwd: Path, timeout: int, task_id: str,
         on_chunk: Any = None,
@@ -2702,6 +2847,79 @@ class ProcessManager:
             metrics["token_output"] = output
         return metrics
 
+    def _parse_copilot_output(self, stdout: str) -> dict:
+        """Extract metrics from GitHub Copilot CLI JSONL output.
+
+        Copilot CLI (--output-format json) emits one JSON object per line.
+        The key event types:
+          - ``assistant.message``  -> content + model + outputTokens per turn
+          - ``result``             -> exitCode + usage (premiumRequests,
+                                     totalApiDurationMs, codeChanges)
+
+        Copilot is subscription-based and does NOT report USD cost or input
+        tokens, so those fields are intentionally omitted.
+        """
+        metrics: dict[str, Any] = {}
+        total_output_tokens = 0
+        model_seen: str | None = None
+
+        for raw in stdout.strip().split("\n"):
+            raw = raw.strip()
+            if not raw:
+                continue
+            try:
+                data = json.loads(raw)
+            except json.JSONDecodeError:
+                continue
+            if not isinstance(data, dict):
+                continue
+
+            ev_type = str(data.get("type", ""))
+
+            if ev_type == "assistant.message":
+                msg_data = data.get("data") or {}
+                out_tokens = msg_data.get("outputTokens")
+                if out_tokens:
+                    total_output_tokens += int(out_tokens)
+                if not model_seen and isinstance(msg_data.get("model"), str):
+                    model_seen = msg_data["model"]
+
+            elif ev_type == "result":
+                usage = data.get("usage") or {}
+                premium_reqs = usage.get("premiumRequests")
+                if premium_reqs is not None:
+                    metrics["premium_requests"] = int(premium_reqs)
+                api_ms = usage.get("totalApiDurationMs")
+                if api_ms:
+                    metrics["api_duration_ms"] = int(api_ms)
+                changes = usage.get("codeChanges") or {}
+                if changes.get("linesAdded") or changes.get("linesRemoved"):
+                    metrics["lines_added"] = int(changes.get("linesAdded") or 0)
+                    metrics["lines_removed"] = int(changes.get("linesRemoved") or 0)
+
+        if total_output_tokens:
+            metrics["token_output"] = total_output_tokens
+        if model_seen:
+            metrics["model"] = model_seen
+        return metrics
+
+    @staticmethod
+    def _extract_copilot_exit_code(stdout: str) -> int | None:
+        """Extract the exitCode from Copilot JSONL ``result`` event."""
+        for raw in reversed(stdout.strip().split("\n")):
+            raw = raw.strip()
+            if not raw:
+                continue
+            try:
+                data = json.loads(raw)
+            except json.JSONDecodeError:
+                continue
+            if isinstance(data, dict) and data.get("type") == "result":
+                ec = data.get("exitCode")
+                if ec is not None:
+                    return int(ec)
+        return None
+
     async def _collect_git_info(self, cwd: Path) -> dict:
         """Collect git diff stats from workspace."""
         info: dict[str, Any] = {}
@@ -2779,7 +2997,7 @@ class ProcessManager:
         """Collect git diff stats comparing HEAD vs merge-base with default branch.
 
         Uses merge-base to capture ALL changes on the feature branch, not just
-        the last commit (agents like claude-code may create multiple commits).
+        the last commit (agents like claude may create multiple commits).
         Falls back to HEAD~1 if merge-base detection fails.
         """
         info: dict[str, Any] = {}
@@ -3140,7 +3358,7 @@ class TaskPoller:
                     task_id=t["task_id"],
                     graph_id=t["graph_id"],
                     node_type=t["node_type"],
-                    agent_type=t.get("agent_type", "claude-code"),
+                    agent_type=t.get("agent_type", "claude"),
                     input_prompt=t.get("input_prompt", ""),
                     input_data=t.get("input_data", {}),
                     timeout_seconds=t.get("timeout_seconds", settings.AGENT_TIMEOUT),
@@ -3787,10 +4005,22 @@ class RuntimeDaemon:
             # 1. Find the right agent
             agent = self._select_agent(task.agent_type, task.fallback_chain)
             if not agent:
-                logger.error("No agent found for type '%s'", task.agent_type)
+                _INSTALL_HINTS = {
+                    "claude": "npm install -g @anthropic-ai/claude-code",
+                    "codex": "npm install -g @openai/codex",
+                    "opencode": "curl -sSL https://opencode.ai/install | sh",
+                    "gemini": "npm install -g @google/gemini-cli",
+                    "kimi": "curl -LsSf https://code.kimi.com/install.sh | bash",
+                    "copilot": "Install VS Code GitHub Copilot Chat extension, or run: gh copilot. Then: gh auth login",
+                }
+                hint = _INSTALL_HINTS.get(task.agent_type, f"install the '{task.agent_type}' CLI tool")
+                logger.error("No agent found for type '%s' on this runtime", task.agent_type)
                 await reporter.report_complete(task.task_id, TaskResult(
                     status="failed", exit_code=-1, stdout="", stderr="",
-                    error=f"No agent CLI available for type '{task.agent_type}'",
+                    error=(
+                        f"Agent '{task.agent_type}' is not available on this runtime. "
+                        f"Install it: {hint}"
+                    ),
                 ))
                 return
 
@@ -3818,15 +4048,22 @@ class RuntimeDaemon:
                 _line_buffer.extend(lines)
 
             async def _progress_ticker():
-                """Flush buffered output lines + update progress % every 5 s."""
+                """Flush buffered output lines + update progress % every 1 s.
+
+                Using 1-second ticks keeps the UI responsive without flooding
+                the backend. Empty ticks are skipped to reduce HTTP traffic.
+                """
                 import math as _math
                 tick = 0
                 while not progress_stop.is_set():
-                    await asyncio.sleep(5)
+                    await asyncio.sleep(1)
                     if progress_stop.is_set():
                         break
+                    if not _line_buffer and tick < 3:
+                        tick += 1
+                        continue
                     tick += 1
-                    pct = min(int(10 + 80 * (1 - 1 / (1 + tick / 16))), 90)
+                    pct = min(int(10 + 80 * (1 - 1 / (1 + tick / 80))), 90)
                     pid = self.process_manager.active_processes.get(task.task_id)
                     step = "running_agent"
                     if pid:
@@ -3912,11 +4149,14 @@ class RuntimeDaemon:
                     async def _progress_ticker2():
                         tick = 0
                         while not progress_stop2.is_set():
-                            await asyncio.sleep(5)
+                            await asyncio.sleep(1)
                             if progress_stop2.is_set():
                                 break
+                            if not _line_buffer and tick < 3:
+                                tick += 1
+                                continue
                             tick += 1
-                            pct = min(int(10 + 80 * (1 - 1 / (1 + tick / 16))), 90)
+                            pct = min(int(10 + 80 * (1 - 1 / (1 + tick / 80))), 90)
                             pid = self.process_manager.active_processes.get(task.task_id)
                             step = f"running_agent:{agent.agent_id}"
                             if pid:
@@ -4136,8 +4376,8 @@ class RuntimeDaemon:
                     if agent.agent_id == fallback_id:
                         return agent
 
-        # 2. Try any available agent not yet tried (prefer opencode > gemini > claude-code)
-        preferred_order = ["opencode", "gemini", "claude-code"]
+        # 2. Try any available agent not yet tried (prefer opencode > copilot > gemini > claude)
+        preferred_order = ["opencode", "copilot", "gemini", "claude"]
         for preferred_id in preferred_order:
             if preferred_id in tried:
                 continue
@@ -4152,7 +4392,17 @@ class RuntimeDaemon:
         return None
 
     def _select_agent(self, agent_type: str, fallback_chain: list[str] | None = None) -> DiscoveredAgent | None:
-        """Find best matching agent for the requested type with fallback chain support."""
+        """Find best matching agent for the requested type with fallback chain support.
+
+        Returns ``None`` when the requested agent is a known canonical ID but is not
+        currently installed/discovered on this machine — callers should report a clear
+        error rather than silently running a different agent.
+
+        The "any available agent" fallbacks (steps 3–4) only apply when ``agent_type``
+        is NOT a recognized canonical ID (e.g. empty string, "auto", or an unknown
+        custom identifier).  This prevents silent substitution when the user explicitly
+        selected an agent that is just not installed locally.
+        """
         # 1. Exact match
         for agent in self.agents:
             if agent.agent_id == agent_type:
@@ -4168,11 +4418,18 @@ class RuntimeDaemon:
                         logger.info("Using fallback agent '%s' (requested '%s')", fallback_id, agent_type)
                         return agent
 
-        # 3. Fallback: first available L3 agent
+        # 3. If the requested agent_type is a KNOWN canonical ID (registered in
+        #    AGENT_REGISTRY) but not discovered locally, return None so the caller
+        #    can surface a clear "agent not installed" error instead of silently
+        #    using whatever L3 agent happens to be available.
+        if agent_type in AgentDiscovery.AGENT_REGISTRY:
+            return None
+
+        # 4. Fallback: first available L3 agent (only for unrecognized/generic types)
         for agent in self.agents:
             if agent.compatibility_level == "L3":
                 return agent
-        # 4. Any agent
+        # 5. Any agent (last resort for unrecognized types)
         return self.agents[0] if self.agents else None
 
     # ── Layer 2: Validation Gate ──
@@ -4390,13 +4647,30 @@ class RuntimeDaemon:
                 timeout=10,
             )
 
-            # 1. Select agent
-            agent_type = agent_override or "claude-code"
+            # 1. Select agent — normalize legacy aliases to canonical IDs
+            _AGENT_ALIASES = {"claude": "claude", "kimi": "kimi"}
+            agent_type = _AGENT_ALIASES.get(agent_override or "", agent_override or "claude")
             agent = self._select_agent(agent_type, [])
             if not agent:
+                _INSTALL_HINTS = {
+                    "claude": "npm install -g @anthropic-ai/claude-code",
+                    "codex": "npm install -g @openai/codex",
+                    "opencode": "curl -sSL https://opencode.ai/install | sh",
+                    "gemini": "npm install -g @google/gemini-cli",
+                    "kimi": "curl -LsSf https://code.kimi.com/install.sh | bash",
+                    "copilot": "Install VS Code GitHub Copilot Chat extension, or run: gh copilot. Then: gh auth login",
+                }
+                hint = _INSTALL_HINTS.get(agent_type, f"install the '{agent_type}' CLI tool")
                 await conn.client.post(
                     f"{reporter_url}/complete",
-                    json={"status": "failed", "error": f"No agent CLI for '{agent_type}'", "failure_code": "no_agent"},
+                    json={
+                        "status": "failed",
+                        "error": (
+                            f"Agent '{agent_type}' is not available on this runtime. "
+                            f"Install it: {hint}"
+                        ),
+                        "failure_code": "no_agent",
+                    },
                     timeout=10,
                 )
                 return
@@ -4683,7 +4957,7 @@ class RuntimeDaemon:
     async def _auto_commit(self, workspace_path: Path, task: TaskInfo) -> dict:
         """Auto-commit and push agent changes.
 
-        Some agents (e.g. claude-code) commit changes internally, so we must
+        Some agents (e.g. claude) commit changes internally, so we must
         also push even when the working directory is clean.
 
         Before pushing, we rebase onto the latest ``origin/{default_branch}``

{forgexa_cli-1.7.6 → forgexa_cli-1.8.3}/forgexa_cli.egg-info/PKG-INFO

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

{forgexa_cli-1.7.6 → forgexa_cli-1.8.3}/pyproject.toml

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