@hunyed15/codecgc 0.1.0

package/scripts/codecgc_roadmap_templates.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+
+def render_bullet_list(items: list[str], indent: str, fallback: str) -> str:
+    values = [item.strip() for item in items if item.strip()]
+    if not values:
+        return f"{indent}- {fallback}"
+    return "\n".join(f"{indent}- {item}" for item in values)
+
+
+def render_overview(
+    *,
+    initiative: str,
+    summary: str,
+    user_story: str,
+    goal: str,
+    context: list[str],
+    scope: list[str],
+    risks: list[str],
+    reasons: list[str],
+    artifact_class: str,
+) -> str:
+    return f"""---
+doc_type: roadmap-overview
+artifact_class: {artifact_class}
+initiative: {initiative}
+status: draft
+summary: {summary}
+tags: []
+---
+
+# {summary}
+
+## 1. 目标
+
+- 摘要: {summary}
+- 目标: {goal or '待补充'}
+- 用户故事或操作者诉求: {user_story or '待补充'}
+
+## 2. 背景
+
+{render_bullet_list(context, '', '待补充')}
+
+## 3. 为什么需要走 Roadmap
+
+{render_bullet_list(reasons, '', '待补充')}
+
+## 4. 范围
+
+{render_bullet_list(scope, '', '待补充')}
+
+## 5. 风险
+
+{render_bullet_list(risks, '', '待补充')}
+"""
+
+
+def render_phases(
+    *,
+    initiative: str,
+    grouped_paths: dict[str, list[str]],
+    artifact_class: str,
+) -> str:
+    frontend_paths = grouped_paths.get("frontend", [])
+    backend_paths = grouped_paths.get("backend", [])
+    shared_paths = grouped_paths.get("shared", [])
+    unknown_paths = grouped_paths.get("unknown", [])
+    return f"""---
+doc_type: roadmap-phases
+artifact_class: {artifact_class}
+initiative: {initiative}
+status: draft
+tags: []
+---
+
+# {initiative} 阶段拆分
+
+## 1. 阶段说明
+
+- 第 1 阶段：澄清范围、依赖和成功标准
+- 第 2 阶段：把 initiative 拆成可执行的 feature 或 issue track
+- 第 3 阶段：按正常 CodeCGC 流程交付前端和后端 track
+
+## 2. 候选前端 Track
+
+{render_bullet_list(frontend_paths, '', '暂未识别。')}
+
+## 3. 候选后端 Track
+
+{render_bullet_list(backend_paths, '', '暂未识别。')}
+
+## 4. 共享或未知范围
+
+共享范围:
+{render_bullet_list(shared_paths, '  ', '无。')}
+
+未知范围:
+{render_bullet_list(unknown_paths, '  ', '无。')}
+
+## 5. 已初始化的子工作流
+
+- 暂无。
+"""
+
+
+def render_delivery_plan(
+    *,
+    initiative: str,
+    dependencies: list[str],
+    assumptions: list[str],
+    validation: list[str],
+    rollback: list[str],
+    open_questions: list[str],
+    artifact_class: str,
+) -> str:
+    return f"""---
+doc_type: roadmap-delivery-plan
+artifact_class: {artifact_class}
+initiative: {initiative}
+status: draft
+tags: []
+---
+
+# {initiative} 交付计划
+
+## 1. 依赖
+
+{render_bullet_list(dependencies, '', '待补充')}
+
+## 2. 前提假设
+
+{render_bullet_list(assumptions, '', '待补充')}
+
+## 3. 验证策略
+
+{render_bullet_list(validation, '', '待补充')}
+
+## 4. 回退策略
+
+{render_bullet_list(rollback, '', '待补充')}
+
+## 5. 开放问题
+
+{render_bullet_list(open_questions, '', '当前无。')}
+
+## 6. 工作流跟踪
+
+- 目前还没有登记子工作流。
+"""

package/scripts/codecgc_routing_paths.py

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

package/scripts/codecgc_routing_template.py

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

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[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()

package/scripts/codecgc_session_recovery.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from codecgc_artifact_roots import execution_root
+
+
+def load_audit_json(path: Path) -> dict[str, Any] | None:
+    if not path.exists():
+        return None
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def extract_reusable_session_id(audit: dict[str, Any] | None) -> str:
+    if not isinstance(audit, dict):
+        return ""
+
+    result = audit.get("result", {})
+    if isinstance(result, dict):
+        session_id = str(result.get("session_id", "")).strip()
+        if session_id:
+            return session_id
+
+    return str(audit.get("requested_session_id", "")).strip()
+
+
+def resolve_task_audit_path(task_id: str, artifact_class: str) -> Path | None:
+    cleaned_task_id = str(task_id).strip()
+    if not cleaned_task_id:
+        return None
+    return execution_root(artifact_class) / f"{cleaned_task_id}.json"
+
+
+def resolve_session_id_from_task(task_id: str, artifact_class: str) -> str:
+    audit_path = resolve_task_audit_path(task_id, artifact_class)
+    if audit_path is None:
+        return ""
+    return extract_reusable_session_id(load_audit_json(audit_path))

package/scripts/codecgc_step_control.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from build_codecgc_task import load_checklist_yaml
+
+
+def resolve_artifact_type(data: dict[str, Any]) -> str:
+    if data.get("feature"):
+        return "feature"
+    if data.get("issue"):
+        return "issue"
+    return "checklist"
+
+
+def is_placeholder_path(path_text: str) -> bool:
+    normalized = str(path_text or "").strip().replace("\\", "/").lower()
+    return not normalized or normalized == "todo/path" or normalized.startswith("todo/")
+
+
+def is_executable_codecgc_block(codecgc: Any) -> bool:
+    if not isinstance(codecgc, dict):
+        return False
+
+    kind = str(codecgc.get("kind", "")).strip().lower()
+    if kind not in {"frontend", "backend"}:
+        return False
+
+    target_paths = codecgc.get("target_paths", [])
+    if not isinstance(target_paths, list) or not target_paths:
+        return False
+
+    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)
+
+
+def is_test_codecgc_block(codecgc: Any) -> bool:
+    if not is_executable_codecgc_block(codecgc):
+        return False
+    return str(codecgc.get("step_type", "")).strip().lower() == "test"
+
+
+def select_next_executable_step(checklist_path: Path) -> dict[str, Any]:
+    data = load_checklist_yaml(checklist_path)
+    steps = data.get("steps", [])
+    if not isinstance(steps, list) or not steps:
+        raise ValueError("Checklist does not contain any steps.")
+
+    first_planning_index: int | None = None
+    first_executable_index: int | None = None
+
+    for index, step in enumerate(steps, start=1):
+        if not isinstance(step, dict):
+            continue
+        status = str(step.get("status", "pending")).strip().lower()
+        if status not in {"pending", ""}:
+            continue
+
+        codecgc = step.get("codecgc")
+        if is_executable_codecgc_block(codecgc):
+            if first_executable_index is None:
+                first_executable_index = index
+            continue
+
+        if first_planning_index is None:
+            first_planning_index = index
+
+    if first_planning_index is not None:
+        step = steps[first_planning_index - 1]
+        raise ValueError(
+            f"Planning-only step {first_planning_index} must be resolved before execution: "
+            f"{step.get('action', 'unknown action')}"
+        )
+
+    if first_executable_index is None:
+        raise ValueError("No pending executable step remains in this checklist.")
+
+    step = steps[first_executable_index - 1]
+    codecgc = step.get("codecgc", {})
+    return {
+        "step_number": first_executable_index,
+        "task_id": str(codecgc.get("task_id", "")),
+        "action": str(step.get("action", "")),
+        "kind": str(codecgc.get("kind", "")),
+        "target_paths": codecgc.get("target_paths", []),
+        "task_summary": str(codecgc.get("task_summary", "")),
+        "artifact_type": resolve_artifact_type(data),
+        "timeout_seconds": int(codecgc.get("timeout_seconds", 0)) or 0,
+    }
+
+
+def get_step_metadata(checklist_path: Path, step_number: int) -> dict[str, Any]:
+    data = load_checklist_yaml(checklist_path)
+    steps = data.get("steps", [])
+    if not isinstance(steps, list) or step_number < 1 or step_number > len(steps):
+        raise ValueError(f"Step number must be between 1 and {len(steps)}.")
+    step = steps[step_number - 1]
+    codecgc = step.get("codecgc", {}) if isinstance(step, dict) else {}
+    executable = is_executable_codecgc_block(codecgc)
+    return {
+        "step_number": step_number,
+        "task_id": str(codecgc.get("task_id", "")),
+        "action": str(step.get("action", "")) if isinstance(step, dict) else "",
+        "kind": str(codecgc.get("kind", "")),
+        "target_paths": codecgc.get("target_paths", []),
+        "task_summary": str(codecgc.get("task_summary", "")),
+        "artifact_type": resolve_artifact_type(data),
+        "executable": executable,
+        "timeout_seconds": int(codecgc.get("timeout_seconds", 0)) or 0,
+    }
+
+
+def replace_step_status(text: str, step_number: int, new_status: str) -> str:
+    lines = text.splitlines()
+    current_step = 0
+    inside_steps = False
+    current_step_indent = ""
+
+    for index, line in enumerate(lines):
+        stripped = line.strip()
+        if stripped == "steps:":
+            inside_steps = True
+            continue
+
+        if inside_steps and not line.startswith(" "):
+            break
+
+        if inside_steps and line.startswith("  - "):
+            current_step += 1
+            current_step_indent = line[: len(line) - len(line.lstrip(" "))]
+            continue
+
+        if (
+            inside_steps
+            and current_step == step_number
+            and stripped.startswith("status:")
+            and line.startswith(f"{current_step_indent}  ")
+        ):
+            indent = line[: len(line) - len(line.lstrip(" "))]
+            lines[index] = f"{indent}status: {new_status}"
+            return "\n".join(lines) + ("\n" if text.endswith("\n") else "")
+
+    raise ValueError(f"Could not find status field for step {step_number}.")
+
+
+def update_step_status(checklist_path: Path, step_number: int, new_status: str) -> None:
+    original = checklist_path.read_text(encoding="utf-8")
+    updated = replace_step_status(original, step_number, new_status)
+    checklist_path.write_text(updated, encoding="utf-8")

package/scripts/codecgc_workflow_runtime.py

@@ -0,0 +1,63 @@
+import json
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+from codecgc_runtime_paths import PACKAGE_ROOT
+from codecgc_runtime_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)
+    completed = subprocess.run(
+        command,
+        cwd=PROJECT_WORKSPACE,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+
+    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}.",
+    }