@agentsky/sky 2.20.2 → 2.22.0

package/vendor/trace-collect/sources/claude-ai.mjs

@@ -0,0 +1,94 @@
+// claude.ai keeps conversations in the cloud; Settings › Privacy › Export data emails a zip whose
+// conversations.json is an array of { uuid, name, summary, created_at, updated_at, chat_messages[] }.
+// Each message has sender "human" | "assistant", content[] blocks (text, thinking, tool_use, tool_result),
+// attachments[] (pasted or uploaded documents with extracted_content) and files[] (binaries, names only).
+// This turns each conversation into one trace/v1 session so the normal scan → scrub → draft flow can take it.
+
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { FORMAT } from "../normalize.mjs";
+
+const IMAGE = /\.(png|jpe?g|gif|webp|heic)$/i;
+
+/** conversations.json from an export zip, a folder it was unpacked into, or the file itself. */
+export function readClaudeAiExport(input) {
+  const st = fs.statSync(input);
+  if (st.isDirectory()) {
+    const f = path.join(input, "conversations.json");
+    if (!fs.existsSync(f)) throw new Error(`no conversations.json in ${input}`);
+    return JSON.parse(fs.readFileSync(f, "utf8"));
+  }
+  if (input.endsWith(".zip")) {
+    const list = execFileSync("unzip", ["-Z1", input], { encoding: "utf8" }).split("\n");
+    const f = list.find((n) => /(^|\/)conversations\.json$/.test(n));
+    if (!f) throw new Error(`no conversations.json in ${input}`);
+    return JSON.parse(execFileSync("unzip", ["-p", input, f], { encoding: "utf8", maxBuffer: 2 * 1024 ** 3 }));
+  }
+  return JSON.parse(fs.readFileSync(input, "utf8"));
+}
+
+function blockText(c) {
+  if (typeof c === "string") return c;
+  if (!Array.isArray(c)) return c == null ? "" : JSON.stringify(c);
+  return c.map((p) => (typeof p === "string" ? p : p?.type === "text" ? p.text : p?.type === "knowledge" ? [p.title, p.url, p.text].filter(Boolean).join("\n") : p?.type === "image" ? "[image]" : JSON.stringify(p))).filter(Boolean).join("\n\n");
+}
+
+/** An edited conversation is a tree; keep the branch that ends at the latest message, the one the person saw last. */
+function lastBranch(msgs) {
+  if (!msgs.some((m) => m.parent_message_uuid)) return msgs;
+  const byId = new Map(msgs.map((m) => [m.uuid, m]));
+  let leaf = msgs.reduce((a, m) => (Date.parse(m.created_at || 0) >= Date.parse(a.created_at || 0) ? m : a), msgs[0]);
+  const chain = [], seen = new Set();
+  while (leaf && !seen.has(leaf.uuid)) { seen.add(leaf.uuid); chain.unshift(leaf); leaf = byId.get(leaf.parent_message_uuid); }
+  return chain.length >= 2 ? chain : msgs;
+}
+
+/** One conversation as trace/v1. Attached documents carry their extracted text; binaries are named, never included (the export has no bytes). */
+export function claudeAiSession(conv) {
+  const messages = [];
+  for (const m of lastBranch(conv.chat_messages || [])) {
+    const content = Array.isArray(m.content) && m.content.length ? m.content : [{ type: "text", text: m.text || "" }];
+    if (m.sender === "human") {
+      const attachments = [
+        ...(m.attachments || []).filter((a) => a.extracted_content).map((a) => ({ kind: "document", media_type: "text/plain", name: a.file_name || "", text: a.extracted_content })),
+        ...[...(m.files || []), ...(m.files_v2 || [])].map((f) => ({ kind: IMAGE.test(f.file_name || "") || f.file_kind === "image" ? "image" : "document", media_type: "", name: f.file_name || "" })),
+      ];
+      const text = blockText(content.filter((p) => typeof p === "string" || p.type === "text"));
+      if (text || attachments.length) messages.push({ role: "user", ts: m.created_at, text, ...(attachments.length ? { attachments } : {}) });
+      continue;
+    }
+    // An assistant message interleaves text, thinking, tool calls and their results in order.
+    let cur = null, lastCall = "";
+    const open = () => (cur ||= { role: "assistant", ts: m.created_at, text: "" });
+    const flush = () => { if (cur && (cur.text || cur.thinking || cur.tool_calls)) messages.push(cur); cur = null; };
+    for (const p of content) {
+      if (p.type === "text") { const c = open(); c.text += (c.text ? "\n\n" : "") + (p.text || ""); }
+      else if (p.type === "thinking" && p.thinking) { const c = open(); c.thinking = [c.thinking, p.thinking].filter(Boolean).join("\n"); }
+      else if (p.type === "tool_use") { const c = open(); lastCall = p.id || `${m.uuid}:${(c.tool_calls || []).length}`; (c.tool_calls ||= []).push({ id: lastCall, name: p.name, input: p.input }); }
+      else if (p.type === "tool_result") { flush(); messages.push({ role: "tool", ts: m.created_at, tool_use_id: p.tool_use_id || lastCall, tool_name: p.name, is_error: !!p.is_error, text: blockText(p.content).slice(0, 1_000_000) }); }
+    }
+    flush();
+  }
+  const models = [...new Set((conv.chat_messages || []).map((m) => m.model).filter(Boolean))];
+  return {
+    format: FORMAT, harness: "claude-ai", model: conv.model || models[0] || "", ...(models.length > 1 ? { models } : {}),
+    session_id: `claude-ai-${createHash("sha256").update(`claude-ai:${conv.uuid}`).digest("hex").slice(0, 16)}`,
+    title: conv.name || "", started_at: conv.created_at, ended_at: conv.updated_at, cwd: "", source: "claude-ai-export",
+    messages,
+  };
+}
+
+export function claudeAiSessions(convs) {
+  return convs.map(claudeAiSession).filter((s) => s.messages.some((m) => m.role === "user") && s.messages.some((m) => m.role === "assistant"));
+}
+
+export default {
+  id: "claude-ai",
+  name: "Claude (claude.ai, desktop and mobile chats)",
+  kind: "export",
+  how: "claude.ai → Settings → Privacy → Export data; download the zip from the email",
+  sniff: (l) => l.names.some((n) => /(^|\/)conversations\.json$/.test(n)) && l.names.some((n) => /(^|\/)users\.json$/.test(n)) && /"chat_messages"/.test(l.read(l.names.find((n) => /(^|\/)conversations\.json$/.test(n))).slice(0, 200000)),
+  *collect(input) { yield* claudeAiSessions(readClaudeAiExport(input)); },
+};

package/vendor/trace-collect/sources/claude-code.mjs

@@ -0,0 +1,4 @@
+// Claude Code: read in place by the scan (lib/normalize.mjs); listed here so every agent shows up in one registry.
+import path from "node:path";
+
+export default { id: "claude-code", name: "Claude Code", kind: "native", roots: (home) => [path.join(home, ".claude/projects")] };

package/vendor/trace-collect/sources/claude-desktop.mjs

@@ -0,0 +1,87 @@
+// Claude desktop app agent-mode sessions.
+// Directory: ~/Library/Application Support/Claude/local-agent-mode-sessions
+// Structure: <root>/<workspace-uuid>/<session-uuid>/local_<agent-uuid>/audit.jsonl
+//
+// The audit.jsonl files are in Claude Code JSONL format (type "user" / "assistant" / "system"
+// with message.role and message.content) but written by the desktop app's native agent runner.
+// They live at separate paths from ~/.claude/projects/ so they never overlap with the
+// "claude-code" native source.
+//
+// We reuse normalizeClaudeCode from normalize.mjs and re-label the harness "claude-desktop".
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { parseJsonl, normalizeClaudeCode, FORMAT } from "../normalize.mjs";
+
+const ROOT_REL = "Library/Application Support/Claude/local-agent-mode-sessions";
+
+/** Collect audit.jsonl paths: <root>/<workspace>/<session>/local_<agent>/audit.jsonl */
+function* findAuditFiles(root) {
+  let workspaces;
+  try { workspaces = fs.readdirSync(root); } catch { return; }
+  for (const ws of workspaces) {
+    const wsDir = path.join(root, ws);
+    let sessions;
+    try {
+      if (!fs.statSync(wsDir).isDirectory()) continue;
+      sessions = fs.readdirSync(wsDir);
+    } catch { continue; }
+    for (const sess of sessions) {
+      const sessDir = path.join(wsDir, sess);
+      let agents;
+      try {
+        if (!fs.statSync(sessDir).isDirectory()) continue;
+        agents = fs.readdirSync(sessDir);
+      } catch { continue; }
+      // The session's own agent is <session>/local_<id>/; helper ("ditto") agents it starts live in <session>/agent/.
+      let helpers = []; try { helpers = fs.readdirSync(path.join(sessDir, "agent")).map((h) => path.join("agent", h)); } catch {}
+      const main = agents.find((a) => a.startsWith("local_") && !a.startsWith("local_ditto_"));
+      for (const ag of [...agents, ...helpers]) {
+        const name = path.basename(ag);
+        if (!name.startsWith("local_")) continue;
+        const auditPath = path.join(sessDir, ag, "audit.jsonl");
+        try {
+          if (fs.statSync(auditPath).isFile()) yield { auditPath, wsId: ws, sessId: sess, agentId: name, parent: name.startsWith("local_ditto_") && main ? main : null };
+        } catch { /* skip */ }
+      }
+    }
+  }
+}
+
+export default {
+  id: "claude-desktop",
+  name: "Claude Desktop (agent-mode sessions)",
+  kind: "local",
+  roots: (home) => [path.join(home, ROOT_REL)],
+
+  *collect(root) {
+    for (const { auditPath, wsId, sessId, agentId, parent } of findAuditFiles(root)) {
+      let raw;
+      try { raw = fs.readFileSync(auditPath, "utf8"); } catch { continue; }
+      let rows;
+      try { rows = parseJsonl(raw); } catch { continue; }
+      if (!rows.length) continue;
+
+      // normalizeClaudeCode reads type:user/assistant rows.
+      // audit.jsonl rows also have _audit_timestamp / _audit_hmac / client_platform
+      // but the core fields match claude-code format.
+      let trace;
+      try { trace = normalizeClaudeCode(rows, { source: auditPath }); } catch { continue; }
+      if (!trace.messages.some((m) => m.role === "user")) continue;
+
+      // Re-label harness.
+      trace.harness = "claude-desktop";
+
+      // The agent folder name is the one id unique per conversation (rows carry both it and an inner run id).
+      trace.session_id = agentId;
+      if (parent) trace.parent_session_id = parent;
+      trace.cowork = { workspace_id: wsId, session_id: sessId };
+      // Rows record the session's working folder (its outputs/ folder) only on some lines.
+      trace.cwd = trace.cwd || rows.find((r) => typeof r.cwd === "string")?.cwd || "";
+      trace.format = FORMAT;
+
+      yield trace;
+    }
+  },
+};

package/vendor/trace-collect/sources/cline.mjs

@@ -0,0 +1,14 @@
+// Cline (VS Code extension: saoudrizwan.claude-dev)
+// Tasks: <vscode-globalStorage>/saoudrizwan.claude-dev/tasks/<id>/api_conversation_history.json
+// See _cline-family.mjs for the shared format and conversion logic.
+
+import path from "node:path";
+import { clineRoots, collectClineRoot } from "./_cline-family.mjs";
+
+export default {
+  id: "cline",
+  name: "Cline (VS Code extension)",
+  kind: "local",
+  roots: (home) => clineRoots(home, "saoudrizwan.claude-dev"),
+  *collect(root) { yield* collectClineRoot(root, "cline"); },
+};

package/vendor/trace-collect/sources/codex.mjs

@@ -0,0 +1,4 @@
+// Codex (CLI, IDE and desktop app): read in place by the scan (lib/normalize.mjs); listed here so every agent shows up in one registry.
+import path from "node:path";
+
+export default { id: "codex", name: "Codex (CLI, IDE and desktop app)", kind: "native", roots: (home) => [path.join(home, ".codex/sessions"), path.join(home, ".codex/archived_sessions")] };

package/vendor/trace-collect/sources/continue.mjs

@@ -0,0 +1,117 @@
+// Continue VS Code extension session history.
+// Files: ~/.continue/sessions/<sessionId>.json  (set CONTINUE_GLOBAL_DIR to override root)
+// Also ~/.continue-cli/sessions/ (CLI variant)
+//
+// Each file is a Session JSON:
+//   { sessionId, title, workspaceDirectory, history: ChatHistoryItem[], mode?, chatModelTitle?, usage? }
+// where each ChatHistoryItem is { message: { role, content, toolCalls?, ... }, ... }
+// roles: "user" | "assistant" | "thinking" | "tool" | "system"
+// content: string | MessagePart[]   MessagePart: { type, text?, ... }
+
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { FORMAT } from "../normalize.mjs";
+
+const SESSION_DIRS = [
+  ".continue/sessions",
+  ".continue-cli/sessions",
+];
+
+function readJson(p) {
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return null; }
+}
+
+function messageText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return content == null ? "" : JSON.stringify(content);
+  return content.map((p) => {
+    if (typeof p === "string") return p;
+    if (p?.type === "text" || p?.type === "imageUrl") return p.text || "";
+    if (p?.type === "image_url") return "";
+    return "";
+  }).filter(Boolean).join("\n");
+}
+
+function buildMessages(history) {
+  const messages = [];
+  const callNames = new Map();
+  for (const item of (history || [])) {
+    const m = item?.message;
+    if (!m || typeof m !== "object") continue;
+    const role = m.role;
+    const text = messageText(m.content);
+    if (role === "system") continue;
+    if (role === "user") {
+      if (text) messages.push({ role: "user", text });
+    } else if (role === "assistant") {
+      const tool_calls = (m.toolCalls || []).map((tc) => {
+        const id = tc.id || tc.call_id || `call-${messages.length}`;
+        const name = tc.function?.name || tc.name || "tool";
+        let input = tc.function?.arguments ?? tc.arguments ?? tc.input ?? {};
+        if (typeof input === "string") { try { input = JSON.parse(input); } catch { /* keep */ } }
+        callNames.set(id, name);
+        return { id, name, input };
+      });
+      if (text || tool_calls.length) {
+        messages.push({ role: "assistant", text, ...(tool_calls.length ? { tool_calls } : {}) });
+      }
+    } else if (role === "thinking") {
+      const thinking = messageText(m.content);
+      if (thinking) messages.push({ role: "assistant", text: "", thinking });
+    } else if (role === "tool") {
+      const toolCallId = m.toolCallId || "";
+      messages.push({ role: "tool", tool_use_id: toolCallId, tool_name: callNames.get(toolCallId) || m.name || "", is_error: false, text: text.slice(0, 1_000_000) });
+    }
+  }
+  return messages;
+}
+
+export default {
+  id: "continue",
+  name: "Continue (VS Code extension)",
+  kind: "local",
+  roots: (home) => SESSION_DIRS.map((d) => path.join(home, d)).filter((p) => fs.existsSync(p)),
+
+  *collect(root) {
+    let entries;
+    try { entries = fs.readdirSync(root); } catch { return; }
+    for (const f of entries) {
+      if (!f.endsWith(".json") || f === "sessions.json") continue;
+      const filePath = path.join(root, f);
+      const data = readJson(filePath);
+      if (!data || !Array.isArray(data.history)) continue;
+
+      const messages = buildMessages(data.history);
+      if (!messages.some((m) => m.role === "user")) continue;
+
+      const sessionId = data.sessionId || f.slice(0, -5);
+      let started = data.dateCreated ? new Date(data.dateCreated).toISOString() : null;
+      if (!started) {
+        try { started = new Date(fs.statSync(filePath).birthtimeMs).toISOString(); } catch { }
+      }
+      let ended = null;
+      try { ended = new Date(fs.statSync(filePath).mtimeMs).toISOString(); } catch { }
+
+      const model = data.chatModelTitle || "";
+      const usage = data.usage ? {
+        ...(data.usage.inputTokens != null ? { input_tokens: data.usage.inputTokens } : {}),
+        ...(data.usage.outputTokens != null ? { output_tokens: data.usage.outputTokens } : {}),
+      } : undefined;
+
+      yield {
+        format: FORMAT,
+        harness: "continue",
+        session_id: createHash("sha256").update(`continue:${sessionId}`).digest("hex").slice(0, 16),
+        model,
+        title: data.title || "",
+        started_at: started,
+        ended_at: ended,
+        cwd: data.workspaceDirectory || "",
+        ...(usage && Object.keys(usage).length ? { usage } : {}),
+        source: filePath,
+        messages,
+      };
+    }
+  },
+};

package/vendor/trace-collect/sources/copilot-chat.mjs

@@ -0,0 +1,145 @@
+// GitHub Copilot Chat session files.
+//
+// Locations (macOS):
+//   ~/Library/Application Support/<App>/User/workspaceStorage/*/chatSessions/*.json
+//   ~/Library/Application Support/<App>/User/globalStorage/github.copilot-chat/emptyWindowChatSessions/*.json
+//
+// Apps: Code, Code - Insiders, Cursor, Windsurf, VSCodium (and Linux ~/.config equivalents)
+//
+// Format: each file is a CopilotChatSession JSON:
+//   { requests: [{ message: string|{text?}, response: [{value}]?, result?: {errorDetails?} }]* }
+// The session ID comes from the filename.  Workspace path comes from sibling workspace.json.
+//
+// The "cursor" and "claude-code" native sources read agent transcripts from different paths
+// and never read chatSessions files — no deduplication needed.
+
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { FORMAT } from "../normalize.mjs";
+
+const VSCODE_APPS_MAC = [
+  "Library/Application Support/Code/User",
+  "Library/Application Support/Code - Insiders/User",
+  "Library/Application Support/Cursor/User",
+  "Library/Application Support/Windsurf/User",
+  "Library/Application Support/VSCodium/User",
+];
+const VSCODE_APPS_LINUX = [
+  ".config/Code/User",
+  ".config/Code - Insiders/User",
+  ".config/Cursor/User",
+  ".config/Windsurf/User",
+  ".config/VSCodium/User",
+];
+
+function appUserDirs(home) {
+  return [...VSCODE_APPS_MAC, ...VSCODE_APPS_LINUX].map((p) => path.join(home, p));
+}
+
+function* chatSessionDirs(home) {
+  for (const userDir of appUserDirs(home)) {
+    // workspaceStorage/*/chatSessions
+    const wsRoot = path.join(userDir, "workspaceStorage");
+    try {
+      for (const ws of fs.readdirSync(wsRoot)) {
+        const csDir = path.join(wsRoot, ws, "chatSessions");
+        if (fs.existsSync(csDir)) yield { dir: csDir, wsDir: path.join(wsRoot, ws) };
+      }
+    } catch { /* ok */ }
+    // globalStorage/github.copilot-chat/emptyWindowChatSessions
+    const ewDir = path.join(userDir, "globalStorage", "github.copilot-chat", "emptyWindowChatSessions");
+    if (fs.existsSync(ewDir)) yield { dir: ewDir, wsDir: null };
+  }
+}
+
+function readJson(p) {
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return null; }
+}
+
+function msgText(m) {
+  if (!m) return "";
+  if (typeof m === "string") return m;
+  if (typeof m === "object") return m.text || m.content || JSON.stringify(m);
+  return String(m);
+}
+
+function respText(parts) {
+  if (!Array.isArray(parts)) return "";
+  return parts.map((p) => {
+    if (!p) return "";
+    if (typeof p.value === "string") return p.value;
+    if (p.value && typeof p.value === "object") return p.value.value || p.value.text || JSON.stringify(p.value);
+    return "";
+  }).filter(Boolean).join("");
+}
+
+function buildMessages(requests) {
+  const messages = [];
+  for (const req of (requests || [])) {
+    const userText = msgText(req.message);
+    if (userText) messages.push({ role: "user", text: userText });
+    const asst = respText(req.response);
+    const isError = !!req.result?.errorDetails;
+    if (asst) {
+      messages.push({ role: "assistant", text: asst, ...(isError ? { error: req.result.errorDetails.message || "" } : {}) });
+    }
+  }
+  return messages;
+}
+
+export default {
+  id: "copilot-chat",
+  name: "GitHub Copilot Chat",
+  kind: "local",
+  roots: (home) => {
+    const roots = [];
+    for (const { dir } of chatSessionDirs(home)) {
+      if (!roots.includes(dir)) roots.push(dir);
+    }
+    return roots;
+  },
+
+  *collect(root, ctx) {
+    // root is one chatSessions dir; find workspace path from sibling workspace.json
+    const wsDir = path.dirname(root);
+    let workspacePath = "";
+    const wsJson = readJson(path.join(wsDir, "workspace.json"));
+    if (wsJson?.folder) {
+      try { workspacePath = new URL(wsJson.folder).pathname; } catch { workspacePath = wsJson.folder; }
+    }
+
+    let entries;
+    try { entries = fs.readdirSync(root); } catch { return; }
+
+    for (const f of entries) {
+      if (!f.endsWith(".json")) continue;
+      const sessionId = f.slice(0, -5);
+      const data = readJson(path.join(root, f));
+      if (!data || !Array.isArray(data.requests)) continue;
+
+      const messages = buildMessages(data.requests);
+      if (!messages.some((m) => m.role === "user")) continue;
+
+      let started = null, ended = null;
+      try {
+        const st = fs.statSync(path.join(root, f));
+        ended = new Date(st.mtimeMs).toISOString();
+        started = new Date(st.birthtimeMs).toISOString();
+      } catch { }
+
+      yield {
+        format: FORMAT,
+        harness: "copilot-chat",
+        session_id: createHash("sha256").update(`copilot-chat:${sessionId}`).digest("hex").slice(0, 16),
+        model: "",
+        title: "",
+        started_at: started,
+        ended_at: ended,
+        cwd: workspacePath,
+        source: path.join(root, f),
+        messages,
+      };
+    }
+  },
+};