@hunyed15/codecgc 0.1.7 → 0.1.8

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

package/scripts/codecgc_routing_template.py

@@ -1,135 +1,11 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-
-DEFAULT_FRONTEND_PATHS = [
-    "apps/web/**",
-    "src/components/**",
-    "src/pages/**",
-    "src/app/**",
-    "src/styles/**",
-    "web/**",
-    "frontend/**",
-]
-
-DEFAULT_BACKEND_PATHS = [
-    "apps/api/**",
-    "server/**",
-    "src/server/**",
-    "src/services/**",
-    "src/repositories/**",
-    "backend/**",
-]
-
-DEFAULT_SHARED_PATHS = [
-    "packages/shared/**",
-    "src/shared/**",
-    "src/lib/**",
-    "src/types/**",
-]
-
-DEFAULT_RULES = {
-    "frontend_executor": "geminimcp",
-    "backend_executor": "codexmcp",
-    "shared_policy": "split-first",
-    "claude_role": "plan-review-accept-only",
-}
-
-
-def _render_list_block(name: str, items: list[str]) -> list[str]:
-    lines = [f"{name}:"]
-    for item in items:
-        lines.append(f'  - "{item}"')
-    return lines
-
-
-def _render_rules_block() -> list[str]:
-    lines = ["rules:"]
-    for key, value in DEFAULT_RULES.items():
-        lines.append(f'  {key}: "{value}"')
-    return lines
-
-
-def render_default_routing_yaml() -> str:
-    lines: list[str] = [
-        "version: 1",
-        "",
-        *_render_list_block("frontend_paths", DEFAULT_FRONTEND_PATHS),
-        "",
-        *_render_list_block("custom_frontend_paths", []),
-        "",
-        *_render_list_block("backend_paths", DEFAULT_BACKEND_PATHS),
-        "",
-        *_render_list_block("custom_backend_paths", []),
-        "",
-        *_render_list_block("shared_paths", DEFAULT_SHARED_PATHS),
-        "",
-        *_render_rules_block(),
-        "",
-    ]
-    return "\n".join(lines)
-
-
-def _normalize_line_endings(text: str) -> str:
-    return text.replace("\r\n", "\n").replace("\r", "\n")
-
-
-def _extract_list_block(lines: list[str], block_name: str) -> list[str]:
-    items: list[str] = []
-    inside = False
-    for line in lines:
-        stripped = line.strip()
-        if not inside:
-            if stripped == f"{block_name}:":
-                inside = True
-            continue
-
-        if line and not line.startswith(" "):
-            break
-        if stripped.startswith("- "):
-            value = stripped[2:].strip()
-            if len(value) >= 2 and value[0] == value[-1] and value[0] in {'"', "'"}:
-                value = value[1:-1]
-            if value:
-                items.append(value)
-    return items
-
-
-def merge_routing_template(existing_text: str) -> str:
-    if not existing_text.strip():
-        return render_default_routing_yaml()
-
-    lines = _normalize_line_endings(existing_text).split("\n")
-    custom_frontend = _extract_list_block(lines, "custom_frontend_paths")
-    custom_backend = _extract_list_block(lines, "custom_backend_paths")
-
-    merged = render_default_routing_yaml().split("\n")
-    output: list[str] = []
-    current_block = ""
-
-    for line in merged:
-        stripped = line.strip()
-        output.append(line)
-        if stripped == "custom_frontend_paths:":
-            current_block = "custom_frontend_paths"
-            for item in custom_frontend:
-                output.append(f'  - "{item}"')
-            continue
-        if stripped == "custom_backend_paths:":
-            current_block = "custom_backend_paths"
-            for item in custom_backend:
-                output.append(f'  - "{item}"')
-            continue
-        if stripped.endswith(":") and stripped not in {"custom_frontend_paths:", "custom_backend_paths:"}:
-            current_block = stripped[:-1]
-
-    return "\n".join(output).rstrip() + "\n"
-
-
-def sync_workspace_routing_file(target_path: Path) -> Path:
-    existing_text = target_path.read_text(encoding="utf-8") if target_path.exists() else ""
-    merged_text = merge_routing_template(existing_text)
-    target_path.parent.mkdir(parents=True, exist_ok=True)
-    target_path.write_text(merged_text, encoding="utf-8")
-    return target_path
+from codecgc_runtime.routing_template import DEFAULT_BACKEND_PATHS
+from codecgc_runtime.routing_template import DEFAULT_BACKEND_TEST_PATHS
+from codecgc_runtime.routing_template import DEFAULT_DOCS_PATHS
+from codecgc_runtime.routing_template import DEFAULT_FRONTEND_PATHS
+from codecgc_runtime.routing_template import DEFAULT_FRONTEND_TEST_PATHS
+from codecgc_runtime.routing_template import DEFAULT_ORCHESTRATION_PATHS
+from codecgc_runtime.routing_template import DEFAULT_RULES
+from codecgc_runtime.routing_template import DEFAULT_SHARED_PATHS
+from codecgc_runtime.routing_template import merge_routing_template
+from codecgc_runtime.routing_template import render_default_routing_yaml
+from codecgc_runtime.routing_template import sync_workspace_routing_file

package/scripts/codecgc_runtime/__init__.py

@@ -0,0 +1 @@
+"""Shared CodeCGC runtime helpers."""

package/scripts/codecgc_runtime/artifacts.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from .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

package/scripts/codecgc_runtime/console.py

@@ -0,0 +1,45 @@
+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)

package/scripts/codecgc_runtime/executor_registry.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import os
+import sys
+from typing import Any
+
+from .paths import PACKAGE_ROOT
+
+
+WORKSPACE = PACKAGE_ROOT
+
+
+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