forgexa-cli 1.85.3__tar.gz → 1.86.0__tar.gz

{forgexa_cli-1.85.3 → forgexa_cli-1.86.0}/PKG-INFO

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

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

{forgexa_cli-1.85.3 → forgexa_cli-1.86.0}/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.85.3"
+DAEMON_VERSION = "1.86.0"
 
 
 def _detect_client_type() -> str:
@@ -1663,6 +1663,8 @@ _RUNTIME_CRITIC_TIMEOUT_SECONDS = 300
 _RUNTIME_CRITIC_DIFF_MAX_CHARS = 30_000
 _RUNTIME_CRITIC_OUTPUT_MAX_CHARS = 20_000
 _RUNTIME_CRITIC_SOURCE_MAX_BYTES = 1_000_000
+_RUNTIME_CRITIC_SOURCE_MAX_FILES = 128
+_RUNTIME_CRITIC_SOURCE_TIMEOUT_SECONDS = 200
 _RUNTIME_CRITIC_SYSTEM_PROMPT = """You are the Critic Agent for a software delivery gate.
 Review only the supplied task context, code diff and committed source snapshots. You are running in an
 isolated review capsule, not the project workspace. Do not write or modify files,
@@ -3075,9 +3077,25 @@ def _runtime_critic_reference_candidates(
             php_context and all(re.fullmatch(r"[A-Z][A-Za-z0-9]*[A-Z][A-Za-z0-9]*", part) for part in Path(candidate).parts)
         ):
             directories.add(candidate)
+    alias_roots = {}
+    for path in [*source_paths, *explicit]:
+        parts = Path(path).parts
+        if safe_path(path) and len(parts) > 4 and parts[:2] == ("app", "code"):
+            alias_roots.setdefault(parts[2], set()).add("app/code")
+        elif safe_path(path) and len(parts) > 2 and parts[0] == "vendor":
+            alias_roots.setdefault(parts[1], set()).add("vendor")
+    for reference in tuple(explicit):
+        roots = alias_roots.get(Path(reference).parts[0], set())
+        if len(roots) == 1:
+            rooted = safe_path(next(iter(roots)) + "/" + reference)
+            if rooted is not None and (inventory is None or rooted in inventory):
+                explicit.add(rooted)
+                directories.add(Path(rooted).parent.as_posix())
+    php_context = php_context or any(Path(path).suffix.lower() == ".php" for path in explicit)
     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,
     ))
+    names.update(re.findall(r"(?<![\w./\\:-])(composer\.lock)\b", text))
     if php_context:
         names.update(name + ".php" for name in re.findall(
             r"(?<![\w./\\:-])([A-Z][A-Za-z0-9_]*)::[A-Za-z_][A-Za-z0-9_]*\b", text,
@@ -3087,14 +3105,30 @@ def _runtime_critic_reference_candidates(
             r"(?<![\w.\\:-])(?=[A-Za-z0-9]*[a-z])([A-Z][A-Za-z0-9]*[A-Z][A-Za-z0-9]*)(?![\w.\\:-])", bare_text,
         ))
     module_roots = sorted({
-        "/".join(Path(path).parts[:4]) for path in source_paths
+        "/".join(Path(path).parts[:4]) for path in [*source_paths, *explicit]
         if safe_path(path) and len(Path(path).parts) > 4 and Path(path).parts[:2] == ("app", "code")
         and Path(path).suffix.lower() == ".php"
     })[:5]
     known_names = {Path(path).name for path in [*source_paths, *explicit]}
-    candidates = set(explicit)
-    for name in sorted(names - known_names)[:20]:
-        if inventory is not None and module_roots and name.endswith(".php"):
+    root_files = names & {"composer.lock", "AGENTS.md"}
+    candidates = set(explicit) | root_files
+    if any(name.endswith("Factory.php") for name in names | known_names):
+        configurations = {f"{root}/etc/di.xml" for root in module_roots}
+        if inventory is not None:
+            configurations.intersection_update(inventory)
+        if inventory is None or len(configurations) == 1:
+            candidates.update(configurations)
+    for reference in explicit:
+        if Path(reference).suffix.lower() != ".xml" or reference.startswith(("app/code/", "vendor/")):
+            continue
+        module_references = {f"{root}/{reference}" for root in module_roots}
+        if inventory is not None:
+            module_references.intersection_update(inventory)
+            if len(module_references) != 1:
+                continue
+        candidates.update(module_references)
+    for name in sorted(names - known_names - root_files)[:20]:
+        if inventory is not None and module_roots and Path(name).suffix.lower() in {".php", ".xml"}:
             matches = [path for path in inventory if Path(path).name == name
                        and any(path.startswith(root + "/") for root in module_roots)]
             if len(matches) == 1 and (path := safe_path(matches[0])) is not None:
@@ -3102,9 +3136,14 @@ def _runtime_critic_reference_candidates(
             continue
         candidates.update(path for directory in sorted(directories)[:5]
                           if (path := safe_path(f"{directory}/{name}")) is not None)
-        if name.endswith(".php"):
+        if Path(name).suffix.lower() in {".php", ".xml"}:
             candidates.update(f"{root}/{name}" for root in module_roots)
-    return sorted(candidates - set(source_paths))[:128]
+    primary = (explicit | root_files) - set(source_paths)
+    ordered = sorted(primary, key=lambda path: (
+        path not in root_files, inventory is None or path not in inventory,
+        not path.startswith(("app/code/", "vendor/", "setup/", "build/", "config/")), path,
+    ))
+    return (ordered + sorted(candidates - primary - set(source_paths)))[:128]
 
 
 def _try_acquire_local_workspace_file_lock(binding_id: str, workspace_path: Path | None = None):
@@ -4008,8 +4047,15 @@ class WorkspaceManager:
 
         if remote_branch.strip():
             try:
+                # The tracking ref is a cache of remote state and the remote is
+                # authoritative (its existence and tip were just confirmed via
+                # ls-remote). Update it even when the remote was rewritten: a
+                # fresh-analysis reset legitimately force-pushes this branch,
+                # and a non-forced refspec is rejected non-fast-forward against
+                # the stale tracking ref forever — the same cache-alignment
+                # rule every other fetch in this file already follows.
                 await self._git(
-                    "fetch", "origin", f"{target_branch}:refs/remotes/origin/{target_branch}",
+                    "fetch", "origin", f"+{target_branch}:refs/remotes/origin/{target_branch}",
                     cwd=local_path,
                 )
             except RuntimeError as exc:
@@ -4021,6 +4067,19 @@ class WorkspaceManager:
                 "rev-list", f"origin/{target_branch}..HEAD", "--count", cwd=local_path,
             )
             if ahead_output.strip() not in ("", "0"):
+                behind_output = await self._git(
+                    "rev-list", f"HEAD..origin/{target_branch}", "--count", cwd=local_path,
+                )
+                if behind_output.strip() not in ("", "0"):
+                    raise RuntimeError(
+                        f"local_binding_unavailable: local branch '{target_branch}' diverged "
+                        f"from origin/{target_branch} (ahead {ahead_output.strip()}, behind "
+                        f"{behind_output.strip()}); the remote branch was rewritten — for "
+                        "example by a fresh-analysis reset, whose retired tips are preserved "
+                        "under 'forgexa/fresh-analysis-backup/*' tags. Align your local branch "
+                        f"(git reset --hard origin/{target_branch}) after keeping anything you "
+                        "need, then retry."
+                    )
                 raise RuntimeError(
                     f"local_binding_unavailable: local branch '{target_branch}' has "
                     f"{ahead_output.strip()} unpushed commit(s) ahead of origin — push them "
@@ -4058,7 +4117,7 @@ class WorkspaceManager:
 
             try:
                 await self._git(
-                    "fetch", "origin", f"{default_branch}:refs/remotes/origin/{default_branch}",
+                    "fetch", "origin", f"+{default_branch}:refs/remotes/origin/{default_branch}",
                     cwd=local_path,
                 )
                 local_head = (await self._git("rev-parse", "HEAD", cwd=local_path)).strip()
@@ -5677,7 +5736,7 @@ class WorkspaceManager:
         try:
             await self._git(
                 "fetch", "origin",
-                f"{default_branch}:refs/remotes/origin/{default_branch}",
+                f"+{default_branch}:refs/remotes/origin/{default_branch}",
                 cwd=main_repo,
                 timeout=settings.GIT_FETCH_TIMEOUT,
                 project_key=project_key,
@@ -14021,6 +14080,11 @@ class RuntimeDaemon:
             paths = agent_core.missing_planned_task_files({
                 "files": planned.get("files") or [], "items": planned.get("items") or [],
             }, [])
+            source_file_limit = (
+                _RUNTIME_CRITIC_SOURCE_MAX_FILES if planned.get("type") == "design"
+                else min(_RUNTIME_CRITIC_SOURCE_MAX_FILES, max(20, len(set(paths + changed_files))))
+            )
+            source_deadline = time.monotonic() + _RUNTIME_CRITIC_SOURCE_TIMEOUT_SECONDS if source_file_limit > 20 else None
             assigned_paths = list(paths)
             primary_paths = list(paths)
             if planned.get("type") in ("testing", "review") and getattr(task, "requirement_key", ""):
@@ -14109,17 +14173,52 @@ class RuntimeDaemon:
                     "items": related.get("items") or [],
                 }, []))
             reference_baseline = {**baseline, "related_tasks": reference_tasks}
+            document_sources = {}
+            requirement_key = str(getattr(task, "requirement_key", "") or "")
+            if source_deadline is not None and requirement_key:
+                document_paths = [path for path in dict.fromkeys([*assigned_paths, *changed_files])
+                                  if path.startswith(f"docs/requirements/{requirement_key}/implement/")
+                                  and path.endswith(".md") and ".." not in Path(path).parts
+                                  and re.fullmatch(r"[A-Za-z0-9_./-]+", path) and not _is_sensitive_local_path(path)][:8]
+                document_bytes = 0
+                for path in document_paths:
+                    seconds_left = source_deadline - time.monotonic()
+                    if seconds_left <= 0:
+                        coverage["source_collection_timed_out"] = True
+                        coverage["design_reference_documents_unavailable"] = True
+                        break
+                    try:
+                        source = await self.workspace_manager._git(
+                            "show", f"{after_sha}:{path}", cwd=workspace_path, timeout=min(10, max(1, int(seconds_left))),
+                        )
+                        encoded_size = len(source.encode("utf-8"))
+                        if document_bytes + encoded_size > _RUNTIME_CRITIC_SOURCE_MAX_BYTES:
+                            coverage["design_reference_documents_unavailable"] = True
+                            continue
+                        document_sources[path] = source
+                        document_bytes += encoded_size
+                    except Exception:
+                        coverage["design_reference_documents_unavailable"] = True
+                reference_baseline = {**reference_baseline, "task": {
+                    **planned, "description": str(planned.get("description") or "") + "\n" + "\n".join(document_sources.values()),
+                }}
             reference_candidates = _runtime_critic_reference_candidates(reference_baseline, primary_paths)
             if reference_candidates:
                 try:
                     reference_modules = sorted({
                         Path(path).parent.as_posix() for path in reference_candidates
                         if len(Path(path).parts) == 5 and Path(path).parts[:2] == ("app", "code")
-                        and Path(path).suffix.lower() == ".php"
+                        and Path(path).suffix.lower() in {".php", ".xml"}
                     })[:5]
+                    inventory_timeout = 10
+                    if source_deadline is not None:
+                        seconds_left = source_deadline - time.monotonic()
+                        if seconds_left <= 0:
+                            raise TimeoutError("Source collection deadline reached")
+                        inventory_timeout = min(10, max(1, int(seconds_left)))
                     inventory = await self.workspace_manager._git(
                         "ls-tree", "-r", "--name-only", after_sha, "--", *reference_candidates, *reference_modules,
-                        cwd=workspace_path, timeout=10,
+                        cwd=workspace_path, timeout=inventory_timeout,
                     )
                     if len(inventory.encode("utf-8")) > _RUNTIME_CRITIC_SOURCE_MAX_BYTES:
                         raise ValueError("Committed reference inventory exceeds its bounded evidence budget")
@@ -14134,15 +14233,24 @@ class RuntimeDaemon:
             coverage["candidate_files"] = len(paths)
             remaining = _RUNTIME_CRITIC_DIFF_MAX_CHARS - len(diff or "")
             source_context = []
-            for path in paths[:20]:
+            for path in paths[:source_file_limit]:
+                source_timeout = 10
+                if source_deadline is not None:
+                    seconds_left = source_deadline - time.monotonic()
+                    if seconds_left <= 0:
+                        coverage["source_collection_timed_out"] = True
+                        break
+                    source_timeout = min(10, max(1, int(seconds_left)))
                 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,
-                    )
+                    source = document_sources.get(path)
+                    if source is None:
+                        source = await self.workspace_manager._git(
+                            "show", f"{after_sha}:{path}", cwd=workspace_path, timeout=source_timeout,
+                        )
                 except Exception as error:
                     coverage["unreadable_files"] += 1
                     detail = str(error).lower()
@@ -14176,6 +14284,7 @@ class RuntimeDaemon:
         coverage["capsule_incomplete"] = (
             coverage["omitted_files"] > 0 or coverage.get("reference_inventory_unavailable", False)
             or coverage.get("verification_inventory_unavailable", False)
+            or coverage.get("design_reference_documents_unavailable", False)
         )
         result.metrics["runtime_critic_coverage"] = coverage
         if not diff:

{forgexa_cli-1.85.3 → forgexa_cli-1.86.0}/forgexa_cli.egg-info/PKG-INFO

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

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