@hunyed15/codecgc 0.1.7 → 0.1.9

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

package/scripts/codecgc_runtime/routing_template.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+
+
+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_ORCHESTRATION_PATHS = [
+    "codecgc/**",
+    ".claude/commands/**",
+    ".claude/settings.local.json",
+    ".codex/codecgcrc.json",
+    ".gemini/policies/**",
+    ".mcp.json",
+    "model-routing.yaml",
+]
+
+DEFAULT_DOCS_PATHS = [
+    "README.md",
+    "INSTALLATION.md",
+    "docs/**",
+    "CHANGELOG.md",
+]
+
+DEFAULT_BACKEND_TEST_PATHS = [
+    "apps/api/*.test.*",
+    "apps/api/*.spec.*",
+    "apps/api/**/*.test.*",
+    "apps/api/**/*.spec.*",
+    "tests/backend/**",
+]
+
+DEFAULT_FRONTEND_TEST_PATHS = [
+    "apps/web/*.test.*",
+    "apps/web/*.spec.*",
+    "apps/web/**/*.test.*",
+    "apps/web/**/*.spec.*",
+    "tests/frontend/**",
+]
+
+DEFAULT_RULES = {
+    "claude_allowed_owners": ["orchestration", "docs"],
+    "backend_executor": "codexmcp",
+    "frontend_executor": "geminimcp",
+    "shared_policy": "split-first",
+}
+
+
+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_nested_list_block(name: str, groups: dict[str, list[str]]) -> list[str]:
+    lines = [f"{name}:"]
+    for group_name, items in groups.items():
+        lines.append(f"  {group_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():
+        if isinstance(value, list):
+            lines.append(f"  {key}:")
+            lines.extend(f'    - "{item}"' for item in value)
+        else:
+            lines.append(f'  {key}: "{value}"')
+    return lines
+
+
+def render_default_routing_yaml() -> str:
+    lines: list[str] = [
+        "version: 2",
+        "",
+        *_render_list_block("orchestration_paths", DEFAULT_ORCHESTRATION_PATHS),
+        "",
+        *_render_list_block("docs_paths", DEFAULT_DOCS_PATHS),
+        "",
+        *_render_list_block("frontend_paths", DEFAULT_FRONTEND_PATHS),
+        "",
+        *_render_list_block("backend_paths", DEFAULT_BACKEND_PATHS),
+        "",
+        *_render_nested_list_block(
+            "test_paths",
+            {
+                "frontend": DEFAULT_FRONTEND_TEST_PATHS,
+                "backend": DEFAULT_BACKEND_TEST_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 existing_text.strip():
+        try:
+            data = yaml.safe_load(existing_text)
+        except yaml.YAMLError:
+            data = None
+        if isinstance(data, dict) and int(data.get("version", 0) or 0) == 2:
+            return _normalize_line_endings(existing_text).rstrip() + "\n"
+    return render_default_routing_yaml()
+
+
+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

package/scripts/codecgc_runtime/workflow_runtime.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+from typing import Any
+
+from .paths import PACKAGE_ROOT
+from .paths import PROJECT_ROOT
+
+
+WORKSPACE = PACKAGE_ROOT
+PROJECT_WORKSPACE = PROJECT_ROOT
+SCRIPTS_DIR = WORKSPACE / "scripts"
+
+
+def build_script_command(script_name: str, *args: str) -> list[str]:
+    return [sys.executable, str(SCRIPTS_DIR / script_name), *args]
+
+
+def parse_json_text(text: str) -> dict[str, Any]:
+    stripped = text.strip()
+    if not stripped:
+        raise ValueError("Command produced no JSON output.")
+    return json.loads(stripped)
+
+
+def run_json_script(script_name: str, *args: str) -> dict[str, Any]:
+    command = build_script_command(script_name, *args)
+
+    env = os.environ.copy()
+    env["CODECGC_WORKSPACE_ROOT"] = str(PROJECT_WORKSPACE)
+
+    completed = subprocess.run(
+        command,
+        cwd=PROJECT_WORKSPACE,
+        stdin=subprocess.DEVNULL,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        env=env,
+    )
+
+    stdout = completed.stdout.strip()
+    stderr = completed.stderr.strip()
+
+    if completed.returncode == 0:
+        if not stdout:
+            return {"success": True}
+        return parse_json_text(stdout)
+
+    for candidate in (stdout, stderr):
+        if not candidate:
+            continue
+        try:
+            parsed = parse_json_text(candidate)
+        except Exception:
+            continue
+        if isinstance(parsed, dict):
+            parsed.setdefault("success", False)
+            parsed.setdefault("returncode", completed.returncode)
+            return parsed
+
+    return {
+        "success": False,
+        "returncode": completed.returncode,
+        "stdout": stdout,
+        "stderr": stderr,
+        "error": f"{script_name} failed with exit code {completed.returncode}.",
+    }

package/scripts/codecgc_runtime_paths.py

@@ -1,22 +1,3 @@
-from __future__ import annotations
-
-import os
-from pathlib import Path
-
-
-PACKAGE_ROOT = Path(__file__).resolve().parents[1]
-
-
-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()
+from codecgc_runtime.paths import PACKAGE_ROOT
+from codecgc_runtime.paths import PROJECT_ROOT
+from codecgc_runtime.paths import resolve_workspace_root

package/scripts/codecgc_step_control.py

@@ -34,9 +34,8 @@ def is_executable_codecgc_block(codecgc: Any) -> bool:
     if any(is_placeholder_path(path) for path in target_paths):
         return False
 
-    task_id = str(codecgc.get("task_id", "")).strip()
     task_summary = str(codecgc.get("task_summary", "")).strip()
-    return bool(task_id and task_summary)
+    return bool(task_summary)
 
 
 def is_test_codecgc_block(codecgc: Any) -> bool:
@@ -87,6 +86,7 @@ def select_next_executable_step(checklist_path: Path) -> dict[str, Any]:
         "task_id": str(codecgc.get("task_id", "")),
         "action": str(step.get("action", "")),
         "kind": str(codecgc.get("kind", "")),
+        "step_type": str(codecgc.get("step_type", "")),
         "target_paths": codecgc.get("target_paths", []),
         "task_summary": str(codecgc.get("task_summary", "")),
         "artifact_type": resolve_artifact_type(data),
@@ -107,6 +107,7 @@ def get_step_metadata(checklist_path: Path, step_number: int) -> dict[str, Any]:
         "task_id": str(codecgc.get("task_id", "")),
         "action": str(step.get("action", "")) if isinstance(step, dict) else "",
         "kind": str(codecgc.get("kind", "")),
+        "step_type": str(codecgc.get("step_type", "")),
         "target_paths": codecgc.get("target_paths", []),
         "task_summary": str(codecgc.get("task_summary", "")),
         "artifact_type": resolve_artifact_type(data),