micro-models-agent 0.60.1 → 0.61.1

package/dist/tools/path-utils.js

@@ -0,0 +1,101 @@
+import { resolve, normalize, dirname, basename, sep, relative, isAbsolute } from "path";
+import { existsSync } from "fs";
+/**
+ * True when targetPath equals dirPath or lies inside it.
+ *
+ * Cross-platform notes:
+ * - Uses path.relative() instead of raw startsWith, so a sibling directory
+ *   sharing the string prefix ("src" vs "src-other") can never pass.
+ * - On Windows the filesystem is case-insensitive: both sides are lowercased
+ *   before comparison so "E:\Proj" and "e:\proj" resolve to the same dir.
+ */
+export function isInsideDir(targetPath, dirPath) {
+    const norm = (p) => (process.platform === "win32" ? p.toLowerCase() : p);
+    const t = norm(resolve(targetPath));
+    const d = norm(resolve(dirPath));
+    if (t === d)
+        return true;
+    const rel = relative(d, t);
+    return rel.length > 0 && !isAbsolute(rel) && !rel.startsWith("..");
+}
+/**
+ * True when targetPath matches a scope entry: either the entry file itself or
+ * anything inside the entry directory. Separator- and case-safe (see
+ * isInsideDir).
+ */
+export function matchesScopeEntry(targetResolved, entryResolved) {
+    if (targetResolved === entryResolved)
+        return true;
+    return isInsideDir(targetResolved, entryResolved);
+}
+/**
+ * Resolve a user-provided path against baseDir.
+ *
+ * Handles common model mistakes:
+ * 1. Leading slash: "/testing/cat3" → resolve relative to baseDir
+ * 2. Missing separator: "E:\agent_test" when baseDir is "E:\agent\_test"
+ *    → inserts the missing backslash
+ *
+ * For new files the parent directory must exist; we check that instead of
+ * the full path so write_file still works.
+ */
+export function safeResolvePath(baseDir, userPath) {
+    // Absolute path that actually exists — honor it as-is
+    const asIs = resolve(normalize(userPath));
+    if (userPath.startsWith("/") || userPath.startsWith("\\")) {
+        if (existsSync(asIs) || existsSync(dirname(asIs)))
+            return asIs;
+    }
+    const norm = normalize(userPath);
+    // Absolute paths are used verbatim — do NOT strip a leading slash and
+    // re-resolve against baseDir (that would turn /var/folders/... into
+    // baseDir/var/folders/... on POSIX). The leading-slash heuristic below
+    // only applies as a fallback when the absolute path does not resolve.
+    if (isAbsolute(norm)) {
+        if (existsSync(norm) || existsSync(dirname(norm)))
+            return norm;
+        // Absolute but not on disk yet (e.g. a new file whose dirs don't exist).
+        // Model mistake recovery: a leading slash may mean "relative to baseDir".
+        const stripped = norm.replace(/^[/\\]/, "");
+        const relativeCandidate = resolve(baseDir, stripped);
+        if (existsSync(relativeCandidate) || existsSync(dirname(relativeCandidate))) {
+            return relativeCandidate;
+        }
+        return norm;
+    }
+    const stripped = norm.replace(/^[/\\]/, "");
+    const resolved = resolve(baseDir, stripped);
+    // Fast path: if it exists (or parent does for new files), return it
+    if (existsSync(resolved) || existsSync(dirname(resolved)))
+        return resolved;
+    const baseNorm = normalize(baseDir);
+    // Walk ancestors and look for missing separators
+    let cur = baseNorm;
+    while (cur && cur !== dirname(cur)) {
+        const name = basename(cur);
+        if (!name) {
+            cur = dirname(cur);
+            continue;
+        }
+        let idx = stripped.toLowerCase().indexOf(name.toLowerCase());
+        while (idx >= 0) {
+            const afterIdx = idx + name.length;
+            const afterChar = stripped[afterIdx];
+            if (afterChar && afterChar !== "\\" && afterChar !== "/") {
+                const fixed = stripped.slice(0, afterIdx) + sep + stripped.slice(afterIdx);
+                const fixedResolved = resolve(baseDir, normalize(fixed));
+                if (existsSync(fixedResolved) || existsSync(dirname(fixedResolved))) {
+                    return fixedResolved;
+                }
+                // Try from ancestor's parent
+                const fromParent = resolve(dirname(cur), normalize(fixed));
+                if (existsSync(fromParent) || existsSync(dirname(fromParent))) {
+                    return fromParent;
+                }
+            }
+            idx = stripped.toLowerCase().indexOf(name.toLowerCase(), idx + 1);
+        }
+        cur = dirname(cur);
+    }
+    return resolved;
+}

package/dist/tools/pipeline-run.js

@@ -0,0 +1,145 @@
+import { t } from "../i18n/index";
+import { PipelineEngine } from "../modules/pipelines/engine";
+import { PipelineParser } from "../modules/pipelines/parser";
+import { TemplateEngine } from "../modules/pipelines/template";
+import { Agent } from "../core/agent";
+import { ContextManager } from "../modules/context/manager";
+import { PluginManager } from "../modules/plugins/manager";
+import { HallucinationDetector } from "../modules/hallucination/detector";
+import { logSecurityBlock } from "../modules/security/audit-log";
+import { getSessionSecurityConfig } from "../modules/security/session-isolation";
+const engine = new PipelineEngine();
+const MAX_CONCURRENT = 3;
+const MAX_ATTEMPTS = 3;
+async function runStep(ctx, step, params, outputs) {
+    const prompt = TemplateEngine.render(step.prompt, params, outputs);
+    let lastError = "";
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+        try {
+            const subContextManager = new ContextManager(ctx.config.contextWindow, ctx.config.contextBudget);
+            const subPluginManager = new PluginManager();
+            const systemPrompt = {
+                content: `You are a pipeline step agent ("${step.agent}"). Complete the given task using the available tools.`,
+                priority: "critical",
+                essential: true,
+                estimatedTokens: 80,
+            };
+            const subDeps = {
+                config: ctx.config,
+                llmProvider: ctx.llmProvider,
+                toolExecutor: ctx.toolExecutor,
+                pluginManager: subPluginManager,
+                contextManager: subContextManager,
+                hallucinationDetector: new HallucinationDetector(ctx.baseDir, ctx.llmProvider),
+                logger: ctx.logger,
+                baseDir: ctx.baseDir,
+                scope: ctx.scope,
+                recursionDepth: (ctx.recursionDepth ?? 0) + 1,
+                promptBlocks: [systemPrompt],
+            };
+            const subAgent = new Agent(subDeps);
+            const result = await subAgent.run(prompt);
+            if (result.success) {
+                return { ok: true, output: result.text };
+            }
+            lastError = result.error || "no output";
+        }
+        catch (e) {
+            lastError = e.message;
+        }
+        await new Promise((r) => setTimeout(r, 500 * attempt));
+    }
+    return { ok: false, output: "", error: lastError };
+}
+export const pipelineRunTool = {
+    name: "pipeline_run",
+    icon: "▶️",
+    description: "Run a named pipeline with YAML definition. Creates a DAG of sub-agents that execute in dependency order.",
+    tags: ["shell", "code"],
+    parameters: {
+        type: "object",
+        properties: {
+            name: { type: "string", description: "Pipeline name" },
+            yaml: { type: "string", description: "Pipeline YAML definition with steps" },
+            params: { type: "object", description: "Template params for {key} placeholders" },
+        },
+        required: ["name", "yaml"],
+    },
+    handler: async (ctx, args) => {
+        const name = String(args.name || "");
+        const yaml = String(args.yaml || "");
+        const params = args.params || {};
+        if (!yaml) {
+            return { success: false, output: t("pipeline.invalid") };
+        }
+        if (!ctx.llmProvider || !ctx.toolExecutor) {
+            return {
+                success: false,
+                output: "Pipeline cannot run: missing llmProvider or toolExecutor in context",
+            };
+        }
+        const securityConfig = ctx.sessionContext
+            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext)
+            : ctx.config.security;
+        const maxDepth = securityConfig?.maxRecursionDepth ?? 3;
+        const currentDepth = ctx.recursionDepth ?? 0;
+        if (currentDepth >= maxDepth) {
+            logSecurityBlock(ctx.sessionId, "bash_command", `Maximum recursion depth (${maxDepth}) exceeded`, name);
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] Maximum pipeline recursion depth (${maxDepth}) exceeded`,
+            };
+        }
+        try {
+            const pipeline = PipelineParser.parse(yaml);
+            engine.reset();
+            const order = engine.resolveDependencies(pipeline.steps);
+            const completed = new Set();
+            const outputs = {};
+            const logs = [];
+            const failed = new Set();
+            while (completed.size < pipeline.steps.length) {
+                const ready = engine
+                    .getReadySteps(pipeline.steps, completed)
+                    .filter((s) => !failed.has(s.id));
+                if (ready.length === 0) {
+                    if (failed.size > 0)
+                        break;
+                    throw new Error(t("pipeline.circular", { stepId: order.join(", ") }));
+                }
+                const batch = ready.slice(0, MAX_CONCURRENT);
+                const results = await Promise.all(batch.map((step) => runStep(ctx, step, params, outputs)));
+                for (let i = 0; i < batch.length; i++) {
+                    const step = batch[i];
+                    const result = results[i];
+                    if (result.ok) {
+                        completed.add(step.id);
+                        outputs[step.id] = { output: result.output };
+                        engine.setStepStatus(step.id, "done");
+                        logs.push(`  ✓ ${step.id}: ${result.output.split("\n")[0]}`);
+                    }
+                    else {
+                        failed.add(step.id);
+                        engine.setStepStatus(step.id, "failed");
+                        logs.push(`  ✗ ${step.id}: ${result.error}`);
+                    }
+                }
+                if (failed.size > 0)
+                    break;
+            }
+            if (failed.size > 0) {
+                return {
+                    success: false,
+                    output: `Pipeline "${pipeline.name}" failed. Executed ${completed.size}/${pipeline.steps.length} steps.\n${logs.join("\n")}`,
+                };
+            }
+            return {
+                success: true,
+                output: `Pipeline "${pipeline.name}" completed successfully (${completed.size} steps).\n${logs.join("\n")}`,
+            };
+        }
+        catch (e) {
+            return { success: false, output: `Pipeline error: ${e.message}` };
+        }
+    },
+};

package/dist/tools/preview.js

@@ -0,0 +1,2 @@
+/** Maximum number of lines shown in tool output previews. */
+export const MAX_PREVIEW_LINES = 15;

package/dist/tools/process-kill.js

@@ -0,0 +1,40 @@
+import { processRegistry } from "../modules/processes";
+import { t } from "../i18n/index";
+export const processKillTool = {
+    name: "process_kill",
+    icon: "⛔",
+    description: "Stop a background process started via bash (dev server, watcher). Kills the whole process tree (children included). Use the id returned by bash or process_list.",
+    tags: ["shell"],
+    parameters: {
+        type: "object",
+        properties: {
+            id: { type: "string", description: "Process id from bash output or process_list" },
+        },
+        required: ["id"],
+    },
+    handler: async (ctx, args) => {
+        if (args.id === undefined || String(args.id).trim() === "") {
+            // ses_mt4fn58c: `process_kill -p=5173` produced "Process not found:
+            // undefined" — no hint about the correct format. Answer with usage.
+            const known = processRegistry.list();
+            const ids = known.map((p) => p.id);
+            const listPart = ids.length
+                ? `\n${t("proc.list_header")}: ${ids.join(", ")}`
+                : `\n${t("proc.missing_id_list")}`;
+            return { success: false, output: `${t("proc.missing_id")}${listPart}` };
+        }
+        const id = String(args.id);
+        const entry = processRegistry.get(id);
+        if (!entry) {
+            return { success: false, output: t("proc.not_found", { id }) };
+        }
+        const killed = processRegistry.kill(id);
+        if (!killed) {
+            return { success: false, output: t("proc.kill_failed", { id }) };
+        }
+        return {
+            success: true,
+            output: t("proc.killed", { id, pid: entry.pid }),
+        };
+    },
+};

package/dist/tools/process-list.js

@@ -0,0 +1,37 @@
+import { processRegistry } from "../modules/processes";
+import { t } from "../i18n/index";
+export const processListTool = {
+    name: "process_list",
+    icon: "📊",
+    description: "List background processes started via the bash tool (dev servers, watchers, long-running commands). Shows id, pid, command, status, and recent output. Use with process_log and process_kill to inspect or stop them.",
+    tags: ["shell"],
+    parameters: {
+        type: "object",
+        properties: {},
+    },
+    handler: async (ctx) => {
+        const list = processRegistry.list(ctx.sessionId);
+        if (list.length === 0) {
+            return { success: true, output: t("proc.none") };
+        }
+        const statusLabel = (status) => {
+            if (status === "running")
+                return t("proc.status_running");
+            if (status === "exited")
+                return t("proc.status_exited");
+            return t("proc.status_killed");
+        };
+        const lines = [`${t("proc.list_header")} (${list.length}):`];
+        for (const entry of list) {
+            const tail = entry.log.length > 0 ? entry.log[entry.log.length - 1] : "";
+            const detail = tail ? ` — ${tail.slice(0, 80)}${tail.length > 80 ? "…" : ""}` : "";
+            lines.push(`  ${entry.id}  PID ${entry.pid}  ${statusLabel(entry.status)}  ${entry.command}${detail}`);
+        }
+        lines.push(`\n${t("proc.hint", {
+            list: "process_list",
+            log: "process_log",
+            kill: "process_kill",
+        })}`);
+        return { success: true, output: lines.join("\n") };
+    },
+};

package/dist/tools/process-log.js

@@ -0,0 +1,54 @@
+import { processRegistry } from "../modules/processes";
+import { t } from "../i18n/index";
+import { MAX_PREVIEW_LINES } from "./preview";
+const DEFAULT_TAIL = MAX_PREVIEW_LINES;
+export const processLogTool = {
+    name: "process_log",
+    icon: "📜",
+    description: `Show the buffered output of a background process started via bash. Shows the last ${DEFAULT_TAIL} lines by default. Use after starting a dev server to verify it came up without errors, and while it runs to check its state.`,
+    tags: ["shell"],
+    boundedOutput: true,
+    parameters: {
+        type: "object",
+        properties: {
+            id: { type: "string", description: "Process id from bash output or process_list" },
+            tail: {
+                type: "number",
+                description: `Number of trailing lines to show (default: ${DEFAULT_TAIL}, max 300)`,
+            },
+        },
+        required: ["id"],
+    },
+    handler: async (ctx, args) => {
+        if (args.id === undefined || String(args.id).trim() === "") {
+            const known = processRegistry.list();
+            const ids = known.map((p) => p.id);
+            const listPart = ids.length
+                ? `\n${t("proc.list_header")}: ${ids.join(", ")}`
+                : `\n${t("proc.missing_id_list")}`;
+            return { success: false, output: `${t("proc.missing_id")}${listPart}` };
+        }
+        const id = String(args.id);
+        const entry = processRegistry.get(id);
+        if (!entry) {
+            return { success: false, output: t("proc.not_found", { id }) };
+        }
+        const status = entry.status === "running"
+            ? t("proc.status_running")
+            : entry.status === "exited"
+                ? t("proc.status_exited")
+                : t("proc.status_killed");
+        const tail = typeof args.tail === "number" ? args.tail : DEFAULT_TAIL;
+        const log = processRegistry.getLog(id, tail);
+        if (!log) {
+            return {
+                success: true,
+                output: `${t("proc.log_header", { id, status })} ${t("proc.log_empty")}`,
+            };
+        }
+        return {
+            success: true,
+            output: `${t("proc.log_header", { id, status })}\n${log}`,
+        };
+    },
+};

package/dist/tools/question.js

@@ -0,0 +1,141 @@
+import { t } from "../i18n/index";
+import { askUser } from "./user-input";
+const DESCRIPTION = `Use this tool when you need to ask the user questions during execution. This allows you to:
+1. Gather user preferences or requirements
+2. Clarify ambiguous instructions
+3. Get decisions on implementation choices as you work
+4. Offer choices to the user about what direction to take.
+
+Usage notes:
+- When "custom" is enabled (default), a "Type your own answer" option is added automatically; don't include "Other" or catch-all options
+- Answers are returned as arrays of labels; set "multiple": true to allow selecting more than one
+- If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label
+- Execution blocks until the user answers every question
+- Omit "options" for a free-text question`;
+function isOption(val) {
+    if (!val || typeof val !== "object")
+        return false;
+    const opt = val;
+    return typeof opt.label === "string" && typeof opt.description === "string";
+}
+function normalizeQuestions(args) {
+    const raw = args.questions;
+    if (Array.isArray(raw)) {
+        const specs = [];
+        for (const item of raw) {
+            if (!item || typeof item !== "object")
+                continue;
+            const q = item;
+            if (typeof q.question !== "string" || !q.question.trim())
+                continue;
+            const options = Array.isArray(q.options) ? q.options.filter(isOption) : undefined;
+            // An explicitly provided options array with no valid entries is a
+            // malformed call — skip the question instead of blocking on stdin.
+            if (Array.isArray(q.options) && options.length === 0)
+                continue;
+            specs.push({
+                question: q.question,
+                header: typeof q.header === "string" ? q.header : undefined,
+                options,
+                multiple: q.multiple === true,
+                custom: q.custom === false ? false : undefined,
+            });
+        }
+        return specs;
+    }
+    // Legacy format: { question: "..." } — plain free-text question.
+    if (typeof args.question === "string" && args.question.trim()) {
+        return [{ question: args.question }];
+    }
+    return [];
+}
+export const questionTool = {
+    name: "question",
+    icon: "❓",
+    description: DESCRIPTION,
+    tags: ["core"],
+    interactive: true,
+    parameters: {
+        type: "object",
+        properties: {
+            questions: {
+                type: "array",
+                description: "Questions to ask",
+                items: {
+                    type: "object",
+                    properties: {
+                        question: { type: "string", description: "Complete question" },
+                        header: {
+                            type: "string",
+                            description: "Very short label (max 30 chars)",
+                        },
+                        options: {
+                            type: "array",
+                            description: "Available choices; omit for a free-text question",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    label: {
+                                        type: "string",
+                                        description: "Display text (1-5 words, concise)",
+                                    },
+                                    description: {
+                                        type: "string",
+                                        description: "Explanation of choice",
+                                    },
+                                },
+                                required: ["label", "description"],
+                            },
+                        },
+                        multiple: {
+                            type: "boolean",
+                            description: "Allow selecting multiple choices",
+                        },
+                        custom: {
+                            type: "boolean",
+                            description: "Allow typing a custom answer (default: true)",
+                        },
+                    },
+                    required: ["question"],
+                },
+            },
+            question: {
+                type: "string",
+                description: "Legacy single free-text question",
+            },
+        },
+    },
+    handler: async (ctx, args) => {
+        if (ctx.exitOnComplete) {
+            return { success: false, output: t("tool.interactive_disabled") };
+        }
+        const questions = normalizeQuestions(args);
+        if (questions.length === 0) {
+            return { success: false, output: t("tool.question.no_questions") };
+        }
+        const answers = [];
+        for (let i = 0; i < questions.length; i++) {
+            const q = questions[i];
+            const progress = questions.length > 1
+                ? t("tool.question.progress", {
+                    current: i + 1,
+                    total: questions.length,
+                })
+                : undefined;
+            answers.push(await askUser(q.question, {
+                header: q.header,
+                options: q.options,
+                multiple: q.multiple,
+                custom: q.custom,
+                progress,
+            }));
+        }
+        const formatted = questions
+            .map((q, i) => `"${q.question}"="${answers[i].length ? answers[i].join(", ") : t("tool.question.unanswered")}"`)
+            .join(", ");
+        return {
+            success: true,
+            output: t("tool.question.answered", { formatted }),
+        };
+    },
+};