micro-models-agent 0.54.1 → 0.55.1

package/dist/tools/path-utils.js

@@ -1,101 +0,0 @@
-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

@@ -1,145 +0,0 @@
-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

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

package/dist/tools/process-kill.js

@@ -1,40 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,141 +0,0 @@
-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 }),
-        };
-    },
-};