@michaelxwb/code-flow 0.6.5 → 1.0.0

package/src/core/code-flow/config.yml

@@ -1,158 +0,0 @@
-version: 1
-
-spec_workflow:
-    schema_version: 1
-    enforcement: required  # required=全门禁 | warn=门禁仅记录不阻断 | inject=只注入不门禁
-    drift_check: true
-    scope_expansion_check: true
-    metrics: true
-    catalog:
-        dedup_window: 5
-
-budget:
-    total: 2500
-    l0_max: 800
-    l1_max: 1700
-    map_max: 400
-    # catalog 模式下 spec 目录的 token 上限（超出按 Tier1 优先截断并告警）
-    catalog_max: 200
-
-# 质量闭环（v0.5）：合规反馈 + 学习采集。
-# enabled 仅 literal true 启用（缺失即关闭，升级用户行为不变）；
-# 子开关缺省跟随 enabled，仅 literal false 单独关闭。
-# 数据仅存本地 .code-flow/（.session-log.jsonl / .check-state.json）。
-quality_loop:
-    enabled: true
-    post_check: true            # PostToolUse 违规反馈（只提示不阻断）
-    stop_check: true            # Stop 收尾按 validation.yml 校验（heavy 项跳过）
-    finish_check: true          # 任务 finish 时全量执行 validation.yml（含 heavy，每任务一次）
-    correction_capture: true    # 纠正句式采集（喂 cf-learn 候选）
-    # 注入时对 spec 内容做保守无损压缩（去行尾空白、折叠多空行、剥 HTML 注释、去重 bullet）
-    # 缺省视为 true；仅显式 false 关闭
-    compress: true
-    compress_reminder: true     # 会话过长每 N 轮提醒 /compact（per-session 计数，缺省 true）
-    code_extensions:
-        - ".py"
-        - ".ts"
-        - ".tsx"
-        - ".js"
-        - ".jsx"
-        - ".go"
-        - ".java"
-        - ".rs"
-        - ".rb"
-        - ".vue"
-        - ".svelte"
-    skip_extensions:
-        - ".md"
-        - ".txt"
-        - ".json"
-        - ".yml"
-        - ".yaml"
-        - ".toml"
-        - ".lock"
-        - ".csv"
-        - ".xml"
-        - ".svg"
-        - ".png"
-        - ".jpg"
-        - ".jpeg"
-        - ".gif"
-        - ".ico"
-        - ".pdf"
-        - ".zip"
-        - ".gz"
-        - ".tar"
-    skip_paths:
-        - "docs/**"
-        - "*.config.*"
-        - ".code-flow/**"
-        - ".claude/**"
-        - ".codex/**"
-        - ".costrict/**"
-        - ".opencode/**"
-        - "node_modules/**"
-        - "dist/**"
-        - "build/**"
-        - "out/**"
-        - "coverage/**"
-        - ".next/**"
-        - ".cache/**"
-        - ".venv/**"
-        - "venv/**"
-        - "__pycache__/**"
-        - ".git/**"
-
-path_mapping:
-    shared:
-        # 共享模板供 cf-task:align / cf-task:prd 命令显式 Read 使用，
-        # 不是约束规范，禁止通配符自动注入。
-        # 仅 _map.md 保持 "*" 作为 Tier 0 导航。
-        specs:
-            - path: "shared/_map.md"
-              tags: ["*"]
-              tier: 0
-            - path: "shared/prd-template.md"
-              tags: []          # 永不自动注入，仅 cf-task:prd 命令显式 Read
-              tier: 1
-            - path: "shared/design/design-lite.md"
-              tags: []          # 永不自动注入，仅 cf-task:align 命令显式 Read
-              tier: 1
-            - path: "shared/design/design-full.md"
-              tags: []          # 永不自动注入，仅 cf-task:align 命令显式 Read
-              tier: 1
-            - path: "shared/design/design-frontend.md"
-              tags: []          # 永不自动注入，仅 cf-task:align 命令显式 Read（前端设计模板）
-              tier: 1
-    frontend:
-        patterns:
-            - "src/components/**"
-            - "src/pages/**"
-            - "src/hooks/**"
-            - "src/composables/**"
-            - "src/services/**"
-            - "src/styles/**"
-            - "**/*.tsx"
-            - "**/*.jsx"
-            - "**/*.css"
-            - "**/*.scss"
-        specs:
-            - path: "frontend/_map.md"
-              tags: ["*"]
-              tier: 0
-            - path: "frontend/directory-structure.md"
-              tags: ["directory", "structure", "folder", "route", "page", "layout"]
-              tier: 1
-            - path: "frontend/quality-standards.md"
-              tags: ["quality", "type", "lint", "error", "test", "state", "strict"]
-              tier: 1
-            - path: "frontend/component-specs.md"
-              tags: ["component", "prop", "hook", "render", "ui", "style"]
-              tier: 1
-    backend:
-        patterns:
-            - "services/**"
-            - "api/**"
-            - "models/**"
-            - "*.py"
-            - "**/*.py"
-            - "**/*.go"
-        specs:
-            - path: "backend/_map.md"
-              tags: ["*"]
-              tier: 0
-            - path: "backend/directory-structure.md"
-              tags: ["directory", "structure", "folder", "module", "layout"]
-              tier: 1
-            - path: "backend/logging.md"
-              tags: ["log", "logging", "debug", "trace", "monitor", "observe"]
-              tier: 1
-            - path: "backend/database.md"
-              tags: ["database", "db", "sql", "orm", "model", "migration", "query", "table", "schema"]
-              tier: 1
-            - path: "backend/platform-rules.md"
-              tags: ["api", "deploy", "config", "version", "compatibility", "release", "flag"]
-              tier: 1
-            - path: "backend/code-quality-performance.md"
-              tags: ["quality", "performance", "error", "exception", "test", "timeout", "retry", "cache"]
-              tier: 1

package/src/core/code-flow/scripts/cf_acceptance_evidence.py

@@ -1,100 +0,0 @@
-"""Append execution history without erasing the user's acceptance contract."""
-from __future__ import annotations
-
-import json
-import re
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Mapping, Sequence
-from uuid import uuid4
-
-STATES = frozenset(("planned", "pending", "tbd", "verified", "unverified", "failed", "incomplete", "not_configured", "e2e_deferred", "manual_pending"))
-
-
-def scenario_line(line: str, scenario_id: str) -> bool:
-    return bool(re.match(rf"^\s*(?:\|\s*|[-*]\s+){re.escape(scenario_id)}(?=\s*[:|])", line))
-
-
-def line_status(line: str, scenario_id: str) -> str:
-    if not scenario_line(line, scenario_id):
-        return ""
-    if line.lstrip().startswith("|"):
-        cells = [cell.strip().lower() for cell in line.strip().strip("|").split("|")]
-        return next((cell for cell in reversed(cells) if cell in STATES), "")
-    match = re.match(r"^\s*[-*]\s+[^:]+:\s*([a-z0-9_]+)\b", line, re.I)
-    return match.group(1).lower() if match and match.group(1).lower() in STATES else ""
-
-
-def _status_line(line: str, scenario_id: str, status: str) -> str:
-    if not scenario_line(line, scenario_id):
-        return line
-    if line.lstrip().startswith("|"):
-        cells = line.split("|")
-        for index in range(len(cells) - 1, 0, -1):
-            if cells[index].strip().lower() in STATES:
-                cells[index] = f" {status} "
-                return "|".join(cells)
-        return line.rstrip().rstrip("|") + f"| {status} |"
-    prefix = r"(^\s*[-*]\s+[^:]+:\s*)"
-    if line_status(line, scenario_id):
-        return re.sub(prefix + r"(?:" + "|".join(sorted(STATES)) + r")\b", rf"\g<1>{status}", line, count=1, flags=re.I)
-    return re.sub(prefix, rf"\g<1>{status} — ", line, count=1)
-
-
-def _patch_section(section: str, scenario_id: str, status: str, record: str) -> str:
-    contract = re.search(r"(?ms)^### Acceptance Contract[^\n]*\n(.*?)(?=^### |^## |\Z)", section)
-    if contract:
-        body = "\n".join(_status_line(line, scenario_id, status) for line in contract.group(1).splitlines()) + "\n"
-        section = section[:contract.start(1)] + body + section[contract.end(1):]
-    evidence = re.search(r"(?ms)^### Acceptance Evidence[^\n]*\n(.*?)(?=^### |^## |\Z)", section)
-    if evidence:
-        body = evidence.group(1)
-        if record not in body.splitlines():
-            body = body.rstrip() + "\n" + record + "\n\n"
-        section = section[:evidence.start(1)] + body + section[evidence.end(1):]
-    else:
-        section = section.rstrip() + "\n\n### Acceptance Evidence\n" + record + "\n"
-    return section
-
-
-def sync_task_evidence(task: Path, scenario_id: str, confirmed_by: str, evidence: str, owner: str = "", status: str = "verified") -> None:
-    text = task.read_text(encoding="utf-8")
-    task_pattern = re.escape(owner) if owner else r"TASK-\d+"
-    match = re.search(rf"(?ms)^##\s+{task_pattern}:.*?(?=^## |\Z)", text)
-    if match is None:
-        raise ValueError(f"acceptance owner missing: {owner}")
-    record = f"- {scenario_id}: {status} — {evidence} (confirmed_by: {confirmed_by})"
-    section = _patch_section(match.group(0), scenario_id, status, record)
-    text = text[:match.start()] + section + text[match.end():]
-    coverage = re.search(r"(?ms)^## Acceptance Coverage[^\n]*\n(.*?)(?=^## |\Z)", text)
-    if coverage:
-        body = "\n".join(_status_line(line, scenario_id, status) for line in coverage.group(1).splitlines()) + "\n"
-        text = text[:coverage.start(1)] + body + text[coverage.end(1):]
-    from cf_spec_context import _atomic_text
-    _atomic_text(task, text)
-
-
-def persist_results(path: Path, data: dict[str, object], results: Sequence[Mapping[str, object]]) -> None:
-    rows = {row["id"]: row for row in data["scenarios"]}
-    run_id, executed_at = uuid4().hex, datetime.now(timezone.utc).isoformat()
-    updates = []
-    for result in results:
-        state = str(result["status"])
-        if state in ("not_included", "manual_pending"):
-            continue
-        row = rows[result["id"]]
-        row["revision"] = int(row.get("revision", 0)) + 1
-        status = "verified" if state == "passed" else state
-        row["status"] = status
-        record = {**result, "revision": row["revision"], "run_id": run_id, "executed_at": executed_at}
-        row["evidence"] = record
-        row.setdefault("runs", []).append(record)
-        updates.append((row, record, status))
-    from cf_spec_context import _atomic_text
-    _atomic_text(path, json.dumps(data, ensure_ascii=False, indent=2) + "\n")
-    task_name = data.get("task_file")
-    if isinstance(task_name, str) and task_name:
-        task = Path(task_name) if Path(task_name).is_absolute() else path.parent / task_name
-        for row, record, status in updates:
-            detail = f"automated command {record['status']}; run_id={run_id}"
-            sync_task_evidence(task, str(row["id"]), "runner", detail, str(row.get("owner", "")), status)

package/src/core/code-flow/scripts/cf_acceptance_manifest.py

@@ -1,294 +0,0 @@
-#!/usr/bin/env python3
-"""Lock and validate plan Acceptance Coverage entries."""
-
-from __future__ import annotations
-
-import argparse
-import hashlib
-import json
-import shlex
-from pathlib import Path
-import re
-import sys
-from typing import IO, Callable, Mapping, Optional, Sequence
-
-from cf_acceptance_schema import load_manifest, validate_scenarios
-
-
-_ROW_RE = re.compile(r"^\|\s*([SEB]-\d+)\s*\|(.+?)\|$")
-
-_MANIFEST_SCHEMA = 2
-
-
-def _kind(level: str) -> str:
-    """Map test level to execution kind.
-
-    - functional: auto-executed in Done Gate (unit, integration)
-    - e2e: deferred until explicit --verify-e2e (needs external dependencies)
-    - manual: user confirmation required, never auto-executed
-
-    层级单元格允许带注解（如 `E2E（Playwright）`、`e2e/chrome`、`manual(chrome)`），
-    取分隔符前的词元判定；避免带注解的 E2E 被误判为 functional 而每任务执行。
-    """
-    head = level.strip().lower()
-    for separator in ("(", "（", "[", "/", ",", "，", " ", "—", "-"):
-        head = head.split(separator, 1)[0]
-    head = head.strip()
-    if head in ("manual", "手工", "手动"):
-        return "manual"
-    if head in ("e2e", "端到端", "end"):
-        return "e2e"
-    return "functional"
-
-
-def _parse_command(cell: str, scenario_id: str) -> Optional[list[str]]:
-    """Parse the optional 命令 column: argv JSON array preferred, else shell words.
-
-    Empty / `-` / `planned` → None (not yet registered, not executable).
-    """
-    text = (cell or "").strip()
-    if not text or text in {"-", "planned", "pending", "TBD", "tbd"}:
-        return None
-    if text.startswith("["):
-        try:
-            value = json.loads(text)
-        except json.JSONDecodeError as exc:
-            raise ValueError(f"{scenario_id} 命令列不是合法 argv JSON: {exc}") from exc
-        if not isinstance(value, list) or not value or not all(isinstance(item, str) for item in value):
-            raise ValueError(f"{scenario_id} 命令列必须是 argv 字符串数组")
-        return list(value)
-    return shlex.split(text)
-
-
-def _parse_float(cell: str, default: float) -> float:
-    try:
-        return float((cell or "").strip() or default)
-    except (TypeError, ValueError):
-        return default
-
-
-def _manifest_hash(rows: list[dict[str, object]]) -> str:
-    immutable = [
-        {key: item[key] for key in ("id", "source", "level", "kind", "boundary", "owner", "command", "cwd", "timeout", "depends_on")}
-        for item in rows
-    ]
-    payload = json.dumps(immutable, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")
-    return hashlib.sha256(payload).hexdigest()
-
-
-def _legacy_kind(level: str) -> str:
-    """v1 精确匹配：仅用于识别旧版锁定的 manifest，不做新语义判定。"""
-    normalized = level.strip().lower()
-    if normalized == "manual":
-        return "manual"
-    if normalized == "e2e":
-        return "e2e"
-    return "functional"
-
-
-def _extract_rows(task_file: str, kind_fn: Callable[[str], str]) -> dict[str, object]:
-    path = Path(task_file)
-    text = path.read_text(encoding="utf-8")
-    rows: list[dict[str, object]] = []
-    in_table = False
-    seen: set[str] = set()
-    for line in text.splitlines():
-        if line.startswith("## Acceptance Coverage"):
-            in_table = True
-            continue
-        if in_table and line.startswith("## "):
-            break
-        if not in_table:
-            continue
-        match = _ROW_RE.match(line)
-        if not match or set(match.group(2).replace("|", "").strip()) <= {"-", " "}:
-            continue
-        fields = [item.strip() for item in match.group(2).split("|")]
-        if match.group(1) in seen:
-            raise ValueError(f"duplicate scenario id: {match.group(1)}")
-        if len(fields) < 5:
-            raise ValueError(f"Acceptance Coverage missing columns: {match.group(1)}")
-        seen.add(match.group(1))
-        depends = [item.strip() for item in (fields[8] if len(fields) > 8 else "").split(",") if item.strip()]
-        rows.append({
-            "id": match.group(1),
-            "source": fields[0],
-            "level": fields[1],
-            "kind": kind_fn(fields[1]),
-            "boundary": fields[2],
-            "owner": fields[3],
-            "status": fields[4],
-            "command": _parse_command(fields[5], match.group(1)) if len(fields) > 5 else None,
-            "cwd": (fields[6] if len(fields) > 6 else "").strip() or ".",
-            "timeout": _parse_float(fields[7], 60.0) if len(fields) > 7 else 60.0,
-            "depends_on": depends,
-        })
-    if not rows:
-        raise ValueError("Acceptance Coverage 缺失或为空")
-    validate_scenarios(rows)
-    return {"schema": _MANIFEST_SCHEMA, "task_file": str(path), "task_sha256": _manifest_hash(rows), "scenarios": rows}
-
-
-def extract_manifest(task_file: str, kind_fn: Callable[[str], str] = _kind) -> dict[str, object]:
-    return _extract_rows(task_file, kind_fn)
-
-
-def write_manifest(task_file: str, output: str) -> dict[str, object]:
-    manifest = extract_manifest(task_file)
-    target = Path(output)
-    try:
-        manifest["task_file"] = str(Path(task_file).resolve().relative_to(target.parent.resolve()))
-    except ValueError:
-        manifest["task_file"] = str(Path(task_file).resolve())
-    target.parent.mkdir(parents=True, exist_ok=True)
-    target.write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
-    return manifest
-
-
-_IMMUTABLE_SCENARIO_FIELDS = (
-    "id", "source", "level", "kind", "boundary", "owner", "command", "cwd", "timeout", "depends_on",
-)
-
-
-def _heal_legacy_kinds(manifest_file: Path, manifest: dict[str, object], expected: dict[str, object]) -> None:
-    """旧版 `_kind` 精确匹配把带注解的 E2E 锁成 functional；任务内容未变时
-    原地升级 kind 并重锁哈希，保留 execution evidence 等运行态字段。"""
-    by_id: dict[str, dict[str, object]] = {}
-    scenarios = expected.get("scenarios")
-    if isinstance(scenarios, list):
-        for item in scenarios:
-            if isinstance(item, dict) and isinstance(item.get("id"), str):
-                by_id[item["id"]] = item
-    current = manifest.get("scenarios")
-    if isinstance(current, list):
-        for item in current:
-            if not isinstance(item, dict):
-                continue
-            target = by_id.get(item.get("id")) if isinstance(item.get("id"), str) else None
-            if target is not None:
-                item["kind"] = target.get("kind")
-    manifest["task_sha256"] = expected["task_sha256"]
-    manifest_file.write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
-
-
-def validate_manifest(task_file: str, manifest_file: str) -> tuple[bool, str]:
-    try:
-        manifest = load_manifest(Path(manifest_file))
-        expected = extract_manifest(task_file)
-    except (OSError, ValueError, json.JSONDecodeError) as exc:
-        return False, f"acceptance_manifest_invalid: {exc}"
-    if manifest.get("schema") != _MANIFEST_SCHEMA:
-        return False, "acceptance_manifest_drift"
-    if manifest.get("task_sha256") != expected["task_sha256"]:
-        legacy = extract_manifest(task_file, _legacy_kind)
-        if manifest.get("task_sha256") != legacy["task_sha256"]:
-            return False, "acceptance_manifest_drift"
-        _heal_legacy_kinds(Path(manifest_file), manifest, expected)
-    stored_task = manifest.get("task_file", "")
-    if not stored_task or (Path(manifest_file).parent / stored_task).resolve() != Path(task_file).resolve():
-        return False, "acceptance_manifest_task_mismatch"
-    if not isinstance(manifest.get("scenarios"), list):
-        return False, "acceptance_manifest_scenarios_changed"
-    stored = {
-        item.get("id"): item
-        for item in manifest["scenarios"]
-        if isinstance(item, Mapping) and isinstance(item.get("id"), str)
-    }
-    required = {item["id"] for item in expected["scenarios"]}
-    if set(stored) != required:
-        return False, "acceptance_manifest_scenarios_changed"
-    for item in expected["scenarios"]:
-        current = stored[item["id"]]
-        for field in _IMMUTABLE_SCENARIO_FIELDS:
-            if current.get(field) != item.get(field):
-                return False, f"acceptance_manifest_field_changed:{item['id']}:{field}"
-    text = Path(task_file).read_text(encoding="utf-8")
-    for scenario in expected["scenarios"]:
-        owner = scenario["owner"]
-        section = re.search(rf"(?ms)^##\s+{re.escape(owner)}:.*?(?=^##\s+TASK-|\Z)", text)
-        refs = re.search(r"(?m)^- \*\*Acceptance-Refs\*\*:[ \t]*([^\n]*)", section.group(0)) if section else None
-        if not refs or scenario["id"] not in re.findall(r"\b[SEB]-\d+\b", refs.group(1)):
-            return False, "acceptance_manifest_owner_missing"
-    return True, ""
-
-
-def record_manual_evidence(manifest_file: str, scenario_id: str, confirmed_by: str, evidence: str) -> None:
-    if not confirmed_by or confirmed_by.lower().split(":", 1)[0] in {"agent", "assistant", "codex", "claude", "opencode", "costrict"}:
-        raise ValueError("manual evidence must be confirmed by a user")
-    path = Path(manifest_file)
-    data = load_manifest(path)
-    scenarios = data.get("scenarios")
-    if not isinstance(scenarios, list):
-        raise ValueError("invalid manifest scenarios")
-    found = False
-    owner = ""
-    task_file = data.get("task_file")
-    for item in scenarios:
-        if isinstance(item, dict) and item.get("id") == scenario_id:
-            if item.get("kind") != "manual":
-                raise ValueError("scenario is not manual")
-            item["status"] = "verified"
-            item["evidence"] = {"confirmed_by": confirmed_by, "evidence": evidence}
-            found = True
-            owner = item.get("owner") if isinstance(item.get("owner"), str) else ""
-    if not found:
-        raise ValueError("scenario not found")
-    path.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
-    if isinstance(task_file, str) and task_file:
-        task_path = Path(task_file)
-        if not task_path.is_absolute():
-            task_path = path.parent / task_path
-        _sync_task_evidence(task_path, scenario_id, confirmed_by, evidence, owner)
-
-
-def _sync_task_evidence(task_file: Path, scenario_id: str, confirmed_by: str, evidence: str, owner: str = "") -> None:
-    from cf_acceptance_evidence import sync_task_evidence
-    sync_task_evidence(task_file, scenario_id, confirmed_by, evidence, owner)
-
-
-def main(argv: Optional[Sequence[str]] = None, stdout: IO[str] = sys.stdout) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--task-file", required=True)
-    parser.add_argument("--output", default="")
-    parser.add_argument("--verify-plan", action="store_true")
-    parser.add_argument("--task-dir", default="")
-    parser.add_argument("--record-manual", action="store_true")
-    parser.add_argument("--scenario-id", default="")
-    parser.add_argument("--confirmed-by", default="")
-    parser.add_argument("--evidence", default="")
-    args = parser.parse_args(argv)
-    try:
-        if args.record_manual:
-            if not args.output or not args.scenario_id or not args.evidence:
-                raise ValueError("--record-manual requires --output, --scenario-id and --evidence")
-            record_manual_evidence(args.output, args.scenario_id, args.confirmed_by, args.evidence)
-            stdout.write(json.dumps({"ok": True, "scenario": args.scenario_id}, ensure_ascii=False))
-            return 0
-        if args.verify_plan:
-            if not args.task_dir:
-                raise ValueError("--verify-plan requires --task-dir")
-            from cf_spec_context import load_context
-            from cf_spec_gate import result_to_data, validate_plan_coverage, validate_stage
-
-            context = load_context(str(Path(args.task_dir) / "spec-context.yml"))
-            gate = validate_stage(context, "plan")
-            coverage = validate_plan_coverage(context, args.task_file)
-            result = {
-                "decision": "block" if gate.decision == "block" or coverage.decision == "block" else "pass",
-                "gate": result_to_data(gate),
-                "coverage": result_to_data(coverage),
-            }
-            stdout.write(json.dumps(result, ensure_ascii=False))
-            return 0 if result["decision"] == "pass" else 3
-        if not args.output:
-            raise ValueError("--output is required unless --verify-plan is used")
-        manifest = write_manifest(args.task_file, args.output)
-        stdout.write(json.dumps({"ok": True, "scenarios": len(manifest["scenarios"])}, ensure_ascii=False))
-        return 0
-    except (OSError, ValueError) as exc:
-        stdout.write(json.dumps({"ok": False, "error": str(exc)}, ensure_ascii=False))
-        return 2
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())