min-agent 0.2.0 → 0.3.0

package/dist/clipboard.js

@@ -1,6 +1,18 @@
 import { execSync } from "child_process";
+import { readFileSync, unlinkSync } from "fs";
 import path from "path";
 import os from "os";
+function readTmpImage(tmpFile) {
+    const data = readFileSync(tmpFile);
+    try {
+        unlinkSync(tmpFile);
+    }
+    catch { }
+    return data.length > 0 ? data : null;
+}
+function tmpImagePath() {
+    return path.join(os.tmpdir(), `min-agent-paste-${Date.now()}.png`);
+}
 export function getClipboardImage() {
     switch (process.platform) {
         case "darwin":
@@ -13,18 +25,52 @@ export function getClipboardImage() {
             return null;
     }
 }
+/** Write plain text to the system clipboard. False on failure (silent). */
+export function writeClipboard(text) {
+    switch (process.platform) {
+        case "darwin":
+            try {
+                execSync("pbcopy", { input: text, stdio: "pipe" });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        case "linux": {
+            try {
+                execSync("xclip -selection clipboard", { input: text, stdio: "pipe" });
+                return true;
+            }
+            catch { }
+            try {
+                execSync("xsel --clipboard --input", { input: text, stdio: "pipe" });
+                return true;
+            }
+            catch { }
+            return false;
+        }
+        case "win32":
+            try {
+                execSync('powershell -NoProfile -Command "Set-Clipboard -Value ([Console]::In.ReadToEnd())"', {
+                    input: text,
+                    stdio: "pipe",
+                });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        default:
+            return false;
+    }
+}
 function getClipboardImageMac() {
-    const tmpFile = path.join(os.tmpdir(), `min-agent-paste-${Date.now()}.png`);
+    const tmpFile = tmpImagePath();
     try {
         // Try pngpaste first (brew install pngpaste)
         execSync(`pngpaste "${tmpFile}" 2>/dev/null`, { stdio: "pipe" });
-        const { readFileSync } = require("fs");
-        const data = readFileSync(tmpFile);
-        try {
-            require("fs").unlinkSync(tmpFile);
-        }
-        catch { }
-        if (data.length > 0)
+        const data = readTmpImage(tmpFile);
+        if (data)
             return { data, mimeType: "image/png" };
     }
     catch { }
@@ -44,13 +90,8 @@ function getClipboardImageMac() {
     `;
         const result = execSync(`osascript -e '${script.replace(/'/g, "'\\''")}'`, { encoding: "utf-8" }).trim();
         if (result === "ok") {
-            const { readFileSync, unlinkSync } = require("fs");
-            const data = readFileSync(tmpFile);
-            try {
-                unlinkSync(tmpFile);
-            }
-            catch { }
-            if (data.length > 0)
+            const data = readTmpImage(tmpFile);
+            if (data)
                 return { data, mimeType: "image/png" };
         }
     }
@@ -81,7 +122,7 @@ function getClipboardImageLinux() {
     return null;
 }
 function getClipboardImageWindows() {
-    const tmpFile = path.join(os.tmpdir(), `min-agent-paste-${Date.now()}.png`);
+    const tmpFile = tmpImagePath();
     try {
         const ps = `
       Add-Type -AssemblyName System.Windows.Forms
@@ -91,13 +132,8 @@ function getClipboardImageWindows() {
     `;
         const result = execSync(`powershell -NoProfile -Command "${ps}"`, { encoding: "utf-8" }).trim();
         if (result === "ok") {
-            const { readFileSync, unlinkSync } = require("fs");
-            const data = readFileSync(tmpFile);
-            try {
-                unlinkSync(tmpFile);
-            }
-            catch { }
-            if (data.length > 0)
+            const data = readTmpImage(tmpFile);
+            if (data)
                 return { data, mimeType: "image/png" };
         }
     }

package/dist/code-mode.js

@@ -7,19 +7,19 @@ export function scanProject() {
     let branch;
     if (isGitRepo) {
         try {
-            branch = execSync("git branch --show-current", { encoding: "utf-8", cwd }).trim();
+            branch = execSync("git branch --show-current", { encoding: "utf-8", cwd, timeout: 5000 }).trim();
         }
         catch { }
     }
     const languages = [];
     const configFiles = [];
     const entryFiles = [];
-    // Detect by config files
+    // Detect by config files (lockfiles first so they win over package.json)
     const checks = [
-        { file: "package.json", lang: "TypeScript/JavaScript", pm: "npm" },
         { file: "bun.lock", lang: "TypeScript/JavaScript", pm: "bun" },
         { file: "yarn.lock", lang: "TypeScript/JavaScript", pm: "yarn" },
         { file: "pnpm-lock.yaml", lang: "TypeScript/JavaScript", pm: "pnpm" },
+        { file: "package.json", lang: "TypeScript/JavaScript", pm: "npm" },
         { file: "tsconfig.json", lang: "TypeScript" },
         { file: "Cargo.toml", lang: "Rust", pm: "cargo" },
         { file: "go.mod", lang: "Go" },

package/dist/compaction.js

@@ -1,6 +1,8 @@
 import { generateText } from "ai";
-import { loadConfig } from "./config.js";
+import { loadConfig, getActiveProvider } from "./config.js";
 import { resolveModel } from "./provider.js";
+import { getContextWindow } from "./context-window.js";
+import { collectLoadedSkillNames, buildSkillReloadNote } from "./skills.js";
 /**
  * Context compaction system — modeled after opencode's SessionCompaction.
  *
@@ -57,7 +59,7 @@ const DEFAULT_TAIL_TURNS = 2;
 const TAIL_TOKEN_BUDGET_RATIO = 0.25;
 const MIN_TAIL_BUDGET = 2000;
 const MAX_TAIL_BUDGET = 8000;
-const PRUNE_PROTECT_TOKENS = 40000;
+const PRUNE_PROTECT_TOKENS = 24000;
 const TOOL_OUTPUT_MAX_CHARS = 2000;
 /** Tools whose output should never be pruned during compaction */
 const PRUNE_PROTECTED_TOOLS = new Set(["skill"]);
@@ -68,10 +70,15 @@ export class TokenTracker {
     _totalInputTokens = 0;
     _totalCacheRead = 0;
     update(usage) {
+        this.add(usage);
+        this._lastInputTokens = usage.inputTokens ?? 0;
+    }
+    /** Add to running totals only (e.g. compaction / sub-agent calls), without
+     * touching the "last step input" used for context-window display. */
+    add(usage) {
         const input = usage.inputTokens ?? 0;
         const output = usage.outputTokens ?? 0;
         const cacheRead = usage.cachedInputTokens ?? 0;
-        this._lastInputTokens = input;
         this._totalInputTokens += input;
         this._totalOutputTokens += output;
         this._totalCacheRead += cacheRead;
@@ -93,104 +100,146 @@ export class TokenTracker {
     }
 }
 // ─── Token Estimation ──────────────────────────────────────────────────────
-/** Token estimation: ~4 chars per token (aligned with opencode) */
-export function estimateTokens(messages) {
-    let chars = 0;
-    for (const msg of messages) {
-        if (typeof msg.content === "string") {
-            chars += msg.content.length;
-        }
-        else if (Array.isArray(msg.content)) {
-            for (const part of msg.content) {
-                if ("text" in part && typeof part.text === "string") {
-                    chars += part.text.length;
-                }
-            }
-        }
+function isCjk(code) {
+    return ((code >= 0x2e80 && code <= 0x9fff) ||
+        (code >= 0xf900 && code <= 0xfaff) ||
+        (code >= 0xff00 && code <= 0xffef) ||
+        (code >= 0x20000 && code <= 0x3fffd) ||
+        (code >= 0x3040 && code <= 0x30ff) ||
+        (code >= 0xac00 && code <= 0xd7af));
+}
+/** ~4 ASCII chars per token, CJK chars weighted separately (much denser in tokens). */
+function estimateTextTokens(text) {
+    let ascii = 0;
+    let other = 0;
+    for (const ch of text) {
+        if (isCjk(ch.codePointAt(0) ?? 0))
+            other++;
+        else
+            ascii++;
     }
-    return Math.ceil(chars / 4);
+    return ascii / 4 + other * 0.7;
 }
-function estimateMessageTokens(msg) {
-    if (typeof msg.content === "string")
-        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;
+function estimateMessageTextTokens(msg) {
+    const content = msg.content;
+    if (typeof content === "string")
+        return estimateTextTokens(content);
+    if (Array.isArray(content)) {
+        let tokens = 0;
+        for (const part of content) {
+            if ("text" in part && typeof part.text === "string") {
+                tokens += estimateTextTokens(part.text);
+            }
         }
-        return Math.ceil(chars / 4);
+        return tokens;
     }
     return 0;
 }
+/** Token estimation: ASCII ~4 chars/token, CJK ~0.7 token/char (aligned with opencode) */
+export function estimateTokens(messages) {
+    return Math.ceil(messages.reduce((sum, msg) => sum + estimateMessageTextTokens(msg), 0));
+}
+function estimateMessageTokens(msg) {
+    return Math.ceil(estimateMessageTextTokens(msg));
+}
 // ─── Compaction Check ──────────────────────────────────────────────────────
+/**
+ * Resolve max tokens: explicit user config first, then model-aware detection.
+ */
+async function resolveMaxTokens() {
+    const cfg = loadConfig();
+    const provider = getActiveProvider(cfg);
+    if (provider?.contextWindow)
+        return provider.contextWindow;
+    try {
+        return await getContextWindow(provider?.defaultModel);
+    }
+    catch {
+        return DEFAULT_MAX_TOKENS;
+    }
+}
 /**
  * Check if compaction is needed.
- * Uses model-aware context window from config or getContextWindow cache.
+ * Uses model-aware context window (user config or provider detection).
  */
-export function needsCompaction(messages, tracker, config) {
-    const maxTokens = config?.maxTokens ?? getMaxTokensFromConfig();
+export async function needsCompaction(messages, tracker, config) {
+    const maxTokens = config?.maxTokens ?? await resolveMaxTokens();
     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 ───────────────────────────────────────────────────
+function toolResultText(part) {
+    const out = part.output;
+    if (typeof out === "string")
+        return out;
+    if (out && typeof out === "object" && "value" in out) {
+        const v = out.value;
+        if (typeof v === "string")
+            return v;
+    }
+    return null;
+}
+function isProtectedToolMessage(msg) {
+    if (typeof msg.content === "string") {
+        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;
+}
 /**
- * Prune old tool outputs in-place to free context space.
- * Keeps recent tool outputs intact, trims older ones.
- * Protects skill tool outputs from pruning.
- * Returns the estimated tokens saved.
+ * Return a copy of messages with old tool outputs truncated to free context space.
+ * Keeps recent tool results intact, trims older ones.
+ * Protects skill tool results from pruning.
+ * Does not mutate the input.
  */
 export function pruneToolOutputs(messages) {
     let totalTokens = 0;
-    let saved = 0;
     let turns = 0;
+    const replaced = new Map();
     for (let i = messages.length - 1; i >= 0; i--) {
         const msg = messages[i];
         if (msg.role === "user")
             turns++;
         if (turns < 2)
             continue;
-        // 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))
+        if (msg.role !== "tool")
+            continue;
+        if (isProtectedToolMessage(msg))
+            continue;
+        const parts = [...msg.content];
+        let changed = false;
+        for (let j = 0; j < parts.length; j++) {
+            const p = parts[j];
+            if (p.type !== "tool-result")
                 continue;
-            const content = typeof msg.content === "string" ? msg.content : "";
-            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 / 4);
+            const text = toolResultText(p);
+            if (!text)
+                continue;
+            totalTokens += estimateTextTokens(text);
+            if (totalTokens > PRUNE_PROTECT_TOKENS && text.length > TOOL_OUTPUT_MAX_CHARS) {
+                const truncated = text.slice(0, TOOL_OUTPUT_MAX_CHARS) + "\n\n[... output truncated during compaction ...]";
+                parts[j] = { ...p, output: { type: "text", value: truncated } };
+                changed = true;
             }
         }
+        if (changed)
+            replaced.set(i, { ...msg, content: parts });
     }
-    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;
+    if (replaced.size === 0)
+        return messages;
+    return messages.map((msg, i) => replaced.get(i) ?? msg);
 }
 /**
  * Select how many recent turns to keep verbatim based on token budget.
  */
-function selectTail(messages, config) {
-    const maxTokens = config?.maxTokens ?? getMaxTokensFromConfig();
+async function selectTail(messages, config) {
+    const maxTokens = config?.maxTokens ?? await resolveMaxTokens();
     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)));
     const turnStarts = [];
@@ -245,14 +294,29 @@ function resolveCompactionModel(mainModel) {
     }
     return mainModel;
 }
+const SKILL_NOTE_HEADER = "## Skills Previously Loaded";
 function extractPreviousSummary(messages) {
     const first = messages[0];
     if (first?.role === "system" && typeof first.content === "string" && first.content.includes("[Context Summary")) {
         const match = first.content.match(/\[Context Summary[^\]]*\]\n\n([\s\S]*)/);
-        return match?.[1];
+        return match?.[1]?.split(SKILL_NOTE_HEADER)[0]?.trimEnd();
     }
     return undefined;
 }
+/** Skills listed in a previous compaction note, so repeated compactions don't forget them. */
+function extractNotedSkills(messages) {
+    const first = messages[0];
+    if (first?.role !== "system" || typeof first.content !== "string")
+        return [];
+    const section = first.content.split(SKILL_NOTE_HEADER)[1];
+    if (!section)
+        return [];
+    return section
+        .split("\n")
+        .filter((line) => line.startsWith("- "))
+        .map((line) => line.slice(2).replace(/\s*\(base dir:.*$/, "").trim())
+        .filter(Boolean);
+}
 function buildCompactionPrompt(previousSummary) {
     const anchor = previousSummary
         ? [
@@ -266,14 +330,32 @@ function buildCompactionPrompt(previousSummary) {
         : "Create a new anchored summary from the conversation history above.";
     return [anchor, "", SUMMARY_TEMPLATE].join("\n");
 }
+function isToolResultPart(p) {
+    return typeof p === "object" && p !== null && "type" in p && p.type === "tool-result";
+}
 function messageToText(msg) {
     if (typeof msg.content === "string")
         return msg.content;
     if (Array.isArray(msg.content)) {
-        return msg.content
-            .filter((p) => "text" in p && typeof p.text === "string")
-            .map((p) => p.text)
-            .join("\n");
+        const parts = [];
+        for (const p of msg.content) {
+            if ("text" in p && typeof p.text === "string") {
+                parts.push(p.text);
+            }
+            else if (isToolResultPart(p)) {
+                const out = p.output;
+                if (typeof out === "string") {
+                    parts.push(out);
+                }
+                else if ("value" in out && out.value != null) {
+                    parts.push(String(out.value));
+                }
+                else {
+                    parts.push(JSON.stringify(out));
+                }
+            }
+        }
+        return parts.join("\n");
     }
     return "";
 }
@@ -303,15 +385,15 @@ function extractTextOnly(msg) {
 export async function compactMessages(messages, model, config) {
     const cfg = loadConfig();
     const autoContinue = config?.autoContinue ?? cfg.compaction?.autoContinue ?? true;
-    // Step 1: Prune old tool outputs (skip skill results)
-    pruneToolOutputs(messages);
+    // Step 1: Prune old tool results (skip skill results)
+    const pruned = pruneToolOutputs(messages);
     // Step 2: Select tail (recent turns to keep verbatim)
-    const { headEnd, tailStart } = selectTail(messages, config);
+    const { headEnd, tailStart } = await selectTail(pruned, config);
     if (headEnd <= 1) {
         return { messages, compacted: false, shouldContinue: false };
     }
-    const toSummarize = messages.slice(0, headEnd);
-    const toKeep = messages.slice(tailStart);
+    const toSummarize = pruned.slice(0, headEnd);
+    const toKeep = pruned.slice(tailStart);
     // Step 3: Check for previous summary (incremental)
     const previousSummary = extractPreviousSummary(toSummarize);
     // Step 4: Build conversation text for summarization
@@ -333,24 +415,43 @@ export async function compactMessages(messages, model, config) {
             messages: [
                 { role: "user", content: conversationText + "\n\n" + prompt },
             ],
+            abortSignal: config?.abortSignal,
         });
         const summary = result.text;
+        const stillPresent = collectLoadedSkillNames(toKeep);
+        const droppedSkills = [
+            ...new Set([...collectLoadedSkillNames(toSummarize), ...extractNotedSkills(toSummarize)]),
+        ].filter((name) => !stillPresent.has(name));
+        const reloadNote = buildSkillReloadNote(droppedSkills);
         const compactedMessages = [
             {
                 role: "system",
-                content: `[Context Summary - Previous conversation was compacted]\n\n${summary}`,
+                content: `[Context Summary - Previous conversation was compacted]\n\n${summary}${reloadNote ? `\n\n${reloadNote}` : ""}`,
             },
             ...toKeep,
         ];
-        // Step 7: Check if the last user message had media — if so, provide replay text
+        // Step 7: If the last user message (in the kept tail) had media, provide replay text
         let replayText;
-        const lastUserMsg = toKeep.find((m) => m.role === "user");
+        let lastUserMsg;
+        for (let i = toKeep.length - 1; i >= 0; i--) {
+            if (toKeep[i].role === "user") {
+                lastUserMsg = toKeep[i];
+                break;
+            }
+        }
         if (lastUserMsg && hasMedia(lastUserMsg)) {
             replayText = extractTextOnly(lastUserMsg);
         }
-        return { messages: compactedMessages, compacted: true, shouldContinue: autoContinue, replayText };
+        return {
+            messages: compactedMessages,
+            compacted: true,
+            shouldContinue: autoContinue,
+            replayText,
+            usage: result.usage,
+        };
     }
-    catch {
-        return { messages: toKeep, compacted: true, shouldContinue: false };
+    catch (error) {
+        console.error("[compaction] summary generation failed, keeping original messages:", error);
+        return { messages, compacted: false, shouldContinue: false };
     }
 }