@butlerw/vellum 0.1.0

package/src/commands/batch/executor.ts

@@ -0,0 +1,361 @@
+/**
+ * Batch Executor (T-048)
+ *
+ * Executes multiple commands in sequence from a batch script.
+ * Supports continue-on-error option for resilient batch processing.
+ *
+ * @module cli/commands/batch/executor
+ */
+
+import type { CommandExecutor } from "../executor.js";
+import type { CommandResult } from "../types.js";
+
+// =============================================================================
+// Interfaces
+// =============================================================================
+
+/**
+ * Configuration for batch execution
+ */
+export interface BatchConfig {
+  /** Continue executing remaining commands if one fails */
+  continueOnError?: boolean;
+  /** Abort signal for cancellation */
+  signal?: AbortSignal;
+  /** Callback invoked before each command */
+  onBeforeCommand?: (command: string, index: number) => void;
+  /** Callback invoked after each command */
+  onAfterCommand?: (command: string, index: number, result: CommandResult) => void;
+  /** Skip empty lines and comments (lines starting with #) */
+  skipComments?: boolean;
+}
+
+/**
+ * Result of a single command in batch execution
+ */
+export interface BatchCommandResult {
+  /** Original command string */
+  command: string;
+  /** Command index in batch (0-based) */
+  index: number;
+  /** Execution result */
+  result: CommandResult;
+  /** Whether command was skipped (comment or empty) */
+  skipped: boolean;
+}
+
+/**
+ * Result of batch execution
+ */
+export interface BatchResult {
+  /** Results for each command */
+  commands: BatchCommandResult[];
+  /** Total commands processed */
+  total: number;
+  /** Number of successful commands */
+  succeeded: number;
+  /** Number of failed commands */
+  failed: number;
+  /** Number of skipped commands */
+  skipped: number;
+  /** Whether batch completed (not aborted early) */
+  completed: boolean;
+  /** Error that caused early abort (if any) */
+  abortError?: Error;
+}
+
+/**
+ * Result of batch script validation
+ */
+export interface BatchValidationResult {
+  /** Whether script is valid */
+  valid: boolean;
+  /** Number of commands found */
+  commandCount: number;
+  /** Validation warnings */
+  warnings: string[];
+}
+
+// =============================================================================
+// Batch Script Parser
+// =============================================================================
+
+/**
+ * Parses batch scripts into individual commands
+ *
+ * Handles:
+ * - Newline-separated commands
+ * - Comment lines (starting with #)
+ * - Empty lines
+ * - Leading/trailing whitespace
+ */
+// biome-ignore lint/complexity/noStaticOnlyClass: Parser provides a logical grouping for batch parsing functionality
+export class BatchScriptParser {
+  /**
+   * Parse a batch script into command lines
+   *
+   * @param script - Batch script content
+   * @param skipComments - Whether to filter out comments and empty lines
+   * @returns Array of command strings
+   */
+  static parse(script: string, skipComments = true): string[] {
+    const lines = script.split(/\r?\n/);
+
+    if (!skipComments) {
+      return lines;
+    }
+
+    const result: string[] = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      // Skip empty lines
+      if (trimmed === "") continue;
+      // Skip comment lines
+      if (trimmed.startsWith("#")) continue;
+      result.push(trimmed);
+    }
+    return result;
+  }
+
+  /**
+   * Check if a line is a comment
+   *
+   * @param line - Line to check
+   * @returns true if line is a comment
+   */
+  static isComment(line: string): boolean {
+    return line.trim().startsWith("#");
+  }
+
+  /**
+   * Check if a line is empty (whitespace only)
+   *
+   * @param line - Line to check
+   * @returns true if line is empty
+   */
+  static isEmpty(line: string): boolean {
+    return line.trim() === "";
+  }
+
+  /**
+   * Validate batch script for common issues
+   *
+   * @param script - Batch script content
+   * @returns Validation result with any warnings
+   */
+  static validate(script: string): BatchValidationResult {
+    const lines = script.split(/\r?\n/);
+    const warnings: string[] = [];
+    let commandCount = 0;
+
+    for (let i = 0; i < lines.length; i++) {
+      const rawLine = lines[i];
+      if (rawLine === undefined) continue;
+      const line = rawLine.trim();
+
+      if (BatchScriptParser.isEmpty(line) || BatchScriptParser.isComment(line)) {
+        continue;
+      }
+
+      commandCount++;
+
+      // Check for common issues
+      if (!line.startsWith("/")) {
+        warnings.push(`Line ${i + 1}: Command should start with /`);
+      }
+    }
+
+    return {
+      valid: commandCount > 0,
+      commandCount,
+      warnings,
+    };
+  }
+}
+
+// =============================================================================
+// Batch Executor
+// =============================================================================
+
+/**
+ * Executes batch scripts with error handling
+ *
+ * @example
+ * ```typescript
+ * const batch = new BatchExecutor(executor);
+ *
+ * const script = `
+ * # Setup commands
+ * /login anthropic
+ * /config set theme dark
+ *
+ * # Main operation
+ * /help
+ * `;
+ *
+ * const result = await batch.execute(script, {
+ *   continueOnError: true,
+ *   onBeforeCommand: (cmd, i) => console.log(`Running ${i + 1}: ${cmd}`),
+ * });
+ *
+ * console.log(`Completed: ${result.succeeded}/${result.total}`);
+ * ```
+ */
+export class BatchExecutor {
+  constructor(private readonly executor: CommandExecutor) {}
+
+  /**
+   * Execute a batch script
+   *
+   * @param script - Batch script content (newline-separated commands)
+   * @param config - Batch execution configuration
+   * @returns Batch execution result
+   */
+  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: Core batch execution logic requires sequential processing
+  async execute(script: string, config: BatchConfig = {}): Promise<BatchResult> {
+    const {
+      continueOnError = false,
+      signal,
+      onBeforeCommand,
+      onAfterCommand,
+      skipComments = true,
+    } = config;
+
+    const lines = script.split(/\r?\n/);
+    const commands: BatchCommandResult[] = [];
+    let completed = true;
+    let abortError: Error | undefined;
+
+    for (let i = 0; i < lines.length; i++) {
+      // Check for abort signal
+      if (signal?.aborted) {
+        completed = false;
+        abortError = new Error("Batch execution aborted");
+        break;
+      }
+
+      const line = lines[i];
+      if (line === undefined) continue;
+      const trimmedLine = line.trim();
+
+      // Handle comments and empty lines
+      if (
+        skipComments &&
+        (BatchScriptParser.isEmpty(trimmedLine) || BatchScriptParser.isComment(trimmedLine))
+      ) {
+        commands.push({
+          command: line,
+          index: i,
+          result: { kind: "success" },
+          skipped: true,
+        });
+        continue;
+      }
+
+      // Execute command
+      onBeforeCommand?.(trimmedLine, i);
+
+      try {
+        const result = await this.executor.execute(trimmedLine, signal);
+
+        commands.push({
+          command: trimmedLine,
+          index: i,
+          result,
+          skipped: false,
+        });
+
+        onAfterCommand?.(trimmedLine, i, result);
+
+        // Check for failure
+        if (result.kind === "error" && !continueOnError) {
+          completed = false;
+          abortError = new Error(`Command failed: ${result.message}`);
+          break;
+        }
+      } catch (error) {
+        const errorResult: CommandResult = {
+          kind: "error",
+          code: "INTERNAL_ERROR",
+          message: error instanceof Error ? error.message : String(error),
+        };
+
+        commands.push({
+          command: trimmedLine,
+          index: i,
+          result: errorResult,
+          skipped: false,
+        });
+
+        onAfterCommand?.(trimmedLine, i, errorResult);
+
+        if (!continueOnError) {
+          completed = false;
+          abortError = error instanceof Error ? error : new Error(String(error));
+          break;
+        }
+      }
+    }
+
+    // Calculate summary
+    const executed = commands.filter((c) => !c.skipped);
+    const succeeded = executed.filter((c) => c.result.kind === "success").length;
+    const failed = executed.filter((c) => c.result.kind === "error").length;
+    const skipped = commands.filter((c) => c.skipped).length;
+
+    return {
+      commands,
+      total: executed.length,
+      succeeded,
+      failed,
+      skipped,
+      completed,
+      abortError,
+    };
+  }
+
+  /**
+   * Execute commands from an array
+   *
+   * @param commands - Array of command strings
+   * @param config - Batch execution configuration
+   * @returns Batch execution result
+   */
+  async executeCommands(commands: string[], config: BatchConfig = {}): Promise<BatchResult> {
+    const script = commands.join("\n");
+    return this.execute(script, { ...config, skipComments: false });
+  }
+}
+
+/**
+ * Create a batch script from an array of commands
+ *
+ * @param commands - Array of command strings
+ * @param options - Script creation options
+ * @returns Formatted batch script
+ */
+export function createBatchScript(
+  commands: string[],
+  options: { header?: string; comments?: Record<number, string> } = {}
+): string {
+  const { header, comments = {} } = options;
+  const lines: string[] = [];
+
+  if (header) {
+    lines.push(`# ${header}`);
+    lines.push("");
+  }
+
+  for (let i = 0; i < commands.length; i++) {
+    const comment = comments[i];
+    const cmd = commands[i];
+    if (comment) {
+      lines.push(`# ${comment}`);
+    }
+    if (cmd !== undefined) {
+      lines.push(cmd);
+    }
+  }
+
+  return lines.join("\n");
+}

package/src/commands/batch/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Batch Module
+ *
+ * Barrel file for batch execution functionality.
+ *
+ * @module cli/commands/batch
+ */
+
+// Re-export command
+export * from "./command.js";
+// Re-export executor components
+export * from "./executor.js";

package/src/commands/commit.ts

@@ -0,0 +1,235 @@
+/**
+ * Commit Command
+ *
+ * Quick Git commit command with optional auto-generated message.
+ * Inspired by Aider's /commit command pattern.
+ *
+ * Usage:
+ * - /commit - Stage all changes and commit with auto-generated message
+ * - /commit "message" - Stage all changes and commit with specified message
+ * - /commit --amend - Amend the last commit
+ *
+ * @module cli/commands/commit
+ */
+
+import { execSync } from "node:child_process";
+import type { CommandContext, CommandResult, SlashCommand } from "./types.js";
+import { error, success } from "./types.js";
+
+// =============================================================================
+// Git Utilities
+// =============================================================================
+
+/**
+ * Execute a git command and return the result.
+ */
+function runGitCommand(command: string, cwd?: string): { success: boolean; output: string } {
+  try {
+    const output = execSync(command, {
+      encoding: "utf-8",
+      cwd: cwd ?? process.cwd(),
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return { success: true, output: output.trim() };
+  } catch (err) {
+    const error = err as { stderr?: string; message?: string };
+    return { success: false, output: error.stderr?.trim() ?? error.message ?? "Unknown error" };
+  }
+}
+
+/**
+ * Check if we're in a git repository.
+ */
+function isGitRepo(): boolean {
+  const result = runGitCommand("git rev-parse --is-inside-work-tree");
+  return result.success && result.output === "true";
+}
+
+/**
+ * Get list of staged files.
+ */
+function getStagedFiles(): string[] {
+  const result = runGitCommand("git diff --cached --name-only");
+  if (!result.success || !result.output) return [];
+  return result.output.split("\n").filter((f) => f.trim().length > 0);
+}
+
+/**
+ * Get list of unstaged/untracked changes.
+ */
+function getUnstagedChanges(): { modified: string[]; untracked: string[] } {
+  const statusResult = runGitCommand("git status --porcelain");
+  if (!statusResult.success) return { modified: [], untracked: [] };
+
+  const modified: string[] = [];
+  const untracked: string[] = [];
+
+  for (const line of statusResult.output.split("\n")) {
+    if (!line.trim()) continue;
+    const status = line.slice(0, 2);
+    const file = line.slice(3);
+
+    if (status.includes("?")) {
+      untracked.push(file);
+    } else if (status[1] !== " " && status[1] !== "?") {
+      modified.push(file);
+    }
+  }
+
+  return { modified, untracked };
+}
+
+/**
+ * Generate a simple commit message from staged changes.
+ */
+function generateCommitMessage(stagedFiles: string[]): string {
+  if (stagedFiles.length === 0) return "Update files";
+  if (stagedFiles.length === 1) {
+    const file = stagedFiles[0];
+    return `Update ${file}`;
+  }
+  // Group by directory or type
+  const extensions = new Set(stagedFiles.map((f) => f.split(".").pop() ?? "file"));
+  if (extensions.size === 1) {
+    const ext = [...extensions][0];
+    return `Update ${stagedFiles.length} ${ext} files`;
+  }
+  return `Update ${stagedFiles.length} files`;
+}
+
+// =============================================================================
+// Command Definition
+// =============================================================================
+
+/**
+ * /commit command - Quick git commit with optional message.
+ *
+ * Stages all changes and commits. If no message is provided,
+ * generates a simple descriptive message based on changed files.
+ */
+export const commitCommand: SlashCommand = {
+  name: "commit",
+  description: "Stage and commit all changes with optional message",
+  kind: "builtin",
+  category: "tools",
+  aliases: ["ci"],
+  positionalArgs: [
+    {
+      name: "message",
+      type: "string",
+      description: "Commit message (auto-generated if omitted)",
+      required: false,
+    },
+  ],
+  namedArgs: [
+    {
+      name: "amend",
+      shorthand: "a",
+      type: "boolean",
+      description: "Amend the last commit",
+      required: false,
+      default: false,
+    },
+    {
+      name: "no-stage",
+      shorthand: "n",
+      type: "boolean",
+      description: "Skip staging (commit only already staged files)",
+      required: false,
+      default: false,
+    },
+  ],
+  examples: [
+    "/commit                    - Auto-generate message and commit all",
+    '/commit "Fix login bug"    - Commit with specific message',
+    "/commit --amend            - Amend last commit",
+    '/commit --amend "New msg"  - Amend with new message',
+  ],
+
+  execute: async (ctx: CommandContext): Promise<CommandResult> => {
+    // Check if we're in a git repository
+    if (!isGitRepo()) {
+      return error("OPERATION_NOT_ALLOWED", "Not in a git repository", [
+        "Navigate to a git repository first",
+        "Use `git init` to initialize a new repository",
+      ]);
+    }
+
+    const message = ctx.parsedArgs.positional[0] as string | undefined;
+    const amend = ctx.parsedArgs.named["amend"] as boolean | undefined;
+    const noStage = ctx.parsedArgs.named["no-stage"] as boolean | undefined;
+
+    // Stage all changes unless --no-stage is specified
+    if (!noStage) {
+      const stageResult = runGitCommand("git add -A");
+      if (!stageResult.success) {
+        return error("INTERNAL_ERROR", `Failed to stage changes: ${stageResult.output}`);
+      }
+    }
+
+    // Check for staged changes
+    const stagedFiles = getStagedFiles();
+    if (stagedFiles.length === 0 && !amend) {
+      const unstaged = getUnstagedChanges();
+      if (unstaged.modified.length === 0 && unstaged.untracked.length === 0) {
+        return error("OPERATION_NOT_ALLOWED", "Nothing to commit - working tree is clean");
+      }
+      return error("OPERATION_NOT_ALLOWED", "No staged changes to commit", [
+        "Use /commit without --no-stage to auto-stage all changes",
+        "Stage files manually with `git add <file>`",
+      ]);
+    }
+
+    // Generate or use provided message
+    const commitMessage = message ?? generateCommitMessage(stagedFiles);
+
+    // Build commit command
+    let gitCmd = `git commit -m "${commitMessage.replace(/"/g, '\\"')}"`;
+    if (amend) {
+      gitCmd = message
+        ? `git commit --amend -m "${commitMessage.replace(/"/g, '\\"')}"`
+        : "git commit --amend --no-edit";
+    }
+
+    // Execute commit
+    const commitResult = runGitCommand(gitCmd);
+    if (!commitResult.success) {
+      return error("INTERNAL_ERROR", `Commit failed: ${commitResult.output}`);
+    }
+
+    // Get the commit hash
+    const hashResult = runGitCommand("git rev-parse --short HEAD");
+    const commitHash = hashResult.success ? hashResult.output : "unknown";
+
+    // Build success message
+    const lines = [
+      amend ? "📝 Amended commit" : "✅ Committed successfully",
+      "",
+      `  Commit: ${commitHash}`,
+      `  Message: ${commitMessage}`,
+    ];
+
+    if (!amend && stagedFiles.length > 0) {
+      lines.push(`  Files: ${stagedFiles.length} changed`);
+      if (stagedFiles.length <= 5) {
+        for (const file of stagedFiles) {
+          lines.push(`    • ${file}`);
+        }
+      } else {
+        for (const file of stagedFiles.slice(0, 3)) {
+          lines.push(`    • ${file}`);
+        }
+        lines.push(`    • ... and ${stagedFiles.length - 3} more`);
+      }
+    }
+
+    return success(lines.join("\n"), {
+      hash: commitHash,
+      message: commitMessage,
+      files: stagedFiles,
+      amended: amend ?? false,
+    });
+  },
+};
+
+export default commitCommand;