@towles/tool 0.0.20 → 0.0.48

package/src/lib/journal/utils.ts

@@ -0,0 +1,399 @@
+import { exec } from "node:child_process";
+import { existsSync, mkdirSync, 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";
+
+// Default template file names
+const TEMPLATE_FILES = {
+  dailyNotes: "daily-notes.md",
+  meeting: "meeting.md",
+  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
+ */
+export function loadTemplate(templateDir: string, templateFile: string): string | null {
+  const templatePath = path.join(templateDir, templateFile);
+  if (existsSync(templatePath)) {
+    return readFileSync(templatePath, "utf8");
+  }
+  return null;
+}
+
+/**
+ * Get default template content for initial setup
+ */
+function getDefaultDailyNotesTemplate(): string {
+  return `# Journal for Week {monday:yyyy-MM-dd}
+
+## {monday:yyyy-MM-dd} Monday
+
+## {tuesday:yyyy-MM-dd} Tuesday
+
+## {wednesday:yyyy-MM-dd} Wednesday
+
+## {thursday:yyyy-MM-dd} Thursday
+
+## {friday:yyyy-MM-dd} Friday
+`;
+}
+
+function getDefaultMeetingTemplate(): string {
+  return `# Meeting: {title}
+
+**Date:** {date}
+**Time:** {time}
+**Attendees:**
+
+## Agenda
+
+-
+
+## Notes
+
+## Action Items
+
+- [ ]
+
+## Follow-up
+`;
+}
+
+function getDefaultNoteTemplate(): string {
+  return `# {title}
+
+**Created:** {date} {time}
+
+## Summary
+
+## Details
+
+## References
+`;
+}
+
+/**
+ * Initialize template directory with default templates (first run)
+ */
+export function ensureTemplatesExist(templateDir: string): void {
+  ensureDirectoryExists(templateDir);
+
+  const templates = [
+    { file: TEMPLATE_FILES.dailyNotes, content: getDefaultDailyNotesTemplate() },
+    { file: TEMPLATE_FILES.meeting, content: getDefaultMeetingTemplate() },
+    { file: TEMPLATE_FILES.note, content: getDefaultNoteTemplate() },
+  ];
+
+  for (const { file, content } of templates) {
+    const templatePath = path.join(templateDir, file);
+    if (!existsSync(templatePath)) {
+      writeFileSync(templatePath, content, "utf8");
+      consola.info(`Created default template: ${colors.cyan(templatePath)}`);
+    }
+  }
+}
+
+/**
+ * Render template with variables
+ */
+function renderTemplate(template: string, vars: Record<string, string>): string {
+  return template.replace(/\{([^}]+)\}/g, (match, key) => {
+    return vars[key] ?? match;
+  });
+}
+
+/**
+ * Create initial journal content with date header
+ */
+export function createJournalContent({
+  mondayDate,
+  templateDir,
+}: {
+  mondayDate: Date;
+  templateDir?: string;
+}): string {
+  const weekInfo = getWeekInfo(mondayDate);
+
+  // Try external template first
+  if (templateDir) {
+    const externalTemplate = loadTemplate(templateDir, TEMPLATE_FILES.dailyNotes);
+    if (externalTemplate) {
+      return renderTemplate(externalTemplate, {
+        "monday:yyyy-MM-dd": formatDate(weekInfo.mondayDate),
+        "tuesday:yyyy-MM-dd": formatDate(weekInfo.tuesdayDate),
+        "wednesday:yyyy-MM-dd": formatDate(weekInfo.wednesdayDate),
+        "thursday:yyyy-MM-dd": formatDate(weekInfo.thursdayDate),
+        "friday:yyyy-MM-dd": formatDate(weekInfo.fridayDate),
+      });
+    }
+  }
+
+  // Fallback to hardcoded template
+  const content = [`# Journal for Week ${formatDate(mondayDate)}`];
+  content.push(``);
+  content.push(`## ${formatDate(weekInfo.mondayDate)} Monday`);
+  content.push(``);
+  content.push(`## ${formatDate(weekInfo.tuesdayDate)} Tuesday`);
+  content.push(``);
+  content.push(`## ${formatDate(weekInfo.wednesdayDate)} Wednesday`);
+  content.push(``);
+  content.push(`## ${formatDate(weekInfo.thursdayDate)} Thursday`);
+  content.push(``);
+  content.push(`## ${formatDate(weekInfo.fridayDate)} Friday`);
+  content.push(``);
+
+  return content.join("\n");
+}
+
+/**
+ * Create meeting template content
+ */
+export function createMeetingContent({
+  title,
+  date,
+  templateDir,
+}: {
+  title?: string;
+  date: Date;
+  templateDir?: string;
+}): string {
+  const dateStr = formatDate(date);
+  const timeStr = date.toLocaleTimeString("en-US", {
+    hour12: false,
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+  const meetingTitle = title || "Meeting";
+
+  // Try external template first
+  if (templateDir) {
+    const externalTemplate = loadTemplate(templateDir, TEMPLATE_FILES.meeting);
+    if (externalTemplate) {
+      return renderTemplate(externalTemplate, {
+        title: meetingTitle,
+        date: dateStr,
+        time: timeStr,
+      });
+    }
+  }
+
+  // Fallback to hardcoded template
+  const content = [`# Meeting: ${meetingTitle}`];
+  content.push(``);
+  content.push(`**Date:** ${dateStr}`);
+  content.push(`**Time:** ${timeStr}`);
+  content.push(`**Attendees:** `);
+  content.push(``);
+  content.push(`## Agenda`);
+  content.push(``);
+  content.push(`- `);
+  content.push(``);
+  content.push(`## Notes`);
+  content.push(``);
+  content.push(`## Action Items`);
+  content.push(``);
+  content.push(`- [ ] `);
+  content.push(``);
+  content.push(`## Follow-up`);
+  content.push(``);
+
+  return content.join("\n");
+}
+
+/**
+ * Create note template content
+ */
+export function createNoteContent({
+  title,
+  date,
+  templateDir,
+}: {
+  title?: string;
+  date: Date;
+  templateDir?: string;
+}): string {
+  const dateStr = formatDate(date);
+  const timeStr = date.toLocaleTimeString("en-US", {
+    hour12: false,
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+  const noteTitle = title || "Note";
+
+  // Try external template first
+  if (templateDir) {
+    const externalTemplate = loadTemplate(templateDir, TEMPLATE_FILES.note);
+    if (externalTemplate) {
+      return renderTemplate(externalTemplate, {
+        title: noteTitle,
+        date: dateStr,
+        time: timeStr,
+      });
+    }
+  }
+
+  // Fallback to hardcoded template
+  const content = [`# ${noteTitle}`];
+  content.push(``);
+  content.push(`**Created:** ${dateStr} ${timeStr}`);
+  content.push(``);
+  content.push(`## Summary`);
+  content.push(``);
+  content.push(`## Details`);
+  content.push(``);
+  content.push(`## References`);
+  content.push(``);
+
+  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;
+}

package/src/lib/ralph/execution.ts

@@ -0,0 +1,292 @@
+import type { WriteStream } from "node:fs";
+// NOTE: We use spawn instead of tinyexec for runIteration because we need
+// real-time streaming of stdout/stderr. tinyexec waits for command completion
+// before returning output, which doesn't work for long-running claude sessions.
+import { spawn } from "node:child_process";
+import pc from "picocolors";
+import { x } from "tinyexec";
+import { CLAUDE_DEFAULT_ARGS } from "./state.js";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+interface StreamEvent {
+  type: string;
+  message?: {
+    content?: Array<{ type: string; text?: string }>;
+    usage?: {
+      input_tokens?: number;
+      output_tokens?: number;
+      cache_read_input_tokens?: number;
+      cache_creation_input_tokens?: number;
+    };
+  };
+  result?: string;
+  total_cost_usd?: number;
+  num_turns?: number;
+  session_id?: string;
+  usage?: {
+    input_tokens?: number;
+    output_tokens?: number;
+    cache_read_input_tokens?: number;
+    cache_creation_input_tokens?: number;
+  };
+}
+
+// Claude model context windows (tokens)
+const MODEL_CONTEXT_WINDOWS: Record<string, number> = {
+  "claude-sonnet-4-20250514": 200000,
+  "claude-opus-4-20250514": 200000,
+  "claude-3-5-sonnet-20241022": 200000,
+  "claude-3-opus-20240229": 200000,
+  default: 200000,
+};
+
+export interface IterationResult {
+  output: string;
+  exitCode: number;
+  contextUsedPercent?: number;
+  sessionId?: string;
+}
+
+interface ParsedLine {
+  text: string | null;
+  tool?: { name: string; summary: string };
+  usage?: StreamEvent["usage"];
+  sessionId?: string;
+}
+
+// ============================================================================
+// Claude CLI Check
+// ============================================================================
+
+export async function checkClaudeCli(): Promise<boolean> {
+  try {
+    const result = await x("which", ["claude"]);
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+
+// ============================================================================
+// Stream Parsing
+// ============================================================================
+
+// Track accumulated text from assistant messages to compute deltas
+let lastAssistantText = "";
+
+/**
+ * Reset stream parsing state between iterations.
+ */
+export function resetStreamState(): void {
+  lastAssistantText = "";
+}
+
+function summarizeTool(name: string, input: Record<string, unknown>): string {
+  switch (name) {
+    case "Read":
+      return (
+        String(input.file_path || input.path || "")
+          .split("/")
+          .pop() || "file"
+      );
+    case "Write":
+    case "Edit":
+      return (
+        String(input.file_path || input.path || "")
+          .split("/")
+          .pop() || "file"
+      );
+    case "Glob":
+      return String(input.pattern || "");
+    case "Grep":
+      return String(input.pattern || "");
+    case "Bash":
+      return String(input.command || "").substring(0, 40);
+    case "TodoWrite":
+      return "updating todos";
+    default:
+      return Object.values(input)[0]?.toString().substring(0, 30) || "";
+  }
+}
+
+function parseStreamLine(line: string): ParsedLine {
+  if (!line.trim()) return { text: null };
+  try {
+    const data = JSON.parse(line) as StreamEvent & {
+      tool_use?: { name: string; input: Record<string, unknown> };
+      content_block?: { type: string; name?: string; input?: Record<string, unknown> };
+    };
+
+    // Handle tool_use events
+    if (data.type === "tool_use" && data.tool_use) {
+      const name = data.tool_use.name;
+      const summary = summarizeTool(name, data.tool_use.input || {});
+      return { text: null, tool: { name, summary } };
+    }
+
+    // Handle content_block with tool_use (streaming format)
+    if (data.type === "content_block" && data.content_block?.type === "tool_use") {
+      const name = data.content_block.name || "Tool";
+      const summary = summarizeTool(name, data.content_block.input || {});
+      return { text: null, tool: { name, summary } };
+    }
+
+    // Handle assistant messages with content array
+    if (data.type === "assistant" && data.message) {
+      // Check for tool_use in content blocks
+      const toolBlocks = data.message.content?.filter((c) => c.type === "tool_use") || [];
+      if (toolBlocks.length > 0) {
+        const tb = toolBlocks[toolBlocks.length - 1] as {
+          name?: string;
+          input?: Record<string, unknown>;
+        };
+        const name = tb.name || "Tool";
+        const summary = summarizeTool(name, tb.input || {});
+        return {
+          text: null,
+          tool: { name, summary },
+          usage: data.message.usage || data.usage,
+          sessionId: data.session_id,
+        };
+      }
+
+      // Extract full text from content blocks
+      const fullText =
+        data.message.content
+          ?.filter((c) => c.type === "text" && c.text)
+          .map((c) => c.text)
+          .join("") || "";
+
+      // Compute delta (only new portion) to avoid duplicate output
+      let delta: string | null = null;
+      if (fullText.startsWith(lastAssistantText)) {
+        delta = fullText.slice(lastAssistantText.length) || null;
+      } else {
+        // Text doesn't match prefix - new context
+        delta = fullText || null;
+      }
+      lastAssistantText = fullText;
+
+      return { text: delta, usage: data.message.usage || data.usage, sessionId: data.session_id };
+    }
+    // Capture final result with usage and session_id
+    if (data.type === "result") {
+      const resultText = data.result
+        ? `\n[Result: ${data.result.substring(0, 100)}${data.result.length > 100 ? "..." : ""}]\n`
+        : null;
+      return { text: resultText, usage: data.usage, sessionId: data.session_id };
+    }
+  } catch {
+    // Not JSON, return raw
+    return { text: line };
+  }
+  return { text: null };
+}
+
+// ============================================================================
+// Run Iteration
+// ============================================================================
+
+export async function runIteration(
+  prompt: string,
+  claudeArgs: string[],
+  logStream?: WriteStream,
+): Promise<IterationResult> {
+  // Reset accumulated text state from previous iteration
+  resetStreamState();
+
+  // Pass task context as system prompt via --append-system-prompt
+  // 'continue' is the user prompt - required by claude CLI when using --print
+  const allArgs = [
+    ...CLAUDE_DEFAULT_ARGS,
+    ...claudeArgs,
+    "--append-system-prompt",
+    prompt,
+    "continue",
+  ];
+
+  let output = "";
+  let lineBuffer = "";
+  let finalUsage: StreamEvent["usage"] | undefined;
+  let sessionId: string | undefined;
+  let lastCharWasNewline = true;
+
+  const processLine = (line: string) => {
+    const { text: parsed, tool, usage, sessionId: sid } = parseStreamLine(line);
+    if (usage) finalUsage = usage;
+    if (sid) sessionId = sid;
+    if (tool) {
+      const prefix = lastCharWasNewline ? "" : "\n";
+      const toolLine = `${prefix}${pc.yellow("⚡")} ${pc.cyan(tool.name)}: ${tool.summary}\n`;
+      process.stdout.write(toolLine);
+      logStream?.write(`${prefix}⚡ ${tool.name}: ${tool.summary}\n`);
+      lastCharWasNewline = true;
+    }
+    if (parsed) {
+      process.stdout.write(parsed);
+      logStream?.write(parsed);
+      output += parsed;
+      lastCharWasNewline = parsed.endsWith("\n");
+    }
+  };
+
+  return new Promise((resolve) => {
+    const proc = spawn("claude", allArgs, {
+      stdio: ["inherit", "pipe", "pipe"],
+    });
+
+    proc.stdout.on("data", (chunk: Buffer) => {
+      const text = chunk.toString();
+      lineBuffer += text;
+
+      const lines = lineBuffer.split("\n");
+      lineBuffer = lines.pop() || "";
+
+      for (const line of lines) {
+        processLine(line);
+      }
+    });
+
+    proc.stderr.on("data", (chunk: Buffer) => {
+      const text = chunk.toString();
+      process.stderr.write(text);
+      logStream?.write(text);
+      output += text;
+    });
+
+    proc.on("close", (code: number | null) => {
+      if (lineBuffer) {
+        processLine(lineBuffer);
+      }
+
+      if (output && !output.endsWith("\n")) {
+        process.stdout.write("\n");
+        logStream?.write("\n");
+        output += "\n";
+      }
+
+      // Calculate context usage percent
+      let contextUsedPercent: number | undefined;
+      if (finalUsage) {
+        const totalTokens =
+          (finalUsage.input_tokens || 0) +
+          (finalUsage.output_tokens || 0) +
+          (finalUsage.cache_read_input_tokens || 0) +
+          (finalUsage.cache_creation_input_tokens || 0);
+        const maxContext = MODEL_CONTEXT_WINDOWS.default;
+        contextUsedPercent = Math.round((totalTokens / maxContext) * 100);
+      }
+
+      resolve({ output, exitCode: code ?? 0, contextUsedPercent, sessionId });
+    });
+
+    proc.on("error", (err: Error) => {
+      console.error(pc.red(`Error running claude: ${err}`));
+      logStream?.write(`Error running claude: ${err}\n`);
+      resolve({ output, exitCode: 1 });
+    });
+  });
+}