@towles/tool 0.0.11 → 0.0.13

package/README.md

@@ -70,11 +70,16 @@ if that works, then you need to add the pnpm global bin directory to your PATH.
 - [@anthropic-ai/claude-code](https://github.com/anthropic-ai/claude-code) - A library for interacting with the Claude code
 - [zod](https://github.com/colinhacks/zod) - TypeScript-first schema validation
 - [Consola](https://github.com/unjs/consola) console wrapper and colors
-- [c12](https://github.com/unjs/c12) configuration loader and utilities
+- ~~[c12](https://github.com/unjs/c12) configuration loader and utilities~~
+    - referted stayed to json config
 - [rolldown-vite](https://voidzero.dev/posts/announcing-rolldown-vite) - A Vite plugin for rolling down your code
 - ~~[zx](https://github.com/google/zx) google created library to write shell scripts in a more powerful and expressive way via the Anthropic API.~~
 - [prompts](https://github.com/terkelg/prompts) - A library for creating beautiful command-line prompts, with fuzzy search and other features.
-- [commander](https://github.com/tj/commander.js) - A library for building command-line interfaces, with support for subcommands, argument parsing, and more.
+- [yargs](https://github.com/yargs/yargs) - A modern, feature-rich command-line argument parser with enhanced error handling, TypeScript support, and flexible command configuration.
+- ~~[ink](https://github.com/vadimdemedes/ink) - React for interactive command-line apps~~
+    - wanted hotkey support and more complex UI but this was overkill for this project.
+- [publint](https://publint.dev/)
+- [e18e.dev](https://e18e.dev/guide/resources.html)
 
 ## Document verbose and debug options
 
@@ -98,13 +103,13 @@ I'm using a lot of inspiration from [Anthony Fu](https://github.com/antfu) for t
 
 <!-- Badges -->
 
-[npm-version-src]: https://img.shields.io/npm/v/pkg-placeholder?style=flat&colorA=080f12&colorB=1fa669
-[npm-version-href]: https://npmjs.com/package/pkg-placeholder
-[npm-downloads-src]: https://img.shields.io/npm/dm/pkg-placeholder?style=flat&colorA=080f12&colorB=1fa669
-[npm-downloads-href]: https://npmjs.com/package/pkg-placeholder
-[bundle-src]: https://img.shields.io/bundlephobia/minzip/pkg-placeholder?style=flat&colorA=080f12&colorB=1fa669&label=minzip
-[bundle-href]: https://bundlephobia.com/result?p=pkg-placeholder
-[license-src]: https://img.shields.io/github/license/antfu/pkg-placeholder.svg?style=flat&colorA=080f12&colorB=1fa669
+[npm-version-src]: https://img.shields.io/npm/v/@towles/tool?style=flat&colorA=080f12&colorB=1fa669
+[npm-version-href]: https://npmjs.com/package/@towles/tool
+[npm-downloads-src]: https://img.shields.io/npm/dm/@towles/tool?style=flat&colorA=080f12&colorB=1fa669
+[npm-downloads-href]: https://npmjs.com/package/@towles/tool
+[bundle-src]: https://img.shields.io/bundlephobia/minzip/@towles/tool?style=flat&colorA=080f12&colorB=1fa669&label=minzip
+[bundle-href]: https://bundlephobia.com/result?p=@towles/tool
+[license-src]: https://img.shields.io/github/license/ChrisTowles/towles-tool.svg?style=flat&colorA=080f12&colorB=1fa669
 [license-href]: https://github.com/ChrisTowles/towles-tool/blob/main/LICENSE.md
 [jsdocs-src]: https://img.shields.io/badge/jsdocs-reference-080f12?style=flat&colorA=080f12&colorB=1fa669
-[jsdocs-href]: https://www.jsdocs.io/package/pkg-placeholder
+[jsdocs-href]: https://www.jsdocs.io/package/@towles/tool

package/dist/index.mjs

@@ -1,116 +1,121 @@
 #!/usr/bin/env node
-import process from 'node:process';
-import { Command } from 'commander';
+import process$1 from 'node:process';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
 import consola from 'consola';
-import { colors } from 'consola/utils';
 import prompts from 'prompts';
 import { execSync, exec } from 'node:child_process';
+import * as fs from 'node:fs';
 import { existsSync, writeFileSync, mkdirSync } from 'node:fs';
 import * as path from 'node:path';
 import path__default from 'node:path';
-import util, { promisify } from 'node:util';
+import { promisify } from 'node:util';
+import { colors } from 'consola/utils';
+import { DateTime } from 'luxon';
+import { z } from 'zod/v4';
 import { homedir } from 'node:os';
-import { setupDotenv, loadConfig } from 'c12';
-import { updateConfig } from 'c12/update';
+import stripJsonComments from 'strip-json-comments';
 
-const version = "0.0.11";
+const version = "0.0.13";
 
 function execCommand(cmd, cwd) {
   return execSync(cmd, { encoding: "utf8", cwd }).trim();
 }
 
-async function gitCommitCommand(config, messageArgs) {
-  let statusOutput;
+async function gitCommitCommand(context, messageArgs) {
   try {
-    statusOutput = execCommand("git status --porcelain", config.cwd);
-  } catch (error) {
-    consola.error("Failed to get git status");
-    process.exit(1);
-  }
-  const lines = statusOutput.trim().split("\n").filter((line) => line.length > 0);
-  const stagedFiles = lines.filter((line) => line[0] !== " " && line[0] !== "?");
-  const unstagedFiles = lines.filter((line) => line[1] !== " " && line[1] !== "?");
-  const untrackedFiles = lines.filter((line) => line.startsWith("??"));
-  if (lines.length === 0) {
-    consola.info("Working tree clean - nothing to commit");
-    return;
-  }
-  consola.info("Git status:");
-  if (stagedFiles.length > 0) {
-    consola.info(colors.green("Staged files:"));
-    stagedFiles.forEach((file) => consola.info(`  ${colors.green(file)}`));
-  }
-  if (unstagedFiles.length > 0) {
-    consola.info(colors.yellow("Modified files (not staged):"));
-    unstagedFiles.forEach((file) => consola.info(`  ${colors.yellow(file)}`));
-  }
-  if (untrackedFiles.length > 0) {
-    consola.info(colors.red("Untracked files:"));
-    untrackedFiles.forEach((file) => consola.info(`  ${colors.red(file)}`));
-  }
-  if (stagedFiles.length === 0) {
-    if (unstagedFiles.length > 0 || untrackedFiles.length > 0) {
-      const { shouldStage } = await prompts({
+    const status = await getGitStatus(context.cwd);
+    if (!status || status.staged.length === 0 && status.unstaged.length === 0 && status.untracked.length === 0) {
+      consola.success("\u2713 Working tree clean - nothing to commit");
+      return;
+    }
+    displayGitStatus(status);
+    if (status.staged.length === 0) {
+      const shouldStage = await prompts({
         type: "confirm",
-        name: "shouldStage",
-        message: "No files are staged. Would you like to add files first?",
+        name: "stage",
+        message: "No files are staged. Add all modified and untracked files?",
         initial: true
       });
-      if (shouldStage) {
-        const { addAll } = await prompts({
-          type: "confirm",
-          name: "addAll",
-          message: "Add all modified and untracked files?",
-          initial: true
-        });
-        if (addAll) {
-          try {
-            execCommand("git add .", config.cwd);
-            consola.success("All files staged successfully");
-          } catch (error) {
-            consola.error("Failed to stage files");
-            process.exit(1);
-          }
-        } else {
-          consola.info(`Use ${colors.cyan("git add <file>...")} to stage specific files, then run the commit command again`);
-          return;
-        }
-      } else {
-        consola.error(`No staged changes found to commit. Use ${colors.cyan("git add <file>...")} to stage changes before committing.`);
-        process.exit(1);
+      if (!shouldStage.stage) {
+        consola.info("Cancelled");
+        return;
       }
-    } else {
-      consola.error("No changes to commit");
-      return;
+      consola.start("Staging files...");
+      await execCommand("git add .", context.cwd);
+      consola.success("Files staged");
     }
-  }
-  let commitMessage;
-  if (messageArgs && messageArgs.length > 0) {
-    commitMessage = messageArgs.join(" ");
-  } else {
-    const { message } = await prompts({
-      type: "text",
-      name: "message",
-      message: "Enter commit message:",
-      validate: (value) => value.trim().length > 0 || "Commit message cannot be empty"
-    });
-    if (!message) {
-      consola.info(colors.dim("Commit cancelled"));
-      return;
+    let commitMessage = messageArgs?.join(" ") || "";
+    if (!commitMessage) {
+      const response = await prompts({
+        type: "text",
+        name: "message",
+        message: "Enter commit message:",
+        validate: (value) => value.trim().length > 0 || "Commit message cannot be empty"
+      });
+      if (!response.message) {
+        consola.info("Cancelled");
+        return;
+      }
+      commitMessage = response.message;
     }
-    commitMessage = message.trim();
-  }
-  const commandWithArgs = `git commit -m "${commitMessage.replace(/"/g, '\\"')}"`;
-  consola.info(`Running: ${colors.cyan(commandWithArgs)}`);
-  try {
-    execCommand(commandWithArgs, config.cwd);
-    consola.success("Commit created successfully!");
+    consola.start("Creating commit...");
+    await execCommand(`git commit -m "${commitMessage}"`, context.cwd);
+    consola.success("\u2713 Commit created successfully!");
   } catch (error) {
-    consola.error("Failed to commit changes:");
-    consola.error(error);
+    consola.error("Git commit failed:", error instanceof Error ? error.message : String(error));
     process.exit(1);
   }
 }
+async function getGitStatus(cwd) {
+  try {
+    const output = await execCommand("git status --porcelain", cwd);
+    const lines = output.trim().split("\n").filter((line) => line.trim());
+    const staged = [];
+    const unstaged = [];
+    const untracked = [];
+    for (const line of lines) {
+      const status = line.substring(0, 2);
+      const file = line.substring(3);
+      if (status[0] !== " " && status[0] !== "?") {
+        staged.push(file);
+      }
+      if (status[1] !== " " && status[1] !== "?") {
+        unstaged.push(file);
+      }
+      if (status === "??") {
+        untracked.push(file);
+      }
+    }
+    return { staged, unstaged, untracked };
+  } catch {
+    return null;
+  }
+}
+function displayGitStatus(status) {
+  consola.info("Current git status:");
+  if (status.staged.length > 0) {
+    consola.success(`\u2713 Staged files (${status.staged.length}):`);
+    status.staged.slice(0, 5).forEach((file) => consola.log(`  ${file}`));
+    if (status.staged.length > 5) {
+      consola.log(`  ... and ${status.staged.length - 5} more`);
+    }
+  }
+  if (status.unstaged.length > 0) {
+    consola.warn(`M Modified files (${status.unstaged.length}):`);
+    status.unstaged.slice(0, 3).forEach((file) => consola.log(`  ${file}`));
+    if (status.unstaged.length > 3) {
+      consola.log(`  ... and ${status.unstaged.length - 3} more`);
+    }
+  }
+  if (status.untracked.length > 0) {
+    consola.error(`? Untracked files (${status.untracked.length}):`);
+    status.untracked.slice(0, 3).forEach((file) => consola.log(`  ${file}`));
+    if (status.untracked.length > 3) {
+      consola.log(`  ... and ${status.untracked.length - 3} more`);
+    }
+  }
+}
 
 function getMondayOfWeek(date) {
   const newDate = new Date(date);
@@ -214,44 +219,71 @@ async function openInEditor({ editor, filePath }) {
     consola.warn(`Could not open in editor : '${editor}'. Modify your editor in the config: examples include 'code', 'code-insiders',  etc...`, ex);
   }
 }
-function generateJournalFileInfoByType({ date = /* @__PURE__ */ new Date(), type = JOURNAL_TYPES.DAILY_NOTES, title }) {
+function resolvePathTemplate(template, title, date) {
+  const dateTime = DateTime.fromJSDate(date, { zone: "utc" });
+  return template.replace(/\{([^}]+)\}/g, (match, token) => {
+    try {
+      if (token === "title") {
+        return title.toLowerCase().replace(/\s+/g, "-");
+      }
+      const result = dateTime.toFormat(token);
+      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;
+    }
+  });
+}
+function generateJournalFileInfoByType({ journalSettings, date = /* @__PURE__ */ new Date(), type = JOURNAL_TYPES.DAILY_NOTES, title }) {
   const currentDate = new Date(date);
-  const year = currentDate.getFullYear().toString();
+  let templatePath = "";
+  let mondayDate = getMondayOfWeek(currentDate);
   switch (type) {
     case JOURNAL_TYPES.DAILY_NOTES: {
       const monday = getMondayOfWeek(currentDate);
-      const fileName = `${formatDate(monday)}-week-log.md`;
-      const pathPrefix = [year, "daily-notes"];
-      return { pathPrefix, fileName, mondayDate: monday };
+      templatePath = journalSettings.dailyPathTemplate;
+      mondayDate = monday;
+      break;
     }
     case JOURNAL_TYPES.MEETING: {
-      const dateStr = formatDate(currentDate);
-      const timeStr = currentDate.toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit" }).replace(":", "");
-      const titleSlug = title ? `-${title.toLowerCase().replace(/\s+/g, "-")}` : "";
-      const fileName = `${dateStr}-${timeStr}-meeting${titleSlug}.md`;
-      const pathPrefix = [year, "meetings"];
-      return { pathPrefix, fileName, mondayDate: currentDate };
+      templatePath = journalSettings.meetingPathTemplate;
+      mondayDate = currentDate;
+      break;
     }
     case JOURNAL_TYPES.NOTE: {
-      const dateStr = formatDate(currentDate);
-      const timeStr = currentDate.toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit" }).replace(":", "");
-      const titleSlug = title ? `-${title.toLowerCase().replace(/\s+/g, "-")}` : "";
-      const fileName = `${dateStr}-${timeStr}-note${titleSlug}.md`;
-      const pathPrefix = [year, "notes"];
-      return { pathPrefix, fileName, mondayDate: currentDate };
+      templatePath = journalSettings.notePathTemplate;
+      mondayDate = currentDate;
+      break;
     }
     default:
       throw new Error(`Unknown journal type: ${type}`);
   }
+  const resolvedPath = resolvePathTemplate(templatePath, title, currentDate);
+  return {
+    currentDate,
+    fullPath: resolvedPath,
+    mondayDate
+  };
 }
-async function createJournalFile({ userConfig, type, title }) {
+async function createJournalFile({ context, type, title }) {
   try {
     const currentDate = /* @__PURE__ */ new Date();
-    const fileInfo = generateJournalFileInfoByType({ date: currentDate, type, title });
-    const filePath = path__default.join(userConfig.journalDir, ...fileInfo.pathPrefix, fileInfo.fileName);
-    ensureDirectoryExists(path__default.join(userConfig.journalDir, ...fileInfo.pathPrefix));
-    if (existsSync(filePath)) {
-      consola.info(`Opening existing ${type} file: ${colors.cyan(filePath)}`);
+    const fileInfo = generateJournalFileInfoByType({
+      journalSettings: context.settingsFile.settings.journalSettings,
+      date: currentDate,
+      type,
+      title
+    });
+    ensureDirectoryExists(path__default.dirname(fileInfo.fullPath));
+    if (existsSync(fileInfo.fullPath)) {
+      consola.info(`Opening existing ${type} file: ${colors.cyan(fileInfo.fullPath)}`);
     } else {
       let content;
       switch (type) {
@@ -267,122 +299,208 @@ async function createJournalFile({ userConfig, type, title }) {
         default:
           throw new Error(`Unknown journal type: ${type}`);
       }
-      writeFileSync(filePath, content, "utf8");
-      consola.info(`Created new ${type} file: ${colors.cyan(filePath)}`);
+      consola.info(`Creating new ${type} file: ${colors.cyan(fileInfo.fullPath)}`);
+      writeFileSync(fileInfo.fullPath, content, "utf8");
     }
-    await openInEditor({ editor: userConfig.editor, filePath });
+    await openInEditor({ editor: context.settingsFile.settings.preferredEditor, filePath: fileInfo.fullPath });
   } catch (error) {
     consola.warn(`Error creating ${type} file:`, error);
-    process.exit(1);
+    process$1.exit(1);
   }
 }
 
-const constants = {
+async function loadTowlesToolContext({
+  cwd,
+  settingsFile,
+  debug = false
+}) {
+  return {
+    cwd,
+    settingsFile,
+    args: [],
+    // TODO: Load args from yargs
+    debug
+  };
+}
+
+const AppInfo = {
   toolName: "towles-tool"
 };
 
-function printJson(obj) {
-  consola.log(util.inspect(obj, {
-    depth: 2,
-    colors: true,
-    showHidden: false,
-    compact: false
-  }));
+async function configCommand(context) {
+  consola.info("Configuration");
+  consola.log("");
+  consola.info(`Settings File: ${context.settingsFile.path}`);
+  consola.log("");
+  consola.warn("User Config:");
+  consola.log(`  Daily Path Template: ${context.settingsFile.settings.journalSettings.dailyPathTemplate}`);
+  consola.log(`  Meeting Path Template: ${context.settingsFile.settings.journalSettings.meetingPathTemplate}`);
+  consola.log(`  Note Path Template: ${context.settingsFile.settings.journalSettings.notePathTemplate}`);
+  consola.log(`  Editor: ${context.settingsFile.settings.preferredEditor}`);
+  consola.log("");
+  consola.warn("Working Directory:");
+  consola.log(`  ${context.cwd}`);
 }
-function printDebug(message, ...args) {
-  if (process.env.DEBUG) {
-    consola.debug(`DEBUG: ${message}`, ...args);
+
+const USER_SETTINGS_DIR = path.join(homedir(), ".config", AppInfo.toolName);
+const USER_SETTINGS_PATH = path.join(USER_SETTINGS_DIR, `${AppInfo.toolName}.settings.json`);
+const JournalSettingsSchema = z.object({
+  // https://moment.github.io/luxon/#/formatting?id=table-of-tokens
+  dailyPathTemplate: z.string().default(path.join(homedir(), "journal", "{yyyy}/{MM}/daily-notes/{yyyy}-{MM}-{dd}-daily-notes.md")),
+  meetingPathTemplate: z.string().default(path.join(homedir(), "journal", "{yyyy}/{MM}/meetings/{yyyy}-{MM}-{dd}-{title}.md")),
+  notePathTemplate: z.string().default(path.join(homedir(), "journal", "{yyyy}/{MM}/notes/{yyyy}-{MM}-{dd}-{title}.md"))
+});
+const UserSettingsSchema = z.object({
+  preferredEditor: z.string().default("code"),
+  journalSettings: JournalSettingsSchema
+});
+class LoadedSettings {
+  constructor(settingsFile) {
+    this.settingsFile = settingsFile;
   }
+  settingsFile;
 }
-
-function getDefaultUserConfig() {
-  return {
-    journalDir: path.join(homedir(), "journal"),
-    editor: "code"
+function createSettingsFile() {
+  const defaultSettings = UserSettingsSchema.parse({
+    // its odd, but but we have to get default value from each schema object, if we don't it failes.
+    // https://github.com/colinhacks/zod/discussions/1953
+    journalSettings: JournalSettingsSchema.parse({})
+  });
+  const settingsFile = {
+    path: USER_SETTINGS_PATH,
+    settings: defaultSettings
   };
+  saveSettings(settingsFile);
+  consola.success(`Created settings file: ${USER_SETTINGS_PATH}`);
+  return defaultSettings;
 }
-async function loadTowlesToolConfig({
-  cwd,
-  overrides
-}) {
-  await setupDotenv({ cwd });
-  const defaults = getDefaultUserConfig();
-  const defaultConfigFolder = path.join(homedir(), ".config", constants.toolName);
-  const updateResult = await updateConfig({
-    cwd: defaultConfigFolder,
-    configFile: `${constants.toolName}.config`,
-    createExtension: ".ts",
-    async onCreate({ configFile: configFile2 }) {
-      const shallCreate = await consola.prompt(
-        `Do you want to initialize a new config in ${colors.cyan(configFile2)}?`,
-        {
-          type: "confirm",
-          default: true
-        }
-      );
-      if (shallCreate !== true) {
-        return false;
-      }
-      return `
-// Default configuration for Towles Tool
-// You can customize these values to fit your needs
-// cwd: null means it will use the current working directory
-export default  ${JSON.stringify(defaults, null, 2)};
-`;
-    },
-    async onUpdate(config) {
-      return config;
+function saveSettings(settingsFile) {
+  try {
+    const dirPath = path.dirname(settingsFile.path);
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
     }
-  }).catch((error) => {
-    consola.error(`Failed to update config: ${error.message}`);
-    return null;
-  });
-  if (!updateResult?.configFile) {
-    consola.error(`Failed to load or update config. Please check your configuration.`);
-    process.exit(1);
+    fs.writeFileSync(
+      settingsFile.path,
+      JSON.stringify(settingsFile.settings, null, 2),
+      "utf-8"
+    );
+  } catch (error) {
+    consola.error("Error saving user settings file:", error);
   }
-  const { config: userConfig, configFile } = await loadConfig({
-    cwd: cwd || defaultConfigFolder,
-    configFile: updateResult.configFile,
-    name: constants.toolName,
-    packageJson: true,
-    defaults,
-    overrides: {
-      // cwd,
-      ...overrides
+}
+async function loadSettings() {
+  let userSettings = null;
+  if (fs.existsSync(USER_SETTINGS_PATH)) {
+    const userContent = fs.readFileSync(USER_SETTINGS_PATH, "utf-8");
+    const parsedUserSettings = JSON.parse(stripJsonComments(userContent));
+    userSettings = UserSettingsSchema.parse(parsedUserSettings);
+    if (JSON.stringify(parsedUserSettings) !== JSON.stringify(userSettings)) {
+      consola.warn(`Settings file ${USER_SETTINGS_PATH} has been updated with default values.`);
+      const tempSettingsFile = {
+        path: USER_SETTINGS_PATH,
+        settings: userSettings
+      };
+      saveSettings(tempSettingsFile);
     }
-  });
-  printDebug(`Using config from: ${colors.cyan(configFile)}`);
-  return {
-    configFile,
-    cwd,
-    userConfig
-  };
+  } else {
+    const confirmed = await consola.prompt(`Settings file not found. Create ${colors.cyan(USER_SETTINGS_PATH)}?`, {
+      type: "confirm"
+    });
+    if (!confirmed) {
+      throw new Error(`Settings file not found and user chose not to create it.`);
+    }
+    userSettings = createSettingsFile();
+  }
+  return new LoadedSettings(
+    {
+      path: USER_SETTINGS_PATH,
+      settings: userSettings
+    }
+  );
 }
 
 async function main() {
-  const consola$1 = consola.withTag(constants.toolName);
-  const config = await loadTowlesToolConfig({ cwd: process.cwd() });
-  const program = new Command();
-  program.name(constants.toolName).description("One off quality of life scripts that I use on a daily basis").version(version);
-  const journalCmd = program.command("journal").description("quickly create md files from templates files like daily-notes, meeting, notes, etc.");
-  journalCmd.command("daily-notes").description("Weekly files with daily sections for ongoing work and notes").action(async () => {
-    await createJournalFile({ userConfig: config.userConfig, type: JOURNAL_TYPES.DAILY_NOTES });
-  });
-  journalCmd.command("meeting [title]").description("Structured meeting notes with agenda and action items").action(async (title) => {
-    await createJournalFile({ userConfig: config.userConfig, type: JOURNAL_TYPES.MEETING, title });
-  });
-  journalCmd.command("note [title]").description("General-purpose notes with structured sections").action(async (title) => {
-    await createJournalFile({ userConfig: config.userConfig, type: JOURNAL_TYPES.NOTE, title });
-  });
-  program.command("git-commit [message...]").alias("gc").description("Git commit command with optional message").action(async (message) => {
-    await gitCommitCommand(config, message);
-  });
-  program.command("config").description("set or show configuration file.").action(async () => {
-    consola$1.log(colors.green("Showing configuration..."));
-    consola$1.log("Settings File:", config.configFile);
-    printJson(config);
+  const settings = await loadSettings();
+  const context = await loadTowlesToolContext({
+    cwd: process$1.cwd(),
+    settingsFile: settings.settingsFile,
+    debug: true
+    // later can be set to false in production or when not debugging
   });
-  program.parse();
+  consola.info(`Using configuration from ${settings.settingsFile.path}`);
+  const parser = yargs(hideBin(process$1.argv)).scriptName(AppInfo.toolName).usage("Usage: $0 <command> [options]").version(version).demandCommand(1, "You need at least one command").recommendCommands().strict().help().wrap(yargs().terminalWidth());
+  parser.command(
+    ["journal", "j"],
+    "quickly create md files from templates files like daily-notes, meeting, notes, etc.",
+    (yargs2) => {
+      return yargs2.command(
+        ["daily-notes", "today"],
+        "Weekly files with daily sections for ongoing work and notes",
+        {},
+        async () => {
+          await createJournalFile({ context, type: JOURNAL_TYPES.DAILY_NOTES, title: "" });
+        }
+      ).command(
+        ["meeting [title]", "m"],
+        "Structured meeting notes with agenda and action items",
+        (yargs3) => {
+          return yargs3.positional("title", {
+            type: "string",
+            describe: "Meeting title"
+          });
+        },
+        async (argv) => {
+          await createJournalFile({ context, type: JOURNAL_TYPES.MEETING, title: argv.title || "" });
+        }
+      ).command(
+        ["note [title]", "n"],
+        "General-purpose notes with structured sections",
+        (yargs3) => {
+          return yargs3.positional("title", {
+            type: "string",
+            describe: "Note title"
+          });
+        },
+        async (argv) => {
+          await createJournalFile({ context, type: JOURNAL_TYPES.NOTE, title: argv.title || "" });
+        }
+      ).demandCommand(1, "You need to specify a journal subcommand").help();
+    },
+    () => {
+      parser.showHelp();
+    }
+  );
+  parser.command(
+    ["git-commit [message...]", "gc"],
+    "Git commit command with optional message",
+    (yargs2) => {
+      return yargs2.positional("message", {
+        type: "string",
+        array: true,
+        describe: "Commit message words"
+      });
+    },
+    async (argv) => {
+      await gitCommitCommand(context, argv.message || []);
+    }
+  );
+  parser.command(
+    ["config", "cfg"],
+    "set or show configuration file.",
+    {},
+    async () => {
+      await configCommand(context);
+    }
+  );
+  await parser.parse();
 }
-await main();
+main().catch((error) => {
+  consola.error("An unexpected critical error occurred:");
+  if (error instanceof Error) {
+    consola.error(error.stack);
+  } else {
+    consola.error(String(error));
+  }
+  process$1.exit(1);
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@towles/tool",
   "type": "module",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "One off quality of life scripts that I use on a daily basis.",
   "author": "Chris Towles <Chris.Towles.Dev@gmail.com>",
   "license": "MIT",
@@ -35,22 +35,21 @@
   "dependencies": {
     "@anthropic-ai/claude-code": "^1.0.51",
     "@anthropic-ai/sdk": "^0.56.0",
-    "@clack/prompts": "^0.11.0",
-    "c12": "^3.0.4",
-    "changelogen": "^0.6.2",
-    "commander": "^14.0.0",
     "consola": "^3.4.2",
     "fzf": "^0.5.2",
-    "magicast": "^0.3.5",
+    "luxon": "^3.7.1",
     "neverthrow": "^8.2.0",
     "prompts": "^2.4.2",
+    "strip-json-comments": "^5.0.2",
+    "yargs": "^17.7.2",
     "zod": "^4.0.5"
   },
   "devDependencies": {
     "@antfu/ni": "^25.0.0",
-    "@antfu/utils": "^9.2.0",
+    "@types/luxon": "^3.6.2",
     "@types/node": "^22.16.3",
     "@types/prompts": "^2.4.9",
+    "@types/yargs": "^17.0.32",
     "bumpp": "^10.2.0",
     "lint-staged": "^15.5.2",
     "oxlint": "^1.7.0",
@@ -79,11 +78,12 @@
     "lint": "oxlint",
     "lint:fix": "oxlint --fix",
     "lint:fix_all": "oxlint --fix .",
+    "lint:package": "pnpm dlx publint --fix && pnpm dlx knip",
     "release:local": "bumpp && pnpm publish --no-git-checks -r --access public",
     "release": "bumpp && echo \"github action will run and publish to npm\"",
     "start": "tsx src/index.ts",
     "test": "vitest --run",
-    "test:watch": "vitest",
+    "test:watch": "CI=DisableCallingClaude vitest --watch",
     "typecheck": "tsc --noEmit"
   }
 }