ai-project-manage-cli 8.1.21 → 8.1.22

package/template/skills/webide-run-retro/scripts/inspect-run.mjs

@@ -1,335 +0,0 @@
-#!/usr/bin/env node
-/**
- * Resolve a Cursor SDK run-id or agent-id to the local transcript and a
- * structured conversation summary. Execute this script; do not reimplement.
- *
- * Usage:
- *   node inspect-run.mjs --id run-<uuid>
- *   node inspect-run.mjs --id agent-<uuid>
- *   node inspect-run.mjs --id <uuid>
- */
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { DatabaseSync } from "node:sqlite";
-
-const UUID_RE =
-  "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
-const RUN_RE = new RegExp(`run-${UUID_RE}`, "gi");
-const AGENT_RE = new RegExp(`agent-${UUID_RE}`, "gi");
-
-function arg(name, fallback) {
-  const idx = process.argv.indexOf(name);
-  if (idx >= 0 && process.argv[idx + 1]) return process.argv[idx + 1];
-  return fallback;
-}
-
-function walkFiles(root, matcher, acc = [], depth = 0) {
-  if (!root || depth > 6 || acc.length > 80) return acc;
-  let entries = [];
-  try {
-    entries = fs.readdirSync(root, { withFileTypes: true });
-  } catch {
-    return acc;
-  }
-  for (const ent of entries) {
-    const full = path.join(root, ent.name);
-    if (ent.isDirectory()) {
-      if (["node_modules", ".git", "target"].includes(ent.name)) continue;
-      walkFiles(full, matcher, acc, depth + 1);
-    } else if (matcher(full, ent.name)) {
-      acc.push(full);
-    }
-  }
-  return acc;
-}
-
-function normalizeId(raw) {
-  const id = String(raw || "").trim();
-  if (!id) throw new Error("missing --id");
-  if (id.startsWith("run-") || id.startsWith("agent-")) return id;
-  if (new RegExp(`^${UUID_RE}$`, "i").test(id)) {
-    return { uuid: id, ambiguous: true };
-  }
-  return id;
-}
-
-function texts(rec) {
-  const content = rec?.message?.content;
-  if (!Array.isArray(content)) return [];
-  return content
-    .filter((c) => c?.type === "text" && c.text)
-    .map((c) => String(c.text).replace(/\[REDACTED\]/g, "").trim())
-    .filter(Boolean);
-}
-
-function tools(rec) {
-  const content = rec?.message?.content;
-  if (!Array.isArray(content)) return [];
-  return content.filter((c) => c?.type === "tool_use").map((c) => c.name);
-}
-
-function parseTranscript(filePath) {
-  const lines = fs.readFileSync(filePath, "utf8").trim().split("\n").filter(Boolean);
-  const records = lines.map((line, i) => {
-    try {
-      return { i, ...JSON.parse(line) };
-    } catch {
-      return { i, role: "unknown", parseError: true };
-    }
-  });
-
-  const rounds = [];
-  let cur = null;
-  for (const rec of records) {
-    if (rec.role === "user") {
-      const raw = texts(rec).join("\n");
-      if (raw.startsWith("<dynamic_tools>")) continue;
-      if (cur) rounds.push(cur);
-      const ts = (raw.match(/<timestamp>(.*?)<\/timestamp>/) || [])[1] || "";
-      const action = (raw.match(/\baction=([^\s]+)/) || [])[1] || "";
-      const taskId = (raw.match(/\btaskId=([^\s]+)/) || [])[1] || "";
-      const title = (raw.match(/标题：(.+)/) || [])[1]?.trim() || "";
-      const dm = raw.match(/【现状】\s*([\s\S]*?)\s*【预期】/);
-      const em = raw.match(/【预期】\s*([\s\S]*?)(?:\n\n##|\npayload=|$)/);
-      cur = {
-        ts,
-        action,
-        taskId,
-        title,
-        defect: dm ? dm[1].trim().replace(/\s+/g, " ") : "",
-        expected: em ? em[1].trim().replace(/\s+/g, " ") : "",
-        userPreview: raw.replace(/\s+/g, " ").slice(0, 280),
-        lastReply: "",
-        assistantNotes: [],
-        toolCount: 0,
-      };
-    } else if (cur && rec.role === "assistant") {
-      const t = texts(rec).join(" ").trim();
-      cur.toolCount += tools(rec).length;
-      if (t) {
-        cur.assistantNotes.push(t.slice(0, 240));
-        cur.lastReply = t.slice(0, 400);
-      }
-    }
-  }
-  if (cur) rounds.push(cur);
-
-  const first = rounds[0] || {};
-  return {
-    recordCount: records.length,
-    taskId: rounds.map((r) => r.taskId).find(Boolean) || "",
-    title: rounds.map((r) => r.title).find(Boolean) || "",
-    rounds,
-    defects: rounds
-      .filter((r) => r.action === "report-defect" || r.defect)
-      .map((r, idx) => ({
-        n: idx + 1,
-        ts: r.ts,
-        defect: r.defect,
-        expected: r.expected,
-        lastReply: r.lastReply,
-        toolCount: r.toolCount,
-      })),
-    actions: rounds.map((r) => r.action).filter(Boolean),
-    firstAction: first.action || "",
-  };
-}
-
-function readLiveSqlite(dbPath) {
-  const out = { agents: [], runs: [] };
-  try {
-    const db = new DatabaseSync(dbPath);
-    try {
-      out.agents = db.prepare("SELECT * FROM agents").all();
-      out.runs = db.prepare("SELECT * FROM runs").all();
-    } finally {
-      db.close();
-    }
-  } catch (err) {
-    out.error = err.message;
-  }
-  return out;
-}
-
-function scanSqliteBinary(dbPath) {
-  const buf = fs.readFileSync(dbPath);
-  const text = buf.toString("latin1");
-  return {
-    agentIds: [...new Set(text.match(AGENT_RE) || [])],
-    runIds: [...new Set(text.match(RUN_RE) || [])],
-  };
-}
-
-function discoverRoots() {
-  const cwd = process.cwd();
-  const home = os.homedir();
-  const transcriptsEnv = process.env.AGENT_TRANSCRIPTS;
-  const cursorHome = fs.existsSync(path.join(home, ".cursor"))
-    ? path.join(home, ".cursor")
-    : path.join("/data", "cursor-home");
-  const projectsDir = path.join(cursorHome, "projects");
-  return { cwd, home, transcriptsEnv, cursorHome, projectsDir };
-}
-
-function findTranscripts(roots) {
-  const dirs = [];
-  if (roots.transcriptsEnv && fs.existsSync(roots.transcriptsEnv)) {
-    dirs.push(roots.transcriptsEnv);
-  }
-  if (fs.existsSync(roots.projectsDir)) {
-    for (const name of fs.readdirSync(roots.projectsDir)) {
-      const p = path.join(roots.projectsDir, name, "agent-transcripts");
-      if (fs.existsSync(p)) dirs.push(p);
-    }
-  }
-  return [...new Set(dirs)];
-}
-
-function findStores(roots) {
-  const files = [];
-  if (fs.existsSync(roots.projectsDir)) {
-    for (const name of fs.readdirSync(roots.projectsDir)) {
-      const store = path.join(roots.projectsDir, name, "sdk-agent-store");
-      walkFiles(store, (full, base) => base === "index.db", files, 0);
-    }
-  }
-  walkFiles(
-    path.join(roots.cwd, ".apm"),
-    (full, base) => base === "cursor-agent.json",
-    files,
-    0,
-  );
-  return files;
-}
-
-function findTranscriptFile(transcriptDirs, agentId) {
-  const stems = [agentId, agentId.replace(/^agent-/, ""), `agent-${agentId.replace(/^agent-/, "")}`];
-  for (const dir of transcriptDirs) {
-    for (const stem of stems) {
-      const nested = path.join(dir, stem, `${stem}.jsonl`);
-      if (fs.existsSync(nested)) return nested;
-      const flat = path.join(dir, `${stem}.jsonl`);
-      if (fs.existsSync(flat)) return flat;
-    }
-    try {
-      for (const name of fs.readdirSync(dir)) {
-        if (name.includes(agentId.replace(/^agent-/, ""))) {
-          const candidate = path.join(dir, name, `${name}.jsonl`);
-          if (fs.existsSync(candidate)) return candidate;
-        }
-      }
-    } catch {
-      /* ignore */
-    }
-  }
-  return null;
-}
-
-function main() {
-  const rawId = arg("--id", process.argv[2]);
-  const normalized = normalizeId(rawId);
-  const roots = discoverRoots();
-  const transcriptDirs = findTranscripts(roots);
-  const storeFiles = findStores(roots);
-
-  const recovered = { agentIds: new Set(), runIds: new Set(), liveRuns: [] };
-  for (const file of storeFiles.filter((f) => f.endsWith("index.db"))) {
-    const live = readLiveSqlite(file);
-    for (const row of live.runs || []) {
-      recovered.liveRuns.push({
-        store: file,
-        runId: row.run_id || row.runId,
-        agentId: row.agent_id || row.agentId,
-        status: row.status,
-        turnNumber: row.turn_number || row.turnNumber,
-      });
-      if (row.run_id) recovered.runIds.add(row.run_id);
-      if (row.agent_id) recovered.agentIds.add(row.agent_id);
-    }
-    for (const row of live.agents || []) {
-      if (row.agent_id) recovered.agentIds.add(row.agent_id);
-    }
-    const scanned = scanSqliteBinary(file);
-    scanned.agentIds.forEach((id) => recovered.agentIds.add(id));
-    scanned.runIds.forEach((id) => recovered.runIds.add(id));
-  }
-
-  for (const file of storeFiles.filter((f) => f.endsWith("cursor-agent.json"))) {
-    try {
-      const j = JSON.parse(fs.readFileSync(file, "utf8"));
-      if (j.agentId) recovered.agentIds.add(j.agentId);
-    } catch {
-      /* ignore */
-    }
-  }
-
-  let input = typeof normalized === "string" ? normalized : `uuid:${normalized.uuid}`;
-  let kind = "unknown";
-  let agentId = null;
-  let matchedRunId = null;
-
-  const asString = typeof normalized === "string" ? normalized : normalized.uuid;
-  const wantRun = asString.startsWith("run-")
-    ? asString
-    : recovered.runIds.has(`run-${asString}`)
-      ? `run-${asString}`
-      : null;
-  const wantAgent = asString.startsWith("agent-")
-    ? asString
-    : recovered.agentIds.has(`agent-${asString}`)
-      ? `agent-${asString}`
-      : asString.startsWith("agent-")
-        ? asString
-        : `agent-${asString.replace(/^agent-/, "")}`;
-
-  if (asString.startsWith("run-") || recovered.runIds.has(wantRun)) {
-    kind = "run";
-    matchedRunId = wantRun || asString;
-    const live = recovered.liveRuns.find((r) => r.runId === matchedRunId);
-    if (live?.agentId) agentId = live.agentId;
-    if (!agentId && recovered.agentIds.size === 1) {
-      agentId = [...recovered.agentIds][0];
-    }
-  } else if (asString.startsWith("agent-") || recovered.agentIds.has(wantAgent)) {
-    kind = "agent";
-    agentId = wantAgent.startsWith("agent-") ? wantAgent : `agent-${wantAgent}`;
-  } else if (asString.startsWith("agent-") || asString.length === 36) {
-    kind = asString.startsWith("run-") ? "run" : "agent";
-    agentId = kind === "agent" ? (asString.startsWith("agent-") ? asString : `agent-${asString}`) : null;
-    matchedRunId = kind === "run" ? asString : null;
-  }
-
-  if (!agentId && kind === "agent") {
-    agentId = asString.startsWith("agent-") ? asString : `agent-${asString}`;
-  }
-
-  let transcriptPath = agentId ? findTranscriptFile(transcriptDirs, agentId) : null;
-  if (!transcriptPath && kind === "agent") {
-    transcriptPath = findTranscriptFile(transcriptDirs, asString);
-  }
-
-  const conversation = transcriptPath ? parseTranscript(transcriptPath) : null;
-
-  const result = {
-    input: rawId,
-    kind,
-    agentId,
-    matchedRunId,
-    recoveredAgentIds: [...recovered.agentIds],
-    recoveredRunIds: [...recovered.runIds],
-    liveRuns: recovered.liveRuns,
-    transcriptPath,
-    transcriptDirs,
-    storeFiles,
-    conversation,
-    note: !transcriptPath
-      ? "No transcript found. Check AGENT_TRANSCRIPTS or ~/.cursor/projects/*/agent-transcripts."
-      : recovered.liveRuns.length === 0 && matchedRunId
-        ? "Run tables were empty; mapping used leftover SQLite pages plus the only local agent-id."
-        : undefined,
-  };
-  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-}
-
-main();