@towles/tool 0.0.11-beta.2 → 0.0.11

package/README.md

@@ -8,8 +8,35 @@
 
 One off quality of life scripts that I use on a daily basis.
 
+## Journal Type System
+
+The journal system supports three types of files with different templates and organization:
+
+### Daily Notes (`journal daily-notes`)
+- **Purpose**: Weekly files with daily sections for ongoing work and notes
+- **File structure**: `YYYY/daily-notes/YYYY-MM-DD-week-log.md` (Monday's date)
+- **Template**: Includes sections for Monday through Friday with date headers
+- **Use case**: Regular daily journaling, work logs, scratch pad for notes
+
+### Meeting Files (`journal meeting [title]`)
+- **Purpose**: Structured meeting notes with agenda and action items
+- **File structure**: `YYYY/meetings/YYYY-MM-DD-HHMM-meeting-[title].md`
+- **Template**: Includes Date, Time, Attendees, Agenda, Notes, Action Items, and Follow-up sections
+- **Use case**: Meeting preparation, note-taking, and action item tracking
+
+### Note Files (`journal note [title]`)
+- **Purpose**: General-purpose notes with structured sections
+- **File structure**: `YYYY/notes/YYYY-MM-DD-HHMM-note-[title].md`
+- **Template**: Includes Summary, Details, and References sections
+- **Use case**: Research notes, documentation, general information capture
+
+### Commands
+- `journal` or `journal daily-notes` - Create/open current week's daily notes
+- `journal meeting [title]` - Create a new meeting file with optional title
+- `journal note [title]` - Create a new note file with optional title
+
 ## Tools to add
-- [x] Today - creates and opens a markdown file, named the current week of the year, for you to keep your daily notes and use a scratch pad for notes.
+- [x] Journal system - creates and opens markdown files with templates for daily-notes, meetings, and notes
 - [ ] use claude code to generate git commits with multiple options for the commit message.
 
 ## Install from repository

package/dist/index.mjs

@@ -3,360 +3,111 @@ import process from 'node:process';
 import { Command } from 'commander';
 import consola from 'consola';
 import { colors } from 'consola/utils';
-import { spinner } from '@clack/prompts';
-import { Fzf } from 'fzf';
 import prompts from 'prompts';
-import z$1, { z } from 'zod/v4';
-import { err, ok } from 'neverthrow';
-import { query } from '@anthropic-ai/claude-code';
 import { execSync, exec } from 'node:child_process';
-import util, { promisify } from 'node:util';
 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 { homedir } from 'node:os';
 import { setupDotenv, loadConfig } from 'c12';
 import { updateConfig } from 'c12/update';
 
-const version = "0.0.11-beta.2";
+const version = "0.0.11";
 
-class AnyError extends Error {
-  name = "AnyError";
-  cause;
-  constructor(message, cause) {
-    super(message);
-    this.cause = isError(cause) ? cause : void 0;
-  }
-}
-class ClaudeError extends AnyError {
-  name = "ClaudeError";
-}
-function isError(error) {
-  return error instanceof Error || error instanceof AnyError;
+function execCommand(cmd, cwd) {
+  return execSync(cmd, { encoding: "utf8", cwd }).trim();
 }
 
-class ValidationError extends AnyError {
-  // eslint-disable-next-line node/handle-callback-err
-  constructor(error, message, cause) {
-    super(message, cause);
-    this.error = error;
-    this.message = message;
+async function gitCommitCommand(config, messageArgs) {
+  let statusOutput;
+  try {
+    statusOutput = execCommand("git status --porcelain", config.cwd);
+  } catch (error) {
+    consola.error("Failed to get git status");
+    process.exit(1);
   }
-  name = "ValidationError";
-}
-function validate(schema, data) {
-  const result = schema.safeParse(data);
-  if (!result.success) {
-    consola.error("Validation failed:", result.error);
-    return err(new ValidationError(result.error, "Validation error occurred"));
+  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;
   }
-  return ok(result.data);
-}
-
-const jsonPrimitiveSchema = z.union([
-  z.string(),
-  z.number(),
-  z.boolean(),
-  z.null()
-]);
-const jsonValueSchema = z.lazy(
-  () => z.union([
-    jsonPrimitiveSchema,
-    z.array(jsonValueSchema),
-    z.record(z.string(), jsonValueSchema)
-  ])
-);
-z.record(
-  z.string(),
-  jsonValueSchema
-);
-
-class ClaudeService {
-  pathToClaudeCodeExecutable;
-  constructor(pathToClaudeCodeExecutable) {
-    this.pathToClaudeCodeExecutable = pathToClaudeCodeExecutable;
+  consola.info("Git status:");
+  if (stagedFiles.length > 0) {
+    consola.info(colors.green("Staged files:"));
+    stagedFiles.forEach((file) => consola.info(`  ${colors.green(file)}`));
   }
-  async sendMessageStream(input, onChunk) {
-    try {
-      const options = {
-        pathToClaudeCodeExecutable: this.pathToClaudeCodeExecutable,
-        permissionMode: "bypassPermissions"
-      };
-      if (input.sessionId) {
-        options.resume = input.sessionId;
-      }
-      if (input.cwd) {
-        options.cwd = input.cwd;
-      }
-      if (input.allowedTools) {
-        options.allowedTools = input.allowedTools;
-      }
-      if (input.bypassPermissions) {
-        options.permissionMode = "bypassPermissions";
-      }
-      const messages = [];
-      for await (const message of query({
-        prompt: input.message,
-        options
-      })) {
-        const customMessage = message;
-        messages.push(customMessage);
-        onChunk(customMessage);
-      }
-      if (messages.length === 0) {
-        throw new Error("No response received from Claude Code SDK");
-      }
-      return ok(messages);
-    } catch (error) {
-      return err(
-        new ClaudeError("Failed to stream message from Claude", error)
-      );
-    }
+  if (unstagedFiles.length > 0) {
+    consola.info(colors.yellow("Modified files (not staged):"));
+    unstagedFiles.forEach((file) => consola.info(`  ${colors.yellow(file)}`));
   }
-  parseAssistantContent(rawContent) {
-    const parsed = validate(jsonValueSchema, rawContent);
-    if (parsed.isErr()) {
-      return err(
-        new ClaudeError("Invalid assistant content format", parsed.error)
-      );
-    }
-    if (!Array.isArray(parsed.value)) {
-      return err(
-        new ClaudeError("Assistant content must be an array of content blocks")
-      );
-    }
-    for (const item of parsed.value) {
-      if (typeof item !== "object" || item === null || !("type" in item)) {
-        return err(
-          new ClaudeError("Assistant content contains invalid content block")
-        );
-      }
-    }
-    return ok(parsed.value);
+  if (untrackedFiles.length > 0) {
+    consola.info(colors.red("Untracked files:"));
+    untrackedFiles.forEach((file) => consola.info(`  ${colors.red(file)}`));
   }
-  parseUserContent(rawContent) {
-    const parsed = validate(jsonValueSchema, rawContent);
-    if (parsed.isErr()) {
-      return err(new ClaudeError("Invalid user content format", parsed.error));
-    }
-    if (typeof parsed.value === "string") {
-      return ok(parsed.value);
-    }
-    if (Array.isArray(parsed.value)) {
-      for (const item of parsed.value) {
-        if (typeof item !== "object" || item === null || !("type" in item)) {
-          return err(
-            new ClaudeError(
-              "User content array contains invalid content block"
-            )
-          );
+  if (stagedFiles.length === 0) {
+    if (unstagedFiles.length > 0 || untrackedFiles.length > 0) {
+      const { shouldStage } = await prompts({
+        type: "confirm",
+        name: "shouldStage",
+        message: "No files are staged. Would you like to add files first?",
+        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);
       }
-      return ok(parsed.value);
+    } else {
+      consola.error("No changes to commit");
+      return;
     }
-    return err(
-      new ClaudeError(
-        "User content must be a string or array of content blocks"
-      )
-    );
   }
-}
-
-function execCommand(cmd, cwd) {
-  return execSync(cmd, { encoding: "utf8", cwd }).trim();
-}
-
-async function getGitDiff(cwd) {
-  const r = execCommand(
-    // `git --no-pager log "${from ? `${from}...` : ''}${to}"  `,
-    `git --no-pager diff --staged`,
-    // --name-status
-    // --pretty="----%n%s|%h|%an|%ae%n%b"
-    cwd
-  );
-  return r;
-}
-
-function printJson(obj) {
-  consola.log(util.inspect(obj, {
-    depth: 2,
-    colors: true,
-    showHidden: false,
-    compact: false
-  }));
-}
-function printDebug(message, ...args) {
-  if (process.env.DEBUG) {
-    consola.debug(`DEBUG: ${message}`, ...args);
-  }
-}
-
-const commitTypes = ["feat", "fix", "docs", "test", "wip"];
-const maxSubjectLength = 72;
-const llmMaxSubjectLength = maxSubjectLength - 12;
-const gitCommitSuggestionSchema = z$1.object({
-  subject: z$1.string().min(1).max(maxSubjectLength),
-  // larger than we told the LLM to generate
-  body: z$1.string().optional()
-});
-function finalPrompt(diff, generate_number) {
-  const generate_number_plural = "s" ;
-  const first_part = [
-    `You are a helpful assistant specializing in writing clear and informative Git commit messages using the conventional style.`,
-    `Based on the given code changes or context, generate exactly ${generate_number} conventional Git commit message${generate_number_plural} based on the following guidelines.`,
-    `1. Format: follow the conventional commits format following of one of the following. :`,
-    "<type>: <commit message>",
-    "<type>(<optional scope>): <commit message>",
-    "",
-    `2. Types: use one of the following types:`,
-    `     ${commitTypes.join("-, ")}`,
-    "3. Guidelines for writing commit messages:",
-    "   - Be specific about what changes were made",
-    '   - Use imperative mood ("add feature" not "added feature")',
-    `   - Keep subject line under ${llmMaxSubjectLength} characters`,
-    "   - make each entry more generic and not too specific to the code changes",
-    "   - Do not end the subject line with a period",
-    "   - Use the body to explain what and why vs. how",
-    "4. Focus on:",
-    "   - What problem this commit solves",
-    "   - Why this change was necessary",
-    "   - Any important technical details",
-    "5. Exclude anything unnecessary such as translation or implementation details."
-  ];
-  const diff_part = [
-    `Here is the context for the commit message${generate_number_plural}:`,
-    "",
-    "```diff",
-    `${diff}`,
-    "```",
-    "",
-    `If no code changes are provided, use the context to generate a commit message based on the task or issue description.`
-  ];
-  const last_part = [
-    "",
-    `Lastly, Provide your response as a JSON array containing exactly ${generate_number} object${generate_number_plural}, each with the following keys:`,
-    `- "subject": The main commit message using the conventional commit style. It should be a concise summary of the changes.`,
-    `- "body": An optional detailed explanation of the changes. If not needed, use an empty string.`,
-    `The array must always contain ${generate_number} element${generate_number_plural}, no more and no less.`,
-    `The LLM result will be valid json only if it is well-formed and follows the schema below.`,
-    "",
-    `<result>`,
-    `[`,
-    `  {`,
-    `    "subject": "chore: update <file> to handle auth",`,
-    `    "body": "- Update login function to handle edge cases\\n- Add additional error logging for debugging",`,
-    `  }`,
-    `  {`,
-    `    "subject": "fix(auth): fix bug in user authentication process",`,
-    `    "body": "- Update login function to handle edge cases\\n- Add additional error logging for debugging",`,
-    `  }`,
-    `]`,
-    `</result>`,
-    "",
-    "",
-    `Ensure you generate exactly ${generate_number} commit message${generate_number_plural}, even if it requires creating slightly varied versions for similar changes.`,
-    `The response should be valid JSON that can be parsed without errors.`
-  ];
-  return [
-    ...first_part,
-    ...diff_part,
-    ...last_part
-  ].join("\n");
-}
-async function gitCommitCommand(config) {
-  const s = spinner();
-  s.start("Generating commit message based on diff...");
-  s.message("getting git diff...");
-  const diff = await getGitDiff(config.cwd);
-  if (diff.trim().length === 0) {
-    consola.error(`No staged changes found to commit. use '${colors.blue("git add <file>...")}' to stage changes before committing.`);
-    process.exit(1);
-  }
-  s.message("generating prompt...");
-  const prompt = finalPrompt(
-    diff,
-    /* config.generate_number || */
-    6
-  );
-  const service = new ClaudeService();
-  const input = {
-    message: prompt
-  };
-  s.message("sending prompt to claude and waiting answer...");
-  const result = await service.sendMessageStream(input, () => {
-  });
-  if (result.isErr()) {
-    consola.error(`Error sending message: ${result.error.message}`);
-    process.exit(1);
-  }
-  s.stop(`Received commit messages from Claude!${colors.green("\u2713")}`);
-  const filteredResults = result.value.filter((msg) => msg.type === "result");
-  if (filteredResults.length === 0) {
-    consola.error("No valid commit messages received from Claude");
-    process.exit(1);
-  }
-  if (filteredResults.length > 1) {
-    consola.warn(`Received ${filteredResults.length} commit messages, using the first one`);
-  }
-  const startIndex = filteredResults[0].result.indexOf("[");
-  const endIndex = filteredResults[0].result.lastIndexOf("]");
-  if (startIndex === -1 || endIndex === -1 || startIndex >= endIndex) {
-    consola.error("Could not find valid JSON array in Claude response");
-    process.exit(1);
-  }
-  const cleanedResultRaw = filteredResults[0].result.substring(startIndex, endIndex + 1);
-  const cleanedResult = JSON.parse(cleanedResultRaw);
-  const suggestions = validate(z$1.array(gitCommitSuggestionSchema), cleanedResult);
-  consola.success("Claude suggestions validated for format!");
-  if (!suggestions.isOk()) {
-    consola.error("Invalid suggestions format:", suggestions.error);
-    process.exit(1);
+  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;
+    }
+    commitMessage = message.trim();
   }
-  const choosenSuggestion = await promptUserForCommitMessage(suggestions.value);
-  const commandWithArgs = `git commit -m "${choosenSuggestion.subject}"`;
-  consola.info(`Running command: ${colors.bgCyan(commandWithArgs)}`);
+  const commandWithArgs = `git commit -m "${commitMessage.replace(/"/g, '\\"')}"`;
+  consola.info(`Running: ${colors.cyan(commandWithArgs)}`);
   try {
     execCommand(commandWithArgs, config.cwd);
+    consola.success("Commit created successfully!");
   } catch (error) {
-    consola.error(`Failed to commit changes:`);
-    printJson(error);
-    process.exit(1);
-  }
-}
-async function promptUserForCommitMessage(suggestions) {
-  let profileChoices = suggestions.map((x) => ({
-    title: x.subject,
-    value: x.subject
-    // description: limitText(`${x.getFriendlyAccountName()}`, 15),
-  }));
-  profileChoices = profileChoices.sort((a, b) => a.title.localeCompare(b.title));
-  const fzf = new Fzf(profileChoices, {
-    selector: (item) => `${item.title}`,
-    casing: "case-insensitive"
-  });
-  try {
-    const { fn } = await prompts({
-      name: "fn",
-      message: "Choose your git commit:",
-      type: "autocomplete",
-      choices: profileChoices,
-      async suggest(input, choices) {
-        const results = fzf.find(input);
-        return results.map((r) => choices.find((x) => x.value === r.item.title));
-      }
-    });
-    if (!fn) {
-      consola.log(colors.dim("Cancelled!"));
-      process.exit(1);
-    }
-    const entry = suggestions.find((x) => x.subject === fn);
-    if (!entry) {
-      consola.error("No matching commit message found");
-      process.exit(1);
-    }
-    return entry;
-  } catch (ex) {
-    consola.error("Failed to run : exit", ex);
+    consola.error("Failed to commit changes:");
+    consola.error(error);
     process.exit(1);
   }
 }
@@ -391,6 +142,11 @@ function formatDate(date) {
 }
 
 const execAsync = promisify(exec);
+const JOURNAL_TYPES = {
+  DAILY_NOTES: "daily-notes",
+  MEETING: "meeting",
+  NOTE: "note"
+};
 function ensureDirectoryExists(folderPath) {
   if (!existsSync(folderPath)) {
     consola.info(`Creating journal directory: ${colors.cyan(folderPath)}`);
@@ -413,6 +169,44 @@ function createJournalContent({ mondayDate }) {
   content.push(``);
   return content.join("\n");
 }
+function createMeetingContent({ title, date }) {
+  const dateStr = formatDate(date);
+  const timeStr = date.toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit" });
+  const content = [`# Meeting: ${title || "Meeting"}`];
+  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");
+}
+function createNoteContent({ title, date }) {
+  const dateStr = formatDate(date);
+  const timeStr = date.toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit" });
+  const content = [`# ${title || "Note"}`];
+  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");
+}
 async function openInEditor({ editor, filePath }) {
   try {
     await execAsync(`"${editor}" "${filePath}"`);
@@ -420,35 +214,87 @@ 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);
   }
 }
-async function todayCommand(userConfig) {
+function generateJournalFileInfoByType({ date = /* @__PURE__ */ new Date(), type = JOURNAL_TYPES.DAILY_NOTES, title }) {
+  const currentDate = new Date(date);
+  const year = currentDate.getFullYear().toString();
+  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 };
+    }
+    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 };
+    }
+    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 };
+    }
+    default:
+      throw new Error(`Unknown journal type: ${type}`);
+  }
+}
+async function createJournalFile({ userConfig, type, title }) {
   try {
-    const fileInfo = generateJournalFileInfo();
+    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)) {
-      const content = createJournalContent({ mondayDate: fileInfo.mondayDate });
-      writeFileSync(filePath, content, "utf8");
-      consola.info(`Created new journal file: ${colors.cyan(filePath)}`);
+    if (existsSync(filePath)) {
+      consola.info(`Opening existing ${type} file: ${colors.cyan(filePath)}`);
     } else {
-      consola.info(`Opening existing journal file: ${colors.cyan(filePath)}`);
+      let content;
+      switch (type) {
+        case JOURNAL_TYPES.DAILY_NOTES:
+          content = createJournalContent({ mondayDate: fileInfo.mondayDate });
+          break;
+        case JOURNAL_TYPES.MEETING:
+          content = createMeetingContent({ title, date: currentDate });
+          break;
+        case JOURNAL_TYPES.NOTE:
+          content = createNoteContent({ title, date: currentDate });
+          break;
+        default:
+          throw new Error(`Unknown journal type: ${type}`);
+      }
+      writeFileSync(filePath, content, "utf8");
+      consola.info(`Created new ${type} file: ${colors.cyan(filePath)}`);
     }
     await openInEditor({ editor: userConfig.editor, filePath });
   } catch (error) {
-    consola.warn("Error creating journal file:", error);
+    consola.warn(`Error creating ${type} file:`, error);
     process.exit(1);
   }
 }
-function generateJournalFileInfo(date = /* @__PURE__ */ new Date()) {
-  const monday = getMondayOfWeek(new Date(date));
-  const fileName = `${formatDate(monday)}-week.md`;
-  const pathPrefix = [`${date.getFullYear()}`, "journal"];
-  return { pathPrefix, fileName, mondayDate: monday };
-}
 
 const constants = {
   toolName: "towles-tool"
 };
 
+function printJson(obj) {
+  consola.log(util.inspect(obj, {
+    depth: 2,
+    colors: true,
+    showHidden: false,
+    compact: false
+  }));
+}
+function printDebug(message, ...args) {
+  if (process.env.DEBUG) {
+    consola.debug(`DEBUG: ${message}`, ...args);
+  }
+}
+
 function getDefaultUserConfig() {
   return {
     journalDir: path.join(homedir(), "journal"),
@@ -519,11 +365,18 @@ async function main() {
   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);
-  program.command("today").description("Create and open a weekly journal file based on Monday of current week").action(async () => {
-    await todayCommand(config.userConfig);
+  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").alias("gc").description("Git commit command").action(async () => {
-    await gitCommitCommand(config);
+  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..."));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@towles/tool",
   "type": "module",
-  "version": "0.0.11-beta.2",
+  "version": "0.0.11",
   "description": "One off quality of life scripts that I use on a daily basis.",
   "author": "Chris Towles <Chris.Towles.Dev@gmail.com>",
   "license": "MIT",
@@ -47,14 +47,13 @@
     "zod": "^4.0.5"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^4.16.2",
     "@antfu/ni": "^25.0.0",
     "@antfu/utils": "^9.2.0",
     "@types/node": "^22.16.3",
     "@types/prompts": "^2.4.9",
     "bumpp": "^10.2.0",
-    "eslint": "^9.31.0",
     "lint-staged": "^15.5.2",
+    "oxlint": "^1.7.0",
     "simple-git-hooks": "^2.13.0",
     "tinyexec": "^0.3.2",
     "tsx": "^4.20.3",
@@ -69,7 +68,7 @@
     "pre-commit": "pnpm i --frozen-lockfile --ignore-scripts --offline && npx lint-staged"
   },
   "lint-staged": {
-    "*": "eslint --fix"
+    "*": "oxlint --fix"
   },
   "directories": {
     "test": "test"
@@ -77,9 +76,9 @@
   "scripts": {
     "build": "unbuild",
     "dev": "unbuild --stub",
-    "lint": "eslint",
-    "lint:fix": "eslint --fix",
-    "lint:fix_all": "eslint --fix .",
+    "lint": "oxlint",
+    "lint:fix": "oxlint --fix",
+    "lint:fix_all": "oxlint --fix .",
     "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",