min-agent 0.1.8 → 0.2.0

package/dist/compaction.js

@@ -1,4 +1,6 @@
 import { generateText } from "ai";
+import { loadConfig } from "./config.js";
+import { resolveModel } from "./provider.js";
 /**
  * Context compaction system — modeled after opencode's SessionCompaction.
  *
@@ -6,11 +8,13 @@ import { generateText } from "ai";
  * 1. Real token tracking from API responses
  * 2. Structured summary template (Goal/Progress/Decisions/Files)
  * 3. Incremental summaries (update previous summary instead of rewriting)
- * 4. Tool output pruning (trim old tool results to save space)
- * 5. Auto-continue after compaction
+ * 4. Tool output pruning with skill protection
+ * 5. Auto-continue after compaction with overflow replay
  * 6. Token-budget-aware tail preservation
+ * 7. Model-aware thresholds (uses actual context window)
+ * 8. Configurable compaction model
  */
-// ─── Structured Summary Template (from opencode) ───────────────────────────
+// ─── Structured Summary Template ───────────────────────────────────────────
 const SUMMARY_TEMPLATE = `Output exactly the Markdown structure shown below. Keep the section order unchanged.
 
 ## Goal
@@ -54,8 +58,9 @@ const TAIL_TOKEN_BUDGET_RATIO = 0.25;
 const MIN_TAIL_BUDGET = 2000;
 const MAX_TAIL_BUDGET = 8000;
 const PRUNE_PROTECT_TOKENS = 40000;
-const PRUNE_MIN_SAVINGS = 20000;
 const TOOL_OUTPUT_MAX_CHARS = 2000;
+/** Tools whose output should never be pruned during compaction */
+const PRUNE_PROTECTED_TOOLS = new Set(["skill"]);
 // ─── Token Tracker ─────────────────────────────────────────────────────────
 export class TokenTracker {
     _lastInputTokens = 0;
@@ -88,7 +93,7 @@ export class TokenTracker {
     }
 }
 // ─── Token Estimation ──────────────────────────────────────────────────────
-/** Rough token estimation (fallback) */
+/** Token estimation: ~4 chars per token (aligned with opencode) */
 export function estimateTokens(messages) {
     let chars = 0;
     for (const msg of messages) {
@@ -103,70 +108,91 @@ export function estimateTokens(messages) {
             }
         }
     }
-    return Math.ceil(chars / 3);
+    return Math.ceil(chars / 4);
 }
 function estimateMessageTokens(msg) {
     if (typeof msg.content === "string")
-        return Math.ceil(msg.content.length / 3);
+        return Math.ceil(msg.content.length / 4);
     if (Array.isArray(msg.content)) {
         let chars = 0;
         for (const part of msg.content) {
             if ("text" in part && typeof part.text === "string")
                 chars += part.text.length;
         }
-        return Math.ceil(chars / 3);
+        return Math.ceil(chars / 4);
     }
     return 0;
 }
 // ─── Compaction Check ──────────────────────────────────────────────────────
+/**
+ * Check if compaction is needed.
+ * Uses model-aware context window from config or getContextWindow cache.
+ */
 export function needsCompaction(messages, tracker, config) {
-    const maxTokens = config?.maxTokens ?? DEFAULT_MAX_TOKENS;
+    const maxTokens = config?.maxTokens ?? getMaxTokensFromConfig();
     const threshold = maxTokens * COMPACTION_RATIO;
     if (tracker && tracker.lastInputTokens > 0) {
         return tracker.lastInputTokens > threshold;
     }
     return estimateTokens(messages) > threshold;
 }
+/** Get max tokens from user config (model-aware) */
+function getMaxTokensFromConfig() {
+    const cfg = loadConfig();
+    return cfg.provider?.contextWindow ?? DEFAULT_MAX_TOKENS;
+}
 // ─── Tool Output Pruning ───────────────────────────────────────────────────
 /**
  * Prune old tool outputs in-place to free context space.
- * Keeps recent tool outputs intact, trims older ones to a short summary.
+ * Keeps recent tool outputs intact, trims older ones.
+ * Protects skill tool outputs from pruning.
  * Returns the estimated tokens saved.
  */
 export function pruneToolOutputs(messages) {
     let totalTokens = 0;
     let saved = 0;
     let turns = 0;
-    // Walk backwards, skip recent 2 turns
     for (let i = messages.length - 1; i >= 0; i--) {
         const msg = messages[i];
         if (msg.role === "user")
             turns++;
         if (turns < 2)
             continue;
-        // Prune tool results in older messages
+        // Check if this is a tool result
         if (msg.role === "tool" || (Array.isArray(msg.content) && msg.content.some((p) => p.type === "tool-result"))) {
+            // Skip protected tools (skill results are never pruned)
+            if (isProtectedToolMessage(msg))
+                continue;
             const content = typeof msg.content === "string" ? msg.content : "";
-            const estimate = Math.ceil(content.length / 3);
+            const estimate = Math.ceil(content.length / 4);
             totalTokens += estimate;
             if (totalTokens > PRUNE_PROTECT_TOKENS && content.length > TOOL_OUTPUT_MAX_CHARS) {
                 const truncated = content.slice(0, TOOL_OUTPUT_MAX_CHARS) + "\n\n[... output truncated during compaction ...]";
                 msg.content = truncated;
-                saved += estimate - Math.ceil(truncated.length / 3);
+                saved += estimate - Math.ceil(truncated.length / 4);
             }
         }
     }
     return saved;
 }
+/** Check if a message is from a protected tool (e.g. skill) */
+function isProtectedToolMessage(msg) {
+    if (typeof msg.content === "string") {
+        // Skill tool outputs are wrapped in <skill_content> tags
+        return msg.content.includes("<skill_content");
+    }
+    if (Array.isArray(msg.content)) {
+        return msg.content.some((p) => p.type === "tool-result" && PRUNE_PROTECTED_TOOLS.has(p.toolName ?? ""));
+    }
+    return false;
+}
 /**
  * Select how many recent turns to keep verbatim based on token budget.
- * Similar to opencode's select() function.
  */
 function selectTail(messages, config) {
-    const maxTokens = config?.maxTokens ?? DEFAULT_MAX_TOKENS;
+    const maxTokens = config?.maxTokens ?? getMaxTokensFromConfig();
     const tailTurns = config?.keepRecentTurns ?? DEFAULT_TAIL_TURNS;
     const budget = Math.min(MAX_TAIL_BUDGET, Math.max(MIN_TAIL_BUDGET, Math.floor(maxTokens * TAIL_TOKEN_BUDGET_RATIO)));
-    // Find user message boundaries (turns)
     const turnStarts = [];
     for (let i = 0; i < messages.length; i++) {
         if (messages[i].role === "user")
@@ -175,7 +201,6 @@ function selectTail(messages, config) {
     if (turnStarts.length <= 1) {
         return { headEnd: 0, tailStart: 0 };
     }
-    // Try to keep the last N turns within budget
     let tokensUsed = 0;
     let tailStart = messages.length;
     const recentTurns = turnStarts.slice(-tailTurns);
@@ -197,7 +222,7 @@ function selectTail(messages, config) {
         tailStart = 0;
     return { headEnd: tailStart, tailStart };
 }
-// ─── Compaction Agent Prompt ────────────────────────────────────────────────
+// ─── Compaction Agent ──────────────────────────────────────────────────────
 const COMPACTION_AGENT_SYSTEM = `You are an anchored context summarization assistant for coding sessions.
 
 Summarize only the conversation history you are given. The newest turns may be kept verbatim outside your summary, so focus on the older context that still matters for continuing the work.
@@ -207,11 +232,22 @@ If the prompt includes a <previous-summary> block, treat it as the current ancho
 Always follow the exact output structure requested by the user prompt. Keep every section, preserve exact file paths and identifiers when known, and prefer terse bullets over paragraphs.
 
 Do not answer the conversation itself. Do not mention that you are summarizing, compacting, or merging context. Respond in the same language as the conversation.`;
-/** Previous summary stored in the first system message if present */
+/**
+ * Resolve the model to use for compaction.
+ * If config.compaction.model is set, use that (allows cheap/fast model for summaries).
+ * Otherwise falls back to the main model.
+ */
+function resolveCompactionModel(mainModel) {
+    const cfg = loadConfig();
+    const compactionModelId = cfg.compaction?.model;
+    if (compactionModelId) {
+        return resolveModel(compactionModelId);
+    }
+    return mainModel;
+}
 function extractPreviousSummary(messages) {
     const first = messages[0];
     if (first?.role === "system" && typeof first.content === "string" && first.content.includes("[Context Summary")) {
-        // Extract just the summary content after the header
         const match = first.content.match(/\[Context Summary[^\]]*\]\n\n([\s\S]*)/);
         return match?.[1];
     }
@@ -241,12 +277,33 @@ function messageToText(msg) {
     }
     return "";
 }
+/** Check if a message contains media (images, etc.) */
+function hasMedia(msg) {
+    if (!Array.isArray(msg.content))
+        return false;
+    return msg.content.some((p) => p.type === "image" || p.type === "file");
+}
+/** Extract text-only content from a message (strip media) */
+function extractTextOnly(msg) {
+    if (typeof msg.content === "string")
+        return msg.content;
+    if (Array.isArray(msg.content)) {
+        return msg.content
+            .filter((p) => p.type === "text")
+            .map((p) => p.text)
+            .join("\n");
+    }
+    return "";
+}
 /**
  * Compact messages by summarizing older history with structured template.
- * Supports incremental summaries and token-budget tail preservation.
+ * Supports incremental summaries, skill protection, configurable model,
+ * and overflow replay.
  */
 export async function compactMessages(messages, model, config) {
-    // Step 1: Prune old tool outputs first
+    const cfg = loadConfig();
+    const autoContinue = config?.autoContinue ?? cfg.compaction?.autoContinue ?? true;
+    // Step 1: Prune old tool outputs (skip skill results)
     pruneToolOutputs(messages);
     // Step 2: Select tail (recent turns to keep verbatim)
     const { headEnd, tailStart } = selectTail(messages, config);
@@ -262,15 +319,16 @@ export async function compactMessages(messages, model, config) {
         .map((msg) => {
         const role = msg.role;
         const text = messageToText(msg);
-        // Limit each message to avoid overwhelming the summarizer
         return `[${role}]: ${text.slice(0, 3000)}`;
     })
         .join("\n\n");
-    // Step 5: Generate structured summary using dedicated compaction agent
+    // Step 5: Resolve compaction model (may differ from main model)
+    const compactionModel = resolveCompactionModel(model);
+    // Step 6: Generate structured summary
     try {
         const prompt = buildCompactionPrompt(previousSummary);
         const result = await generateText({
-            model,
+            model: compactionModel,
             system: COMPACTION_AGENT_SYSTEM,
             messages: [
                 { role: "user", content: conversationText + "\n\n" + prompt },
@@ -284,11 +342,15 @@ export async function compactMessages(messages, model, config) {
             },
             ...toKeep,
         ];
-        const shouldContinue = config?.autoContinue !== false;
-        return { messages: compactedMessages, compacted: true, shouldContinue };
+        // Step 7: Check if the last user message had media — if so, provide replay text
+        let replayText;
+        const lastUserMsg = toKeep.find((m) => m.role === "user");
+        if (lastUserMsg && hasMedia(lastUserMsg)) {
+            replayText = extractTextOnly(lastUserMsg);
+        }
+        return { messages: compactedMessages, compacted: true, shouldContinue: autoContinue, replayText };
     }
     catch {
-        // Fallback: just keep the tail
         return { messages: toKeep, compacted: true, shouldContinue: false };
     }
 }

package/dist/confirm.js

@@ -1,33 +1,54 @@
+import { loadConfig } from "./config.js";
 let autoApprove = false;
 export function setAutoApprove(value) {
     autoApprove = value;
 }
 export function isAutoApprove() {
-    return autoApprove;
+    if (autoApprove)
+        return true;
+    const config = loadConfig();
+    return config.permission === "allow-all";
 }
 /** Optional readline interface to pause/resume during confirmation prompts. */
 let _rl = null;
 export function setConfirmReadline(rl) {
     _rl = rl;
 }
-/** Ask user for confirmation. Returns true if approved. */
+/** Optional TUI confirm handler — when set, confirm() delegates to the TUI overlay. */
+let _tuiConfirm = null;
+export function setTuiConfirm(handler) {
+    _tuiConfirm = handler;
+}
+/**
+ * Ask user for confirmation. Returns true if approved.
+ * Display order: detail first, then [y/N] prompt at the bottom.
+ */
 export async function confirm(message) {
-    if (autoApprove)
+    if (isAutoApprove())
         return true;
+    // If TUI mode is active, delegate to the TUI overlay
+    if (_tuiConfirm)
+        return _tuiConfirm(message);
     // Pause readline so it doesn't consume/echo the keystroke
     _rl?.pause();
-    process.stdout.write(`\n\n\x1b[1;34m⚠ ${message} [y/N] \x1b[0m\n\n`);
+    // Detail on top, prompt at the bottom
+    process.stdout.write(`\n\x1b[90m┌─ 即将执行 ─────────────────────────────────\x1b[0m\n`);
+    process.stdout.write(`\x1b[90m│\x1b[0m ${message}\n`);
+    process.stdout.write(`\x1b[90m└────────────────────────────────────────────\x1b[0m\n`);
+    process.stdout.write(`\n\x1b[1;34m? 是否允许执行？ [y/N] \x1b[0m`);
     return new Promise((resolve) => {
         const wasRaw = process.stdin.isRaw;
         if (process.stdin.isTTY)
             process.stdin.setRawMode(true);
+        // Ensure stdin is flowing so we can receive data even after readline pause
+        process.stdin.resume();
         const onData = (buf) => {
             const ch = buf.toString();
             process.stdin.removeListener("data", onData);
             if (process.stdin.isTTY)
                 process.stdin.setRawMode(wasRaw ?? false);
             // Echo the character and newline
-            process.stdout.write(ch === "\r" || ch === "\n" ? "\n" : `${ch}\n`);
+            process.stdout.write(ch === "\r" || ch === "\n" ? "\n\n" : `${ch}\n\n`);
             // Resume readline after confirmation
             _rl?.resume();
             const answer = ch.trim().toLowerCase();

package/dist/skills.js

@@ -25,6 +25,9 @@ export function discoverSkills(opts) {
         for (const match of matches) {
             const skill = parseSkillFile(match);
             if (skill) {
+                if (loadedSkills[skill.name]) {
+                    console.warn(`\x1b[33m  ⚠ Duplicate skill "${skill.name}": ${match} overrides ${loadedSkills[skill.name].location}\x1b[0m`);
+                }
                 loadedSkills[skill.name] = skill;
             }
         }
@@ -39,7 +42,6 @@ export function discoverSkills(opts) {
 function parseSkillFile(filePath) {
     try {
         const raw = readFileSync(filePath, "utf-8");
-        // Parse frontmatter (---\n...\n---)
         const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
         if (!fmMatch)
             return null;
@@ -67,13 +69,19 @@ export function getSkills() {
 export function getSkill(name) {
     return loadedSkills[name];
 }
+/**
+ * Skill tool — content is loaded on-demand when the model calls this tool.
+ * The tool description is kept minimal; the full skill list lives in the system prompt.
+ */
 export function getSkillsTool() {
     return tool({
-        description: buildSkillDescription(),
+        description: "Load a specialized skill when the task at hand matches one of the skills listed in the system prompt. " +
+            "Use this tool to inject the skill's instructions and resources into the current conversation. " +
+            "The skill name must match one of the skills listed in your system prompt under available_skills.",
         inputSchema: jsonSchema({
             type: "object",
             properties: {
-                name: { type: "string", description: "The name of the skill to load" },
+                name: { type: "string", description: "The name of the skill from available_skills" },
             },
             required: ["name"],
         }),
@@ -101,9 +109,10 @@ export function getSkillsTool() {
                 "",
                 skill.content,
                 "",
-                `Base directory: ${dir}`,
+                `Base directory for this skill: ${dir}`,
+                "Relative paths in this skill (e.g., scripts/, reference/) are relative to this base directory.",
                 "",
-                files.length ? `<skill_files>\n${files.map((f) => `  ${f}`).join("\n")}\n</skill_files>` : "",
+                files.length ? `<skill_files>\n${files.map((f) => `  <file>${path.join(dir, f)}</file>`).join("\n")}\n</skill_files>` : "",
                 `</skill_content>`,
             ]
                 .filter(Boolean)
@@ -111,25 +120,26 @@ export function getSkillsTool() {
         },
     });
 }
+/**
+ * System prompt section — verbose XML format for better model comprehension.
+ * Only name/description/location are injected; content is loaded on-demand via the skill tool.
+ */
 export function getSkillsSystemPrompt() {
     const skills = getSkills();
     if (skills.length === 0)
         return "";
     return [
-        "## Available Skills",
-        "Use the `skill` tool to load specialized instructions when a task matches a skill's description.",
-        "",
-        ...skills.map((s) => `- **${s.name}**: ${s.description}`),
-    ].join("\n");
-}
-function buildSkillDescription() {
-    const skills = getSkills();
-    if (skills.length === 0)
-        return "Load a specialized skill. No skills are currently available.";
-    return [
-        "Load a specialized skill that provides domain-specific instructions and workflows.",
+        "Skills provide specialized instructions and workflows for specific tasks.",
+        "Use the skill tool to load a skill when a task matches its description.",
         "",
-        "Available skills:",
-        ...skills.map((s) => `- ${s.name}: ${s.description}`),
+        "<available_skills>",
+        ...skills.flatMap((s) => [
+            "  <skill>",
+            `    <name>${s.name}</name>`,
+            `    <description>${s.description}</description>`,
+            `    <location>${s.location}</location>`,
+            "  </skill>",
+        ]),
+        "</available_skills>",
     ].join("\n");
 }

package/dist/tui/App.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, useInput } from "ink";
+import { Spinner } from "./Spinner.js";
+import { InputBar } from "./InputBar.js";
+import { MessageList } from "./MessageList.js";
+import { ConfirmBar } from "./ConfirmBar.js";
+import { StatusBar } from "./StatusBar.js";
+export function App({ initialState, onSubmit, onConfirm, onExit }) {
+    useInput((_input, key) => {
+        if (key.escape && initialState.isRunning) {
+            onExit();
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(MessageList, { messages: initialState.messages }), initialState.isRunning && (_jsx(Box, { paddingLeft: 1, children: _jsx(Spinner, { label: initialState.spinnerText || "思考中..." }) })), _jsx(StatusBar, { state: initialState }), initialState.confirmMessage ? (_jsx(ConfirmBar, { message: initialState.confirmMessage, onConfirm: onConfirm })) : (_jsx(InputBar, { onSubmit: onSubmit, disabled: initialState.isRunning, placeholder: initialState.isRunning ? "按 Esc 取消运行..." : "输入消息... (Ctrl+J 换行)" }))] }));
+}

package/dist/tui/ConfirmBar.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from "ink";
+export function ConfirmBar({ message, onConfirm }) {
+    useInput((input, key) => {
+        if (input.toLowerCase() === "y") {
+            onConfirm(true);
+        }
+        else if (input.toLowerCase() === "n" || key.escape || key.return) {
+            onConfirm(false);
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "blue", paddingX: 1, children: [_jsx(Box, { children: _jsx(Text, { color: "gray", children: "\u250C\u2500 \u5373\u5C06\u6267\u884C \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }) }), _jsx(Box, { paddingLeft: 1, children: _jsx(Text, { children: message }) }), _jsx(Box, { children: _jsx(Text, { color: "gray", children: "\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }) }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { bold: true, color: "blue", children: "? \u662F\u5426\u5141\u8BB8\u6267\u884C\uFF1F " }), _jsx(Text, { color: "green", children: "[y]" }), _jsx(Text, { color: "gray", children: " / " }), _jsx(Text, { color: "red", children: "[N]" })] })] }));
+}

package/dist/tui/InputBar.js

@@ -0,0 +1,83 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { Box, Text, useInput, useStdin } from "ink";
+/**
+ * Multi-line input bar.
+ * - Enter: submit
+ * - Shift+Enter (Kitty protocol terminals): new line
+ * - Ctrl+J: new line (universal fallback)
+ * - Backslash at end + Enter: continue on next line
+ */
+export function InputBar({ onSubmit, disabled, placeholder }) {
+    const [value, setValue] = useState("");
+    const [shiftEnterDetected, setShiftEnterDetected] = useState(false);
+    const { stdin } = useStdin();
+    // Listen for Kitty protocol Shift+Enter: ESC[13;2u
+    useEffect(() => {
+        if (!stdin || disabled)
+            return;
+        const handleData = (data) => {
+            const str = data.toString("utf-8");
+            // Kitty keyboard protocol: \x1b[13;2u = Shift+Enter
+            if (str.includes("\x1b[13;2u")) {
+                setShiftEnterDetected(true);
+                setValue((v) => v + "\n");
+            }
+        };
+        stdin.on("data", handleData);
+        return () => { stdin.off("data", handleData); };
+    }, [stdin, disabled]);
+    useInput((input, key) => {
+        if (disabled)
+            return;
+        // If we just handled a Shift+Enter via raw stdin, skip this cycle
+        if (shiftEnterDetected) {
+            setShiftEnterDetected(false);
+            return;
+        }
+        // Ctrl+J: insert newline
+        if (key.ctrl && input === "j") {
+            setValue((v) => v + "\n");
+            return;
+        }
+        // Enter: submit or continue if ends with backslash
+        if (key.return) {
+            if (value.endsWith("\\")) {
+                setValue((v) => v.slice(0, -1) + "\n");
+                return;
+            }
+            const text = value.trim();
+            if (text) {
+                onSubmit(text);
+                setValue("");
+            }
+            return;
+        }
+        // Backspace / Delete
+        if (key.backspace || key.delete) {
+            setValue((v) => v.slice(0, -1));
+            return;
+        }
+        // Escape, arrows, etc. — ignore (handled elsewhere)
+        if (key.escape || key.upArrow || key.downArrow || key.leftArrow || key.rightArrow)
+            return;
+        if (key.pageUp || key.pageDown)
+            return;
+        if (key.ctrl || key.meta)
+            return;
+        // Tab → 2 spaces
+        if (key.tab) {
+            setValue((v) => v + "  ");
+            return;
+        }
+        // Normal character input (including CJK)
+        if (input) {
+            setValue((v) => v + input);
+        }
+    }, { isActive: !disabled });
+    const isEmpty = value === "";
+    const lines = value.split("\n");
+    const isMultiline = lines.length > 1;
+    const borderColor = disabled ? "gray" : "cyan";
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: borderColor, paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: disabled ? "gray" : "cyan", children: "\u276F " }), isEmpty && placeholder ? (_jsx(Text, { color: "gray", dimColor: true, children: placeholder })) : (_jsxs(Text, { wrap: "wrap", children: [value, "\u2588"] }))] }), isMultiline && (_jsx(Box, { justifyContent: "flex-end", children: _jsxs(Text, { color: "gray", dimColor: true, children: [lines.length, " \u884C | Shift+Enter/Ctrl+J \u6362\u884C | Enter \u53D1\u9001"] }) }))] }));
+}

package/dist/tui/MessageList.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { MarkdownRenderer } from "../markdown.js";
+/**
+ * Message list — renders all messages naturally.
+ * Scrolling is handled by the terminal's own scrollback buffer.
+ */
+export function MessageList({ messages }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [messages.length === 0 && (_jsx(Box, { paddingLeft: 1, paddingTop: 1, children: _jsx(Text, { color: "gray", children: "\u8F93\u5165\u6D88\u606F\u5F00\u59CB\u5BF9\u8BDD\uFF0C\u8F93\u5165 /help \u67E5\u770B\u547D\u4EE4\uFF0CEsc \u53D6\u6D88\u8FD0\u884C" }) })), messages.map((msg) => (_jsx(MessageRow, { message: msg }, msg.id)))] }));
+}
+/** Render markdown content to ANSI-formatted string */
+function renderMarkdown(content) {
+    const md = new MarkdownRenderer();
+    const output = md.write(content);
+    const flushed = md.flush();
+    return output + flushed;
+}
+function MessageRow({ message }) {
+    switch (message.role) {
+        case "user":
+            return (_jsxs(Box, { paddingLeft: 1, marginTop: 1, children: [_jsxs(Text, { color: "cyan", bold: true, children: [">", " "] }), _jsx(Text, { children: message.content })] }));
+        case "assistant":
+            return (_jsx(Box, { paddingLeft: 1, children: _jsx(Text, { children: renderMarkdown(message.content) }) }));
+        case "thinking":
+            return (_jsx(Box, { paddingLeft: 1, children: _jsx(Text, { dimColor: true, children: message.content }) }));
+        case "tool":
+            return (_jsxs(Box, { paddingLeft: 1, children: [_jsxs(Text, { color: "yellow", children: ["\u26A1 ", message.toolName, " "] }), _jsx(Text, { color: "gray", children: message.content.length > 120 ? message.content.slice(0, 120) + "..." : message.content })] }));
+        case "system":
+            return (_jsx(Box, { paddingLeft: 1, children: _jsx(Text, { children: message.content }) }));
+        default:
+            return null;
+    }
+}

package/dist/tui/Spinner.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import InkSpinner from "ink-spinner";
+export function Spinner({ label }) {
+    return (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(InkSpinner, { type: "dots" }) }), label && _jsxs(Text, { color: "gray", children: [" ", label] })] }));
+}

package/dist/tui/StatusBar.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+export function StatusBar({ state }) {
+    const model = state.model || "unknown";
+    const tokens = state.tokenInfo;
+    let bar = "";
+    let barColor = "green";
+    if (tokens && tokens.contextWindow > 0) {
+        const pct = Math.round((tokens.input / tokens.contextWindow) * 100);
+        const filled = Math.round(pct / 10);
+        const empty = 10 - filled;
+        bar = `${tokens.input}/${tokens.contextWindow} ${"█".repeat(filled)}${"░".repeat(empty)} ${pct}%`;
+        barColor = pct >= 80 ? "red" : pct >= 50 ? "yellow" : "green";
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "─".repeat(60) }), _jsxs(Box, { children: [_jsx(Text, { children: " \uD83E\uDD16 min-agent" }), _jsxs(Text, { color: "gray", children: [" (", model, ")"] }), bar && (_jsxs(_Fragment, { children: [_jsx(Text, { children: "  " }), _jsx(Text, { color: barColor, children: bar })] }))] })] }));
+}