forgexa-cli 1.84.1__tar.gz → 1.84.2__tar.gz

{forgexa_cli-1.84.1 → forgexa_cli-1.84.2}/PKG-INFO

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

{forgexa_cli-1.84.1 → forgexa_cli-1.84.2}/forgexa_cli/__init__.py

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

{forgexa_cli-1.84.1 → forgexa_cli-1.84.2}/forgexa_cli/daemon.py

@@ -1234,7 +1234,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.84.1"
+DAEMON_VERSION = "1.84.2"
 
 
 def _detect_client_type() -> str:
@@ -3018,6 +3018,52 @@ def _is_sensitive_local_path(path: str) -> bool:
     return any(pattern.search(normalized) for pattern in _LOCAL_BIND_SENSITIVE_PATH_PATTERNS)
 
 
+def _runtime_critic_reference_candidates(baseline: dict, source_paths: list[str]) -> list[str]:
+    planned = baseline.get("task") or {}
+    texts = [str(planned.get("description") or "")]
+    texts.extend(str(item.get("description") or "") for item in planned.get("items") or [] if isinstance(item, dict))
+    if planned.get("type") == "design":
+        texts.append(json.dumps({"analysis": baseline.get("approved_analysis"),
+                                 "documents": baseline.get("analysis_documents")}, ensure_ascii=True)[:200_000])
+    text = re.sub(r"https?://\S+", " ", "\n".join(texts))
+    suffixes = {".php", ".py", ".ts", ".tsx", ".js", ".jsx", ".xml", ".json", ".md", ".yml", ".yaml", ".toml", ".html", ".phtml"}
+
+    def safe_path(value: str) -> str | None:
+        path = Path(value)
+        if path.is_absolute() or ".." in path.parts or not path.parts:
+            return None
+        normalized = path.as_posix().rstrip(".")
+        path = Path(normalized)
+        if normalized.startswith("docs/requirements/") or _is_sensitive_local_path(normalized):
+            return None
+        if path.name.lower() in ("env.php", "auth.json", "credentials.json", "secrets.json", "service-account.json"):
+            return None
+        if any(part in (".git", ".forgexa", ".aws", ".ssh", ".env") or part.startswith(".env.") for part in path.parts):
+            return None
+        return normalized
+
+    directories = {Path(path).parent.as_posix() for path in source_paths if safe_path(path)} - {"."}
+    explicit = set()
+    for token in re.findall(r"(?<![\w./\\:-])[A-Za-z0-9_.-]+(?:/[A-Za-z0-9_.-]+)+", text):
+        candidate = safe_path(token)
+        if candidate is None:
+            continue
+        if Path(candidate).suffix.lower() in suffixes:
+            explicit.add(candidate)
+            directories.add(Path(candidate).parent.as_posix())
+        elif not Path(candidate).suffix:
+            directories.add(candidate)
+    names = set(re.findall(
+        r"(?<![\w./\\:-])([A-Za-z0-9_][A-Za-z0-9_.-]*\.(?:php|py|tsx?|jsx?|xml|json|md|ya?ml|toml|html|phtml))\b", text,
+    ))
+    known_names = {Path(path).name for path in [*source_paths, *explicit]}
+    candidates = set(explicit)
+    for name in sorted(names - known_names)[:20]:
+        candidates.update(path for directory in sorted(directories)[:5]
+                          if (path := safe_path(f"{directory}/{name}")) is not None)
+    return sorted(candidates - set(source_paths))[:128]
+
+
 def _try_acquire_local_workspace_file_lock(binding_id: str, workspace_path: Path | None = None):
     """Non-blocking OS-level file lock keyed by binding_id.
 
@@ -13925,6 +13971,11 @@ class RuntimeDaemon:
         after_sha = str((result.git or {}).get("commit_sha") or before_sha or "").strip()
         committed_sources: dict[str, str] = {}
         source_bytes = 0
+        coverage = {
+            "candidate_files": 0, "full_source_files": 0, "unreadable_files": 0,
+            "skipped_paths": 0, "omitted_files": 0, "prompt_excerpt_truncated": False,
+            "capsule_incomplete": False,
+        }
         diff = await self._collect_runtime_critic_diff(
             workspace_path,
             before_sha=(baseline.get("source_base_sha") if isinstance(baseline, dict)
@@ -13937,6 +13988,7 @@ class RuntimeDaemon:
             paths = agent_core.missing_planned_task_files({
                 "files": planned.get("files") or [], "items": planned.get("items") or [],
             }, [])
+            primary_paths = list(paths)
             if planned.get("type") in ("testing", "review") and getattr(task, "requirement_key", ""):
                 output_dir = str((task.input_data or {}).get("output_dir") or "").replace("\\", "/").rstrip("/")
                 artifact_paths = WorkspaceManager._local_requirement_artifact_paths(task, workspace_path)
@@ -13963,6 +14015,21 @@ class RuntimeDaemon:
             if isinstance(audit_contract, dict) and baseline.get("plan_id") is not None and audit_contract.get("plan_id") == baseline["plan_id"]:
                 approved_tasks = {entry["id"]: entry for entry in audit_contract.get("tasks") or [] if isinstance(entry, dict) and isinstance(entry.get("id"), str)}
                 pending = list(planned.get("depends_on") or [])
+                if (
+                    planned.get("type") == "design" and (task.input_data or {}).get("requirement_type") == "bugfix"
+                    and audit_contract.get("subject_task_id") == planned.get("id")
+                ):
+                    diagnosis_dependents = {planned["id"]}
+                    while True:
+                        expanded = diagnosis_dependents | {
+                            task_id for task_id, entry in approved_tasks.items()
+                            if any(dependency in diagnosis_dependents for dependency in entry.get("depends_on") or [])
+                        }
+                        if expanded == diagnosis_dependents:
+                            break
+                        diagnosis_dependents = expanded
+                    pending.extend(task_id for task_id in diagnosis_dependents
+                                   if task_id in approved_tasks and approved_tasks[task_id].get("type") == "coding")
                 visited = set()
                 while pending:
                     dependency_id = pending.pop()
@@ -13971,29 +14038,45 @@ class RuntimeDaemon:
                     visited.add(dependency_id)
                     dependency = approved_tasks.get(dependency_id)
                     if dependency is not None:
-                        paths.extend(agent_core.missing_planned_task_files({
+                        dependency_paths = agent_core.missing_planned_task_files({
                             "files": (dependency.get("input") or {}).get("files") or [],
                             "items": dependency.get("items") or [],
-                        }, []))
+                        }, [])
+                        paths.extend(dependency_paths)
+                        primary_paths.extend(dependency_paths)
                         pending.extend(dependency.get("depends_on") or [])
             for related in baseline.get("related_tasks") or []:
                 paths.extend(agent_core.missing_planned_task_files({
                     "files": (related.get("input") or {}).get("files") or [],
                     "items": related.get("items") or [],
                 }, []))
+            reference_candidates = _runtime_critic_reference_candidates(baseline, primary_paths)
+            if reference_candidates:
+                try:
+                    inventory = await self.workspace_manager._git(
+                        "ls-tree", "-r", "--name-only", after_sha, "--", *reference_candidates,
+                        cwd=workspace_path, timeout=10,
+                    )
+                    confirmed = [path for path in inventory.splitlines() if path in reference_candidates]
+                    paths = [*primary_paths, *confirmed, *paths]
+                except Exception:
+                    coverage["reference_inventory_unavailable"] = True
             paths.extend(changed_files)
             paths = list(dict.fromkeys(paths))
+            coverage["candidate_files"] = len(paths)
             remaining = _RUNTIME_CRITIC_DIFF_MAX_CHARS - len(diff or "")
             source_context = []
             for path in paths[:20]:
                 normalized = Path(path)
                 if normalized.is_absolute() or ".." in normalized.parts or path.endswith("/"):
+                    coverage["skipped_paths"] += 1
                     continue
                 try:
                     source = await self.workspace_manager._git(
                         "show", f"{after_sha}:{path}", cwd=workspace_path, timeout=10,
                     )
                 except Exception:
+                    coverage["unreadable_files"] += 1
                     continue
                 encoded_size = len(source.encode("utf-8"))
                 if source_bytes + encoded_size <= _RUNTIME_CRITIC_SOURCE_MAX_BYTES:
@@ -14002,12 +14085,17 @@ class RuntimeDaemon:
                 excerpt = source[:min(max(remaining, 0), 16000)]
                 source_context.append(f"\n## Committed source {after_sha}:{path}\n{excerpt}")
                 if len(excerpt) < len(source):
+                    coverage["prompt_excerpt_truncated"] = True
                     source_context.append("\nSource truncated; do not infer omitted obligations as conformant.")
                 remaining -= len(excerpt)
                 if path not in changed_files:
                     changed_files.append(path)
             if source_context:
                 diff = (diff or "No new changes; review committed delivery instead.") + "".join(source_context)
+        coverage["full_source_files"] = len(committed_sources)
+        coverage["omitted_files"] = coverage["candidate_files"] - coverage["full_source_files"]
+        coverage["capsule_incomplete"] = coverage["omitted_files"] > 0
+        result.metrics["runtime_critic_coverage"] = coverage
         if not diff:
             return {
                 "collection_status": "unavailable",
@@ -14033,6 +14121,12 @@ class RuntimeDaemon:
             project={},
             work_item={},
         )
+        review_task.input_prompt += "\n## Review Evidence Coverage\n" + json.dumps(coverage, sort_keys=True)
+        if coverage["capsule_incomplete"]:
+            review_task.input_prompt += (
+                "\nSome candidate files were not available as complete source. Assess the evidence you can inspect; "
+                "keep unresolved responsibilities unverified rather than inferring omitted source is conformant."
+            )
         if committed_sources:
             review_task.input_prompt += (
                 "\n## Read-Only Committed Source Capsule\n"

{forgexa_cli-1.84.1 → forgexa_cli-1.84.2}/forgexa_cli.egg-info/PKG-INFO

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

{forgexa_cli-1.84.1 → forgexa_cli-1.84.2}/pyproject.toml

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