@hifullmoon/aicommit 2.6.1 → 2.6.2

package/CHANGELOG.md

@@ -4,6 +4,12 @@ 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
@@ -239,7 +245,8 @@ 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.1...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

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.1
+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.1",
+  "version": "2.6.2",
   "description": "Safe, local-first AI commit message generator for Git workflows",
   "type": "module",
   "bin": {

package/src/generation-ui.js

@@ -17,16 +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) {
-            if (spinner.isSpinning) spinner.text = chalk.dim(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/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);