@hifullmoon/aicommit 2.4.1 → 2.6.0

package/src/change-analysis.js

@@ -12,7 +12,7 @@ import {
   isDeepAnalysis,
   isGeneratedFile,
   localOverview,
-  localPlanItems,
+  localPlanBatches,
 } from './local-analysis.js';
 
 function gitQuote(path) {
@@ -230,16 +230,17 @@ const ANALYSIS_SYSTEM =
 export function analysisConfig(config) {
   if (config.analysisBudget) return config;
   const settings = { ...DEFAULT_LARGE_CHANGE, ...config.largeChange };
+  settings.cache = { ...DEFAULT_LARGE_CHANGE.cache, ...config.largeChange?.cache };
   const model = getProviderAdapter(config).model;
-  const output = Math.max(
-    config.maxTokens || 1024,
-    config.reasoning?.mode === 'on' ? config.reasoning.maxTokens || 4096 : 0,
-  );
+  const output =
+    config.reasoning?.mode === 'off'
+      ? config.maxTokens || 1024
+      : Math.max(config.maxTokens || 1024, config.reasoning?.maxTokens || 4096);
   settings.chunkInputTokens = Math.min(
     settings.chunkInputTokens,
     Math.max(256, model.contextWindow - output - 1024),
   );
-  return { ...config, analysisBudget: createAnalysisBudget(settings) };
+  return { ...config, largeChange: settings, analysisBudget: createAnalysisBudget(settings) };
 }
 
 export function packItems(items, maxChars, maxItems = 24) {
@@ -312,7 +313,7 @@ function parseAnalysisJson(raw) {
   throw new SyntaxError('Response contains no complete JSON array.');
 }
 
-async function jsonCall(config, instruction, items, validate = null) {
+async function jsonCall(config, instruction, items, validate = null, stream = null) {
   const parseAndValidate = (raw) => {
     const parsed = parseAnalysisJson(raw);
     validate?.(parsed);
@@ -328,7 +329,7 @@ async function jsonCall(config, instruction, items, validate = null) {
     Math.min(2048, config.maxTokens || 1024),
     'Return the complete requested JSON array, preserving every required input ID exactly once. ' +
       `Required IDs: ${JSON.stringify(items.map((item) => item.id))}`,
-    null,
+    stream,
     (response) => {
       try {
         parseAndValidate(response);
@@ -338,6 +339,7 @@ async function jsonCall(config, instruction, items, validate = null) {
       }
     },
   );
+  stream?.onReasoningComplete?.(result.reasoning);
   try {
     return parseAndValidate(result.text);
   } catch (cause) {
@@ -372,63 +374,201 @@ export function validatePartition(groups, ids) {
     throw fail(ERROR_CATEGORIES.RESPONSE_FORMAT, 'Analysis left input IDs unassigned.');
 }
 
+function fragmentCacheKey(config, input, protect, persistentCache) {
+  return persistentCache
+    ? persistentCache.keyFor('fragment-analysis', input)
+    : createHash('sha256')
+        .update(
+          JSON.stringify({
+            version: 1,
+            input,
+            protect,
+            model: config.modelId,
+            endpoint: config.apiUrl,
+            context: config.repositoryContextText,
+          }),
+        )
+        .digest('hex');
+}
+
+function validateFragmentGroups(candidate, inputIds) {
+  validatePartition(candidate, inputIds);
+  if (candidate.some((group) => group.ids.length !== 1))
+    throw fail(
+      ERROR_CATEGORIES.RESPONSE_FORMAT,
+      'Fragment analysis combined unrelated source IDs.',
+    );
+}
+
+function estimateInitialDeepCost(
+  config,
+  capture,
+  protect,
+  previews,
+  maxBatchTokens,
+  persistentCache,
+) {
+  const batchSizes = [];
+  let batch = [];
+  let batchTokens = 0;
+  let chunks = 0;
+  let cachedChunks = 0;
+  let oversizedInput = false;
+  const fragmentsByFile = new Map();
+  const flush = () => {
+    if (!batch.length) return;
+    chunks++;
+    const inputIds = batch.map((item) => item.id);
+    const cacheKey = fragmentCacheKey(config, batch, protect, persistentCache);
+    const cached =
+      capture.analysisCache?.get(cacheKey) ||
+      persistentCache?.read(cacheKey, inputIds, (candidate) =>
+        validateFragmentGroups(candidate, inputIds),
+      );
+    if (cached) cachedChunks++;
+    else batchSizes.push(batchTokens);
+    batch = [];
+    batchTokens = 0;
+  };
+  for (const unit of capture.units(protect, previews)) {
+    if (unit.metadataOnly) continue;
+    fragmentsByFile.set(unit.fileId, (fragmentsByFile.get(unit.fileId) || 0) + 1);
+    const size = estimateTokens(JSON.stringify(unit));
+    if (size + 768 > config.analysisBudget.limits.chunkInputTokens) oversizedInput = true;
+    if (batch.length && (batchTokens + size > maxBatchTokens || batch.length >= 16)) flush();
+    batch.push(unit);
+    batchTokens += size;
+  }
+  flush();
+  const output = Math.min(2048, config.maxTokens || 1024);
+  let reductionRequests = 0;
+  if (config.analysisTask === 'split') {
+    for (const fragments of fragmentsByFile.values()) {
+      let summaries = fragments;
+      while (summaries * 160 > 2000) {
+        const batches = Math.ceil(summaries / 24);
+        reductionRequests += batches;
+        summaries = batches;
+      }
+    }
+  }
+  let planningRequests = 1;
+  if (config.analysisTask === 'split') {
+    planningRequests = 0;
+    let candidates = Math.max(1, capture.manifest.length);
+    for (let level = 0; level < 8; level++) {
+      const batches = Math.ceil(candidates / (config.splitMaxPlanFiles || 100));
+      planningRequests += batches;
+      if (batches === 1) break;
+      candidates = batches;
+    }
+  }
+  const downstreamRequests = reductionRequests + planningRequests;
+  const downstreamReserve =
+    downstreamRequests * (config.analysisBudget.limits.chunkInputTokens + output);
+  const estimatedTokens =
+    batchSizes.reduce(
+      (total, input) =>
+        total + Math.min(config.analysisBudget.limits.chunkInputTokens, input + 768) + output,
+      0,
+    ) + downstreamReserve;
+  return {
+    chunks,
+    cachedChunks,
+    requestedChunks: batchSizes.length,
+    estimatedTokens,
+    oversizedInput,
+    reductionRequests,
+    planningRequests,
+    downstreamReserve,
+  };
+}
+
 export async function analyzeChanges(
   config,
   capture,
   protect = true,
   previews = null,
   onProgress = null,
+  persistentCache = null,
 ) {
   if (!isDeepAnalysis(config)) return analyzeLocally(config, capture, protect, previews);
   const budget = config.analysisBudget;
+  const maxBatchTokens = Math.min(
+    estimateTokens('x'.repeat(config.maxDiffChars || 30000)),
+    Math.floor(budget.limits.chunkInputTokens * 0.65),
+  );
+  // chunkInputTokens is a token budget, while String#length counts UTF-16 code
+  // units. Track the same conservative UTF-8 estimate used at dispatch time so
+  // ASCII-heavy repositories do not produce roughly twice as many requests and
+  // multibyte input still stays within the configured ceiling.
   const maxChars = Math.min(
     config.maxDiffChars || 30000,
     Math.floor(budget.limits.chunkInputTokens * 0.65),
   );
-  budget.reserveFinal(
-    budget.limits.chunkInputTokens +
-      Math.max(config.maxTokens || 1024, config.reasoning?.maxTokens || 4096),
+  const estimate = estimateInitialDeepCost(
+    config,
+    capture,
+    protect,
+    previews,
+    maxBatchTokens,
+    persistentCache,
   );
+  if (estimate.oversizedInput || estimate.estimatedTokens > budget.limits.maxTotalTokens) {
+    const fallbackConfig = {
+      ...config,
+      largeChange: { ...config.largeChange, strategy: 'auto' },
+    };
+    const local = analyzeLocally(fallbackConfig, capture, protect, previews);
+    local.coverage = {
+      ...local.coverage,
+      degradedFrom: 'deep',
+      fallbackReason: estimate.oversizedInput ? 'preflight_input' : 'preflight_tokens',
+      estimatedDeepChunks: estimate.chunks,
+      estimatedCachedChunks: estimate.cachedChunks,
+      estimatedRequestedChunks: estimate.requestedChunks,
+      estimatedReductionRequests: estimate.reductionRequests,
+      estimatedPlanningRequests: estimate.planningRequests,
+      estimatedDeepTokens: estimate.estimatedTokens,
+    };
+    return local;
+  }
+  budget.reserveFinal(estimate.downstreamReserve);
   const fileFacts = new Map(capture.manifest.map((f) => [f.id, []]));
   let batch = [];
-  let length = 0;
+  let batchTokens = 0;
   let done = 0;
   let analyzed = 0;
+  let cachedChunks = 0;
+  let requestedChunks = 0;
   const pending = [];
   const cache = (capture.analysisCache ||= new Map());
   async function flush() {
     if (!batch.length) return;
     const input = batch;
     batch = [];
-    length = 0;
-    const cacheKey = createHash('sha256')
-      .update(
-        JSON.stringify({
-          version: 1,
-          input,
-          protect,
-          model: config.modelId,
-          endpoint: config.apiUrl,
-          context: config.repositoryContextText,
-        }),
-      )
-      .digest('hex');
+    batchTokens = 0;
+    const cacheKey = fragmentCacheKey(config, input, protect, persistentCache);
     const inputIds = input.map((x) => x.id);
-    const groups =
-      cache.get(cacheKey) ||
-      (await jsonCall(
+    const validateGroups = (candidate) => validateFragmentGroups(candidate, inputIds);
+    let groups = cache.get(cacheKey);
+    let cacheHit = Boolean(groups);
+    if (!groups && persistentCache) {
+      groups = persistentCache.read(cacheKey, inputIds, validateGroups);
+      cacheHit = Boolean(groups);
+    }
+    if (!groups) {
+      groups = await jsonCall(
         config,
         'Return one entry per input ID: [{"ids":["input ID"],"summary":"concise factual changes and uncertainties"}]. Each input ID must appear exactly once. Never combine different IDs. Summaries must be at most 160 characters.',
         input,
-        (candidate) => {
-          validatePartition(candidate, inputIds);
-          if (candidate.some((group) => group.ids.length !== 1))
-            throw fail(
-              ERROR_CATEGORIES.RESPONSE_FORMAT,
-              'Fragment analysis combined unrelated source IDs.',
-            );
-        },
-      ));
+        validateGroups,
+      );
+      requestedChunks++;
+      persistentCache?.write(cacheKey, inputIds, groups);
+    } else {
+      cachedChunks++;
+    }
     const byId = new Map(input.map((x) => [x.id, x.fileId]));
     cache.set(cacheKey, groups);
     for (const group of groups) {
@@ -436,7 +576,13 @@ export async function analyzeChanges(
         fileFacts.get(id).push(group.summary);
     }
     analyzed += input.filter((x) => !x.metadataOnly).length;
-    onProgress?.({ completedChunks: ++done, analyzedFragments: analyzed });
+    onProgress?.({
+      completedChunks: ++done,
+      analyzedFragments: analyzed,
+      cachedChunks,
+      requestedChunks,
+      cacheHit,
+    });
   }
   async function schedule() {
     pending.push(
@@ -456,10 +602,11 @@ export async function analyzeChanges(
         fileFacts.get(unit.fileId).push(unit.text);
         continue;
       }
-      const size = JSON.stringify(unit).length;
-      if (batch.length && (length + size > maxChars || batch.length >= 16)) await schedule();
+      const size = estimateTokens(JSON.stringify(unit));
+      if (batch.length && (batchTokens + size > maxBatchTokens || batch.length >= 16))
+        await schedule();
       batch.push(unit);
-      length += size;
+      batchTokens += size;
     }
     await schedule();
     for (const err of await Promise.all(pending)) if (err) throw err;
@@ -510,15 +657,22 @@ export async function analyzeChanges(
         metadataOnlyFiles: capture.manifest.filter((f) => f.metadataOnly).length,
         failedFiles: 0,
         completedChunks: done,
+        cachedChunks,
+        requestedChunks,
       },
     };
   } catch (err) {
+    const exhausted = err.data?.analysis?.exhausted || (!budget.remainingMs() ? 'time' : undefined);
     err.data = {
       ...err.data,
       analysis: {
         ...budget.snapshot(),
+        ...err.data?.analysis,
+        ...(exhausted ? { exhausted } : {}),
         totalFiles: capture.manifest.length,
         completedChunks: done,
+        cachedChunks,
+        requestedChunks,
         complete: false,
       },
     };
@@ -559,8 +713,9 @@ export async function summarizeChanges(config, facts) {
   return `Structured change summaries (not raw diff):\n${JSON.stringify(items)}`;
 }
 
-export async function planAnalyzedChanges(config, facts, coverage = null) {
+export async function planAnalyzedChanges(config, facts, coverage = null, stream = null) {
   let candidates = facts;
+  const deep = isDeepAnalysis(config) && coverage?.strategy !== 'auto';
   const policy = normalizeCommitPolicy(config.commitPolicy, config.language);
   const cap = Math.min(
     config.splitMaxDiffChars || 16000,
@@ -568,15 +723,16 @@ export async function planAnalyzedChanges(config, facts, coverage = null) {
   );
   for (let level = 0; level < 8; level++) {
     const byId = new Map(candidates.map((x) => [x.id, x]));
-    const batches = !isDeepAnalysis(config)
-      ? [localPlanItems(config, candidates, cap)]
-      : packItems(
-          candidates.map(({ id, path, summary }) => ({ id, path, summary })),
-          cap,
-          config.splitMaxPlanFiles || 100,
-        );
-    if (!isDeepAnalysis(config) && coverage) {
-      coverage.sampledFiles = batches[0].filter((item) => item.representativeExcerpt).length;
+    const batches =
+      !deep && level === 0
+        ? localPlanBatches(config, candidates, cap)
+        : packItems(
+            candidates.map(({ id, path, summary }) => ({ id, path, summary })),
+            cap,
+            config.splitMaxPlanFiles || 100,
+          );
+    if (!deep && level === 0 && coverage) {
+      coverage.sampledFiles = batches.flat().filter((item) => item.representativeExcerpt).length;
       coverage.metadataOnlyFiles = coverage.totalFiles - coverage.sampledFiles;
     }
     const next = [];
@@ -594,6 +750,9 @@ export async function planAnalyzedChanges(config, facts, coverage = null) {
               'Analysis plan is missing a commit subject.',
             );
         },
+        // Earlier batches may run many requests. Surface thinking from the
+        // final plan, which is the reasoning relevant to the review screen.
+        batches.length === 1 ? stream : null,
       );
       for (const group of groups) {
         next.push({
@@ -605,14 +764,11 @@ export async function planAnalyzedChanges(config, facts, coverage = null) {
     }
     if (batches.length === 1)
       return next.map(({ subject, body, files }) => ({ subject, body, files }));
-    if (next.length >= candidates.length)
-      throw fail(
-        ERROR_CATEGORIES.PROVIDER,
-        'Too many independent change groups for a complete global plan. Stage a smaller logical change or increase planning limits.',
-      );
     candidates = next;
   }
-  throw fail(ERROR_CATEGORIES.PROVIDER, 'Split planning exceeded the maximum summary depth.');
+  throw fail(ERROR_CATEGORIES.PROVIDER, 'Split planning exceeded the maximum summary depth.', {
+    data: { fallbackPlan: true },
+  });
 }
 
 export function needsAnalysis(capture, config, split = false) {

package/src/cli.js

@@ -16,13 +16,17 @@ function showHelp() {
     ${chalk.dim('$')} aicommit [path] [options]
     ${chalk.dim('$')} aicommit setup
     ${chalk.dim('$')} aicommit update
-    ${chalk.dim('$')} aicommit split [run|plan|apply|resume|abort] [options]
+    ${chalk.dim('$')} aicommit generate --scope=staged|all --file=<path> [options]
+    ${chalk.dim('$')} aicommit apply --file=<path> [options]
+    ${chalk.dim('$')} aicommit split [run|plan|apply|resume|abort|status] [options]
 
   ${chalk.bold('Everyday commands:')}
     setup                 Interactive configuration wizard
     update                Update the global npm installation to latest
     doctor                Diagnose runtime, config, credentials, and connectivity
     split                 Plan and create file-level logical commits
+    generate              Export one validated commit plan without committing
+    apply                 Apply a validated commit plan
 
   ${chalk.bold('Advanced commands:')}
     config show           Print the effective configuration with secrets redacted
@@ -35,6 +39,7 @@ function showHelp() {
     split apply           Validate and apply an exported JSON plan
     split resume          Resume the repository's unfinished transaction
     split abort           Discard recovery metadata; keep commits and changes
+    split status          Inspect recovery metadata without changing Git state
 
   ${chalk.bold('Arguments:')}
     path                  Target directory (default: current directory)
@@ -45,13 +50,14 @@ function showHelp() {
     -l, --lang=<zh|en>    Commit message language (default: zh)
     -p, --provider=<name> Use the named provider from config "providers"
     -m, --model=<name>    Use a named model from the selected provider
-    --scope=<scope>       Scope for "split|split plan": staged, all
-    --file=<path>         Split-plan artifact or commit-message file
+    --scope=<scope>       Scope for dry-run, generate, or split planning: staged, all
+    --file=<path>         Commit-plan artifact or commit-message file
     --range=<revision>    Git revision/range for "policy check" (default: HEAD)
     --reasoning=<level>   Set reasoning effort (enabled by default: medium)
     --no-reasoning        Explicitly disable reasoning when supported
     --dry-run             Generate and review without creating commits
     -y, --yes             Non-interactive: accept the generated message/plan
+    --allow-single-fallback  Let non-interactive split commit one complete group if planning exhausts its budget
     --output=<text|json>  Output mode; JSON requires --yes for commit flows
     --debug               Print debug info (parsed args, final config, etc.)
 
@@ -90,9 +96,13 @@ function parsedDefaults(overrides = {}) {
     debug: false,
     split: null,
     splitCommand: null,
+    generate: false,
+    generateScope: null,
+    previewScope: null,
     splitPlanFile: null,
     dryRun: false,
     yes: false,
+    allowSingleFallback: false,
     setup: false,
     update: false,
     doctor: false,
@@ -163,10 +173,17 @@ export function parseArgs(args = process.argv.slice(2)) {
     args = args.slice(2);
   }
 
+  const generate = !update && args[0] === 'generate';
+  if (generate) args = args.slice(1);
+
   let splitCommand = null;
+  if (!update && args[0] === 'apply') {
+    splitCommand = 'apply';
+    args = args.slice(1);
+  }
   if (!update && args[0] === 'split') {
     const requestedAction = args[1];
-    const actions = ['run', 'plan', 'apply', 'resume', 'abort'];
+    const actions = ['run', 'plan', 'apply', 'resume', 'abort', 'status'];
     if (!requestedAction || requestedAction.startsWith('-')) {
       // Keep the common path short: `aicommit split` is the interactive
       // split flow, while explicit actions remain available for automation
@@ -179,7 +196,7 @@ export function parseArgs(args = process.argv.slice(2)) {
     } else {
       throw fail(
         ERROR_CATEGORIES.CONFIG,
-        'split requires one action: run, plan, apply, resume, or abort.',
+        'split requires one action: run, plan, apply, resume, abort, or status.',
       );
     }
   }
@@ -195,12 +212,15 @@ export function parseArgs(args = process.argv.slice(2)) {
   let output = 'text';
   let debug = false;
   let split = null;
+  let generateScope = null;
+  let previewScope = null;
   let splitPlanFile = null;
   let policyMessageFile = null;
   let policyRange = null;
   let splitScopeOption = false;
   let dryRun = false;
   let yes = false;
+  let allowSingleFallback = false;
   const setup = false;
 
   for (let i = 0; i < args.length; i++) {
@@ -235,20 +255,26 @@ export function parseArgs(args = process.argv.slice(2)) {
 
     if (arg === '--scope') {
       splitScopeOption = true;
-      split = takeValue(args, i, arg, 'staged|all');
+      const scope = takeValue(args, i, arg, 'staged|all');
       i++;
-      if (!['staged', 'all'].includes(split)) {
-        throw fail(ERROR_CATEGORIES.CONFIG, `Invalid split scope: "${split}". Use staged or all.`);
+      if (!['staged', 'all'].includes(scope)) {
+        throw fail(ERROR_CATEGORIES.CONFIG, `Invalid split scope: "${scope}". Use staged or all.`);
       }
+      if (generate) generateScope = scope;
+      else if (splitCommand) split = scope;
+      else previewScope = scope;
       continue;
     }
 
     if (arg.startsWith('--scope=')) {
       splitScopeOption = true;
-      split = arg.slice('--scope='.length);
-      if (!['staged', 'all'].includes(split)) {
-        throw fail(ERROR_CATEGORIES.CONFIG, `Invalid split scope: "${split}". Use staged or all.`);
+      const scope = arg.slice('--scope='.length);
+      if (!['staged', 'all'].includes(scope)) {
+        throw fail(ERROR_CATEGORIES.CONFIG, `Invalid split scope: "${scope}". Use staged or all.`);
       }
+      if (generate) generateScope = scope;
+      else if (splitCommand) split = scope;
+      else previewScope = scope;
       continue;
     }
 
@@ -290,6 +316,11 @@ export function parseArgs(args = process.argv.slice(2)) {
       continue;
     }
 
+    if (arg === '--allow-single-fallback') {
+      allowSingleFallback = true;
+      continue;
+    }
+
     if (arg === '--reasoning') {
       cliReasoning = takeValue(args, i, arg, 'low|medium|high|xhigh|max');
       i++;
@@ -419,14 +450,38 @@ export function parseArgs(args = process.argv.slice(2)) {
       }
     }
   }
-  if (splitScopeOption && !['run', 'plan'].includes(splitCommand)) {
+  if (generate) {
+    if (!generateScope || !splitPlanFile) {
+      throw fail(
+        ERROR_CATEGORIES.CONFIG,
+        'generate requires --scope=staged|all and --file=<path>.',
+      );
+    }
+    if (splitCommand || allowSingleFallback) {
+      throw fail(ERROR_CATEGORIES.CONFIG, 'generate does not accept split commit options.');
+    }
+    dryRun = true;
+  }
+  if (splitScopeOption && !generate && splitCommand && !['run', 'plan'].includes(splitCommand)) {
     throw fail(
       ERROR_CATEGORIES.CONFIG,
-      '--scope is only valid with "aicommit split run" or "aicommit split plan".',
+      '--scope is only valid with dry-run, generate, split run, or split plan.',
     );
   }
-  if (splitPlanFile && !['plan', 'apply'].includes(splitCommand)) {
-    throw fail(ERROR_CATEGORIES.CONFIG, '--file is only valid with split plan or split apply.');
+  if (previewScope && !dryRun) {
+    throw fail(ERROR_CATEGORIES.CONFIG, '--scope without a subcommand requires --dry-run.');
+  }
+  if (splitPlanFile && !generate && !['plan', 'apply'].includes(splitCommand)) {
+    throw fail(
+      ERROR_CATEGORIES.CONFIG,
+      '--file is only valid with generate, apply, or split plan/apply.',
+    );
+  }
+  if (allowSingleFallback && (splitCommand !== 'run' || !yes || dryRun)) {
+    throw fail(
+      ERROR_CATEGORIES.CONFIG,
+      '--allow-single-fallback requires non-dry-run "aicommit split run --yes".',
+    );
   }
   if (
     configAction &&
@@ -494,9 +549,13 @@ export function parseArgs(args = process.argv.slice(2)) {
     debug,
     split,
     splitCommand,
+    generate,
+    generateScope,
+    previewScope,
     splitPlanFile,
     dryRun,
     yes,
+    allowSingleFallback,
     setup,
     update,
     doctor,