forgexa-cli 1.11.4__tar.gz → 1.11.5__tar.gz

{forgexa_cli-1.11.4 → forgexa_cli-1.11.5}/PKG-INFO

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

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

{forgexa_cli-1.11.4 → forgexa_cli-1.11.5}/forgexa_cli/daemon.py

@@ -474,7 +474,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.4"
+DAEMON_VERSION = "1.11.5"
 
 
 def _detect_client_type() -> str:
@@ -726,6 +726,100 @@ class TaskResult:
     git: dict = field(default_factory=dict)
 
 
+def _prepare_ai_job_output(
+    *,
+    task_type: str,
+    agent_id: str,
+    raw_output: str,
+    max_content: int,
+) -> tuple[str, list[dict] | None]:
+    """Normalize AIJob output before reporting it back to the server."""
+    normalized_output, scenario_items = _normalize_ai_job_output(
+        task_type=task_type,
+        agent_id=agent_id,
+        raw_output=raw_output,
+    )
+    output_content = normalized_output[-max_content:] if normalized_output else ""
+    return output_content, scenario_items
+
+
+def _normalize_ai_job_output(
+    *,
+    task_type: str,
+    agent_id: str,
+    raw_output: str,
+) -> tuple[str, list[dict] | None]:
+    """Extract agent-specific final text before truncating for transport."""
+    if not raw_output:
+        return "", None
+
+    if task_type not in {"qa_scenario_generate_prompt", "test_script_generate"}:
+        return raw_output, None
+
+    from app.services.ai_execution_strategy import AIExecutionStrategy
+
+    extracted_output = AIExecutionStrategy._extract_agent_output(agent_id, raw_output)
+    if task_type == "test_script_generate":
+        return extracted_output or raw_output, None
+
+    from app.services.qa_ai_assistant import QAAIAssistant
+
+    parsed = QAAIAssistant._extract_json(extracted_output)
+    if isinstance(parsed, list):
+        return json.dumps(parsed), parsed
+    if isinstance(parsed, dict):
+        items = parsed.get("items")
+        if isinstance(items, list):
+            return json.dumps(items), items
+    if extracted_output and extracted_output != raw_output:
+        return extracted_output, None
+    return raw_output, None
+
+
+def _extract_ai_job_scripts(
+    *,
+    output_text: str,
+    scenario_ids: list[str],
+    workspace_path: Path,
+) -> dict[str, str]:
+    scripts: dict[str, str] = {}
+    if not scenario_ids or not output_text:
+        return scripts
+
+    import re as _re
+
+    for sid in scenario_ids:
+        pattern = (
+            r"##\s*SCRIPT_START::" + _re.escape(sid)
+            + r"\s*\n(.*?)\n##\s*SCRIPT_END::" + _re.escape(sid)
+        )
+        match = _re.search(pattern, output_text, _re.DOTALL)
+        if match:
+            scripts[sid] = match.group(1).strip()
+
+    if not scripts and len(scenario_ids) == 1:
+        scripts[scenario_ids[0]] = output_text.strip()
+
+    if scripts:
+        return scripts
+
+    import glob as _glob
+
+    for sid in scenario_ids:
+        test_files = _glob.glob(
+            str(workspace_path / "tests" / "**" / f"*{sid[:8]}*"),
+            recursive=True,
+        )
+        if test_files:
+            try:
+                with open(test_files[0], "r") as f:
+                    scripts[sid] = f.read()
+            except Exception:
+                pass
+
+    return scripts
+
+
 def _resolve_git_author(project: dict) -> tuple[str, str]:
     """Resolve git commit author (name, email) using a 5-tier fallback chain.
 
@@ -1207,6 +1301,20 @@ class WorkspaceManager:
             return None
         return key_content  # Return raw key content, _git will handle it
 
+    @staticmethod
+    def _clone_args(*, branch: str | None = None) -> tuple[str, ...]:
+        """Return the standard clone args for daemon workspaces.
+
+        Runtime workspaces only need the current branch contents. They already
+        avoid tags and non-target branches, so making the clone shallow is
+        consistent and prevents very large repositories from timing out while
+        transferring years of irrelevant history.
+        """
+        args: list[str] = ["clone", "--depth", "1", "--single-branch", "--no-tags"]
+        if branch:
+            args.extend(["--branch", branch])
+        return tuple(args)
+
     async def prepare_workspace(self, project: dict, task: TaskInfo) -> Path:
         """Create or reuse a workspace for the given task.
 
@@ -1952,8 +2060,7 @@ class WorkspaceManager:
         # Ensure _main repo is present and up-to-date
         if not main_repo.exists():
             await self._git(
-                "clone", "--single-branch", "--no-tags",
-                "--branch", default_branch,
+                *self._clone_args(branch=default_branch),
                 repo_url, str(main_repo), timeout=settings.GIT_CLONE_TIMEOUT, project_key=project_key,
             )
         else:
@@ -1983,8 +2090,7 @@ class WorkspaceManager:
                 await self._safe_rmtree_main(main_repo)
                 try:
                     await self._git(
-                        "clone", "--single-branch", "--no-tags",
-                        "--branch", default_branch,
+                        *self._clone_args(branch=default_branch),
                         repo_url, str(main_repo), timeout=settings.GIT_CLONE_TIMEOUT, project_key=project_key,
                     )
                 except Exception:
@@ -2016,8 +2122,7 @@ class WorkspaceManager:
                         await self._safe_rmtree_main(main_repo)
                         try:
                             await self._git(
-                                "clone", "--single-branch", "--no-tags",
-                                "--branch", default_branch,
+                                *self._clone_args(branch=default_branch),
                                 repo_url, str(main_repo), timeout=settings.GIT_CLONE_TIMEOUT,
                                 project_key=project_key,
                             )
@@ -2129,7 +2234,7 @@ class WorkspaceManager:
                     except Exception:
                         ws_path.mkdir(parents=True, exist_ok=True)
                         await self._git(
-                            "clone", "--single-branch", "--no-tags",
+                            *self._clone_args(),
                             repo_url, str(ws_path), timeout=settings.GIT_CLONE_TIMEOUT, project_key=project_key,
                         )
                         # Ensure we're on the correct branch after clone
@@ -2154,7 +2259,7 @@ class WorkspaceManager:
                     # Fallback to simple clone
                     ws_path.mkdir(parents=True, exist_ok=True)
                     await self._git(
-                        "clone", "--single-branch", "--no-tags",
+                        *self._clone_args(),
                         repo_url, str(ws_path), timeout=settings.GIT_CLONE_TIMEOUT, project_key=project_key,
                     )
                     # Ensure we're on the correct branch after clone
@@ -3604,6 +3709,50 @@ class ProcessManager:
         result.error = error_clean or result.error
         return result
 
+    @staticmethod
+    def _prepare_copilot_home() -> str:
+        """Prepare a writable Copilot home under ~/.forgexa for sandboxed runs.
+
+        The systemd daemon runs with ProtectSystem=strict and can only write to
+        ~/.forgexa plus the workspace root. Copilot CLI 1.0.64 persists runtime
+        state under ~/.copilot/session-state and its SQLite session store. That
+        causes EROFS failures under the daemon even when interactive shell runs
+        work fine.
+
+        Mirror the user-facing ~/.copilot state into a writable daemon-owned
+        directory, then point COPILOT_HOME there for non-interactive runs.
+        """
+        source_root = Path.home() / ".copilot"
+        target_root = Path.home() / ".forgexa" / "copilot-home"
+        target_root.mkdir(parents=True, exist_ok=True)
+
+        if not source_root.exists():
+            return str(target_root)
+
+        for child in source_root.iterdir():
+            if child.name in {"logs", "session-state"}:
+                continue
+
+            dest = target_root / child.name
+            try:
+                if child.is_dir():
+                    if child.name != "ide":
+                        continue
+                    dest.mkdir(parents=True, exist_ok=True)
+                    for sub in child.iterdir():
+                        if not sub.is_file() or sub.name.endswith(".lock"):
+                            continue
+                        shutil.copy2(sub, dest / sub.name)
+                elif child.is_file():
+                    shutil.copy2(child, dest)
+            except Exception as exc:
+                logger.debug(
+                    "Copilot home mirror skipped %s -> %s: %s",
+                    child, dest, exc,
+                )
+
+        return str(target_root)
+
     async def _run_copilot(
         self, agent: DiscoveredAgent, prompt: str, cwd: Path, timeout: int, task_id: str,
         on_chunk: Any = None,
@@ -3623,6 +3772,7 @@ class ProcessManager:
         """
         env = os.environ.copy()
         env["TERM"] = "dumb"  # suppress TTY-detection that suspends the process
+        env["COPILOT_HOME"] = self._prepare_copilot_home()
 
         model_override = os.environ.get("FACTORY_COPILOT_MODEL")
         reasoning = os.environ.get("FACTORY_COPILOT_REASONING", "medium")
@@ -6360,42 +6510,24 @@ class RuntimeDaemon:
             # 5. Report completion
             # For deliverables: allow up to 200K chars (full document); others: last 20K
             max_content = 200000 if task_type == "deliverable_generate" else 20000
-            output_content = (result.stdout or "")[-max_content:] if result.stdout else ""
-            scripts: dict = {}
-
-            scenario_ids = input_ctx.get("scenario_ids", [])
-            if scenario_ids and output_content:
-                # Primary: extract scripts using structured SCRIPT_START/END markers
-                # inserted by poll_ai_jobs into the multi-scenario prompt.
-                import re as _re
-                for sid in scenario_ids:
-                    pattern = (
-                        r"##\s*SCRIPT_START::" + _re.escape(sid)
-                        + r"\s*\n(.*?)\n##\s*SCRIPT_END::" + _re.escape(sid)
-                    )
-                    m = _re.search(pattern, output_content, _re.DOTALL)
-                    if m:
-                        scripts[sid] = m.group(1).strip()
-
-                # Fallback: if no markers found but only one scenario, treat
-                # the entire output as that scenario's script.
-                if not scripts and len(scenario_ids) == 1:
-                    scripts[scenario_ids[0]] = output_content.strip()
-
-                # Fallback: check workspace for test files named after scenario
-                if not scripts:
-                    import glob as _glob
-                    for sid in scenario_ids:
-                        test_files = _glob.glob(
-                            str(workspace_path / "tests" / "**" / f"*{sid[:8]}*"),
-                            recursive=True,
-                        )
-                        if test_files:
-                            try:
-                                with open(test_files[0], "r") as f:
-                                    scripts[sid] = f.read()
-                            except Exception:
-                                pass
+            normalized_output, scenario_items = _normalize_ai_job_output(
+                task_type=task_type,
+                agent_id=agent.agent_id,
+                raw_output=result.stdout or "",
+            )
+            output_content = normalized_output[-max_content:] if normalized_output else ""
+            scripts = _extract_ai_job_scripts(
+                output_text=normalized_output,
+                scenario_ids=input_ctx.get("scenario_ids", []),
+                workspace_path=workspace_path,
+            )
+            if task_type == "qa_scenario_generate_prompt":
+                output_content, scenario_items = _prepare_ai_job_output(
+                    task_type=task_type,
+                    agent_id=agent.agent_id,
+                    raw_output=result.stdout or "",
+                    max_content=max_content,
+                )
 
             # Preserve all_agents_rate_limited so the server does NOT re-enqueue.
             _failure_code = result.failure_code if result.failure_code else (
@@ -6416,6 +6548,8 @@ class RuntimeDaemon:
                 "error": result.error if result.status != "success" else "",
                 "failure_code": _failure_code,
             }
+            if scenario_items:
+                complete_payload["output_result"]["items"] = scenario_items
 
             await conn.client.post(
                 f"{reporter_url}/complete",

{forgexa_cli-1.11.4 → forgexa_cli-1.11.5}/forgexa_cli.egg-info/PKG-INFO

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

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