forgexa-cli 1.13.3__tar.gz → 1.13.4__tar.gz

{forgexa_cli-1.13.3 → forgexa_cli-1.13.4}/PKG-INFO

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

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

{forgexa_cli-1.13.3 → forgexa_cli-1.13.4}/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.13.3"
+DAEMON_VERSION = "1.13.4"
 
 
 def _detect_client_type() -> str:
@@ -794,28 +794,231 @@ def _prepare_ai_job_output(
     return output_content, scenario_items
 
 
+# ── Self-contained agent-output extraction ────────────────────────────────────
+# These functions are deliberately inlined here (duplicated from
+# app.services.ai_execution_strategy / qa_ai_assistant) so that the daemon
+# works correctly when running as the CLI or desktop standalone daemon where
+# the `app` package is NOT on sys.path.  Any time the originals change,
+# keep these in sync.
+
+def _daemon_extract_copilot_output(raw: str) -> str:
+    """Extract assistant text from Copilot CLI JSONL output."""
+    final_answer_ids: set[str] = set()
+    final_message_parts: list[str] = []
+    final_delta_parts: list[str] = []
+    fallback_message_parts: list[str] = []
+    fallback_delta_parts: list[str] = []
+
+    for line in raw.split("\n"):
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            data = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if not isinstance(data, dict):
+            continue
+
+        event_type = str(data.get("type", ""))
+        msg_data = data.get("data") or data
+
+        if event_type == "assistant.message_start":
+            if msg_data.get("phase") == "final_answer":
+                message_id = msg_data.get("messageId")
+                if isinstance(message_id, str) and message_id:
+                    final_answer_ids.add(message_id)
+            continue
+
+        if event_type == "assistant.message":
+            content = msg_data.get("content", "")
+            if not isinstance(content, str) or not content.strip():
+                continue
+            message_id = msg_data.get("messageId")
+            if message_id in final_answer_ids or msg_data.get("phase") == "final_answer":
+                final_message_parts.append(content.strip())
+            else:
+                fallback_message_parts.append(content.strip())
+            continue
+
+        if event_type == "assistant.message_delta":
+            delta = msg_data.get("deltaContent", "")
+            if not isinstance(delta, str) or not delta:
+                continue
+            message_id = msg_data.get("messageId")
+            if message_id in final_answer_ids:
+                final_delta_parts.append(delta)
+            else:
+                fallback_delta_parts.append(delta)
+
+    if final_delta_parts:
+        return "".join(final_delta_parts).strip()
+    if final_message_parts:
+        return "\n\n".join(final_message_parts).strip()
+    if fallback_message_parts:
+        return "\n\n".join(fallback_message_parts).strip()
+    if fallback_delta_parts:
+        return "".join(fallback_delta_parts).strip()
+    return raw
+
+
+def _daemon_extract_claude_output(raw: str) -> str:
+    """Extract result text from Claude CLI JSON/stream-json output."""
+    raw = raw.strip()
+    try:
+        data = json.loads(raw)
+        if isinstance(data, dict):
+            if "result" in data:
+                return data["result"]
+            if "content" in data:
+                blocks = data["content"]
+                if isinstance(blocks, list):
+                    texts = [b.get("text", "") for b in blocks if b.get("type") == "text"]
+                    return "\n".join(texts)
+        elif isinstance(data, list):
+            texts = [item.get("text", "") for item in data if isinstance(item, dict) and item.get("type") == "text"]
+            if texts:
+                return "\n".join(texts)
+    except (json.JSONDecodeError, KeyError, TypeError):
+        pass
+
+    lines = raw.split("\n")
+    for line in reversed(lines):
+        line = line.strip()
+        if not line.startswith("{"):
+            continue
+        try:
+            data = json.loads(line)
+            if isinstance(data, dict) and "result" in data:
+                result_val = data["result"]
+                if isinstance(result_val, str) and result_val.strip():
+                    return result_val
+        except (json.JSONDecodeError, KeyError, TypeError):
+            continue
+
+    parts: list[str] = []
+    for line in lines:
+        line = line.strip()
+        if not line.startswith("{"):
+            continue
+        try:
+            data = json.loads(line)
+            if not isinstance(data, dict):
+                continue
+            ev_type = data.get("type", "")
+            if ev_type == "assistant":
+                msg = data.get("message") or {}
+                for block in msg.get("content", []):
+                    if isinstance(block, dict) and block.get("type") == "text":
+                        text = block.get("text", "")
+                        if isinstance(text, str) and text.strip():
+                            parts.append(text)
+        except (json.JSONDecodeError, KeyError, TypeError):
+            continue
+    if parts:
+        return "\n\n".join(parts)
+
+    brace_start = raw.rfind('{"type":"result"')
+    if brace_start == -1:
+        brace_start = raw.rfind('{"type": "result"')
+    if brace_start >= 0:
+        depth = 0
+        for i in range(brace_start, len(raw)):
+            if raw[i] == "{":
+                depth += 1
+            elif raw[i] == "}":
+                depth -= 1
+                if depth == 0:
+                    try:
+                        data = json.loads(raw[brace_start : i + 1])
+                        if isinstance(data, dict) and "result" in data:
+                            return data["result"]
+                    except (json.JSONDecodeError, KeyError, TypeError):
+                        pass
+                    break
+    return raw
+
+
+def _daemon_extract_opencode_output(raw: str) -> str:
+    """Extract text content from OpenCode JSONL output."""
+    parts: list[str] = []
+    for line in raw.split("\n"):
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            data = json.loads(line)
+        except json.JSONDecodeError:
+            if line:
+                parts.append(line)
+            continue
+        if not isinstance(data, dict):
+            continue
+        ev_type = str(data.get("type", ""))
+        part = data.get("part") or {}
+        if ev_type == "text" and isinstance(part, dict):
+            text = part.get("text", "")
+            if isinstance(text, str) and text.strip():
+                parts.append(text)
+    return "\n".join(parts) if parts else raw
+
+
+def _daemon_extract_agent_output(agent_id: str, raw: str) -> str:
+    """Dispatch to per-agent extraction; falls back to raw for unknown agents."""
+    if agent_id == "claude":
+        return _daemon_extract_claude_output(raw)
+    if agent_id == "copilot":
+        return _daemon_extract_copilot_output(raw)
+    if agent_id == "opencode":
+        return _daemon_extract_opencode_output(raw)
+    return raw
+
+
+def _daemon_extract_json(text: str):
+    """Extract a JSON array or object from text (no external imports)."""
+    text = text.strip()
+    if text.startswith("```"):
+        text = text.split("\n", 1)[-1].rsplit("```", 1)[0].strip()
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        pass
+    for start_char, end_char in [("[", "]"), ("{", "}")]:
+        start = text.find(start_char)
+        end = text.rfind(end_char)
+        if start != -1 and end > start:
+            try:
+                return json.loads(text[start : end + 1])
+            except json.JSONDecodeError:
+                continue
+    return None
+
+# ─────────────────────────────────────────────────────────────────────────────
+
+
 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."""
+    """Extract agent-specific final text before truncating for transport.
+
+    Uses self-contained helpers (_daemon_extract_*) so this function works
+    both inside the backend server (where ``app.*`` is importable) and in the
+    standalone CLI / desktop daemon (where it is not).
+    """
     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)
+    extracted_output = _daemon_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)
+    parsed = _daemon_extract_json(extracted_output)
     if isinstance(parsed, list):
         return json.dumps(parsed), parsed
     if isinstance(parsed, dict):

{forgexa_cli-1.13.3 → forgexa_cli-1.13.4}/forgexa_cli.egg-info/PKG-INFO

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

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