@hunyed15/codecgc 0.1.7 → 0.1.9

package/scripts/audit_codecgc_package_runtime.py

@@ -13,14 +13,21 @@ PACKAGE_JSON_PATH = WORKSPACE / "package.json"
 
 RUNTIME_ENTRYPOINTS = [
     "bin/codecgc.js",
+    "bin/cgc-start.js",
+    "codecgcmcp/src/codecgcmcp/cli.py",
     "scripts/install_codecgc.py",
     "scripts/codecgc_cli.py",
+    "scripts/codecgc_policy.py",
 ]
 
 RUNTIME_STATIC_REQUIREMENTS = [
     ".claude/hooks/route-edit.ps1",
+    "codecgc/templates/claude/settings.local.json",
+    "codecgc/templates/codex/codecgcrc.json",
+    "codecgc/templates/gemini/codecgc-policy.toml",
     "model-routing.yaml",
     "requirements.txt",
+    "scripts/codecgc_runtime/__init__.py",
     "scripts/audit_codecgc_external_capabilities.py",
     "scripts/audit_codecgc_lifecycle.py",
     "codexmcp/pyproject.toml",
@@ -45,10 +52,25 @@ DOC_RUNTIME_PATHS = [
     "codecgc/cgc-onboard/SKILL.md",
     "codecgc/cgc-plan/SKILL.md",
     "codecgc/cgc-review/SKILL.md",
+    "codecgc/compound/codecgc-capability-matrix.md",
+    "codecgc/reference/README.md",
     "codecgc/reference/external-capability-registry.json",
     "codecgc/reference/lifecycle-playbook.md",
+    "codecgc/reference/maintainer-guide.md",
+    "codecgc/reference/mcp-tool-surface.md",
     "codecgc/reference/operation-guide.md",
+    "codecgc/reference/path-contract.md",
+    "codecgc/reference/policy-routing.md",
+    "codecgc/reference/project-structure.md",
+    "codecgc/reference/quickstart.md",
+    "codecgc/reference/onboarding.md",
+    "codecgc/reference/recovery-loop.md",
+    "codecgc/reference/real-workflow-loop.md",
     "codecgc/reference/release-maintenance-playbook.md",
+    "codecgc/reference/troubleshooting.md",
+    "codecgc/roadmap/codecgc-release-maintenance/delivery-plan.md",
+    "codecgc/roadmap/codecgc-release-maintenance/overview.md",
+    "codecgc/roadmap/codecgc-release-maintenance/phases.md",
 ]
 
 PLACEHOLDER_METADATA_MARKERS = (
@@ -148,19 +170,64 @@ def path_matches_package_files(path_text: str, file_rules: list[str]) -> bool:
             continue
         if normalized == normalized_rule:
             return True
+        if (WORKSPACE / normalized_rule).is_dir() and normalized.startswith(f"{normalized_rule}/"):
+            return True
     return False
 
 
 def resolve_local_python_module(module_name: str) -> str:
     relative = normalize_path_text(module_name.replace(".", "/") + ".py")
-    script_candidate = f"scripts/{relative.split('/')[-1]}"
-    if (WORKSPACE / script_candidate).exists():
-        return script_candidate
+    package_candidates = [
+        f"{package}/src/{relative}"
+        for package in ("codecgcmcp", "codexmcp", "geminimcp")
+        if module_name == package or module_name.startswith(f"{package}.")
+    ]
+    candidates = [
+        *package_candidates,
+        f"scripts/{relative}",
+        f"scripts/{relative.split('/')[-1]}",
+        relative,
+    ]
+    for candidate in candidates:
+        if (WORKSPACE / candidate).exists():
+            return candidate
+    package_init = f"scripts/{normalize_path_text(module_name.replace('.', '/'))}/__init__.py"
+    if (WORKSPACE / package_init).exists():
+        return package_init
+    for package in ("codecgcmcp", "codexmcp", "geminimcp"):
+        if module_name == package or module_name.startswith(f"{package}."):
+            package_init = f"{package}/src/{normalize_path_text(module_name.replace('.', '/'))}/__init__.py"
+            if (WORKSPACE / package_init).exists():
+                return package_init
+    root_package_init = f"{normalize_path_text(module_name.replace('.', '/'))}/__init__.py"
+    if (WORKSPACE / root_package_init).exists():
+        return root_package_init
     if (WORKSPACE / relative).exists():
         return relative
     return ""
 
 
+def resolve_relative_python_module(current_path: str, level: int, module_name: str | None) -> str:
+    current = Path(normalize_path_text(current_path))
+    package_dir = current.parent
+    for _ in range(max(level - 1, 0)):
+        package_dir = package_dir.parent
+
+    if module_name:
+        candidate = package_dir / normalize_path_text(module_name.replace(".", "/") + ".py")
+        if (WORKSPACE / candidate).exists():
+            return normalize_path_text(str(candidate))
+
+        package_init = package_dir / normalize_path_text(module_name.replace(".", "/")) / "__init__.py"
+        if (WORKSPACE / package_init).exists():
+            return normalize_path_text(str(package_init))
+
+    init_candidate = package_dir / "__init__.py"
+    if (WORKSPACE / init_candidate).exists():
+        return normalize_path_text(str(init_candidate))
+    return ""
+
+
 def parse_local_python_dependencies(relative_path: str) -> tuple[list[str], list[str]]:
     path = WORKSPACE / relative_path
     tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
@@ -174,7 +241,12 @@ def parse_local_python_dependencies(relative_path: str) -> tuple[list[str], list
                 if resolved:
                     imports.append(resolved)
         elif isinstance(node, ast.ImportFrom):
-            if node.level != 0 or not node.module:
+            if node.level != 0:
+                resolved_relative = resolve_relative_python_module(relative_path, node.level, node.module)
+                if resolved_relative:
+                    imports.append(resolved_relative)
+                continue
+            if not node.module:
                 continue
             resolved = resolve_local_python_module(node.module)
             if resolved:

package/scripts/audit_codecgc_release_readiness.py

@@ -1,5 +1,7 @@
 import argparse
 import json
+import os
+import tempfile
 from pathlib import Path
 from typing import Any
 
@@ -8,14 +10,25 @@ from audit_codecgc_package_runtime import audit_package_runtime
 from codecgc_console_io import render_summary_block
 from install_codecgc import collect_doctor_status
 from install_codecgc import collect_install_status
+from install_codecgc import install_local_runtime
 
 WORKSPACE = Path(__file__).resolve().parents[1]
+RELEASE_PROBE_ROOT_ENV = "CODECGC_RELEASE_PROBE_ROOT"
 
 LIFECYCLE_REQUIRED_PATHS = [
+    "codecgc/reference/README.md",
     "codecgc/reference/lifecycle-map.md",
     "codecgc/reference/lifecycle-playbook.md",
+    "codecgc/reference/maintainer-guide.md",
+    "codecgc/reference/mcp-tool-surface.md",
     "codecgc/reference/operation-guide.md",
+    "codecgc/reference/onboarding.md",
+    "codecgc/reference/path-contract.md",
+    "codecgc/reference/quickstart.md",
+    "codecgc/reference/recovery-loop.md",
+    "codecgc/reference/real-workflow-loop.md",
     "codecgc/reference/release-maintenance-playbook.md",
+    "codecgc/reference/troubleshooting.md",
     "codecgc/reference/external-capability-registry.json",
     "codecgc/compound/codecgc-capability-matrix.md",
 ]
@@ -83,9 +96,44 @@ def collect_deploy_signals() -> dict[str, Any]:
     }
 
 
+def collect_install_probe(workspace_override: str = "") -> dict[str, Any]:
+    if str(workspace_override or "").strip():
+        install_status = collect_install_status(workspace_override)
+        doctor_status = collect_doctor_status(workspace_override)
+        return {
+            "mode": "target-workspace",
+            "workspace": str(install_status.get("workspace", "")),
+            "install_result": {},
+            "install_status": install_status,
+            "doctor_status": doctor_status,
+        }
+
+    probe_root_value = os.environ.get(RELEASE_PROBE_ROOT_ENV, "").strip()
+    probe_root = Path(probe_root_value).expanduser().resolve() if probe_root_value else None
+    if probe_root is not None:
+        probe_root.mkdir(parents=True, exist_ok=True)
+
+    with tempfile.TemporaryDirectory(
+        prefix="codecgc-release-check-",
+        dir=str(probe_root) if probe_root is not None else None,
+        ignore_cleanup_errors=True,
+    ) as temp_dir:
+        install_result = install_local_runtime(temp_dir)
+        install_status = collect_install_status(temp_dir)
+        doctor_status = collect_doctor_status(temp_dir)
+        return {
+            "mode": "temporary-project-install",
+            "workspace": temp_dir,
+            "install_result": install_result,
+            "install_status": install_status,
+            "doctor_status": doctor_status,
+        }
+
+
 def audit_release_readiness(workspace_override: str = "") -> dict[str, Any]:
-    install_status = collect_install_status(workspace_override)
-    doctor_status = collect_doctor_status(workspace_override)
+    install_probe = collect_install_probe(workspace_override)
+    install_status = install_probe["install_status"]
+    doctor_status = install_probe["doctor_status"]
     package_audit = audit_package_runtime()
     external_audit = audit_external_capabilities(workspace_override)
     lifecycle_docs = audit_document_set(LIFECYCLE_REQUIRED_PATHS)
@@ -119,12 +167,14 @@ def audit_release_readiness(workspace_override: str = "") -> dict[str, Any]:
     return {
         "success": ready,
         "mode": "release-readiness-audit",
-        "workspace": str(install_status.get("workspace", "")),
+        "workspace": str(WORKSPACE),
         "summary": {
             "ready": ready,
             "scope": "release / maintenance / ops 就绪状态",
             "human_summary": human_summary,
             "recommended_next_action": recommended_next_action,
+            "install_probe_mode": install_probe["mode"],
+            "install_probe_workspace": install_probe["workspace"],
             "install_ready": install_ready,
             "doctor_ready": doctor_ready,
             "package_ready": package_ready,
@@ -134,6 +184,7 @@ def audit_release_readiness(workspace_override: str = "") -> dict[str, Any]:
             "deploy_signals_detected": deploy_signals["deploy_signals_detected"],
             "deploy_readiness_stage": deploy_signals["deploy_readiness_stage"],
         },
+        "install_probe": install_probe,
         "install_status": install_status,
         "doctor_status": doctor_status,
         "package_audit": package_audit,
@@ -152,6 +203,7 @@ def build_summary(result: dict[str, Any]) -> str:
     lines = [
         f"- 工作区: {result.get('workspace', '')}",
         f"- 范围: {summary.get('scope', '')}",
+        f"- 安装探针: {summary.get('install_probe_mode', '')} ({summary.get('install_probe_workspace', '')})",
         f"- 就绪: {'是' if summary.get('ready') else '否'}",
         f"- 摘要: {summary.get('human_summary', '')}",
         f"- 项目级集成: {'就绪' if summary.get('install_ready') else '未就绪'}",

package/scripts/audit_codecgc_workflow_history.py

@@ -9,6 +9,8 @@ from typing import Any
 from codecgc_artifact_roots import FIXTURE_ROOT
 from codecgc_artifact_roots import PRODUCT_ROOT
 from codecgc_console_io import render_summary_block
+from codecgc_path_contract import normalize_persisted_project_path
+from codecgc_path_contract import resolve_project_path
 from codecgc_runtime_paths import PROJECT_ROOT
 from route_codecgc_workflow import attach_route_summary
 from route_codecgc_workflow import route_feature
@@ -84,7 +86,7 @@ def locate_summary_file(flow: str, directory: Path) -> str:
     matches = sorted(directory.glob(f"*{suffix}"))
     if not matches:
         return ""
-    return str(matches[0].resolve())
+    return normalize_persisted_project_path(matches[0])
 
 
 def collect_history_record(flow: str, artifact_class: str, directory: Path) -> dict[str, Any]:
@@ -97,7 +99,8 @@ def collect_history_record(flow: str, artifact_class: str, directory: Path) -> d
     audit_path = str(route.get("audit_path", "")).strip()
     audit_timestamp = ""
     if audit_path:
-        audit_time = parse_iso_like_timestamp(Path(audit_path).stat().st_mtime_ns and datetime.fromtimestamp(Path(audit_path).stat().st_mtime).isoformat())
+        resolved_audit_path = resolve_project_path(audit_path)
+        audit_time = parse_iso_like_timestamp(resolved_audit_path.stat().st_mtime_ns and datetime.fromtimestamp(resolved_audit_path.stat().st_mtime).isoformat())
         if audit_time:
             audit_timestamp = audit_time.isoformat()
 
@@ -106,7 +109,7 @@ def collect_history_record(flow: str, artifact_class: str, directory: Path) -> d
         "artifact_class": artifact_class,
         "slug": slug,
         "created": extract_created_from_slug(slug),
-        "directory": str(directory.resolve()),
+        "directory": normalize_persisted_project_path(directory),
         "workflow_state": workflow_state,
         "state_label": STATE_LABELS.get(workflow_state, workflow_state or "未知"),
         "recommended_command": str(route.get("recommended_command", "")).strip(),
@@ -116,10 +119,10 @@ def collect_history_record(flow: str, artifact_class: str, directory: Path) -> d
         "current_task_id": str(summary.get("current_task_id", "")).strip(),
         "review_decision": str(summary.get("review_decision", "")).strip(),
         "is_closed": bool(summary.get("is_closed")),
-        "audit_path": audit_path,
+        "audit_path": normalize_persisted_project_path(audit_path) if audit_path else "",
         "audit_timestamp": audit_timestamp,
         "summary_file": locate_summary_file(flow, directory),
-        "root": str(artifact_root(artifact_class).resolve()),
+        "root": normalize_persisted_project_path(artifact_root(artifact_class)),
     }
     if current_step:
         record["current_step"] = {

package/scripts/build_codecgc_task.py

@@ -1,13 +1,17 @@
 import argparse
 import json
 import sys
-import yaml
-from fnmatch import fnmatch
 from pathlib import Path
 from typing import Any
 
+import yaml
+
 from codecgc_console_io import configure_utf8_stdio
 from codecgc_console_io import print_json
+from codecgc_path_contract import normalize_persisted_project_path
+from codecgc_policy import classify_path
+from codecgc_policy import load_policy
+from codecgc_policy import validate_executor_target
 from codecgc_routing_paths import resolve_active_routing_file
 from codecgc_runtime_paths import PACKAGE_ROOT
 from codecgc_runtime_paths import PROJECT_ROOT
@@ -26,19 +30,7 @@ def normalize_path_text(path_text: str) -> str:
 
 def load_simple_routing_config(path: Path) -> dict[str, Any]:
     """Load routing configuration YAML file using standard yaml library."""
-    if not path.exists():
-        raise FileNotFoundError(f"Routing file not found: {path}")
-
-    try:
-        with open(path, "r", encoding="utf-8") as f:
-            data = yaml.safe_load(f)
-
-        if not isinstance(data, dict):
-            raise ValueError(f"Routing config must be a dictionary, got {type(data).__name__}")
-
-        return data
-    except yaml.YAMLError as e:
-        raise ValueError(f"Failed to parse routing YAML file {path}: {e}") from e
+    return load_policy(path)
 
 
 def load_checklist_yaml(path: Path) -> dict[str, Any]:
@@ -61,9 +53,40 @@ def load_checklist_yaml(path: Path) -> dict[str, Any]:
 def normalize_string_list(value: Any) -> list[str]:
     if value is None:
         return []
+    if isinstance(value, str):
+        return [item.strip() for item in value.split(",") if item.strip()]
     if isinstance(value, list):
-        return [str(item) for item in value]
-    return [str(value)]
+        normalized: list[str] = []
+        for item in value:
+            if item is None:
+                continue
+            text = str(item).strip()
+            if text:
+                normalized.append(text)
+        return normalized
+    text = str(value).strip()
+    return [text] if text else []
+
+
+def is_executable_codecgc_block(block: Any) -> bool:
+    """Compatibility helper for older tests and scripts.
+
+    Runtime step selection uses codecgc_step_control.is_executable_codecgc_block,
+    which is intentionally stricter. This helper preserves the historical task
+    builder contract: explicit frontend/backend kind plus at least one target.
+    """
+    if not isinstance(block, dict):
+        return False
+
+    kind = str(block.get("kind", "")).strip().lower()
+    if not kind or kind == "auto":
+        return False
+
+    target_paths = block.get("target_paths", [])
+    if not isinstance(target_paths, list):
+        return False
+
+    return any(str(path).strip() for path in target_paths)
 
 
 def resolve_optional_value(cli_value: Any, spec_value: Any, default_value: Any) -> Any:
@@ -140,7 +163,7 @@ def load_checklist_step_payload(args: argparse.Namespace) -> dict[str, Any]:
         "constraint": constraints,
         "acceptance": acceptance,
         "cd": resolve_cd_value(str(resolve_optional_value(args.cd, step_spec.get("cd"), None))),
-        "routing_file": str(Path(str(args.routing_file)).resolve()),
+        "routing_file": normalize_persisted_project_path(args.routing_file),
         "session_id": str(resolve_optional_value(args.session_id, step_spec.get("session_id"), "")),
         "model": str(resolve_optional_value(args.model, step_spec.get("model"), "")),
         "profile": str(resolve_optional_value(args.profile, step_spec.get("profile"), "")),
@@ -160,7 +183,7 @@ def load_checklist_step_payload(args: argparse.Namespace) -> dict[str, Any]:
         "timeout_seconds": int(step_spec.get("timeout_seconds", 0)) or 0,
         "source": {
             "type": "workflow-step",
-            "artifact_file": str(checklist_path.resolve()),
+            "artifact_file": normalize_persisted_project_path(checklist_path),
             "artifact_type": artifact_type,
             "artifact_class": artifact_class,
             "artifact_slug": artifact_slug,
@@ -179,37 +202,18 @@ def load_explicit_task_payload(args: argparse.Namespace) -> dict[str, Any]:
         "constraint": args.constraint,
         "acceptance": args.acceptance,
         "cd": resolve_cd_value(args.cd),
-        "routing_file": str(Path(str(args.routing_file)).resolve()),
+        "routing_file": normalize_persisted_project_path(args.routing_file),
         "session_id": args.session_id or "",
         "model": args.model or "",
         "profile": args.profile or "",
         "codex_sandbox": args.codex_sandbox or "workspace-write",
         "gemini_sandbox": bool(args.gemini_sandbox),
         "return_all_messages": bool(args.return_all_messages),
+        "timeout_seconds": int(getattr(args, "timeout_seconds", 0) or 0),
         "source": None,
     }
 
 
-def classify_path(path_text: str, routing: dict[str, Any]) -> str:
-    normalized = normalize_path_text(path_text)
-
-    for pattern in routing.get("shared_paths", []):
-        if fnmatch(normalized, pattern):
-            return "shared"
-
-    frontend_patterns = list(routing.get("frontend_paths", [])) + list(routing.get("custom_frontend_paths", []))
-    for pattern in frontend_patterns:
-        if fnmatch(normalized, pattern):
-            return "frontend"
-
-    backend_patterns = list(routing.get("backend_paths", [])) + list(routing.get("custom_backend_paths", []))
-    for pattern in backend_patterns:
-        if fnmatch(normalized, pattern):
-            return "backend"
-
-    return "unknown"
-
-
 def classify_paths(paths: list[str], routing: dict[str, Any]) -> dict[str, str]:
     return {path: classify_path(path, routing) for path in paths}
 
@@ -218,6 +222,10 @@ def split_paths_by_category(classifications: dict[str, str]) -> dict[str, list[s
     grouped = {
         "frontend": [],
         "backend": [],
+        "frontend-test": [],
+        "backend-test": [],
+        "docs": [],
+        "orchestration": [],
         "shared": [],
         "unknown": [],
     }
@@ -275,13 +283,15 @@ def detect_target_kind(paths: list[str], routing: dict[str, Any]) -> tuple[str,
     classifications = classify_paths(paths, routing)
     categories = set(classifications.values())
 
-    if "shared" in categories:
+    if categories & {"shared", "docs", "orchestration"}:
         details = [
-            f"{path} -> shared" for path, category in classifications.items() if category == "shared"
+            f"{path} -> {category}"
+            for path, category in classifications.items()
+            if category in {"shared", "docs", "orchestration"}
         ]
         split_payload = build_split_required_payload(paths, routing)
         raise ValueError(
-            "Detected shared paths. Split the task first.\n"
+            "Detected non-executor-owned paths. Route them through Claude workflow first.\n"
             + "\n".join(details)
             + "\nSPLIT_PAYLOAD: "
             + json.dumps(split_payload, ensure_ascii=False)
@@ -295,10 +305,10 @@ def detect_target_kind(paths: list[str], routing: dict[str, Any]) -> tuple[str,
             "Some target paths are not covered by model-routing.yaml.\n" + "\n".join(details)
         )
 
-    if categories == {"frontend"}:
+    if categories <= {"frontend", "frontend-test"}:
         return "frontend", [f"{path} -> frontend" for path in paths]
 
-    if categories == {"backend"}:
+    if categories <= {"backend", "backend-test"}:
         return "backend", [f"{path} -> backend" for path in paths]
 
     details = [f"{path} -> {classifications[path]}" for path in paths]
@@ -329,6 +339,17 @@ def build_tool_call(args: argparse.Namespace, routing: dict[str, Any]) -> dict[s
         kind = requested_kind
         route_notes = [f"{path} -> forced:{kind}" for path in target_paths]
 
+    policy_result = validate_executor_target(kind, target_paths, routing)
+    if not policy_result.get("allowed"):
+        raise ValueError(
+            "Target paths violate CodeCGC routing policy.\n"
+            + json.dumps(policy_result, ensure_ascii=False)
+        )
+
+    effective_timeout_seconds = int(payload_inputs.get("timeout_seconds", 0)) or int(
+        getattr(args, "timeout_seconds", 0) or 0
+    )
+
     if kind == "frontend":
         tool_name = "implement_frontend_task"
         tool_args: dict[str, Any] = {
@@ -342,6 +363,7 @@ def build_tool_call(args: argparse.Namespace, routing: dict[str, Any]) -> dict[s
             "sandbox": payload_inputs["gemini_sandbox"],
             "return_all_messages": payload_inputs["return_all_messages"],
             "model": payload_inputs["model"],
+            "timeout_seconds": effective_timeout_seconds,
         }
     elif kind == "backend":
         tool_name = "implement_backend_task"
@@ -366,7 +388,9 @@ def build_tool_call(args: argparse.Namespace, routing: dict[str, Any]) -> dict[s
         "target": kind,
         "tool_name": tool_name,
         "tool_args": tool_args,
+        "timeout_seconds": effective_timeout_seconds,
         "route_notes": route_notes,
+        "policy": policy_result,
         "routing_file": payload_inputs["routing_file"],
     }
     if payload_inputs["source"] is not None:

package/scripts/codecgc_artifact_roots.py

@@ -1,40 +1,8 @@
-from __future__ import annotations
-
-from codecgc_runtime_paths import PROJECT_ROOT
-
-
-CODECGC_ROOT = PROJECT_ROOT / "codecgc"
-PRODUCT_ROOT = CODECGC_ROOT
-FIXTURE_ROOT = CODECGC_ROOT / "fixtures"
-
-
-def normalize_artifact_class(value: str | None) -> str:
-    cleaned = str(value or "product").strip().lower()
-    return "fixture" if cleaned == "fixture" else "product"
-
-
-def flow_root(flow: str, artifact_class: str) -> Path:
-    base = FIXTURE_ROOT if normalize_artifact_class(artifact_class) == "fixture" else PRODUCT_ROOT
-    return base / ("features" if flow == "feature" else "issues")
-
-
-def execution_root(artifact_class: str) -> Path:
-    base = FIXTURE_ROOT if normalize_artifact_class(artifact_class) == "fixture" else PRODUCT_ROOT
-    return base / "execution"
-
-
-def discover_flow_directory(flow: str, slug: str, artifact_class: str = "auto") -> tuple[str, Path] | None:
-    classes = (
-        [normalize_artifact_class(artifact_class)]
-        if artifact_class in {"product", "fixture"}
-        else ["product", "fixture"]
-    )
-    for candidate_class in classes:
-        directory = flow_root(flow, candidate_class) / slug
-        if directory.exists():
-            return candidate_class, directory
-    return None
-
-
-def artifact_output_root(artifact_class: str) -> Path:
-    return FIXTURE_ROOT if normalize_artifact_class(artifact_class) == "fixture" else PRODUCT_ROOT
+from codecgc_runtime.artifacts import CODECGC_ROOT
+from codecgc_runtime.artifacts import FIXTURE_ROOT
+from codecgc_runtime.artifacts import PRODUCT_ROOT
+from codecgc_runtime.artifacts import artifact_output_root
+from codecgc_runtime.artifacts import discover_flow_directory
+from codecgc_runtime.artifacts import execution_root
+from codecgc_runtime.artifacts import flow_root
+from codecgc_runtime.artifacts import normalize_artifact_class

package/scripts/codecgc_console_io.py

@@ -1,45 +1,3 @@
-from __future__ import annotations
-
-import json
-import sys
-from typing import Any
-
-
-def configure_utf8_stdio() -> None:
-    for stream_name in ("stdout", "stderr"):
-        stream = getattr(sys, stream_name, None)
-        if stream is None:
-            continue
-        reconfigure = getattr(stream, "reconfigure", None)
-        if callable(reconfigure):
-            try:
-                reconfigure(encoding="utf-8", errors="replace")
-            except Exception:
-                pass
-
-
-def print_json(payload: dict[str, Any], *, file: Any | None = None) -> None:
-    target = file or sys.stdout
-    text = json.dumps(payload, ensure_ascii=False, indent=2)
-    target.write(text)
-    target.write("\n")
-
-
-def render_summary_block(title: str, base_lines: list[str], next_actions: list[str]) -> str:
-    lines = [title, *base_lines]
-    unique_actions: list[str] = []
-    seen: set[str] = set()
-    for item in next_actions:
-        normalized = str(item).strip()
-        if not normalized or normalized in seen:
-            continue
-        seen.add(normalized)
-        unique_actions.append(normalized)
-
-    if unique_actions:
-        lines.append(f"- 下一步: {unique_actions[0]}")
-        for item in unique_actions[1:]:
-            lines.append(f"- 备选动作: {item}")
-    else:
-        lines.append("- 下一步: 无")
-    return "\n".join(lines)
+from codecgc_runtime.console import configure_utf8_stdio
+from codecgc_runtime.console import print_json
+from codecgc_runtime.console import render_summary_block

package/scripts/codecgc_executor_registry.py

@@ -1,54 +1,4 @@
-from __future__ import annotations
-
-import os
-import sys
-from pathlib import Path
-from typing import Any
-
-
-WORKSPACE = Path(__file__).resolve().parents[1]
-
-
-def resolve_python_command() -> str:
-    override = os.environ.get("CODECGC_PYTHON_COMMAND", "").strip()
-    if override:
-        return override
-    return sys.executable
-
-
-def build_executor_registry() -> dict[str, dict[str, Any]]:
-    python_command = resolve_python_command()
-    return {
-        "backend": {
-            "target": "backend",
-            "mcp_server_name": "codex",
-            "routing_executor": "codexmcp",
-            "tool_name": "implement_backend_task",
-            "python_module": "codexmcp.cli",
-            "pythonpath": str(WORKSPACE / "codexmcp" / "src"),
-            "python_command": python_command,
-        },
-        "frontend": {
-            "target": "frontend",
-            "mcp_server_name": "gemini",
-            "routing_executor": "geminimcp",
-            "tool_name": "implement_frontend_task",
-            "python_module": "geminimcp.cli",
-            "pythonpath": str(WORKSPACE / "geminimcp" / "src"),
-            "python_command": python_command,
-        },
-    }
-
-
-def get_executor_config(target: str) -> dict[str, Any]:
-    registry = build_executor_registry()
-    if target not in registry:
-        raise ValueError(f"Unsupported target: {target}")
-    return registry[target]
-
-
-def build_executor_env(target: str) -> dict[str, str]:
-    env = dict(os.environ)
-    config = get_executor_config(target)
-    env["PYTHONPATH"] = str(config["pythonpath"])
-    return env
+from codecgc_runtime.executor_registry import build_executor_env
+from codecgc_runtime.executor_registry import build_executor_registry
+from codecgc_runtime.executor_registry import get_executor_config
+from codecgc_runtime.executor_registry import resolve_python_command