@hunyed15/codecgc 0.1.6 → 0.1.8

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

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

package/scripts/codecgc_path_contract.py

@@ -0,0 +1,7 @@
+from codecgc_runtime.path_contract import is_project_relative_path
+from codecgc_runtime.path_contract import normalize_audit_path_fields
+from codecgc_runtime.path_contract import normalize_path_text
+from codecgc_runtime.path_contract import normalize_persisted_project_path
+from codecgc_runtime.path_contract import normalize_source_contract
+from codecgc_runtime.path_contract import resolve_project_path
+from codecgc_runtime.path_contract import to_project_relative_path

package/scripts/codecgc_policy.py

@@ -0,0 +1,275 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from dataclasses import dataclass
+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 to_project_relative_path
+from codecgc_routing_paths import resolve_active_routing_file
+
+
+OWNERS = {"orchestration", "docs", "frontend", "backend", "frontend-test", "backend-test", "shared", "unknown"}
+POLICY_PROJECT_ROOT_KEY = "_codecgc_project_root"
+
+
+@dataclass(frozen=True)
+class PathDecision:
+    path: str
+    owner: str
+    allowed: bool
+    reason: str
+    recommended_action: str
+
+
+def normalize_path_text(path_text: str) -> str:
+    normalized = str(path_text or "").replace("\\", "/").strip()
+    while normalized.startswith("./"):
+        normalized = normalized[2:]
+    return normalized
+
+
+def _as_string_list(value: Any) -> list[str]:
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return [str(item).strip() for item in value if str(item).strip()]
+    return [str(value).strip()] if str(value).strip() else []
+
+
+def _load_yaml(path: Path) -> dict[str, Any]:
+    if not path.exists():
+        raise FileNotFoundError(f"Routing policy file not found: {path}")
+    data = yaml.safe_load(path.read_text(encoding="utf-8"))
+    if not isinstance(data, dict):
+        raise ValueError(f"Routing policy must be a mapping: {path}")
+    return data
+
+
+def load_policy(path: Path | None = None) -> dict[str, Any]:
+    policy_path = path or resolve_active_routing_file()
+    policy = _load_yaml(policy_path)
+    if int(policy.get("version", 0) or 0) != 2:
+        raise ValueError("model-routing.yaml must use version: 2.")
+    validate_policy(policy)
+    policy[POLICY_PROJECT_ROOT_KEY] = str(policy_path.parent.resolve())
+    return policy
+
+
+def validate_policy(policy: dict[str, Any]) -> None:
+    required_lists = [
+        "orchestration_paths",
+        "docs_paths",
+        "frontend_paths",
+        "backend_paths",
+        "shared_paths",
+    ]
+    missing = [name for name in required_lists if not isinstance(policy.get(name), list)]
+    test_paths = policy.get("test_paths")
+    rules = policy.get("rules")
+    if not isinstance(test_paths, dict):
+        missing.append("test_paths")
+    if not isinstance(rules, dict):
+        missing.append("rules")
+    if missing:
+        raise ValueError(f"model-routing.yaml is missing required policy sections: {', '.join(missing)}")
+
+    for name in ("frontend", "backend"):
+        if not isinstance(test_paths.get(name), list):
+            raise ValueError(f"model-routing.yaml test_paths.{name} must be a list.")
+
+    allowed = set(_as_string_list(rules.get("claude_allowed_owners")))
+    invalid_allowed = sorted(allowed - OWNERS)
+    if invalid_allowed:
+        raise ValueError(f"Invalid claude_allowed_owners entries: {', '.join(invalid_allowed)}")
+
+    if str(rules.get("shared_policy", "")).strip() != "split-first":
+        raise ValueError("Only shared_policy: split-first is supported.")
+
+
+def _matches_any(path_text: str, patterns: list[str]) -> bool:
+    return any(fnmatch(path_text, pattern) for pattern in patterns)
+
+
+def normalize_policy_path(path_text: str, policy: dict[str, Any]) -> str:
+    project_root = str(policy.get(POLICY_PROJECT_ROOT_KEY, "")).strip()
+    if project_root:
+        return normalize_path_text(
+            to_project_relative_path(path_text, Path(project_root), allow_legacy_suffix=False)
+        )
+    return normalize_path_text(path_text)
+
+
+def classify_path(path_text: str, policy: dict[str, Any]) -> str:
+    normalized = normalize_policy_path(path_text, policy)
+    test_paths = policy.get("test_paths", {})
+
+    ordered_groups: list[tuple[str, list[str]]] = [
+        ("shared", _as_string_list(policy.get("shared_paths"))),
+        ("orchestration", _as_string_list(policy.get("orchestration_paths"))),
+        ("docs", _as_string_list(policy.get("docs_paths"))),
+        ("frontend-test", _as_string_list(test_paths.get("frontend"))),
+        ("backend-test", _as_string_list(test_paths.get("backend"))),
+        ("frontend", _as_string_list(policy.get("frontend_paths"))),
+        ("backend", _as_string_list(policy.get("backend_paths"))),
+    ]
+    for owner, patterns in ordered_groups:
+        if _matches_any(normalized, patterns):
+            return owner
+    return "unknown"
+
+
+def allowed_owners_for_actor(actor: str, policy: dict[str, Any]) -> set[str]:
+    normalized_actor = str(actor or "").strip().lower()
+    rules = policy.get("rules", {})
+    if normalized_actor == "claude":
+        return set(_as_string_list(rules.get("claude_allowed_owners")))
+    if normalized_actor in {"codex", "codexmcp", "backend"}:
+        return {"backend", "backend-test"}
+    if normalized_actor in {"gemini", "geminimcp", "frontend"}:
+        return {"frontend", "frontend-test"}
+    return set()
+
+
+def recommended_action_for(owner: str, actor: str) -> str:
+    if owner == "backend":
+        return "route through cgc-build or cgc-fix with a backend step"
+    if owner == "backend-test":
+        return "route through cgc-test with a backend test step"
+    if owner == "frontend":
+        return "route through cgc-build or cgc-fix with a frontend step"
+    if owner == "frontend-test":
+        return "route through cgc-test with a frontend test step"
+    if owner == "shared":
+        return "split the shared change before execution"
+    if owner == "unknown":
+        return "add the path to model-routing.yaml or narrow the target path"
+    return f"request a policy route for actor {actor}"
+
+
+def decide_path(path_text: str, actor: str, operation: str, policy: dict[str, Any]) -> PathDecision:
+    owner = classify_path(path_text, policy)
+    allowed_owners = allowed_owners_for_actor(actor, policy)
+    normalized_actor = str(actor or "").strip().lower()
+    normalized_operation = str(operation or "").strip().lower() or "write"
+
+    allowed = normalized_operation in {"read", "inspect"} or owner in allowed_owners
+    if owner == "unknown":
+        allowed = False
+    if owner == "shared" and normalized_operation not in {"read", "inspect"}:
+        allowed = False
+
+    if allowed:
+        reason = f"{normalized_actor} may {normalized_operation} {owner} paths"
+        recommended = ""
+    elif owner == "shared":
+        reason = "shared paths require split-first routing"
+        recommended = recommended_action_for(owner, normalized_actor)
+    elif owner == "unknown":
+        reason = "path is not covered by model-routing.yaml"
+        recommended = recommended_action_for(owner, normalized_actor)
+    else:
+        reason = f"{owner} paths are not owned by {normalized_actor}"
+        recommended = recommended_action_for(owner, normalized_actor)
+
+    return PathDecision(
+        path=normalize_policy_path(path_text, policy),
+        owner=owner,
+        allowed=allowed,
+        reason=reason,
+        recommended_action=recommended,
+    )
+
+
+def evaluate_paths(paths: list[str], actor: str, operation: str, policy: dict[str, Any]) -> dict[str, Any]:
+    decisions = [decide_path(path, actor, operation, policy) for path in paths]
+    return {
+        "success": all(decision.allowed for decision in decisions),
+        "allowed": all(decision.allowed for decision in decisions),
+        "actor": str(actor or "").strip().lower(),
+        "operation": str(operation or "").strip().lower() or "write",
+        "decisions": [decision.__dict__ for decision in decisions],
+        "owners": sorted({decision.owner for decision in decisions}),
+    }
+
+
+def validate_executor_target(kind: str, target_paths: list[str], policy: dict[str, Any]) -> dict[str, Any]:
+    actor = "codex" if str(kind).strip().lower() == "backend" else "gemini" if str(kind).strip().lower() == "frontend" else str(kind)
+    result = evaluate_paths(target_paths, actor=actor, operation="write", policy=policy)
+    result["kind"] = str(kind).strip().lower()
+    return result
+
+
+def parse_hook_payload(text: str) -> tuple[str, str]:
+    if not text.strip():
+        return "", ""
+    payload = json.loads(text)
+    if not isinstance(payload, dict):
+        return "", ""
+    tool_name = str(payload.get("tool_name", "")).strip()
+    tool_input = payload.get("tool_input", {})
+    if not isinstance(tool_input, dict):
+        return tool_name, ""
+    file_path = str(tool_input.get("file_path") or tool_input.get("path") or "").strip()
+    return tool_name, file_path
+
+
+def build_hook_response(allowed: bool, reason: str) -> dict[str, Any]:
+    if allowed:
+        return {"decision": "approve"}
+    return {"decision": "deny", "reason": reason}
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Evaluate CodeCGC routing policy decisions.")
+    parser.add_argument("--routing-file", default="", help="Optional explicit model-routing.yaml path.")
+    parser.add_argument("--actor", default="claude", help="Actor requesting the operation.")
+    parser.add_argument("--operation", default="write", help="Operation to evaluate.")
+    parser.add_argument("--path", action="append", default=[], help="Path to evaluate. Repeatable.")
+    parser.add_argument("--hook-check", action="store_true", help="Read Claude hook JSON from stdin and return hook JSON.")
+    return parser
+
+
+def main() -> int:
+    configure_utf8_stdio()
+    parser = build_parser()
+    args = parser.parse_args()
+
+    try:
+        policy_path = Path(args.routing_file).resolve() if args.routing_file else resolve_active_routing_file()
+        policy = load_policy(policy_path)
+
+        if args.hook_check:
+            tool_name, file_path = parse_hook_payload(sys.stdin.read())
+            if tool_name not in {"Edit", "Write", "MultiEdit"} or not file_path:
+                print_json(build_hook_response(True, ""))
+                return 0
+            result = evaluate_paths([file_path], actor=args.actor, operation=args.operation, policy=policy)
+            decision = result["decisions"][0]
+            reason = decision.get("reason", "")
+            recommended = decision.get("recommended_action", "")
+            hook_reason = f"CodeCGC: {reason}."
+            if recommended:
+                hook_reason += f" {recommended}."
+            print_json(build_hook_response(bool(result["allowed"]), hook_reason))
+            return 0
+
+        if not args.path:
+            raise ValueError("At least one --path is required unless --hook-check is used.")
+
+        print_json(evaluate_paths(args.path, actor=args.actor, operation=args.operation, policy=policy))
+        return 0
+    except Exception as error:
+        print_json({"success": False, "allowed": False, "error": str(error)}, file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/codecgc_routing_paths.py

@@ -1,16 +1,3 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-from codecgc_runtime_paths import PACKAGE_ROOT
-from codecgc_runtime_paths import PROJECT_ROOT
-
-
-PACKAGE_ROUTING_FILE = PACKAGE_ROOT / "model-routing.yaml"
-PROJECT_ROUTING_FILE = PROJECT_ROOT / "model-routing.yaml"
-
-
-def resolve_active_routing_file() -> Path:
-    if PROJECT_ROUTING_FILE.exists():
-        return PROJECT_ROUTING_FILE
-    return PACKAGE_ROUTING_FILE
+from codecgc_runtime.routing_paths import PACKAGE_ROUTING_FILE
+from codecgc_runtime.routing_paths import PROJECT_ROUTING_FILE
+from codecgc_runtime.routing_paths import resolve_active_routing_file