claude-session-insights 0.3.0

package/src/ai-analyze.js

@@ -0,0 +1,277 @@
+// AI-powered analysis using Claude Code CLI
+// Manually triggered — streams output from `claude` via SSE.
+
+import { spawn, execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+// Strip all Claude Code env vars so spawned claude processes don't think they're nested
+const cleanEnv = Object.fromEntries(
+  Object.entries(process.env).filter(([k]) => !k.startsWith("CLAUDE"))
+);
+
+const execFileAsync = promisify(execFile);
+
+const MODELS = [
+  { id: "claude-sonnet-4-6", label: "Sonnet 4.6", family: "sonnet" },
+  { id: "claude-opus-4-6", label: "Opus 4.6", family: "opus" },
+  { id: "claude-haiku-4-5", label: "Haiku 4.5", family: "haiku" },
+];
+
+let detectedDefaultModel = "claude-sonnet-4-6";
+
+function prettyModelName(modelId) {
+  if (!modelId) return null;
+  const m = MODELS.find(m => m.id === modelId);
+  if (m) return m.label;
+  // Fallback: clean up the raw ID
+  return modelId.replace("claude-", "").replace(/-/g, " ").replace(/(\d+) (\d+)/, "$1.$2");
+}
+
+/**
+ * Detect the default model from Claude CLI config.
+ * Called once at startup — non-blocking, best-effort.
+ */
+export async function detectDefaultModel() {
+  try {
+    const { stdout } = await execFileAsync("claude", ["config", "get", "model"], {
+      timeout: 5000,
+      env: cleanEnv,
+    });
+    const model = stdout.trim();
+    if (model && model !== "undefined" && model !== "null") {
+      detectedDefaultModel = model;
+    }
+  } catch {
+    // Ignore — we'll detect from the first stream result instead
+  }
+}
+
+function buildDataSnapshot(scoredData) {
+  const { sessions, overallScore, badges, dailyScores, overallSummary } = scoredData;
+
+  const totalCost = sessions.reduce((s, x) => s + x.totals.estimatedCost, 0);
+  const totalTokens = sessions.reduce((s, x) => s + x.totals.totalTokens, 0);
+  const avgCacheHit = sessions.length > 0
+    ? sessions.reduce((s, x) => s + x.totals.cacheHitRate, 0) / sessions.length : 0;
+
+  const topSessions = [...sessions]
+    .sort((a, b) => b.totals.estimatedCost - a.totals.estimatedCost)
+    .slice(0, 10)
+    .map(s => ({
+      project: s.project,
+      model: s.model,
+      score: s.score,
+      messages: s.totals.userMessages,
+      tokens: s.totals.totalTokens,
+      cost: s.totals.estimatedCost.toFixed(2),
+      cacheHitRate: (s.totals.cacheHitRate * 100).toFixed(0) + '%',
+      toolCalls: s.totals.toolCalls,
+      toolRatio: s.totals.userMessages > 0
+        ? (s.totals.toolCalls / s.totals.userMessages).toFixed(1) + 'x'
+        : 'n/a',
+      suggestedModel: s.suggestedModel || null,
+      summary: s.summary,
+    }));
+
+  const modelCounts = {};
+  for (const s of sessions) {
+    const m = s.model || 'unknown';
+    const family = m.includes('opus') ? 'opus' : m.includes('haiku') ? 'haiku' : 'sonnet';
+    modelCounts[family] = (modelCounts[family] || 0) + 1;
+  }
+
+  return JSON.stringify({
+    overview: {
+      totalSessions: sessions.length,
+      overallScore,
+      totalCost: '$' + totalCost.toFixed(2),
+      totalTokens,
+      avgCacheHitRate: (avgCacheHit * 100).toFixed(0) + '%',
+      badges: badges.map(b => ({ name: b.name, negative: b.negative })),
+      modelDistribution: modelCounts,
+    },
+    dailyScores: dailyScores.slice(-14),
+    topSessionsByCost: topSessions,
+    staticInsights: {
+      patterns: overallSummary?.patterns || [],
+      recommendations: overallSummary?.recommendations || [],
+    },
+  }, null, 2);
+}
+
+function buildPrompt(dataSnapshot) {
+  return `You are analyzing a developer's Claude Code usage data. Your job is to find non-obvious patterns and give specific, actionable advice that goes beyond the static rule-based analysis already shown to the user.
+
+Here is their usage data:
+${dataSnapshot}
+
+Analyze this data and provide insights in the following format. Be specific — reference actual numbers, sessions, and projects. Be concise — no filler.
+
+## Key Patterns
+2-3 non-obvious patterns you notice (things the static rules might miss — e.g. time-of-day patterns, project-specific habits, cost trajectory trends, session clustering).
+
+## Biggest Opportunities
+2-3 specific workflow changes that would have the highest impact on cost or efficiency. Quantify the potential savings where possible (e.g. "switching to Sonnet for your X project sessions could save ~$Y/week").
+
+## What's Working Well
+1-2 things the user is doing right that they should keep doing.
+
+## Standout Session
+Pick the single most interesting session (most expensive, most efficient, or most unusual) and explain what makes it notable and what can be learned from it.
+
+Keep the entire response under 400 words. Use markdown formatting.`;
+}
+
+export { buildPrompt, buildDataSnapshot };
+
+let cachedResult = null;
+const activeChildren = new Set();
+
+/**
+ * Kill all in-flight claude processes (called on server shutdown).
+ */
+export function killActiveProcesses() {
+  for (const child of activeChildren) {
+    if (child.exitCode === null) child.kill();
+  }
+  activeChildren.clear();
+}
+
+/**
+ * Stream AI analysis to an SSE response.
+ * Sends: { event: "model", data: modelId }
+ *        { event: "chunk", data: text }
+ *        { event: "done", data: { generatedAt } }
+ *        { event: "error", data: { message } }
+ */
+export function streamAIAnalysis(scoredData, res, modelId) {
+  const dataSnapshot = buildDataSnapshot(scoredData);
+  const prompt = buildPrompt(dataSnapshot);
+
+  const args = ["-p", "-", "--output-format", "stream-json", "--verbose"];
+  if (modelId) {
+    args.push("--model", modelId);
+  }
+
+  // Send the model being used
+  const resolvedModel = modelId || "default";
+  console.log(`[ai] Starting analysis (model: ${resolvedModel})`);
+  res.write(`event: model\ndata: ${JSON.stringify(resolvedModel)}\n\n`);
+
+  const child = spawn("claude", args, {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: cleanEnv,
+  });
+  activeChildren.add(child);
+
+  // Pipe prompt via stdin to avoid CLI argument length limits
+  child.stdin.write(prompt);
+  child.stdin.end();
+
+  let fullContent = "";
+  let errOutput = "";
+  let detectedModel = modelId || detectedDefaultModel || null;
+  let lineBuf = "";
+
+  child.stdout.on("data", (buf) => {
+    lineBuf += buf.toString();
+    const lines = lineBuf.split("\n");
+    // Keep the last (possibly incomplete) line in the buffer
+    lineBuf = lines.pop();
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+        // Skip system init and rate_limit events
+        if (obj.type === "system" || obj.type === "rate_limit_event") continue;
+        // Final result — extract model from modelUsage keys
+        if (obj.type === "result") {
+          const models = Object.keys(obj.modelUsage || {});
+          if (models.length > 0) {
+            detectedModel = models[0];
+            if (!modelId) detectedDefaultModel = models[0];
+          }
+          continue;
+        }
+        // Assistant message — text is in message.content[]
+        if (obj.type === "assistant" && obj.message?.content) {
+          for (const block of obj.message.content) {
+            if (block.type === "text" && block.text) {
+              fullContent += block.text;
+              res.write(`event: chunk\ndata: ${JSON.stringify(block.text)}\n\n`);
+            }
+          }
+          // Extract model from message
+          if (obj.message.model && !detectedModel) {
+            detectedModel = obj.message.model;
+            if (!modelId) detectedDefaultModel = obj.message.model;
+          }
+        }
+      } catch {
+        // Not JSON — treat as raw text chunk
+        if (line.trim()) {
+          fullContent += line;
+          res.write(`event: chunk\ndata: ${JSON.stringify(line)}\n\n`);
+        }
+      }
+    }
+  });
+
+  child.stderr.on("data", (buf) => {
+    const text = buf.toString();
+    errOutput += text;
+    console.error(`[ai] stderr: ${text.trim()}`);
+  });
+
+  child.on("error", (err) => {
+    const message = err.code === "ENOENT"
+      ? "Claude CLI not found. Make sure `claude` is installed and in your PATH."
+      : `Claude CLI error: ${err.message}`;
+    console.error(`[ai] Process error: ${message}`);
+    res.write(`event: error\ndata: ${JSON.stringify({ message })}\n\n`);
+    res.end();
+  });
+
+  child.on("close", (code) => {
+    activeChildren.delete(child);
+    if (code !== 0 && !fullContent) {
+      const message = errOutput.trim() || `Claude CLI exited with code ${code}`;
+      console.error(`[ai] Failed (exit ${code}): ${message}`);
+      res.write(`event: error\ndata: ${JSON.stringify({ message })}\n\n`);
+    } else {
+      const finalModel = detectedModel || resolvedModel;
+      console.log(`[ai] Done (model: ${finalModel}, ${fullContent.length} chars)`);
+      cachedResult = {
+        content: fullContent.trim(),
+        generatedAt: new Date().toISOString(),
+        model: finalModel,
+      };
+      res.write(`event: done\ndata: ${JSON.stringify({ generatedAt: cachedResult.generatedAt, model: finalModel })}\n\n`);
+    }
+    res.end();
+  });
+
+  // Allow client disconnect to kill the process
+  res.on("close", () => {
+    if (child.exitCode === null) {
+      console.log("[ai] Client disconnected, killing claude process");
+      child.kill();
+    }
+  });
+}
+
+export function getCachedAnalysis() {
+  return cachedResult;
+}
+
+export function clearCachedAnalysis() {
+  cachedResult = null;
+}
+
+export function getAvailableModels() {
+  return {
+    models: MODELS,
+    defaultModel: detectedDefaultModel,
+    defaultModelLabel: prettyModelName(detectedDefaultModel),
+  };
+}

package/src/export.js

@@ -0,0 +1,79 @@
+import { createHash } from "node:crypto";
+import { userInfo } from "node:os";
+import { writeFile } from "node:fs/promises";
+import { parseAllSessions } from "./parser.js";
+import { scoreAllSessions } from "./scorer.js";
+
+function hashUsername() {
+  const username = userInfo().username;
+  return createHash("sha256").update(username).digest("hex").slice(0, 16);
+}
+
+export async function generateExport(outputPath = "team-export.json") {
+  const sessions = await parseAllSessions();
+  const data = scoreAllSessions(sessions);
+
+  const dates = data.sessions
+    .map((s) => s.startTime)
+    .filter(Boolean)
+    .sort();
+
+  // Model mix
+  const modelTokens = {};
+  let totalTokens = 0;
+  for (const s of data.sessions) {
+    const model = s.model || "unknown";
+    const family = model.includes("opus")
+      ? "opus"
+      : model.includes("haiku")
+        ? "haiku"
+        : "sonnet";
+    modelTokens[family] = (modelTokens[family] || 0) + s.totals.totalTokens;
+    totalTokens += s.totals.totalTokens;
+  }
+  const modelMix = {};
+  for (const [k, v] of Object.entries(modelTokens)) {
+    modelMix[k] = totalTokens > 0 ? Math.round((v / totalTokens) * 100) / 100 : 0;
+  }
+
+  const totalCost = data.sessions.reduce((s, x) => s + x.totals.estimatedCost, 0);
+  const avgCacheHitRate =
+    data.sessions.length > 0
+      ? data.sessions.reduce((s, x) => s + x.totals.cacheHitRate, 0) / data.sessions.length
+      : 0;
+  const avgToolRatio =
+    data.sessions.length > 0
+      ? data.sessions.reduce((s, x) => {
+          const um = x.totals.userMessages || 1;
+          return s + x.totals.toolCalls / um;
+        }, 0) / data.sessions.length
+      : 0;
+
+  // Unique tip types
+  const tipTypes = [...new Set(data.tips.map((t) => t.type))];
+
+  const exportData = {
+    exportVersion: "1.0",
+    devId: hashUsername(),
+    exportDate: new Date().toISOString().slice(0, 10),
+    period: {
+      from: dates[0]?.slice(0, 10) || null,
+      to: dates[dates.length - 1]?.slice(0, 10) || null,
+    },
+    summary: {
+      efficiencyScore: data.overallScore,
+      totalSessions: data.sessions.length,
+      totalTokens,
+      estimatedCost: Math.round(totalCost * 100) / 100,
+      cacheHitRate: Math.round(avgCacheHitRate * 100) / 100,
+      toolCallRatio: Math.round(avgToolRatio * 10) / 10,
+      modelMix,
+    },
+    dailyScores: data.dailyScores,
+    topInsights: tipTypes,
+    badges: data.badges.map((b) => b.id),
+  };
+
+  await writeFile(outputPath, JSON.stringify(exportData, null, 2) + "\n");
+  return exportData;
+}

package/src/parser.js

@@ -0,0 +1,273 @@
+import { readdir, stat } from "node:fs/promises";
+import { createReadStream } from "node:fs";
+import { createInterface } from "node:readline";
+import { join, basename } from "node:path";
+import { homedir } from "node:os";
+
+// API-equivalent pricing per million tokens
+const PRICING = {
+  "claude-opus-4-6": { input: 5, output: 25 },
+  "claude-opus-4-5": { input: 5, output: 25 },
+  "claude-opus-4-20250514": { input: 15, output: 75 },
+  "claude-sonnet-4-6": { input: 3, output: 15 },
+  "claude-sonnet-4-5": { input: 3, output: 15 },
+  "claude-sonnet-4-5-20250514": { input: 3, output: 15 },
+  "claude-haiku-4-5": { input: 0.8, output: 4 },
+  "claude-haiku-4-5-20251001": { input: 0.8, output: 4 },
+};
+
+const DEFAULT_PRICING = { input: 3, output: 15 }; // fallback to sonnet-tier
+const CACHE_WRITE_MULTIPLIER = 1.25;
+const CACHE_READ_MULTIPLIER = 0.1;
+
+function getModelPricing(model) {
+  if (!model) return DEFAULT_PRICING;
+  return PRICING[model] ?? DEFAULT_PRICING;
+}
+
+function computeTurnCost(tokens, model) {
+  const p = getModelPricing(model);
+  const m = 1_000_000;
+  return (
+    (tokens.input * p.input) / m +
+    (tokens.cacheCreation * p.input * CACHE_WRITE_MULTIPLIER) / m +
+    (tokens.cacheRead * p.input * CACHE_READ_MULTIPLIER) / m +
+    (tokens.output * p.output) / m
+  );
+}
+
+// "-Users-archie-dev-carepatron-App" -> { name: "App", path: "/Users/archie/dev/carepatron/App" }
+function decodeProjectDir(dirName) {
+  // Leading dash + split by dash, reconstruct as path
+  const fullPath = dirName.startsWith("-")
+    ? "/" + dirName.slice(1).replace(/-/g, "/")
+    : dirName.replace(/-/g, "/");
+  const name = fullPath.split("/").pop() || dirName;
+  return { name, path: fullPath };
+}
+
+async function parseSessionFile(filePath) {
+  const turns = [];
+  const clearPoints = [];
+  const modelCounts = {};
+  let turnIndex = 0;
+
+  const rl = createInterface({
+    input: createReadStream(filePath),
+    crlfDelay: Infinity,
+  });
+
+  for await (const line of rl) {
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+
+    if (entry.type === "user" && entry.message?.role === "user") {
+      const content = entry.message.content;
+      // Detect /clear commands
+      if (typeof content === "string" && content.includes("<command-name>/clear</command-name>")) {
+        clearPoints.push(turnIndex);
+      }
+      // Extract raw text for preview
+      let rawText = "";
+      if (typeof content === "string") {
+        rawText = content;
+      } else if (Array.isArray(content)) {
+        rawText = content.map((c) => c.text || "").join(" ");
+      }
+
+      // Strip XML tags (command wrappers, system reminders, etc.)
+      const cleanText = rawText
+        .replace(/<[^>]+>/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+
+      const promptLength = cleanText.length;
+
+      // Skip meta messages (system-generated)
+      if (entry.isMeta) continue;
+      // Skip empty/system-only messages
+      if (promptLength === 0) continue;
+
+      turns.push({
+        role: "user",
+        timestamp: entry.timestamp,
+        tokens: { input: 0, output: 0, cacheCreation: 0, cacheRead: 0 },
+        toolCalls: [],
+        promptLength,
+        promptPreview: cleanText.slice(0, 300),
+      });
+      turnIndex++;
+    } else if (entry.type === "assistant" && entry.message) {
+      const msg = entry.message;
+      const usage = msg.usage;
+      if (!usage) continue;
+
+      const model = msg.model || null;
+      if (model) {
+        modelCounts[model] = (modelCounts[model] || 0) + (usage.output_tokens || 0);
+      }
+
+      const contentBlocks = msg.content || [];
+      const toolCalls = contentBlocks
+        .filter((c) => c.type === "tool_use")
+        .map((c) => c.name);
+
+      const textPreview = contentBlocks
+        .filter((c) => c.type === "text")
+        .map((c) => c.text || "")
+        .join(" ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, 300);
+
+      const tokens = {
+        input: usage.input_tokens || 0,
+        output: usage.output_tokens || 0,
+        cacheCreation: usage.cache_creation_input_tokens || 0,
+        cacheRead: usage.cache_read_input_tokens || 0,
+      };
+
+      turns.push({
+        role: "assistant",
+        timestamp: entry.timestamp,
+        tokens,
+        toolCalls,
+        model,
+        cost: computeTurnCost(tokens, model),
+        textPreview,
+      });
+      turnIndex++;
+    } else if (entry.type === "system" && entry.subtype === "compact_boundary") {
+      clearPoints.push(turnIndex);
+    }
+  }
+
+  return { turns, clearPoints, modelCounts };
+}
+
+function computeSessionTotals(turns) {
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cacheCreationTokens = 0;
+  let cacheReadTokens = 0;
+  let toolCalls = 0;
+  let userMessages = 0;
+  let assistantMessages = 0;
+  let estimatedCost = 0;
+
+  for (const turn of turns) {
+    if (turn.role === "user") {
+      userMessages++;
+    } else {
+      assistantMessages++;
+      inputTokens += turn.tokens.input;
+      outputTokens += turn.tokens.output;
+      cacheCreationTokens += turn.tokens.cacheCreation;
+      cacheReadTokens += turn.tokens.cacheRead;
+      toolCalls += turn.toolCalls.length;
+      estimatedCost += turn.cost || 0;
+    }
+  }
+
+  const totalInput = inputTokens + cacheCreationTokens + cacheReadTokens;
+  const cacheHitRate = totalInput > 0 ? cacheReadTokens / totalInput : 0;
+
+  return {
+    inputTokens,
+    outputTokens,
+    cacheCreationTokens,
+    cacheReadTokens,
+    totalTokens: totalInput + outputTokens,
+    estimatedCost,
+    toolCalls,
+    userMessages,
+    assistantMessages,
+    cacheHitRate,
+  };
+}
+
+function primaryModel(modelCounts) {
+  let best = null;
+  let max = 0;
+  for (const [model, count] of Object.entries(modelCounts)) {
+    if (count > max) {
+      best = model;
+      max = count;
+    }
+  }
+  return best;
+}
+
+export async function parseAllSessions(claudeDir) {
+  const projectsDir = join(claudeDir || join(homedir(), ".claude"), "projects");
+  let projectDirs;
+  try {
+    projectDirs = await readdir(projectsDir);
+  } catch {
+    return [];
+  }
+
+  const sessions = [];
+
+  for (const projDir of projectDirs) {
+    const projPath = join(projectsDir, projDir);
+    const projStat = await stat(projPath).catch(() => null);
+    if (!projStat?.isDirectory()) continue;
+
+    const { name: projectName, path: projectPath } = decodeProjectDir(projDir);
+
+    let files;
+    try {
+      files = await readdir(projPath);
+    } catch {
+      continue;
+    }
+
+    for (const file of files) {
+      if (!file.endsWith(".jsonl")) continue;
+      const filePath = join(projPath, file);
+      const sessionId = basename(file, ".jsonl");
+
+      try {
+        const { turns, clearPoints, modelCounts } = await parseSessionFile(filePath);
+
+        // Skip empty sessions
+        const assistantTurns = turns.filter((t) => t.role === "assistant");
+        if (assistantTurns.length === 0) continue;
+
+        const totals = computeSessionTotals(turns);
+        const timestamps = turns.map((t) => t.timestamp).filter(Boolean);
+        const firstUserTurn = turns.find((t) => t.role === "user");
+        const title = firstUserTurn?.promptPreview?.slice(0, 120) || "Untitled session";
+
+        sessions.push({
+          id: sessionId,
+          project: projectName,
+          projectPath,
+          model: primaryModel(modelCounts),
+          startTime: timestamps[0] || null,
+          endTime: timestamps[timestamps.length - 1] || null,
+          title,
+          turns,
+          totals,
+          clearPoints,
+        });
+      } catch {
+        // Skip unreadable files
+        continue;
+      }
+    }
+  }
+
+  // Sort by start time, newest first
+  sessions.sort((a, b) => {
+    if (!a.startTime || !b.startTime) return 0;
+    return new Date(b.startTime) - new Date(a.startTime);
+  });
+
+  return sessions;
+}