@hunyed15/codecgc 0.1.7 → 0.1.8

package/scripts/audit_codecgc_historical_audits.py

@@ -6,6 +6,8 @@ from typing import Any
 from codecgc_artifact_roots import discover_flow_directory
 from codecgc_artifact_roots import execution_root
 from codecgc_artifact_roots import normalize_artifact_class
+from codecgc_path_contract import is_project_relative_path
+from codecgc_path_contract import resolve_project_path
 
 
 WORKSPACE = Path(__file__).resolve().parents[1]
@@ -33,6 +35,19 @@ def contains_old_repo_name(value: Any) -> bool:
     return isinstance(value, str) and OLD_REPO_NAME in value
 
 
+def contains_persisted_absolute_project_path(value: Any) -> bool:
+    if not isinstance(value, str) or not value.strip():
+        return False
+    if is_project_relative_path(value):
+        return False
+    resolved = resolve_project_path(value)
+    try:
+        resolved.relative_to(WORKSPACE.resolve())
+        return True
+    except ValueError:
+        return False
+
+
 def expected_artifact_filename(artifact_type: str, artifact_slug: str) -> str:
     base_slug = artifact_slug[11:] if len(artifact_slug) > 11 and artifact_slug[4] == "-" else artifact_slug
     if artifact_type == "feature":
@@ -97,7 +112,7 @@ def validate_source_contract(source: dict[str, Any]) -> list[dict[str, str]]:
         )
 
     if artifact_file:
-        artifact_file_path = Path(artifact_file)
+        artifact_file_path = resolve_project_path(artifact_file)
         if not artifact_file_path.exists():
             issues.append(
                 {
@@ -105,7 +120,7 @@ def validate_source_contract(source: dict[str, Any]) -> list[dict[str, str]]:
                     "detail": artifact_file,
                 }
             )
-        elif directory not in artifact_file_path.parents:
+        elif directory.resolve() not in artifact_file_path.resolve().parents:
             issues.append(
                 {
                     "problem": "source-artifact-file-directory-mismatch",
@@ -174,6 +189,31 @@ def inspect_audit(path: Path) -> list[dict[str, str]]:
             }
         )
 
+    if contains_persisted_absolute_project_path(data.get("routing_file")):
+        issues.append(
+            {
+                "path": str(path),
+                "problem": "absolute-project-routing-file",
+                "detail": str(data.get("routing_file", "")),
+            }
+        )
+    if contains_persisted_absolute_project_path(data.get("cd")):
+        issues.append(
+            {
+                "path": str(path),
+                "problem": "absolute-project-cd",
+                "detail": str(data.get("cd", "")),
+            }
+        )
+    if contains_persisted_absolute_project_path(source.get("artifact_file")):
+        issues.append(
+            {
+                "path": str(path),
+                "problem": "absolute-project-artifact-file",
+                "detail": str(source.get("artifact_file", "")),
+            }
+        )
+
     for item in validate_source_contract(source):
         issues.append(
             {

package/scripts/audit_codecgc_package_runtime.py

@@ -13,14 +13,18 @@ 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",
     "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 +49,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 +167,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 +238,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,7 +202,7 @@ 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 "",
@@ -190,26 +213,6 @@ def load_explicit_task_payload(args: argparse.Namespace) -> dict[str, Any]:
     }
 
 
-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 +221,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 +282,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 +304,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 +338,13 @@ 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)
+        )
+
     if kind == "frontend":
         tool_name = "implement_frontend_task"
         tool_args: dict[str, Any] = {
@@ -367,6 +383,7 @@ def build_tool_call(args: argparse.Namespace, routing: dict[str, Any]) -> dict[s
         "tool_name": tool_name,
         "tool_args": tool_args,
         "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