micro-models-agent 0.50.4 → 0.51.2

package/dist/tools/chunk-query.js

@@ -1,99 +0,0 @@
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { t } from "../i18n/index";
-import { isPathInScope } from "./scope-check";
-import { runChunkQuery } from "../modules/context/chunk-query";
-export const chunkQueryTool = {
-    name: "chunk_query",
-    description: "Answer a query over a large text (file or inline) by splitting it into chunks and querying the model per chunk in parallel, then optionally synthesizing a final answer. Use when the input is too large for the context window.",
-    tags: ["research", "code"],
-    /** Multiple LLM calls (parallel chunk queries + synthesis) need a longer budget. */
-    timeoutMs: 300000,
-    parameters: {
-        type: "object",
-        properties: {
-            query: {
-                type: "string",
-                description: "The question to answer over the text.",
-            },
-            input_path: {
-                type: "string",
-                description: "Path to the large text file (scope-checked). Preferred over text.",
-            },
-            text: {
-                type: "string",
-                description: "Inline text. Use only when a file path is not available.",
-            },
-            chunk_chars: {
-                type: "number",
-                description: "Approximate chunk size in chars (default 12000).",
-            },
-            max_parallel: {
-                type: "number",
-                description: "Max parallel chunk queries (default from config.subagent.maxParallelChunkQueries).",
-            },
-            max_chunk_tokens: {
-                type: "number",
-                description: "Cap on generated tokens per chunk call (default 1024).",
-            },
-            max_synthesis_tokens: {
-                type: "number",
-                description: "Cap on generated tokens for the synthesis call (default 2048).",
-            },
-            reasoning_effort: {
-                type: "string",
-                enum: ["none", "low", "medium", "high"],
-                description: 'Reasoning effort for chunk/synthesis calls (default "none"). "none" prevents long thinking chains from eating the token budget on reasoning models.',
-            },
-            synthesize: {
-                type: "boolean",
-                description: "Run a final synthesis call over chunk answers (default true).",
-            },
-        },
-        required: ["query"],
-    },
-    handler: async (ctx, args) => {
-        const query = String(args.query || "");
-        const inputPath = args.input_path ? String(args.input_path) : undefined;
-        const text = args.text ? String(args.text) : undefined;
-        if (!query)
-            return { success: false, output: t("tool.chunk_query_no_query") };
-        if (!inputPath && !text)
-            return { success: false, output: t("tool.chunk_query_no_input") };
-        let content = text || "";
-        if (inputPath) {
-            const check = isPathInScope(ctx.baseDir, inputPath, ctx.scope);
-            if (!check.allowed) {
-                return { success: false, output: `[SCOPE] ${check.reason || "Path not allowed"}` };
-            }
-            try {
-                content = readFileSync(resolve(ctx.baseDir, inputPath), "utf8");
-            }
-            catch (e) {
-                return { success: false, output: `Cannot read ${inputPath}: ${e.message}` };
-            }
-        }
-        if (!ctx.llmProvider) {
-            return { success: false, output: "chunk_query: missing llmProvider in context" };
-        }
-        const maxParallel = typeof args.max_parallel === "number"
-            ? args.max_parallel
-            : (ctx.config.subagent?.maxParallelChunkQueries ?? 4);
-        const res = await runChunkQuery(ctx.llmProvider, content, query, {
-            chunkChars: typeof args.chunk_chars === "number" ? args.chunk_chars : undefined,
-            maxParallel,
-            synthesize: typeof args.synthesize === "boolean" ? args.synthesize : undefined,
-            maxChunkTokens: typeof args.max_chunk_tokens === "number" ? args.max_chunk_tokens : undefined,
-            maxSynthesisTokens: typeof args.max_synthesis_tokens === "number" ? args.max_synthesis_tokens : undefined,
-            reasoningEffort: ["none", "low", "medium", "high"].includes(args.reasoning_effort)
-                ? args.reasoning_effort
-                : undefined,
-            logger: ctx.logger,
-        });
-        ctx.logger.debug(`chunk_query: ${res.chunks} chunk(s), ${res.totalChars} chars, max parallel ${res.maxParallelObserved}`);
-        return {
-            success: true,
-            output: `[chunk_query] ${res.chunks} chunk(s), ${res.totalChars} chars, max parallel ${res.maxParallelObserved}\n\n${res.synthesis || res.answers.join("\n")}`,
-        };
-    },
-};

package/dist/tools/create-dir.js

@@ -1,55 +0,0 @@
-import { mkdirSync, existsSync } from "fs";
-import { t } from "../i18n/index";
-import { isPathWritable } from "../modules/security/path-validator";
-import { logFileWrite, logSecurityBlock } from "../modules/security/audit-log";
-import { getSessionSecurityConfig } from "../modules/security/session-isolation";
-import { safeResolvePath } from "./path-utils";
-export const createDirTool = {
-    name: "create_dir",
-    description: "Create a directory (and any intermediate directories).",
-    tags: ["file"],
-    parameters: {
-        type: "object",
-        properties: {
-            path: { type: "string", description: "Directory path" },
-        },
-        required: ["path"],
-    },
-    handler: async (ctx, args) => {
-        const path = String(args.path);
-        const resolved = safeResolvePath(ctx.baseDir, path);
-        // Get session-specific security config
-        const securityConfig = ctx.sessionContext
-            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext)
-            : ctx.config.security;
-        // Check file operations limit
-        const maxFileOps = securityConfig?.maxFileOperations ?? 100;
-        const currentCount = ctx.fileOperationsCount ?? 0;
-        if (currentCount >= maxFileOps) {
-            logSecurityBlock(ctx.sessionId, "file_write", `Maximum file operations (${maxFileOps}) exceeded`, path);
-            return {
-                success: false,
-                output: `[SECURITY BLOCKED] Maximum file operations (${maxFileOps}) exceeded`,
-            };
-        }
-        // Check path permissions
-        const scopeCheck = isPathWritable(ctx.baseDir, resolved, ctx.scope, ctx.config.security?.paths);
-        if (!scopeCheck.allowed) {
-            logSecurityBlock(ctx.sessionId, "file_write", scopeCheck.reason || "Path not allowed", path);
-            return {
-                success: false,
-                output: t("file.path_not_allowed", {
-                    path: `${path} — ${scopeCheck.reason}`,
-                }),
-            };
-        }
-        if (!existsSync(resolved)) {
-            mkdirSync(resolved, { recursive: true });
-        }
-        // Increment file operations counter
-        ctx.fileOperationsCount = currentCount + 1;
-        // Log directory creation
-        logFileWrite(ctx.sessionId, path, true, "Directory created");
-        return { success: true, output: t("file.created", { path }) };
-    },
-};

package/dist/tools/delete-file.js

@@ -1,62 +0,0 @@
-import { unlinkSync, existsSync, statSync, readFileSync } from "fs";
-import { t } from "../i18n/index";
-import { isPathWritable } from "../modules/security/path-validator";
-import { logFileDelete, logSecurityBlock } from "../modules/security/audit-log";
-import { getSessionSecurityConfig } from "../modules/security/session-isolation";
-import { generateDeleteDiff } from "../ui/diff";
-import { safeResolvePath } from "./path-utils";
-export const deleteFileTool = {
-    name: "delete_file",
-    description: "Delete a file from the filesystem.",
-    tags: ["file"],
-    parameters: {
-        type: "object",
-        properties: {
-            path: { type: "string", description: "File path" },
-        },
-        required: ["path"],
-    },
-    handler: async (ctx, args) => {
-        const path = String(args.path);
-        const resolved = safeResolvePath(ctx.baseDir, path);
-        // Get session-specific security config
-        const securityConfig = ctx.sessionContext
-            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext)
-            : ctx.config.security;
-        // Check file operations limit
-        const maxFileOps = securityConfig?.maxFileOperations ?? 100;
-        const currentCount = ctx.fileOperationsCount ?? 0;
-        if (currentCount >= maxFileOps) {
-            logSecurityBlock(ctx.sessionId, "file_delete", `Maximum file operations (${maxFileOps}) exceeded`, path);
-            return {
-                success: false,
-                output: `[SECURITY BLOCKED] Maximum file operations (${maxFileOps}) exceeded`,
-            };
-        }
-        // Check path permissions
-        const scopeCheck = isPathWritable(ctx.baseDir, resolved, ctx.scope, ctx.config.security?.paths);
-        if (!scopeCheck.allowed) {
-            logSecurityBlock(ctx.sessionId, "file_delete", scopeCheck.reason || "Path not allowed", path);
-            return {
-                success: false,
-                output: t("file.path_not_allowed", {
-                    path: `${path} — ${scopeCheck.reason}`,
-                }),
-            };
-        }
-        if (!existsSync(resolved)) {
-            return { success: false, output: t("file.notfound", { path }) };
-        }
-        if (statSync(resolved).isDirectory()) {
-            return { success: false, output: t("file.is_directory", { path }) };
-        }
-        const content = readFileSync(resolved, "utf-8");
-        unlinkSync(resolved);
-        const diff = generateDeleteDiff(content);
-        // Increment file operations counter
-        ctx.fileOperationsCount = currentCount + 1;
-        // Log successful file deletion
-        logFileDelete(ctx.sessionId, path, true);
-        return { success: true, output: t("file.deleted", { path }), diff };
-    },
-};

package/dist/tools/download-file.js

@@ -1,116 +0,0 @@
-import { writeFileSync, mkdirSync } from "fs";
-import { dirname } from "path";
-import { t } from "../i18n/index";
-import { isUrlAllowed, sanitizeUrl } from "../modules/security/network-validator";
-import { isPathWritable } from "../modules/security/path-validator";
-import { logNetworkRequest, logFileWrite, logSecurityBlock } from "../modules/security/audit-log";
-import { getSessionSecurityConfig } from "../modules/security/session-isolation";
-import { DEFAULT_SECURITY_CONFIG } from "../config/security";
-import { safeResolvePath } from "./path-utils";
-/** Default cap for a single download (bytes). Chunked responses without a
- * content-length header are checked after the body is read. */
-export const MAX_DOWNLOAD_BYTES = 100 * 1024 * 1024;
-export const downloadFileTool = {
-    name: "download_file",
-    description: "Download a file (image, archive, binary, font, etc.) from a URL and save it to disk. Returns only the path, size and content type — read the saved file with read_file/attach_image afterwards. Use this for binary files; web_fetch/web_browse return text only and cannot save bytes.",
-    tags: ["file", "research"],
-    parameters: {
-        type: "object",
-        properties: {
-            url: { type: "string", description: "URL to download" },
-            path: {
-                type: "string",
-                description: "Destination path (relative to the working directory)",
-            },
-            max_bytes: {
-                type: "number",
-                description: "Optional size cap in bytes (default 100 MB)",
-            },
-        },
-        required: ["url", "path"],
-    },
-    handler: async (ctx, args) => {
-        const url = String(args.url || "").trim();
-        const path = String(args.path || "").trim();
-        if (!url || !path) {
-            return { success: false, output: t("tool.invalid_params") };
-        }
-        // Network security: same rules as web_fetch/web_browse.
-        const securityConfig = ctx.sessionContext
-            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext).network
-            : ctx.config.security?.network || DEFAULT_SECURITY_CONFIG.network;
-        const validation = isUrlAllowed(url, securityConfig);
-        if (!validation.allowed) {
-            logSecurityBlock(ctx.sessionId, "network_request", validation.reason || "URL blocked by security policy", sanitizeUrl(url));
-            return {
-                success: false,
-                output: `[SECURITY BLOCKED] URL is not allowed: ${validation.reason}`,
-            };
-        }
-        // Path safety: resolve against baseDir and verify writability.
-        const resolved = safeResolvePath(ctx.baseDir, path);
-        const scopeCheck = isPathWritable(ctx.baseDir, resolved, ctx.scope, ctx.config.security?.paths);
-        if (!scopeCheck.allowed) {
-            logSecurityBlock(ctx.sessionId, "file_write", scopeCheck.reason || "Path not allowed", path);
-            return {
-                success: false,
-                output: t("file.path_not_allowed", {
-                    path: `${path} — ${scopeCheck.reason}`,
-                }),
-            };
-        }
-        const maxBytes = Number(args.max_bytes) > 0 ? Number(args.max_bytes) : MAX_DOWNLOAD_BYTES;
-        try {
-            const response = await fetch(url, {
-                signal: AbortSignal.timeout(securityConfig?.requestTimeout || 15000),
-            });
-            if (!response.ok) {
-                logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Status: ${response.status}`);
-                return {
-                    success: false,
-                    output: t("error.http", {
-                        status: response.status,
-                        statusText: response.statusText,
-                    }),
-                };
-            }
-            const contentLength = Number(response.headers.get("content-length") || "0");
-            if (contentLength > maxBytes) {
-                logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Too large: ${contentLength}`);
-                return {
-                    success: false,
-                    output: t("tool.download_too_large", { max: String(maxBytes) }),
-                };
-            }
-            const buffer = Buffer.from(await response.arrayBuffer());
-            if (buffer.byteLength > maxBytes) {
-                logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Too large: ${buffer.byteLength}`);
-                return {
-                    success: false,
-                    output: t("tool.download_too_large", { max: String(maxBytes) }),
-                };
-            }
-            mkdirSync(dirname(resolved), { recursive: true });
-            writeFileSync(resolved, buffer);
-            const contentType = response.headers.get("content-type")?.split(";")[0]?.trim() || "unknown";
-            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), true, `Status: ${response.status}`);
-            logFileWrite(ctx.sessionId, resolved, true, `Downloaded ${buffer.byteLength} bytes`);
-            return {
-                success: true,
-                output: t("tool.downloaded", {
-                    url: sanitizeUrl(url),
-                    path: resolved,
-                    size: String(buffer.byteLength),
-                    type: contentType,
-                }),
-            };
-        }
-        catch (e) {
-            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Error: ${e.message}`);
-            return {
-                success: false,
-                output: t("error.fetch_failed", { message: e.message }),
-            };
-        }
-    },
-};

package/dist/tools/edit-file.js

@@ -1,79 +0,0 @@
-import { readFileSync, writeFileSync } from "fs";
-import { t } from "../i18n/index";
-import { isPathWritable } from "../modules/security/path-validator";
-import { scanContent } from "../modules/security/content-scanner";
-import { logFileWrite, logSecurityBlock } from "../modules/security/audit-log";
-import { getSessionSecurityConfig } from "../modules/security/session-isolation";
-import { generateDiff } from "../ui/diff";
-import { safeResolvePath } from "./path-utils";
-export const editFileTool = {
-    name: "edit_file",
-    description: "Find and replace text in an existing file. Uses exact string match (not regex).",
-    tags: ["file", "code"],
-    parameters: {
-        type: "object",
-        properties: {
-            path: { type: "string", description: "File path" },
-            old: { type: "string", description: "Text to replace" },
-            new: { type: "string", description: "Replacement text" },
-        },
-        required: ["path", "old", "new"],
-    },
-    handler: async (ctx, args) => {
-        const path = String(args.path);
-        const resolved = safeResolvePath(ctx.baseDir, path);
-        // Get session-specific security config
-        const securityConfig = ctx.sessionContext
-            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext)
-            : ctx.config.security;
-        // Check file operations limit
-        const maxFileOps = securityConfig?.maxFileOperations ?? 100;
-        const currentCount = ctx.fileOperationsCount ?? 0;
-        if (currentCount >= maxFileOps) {
-            logSecurityBlock(ctx.sessionId, "file_write", `Maximum file operations (${maxFileOps}) exceeded`, path);
-            return {
-                success: false,
-                output: `[SECURITY BLOCKED] Maximum file operations (${maxFileOps}) exceeded`,
-            };
-        }
-        // Check path permissions
-        const scopeCheck = isPathWritable(ctx.baseDir, resolved, ctx.scope, ctx.config.security?.paths);
-        if (!scopeCheck.allowed) {
-            logSecurityBlock(ctx.sessionId, "file_write", scopeCheck.reason || "Path not allowed", path);
-            return {
-                success: false,
-                output: t("file.path_not_allowed", {
-                    path: `${path} — ${scopeCheck.reason}`,
-                }),
-            };
-        }
-        const content = readFileSync(resolved, "utf-8");
-        const oldStr = String(args.old);
-        const newStr = String(args.new);
-        if (!content.includes(oldStr)) {
-            return {
-                success: false,
-                output: t("file.string_not_found", { str: oldStr }),
-            };
-        }
-        const updated = content.replace(oldStr, newStr);
-        // Check new content for dangerous patterns — only when security is enabled
-        if (securityConfig?.enabled && securityConfig?.contentScan?.enabled) {
-            const scanResult = scanContent(updated, path, securityConfig.contentScan);
-            if (!scanResult.allowed) {
-                logSecurityBlock(ctx.sessionId, "file_write", scanResult.reason || "Content contains dangerous patterns", path);
-                return {
-                    success: false,
-                    output: `[SECURITY BLOCKED] ${scanResult.reason}`,
-                };
-            }
-        }
-        writeFileSync(resolved, updated, "utf-8");
-        const diff = generateDiff(content, updated);
-        // Increment file operations counter
-        ctx.fileOperationsCount = currentCount + 1;
-        // Log successful file edit
-        logFileWrite(ctx.sessionId, path, true, "File edited");
-        return { success: true, output: t("file.replaced_in", { path }), diff };
-    },
-};

package/dist/tools/enable-tools.js

@@ -1,58 +0,0 @@
-import { t } from "../i18n/index";
-/**
- * On-demand tool activation. The main loop exposes only `config.tools.defaultTags`
- * (+ `alwaysOn` structural tools). Specialized tools (web, browser, memory,
- * process) are hidden from the schema to shrink the token footprint; the model
- * activates them by calling this tool with the desired tag. The handler pushes
- * the tags into the shared mutable `ctx.activeToolTags` array, which the agent
- * loop re-reads each iteration to recompute the LLM-visible tool set.
- */
-export const enableToolsTool = {
-    name: "enable_tools",
-    description: "Enable hidden tool categories for the current session. Only the essential tools (file/code/shell) are active by default. Call this with the tags you need and they become available from the next turn. Available tags: file, code, shell, research, browser, vision, image, memory, core. Returns the newly available tools. To run a task in a separate context instead, use subagent with tool_tags.",
-    alwaysOn: true,
-    parameters: {
-        type: "object",
-        properties: {
-            tags: {
-                type: "array",
-                items: { type: "string" },
-                description: 'Tool tags to enable (e.g. ["research"] for web_search/web_fetch, ["browser"] for the browser, ["memory"] for remember/recall, ["shell"] for process management).',
-            },
-        },
-        required: ["tags"],
-    },
-    handler: async (ctx, args) => {
-        const requested = Array.isArray(args.tags) ? args.tags.map(String).filter(Boolean) : [];
-        if (requested.length === 0) {
-            return { success: false, output: t("tools.enable_no_tags") };
-        }
-        const active = ctx.activeToolTags ?? [];
-        const added = [];
-        for (const tag of requested) {
-            if (!active.includes(tag)) {
-                active.push(tag);
-                added.push(tag);
-            }
-        }
-        if (!ctx.toolExecutor) {
-            return { success: false, output: t("tools.enable_no_executor") };
-        }
-        const nowVisible = ctx.toolExecutor.getToolDefinitions([...active]).map((t) => t.name);
-        if (added.length === 0) {
-            return {
-                success: true,
-                output: t("tools.enable_already_active", {
-                    tags: requested.join(", "),
-                }),
-            };
-        }
-        return {
-            success: true,
-            output: t("tools.enable_added", {
-                tags: added.join(", "),
-                tools: nowVisible.join(", "),
-            }),
-        };
-    },
-};

package/dist/tools/executor.js

@@ -1,144 +0,0 @@
-import { killByCallId } from "../modules/processes/runner";
-import { t } from "../i18n/index";
-const TOOL_EXECUTION_TIMEOUT_MS = 60000;
-export class ToolExecutor {
-    registry;
-    ctx;
-    pluginManager;
-    constructor(registry, ctx, pluginManager) {
-        this.registry = registry;
-        this.ctx = ctx;
-        this.pluginManager = pluginManager;
-    }
-    /**
-     * Execute a tool by name with plain arguments (no call id, no timeout
-     * wiring). Used internally — e.g. bash redirects a mistaken tool-call-as-
-     * command into the real tool. Runs through the same registry and plugin
-     * hooks as a normal call.
-     */
-    async executeByName(name, args, ctx) {
-        const prevCtx = this.ctx;
-        if (ctx)
-            this.ctx = ctx;
-        try {
-            return await this.execute({
-                id: `redirect_${Date.now()}`,
-                name,
-                arguments: args,
-            });
-        }
-        finally {
-            this.ctx = prevCtx;
-        }
-    }
-    /** Whether a tool with this name is registered (used before redirects). */
-    hasTool(name) {
-        return this.registry.has(name);
-    }
-    async execute(call, signal) {
-        const tool = this.registry.get(call.name);
-        if (!tool) {
-            return {
-                success: false,
-                output: t("tool.unknown", { name: call.name }),
-                toolCallId: call.id,
-            };
-        }
-        for (const plugin of this.pluginManager.getAllPlugins()) {
-            if (plugin.onBeforeTool) {
-                try {
-                    const proceed = await plugin.onBeforeTool(this.ctx, call);
-                    if (proceed === false || typeof proceed === "string") {
-                        const pluginName = plugin.name || plugin.constructor?.name || "unknown";
-                        const reason = typeof proceed === "string" ? proceed : undefined;
-                        return {
-                            success: false,
-                            output: reason
-                                ? t("tool.blocked_reason", { plugin: pluginName, reason })
-                                : t("tool.blocked", { plugin: pluginName }),
-                            toolCallId: call.id,
-                        };
-                    }
-                }
-                catch (e) {
-                    this.ctx.logger.warn(`Plugin onBeforeTool error: ${e.message}`);
-                }
-            }
-        }
-        let result;
-        try {
-            this.ctx.activeCallId = call.id;
-            if (tool.interactive) {
-                // Interactive tools wait for user input — no timeout.
-                result = await tool.handler(this.ctx, call.arguments);
-            }
-            else {
-                const timeoutMs = tool.timeoutMs ?? TOOL_EXECUTION_TIMEOUT_MS;
-                const timeoutPromise = new Promise((_, reject) => {
-                    setTimeout(() => {
-                        // Kill any long-running child process registered for this call.
-                        killByCallId(call.id);
-                        reject(new Error(t("tool.timeout", {
-                            name: call.name,
-                            seconds: Math.round(timeoutMs / 1000),
-                        })));
-                    }, timeoutMs);
-                });
-                const racePromises = [
-                    tool.handler(this.ctx, call.arguments),
-                    timeoutPromise,
-                ];
-                if (signal) {
-                    const abortPromise = new Promise((_, reject) => {
-                        const onAbort = () => {
-                            killByCallId(call.id);
-                            reject(new Error(t("tool.aborted", { name: call.name })));
-                        };
-                        if (signal.aborted) {
-                            onAbort();
-                        }
-                        else {
-                            signal.addEventListener("abort", onAbort, { once: true });
-                        }
-                    });
-                    racePromises.push(abortPromise);
-                }
-                result = await Promise.race(racePromises);
-            }
-            result.toolCallId = call.id;
-        }
-        catch (e) {
-            result = {
-                success: false,
-                output: `${t("error.prefix")}${e.message}`,
-                toolCallId: call.id,
-            };
-        }
-        for (const plugin of this.pluginManager.getAllPlugins()) {
-            if (plugin.onAfterTool) {
-                try {
-                    await plugin.onAfterTool(this.ctx, call, result);
-                }
-                catch (e) {
-                    this.ctx.logger.warn(`Plugin onAfterTool error: ${e.message}`);
-                }
-            }
-        }
-        this.ctx.logger.logToolCall(call.name, JSON.stringify(call.arguments)?.slice(0, 200) ?? "", result.success ? "OK" : `FAIL: ${result.output?.slice(0, 200)}`);
-        this.ctx.logger.logToolOutput(call.name, result.output ?? "", result.success ? 0 : 1);
-        this.ctx.logger.debug(`Tool ${call.name}: ${result.success ? "OK" : "FAIL"}`);
-        return result;
-    }
-    getToolDefinitions(tags) {
-        return this.registry.getAllForLLM(tags);
-    }
-    getRegistry() {
-        return this.registry;
-    }
-    setScope(scope) {
-        this.ctx.scope = scope;
-    }
-    updateProvider(provider) {
-        this.ctx.llmProvider = provider;
-    }
-}

package/dist/tools/file-info.js

@@ -1,46 +0,0 @@
-import { statSync, existsSync } from "fs";
-import { t } from "../i18n/index";
-import { isPathInScope } from "../modules/security/path-validator";
-import { safeResolvePath } from "./path-utils";
-export const fileInfoTool = {
-    name: "file_info",
-    description: "Get metadata about a file or directory (size, creation date, modification date).",
-    tags: ["file"],
-    boundedOutput: true,
-    parameters: {
-        type: "object",
-        properties: {
-            path: { type: "string", description: "File path" },
-        },
-        required: ["path"],
-    },
-    handler: async (ctx, args) => {
-        const path = String(args.path);
-        const resolved = safeResolvePath(ctx.baseDir, path);
-        // Check path permissions
-        const scopeCheck = isPathInScope(ctx.baseDir, resolved, ctx.scope, ctx.config.security?.paths);
-        if (!scopeCheck.allowed) {
-            return {
-                success: false,
-                output: t("file.path_not_allowed", {
-                    path: `${path} — ${scopeCheck.reason}`,
-                }),
-            };
-        }
-        if (!existsSync(resolved)) {
-            return { success: false, output: t("file.not_found_short", { path }) };
-        }
-        const stat = statSync(resolved);
-        return {
-            success: true,
-            output: JSON.stringify({
-                path,
-                size: stat.size,
-                isDirectory: stat.isDirectory(),
-                isFile: stat.isFile(),
-                created: stat.birthtime,
-                modified: stat.mtime,
-            }, null, 2),
-        };
-    },
-};