@towles/tool 0.0.62 → 0.0.64

package/src/lib/graph/analyzer.test.ts

@@ -0,0 +1,451 @@
+import { describe, expect, it } from "vitest";
+import type { ContentBlock, JournalEntry } from "./types";
+import {
+  aggregateSessionTools,
+  analyzeSession,
+  extractProjectName,
+  getModelName,
+  getPrimaryModel,
+} from "./analyzer";
+import { extractSessionLabel } from "./labels";
+import { extractToolData, extractToolDetail, sanitizeString, truncateDetail } from "./tools";
+
+// ── Helpers ──
+
+function makeEntry(overrides: Partial<JournalEntry> = {}): JournalEntry {
+  return {
+    type: "assistant",
+    sessionId: "test-session",
+    timestamp: "2025-01-01T00:00:00Z",
+    ...overrides,
+  };
+}
+
+function makeAssistantEntry(
+  model: string,
+  inputTokens: number,
+  outputTokens: number,
+  content?: ContentBlock[],
+  extra?: Partial<JournalEntry["message"]>,
+): JournalEntry {
+  return makeEntry({
+    type: "assistant",
+    message: {
+      role: "assistant",
+      model,
+      usage: { input_tokens: inputTokens, output_tokens: outputTokens },
+      content: content ?? [{ type: "text", text: "response" }],
+      ...extra,
+    },
+  });
+}
+
+// ── analyzeSession ──
+
+describe("analyzeSession", () => {
+  it("returns zeros for empty entries", () => {
+    const result = analyzeSession([]);
+    expect(result.inputTokens).toBe(0);
+    expect(result.outputTokens).toBe(0);
+    expect(result.opusTokens).toBe(0);
+    expect(result.sonnetTokens).toBe(0);
+    expect(result.haikuTokens).toBe(0);
+    expect(result.cacheHitRate).toBe(0);
+    expect(result.repeatedReads).toBe(0);
+    expect(result.modelEfficiency).toBe(0);
+  });
+
+  it("counts tokens by model", () => {
+    const entries = [
+      makeAssistantEntry("claude-opus-4", 100, 50),
+      makeAssistantEntry("claude-sonnet-4", 200, 100),
+      makeAssistantEntry("claude-haiku-3", 50, 25),
+    ];
+    const result = analyzeSession(entries);
+    expect(result.inputTokens).toBe(350);
+    expect(result.outputTokens).toBe(175);
+    expect(result.opusTokens).toBe(150);
+    expect(result.sonnetTokens).toBe(300);
+    expect(result.haikuTokens).toBe(75);
+  });
+
+  it("calculates cache hit rate", () => {
+    const entries = [
+      makeEntry({
+        type: "assistant",
+        message: {
+          role: "assistant",
+          model: "claude-opus-4",
+          usage: { input_tokens: 1000, output_tokens: 0, cache_read_input_tokens: 800 },
+          content: [{ type: "text", text: "hi" }],
+        },
+      }),
+    ];
+    const result = analyzeSession(entries);
+    expect(result.cacheHitRate).toBe(0.8);
+  });
+
+  it("counts repeated file reads", () => {
+    const content: ContentBlock[] = [
+      { type: "tool_use", name: "Read", input: { file_path: "/a.ts" } },
+      { type: "tool_use", name: "Read", input: { file_path: "/a.ts" } },
+      { type: "tool_use", name: "Read", input: { file_path: "/b.ts" } },
+    ];
+    const entries = [makeAssistantEntry("claude-opus-4", 100, 50, content)];
+    const result = analyzeSession(entries);
+    expect(result.repeatedReads).toBe(1); // /a.ts read twice => 1 repeated
+  });
+
+  it("calculates model efficiency as opus fraction", () => {
+    const entries = [
+      makeAssistantEntry("claude-opus-4", 400, 100), // 500 opus
+      makeAssistantEntry("claude-sonnet-4", 400, 100), // 500 sonnet
+    ];
+    const result = analyzeSession(entries);
+    expect(result.modelEfficiency).toBe(0.5);
+  });
+
+  it("skips entries without usage", () => {
+    const entries = [makeEntry({ message: { role: "assistant", content: "text" } })];
+    const result = analyzeSession(entries);
+    expect(result.inputTokens).toBe(0);
+  });
+});
+
+// ── extractSessionLabel ──
+
+describe("extractSessionLabel", () => {
+  it("uses first user text message", () => {
+    const entries = [
+      makeEntry({
+        type: "user",
+        message: { role: "user", content: "Fix the bug in parser" },
+      }),
+    ];
+    expect(extractSessionLabel(entries, "abc12345")).toBe("Fix the bug in parser");
+  });
+
+  it("skips UUID-only user messages", () => {
+    const entries = [
+      makeEntry({
+        type: "user",
+        message: { role: "user", content: "a1b2c3d4-e5f6-7890-abcd-ef1234567890" },
+      }),
+      makeEntry({
+        type: "user",
+        message: { role: "user", content: "Real message" },
+      }),
+    ];
+    expect(extractSessionLabel(entries, "abc12345")).toBe("Real message");
+  });
+
+  it("extracts text from array content blocks", () => {
+    const entries = [
+      makeEntry({
+        type: "user",
+        message: {
+          role: "user",
+          content: [{ type: "text", text: "Array content message" }],
+        },
+      }),
+    ];
+    expect(extractSessionLabel(entries, "abc12345")).toBe("Array content message");
+  });
+
+  it("falls back to assistant text", () => {
+    const entries = [
+      makeEntry({
+        type: "assistant",
+        message: {
+          role: "assistant",
+          content: [{ type: "text", text: "I'll help you with that" }],
+        },
+      }),
+    ];
+    expect(extractSessionLabel(entries, "abc12345")).toBe("I'll help you with that");
+  });
+
+  it("falls back to gitBranch", () => {
+    const entries = [makeEntry({ type: "user" }) as any];
+    (entries[0] as any).gitBranch = "feat/new-feature";
+    expect(extractSessionLabel(entries, "abc12345")).toBe("feat/new-feature");
+  });
+
+  it("falls back to short session ID", () => {
+    expect(extractSessionLabel([], "abc12345-long-id")).toBe("abc12345");
+  });
+
+  it("removes /command prefixes", () => {
+    const entries = [
+      makeEntry({
+        type: "user",
+        message: { role: "user", content: "/review Fix the parser" },
+      }),
+    ];
+    expect(extractSessionLabel(entries, "abc12345")).toBe("Fix the parser");
+  });
+
+  it("removes XML tags", () => {
+    const entries = [
+      makeEntry({
+        type: "user",
+        message: { role: "user", content: "<tag>content</tag> Real text" },
+      }),
+    ];
+    expect(extractSessionLabel(entries, "abc12345")).toBe("Real text");
+  });
+
+  it("truncates labels longer than 80 chars", () => {
+    const longText = "A".repeat(100);
+    const entries = [
+      makeEntry({
+        type: "user",
+        message: { role: "user", content: longText },
+      }),
+    ];
+    const label = extractSessionLabel(entries, "abc12345");
+    expect(label.length).toBe(80);
+    expect(label.endsWith("...")).toBe(true);
+  });
+
+  it("uses slug fallback for short labels after cleanup", () => {
+    const entries = [makeEntry() as any];
+    (entries[0] as any).slug = "my-slug";
+    expect(extractSessionLabel(entries, "abc12345")).toBe("my-slug");
+  });
+});
+
+// ── sanitizeString ──
+
+describe("sanitizeString", () => {
+  it("replaces control characters with space", () => {
+    expect(sanitizeString("hello\nworld\ttab")).toBe("hello world tab");
+  });
+
+  it("trims result", () => {
+    expect(sanitizeString("  hello  ")).toBe("hello");
+  });
+
+  it("collapses multiple control chars", () => {
+    expect(sanitizeString("a\n\n\nb")).toBe("a b");
+  });
+
+  it("handles empty string", () => {
+    expect(sanitizeString("")).toBe("");
+  });
+});
+
+// ── truncateDetail ──
+
+describe("truncateDetail", () => {
+  it("returns undefined for undefined input", () => {
+    expect(truncateDetail(undefined)).toBeUndefined();
+  });
+
+  it("returns short strings unchanged", () => {
+    expect(truncateDetail("hello")).toBe("hello");
+  });
+
+  it("truncates long strings with ellipsis", () => {
+    const long = "A".repeat(40);
+    const result = truncateDetail(long, 30);
+    expect(result?.length).toBe(30);
+    expect(result?.endsWith("...")).toBe(true);
+  });
+
+  it("extracts filename from paths", () => {
+    expect(truncateDetail("/home/user/project/file.ts")).toBe("file.ts");
+  });
+
+  it("truncates long filenames", () => {
+    const longFile = "/path/" + "A".repeat(40) + ".ts";
+    const result = truncateDetail(longFile, 30);
+    expect(result?.length).toBe(30);
+    expect(result?.endsWith("...")).toBe(true);
+  });
+});
+
+// ── extractToolDetail ──
+
+describe("extractToolDetail", () => {
+  it("returns undefined when no input", () => {
+    expect(extractToolDetail("Read")).toBeUndefined();
+  });
+
+  it("extracts file_path for Read", () => {
+    expect(extractToolDetail("Read", { file_path: "/src/index.ts" })).toBe("index.ts");
+  });
+
+  it("extracts file_path for Write", () => {
+    expect(extractToolDetail("Write", { file_path: "/src/utils.ts" })).toBe("utils.ts");
+  });
+
+  it("extracts file_path for Edit", () => {
+    expect(extractToolDetail("Edit", { file_path: "/src/edit.ts" })).toBe("edit.ts");
+  });
+
+  it("extracts command for Bash", () => {
+    expect(extractToolDetail("Bash", { command: "pnpm test" })).toBe("pnpm test");
+  });
+
+  it("extracts pattern for Glob", () => {
+    // Pattern contains "/" so truncateDetail extracts the last segment
+    expect(extractToolDetail("Glob", { pattern: "**/*.ts" })).toBe("*.ts");
+  });
+
+  it("extracts pattern for Grep", () => {
+    expect(extractToolDetail("Grep", { pattern: "TODO" })).toBe("TODO");
+  });
+
+  it("returns undefined for unknown tools", () => {
+    expect(extractToolDetail("CustomTool", { foo: "bar" })).toBeUndefined();
+  });
+});
+
+// ── extractToolData ──
+
+describe("extractToolData", () => {
+  it("returns empty for undefined content", () => {
+    expect(extractToolData(undefined, 100, 50)).toEqual([]);
+  });
+
+  it("returns empty for string content", () => {
+    expect(extractToolData("text", 100, 50)).toEqual([]);
+  });
+
+  it("returns empty when no tool_use blocks", () => {
+    const content: ContentBlock[] = [{ type: "text", text: "hello" }];
+    expect(extractToolData(content, 100, 50)).toEqual([]);
+  });
+
+  it("extracts tool calls and distributes tokens", () => {
+    const content: ContentBlock[] = [
+      { type: "tool_use", name: "Read", input: { file_path: "/a.ts" } },
+      { type: "tool_use", name: "Bash", input: { command: "ls" } },
+    ];
+    const result = extractToolData(content, 200, 100);
+    expect(result).toHaveLength(2);
+    expect(result[0].name).toBe("Read");
+    expect(result[0].inputTokens).toBe(100);
+    expect(result[0].outputTokens).toBe(50);
+    expect(result[1].name).toBe("Bash");
+    expect(result[1].inputTokens).toBe(100);
+  });
+});
+
+// ── aggregateSessionTools ──
+
+describe("aggregateSessionTools", () => {
+  it("returns empty for no entries", () => {
+    expect(aggregateSessionTools([])).toEqual([]);
+  });
+
+  it("aggregates tools across entries", () => {
+    const entries = [
+      makeAssistantEntry("claude-opus-4", 100, 50, [
+        { type: "tool_use", name: "Read", input: { file_path: "/a.ts" } },
+      ]),
+      makeAssistantEntry("claude-opus-4", 200, 100, [
+        { type: "tool_use", name: "Read", input: { file_path: "/b.ts" } },
+        { type: "tool_use", name: "Bash", input: { command: "ls" } },
+      ]),
+    ];
+    const result = aggregateSessionTools(entries);
+    const readTool = result.find((t) => t.name === "Read");
+    expect(readTool).toBeDefined();
+    expect(readTool?.detail).toBe("2x");
+  });
+
+  it("sorts by total token usage descending", () => {
+    const entries = [
+      makeAssistantEntry("claude-opus-4", 100, 50, [
+        { type: "tool_use", name: "Bash", input: { command: "ls" } },
+      ]),
+      makeAssistantEntry("claude-opus-4", 1000, 500, [
+        { type: "tool_use", name: "Read", input: { file_path: "/a.ts" } },
+      ]),
+    ];
+    const result = aggregateSessionTools(entries);
+    expect(result[0].name).toBe("Read");
+  });
+});
+
+// ── getPrimaryModel ──
+
+describe("getPrimaryModel", () => {
+  it("returns Opus when opus has most tokens", () => {
+    expect(getPrimaryModel({ opusTokens: 100, sonnetTokens: 50, haikuTokens: 10 })).toBe("Opus");
+  });
+
+  it("returns Sonnet when sonnet dominates", () => {
+    expect(getPrimaryModel({ opusTokens: 10, sonnetTokens: 500, haikuTokens: 10 })).toBe("Sonnet");
+  });
+
+  it("returns Haiku when haiku dominates", () => {
+    expect(getPrimaryModel({ opusTokens: 0, sonnetTokens: 0, haikuTokens: 100 })).toBe("Haiku");
+  });
+
+  it("returns Opus on tie between opus and sonnet", () => {
+    expect(getPrimaryModel({ opusTokens: 100, sonnetTokens: 100, haikuTokens: 0 })).toBe("Opus");
+  });
+
+  it("returns Opus when all zero", () => {
+    expect(getPrimaryModel({ opusTokens: 0, sonnetTokens: 0, haikuTokens: 0 })).toBe("Opus");
+  });
+});
+
+// ── getModelName ──
+
+describe("getModelName", () => {
+  it("returns 'unknown' for undefined", () => {
+    expect(getModelName()).toBe("unknown");
+  });
+
+  it("returns Opus for opus models", () => {
+    expect(getModelName("claude-opus-4-20250514")).toBe("Opus");
+  });
+
+  it("returns Sonnet for sonnet models", () => {
+    expect(getModelName("claude-sonnet-4-20250514")).toBe("Sonnet");
+  });
+
+  it("returns Haiku for haiku models", () => {
+    expect(getModelName("claude-3-haiku")).toBe("Haiku");
+  });
+
+  it("returns first segment for unknown models", () => {
+    expect(getModelName("gpt-4-turbo")).toBe("gpt");
+  });
+
+  it("returns 'unknown' for empty string", () => {
+    expect(getModelName("")).toBe("unknown");
+  });
+});
+
+// ── extractProjectName ──
+
+describe("extractProjectName", () => {
+  it("extracts project name after path markers", () => {
+    expect(extractProjectName("-home-ctowles-code-p-towles-tool")).toBe("towles-tool");
+  });
+
+  it("handles 'projects' marker", () => {
+    expect(extractProjectName("-home-user-projects-my-app")).toBe("my-app");
+  });
+
+  it("handles 'src' marker", () => {
+    expect(extractProjectName("-home-user-src-cool-lib")).toBe("cool-lib");
+  });
+
+  it("uses last two parts when no marker found", () => {
+    expect(extractProjectName("-foo-bar-baz")).toBe("bar-baz");
+  });
+
+  it("handles single segment after marker", () => {
+    expect(extractProjectName("-home-user-code-myproject")).toBe("myproject");
+  });
+
+  it("uses last marker when multiple exist", () => {
+    expect(extractProjectName("-home-code-old-src-new-project")).toBe("new-project");
+  });
+});

package/src/lib/graph/analyzer.ts

@@ -0,0 +1,165 @@
+import type { JournalEntry, ToolData } from "./types.js";
+import { extractToolData } from "./tools.js";
+
+/**
+ * Analyze session entries to get token breakdown by model.
+ */
+export function analyzeSession(entries: JournalEntry[]): {
+  inputTokens: number;
+  outputTokens: number;
+  opusTokens: number;
+  sonnetTokens: number;
+  haikuTokens: number;
+  cacheHitRate: number;
+  repeatedReads: number;
+  modelEfficiency: number;
+} {
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let opusTokens = 0;
+  let sonnetTokens = 0;
+  let haikuTokens = 0;
+  let cacheRead = 0;
+  let totalInput = 0;
+  const fileReadCounts = new Map<string, number>();
+
+  for (const entry of entries) {
+    // Count file reads for repeatedReads metric
+    if (entry.message?.content && Array.isArray(entry.message.content)) {
+      for (const block of entry.message.content) {
+        if (block.type === "tool_use" && block.name === "Read" && block.input) {
+          const filePath = (block.input as { file_path?: string }).file_path;
+          if (filePath) {
+            fileReadCounts.set(filePath, (fileReadCounts.get(filePath) || 0) + 1);
+          }
+        }
+      }
+    }
+
+    if (!entry.message?.usage) continue;
+    const usage = entry.message.usage;
+    const model = entry.message.model || "";
+    const tokens = (usage.input_tokens || 0) + (usage.output_tokens || 0);
+
+    inputTokens += usage.input_tokens || 0;
+    outputTokens += usage.output_tokens || 0;
+    cacheRead += usage.cache_read_input_tokens || 0;
+    totalInput += usage.input_tokens || 0;
+
+    if (model.includes("opus")) opusTokens += tokens;
+    else if (model.includes("sonnet")) sonnetTokens += tokens;
+    else if (model.includes("haiku")) haikuTokens += tokens;
+  }
+
+  // Count files read more than once
+  let repeatedReads = 0;
+  for (const count of fileReadCounts.values()) {
+    if (count > 1) repeatedReads += count - 1;
+  }
+
+  const totalTokens = opusTokens + sonnetTokens + haikuTokens;
+
+  return {
+    inputTokens,
+    outputTokens,
+    opusTokens,
+    sonnetTokens,
+    haikuTokens,
+    cacheHitRate: totalInput > 0 ? cacheRead / totalInput : 0,
+    repeatedReads,
+    modelEfficiency: totalTokens > 0 ? opusTokens / totalTokens : 0,
+  };
+}
+
+/**
+ * Aggregate tool usage across all entries in a session.
+ * Returns combined tool data for session-level tooltips (aggregated by name).
+ */
+export function aggregateSessionTools(entries: JournalEntry[]): ToolData[] {
+  const toolAgg = new Map<string, { count: number; inputTokens: number; outputTokens: number }>();
+
+  for (const entry of entries) {
+    if (!entry.message?.content || typeof entry.message.content === "string") continue;
+    if (!entry.message.usage) continue;
+
+    const inputTokens = entry.message.usage.input_tokens || 0;
+    const outputTokens = entry.message.usage.output_tokens || 0;
+    const turnTools = extractToolData(entry.message.content, inputTokens, outputTokens);
+
+    for (const tool of turnTools) {
+      const existing = toolAgg.get(tool.name);
+      if (existing) {
+        existing.count += 1;
+        existing.inputTokens += tool.inputTokens;
+        existing.outputTokens += tool.outputTokens;
+      } else {
+        toolAgg.set(tool.name, {
+          count: 1,
+          inputTokens: tool.inputTokens,
+          outputTokens: tool.outputTokens,
+        });
+      }
+    }
+  }
+
+  // Convert to array and sort by token usage
+  const tools: ToolData[] = [...toolAgg.entries()].map(([name, data]) => ({
+    name,
+    detail: `${data.count}x`,
+    inputTokens: data.inputTokens,
+    outputTokens: data.outputTokens,
+  }));
+  tools.sort((a, b) => b.inputTokens + b.outputTokens - (a.inputTokens + a.outputTokens));
+
+  return tools;
+}
+
+/**
+ * Get the primary model name from analysis results.
+ */
+export function getPrimaryModel(analysis: {
+  opusTokens: number;
+  sonnetTokens: number;
+  haikuTokens: number;
+}): string {
+  const { opusTokens, sonnetTokens, haikuTokens } = analysis;
+  if (opusTokens >= sonnetTokens && opusTokens >= haikuTokens) return "Opus";
+  if (sonnetTokens >= haikuTokens) return "Sonnet";
+  return "Haiku";
+}
+
+/**
+ * Get a short model name from the full model string.
+ */
+export function getModelName(model?: string): string {
+  if (!model) return "unknown";
+  if (model.includes("opus")) return "Opus";
+  if (model.includes("sonnet")) return "Sonnet";
+  if (model.includes("haiku")) return "Haiku";
+  return model.split("-")[0] || "unknown";
+}
+
+/**
+ * Extract project name from encoded directory name.
+ */
+export function extractProjectName(encodedProject: string): string {
+  // Directory names encode paths: -home-ctowles-code-p-towles-tool
+  const parts = encodedProject.split("-").filter(Boolean);
+  const pathMarkers = new Set(["code", "projects", "src", "p", "repos", "git", "workspace"]);
+
+  // Find LAST index of a path marker
+  let lastMarkerIdx = -1;
+  for (let i = 0; i < parts.length; i++) {
+    if (pathMarkers.has(parts[i].toLowerCase())) {
+      lastMarkerIdx = i;
+    }
+  }
+
+  // Take everything after the last marker
+  const projectParts = lastMarkerIdx >= 0 ? parts.slice(lastMarkerIdx + 1) : parts.slice(-2);
+
+  if (projectParts.length === 0) {
+    return parts[parts.length - 1] || encodedProject.slice(0, 20);
+  }
+  return projectParts.join("-");
+}

package/src/lib/graph/index.ts

@@ -0,0 +1,24 @@
+export {
+  analyzeSession,
+  aggregateSessionTools,
+  getPrimaryModel,
+  getModelName,
+  extractProjectName,
+} from "./analyzer.js";
+export { extractSessionLabel } from "./labels.js";
+export { calculateCutoffMs, filterByDays, parseJsonl, quickTokenCount } from "./parser.js";
+export { generateTreemapHtml } from "./render.js";
+export { openInBrowser, startServer, waitForShutdown } from "./server.js";
+export { findRecentSessions, findSessionPath, buildBarChartData } from "./sessions.js";
+export { sanitizeString, truncateDetail, extractToolDetail, extractToolData } from "./tools.js";
+export { buildTurnNodes, buildSessionTreemap, buildAllSessionsTreemap } from "./treemap.js";
+export type {
+  BarChartData,
+  BarChartDay,
+  ContentBlock,
+  JournalEntry,
+  ProjectBar,
+  SessionResult,
+  ToolData,
+  TreemapNode,
+} from "./types.js";