@towles/tool 0.0.87 → 0.0.89

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@towles/tool",
-  "version": "0.0.87",
+  "version": "0.0.89",
   "description": "One off quality of life scripts that I use on a daily basis.",
   "homepage": "https://github.com/ChrisTowles/towles-tool#readme",
   "bugs": {

package/src/lib/auto-claude/claude-cli.ts

@@ -1,12 +1,15 @@
 import { createInterface } from "node:readline";
+import { join } from "node:path";
 
 import consola from "consola";
 import pc from "picocolors";
 
+import { readFile } from "../../utils/fs.js";
 import { getConfig } from "./config.js";
 import { sleep } from "./shell.js";
 import { spawnClaude as defaultSpawnClaude } from "./spawn-claude.js";
 import type { SpawnClaudeFn } from "./spawn-claude.js";
+import { parseStreamLine } from "./stream-parser.js";
 
 // ── Claude CLI ──
 
@@ -52,6 +55,20 @@ export async function runClaude(opts: {
 
   log.info(`${pc.dim("▶")} Calling Claude${opts.maxTurns ? ` (max ${opts.maxTurns} turns)` : ""}…`);
 
+  try {
+    const systemPrompt = readFile(join(process.cwd(), "CLAUDE.md"));
+    log.info(
+      `\n${pc.bold(pc.cyan("── System Prompt (CLAUDE.md) ──"))}\n${pc.dim(systemPrompt.trimEnd())}\n`,
+    );
+  } catch { /* CLAUDE.md not present */ }
+
+  try {
+    const promptContent = readFile(join(process.cwd(), opts.promptFile));
+    log.info(
+      `\n${pc.bold(pc.cyan(`── Prompt (${opts.promptFile}) ──`))}\n${pc.dim(promptContent.trimEnd())}\n`,
+    );
+  } catch { /* prompt file not present */ }
+
   let lastError: Error | undefined;
   for (let attempt = 1; attempt <= PROCESS_RETRIES; attempt++) {
     try {
@@ -74,6 +91,31 @@ export async function runClaude(opts: {
   throw lastError ?? new Error("runClaude failed after all retries");
 }
 
+function logActivityEvent(event: ReturnType<typeof parseStreamLine>, log: ClaudeLogger): void {
+  if (!event) return;
+
+  switch (event.kind) {
+    case "tool_use":
+      log.info(
+        `  ${pc.dim("\u21B3")} ${event.name}${event.detail ? pc.dim(` ${event.detail}`) : ""}`,
+      );
+      break;
+    case "thinking":
+      log.info(
+        `  ${pc.dim("\u21B3")} ${pc.italic("thinking")}${event.summary ? pc.dim(` ${event.summary}`) : ""}`,
+      );
+      break;
+    case "text":
+      if (event.content.trim()) {
+        log.info(`  ${pc.dim("\u21B3")} ${pc.dim(event.content.split("\n")[0].trim())}`);
+      }
+      break;
+    case "result":
+      // Handled separately via capturedResult
+      break;
+  }
+}
+
 function runClaudeStreaming(
   args: string[],
   spawnFn: SpawnClaudeFn,
@@ -93,19 +135,28 @@ function runClaudeStreaming(
 
     rl.on("line", (line) => {
       if (!line.trim()) return;
+
+      const activity = parseStreamLine(line);
+      logActivityEvent(activity, log);
+
+      if (activity?.kind === "result") {
+        capturedResult = {
+          result: "",
+          is_error: activity.isError,
+          total_cost_usd: activity.costUsd,
+          num_turns: activity.numTurns,
+        };
+      }
+
+      // Track turn count from intermediate events (parser returns null for these)
       try {
-        const event = JSON.parse(line) as Record<string, unknown>;
-        handleStreamEvent(event, log, (turns) => {
-          turnCount = turns;
-        });
-
-        if ("result" in event && "is_error" in event && "num_turns" in event) {
-          capturedResult = {
-            result: String(event.result ?? ""),
-            is_error: Boolean(event.is_error),
-            total_cost_usd: Number(event.total_cost_usd ?? 0),
-            num_turns: Number(event.num_turns),
-          };
+        const raw = JSON.parse(line) as Record<string, unknown>;
+        if (typeof raw.num_turns === "number" && !("result" in raw)) {
+          turnCount = raw.num_turns as number;
+        }
+        // Capture the result text from the final event
+        if ("result" in raw && capturedResult) {
+          capturedResult.result = String(raw.result ?? "");
         }
       } catch {
         // Skip non-JSON lines
@@ -129,74 +180,3 @@ function runClaudeStreaming(
     });
   });
 }
-
-function truncate(s: string, max: number): string {
-  return s.length > max ? s.slice(0, max) + "\u2026" : s;
-}
-
-function toolDetail(block: Record<string, unknown>): string {
-  const input =
-    typeof block.input === "object" && block.input !== null
-      ? (block.input as Record<string, unknown>)
-      : null;
-  if (!input) return "";
-
-  const filePath = input.file_path ?? input.path;
-  if (typeof filePath === "string") {
-    let detail = pc.dim(` ${filePath}`);
-    // Show edit context for Edit tool
-    if (typeof input.old_string === "string" && typeof input.new_string === "string") {
-      const old = truncate(input.old_string.split("\n")[0].trim(), 40);
-      const replacement = truncate(input.new_string.split("\n")[0].trim(), 40);
-      detail += pc.dim(` "${old}" → "${replacement}"`);
-    }
-    return detail;
-  }
-  if (typeof input.pattern === "string") return pc.dim(` ${input.pattern}`);
-  if (typeof input.command === "string") {
-    return pc.dim(` ${truncate(input.command, 60)}`);
-  }
-  // TodoWrite/TaskCreate — show subject
-  if (typeof input.subject === "string") return pc.dim(` ${truncate(input.subject, 60)}`);
-  return "";
-}
-
-function logToolUse(block: Record<string, unknown>, log: ClaudeLogger): void {
-  const name = block.name;
-  if (typeof name === "string") {
-    log.info(`  ${pc.dim("\u21B3")} ${name}${toolDetail(block)}`);
-  }
-}
-
-function handleStreamEvent(
-  event: Record<string, unknown>,
-  log: ClaudeLogger,
-  onTurn: (count: number) => void,
-): void {
-  // Only handle stream_event — assistant turn events duplicate the same tools
-  if (event.type === "stream_event" && typeof event.event === "object" && event.event !== null) {
-    const inner = event.event as Record<string, unknown>;
-
-    if (
-      inner.type === "content_block_start" &&
-      typeof inner.content_block === "object" &&
-      inner.content_block !== null
-    ) {
-      const block = inner.content_block as Record<string, unknown>;
-      if (block.type === "tool_use") {
-        logToolUse(block, log);
-      } else if (block.type === "thinking") {
-        const thinkingText =
-          typeof block.thinking === "string" && block.thinking.length > 0
-            ? pc.dim(` ${truncate(block.thinking.split("\n")[0].trim(), 60)}`)
-            : "";
-        log.info(`  ${pc.dim("\u21B3")} ${pc.italic("thinking")}${thinkingText}`);
-      }
-    }
-  }
-
-  // Turn count tracking
-  if (typeof event.num_turns === "number" && !("result" in event)) {
-    onTurn(event.num_turns as number);
-  }
-}

package/src/lib/auto-claude/stream-parser.test.ts

@@ -0,0 +1,412 @@
+import { describe, it, expect } from "vitest";
+import { parseStreamLine } from "./stream-parser";
+
+describe("parseStreamLine", () => {
+  it("returns null for empty lines", () => {
+    expect(parseStreamLine("")).toBeNull();
+    expect(parseStreamLine("   ")).toBeNull();
+  });
+
+  it("returns null for invalid JSON", () => {
+    expect(parseStreamLine("not json")).toBeNull();
+    expect(parseStreamLine("{broken")).toBeNull();
+  });
+
+  it("returns null for unrecognized event types", () => {
+    expect(parseStreamLine(JSON.stringify({ type: "ping" }))).toBeNull();
+    expect(parseStreamLine(JSON.stringify({ type: "system", data: {} }))).toBeNull();
+  });
+
+  describe("result events", () => {
+    it("parses a result event", () => {
+      const line = JSON.stringify({
+        result: "Task completed",
+        is_error: false,
+        num_turns: 5,
+        cost_usd: 0.0342,
+        duration_ms: 12000,
+      });
+
+      expect(parseStreamLine(line)).toEqual({
+        kind: "result",
+        costUsd: 0.0342,
+        durationMs: 12000,
+        numTurns: 5,
+        isError: false,
+      });
+    });
+
+    it("parses an error result", () => {
+      const line = JSON.stringify({
+        result: "Failed",
+        is_error: true,
+        num_turns: 1,
+        cost_usd: 0.001,
+        duration_ms: 500,
+      });
+
+      expect(parseStreamLine(line)).toEqual({
+        kind: "result",
+        costUsd: 0.001,
+        durationMs: 500,
+        numTurns: 1,
+        isError: true,
+      });
+    });
+
+    it("defaults cost and duration to 0 when missing", () => {
+      const line = JSON.stringify({
+        result: "done",
+        is_error: false,
+        num_turns: 3,
+      });
+
+      const event = parseStreamLine(line);
+      expect(event?.kind).toBe("result");
+      if (event?.kind === "result") {
+        expect(event.costUsd).toBe(0);
+        expect(event.durationMs).toBe(0);
+      }
+    });
+
+    it("handles total_cost_usd field name", () => {
+      const line = JSON.stringify({
+        result: "done",
+        is_error: false,
+        num_turns: 2,
+        total_cost_usd: 0.05,
+      });
+
+      const event = parseStreamLine(line);
+      if (event?.kind === "result") {
+        expect(event.costUsd).toBe(0.05);
+      }
+    });
+  });
+
+  describe("stream_event tool_use", () => {
+    it("parses a tool_use event with file_path input", () => {
+      const line = JSON.stringify({
+        type: "stream_event",
+        event: {
+          type: "content_block_start",
+          content_block: {
+            type: "tool_use",
+            name: "Read",
+            input: { file_path: "/home/user/code/main.ts" },
+          },
+        },
+      });
+
+      expect(parseStreamLine(line)).toEqual({
+        kind: "tool_use",
+        name: "Read",
+        detail: "/home/user/code/main.ts",
+        input: { file_path: "/home/user/code/main.ts" },
+      });
+    });
+
+    it("parses Edit tool with old/new string detail", () => {
+      const line = JSON.stringify({
+        type: "stream_event",
+        event: {
+          type: "content_block_start",
+          content_block: {
+            type: "tool_use",
+            name: "Edit",
+            input: {
+              file_path: "src/index.ts",
+              old_string: "const x = 1;",
+              new_string: "const x = 2;",
+            },
+          },
+        },
+      });
+
+      const event = parseStreamLine(line);
+      expect(event?.kind).toBe("tool_use");
+      if (event?.kind === "tool_use") {
+        expect(event.name).toBe("Edit");
+        expect(event.detail).toContain("src/index.ts");
+        expect(event.detail).toContain('"const x = 1;"');
+        expect(event.detail).toContain('"const x = 2;"');
+      }
+    });
+
+    it("parses Bash tool with command detail", () => {
+      const line = JSON.stringify({
+        type: "stream_event",
+        event: {
+          type: "content_block_start",
+          content_block: {
+            type: "tool_use",
+            name: "Bash",
+            input: { command: "pnpm test" },
+          },
+        },
+      });
+
+      const event = parseStreamLine(line);
+      if (event?.kind === "tool_use") {
+        expect(event.name).toBe("Bash");
+        expect(event.detail).toBe("pnpm test");
+      }
+    });
+
+    it("parses Grep tool with pattern detail", () => {
+      const line = JSON.stringify({
+        type: "stream_event",
+        event: {
+          type: "content_block_start",
+          content_block: {
+            type: "tool_use",
+            name: "Grep",
+            input: { pattern: "parseStreamLine" },
+          },
+        },
+      });
+
+      const event = parseStreamLine(line);
+      if (event?.kind === "tool_use") {
+        expect(event.name).toBe("Grep");
+        expect(event.detail).toBe("parseStreamLine");
+      }
+    });
+
+    it("returns empty detail for tool with no recognized input fields", () => {
+      const line = JSON.stringify({
+        type: "stream_event",
+        event: {
+          type: "content_block_start",
+          content_block: {
+            type: "tool_use",
+            name: "CustomTool",
+            input: { some_field: "value" },
+          },
+        },
+      });
+
+      const event = parseStreamLine(line);
+      if (event?.kind === "tool_use") {
+        expect(event.detail).toBe("");
+      }
+    });
+
+    it("handles tool_use with no input", () => {
+      const line = JSON.stringify({
+        type: "stream_event",
+        event: {
+          type: "content_block_start",
+          content_block: { type: "tool_use", name: "SomeTool" },
+        },
+      });
+
+      const event = parseStreamLine(line);
+      if (event?.kind === "tool_use") {
+        expect(event.input).toEqual({});
+        expect(event.detail).toBe("");
+      }
+    });
+  });
+
+  describe("stream_event thinking", () => {
+    it("parses a thinking event", () => {
+      const line = JSON.stringify({
+        type: "stream_event",
+        event: {
+          type: "content_block_start",
+          content_block: {
+            type: "thinking",
+            thinking: "I need to read the file first.",
+          },
+        },
+      });
+
+      expect(parseStreamLine(line)).toEqual({
+        kind: "thinking",
+        summary: "I need to read the file first.",
+      });
+    });
+
+    it("truncates long thinking to 120 chars", () => {
+      const longThinking = "A".repeat(200);
+      const line = JSON.stringify({
+        type: "stream_event",
+        event: {
+          type: "content_block_start",
+          content_block: { type: "thinking", thinking: longThinking },
+        },
+      });
+
+      const event = parseStreamLine(line);
+      if (event?.kind === "thinking") {
+        expect(event.summary.length).toBeLessThanOrEqual(121);
+        expect(event.summary).toContain("\u2026");
+      }
+    });
+
+    it("uses only first line of multi-line thinking", () => {
+      const line = JSON.stringify({
+        type: "stream_event",
+        event: {
+          type: "content_block_start",
+          content_block: {
+            type: "thinking",
+            thinking: "First line\nSecond line\nThird line",
+          },
+        },
+      });
+
+      const event = parseStreamLine(line);
+      if (event?.kind === "thinking") {
+        expect(event.summary).toBe("First line");
+      }
+    });
+
+    it("handles empty thinking", () => {
+      const line = JSON.stringify({
+        type: "stream_event",
+        event: {
+          type: "content_block_start",
+          content_block: { type: "thinking" },
+        },
+      });
+
+      const event = parseStreamLine(line);
+      if (event?.kind === "thinking") {
+        expect(event.summary).toBe("");
+      }
+    });
+  });
+
+  describe("stream_event text", () => {
+    it("parses a text event", () => {
+      const line = JSON.stringify({
+        type: "stream_event",
+        event: {
+          type: "content_block_start",
+          content_block: {
+            type: "text",
+            text: "Here is the implementation plan:",
+          },
+        },
+      });
+
+      expect(parseStreamLine(line)).toEqual({
+        kind: "text",
+        content: "Here is the implementation plan:",
+      });
+    });
+  });
+
+  describe("assistant message format", () => {
+    it("parses tool_use from assistant message content array", () => {
+      const line = JSON.stringify({
+        type: "assistant",
+        message: {
+          content: [
+            {
+              type: "tool_use",
+              name: "Write",
+              input: { file_path: "/tmp/test.ts", content: "hello" },
+            },
+          ],
+        },
+      });
+
+      const event = parseStreamLine(line);
+      expect(event?.kind).toBe("tool_use");
+      if (event?.kind === "tool_use") {
+        expect(event.name).toBe("Write");
+        expect(event.detail).toBe("/tmp/test.ts");
+      }
+    });
+
+    it("parses thinking from assistant message content array", () => {
+      const line = JSON.stringify({
+        type: "assistant",
+        message: {
+          content: [{ type: "thinking", thinking: "Let me think about this" }],
+        },
+      });
+
+      expect(parseStreamLine(line)).toEqual({
+        kind: "thinking",
+        summary: "Let me think about this",
+      });
+    });
+
+    it("parses text from assistant message content array", () => {
+      const line = JSON.stringify({
+        type: "assistant",
+        message: {
+          content: [{ type: "text", text: "I will now implement the feature." }],
+        },
+      });
+
+      expect(parseStreamLine(line)).toEqual({
+        kind: "text",
+        content: "I will now implement the feature.",
+      });
+    });
+
+    it("returns null for empty content array", () => {
+      const line = JSON.stringify({
+        type: "assistant",
+        message: { content: [] },
+      });
+
+      expect(parseStreamLine(line)).toBeNull();
+    });
+
+    it("skips unrecognized blocks and returns first recognized one", () => {
+      const line = JSON.stringify({
+        type: "assistant",
+        message: {
+          content: [
+            { type: "unknown_block", data: "ignored" },
+            { type: "tool_use", name: "Read", input: { file_path: "src/main.ts" } },
+          ],
+        },
+      });
+
+      const event = parseStreamLine(line);
+      expect(event?.kind).toBe("tool_use");
+      if (event?.kind === "tool_use") {
+        expect(event.name).toBe("Read");
+      }
+    });
+  });
+
+  describe("ignores non-interesting events", () => {
+    it("ignores content_block_delta", () => {
+      const line = JSON.stringify({
+        type: "stream_event",
+        event: {
+          type: "content_block_delta",
+          delta: { type: "text_delta", text: "partial" },
+        },
+      });
+
+      expect(parseStreamLine(line)).toBeNull();
+    });
+
+    it("ignores message_start", () => {
+      const line = JSON.stringify({
+        type: "stream_event",
+        event: { type: "message_start", message: {} },
+      });
+
+      expect(parseStreamLine(line)).toBeNull();
+    });
+
+    it("ignores message_stop", () => {
+      const line = JSON.stringify({
+        type: "stream_event",
+        event: { type: "message_stop" },
+      });
+
+      expect(parseStreamLine(line)).toBeNull();
+    });
+  });
+});

package/src/lib/auto-claude/stream-parser.ts

@@ -0,0 +1,139 @@
+export interface AgentToolEvent {
+  kind: "tool_use";
+  name: string;
+  detail: string;
+  input: Record<string, unknown>;
+}
+
+export interface AgentThinkingEvent {
+  kind: "thinking";
+  summary: string;
+}
+
+export interface AgentTextEvent {
+  kind: "text";
+  content: string;
+}
+
+export interface AgentResultEvent {
+  kind: "result";
+  costUsd: number;
+  durationMs: number;
+  numTurns: number;
+  isError: boolean;
+}
+
+export type AgentActivityEvent =
+  | AgentToolEvent
+  | AgentThinkingEvent
+  | AgentTextEvent
+  | AgentResultEvent;
+
+function truncate(s: string, max: number): string {
+  return s.length > max ? s.slice(0, max) + "\u2026" : s;
+}
+
+function toolDetail(block: Record<string, unknown>): string {
+  const input =
+    typeof block.input === "object" && block.input !== null
+      ? (block.input as Record<string, unknown>)
+      : null;
+  if (!input) return "";
+
+  const filePath = input.file_path ?? input.path;
+  if (typeof filePath === "string") {
+    let detail = filePath;
+    if (typeof input.old_string === "string" && typeof input.new_string === "string") {
+      const old = truncate(input.old_string.split("\n")[0].trim(), 40);
+      const replacement = truncate(input.new_string.split("\n")[0].trim(), 40);
+      detail += ` "${old}" -> "${replacement}"`;
+    }
+    return detail;
+  }
+  if (typeof input.pattern === "string") return input.pattern;
+  if (typeof input.command === "string") return truncate(input.command, 60);
+  if (typeof input.subject === "string") return truncate(input.subject, 60);
+  return "";
+}
+
+function parseContentBlock(block: Record<string, unknown>): AgentActivityEvent | null {
+  if (block.type === "tool_use" && typeof block.name === "string") {
+    return {
+      kind: "tool_use",
+      name: block.name,
+      detail: toolDetail(block),
+      input:
+        typeof block.input === "object" && block.input !== null
+          ? (block.input as Record<string, unknown>)
+          : {},
+    };
+  }
+
+  if (block.type === "thinking") {
+    const text = typeof block.thinking === "string" ? block.thinking : "";
+    return {
+      kind: "thinking",
+      summary: truncate(text.split("\n")[0].trim(), 120),
+    };
+  }
+
+  if (block.type === "text" && typeof block.text === "string") {
+    return {
+      kind: "text",
+      content: block.text,
+    };
+  }
+
+  return null;
+}
+
+/** Parse a single NDJSON line from Claude Code's stream-json output */
+export function parseStreamLine(line: string): AgentActivityEvent | null {
+  if (!line.trim()) return null;
+
+  let event: Record<string, unknown>;
+  try {
+    event = JSON.parse(line) as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+
+  // Result event — top-level with result/is_error/num_turns
+  if ("result" in event && "is_error" in event && "num_turns" in event) {
+    return {
+      kind: "result",
+      costUsd: Number(event.cost_usd ?? event.total_cost_usd ?? 0),
+      durationMs: Number(event.duration_ms ?? 0),
+      numTurns: Number(event.num_turns),
+      isError: Boolean(event.is_error),
+    };
+  }
+
+  // Stream events — tool_use, thinking, text inside content_block_start
+  if (event.type === "stream_event" && typeof event.event === "object" && event.event !== null) {
+    const inner = event.event as Record<string, unknown>;
+
+    if (
+      inner.type === "content_block_start" &&
+      typeof inner.content_block === "object" &&
+      inner.content_block !== null
+    ) {
+      return parseContentBlock(inner.content_block as Record<string, unknown>);
+    }
+  }
+
+  // Assistant message events — content array with tool_use/thinking/text
+  if (event.type === "assistant" && typeof event.message === "object" && event.message !== null) {
+    const message = event.message as Record<string, unknown>;
+    if (Array.isArray(message.content)) {
+      for (const block of message.content) {
+        if (typeof block === "object" && block !== null) {
+          const parsed = parseContentBlock(block as Record<string, unknown>);
+          if (parsed) return parsed;
+        }
+      }
+    }
+  }
+
+  return null;
+}