@hifullmoon/aicommit 2.4.1 → 2.6.0

package/src/split.js

@@ -74,6 +74,7 @@ import {
   summarizeChanges,
 } from './change-analysis.js';
 import { updateGitHash, spoolGit } from './git-spool.js';
+import { createAnalysisCache } from './analysis-cache.js';
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Split mode: group changes into multiple logical commits
@@ -468,6 +469,51 @@ function groupMessage(g, policy) {
   return validateCommitCandidate(message, { policy }).valid ? message : '';
 }
 
+function fallbackCommitMessage(policy) {
+  const type = policy.types.includes('chore') ? 'chore' : policy.types[0];
+  let scope = '';
+  if (policy.scope.mode === 'required') {
+    if (policy.scope.values.length) scope = policy.scope.values[0];
+    else {
+      const disallowed = new Set(policy.scope.disallowedValues || []);
+      const preferred = ['changes', 'repository', 'all'];
+      scope = preferred.find((candidate) => !disallowed.has(candidate)) || '';
+      for (let index = 1; !scope; index++) {
+        const candidate = `fallback-${index}`;
+        if (!disallowed.has(candidate)) scope = candidate;
+      }
+    }
+  }
+  const breaking = policy.breakingChange === 'require' ? '!' : '';
+  const prefix = `${type}${scope ? `(${scope})` : ''}${breaking}: `;
+  const preferred = policy.effectiveLanguage === 'zh' ? '更新其余文件' : 'update remaining files';
+  const available = Math.max(
+    1,
+    Math.min(
+      policy.subject.maxLength,
+      policy.subject.headerMaxLength
+        ? policy.subject.headerMaxLength - [...prefix].length
+        : policy.subject.maxLength,
+    ),
+  );
+  const subject = [...preferred].slice(0, available).join('');
+  const body =
+    policy.body.mode === 'required'
+      ? policy.effectiveLanguage === 'zh'
+        ? '- 包含本次已审核的全部文件变更'
+        : '- Include all reviewed file changes'
+      : '';
+  const message = cleanCommitMessage(`${prefix}${subject}${body ? `\n\n${body}` : ''}`);
+  const validation = validateCommitCandidate(message, { policy });
+  if (!validation.valid) {
+    throw fail(
+      ERROR_CATEGORIES.CONFIG,
+      `Cannot construct a conservative fallback message under commitPolicy: ${validation.errors.map((item) => item.message).join(' ')}`,
+    );
+  }
+  return message;
+}
+
 // Clean up the model's plan: drop unknown/duplicate files, drop empty
 // groups, and sweep any file the model forgot into a final catch-all group.
 export function normalizePlan(groups, allFiles, language, commitPolicy = null) {
@@ -531,12 +577,8 @@ export function normalizePlan(groups, allFiles, language, commitPolicy = null) {
     if (ids.length) leftoverHunks.push({ path: change.path, ids });
   }
   if (leftoverFiles.length || leftoverHunks.length) {
-    const type = policy.types.includes('chore') ? 'chore' : policy.types[0];
     result.push({
-      message:
-        policy.effectiveLanguage === 'zh'
-          ? `${type}: 更新其余文件`
-          : `${type}: update remaining files`,
+      message: fallbackCommitMessage(policy),
       files: leftoverFiles,
       ...(leftoverHunks.length ? { hunks: leftoverHunks } : {}),
     });
@@ -1121,6 +1163,83 @@ function currentHeadParent(projectRoot) {
   return fields[1] || null;
 }
 
+function splitCheckpointSummary(projectRoot, loaded) {
+  const { path, checkpoint } = loaded;
+  const knownCommits = checkpoint.completed.map((record) => record.commit);
+  let inFlight = null;
+  if (checkpoint.inFlight) {
+    const record = checkpoint.inFlight;
+    const head = currentHead(projectRoot);
+    const state =
+      head === record.parent
+        ? 'pending'
+        : currentHeadParent(projectRoot) === record.parent &&
+            currentHeadTree(projectRoot) === record.tree
+          ? 'committed'
+          : 'unknown';
+    if (state === 'committed') knownCommits.push(head);
+    inFlight = { group: record.index + 1, state };
+  }
+  const totalGroups = checkpoint.plan.groups.length;
+  return {
+    state: 'pending',
+    transactionId: checkpoint.transactionId,
+    checkpointPath: path,
+    scope: checkpoint.plan.scope,
+    totalGroups,
+    completedGroups: knownCommits.length,
+    pendingGroups: totalGroups - knownCommits.length,
+    completedCommits: knownCommits,
+    inFlight,
+    nextAction: 'aicommit split resume --yes',
+  };
+}
+
+export function splitStatus(projectRoot) {
+  let summary;
+  try {
+    summary = splitCheckpointSummary(projectRoot, readSplitCheckpoint(projectRoot));
+  } catch (err) {
+    if (!/No split checkpoint found:/.test(err.message)) {
+      throw fail(ERROR_CATEGORIES.GIT_STATE, `Cannot inspect split checkpoint: ${err.message}`, {
+        code: 'split_checkpoint_invalid',
+        cause: err,
+      });
+    }
+    summary = { state: 'idle' };
+  }
+  const known = summary.completedCommits || [];
+  const commitState =
+    summary.inFlight?.state === 'unknown'
+      ? 'unknown'
+      : !known.length
+        ? 'none'
+        : summary.pendingGroups
+          ? 'partial'
+          : 'complete';
+  return {
+    exitReason: 'split_status',
+    committed: false,
+    commitState,
+    commitSha: known.at(-1) || null,
+    scope: summary.scope || null,
+    data: { split: summary },
+  };
+}
+
+function splitCommitFailure(projectRoot, message) {
+  const status = splitStatus(projectRoot);
+  const knownCommits = status.data.split.completedCommits || [];
+  throw fail(ERROR_CATEGORIES.GIT_STATE, message, {
+    code: knownCommits.length ? 'split_partial_failure' : 'split_commit_failed',
+    reported: true,
+    committed: knownCommits.length > 0,
+    commitState: status.commitState,
+    nextAction: 'aicommit split resume --yes',
+    data: status.data,
+  });
+}
+
 function readHeadEntries(projectRoot, paths) {
   const entries = new Map();
   if (!hasHead(projectRoot) || !paths.length) return entries;
@@ -1421,6 +1540,7 @@ export async function splitFlow(
     scope = 'prompt',
     dryRun = false,
     yes = false,
+    allowSingleFallback = false,
     machineOutput = false,
     provider = null,
     exportPlanPath = null,
@@ -1621,6 +1741,7 @@ export async function splitFlow(
 
   let raw, reasoningText, elapsed, usage;
   let analysis;
+  let persistentAnalysisCache = null;
   const large =
     needsAnalysis(captured, config, true) ||
     untrackedSnapshot.previews.sources?.size > 0 ||
@@ -1634,7 +1755,22 @@ export async function splitFlow(
         ERROR_CATEGORIES.CONFIG,
         'Large-change analysis does not support experimental hunk plans; use file-level split.',
       );
-    planningConfig = analysisConfig(planningConfig);
+    planningConfig = analysisConfig({ ...planningConfig, analysisTask: 'split' });
+    persistentAnalysisCache = createAnalysisCache({
+      projectRoot,
+      snapshotFingerprint: plannedStateFingerprint,
+      config: planningConfig,
+      protect: protectModelInput,
+    });
+    if (
+      planningConfig.largeChange?.strategy === 'deep' &&
+      planningConfig.largeChange.cache?.enabled &&
+      !protectModelInput &&
+      !planningConfig.largeChange.cache.allowUnprotected
+    ) {
+      warnings.push('Deep-analysis recovery cache was disabled for unprotected input.');
+      console.log(chalk.dim('  Recovery cache: disabled for unprotected input.'));
+    }
     console.log(
       chalk.dim(
         planningConfig.largeChange?.strategy === 'deep'
@@ -1657,15 +1793,71 @@ export async function splitFlow(
       failureMessage: 'API call failed',
       task: async (stream) => {
         if (large) {
-          analysis = await analyzeChanges(
-            planningConfig,
-            captured,
-            protectModelInput,
-            untrackedSnapshot.previews,
-            ({ completedChunks }) =>
-              console.error(`  Analysis: ${completedChunks} chunks completed`),
-          );
-          const plan = await planAnalyzedChanges(planningConfig, analysis.facts, analysis.coverage);
+          let plan;
+          let planReasoning = null;
+          const planningStream = stream
+            ? {
+                onReasoningDelta(chunk) {
+                  planReasoning = (planReasoning || '') + chunk;
+                  stream.onReasoningDelta(chunk);
+                },
+                onReasoningComplete(text) {
+                  if (text) planReasoning = text;
+                },
+              }
+            : null;
+          try {
+            analysis = await analyzeChanges(
+              planningConfig,
+              captured,
+              protectModelInput,
+              untrackedSnapshot.previews,
+              ({ completedChunks, cachedChunks }) =>
+                console.error(
+                  `  Analysis: ${completedChunks} chunks completed${cachedChunks ? ` (${cachedChunks} cached)` : ''}`,
+                ),
+              persistentAnalysisCache,
+            );
+            plan = await planAnalyzedChanges(
+              planningConfig,
+              analysis.facts,
+              analysis.coverage,
+              planningStream,
+            );
+          } catch (err) {
+            const exhausted =
+              err.data?.analysis?.exhausted ||
+              (!planningConfig.analysisBudget.remainingMs() ? 'time' : null);
+            if (!exhausted && !err.data?.fallbackPlan) throw err;
+            if (yes && !dryRun && !allowSingleFallback) {
+              throw fail(
+                err.category || ERROR_CATEGORIES.PROVIDER,
+                'Large-change planning requires a conservative single-commit fallback. No commit was created; review interactively or rerun with --allow-single-fallback.',
+                { cause: err, data: err.data },
+              );
+            }
+            const fallbackConfig = {
+              ...planningConfig,
+              largeChange: { ...planningConfig.largeChange, strategy: 'auto' },
+            };
+            analysis = await analyzeChanges(
+              fallbackConfig,
+              captured,
+              protectModelInput,
+              untrackedSnapshot.previews,
+            );
+            analysis.coverage = {
+              ...analysis.coverage,
+              strategy: 'fallback',
+              degradedFrom: planningConfig.largeChange.strategy,
+              fallbackReason: exhausted || 'planning_capacity',
+            };
+            plan = normalizePlan([], allFiles, config.language, config.commitPolicy);
+            planReasoning = null;
+            const warning = `Large-change planning used one conservative all-files commit after ${exhausted || 'planning capacity'} exhaustion; review the fallback message and grouping.`;
+            warnings.push(warning);
+            console.error(`  Fallback: ${warning}`);
+          }
           if (analysis.coverage.strategy === 'auto')
             warnings.push(
               'Split candidates used local metadata and selected excerpts; review the grouping because content was not fully analyzed.',
@@ -1684,7 +1876,7 @@ export async function splitFlow(
             raw: JSON.stringify(plan),
             elapsed: planningConfig.analysisBudget.snapshot().elapsedMs,
             usage: planningConfig.analysisBudget.snapshot().usage,
-            reasoning: null,
+            reasoning: planReasoning,
           };
         }
         return generateSplitPlan(
@@ -1736,6 +1928,8 @@ export async function splitFlow(
       reported: true,
     });
   }
+  persistentAnalysisCache?.clear();
+  persistentAnalysisCache = null;
 
   // Review / edit / regenerate loop
   let regenCounts = groups.map(() => 0);
@@ -1777,7 +1971,7 @@ export async function splitFlow(
               { name: 'Cancel', value: 'cancel', description: 'Abort without committing' },
             ],
           },
-          reasoningEnabled
+          reasoningEnabled || reasoningText
             ? {
                 text: reasoningText,
                 maxChars: config.reasoning.maxDisplayChars,
@@ -1914,6 +2108,8 @@ export async function splitFlow(
     return {
       plan: groups,
       planFile: writtenPlanPath,
+      scope,
+      changeCount: allFiles.length,
       provider,
       model: config.modelId,
       latencyMs: elapsed,
@@ -1955,12 +2151,13 @@ export async function splitFlow(
   if (ok) {
     console.log('\n  ' + chalk.green.bold(`✓ Done! Created ${groups.length} commits.\n`));
   } else {
-    throw fail(ERROR_CATEGORIES.GIT_STATE, 'One or more split commits failed.', {
-      reported: true,
-    });
+    splitCommitFailure(projectRoot, 'One or more split commits failed.');
   }
   return {
     plan: groups,
+    commitSha: currentHead(projectRoot),
+    scope,
+    changeCount: allFiles.length,
     provider,
     model: config.modelId,
     latencyMs: elapsed,
@@ -2069,9 +2266,13 @@ export async function resumeSplit(projectRoot, { yes = false, machineOutput = fa
     );
     return {
       plan: checkpoint.plan.groups,
+      commitSha: currentHead(projectRoot),
+      scope: checkpoint.plan.scope,
+      changeCount: checkpoint.plan.changes.length,
       warnings: [],
       exitReason: 'success',
-      committed: true,
+      committed: false,
+      commitState: 'complete',
       edited: false,
       rewrites: 0,
     };
@@ -2126,9 +2327,7 @@ export async function resumeSplit(projectRoot, { yes = false, machineOutput = fa
     { transaction: { path: transaction.path, checkpoint } },
   );
   if (!ok) {
-    throw fail(ERROR_CATEGORIES.GIT_STATE, 'One or more resumed split commits failed.', {
-      reported: true,
-    });
+    splitCommitFailure(projectRoot, 'One or more resumed split commits failed.');
   }
   console.log(
     '\n  ' +
@@ -2138,6 +2337,9 @@ export async function resumeSplit(projectRoot, { yes = false, machineOutput = fa
   );
   return {
     plan: checkpoint.plan.groups,
+    commitSha: currentHead(projectRoot),
+    scope: checkpoint.plan.scope,
+    changeCount: checkpoint.plan.changes.length,
     provider: null,
     model: null,
     latencyMs: null,
@@ -2344,13 +2546,15 @@ export async function applySplitPlan(
     { planArtifact: artifact },
   );
   if (!ok) {
-    throw fail(ERROR_CATEGORIES.GIT_STATE, 'One or more split commits failed.', {
-      reported: true,
-    });
+    splitCommitFailure(projectRoot, 'One or more split commits failed.');
   }
   console.log('\n  ' + chalk.green.bold(`✓ Done! Created ${artifact.groups.length} commits.\n`));
   return {
     plan: artifact.groups,
+    planFile: loaded.path,
+    commitSha: readGit(['rev-parse', 'HEAD'], projectRoot).trim(),
+    scope: artifact.scope,
+    changeCount: artifact.changes.length,
     provider: null,
     model: null,
     latencyMs: null,