forgexa-cli 1.11.0__tar.gz → 1.11.1__tar.gz

{forgexa_cli-1.11.0 → forgexa_cli-1.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.11.0
+Version: 1.11.1
 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.11.0 → forgexa_cli-1.11.1}/forgexa_cli/__init__.py

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

{forgexa_cli-1.11.0 → forgexa_cli-1.11.1}/forgexa_cli/daemon.py

@@ -404,7 +404,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.11.0"
+DAEMON_VERSION = "1.11.1"
 
 
 def _detect_client_type() -> str:
@@ -841,12 +841,16 @@ class AgentDiscovery:
                         extra_dirs.append(versions[0])
         else:
             # macOS + Linux shared paths
+            # Kimi Code 0.18.0+ standalone installer puts the binary here;
+            # KIMI_CODE_HOME overrides the data dir (officially documented).
+            kimi_home = Path(os.environ.get("KIMI_CODE_HOME", home / ".kimi-code"))
             extra_dirs += [
                 home / ".local" / "bin",         # pip / pipx installs, Claude Code
                 home / ".opencode" / "bin",      # opencode
                 home / ".cargo" / "bin",         # Rust / cargo installs
                 home / ".bun" / "bin",           # bun
                 home / ".volta" / "bin",         # volta (node version manager)
+                kimi_home / "bin",               # Kimi Code 0.18.0+ (standalone installer)
             ]
             if is_mac:
                 # Homebrew Intel + Apple Silicon
@@ -1212,7 +1216,8 @@ class WorkspaceManager:
             if not is_fresh_start:
                 try:
                     await self._git(
-                        "fetch", "origin", branch_name,
+                        "fetch", "origin",
+                        f"{branch_name}:refs/remotes/origin/{branch_name}",
                         cwd=ws_path, project_key=project_key,
                     )
                 except RuntimeError:
@@ -2491,6 +2496,48 @@ class ProcessManager:
             changed_paths.update(self._normalize_repo_paths(paths))
         return bool(required_paths & changed_paths)
 
+    def _recover_timeout_from_workspace_changes(
+        self,
+        task: TaskInfo,
+        workspace_path: Path,
+        result: TaskResult,
+        pre_commit_git: dict,
+    ) -> bool:
+        """Recover absolute-timeout failures after validating workspace output."""
+        error_lower = (result.error or "").lower()
+        is_absolute_timeout = (
+            "absolute limit" in error_lower or "timed out after" in error_lower
+        )
+        changed_files = list(pre_commit_git.get("files_changed") or [])
+        if not is_absolute_timeout or not changed_files:
+            return False
+        if not self.process_manager.has_meaningful_agent_output(result):
+            return False
+
+        if result.files_changed:
+            result.files_changed = sorted(set(result.files_changed) | set(changed_files))
+        else:
+            result.files_changed = changed_files
+        if not result.lines_added:
+            result.lines_added = int(pre_commit_git.get("lines_added", 0) or 0)
+        if not result.lines_removed:
+            result.lines_removed = int(pre_commit_git.get("lines_removed", 0) or 0)
+
+        if not self.process_manager._has_required_deliverable_updates(
+            task,
+            changed_files,
+            result.files_changed,
+        ):
+            return False
+
+        validation_issues = self._validate_outputs(workspace_path, task, result)
+        if validation_issues:
+            result.metrics["timeout_recovery_validation_issues"] = validation_issues
+            return False
+
+        result.metrics["recovered_from_timeout_uncommitted_changes"] = True
+        return True
+
     def _build_prompt(self, task: TaskInfo) -> str:
         """Build the prompt to send to the agent.
 
@@ -2542,6 +2589,7 @@ class ProcessManager:
         task_id: str,
         on_chunk: Any,
         workspace_path: "Path | None" = None,
+        stream_stderr: bool = False,
     ) -> tuple[str, str, int]:
         """Stream stdout line-by-line from a subprocess, flushing to on_chunk.
 
@@ -2551,6 +2599,12 @@ class ProcessManager:
         - Stdout is read line-by-line so callers receive output in real time.
         - Stderr is consumed concurrently via a background task to avoid pipe
           deadlock when the process fills the stderr buffer.
+        - When ``stream_stderr`` is True, stderr lines are also forwarded to
+          ``on_chunk`` in real time and merged into the returned stdout text.
+          This is required for agents (e.g. Kimi Code 0.18.0+) that write all
+          real-time progress to stderr, reserving stdout for a buffered final
+          answer.  Stderr activity also resets the idle timer so the agent is
+          not killed while actively producing output.
         - on_chunk(lines) is called with each decoded line so the caller can
           forward to the progress reporter without waiting for completion.
         - Idle timeout: if the agent produces no stdout for AGENT_IDLE_TIMEOUT
@@ -2582,7 +2636,28 @@ class ProcessManager:
         stderr_chunks: list[bytes] = []
 
         async def _read_stderr():
-            if proc.stderr:
+            if not proc.stderr:
+                return
+            if stream_stderr:
+                # Agent (e.g. Kimi Code 0.18.0+) writes real-time progress to
+                # stderr.  Read line-by-line and forward to on_chunk so the
+                # user sees output immediately.  Also reset the idle timer so
+                # the agent is not killed while actively working on stderr.
+                while True:
+                    line_bytes = await proc.stderr.readline()
+                    if not line_bytes:
+                        break
+                    stderr_chunks.append(line_bytes)
+                    line = line_bytes.decode(errors="replace").rstrip("\n")
+                    if line:
+                        _last_activity_at[0] = time.monotonic()
+                        stdout_lines.append(line)
+                        if on_chunk:
+                            try:
+                                await on_chunk([line])
+                            except Exception:
+                                pass
+            else:
                 data = await proc.stderr.read()
                 stderr_chunks.append(data)
 
@@ -2960,11 +3035,31 @@ class ProcessManager:
         self, agent: DiscoveredAgent, prompt: str, cwd: Path, timeout: int, task_id: str,
         on_chunk: Any = None,
     ) -> TaskResult:
-        """Run Kimi Code CLI in non-interactive, auto-approved mode."""
-        cmd = [agent.command, "--print", "--yolo", "-p", prompt]
-        result = await self._run_cli(cmd, cwd, timeout, task_id, on_chunk=on_chunk)
+        """Run Kimi Code CLI in non-interactive prompt mode.
+
+        Kimi Code 0.18.0+ removed ``--print`` and refuses to combine ``--yolo``
+        or ``--auto`` with ``-p``.  In prompt mode auto-approval is implicit,
+        so a bare ``-p <prompt>`` is the correct non-interactive invocation.
+
+        Kimi 0.18.0+ writes all real-time progress (thinking, tool calls,
+        status) to **stderr**, reserving stdout for a buffered final answer.
+        We therefore stream stderr through ``on_chunk`` so the user sees
+        output in real time instead of a blank panel until process exit.
+        """
+        cmd = [agent.command, "-p", prompt]
+        result = await self._run_cli(
+            cmd, cwd, timeout, task_id, on_chunk=on_chunk,
+            stream_stderr=True,
+        )
         parsed_metrics = self._parse_agent_jsonl_output(result.stdout)
         result.metrics.update(parsed_metrics)
+        # Kimi 0.18.0+ stores token usage in the session wire.jsonl file,
+        # not in CLI output.  Fall back to parsing that file when the
+        # stdout/stderr parsers found nothing.
+        if not result.metrics.get("token_input") and not result.metrics.get("token_output"):
+            wire_metrics = self._parse_kimi_wire_metrics(result.stdout)
+            if wire_metrics:
+                result.metrics.update(wire_metrics)
         return result
 
     async def _run_copilot(
@@ -3076,6 +3171,7 @@ class ProcessManager:
         stdin_input: str | None = None,
         on_chunk: Any = None,
         env: dict | None = None,
+        stream_stderr: bool = False,
     ) -> TaskResult:
         try:
             proc = await asyncio.create_subprocess_exec(
@@ -3093,6 +3189,7 @@ class ProcessManager:
             stdout, stderr, returncode = await self._stream_process(
                 proc, stdin_bytes, timeout, task_id, on_chunk,
                 workspace_path=cwd,
+                stream_stderr=stream_stderr,
             )
             status = "success" if returncode == 0 else "failed"
             return TaskResult(
@@ -3362,6 +3459,109 @@ class ProcessManager:
             metrics["token_output"] = output
         return metrics
 
+    def _parse_kimi_wire_metrics(self, output: str) -> dict:
+        """Extract token usage from Kimi Code 0.18.0+ session wire.jsonl.
+
+        Kimi 0.18.0+ (full architecture rewrite) no longer prints
+        ``TokenUsage(...)`` repr lines to stdout/stderr.  Instead, token
+        usage is persisted in the session's ``wire.jsonl`` file as JSON
+        events::
+
+            {"type":"usage.record",
+             "model":"kimi-code/kimi-for-coding",
+             "usage":{"inputOther":1241,"output":36,
+                       "inputCacheRead":14592,"inputCacheCreation":0},
+             "usageScope":"turn"}
+
+        We extract the session id from the CLI output, resolve the session
+        directory via ``session_index.jsonl``, then sum every
+        ``usage.record`` event to get cumulative token counts.
+        """
+        import re as _re
+        metrics: dict[str, Any] = {}
+
+        # 1. Extract session id from output — appears as:
+        #    "To resume this session: kimi -r session_<uuid>"
+        #    or JSON: "session_id":"session_<uuid>"
+        session_match = _re.search(
+            r"session_([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})",
+            output,
+        )
+        if not session_match:
+            return metrics
+        session_id = "session_" + session_match.group(1)
+
+        # 2. Resolve session directory via session_index.jsonl
+        kimi_home = Path(os.environ.get("KIMI_CODE_HOME", Path.home() / ".kimi-code"))
+        index_path = kimi_home / "session_index.jsonl"
+        if not index_path.is_file():
+            return metrics
+
+        session_dir: Path | None = None
+        try:
+            with open(index_path, encoding="utf-8", errors="replace") as fh:
+                for line in fh:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        entry = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+                    if entry.get("sessionId") == session_id:
+                        sd = entry.get("sessionDir")
+                        if sd:
+                            session_dir = Path(sd)
+                        break
+        except (OSError, IOError):
+            return metrics
+
+        if not session_dir or not session_dir.is_dir():
+            return metrics
+
+        # 3. Parse wire.jsonl for usage.record events
+        wire_path = session_dir / "agents" / "main" / "wire.jsonl"
+        if not wire_path.is_file():
+            return metrics
+
+        total_input_other = 0
+        total_output = 0
+        total_cache_read = 0
+        total_cache_creation = 0
+        model: str | None = None
+
+        try:
+            with open(wire_path, encoding="utf-8", errors="replace") as fh:
+                for line in fh:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        data = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+                    if data.get("type") != "usage.record":
+                        continue
+                    usage = data.get("usage") or {}
+                    total_input_other += int(usage.get("inputOther") or 0)
+                    total_output += int(usage.get("output") or 0)
+                    total_cache_read += int(usage.get("inputCacheRead") or 0)
+                    total_cache_creation += int(usage.get("inputCacheCreation") or 0)
+                    if not model and data.get("model"):
+                        model = data["model"]
+        except (OSError, IOError):
+            return metrics
+
+        if total_output > 0 or total_input_other > 0 or total_cache_read > 0:
+            metrics["token_input"] = (
+                total_input_other + total_cache_read + total_cache_creation
+            )
+            metrics["token_output"] = total_output
+            if model:
+                metrics["model"] = model
+
+        return metrics
+
     def _parse_copilot_output(self, stdout: str) -> dict:
         """Extract metrics from GitHub Copilot CLI JSONL output.
 
@@ -4527,7 +4727,7 @@ class RuntimeDaemon:
                     "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",
+                    "kimi": "curl -fsSL https://code.kimi.com/kimi-code/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")
@@ -4876,30 +5076,48 @@ class RuntimeDaemon:
                     or result.exit_code not in (None, -1)  # crash: original guard
                 )
                 if can_attempt_recovery:
+                    original_exit_code = result.exit_code
                     committed_git = await self.process_manager._collect_git_info_vs_parent(workspace_path)
                     has_committed_changes = bool(committed_git.get("files_changed"))
-                    has_no_uncommitted = not pre_commit_git.get("files_changed")
+                    has_uncommitted_changes = bool(pre_commit_git.get("files_changed"))
+                    has_no_uncommitted = not has_uncommitted_changes
                     has_tokens = (
                         int(result.metrics.get("token_input", 0) or 0)
                         + int(result.metrics.get("token_output", 0) or 0)
                     ) > 0
                     has_meaningful_output = self.process_manager.has_meaningful_agent_output(result)
+                    recovered_from_workspace_timeout = (
+                        self._recover_timeout_from_workspace_changes(
+                            task, workspace_path, result, pre_commit_git,
+                        )
+                        if has_uncommitted_changes else False
+                    )
                     # Timeout recovery requires stronger evidence: committed work + tokens.
                     # Crash recovery (original): committed + (tokens OR meaningful output).
                     sufficient_evidence = (
-                        (has_committed_changes and has_no_uncommitted and has_tokens and has_meaningful_output)
+                        recovered_from_workspace_timeout
+                        or (has_committed_changes and has_no_uncommitted and has_tokens and has_meaningful_output)
                         if is_timeout_failure
                         else (has_committed_changes and has_no_uncommitted and (has_tokens or has_meaningful_output))
                     )
                     if sufficient_evidence:
-                        _reason = "timed out but already committed changes" if is_timeout_failure else f"exited with code {result.exit_code}"
+                        _reason = (
+                            "timed out after producing valid workspace changes"
+                            if recovered_from_workspace_timeout
+                            else (
+                                "timed out but already committed changes"
+                                if is_timeout_failure else f"exited with code {original_exit_code}"
+                            )
+                        )
                         logger.warning(
                             "Task %s agent %s — recovering as success",
                             task.task_id, _reason,
                         )
                         result.status = "success"
                         result.error = ""
-                        result.metrics["recovered_from_exit_code"] = result.exit_code
+                        result.exit_code = 0
+                        result.failure_code = ""
+                        result.metrics["recovered_from_exit_code"] = original_exit_code
 
             # 4.5 Layer 2: Validation gate — check outputs before committing
             if result.status == "success":
@@ -5060,6 +5278,10 @@ class RuntimeDaemon:
                 result.lines_removed = result.git.get("lines_removed", 0)
             else:
                 result.git = pre_commit_git
+                if not result.files_changed and pre_commit_git.get("files_changed"):
+                    result.files_changed = pre_commit_git["files_changed"]
+                    result.lines_added = pre_commit_git.get("lines_added", 0)
+                    result.lines_removed = pre_commit_git.get("lines_removed", 0)
 
             # 6. Report completion (include actual agent used if different from requested)
             result.metrics["actual_agent"] = agent.agent_id
@@ -5385,7 +5607,7 @@ class RuntimeDaemon:
                     "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",
+                    "kimi": "curl -fsSL https://code.kimi.com/kimi-code/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")
@@ -6283,6 +6505,23 @@ class RuntimeDaemon:
 
         return "\n".join(parts).rstrip()
 
+    async def _fetch_branch_tracking_ref(
+        self,
+        workspace_path: Path,
+        branch: str,
+        project_key: str = "default",
+        *,
+        timeout: int = 120,
+    ) -> None:
+        """Refresh origin/<branch> explicitly, even inside single-branch clones."""
+        await self.workspace_manager._git(
+            "fetch", "origin",
+            f"{branch}:refs/remotes/origin/{branch}",
+            cwd=workspace_path,
+            timeout=timeout,
+            project_key=project_key,
+        )
+
     @staticmethod
     def _is_test_path(path: str) -> bool:
         p = path.lower()
@@ -7103,9 +7342,11 @@ class RuntimeDaemon:
                 # fail with "non-fast-forward".  This is the single most reliable
                 # guard for cross-runtime / cross-machine collaboration scenarios.
                 try:
-                    await git(
-                        "fetch", "origin", branch,
-                        cwd=workspace_path, project_key=project_key,
+                    await self._fetch_branch_tracking_ref(
+                        workspace_path,
+                        branch,
+                        project_key,
+                        timeout=300,
                     )
                 except RuntimeError as _pre_push_fetch_exc:
                     logger.warning(
@@ -7265,9 +7506,10 @@ class RuntimeDaemon:
                             )
                             try:
                                 # 1. Fetch the specific remote branch
-                                await git(
-                                    "fetch", "origin", branch,
-                                    cwd=workspace_path,
+                                await self._fetch_branch_tracking_ref(
+                                    workspace_path,
+                                    branch,
+                                    project_key,
                                 )
                                 # 2. Rebase local commits onto the updated remote HEAD.
                                 #    Use -X theirs so that when the same file was modified by

{forgexa_cli-1.11.0 → forgexa_cli-1.11.1}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.11.0
+Version: 1.11.1
 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.11.0 → forgexa_cli-1.11.1}/pyproject.toml

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