micro-models-agent 0.19.0 → 0.19.2

package/dist/tools/edit-file.js

@@ -1,77 +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
-        const scanResult = scanContent(updated, path, ctx.config.security?.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/executor.js

@@ -1,95 +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;
-    }
-    async execute(call) {
-        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) {
-                        return {
-                            success: false,
-                            output: t("tool.blocked", {
-                                plugin: plugin.constructor?.name || "unknown",
-                            }),
-                            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 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: TOOL_EXECUTION_TIMEOUT_MS / 1000,
-                        })));
-                    }, TOOL_EXECUTION_TIMEOUT_MS);
-                });
-                result = await Promise.race([
-                    tool.handler(this.ctx, call.arguments),
-                    timeoutPromise,
-                ]);
-            }
-            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.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;
-    }
-}

package/dist/tools/file-info.js

@@ -1,45 +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'],
-    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),
-        };
-    },
-};

package/dist/tools/filter-tools.js

@@ -1,10 +0,0 @@
-export function filterToolsByTags(tools, toolTags) {
-    if (!toolTags || toolTags.length === 0)
-        return tools;
-    const tagSet = new Set(toolTags);
-    return tools.filter(t => {
-        if (!t.tags || t.tags.length === 0)
-            return false;
-        return t.tags.some(tag => tagSet.has(tag));
-    });
-}

package/dist/tools/glob-tool.js

@@ -1,26 +0,0 @@
-import { globSync } from 'fs';
-import { t } from '../i18n/index';
-import { MAX_PREVIEW_LINES } from './preview';
-export const globTool = {
-    name: 'glob',
-    description: `Search for files matching a glob pattern. Shows up to ${MAX_PREVIEW_LINES} results by default. Uses standard glob syntax (e.g., **/*.ts, src/**/*.test.ts).`,
-    tags: ['file', 'code', 'research'],
-    parameters: {
-        type: 'object',
-        properties: {
-            pattern: { type: 'string', description: 'Glob pattern' },
-        },
-        required: ['pattern'],
-    },
-    handler: async (ctx, args) => {
-        const pattern = String(args.pattern);
-        const results = globSync(pattern, { cwd: ctx.baseDir });
-        if (results.length === 0) {
-            return { success: true, output: t('file.no_matches') };
-        }
-        const truncated = results.length > MAX_PREVIEW_LINES
-            ? `\n... (${results.length - MAX_PREVIEW_LINES} more files)`
-            : '';
-        return { success: true, output: results.slice(0, MAX_PREVIEW_LINES).join('\n') + truncated };
-    },
-};

package/dist/tools/grep-tool.js

@@ -1,64 +0,0 @@
-import { execFileSync, execSync } from 'child_process';
-import { resolve } from 'path';
-import { t } from '../i18n/index';
-import { logBashCommand } from '../modules/security/audit-log';
-import { MAX_PREVIEW_LINES } from './preview';
-function truncateLines(output) {
-    const lines = output.split('\n');
-    if (lines.length <= MAX_PREVIEW_LINES)
-        return output;
-    return lines.slice(0, MAX_PREVIEW_LINES).join('\n') + `\n... (${lines.length - MAX_PREVIEW_LINES} more lines)`;
-}
-export const grepTool = {
-    name: 'grep',
-    description: `Search file contents using a regular expression. Shows up to ${MAX_PREVIEW_LINES} matching lines by default. Uses ripgrep (rg) if available, otherwise falls back to grep -r.`,
-    tags: ['file', 'code', 'research'],
-    parameters: {
-        type: 'object',
-        properties: {
-            pattern: { type: 'string', description: 'Regex pattern to search' },
-            include: { type: 'string', description: 'File pattern to filter (e.g. *.ts)' },
-            path: { type: 'string', description: 'Directory to search (defaults to baseDir)' },
-        },
-        required: ['pattern'],
-    },
-    handler: async (ctx, args) => {
-        const pattern = String(args.pattern);
-        const searchPath = args.path ? resolve(ctx.baseDir, String(args.path)) : ctx.baseDir;
-        // Build rg arguments as an array to avoid shell interpretation of regex
-        // metacharacters like |, (, ) — these are regex patterns, not shell operators.
-        const rgArgs = ['-n', '--with-filename', pattern, searchPath];
-        if (args.include) {
-            rgArgs.push('-g', String(args.include));
-        }
-        // Log the search (sanitized) for audit purposes
-        logBashCommand(ctx.sessionId, `rg ${rgArgs.join(' ')}`, false, 'grep-tool');
-        try {
-            const output = execFileSync('rg', rgArgs, {
-                encoding: 'utf-8',
-                maxBuffer: 1024 * 1024,
-                cwd: ctx.baseDir,
-            });
-            return { success: true, output: truncateLines(output || t('file.no_matches')) };
-        }
-        catch (e) {
-            if (e.status === 1)
-                return { success: true, output: t('file.no_matches') };
-            // Fall back to plain grep -r when rg is not available or fails
-            try {
-                const cmd = `grep -rn "${pattern.replace(/"/g, '\\"')}" "${searchPath}"`;
-                const output = execSync(cmd, {
-                    encoding: 'utf-8',
-                    maxBuffer: 1024 * 1024,
-                    cwd: ctx.baseDir,
-                });
-                return { success: true, output: truncateLines(output || t('file.no_matches')) };
-            }
-            catch (e2) {
-                if (e2.status === 1)
-                    return { success: true, output: t('file.no_matches') };
-                return { success: false, output: t('error.grep_failed', { message: e2.message }) };
-            }
-        }
-    },
-};

package/dist/tools/index.js

@@ -1,52 +0,0 @@
-import { ToolRegistry } from './registry';
-import { ToolExecutor } from './executor';
-import { readFileTool } from './read-file';
-import { writeFileTool } from './write-file';
-import { editFileTool } from './edit-file';
-import { globTool } from './glob-tool';
-import { grepTool } from './grep-tool';
-import { listDirTool } from './list-dir';
-import { createDirTool } from './create-dir';
-import { deleteFileTool } from './delete-file';
-import { moveFileTool } from './move-file';
-import { fileInfoTool } from './file-info';
-import { bashTool } from './bash';
-import { processListTool } from './process-list';
-import { processLogTool } from './process-log';
-import { processKillTool } from './process-kill';
-import { subagentTool } from './subagent';
-import { webSearchTool } from './web-search';
-import { webFetchTool } from './web-fetch';
-import { webBrowseTool } from './web-browse';
-import { questionTool } from './question';
-import { approveTool } from './approve';
-import { createLoadSkillTool } from './load-skill';
-import { pipelineRunTool } from './pipeline-run';
-import { mcpCallTool } from './mcp-call';
-import { searchHistoryTool } from './search-history';
-import { rememberTool } from './remember';
-import { recallTool } from './recall';
-import { createBrowserTool } from './browser';
-import { attachImageTool } from './attach-image';
-export { ToolRegistry, ToolExecutor };
-export { filterToolsByTags } from './filter-tools';
-export { readFileTool, writeFileTool, editFileTool, globTool, grepTool, listDirTool, createDirTool, deleteFileTool, moveFileTool, fileInfoTool, bashTool, subagentTool, processListTool, processLogTool, processKillTool, webSearchTool, webFetchTool, webBrowseTool, questionTool, approveTool, createLoadSkillTool, pipelineRunTool, mcpCallTool, searchHistoryTool, rememberTool, recallTool, createBrowserTool, attachImageTool, };
-export function registerAllTools(registry, skillsModule) {
-    const tools = [
-        readFileTool, writeFileTool, editFileTool,
-        globTool, grepTool, listDirTool, createDirTool,
-        deleteFileTool, moveFileTool, fileInfoTool,
-        bashTool, subagentTool,
-        processListTool, processLogTool, processKillTool,
-        webSearchTool, webFetchTool, webBrowseTool,
-        questionTool, approveTool,
-        pipelineRunTool, mcpCallTool, searchHistoryTool,
-        attachImageTool,
-    ];
-    if (skillsModule) {
-        tools.push(createLoadSkillTool(skillsModule));
-    }
-    for (const tool of tools) {
-        registry.register(tool);
-    }
-}

package/dist/tools/list-dir.js

@@ -1,47 +0,0 @@
-import { readdirSync, statSync, existsSync } from 'fs';
-import { resolve } from 'path';
-import { t } from '../i18n/index';
-import { isPathInScope } from '../modules/security/path-validator';
-import { safeResolvePath } from './path-utils';
-import { MAX_PREVIEW_LINES } from './preview';
-export const listDirTool = {
-    name: 'list_dir',
-    description: `List files and directories in a given path. Shows up to ${MAX_PREVIEW_LINES} entries by default.`,
-    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);
-        // 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.dir_notfound', { path }) };
-        }
-        const entries = readdirSync(resolved);
-        const lines = entries.map(e => {
-            const full = resolve(resolved, e);
-            return statSync(full).isDirectory() ? `${e}/` : e;
-        });
-        if (lines.length === 0) {
-            return { success: true, output: t('file.empty') };
-        }
-        const truncated = lines.length > MAX_PREVIEW_LINES
-            ? `\n... (${lines.length - MAX_PREVIEW_LINES} more entries)`
-            : '';
-        return { success: true, output: lines.slice(0, MAX_PREVIEW_LINES).join('\n') + truncated };
-    },
-};

package/dist/tools/load-skill.js

@@ -1,48 +0,0 @@
-import { t } from "../i18n/index";
-export function createLoadSkillTool(skillsModule) {
-    return {
-        name: "load_skill",
-        tags: ["core"],
-        description: "Load a skill by name or task description. Skills provide specialized instructions and workflows. Only use when the task clearly requires domain-specific knowledge. If loading fails because the skill is too large, continue the task without it.",
-        parameters: {
-            type: "object",
-            properties: {
-                name: { type: "string", description: "Skill name to load directly" },
-                task: {
-                    type: "string",
-                    description: "Task description to find matching skill",
-                },
-            },
-        },
-        handler: async (_ctx, args) => {
-            const name = args.name ? String(args.name) : undefined;
-            const task = args.task ? String(args.task) : undefined;
-            if (!name && !task) {
-                return { success: false, output: t("tool.name_or_task") };
-            }
-            let result;
-            if (name) {
-                result = skillsModule.loadByName(name);
-            }
-            else if (task) {
-                result = skillsModule.loadByMatch(task);
-            }
-            else {
-                return { success: false, output: t("tool.invalid_params") };
-            }
-            if (!result.success) {
-                const available = skillsModule.getAvailable();
-                const hint = available.length > 0
-                    ? `\n\n${t("tool.skill_available_hint")}: ${available.map((s) => s.name).join(", ")}`
-                    : "";
-                return { success: false, output: result.message + hint };
-            }
-            const skill = result.skill;
-            const budget = skillsModule.getBudget();
-            return {
-                success: true,
-                output: `${result.message}\n\n--- Skill Content ---\n${skill.content}\n\n${t("tool.skill_budget", { remaining: budget.remaining })}`,
-            };
-        },
-    };
-}

package/dist/tools/mcp-call.js

@@ -1,68 +0,0 @@
-import { MCPClient } from "../modules/mcp/client";
-import { MCPRegistry } from "../modules/mcp/registry";
-const registry = new MCPRegistry();
-let initialized = false;
-function ensureInitialized(ctx) {
-    if (initialized)
-        return;
-    initialized = true;
-    const servers = ctx.config.mcpServers || {};
-    for (const [name, cfg] of Object.entries(servers)) {
-        if (cfg.enabled !== false) {
-            registry.register({
-                name: cfg.name || name,
-                command: cfg.command,
-                args: cfg.args,
-                env: cfg.env,
-                transport: cfg.transport,
-                url: cfg.url,
-                headers: cfg.headers,
-                timeout: cfg.timeout,
-            });
-        }
-    }
-}
-export const mcpCallTool = {
-    name: "mcp_call",
-    description: "Call a tool on an MCP (Model Context Protocol) server. MCP servers provide external capabilities like databases, APIs, or specialized tools.",
-    tags: ["code", "research"],
-    parameters: {
-        type: "object",
-        properties: {
-            server: { type: "string", description: "MCP server name" },
-            tool: { type: "string", description: "Tool name on the server" },
-            args: { type: "object", description: "Arguments to pass to the tool" },
-        },
-        required: ["server", "tool"],
-    },
-    handler: async (ctx, args) => {
-        const serverName = String(args.server || "");
-        const toolName = String(args.tool || "");
-        const toolArgs = (args.args || {});
-        if (!serverName || !toolName) {
-            return { success: false, output: "Server and tool names are required" };
-        }
-        ensureInitialized(ctx);
-        const serverConfig = registry.get(serverName);
-        if (!serverConfig) {
-            const available = registry.list();
-            return {
-                success: false,
-                output: `MCP server "${serverName}" not found. Available: ${available.join(", ") || "(none)"}`,
-            };
-        }
-        try {
-            const client = new MCPClient(serverConfig);
-            await client.connect();
-            const result = await client.callTool(toolName, toolArgs);
-            await client.disconnect();
-            return {
-                success: true,
-                output: `MCP call result:\n${JSON.stringify(result, null, 2)}`,
-            };
-        }
-        catch (e) {
-            return { success: false, output: `MCP call failed: ${e.message}` };
-        }
-    },
-};

package/dist/tools/move-file.js

@@ -1,84 +0,0 @@
-import { renameSync, existsSync, mkdirSync } from "fs";
-import { resolve, normalize, dirname } from "path";
-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 { generateMoveDiff } from "../ui/diff";
-export const moveFileTool = {
-    name: "move_file",
-    description: "Move or rename a file or directory.",
-    tags: ["file"],
-    parameters: {
-        type: "object",
-        properties: {
-            from: { type: "string", description: "Source path" },
-            to: { type: "string", description: "Destination path" },
-        },
-        required: ["from", "to"],
-    },
-    handler: async (ctx, args) => {
-        const fromPath = String(args.from);
-        const toPath = String(args.to);
-        const baseDir = resolve(ctx.baseDir);
-        const fromResolved = resolve(baseDir, normalize(fromPath));
-        const toResolved = resolve(baseDir, normalize(toPath));
-        // 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`, `${fromPath} -> ${toPath}`);
-            return {
-                success: false,
-                output: `[SECURITY BLOCKED] Maximum file operations (${maxFileOps}) exceeded`,
-            };
-        }
-        // Check source path permissions
-        const fromCheck = isPathWritable(ctx.baseDir, fromPath, ctx.scope, ctx.config.security?.paths);
-        if (!fromCheck.allowed) {
-            logSecurityBlock(ctx.sessionId, "file_write", fromCheck.reason || "Source path not allowed", fromPath);
-            return {
-                success: false,
-                output: t("file.path_not_allowed", {
-                    path: `${fromPath} — ${fromCheck.reason}`,
-                }),
-            };
-        }
-        // Check destination path permissions
-        const toCheck = isPathWritable(ctx.baseDir, toPath, ctx.scope, ctx.config.security?.paths);
-        if (!toCheck.allowed) {
-            logSecurityBlock(ctx.sessionId, "file_write", toCheck.reason || "Destination path not allowed", toPath);
-            return {
-                success: false,
-                output: t("file.path_not_allowed", {
-                    path: `${toPath} — ${toCheck.reason}`,
-                }),
-            };
-        }
-        if (!existsSync(fromResolved)) {
-            return {
-                success: false,
-                output: t("file.not_found_short", { path: fromPath }),
-            };
-        }
-        const toDir = dirname(toResolved);
-        if (!existsSync(toDir)) {
-            mkdirSync(toDir, { recursive: true });
-        }
-        renameSync(fromResolved, toResolved);
-        const diff = generateMoveDiff(fromPath, toPath);
-        // Increment file operations counter
-        ctx.fileOperationsCount = currentCount + 1;
-        // Log file move
-        logFileWrite(ctx.sessionId, `${fromPath} -> ${toPath}`, true, "File moved");
-        return {
-            success: true,
-            output: t("file.moved", { from: fromPath, to: toPath }),
-            diff,
-        };
-    },
-};

package/dist/tools/path-utils.js

@@ -1,51 +0,0 @@
-import { resolve, normalize, dirname, basename, sep } from 'path';
-import { existsSync } from 'fs';
-/**
- * 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) {
-    const norm = normalize(userPath);
-    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;
-}