@towles/tool 0.0.62 → 0.0.64

package/src/lib/graph/treemap.ts

@@ -0,0 +1,211 @@
+import {
+  aggregateSessionTools,
+  analyzeSession,
+  extractProjectName,
+  getModelName,
+  getPrimaryModel,
+} from "./analyzer.js";
+import { extractSessionLabel } from "./labels.js";
+import { parseJsonl } from "./parser.js";
+import { extractToolData } from "./tools.js";
+import type { JournalEntry, TreemapNode } from "./types.js";
+
+/**
+ * Build turn-level nodes from session entries.
+ * Used by both single-session and all-sessions views.
+ */
+export function buildTurnNodes(
+  sessionId: string,
+  entries: JournalEntry[],
+  filePath?: string,
+): TreemapNode[] {
+  const children: TreemapNode[] = [];
+  let turnNumber = 0;
+
+  for (const entry of entries) {
+    if (entry.type !== "user" && entry.type !== "assistant") continue;
+    if (!entry.message) continue;
+
+    const role = entry.message.role;
+    const usage = entry.message.usage;
+    const model = entry.message.model;
+
+    if (role === "user") {
+      turnNumber++;
+    }
+
+    if (!usage) continue;
+
+    const inputTokens = usage.input_tokens || 0;
+    const outputTokens = usage.output_tokens || 0;
+    const totalTokens = inputTokens + outputTokens;
+
+    if (totalTokens === 0) continue;
+
+    const ratio = outputTokens > 0 ? inputTokens / outputTokens : inputTokens > 0 ? 999 : 0;
+
+    // Extract individual tool calls from content blocks
+    const tools = extractToolData(entry.message.content, inputTokens, outputTokens);
+
+    // Create individual tool children nodes
+    const toolChildren: TreemapNode[] = tools.map((tool) => ({
+      name: tool.detail ? `${tool.name}: ${tool.detail}` : tool.name,
+      value: tool.inputTokens + tool.outputTokens,
+      inputTokens: tool.inputTokens,
+      outputTokens: tool.outputTokens,
+      ratio: tool.outputTokens > 0 ? tool.inputTokens / tool.outputTokens : 0,
+      toolName: tool.name,
+    }));
+
+    // Format turn name based on tools used
+    let turnName: string;
+    let primaryToolName: string | undefined;
+    if (role === "user") {
+      turnName = `Turn ${turnNumber}: User`;
+    } else if (tools.length === 1) {
+      // Single tool: show tool name and detail
+      const t = tools[0];
+      turnName = t.detail ? `${t.name}: ${t.detail}` : t.name;
+      primaryToolName = t.name;
+    } else if (tools.length > 1) {
+      // Multiple tools: list unique tool names, primary is most common
+      const uniqueNames = [...new Set(tools.map((t) => t.name))];
+      turnName = uniqueNames.slice(0, 3).join(", ") + (uniqueNames.length > 3 ? "..." : "");
+      primaryToolName = tools[0].name; // Use first tool as primary
+    } else {
+      turnName = `Turn ${turnNumber}: Response`;
+      primaryToolName = "Response";
+    }
+    children.push({
+      name: turnName,
+      value: toolChildren.length > 0 ? undefined : totalTokens, // Let children sum if present
+      children: toolChildren.length > 0 ? toolChildren : undefined,
+      sessionId: sessionId.slice(0, 8),
+      fullSessionId: sessionId,
+      filePath,
+      toolName: primaryToolName,
+      model: getModelName(model),
+      inputTokens,
+      outputTokens,
+      ratio,
+      tools: tools.length > 0 ? tools : undefined,
+    });
+  }
+
+  return children;
+}
+
+/**
+ * Build treemap for a single session.
+ */
+export function buildSessionTreemap(sessionId: string, entries: JournalEntry[]): TreemapNode {
+  return {
+    name: `Session ${sessionId.slice(0, 8)}`,
+    children: buildTurnNodes(sessionId, entries),
+  };
+}
+
+/**
+ * Build treemap for all sessions, grouped by project and date.
+ */
+export function buildAllSessionsTreemap(
+  sessions: Array<{
+    sessionId: string;
+    path: string;
+    date: string;
+    tokens: number;
+    project: string;
+  }>,
+): TreemapNode {
+  // Group sessions by project, then by date
+  const byProject = new Map<string, typeof sessions>();
+  for (const session of sessions) {
+    const projectName = extractProjectName(session.project);
+    if (!byProject.has(projectName)) {
+      byProject.set(projectName, []);
+    }
+    byProject.get(projectName)!.push(session);
+  }
+
+  // Sort projects by total tokens
+  const projectTotals = [...byProject.entries()].map(([name, sess]) => ({
+    name,
+    sessions: sess,
+    total: sess.reduce((sum, s) => sum + s.tokens, 0),
+  }));
+  projectTotals.sort((a, b) => b.total - a.total);
+
+  const projectChildren: TreemapNode[] = [];
+
+  for (const { name: projectName, sessions: projectSessions } of projectTotals) {
+    // Group by date within project
+    const byDate = new Map<string, typeof sessions>();
+    for (const session of projectSessions) {
+      if (!byDate.has(session.date)) {
+        byDate.set(session.date, []);
+      }
+      byDate.get(session.date)!.push(session);
+    }
+
+    // Sort dates (most recent first)
+    const sortedDates = [...byDate.keys()].sort().reverse();
+
+    const dateChildren: TreemapNode[] = [];
+
+    for (const date of sortedDates) {
+      const dateSessions = byDate.get(date)!;
+
+      const sessionChildren: TreemapNode[] = [];
+
+      for (const session of dateSessions) {
+        const entries = parseJsonl(session.path);
+        const analysis = analyzeSession(entries);
+        const label = extractSessionLabel(entries, session.sessionId);
+        const tools = aggregateSessionTools(entries);
+        const startTime = entries[0]?.timestamp
+          ? new Date(entries[0].timestamp).toLocaleTimeString()
+          : undefined;
+
+        // Build turn-level children for drill-down
+        const turnChildren = buildTurnNodes(session.sessionId, entries, session.path);
+
+        sessionChildren.push({
+          name: label,
+          // If we have turn children, let them sum; otherwise use session total
+          value: turnChildren.length > 0 ? undefined : session.tokens,
+          children: turnChildren.length > 0 ? turnChildren : undefined,
+          sessionId: session.sessionId.slice(0, 8),
+          fullSessionId: session.sessionId,
+          filePath: session.path,
+          startTime,
+          model: getPrimaryModel(analysis),
+          inputTokens: analysis.inputTokens,
+          outputTokens: analysis.outputTokens,
+          ratio: analysis.outputTokens > 0 ? analysis.inputTokens / analysis.outputTokens : 0,
+          date: session.date,
+          project: projectName,
+          repeatedReads: analysis.repeatedReads,
+          modelEfficiency: analysis.modelEfficiency,
+          tools: tools.length > 0 ? tools : undefined,
+        });
+      }
+
+      dateChildren.push({
+        name: date,
+        children: sessionChildren,
+        date,
+      });
+    }
+
+    projectChildren.push({
+      name: projectName,
+      children: dateChildren,
+      project: projectName,
+    });
+  }
+
+  return {
+    name: "All Sessions",
+    children: projectChildren,
+  };
+}

package/src/lib/graph/types.ts

@@ -0,0 +1,80 @@
+// Types for parsing Claude Code session JSONL files
+export interface ContentBlock {
+  type: string;
+  text?: string;
+  id?: string;
+  name?: string;
+  input?: Record<string, unknown>;
+}
+
+export interface JournalEntry {
+  type: string;
+  sessionId: string;
+  timestamp: string;
+  message?: {
+    role: "user" | "assistant";
+    model?: string;
+    usage?: {
+      input_tokens?: number;
+      output_tokens?: number;
+      cache_read_input_tokens?: number;
+      cache_creation_input_tokens?: number;
+    };
+    content?: ContentBlock[] | string;
+  };
+  uuid?: string;
+}
+
+export interface ToolData {
+  name: string;
+  detail?: string;
+  inputTokens: number;
+  outputTokens: number;
+}
+
+// Bar chart types for stacked bar visualization - aggregated by project
+export interface ProjectBar {
+  project: string;
+  totalTokens: number;
+}
+
+export interface BarChartDay {
+  date: string; // YYYY-MM-DD format
+  projects: ProjectBar[];
+}
+
+export interface BarChartData {
+  days: BarChartDay[];
+}
+
+export interface SessionResult {
+  sessionId: string;
+  path: string;
+  date: string;
+  tokens: number;
+  project: string;
+  mtime: number;
+}
+
+export interface TreemapNode {
+  name: string;
+  value?: number;
+  children?: TreemapNode[];
+  // Metadata for tooltips
+  sessionId?: string;
+  fullSessionId?: string;
+  filePath?: string;
+  startTime?: string;
+  model?: string;
+  inputTokens?: number;
+  outputTokens?: number;
+  ratio?: number;
+  date?: string;
+  project?: string;
+  // Waste metrics
+  repeatedReads?: number;
+  modelEfficiency?: number; // Opus tokens / total tokens
+  // Tool data
+  tools?: ToolData[];
+  toolName?: string; // For coloring by tool type
+}

package/src/lib/install/claude-settings.ts

@@ -0,0 +1,64 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+
+export interface ClaudeSettings {
+  cleanupPeriodDays?: number;
+  alwaysThinkingEnabled?: boolean;
+  hooks?: Record<string, unknown[]>;
+  [key: string]: unknown;
+}
+
+export const CLAUDE_SETTINGS_PATH = path.join(homedir(), ".claude", "settings.json");
+
+/**
+ * Load Claude settings from the given path.
+ * Returns an empty object if the file is missing or contains invalid JSON.
+ */
+export function loadClaudeSettings(settingsPath: string): ClaudeSettings {
+  if (!fs.existsSync(settingsPath)) {
+    return {};
+  }
+  try {
+    const content = fs.readFileSync(settingsPath, "utf-8");
+    return JSON.parse(content) as ClaudeSettings;
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Pure function that applies recommended defaults and returns the updated
+ * settings plus a list of human-readable change descriptions.
+ */
+export function applyRecommendedSettings(settings: ClaudeSettings): {
+  settings: ClaudeSettings;
+  changes: string[];
+} {
+  const result = { ...settings };
+  const changes: string[] = [];
+
+  if (result.cleanupPeriodDays !== 99999) {
+    result.cleanupPeriodDays = 99999;
+    changes.push("Set cleanupPeriodDays: 99999 (prevent log deletion)");
+  }
+
+  if (result.alwaysThinkingEnabled !== true) {
+    result.alwaysThinkingEnabled = true;
+    changes.push("Set alwaysThinkingEnabled: true");
+  }
+
+  return { settings: result, changes };
+}
+
+/**
+ * Write Claude settings as formatted JSON to the given path,
+ * creating parent directories if needed.
+ */
+export function saveClaudeSettings(settingsPath: string, settings: ClaudeSettings): void {
+  const dir = path.dirname(settingsPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+}

package/src/lib/journal/editor.ts

@@ -0,0 +1,33 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import consola from "consola";
+
+const execAsync = promisify(exec);
+
+/**
+ * Open file in default editor with folder context
+ */
+export async function openInEditor({
+  editor,
+  filePath,
+  folderPath,
+}: {
+  editor: string;
+  filePath: string;
+  folderPath?: string;
+}): Promise<void> {
+  try {
+    if (folderPath) {
+      // Open both folder and file - this works with VS Code and similar editors
+      // the purpose is to open the folder context for better navigation
+      await execAsync(`"${editor}" "${folderPath}" "${filePath}"`);
+    } else {
+      await execAsync(`"${editor}" "${filePath}"`);
+    }
+  } catch (ex) {
+    consola.warn(
+      `Could not open in editor : '${editor}'. Modify your editor in the config: examples include 'code', 'code-insiders',  etc...`,
+      ex,
+    );
+  }
+}

package/src/lib/journal/fs.ts

@@ -0,0 +1,13 @@
+import { existsSync, mkdirSync } from "node:fs";
+import consola from "consola";
+import { colors } from "consola/utils";
+
+/**
+ * Create journal directory if it doesn't exist
+ */
+export function ensureDirectoryExists(folderPath: string): void {
+  if (!existsSync(folderPath)) {
+    consola.info(`Creating journal directory: ${colors.cyan(folderPath)}`);
+    mkdirSync(folderPath, { recursive: true });
+  }
+}

package/src/lib/journal/index.ts

@@ -0,0 +1,11 @@
+export { ensureDirectoryExists } from "./fs.js";
+export { openInEditor } from "./editor.js";
+export {
+  loadTemplate,
+  ensureTemplatesExist,
+  createJournalContent,
+  createMeetingContent,
+  createNoteContent,
+} from "./templates.js";
+export { resolvePathTemplate, generateJournalFileInfoByType } from "./paths.js";
+export type { GenerateJournalFileResult, GenerateJournalFileParams } from "./paths.js";

package/src/lib/journal/paths.ts

@@ -0,0 +1,106 @@
+import path from "node:path";
+import consola from "consola";
+import { DateTime } from "luxon";
+import { getMondayOfWeek } from "../../utils/date-utils.js";
+import type { JournalSettings } from "../../config/settings.js";
+import { JOURNAL_TYPES } from "../../types/journal.js";
+import type { JournalType } from "../../types/journal.js";
+
+export interface GenerateJournalFileResult {
+  fullPath: string;
+  mondayDate: Date;
+  currentDate: Date;
+}
+
+export interface GenerateJournalFileParams {
+  date: Date;
+  type: JournalType;
+  title: string;
+  journalSettings: JournalSettings;
+}
+
+export function resolvePathTemplate(
+  template: string,
+  title: string,
+  date: Date,
+  mondayDate: Date,
+): string {
+  const dateTime = DateTime.fromJSDate(date, { zone: "utc" });
+
+  // Replace Luxon format tokens wrapped in curly braces
+  return template.replace(/\{([^}]+)\}/g, (match, token) => {
+    try {
+      if (token === "title") {
+        return title.toLowerCase().replace(/\s+/g, "-");
+      }
+
+      if (token.startsWith("monday:")) {
+        const mondayToken = token.substring(7); // Remove 'monday:' prefix
+        const mondayDateTime = DateTime.fromJSDate(mondayDate, { zone: "utc" });
+        return mondayDateTime.toFormat(mondayToken);
+      }
+
+      const result = dateTime.toFormat(token);
+      // Check if the result contains suspicious patterns that indicate invalid tokens
+      // This is a heuristic to detect when Luxon produces garbage output for invalid tokens
+      const isLikelyInvalid =
+        token.includes("invalid") ||
+        result.length > 20 || // Very long results are likely garbage
+        (result.length > token.length * 2 && /\d{10,}/.test(result)) || // Contains very long numbers
+        result.includes("UTC");
+
+      if (isLikelyInvalid) {
+        consola.warn(`Invalid date format token: ${token}`);
+        return match;
+      }
+      return result;
+    } catch (error) {
+      consola.warn(`Invalid date format token: ${token}`);
+      return match; // Return original token if format is invalid
+    }
+  });
+}
+
+/**
+ * Generate journal file info for different types using individual path templates
+ */
+export function generateJournalFileInfoByType({
+  journalSettings,
+  date = new Date(),
+  type,
+  title,
+}: GenerateJournalFileParams): GenerateJournalFileResult {
+  const currentDate = new Date(date);
+
+  let templatePath: string;
+  let mondayDate: Date;
+
+  switch (type) {
+    case JOURNAL_TYPES.DAILY_NOTES:
+      templatePath = journalSettings.dailyPathTemplate;
+      mondayDate = getMondayOfWeek(currentDate);
+      break;
+    case JOURNAL_TYPES.MEETING:
+      templatePath = journalSettings.meetingPathTemplate;
+      mondayDate = currentDate;
+      break;
+    case JOURNAL_TYPES.NOTE:
+      templatePath = journalSettings.notePathTemplate;
+      mondayDate = currentDate;
+      break;
+    default:
+      throw new Error(`Unknown JournalType: ${type}`);
+  }
+
+  // Resolve the path template and extract directory structure
+  const resolvedPath = resolvePathTemplate(templatePath, title, currentDate, mondayDate);
+
+  // Join baseFolder with the resolved path
+  const fullPath = path.join(journalSettings.baseFolder, resolvedPath);
+
+  return {
+    currentDate,
+    fullPath,
+    mondayDate,
+  } satisfies GenerateJournalFileResult;
+}

package/src/lib/journal/{utils.ts → templates.ts}

@@ -1,14 +1,9 @@
-import { exec } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
-import { promisify } from "node:util";
 import consola from "consola";
 import { colors } from "consola/utils";
-import { DateTime } from "luxon";
-import { formatDate, getMondayOfWeek, getWeekInfo } from "../../utils/date-utils.js";
-import type { JournalSettings } from "../../config/settings.js";
-import { JOURNAL_TYPES } from "../../types/journal.js";
-import type { JournalType } from "../../types/journal.js";
+import { formatDate, getWeekInfo } from "../../utils/date-utils.js";
+import { ensureDirectoryExists } from "./fs.js";
 
 // Default template file names
 const TEMPLATE_FILES = {
@@ -17,18 +12,6 @@ const TEMPLATE_FILES = {
   note: "note.md",
 } as const;
 
-const execAsync = promisify(exec);
-
-/**
- * Create journal directory if it doesn't exist
- */
-export function ensureDirectoryExists(folderPath: string): void {
-  if (!existsSync(folderPath)) {
-    consola.info(`Creating journal directory: ${colors.cyan(folderPath)}`);
-    mkdirSync(folderPath, { recursive: true });
-  }
-}
-
 /**
  * Load template from external file or return null if not found
  */
@@ -266,134 +249,3 @@ export function createNoteContent({
 
   return content.join("\n");
 }
-
-/**
- * Open file in default editor with folder context
- */
-export async function openInEditor({
-  editor,
-  filePath,
-  folderPath,
-}: {
-  editor: string;
-  filePath: string;
-  folderPath?: string;
-}): Promise<void> {
-  try {
-    if (folderPath) {
-      // Open both folder and file - this works with VS Code and similar editors
-      // the purpose is to open the folder context for better navigation
-      await execAsync(`"${editor}" "${folderPath}" "${filePath}"`);
-    } else {
-      await execAsync(`"${editor}" "${filePath}"`);
-    }
-  } catch (ex) {
-    consola.warn(
-      `Could not open in editor : '${editor}'. Modify your editor in the config: examples include 'code', 'code-insiders',  etc...`,
-      ex,
-    );
-  }
-}
-
-export function resolvePathTemplate(
-  template: string,
-  title: string,
-  date: Date,
-  mondayDate: Date,
-): string {
-  const dateTime = DateTime.fromJSDate(date, { zone: "utc" });
-
-  // Replace Luxon format tokens wrapped in curly braces
-  return template.replace(/\{([^}]+)\}/g, (match, token) => {
-    try {
-      if (token === "title") {
-        return title.toLowerCase().replace(/\s+/g, "-");
-      }
-
-      if (token.startsWith("monday:")) {
-        const mondayToken = token.substring(7); // Remove 'monday:' prefix
-        const mondayDateTime = DateTime.fromJSDate(mondayDate, { zone: "utc" });
-        return mondayDateTime.toFormat(mondayToken);
-      }
-
-      const result = dateTime.toFormat(token);
-      // Check if the result contains suspicious patterns that indicate invalid tokens
-      // This is a heuristic to detect when Luxon produces garbage output for invalid tokens
-      const isLikelyInvalid =
-        token.includes("invalid") ||
-        result.length > 20 || // Very long results are likely garbage
-        (result.length > token.length * 2 && /\d{10,}/.test(result)) || // Contains very long numbers
-        result.includes("UTC");
-
-      if (isLikelyInvalid) {
-        consola.warn(`Invalid date format token: ${token}`);
-        return match;
-      }
-      return result;
-    } catch (error) {
-      consola.warn(`Invalid date format token: ${token}`);
-      return match; // Return original token if format is invalid
-    }
-  });
-}
-
-interface GenerateJournalFileResult {
-  fullPath: string;
-  mondayDate: Date;
-  currentDate: Date;
-}
-
-interface GenerateJournalFileParams {
-  date: Date;
-  type: JournalType;
-  title: string;
-  journalSettings: JournalSettings;
-}
-
-/**
- * Generate journal file info for different types using individual path templates
- */
-export function generateJournalFileInfoByType({
-  journalSettings,
-  date = new Date(),
-  type,
-  title,
-}: GenerateJournalFileParams): GenerateJournalFileResult {
-  const currentDate = new Date(date);
-
-  let templatePath: string = "";
-  let mondayDate: Date = getMondayOfWeek(currentDate);
-
-  switch (type) {
-    case JOURNAL_TYPES.DAILY_NOTES: {
-      const monday = getMondayOfWeek(currentDate);
-      templatePath = journalSettings.dailyPathTemplate;
-      mondayDate = monday;
-      break;
-    }
-    case JOURNAL_TYPES.MEETING: {
-      templatePath = journalSettings.meetingPathTemplate;
-      mondayDate = currentDate;
-      break;
-    }
-    case JOURNAL_TYPES.NOTE: {
-      templatePath = journalSettings.notePathTemplate;
-      mondayDate = currentDate;
-      break;
-    }
-    default:
-      throw new Error(`Unknown JournalType: ${type}`);
-  }
-
-  // Resolve the path template and extract directory structure
-  const resolvedPath = resolvePathTemplate(templatePath, title, currentDate, mondayDate);
-
-  // Join baseFolder with the resolved path
-  const fullPath = path.join(journalSettings.baseFolder, resolvedPath);
-
-  return {
-    currentDate: currentDate,
-    fullPath: fullPath,
-    mondayDate,
-  } satisfies GenerateJournalFileResult;
-}