@towles/tool 0.0.20 → 0.0.41

package/src/commands/index.ts

@@ -0,0 +1,55 @@
+// 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/install.ts

@@ -0,0 +1,148 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+import { Flags } from "@oclif/core";
+import pc from "picocolors";
+import consola from "consola";
+import { BaseCommand } from "./base.js";
+
+const CLAUDE_SETTINGS_PATH = path.join(homedir(), ".claude", "settings.json");
+
+interface ClaudeSettings {
+  cleanupPeriodDays?: number;
+  alwaysThinkingEnabled?: boolean;
+  hooks?: Record<string, unknown[]>;
+  [key: string]: unknown;
+}
+
+/**
+ * Install and configure towles-tool with Claude Code
+ */
+export default class Install extends BaseCommand {
+  static override description =
+    "Configure Claude Code settings and optionally enable observability";
+
+  static override examples = [
+    "<%= config.bin %> install",
+    "<%= config.bin %> install --observability",
+  ];
+
+  static override flags = {
+    ...BaseCommand.baseFlags,
+    observability: Flags.boolean({
+      char: "o",
+      description: "Show OTEL setup instructions and configure SubagentStop hook",
+      default: false,
+    }),
+  };
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(Install);
+
+    this.log(pc.bold("\n🔧 towles-tool install\n"));
+
+    // Load or create Claude settings
+    let claudeSettings: ClaudeSettings = {};
+    if (fs.existsSync(CLAUDE_SETTINGS_PATH)) {
+      try {
+        const content = fs.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
+        claudeSettings = JSON.parse(content);
+        this.log(pc.dim(`Found existing Claude settings at ${CLAUDE_SETTINGS_PATH}`));
+      } catch {
+        this.log(
+          pc.yellow(`Warning: Could not parse ${CLAUDE_SETTINGS_PATH}, will create fresh settings`),
+        );
+      }
+    } else {
+      this.log(pc.dim(`No Claude settings file found, will create one`));
+    }
+
+    // Configure recommended settings
+    let modified = false;
+
+    // Prevent log deletion (set to ~274 years)
+    if (claudeSettings.cleanupPeriodDays !== 99999) {
+      claudeSettings.cleanupPeriodDays = 99999;
+      modified = true;
+      this.log(pc.green("✓ Set cleanupPeriodDays: 99999 (prevent log deletion)"));
+    } else {
+      this.log(pc.dim("✓ cleanupPeriodDays already set to 99999"));
+    }
+
+    // Enable thinking by default
+    if (claudeSettings.alwaysThinkingEnabled !== true) {
+      claudeSettings.alwaysThinkingEnabled = true;
+      modified = true;
+      this.log(pc.green("✓ Set alwaysThinkingEnabled: true"));
+    } else {
+      this.log(pc.dim("✓ alwaysThinkingEnabled already set to true"));
+    }
+
+    // Save settings if modified
+    if (modified) {
+      this.saveClaudeSettings(claudeSettings);
+      this.log(pc.green(`\n✓ Saved Claude settings to ${CLAUDE_SETTINGS_PATH}`));
+    }
+
+    // Show observability setup if requested
+    if (flags.observability) {
+      this.log(pc.bold("\n📊 Observability Setup\n"));
+      this.showOtelInstructions();
+    }
+
+    this.log(pc.bold(pc.green("\n✅ Installation complete!\n")));
+
+    // Offer to install plugins from marketplace
+    this.log(pc.cyan("To install plugins from the Claude Code marketplace:"));
+    this.log(
+      pc.dim("  claude /plugins marketplace add https://github.com/ChrisTowles/towles-tool"),
+    );
+    this.log("");
+
+    const answer = await consola.prompt("Install tt-core plugin from marketplace now?", {
+      type: "confirm",
+      initial: true,
+    });
+
+    if (answer) {
+      const { x } = await import("tinyexec");
+      this.log("");
+
+      const result = await x("claude", ["plugin", "install", "tt@towles-tool", "--scope", "user"]);
+      if (result.stdout) this.log(result.stdout);
+      if (result.stderr) this.log(pc.dim(result.stderr));
+      if (result.exitCode === 0) {
+        this.log(pc.green("✓ tt-core plugin installed"));
+      } else {
+        this.log(pc.yellow(`Command exited with code ${result.exitCode}`));
+      }
+    }
+
+    this.log("");
+  }
+
+  private saveClaudeSettings(settings: ClaudeSettings): void {
+    const dir = path.dirname(CLAUDE_SETTINGS_PATH);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
+  }
+
+  private showOtelInstructions(): void {
+    this.log(pc.cyan("Add these environment variables to your shell profile:\n"));
+
+    consola.box(`export CLAUDE_CODE_ENABLE_TELEMETRY=1
+export OTEL_METRICS_EXPORTER=otlp
+export OTEL_LOGS_EXPORTER=otlp
+export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317`);
+
+    this.log("");
+    this.log(
+      pc.dim("For more info, see: https://github.com/anthropics/claude-code-monitoring-guide"),
+    );
+    this.log("");
+    this.log(pc.cyan("Quick cost analysis (no setup required):"));
+    this.log(pc.dim("  npx ccusage@latest --breakdown"));
+  }
+}

package/src/commands/journal/daily-notes.ts

@@ -0,0 +1,66 @@
+import { existsSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import consola from "consola";
+import { colors } from "consola/utils";
+import { BaseCommand } from "../base.js";
+import { JOURNAL_TYPES } from "../../types/journal.js";
+import {
+  createJournalContent,
+  ensureDirectoryExists,
+  ensureTemplatesExist,
+  generateJournalFileInfoByType,
+  openInEditor,
+} from "./utils.js";
+
+/**
+ * Create or open daily notes journal file
+ */
+export default class DailyNotes extends BaseCommand {
+  static override description = "Weekly files with daily sections for ongoing work and notes";
+
+  static override examples = [
+    "<%= config.bin %> journal daily-notes",
+    "<%= config.bin %> journal today",
+  ];
+
+  async run(): Promise<void> {
+    await this.parse(DailyNotes);
+
+    try {
+      const journalSettings = this.settings.settingsFile.settings.journalSettings;
+      const templateDir = journalSettings.templateDir;
+
+      // Ensure templates exist on first run
+      ensureTemplatesExist(templateDir);
+
+      const currentDate = new Date();
+      const fileInfo = generateJournalFileInfoByType({
+        journalSettings,
+        date: currentDate,
+        type: JOURNAL_TYPES.DAILY_NOTES,
+        title: "",
+      });
+
+      // Ensure journal directory exists
+      ensureDirectoryExists(path.dirname(fileInfo.fullPath));
+
+      if (existsSync(fileInfo.fullPath)) {
+        consola.info(`Opening existing daily-notes file: ${colors.cyan(fileInfo.fullPath)}`);
+      } else {
+        const content = createJournalContent({ mondayDate: fileInfo.mondayDate, templateDir });
+        consola.info(`Creating new daily-notes file: ${colors.cyan(fileInfo.fullPath)}`);
+        writeFileSync(fileInfo.fullPath, content, "utf8");
+      }
+
+      await openInEditor({
+        editor: this.settings.settingsFile.settings.preferredEditor,
+        filePath: fileInfo.fullPath,
+        folderPath: journalSettings.baseFolder,
+      });
+    } catch (error) {
+      consola.warn(`Error creating daily-notes file:`, error);
+      process.exit(1);
+    }
+  }
+}

package/src/commands/journal/meeting.ts

@@ -0,0 +1,83 @@
+import { existsSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { Args } from "@oclif/core";
+import consola from "consola";
+import { colors } from "consola/utils";
+import { BaseCommand } from "../base.js";
+import { JOURNAL_TYPES } from "../../types/journal.js";
+import {
+  createMeetingContent,
+  ensureDirectoryExists,
+  ensureTemplatesExist,
+  generateJournalFileInfoByType,
+  openInEditor,
+} from "./utils.js";
+
+/**
+ * Create or open meeting notes file
+ */
+export default class Meeting extends BaseCommand {
+  static override description = "Structured meeting notes with agenda and action items";
+
+  static override args = {
+    title: Args.string({
+      description: "Meeting title",
+      required: false,
+    }),
+  };
+
+  static override examples = [
+    "<%= config.bin %> journal meeting",
+    '<%= config.bin %> journal meeting "Sprint Planning"',
+    '<%= config.bin %> journal m "Standup"',
+  ];
+
+  async run(): Promise<void> {
+    const { args } = await this.parse(Meeting);
+
+    try {
+      const journalSettings = this.settings.settingsFile.settings.journalSettings;
+      const templateDir = journalSettings.templateDir;
+
+      // Ensure templates exist on first run
+      ensureTemplatesExist(templateDir);
+
+      // Prompt for title if not provided
+      let title = args.title || "";
+      if (title.trim().length === 0) {
+        title = await consola.prompt(`Enter meeting title:`, {
+          type: "text",
+        });
+      }
+
+      const currentDate = new Date();
+      const fileInfo = generateJournalFileInfoByType({
+        journalSettings,
+        date: currentDate,
+        type: JOURNAL_TYPES.MEETING,
+        title,
+      });
+
+      // Ensure journal directory exists
+      ensureDirectoryExists(path.dirname(fileInfo.fullPath));
+
+      if (existsSync(fileInfo.fullPath)) {
+        consola.info(`Opening existing meeting file: ${colors.cyan(fileInfo.fullPath)}`);
+      } else {
+        const content = createMeetingContent({ title, date: currentDate, templateDir });
+        consola.info(`Creating new meeting file: ${colors.cyan(fileInfo.fullPath)}`);
+        writeFileSync(fileInfo.fullPath, content, "utf8");
+      }
+
+      await openInEditor({
+        editor: this.settings.settingsFile.settings.preferredEditor,
+        filePath: fileInfo.fullPath,
+        folderPath: journalSettings.baseFolder,
+      });
+    } catch (error) {
+      consola.warn(`Error creating meeting file:`, error);
+      process.exit(1);
+    }
+  }
+}

package/src/commands/journal/note.ts

@@ -0,0 +1,83 @@
+import { existsSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { Args } from "@oclif/core";
+import consola from "consola";
+import { colors } from "consola/utils";
+import { BaseCommand } from "../base.js";
+import { JOURNAL_TYPES } from "../../types/journal.js";
+import {
+  createNoteContent,
+  ensureDirectoryExists,
+  ensureTemplatesExist,
+  generateJournalFileInfoByType,
+  openInEditor,
+} from "./utils.js";
+
+/**
+ * Create or open general-purpose note file
+ */
+export default class Note extends BaseCommand {
+  static override description = "General-purpose notes with structured sections";
+
+  static override args = {
+    title: Args.string({
+      description: "Note title",
+      required: false,
+    }),
+  };
+
+  static override examples = [
+    "<%= config.bin %> journal note",
+    '<%= config.bin %> journal note "Research Notes"',
+    '<%= config.bin %> journal n "Ideas"',
+  ];
+
+  async run(): Promise<void> {
+    const { args } = await this.parse(Note);
+
+    try {
+      const journalSettings = this.settings.settingsFile.settings.journalSettings;
+      const templateDir = journalSettings.templateDir;
+
+      // Ensure templates exist on first run
+      ensureTemplatesExist(templateDir);
+
+      // Prompt for title if not provided
+      let title = args.title || "";
+      if (title.trim().length === 0) {
+        title = await consola.prompt(`Enter note title:`, {
+          type: "text",
+        });
+      }
+
+      const currentDate = new Date();
+      const fileInfo = generateJournalFileInfoByType({
+        journalSettings,
+        date: currentDate,
+        type: JOURNAL_TYPES.NOTE,
+        title,
+      });
+
+      // Ensure journal directory exists
+      ensureDirectoryExists(path.dirname(fileInfo.fullPath));
+
+      if (existsSync(fileInfo.fullPath)) {
+        consola.info(`Opening existing note file: ${colors.cyan(fileInfo.fullPath)}`);
+      } else {
+        const content = createNoteContent({ title, date: currentDate, templateDir });
+        consola.info(`Creating new note file: ${colors.cyan(fileInfo.fullPath)}`);
+        writeFileSync(fileInfo.fullPath, content, "utf8");
+      }
+
+      await openInEditor({
+        editor: this.settings.settingsFile.settings.preferredEditor,
+        filePath: fileInfo.fullPath,
+        folderPath: journalSettings.baseFolder,
+      });
+    } catch (error) {
+      consola.warn(`Error creating note file:`, error);
+      process.exit(1);
+    }
+  }
+}