min-agent 0.1.3 → 0.1.5

package/dist/code-mode.js

@@ -0,0 +1,166 @@
+import { execSync } from "child_process";
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import path from "path";
+export function scanProject() {
+    const cwd = process.cwd();
+    const isGitRepo = existsSync(path.join(cwd, ".git"));
+    let branch;
+    if (isGitRepo) {
+        try {
+            branch = execSync("git branch --show-current", { encoding: "utf-8", cwd }).trim();
+        }
+        catch { }
+    }
+    const languages = [];
+    const configFiles = [];
+    const entryFiles = [];
+    // Detect by config files
+    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: "tsconfig.json", lang: "TypeScript" },
+        { file: "Cargo.toml", lang: "Rust", pm: "cargo" },
+        { file: "go.mod", lang: "Go" },
+        { file: "pyproject.toml", lang: "Python", pm: "pip/uv" },
+        { file: "requirements.txt", lang: "Python", pm: "pip" },
+        { file: "Gemfile", lang: "Ruby", pm: "bundler" },
+        { file: "pom.xml", lang: "Java", pm: "maven" },
+        { file: "build.gradle", lang: "Java/Kotlin", pm: "gradle" },
+        { file: "composer.json", lang: "PHP", pm: "composer" },
+        { file: "Makefile", lang: "" },
+        { file: "Dockerfile", lang: "" },
+    ];
+    let packageManager;
+    let framework;
+    for (const check of checks) {
+        if (existsSync(path.join(cwd, check.file))) {
+            configFiles.push(check.file);
+            if (check.lang && !languages.includes(check.lang))
+                languages.push(check.lang);
+            if (check.pm && !packageManager)
+                packageManager = check.pm;
+        }
+    }
+    // Detect framework from package.json
+    if (existsSync(path.join(cwd, "package.json"))) {
+        try {
+            const pkg = JSON.parse(readFileSync(path.join(cwd, "package.json"), "utf-8"));
+            const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+            if (allDeps["next"])
+                framework = "Next.js";
+            else if (allDeps["nuxt"])
+                framework = "Nuxt";
+            else if (allDeps["@angular/core"])
+                framework = "Angular";
+            else if (allDeps["vue"])
+                framework = "Vue";
+            else if (allDeps["react"])
+                framework = "React";
+            else if (allDeps["svelte"])
+                framework = "Svelte";
+            else if (allDeps["express"])
+                framework = "Express";
+            else if (allDeps["fastify"])
+                framework = "Fastify";
+            else if (allDeps["hono"])
+                framework = "Hono";
+            else if (allDeps["effect"])
+                framework = "Effect";
+        }
+        catch { }
+    }
+    // Find entry files
+    const entryPatterns = [
+        "src/index.ts", "src/index.js", "src/main.ts", "src/main.js",
+        "src/app.ts", "src/app.js", "index.ts", "index.js",
+        "main.ts", "main.js", "app.ts", "app.js",
+        "src/lib.rs", "main.go", "main.py", "app.py",
+    ];
+    for (const p of entryPatterns) {
+        if (existsSync(path.join(cwd, p)))
+            entryFiles.push(p);
+    }
+    // Build summary
+    const parts = [];
+    parts.push(`Directory: ${cwd}`);
+    if (isGitRepo)
+        parts.push(`Git: yes (branch: ${branch ?? "unknown"})`);
+    if (languages.length)
+        parts.push(`Languages: ${languages.join(", ")}`);
+    if (framework)
+        parts.push(`Framework: ${framework}`);
+    if (packageManager)
+        parts.push(`Package manager: ${packageManager}`);
+    if (configFiles.length)
+        parts.push(`Config files: ${configFiles.join(", ")}`);
+    if (entryFiles.length)
+        parts.push(`Entry points: ${entryFiles.join(", ")}`);
+    // List top-level directory structure
+    try {
+        const items = readdirSync(cwd)
+            .filter((f) => !f.startsWith(".") || f === ".env.example")
+            .filter((f) => f !== "node_modules" && f !== ".git")
+            .slice(0, 30)
+            .map((f) => {
+            const stat = statSync(path.join(cwd, f));
+            return stat.isDirectory() ? `${f}/` : f;
+        });
+        parts.push(`Structure: ${items.join(", ")}`);
+    }
+    catch { }
+    return {
+        directory: cwd,
+        isGitRepo,
+        branch,
+        languages,
+        framework,
+        packageManager,
+        entryFiles,
+        configFiles,
+        summary: parts.join("\n"),
+    };
+}
+export function buildCodeSystemPrompt(project, instructions) {
+    const parts = [
+        "You are an expert AI coding assistant. You help users with software engineering tasks including writing code, debugging, refactoring, and architecture decisions.",
+        "",
+        "# Principles",
+        "- Be concise and direct. Minimize output tokens while maintaining quality.",
+        "- NEVER add comments to code unless asked. Write self-documenting code.",
+        "- Follow existing code conventions in the project. Mimic style, libraries, and patterns.",
+        "- NEVER assume a library is available — check package.json/Cargo.toml/etc first.",
+        "- Prefer editing existing files over creating new ones.",
+        "- After making changes, run lint/typecheck/build if available.",
+        "- NEVER commit unless explicitly asked.",
+        "",
+        "# Workflow",
+        "- Use search tools (grep, glob) to understand the codebase before making changes.",
+        "- Use the edit tool for precise changes instead of rewriting entire files.",
+        "- When fixing bugs: read the relevant code, understand the issue, fix it, verify.",
+        "- When adding features: explore existing patterns first, then implement consistently.",
+        "- Run tests after changes when a test command is available.",
+        "",
+        "# Environment",
+        `<env>`,
+        `  Working directory: ${project.directory}`,
+        `  Git repo: ${project.isGitRepo ? `yes (branch: ${project.branch ?? "unknown"})` : "no"}`,
+        `  Platform: ${process.platform}`,
+        `  Date: ${new Date().toDateString()}`,
+        project.languages.length ? `  Languages: ${project.languages.join(", ")}` : "",
+        project.framework ? `  Framework: ${project.framework}` : "",
+        project.packageManager ? `  Package manager: ${project.packageManager}` : "",
+        `</env>`,
+        "",
+        "# Project Structure",
+        "```",
+        project.summary,
+        "```",
+    ].filter(Boolean);
+    if (instructions.length > 0) {
+        parts.push("", "# User Instructions", "");
+        parts.push(...instructions);
+    }
+    return parts.join("\n");
+}

package/dist/compaction.js

@@ -1,29 +1,94 @@
 import { generateText } from "ai";
 /**
- * Context compaction system.
+ * Context compaction system — modeled after opencode's SessionCompaction.
  *
- * When conversation history exceeds a token threshold, older messages are
- * summarized into a compact form to free up context window space.
- *
- * Strategy:
- * 1. Estimate token count of messages (rough: 1 token ≈ 4 chars for English, 2 chars for CJK)
- * 2. When over threshold, take older messages and summarize them via the LLM
- * 3. Replace old messages with a single system summary message
- * 4. Keep recent N turns verbatim for continuity
+ * Features:
+ * 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
+ * 6. Token-budget-aware tail preservation
  */
-const COMPACTION_PROMPT = `You are a conversation summarizer. Summarize the following conversation history into a concise but complete summary that preserves:
-- Key decisions made
-- Important context and facts discussed
-- Current state of any tasks in progress
-- User preferences mentioned
-- File paths, code snippets, or technical details that are still relevant
+// ─── Structured Summary Template (from opencode) ───────────────────────────
+const SUMMARY_TEMPLATE = `Output exactly the Markdown structure shown below. Keep the section order unchanged.
+
+## Goal
+- [single-sentence task summary]
+
+## Constraints & Preferences
+- [user constraints, preferences, specs, or "(none)"]
+
+## Progress
+### Done
+- [completed work or "(none)"]
+
+### In Progress
+- [current work or "(none)"]
+
+### Blocked
+- [blockers or "(none)"]
 
-Be concise but don't lose critical information. Output only the summary, no preamble.`;
-// Default: trigger compaction at ~80% of context window
+## Key Decisions
+- [decision and why, or "(none)"]
+
+## Next Steps
+- [ordered next actions or "(none)"]
+
+## Critical Context
+- [important technical facts, errors, open questions, or "(none)"]
+
+## Relevant Files
+- [file or directory path: why it matters, or "(none)"]
+
+Rules:
+- Keep every section, even when empty.
+- Use terse bullets, not prose paragraphs.
+- Preserve exact file paths, commands, error strings, and identifiers when known.
+- Do not mention the summary process or that context was compacted.`;
+// ─── Constants ─────────────────────────────────────────────────────────────
 const DEFAULT_MAX_TOKENS = 128000;
 const COMPACTION_RATIO = 0.75;
-const KEEP_RECENT_TURNS = 4; // Keep last N user+assistant pairs verbatim
-/** Rough token estimation */
+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_MIN_SAVINGS = 20000;
+const TOOL_OUTPUT_MAX_CHARS = 2000;
+// ─── Token Tracker ─────────────────────────────────────────────────────────
+export class TokenTracker {
+    _lastInputTokens = 0;
+    _totalOutputTokens = 0;
+    _totalInputTokens = 0;
+    _totalCacheRead = 0;
+    update(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;
+    }
+    get lastInputTokens() {
+        return this._lastInputTokens;
+    }
+    get totalInputTokens() {
+        return this._totalInputTokens;
+    }
+    get totalOutputTokens() {
+        return this._totalOutputTokens;
+    }
+    summary() {
+        return `context: ${this._lastInputTokens} | total in: ${this._totalInputTokens} out: ${this._totalOutputTokens}`;
+    }
+    resetContext() {
+        this._lastInputTokens = 0;
+    }
+}
+// ─── Token Estimation ──────────────────────────────────────────────────────
+/** Rough token estimation (fallback) */
 export function estimateTokens(messages) {
     let chars = 0;
     for (const msg of messages) {
@@ -38,51 +103,180 @@ export function estimateTokens(messages) {
             }
         }
     }
-    // Rough estimate: mix of English (~4 chars/token) and CJK (~2 chars/token)
     return Math.ceil(chars / 3);
 }
-/** Check if compaction is needed */
-export function needsCompaction(messages, config) {
+function estimateMessageTokens(msg) {
+    if (typeof msg.content === "string")
+        return Math.ceil(msg.content.length / 3);
+    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 0;
+}
+// ─── Compaction Check ──────────────────────────────────────────────────────
+export function needsCompaction(messages, tracker, config) {
     const maxTokens = config?.maxTokens ?? DEFAULT_MAX_TOKENS;
     const threshold = maxTokens * COMPACTION_RATIO;
+    if (tracker && tracker.lastInputTokens > 0) {
+        return tracker.lastInputTokens > threshold;
+    }
     return estimateTokens(messages) > threshold;
 }
-/** Compact messages by summarizing older history */
+// ─── 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.
+ * 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
+        if (msg.role === "tool" || (Array.isArray(msg.content) && msg.content.some((p) => p.type === "tool-result"))) {
+            const content = typeof msg.content === "string" ? msg.content : "";
+            const estimate = Math.ceil(content.length / 3);
+            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);
+            }
+        }
+    }
+    return saved;
+}
+/**
+ * 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 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")
+            turnStarts.push(i);
+    }
+    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);
+    for (let i = recentTurns.length - 1; i >= 0; i--) {
+        const turnStart = recentTurns[i];
+        const turnEnd = i < recentTurns.length - 1 ? recentTurns[i + 1] : messages.length;
+        let turnTokens = 0;
+        for (let j = turnStart; j < turnEnd; j++) {
+            turnTokens += estimateMessageTokens(messages[j]);
+        }
+        if (tokensUsed + turnTokens > budget && tokensUsed > 0)
+            break;
+        tokensUsed += turnTokens;
+        tailStart = turnStart;
+    }
+    if (tailStart >= messages.length)
+        tailStart = messages.length - 2;
+    if (tailStart < 0)
+        tailStart = 0;
+    return { headEnd: tailStart, tailStart };
+}
+// ─── Compaction Agent Prompt ────────────────────────────────────────────────
+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.
+
+If the prompt includes a <previous-summary> block, treat it as the current anchored summary. Update it with the new history by preserving still-true details, removing stale details, and merging in new facts.
+
+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 */
+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];
+    }
+    return undefined;
+}
+function buildCompactionPrompt(previousSummary) {
+    const anchor = previousSummary
+        ? [
+            "Update the anchored summary below using the conversation history above.",
+            "Preserve still-true details, remove stale details, and merge in the new facts.",
+            "",
+            "<previous-summary>",
+            previousSummary,
+            "</previous-summary>",
+        ].join("\n")
+        : "Create a new anchored summary from the conversation history above.";
+    return [anchor, "", SUMMARY_TEMPLATE].join("\n");
+}
+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");
+    }
+    return "";
+}
+/**
+ * Compact messages by summarizing older history with structured template.
+ * Supports incremental summaries and token-budget tail preservation.
+ */
 export async function compactMessages(messages, model, config) {
-    const keepTurns = config?.keepRecentTurns ?? KEEP_RECENT_TURNS;
-    if (messages.length <= keepTurns * 2) {
-        // Not enough messages to compact
-        return { messages, compacted: false };
-    }
-    // Split: older messages to summarize, recent messages to keep
-    const splitIdx = messages.length - keepTurns * 2;
-    const toSummarize = messages.slice(0, splitIdx);
-    const toKeep = messages.slice(splitIdx);
-    // Build conversation text for summarization
+    // Step 1: Prune old tool outputs first
+    pruneToolOutputs(messages);
+    // Step 2: Select tail (recent turns to keep verbatim)
+    const { headEnd, tailStart } = selectTail(messages, config);
+    if (headEnd <= 1) {
+        return { messages, compacted: false, shouldContinue: false };
+    }
+    const toSummarize = messages.slice(0, headEnd);
+    const toKeep = messages.slice(tailStart);
+    // Step 3: Check for previous summary (incremental)
+    const previousSummary = extractPreviousSummary(toSummarize);
+    // Step 4: Build conversation text for summarization
     const conversationText = toSummarize
         .map((msg) => {
         const role = msg.role;
-        const content = typeof msg.content === "string"
-            ? msg.content
-            : Array.isArray(msg.content)
-                ? msg.content
-                    .filter((p) => "text" in p)
-                    .map((p) => p.text)
-                    .join("\n")
-                : "";
-        return `[${role}]: ${content.slice(0, 2000)}`;
+        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
     try {
+        const prompt = buildCompactionPrompt(previousSummary);
         const result = await generateText({
             model,
+            system: COMPACTION_AGENT_SYSTEM,
             messages: [
-                { role: "system", content: COMPACTION_PROMPT },
-                { role: "user", content: `Summarize this conversation:\n\n${conversationText}` },
+                { role: "user", content: conversationText + "\n\n" + prompt },
             ],
         });
         const summary = result.text;
-        // Build compacted message list
         const compactedMessages = [
             {
                 role: "system",
@@ -90,10 +284,11 @@ export async function compactMessages(messages, model, config) {
             },
             ...toKeep,
         ];
-        return { messages: compactedMessages, compacted: true };
+        const shouldContinue = config?.autoContinue !== false;
+        return { messages: compactedMessages, compacted: true, shouldContinue };
     }
     catch {
-        // If summarization fails, just truncate older messages
-        return { messages: toKeep, compacted: true };
+        // Fallback: just keep the tail
+        return { messages: toKeep, compacted: true, shouldContinue: false };
     }
 }

package/dist/config.js

@@ -56,20 +56,47 @@ function ask(rl, question, defaultValue) {
         });
     });
 }
+const MODELS_CACHE_FILE = path.join(CONFIG_DIR, "models-cache.json");
+function loadModelsCache() {
+    if (!existsSync(MODELS_CACHE_FILE))
+        return [];
+    try {
+        return JSON.parse(readFileSync(MODELS_CACHE_FILE, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+}
+function saveModelsCache(models) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(MODELS_CACHE_FILE, JSON.stringify(models), "utf-8");
+}
 export async function fetchModels(baseURL, apiKey) {
     try {
         const trimmed = baseURL.replace(/\/$/, "");
-        const primary = await fetchModelsFromURL(`${trimmed}/models`, apiKey);
-        if (primary.length > 0)
-            return primary;
+        let models = await fetchModelsFromURL(`${trimmed}/models`, apiKey);
         // Ollama users often provide host without /v1; auto-retry that variant.
-        if (!trimmed.endsWith("/v1")) {
-            return await fetchModelsFromURL(`${trimmed}/v1/models`, apiKey);
+        if (models.length === 0 && !trimmed.endsWith("/v1")) {
+            models = await fetchModelsFromURL(`${trimmed}/v1/models`, apiKey);
         }
-        return [];
+        if (models.length > 0) {
+            saveModelsCache(models);
+            return models;
+        }
+        // Fallback to cache if live fetch returned nothing
+        const cached = loadModelsCache();
+        if (cached.length > 0) {
+            console.log("\x1b[90m  (using cached model list)\x1b[0m");
+        }
+        return cached;
     }
     catch {
-        return [];
+        // Network error — fallback to cache
+        const cached = loadModelsCache();
+        if (cached.length > 0) {
+            console.log("\x1b[90m  (using cached model list — network unavailable)\x1b[0m");
+        }
+        return cached;
     }
 }
 export async function runSetup() {