@danforthh/aimprint-sync 1.0.0

package/dist/index.js

@@ -0,0 +1,417 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// index.ts
+var import_node_fs2 = __toESM(require("node:fs"));
+var import_node_path2 = __toESM(require("node:path"));
+var import_node_os2 = __toESM(require("node:os"));
+var import_node_readline = __toESM(require("node:readline"));
+
+// cursor.ts
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_os = __toESM(require("node:os"));
+var CURSOR_DIR = import_node_path.default.join(import_node_os.default.homedir(), ".claude-tracker");
+var CURSOR_FILE = import_node_path.default.join(CURSOR_DIR, "cursor.json");
+function loadCursors() {
+  try {
+    if (!import_node_fs.default.existsSync(CURSOR_FILE)) return {};
+    return JSON.parse(import_node_fs.default.readFileSync(CURSOR_FILE, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveCursors(cursors) {
+  import_node_fs.default.mkdirSync(CURSOR_DIR, { recursive: true });
+  import_node_fs.default.writeFileSync(CURSOR_FILE, JSON.stringify(cursors, null, 2));
+}
+
+// classifier.ts
+var RE_REFINEMENT = /refactor|simplif|improve|clean|optim|restructur|reorganis|reorganiz/i;
+var RE_QUALITY = /test|coverage|jest|vitest|eslint|lint|review|security|audit|sonar/i;
+var RE_OPS = /deploy|docker|ci\b|cd\b|pipeline|github.?action|kubernetes|k8s|helm|terraform|wrangler deploy|npm run build|npm run deploy/i;
+var RE_PLANNING = /plan|prd|ticket|story|roadmap|strateg|epic|sprint|backlog|clickup|jira|milestone/i;
+var RE_ANALYSIS = /explai|analys|analyz|understand|how does|what is|why |architecture|investigate|research|explore/i;
+var RE_WRITING = /implement|write|create|add|build|generat|develop|code/i;
+var RE_DEBUG = /fix|bug|error|crash|broken|debug|issue|problem|fail/i;
+var RE_DOCUMENT = /powerpoint|presentation|slides|slide.?deck|\.pptx|word.?doc|\.docx|spreadsheet|\.xlsx|generate.*(report|document|pdf)|pptx|docx|xlsx/i;
+var RE_BASH_OPS = /docker|kubectl|helm|wrangler deploy|terraform|npm run (deploy|prod)|yarn deploy|gh pr create|gh release/i;
+var RE_BASH_QUAL = /jest|vitest|npm test|yarn test|eslint|prettier|lint|coverage/i;
+var RE_BASH_DOC = /\.pptx\b|\.docx\b|\.xlsx\b|python-pptx/i;
+function classifyRequest(input) {
+  const { toolNames, bashCommands, userMessage = "" } = input;
+  if (bashCommands.some((c) => RE_BASH_OPS.test(c))) return "code_process";
+  if (bashCommands.some((c) => RE_BASH_QUAL.test(c))) return "quality";
+  if (bashCommands.some((c) => RE_BASH_DOC.test(c))) return "document_writing";
+  if (toolNames.includes("TodoWrite")) return "planning";
+  if (toolNames.some((t) => ["Edit", "Write", "NotebookEdit"].includes(t))) return "code_writing";
+  if (toolNames.length > 0 && toolNames.every((t) => ["Read", "Grep", "Glob"].includes(t))) return "";
+  if (toolNames.length === 0 && userMessage) {
+    if (RE_OPS.test(userMessage)) return "code_process";
+    if (RE_QUALITY.test(userMessage)) return "quality";
+    if (RE_DOCUMENT.test(userMessage)) return "document_writing";
+    if (RE_PLANNING.test(userMessage)) return "planning";
+    if (RE_REFINEMENT.test(userMessage)) return "refinement";
+    if (RE_ANALYSIS.test(userMessage)) return "deep_analysis";
+    if (RE_WRITING.test(userMessage)) return "code_writing";
+    if (RE_DEBUG.test(userMessage)) return "code_writing";
+  }
+  return "";
+}
+function classify(input) {
+  const { firstMessage = "", toolCounts, bashCommands, durationMinutes, requestCount } = input;
+  if (requestCount <= 3 && toolCounts.total <= 2 && durationMinutes < 3) return "random";
+  const opsCount = bashCommands.filter((c) => RE_BASH_OPS.test(c)).length;
+  const qualCount = bashCommands.filter((c) => RE_BASH_QUAL.test(c)).length;
+  const totalBash = bashCommands.length || 1;
+  const opsRatio = opsCount / totalBash;
+  const bashHasOps = opsCount >= 2 || opsCount >= 1 && opsRatio >= 0.3;
+  const bashHasQual = qualCount >= 1;
+  const docBashCount = bashCommands.filter((c) => RE_BASH_DOC.test(c)).length;
+  const signals = {
+    planning: (toolCounts.todo > 0 ? 3 : 0) + (RE_PLANNING.test(firstMessage) ? 2 : 0),
+    code_process: (bashHasOps ? 4 : 0) + (RE_OPS.test(firstMessage) ? 2 : 0),
+    quality: (bashHasQual ? 4 : 0) + (RE_QUALITY.test(firstMessage) ? 2 : 0),
+    document_writing: (docBashCount >= 1 ? 4 : 0) + (RE_DOCUMENT.test(firstMessage) ? 3 : 0),
+    refinement: (RE_REFINEMENT.test(firstMessage) ? 3 : 0) + (toolCounts.edit > 2 && toolCounts.bash === 0 ? 1 : 0),
+    deep_analysis: (toolCounts.read > 8 && toolCounts.edit < 2 ? 4 : 0) + (RE_ANALYSIS.test(firstMessage) ? 2 : 0),
+    code_writing: (toolCounts.edit > 3 ? 3 : 0) + (RE_WRITING.test(firstMessage) ? 2 : 0) + (RE_DEBUG.test(firstMessage) ? 1 : 0)
+  };
+  const top = Object.entries(signals).sort((a, b) => b[1] - a[1])[0];
+  if (top[1] === 0) {
+    if (toolCounts.edit > 2) return "code_writing";
+    if (toolCounts.read > 5) return "deep_analysis";
+    if (requestCount <= 4) return "random";
+    return "other";
+  }
+  return top[0];
+}
+
+// index.ts
+var ALLOWED_ENV_KEYS = /* @__PURE__ */ new Set(["WORKER_URL", "SYNC_TOKEN"]);
+var envCandidates = [
+  import_node_path2.default.join(import_node_os2.default.homedir(), ".aimprint"),
+  import_node_path2.default.join(process.cwd(), "sync", ".env")
+];
+for (const f of envCandidates) {
+  if (import_node_fs2.default.existsSync(f)) {
+    for (const line of import_node_fs2.default.readFileSync(f, "utf8").split("\n")) {
+      const m = line.match(/^([A-Z_]+)=(.+)$/);
+      if (m && ALLOWED_ENV_KEYS.has(m[1]) && !process.env[m[1]]) process.env[m[1]] = m[2].trim();
+    }
+    break;
+  }
+}
+var WORKER_URL = process.env["WORKER_URL"];
+var SYNC_TOKEN = process.env["SYNC_TOKEN"];
+if (!WORKER_URL || !SYNC_TOKEN) {
+  console.error("Error: WORKER_URL and SYNC_TOKEN are required.");
+  console.error("Create ~/.aimprint with:");
+  console.error("  WORKER_URL=https://your-worker.workers.dev");
+  console.error("  SYNC_TOKEN=your-sync-token");
+  process.exit(1);
+}
+var CLAUDE_PROJECTS_DIR = import_node_path2.default.join(import_node_os2.default.homedir(), ".claude", "projects");
+var REAL_PROJECTS_DIR = (() => {
+  try {
+    return import_node_fs2.default.realpathSync(CLAUDE_PROJECTS_DIR);
+  } catch {
+    return CLAUDE_PROJECTS_DIR;
+  }
+})();
+var MACHINE = import_node_os2.default.hostname();
+var BATCH_SIZE = 100;
+function estimateCost(model, input, output, cacheRead, cacheCreation) {
+  const p = {
+    "claude-fable-5": [10, 50, 1, 12.5],
+    "claude-opus-4-8": [5, 25, 0.5, 6.25],
+    "claude-opus-4-7": [5, 25, 0.5, 6.25],
+    "claude-opus-4-6": [5, 25, 0.5, 6.25],
+    "claude-opus-4-5": [5, 25, 0.5, 6.25],
+    "claude-sonnet-4-6": [3, 15, 0.3, 3.75],
+    "claude-sonnet-4-5": [3, 15, 0.3, 3.75],
+    "claude-haiku-4-5": [1, 5, 0.1, 1.25]
+  };
+  const [pi, po, pr, pc] = p[model] ?? [3, 15, 0.3, 3.75];
+  return (input * pi + output * po + cacheRead * pr + cacheCreation * pc) / 1e6;
+}
+var TICKET_RE = /\b(PROTOP-\d+|PORTV4-\d+|NODE20-\d+)\b/i;
+function extractTicket(branch) {
+  if (!branch) return void 0;
+  const m = branch.match(TICKET_RE);
+  return m ? m[1].toUpperCase() : void 0;
+}
+async function parseFile(filePath, offset) {
+  const stat = import_node_fs2.default.statSync(filePath);
+  if (stat.size <= offset) return { records: /* @__PURE__ */ new Map(), sessions: /* @__PURE__ */ new Map(), newOffset: offset };
+  const fd = import_node_fs2.default.openSync(filePath, "r");
+  const stream = import_node_fs2.default.createReadStream(filePath, { start: offset, fd, autoClose: true });
+  const rl = import_node_readline.default.createInterface({ input: stream, crlfDelay: Infinity });
+  const records = /* @__PURE__ */ new Map();
+  const sessions = /* @__PURE__ */ new Map();
+  let newOffset = offset;
+  const lastUserMessage = /* @__PURE__ */ new Map();
+  for await (const line of rl) {
+    newOffset += Buffer.byteLength(line + "\n");
+    if (!line.trim()) continue;
+    let d;
+    try {
+      d = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const sid = d.sessionId ?? "";
+    if (!sid) continue;
+    if (!sessions.has(sid)) {
+      sessions.set(sid, {
+        sessionId: sid,
+        cwd: d.cwd ?? "",
+        model: "",
+        entrypoint: d.entrypoint ?? "",
+        gitBranch: d.gitBranch ?? "",
+        toolCounts: { edit: 0, bash: 0, read: 0, todo: 0, agent: 0, total: 0 },
+        bashCommands: [],
+        requestCount: 0
+      });
+    }
+    const sess = sessions.get(sid);
+    if (d.cwd) sess.cwd = d.cwd;
+    if (d.entrypoint) sess.entrypoint = d.entrypoint;
+    if (d.gitBranch) sess.gitBranch = d.gitBranch;
+    if (d.type === "user" && d.message?.role === "user") {
+      const content = d.message.content;
+      let msgText;
+      if (Array.isArray(content)) {
+        const textBlock = content.find((b) => b["type"] === "text");
+        if (textBlock && "text" in textBlock) {
+          msgText = String(textBlock["text"]).slice(0, 500);
+        }
+      } else if (typeof content === "string") {
+        msgText = content.slice(0, 500);
+      }
+      if (msgText) {
+        if (!sess.firstMessage) sess.firstMessage = msgText;
+        lastUserMessage.set(sid, msgText);
+      }
+    }
+    const turnToolNames = [];
+    const turnBashCmds = [];
+    if (d.type === "assistant" && d.message?.content) {
+      for (const block of d.message.content) {
+        if (block.type !== "tool_use") continue;
+        const name = block.name ?? "";
+        sess.toolCounts.total++;
+        if (/^(Edit|Write|NotebookEdit)$/.test(name)) sess.toolCounts.edit++;
+        else if (name === "Bash") {
+          sess.toolCounts.bash++;
+          const cmd = String(block.input?.["command"] ?? "");
+          if (cmd) {
+            sess.bashCommands.push(cmd.slice(0, 200));
+            turnBashCmds.push(cmd.slice(0, 200));
+          }
+        } else if (/^(Read|Grep|Glob)$/.test(name)) sess.toolCounts.read++;
+        else if (name === "TodoWrite") sess.toolCounts.todo++;
+        else if (name === "Agent") sess.toolCounts.agent++;
+        turnToolNames.push(name);
+      }
+    }
+    if (d.type === "assistant" && d.requestId && d.message?.usage) {
+      const usage = d.message.usage;
+      const input = usage.input_tokens ?? 0;
+      const output = usage.output_tokens ?? 0;
+      const cacheR = usage.cache_read_input_tokens ?? 0;
+      const cacheC = usage.cache_creation_input_tokens ?? 0;
+      if (output > 0) {
+        sess.requestCount++;
+        sess.model = d.message.model ?? sess.model;
+        if (!sess.firstMessageAt || d.timestamp < sess.firstMessageAt) sess.firstMessageAt = d.timestamp;
+        if (!sess.lastMessageAt || d.timestamp > sess.lastMessageAt) sess.lastMessageAt = d.timestamp;
+        const project = import_node_path2.default.basename(d.cwd ?? sess.cwd ?? "unknown");
+        const ticket = extractTicket(d.gitBranch ?? sess.gitBranch);
+        const ts = d.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+        if (!records.has(d.requestId)) {
+          const reqCategory = classifyRequest({
+            toolNames: turnToolNames,
+            bashCommands: turnBashCmds,
+            userMessage: lastUserMessage.get(sid) ?? ""
+          });
+          records.set(d.requestId, {
+            request_id: d.requestId,
+            session_id: sid,
+            timestamp: ts,
+            date: ts.slice(0, 10),
+            machine: MACHINE,
+            project,
+            cwd: d.cwd ?? sess.cwd,
+            model: sess.model,
+            entrypoint: d.entrypoint ?? sess.entrypoint,
+            git_branch: d.gitBranch ?? sess.gitBranch ?? void 0,
+            ticket,
+            input_tokens: input,
+            output_tokens: output,
+            cache_read: cacheR,
+            cache_creation: cacheC,
+            is_sidechain: d.isSidechain ? 1 : 0,
+            cost_usd: estimateCost(sess.model, input, output, cacheR, cacheC),
+            request_category: reqCategory
+          });
+        }
+      }
+    }
+  }
+  return { records, sessions, newOffset };
+}
+async function postBatch(records, sessions, attempt = 1) {
+  try {
+    const res = await fetch(`${WORKER_URL}/ingest`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Sync-Token": SYNC_TOKEN },
+      body: JSON.stringify({ records, sessions })
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      if (res.status >= 500 && attempt < 3) {
+        await new Promise((r) => setTimeout(r, 1e3 * attempt));
+        return postBatch(records, sessions, attempt + 1);
+      }
+      throw new Error(`Ingest failed ${res.status}: ${text}`);
+    }
+    const result = await res.json();
+    console.log(`  \u2192 inserted: ${result.inserted}, skipped: ${result.skipped}`);
+  } catch (e) {
+    if (attempt < 3 && e instanceof TypeError) {
+      await new Promise((r) => setTimeout(r, 1e3 * attempt));
+      return postBatch(records, sessions, attempt + 1);
+    }
+    throw e;
+  }
+}
+async function main() {
+  console.log(`Aimprint sync agent`);
+  console.log(`Machine: ${MACHINE}`);
+  console.log(`Scanning: ${CLAUDE_PROJECTS_DIR}
+`);
+  if (!import_node_fs2.default.existsSync(CLAUDE_PROJECTS_DIR)) {
+    console.error(`Directory not found: ${CLAUDE_PROJECTS_DIR}`);
+    process.exit(1);
+  }
+  const cursors = loadCursors();
+  const allRecords = /* @__PURE__ */ new Map();
+  const allSessions = /* @__PURE__ */ new Map();
+  for (const projectDir of import_node_fs2.default.readdirSync(CLAUDE_PROJECTS_DIR)) {
+    const fullDir = import_node_path2.default.join(CLAUDE_PROJECTS_DIR, projectDir);
+    if (!import_node_fs2.default.statSync(fullDir).isDirectory()) continue;
+    for (const file of import_node_fs2.default.readdirSync(fullDir)) {
+      if (!file.endsWith(".jsonl")) continue;
+      const filePath = import_node_path2.default.join(fullDir, file);
+      try {
+        const realFilePath = import_node_fs2.default.realpathSync(filePath);
+        if (!realFilePath.startsWith(REAL_PROJECTS_DIR + import_node_path2.default.sep)) continue;
+      } catch {
+        continue;
+      }
+      const offset = cursors[filePath] ?? 0;
+      try {
+        const { records: records2, sessions, newOffset } = await parseFile(filePath, offset);
+        for (const [k, v] of records2) allRecords.set(k, v);
+        for (const [k, v] of sessions) {
+          const existing = allSessions.get(k);
+          if (!existing) {
+            allSessions.set(k, v);
+          } else {
+            existing.requestCount += v.requestCount;
+            existing.toolCounts.edit += v.toolCounts.edit;
+            existing.toolCounts.bash += v.toolCounts.bash;
+            existing.toolCounts.read += v.toolCounts.read;
+            existing.toolCounts.todo += v.toolCounts.todo;
+            existing.toolCounts.agent += v.toolCounts.agent;
+            existing.toolCounts.total += v.toolCounts.total;
+            existing.bashCommands.push(...v.bashCommands);
+            if (!existing.firstMessage && v.firstMessage) existing.firstMessage = v.firstMessage;
+            if (!existing.model && v.model) existing.model = v.model;
+            if (!existing.cwd && v.cwd) existing.cwd = v.cwd;
+            if (!existing.gitBranch && v.gitBranch) existing.gitBranch = v.gitBranch;
+            if (!existing.entrypoint && v.entrypoint) existing.entrypoint = v.entrypoint;
+            if (v.firstMessageAt && (!existing.firstMessageAt || v.firstMessageAt < existing.firstMessageAt))
+              existing.firstMessageAt = v.firstMessageAt;
+            if (v.lastMessageAt && (!existing.lastMessageAt || v.lastMessageAt > existing.lastMessageAt))
+              existing.lastMessageAt = v.lastMessageAt;
+          }
+        }
+        cursors[filePath] = newOffset;
+      } catch (e) {
+        console.warn(`  Warning: could not parse ${filePath}: ${e}`);
+      }
+    }
+  }
+  console.log(`Found ${allRecords.size} new request records across ${allSessions.size} sessions`);
+  if (allRecords.size === 0) {
+    console.log("Nothing new to sync.");
+    saveCursors(cursors);
+    return;
+  }
+  const sessionMetas = [];
+  for (const [, sess] of allSessions) {
+    const duration = (() => {
+      if (!sess.firstMessageAt || !sess.lastMessageAt) return 0;
+      const start = new Date(sess.firstMessageAt).getTime();
+      const end = new Date(sess.lastMessageAt).getTime();
+      if (isNaN(start) || isNaN(end) || end < start) return 0;
+      return (end - start) / 6e4;
+    })();
+    const input = {
+      firstMessage: sess.firstMessage,
+      toolCounts: sess.toolCounts,
+      bashCommands: sess.bashCommands,
+      durationMinutes: duration,
+      requestCount: sess.requestCount
+    };
+    sessionMetas.push({
+      session_id: sess.sessionId,
+      category: classify(input),
+      category_source: "auto",
+      first_message: sess.firstMessage,
+      tool_summary: JSON.stringify({
+        edit: sess.toolCounts.edit,
+        bash: sess.toolCounts.bash,
+        read: sess.toolCounts.read,
+        todo: sess.toolCounts.todo,
+        agent: sess.toolCounts.agent
+      })
+    });
+  }
+  const records = Array.from(allRecords.values());
+  const totalBatches = Math.ceil(records.length / BATCH_SIZE);
+  for (let i = 0; i < records.length; i += BATCH_SIZE) {
+    const batch = records.slice(i, i + BATCH_SIZE);
+    console.log(`Posting batch ${Math.floor(i / BATCH_SIZE) + 1}/${totalBatches}...`);
+    await postBatch(batch, sessionMetas);
+  }
+  saveCursors(cursors);
+  console.log("\nSync complete.");
+}
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@danforthh/aimprint-sync",
+  "version": "1.0.0",
+  "description": "Sync Claude Code token logs to your Aimprint dashboard",
+  "type": "commonjs",
+  "bin": {
+    "aimprint-sync": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "node build.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "esbuild": "^0.25.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Danforthhh/Aimprint.git"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "token",
+    "usage",
+    "tracker"
+  ],
+  "license": "MIT"
+}