claude-coding-flow 1.0.0 → 1.1.0

package/bin/flow.js

@@ -2,6 +2,7 @@
 
 const fs = require("fs");
 const path = require("path");
+const { spawn } = require("child_process");
 
 const PKG_ROOT = path.resolve(__dirname, "..");
 const CWD = process.cwd();
@@ -25,29 +26,65 @@ function copyRecursive(src, dest) {
 function init() {
   console.log(yellow("flow init"));
 
+  // Copy skill commands
   const commandsSrc = path.join(PKG_ROOT, "commands");
   const commandsDest = path.join(CWD, ".claude", "commands");
 
-  if (!fs.existsSync(commandsSrc)) {
-    console.log(red("Error: commands directory not found in package"));
+  if (fs.existsSync(commandsSrc)) {
+    fs.mkdirSync(commandsDest, { recursive: true });
+    const files = fs.readdirSync(commandsSrc).filter((f) => f.endsWith(".md"));
+    for (const file of files) {
+      const src = path.join(commandsSrc, file);
+      const dest = path.join(commandsDest, file);
+      if (fs.existsSync(dest)) {
+        console.log(yellow(`  skip (exists): .claude/commands/${file}`));
+      } else {
+        fs.copyFileSync(src, dest);
+        console.log(green(`  copied: .claude/commands/${file}`));
+      }
+    }
+  }
+
+  // Copy dashboard
+  const dashSrc = path.join(PKG_ROOT, "dashboard");
+  const dashDest = path.join(CWD, "dashboard");
+
+  if (fs.existsSync(dashSrc)) {
+    fs.mkdirSync(dashDest, { recursive: true });
+    copyRecursive(dashSrc, dashDest);
+    console.log(green("  copied: dashboard/"));
+  }
+
+  console.log(green("\ndone!"));
+}
+
+function dashboard() {
+  const dashDir = path.join(CWD, "dashboard");
+  const pkgDashDir = path.join(PKG_ROOT, "dashboard");
+
+  const target = fs.existsSync(dashDir) ? dashDir : pkgDashDir;
+
+  if (!fs.existsSync(path.join(target, "main.py"))) {
+    console.log(red("Error: dashboard/main.py not found. Run `flow init` first."));
     process.exit(1);
   }
 
-  fs.mkdirSync(commandsDest, { recursive: true });
-
-  const files = fs.readdirSync(commandsSrc).filter((f) => f.endsWith(".md"));
-  for (const file of files) {
-    const src = path.join(commandsSrc, file);
-    const dest = path.join(commandsDest, file);
-    if (fs.existsSync(dest)) {
-      console.log(yellow(`  skip (exists): .claude/commands/${file}`));
-    } else {
-      fs.copyFileSync(src, dest);
-      console.log(green(`  copied: .claude/commands/${file}`));
-    }
+  const requirements = path.join(target, "requirements.txt");
+  if (fs.existsSync(requirements)) {
+    console.log(yellow("Installing dashboard dependencies..."));
+    try {
+      require("child_process").execSync(`pip3 install -r "${requirements}"`, {
+        stdio: "inherit",
+      });
+    } catch {}
   }
 
-  console.log(green("\ndone! skills installed to .claude/commands/"));
+  console.log(green("Starting dashboard on http://localhost:8000"));
+  const child = spawn("python3", [path.join(target, "main.py"), "serve"], {
+    stdio: "inherit",
+    cwd: CWD,
+  });
+  child.on("exit", (code) => process.exit(code));
 }
 
 const args = process.argv.slice(2);
@@ -57,10 +94,14 @@ switch (command) {
   case "init":
     init();
     break;
+  case "dashboard":
+    dashboard();
+    break;
   default:
     console.log(`Usage: flow <command>
 
 Commands:
-  init    Install skills to .claude/commands/ in current project`);
+  init        Install skills and dashboard to current project
+  dashboard   Start the dashboard server (http://localhost:8000)`);
     break;
 }

package/dashboard/db.py

@@ -0,0 +1,296 @@
+import json
+import os
+from datetime import datetime
+from typing import Optional, List, Dict
+
+WORKTREE_DIR = os.path.join(os.getcwd(), ".worktree")
+
+PHASE_NAMES_CODE_GEN = {
+    1: "需求收集", 2: "信息加载", 3: "方案规划",
+    4: "代码生成", 5: "编译校验", 6: "代码反思", 7: "交付",
+}
+PHASE_NAMES_DOC_GEN = {1: "信息收集"}
+PHASE_NAMES_BUG_FIX = {1: "定位", 2: "修复", 3: "验证"}
+
+
+def get_phase_name(task_type: str, phase_num: int) -> str:
+    if task_type == "bug-fix":
+        return PHASE_NAMES_BUG_FIX.get(phase_num, f"阶段{phase_num}")
+    elif task_type == "doc-gen":
+        return PHASE_NAMES_DOC_GEN.get(phase_num, f"阶段{phase_num}")
+    return PHASE_NAMES_CODE_GEN.get(phase_num, f"阶段{phase_num}")
+
+
+def _worktree() -> str:
+    os.makedirs(WORKTREE_DIR, exist_ok=True)
+    return WORKTREE_DIR
+
+
+# ── 模块 ──
+
+def _scan_module_dirs() -> List[str]:
+    """扫描 worktree 下所有类型子目录中包含 module.json 的模块目录"""
+    wt = _worktree()
+    dirs = []
+    if not os.path.exists(wt):
+        return dirs
+    for type_dir_name in sorted(os.listdir(wt)):
+        type_path = os.path.join(wt, type_dir_name)
+        if not os.path.isdir(type_path):
+            continue
+        for name in sorted(os.listdir(type_path)):
+            path = os.path.join(type_path, name)
+            if os.path.isdir(path) and os.path.exists(os.path.join(path, "module.json")):
+                dirs.append(path)
+    return dirs
+
+
+def get_modules() -> List[Dict]:
+    result = []
+    for path in _scan_module_dirs():
+        try:
+            with open(os.path.join(path, "module.json"), "r", encoding="utf-8") as f:
+                mod = json.load(f)
+            mod["_path"] = path
+            result.append(mod)
+        except Exception:
+            pass
+    return result
+
+
+def get_module(module_id: str) -> Optional[Dict]:
+    for mod in get_modules():
+        if mod["id"] == module_id:
+            return mod
+    return None
+
+
+def _module_dir(module_id: str) -> Optional[str]:
+    for path in _scan_module_dirs():
+        try:
+            with open(os.path.join(path, "module.json"), "r", encoding="utf-8") as f:
+                mod = json.load(f)
+            if mod["id"] == module_id:
+                return path
+        except Exception:
+            pass
+    return None
+
+
+# ── 任务 ──
+
+def _scan_task_dirs(module_id: str) -> List[str]:
+    """扫描模块目录下所有包含 task.json 的子目录"""
+    md = _module_dir(module_id)
+    if not md:
+        return []
+    dirs = []
+    for name in sorted(os.listdir(md)):
+        path = os.path.join(md, name)
+        if os.path.isdir(path) and os.path.exists(os.path.join(path, "task.json")):
+            dirs.append(path)
+    return dirs
+
+
+def get_module_tasks(module_id: str) -> List[Dict]:
+    result = []
+    for path in _scan_task_dirs(module_id):
+        try:
+            with open(os.path.join(path, "task.json"), "r", encoding="utf-8") as f:
+                task = json.load(f)
+            result.append(task)
+        except Exception:
+            pass
+    return result
+
+
+def get_tasks() -> List[Dict]:
+    result = []
+    for mod in get_modules():
+        result.extend(get_module_tasks(mod["id"]))
+    return result
+
+
+def get_task(task_id: str) -> Optional[Dict]:
+    for task in get_tasks():
+        if task["id"] == task_id:
+            return task
+    return None
+
+
+def get_task_dir(task_id: str) -> Optional[str]:
+    """根据 task_id 查找其所在目录"""
+    for mod in get_modules():
+        for path in _scan_task_dirs(mod["id"]):
+            try:
+                with open(os.path.join(path, "task.json"), "r", encoding="utf-8") as f:
+                    task = json.load(f)
+                if task["id"] == task_id:
+                    return path
+            except Exception:
+                pass
+    return None
+
+
+# ── 按类型过滤 ──
+
+def get_modules_by_type(module_type: str) -> List[Dict]:
+    """按 type 字段过滤模块，未指定 type 的默认为 code-gen"""
+    result = []
+    for mod in get_modules():
+        mod_type = mod.get("type", "code-gen")
+        if mod_type == module_type:
+            result.append(mod)
+    return result
+
+
+# ── doc-gen 产物 ──
+
+def get_doc_gen_artifacts(task_dir: str) -> Dict:
+    """读取 doc-gen 任务的产物信息"""
+    result = {"requirement_doc": None, "images": [], "develop_doc": None}
+
+    req_dir = os.path.join(task_dir, "requirement")
+    if os.path.exists(req_dir):
+        files = [f for f in os.listdir(req_dir) if not f.startswith(".")]
+        result["requirement_doc"] = files[0] if files else None
+
+    img_dir = os.path.join(task_dir, "images")
+    if os.path.exists(img_dir):
+        result["images"] = sorted(
+            f for f in os.listdir(img_dir) if not f.startswith(".")
+        )
+
+    for f in os.listdir(task_dir):
+        if f.endswith("-develop.md"):
+            result["develop_doc"] = f
+            break
+
+    return result
+
+
+# ── bug-fix 信息 ──
+
+def get_bug_fix_info(task_dir: str) -> Dict:
+    """读取 bug-fix 任务的 bug 信息"""
+    try:
+        with open(os.path.join(task_dir, "task.json"), "r", encoding="utf-8") as f:
+            task = json.load(f)
+    except Exception:
+        return {}
+    return {
+        "bug_status": task.get("bug_status", "unresolved"),
+        "bug_description": task.get("bug_description", ""),
+        "source_info": task.get("source_info", {}),
+    }
+
+
+# ── 任务链 ──
+
+def get_task_chain(module_id: str) -> Dict:
+    """获取模块内的任务链关系"""
+    tasks = get_module_tasks(module_id)
+    if not tasks:
+        return {"chains": [], "task_map": {}}
+
+    task_map = {t["id"]: t for t in tasks}
+    chains = []
+    visited = set()
+
+    # 找到所有起始任务（prev_task_id 为空）
+    roots = [t for t in tasks if not t.get("prev_task_id")]
+    for root in roots:
+        chain = []
+        current = root
+        while current:
+            chain.append(current["id"])
+            visited.add(current["id"])
+            next_tasks = [t for t in tasks if t.get("prev_task_id") == current["id"]]
+            current = next_tasks[0] if next_tasks else None
+        chains.append(chain)
+
+    # 处理未在链中的任务（无 root 且未被访问）
+    for t in tasks:
+        if t["id"] not in visited:
+            chains.append([t["id"]])
+
+    return {
+        "chains": chains,
+        "task_map": {
+            tid: {"title": t["title"], "status": t["status"]}
+            for tid, t in task_map.items()
+        },
+    }
+
+
+# ── 跨类型关联 ──
+
+def get_cross_relations(task_id: str) -> Dict:
+    """查找任务的跨类型关联关系"""
+    task = get_task(task_id)
+    if not task:
+        return {"relations": []}
+
+    relations = []
+
+    # code-gen → doc-gen: 通过 dev_doc 反查
+    dev_doc = task.get("dev_doc")
+    if dev_doc and task.get("type") == "code-gen":
+        # 在 doc-gen 任务中查找生成该 develop.md 的任务
+        for mod in get_modules():
+            if mod.get("type") != "doc-gen":
+                continue
+            for tp in _scan_task_dirs(mod["id"]):
+                try:
+                    with open(os.path.join(tp, "task.json"), "r", encoding="utf-8") as f:
+                        dt = json.load(f)
+                    if dt.get("output_doc") and dev_doc.endswith(dt["output_doc"]):
+                        relations.append({
+                            "type": "based-on",
+                            "label": "基于开发文档",
+                            "from_task": task_id,
+                            "to_task": dt["id"],
+                            "to_task_title": dt.get("title", ""),
+                            "to_module_id": mod["id"],
+                            "to_module_name": mod.get("name", ""),
+                            "artifact": dt.get("output_doc", ""),
+                        })
+                        break
+                except Exception:
+                    pass
+
+    # bug-fix → code-gen: 通过 related_task_id
+    related = task.get("related_task_id")
+    if related and task.get("type") == "bug-fix":
+        rt = get_task(related)
+        if rt:
+            relations.append({
+                "type": "traces-to",
+                "label": "溯源",
+                "from_task": task_id,
+                "to_task": related,
+                "to_task_title": rt.get("title", ""),
+            })
+
+    # code-gen ← doc-gen: 反向查找哪些 code-gen 任务基于此 doc-gen 任务
+    if task.get("type") == "doc-gen" and task.get("output_doc"):
+        for mod in get_modules():
+            if mod.get("type") != "code-gen":
+                continue
+            for tp in _scan_task_dirs(mod["id"]):
+                try:
+                    with open(os.path.join(tp, "task.json"), "r", encoding="utf-8") as f:
+                        ct = json.load(f)
+                    dd = ct.get("dev_doc", "")
+                    if dd and task["output_doc"] and dd.endswith(task["output_doc"]):
+                        relations.append({
+                            "type": "used-by",
+                            "label": "被引用",
+                            "from_task": ct["id"],
+                            "from_task_title": ct.get("title", ""),
+                            "to_task": task_id,
+                        })
+                except Exception:
+                    pass
+
+    return {"relations": relations}

package/dashboard/logger.py

@@ -0,0 +1,110 @@
+import json
+import os
+from typing import Optional, List, Dict
+
+
+def _jsonl_path(task_dir: str) -> str:
+    return os.path.join(task_dir, "log.jsonl")
+
+
+def _text_log_path(task_dir: str) -> str:
+    return os.path.join(task_dir, "log")
+
+
+def _snapshot_base(task_dir: str) -> str:
+    return os.path.join(task_dir, "snapshots")
+
+
+# ── 执行日志 ──
+
+def get_logs(task_dir: str) -> List[Dict]:
+    path = _jsonl_path(task_dir)
+    if not os.path.exists(path):
+        return []
+    with open(path, "r", encoding="utf-8") as f:
+        return [json.loads(line) for line in f if line.strip()]
+
+
+def get_token_summary(task_dir: str) -> Dict:
+    logs = get_logs(task_dir)
+    total = sum(e.get("tokens", 0) or 0 for e in logs)
+    phases = {}
+    for e in logs:
+        p = e.get("phase", 0)
+        t = e.get("tokens", 0) or 0
+        phases[p] = phases.get(p, 0) + t
+    return {"total_tokens": total, "tokens_by_phase": phases}
+
+
+def get_text_log(task_dir: str) -> Optional[str]:
+    # 优先读 log.md，兼容旧 log 文件
+    md_path = os.path.join(task_dir, "log.md")
+    if os.path.exists(md_path):
+        with open(md_path, "r", encoding="utf-8") as f:
+            return f.read()
+    path = _text_log_path(task_dir)
+    if os.path.exists(path):
+        with open(path, "r", encoding="utf-8") as f:
+            return f.read()
+    return None
+
+
+# ── Plan 存储 ──
+
+def get_plan(task_dir: str) -> Optional[str]:
+    plan_path = os.path.join(task_dir, "plan.md")
+    if not os.path.exists(plan_path):
+        return None
+    with open(plan_path, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+# ── 代码快照 ──
+
+def list_snapshots(task_dir: str) -> List[Dict]:
+    snap_dir = _snapshot_base(task_dir)
+    if not os.path.exists(snap_dir):
+        return []
+
+    files = []
+    for name in sorted(os.listdir(snap_dir)):
+        path = os.path.join(snap_dir, name)
+        if os.path.isfile(path) and not name.startswith("."):
+            files.append(name)
+
+    # 检查子目录（兼容旧结构）
+    sub_dirs = []
+    for name in sorted(os.listdir(snap_dir)):
+        path = os.path.join(snap_dir, name)
+        if os.path.isdir(path):
+            sub_files = []
+            for root, _, fs in os.walk(path):
+                for fname in fs:
+                    if fname == "_summary.json":
+                        continue
+                    rel = os.path.relpath(os.path.join(root, fname), path)
+                    sub_files.append(rel)
+            if sub_files:
+                sub_dirs.append({"name": name, "files": sub_files})
+
+    result = []
+    if files:
+        result.append({"name": "files", "files": files})
+    result.extend(sub_dirs)
+    return result
+
+
+def get_snapshot_file(task_dir: str, snapshot_name: str, filepath: str) -> Optional[str]:
+    snap_dir = _snapshot_base(task_dir)
+    # 扁平结构（snapshot_name == "files"）：文件直接在 snapshots/ 下
+    if snapshot_name == "files":
+        path = os.path.join(snap_dir, filepath)
+    else:
+        path = os.path.join(snap_dir, snapshot_name, filepath)
+    if not os.path.exists(path):
+        return None
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return f.read()
+    except UnicodeDecodeError:
+        return None