mini-coder 0.5.11 → 0.5.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mini-coder",
-  "version": "0.5.11",
+  "version": "0.5.13",
   "description": "A small, fast CLI coding agent",
   "module": "src/index.ts",
   "type": "module",
@@ -18,17 +18,18 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@cel-tui/components": "^0.7.2",
-    "@cel-tui/core": "^0.7.2",
-    "@cel-tui/types": "^0.7.2",
-    "@mariozechner/pi-ai": "^0.66.1"
+    "@cel-tui/components": "^0.8.1",
+    "@cel-tui/core": "^0.8.1",
+    "@cel-tui/types": "^0.8.1",
+    "@mariozechner/pi-ai": "^0.67.68",
+    "@modelcontextprotocol/sdk": "^1.29.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.12",
     "@types/bun": "^1.3.12",
-    "lefthook": "^2.1.5",
+    "lefthook": "^2.1.6",
     "prettier": "^3.8.3",
-    "typescript": "^6.0.2"
+    "typescript": "^6.0.3"
   },
   "license": "MIT"
 }

package/skills-lock.json

@@ -0,0 +1,15 @@
+{
+  "version": 1,
+  "skills": {
+    "bun-development": {
+      "source": "sickn33/antigravity-awesome-skills",
+      "sourceType": "github",
+      "computedHash": "87e59a1e7f7fe512333aad64022955501a4e36be6e65487196dfc311e5b786b7"
+    },
+    "typescript-advanced-types": {
+      "source": "wshobson/agents",
+      "sourceType": "github",
+      "computedHash": "3a3be8c925f96ac4e1280db28a01677e7ca5197f3792de2bbf35ab3bb324b6dd"
+    }
+  }
+}

package/src/agent.ts

@@ -418,6 +418,19 @@ function buildIncompleteAssistantMessage(
   };
 }
 
+async function resolveStreamResultSoon(
+  streamResult: Promise<AssistantMessage>,
+): Promise<AssistantMessage | undefined> {
+  const pending = Symbol("pending");
+  const result = await Promise.race([
+    streamResult,
+    new Promise<typeof pending>((resolve) => {
+      setTimeout(() => resolve(pending), 0);
+    }),
+  ]);
+  return result === pending ? undefined : result;
+}
+
 async function streamAssistantMessage(
   opts: Pick<
     RunAgentOpts,
@@ -455,7 +468,13 @@ async function streamAssistantMessage(
   }
 
   // `end(result)` resolves the final result without emitting a terminal event.
+  // Some wrappers settle that promise on the next task, so give it one more
+  // turn before treating the stream as incomplete.
   await Promise.resolve();
+  if (!assistantMessage && !settledStreamResult) {
+    settledStreamResult = await resolveStreamResultSoon(streamResult);
+  }
+
   const finalAssistantMessage =
     assistantMessage ??
     settledStreamResult ??
@@ -596,6 +615,7 @@ function appendToolResultMessage(
     toolCallId: toolCall.id,
     toolName: toolCall.name,
     content: result.content,
+    ...(result.details !== undefined ? { details: result.details } : {}),
     isError: result.isError,
     timestamp: Date.now(),
   };

package/src/cli.ts

@@ -32,7 +32,8 @@ export interface TtyState {
  * Parse supported CLI arguments.
  *
  * Supports `-p, --prompt <text>` for headless one-shot mode and `--json`
- * to stream NDJSON events instead of the default final-text output.
+ * to stream NDJSON events instead of the default final-text mode
+ * (stdout final answer plus stderr activity snippets).
  * Unknown flags and positional arguments fail eagerly.
  *
  * @param argv - Process arguments excluding the Bun executable and script path.

package/src/headless.ts

@@ -12,6 +12,11 @@ import {
   type SubmitTurnHooks,
   submitResolvedInput,
 } from "./submit.ts";
+import {
+  collapseWhitespaceToNull,
+  joinTextBlocks,
+  truncateText,
+} from "./text.ts";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -22,32 +27,80 @@ type HeadlessStopReason = "stop" | "length" | "error" | "aborted";
 /** Options for a headless NDJSON run. */
 export interface HeadlessRunOptions {
   /** Optional line writer for completed NDJSON event output. */
-  writeLine?: (line: string) => void;
+  writeLine?: (line: string) => void | Promise<void>;
 }
 
 /** Options for a headless final-text run. */
 export interface HeadlessTextRunOptions {
+  /** Optional writer for lightweight assistant-activity snippets. */
+  writeActivity?: (text: string) => void | Promise<void>;
   /** Optional writer for the final assistant text output. */
-  writeText?: (text: string) => void;
+  writeText?: (text: string) => void | Promise<void>;
 }
 
 interface HeadlessOutputController {
-  /** Write text to stdout with broken-pipe handling. */
+  /** Queue text for one output stream with broken-pipe handling. */
   write(text: string): void;
-  /** Attach SIGINT/stdout error handlers for the active run. */
+  /** Attach error handlers for the active run. */
   attach(): void;
-  /** Remove SIGINT/stdout error handlers after the run. */
+  /** Remove error handlers after the run. */
   detach(): void;
-  /** Resolve the final stop reason, converting broken pipes into quiet shutdowns. */
-  finalize(stopReason: HeadlessStopReason): HeadlessStopReason;
+  /** Wait for queued writes and resolve the final stop reason. */
+  finalize(stopReason: HeadlessStopReason): Promise<HeadlessStopReason>;
+}
+
+interface HeadlessProcessStream {
+  /** Register an output-stream error handler. */
+  on(event: "error", listener: (error: unknown) => void): void;
+  /** Remove an output-stream error handler. */
+  off(event: "error", listener: (error: unknown) => void): void;
+  /** Write a text chunk to the stream. */
+  write(text: string, callback?: () => void): boolean;
 }
 
+const HEADLESS_ACTIVITY_MAX_CHARS = 160;
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
-function defaultWrite(text: string): void {
-  process.stdout.write(text);
+function defaultWrite(
+  stream: HeadlessProcessStream,
+  text: string,
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+
+    const cleanup = (): void => {
+      stream.off("error", handleError);
+    };
+
+    const settle = (callback: () => void): void => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      callback();
+    };
+
+    const handleError = (error: unknown): void => {
+      settle(() => {
+        reject(error);
+      });
+    };
+
+    stream.on("error", handleError);
+    try {
+      stream.write(text, () => {
+        settle(resolve);
+      });
+    } catch (error) {
+      settle(() => {
+        reject(error);
+      });
+    }
+  });
 }
 
 function isBrokenPipeError(error: unknown): boolean {
@@ -110,6 +163,17 @@ function extractAssistantText(message: AssistantMessage | null): string {
     .join("");
 }
 
+function extractAssistantActivitySnippet(
+  message: AssistantMessage,
+): string | null {
+  if (!message.content.some((block) => block.type === "toolCall")) {
+    return null;
+  }
+
+  const text = collapseWhitespaceToNull(joinTextBlocks(message.content));
+  return text ? truncateText(text, HEADLESS_ACTIVITY_MAX_CHARS) : null;
+}
+
 function shouldWriteHeadlessJsonEvent(event: AgentEvent): boolean {
   switch (event.type) {
     case "user_message":
@@ -126,11 +190,17 @@ function shouldWriteHeadlessJsonEvent(event: AgentEvent): boolean {
 
 function createHeadlessOutputController(
   state: AppState,
-  writeImpl: (text: string) => void,
+  stream: HeadlessProcessStream,
+  writeImpl: (text: string) => void | Promise<void>,
+  options?: {
+    attachSigint?: boolean;
+  },
 ): HeadlessOutputController {
   let brokenPipe = false;
   let outputError: unknown = null;
+  let pendingWrite = Promise.resolve();
   const sigintHandler = createSigintHandler(state);
+  const attachSigint = options?.attachSigint ?? true;
 
   const stopForBrokenPipe = (): void => {
     if (brokenPipe) {
@@ -140,40 +210,52 @@ function createHeadlessOutputController(
     state.abortController?.abort();
   };
 
-  const stdoutErrorHandler = (error: unknown): void => {
+  const failOutput = (error: unknown): void => {
     if (isBrokenPipeError(error)) {
       stopForBrokenPipe();
       return;
     }
 
-    outputError = error;
+    outputError = outputError ?? error;
     state.abortController?.abort();
   };
 
+  const streamErrorHandler = (error: unknown): void => {
+    failOutput(error);
+  };
+
   return {
     write(text) {
-      if (brokenPipe) {
+      if (brokenPipe || outputError) {
         return;
       }
 
-      try {
-        writeImpl(text);
-      } catch (error) {
-        if (!isBrokenPipeError(error)) {
-          throw error;
+      pendingWrite = pendingWrite.then(async () => {
+        if (brokenPipe || outputError) {
+          return;
         }
-        stopForBrokenPipe();
-      }
+
+        try {
+          await writeImpl(text);
+        } catch (error) {
+          failOutput(error);
+        }
+      });
     },
     attach() {
-      process.stdout.on("error", stdoutErrorHandler);
-      process.on("SIGINT", sigintHandler);
+      stream.on("error", streamErrorHandler);
+      if (attachSigint) {
+        process.on("SIGINT", sigintHandler);
+      }
     },
     detach() {
-      process.stdout.off("error", stdoutErrorHandler);
-      process.off("SIGINT", sigintHandler);
+      stream.off("error", streamErrorHandler);
+      if (attachSigint) {
+        process.off("SIGINT", sigintHandler);
+      }
     },
-    finalize(stopReason) {
+    async finalize(stopReason) {
+      await pendingWrite;
       if (outputError) {
         throw outputError;
       }
@@ -203,7 +285,8 @@ export async function runHeadlessPrompt(
   const content = resolveHeadlessContent(state, rawInput);
   const output = createHeadlessOutputController(
     state,
-    options?.writeLine ?? ((line) => defaultWrite(`${line}\n`)),
+    process.stdout,
+    options?.writeLine ?? ((line) => defaultWrite(process.stdout, `${line}\n`)),
   );
   const hooks: SubmitTurnHooks = {
     onEvent: (event) => {
@@ -222,18 +305,19 @@ export async function runHeadlessPrompt(
       state,
       hooks,
     );
-    return output.finalize(stopReason);
+    return await output.finalize(stopReason);
   } finally {
     output.detach();
   }
 }
 
 /**
- * Run a single headless prompt to completion and write only the final assistant text.
+ * Run a single headless prompt to completion and write the final assistant text.
  *
  * The raw input is parsed with the same rules as interactive input. Slash
- * commands are rejected in headless mode. Only the final persisted assistant
- * message's text content is written to stdout.
+ * commands are rejected in headless mode. The final assistant text is written
+ * to stdout, while lightweight assistant commentary snippets from tool-use
+ * turns are written to stderr.
  *
  * @param state - Mutable application state for the run.
  * @param rawInput - Exact raw prompt text supplied by the user.
@@ -246,20 +330,43 @@ export async function runHeadlessPromptText(
   options?: HeadlessTextRunOptions,
 ): Promise<HeadlessStopReason> {
   const content = resolveHeadlessContent(state, rawInput);
-  const output = createHeadlessOutputController(
+  const finalOutput = createHeadlessOutputController(
+    state,
+    process.stdout,
+    options?.writeText ?? ((text) => defaultWrite(process.stdout, text)),
+  );
+  const activityOutput = createHeadlessOutputController(
     state,
-    options?.writeText ?? defaultWrite,
+    process.stderr,
+    options?.writeActivity ?? ((text) => defaultWrite(process.stderr, text)),
+    { attachSigint: false },
   );
   let finalAssistantMessage: AssistantMessage | null = null;
   const hooks: SubmitTurnHooks = {
     onEvent: (event) => {
-      if (event.type === "assistant_message") {
-        finalAssistantMessage = event.message;
+      switch (event.type) {
+        case "assistant_message": {
+          const activitySnippet = extractAssistantActivitySnippet(
+            event.message,
+          );
+          if (activitySnippet) {
+            activityOutput.write(`${activitySnippet}\n`);
+          }
+          return;
+        }
+        case "done":
+        case "error":
+        case "aborted":
+          finalAssistantMessage = event.message;
+          return;
+        default:
+          return;
       }
     },
   };
 
-  output.attach();
+  finalOutput.attach();
+  activityOutput.attach();
   try {
     const stopReason = await submitResolvedInput(
       rawInput,
@@ -269,10 +376,17 @@ export async function runHeadlessPromptText(
     );
     const finalText = extractAssistantText(finalAssistantMessage);
     if (finalText.length > 0) {
-      output.write(finalText);
+      finalOutput.write(finalText);
     }
-    return output.finalize(stopReason);
+    const [finalStopReason, activityStopReason] = await Promise.all([
+      finalOutput.finalize(stopReason),
+      activityOutput.finalize(stopReason),
+    ]);
+    return finalStopReason === "stop" || activityStopReason === "stop"
+      ? "stop"
+      : stopReason;
   } finally {
-    output.detach();
+    activityOutput.detach();
+    finalOutput.detach();
   }
 }