gitxplain 0.1.8 → 0.1.9

package/cli/index.js

@@ -3,10 +3,12 @@
 import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
-import { realpathSync } from "node:fs";
+import { readFileSync, realpathSync } from "node:fs";
 import { generateExplanation } from "./services/aiService.js";
+import { clearCache, getCacheStats } from "./services/cacheService.js";
 import { loadEnvFile } from "./services/envLoader.js";
 import { copyToClipboard } from "./services/clipboardService.js";
+import { getUsageStats } from "./services/usageService.js";
 import {
   applyConfigEnvironment,
   getProviderApiKeyField,
@@ -18,7 +20,11 @@ import {
 import {
   buildBranchRange,
   deletePaths,
+  fetchBlameData,
   fetchCommitData,
+  fetchCommitDataForFile,
+  fetchConflictData,
+  fetchStashData,
   fetchWorkingTreeData,
   gitAddFiles,
   gitPull,
@@ -80,6 +86,13 @@ const MODE_FLAGS = new Map([
   ["--lines", "lines"],
   ["--review", "review"],
   ["--security", "security"],
+  ["--refactor", "refactor"],
+  ["--test-suggest", "test-suggest"],
+  ["--pr-description", "pr-description"],
+  ["--changelog", "changelog"],
+  ["--blame", "blame"],
+  ["--conflict", "conflict"],
+  ["--stash", "stash"],
   ["--split", "split"],
   ["--merge", "merge"],
   ["--tag", "tag"],
@@ -96,8 +109,28 @@ const FORMAT_FLAGS = new Map([
   ["--html", "html"]
 ]);
 
+const ANALYSIS_MODES = new Set([
+  "summary",
+  "issues",
+  "fix",
+  "impact",
+  "full",
+  "lines",
+  "review",
+  "security",
+  "refactor",
+  "test-suggest",
+  "pr-description",
+  "changelog",
+  "blame",
+  "conflict",
+  "stash",
+  "split"
+]);
+
 const RESERVED_SUBCOMMANDS = new Set([
   "help",
+  "cache",
   "config",
   "install-hook",
   "git",
@@ -110,11 +143,18 @@ const RESERVED_SUBCOMMANDS = new Set([
   "push"
 ]);
 
+const CLI_VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+
 function printHelp() {
   console.log(`gitxplain - AI-powered Git change analysis, review, and commit workflow CLI
 
 Usage:
   gitxplain --help
+  gitxplain --version
+  gitxplain cache clear
+  gitxplain cache stats
+  gitxplain --cost
+  gitxplain install-hook [post-commit|post-merge|pre-push]
   gitxplain config set provider <name>
   gitxplain config set api-key <value> [--provider <name>]
   gitxplain config get [key]
@@ -127,6 +167,8 @@ Usage:
   gitxplain --release [status]
   gitxplain --merge
   gitxplain --tag
+  gitxplain --conflict
+  gitxplain --stash [stash-ref]
   gitxplain --log
   gitxplain --status
   gitxplain --pipeline
@@ -140,10 +182,19 @@ Analysis:
   --lines         Walk through the changed code file by file
   --review        Generate review findings, risks, and suggestions
   --security      Focus on security-relevant changes and concerns
+  --refactor      Suggest refactoring opportunities in the change
+  --test-suggest  Suggest tests to add or update for the change
+  --pr-description Generate a ready-to-paste PR description
+  --changelog     Generate changelog-style release notes
+  --blame <file>  Analyze ownership and history for one file with git blame
+  --conflict      Suggest resolutions for unresolved merge conflicts in the working tree
+  --stash [ref]   Explain a stash entry, defaulting to stash@{0}
   --split         Propose splitting a commit into smaller atomic commits
+  --cost          Show cumulative token usage and estimated cost totals
   --commit        Propose commits for current uncommitted changes
   --execute       Execute a proposed split or commit plan
   --dry-run       Preview the plan without executing it
+  --interactive   Review or edit a split plan before execution
 
 Release:
   --release [status]  Show release branch health and next recommended action
@@ -153,7 +204,7 @@ Release:
 Repo:
   --log           Print Git log entries for the current repository
   --status        Print Git working tree status for the current repository
-  --pipeline      Detect the current repository stack and create CI/CD workflow files
+  --pipeline      Detect the current repository stack and create GitHub/GitLab/CircleCI/Bitbucket CI files
 
 Quick Actions:
   config          Persist provider, model, and API key settings
@@ -165,7 +216,8 @@ Quick Actions:
   pop             Pop a stash entry like "pop 2"
   pull            Run git pull, optionally with a remote and branch
   push            Run git push, optionally with a remote and branch
-  install-hook    Install the gitxplain hook
+  install-hook    Install a post-commit, post-merge, or pre-push gitxplain hook
+  cache           Manage gitxplain cache entries
   git             Pass through to native git commands
 
 Output:
@@ -178,6 +230,8 @@ Output:
   --verbose
   --clipboard
   --stream
+  --no-cache
+  --diff <file>
   --max-diff-lines <n>
 
 Comparison:
@@ -193,6 +247,7 @@ Notes:
   If no command or mode is supplied, gitxplain prints this help text.
   Use --provider or --model to override your config or environment for one command.
   Use gitxplain git <args...> to run any native Git subcommand with its normal flags.
+  install-hook supports: post-commit, post-merge, pre-push.
 `);
 }
 
@@ -322,6 +377,34 @@ function handleConfigCommand(parsed) {
   throw new Error(`Unknown config subcommand: ${parsed.configAction}`);
 }
 
+function handleCacheCommand(parsed) {
+  if (parsed.cacheAction == null) {
+    throw new Error('Usage: gitxplain cache <clear|stats>');
+  }
+
+  if (parsed.cacheAction === "clear") {
+    const deletedCount = clearCache();
+    console.log(`Cleared ${deletedCount} cache entr${deletedCount === 1 ? "y" : "ies"}.`);
+    return 0;
+  }
+
+  if (parsed.cacheAction === "stats") {
+    const stats = getCacheStats();
+    console.log(
+      [
+        "Cache Stats",
+        `Entries: ${stats.entryCount}`,
+        `Size: ${stats.totalSizeBytes} bytes`,
+        `Oldest: ${stats.oldestEntryIso ?? "n/a"}`,
+        `Newest: ${stats.newestEntryIso ?? "n/a"}`
+      ].join("\n")
+    );
+    return 0;
+  }
+
+  throw new Error(`Unknown cache subcommand: ${parsed.cacheAction}`);
+}
+
 function isDirectNativeGitSubcommand(subcommand, knownGitSubcommands) {
   if (!subcommand || subcommand.startsWith("-")) {
     return false;
@@ -339,7 +422,7 @@ export function parseArgs(argv, options = {}) {
   const subcommand = args[0];
   const knownGitSubcommands = options.gitSubcommands ?? listGitSubcommands();
   const flags = new Set(args.filter((arg) => arg.startsWith("--")));
-  const valueFlags = new Set(["--provider", "--model", "--max-diff-lines", "--branch", "--pr"]);
+  const valueFlags = new Set(["--provider", "--model", "--max-diff-lines", "--branch", "--pr", "--blame", "--stash", "--diff"]);
   const positional = [];
 
   for (let index = 0; index < args.length; index += 1) {
@@ -366,6 +449,7 @@ export function parseArgs(argv, options = {}) {
   const explicitFormat = [...FORMAT_FLAGS.entries()].find(([flag]) => flags.has(flag))?.[1] ?? null;
   const isInstallHook = subcommand === "install-hook";
   const isConfigCommand = subcommand === "config";
+  const isCacheCommand = subcommand === "cache";
   const isNativeGitWrapper = subcommand === "git";
   const isReleaseCommand = flags.has("--release");
   const isAddCommand = subcommand === "add";
@@ -382,17 +466,16 @@ export function parseArgs(argv, options = {}) {
   return {
     subcommand,
     help: flags.has("--help") || subcommand === "help",
+    version: flags.has("--version"),
+    cost: flags.has("--cost"),
     nativeGitCommand: isNativeGitCommand,
     installHook: isInstallHook,
     configCommand: isConfigCommand,
+    cacheCommand: isCacheCommand,
     configAction: isConfigCommand ? positional[1] ?? null : null,
     configKey: isConfigCommand ? positional[2] ?? null : null,
     configValue: isConfigCommand ? positional.slice(3).join(" ") || null : null,
-    logCommand: false,
-    statusCommand: false,
-    commitCommand: false,
-    mergeCommand: false,
-    tagCommand: false,
+    cacheAction: isCacheCommand ? positional[1] ?? null : null,
     releaseCommand: isReleaseCommand,
     releaseAction: isReleaseCommand ? positional[0] ?? "status" : null,
     addCommand: isAddCommand,
@@ -416,6 +499,7 @@ export function parseArgs(argv, options = {}) {
     commitRef:
       isInstallHook ||
       isConfigCommand ||
+      isCacheCommand ||
       isNativeGitCommand ||
       isReleaseCommand ||
       isAddCommand ||
@@ -434,16 +518,21 @@ export function parseArgs(argv, options = {}) {
     provider: getFlagValue(args, "--provider"),
     model: getFlagValue(args, "--model"),
     maxDiffLines: parseNumber(getFlagValue(args, "--max-diff-lines")),
+    blameFile: getFlagValue(args, "--blame"),
+    stashRef: flags.has("--stash") || args.some((arg) => arg.startsWith("--stash=")) ? getFlagValue(args, "--stash") : null,
+    diffFile: getFlagValue(args, "--diff"),
     hasBranchFlag: flags.has("--branch") || args.some((arg) => arg.startsWith("--branch=")),
     branchBase: getFlagValue(args, "--branch"),
     hasPrFlag: flags.has("--pr") || args.some((arg) => arg.startsWith("--pr=")),
     prBase: getFlagValue(args, "--pr"),
     clipboard: flags.has("--clipboard"),
     stream: flags.has("--stream"),
+    noCache: flags.has("--no-cache"),
     verbose: flags.has("--verbose"),
     quiet: flags.has("--quiet"),
     execute: flags.has("--execute"),
     dryRun: flags.has("--dry-run"),
+    interactive: flags.has("--interactive"),
     release: flags.has("--release"),
     log: flags.has("--log"),
     status: flags.has("--status"),
@@ -464,62 +553,86 @@ function askQuestion(prompt) {
   });
 }
 
-async function chooseModeInteractively() {
-  const answer = await askQuestion(
-    [
-      "What do you want to know?",
-      "1. Summary",
-      "2. Issues Fixed",
-      "3. Fix Explanation",
-      "4. Impact",
-      "5. Full Analysis",
-      "6. Line-by-Line Code Walkthrough",
-      "7. Code Review",
-      "8. Security Review",
-      "9. Split Commit",
-      "10. Merge To Release Branch",
-      "11. Tag Release Commits",
-      "12. Repository Log",
-      "13. Commit Working Tree",
-      "14. Create CI/CD Pipelines",
-      "> "
-    ].join("\n")
-  );
-
-  const selections = {
-    "1": "summary",
-    "2": "issues",
-    "3": "fix",
-    "4": "impact",
-    "5": "full",
-    "6": "lines",
-    "7": "review",
-    "8": "security",
-    "9": "split",
-    "10": "merge",
-    "11": "tag",
-    "12": "log",
-    "13": "commit",
-    "14": "pipeline"
-  };
-
-  return selections[answer] ?? "full";
+function resolveConfiguredAnalysisMode(config) {
+  return ANALYSIS_MODES.has(config.mode) ? config.mode : "full";
 }
 
 function resolveRuntimeOptions(parsed, config) {
   return {
-    mode: parsed.mode ?? config.mode ?? "full",
+    mode: parsed.mode ?? resolveConfiguredAnalysisMode(config),
     format: parsed.format ?? config.format ?? "plain",
     provider: parsed.provider ?? config.provider ?? null,
     model: parsed.model ?? config.model ?? null,
     maxDiffLines: parsed.maxDiffLines ?? config.maxDiffLines ?? 800,
     clipboard: parsed.clipboard || config.clipboard === true,
     stream: parsed.stream || config.stream === true,
+    noCache: parsed.noCache,
     verbose: parsed.verbose || config.verbose === true,
     quiet: parsed.quiet || config.quiet === true
   };
 }
 
+function formatUsageStats(stats) {
+  return [
+    "Usage Stats",
+    `Requests: ${stats.requestCount}`,
+    `Input Tokens: ${stats.inputTokens}`,
+    `Output Tokens: ${stats.outputTokens}`,
+    `Total Tokens: ${stats.totalTokens}`,
+    `Estimated Cost: $${stats.estimatedCostUsd.toFixed(6)}`
+  ].join("\n");
+}
+
+async function reviewSplitPlanInteractively(plan) {
+  const editedCommits = [];
+  const deferredFiles = [];
+
+  for (const commit of [...plan.commits].sort((left, right) => left.order - right.order)) {
+    console.log("");
+    console.log(`${commit.order}. ${commit.message}`);
+    console.log(`Files: ${commit.files.join(", ")}`);
+    console.log(`Why: ${commit.description}`);
+
+    const action = (await askQuestion('Action [keep/edit/skip/abort] > ')).trim().toLowerCase();
+
+    if (action === "abort") {
+      return null;
+    }
+
+    if (action === "skip") {
+      deferredFiles.push(...commit.files);
+      continue;
+    }
+
+    if (action === "edit") {
+      const nextMessage = await askQuestion("New commit message (leave blank to keep current) > ");
+      const nextDescription = await askQuestion("New description (leave blank to keep current) > ");
+      editedCommits.push({
+        ...commit,
+        message: nextMessage.trim() === "" ? commit.message : nextMessage.trim(),
+        description: nextDescription.trim() === "" ? commit.description : nextDescription.trim()
+      });
+      continue;
+    }
+
+    editedCommits.push(commit);
+  }
+
+  if (deferredFiles.length > 0) {
+    editedCommits.push({
+      order: editedCommits.length + 1,
+      message: "chore: include deferred split changes",
+      files: deferredFiles,
+      description: "Captures split groups that were skipped during interactive review."
+    });
+  }
+
+  return {
+    ...plan,
+    commits: editedCommits.map((commit, index) => ({ ...commit, order: index + 1 }))
+  };
+}
+
 function resolveTargetRef(parsed, cwd) {
   if (parsed.commitRef) {
     return parsed.commitRef;
@@ -556,6 +669,36 @@ function renderFinalOutput({ runtimeOptions, mode, commitData, explanation, resp
   });
 }
 
+async function runPipelineCommand(cwd) {
+  const analysis = inspectRepositoryForPipeline(cwd);
+
+  if (!analysis.supported) {
+    console.log(analysis.reason);
+    return 1;
+  }
+
+  console.log(formatPipelineRecommendations(analysis));
+
+  const answer = await askQuestion(
+    `\nChoose a pipeline option (1-${analysis.options.length}) or type "cancel" > `
+  );
+  const selection = resolvePipelineSelection(analysis, answer);
+
+  if (!selection) {
+    console.log("Aborted.");
+    return 0;
+  }
+
+  const { writtenFiles, notes } = writePipelineFiles(cwd, analysis, selection);
+  console.log(`\nCreated workflow files: ${writtenFiles.join(", ")}`);
+
+  if (notes.length > 0) {
+    console.log(`\n${notes.join("\n")}`);
+  }
+
+  return 0;
+}
+
 export async function main(argv = process.argv) {
   const cwd = process.cwd();
   const parsed = parseArgs(argv);
@@ -565,6 +708,16 @@ export async function main(argv = process.argv) {
   const config = loadConfig(cwd);
   applyConfigEnvironment(config);
 
+  if (parsed.version) {
+    console.log(CLI_VERSION);
+    return 0;
+  }
+
+  if (parsed.cost) {
+    console.log(formatUsageStats(getUsageStats()));
+    return 0;
+  }
+
   if (parsed.help || hasNoCommandOrFlags) {
     printHelp();
     return 0;
@@ -574,6 +727,10 @@ export async function main(argv = process.argv) {
     return handleConfigCommand(parsed);
   }
 
+  if (parsed.cacheCommand) {
+    return handleCacheCommand(parsed);
+  }
+
   if (parsed.nativeGitCommand) {
     return runNativeGitPassthrough(parsed.nativeGitArgs, cwd);
   }
@@ -608,36 +765,6 @@ export async function main(argv = process.argv) {
     return 0;
   }
 
-  if (parsed.pipelineCommand) {
-    const analysis = inspectRepositoryForPipeline(cwd);
-
-    if (!analysis.supported) {
-      console.log(analysis.reason);
-      return 1;
-    }
-
-    console.log(formatPipelineRecommendations(analysis));
-
-    const answer = await askQuestion(
-      `\nChoose a pipeline option (1-${analysis.options.length}) or type "cancel" > `
-    );
-    const selection = resolvePipelineSelection(analysis, answer);
-
-    if (!selection) {
-      console.log("Aborted.");
-      return 0;
-    }
-
-    const { writtenFiles, notes } = writePipelineFiles(cwd, analysis, selection);
-    console.log(`\nCreated workflow files: ${writtenFiles.join(", ")}`);
-
-    if (notes.length > 0) {
-      console.log(`\n${notes.join("\n")}`);
-    }
-
-    return 0;
-  }
-
   if (
     parsed.addCommand ||
     parsed.removeCommand ||
@@ -706,39 +833,9 @@ export async function main(argv = process.argv) {
   }
 
   const runtimeOptions = resolveRuntimeOptions(parsed, config);
-  const mode = parsed.mode ?? config.mode ?? (await chooseModeInteractively());
-
-  if (mode === "pipeline") {
-    const analysis = inspectRepositoryForPipeline(cwd);
-
-    if (!analysis.supported) {
-      console.log(analysis.reason);
-      return 1;
-    }
-
-    console.log(formatPipelineRecommendations(analysis));
-
-    const answer = await askQuestion(
-      `\nChoose a pipeline option (1-${analysis.options.length}) or type "cancel" > `
-    );
-    const selection = resolvePipelineSelection(analysis, answer);
-
-    if (!selection) {
-      console.log("Aborted.");
-      return 0;
-    }
-
-    const { writtenFiles, notes } = writePipelineFiles(cwd, analysis, selection);
-    console.log(`\nCreated workflow files: ${writtenFiles.join(", ")}`);
-
-    if (notes.length > 0) {
-      console.log(`\n${notes.join("\n")}`);
-    }
+  const mode = ANALYSIS_MODES.has(parsed.mode) ? parsed.mode : resolveConfiguredAnalysisMode(config);
 
-    return 0;
-  }
-
-  if (mode === "commit") {
+  if (parsed.mode === "commit") {
     const commitData = fetchWorkingTreeData(cwd);
 
     if (commitData.filesChanged.length === 0 || commitData.diff === "") {
@@ -752,6 +849,7 @@ export async function main(argv = process.argv) {
       providerOverride: runtimeOptions.provider,
       modelOverride: runtimeOptions.model,
       maxDiffLines: runtimeOptions.maxDiffLines,
+      noCache: runtimeOptions.noCache,
       stream: false,
       onChunk: null,
       onStart: null
@@ -788,7 +886,7 @@ export async function main(argv = process.argv) {
     return 0;
   }
 
-  if (mode === "merge" || parsed.merge) {
+  if (parsed.mode === "merge" || parsed.merge) {
     if (parsed.commitRef) {
       throw new Error("--merge works from the current branch and does not accept a commit ref.");
     }
@@ -820,7 +918,7 @@ export async function main(argv = process.argv) {
     return 0;
   }
 
-  if (mode === "tag" || parsed.tag) {
+  if (parsed.mode === "tag" || parsed.tag) {
     if (parsed.commitRef) {
       throw new Error("--tag works from the current branch and does not accept a commit ref.");
     }
@@ -854,12 +952,210 @@ export async function main(argv = process.argv) {
 
   const targetRef = resolveTargetRef(parsed, cwd);
 
+  if (parsed.mode === "blame") {
+    if (!parsed.blameFile) {
+      throw new Error("--blame requires a file path.");
+    }
+
+    const commitData = fetchBlameData(parsed.blameFile, cwd);
+    const canStream = runtimeOptions.stream && runtimeOptions.format === "plain";
+    let streamStarted = false;
+
+    if (runtimeOptions.stream && !canStream && !runtimeOptions.quiet) {
+      console.error(`Streaming is only supported with plain output. Ignoring --stream for ${runtimeOptions.format} format.`);
+    }
+
+    const { explanation, responseMeta, promptMeta } = await generateExplanation({
+      mode: "blame",
+      commitData,
+      providerOverride: runtimeOptions.provider,
+      modelOverride: runtimeOptions.model,
+      maxDiffLines: runtimeOptions.maxDiffLines,
+      noCache: runtimeOptions.noCache,
+      stream: canStream,
+      onStart: canStream
+        ? ({ promptMeta: streamPromptMeta }) => {
+            if (!runtimeOptions.quiet && !streamStarted) {
+              process.stdout.write(
+                formatPreamble({
+                  mode: "blame",
+                  commitData,
+                  responseMeta: null,
+                  promptMeta: streamPromptMeta,
+                  options: runtimeOptions
+                })
+              );
+              streamStarted = true;
+            }
+          }
+        : null,
+      onChunk: canStream ? (chunk) => process.stdout.write(chunk) : null
+    });
+
+    const renderedOutput = renderFinalOutput({
+      runtimeOptions,
+      mode: "blame",
+      commitData,
+      explanation,
+      responseMeta,
+      promptMeta
+    });
+
+    if (canStream) {
+      process.stdout.write("\n");
+      if (runtimeOptions.verbose) {
+        process.stdout.write(formatFooter({ responseMeta, promptMeta, options: runtimeOptions }));
+      }
+    } else {
+      console.log(renderedOutput);
+    }
+
+    if (runtimeOptions.clipboard) {
+      copyToClipboard(renderedOutput);
+      if (!runtimeOptions.quiet) {
+        console.error("Copied output to clipboard.");
+      }
+    }
+
+    return 0;
+  }
+
+  if (parsed.mode === "conflict") {
+    const commitData = fetchConflictData(cwd, parsed.diffFile);
+    const canStream = runtimeOptions.stream && runtimeOptions.format === "plain";
+    let streamStarted = false;
+
+    if (runtimeOptions.stream && !canStream && !runtimeOptions.quiet) {
+      console.error(`Streaming is only supported with plain output. Ignoring --stream for ${runtimeOptions.format} format.`);
+    }
+
+    const { explanation, responseMeta, promptMeta } = await generateExplanation({
+      mode: "conflict",
+      commitData,
+      providerOverride: runtimeOptions.provider,
+      modelOverride: runtimeOptions.model,
+      maxDiffLines: runtimeOptions.maxDiffLines,
+      noCache: runtimeOptions.noCache,
+      stream: canStream,
+      onStart: canStream
+        ? ({ promptMeta: streamPromptMeta }) => {
+            if (!runtimeOptions.quiet && !streamStarted) {
+              process.stdout.write(
+                formatPreamble({
+                  mode: "conflict",
+                  commitData,
+                  responseMeta: null,
+                  promptMeta: streamPromptMeta,
+                  options: runtimeOptions
+                })
+              );
+              streamStarted = true;
+            }
+          }
+        : null,
+      onChunk: canStream ? (chunk) => process.stdout.write(chunk) : null
+    });
+
+    const renderedOutput = renderFinalOutput({
+      runtimeOptions,
+      mode: "conflict",
+      commitData,
+      explanation,
+      responseMeta,
+      promptMeta
+    });
+
+    if (canStream) {
+      process.stdout.write("\n");
+      if (runtimeOptions.verbose) {
+        process.stdout.write(formatFooter({ responseMeta, promptMeta, options: runtimeOptions }));
+      }
+    } else {
+      console.log(renderedOutput);
+    }
+
+    if (runtimeOptions.clipboard) {
+      copyToClipboard(renderedOutput);
+      if (!runtimeOptions.quiet) {
+        console.error("Copied output to clipboard.");
+      }
+    }
+
+    return 0;
+  }
+
+  if (parsed.mode === "stash") {
+    const commitData = fetchStashData(parsed.stashRef, cwd, parsed.diffFile);
+    const canStream = runtimeOptions.stream && runtimeOptions.format === "plain";
+    let streamStarted = false;
+
+    if (runtimeOptions.stream && !canStream && !runtimeOptions.quiet) {
+      console.error(`Streaming is only supported with plain output. Ignoring --stream for ${runtimeOptions.format} format.`);
+    }
+
+    const { explanation, responseMeta, promptMeta } = await generateExplanation({
+      mode: "stash",
+      commitData,
+      providerOverride: runtimeOptions.provider,
+      modelOverride: runtimeOptions.model,
+      maxDiffLines: runtimeOptions.maxDiffLines,
+      noCache: runtimeOptions.noCache,
+      stream: canStream,
+      onStart: canStream
+        ? ({ promptMeta: streamPromptMeta }) => {
+            if (!runtimeOptions.quiet && !streamStarted) {
+              process.stdout.write(
+                formatPreamble({
+                  mode: "stash",
+                  commitData,
+                  responseMeta: null,
+                  promptMeta: streamPromptMeta,
+                  options: runtimeOptions
+                })
+              );
+              streamStarted = true;
+            }
+          }
+        : null,
+      onChunk: canStream ? (chunk) => process.stdout.write(chunk) : null
+    });
+
+    const renderedOutput = renderFinalOutput({
+      runtimeOptions,
+      mode: "stash",
+      commitData,
+      explanation,
+      responseMeta,
+      promptMeta
+    });
+
+    if (canStream) {
+      process.stdout.write("\n");
+      if (runtimeOptions.verbose) {
+        process.stdout.write(formatFooter({ responseMeta, promptMeta, options: runtimeOptions }));
+      }
+    } else {
+      console.log(renderedOutput);
+    }
+
+    if (runtimeOptions.clipboard) {
+      copyToClipboard(renderedOutput);
+      if (!runtimeOptions.quiet) {
+        console.error("Copied output to clipboard.");
+      }
+    }
+
+    return 0;
+  }
+
   if (!targetRef) {
     printHelp();
     return 1;
   }
 
-  const commitData = fetchCommitData(targetRef, cwd);
+  const commitData = parsed.diffFile
+    ? fetchCommitDataForFile(targetRef, parsed.diffFile, cwd)
+    : fetchCommitData(targetRef, cwd);
 
   if (mode === "split") {
     if (commitData.analysisType !== "commit") {
@@ -872,6 +1168,7 @@ export async function main(argv = process.argv) {
       providerOverride: runtimeOptions.provider,
       modelOverride: runtimeOptions.model,
       maxDiffLines: runtimeOptions.maxDiffLines,
+      noCache: runtimeOptions.noCache,
       stream: false,
       onChunk: null,
       onStart: null
@@ -887,6 +1184,17 @@ export async function main(argv = process.argv) {
     console.log(formatSplitPlan(plan));
 
     if (parsed.execute && !parsed.dryRun) {
+      const reviewedPlan = parsed.interactive ? await reviewSplitPlanInteractively(plan) : plan;
+      if (reviewedPlan == null) {
+        console.log("Aborted.");
+        return 0;
+      }
+
+      if (parsed.interactive) {
+        console.log("");
+        console.log(formatSplitPlan(reviewedPlan));
+      }
+
       validateSplitExecutionTarget(commitData.commitId, cwd);
       const confirmed = await askQuestion(
         "\nThis will rewrite git history. Continue? (yes/no) > "
@@ -896,8 +1204,8 @@ export async function main(argv = process.argv) {
         return 0;
       }
 
-      executeSplit(plan, commitData.commitId, cwd);
-      console.log(`\nSplit complete. Created ${plan.commits.length} commits.`);
+      executeSplit(reviewedPlan, commitData.commitId, cwd);
+      console.log(`\nSplit complete. Created ${reviewedPlan.commits.length} commits.`);
     } else {
       console.log("\nThis is a preview. Run with --execute to apply the split.");
     }
@@ -912,12 +1220,17 @@ export async function main(argv = process.argv) {
   const canStream = runtimeOptions.stream && runtimeOptions.format === "plain";
   let streamStarted = false;
 
+  if (runtimeOptions.stream && !canStream && !runtimeOptions.quiet) {
+    console.error(`Streaming is only supported with plain output. Ignoring --stream for ${runtimeOptions.format} format.`);
+  }
+
   const { explanation, responseMeta, promptMeta } = await generateExplanation({
     mode,
     commitData,
     providerOverride: runtimeOptions.provider,
     modelOverride: runtimeOptions.model,
     maxDiffLines: runtimeOptions.maxDiffLines,
+    noCache: runtimeOptions.noCache,
     stream: canStream,
     onStart: canStream
       ? ({ promptMeta: streamPromptMeta }) => {