forgexa-cli 1.14.0__tar.gz → 1.14.3__tar.gz

{forgexa_cli-1.14.0 → forgexa_cli-1.14.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.14.0
+Version: 1.14.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.14.0 → forgexa_cli-1.14.3}/forgexa_cli/__init__.py

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

{forgexa_cli-1.14.0 → forgexa_cli-1.14.3}/forgexa_cli/daemon.py

@@ -523,7 +523,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.14.0"
+DAEMON_VERSION = "1.14.3"
 
 
 def _detect_client_type() -> str:
@@ -1074,6 +1074,85 @@ def _extract_ai_job_scripts(
     return scripts
 
 
+def _resolve_ai_job_workspace_scope(ai_job: dict) -> str | None:
+    workspace_key = str(ai_job.get("workspace_key") or "").strip()
+    if workspace_key:
+        return workspace_key
+
+    input_ctx = ai_job.get("input_context") or {}
+
+    explicit_key = str(input_ctx.get("workspace_key") or "").strip()
+    if explicit_key:
+        return explicit_key
+
+    suite_id = str(input_ctx.get("suite_id") or "").strip()
+    if suite_id:
+        return f"qa-suite-{suite_id}"
+
+    requirement_id = str(input_ctx.get("requirement_id") or "").strip()
+    if requirement_id:
+        return f"requirement-{requirement_id}"
+
+    requirement_key = str(ai_job.get("requirement_key") or "").strip()
+    if requirement_key:
+        return f"requirement-{requirement_key}"
+
+    return None
+
+
+def _summarize_workspace_source(workspace_path: Path) -> str | None:
+    """Extract a lightweight local workspace summary for prompt grounding."""
+    import os
+
+    if not workspace_path.exists():
+        return None
+
+    file_list: list[str] = []
+    for root, dirs, files in os.walk(workspace_path):
+        dirs[:] = [
+            d for d in dirs
+            if not d.startswith(".") and d not in (
+                "node_modules", "__pycache__", ".git", "dist", "build", "venv", ".venv",
+            )
+        ]
+        rel = os.path.relpath(root, workspace_path)
+        for file_name in files:
+            if file_name.startswith("."):
+                continue
+            path = f"{rel}/{file_name}" if rel != "." else file_name
+            file_list.append(path)
+            if len(file_list) >= 250:
+                break
+        if len(file_list) >= 250:
+            break
+
+    if not file_list:
+        return None
+
+    lines: list[str] = ["## Project Structure", "```", *file_list[:250], "```"]
+    priority_patterns = [
+        "routes", "router", "api", "endpoints", "views",
+        "models", "schema", "types", "entities",
+        "package.json", "pyproject.toml", "requirements.txt",
+        "dockerfile", "docker-compose", "nginx.conf",
+        "readme",
+    ]
+    key_files = [
+        path for path in file_list
+        if any(pattern in path.lower() for pattern in priority_patterns)
+    ][:8]
+
+    for key_file in key_files:
+        full_path = workspace_path / key_file
+        try:
+            content = full_path.read_text(encoding="utf-8", errors="ignore")[:3000]
+        except Exception:
+            continue
+        lines.append(f"\n### {key_file}\n```\n{content}\n```")
+
+    return "\n".join(lines)[:8000]
+
+
 def _resolve_git_author(project: dict) -> tuple[str, str]:
     """Resolve git commit author (name, email) using a 5-tier fallback chain.
 
@@ -1576,11 +1655,13 @@ class WorkspaceManager:
             "timeout",
             "timed out",
             "server not responding",
+            "received disconnect",
             "unexpected disconnect",
             "early eof",
             "invalid index-pack output",
             "fetch-pack",
             "remote hung up unexpectedly",
+            "too many concurrent connections",
             "connection reset",
             "connection closed",
             "connection refused",
@@ -1901,6 +1982,42 @@ class WorkspaceManager:
             _shutil.rmtree(wt, ignore_errors=True)
         _shutil.rmtree(main_repo, ignore_errors=True)
 
+    async def _find_existing_worktree_for_branch(
+        self,
+        main_repo: Path,
+        branch_name: str,
+    ) -> Path | None:
+        """Return an existing healthy linked worktree already on branch_name."""
+        try:
+            raw = await self._git("worktree", "list", "--porcelain", cwd=main_repo)
+        except RuntimeError:
+            return None
+
+        target_ref = f"refs/heads/{branch_name}"
+        entries: list[tuple[Path, str | None]] = []
+        current_path: Path | None = None
+        current_branch: str | None = None
+
+        for line in raw.splitlines():
+            if line.startswith("worktree "):
+                if current_path is not None:
+                    entries.append((current_path, current_branch))
+                current_path = Path(line.split(" ", 1)[1].strip())
+                current_branch = None
+            elif line.startswith("branch "):
+                current_branch = line.split(" ", 1)[1].strip()
+
+        if current_path is not None:
+            entries.append((current_path, current_branch))
+
+        for candidate_path, candidate_branch in entries:
+            if candidate_path == main_repo or candidate_branch != target_ref:
+                continue
+            if candidate_path.exists() and await self._is_healthy_worktree(candidate_path, main_repo=main_repo):
+                return candidate_path
+
+        return None
+
     async def _detect_unrelated_histories(self, repo_path: Path, project_key: str) -> bool:
         """Detect whether local clone has diverged from remote due to history rewrite.
 
@@ -2550,12 +2667,34 @@ class WorkspaceManager:
                     cwd=main_repo,
                 )
             except Exception:
+                existing_branch_worktree = await self._find_existing_worktree_for_branch(
+                    main_repo, branch_name,
+                )
+                if existing_branch_worktree is not None:
+                    logger.info(
+                        "Reusing existing worktree %s for branch %s instead of creating %s",
+                        existing_branch_worktree,
+                        branch_name,
+                        ws_path,
+                    )
+                    return existing_branch_worktree
                 try:
                     await self._git(
                         "worktree", "add", str(ws_path), branch_name,
                         cwd=main_repo,
                     )
                 except Exception:
+                    existing_branch_worktree = await self._find_existing_worktree_for_branch(
+                        main_repo, branch_name,
+                    )
+                    if existing_branch_worktree is not None:
+                        logger.info(
+                            "Reusing existing worktree %s for branch %s instead of creating %s",
+                            existing_branch_worktree,
+                            branch_name,
+                            ws_path,
+                        )
+                        return existing_branch_worktree
                     # Fallback: create from default_branch
                     try:
                         await self._git(
@@ -2563,6 +2702,17 @@ class WorkspaceManager:
                             cwd=main_repo,
                         )
                     except Exception:
+                        existing_branch_worktree = await self._find_existing_worktree_for_branch(
+                            main_repo, branch_name,
+                        )
+                        if existing_branch_worktree is not None:
+                            logger.info(
+                                "Reusing existing worktree %s for branch %s instead of cloning %s",
+                                existing_branch_worktree,
+                                branch_name,
+                                ws_path,
+                            )
+                            return existing_branch_worktree
                         ws_path.mkdir(parents=True, exist_ok=True)
                         await self._clone_repo(
                             repo_url,
@@ -2891,6 +3041,7 @@ class ProcessManager:
         "rate limit",
         "rate_limit",
         "quota exceeded",
+        "monthly quota",        # Copilot: "You have exceeded your monthly quota"
         "too many requests",
         "overloaded",
         "insufficient_quota",
@@ -3028,7 +3179,12 @@ class ProcessManager:
                 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")
+                        raw_errors = data.get("errors")
+                        if isinstance(raw_errors, list):
+                            err_text = "; ".join(str(item).strip() for item in raw_errors if str(item).strip())
+                        else:
+                            err_text = ""
+                        err_text = err_text or 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
@@ -3411,48 +3567,6 @@ 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.
 
@@ -3743,6 +3857,7 @@ class ProcessManager:
             "--output-format", "stream-json",
             "--verbose",
             "--max-turns", str(max_turns),
+            "--no-session-persistence",
             "--dangerously-skip-permissions",
         ]
 
@@ -3750,6 +3865,7 @@ class ProcessManager:
         model_override = os.environ.get("FACTORY_CLAUDE_MODEL")
         if model_override:
             env["ANTHROPIC_MODEL"] = model_override
+        env.update(self._prepare_claude_environment())
 
         try:
             proc = await asyncio.create_subprocess_exec(
@@ -3770,6 +3886,8 @@ class ProcessManager:
 
             # Parse Claude JSON output for metrics
             metrics = self._parse_claude_output(stdout)
+            structured_errors = self._extract_output_signals("\n".join(part for part in (stdout, stderr) if part))["error_messages"]
+            structured_error_text = "; ".join(str(msg).strip() for msg in structured_errors if str(msg).strip())
 
             if returncode == 0:
                 return TaskResult(
@@ -3798,6 +3916,15 @@ class ProcessManager:
                               "exceeded the model's limit. Reduce prompt size or shorten file reads.",
                         metrics=metrics,
                     )
+                if structured_error_text:
+                    return TaskResult(
+                        status="failed",
+                        exit_code=returncode,
+                        stdout=stdout[-settings.AGENT_MAX_OUTPUT_SIZE:],
+                        stderr=stderr[-10000:],
+                        error=f"Claude exited with code {returncode}: {structured_error_text}",
+                        metrics=metrics,
+                    )
                 return TaskResult(
                     status="failed",
                     exit_code=returncode,
@@ -4101,6 +4228,58 @@ class ProcessManager:
         result.error = error_clean or result.error
         return result
 
+    @staticmethod
+    def _prepare_claude_environment() -> dict[str, str]:
+        """Prepare writable Claude config/data/cache dirs under ~/.forgexa.
+
+        The daemon service runs with ProtectSystem=strict and only allows
+        writes under ~/.forgexa plus the workspace root. Claude Code writes
+        config, debug logs, cache, and session state under XDG paths and
+        ~/.claude by default, which can fail with EROFS inside the daemon.
+
+        Point Claude at writable daemon-owned directories and mirror only the
+        small set of user config files it needs for headless execution.
+        """
+        sandbox_root = Path.home() / ".forgexa" / "claude-home"
+        config_root = sandbox_root / "config"
+        data_root = sandbox_root / "data"
+        cache_root = sandbox_root / "cache"
+        state_root = sandbox_root / "state"
+        claude_config_dir = config_root / "claude"
+
+        for path in (config_root, data_root, cache_root, state_root, claude_config_dir):
+            path.mkdir(parents=True, exist_ok=True)
+
+        source_files = [
+            (Path.home() / ".claude.json", claude_config_dir / ".claude.json"),
+            (Path.home() / ".claude" / "settings.json", claude_config_dir / "settings.json"),
+        ]
+        for source, dest in source_files:
+            try:
+                if source.is_file() and not dest.exists():
+                    shutil.copy2(source, dest)
+            except Exception as exc:
+                logger.debug(
+                    "Claude config mirror skipped %s -> %s: %s",
+                    source, dest, exc,
+                )
+
+        env = {
+            "XDG_CONFIG_HOME": str(config_root),
+            "XDG_DATA_HOME": str(data_root),
+            "XDG_CACHE_HOME": str(cache_root),
+            "XDG_STATE_HOME": str(state_root),
+            "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": str(
+                os.environ.get("CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC", "1")
+            ),
+        }
+
+        if not os.environ.get("CLAUDE_CODE_DEBUG_LOGS_DIR"):
+            env["CLAUDE_CODE_DEBUG_LOGS_DIR"] = str(cache_root / "claude-debug")
+            Path(env["CLAUDE_CODE_DEBUG_LOGS_DIR"]).mkdir(parents=True, exist_ok=True)
+
+        return env
+
     @staticmethod
     def _prepare_copilot_home() -> str:
         """Prepare a writable Copilot home under ~/.forgexa for sandboxed runs.
@@ -6031,6 +6210,48 @@ class RuntimeDaemon:
                         self._execute_ai_job(aj, conn)
                     )
 
+    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
+
     async def _execute_task(self, task: TaskInfo, conn: ServerConnection):
         """Execute a single task, reporting to the originating server connection."""
         reporter = conn.reporter
@@ -7053,12 +7274,14 @@ class RuntimeDaemon:
         agent_override = aj.get("agent_override")
         system_prompt = aj.get("system_prompt", "")
         user_prompt = aj.get("user_prompt", "")
+        input_ctx = aj.get("input_context", {})
+        ai_workspace_scope = _resolve_ai_job_workspace_scope(aj)
 
         reporter_url = f"{conn.server_url.rstrip('/')}/api/v1/runtimes/{conn.runtime_id}/ai-jobs/{job_id}"
         # Use workspace-level key (project:requirement or project:job_id) so AI jobs
         # for different requirements run in parallel while same-requirement jobs serialize.
         _aj_proj_key = project_info.get("project_key") or str(project_info.get("id") or "default")
-        project_lock_key = f"{_aj_proj_key}:{requirement_key or job_id}"
+        project_lock_key = f"{_aj_proj_key}:{ai_workspace_scope or job_id}"
         project_lock = await self._get_project_execution_lock(project_lock_key)
         if project_lock.locked():
             logger.info(
@@ -7111,11 +7334,10 @@ class RuntimeDaemon:
             full_prompt = f"{system_prompt}\n\n{user_prompt}" if system_prompt else user_prompt
             fake_task = TaskInfo(
                 task_id=job_id,
-                # Use job_id as graph_id so workspace_key is non-empty.
-                # If graph_id="" then workspace_key="" and ws_path == project_dir
-                # (Python: Path("x") / "" == Path("x")), causing git clone to
-                # fail with "destination path already exists" on the second run.
-                graph_id=job_id,
+                # Reuse a stable workspace key when the server provides one so
+                # delegated retries do not create a fresh clone per AIJob row.
+                # Fall back to job_id so workspace_key is always non-empty.
+                graph_id=ai_workspace_scope or job_id,
                 node_type="ai_job",
                 agent_type=agent_type,
                 input_prompt=full_prompt,
@@ -7134,6 +7356,17 @@ class RuntimeDaemon:
                 project_info, fake_task,
             )
 
+            if task_type == "qa_scenario_generate_prompt" and not input_ctx.get("project_context"):
+                local_project_context = _summarize_workspace_source(workspace_path)
+                if local_project_context:
+                    fake_task.input_prompt = (
+                        f"{full_prompt}\n\n"
+                        "Use the provided project source context when grounding scenario coverage. "
+                        "Do not rely on additional workspace searching before responding.\n"
+                        "Do not call Grep or search tools against '.' or a bare directory path directly.\n\n"
+                        f"## Project Source Code Context\n{local_project_context}"
+                    )
+
             await conn.client.post(
                 f"{reporter_url}/progress",
                 json={"current_phase": "running", "current_step": "Running agent...", "progress_pct": 15},
@@ -7210,7 +7443,6 @@ class RuntimeDaemon:
             # 4. Auto-commit if successful (always call _auto_commit on success:
             # _auto_commit handles both uncommitted changes AND internally-committed
             # changes that just need to be pushed — same as _execute_task).
-            input_ctx = aj.get("input_context", {})
             git_info = {}
             if result.status == "success":
                 git_info = await self._auto_commit(workspace_path, fake_task)

{forgexa_cli-1.14.0 → forgexa_cli-1.14.3}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.14.0
+Version: 1.14.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.14.0 → forgexa_cli-1.14.3}/pyproject.toml

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