@hifullmoon/aicommit 2.6.4 → 2.6.6

package/CHANGELOG.md

@@ -4,6 +4,18 @@ This file lists notable user-facing changes. Internal refactors, test-only chang
 
 ## [Unreleased]
 
+## [2.6.6] - 2026-09-21
+
+### Fixed
+
+- Large split plans now preserve complete file groupings while correcting only invalid commit messages, with bounded retries and character counts. Interactive runs can edit messages after automatic correction fails and continue to plan review; non-interactive failures preserve a private diagnostic draft for protected input.
+
+## [2.6.5] - 2026-09-21
+
+### Fixed
+
+- Large split plans now validate commit messages during planning and automatically retry with specific policy errors, including missing or empty subjects. Planning failures are labeled accurately instead of being reported as API failures.
+
 ## [2.6.4] - 2026-09-19
 
 ### Fixed
@@ -261,7 +273,9 @@ This file lists notable user-facing changes. Internal refactors, test-only chang
 - Added file-level split planning and execution with Git-state concurrency checks.
 - Added provider presets and user/project configuration boundaries.
 
-[Unreleased]: https://github.com/hi-fullmoon/AICommit/compare/v2.6.4...HEAD
+[Unreleased]: https://github.com/hi-fullmoon/AICommit/compare/v2.6.6...HEAD
+[2.6.6]: https://github.com/hi-fullmoon/AICommit/releases/tag/v2.6.6
+[2.6.5]: https://github.com/hi-fullmoon/AICommit/releases/tag/v2.6.5
 [2.6.4]: https://github.com/hi-fullmoon/AICommit/releases/tag/v2.6.4
 [2.6.3]: https://github.com/hi-fullmoon/AICommit/releases/tag/v2.6.3
 [2.6.2]: https://github.com/hi-fullmoon/AICommit/releases/tag/v2.6.2

package/README.md

@@ -516,4 +516,6 @@ For exhaustive chunk-by-chunk model analysis, opt in through personal configurat
 
 `deep` spends more requests and tokens, with a maximum of 256 requests. Before dispatch, a preflight estimate covers initial chunks, required reductions, and the minimum hierarchical planning tree; an impossible deep run switches to the local inventory path, and validated cache hits are excluded from that estimate. Validated initial fact chunks are stored briefly under Git metadata, reused when the same snapshot is retried after failure or interruption, and removed after complete generation succeeds. The cache does not directly store captured diffs, reasoning, credentials, or complete provider responses; it stores model summaries that may contain code-derived details. Unprotected original input is not persisted unless personal configuration explicitly enables `allowUnprotected`. Repository configuration cannot change this personal strategy, enable unprotected caching, or raise spending/cache ceilings. Both strategies use conservative token estimates; cache hits consume no request or token budget. Incomplete model output is never committed: budget/capacity fallback is a new complete plan containing every reviewed file; interactive runs show it for review, while non-interactive committing requires `--allow-single-fallback`.
 
+Large-change split planning completes file grouping before repairing commit messages. If a message violates the policy (for example, its description exceeds 72 characters), up to three message-only correction rounds preserve file assignments and valid messages without resending diffs. These rounds share the existing request, time, and token budgets; JSON recovery may require an additional request within a round. If automatic repair fails, interactive runs offer an editor for the invalid messages and then return to normal plan review. Non-interactive runs stop without committing or collapsing the groups into a single commit. For protected input, a private temporary diagnostic JSON file preserves the complete grouping and messages; it is not an artifact accepted by `split apply`.
+
 Complete patches and larger untracked text are captured in local temporary files, with descriptors opened only during reads and writes. Files are cleaned on normal exit or cancellation; crashes may leave them behind. Content reads are bounded. Lines exceeding 1 MiB and experimental hunk planning for large changes fail explicitly; file-level planning capacity uses the complete conservative fallback.

package/README.zh-CN.md

@@ -518,4 +518,6 @@ exec zsh
 
 `deep` 会增加请求和 token 消耗，最多 256 次请求。请求前会预估初始分块、必要归并和最小分层规划树的成本；确定无法装入总预算时直接切换到本地清单路径，已验证的缓存命中不计入这次预估。通过完整校验的初始事实分块会短期写入 Git 元数据目录；同一快照失败或中断后重试时直接复用，完整生成成功后清理。缓存不直接保存捕获的 diff、推理、凭据或完整 Provider 响应，只保存可能包含代码派生细节的模型摘要；选择发送未保护的原始内容时默认不落盘，只有个人配置显式设置 `allowUnprotected: true` 才允许。仓库配置不能切换策略、启用未保护缓存或提高费用与缓存上限。两种策略均使用保守 token 估算，未知 usage 按预留额度计入；缓存命中不计请求或 token。模型的不完整输出永远不会被提交：预算或容量降级会重新生成一个包含全部已审核文件的完整计划；交互模式先展示确认，非交互提交则要求 `--allow-single-fallback`。
 
+大变更拆分先完成全部文件分组，再修正不合规的提交信息。自动修正最多三轮，只发送出错的消息、实际长度和校验原因，不重发 diff，也不改动文件归属或已合规的消息。修正与原规划共用请求、时间和 token 预算；每轮 JSON 恢复可能额外请求一次。自动修正失败后，交互模式允许编辑出错的提交信息，校验通过后返回正常计划确认流程。非交互模式停止提交，不会将已有分组合并成单次提交；对于已保护的输入，会将完整分组和消息保存到私有临时诊断文件，该文件不能直接用于 `split apply`。
+
 完整补丁及较大未跟踪文本暂存到本地临时文件，只在读写时打开文件句柄，正常结束或取消时清理；异常崩溃可能遗留临时文件。正文读取有界。单行超过 1 MiB 和大变更的实验性 hunk 规划会明确报错；文件级规划容量不足时使用覆盖完整变更的保守回退。

package/docs/distribution.md

@@ -33,7 +33,7 @@ The release workflow uses npm Trusted Publishing without a long-lived `NPM_TOKEN
 ```bash
 workdir=$(mktemp -d)
 cd "$workdir"
-npm install --package-lock-only @hifullmoon/aicommit@2.6.4
+npm install --package-lock-only @hifullmoon/aicommit@2.6.6
 npm audit signatures
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hifullmoon/aicommit",
-  "version": "2.6.4",
+  "version": "2.6.6",
   "description": "Safe, local-first AI commit message generator for Git workflows",
   "type": "module",
   "bin": {

package/src/api.js

@@ -207,6 +207,7 @@ export async function getResponseText(
         : reasoning || '';
 
     const partial = text.trim();
+    const followUp = typeof followUpPrompt === 'function' ? followUpPrompt() : followUpPrompt;
     const recoveryPrompt =
       truncatedByLimit || invalidResponse
         ? `The previous response was ${
@@ -214,8 +215,8 @@ export async function getResponseText(
           }. ` +
           'Reproduce the COMPLETE answer from the beginning; do not continue from the cut-off point. ' +
           'Keep the answer concise.\n\n' +
-          followUpPrompt
-        : followUpPrompt;
+          followUp
+        : followUp;
 
     // With reasoning, its conclusion plus the partial answer is enough to
     // reconstruct the output without paying to send the original diff again.

package/src/change-analysis.js

@@ -4,7 +4,7 @@ import { createAnalysisBudget, DEFAULT_LARGE_CHANGE, estimateTokens } from './an
 import { getResponseText } from './api.js';
 import { encodeUntrustedData } from './trust.js';
 import { ERROR_CATEGORIES, fail } from './errors.js';
-import { normalizeCommitPolicy } from './policy.js';
+import { normalizeCommitPolicy, parseCommitMessage, validateCommitCandidate } from './policy.js';
 import { getProviderAdapter } from './providers.js';
 import { createHash } from 'node:crypto';
 import {
@@ -315,6 +315,7 @@ function parseAnalysisJson(raw) {
 }
 
 async function jsonCall(config, instruction, items, validate = null, stream = null) {
+  let validationError = '';
   const parseAndValidate = (raw) => {
     const parsed = parseAnalysisJson(raw);
     validate?.(parsed);
@@ -328,14 +329,17 @@ async function jsonCall(config, instruction, items, validate = null, stream = nu
     ],
     0,
     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))}`,
+    () =>
+      'Return the complete requested JSON array, preserving every required input ID exactly once. ' +
+      `Required IDs: ${JSON.stringify(items.map((item) => item.id))}. ` +
+      (validationError ? `Correct these validation errors: ${validationError}` : ''),
     stream,
     (response) => {
       try {
         parseAndValidate(response);
         return true;
-      } catch {
+      } catch (error) {
+        validationError = error.message;
         return false;
       }
     },
@@ -351,6 +355,99 @@ async function jsonCall(config, instruction, items, validate = null, stream = nu
   }
 }
 
+export function validatePlanMessages(groups, policy) {
+  const errors = [];
+  for (const [index, group] of groups.entries()) {
+    const subject = typeof group.subject === 'string' ? group.subject.trim() : '';
+    if (!subject) {
+      errors.push(`Group ${index + 1}: The subject field must be a non-empty commit header.`);
+      continue;
+    }
+    const body = typeof group.body === 'string' ? group.body.trim() : '';
+    const validation = validateCommitCandidate(body ? `${subject}\n\n${body}` : subject, {
+      policy,
+    });
+    if (!validation.valid)
+      errors.push(`Group ${index + 1}: ${validation.errors.map((item) => item.message).join(' ')}`);
+  }
+  if (errors.length)
+    throw fail(
+      ERROR_CATEGORIES.RESPONSE_FORMAT,
+      `Split commit messages violate commitPolicy: ${errors.join(' ')}`,
+    );
+}
+
+export function invalidPlanMessages(groups, policy) {
+  return groups.flatMap((group, index) => {
+    try {
+      validatePlanMessages([group], policy);
+      return [];
+    } catch (error) {
+      const message = parseCommitMessage(typeof group.subject === 'string' ? group.subject : '');
+      return [
+        {
+          id: String(index),
+          subject: group.subject,
+          body: group.body,
+          subjectLength: [...(message.parsed?.subject || '')].length,
+          subjectMaxLength: policy.subject.maxLength,
+          errors: error.message,
+        },
+      ];
+    }
+  });
+}
+
+export function applyMessageCorrections(groups, corrections, policy) {
+  const invalid = invalidPlanMessages(groups, policy);
+  const remaining = new Set(invalid.map((item) => item.id));
+  if (!Array.isArray(corrections)) throw new Error('Expected a message correction array.');
+  const next = groups.map((group) => ({ ...group }));
+  for (const correction of corrections) {
+    if (!correction || !remaining.delete(correction.id))
+      throw new Error('Corrections must contain each invalid group ID exactly once.');
+    validatePlanMessages([correction], policy);
+    // Never accept model-provided file assignments, summaries, or group ordering.
+    next[Number(correction.id)] = {
+      ...next[Number(correction.id)],
+      subject: correction.subject,
+      body: correction.body,
+    };
+  }
+  if (remaining.size) throw new Error('Corrections omitted invalid group IDs.');
+  return next;
+}
+
+async function repairPlanMessages(config, groups, policy, stream) {
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    const invalid = invalidPlanMessages(groups, policy);
+    if (!invalid.length) return groups;
+    stream?.onProgress?.(`Correcting ${invalid.length} commit messages (${attempt}/3) ...`);
+    try {
+      const corrections = await jsonCall(
+        config,
+        `Repair only the supplied commit messages. Policy: ${JSON.stringify(policy)}. ` +
+          `The description after the type/scope prefix must fit within ${policy.subject.maxLength} Unicode characters. ` +
+          (policy.subject.headerMaxLength
+            ? `The complete header must fit within ${policy.subject.headerMaxLength} characters. `
+            : '') +
+          'Rewrite concisely; do not truncate. Move detail into the body only when permitted. ' +
+          'Return [{"id":"original ID","subject":"complete commit header","body":"optional body"}]. ' +
+          'Preserve every supplied ID exactly once. Do not plan or regroup files.',
+        invalid,
+        (candidate) => applyMessageCorrections(groups, candidate, policy),
+        stream,
+      );
+      return applyMessageCorrections(groups, corrections, policy);
+    } catch (error) {
+      if (error.category !== ERROR_CATEGORIES.RESPONSE_FORMAT || attempt === 3) {
+        error.data = { ...error.data, messageRepairDraft: groups };
+        throw error;
+      }
+    }
+  }
+}
+
 export function validatePartition(groups, ids, requireSummary = true) {
   const remaining = new Set(ids);
   if (!Array.isArray(groups) || !groups.length)
@@ -777,15 +874,10 @@ export async function planAnalyzedChanges(config, facts, coverage = null, stream
       };
       const groups = await jsonCall(
         config,
-        `Each commit message must follow this policy: ${JSON.stringify(policy)}.\nGroup related changes into logical commits, including related implementation and tests across directories. Return [{"ids":[input IDs],"summary":"factual combined change summary","subject":"commit subject","body":"optional commit body"}]. Assign every input ID exactly once. Do not merge unrelated changes just to reduce group count.${finalPlan ? ' The summary field is optional in this final plan.' : ''}${!deep && level === 0 ? ' Inputs are a compact local inventory, not full semantic summaries. One ID may represent multiple files and must remain atomic; use kind, module, status, fileCount, examples, and any representativeExcerpt conservatively.' : ''}`,
+        `Each commit message must follow this policy: ${JSON.stringify(policy)}.\nThe subject field must contain the complete Conventional Commit header: <type>[optional scope][optional !]: <description>. Respect the policy's language, scope, length, body, and breaking-change rules; include a body when required and omit it when forbidden.\nGroup related changes into logical commits, including related implementation and tests across directories. Return [{"ids":[input IDs],"summary":"factual combined change summary","subject":"complete commit header","body":"commit body if permitted or required"}]. Assign every input ID exactly once. Do not merge unrelated changes just to reduce group count.${finalPlan ? ' The summary field is optional in this final plan.' : ''}${!deep && level === 0 ? ' Inputs are a compact local inventory, not full semantic summaries. One ID may represent multiple files and must remain atomic; use kind, module, status, fileCount, examples, and any representativeExcerpt conservatively.' : ''}`,
         batch,
         (candidate) => {
           validatePartition(candidate, ids, false);
-          if (candidate.some((group) => typeof group.subject !== 'string' || !group.subject.trim()))
-            throw fail(
-              ERROR_CATEGORIES.RESPONSE_FORMAT,
-              'Analysis plan is missing a commit subject.',
-            );
         },
         batchStream,
       );
@@ -812,8 +904,15 @@ export async function planAnalyzedChanges(config, facts, coverage = null, stream
         });
       }
     }
-    if (batches.length === 1)
-      return next.map(({ subject, body, files }) => ({ subject, body, files }));
+    if (batches.length === 1) {
+      const plan = next.map(({ subject, body, files }) => ({ subject, body, files }));
+      try {
+        return await repairPlanMessages(config, plan, policy, stream);
+      } catch (error) {
+        error.data = { ...error.data, messageRepairDraft: plan, messageRepairComplete: true };
+        throw error;
+      }
+    }
     candidates = next;
   }
   throw fail(ERROR_CATEGORIES.PROVIDER, 'Split planning exceeded the maximum summary depth.', {

package/src/split.js

@@ -8,6 +8,7 @@ import {
   readlinkSync,
   realpathSync,
   rmSync,
+  writeFileSync,
   constants as fsConstants,
 } from 'node:fs';
 import { createHash } from 'node:crypto';
@@ -71,6 +72,8 @@ import {
   analysisConfig,
   analyzeChanges,
   planAnalyzedChanges,
+  invalidPlanMessages,
+  applyMessageCorrections,
   summarizeChanges,
 } from './change-analysis.js';
 import { updateGitHash, spoolGit } from './git-spool.js';
@@ -675,6 +678,35 @@ async function editPlan(groups, allFiles, language, commitPolicy) {
   }
 }
 
+async function editInvalidPlanMessages(groups, policy) {
+  let draft = JSON.stringify(invalidPlanMessages(groups, policy), null, 2);
+  while (true) {
+    const action = await vimSelect({
+      message: 'File grouping is ready. Edit the invalid commit messages to continue?',
+      choices: [
+        { name: 'Edit commit messages', value: 'edit' },
+        { name: 'Cancel', value: 'cancel' },
+      ],
+    });
+    if (action === 'cancel') return null;
+    const edited = await editor({
+      message: 'Fix subject/body fields; keep each id unchanged. Save and close to validate.',
+      default: draft,
+      postfix: '.json',
+      waitForUseInput: false,
+    });
+    try {
+      const candidate = JSON.parse(edited);
+      const corrected = applyMessageCorrections(groups, candidate, policy);
+      return corrected;
+    } catch (error) {
+      // Keep the user's edits available for the next attempt, including invalid JSON.
+      console.error(`  ${sanitizeTerminalText(error.message)}`);
+      draft = edited;
+    }
+  }
+}
+
 // Common binary formats — sending their bytes to the model as utf-8 garbage
 // helps no one, so previews are skipped for these extensions.
 const BINARY_FILE_RE =
@@ -1836,7 +1868,7 @@ export async function splitFlow(
       reasoning: config.reasoning,
       machineOutput,
       cancelMessage: 'Split cancelled.',
-      failureMessage: 'API call failed',
+      failureMessage: 'Split planning failed',
       task: async (stream) => {
         if (large) {
           let plan;
@@ -1880,6 +1912,9 @@ export async function splitFlow(
               );
             }
           } catch (err) {
+            // A validated partition must not become an all-files fallback just
+            // because repairing its messages exhausted the remaining budget.
+            if (err.data?.messageRepairDraft) throw err;
             const exhausted =
               err.data?.analysis?.exhausted ||
               (!planningConfig.analysisBudget.remainingMs() ? 'time' : null);
@@ -1950,9 +1985,58 @@ export async function splitFlow(
       },
     }));
   } catch (err) {
-    console.log(`\n  ${indentError(err)}\n`);
-    err.reported = true;
-    throw err;
+    if (
+      err.data?.messageRepairComplete &&
+      !yes &&
+      !machineOutput &&
+      process.stdin.isTTY &&
+      process.stdout.isTTY
+    ) {
+      console.error(`  ${indentError(err)}`);
+      const corrected = await editInvalidPlanMessages(
+        err.data.messageRepairDraft,
+        normalizeCommitPolicy(config.commitPolicy, config.language),
+      );
+      if (!corrected) return finishCancelled();
+      raw = JSON.stringify(corrected);
+      elapsed = planningConfig.analysisBudget.snapshot().elapsedMs;
+      usage = planningConfig.analysisBudget.snapshot().usage;
+      reasoningText = null;
+      warnings.push('Commit messages were corrected manually; the file grouping was preserved.');
+    }
+    if (!raw && err.data?.messageRepairDraft && protectModelInput) {
+      try {
+        const directory = mkdtempSync(join(tmpdir(), 'aicommit-message-repair-'));
+        const path = join(directory, 'draft.json');
+        writeFileSync(
+          path,
+          JSON.stringify(
+            {
+              kind: 'aicommit-message-repair-draft',
+              notice:
+                'Complete file grouping with invalid messages; not an apply-ready split plan.',
+              groups: err.data.messageRepairDraft,
+            },
+            null,
+            2,
+          ) + '\n',
+          { mode: 0o600, flag: 'wx' },
+        );
+        err.data.messageRepairDraftPath = path;
+        console.error(
+          `  Message repair draft saved to ${path} (complete grouping, not apply-ready).`,
+        );
+      } catch (writeError) {
+        console.error(
+          `  Could not save message repair draft: ${sanitizeTerminalText(writeError.message)}`,
+        );
+      }
+    }
+    if (!raw) {
+      console.log(`\n  ${indentError(err)}\n`);
+      err.reported = true;
+      throw err;
+    }
   }
 
   let groups;