@hunyed15/codecgc 0.1.0

package/scripts/codecgc_flow_control.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+from typing import Any
+
+from codecgc_command_surface import matches_command
+from codecgc_command_surface import to_public_command
+
+
+def extract_execution_result(execution: dict[str, Any]) -> dict[str, Any]:
+    result = execution.get("result", {}) if isinstance(execution, dict) else {}
+    if not isinstance(result, dict):
+        return {}
+    nested = result.get("result")
+    if isinstance(nested, dict):
+        return nested
+    return result
+
+
+def execution_is_ready_for_review(execution: dict[str, Any]) -> bool:
+    if not bool(execution.get("success")):
+        return False
+
+    mode = str(execution.get("mode", "")).strip().lower()
+    result = extract_execution_result(execution)
+    policy_checks = result.get("policy_checks", [])
+    risks = result.get("risks", [])
+    if not isinstance(policy_checks, list):
+        policy_checks = []
+    if not isinstance(risks, list):
+        risks = []
+
+    return (
+        mode != "dry-run"
+        and "dry_run_only" not in {str(item) for item in policy_checks}
+        and "execution_not_performed" not in {str(item) for item in risks}
+        and bool(result.get("success"))
+        and str(result.get("outcome", "")).strip().lower() == "done"
+    )
+
+
+def build_not_ready_result(flow: str, slug: str, route: dict[str, Any], expected_command: str) -> dict[str, Any]:
+    public_expected_command = to_public_command(expected_command)
+    flow_label = "测试执行" if expected_command == "cgc-test" else "功能开发" if flow == "feature" else "问题修复" if flow == "issue" else "当前"
+    result = {
+        "success": False,
+        "flow": flow,
+        "slug": slug,
+        "state": "not-ready",
+        "failure_type": "workflow-state",
+        "route": route,
+        "error": f"{flow_label}工作流当前还未满足 {public_expected_command} 的执行条件。",
+        "recommended_command": to_public_command(route.get("recommended_command", "cgc-plan")),
+        "next": route.get("next", "请先修复当前工作流产物与状态，再继续执行。"),
+    }
+    split_suggestion = route.get("split_suggestion", {}) if isinstance(route.get("split_suggestion"), dict) else {}
+    replan_payload = route.get("replan_payload", {}) if isinstance(route.get("replan_payload"), dict) else {}
+    if split_suggestion:
+        result["split_suggestion"] = split_suggestion
+    if replan_payload:
+        result["replan_payload"] = replan_payload
+    return result
+
+
+def classify_execution_failure(execution: dict[str, Any]) -> tuple[str, str, str, str]:
+    result = extract_execution_result(execution)
+    outcome = str(result.get("outcome", "")).strip().lower()
+    error_text = str(result.get("error", "") or execution.get("error", "")).strip()
+    summary_text = str(result.get("summary", "")).strip()
+    combined = f"{outcome}\n{error_text}\n{summary_text}".lower()
+    target_missing_markers = [
+        "target file path does not exist",
+        "target directory path does not exist",
+        "does not exist in the current workspace",
+        "current workspace",
+        "当前工作区中不存在目标文件",
+        "目标文件路径在当前工作区下不存在",
+        "在当前工作区里不存在",
+        "工作区里没有",
+        "目标文件路径在当前工作区里对不上",
+        "目标文件缺失",
+        "没有可实施对象",
+        "目标文件本身缺失",
+        "提供正确文件路径",
+        "恢复到工作区",
+    ]
+
+    if outcome == "split-required" or "split the task first" in combined:
+        return (
+            "returned-to-planning",
+            "scope-error",
+            "cgc-plan",
+            "请先按执行器归属或路径范围拆分当前步骤，再重新生成更窄的可执行契约。",
+        )
+
+    if outcome == "design-gap" or "not covered by model-routing.yaml" in combined:
+        return (
+            "returned-to-planning",
+            "design-gap",
+            "cgc-plan",
+            "请先修正路由规则、目标路径或步骤契约，再重新尝试执行。",
+        )
+
+    if any(marker in combined for marker in target_missing_markers):
+        return (
+            "returned-to-planning",
+            "design-gap",
+            "cgc-plan",
+            "当前步骤引用的目标路径在工作区中不存在，请先回到 cgc-plan 修正目标路径或步骤契约。",
+        )
+
+    if outcome == "blocked" or "timeout" in combined or "does not exist" in combined:
+        return (
+            "blocked",
+            "environment-or-tooling",
+            "",
+            "请先修复缺失产物、执行器环境或超时条件，再重试当前步骤。",
+        )
+
+    return (
+        "blocked",
+        "executor-failure",
+        "",
+        "请先检查审计产物和执行器输出，修复执行器侧失败后再重试。",
+    )
+
+
+def build_split_scope_replan_payload(flow: str, slug: str, execution: dict[str, Any]) -> dict[str, Any]:
+    result = extract_execution_result(execution)
+    split_suggestion = result.get("split_suggestion", {}) if isinstance(result.get("split_suggestion"), dict) else {}
+    if not split_suggestion:
+        return {}
+
+    grouped_paths = split_suggestion.get("grouped_paths", {}) if isinstance(split_suggestion.get("grouped_paths"), dict) else {}
+    path_classification = split_suggestion.get("path_classification", {}) if isinstance(split_suggestion.get("path_classification"), dict) else {}
+    suggested_steps = split_suggestion.get("suggested_split_steps", []) if isinstance(split_suggestion.get("suggested_split_steps"), list) else []
+
+    payload: dict[str, Any] = {
+        "flow": flow,
+        "slug": slug,
+        "kind": "auto",
+        "split_scope": True,
+        "path_classification": path_classification,
+        "grouped_paths": grouped_paths,
+        "suggested_split_steps": suggested_steps,
+    }
+
+    combined_paths: list[str] = []
+    for key in ("frontend", "backend", "shared"):
+        value = grouped_paths.get(key, [])
+        if isinstance(value, list):
+            combined_paths.extend(str(item).strip() for item in value if str(item).strip())
+    if combined_paths:
+        payload["target_paths"] = combined_paths
+
+    in_scope: list[str] = []
+    for item in suggested_steps:
+        if not isinstance(item, dict):
+            continue
+        kind = str(item.get("kind", "")).strip()
+        paths = [str(path).strip() for path in item.get("target_paths", []) if str(path).strip()]
+        if not paths:
+            continue
+        if kind == "planning":
+            in_scope.append(f"先拆分 shared 路径：{', '.join(paths)}。")
+        else:
+            in_scope.append(f"将 {kind} 范围拆成独立步骤：{', '.join(paths)}。")
+    if in_scope:
+        payload["in_scope"] = in_scope
+
+    return payload
+
+
+def build_execution_result(
+    *,
+    flow: str,
+    slug: str,
+    route: dict[str, Any],
+    execution: dict[str, Any],
+) -> dict[str, Any]:
+    success = bool(execution.get("success"))
+    audit = execution.get("audit", {}) if isinstance(execution, dict) else {}
+    audit_path = audit.get("path", "") if isinstance(audit, dict) else ""
+    result = extract_execution_result(execution)
+
+    if execution_is_ready_for_review(execution):
+        return {
+            "success": True,
+            "flow": flow,
+            "slug": slug,
+            "state": "ready-for-review",
+            "failure_type": "",
+            "route": route,
+            "execution": execution,
+            "audit_path": audit_path,
+            "recommended_command": to_public_command("cgc-review"),
+            "next": "请检查执行审计结果，并写回通过或修复决策。",
+            "summary": result.get("summary", ""),
+        }
+
+    if success:
+        retry_command = "cgc-test" if matches_command(str(route.get("recommended_command", "")).strip(), "cgc-test") else f"cgc-{'build' if flow == 'feature' else 'fix'}"
+        return {
+            "success": False,
+            "flow": flow,
+            "slug": slug,
+            "state": "executed-dry-run",
+            "failure_type": "workflow-state",
+            "route": route,
+            "execution": execution,
+            "audit_path": audit_path,
+            "recommended_command": to_public_command(retry_command),
+            "next": "请去掉 --dry-run 后重新执行同一步骤，再发起审核。",
+            "summary": result.get("summary", ""),
+            "error": "",
+        }
+
+    state, failure_type, recommended_command, next_step = classify_execution_failure(execution)
+    return {
+        "success": False,
+        "flow": flow,
+        "slug": slug,
+        "state": state,
+        "failure_type": failure_type,
+        "route": route,
+        "execution": execution,
+        "audit_path": audit_path,
+        "recommended_command": to_public_command(recommended_command),
+        "next": next_step,
+        "summary": result.get("summary", ""),
+        "error": result.get("error", "") or execution.get("error", ""),
+        "split_suggestion": result.get("split_suggestion", {}),
+        "replan_payload": build_split_scope_replan_payload(flow, slug, execution) if failure_type == "scope-error" else {},
+    }

package/scripts/codecgc_governance_dedupe.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import re
+from collections import Counter
+
+
+STOPWORDS = {
+    "a",
+    "an",
+    "and",
+    "as",
+    "at",
+    "be",
+    "for",
+    "from",
+    "in",
+    "is",
+    "of",
+    "on",
+    "or",
+    "the",
+    "to",
+    "use",
+    "using",
+    "with",
+    "将其",
+    "这条",
+    "一个",
+    "一种",
+    "作为",
+    "写入",
+    "记录",
+    "更新",
+    "默认",
+    "需要",
+    "当前",
+    "长期",
+    "治理",
+    "资产",
+    "说明",
+    "补充",
+    "继续",
+    "用于",
+    "后续",
+    "帮助",
+    "统一",
+    "暴露",
+    "输出",
+    "命令面",
+}
+
+
+def normalize_text(value: str) -> str:
+    text = str(value or "").strip().lower()
+    if not text:
+        return ""
+    text = text.replace("`", "")
+    replacements = {
+        "只暴露": "唯一对外",
+        "只使用": "统一使用",
+        "命令面": "命令",
+        "输出链路": "输出",
+        "使用 utf 8": "utf8",
+        "utf-8": "utf8",
+        "utf 8": "utf8",
+    }
+    for old, new in replacements.items():
+        text = text.replace(old, new)
+    text = re.sub(r"[^\w\u4e00-\u9fff]+", " ", text, flags=re.UNICODE)
+    return re.sub(r"\s+", " ", text).strip()
+
+
+def tokenize(value: str) -> list[str]:
+    normalized = normalize_text(value)
+    if not normalized:
+        return []
+
+    tokens: list[str] = []
+    for part in normalized.split():
+        if not part or part in STOPWORDS:
+            continue
+        if re.fullmatch(r"[\u4e00-\u9fff]+", part):
+            if len(part) <= 2:
+                tokens.append(part)
+            else:
+                tokens.extend([part[index : index + 2] for index in range(len(part) - 1)])
+            continue
+        if len(part) <= 1:
+            continue
+        tokens.append(part)
+    return tokens
+
+
+def extract_entry_summaries(existing: str, field_labels: list[str]) -> list[str]:
+    lines = str(existing or "").splitlines()
+    summaries: list[str] = []
+    for line in lines:
+        stripped = line.strip()
+        if stripped.startswith("### "):
+            heading = stripped[4:].strip()
+            if heading:
+                summaries.append(heading)
+            continue
+        for label in field_labels:
+            marker = f"- {label}:"
+            if stripped.startswith(marker):
+                value = stripped[len(marker) :].strip()
+                if value:
+                    summaries.append(value)
+    seen: set[str] = set()
+    unique: list[str] = []
+    for item in summaries:
+        key = normalize_text(item)
+        if not key or key in seen:
+            continue
+        seen.add(key)
+        unique.append(item.strip())
+    return unique
+
+
+def is_semantically_duplicate(candidate: str, existing_items: list[str], *, threshold: float = 0.72) -> bool:
+    candidate_tokens = tokenize(candidate)
+    if not candidate_tokens:
+        return False
+
+    candidate_counter = Counter(candidate_tokens)
+    candidate_set = set(candidate_counter)
+    candidate_normalized = normalize_text(candidate)
+
+    for item in existing_items:
+        item_normalized = normalize_text(item)
+        if not item_normalized:
+            continue
+        if item_normalized == candidate_normalized:
+            return True
+
+        item_tokens = tokenize(item)
+        if not item_tokens:
+            continue
+        item_counter = Counter(item_tokens)
+        item_set = set(item_counter)
+        overlap = candidate_set & item_set
+        if not overlap:
+            continue
+
+        overlap_count = sum(min(candidate_counter[token], item_counter[token]) for token in overlap)
+        similarity = overlap_count / max(len(candidate_tokens), len(item_tokens))
+        coverage = len(overlap) / max(1, min(len(candidate_set), len(item_set)))
+        candidate_normalized_words = set(normalize_text(candidate).split())
+        item_normalized_words = set(item_normalized.split())
+        word_overlap = candidate_normalized_words & item_normalized_words
+        word_coverage = len(word_overlap) / max(1, min(len(candidate_normalized_words), len(item_normalized_words)))
+        if similarity >= threshold or (similarity >= 0.58 and coverage >= 0.8) or (similarity >= 0.42 and word_coverage >= 0.6):
+            return True
+
+    return False
+
+
+def has_existing_governance_entry(existing: str, summary: str, *, field_labels: list[str], threshold: float = 0.72) -> bool:
+    summaries = extract_entry_summaries(existing, field_labels)
+    return is_semantically_duplicate(summary, summaries, threshold=threshold)

package/scripts/codecgc_plan_decision.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from typing import Any
+
+from codecgc_command_surface import to_public_command
+
+
+def evaluate_plan_decision(
+    *,
+    flow: str,
+    grouped_paths: dict[str, list[str]],
+    target_paths: list[str],
+    executable_steps: int,
+    planning_only_steps: int,
+    goal: str,
+    user_story: str,
+    symptom: str,
+    expected: str,
+    actual: str,
+    in_scope: list[str],
+    acceptance: list[str],
+) -> dict[str, Any]:
+    clarification_reasons: list[str] = []
+    roadmap_reasons: list[str] = []
+    missing_fields: list[str] = []
+
+    if not target_paths:
+        clarification_reasons.append("尚未提供目标路径。")
+        missing_fields.append("target_paths")
+
+    if grouped_paths.get("unknown"):
+        clarification_reasons.append("部分目标路径尚未被 model-routing.yaml 覆盖。")
+        missing_fields.append("routing_coverage")
+
+    if planning_only_steps > 0:
+        clarification_reasons.append("在执行开始前，仍有仅规划 step 需要先处理。")
+        missing_fields.append("planning_blockers")
+
+    if executable_steps < 1:
+        clarification_reasons.append("当前还没有准备好可执行的单归属 step。")
+        missing_fields.append("executable_step")
+
+    if flow == "feature":
+        if not goal.strip():
+            clarification_reasons.append("功能目标仍未补齐。")
+            missing_fields.append("goal")
+        if not user_story.strip():
+            clarification_reasons.append("用户故事仍未补齐。")
+            missing_fields.append("user_story")
+    else:
+        if not symptom.strip():
+            clarification_reasons.append("问题现象仍未补齐。")
+            missing_fields.append("symptom")
+        if not expected.strip():
+            clarification_reasons.append("预期行为仍未补齐。")
+            missing_fields.append("expected")
+        if not actual.strip():
+            clarification_reasons.append("实际行为仍未补齐。")
+            missing_fields.append("actual")
+
+    if not in_scope:
+        clarification_reasons.append("范围内行为仍不明确。")
+        missing_fields.append("in_scope")
+
+    if not acceptance:
+        clarification_reasons.append("验收条件仍未补齐。")
+        missing_fields.append("acceptance")
+
+    if executable_steps >= 3:
+        roadmap_reasons.append("当前计划已经跨越 3 个或以上可执行 step。")
+
+    if len(target_paths) >= 6:
+        roadmap_reasons.append("当前计划涉及的目标路径过多，已经超出单个 feature 级流转的合理范围。")
+
+    if grouped_paths.get("frontend") and grouped_paths.get("backend") and planning_only_steps > 0:
+        roadmap_reasons.append("跨前后端边界的工作仍需要更高层级的拆分。")
+
+    if roadmap_reasons:
+        return {
+            "planning_status": "needs-roadmap",
+            "recommended_command": to_public_command("cgc-plan"),
+            "next": "需要先在 roadmap 层完成拆分，再继续进入可执行的 feature 或 issue step。",
+            "reasons": roadmap_reasons,
+            "missing_fields": [],
+        }
+
+    if clarification_reasons:
+        return {
+            "planning_status": "needs-clarification",
+            "recommended_command": to_public_command("cgc-plan"),
+            "next": "需要先补齐缺失的规划信息，或先解决仅规划阻塞项，再进入执行。",
+            "reasons": clarification_reasons,
+            "missing_fields": missing_fields,
+        }
+
+    ready_command = "cgc-build" if flow == "feature" else "cgc-fix"
+    return {
+        "planning_status": "ready-for-build" if flow == "feature" else "ready-for-fix",
+        "recommended_command": to_public_command(ready_command),
+        "next": "当前待执行 step 已满足委派执行条件。",
+        "reasons": ["当前规划信息与 step 归属已经足以进入执行。"],
+        "missing_fields": [],
+    }