@hifullmoon/aicommit 2.4.0 → 2.5.0

package/src/local-analysis.js

@@ -245,27 +245,57 @@ export function analyzeLocally(config, capture, protect, previews) {
       metadataOnlyFiles: capture.manifest.length - overview.sampledFiles,
       failedFiles: 0,
       completedChunks: 0,
+      cachedChunks: 0,
+      requestedChunks: 0,
     },
   };
 }
 
-export function localPlanItems(config, facts, cap) {
+export function localPlanBatches(config, facts, cap) {
   const error = () =>
-    fail(
+    fail(ERROR_CATEGORIES.CONFIG, 'A split candidate is too large for one planning request.', {
+      data: { fallbackPlan: true },
+    });
+  const maxItems = config.splitMaxPlanFiles || 100;
+  const batches = [];
+  let batch = [];
+  for (const fact of facts) {
+    const item = {
+      ...summaryOf(fact, false),
+      summary: 'Local candidate only; verify grouping. Content not fully analyzed.',
+    };
+    if (Buffer.byteLength(JSON.stringify([item])) > cap) throw error();
+    const candidate = [...batch, item];
+    if (
+      batch.length &&
+      (candidate.length > maxItems || Buffer.byteLength(JSON.stringify(candidate)) > cap)
+    ) {
+      batches.push(batch);
+      batch = [];
+    }
+    batch.push(item);
+  }
+  if (batch.length) batches.push(batch);
+
+  const factsById = new Map(facts.map((fact) => [fact.id, fact]));
+  for (const items of batches) {
+    for (const item of items) {
+      const evidence = factsById.get(item.id)?.evidence;
+      if (!evidence) continue;
+      item.representativeExcerpt = evidence;
+      if (Buffer.byteLength(JSON.stringify(items)) > cap) delete item.representativeExcerpt;
+    }
+  }
+  return batches;
+}
+
+export function localPlanItems(config, facts, cap) {
+  const batches = localPlanBatches(config, facts, cap);
+  if (batches.length !== 1)
+    throw fail(
       ERROR_CATEGORIES.CONFIG,
-      'The complete split candidate inventory does not fit one request. Stage a smaller logical change or explicitly set personal largeChange.strategy to deep. No planning request was sent.',
+      'The complete split candidate inventory requires multiple planning requests.',
+      { data: { fallbackPlan: true } },
     );
-  if (facts.length > (config.splitMaxPlanFiles || 100)) throw error();
-  const items = facts.map((fact) => ({
-    ...summaryOf(fact, false),
-    summary: 'Local candidate only; verify grouping. Content not fully analyzed.',
-  }));
-  if (Buffer.byteLength(JSON.stringify(items)) > cap) throw error();
-  for (const fact of ranked(facts)) {
-    if (!fact.evidence) continue;
-    const item = items.find((item) => item.id === fact.id);
-    item.representativeExcerpt = fact.evidence;
-    if (Buffer.byteLength(JSON.stringify(items)) > cap) delete item.representativeExcerpt;
-  }
-  return items;
+  return batches[0];
 }

package/src/main.js

@@ -29,6 +29,7 @@ import {
   summarizeChanges,
 } from './change-analysis.js';
 import { cleanupGitSpools } from './git-spool.js';
+import { createAnalysisCache } from './analysis-cache.js';
 import { generateCommitMessage } from './api.js';
 import {
   statusColor,
@@ -110,6 +111,7 @@ async function runMain() {
     splitPlanFile,
     dryRun,
     yes,
+    allowSingleFallback,
     setup,
     update,
     doctor,
@@ -291,6 +293,7 @@ async function runMain() {
     console.log(chalk.dim(`  split:        ${split}`));
     console.log(chalk.dim(`  dryRun:       ${dryRun}`));
     console.log(chalk.dim(`  yes:          ${yes}`));
+    console.log(chalk.dim(`  singleFallback: ${allowSingleFallback}`));
     console.log(chalk.dim('  final config:'));
     for (const [key, value] of Object.entries(config)) {
       const display =
@@ -321,6 +324,7 @@ async function runMain() {
       scope: split,
       dryRun,
       yes,
+      allowSingleFallback,
       machineOutput,
       provider: selectedProvider,
       exportPlanPath: splitCommand === 'plan' ? splitPlanFile : null,
@@ -572,9 +576,25 @@ async function runMain() {
       );
   let analysis;
   let analyzedFacts;
+  let persistentAnalysisCache = null;
   let generationConfig = config;
   if (large) {
     generationConfig = analysisConfig(config);
+    persistentAnalysisCache = createAnalysisCache({
+      projectRoot,
+      snapshotFingerprint: plannedIndexFingerprint,
+      config: generationConfig,
+      protect: protectAnalysis,
+    });
+    if (
+      generationConfig.largeChange?.strategy === 'deep' &&
+      generationConfig.largeChange.cache?.enabled &&
+      !protectAnalysis &&
+      !generationConfig.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(
         generationConfig.largeChange?.strategy === 'deep'
@@ -622,8 +642,11 @@ async function runMain() {
               captured,
               protectAnalysis,
               null,
-              ({ completedChunks }) =>
-                console.error(`  Analysis: ${completedChunks} chunks completed`),
+              ({ completedChunks, cachedChunks }) =>
+                console.error(
+                  `  Analysis: ${completedChunks} chunks completed${cachedChunks ? ` (${cachedChunks} cached)` : ''}`,
+                ),
+              persistentAnalysisCache,
             );
             modelDiff =
               analyzedFacts.summary ||
@@ -691,6 +714,8 @@ async function runMain() {
         reported: true,
       });
     }
+    persistentAnalysisCache?.clear();
+    persistentAnalysisCache = null;
 
     // ── 4. User action ─────────────────────────────────────────────────
 

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 } : {}),
     });
@@ -1421,6 +1463,7 @@ export async function splitFlow(
     scope = 'prompt',
     dryRun = false,
     yes = false,
+    allowSingleFallback = false,
     machineOutput = false,
     provider = null,
     exportPlanPath = null,
@@ -1621,6 +1664,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 +1678,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 +1716,53 @@ 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;
+          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);
+          } 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);
+            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.',
@@ -1736,6 +1833,8 @@ export async function splitFlow(
       reported: true,
     });
   }
+  persistentAnalysisCache?.clear();
+  persistentAnalysisCache = null;
 
   // Review / edit / regenerate loop
   let regenCounts = groups.map(() => 0);