@hifullmoon/aicommit 2.6.0 → 2.6.2

package/CHANGELOG.md

@@ -4,6 +4,18 @@ This file lists notable user-facing changes. Internal refactors, test-only chang
 
 ## [Unreleased]
 
+## [2.6.2] - 2026-09-14
+
+### Fixed
+
+- MiniMax streaming now accepts both cumulative snapshots and ordinary deltas without duplicating thinking or corrupting split plans. The live thinking panel also updates batch progress after the spinner stops.
+
+## [2.6.1] - 2026-09-14
+
+### Fixed
+
+- Split mode now streams thinking during each large-change planning batch, with batch progress in the spinner; interactive review still shows only the final plan's reasoning.
+
 ## [2.6.0] - 2026-09-14
 
 ### Added
@@ -233,7 +245,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.0...HEAD
+[Unreleased]: https://github.com/hi-fullmoon/AICommit/compare/v2.6.2...HEAD
+[2.6.2]: https://github.com/hi-fullmoon/AICommit/releases/tag/v2.6.2
+[2.6.1]: https://github.com/hi-fullmoon/AICommit/releases/tag/v2.6.1
 [2.6.0]: https://github.com/hi-fullmoon/AICommit/releases/tag/v2.6.0
 [2.5.0]: https://github.com/hi-fullmoon/AICommit/releases/tag/v2.5.0
 [2.4.1]: https://github.com/hi-fullmoon/AICommit/releases/tag/v2.4.1

package/README.md

@@ -455,7 +455,7 @@ The staged index (or complete split-mode working tree, including untracked file
 
 Reasoning defaults to `on` with `medium` effort. It is mapped natively for OpenAI reasoning models, DeepSeek, OpenRouter, and MiniMax; models that do not expose reasoning continue normally and show an unavailable notice instead of failing. Official OpenAI endpoints validate the selected effort against the model generation before sending the request, so unsupported combinations such as `o3 --no-reasoning` or `gpt-5.1 --reasoning=max` fail locally with a clear list of supported levels. DeepSeek's current `deepseek-v4-flash` and `deepseek-v4-pro` models receive `thinking: { "type": "enabled" }` plus `reasoning_effort`; `medium`/`xhigh` are normalized to DeepSeek's `high` level.
 
-When reasoning mode is `on` (including via `--reasoning=<level>`), aicommit requests a streaming response and displays reasoning as it arrives. In `auto` mode it also displays thinking if the provider emits it, without forcing reasoning on. Split mode streams the final planning request's thinking, including when large changes use batched analysis; the review prompt keeps that reasoning available. Intermediate analysis batches show progress rather than mixing several reasoning streams. The live panel requires an interactive terminal, and JSON output never includes reasoning. The live view follows the newest two terminal lines by default; press `Ctrl+O` to expand or collapse the accumulated text during generation or review. Long expanded output is kept inside the terminal viewport—use `PageUp`/`PageDown` to read every page. Holding `Ctrl+O` counts as one toggle, so key repeat cannot leave duplicate panels behind. Output is sanitized and capped by `reasoning.maxDisplayChars`; providers that do not expose reasoning show a short unavailable notice.
+When reasoning mode is `on` (including via `--reasoning=<level>`), aicommit requests a streaming response and displays reasoning as it arrives. In `auto` mode it also displays thinking if the provider emits it, without forcing reasoning on. Split mode streams thinking from each sequential planning batch with a batch label; the review prompt keeps only the final plan's reasoning. Earlier deep-analysis chunks show progress. The live panel requires an interactive terminal, and JSON output never includes reasoning. The live view follows the newest two terminal lines by default; press `Ctrl+O` to expand or collapse the accumulated text during generation or review. Long expanded output is kept inside the terminal viewport—use `PageUp`/`PageDown` to read every page. Holding `Ctrl+O` counts as one toggle, so key repeat cannot leave duplicate panels behind. Output is sanitized and capped by `reasoning.maxDisplayChars`; providers that do not expose reasoning show a short unavailable notice.
 
 ```json
 {

package/README.zh-CN.md

@@ -457,7 +457,7 @@ exec zsh
 
 推理默认为 `on`，强度为 `medium`。OpenAI 推理模型、DeepSeek、OpenRouter 和 MiniMax 使用各自原生映射；不暴露推理能力的模型会正常继续，并显示“不可用”提示，而不是失败。官方 OpenAI 端点会在发送请求前根据模型代际校验所选强度，因此 `o3 --no-reasoning` 或 `gpt-5.1 --reasoning=max` 等不支持的组合会在本地失败，并清楚列出支持的级别。DeepSeek 当前的 `deepseek-v4-flash` 和 `deepseek-v4-pro` 会收到 `thinking: { "type": "enabled" }` 与 `reasoning_effort`；`medium` / `xhigh` 会归一化为 DeepSeek 的 `high` 级别。
 
-推理模式为 `on` 时（包括通过 `--reasoning=<level>` 启用），AICommit 会请求流式响应并实时显示推理；`auto` 模式下若 Provider 主动返回 think，也会显示，但不会强制开启推理。split 模式会显示最终规划请求的 think，大变更走分批分析时也一样，并在审阅界面保留这段内容；前面的分析批次只显示进度，避免多个推理流混在一起。实时面板需要交互式终端，JSON 输出始终不包含推理。默认实时视图跟随终端最新两行；生成或审阅期间按 `Ctrl+O` 可展开或收起累计文本。较长的展开输出会限制在终端视口内，可用 `PageUp` / `PageDown` 阅读所有页面。长按 `Ctrl+O` 只计为一次切换，避免按键重复留下多个面板。输出会经过清理，并受 `reasoning.maxDisplayChars` 限制；不暴露推理的 Provider 会显示简短的不可用提示。
+推理模式为 `on` 时（包括通过 `--reasoning=<level>` 启用），AICommit 会请求流式响应并实时显示推理；`auto` 模式下若 Provider 主动返回 think，也会显示，但不会强制开启推理。split 模式会按批次实时显示规划请求的 think，并标明当前批次；审阅界面只保留最终规划的推理。更早的深度分析分块仍只显示进度。实时面板需要交互式终端，JSON 输出始终不包含推理。默认实时视图跟随终端最新两行；生成或审阅期间按 `Ctrl+O` 可展开或收起累计文本。较长的展开输出会限制在终端视口内，可用 `PageUp` / `PageDown` 阅读所有页面。长按 `Ctrl+O` 只计为一次切换，避免按键重复留下多个面板。输出会经过清理，并受 `reasoning.maxDisplayChars` 限制；不暴露推理的 Provider 会显示简短的不可用提示。
 
 ```json
 {

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.0
+npm install --package-lock-only @hifullmoon/aicommit@2.6.2
 npm audit signatures
 ```
 

package/package.json

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

package/src/change-analysis.js

@@ -736,8 +736,29 @@ export async function planAnalyzedChanges(config, facts, coverage = null, stream
       coverage.metadataOnlyFiles = coverage.totalFiles - coverage.sampledFiles;
     }
     const next = [];
-    for (const batch of batches) {
+    for (const [batchIndex, batch] of batches.entries()) {
       const ids = batch.map((x) => x.id);
+      const finalPlan = batches.length === 1;
+      stream?.onProgress?.(
+        finalPlan
+          ? 'Planning final split merge ...'
+          : `Planning split batch ${batchIndex + 1}/${batches.length} ...`,
+      );
+      let startedThinking = false;
+      const batchStream = stream && {
+        onReasoningDelta(chunk) {
+          if (!startedThinking && chunk) {
+            startedThinking = true;
+            if (!finalPlan || level > 0) {
+              const stage = finalPlan ? 'final merge' : `batch ${batchIndex + 1}/${batches.length}`;
+              stream.onReasoningDelta?.(`\n\n[Planning ${stage}]\n`);
+            }
+          }
+          stream.onReasoningDelta?.(chunk);
+        },
+        // Only the final merge belongs in the subsequent review prompt.
+        onReasoningComplete: finalPlan ? (text) => stream.onReasoningComplete?.(text) : undefined,
+      };
       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.`,
@@ -750,9 +771,7 @@ export async function planAnalyzedChanges(config, facts, coverage = null, stream
               '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,
+        batchStream,
       );
       for (const group of groups) {
         next.push({

package/src/generation-ui.js

@@ -17,13 +17,25 @@ export async function runModelTask({
 }) {
   const spinner = ora({ text: chalk.dim(spinnerText), color: 'cyan' }).start();
   let liveReasoning;
+  let progressStatus = 'Thinking…';
+  const interactive = process.stdin.isTTY && process.stdout.isTTY;
   const stream =
     reasoning && reasoning.mode !== 'off' && !machineOutput
       ? {
+          onProgress(status) {
+            progressStatus = status;
+            if (liveReasoning) liveReasoning.setProgress(status);
+            else if (spinner.isSpinning) spinner.text = chalk.dim(status);
+          },
           onReasoningDelta(chunk) {
+            if (!interactive) return;
             if (!liveReasoning) {
               spinner.stop();
-              liveReasoning = startReasoningStream(reasoning.maxDisplayChars, chunk);
+              liveReasoning = startReasoningStream(
+                reasoning.maxDisplayChars,
+                chunk,
+                progressStatus,
+              );
               return;
             }
             liveReasoning.append(chunk);

package/src/model-client.js

@@ -236,7 +236,7 @@ function transport(config, adapter, state) {
           if (
             (response.headers.get('content-type') || '').toLowerCase().includes('text/event-stream')
           )
-            return normalizeEventStream(response);
+            return normalizeEventStream(response, adapter.id);
           let data;
           try {
             data = await response.json();

package/src/provider-response.js

@@ -89,14 +89,50 @@ function reasoningDelta(delta) {
   return primary + details;
 }
 
-function normalizeChunk(value) {
+// MiniMax may stream ordinary deltas or the cumulative snapshots shown in its
+// OpenAI-compatible example. Detect a snapshot only when it extends
+// the text already received; otherwise retain the chunk verbatim so repeated
+// ordinary deltas are not lost.
+function miniMaxIncrement(value, state) {
+  if (typeof value !== 'string' || !value) return value;
+  const prior = state.text;
+  if (prior && value.startsWith(prior)) {
+    if (value.length > prior.length) {
+      state.text = value;
+      state.cumulative = true;
+      return value.slice(prior.length);
+    }
+    if (state.cumulative) return '';
+  }
+  state.text += value;
+  state.cumulative = false;
+  return value;
+}
+
+function normalizeChunk(value, miniMaxChoices = null) {
   if (!value || !Array.isArray(value.choices)) return value;
   for (const choice of value.choices) {
     if (!choice || typeof choice !== 'object') continue;
     choice.finish_reason = normalizeFinishReason(choice.finish_reason);
     const delta = choice.delta ?? choice.message;
     if (!delta || typeof delta !== 'object') continue;
-    choice.delta = { ...delta, reasoning_content: reasoningDelta(delta) };
+    const reasoning = reasoningDelta(delta);
+    if (miniMaxChoices) {
+      const index = choice.index ?? 0;
+      if (!miniMaxChoices.has(index))
+        miniMaxChoices.set(index, {
+          content: { text: '', cumulative: false },
+          reasoning: { text: '', cumulative: false },
+        });
+      const state = miniMaxChoices.get(index);
+      choice.delta = {
+        ...delta,
+        content: miniMaxIncrement(delta.content, state.content),
+        reasoning_content: miniMaxIncrement(reasoning, state.reasoning),
+      };
+    } else {
+      choice.delta = { ...delta, reasoning_content: reasoning };
+    }
     // Retain reasoning_details for Pi's replay metadata while also exposing all
     // its textual segments as ordinary thinking deltas, including legacy shapes.
   }
@@ -106,10 +142,11 @@ function normalizeChunk(value) {
 // eventsource-parser handles UTF-8-decoded SSE framing; this boundary adjusts
 // only vendor fields. Pi still owns model-result assembly and finish validation.
 // Web Stream piping preserves backpressure, cancellation and body read errors.
-export function normalizeEventStream(response) {
+export function normalizeEventStream(response, provider = '') {
   if (!response.body)
     throw fail(ERROR_CATEGORIES.RESPONSE_FORMAT, 'Streaming response did not include a body.');
   let done = false;
+  const miniMaxChoices = provider === 'minimax' ? new Map() : null;
   const encoder = new globalThis.TextEncoder();
   const body = response.body
     .pipeThrough(new globalThis.TextDecoderStream())
@@ -132,7 +169,7 @@ export function normalizeEventStream(response) {
                 { cause },
               );
             }
-            data = JSON.stringify(normalizeChunk(value));
+            data = JSON.stringify(normalizeChunk(value, miniMaxChoices));
           }
           controller.enqueue(
             encoder.encode(`${event.event ? `event: ${event.event}\n` : ''}data: ${data}\n\n`),

package/src/split.js

@@ -1797,12 +1797,14 @@ export async function splitFlow(
           let planReasoning = null;
           const planningStream = stream
             ? {
+                onProgress(status) {
+                  stream.onProgress?.(status);
+                },
                 onReasoningDelta(chunk) {
-                  planReasoning = (planReasoning || '') + chunk;
                   stream.onReasoningDelta(chunk);
                 },
                 onReasoningComplete(text) {
-                  if (text) planReasoning = text;
+                  planReasoning = text || null;
                 },
               }
             : null;

package/src/ui.js

@@ -169,6 +169,7 @@ function expandedLineCapacity(reservedRows) {
 
 const reasoningStreamPrompt = createPrompt((config, done) => {
   const [text, setText] = useState(config.initialText || '');
+  const [progressText, setProgressText] = useState(config.initialProgress || 'Thinking…');
   const [expanded, setExpanded] = useState(false);
   const [reasoningOffset, setReasoningOffset] = useState(0);
   const [status, setStatus] = useState('streaming');
@@ -178,6 +179,7 @@ const reasoningStreamPrompt = createPrompt((config, done) => {
   const maxOffset = Math.max(0, completeView.totalLines - pageSize);
 
   config.controller.update = setText;
+  config.controller.updateProgress = setProgressText;
   config.controller.finish = () => {
     setStatus('done');
     done(text);
@@ -220,14 +222,18 @@ const reasoningStreamPrompt = createPrompt((config, done) => {
     maxExpandedLines: pageSize,
     offset: reasoningOffset,
   });
-  return `${panel}\n${chalk.dim('  Thinking…  Ctrl+C cancel')}\x1B[?25l`;
+  return `${panel}\n${chalk.dim(`  ${sanitizeTerminalText(progressText)}  Ctrl+C cancel`)}\x1B[?25l`;
 });
 
 // Start a redraw-safe live reasoning view. Updates are batched to one frame
 // every ~32ms so token-sized SSE chunks do not cause hundreds of terminal
 // redraws per second. The complete text remains available to the subsequent
 // review prompt after this temporary view is cleared.
-export function startReasoningStream(maxChars = 12000, initialText = '') {
+export function startReasoningStream(
+  maxChars = 12000,
+  initialText = '',
+  initialProgress = 'Thinking…',
+) {
   const controller = {};
   let accumulated = String(initialText || '');
   let timer = null;
@@ -238,6 +244,7 @@ export function startReasoningStream(maxChars = 12000, initialText = '') {
       append(chunk) {
         accumulated += String(chunk || '');
       },
+      setProgress() {},
       async stop() {
         stopped = true;
         return accumulated;
@@ -246,7 +253,7 @@ export function startReasoningStream(maxChars = 12000, initialText = '') {
   }
 
   const prompt = reasoningStreamPrompt(
-    { controller, maxChars, initialText: accumulated },
+    { controller, maxChars, initialText: accumulated, initialProgress },
     { clearPromptOnDone: true },
   );
 
@@ -256,6 +263,9 @@ export function startReasoningStream(maxChars = 12000, initialText = '') {
   };
 
   return {
+    setProgress(status) {
+      if (!stopped) controller.updateProgress?.(status);
+    },
     append(chunk) {
       if (stopped || !chunk) return;
       accumulated += String(chunk);