@towles/tool 0.0.41 → 0.0.49

package/src/commands/ralph/run.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import { Flags } from "@oclif/core";
-import pc from "picocolors";
+import consola from "consola";
+import { colors } from "consola/utils";
 import { BaseCommand } from "../base.js";
 import {
   DEFAULT_STATE_FILE,
@@ -13,33 +14,22 @@ import {
   appendHistory,
   resolveRalphPath,
   getRalphPaths,
-} from "./lib/state.js";
+} from "../../lib/ralph/state.js";
 import {
   buildIterationPrompt,
   formatDuration,
   extractOutputSummary,
   detectCompletionMarker,
-  formatTasksForPrompt,
-} from "./lib/formatter.js";
-import { checkClaudeCli, runIteration } from "./lib/execution.js";
-
-/**
- * Read last N iterations from progress file. Only returns iteration entries,
- * excluding headers/status sections that could confuse the model.
- */
-function readLastIterations(filePath: string, count: number): string {
-  if (!fs.existsSync(filePath)) return "";
-  try {
-    const content = fs.readFileSync(filePath, "utf-8");
-    // Split by iteration headers, keeping the delimiter
-    const parts = content.split(/(?=### Iteration)/g);
-    // Skip first part (header/status content) - only want iteration entries
-    const iterations = parts.filter((p) => p.startsWith("### Iteration"));
-    if (iterations.length === 0) return "";
-    return iterations.slice(-count).join("\n").trim();
-  } catch {
-    return "";
+} from "../../lib/ralph/formatter.js";
+import { checkClaudeCli, runIteration } from "../../lib/ralph/execution.js";
+import type { RalphPlan } from "../../lib/ralph/state.js";
+
+/** Get the plan to work on: focused plan or first incomplete */
+function getCurrentPlan(plans: RalphPlan[], focusedPlanId: number | null): RalphPlan | undefined {
+  if (focusedPlanId !== null) {
+    return plans.find((p) => p.id === focusedPlanId);
   }
+  return plans.find((p) => p.status !== "done");
 }
 
 /**
@@ -49,14 +39,23 @@ export default class Run extends BaseCommand {
   static override description = "Start the autonomous ralph loop";
 
   static override examples = [
-    "<%= config.bin %> ralph run",
-    "<%= config.bin %> ralph run --maxIterations 20",
-    "<%= config.bin %> ralph run --taskId 5",
-    "<%= config.bin %> ralph run --no-autoCommit",
-    "<%= config.bin %> ralph run --noFork",
-    "<%= config.bin %> ralph run --dryRun",
-    "<%= config.bin %> ralph run --addIterations 5",
-    "<%= config.bin %> ralph run --label backend",
+    { description: "Start the autonomous loop", command: "<%= config.bin %> <%= command.id %>" },
+    {
+      description: "Limit to 20 iterations",
+      command: "<%= config.bin %> <%= command.id %> --maxIterations 20",
+    },
+    {
+      description: "Focus on specific plan",
+      command: "<%= config.bin %> <%= command.id %> --planId 5",
+    },
+    {
+      description: "Run without auto-committing",
+      command: "<%= config.bin %> <%= command.id %> --no-autoCommit",
+    },
+    {
+      description: "Preview config without executing",
+      command: "<%= config.bin %> <%= command.id %> --dryRun",
+    },
   ];
 
   static override flags = {
@@ -65,29 +64,20 @@ export default class Run extends BaseCommand {
       char: "s",
       description: `State file path (default: ${DEFAULT_STATE_FILE})`,
     }),
-    taskId: Flags.integer({
-      char: "t",
-      description: "Focus on specific task ID",
+    planId: Flags.integer({
+      char: "p",
+      description: "Focus on specific plan ID",
     }),
     maxIterations: Flags.integer({
       char: "m",
       description: "Max iterations",
       default: DEFAULT_MAX_ITERATIONS,
     }),
-    addIterations: Flags.integer({
-      char: "a",
-      description:
-        "Add iterations to current count (e.g., at 5/10, --addIterations 10 makes it 5/20)",
-    }),
     autoCommit: Flags.boolean({
-      description: "Auto-commit after each completed task",
+      description: "Auto-commit after each completed plan",
       default: true,
       allowNo: true,
     }),
-    noFork: Flags.boolean({
-      description: "Disable session forking (start fresh session)",
-      default: false,
-    }),
     dryRun: Flags.boolean({
       char: "n",
       description: "Show config without executing",
@@ -103,108 +93,79 @@ export default class Run extends BaseCommand {
       description: "Completion marker",
       default: DEFAULT_COMPLETION_MARKER,
     }),
-    label: Flags.string({
-      char: "l",
-      description: "Only run tasks with this label",
-    }),
   };
 
   async run(): Promise<void> {
     const { flags } = await this.parse(Run);
-    const ralphSettings = this.settings.settingsFile.settings.ralphSettings;
+    const ralphSettings = this.settings.settings.ralphSettings;
     const stateFile = resolveRalphPath(flags.stateFile, "stateFile", ralphSettings);
     const logFile = resolveRalphPath(flags.logFile, "logFile", ralphSettings);
     const ralphPaths = getRalphPaths(ralphSettings);
 
-    let maxIterations = flags.maxIterations;
-    const addIterations = flags.addIterations;
+    const maxIterations = flags.maxIterations;
     const extraClaudeArgs = flags.claudeArgs?.split(" ").filter(Boolean) || [];
-    const focusedTaskId = flags.taskId ?? null;
+    const focusedPlanId = flags.planId ?? null;
 
     // Load existing state
     let state = loadState(stateFile);
 
     if (!state) {
-      this.error(`No state file found at: ${stateFile}\nUse: tt ralph task add "description"`);
+      this.error(`No state file found at: ${stateFile}\nUse: tt ralph plan add --file path.md`);
     }
 
-    // Handle --addIterations: extend max from current iteration
-    if (addIterations !== undefined) {
-      maxIterations = state.iteration + addIterations;
-      console.log(
-        pc.cyan(
-          `Adding ${addIterations} iterations: ${state.iteration}/${state.maxIterations} → ${state.iteration}/${maxIterations}`,
-        ),
-      );
-    }
-
-    // Filter by label if specified
-    const labelFilter = flags.label;
-    let remainingTasks = state.tasks.filter((t) => t.status !== "done");
-    if (labelFilter) {
-      remainingTasks = remainingTasks.filter((t) => t.label === labelFilter);
-    }
-    if (remainingTasks.length === 0) {
-      const msg = labelFilter
-        ? `All tasks with label '${labelFilter}' are done!`
-        : "All tasks are done!";
-      console.log(pc.green(`✅ ${msg}`));
+    const remainingPlans = state.plans.filter((t) => t.status !== "done");
+    if (remainingPlans.length === 0) {
+      consola.log(colors.green("✅ All plans are done!"));
       return;
     }
 
-    // Validate focused task if specified
-    if (focusedTaskId !== null) {
-      const focusedTask = state.tasks.find((t) => t.id === focusedTaskId);
-      if (!focusedTask) {
-        this.error(`Task #${focusedTaskId} not found. Use: tt ralph task list`);
+    // Validate focused plan if specified
+    if (focusedPlanId !== null) {
+      const focusedPlan = state.plans.find((t) => t.id === focusedPlanId);
+      if (!focusedPlan) {
+        this.error(`Plan #${focusedPlanId} not found. Use: tt ralph plan list`);
       }
-      if (focusedTask.status === "done") {
-        console.log(pc.yellow(`Task #${focusedTaskId} is already done.`));
+      if (focusedPlan.status === "done") {
+        consola.log(colors.yellow(`Plan #${focusedPlanId} is already done.`));
         return;
       }
     }
 
+    // Get current plan to work on
+    const currentPlan = getCurrentPlan(state.plans, focusedPlanId);
+    if (!currentPlan) {
+      consola.log(colors.green("✅ All plans are done!"));
+      return;
+    }
+
     // Dry run mode
     if (flags.dryRun) {
-      console.log(pc.bold("\n=== DRY RUN ===\n"));
-      console.log(pc.cyan("Config:"));
-      console.log(`  Focus: ${focusedTaskId ? `Task #${focusedTaskId}` : "Ralph picks"}`);
-      console.log(`  Label filter: ${labelFilter || "(none)"}`);
-      console.log(`  Max iterations: ${maxIterations}`);
-      console.log(`  State file: ${stateFile}`);
-      console.log(`  Log file: ${logFile}`);
-      console.log(`  Completion marker: ${flags.completionMarker}`);
-      console.log(`  Auto-commit: ${flags.autoCommit}`);
-      console.log(`  Fork session: ${!flags.noFork}`);
-      console.log(`  Session ID: ${state.sessionId || "(none)"}`);
-      console.log(`  Claude args: ${[...CLAUDE_DEFAULT_ARGS, ...extraClaudeArgs].join(" ")}`);
-      console.log(`  Remaining tasks: ${remainingTasks.length}`);
-
-      console.log(pc.cyan("\nTasks:"));
-      for (const t of state.tasks) {
-        const icon = t.status === "done" ? "✓" : "○";
-        const focus = focusedTaskId === t.id ? pc.cyan(" ← FOCUS") : "";
-        console.log(`  ${icon} ${t.id}. ${t.description} (${t.status})${focus}`);
-      }
+      consola.log(colors.bold("\n=== DRY RUN ===\n"));
+      consola.log(colors.cyan("Config:"));
+      consola.log(`  Max iterations: ${maxIterations}`);
+      consola.log(`  State file: ${stateFile}`);
+      consola.log(`  Log file: ${logFile}`);
+      consola.log(`  Completion marker: ${flags.completionMarker}`);
+      consola.log(`  Auto-commit: ${flags.autoCommit}`);
+      consola.log(`  Claude args: ${[...CLAUDE_DEFAULT_ARGS, ...extraClaudeArgs].join(" ")}`);
+      consola.log(`  Remaining plans: ${remainingPlans.length}`);
+
+      consola.log(colors.cyan("\nCurrent plan:"));
+      consola.log(`  #${currentPlan.id}: ${currentPlan.description}`);
 
       // Show prompt preview
-      const progressContent = readLastIterations(ralphPaths.progressFile, 3);
-      const taskList = formatTasksForPrompt(remainingTasks);
       const prompt = buildIterationPrompt({
         completionMarker: flags.completionMarker,
-        progressFile: ralphPaths.progressFile,
-        focusedTaskId,
+        plan: currentPlan,
         skipCommit: !flags.autoCommit,
-        progressContent: progressContent || undefined,
-        taskList,
       });
-      console.log(pc.dim("─".repeat(60)));
-      console.log(pc.bold("Prompt Preview"));
-      console.log(pc.dim("─".repeat(60)));
-      console.log(prompt);
-      console.log(pc.dim("─".repeat(60)));
+      consola.log(colors.dim("─".repeat(60)));
+      consola.log(colors.bold("Prompt Preview"));
+      consola.log(colors.dim("─".repeat(60)));
+      consola.log(prompt);
+      consola.log(colors.dim("─".repeat(60)));
 
-      console.log(pc.bold("\n=== END DRY RUN ===\n"));
+      consola.log(colors.bold("\n=== END DRY RUN ===\n"));
       return;
     }
 
@@ -216,38 +177,29 @@ export default class Run extends BaseCommand {
     }
 
     // Update state for this run
-    state.maxIterations = maxIterations;
     state.status = "running";
 
     // Create log stream (append mode)
     const logStream = fs.createWriteStream(logFile, { flags: "a" });
 
-    const ready = state.tasks.filter((t) => t.status === "ready").length;
-    const done = state.tasks.filter((t) => t.status === "done").length;
+    const ready = state.plans.filter((t) => t.status === "ready").length;
+    const done = state.plans.filter((t) => t.status === "done").length;
 
     logStream.write(`\n${"=".repeat(60)}\n`);
     logStream.write(`Ralph Loop Started: ${new Date().toISOString()}\n`);
     logStream.write(`${"=".repeat(60)}\n\n`);
 
-    console.log(pc.bold(pc.blue("\nRalph Loop Starting\n")));
-    console.log(pc.dim(`Focus: ${focusedTaskId ? `Task #${focusedTaskId}` : "Ralph picks"}`));
-    if (labelFilter) {
-      console.log(pc.dim(`Label filter: ${labelFilter}`));
-    }
-    console.log(pc.dim(`Max iterations: ${maxIterations}`));
-    console.log(pc.dim(`Log file: ${logFile}`));
-    console.log(pc.dim(`Auto-commit: ${flags.autoCommit}`));
-    console.log(
-      pc.dim(
-        `Fork session: ${!flags.noFork}${state.sessionId ? ` (session: ${state.sessionId.slice(0, 8)}...)` : ""}`,
-      ),
-    );
-    console.log(pc.dim(`Tasks: ${state.tasks.length} (${done} done, ${ready} ready)`));
-    console.log();
-
-    logStream.write(`Focus: ${focusedTaskId ? `Task #${focusedTaskId}` : "Ralph picks"}\n`);
+    consola.log(colors.bold(colors.blue("\nRalph Loop Starting\n")));
+    consola.log(colors.dim(`Focus: ${focusedPlanId ? `Plan #${focusedPlanId}` : "Ralph picks"}`));
+    consola.log(colors.dim(`Max iterations: ${maxIterations}`));
+    consola.log(colors.dim(`Log file: ${logFile}`));
+    consola.log(colors.dim(`Auto-commit: ${flags.autoCommit}`));
+    consola.log(colors.dim(`Tasks: ${state.plans.length} (${done} done, ${ready} ready)`));
+    consola.log("");
+
+    logStream.write(`Focus: ${focusedPlanId ? `Plan #${focusedPlanId}` : "Ralph picks"}\n`);
     logStream.write(`Max iterations: ${maxIterations}\n`);
-    logStream.write(`Tasks: ${state.tasks.length} (${done} done, ${ready} ready)\n\n`);
+    logStream.write(`Tasks: ${state.plans.length} (${done} done, ${ready} ready)\n\n`);
 
     // Handle SIGINT gracefully
     let interrupted = false;
@@ -258,7 +210,7 @@ export default class Run extends BaseCommand {
       }
       interrupted = true;
       const msg = "\n\nInterrupted. Press Ctrl+C again to force exit.\n";
-      console.log(pc.yellow(msg));
+      consola.log(colors.yellow(msg));
       logStream.write(msg);
       state.status = "error";
       saveState(state, stateFile);
@@ -266,30 +218,31 @@ export default class Run extends BaseCommand {
 
     // Main loop
     let completed = false;
+    let iteration = 0;
 
-    while (state.iteration < maxIterations && !interrupted && !completed) {
-      state.iteration++;
-      const currentIteration = state.iteration;
+    while (iteration < maxIterations && !interrupted && !completed) {
+      iteration++;
 
-      const iterHeader = `Iteration ${currentIteration}/${maxIterations}`;
+      const iterHeader = `Iteration ${iteration}/${maxIterations}`;
       logStream.write(`\n━━━ ${iterHeader} ━━━\n`);
 
       const iterationStart = new Date().toISOString();
-      const progressContent = readLastIterations(ralphPaths.progressFile, 3);
-      // Reload remaining tasks for current state
-      const currentRemainingTasks = state.tasks.filter((t) => t.status !== "done");
-      const taskList = formatTasksForPrompt(
-        labelFilter
-          ? currentRemainingTasks.filter((t) => t.label === labelFilter)
-          : currentRemainingTasks,
-      );
+      // Get current plan for this iteration
+      const plan = getCurrentPlan(state.plans, focusedPlanId);
+      if (!plan) {
+        completed = true;
+        state.status = "completed";
+        saveState(state, stateFile);
+        consola.log(
+          colors.bold(colors.green(`\n✅ All plans completed after ${iteration} iteration(s)`)),
+        );
+        logStream.write(`\n✅ All plans completed after ${iteration} iteration(s)\n`);
+        break;
+      }
       const prompt = buildIterationPrompt({
         completionMarker: flags.completionMarker,
-        progressFile: ralphPaths.progressFile,
-        focusedTaskId,
+        plan: plan,
         skipCommit: !flags.autoCommit,
-        progressContent: progressContent || undefined,
-        taskList,
       });
 
       // Log the prompt
@@ -297,25 +250,15 @@ export default class Run extends BaseCommand {
 
       // Build claude args
       const iterClaudeArgs = [...extraClaudeArgs];
-      const currentTask = focusedTaskId
-        ? state.tasks.find((t) => t.id === focusedTaskId)
-        : state.tasks.find((t) => t.status === "ready");
-
-      // Fork from task's sessionId (or state-level fallback) unless disabled
-      const taskSessionId = currentTask?.sessionId || state.sessionId;
-      if (!flags.noFork && taskSessionId) {
-        iterClaudeArgs.push("--fork-session", taskSessionId);
-      }
 
       // Print iteration header
-      const sessionInfo = taskSessionId ? pc.dim(` (fork: ${taskSessionId.slice(0, 8)}...)`) : "";
-      console.log();
-      console.log(pc.bold(pc.blue(`━━━ ${iterHeader}${sessionInfo} ━━━`)));
-      console.log(pc.dim("─".repeat(60)));
-      console.log(pc.bold("Prompt"));
-      console.log(pc.dim("─".repeat(60)));
-      console.log(prompt);
-      console.log(pc.dim("─".repeat(60)));
+      consola.log("");
+      consola.log(colors.bold(colors.blue(`━━━ ${iterHeader} ━━━`)));
+      consola.log(colors.dim("─".repeat(60)));
+      consola.log(colors.bold("Prompt"));
+      consola.log(colors.dim("─".repeat(60)));
+      consola.log(prompt);
+      consola.log(colors.dim("─".repeat(60)));
 
       // Run iteration - output goes directly to stdout
       const iterResult = await runIteration(prompt, iterClaudeArgs, logStream);
@@ -323,17 +266,7 @@ export default class Run extends BaseCommand {
       // Reload state from disk to pick up changes made by child claude process
       const freshState = loadState(stateFile);
       if (freshState) {
-        const currentIter = state.iteration;
-        Object.assign(state, freshState, { iteration: currentIter });
-      }
-
-      // Store session ID on the current task for future resumption
-      const taskToUpdate = currentTask
-        ? state.tasks.find((t) => t.id === currentTask.id)
-        : undefined;
-      if (iterResult.sessionId && taskToUpdate && !taskToUpdate.sessionId) {
-        taskToUpdate.sessionId = iterResult.sessionId;
-        state.sessionId = iterResult.sessionId;
+        Object.assign(state, freshState);
       }
 
       const iterationEnd = new Date().toISOString();
@@ -348,7 +281,7 @@ export default class Run extends BaseCommand {
       // Record history
       appendHistory(
         {
-          iteration: state.iteration,
+          iteration,
           startedAt: iterationStart,
           completedAt: iterationEnd,
           durationMs,
@@ -369,11 +302,11 @@ export default class Run extends BaseCommand {
           ? ` | Context: ${iterResult.contextUsedPercent}%`
           : "";
       logStream.write(
-        `\n━━━ Iteration ${state.iteration} Summary ━━━\nDuration: ${durationHuman}${contextInfo}\nMarker found: ${markerFound ? "yes" : "no"}\n`,
+        `\n━━━ Iteration ${iteration} Summary ━━━\nDuration: ${durationHuman}${contextInfo}\nMarker found: ${markerFound ? "yes" : "no"}\n`,
       );
-      console.log(
-        pc.dim(
-          `Duration: ${durationHuman}${contextInfo} | Marker: ${markerFound ? pc.green("yes") : pc.yellow("no")}`,
+      consola.log(
+        colors.dim(
+          `Duration: ${durationHuman}${contextInfo} | Marker: ${markerFound ? colors.green("yes") : colors.yellow("no")}`,
         ),
       );
 
@@ -382,8 +315,10 @@ export default class Run extends BaseCommand {
         completed = true;
         state.status = "completed";
         saveState(state, stateFile);
-        console.log(pc.bold(pc.green(`\n✅ Task completed after ${state.iteration} iteration(s)`)));
-        logStream.write(`\n✅ Task completed after ${state.iteration} iteration(s)\n`);
+        consola.log(
+          colors.bold(colors.green(`\n✅ Plan completed after ${iteration} iteration(s)`)),
+        );
+        logStream.write(`\n✅ Plan completed after ${iteration} iteration(s)\n`);
       }
     }
 
@@ -394,13 +329,15 @@ export default class Run extends BaseCommand {
       return;
     }
 
-    if (!interrupted && state.iteration >= maxIterations) {
+    if (!interrupted && iteration >= maxIterations) {
       state.status = "max_iterations_reached";
       saveState(state, stateFile);
-      console.log(
-        pc.bold(pc.yellow(`\n⚠️  Max iterations (${maxIterations}) reached without completion`)),
+      consola.log(
+        colors.bold(
+          colors.yellow(`\n⚠️  Max iterations (${maxIterations}) reached without completion`),
+        ),
       );
-      console.log(pc.dim(`State saved to: ${stateFile}`));
+      consola.log(colors.dim(`State saved to: ${stateFile}`));
       logStream.write(`\n⚠️  Max iterations (${maxIterations}) reached without completion\n`);
       this.exit(1);
     }

package/src/commands/ralph/show.ts

@@ -0,0 +1,88 @@
+import { Flags } from "@oclif/core";
+import consola from "consola";
+import { colors } from "consola/utils";
+import { BaseCommand } from "../base.js";
+import { DEFAULT_STATE_FILE, loadState, resolveRalphPath } from "../../lib/ralph/state.js";
+import {
+  formatPlanAsMarkdown,
+  formatPlanAsJson,
+  copyToClipboard,
+} from "../../lib/ralph/formatter.js";
+
+/**
+ * Show plan summary with status, tasks, and mermaid graph
+ */
+export default class Show extends BaseCommand {
+  static override description = "Show plan summary with status, tasks, and mermaid graph";
+
+  static override examples = [
+    {
+      description: "Show plan summary with mermaid graph",
+      command: "<%= config.bin %> <%= command.id %>",
+    },
+    {
+      description: "Output plan as JSON",
+      command: "<%= config.bin %> <%= command.id %> --format json",
+    },
+    {
+      description: "Copy plan output to clipboard",
+      command: "<%= config.bin %> <%= command.id %> --copy",
+    },
+  ];
+
+  static override flags = {
+    ...BaseCommand.baseFlags,
+    stateFile: Flags.string({
+      char: "s",
+      description: `State file path (default: ${DEFAULT_STATE_FILE})`,
+    }),
+    format: Flags.string({
+      char: "f",
+      description: "Output format",
+      default: "default",
+      options: ["default", "markdown", "json"],
+    }),
+    copy: Flags.boolean({
+      char: "c",
+      description: "Copy output to clipboard",
+      default: false,
+    }),
+  };
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(Show);
+    const ralphSettings = this.settings.settings.ralphSettings;
+    const stateFile = resolveRalphPath(flags.stateFile, "stateFile", ralphSettings);
+
+    const state = loadState(stateFile);
+
+    if (!state) {
+      consola.log(colors.yellow(`No state file found at: ${stateFile}`));
+      return;
+    }
+
+    if (state.plans.length === 0) {
+      consola.log(colors.yellow("No tasks in state file."));
+      consola.log(colors.dim('Use: tt ralph plan add "description"'));
+      return;
+    }
+
+    let output: string;
+
+    if (flags.format === "json") {
+      output = formatPlanAsJson(state.plans, state);
+    } else {
+      output = formatPlanAsMarkdown(state.plans, state);
+    }
+
+    consola.log(output);
+
+    if (flags.copy) {
+      if (copyToClipboard(output)) {
+        consola.log(colors.green("✓ Copied to clipboard"));
+      } else {
+        consola.log(colors.yellow("⚠ Could not copy to clipboard (xclip/xsel not installed?)"));
+      }
+    }
+  }
+}

package/src/config/settings.ts

@@ -2,26 +2,16 @@ import { z } from "zod/v4";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { homedir } from "node:os";
-import { AppInfo } from "../constants";
 import consola from "consola";
 import { colors } from "consola/utils";
 
+const TOOL_NAME = "towles-tool";
+
 /** Default config directory */
-export const DEFAULT_CONFIG_DIR = path.join(homedir(), ".config", AppInfo.toolName);
+export const DEFAULT_CONFIG_DIR = path.join(homedir(), ".config", TOOL_NAME);
 
 /** User settings file path */
-export const USER_SETTINGS_PATH = path.join(
-  DEFAULT_CONFIG_DIR,
-  `${AppInfo.toolName}.settings.json`,
-);
-
-/** Settings filename used within configDir */
-export const SETTINGS_FILENAME = `${AppInfo.toolName}.settings.json`;
-
-/** Get settings file path for a given configDir */
-export function getSettingsPath(configDir: string): string {
-  return path.join(configDir, SETTINGS_FILENAME);
-}
+export const USER_SETTINGS_PATH = path.join(DEFAULT_CONFIG_DIR, `${TOOL_NAME}.settings.json`);
 
 export const RalphSettingsSchema = z.object({
   // Base directory for ralph files (relative to cwd or absolute)
@@ -48,7 +38,7 @@ export const JournalSettingsSchema = z.object({
     .string()
     .default(path.join("journal/{yyyy}/{MM}/notes/{yyyy}-{MM}-{dd}-{title}.md")),
   // Directory for external templates (fallback to hardcoded if not found)
-  templateDir: z.string().default(path.join(homedir(), ".config", AppInfo.toolName, "templates")),
+  templateDir: z.string().default(path.join(homedir(), ".config", TOOL_NAME, "templates")),
 });
 
 export type JournalSettings = z.infer<typeof JournalSettingsSchema>;
@@ -70,15 +60,6 @@ export interface SettingsFile {
   path: string;
 }
 
-// TODO refactor this.
-export class LoadedSettings {
-  constructor(settingsFile: SettingsFile) {
-    this.settingsFile = settingsFile;
-  }
-
-  readonly settingsFile: SettingsFile;
-}
-
 function createDefaultSettings(): UserSettings {
   return UserSettingsSchema.parse({});
 }
@@ -106,7 +87,7 @@ export function saveSettings(settingsFile: SettingsFile): void {
   }
 }
 
-export async function loadSettings(): Promise<LoadedSettings> {
+export async function loadSettings(): Promise<SettingsFile> {
   let userSettings: UserSettings | null = null;
 
   // Load user settings
@@ -148,8 +129,8 @@ export async function loadSettings(): Promise<LoadedSettings> {
     }
   }
 
-  return new LoadedSettings({
+  return {
     path: USER_SETTINGS_PATH,
     settings: userSettings!,
-  });
+  };
 }