@towles/tool 0.0.7 → 0.0.11-beta.2

package/README.md

@@ -9,8 +9,8 @@
 One off quality of life scripts that I use on a daily basis.
 
 ## Tools to add
-- [ ] 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.
-- [ ] git commit with message prompt
+- [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.
+- [ ] use claude code to generate git commits with multiple options for the commit message.
 
 ## Install from repository
 
@@ -22,7 +22,6 @@ tt
 
 # or
 towles-tool
-
 ```
 
 ## Unisntall
@@ -41,9 +40,14 @@ pnpm tt
 if that works, then you need to add the pnpm global bin directory to your PATH.
 
 ## packages to consider
-
+- [@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
+- [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.
 
 ## Document verbose and debug options
 

package/dist/index.mjs

@@ -3,16 +3,363 @@ import process from 'node:process';
 import { Command } from 'commander';
 import consola from 'consola';
 import { colors } from 'consola/utils';
-import { exec } from 'node:child_process';
+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.7";
+const version = "0.0.11-beta.2";
+
+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;
+}
+
+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;
+  }
+  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"));
+  }
+  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;
+  }
+  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)
+      );
+    }
+  }
+  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);
+  }
+  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"
+            )
+          );
+        }
+      }
+      return ok(parsed.value);
+    }
+    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);
+  }
+  const choosenSuggestion = await promptUserForCommitMessage(suggestions.value);
+  const commandWithArgs = `git commit -m "${choosenSuggestion.subject}"`;
+  consola.info(`Running command: ${colors.bgCyan(commandWithArgs)}`);
+  try {
+    execCommand(commandWithArgs, config.cwd);
+  } 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);
+    process.exit(1);
+  }
+}
 
 function getMondayOfWeek(date) {
   const newDate = new Date(date);
@@ -66,18 +413,18 @@ function createJournalContent({ mondayDate }) {
   content.push(``);
   return content.join("\n");
 }
-async function openInEditor(filePath, config) {
+async function openInEditor({ editor, filePath }) {
   try {
-    await execAsync(`"${config.editor}" "${filePath}"`);
+    await execAsync(`"${editor}" "${filePath}"`);
   } catch (ex) {
-    consola.warn(`Could not open in editor : '${config.editor}'. Modify your editor in the config: examples include 'code', 'code-insiders',  etc...`, ex);
+    consola.warn(`Could not open in editor : '${editor}'. Modify your editor in the config: examples include 'code', 'code-insiders',  etc...`, ex);
   }
 }
-async function todayCommand(config) {
+async function todayCommand(userConfig) {
   try {
     const fileInfo = generateJournalFileInfo();
-    const filePath = path__default.join(config.journalDir, ...fileInfo.pathPrefix, fileInfo.fileName);
-    ensureDirectoryExists(path__default.join(config.journalDir, ...fileInfo.pathPrefix));
+    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");
@@ -85,9 +432,9 @@ async function todayCommand(config) {
     } else {
       consola.info(`Opening existing journal file: ${colors.cyan(filePath)}`);
     }
-    await openInEditor(filePath, config);
+    await openInEditor({ editor: userConfig.editor, filePath });
   } catch (error) {
-    consola.error("Error creating journal file:", error);
+    consola.warn("Error creating journal file:", error);
     process.exit(1);
   }
 }
@@ -102,25 +449,10 @@ 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.log(`DEBUG: ${message}`, ...args);
-  }
-}
-
-function getDefaultConfig() {
+function getDefaultUserConfig() {
   return {
     journalDir: path.join(homedir(), "journal"),
-    editor: "code",
-    debug: false
+    editor: "code"
   };
 }
 async function loadTowlesToolConfig({
@@ -128,7 +460,7 @@ async function loadTowlesToolConfig({
   overrides
 }) {
   await setupDotenv({ cwd });
-  const defaults = getDefaultConfig();
+  const defaults = getDefaultUserConfig();
   const defaultConfigFolder = path.join(homedir(), ".config", constants.toolName);
   const updateResult = await updateConfig({
     cwd: defaultConfigFolder,
@@ -151,11 +483,10 @@ async function loadTowlesToolConfig({
 // cwd: null means it will use the current working directory
 export default  ${JSON.stringify(defaults, null, 2)};
 `;
+    },
+    async onUpdate(config) {
+      return config;
     }
-    // async onUpdate(config) {
-    //   consola.info(`Configuration updated in ${colors.cyan(path.relative('.', configFile))}`)
-    //   return config
-    // },
   }).catch((error) => {
     consola.error(`Failed to update config: ${error.message}`);
     return null;
@@ -164,7 +495,7 @@ export default  ${JSON.stringify(defaults, null, 2)};
     consola.error(`Failed to load or update config. Please check your configuration.`);
     process.exit(1);
   }
-  const { config, configFile } = await loadConfig({
+  const { config: userConfig, configFile } = await loadConfig({
     cwd: cwd || defaultConfigFolder,
     configFile: updateResult.configFile,
     name: constants.toolName,
@@ -176,28 +507,28 @@ export default  ${JSON.stringify(defaults, null, 2)};
     }
   });
   printDebug(`Using config from: ${colors.cyan(configFile)}`);
-  return await resolveTowlesToolConfig(config, configFile, cwd);
-}
-async function resolveTowlesToolConfig(config, configFile, cwd) {
   return {
     configFile,
-    config,
-    cwd
+    cwd,
+    userConfig
   };
 }
 
 async function main() {
   const consola$1 = consola.withTag(constants.toolName);
-  const configWrapper = await loadTowlesToolConfig({ cwd: process.cwd() });
+  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(configWrapper.config);
+    await todayCommand(config.userConfig);
+  });
+  program.command("git-commit").alias("gc").description("Git commit command").action(async () => {
+    await gitCommitCommand(config);
   });
   program.command("config").description("set or show configuration file.").action(async () => {
     consola$1.log(colors.green("Showing configuration..."));
-    consola$1.log("Config File:", configWrapper.configFile);
-    printJson(configWrapper.config);
+    consola$1.log("Settings File:", config.configFile);
+    printJson(config);
   });
   program.parse();
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@towles/tool",
   "type": "module",
-  "version": "0.0.7",
+  "version": "0.0.11-beta.2",
   "description": "One off quality of life scripts that I use on a daily basis.",
   "author": "Chris Towles <Chris.Towles.Dev@gmail.com>",
   "license": "MIT",
@@ -33,28 +33,37 @@
     "dist"
   ],
   "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"
+    "consola": "^3.4.2",
+    "fzf": "^0.5.2",
+    "magicast": "^0.3.5",
+    "neverthrow": "^8.2.0",
+    "prompts": "^2.4.2",
+    "zod": "^4.0.5"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^4.10.1",
-    "@antfu/ni": "^24.1.0",
-    "@antfu/utils": "^9.1.0",
-    "@types/node": "^22.13.10",
-    "bumpp": "^10.1.0",
-    "eslint": "^9.22.0",
-    "lint-staged": "^15.5.0",
-    "magicast": "^0.3.5",
-    "simple-git-hooks": "^2.11.1",
+    "@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",
+    "simple-git-hooks": "^2.13.0",
     "tinyexec": "^0.3.2",
-    "tsx": "^4.19.3",
-    "typescript": "^5.8.2",
+    "tsx": "^4.20.3",
+    "typescript": "^5.8.3",
     "unbuild": "^3.5.0",
-    "vite": "^6.2.1",
-    "vitest": "^3.0.8",
+    "vite": "^6.3.5",
+    "vitest": "^3.2.4",
     "vitest-package-exports": "^0.1.1",
-    "yaml": "^2.7.0"
+    "yaml": "^2.8.0"
   },
   "simple-git-hooks": {
     "pre-commit": "pnpm i --frozen-lockfile --ignore-scripts --offline && npx lint-staged"
@@ -69,6 +78,8 @@
     "build": "unbuild",
     "dev": "unbuild --stub",
     "lint": "eslint",
+    "lint:fix": "eslint --fix",
+    "lint:fix_all": "eslint --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",