min-agent 0.2.1 → 0.4.0

package/dist/memory.js

@@ -1,74 +1,138 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { readFileSync, mkdirSync, existsSync, renameSync } from "fs";
 import path from "path";
-import { getConfigDir } from "./config.js";
+import { getConfigDir, getProjectConfigDir } from "./config.js";
+import { atomicWriteFileSync } from "./tools/atomic-file.js";
 import { tool, jsonSchema } from "ai";
-function getMemoryFile() {
+export function readMemoryScope(value) {
+    if (value === undefined || value === null || value === "")
+        return { ok: true, scope: undefined };
+    if (value === "global" || value === "project")
+        return { ok: true, scope: value };
+    return { ok: false };
+}
+export function takeScopeFlags(tokens) {
+    let scope;
+    const rest = [];
+    for (const t of tokens) {
+        if (t === "--project")
+            scope = "project";
+        else if (t === "--global")
+            scope = "global";
+        else
+            rest.push(t);
+    }
+    return { scope, rest };
+}
+export function defaultMemoryScope() {
+    return existsSync(getProjectConfigDir()) ? "project" : "global";
+}
+function getMemoryFile(scope) {
+    if (scope === "project")
+        return path.join(getProjectConfigDir(), "memory.json");
     return path.join(getConfigDir(), "memory.json");
 }
-export function loadMemories() {
-    const file = getMemoryFile();
+/** Preserve corrupt data instead of letting it be overwritten and lost forever. */
+function backupCorrupt(file) {
+    try {
+        renameSync(file, `${file}.corrupt-${Date.now()}`);
+    }
+    catch {
+        // nothing else we can do with an unreadable file
+    }
+}
+export function loadMemories(scope = "global") {
+    const file = getMemoryFile(scope);
     if (!existsSync(file))
         return [];
+    let data;
     try {
-        return JSON.parse(readFileSync(file, "utf-8"));
+        data = JSON.parse(readFileSync(file, "utf-8"));
     }
     catch {
+        backupCorrupt(file);
         return [];
     }
+    if (!Array.isArray(data)) {
+        backupCorrupt(file);
+        return [];
+    }
+    return data.filter((m) => typeof m === "object" && m !== null && typeof m.content === "string");
 }
-function saveMemories(memories) {
-    const file = getMemoryFile();
+/** Atomic replace via temp file + rename, so a crash never leaves a truncated memory.json. */
+function saveMemories(memories, scope) {
+    const file = getMemoryFile(scope);
     mkdirSync(path.dirname(file), { recursive: true });
-    writeFileSync(file, JSON.stringify(memories, null, 2), "utf-8");
+    atomicWriteFileSync(file, JSON.stringify(memories, null, 2));
 }
-export function addMemory(content, tags = []) {
-    const memories = loadMemories();
+// read-modify-write runs fully synchronously, so concurrent tool calls in
+// this process cannot interleave between load and save.
+export function addMemory(content, tags = [], scope = "global") {
+    const memories = loadMemories(scope);
     const memory = {
         content,
         tags,
         created: new Date().toISOString(),
     };
     memories.push(memory);
-    saveMemories(memories);
+    saveMemories(memories, scope);
     return memory;
 }
-export function deleteMemory(index) {
-    const memories = loadMemories();
+export function deleteMemory(index, scope = "global") {
+    const memories = loadMemories(scope);
     if (index < 0 || index >= memories.length)
         return false;
     memories.splice(index, 1);
-    saveMemories(memories);
+    saveMemories(memories, scope);
     return true;
 }
-export function searchMemories(query) {
-    const memories = loadMemories();
+export function searchMemories(query, scope = "global") {
+    const memories = loadMemories(scope);
     const lower = query.toLowerCase();
     return memories
         .map((m, i) => ({ ...m, index: i }))
-        .filter((m) => m.content.toLowerCase().includes(lower) ||
-        m.tags.some((t) => t.toLowerCase().includes(lower)));
+        .filter((m) => m.content.toLowerCase().includes(lower) || m.tags.some((t) => t.toLowerCase().includes(lower)));
 }
-/** Build a system prompt section from stored memories */
-export function getMemorySystemPrompt() {
-    const memories = loadMemories();
+function formatMemoryBlock(memories, heading) {
     if (memories.length === 0)
         return "";
-    const items = memories.map((m, i) => {
+    const MAX_MEMORIES = 30;
+    const start = Math.max(0, memories.length - MAX_MEMORIES);
+    const items = memories
+        .slice(start)
+        .map((m, i) => ({ m, num: start + i + 1 }))
+        .reverse()
+        .map(({ m, num }) => {
         const tags = m.tags.length > 0 ? ` [${m.tags.join(", ")}]` : "";
-        return `  ${i + 1}. ${m.content}${tags}`;
+        return `  ${num}. ${m.content}${tags}`;
     });
-    return [
+    const capped = memories.length > MAX_MEMORIES
+        ? `\n(${memories.length - MAX_MEMORIES} older memories not shown — use memory_search to find them.)`
+        : "";
+    return [heading, ...items, capped].filter(Boolean).join("\n");
+}
+/** Build a system prompt section from stored memories (newest first, capped). */
+export function getMemorySystemPrompt() {
+    const project = loadMemories("project");
+    const global = loadMemories("global");
+    if (project.length === 0 && global.length === 0)
+        return "";
+    const intro = [
         "## Memories",
         "The following are things you have remembered from previous conversations. Use them to provide better, personalized responses.",
         "You can save new memories with the memory_save tool when the user tells you something worth remembering (preferences, project details, conventions, etc).",
+        'Use scope "project" for repo-specific facts and "global" for preferences that apply everywhere.',
         "",
-        ...items,
-    ].join("\n");
+    ];
+    const sections = [
+        formatMemoryBlock(project, "### This project"),
+        formatMemoryBlock(global, project.length > 0 ? "### Global" : ""),
+    ].filter((s) => s.length > 0);
+    return [...intro, ...sections].join("\n");
 }
 /** Create the memory tools for the agent */
 export function getMemoryTools() {
     const memorySave = tool({
-        description: "Save a memory for future conversations. Use this when the user shares preferences, project conventions, important context, or asks you to remember something. Memories persist across sessions.",
+        description: "Save a memory for future conversations. Use this when the user shares preferences, project conventions, important context, or asks you to remember something. Memories persist across sessions. Use scope project for this repository, global for all projects.",
         inputSchema: jsonSchema({
             type: "object",
             properties: {
@@ -78,12 +142,18 @@ export function getMemoryTools() {
                     items: { type: "string" },
                     description: "Optional tags for categorization (e.g. 'preference', 'project', 'convention')",
                 },
+                scope: {
+                    type: "string",
+                    enum: ["global", "project"],
+                    description: "Where to store the memory. Defaults to project when .min-agent exists, otherwise global.",
+                },
             },
             required: ["content"],
         }),
-        execute: async ({ content, tags }) => {
-            const memory = addMemory(content, tags ?? []);
-            return `Saved memory: "${content}" (tags: ${memory.tags.length > 0 ? memory.tags.join(", ") : "none"})`;
+        execute: async ({ content, tags, scope }) => {
+            const resolved = scope === "global" || scope === "project" ? scope : defaultMemoryScope();
+            const memory = addMemory(content, tags ?? [], resolved);
+            return `Saved ${resolved} memory: "${content}" (tags: ${memory.tags.length > 0 ? memory.tags.join(", ") : "none"})`;
         },
     });
     const memorySearch = tool({
@@ -92,35 +162,48 @@ export function getMemoryTools() {
             type: "object",
             properties: {
                 query: { type: "string", description: "Search keyword or phrase" },
+                scope: {
+                    type: "string",
+                    enum: ["global", "project"],
+                    description: "Limit search to one store. Omit to search both.",
+                },
             },
             required: ["query"],
         }),
-        execute: async ({ query }) => {
-            const results = searchMemories(query);
-            if (results.length === 0)
+        execute: async ({ query, scope }) => {
+            const scopes = scope === "global" || scope === "project" ? [scope] : ["project", "global"];
+            const lines = [];
+            for (const s of scopes) {
+                for (const m of searchMemories(query, s)) {
+                    const tags = m.tags.length > 0 ? ` [${m.tags.join(", ")}]` : "";
+                    lines.push(`${s} #${m.index + 1}: ${m.content}${tags} (${m.created.split("T")[0]})`);
+                }
+            }
+            if (lines.length === 0)
                 return `No memories found matching "${query}"`;
-            return results
-                .map((m) => {
-                const tags = m.tags.length > 0 ? ` [${m.tags.join(", ")}]` : "";
-                return `#${m.index + 1}: ${m.content}${tags} (${m.created.split("T")[0]})`;
-            })
-                .join("\n");
+            return lines.join("\n");
         },
     });
     const memoryDelete = tool({
-        description: "Delete a memory by its number. Use memory_search or memory_list first to find the index.",
+        description: "Delete a memory by its number. Use memory_search first to find the index and scope.",
         inputSchema: jsonSchema({
             type: "object",
             properties: {
                 index: { type: "number", description: "The memory number to delete (1-based)" },
+                scope: {
+                    type: "string",
+                    enum: ["global", "project"],
+                    description: "Which store the number belongs to. Defaults to project when .min-agent exists, otherwise global.",
+                },
             },
             required: ["index"],
         }),
-        execute: async ({ index }) => {
-            const success = deleteMemory(index - 1);
+        execute: async ({ index, scope }) => {
+            const resolved = scope === "global" || scope === "project" ? scope : defaultMemoryScope();
+            const success = deleteMemory(index - 1, resolved);
             if (success)
-                return `Memory #${index} deleted.`;
-            return `Memory #${index} not found.`;
+                return `${resolved} memory #${index} deleted.`;
+            return `${resolved} memory #${index} not found.`;
         },
     });
     return {

package/dist/output.js

@@ -1,4 +1,5 @@
-import { loadConfig } from "./config.js";
+import { loadConfig, getActiveProvider } from "./config.js";
+import { summarizeToolCall, toolResultText, truncateDisplay } from "./tool-display.js";
 const COLORS = {
     reset: "\x1b[0m",
     dim: "\x1b[2m",
@@ -11,34 +12,55 @@ const COLORS = {
     gray: "\x1b[90m",
 };
 export function printHeader(modelId) {
-    const config = loadConfig();
-    const model = modelId ?? config.provider?.defaultModel ?? "unknown";
+    const model = modelId ?? getActiveProvider(loadConfig())?.defaultModel ?? "unknown";
     console.log(`${COLORS.bold}🤖 min-agent${COLORS.reset} ${COLORS.dim}(${model})${COLORS.reset}`);
 }
 export function printDivider() {
     console.log(`${COLORS.dim}${"─".repeat(60)}${COLORS.reset}`);
 }
 export function printToolCall(name, input) {
-    const argsStr = formatArgs(input);
+    const argsStr = summarizeToolCall(name, input, 160);
     console.log(`\n${COLORS.yellow}⚡ ${name}${COLORS.reset} ${COLORS.dim}${argsStr}${COLORS.reset}`);
 }
-export function printToolResult(name, result) {
-    const output = typeof result === "string" ? result : JSON.stringify(result, null, 2);
-    const lines = output.split("\n");
-    const maxLines = 20;
-    const truncated = lines.length > maxLines;
-    const preview = truncated ? lines.slice(0, maxLines).join("\n") : output;
-    const display = preview.length > 500 ? preview.slice(0, 500) + "..." : preview;
-    const suffix = truncated ? ` (${lines.length - maxLines} more lines)` : "";
-    console.log(`${COLORS.green}  ✓${COLORS.reset} ${COLORS.dim}${display}${suffix}${COLORS.reset}\n`);
+/** Console preview limits for a tool result (the full text goes to the model). */
+const RESULT_PREVIEW_MAX_LINES = 20;
+const RESULT_PREVIEW_MAX_CHARS = 1200;
+/**
+ * Print a tool result preview. Lines are kept whole and both limits are
+ * applied in one pass, so the "N more lines" count always matches what was
+ * actually withheld.
+ */
+export function printToolResult(_name, result, isError = false) {
+    const text = toolResultText(result).replace(/\s+$/, "");
+    const lines = text === "" ? [] : text.split("\n");
+    const kept = [];
+    let chars = 0;
+    for (const line of lines) {
+        if (kept.length >= RESULT_PREVIEW_MAX_LINES)
+            break;
+        if (chars + line.length > RESULT_PREVIEW_MAX_CHARS)
+            break;
+        kept.push(line);
+        chars += line.length + 1;
+    }
+    // A single very long first line still deserves a preview.
+    if (kept.length === 0 && lines.length > 0) {
+        kept.push(truncateDisplay(lines[0], RESULT_PREVIEW_MAX_CHARS));
+    }
+    const hidden = lines.length - kept.length;
+    const suffix = hidden > 0 ? ` (${hidden} more line${hidden === 1 ? "" : "s"})` : "";
+    const marker = isError ? `${COLORS.red}  ✗${COLORS.reset}` : `${COLORS.green}  ✓${COLORS.reset}`;
+    const body = kept.join(`\n${COLORS.dim}    `);
+    console.log(`${marker} ${COLORS.dim}${body}${suffix}${COLORS.reset}\n`);
 }
-export function printDone(steps, usage, contextWindow) {
-    const input = usage.inputTokens ?? 0;
-    const output = usage.outputTokens ?? 0;
+export function printDone(steps, usage, contextWindow, contextTokens) {
+    const input = usage?.inputTokens ?? 0;
+    const output = usage?.outputTokens ?? 0;
     const total = input + output;
+    const occupied = contextTokens !== undefined ? contextTokens : input;
     let contextInfo = "";
-    if (input > 0 && contextWindow && contextWindow > 0) {
-        const pct = Math.round((input / contextWindow) * 100);
+    if (occupied > 0 && contextWindow && contextWindow > 0) {
+        const pct = Math.round((occupied / contextWindow) * 100);
         const bar = renderBar(pct);
         contextInfo = ` | Context: ${bar} ${pct}%`;
     }
@@ -46,20 +68,9 @@ export function printDone(steps, usage, contextWindow) {
 }
 function renderBar(pct) {
     const width = 10;
-    const filled = Math.round((pct / 100) * width);
+    const safePct = Math.max(0, Math.min(100, pct));
+    const filled = Math.round((safePct / 100) * width);
     const empty = width - filled;
     const color = pct >= 80 ? "\x1b[31m" : pct >= 50 ? "\x1b[33m" : "\x1b[32m";
     return `${color}${"█".repeat(filled)}${"░".repeat(empty)}\x1b[0m\x1b[90m`;
 }
-function formatArgs(args) {
-    if (!args || typeof args !== "object")
-        return "";
-    const entries = Object.entries(args);
-    if (entries.length === 0)
-        return "";
-    const parts = entries.map(([k, v]) => {
-        const val = typeof v === "string" ? (v.length > 60 ? v.slice(0, 60) + "..." : v) : JSON.stringify(v);
-        return `${k}=${val}`;
-    });
-    return parts.join(" ");
-}

package/dist/paste-handler.js

@@ -17,7 +17,7 @@ const PREVIEW_LINES = 3;
 export function processPastedInput(text) {
     const lineCount = (text.match(/\n/g)?.length ?? 0) + 1;
     if (lineCount < PASTE_LINE_THRESHOLD && text.length <= PASTE_CHAR_THRESHOLD) {
-        return { fullText: text, isLargePaste: false };
+        return { fullText: text, isLargePaste: false, lineCount };
     }
     const lines = text.split("\n");
     const preview = lines.slice(0, PREVIEW_LINES).join("\n");
@@ -25,6 +25,7 @@ export function processPastedInput(text) {
     return {
         fullText: text,
         isLargePaste: true,
+        lineCount,
         summary: remaining > 0
             ? `${preview}\n\x1b[90m  ... (${remaining} more lines, ~${text.length} chars total)\x1b[0m`
             : `\x1b[90m[Pasted ${text.length} chars]\x1b[0m`,
@@ -36,6 +37,5 @@ export function processPastedInput(text) {
 export function printPasteFeedback(result) {
     if (!result.isLargePaste)
         return;
-    const lineCount = (result.fullText.match(/\n/g)?.length ?? 0) + 1;
-    console.log(`\x1b[90m  📋 Pasted ~${lineCount} lines (${result.fullText.length} chars)\x1b[0m`);
+    console.log(`\x1b[90m  📋 Pasted ~${result.lineCount} lines (${result.fullText.length} chars)\x1b[0m`);
 }

package/dist/permission-cli.js

@@ -0,0 +1,43 @@
+import { takeScopeFlags } from "./memory.js";
+import { getPermissionSnapshot, parsePermissionMode, permissionModeLabel, setPermissionMode, } from "./config.js";
+import { getPermissionOverride, setPermissionOverride } from "./confirm.js";
+export const PERMISSION_CLI_USAGE = [
+    "Usage: min-agent permission [ask|accept-edits|allow-all] [--project|--global]",
+    "       min-agent --permission ask|accept-edits|allow-all [--project|--global]",
+].join("\n");
+function sourceLabel(source) {
+    return source === "cli" ? "this run" : source === "project" ? "project" : source === "global" ? "global" : "default";
+}
+function scopeLabel(scope) {
+    return scope === "project" ? "project" : "global";
+}
+export function runPermissionCli(input) {
+    const { scope: posScope, rest } = takeScopeFlags(input.positionals);
+    const scope = posScope ?? input.scope ?? "global";
+    if (rest[0] === "--help" || rest[0] === "-h") {
+        return { ok: true, lines: [PERMISSION_CLI_USAGE] };
+    }
+    if (rest.length === 1) {
+        const parsed = parsePermissionMode(rest[0]);
+        if (!parsed)
+            return { ok: false, lines: [PERMISSION_CLI_USAGE] };
+        setPermissionMode(parsed, scope);
+        setPermissionOverride(parsed);
+        return { ok: true, lines: [`✓ Permission set to ${permissionModeLabel(parsed)} (${scopeLabel(scope)})`] };
+    }
+    if (rest.length > 1)
+        return { ok: false, lines: [PERMISSION_CLI_USAGE] };
+    if (input.flagMode) {
+        setPermissionMode(input.flagMode, scope);
+        setPermissionOverride(input.flagMode);
+        return { ok: true, lines: [`✓ Permission set to ${permissionModeLabel(input.flagMode)} (${scopeLabel(scope)})`] };
+    }
+    const snap = getPermissionSnapshot();
+    const override = getPermissionOverride();
+    const mode = override ?? snap.permission;
+    const source = override ? "cli" : snap.source;
+    return {
+        ok: true,
+        lines: [`Current permission: ${permissionModeLabel(mode)} (${sourceLabel(source)})`, PERMISSION_CLI_USAGE],
+    };
+}

package/dist/plugins.js

@@ -1,15 +1,50 @@
 import { tool, jsonSchema } from "ai";
-import { existsSync, readdirSync } from "fs";
+import { existsSync, readdirSync, statSync } from "fs";
 import { pathToFileURL } from "url";
 import path from "path";
 import { getConfigDir } from "./config.js";
-const PLUGIN_DIRS = [
-    path.join(process.cwd(), ".min-agent", "tools"),
-    path.join(getConfigDir(), "tools"),
-];
-export async function loadPluginTools() {
+import { confirm, isAutoApprove } from "./confirm.js";
+const PLUGIN_DIRS = [path.join(process.cwd(), ".min-agent", "tools"), path.join(getConfigDir(), "tools")];
+let cachedPlugins = null;
+let pluginReadOnlyIds = new Set();
+export function pluginNeedsConfirm(def) {
+    if (def.readOnly === true)
+        return false;
+    if (def.dangerous === false)
+        return false;
+    return true;
+}
+export function getPluginReadOnlyIds() {
+    return pluginReadOnlyIds;
+}
+function pluginSignature(dirs) {
+    return dirs
+        .map((dir) => {
+        if (!existsSync(dir))
+            return `${dir}:missing`;
+        const files = readdirSync(dir)
+            .filter((f) => f.endsWith(".ts") || f.endsWith(".js") || f.endsWith(".mjs"))
+            .sort();
+        const mtimes = files.map((f) => statSync(path.join(dir, f)).mtimeMs).join(",");
+        return `${dir}:${files.join(",")}:${mtimes}`;
+    })
+        .join("|");
+}
+export async function loadPluginTools(dirs) {
+    const pluginDirs = dirs ?? PLUGIN_DIRS;
+    const signature = pluginSignature(pluginDirs);
+    if (cachedPlugins && cachedPlugins.signature === signature) {
+        pluginReadOnlyIds = cachedPlugins.readOnlyIds;
+        return cachedPlugins.tools;
+    }
+    const tools = await loadPluginToolsUncached(pluginDirs);
+    cachedPlugins = { signature, tools, readOnlyIds: pluginReadOnlyIds };
+    return tools;
+}
+async function loadPluginToolsUncached(pluginDirs) {
     const tools = {};
-    for (const dir of PLUGIN_DIRS) {
+    const readOnlyIds = new Set();
+    for (const dir of pluginDirs) {
         if (!existsSync(dir))
             continue;
         const files = readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".js") || f.endsWith(".mjs"));
@@ -22,12 +57,19 @@ export async function loadPluginTools() {
                     if (!isPluginTool(def))
                         continue;
                     const toolId = exportName === "default" ? namespace : `${namespace}_${exportName}`;
+                    if (tools[toolId]) {
+                        console.warn(`\x1b[33m  ⚠ Plugin tool "${toolId}" from ${filePath} conflicts with an existing tool; skipping\x1b[0m`);
+                        continue;
+                    }
                     const properties = {};
                     const required = [];
                     for (const [key, param] of Object.entries(def.parameters)) {
-                        properties[key] = { type: param.type, description: param.description };
+                        const type = narrowJsonType(param.type);
+                        properties[key] = { type, ...(param.description ? { description: param.description } : {}) };
                         required.push(key);
                     }
+                    if (def.readOnly === true)
+                        readOnlyIds.add(toolId);
                     tools[toolId] = tool({
                         description: def.description,
                         inputSchema: jsonSchema({
@@ -36,28 +78,51 @@ export async function loadPluginTools() {
                             required,
                         }),
                         execute: async (args) => {
+                            if (pluginNeedsConfirm(def) && !isAutoApprove()) {
+                                const preview = summarizePluginArgs(args);
+                                const approved = await confirm(`运行自定义工具 ${toolId}${preview ? `\n${preview}` : ""}`);
+                                if (!approved)
+                                    return "自定义工具已被拒绝。";
+                            }
                             try {
                                 const result = await def.execute(args);
-                                return typeof result === "string" ? result : JSON.stringify(result);
+                                return typeof result === "string" ? result : (JSON.stringify(result) ?? "undefined");
                             }
                             catch (err) {
-                                return `Plugin error: ${err.message}`;
+                                return `Plugin error: ${String(err instanceof Error ? err.message : err)}`;
                             }
                         },
                     });
                 }
             }
             catch (err) {
-                console.error(`\x1b[90m  Plugin "${file}" failed to load: ${err.message}\x1b[0m`);
+                console.error(`\x1b[90m  Plugin "${file}" failed to load: ${String(err instanceof Error ? err.message : err)}\x1b[0m`);
             }
         }
     }
+    pluginReadOnlyIds = readOnlyIds;
     const count = Object.keys(tools).length;
     if (count > 0) {
         console.log(`\x1b[90m  Plugins loaded: ${count} tool(s)\x1b[0m`);
     }
     return tools;
 }
+function summarizePluginArgs(args) {
+    try {
+        const text = JSON.stringify(args);
+        if (!text || text === "{}")
+            return "";
+        return text.length > 400 ? `${text.slice(0, 400)}…` : text;
+    }
+    catch {
+        return "";
+    }
+}
+function narrowJsonType(type) {
+    if (type === "number" || type === "boolean" || type === "object" || type === "array")
+        return type;
+    return "string";
+}
 function isPluginTool(value) {
     if (!value || typeof value !== "object")
         return false;