super-engineer-workflow 0.1.0

package/super-engineer-workflow/scripts/generate-discovery.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import shutil
+import subprocess
+from pathlib import Path
+
+from common import (
+    current_session_meta,
+    data_artifact_path,
+    detect_project,
+    ensure_status,
+    extract_todo_keywords,
+    load_workspace_config,
+    now_iso,
+    parse_task_blocks,
+    read_json,
+    read_text,
+    relative_to,
+    report_artifact_path,
+    resolve_target_codebases,
+    todo_path,
+    workspace_root,
+    write_managed_json,
+    write_managed_text,
+)
+
+
+def run_rg(keyword: str, codebase: Path, max_count: int = 12) -> list[dict[str, object]]:
+    if not shutil.which("rg"):
+        return []
+    result = subprocess.run(
+        [
+            "rg",
+            "--line-number",
+            "--column",
+            "--no-heading",
+            "--fixed-strings",
+            "--glob",
+            "!target/**",
+            "--glob",
+            "!build/**",
+            "--glob",
+            "!node_modules/**",
+            "--glob",
+            "!.git/**",
+            keyword,
+            str(codebase),
+        ],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if result.returncode not in (0, 1):
+        return []
+    matches: list[dict[str, object]] = []
+    for line in result.stdout.splitlines()[:max_count]:
+        parts = line.split(":", 3)
+        if len(parts) < 4:
+            continue
+        file_path, line_no, column_no, snippet = parts
+        matches.append(
+            {
+                "file": str(Path(file_path).resolve()),
+                "relative_file": relative_to(file_path, codebase),
+                "line": int(line_no) if line_no.isdigit() else 0,
+                "column": int(column_no) if column_no.isdigit() else 0,
+                "snippet": snippet.strip()[:240],
+            }
+        )
+    return matches
+
+
+def build_discovery_markdown(discovery: dict) -> str:
+    lines = [
+        "# 上下文定位",
+        "",
+        "## 任务",
+    ]
+    tasks = discovery.get("tasks", [])
+    if tasks:
+        lines.extend(f"- {task.get('title')}" for task in tasks)
+    else:
+        lines.append("- 暂无")
+    lines.extend(["", "## 关键词"])
+    keywords = discovery.get("keywords", [])
+    lines.extend(f"- `{item}`" for item in keywords) if keywords else lines.append("- 暂无")
+    lines.extend(["", "## 代码命中"])
+    for codebase in discovery.get("codebases", []):
+        lines.append(f"### {codebase.get('name')}")
+        lines.append(f"- 路径：{codebase.get('path')}")
+        lines.append(f"- 构建工具：{codebase.get('detected_project', {}).get('build_tool') or '未知'}")
+        matches = codebase.get("matches", [])
+        if not matches:
+            lines.append("- 未命中关键词")
+            continue
+        for item in matches[:20]:
+            lines.append(
+                f"- `{item.get('relative_file')}`:{item.get('line')} "
+                f"命中 `{item.get('keyword')}`：{item.get('snippet')}"
+            )
+    lines.extend(["", "## 计划提示"])
+    for hint in discovery.get("planning_hints", []):
+        lines.append(f"- {hint}")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="根据 todo 关键词定位代码证据，生成 discovery 产物。")
+    parser.add_argument("--workspace", help="工作空间路径，默认读取当前目录")
+    args = parser.parse_args()
+
+    workspace = workspace_root(Path(args.workspace).expanduser() if args.workspace else None)
+    config = load_workspace_config(workspace)
+    session_meta = current_session_meta(config)
+    todo_text = read_text(todo_path(config))
+    codebases, resolution = resolve_target_codebases(config, todo_text)
+    keywords = extract_todo_keywords(todo_text)
+    if not keywords:
+        keywords = [task["title"] for task in parse_task_blocks(todo_text)[:8]]
+
+    codebase_sections: list[dict] = []
+    all_matches: list[dict] = []
+    for codebase in codebases:
+        matches: list[dict] = []
+        for keyword in keywords:
+            for match in run_rg(keyword, codebase):
+                match["keyword"] = keyword
+                matches.append(match)
+        seen: set[tuple[str, int, str]] = set()
+        deduped: list[dict] = []
+        for match in matches:
+            key = (str(match.get("file", "")), int(match.get("line", 0)), str(match.get("keyword", "")))
+            if key in seen:
+                continue
+            seen.add(key)
+            deduped.append(match)
+        all_matches.extend(deduped)
+        codebase_sections.append(
+            {
+                "name": codebase.name,
+                "path": str(codebase),
+                "detected_project": detect_project(codebase, config),
+                "matches": deduped[:80],
+            }
+        )
+
+    planning_hints = []
+    if all_matches:
+        planning_hints.append("优先把命中关键词的文件作为影响范围候选，并结合调用链继续定位。")
+    else:
+        planning_hints.append("关键词未命中代码，计划阶段需要基于项目结构继续定位真实入口。")
+    if len(codebases) > 1:
+        planning_hints.append("本轮涉及多个仓库，后续 review 和 verify 必须逐仓执行。")
+
+    discovery = {
+        "session_id": session_meta["session_id"],
+        "tasks": parse_task_blocks(todo_text),
+        "keywords": keywords,
+        "service_resolution": resolution,
+        "codebases": codebase_sections,
+        "planning_hints": planning_hints,
+        "created_at": now_iso(),
+    }
+    write_managed_json(config, data_artifact_path(config, "discovery.json", session_meta), discovery)
+    write_managed_text(config, report_artifact_path(config, "discovery.md", session_meta), build_discovery_markdown(discovery))
+
+    status = ensure_status(config, session_meta, read_json(data_artifact_path(config, "status.json", session_meta), {}))
+    status.update(
+        {
+            "phase": "discover",
+            "current_task": "已完成上下文定位。",
+            "progress": 15,
+            "next_action": "基于 discovery.json 生成可执行计划。",
+            "completed_tasks": list(dict.fromkeys(status.get("completed_tasks", []) + ["已完成上下文定位"])),
+            "updated_at": now_iso(),
+        }
+    )
+    write_managed_json(config, data_artifact_path(config, "status.json", session_meta), status)
+
+
+if __name__ == "__main__":
+    main()

package/super-engineer-workflow/scripts/generate-review-report.py

@@ -0,0 +1,296 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import subprocess
+from pathlib import Path
+
+from common import (
+    current_session_meta,
+    data_artifact_path,
+    ensure_status,
+    load_workspace_config,
+    now_iso,
+    phase_after,
+    planned_codebases,
+    read_json,
+    report_artifact_path,
+    workspace_root,
+    write_managed_json,
+    write_managed_text,
+)
+
+
+def run_git(args: list[str], cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(args, cwd=cwd, capture_output=True, text=True, check=False)
+
+
+def is_git_repo(workspace: Path) -> bool:
+    result = run_git(["git", "rev-parse", "--is-inside-work-tree"], workspace)
+    return result.returncode == 0 and result.stdout.strip() == "true"
+
+
+def changed_files(workspace: Path) -> list[str]:
+    result = run_git(["git", "status", "--porcelain"], workspace)
+    if result.returncode != 0:
+        return []
+
+    files: list[str] = []
+    for line in result.stdout.splitlines():
+        if not line.strip():
+            continue
+        path = line[3:]
+        if " -> " in path:
+            path = path.split(" -> ", 1)[1]
+        normalized = path.strip()
+        if normalized.startswith(".super-engineer/"):
+            continue
+        files.append(str((workspace / normalized).resolve()))
+    return files
+
+
+def diff_summary(workspace: Path) -> list[str]:
+    result = run_git(["git", "diff", "--stat"], workspace)
+    if result.returncode != 0 or not result.stdout.strip():
+        return []
+    lines: list[str] = []
+    for line in result.stdout.splitlines():
+        stripped = line.rstrip()
+        if not stripped or "file changed" in stripped or "files changed" in stripped:
+            continue
+        if ".super-engineer/" in stripped:
+            continue
+        lines.append(stripped)
+    return lines
+
+
+def find_tests(files: list[str]) -> list[str]:
+    return [item for item in files if item.endswith("Test.java") or "/test/" in item]
+
+
+def build_findings(plan_files: list[str], changed: list[str], repo_mode: str, repo_name: str) -> list[dict[str, object]]:
+    findings: list[dict[str, object]] = []
+    planned = set(plan_files)
+    changed_set = set(changed)
+
+    if repo_mode == "git" and not changed:
+        return [
+            {
+                "severity": "blocker",
+                "scope": repo_name,
+                "title": "未检测到代码差异",
+                "detail": f"{repo_name}：未检测到本地代码差异，本次审查只能围绕计划范围进行。",
+                "blocking": True,
+            }
+        ]
+
+    if repo_mode == "fallback":
+        findings.append(
+            {
+                "severity": "warning",
+                "scope": repo_name,
+                "title": "无法读取 Git 差异",
+                "detail": f"{repo_name}：当前无法读取 Git 代码差异，本次审查只能基于计划范围做兜底判断。",
+                "blocking": False,
+            }
+        )
+
+    unplanned = sorted(item for item in changed_set if item not in planned and not item.startswith(".super-engineer/"))
+    if unplanned:
+        findings.append(
+            {
+                "severity": "warning",
+                "scope": repo_name,
+                "title": "计划外改动",
+                "detail": f"{repo_name}：发现计划外改动文件：{', '.join(unplanned)}。请确认是否需要扩展计划范围。",
+                "blocking": False,
+                "files": unplanned,
+            }
+        )
+
+    if changed and planned:
+        unchanged_planned = sorted(item for item in planned if item not in changed_set)
+        if unchanged_planned:
+            findings.append(
+                {
+                    "severity": "info",
+                    "scope": repo_name,
+                    "title": "计划内文件未改动",
+                    "detail": f"{repo_name}：部分计划内文件尚未发生改动：{', '.join(unchanged_planned[:4])}。请确认是尚未实现，还是计划范围过宽。",
+                    "blocking": False,
+                    "files": unchanged_planned[:8],
+                }
+            )
+
+    touches_app_code = any(item.endswith((".java", ".kt", ".xml", ".yml")) and "Test" not in item for item in changed)
+    if touches_app_code and not find_tests(changed):
+        findings.append(
+            {
+                "severity": "warning",
+                "scope": repo_name,
+                "title": "缺少测试改动",
+                "detail": f"{repo_name}：应用代码已经变更，但没有检测到对应测试改动。请确认是否需要补充测试或人工验证。",
+                "blocking": False,
+            }
+        )
+
+    if not findings:
+        findings.append(
+            {
+                "severity": "info",
+                "scope": repo_name,
+                "title": "审查通过",
+                "detail": f"{repo_name}：当前范围内未发现明显的计划与代码差异不一致问题。",
+                "blocking": False,
+            }
+        )
+    return findings
+
+
+def build_review_markdown(plan: dict, sections: list[dict], findings: list[dict[str, object]]) -> str:
+    lines = [
+        "# 代码审查",
+        "",
+        "## 审查范围",
+        plan.get("requirement_summary") or "请补充审查范围。",
+        "",
+        "## 目标仓库",
+    ]
+    targets = plan.get("target_codebases", [])
+    if targets:
+        lines.extend(f"- {target.get('name')}：{target.get('path')}" for target in targets)
+    else:
+        lines.append(f"- {plan.get('resolved_code_path') or '未知'}")
+    lines.extend([
+        "",
+        "## 审查结论",
+    ])
+    lines.extend(f"- [{item.get('severity')}] {item.get('title')}：{item.get('detail')}" for item in findings)
+    lines.extend(["", "## 审查门禁"])
+    blocking = [item for item in findings if item.get("blocking")]
+    if blocking:
+        lines.append("- blocked：存在阻塞项，进入验证前必须处理。")
+    else:
+        lines.append("- passed：未发现阻塞级问题。")
+    lines.extend(["", "## 仓库审查明细"])
+    for section in sections:
+        lines.extend(
+            [
+                f"### {section['name']}",
+                f"- 审查模式：{'基于 Git 代码差异的审查' if section['repo_mode'] == 'git' else '基于计划范围的兜底审查'}",
+                "- 变更文件：",
+            ]
+        )
+        if section["changed"]:
+            lines.extend(f"  - `{item}`" for item in section["changed"])
+        else:
+            lines.append("  - 暂无")
+        lines.append("- 差异摘要：")
+        if section["summary"]:
+            lines.extend(f"  - {item}" for item in section["summary"])
+        else:
+            lines.append("  - 暂无")
+    lines.extend(["", "## 已检查的计划步骤"])
+    if plan.get("change_steps"):
+        lines.extend(f"- {step['title']}" for step in plan["change_steps"])
+    else:
+        lines.append("- 暂无")
+    lines.extend(["", "## 待复核风险"])
+    if plan.get("risks"):
+        lines.extend(f"- {item}" for item in plan["risks"])
+    else:
+        lines.append("- 暂无")
+    lines.extend(["", "## 测试覆盖说明"])
+    if plan.get("test_plan"):
+        lines.extend(f"- {item}" for item in plan["test_plan"])
+    else:
+        lines.append("- 暂无")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="基于计划和真实代码差异生成 review.md。")
+    parser.add_argument("--workspace", help="工作空间路径，默认读取当前目录")
+    args = parser.parse_args()
+
+    workspace = workspace_root(Path(args.workspace).expanduser() if args.workspace else None)
+    config = load_workspace_config(workspace)
+    session_meta = current_session_meta(config)
+    plan = read_json(data_artifact_path(config, "plan.json", session_meta), {})
+    codebases = planned_codebases(config, session_meta)
+    target_plans = plan.get("target_codebases", [])
+    target_map = {str(item.get("path")): item for item in target_plans}
+
+    sections: list[dict] = []
+    findings: list[dict[str, object]] = []
+    for codebase in codebases:
+        repo_name = codebase.name
+        target_plan = target_map.get(str(codebase), {})
+        plan_files = target_plan.get("impacted_files", [])
+        if is_git_repo(codebase):
+            changed = changed_files(codebase)
+            summary = diff_summary(codebase)
+            repo_mode = "git"
+        else:
+            changed = plan_files
+            summary = []
+            repo_mode = "fallback"
+        sections.append(
+            {
+                "name": repo_name,
+                "path": str(codebase),
+                "changed": changed,
+                "summary": summary,
+                "repo_mode": repo_mode,
+            }
+        )
+        findings.extend(build_findings(plan_files, changed, repo_mode, repo_name))
+    review_result = "blocked" if any(item.get("blocking") for item in findings) else "passed"
+    write_managed_json(
+        config,
+        data_artifact_path(config, "review.json", session_meta),
+        {
+            "session_id": session_meta["session_id"],
+            "source": "run-workflow.py review",
+            "schema_version": 1,
+            "result": review_result,
+            "sections": sections,
+            "findings": findings,
+            "created_at": now_iso(),
+        },
+    )
+    write_managed_text(
+        config,
+        report_artifact_path(config, "review.md", session_meta),
+        build_review_markdown(plan, sections, findings) + "\n",
+    )
+
+    status = ensure_status(config, session_meta, read_json(data_artifact_path(config, "status.json", session_meta), {}))
+    phase, awaiting_confirmation, pending_for, next_action = phase_after("review", config["mode"])
+    if review_result == "blocked":
+        phase = "blocked"
+        awaiting_confirmation = False
+        pending_for = ""
+        next_action = "请先处理 review 阻塞项，再重新执行 review。"
+    status.update(
+        {
+            "phase": phase,
+            "current_task": "代码审查已完成。" if review_result == "passed" else "代码审查发现阻塞项。",
+            "progress": 75,
+            "awaiting_confirmation": awaiting_confirmation,
+            "pending_confirmation_for": pending_for,
+            "next_action": next_action,
+            "completed_tasks": list(dict.fromkeys(status.get("completed_tasks", []) + ["已完成代码审查"])),
+            "blocked_tasks": list(dict.fromkeys(status.get("blocked_tasks", []) + [item["title"] for item in findings if item.get("blocking")])),
+            "started_at": status.get("started_at") or session_meta.get("started_at", ""),
+            "updated_at": now_iso(),
+        }
+    )
+    write_managed_json(config, data_artifact_path(config, "status.json", session_meta), status)
+    if review_result == "blocked":
+        raise SystemExit("代码审查发现阻塞项，请查看 review.md。")
+
+
+if __name__ == "__main__":
+    main()

package/super-engineer-workflow/scripts/generate-self-check.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import subprocess
+from pathlib import Path
+
+from common import (
+    current_session_meta,
+    data_artifact_path,
+    ensure_status,
+    load_workspace_config,
+    now_iso,
+    planned_codebases,
+    read_json,
+    report_artifact_path,
+    workspace_root,
+    write_managed_json,
+    write_managed_text,
+)
+
+
+def run_git(args: list[str], cwd: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(args, cwd=cwd, capture_output=True, text=True, check=False)
+
+
+def is_git_repo(path: Path) -> bool:
+    result = run_git(["git", "rev-parse", "--is-inside-work-tree"], path)
+    return result.returncode == 0 and result.stdout.strip() == "true"
+
+
+def changed_files(path: Path) -> list[str]:
+    result = run_git(["git", "status", "--porcelain"], path)
+    if result.returncode != 0:
+        return []
+    files: list[str] = []
+    for line in result.stdout.splitlines():
+        if not line.strip():
+            continue
+        normalized = line[3:].strip()
+        if " -> " in normalized:
+            normalized = normalized.split(" -> ", 1)[1]
+        if normalized.startswith(".super-engineer/"):
+            continue
+        files.append(str((path / normalized).resolve()))
+    return files
+
+
+def build_self_check(plan: dict, sections: list[dict]) -> dict:
+    findings: list[dict] = []
+    plan_files = set(str(item) for item in plan.get("impacted_files", []))
+    changed = {item for section in sections for item in section.get("changed_files", [])}
+    has_git_repo = any(section.get("repo_mode") == "git" for section in sections)
+    changed_app = [item for item in changed if item.endswith((".java", ".kt", ".xml", ".yml", ".yaml", ".ts", ".tsx", ".js"))]
+    changed_tests = [item for item in changed if "/test/" in item or item.endswith(("Test.java", ".test.ts", ".spec.ts", ".test.js"))]
+
+    if not changed and has_git_repo:
+        findings.append(
+            {
+                "severity": "blocker",
+                "title": "未检测到代码差异",
+                "detail": "实现阶段结束后没有发现本地代码变更，无法进入有效审查。",
+                "blocking": True,
+            }
+        )
+    elif not changed:
+        findings.append(
+            {
+                "severity": "warning",
+                "title": "无法读取代码差异",
+                "detail": "目标目录不是 Git 仓库，自查只能依赖后续人工 review 与验证命令。",
+                "blocking": False,
+            }
+        )
+    unplanned = sorted(item for item in changed if plan_files and item not in plan_files)
+    if unplanned:
+        findings.append(
+            {
+                "severity": "warning",
+                "title": "存在计划外改动",
+                "detail": "请确认这些文件是否应补入计划：" + "，".join(unplanned[:8]),
+                "blocking": False,
+            }
+        )
+    if changed_app and not changed_tests:
+        findings.append(
+            {
+                "severity": "warning",
+                "title": "应用代码改动缺少测试改动",
+                "detail": "如果本轮改动无法自动化测试，需要在 verify.md 中补充人工验证项。",
+                "blocking": False,
+            }
+        )
+    if not findings:
+        findings.append(
+            {
+                "severity": "info",
+                "title": "自查通过",
+                "detail": "未发现会阻断 review 的基础问题。",
+                "blocking": False,
+            }
+        )
+    return {
+        "result": "blocked" if any(item.get("blocking") for item in findings) else "passed",
+        "findings": findings,
+    }
+
+
+def build_markdown(self_check: dict, sections: list[dict]) -> str:
+    lines = [
+        "# 实现自查",
+        "",
+        "## 总体结果",
+        f"- {self_check.get('result')}",
+        "",
+        "## 自查发现",
+    ]
+    for finding in self_check.get("findings", []):
+        lines.append(
+            f"- [{finding.get('severity')}] {finding.get('title')}：{finding.get('detail')}"
+        )
+    lines.extend(["", "## 变更文件"])
+    for section in sections:
+        lines.append(f"### {section.get('name')}")
+        changed = section.get("changed_files", [])
+        if changed:
+            lines.extend(f"- `{item}`" for item in changed)
+        else:
+            lines.append("- 暂无")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="实现完成后进行基础自查并生成 self-check 产物。")
+    parser.add_argument("--workspace", help="工作空间路径，默认读取当前目录")
+    args = parser.parse_args()
+
+    workspace = workspace_root(Path(args.workspace).expanduser() if args.workspace else None)
+    config = load_workspace_config(workspace)
+    session_meta = current_session_meta(config)
+    plan = read_json(data_artifact_path(config, "plan.json", session_meta), {})
+
+    sections: list[dict] = []
+    for codebase in planned_codebases(config, session_meta):
+        sections.append(
+            {
+                "name": codebase.name,
+                "path": str(codebase),
+                "repo_mode": "git" if is_git_repo(codebase) else "fallback",
+                "changed_files": changed_files(codebase) if is_git_repo(codebase) else [],
+            }
+        )
+    self_check = build_self_check(plan, sections)
+    payload = {
+        "session_id": session_meta["session_id"],
+        "source": "run-workflow.py self-check",
+        "schema_version": 1,
+        "result": self_check["result"],
+        "sections": sections,
+        "findings": self_check["findings"],
+        "created_at": now_iso(),
+    }
+    write_managed_json(config, data_artifact_path(config, "self-check.json", session_meta), payload)
+    write_managed_text(config, report_artifact_path(config, "self-check.md", session_meta), build_markdown(self_check, sections))
+
+    status = ensure_status(config, session_meta, read_json(data_artifact_path(config, "status.json", session_meta), {}))
+    status.update(
+        {
+            "phase": "self_check" if self_check["result"] == "passed" else "blocked",
+            "current_task": "实现自查已完成。",
+            "progress": 65 if self_check["result"] == "passed" else 62,
+            "next_action": "继续执行代码审查。" if self_check["result"] == "passed" else "请先处理自查阻塞项。",
+            "completed_tasks": list(dict.fromkeys(status.get("completed_tasks", []) + ["已完成实现自查"])),
+            "blocked_tasks": list(dict.fromkeys(status.get("blocked_tasks", []) + [item["title"] for item in self_check["findings"] if item.get("blocking")])),
+            "updated_at": now_iso(),
+        }
+    )
+    write_managed_json(config, data_artifact_path(config, "status.json", session_meta), status)
+    if self_check["result"] == "blocked":
+        raise SystemExit("实现自查发现阻塞项，请查看 self-check.md。")
+
+
+if __name__ == "__main__":
+    main()