@towles/tool 0.0.108 → 0.0.110

package/src/commands/gh/pr.ts

@@ -1,10 +1,9 @@
 import { defineCommand } from "citty";
-import { x } from "tinyexec";
+import { run, isGithubCliInstalled } from "@towles/shared";
 import consola from "consola";
 import { colors } from "consola/utils";
 
 import { debugArg } from "../shared.js";
-import { isGithubCliInstalled } from "../../utils/git/gh-cli-wrapper.js";
 
 function generatePrContent(branch: string, commits: string[]): { title: string; body: string } {
   // Extract issue number from branch name if present (e.g., feature/123-some-feature)
@@ -85,7 +84,7 @@ export default defineCommand({
     }
 
     // Get current branch
-    const branchResult = await x("git", ["branch", "--show-current"]);
+    const branchResult = await run("git", ["branch", "--show-current"]);
     const currentBranch = branchResult.stdout.trim();
 
     if (!currentBranch) {
@@ -102,7 +101,7 @@ export default defineCommand({
     consola.info(`Base branch: ${colors.cyan(args.base)}`);
 
     // Get commits between base and current branch
-    const logResult = await x("git", ["log", `${args.base}..HEAD`, "--pretty=format:%s"]);
+    const logResult = await run("git", ["log", `${args.base}..HEAD`, "--pretty=format:%s"]);
 
     const commits = logResult.stdout.trim().split("\n").filter(Boolean);
 
@@ -135,12 +134,12 @@ export default defineCommand({
     }
 
     // Push branch if needed
-    const statusResult = await x("git", ["status", "-sb"]);
+    const statusResult = await run("git", ["status", "-sb"]);
     const needsPush = !statusResult.stdout.includes("origin/");
 
     if (needsPush) {
       consola.info("Pushing branch to remote...");
-      await x("git", ["push", "-u", "origin", currentBranch]);
+      await run("git", ["push", "-u", "origin", currentBranch]);
     }
 
     // Create PR
@@ -150,7 +149,7 @@ export default defineCommand({
       prArgs.push("--draft");
     }
 
-    const prResult = await x("gh", prArgs);
+    const prResult = await run("gh", prArgs);
     const prUrl = prResult.stdout.trim();
 
     consola.success(`PR created: ${colors.cyan(prUrl)}`);

package/src/{lib → commands}/graph/analyzer.test.ts

@@ -166,8 +166,8 @@ describe("extractSessionLabel", () => {
   });
 
   it("falls back to gitBranch", () => {
-    const entries = [makeEntry({ type: "user" }) as any];
-    (entries[0] as any).gitBranch = "feat/new-feature";
+    const entries = [makeEntry({ type: "user" })];
+    entries[0].gitBranch = "feat/new-feature";
     expect(extractSessionLabel(entries, "abc12345")).toBe("feat/new-feature");
   });
 
@@ -209,8 +209,8 @@ describe("extractSessionLabel", () => {
   });
 
   it("uses slug fallback for short labels after cleanup", () => {
-    const entries = [makeEntry() as any];
-    (entries[0] as any).slug = "my-slug";
+    const entries = [makeEntry()];
+    entries[0].slug = "my-slug";
     expect(extractSessionLabel(entries, "abc12345")).toBe("my-slug");
   });
 });

package/src/commands/graph/format.test.ts

@@ -0,0 +1,130 @@
+import { describe, expect, it } from "vitest";
+import { formatCsv, formatJson } from "./format";
+import type { SessionRow } from "./format";
+
+// ── formatJson ──
+
+describe("formatJson", () => {
+  it("returns valid JSON for empty array", () => {
+    const result = formatJson([]);
+    expect(JSON.parse(result)).toEqual([]);
+  });
+
+  it("serializes session rows with all fields", () => {
+    const rows: SessionRow[] = [
+      {
+        sessionPath: "/home/user/.claude/projects/test/abc123.jsonl",
+        project: "my-project",
+        model: "Opus",
+        inputTokens: 1000,
+        outputTokens: 500,
+        totalTokens: 1500,
+        cost: 0.0525,
+        date: "2025-06-15",
+      },
+    ];
+    const parsed = JSON.parse(formatJson(rows));
+    expect(parsed).toHaveLength(1);
+    expect(parsed[0].sessionPath).toBe("/home/user/.claude/projects/test/abc123.jsonl");
+    expect(parsed[0].project).toBe("my-project");
+    expect(parsed[0].model).toBe("Opus");
+    expect(parsed[0].inputTokens).toBe(1000);
+    expect(parsed[0].outputTokens).toBe(500);
+    expect(parsed[0].totalTokens).toBe(1500);
+    expect(parsed[0].cost).toBe(0.0525);
+    expect(parsed[0].date).toBe("2025-06-15");
+  });
+
+  it("serializes multiple rows", () => {
+    const rows: SessionRow[] = [
+      {
+        sessionPath: "/a.jsonl",
+        project: "proj-a",
+        model: "Opus",
+        inputTokens: 100,
+        outputTokens: 50,
+        totalTokens: 150,
+        cost: 0.005,
+        date: "2025-06-15",
+      },
+      {
+        sessionPath: "/b.jsonl",
+        project: "proj-b",
+        model: "Sonnet",
+        inputTokens: 200,
+        outputTokens: 100,
+        totalTokens: 300,
+        cost: 0.002,
+        date: "2025-06-16",
+      },
+    ];
+    const parsed = JSON.parse(formatJson(rows));
+    expect(parsed).toHaveLength(2);
+    expect(parsed[0].project).toBe("proj-a");
+    expect(parsed[1].project).toBe("proj-b");
+  });
+});
+
+// ── formatCsv ──
+
+describe("formatCsv", () => {
+  it("returns header only for empty array", () => {
+    const result = formatCsv([]);
+    expect(result).toBe(
+      "session_path,project,model,input_tokens,output_tokens,total_tokens,cost,date",
+    );
+  });
+
+  it("formats rows with proper CSV quoting", () => {
+    const rows: SessionRow[] = [
+      {
+        sessionPath: "/home/user/.claude/projects/test/abc123.jsonl",
+        project: "my-project",
+        model: "Opus",
+        inputTokens: 1000,
+        outputTokens: 500,
+        totalTokens: 1500,
+        cost: 0.0525,
+        date: "2025-06-15",
+      },
+    ];
+    const lines = formatCsv(rows).split("\n");
+    expect(lines).toHaveLength(2);
+    expect(lines[0]).toBe(
+      "session_path,project,model,input_tokens,output_tokens,total_tokens,cost,date",
+    );
+    expect(lines[1]).toContain('"my-project"');
+    expect(lines[1]).toContain("1000");
+    expect(lines[1]).toContain("500");
+    expect(lines[1]).toContain("1500");
+    expect(lines[1]).toContain("0.0525");
+    expect(lines[1]).toContain("2025-06-15");
+  });
+
+  it("formats multiple rows", () => {
+    const rows: SessionRow[] = [
+      {
+        sessionPath: "/a.jsonl",
+        project: "proj-a",
+        model: "Opus",
+        inputTokens: 100,
+        outputTokens: 50,
+        totalTokens: 150,
+        cost: 0.005,
+        date: "2025-06-15",
+      },
+      {
+        sessionPath: "/b.jsonl",
+        project: "proj-b",
+        model: "Sonnet",
+        inputTokens: 200,
+        outputTokens: 100,
+        totalTokens: 300,
+        cost: 0.002,
+        date: "2025-06-16",
+      },
+    ];
+    const lines = formatCsv(rows).split("\n");
+    expect(lines).toHaveLength(3);
+  });
+});

package/src/commands/graph/format.ts

@@ -0,0 +1,94 @@
+import { analyzeSession, extractProjectName, getPrimaryModel } from "./analyzer.js";
+import { parseJsonl } from "./parser.js";
+import type { SessionResult } from "./types.js";
+
+export type OutputFormat = "html" | "json" | "csv";
+
+export interface SessionRow {
+  sessionPath: string;
+  project: string;
+  model: string;
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+  cost: number;
+  date: string;
+}
+
+// Approximate pricing per million tokens (as of 2025)
+const COST_PER_MILLION: Record<string, { input: number; output: number }> = {
+  opus: { input: 15, output: 75 },
+  sonnet: { input: 3, output: 15 },
+  haiku: { input: 0.8, output: 4 },
+};
+
+function estimateCost(analysis: {
+  opusTokens: number;
+  sonnetTokens: number;
+  haikuTokens: number;
+  inputTokens: number;
+  outputTokens: number;
+}): number {
+  const total = analysis.opusTokens + analysis.sonnetTokens + analysis.haikuTokens;
+  if (total === 0) return 0;
+
+  // Distribute input/output proportionally across models
+  let cost = 0;
+  for (const [model, tokens] of [
+    ["opus", analysis.opusTokens],
+    ["sonnet", analysis.sonnetTokens],
+    ["haiku", analysis.haikuTokens],
+  ] as const) {
+    if (tokens === 0) continue;
+    const fraction = tokens / total;
+    const inputShare = analysis.inputTokens * fraction;
+    const outputShare = analysis.outputTokens * fraction;
+    const rates = COST_PER_MILLION[model];
+    cost += (inputShare * rates.input + outputShare * rates.output) / 1_000_000;
+  }
+
+  return Math.round(cost * 10000) / 10000; // 4 decimal places
+}
+
+/**
+ * Build flat session rows from session results by parsing and analyzing each session.
+ */
+export function buildSessionRows(sessions: SessionResult[]): SessionRow[] {
+  return sessions.map((session) => {
+    const entries = parseJsonl(session.path);
+    const analysis = analyzeSession(entries);
+    const model = getPrimaryModel(analysis);
+    const project = extractProjectName(session.project);
+    const cost = estimateCost(analysis);
+
+    return {
+      sessionPath: session.path,
+      project,
+      model,
+      inputTokens: analysis.inputTokens,
+      outputTokens: analysis.outputTokens,
+      totalTokens: analysis.inputTokens + analysis.outputTokens,
+      cost,
+      date: session.date,
+    };
+  });
+}
+
+/**
+ * Format session rows as JSON string.
+ */
+export function formatJson(rows: SessionRow[]): string {
+  return JSON.stringify(rows, null, 2);
+}
+
+/**
+ * Format session rows as CSV string.
+ */
+export function formatCsv(rows: SessionRow[]): string {
+  const header = "session_path,project,model,input_tokens,output_tokens,total_tokens,cost,date";
+  const lines = rows.map(
+    (r) =>
+      `"${r.sessionPath}","${r.project}",${r.model},${r.inputTokens},${r.outputTokens},${r.totalTokens},${r.cost},${r.date}`,
+  );
+  return [header, ...lines].join("\n");
+}

package/src/commands/graph/index.ts

@@ -3,44 +3,29 @@ import { DateTime } from "luxon";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { x } from "tinyexec";
+import { run } from "@towles/shared";
 import consola from "consola";
 
 import { debugArg } from "../shared.js";
-import {
-  buildAllSessionsTreemap,
-  buildBarChartData,
-  buildSessionTreemap,
-  findRecentSessions,
-  findSessionPath,
-  generateTreemapHtml,
-  openInBrowser,
-  parseJsonl,
-  startServer,
-  waitForShutdown,
-} from "../../lib/graph/index.js";
+import { buildAllSessionsTreemap, buildSessionTreemap } from "./treemap.js";
+import type { BarChartData } from "./types.js";
+import { buildBarChartData, findRecentSessions, findSessionPath } from "./sessions.js";
+import { buildSessionRows, formatCsv, formatJson } from "./format.js";
+import type { OutputFormat } from "./format.js";
+import { generateTreemapHtml } from "./render.js";
+import { openInBrowser, startServer, waitForShutdown } from "./server.js";
+import { parseJsonl } from "./parser.js";
 
 // Re-export public API for consumers and tests
-export {
-  analyzeSession,
-  buildAllSessionsTreemap,
-  buildBarChartData,
-  buildSessionTreemap,
-  calculateCutoffMs,
-  extractSessionLabel,
-  filterByDays,
-  findRecentSessions,
-  findSessionPath,
-  generateTreemapHtml,
-  parseJsonl,
-} from "../../lib/graph/index.js";
-export type {
-  BarChartData,
-  BarChartDay,
-  ProjectBar,
-  SessionResult,
-  TreemapNode,
-} from "../../lib/graph/index.js";
+export { analyzeSession } from "./analyzer.js";
+export { buildAllSessionsTreemap, buildSessionTreemap } from "./treemap.js";
+export { buildBarChartData, findRecentSessions, findSessionPath } from "./sessions.js";
+export { calculateCutoffMs, filterByDays, parseJsonl } from "./parser.js";
+export { extractSessionLabel } from "./labels.js";
+export { generateTreemapHtml } from "./render.js";
+export { buildSessionRows, formatCsv, formatJson } from "./format.js";
+export type { BarChartData, BarChartDay, ProjectBar, SessionResult, TreemapNode } from "./types.js";
+export type { OutputFormat, SessionRow } from "./format.js";
 
 export default defineCommand({
   meta: { name: "graph", description: "Generate interactive HTML treemap from session token data" },
@@ -73,10 +58,22 @@ export default defineCommand({
       description: "Filter to sessions from last N days (0=no limit, default: 7)",
       default: "7",
     },
+    format: {
+      type: "string" as const,
+      alias: "f",
+      description: "Output format: html (default), json, csv",
+      default: "html",
+    },
   },
   async run({ args }) {
     const port = Number(args.port);
     const days = Number(args.days);
+    const format = args.format as OutputFormat;
+
+    if (!["html", "json", "csv"].includes(format)) {
+      consola.error(`Invalid format "${format}". Use: html, json, csv`);
+      process.exit(1);
+    }
 
     const projectsDir = path.join(os.homedir(), ".claude", "projects");
     if (!fs.existsSync(projectsDir)) {
@@ -85,11 +82,47 @@ export default defineCommand({
     }
 
     const sessionId = args.session;
+
+    // JSON/CSV output: flat session rows to stdout
+    if (format === "json" || format === "csv") {
+      const sessions = sessionId
+        ? (() => {
+            const sessionPath = findSessionPath(projectsDir, sessionId);
+            if (!sessionPath) {
+              consola.error(`Session ${sessionId} not found`);
+              process.exit(1);
+            }
+            const stat = fs.statSync(sessionPath);
+            const project = path.basename(path.dirname(sessionPath));
+            return [
+              {
+                sessionId,
+                path: sessionPath,
+                date: stat.mtime.toLocaleDateString("en-CA"),
+                tokens: 0,
+                project,
+                mtime: stat.mtimeMs,
+              },
+            ];
+          })()
+        : findRecentSessions(projectsDir, 500, days);
+
+      if (sessions.length === 0) {
+        consola.error("No sessions found");
+        process.exit(1);
+      }
+
+      const rows = buildSessionRows(sessions);
+      const output = format === "json" ? formatJson(rows) : formatCsv(rows);
+      process.stdout.write(output + "\n");
+      return;
+    }
+
+    // HTML output (existing behavior)
     let treemapData;
-    let barChartData = { days: [] as any[] };
+    let barChartData: BarChartData = { days: [] };
 
     if (!sessionId) {
-      // All sessions mode
       const sessions = findRecentSessions(projectsDir, 500, days);
       if (sessions.length === 0) {
         consola.error("No sessions found");
@@ -101,7 +134,6 @@ export default defineCommand({
       treemapData = buildAllSessionsTreemap(sessions);
       barChartData = buildBarChartData(sessions);
     } else {
-      // Single session mode
       const sessionPath = findSessionPath(projectsDir, sessionId);
       if (!sessionPath) {
         consola.error(`Session ${sessionId} not found`);
@@ -111,13 +143,10 @@ export default defineCommand({
       consola.info(`📊 Generating treemap for session ${sessionId}...`);
       const entries = parseJsonl(sessionPath);
       treemapData = buildSessionTreemap(sessionId, entries);
-      // Bar chart not meaningful for single session, leave empty
     }
 
-    // Generate HTML
     const html = generateTreemapHtml(treemapData, barChartData);
 
-    // Write output file
     const reportsDir = path.join(os.homedir(), ".claude", "reports");
     if (!fs.existsSync(reportsDir)) {
       fs.mkdirSync(reportsDir, { recursive: true });
@@ -146,13 +175,12 @@ export default defineCommand({
         openInBrowser(url);
       }
 
-      // Keep server running until Ctrl+C
       await waitForShutdown(server);
       consola.info("\n👋 Stopping server...");
     } else if (args.open) {
       consola.info("\n📈 Opening treemap...");
       const openCmd = process.platform === "darwin" ? "open" : "xdg-open";
-      await x(openCmd, [outputPath]);
+      await run(openCmd, [outputPath]);
     }
   },
 });

package/src/{lib → commands}/graph/labels.ts

@@ -11,11 +11,11 @@ export function extractSessionLabel(entries: JournalEntry[], sessionId: string):
 
   for (const entry of entries) {
     // Extract metadata from any entry
-    if (!gitBranch && (entry as any).gitBranch) {
-      gitBranch = (entry as any).gitBranch;
+    if (!gitBranch && entry.gitBranch) {
+      gitBranch = entry.gitBranch;
     }
-    if (!slug && (entry as any).slug) {
-      slug = (entry as any).slug;
+    if (!slug && entry.slug) {
+      slug = entry.slug;
     }
 
     if (!entry.message) continue;

package/src/{lib → commands}/graph/server.ts

@@ -1,5 +1,5 @@
 import * as http from "node:http";
-import { x } from "tinyexec";
+import { run } from "@towles/shared";
 
 /**
  * Start a local HTTP server to serve the generated HTML.
@@ -54,7 +54,7 @@ export async function startServer(
  */
 export function openInBrowser(url: string): void {
   const openCmd = process.platform === "darwin" ? "open" : "xdg-open";
-  x(openCmd, [url]);
+  run(openCmd, [url]);
 }
 
 /**

package/src/{lib → commands}/graph/types.ts

@@ -23,6 +23,8 @@ export interface JournalEntry {
     content?: ContentBlock[] | string;
   };
   uuid?: string;
+  gitBranch?: string;
+  slug?: string;
 }
 
 export interface ToolData {

package/src/commands/graph.test.ts

@@ -2,7 +2,7 @@
  * Tests for graph command --days filtering and bar chart data
  */
 import { describe, it, expect } from "vitest";
-import { analyzeSession, calculateCutoffMs, filterByDays } from "../lib/graph/index.js";
+import { analyzeSession, calculateCutoffMs, filterByDays } from "./graph/index.js";
 
 describe("graph --days filtering", () => {
   describe("calculateCutoffMs", () => {

package/src/commands/install.ts

@@ -7,7 +7,7 @@ import {
   loadClaudeSettings,
   applyRecommendedSettings,
   saveClaudeSettings,
-} from "../lib/install/claude-settings.js";
+} from "./claude-settings.js";
 
 export default defineCommand({
   meta: {
@@ -64,12 +64,12 @@ export default defineCommand({
 });
 
 async function ensureClaudePlugins(): Promise<void> {
-  const { x } = await import("tinyexec");
+  const { run } = await import("@towles/shared");
 
   const requiredPlugins = [
     {
       id: "tt@towles-tool",
-      name: "tt-core",
+      name: "core",
       marketplaceUrl: "https://github.com/ChrisTowles/towles-tool",
       marketplace: "towles-tool",
     },
@@ -81,7 +81,7 @@ async function ensureClaudePlugins(): Promise<void> {
 
   let installedIds = new Set<string>();
   try {
-    const result = await x("claude", ["plugin", "list", "--json"]);
+    const result = await run("claude", ["plugin", "list", "--json"]);
     const plugins: { id: string }[] = JSON.parse(result.stdout);
     installedIds = new Set(plugins.map((p) => p.id));
   } catch {
@@ -91,7 +91,7 @@ async function ensureClaudePlugins(): Promise<void> {
   for (const plugin of requiredPlugins) {
     if (plugin.marketplaceUrl && !installedIds.has(plugin.id)) {
       try {
-        await x("claude", ["plugin", "marketplace", "add", plugin.marketplaceUrl]);
+        await run("claude", ["plugin", "marketplace", "add", plugin.marketplaceUrl]);
         consola.log(colors.dim(`  Added marketplace: ${plugin.marketplace}`));
       } catch {
         // marketplace may already be added
@@ -111,7 +111,7 @@ async function ensureClaudePlugins(): Promise<void> {
     });
 
     if (answer) {
-      const result = await x("claude", ["plugin", "install", plugin.id, "--scope", "user"]);
+      const result = await run("claude", ["plugin", "install", plugin.id, "--scope", "user"]);
       if (result.exitCode === 0) {
         consola.log(colors.green(`✓ ${plugin.name} installed`));
       } else {

package/src/commands/journal/daily-notes.ts

@@ -6,13 +6,10 @@ import consola from "consola";
 import { colors } from "consola/utils";
 import { withSettings, debugArg } from "../shared.js";
 import { JOURNAL_TYPES } from "../../types/journal.js";
-import {
-  createJournalContent,
-  ensureDirectoryExists,
-  ensureTemplatesExist,
-  generateJournalFileInfoByType,
-  openInEditor,
-} from "../../lib/journal/index.js";
+import { ensureDirectoryExists } from "./fs.js";
+import { openInEditor } from "./editor.js";
+import { createJournalContent, ensureTemplatesExist } from "./templates.js";
+import { generateJournalFileInfoByType } from "./paths.js";
 
 export default defineCommand({
   meta: {

package/src/{lib → commands}/journal/fs.ts

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import consola from "consola";
 import { colors } from "consola/utils";
-import { ensureDir } from "../../utils/fs.js";
+import { ensureDir } from "@towles/shared";
 
 /**
  * Create journal directory if it doesn't exist

package/src/commands/journal/index.ts

@@ -6,5 +6,7 @@ export default defineCommand({
     "daily-notes": () => import("./daily-notes.js").then((m) => m.default),
     note: () => import("./note.js").then((m) => m.default),
     meeting: () => import("./meeting.js").then((m) => m.default),
+    search: () => import("./search.js").then((m) => m.default),
+    list: () => import("./list.js").then((m) => m.default),
   },
 });