@hunyed15/codecgc 0.1.6 → 0.1.8

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

package/scripts/codecgc_runtime/mcp_config.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from .executor_registry import build_executor_registry
+from .paths import PACKAGE_ROOT
+
+
+WORKSPACE = PACKAGE_ROOT
+MCP_CONFIG_PATH = WORKSPACE / ".mcp.json"
+
+
+def build_runtime_pythonpath(*extra_paths: Path) -> str:
+    paths = [str(WORKSPACE / "scripts"), *(str(path) for path in extra_paths)]
+    return os.pathsep.join(paths)
+
+
+def _with_workspace_env(env: dict[str, str], workspace_root: Path | None) -> dict[str, str]:
+    if workspace_root is None:
+        return env
+    enriched = dict(env)
+    enriched["CODECGC_WORKSPACE_ROOT"] = str(workspace_root.expanduser().resolve())
+    return enriched
+
+
+def build_mcp_config(workspace_root: Path | None = None) -> dict[str, Any]:
+    registry = build_executor_registry()
+    servers: dict[str, dict[str, Any]] = {}
+
+    servers["codecgc"] = {
+        "command": str(next(iter(registry.values()))["python_command"]),
+        "args": ["-m", "codecgcmcp.cli"],
+        "env": _with_workspace_env(
+            {
+                "PYTHONPATH": build_runtime_pythonpath(WORKSPACE / "codecgcmcp" / "src"),
+            },
+            workspace_root,
+        ),
+    }
+
+    for config in registry.values():
+        servers[str(config["mcp_server_name"])] = {
+            "command": str(config["python_command"]),
+            "args": ["-m", str(config["python_module"])],
+            "env": _with_workspace_env(
+                {
+                    "PYTHONPATH": build_runtime_pythonpath(
+                        WORKSPACE / "codecgcmcp" / "src",
+                        Path(str(config["pythonpath"])),
+                    ),
+                },
+                workspace_root,
+            ),
+        }
+
+    return {"mcpServers": servers}
+
+
+def write_mcp_config(target_path: Path, workspace_root: Path | None = None) -> Path:
+    config = build_mcp_config(workspace_root)
+    target_path.parent.mkdir(parents=True, exist_ok=True)
+    target_path.write_text(json.dumps(config, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    return target_path
+
+
+def main() -> int:
+    write_mcp_config(MCP_CONFIG_PATH, WORKSPACE)
+    print(json.dumps({"success": True, "path": str(MCP_CONFIG_PATH)}, ensure_ascii=False, indent=2))
+    return 0

package/scripts/codecgc_runtime/path_contract.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from .paths import PROJECT_ROOT
+
+
+def normalize_path_text(path_text: str) -> str:
+    return str(path_text or "").replace("\\", "/").strip()
+
+
+def is_project_relative_path(path_text: str) -> bool:
+    normalized = normalize_path_text(path_text)
+    if not normalized:
+        return False
+    if normalized.startswith(("/", "~")):
+        return False
+    if re.match(r"^[A-Za-z]:/", normalized):
+        return False
+    return True
+
+
+def _relative_to_project(path: Path, project_root: Path) -> str | None:
+    try:
+        return path.resolve().relative_to(project_root.resolve()).as_posix()
+    except ValueError:
+        return None
+
+
+def _legacy_project_suffix(path_text: str) -> str | None:
+    normalized = normalize_path_text(path_text)
+    if not normalized:
+        return None
+
+    for marker in ("/CodeCGC/release/", "/CodeCGC/", "/CodeCCG/release/", "/CodeCCG/"):
+        if marker in normalized:
+            return normalized.split(marker, 1)[1].lstrip("/")
+
+    if normalized.endswith(("/CodeCGC/release", "/CodeCGC", "/CodeCCG/release", "/CodeCCG")):
+        return "."
+
+    basename = normalized.rsplit("/", 1)[-1]
+    if basename == "model-routing.yaml":
+        return "model-routing.yaml"
+    return None
+
+
+def to_project_relative_path(
+    path_value: str | Path,
+    project_root: Path = PROJECT_ROOT,
+    *,
+    allow_legacy_suffix: bool = True,
+) -> str:
+    path_text = normalize_path_text(str(path_value))
+    if not path_text:
+        return ""
+    if path_text == ".":
+        return "."
+
+    path = Path(path_text)
+    if path.is_absolute():
+        relative = _relative_to_project(path, project_root)
+        if relative is not None:
+            return relative or "."
+
+        if allow_legacy_suffix:
+            legacy_suffix = _legacy_project_suffix(path_text)
+            if legacy_suffix is not None:
+                return legacy_suffix or "."
+
+        return path_text
+
+    normalized = path_text
+    while normalized.startswith("./"):
+        normalized = normalized[2:]
+    return normalized or "."
+
+
+def resolve_project_path(path_value: str | Path, project_root: Path = PROJECT_ROOT) -> Path:
+    path_text = normalize_path_text(str(path_value))
+    if not path_text or path_text == ".":
+        return project_root.resolve()
+
+    path = Path(path_text)
+    if path.is_absolute():
+        relative = _relative_to_project(path, project_root)
+        if relative is not None:
+            return (project_root / relative).resolve()
+
+        legacy_suffix = _legacy_project_suffix(path_text)
+        if legacy_suffix is not None:
+            return (project_root / legacy_suffix).resolve()
+
+        return path.resolve()
+
+    return (project_root / path_text).resolve()
+
+
+def normalize_persisted_project_path(path_value: str | Path, project_root: Path = PROJECT_ROOT) -> str:
+    return to_project_relative_path(path_value, project_root)
+
+
+def normalize_source_contract(source: object, project_root: Path = PROJECT_ROOT) -> object:
+    if not isinstance(source, dict):
+        return source
+    normalized = dict(source)
+    artifact_file = normalized.get("artifact_file")
+    if isinstance(artifact_file, str) and artifact_file.strip():
+        normalized["artifact_file"] = normalize_persisted_project_path(artifact_file, project_root)
+    return normalized
+
+
+def normalize_audit_path_fields(record: dict, project_root: Path = PROJECT_ROOT) -> dict:
+    normalized = dict(record)
+    for key in ("routing_file", "cd"):
+        value = normalized.get(key)
+        if isinstance(value, str) and value.strip():
+            normalized[key] = normalize_persisted_project_path(value, project_root)
+
+    source = normalized.get("source")
+    normalized["source"] = normalize_source_contract(source, project_root)
+    return normalized

package/scripts/codecgc_runtime/paths.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+PACKAGE_ROOT = Path(__file__).resolve().parents[2]
+
+
+def resolve_workspace_root(override_workspace: str = "") -> Path:
+    explicit = str(override_workspace or "").strip()
+    if explicit:
+        return Path(explicit).expanduser().resolve()
+
+    configured = os.environ.get("CODECGC_WORKSPACE_ROOT", "").strip()
+    if configured:
+        return Path(configured).expanduser().resolve()
+
+    return Path.cwd().resolve()
+
+
+PROJECT_ROOT = resolve_workspace_root()

package/scripts/codecgc_runtime/routing_paths.py

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