@towles/tool 0.0.41 → 0.0.49

package/src/{commands/ralph/lib → lib/ralph}/execution.ts

@@ -1,4 +1,7 @@
 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";
@@ -10,11 +13,6 @@ import { CLAUDE_DEFAULT_ARGS } from "./state.js";
 
 interface StreamEvent {
   type: string;
-  event?: {
-    type: string;
-    delta?: { text?: string };
-  };
-  // New format: assistant message
   message?: {
     content?: Array<{ type: string; text?: string }>;
     usage?: {
@@ -136,15 +134,7 @@ function parseStreamLine(line: string): ParsedLine {
       return { text: null, tool: { name, summary } };
     }
 
-    // Extract text from streaming deltas (legacy format)
-    if (data.type === "stream_event" && data.event?.type === "content_block_delta") {
-      return { text: data.event.delta?.text || null };
-    }
-    // Add newline after content block ends (legacy format)
-    if (data.type === "stream_event" && data.event?.type === "content_block_stop") {
-      return { text: "\n" };
-    }
-    // NEW FORMAT: Handle assistant messages with content array
+    // 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") || [];

package/src/lib/ralph/formatter.ts

@@ -0,0 +1,238 @@
+import { execFileSync } from "node:child_process";
+import type { RalphPlan, PlanStatus, RalphState } from "./state.js";
+
+// ============================================================================
+// Clipboard Utility
+// ============================================================================
+
+export function copyToClipboard(text: string): boolean {
+  try {
+    const platform = process.platform;
+    if (platform === "darwin") {
+      execFileSync("pbcopy", [], { input: text });
+    } else if (platform === "linux") {
+      // Try xclip first, then xsel
+      try {
+        execFileSync("xclip", ["-selection", "clipboard"], { input: text });
+      } catch {
+        execFileSync("xsel", ["--clipboard", "--input"], { input: text });
+      }
+    } else if (platform === "win32") {
+      execFileSync("clip", [], { input: text });
+    } else {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Format plans as markdown with checkboxes and status badges.
+ */
+export function formatPlansAsMarkdown(plans: RalphPlan[]): string {
+  if (plans.length === 0) {
+    return "# Plans\n\nNo plans.\n";
+  }
+
+  const statusBadge = (status: PlanStatus): string => {
+    switch (status) {
+      case "done":
+        return "`✓ done`";
+      case "ready":
+        return "`○ ready`";
+      case "blocked":
+        return "`⏸ blocked`";
+      case "cancelled":
+        return "`✗ cancelled`";
+    }
+  };
+
+  const ready = plans.filter((p) => p.status === "ready");
+  const done = plans.filter((p) => p.status === "done");
+
+  const lines: string[] = ["# Plans", ""];
+  lines.push(
+    `**Total:** ${plans.length} | **Done:** ${done.length} | **Ready:** ${ready.length}`,
+    "",
+  );
+
+  if (ready.length > 0) {
+    lines.push("## Ready", "");
+    for (const p of ready) {
+      lines.push(`- [ ] **#${p.id}** ${p.description} ${statusBadge(p.status)}`);
+    }
+    lines.push("");
+  }
+
+  if (done.length > 0) {
+    lines.push("## Done", "");
+    for (const p of done) {
+      lines.push(`- [x] **#${p.id}** ${p.description} ${statusBadge(p.status)}`);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Format plans with markdown and optional mermaid graph.
+ */
+export function formatPlanAsMarkdown(plans: RalphPlan[], state: RalphState): string {
+  const lines: string[] = ["# Ralph Plan", ""];
+
+  // Summary section
+  const ready = plans.filter((p) => p.status === "ready").length;
+  const done = plans.filter((p) => p.status === "done").length;
+
+  lines.push("## Summary", "");
+  lines.push(`- **Status:** ${state.status}`);
+  lines.push(`- **Total:** ${plans.length}`);
+  lines.push(`- **Done:** ${done} | **Ready:** ${ready}`);
+  lines.push("");
+
+  // Plans section with checkboxes
+  lines.push("## Plans", "");
+  for (const p of plans) {
+    const checkbox = p.status === "done" ? "[x]" : "[ ]";
+    const status = p.status === "done" ? "`done`" : "`ready`";
+    lines.push(`- ${checkbox} **#${p.id}** ${p.description} ${status}`);
+  }
+  lines.push("");
+
+  // Mermaid graph section
+  lines.push("## Progress Graph", "");
+  lines.push("```mermaid");
+  lines.push("graph LR");
+  lines.push(`    subgraph Progress["Plans: ${done}/${plans.length} done"]`);
+
+  for (const p of plans) {
+    const shortDesc =
+      p.description.length > 30 ? p.description.slice(0, 27) + "..." : p.description;
+    // Escape quotes in descriptions
+    const safeDesc = shortDesc.replace(/"/g, "'");
+    const nodeId = `P${p.id}`;
+
+    if (p.status === "done") {
+      lines.push(`        ${nodeId}["#${p.id}: ${safeDesc}"]:::done`);
+    } else {
+      lines.push(`        ${nodeId}["#${p.id}: ${safeDesc}"]:::ready`);
+    }
+  }
+
+  lines.push("    end");
+  lines.push("    classDef done fill:#22c55e,color:#fff");
+  lines.push("    classDef ready fill:#94a3b8,color:#000");
+  lines.push("```");
+  lines.push("");
+
+  return lines.join("\n");
+}
+
+/**
+ * Format plans as JSON for programmatic consumption.
+ */
+export function formatPlanAsJson(plans: RalphPlan[], state: RalphState): string {
+  return JSON.stringify(
+    {
+      status: state.status,
+      summary: {
+        total: plans.length,
+        done: plans.filter((p) => p.status === "done").length,
+        ready: plans.filter((p) => p.status === "ready").length,
+      },
+      plans: plans.map((p) => ({
+        id: p.id,
+        description: p.description,
+        status: p.status,
+        addedAt: p.addedAt,
+        completedAt: p.completedAt,
+      })),
+    },
+    null,
+    2,
+  );
+}
+
+// ============================================================================
+// Duration Formatting
+// ============================================================================
+
+export function formatDuration(ms: number): string {
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+
+  if (hours > 0) {
+    const remainingMins = minutes % 60;
+    return `${hours}h ${remainingMins}m`;
+  }
+  if (minutes > 0) {
+    const remainingSecs = seconds % 60;
+    return `${minutes}m ${remainingSecs}s`;
+  }
+  return `${seconds}s`;
+}
+
+// ============================================================================
+// Output Summary
+// ============================================================================
+
+export function extractOutputSummary(output: string, maxLength: number = 2000): string {
+  const lines = output
+    .split("\n")
+    .filter((l) => l.trim())
+    .slice(-5);
+  let summary = lines.join(" ").trim();
+
+  if (summary.length > maxLength) {
+    summary = summary.substring(0, maxLength) + "...";
+  }
+
+  return summary || "(no output)";
+}
+
+// ============================================================================
+// Prompt Building
+// ============================================================================
+
+export interface BuildPromptOptions {
+  completionMarker: string;
+  plan: RalphPlan;
+  skipCommit?: boolean;
+}
+
+export function buildIterationPrompt({
+  completionMarker,
+  plan,
+  skipCommit = false,
+}: BuildPromptOptions): string {
+  let step = 1;
+
+  const prompt = `
+<plan>
+#${plan.id}: ${plan.description}
+</plan>
+
+<instructions>
+${step++}. Work on the plan above.
+${step++}. Run type checks and tests.
+${step++}. Mark done: \`tt ralph plan done ${plan.id}\`
+${skipCommit ? "" : `${step++}. Make a git commit.`}
+
+**Before ending:** Run \`tt ralph plan list\` to check remaining plans.
+**ONLY if ALL PLANS are done** then Output: <promise>${completionMarker}</promise>
+</instructions>
+`;
+  return prompt.trim();
+}
+
+// ============================================================================
+// Marker Detection
+// ============================================================================
+
+export function detectCompletionMarker(output: string, marker: string): boolean {
+  return output.includes(marker);
+}

package/src/{commands/ralph/lib → lib/ralph}/state.ts

@@ -2,8 +2,8 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import pc from "picocolors";
 import { z } from "zod";
-import type { RalphSettings } from "../../../config/settings";
-import { RalphSettingsSchema } from "../../../config/settings";
+import type { RalphSettings } from "../../config/settings.js";
+import { RalphSettingsSchema } from "../../config/settings.js";
 
 // ============================================================================
 // Constants
@@ -16,7 +16,6 @@ export const DEFAULT_COMPLETION_MARKER = "RALPH_DONE";
 // File names within stateDir
 const STATE_FILE_NAME = "ralph-state.local.json";
 const LOG_FILE_NAME = "ralph-log.local.md";
-const PROGRESS_FILE_NAME = "ralph-progress.local.md";
 const HISTORY_FILE_NAME = "ralph-history.local.log";
 
 // ============================================================================
@@ -28,15 +27,13 @@ export function getRalphPaths(settings?: RalphSettings) {
   return {
     stateFile: path.join(stateDir, STATE_FILE_NAME),
     logFile: path.join(stateDir, LOG_FILE_NAME),
-    progressFile: path.join(stateDir, PROGRESS_FILE_NAME),
     historyFile: path.join(stateDir, HISTORY_FILE_NAME),
   };
 }
 
-// Legacy defaults for backwards compatibility (used in flag descriptions)
+// Defaults used in flag descriptions
 export const DEFAULT_STATE_FILE = `${DEFAULT_STATE_DIR}/${STATE_FILE_NAME}`;
 export const DEFAULT_LOG_FILE = `${DEFAULT_STATE_DIR}/${LOG_FILE_NAME}`;
-export const DEFAULT_PROGRESS_FILE = `${DEFAULT_STATE_DIR}/${PROGRESS_FILE_NAME}`;
 export const DEFAULT_HISTORY_FILE = `${DEFAULT_STATE_DIR}/${HISTORY_FILE_NAME}`;
 
 /**
@@ -44,7 +41,7 @@ export const DEFAULT_HISTORY_FILE = `${DEFAULT_STATE_DIR}/${HISTORY_FILE_NAME}`;
  */
 export function resolveRalphPath(
   flagValue: string | undefined,
-  pathType: "stateFile" | "logFile" | "progressFile" | "historyFile",
+  pathType: "stateFile" | "logFile" | "historyFile",
   settings?: RalphSettings,
 ): string {
   if (flagValue !== undefined) {
@@ -66,27 +63,21 @@ export const CLAUDE_DEFAULT_ARGS = [
 // State Validation Schemas
 // ============================================================================
 
-const TaskStatusSchema = z.enum(["ready", "done", "blocked", "cancelled"]);
+const PlanStatusSchema = z.enum(["ready", "done", "blocked", "cancelled"]);
 
-const RalphTaskSchema = z.object({
+const RalphPlanSchema = z.object({
   id: z.number(),
   description: z.string(),
-  status: TaskStatusSchema,
+  status: PlanStatusSchema,
   addedAt: z.string(),
   completedAt: z.string().optional(),
-  sessionId: z.string().optional(),
-  marker: z.string().optional(),
-  label: z.string().optional(),
 });
 
 const RalphStateSchema = z.object({
   version: z.number(),
-  tasks: z.array(RalphTaskSchema),
+  plans: z.array(RalphPlanSchema),
   startedAt: z.string(),
-  iteration: z.number(),
-  maxIterations: z.number(),
   status: z.enum(["running", "completed", "max_iterations_reached", "error"]),
-  sessionId: z.string().optional(),
 });
 
 // ============================================================================
@@ -104,21 +95,19 @@ export interface IterationHistory {
   contextUsedPercent?: number;
 }
 
-export type TaskStatus = z.infer<typeof TaskStatusSchema>;
-export type RalphTask = z.infer<typeof RalphTaskSchema>;
+export type PlanStatus = z.infer<typeof PlanStatusSchema>;
+export type RalphPlan = z.infer<typeof RalphPlanSchema>;
 export type RalphState = z.infer<typeof RalphStateSchema>;
 
 // ============================================================================
 // State Management
 // ============================================================================
 
-export function createInitialState(maxIterations: number): RalphState {
+export function createInitialState(): RalphState {
   return {
     version: 1,
-    tasks: [],
+    plans: [],
     startedAt: new Date().toISOString(),
-    iteration: 0,
-    maxIterations,
     status: "running",
   };
 }
@@ -149,11 +138,6 @@ export function loadState(stateFile: string): RalphState | null {
     const content = fs.readFileSync(stateFile, "utf-8");
     const parsed = JSON.parse(content);
 
-    // Ensure tasks array exists for backwards compatibility
-    if (!parsed.tasks) {
-      parsed.tasks = [];
-    }
-
     const result = RalphStateSchema.safeParse(parsed);
     if (!result.success) {
       const errors = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ");
@@ -167,25 +151,16 @@ export function loadState(stateFile: string): RalphState | null {
   }
 }
 
-export function addTaskToState(
-  state: RalphState,
-  description: string,
-  sessionId?: string,
-  marker?: string,
-  label?: string,
-): RalphTask {
-  const nextId = state.tasks.length > 0 ? Math.max(...state.tasks.map((t) => t.id)) + 1 : 1;
+export function addPlanToState(state: RalphState, description: string): RalphPlan {
+  const nextId = state.plans.length > 0 ? Math.max(...state.plans.map((p) => p.id)) + 1 : 1;
 
-  const newTask: RalphTask = {
+  const newPlan: RalphPlan = {
     id: nextId,
     description,
     status: "ready",
     addedAt: new Date().toISOString(),
-    ...(sessionId && { sessionId }),
-    ...(marker && { marker }),
-    ...(label && { label }),
   };
 
-  state.tasks.push(newTask);
-  return newTask;
+  state.plans.push(newPlan);
+  return newPlan;
 }

package/src/utils/date-utils.test.ts

@@ -36,7 +36,8 @@ describe("date utilities", () => {
   });
 
   it("should format date correctly", () => {
-    const date = new Date("2025-07-07");
+    // Use local date constructor (year, month-1, day), not ISO string which is UTC
+    const date = new Date(2025, 6, 7); // July 7, 2025 in local time
     expect(formatDate(date)).toBe("2025-07-07");
   });
 

package/src/utils/date-utils.ts

@@ -38,10 +38,10 @@ export function getWeekInfo(mondayDate: Date): weekInfo {
 }
 
 /**
- * Format date as YYYY-MM-DD
+ * Format date as YYYY-MM-DD in local timezone
  */
 export function formatDate(date: Date): string {
-  return date.toISOString().split("T")[0];
+  return date.toLocaleDateString("en-CA");
 }
 
 /**

package/LICENSE.md

@@ -1,20 +0,0 @@
-# Proprietary License
-
-Copyright (c) 2025 Chris Towles. All rights reserved.
-
-This software and associated documentation files (the "Software") are proprietary
-and confidential. Unauthorized copying, modification, distribution, or use of
-this Software, via any medium, is strictly prohibited.
-
-The Software is provided for the sole use of authorized individuals or entities
-who have been granted explicit written permission by the copyright holder.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-For licensing inquiries, contact: Chris.Towles.Dev@gmail.com

package/src/commands/index.ts

@@ -1,55 +0,0 @@
-// Explicit command exports for Bun compiled binaries
-// oclif's pattern-based discovery doesn't work with bundled executables
-
-import GhBranchClean from "./gh/branch-clean.js";
-import Config from "./config.js";
-import Doctor from "./doctor.js";
-import GhBranch from "./gh/branch.js";
-import GhPr from "./gh/pr.js";
-import Install from "./install.js";
-import RalphRun from "./ralph/run.js";
-import RalphPlan from "./ralph/plan.js";
-import RalphProgress from "./ralph/progress.js";
-import RalphMarkerCreate from "./ralph/marker/create.js";
-import RalphTaskAdd from "./ralph/task/add.js";
-import RalphTaskDone from "./ralph/task/done.js";
-import RalphTaskList from "./ralph/task/list.js";
-import RalphTaskRemove from "./ralph/task/remove.js";
-import JournalDailyNotes from "./journal/daily-notes.js";
-import JournalMeeting from "./journal/meeting.js";
-import JournalNote from "./journal/note.js";
-import ObserveSetup from "./observe/setup.js";
-import ObserveStatus from "./observe/status.js";
-import ObserveReport from "./observe/report.js";
-import ObserveGraph from "./observe/graph.js";
-import ObserveSession from "./observe/session.js";
-
-export default {
-  config: Config,
-  doctor: Doctor,
-  "gh:branch": GhBranch,
-  "gh:branch-clean": GhBranchClean,
-  "gh:pr": GhPr,
-  install: Install,
-  "ralph:run": RalphRun,
-  "ralph:plan": RalphPlan,
-  "ralph:progress": RalphProgress,
-  "ralph:marker:create": RalphMarkerCreate,
-  "ralph:task:add": RalphTaskAdd,
-  "ralph:task:done": RalphTaskDone,
-  "ralph:task:list": RalphTaskList,
-  "ralph:task:remove": RalphTaskRemove,
-  "journal:daily-notes": JournalDailyNotes,
-  "journal:meeting": JournalMeeting,
-  "journal:note": JournalNote,
-  "observe:setup": ObserveSetup,
-  "observe:status": ObserveStatus,
-  "observe:report": ObserveReport,
-  "observe:graph": ObserveGraph,
-  "observe:session": ObserveSession,
-  // Aliases
-  graph: ObserveGraph,
-  today: JournalDailyNotes,
-  pr: GhPr,
-  run: RalphRun,
-};

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

@@ -1,89 +0,0 @@
-/**
- * Tests for observe graph command --days filtering
- */
-import { describe, it, expect } from "vitest";
-import { calculateCutoffMs, filterByDays } from "./graph.js";
-
-describe("observe graph --days filtering", () => {
-  describe("calculateCutoffMs", () => {
-    it("returns 0 when days <= 0", () => {
-      expect(calculateCutoffMs(0)).toBe(0);
-      expect(calculateCutoffMs(-1)).toBe(0);
-    });
-
-    it("returns cutoff timestamp for positive days", () => {
-      const now = Date.now();
-      const cutoff = calculateCutoffMs(7);
-      // Should be roughly 7 days ago (within 100ms tolerance for test execution time)
-      const expected = now - 7 * 24 * 60 * 60 * 1000;
-      expect(Math.abs(cutoff - expected)).toBeLessThan(100);
-    });
-  });
-
-  describe("filterByDays", () => {
-    it("filters sessions older than N days when days > 0", () => {
-      const now = Date.now();
-      const sessions = [
-        { mtime: now - 1 * 24 * 60 * 60 * 1000 }, // 1 day ago - included
-        { mtime: now - 2 * 24 * 60 * 60 * 1000 }, // 2 days ago - included
-        { mtime: now - 5 * 24 * 60 * 60 * 1000 }, // 5 days ago - excluded
-        { mtime: now - 10 * 24 * 60 * 60 * 1000 }, // 10 days ago - excluded
-      ];
-
-      const filtered = filterByDays(sessions, 3);
-      expect(filtered).toHaveLength(2);
-    });
-
-    it("returns all sessions when days=0", () => {
-      const now = Date.now();
-      const sessions = [
-        { mtime: now - 1 * 24 * 60 * 60 * 1000 },
-        { mtime: now - 100 * 24 * 60 * 60 * 1000 },
-        { mtime: now - 365 * 24 * 60 * 60 * 1000 },
-      ];
-
-      const filtered = filterByDays(sessions, 0);
-      expect(filtered).toHaveLength(3);
-    });
-
-    it("default 7 days filters correctly", () => {
-      const now = Date.now();
-      const sessions = [
-        { mtime: now - 1 * 24 * 60 * 60 * 1000 }, // 1 day ago - included
-        { mtime: now - 6 * 24 * 60 * 60 * 1000 }, // 6 days ago - included
-        { mtime: now - 8 * 24 * 60 * 60 * 1000 }, // 8 days ago - excluded
-        { mtime: now - 30 * 24 * 60 * 60 * 1000 }, // 30 days ago - excluded
-      ];
-
-      const filtered = filterByDays(sessions, 7);
-      expect(filtered).toHaveLength(2);
-      // Verify the right sessions were kept
-      expect(filtered[0].mtime).toBeGreaterThan(now - 7 * 24 * 60 * 60 * 1000);
-      expect(filtered[1].mtime).toBeGreaterThan(now - 7 * 24 * 60 * 60 * 1000);
-    });
-
-    it("--days 1 filters to today only", () => {
-      const now = Date.now();
-      const sessions = [
-        { mtime: now - 12 * 60 * 60 * 1000 }, // 12 hours ago - included
-        { mtime: now - 25 * 60 * 60 * 1000 }, // 25 hours ago - excluded
-      ];
-
-      const filtered = filterByDays(sessions, 1);
-      expect(filtered).toHaveLength(1);
-    });
-
-    it("preserves additional properties on items", () => {
-      const now = Date.now();
-      const sessions = [
-        { mtime: now, sessionId: "abc", tokens: 100 },
-        { mtime: now - 10 * 24 * 60 * 60 * 1000, sessionId: "old", tokens: 50 },
-      ];
-
-      const filtered = filterByDays(sessions, 7);
-      expect(filtered).toHaveLength(1);
-      expect(filtered[0].sessionId).toBe("abc");
-      expect(filtered[0].tokens).toBe(100);
-    });
-  });
-});