micro-models-agent 0.28.0 → 0.28.2

package/dist/modules/user-profile/profile.js

@@ -1,68 +0,0 @@
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { homedir, hostname, platform, type } from 'os';
-import { env } from 'process';
-import { ProfileCompressor } from './compressor';
-export class UserProfile {
-    profileDir;
-    info = null;
-    preferences = {};
-    constructor(profileDir) {
-        this.profileDir = profileDir;
-    }
-    collect() {
-        this.info = {
-            platform: platform(),
-            os: `${type()} ${hostname()}`,
-            hostname: hostname(),
-            shell: env.SHELL || env.ComSpec || 'unknown',
-            home: homedir(),
-            nodeVersion: process.version,
-            preferences: { ...this.preferences },
-        };
-        return this.info;
-    }
-    save() {
-        if (!existsSync(this.profileDir)) {
-            mkdirSync(this.profileDir, { recursive: true });
-        }
-        writeFileSync(join(this.profileDir, 'profile.json'), JSON.stringify({ ...this.info, preferences: this.preferences }, null, 2), 'utf-8');
-    }
-    load() {
-        const path = join(this.profileDir, 'profile.json');
-        if (!existsSync(path))
-            return null;
-        try {
-            const data = JSON.parse(readFileSync(path, 'utf-8'));
-            this.info = {
-                platform: data.platform,
-                os: data.os,
-                hostname: data.hostname,
-                shell: data.shell,
-                home: data.home,
-                nodeVersion: data.nodeVersion,
-                preferences: data.preferences || {},
-            };
-            this.preferences = data.preferences || {};
-            return this.info;
-        }
-        catch {
-            return null;
-        }
-    }
-    getInfo() {
-        return this.info;
-    }
-    setPreference(key, value) {
-        this.preferences[key] = value;
-    }
-    getPreference(key) {
-        return this.preferences[key];
-    }
-    compress() {
-        if (!this.info)
-            this.collect();
-        const compressor = new ProfileCompressor();
-        return compressor.compress(this.info);
-    }
-}

package/dist/tools/approve.js

@@ -1,32 +0,0 @@
-import { t } from "../i18n/index";
-import { askChoice } from "./user-input";
-export const approveTool = {
-    name: "approve",
-    description: "Request user approval for an action. The user picks Yes or No from a menu.",
-    tags: ["core"],
-    interactive: true,
-    parameters: {
-        type: "object",
-        properties: {
-            action: {
-                type: "string",
-                description: "Description of the action requiring approval",
-            },
-        },
-        required: ["action"],
-    },
-    handler: async (ctx, args) => {
-        if (ctx.exitOnComplete) {
-            return { success: false, output: t("tool.interactive_disabled") };
-        }
-        const action = String(args.action || "");
-        const indexes = await askChoice(t("tool.approve_prompt", { action }), [
-            { label: t("tool.approve_yes"), description: t("tool.approve_yes_desc") },
-            { label: t("tool.approve_no"), description: t("tool.approve_no_desc") },
-        ]);
-        if (indexes[0] === 0) {
-            return { success: true, output: t("tool.approved") };
-        }
-        return { success: false, output: t("tool.rejected") };
-    },
-};

package/dist/tools/attach-image.js

@@ -1,89 +0,0 @@
-import { existsSync } from "fs";
-import { resolve } from "path";
-import { t } from "../i18n/index";
-import { loadFileAsDataUrl, loadUrlAsDataUrl, readClipboardImage, bufferToDataUrl } from "../llm/image-utils";
-import { logSecurityBlock } from "../modules/security/audit-log";
-export const attachImageTool = {
-    name: "attach_image",
-    description: "Attach an image to the conversation from a file path, URL, or clipboard. The image will be included in the next message sent to the model. Supports PNG, JPEG, GIF, WebP.",
-    tags: ["vision", "image"],
-    parameters: {
-        type: "object",
-        properties: {
-            source: {
-                type: "string",
-                description: 'Image source: file path (e.g. "./screenshot.png"), URL (e.g. "https://example.com/img.png"), or "clipboard" to read from system clipboard.',
-            },
-        },
-        required: ["source"],
-    },
-    handler: async (ctx, args) => {
-        const source = String(args.source ?? "").trim();
-        if (!source) {
-            return { success: false, output: t("image.source_required") };
-        }
-        try {
-            let dataUrl;
-            if (source.toLowerCase() === "clipboard") {
-                const clipBuf = await readClipboardImage();
-                if (!clipBuf) {
-                    return {
-                        success: false,
-                        output: t("image.clipboard_empty"),
-                    };
-                }
-                const result = await bufferToDataUrl(clipBuf);
-                dataUrl = result.dataUrl;
-            }
-            else if (source.startsWith("http://") || source.startsWith("https://")) {
-                const result = await loadUrlAsDataUrl(source);
-                dataUrl = result.dataUrl;
-            }
-            else {
-                const absPath = resolve(ctx.baseDir, source);
-                if (!existsSync(absPath)) {
-                    return {
-                        success: false,
-                        output: t("image.not_found", { path: source }),
-                    };
-                }
-                // Security: check path scope
-                if (ctx.scope) {
-                    const { isPathInScope } = await import("../modules/security/path-validator");
-                    const validation = isPathInScope(ctx.baseDir, absPath, ctx.scope);
-                    if (!validation.allowed) {
-                        logSecurityBlock(ctx.sessionId, "file_read", validation.reason ?? "attach_image out of scope", absPath);
-                        return {
-                            success: false,
-                            output: t("file.path_not_allowed", { path: source }),
-                        };
-                    }
-                }
-                const result = await loadFileAsDataUrl(absPath);
-                dataUrl = result.dataUrl;
-            }
-            // Add the image as a pending content part on the context manager
-            if (!ctx.contextManager) {
-                return {
-                    success: false,
-                    output: t("image.no_context"),
-                };
-            }
-            ctx.contextManager.addPendingImage({
-                type: "image_url",
-                image_url: { url: dataUrl },
-            });
-            const sizeKb = Math.round((dataUrl.length * 3) / 4 / 1024);
-            return {
-                success: true,
-                output: t("image.attached", { source, size: `${sizeKb} KB` }),
-            };
-        }
-        catch (err) {
-            return {
-                success: false,
-                output: t("image.error", { message: err.message }),
-            };
-        }
-    },
-};

package/dist/tools/bash.js

@@ -1,140 +0,0 @@
-import { isCommandAllowed, sanitizeCommandForLog } from '../modules/security/command-validator';
-import { logBashCommand, logSecurityBlock } from '../modules/security/audit-log';
-import { getSessionSecurityConfig } from '../modules/security/session-isolation';
-import { DEFAULT_SECURITY_CONFIG } from '../config/security';
-import { runCommand, processRegistry, isLongRunningCommand } from '../modules/processes';
-import { t } from '../i18n/index';
-import { platform } from 'os';
-import { MAX_PREVIEW_LINES } from './preview';
-const BASH_TIMEOUT_MS = 120_000;
-function adaptCommandForWindows(command) {
-    if (platform() !== 'win32')
-        return command;
-    // Windows mkdir does not support -p flag, but creates intermediate dirs by default
-    const trimmed = command.trim();
-    if (trimmed.startsWith('mkdir -p ')) {
-        return trimmed.replace(/^mkdir -p /, 'mkdir ');
-    }
-    if (trimmed === 'mkdir -p' || trimmed.startsWith('mkdir -p ')) {
-        return trimmed.replace(/mkdir -p/g, 'mkdir');
-    }
-    // No encoding adaptation needed — runner.ts handles UTF-8 decoding
-    return command;
-}
-/** Common Unix → Windows command mapping for error hints. */
-const UNIX_TO_WIN_HINTS = {
-    'ls': 'Use "dir" or the list_dir tool instead.',
-    'pwd': 'Use "echo %cd%" or the file_info tool instead.',
-    'cat': 'Use "type" or the read_file tool instead.',
-    'cp': 'Use "copy" or the move_file tool instead.',
-    'mv': 'Use "move" or the move_file tool instead.',
-    'rm': 'Use "del" or the delete_file tool instead.',
-    'grep': 'Use "findstr" or the grep tool instead.',
-    'chmod': 'Use icacls or the chmod tool instead.',
-    'touch': 'Use type nul > file or the write_file tool instead.',
-    'find': 'Use "dir /s" or the glob tool instead.',
-    'head': 'Use the read_file tool with offset/limit instead.',
-    'tail': 'Use the read_file tool instead.',
-    'wc': 'Use the read_file tool instead.',
-    'diff': 'Use the diff tool instead.',
-    'which': 'Use "where" instead.',
-    'echo': 'echo works on Windows, but avoid pipes (|).',
-};
-export const bashTool = {
-    name: 'bash',
-    description: 'Execute a shell command and return its output. Use for running tests, build, git, and shell operations. Long-running commands (dev servers, watchers) start in the background and return a process id immediately — manage them with process_list, process_log, process_kill. Set background=true to force background execution.',
-    tags: ['shell', 'code'],
-    parameters: {
-        type: 'object',
-        properties: {
-            command: { type: 'string', description: 'Shell command to execute' },
-            workdir: { type: 'string', description: 'Working directory (default: baseDir)' },
-            background: { type: 'boolean', description: 'Start the command in the background and return immediately with a process id (default: auto-detect long-running commands)' },
-        },
-        required: ['command'],
-    },
-    handler: async (ctx, args) => {
-        const originalCommand = String(args.command);
-        const command = adaptCommandForWindows(originalCommand);
-        const workdir = args.workdir ? String(args.workdir) : ctx.baseDir;
-        // Get session-specific security config with defaults
-        const appConfig = ctx.config || {};
-        const fullSecurityConfig = ctx.sessionContext
-            ? getSessionSecurityConfig(appConfig, ctx.sessionContext)
-            : appConfig.security || DEFAULT_SECURITY_CONFIG;
-        const securityConfig = fullSecurityConfig.bash || DEFAULT_SECURITY_CONFIG.bash;
-        const validation = isCommandAllowed(command, securityConfig);
-        if (!validation.allowed) {
-            // Log security block
-            logSecurityBlock(ctx.sessionId, "bash_command", validation.reason || "Command blocked by security policy", sanitizeCommandForLog(originalCommand));
-            return {
-                success: false,
-                output: `[SECURITY BLOCKED] Command is not allowed: ${validation.reason}\nHint: Use the "workdir" parameter to run commands in a specific directory instead of "cd dir && cmd". Run one command per tool call.`,
-            };
-        }
-        // Log command execution if enabled
-        if (securityConfig?.logCommands) {
-            logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), false, // Will be updated after execution
-            `Working directory: ${workdir}`);
-        }
-        const background = args.background === true || isLongRunningCommand(command);
-        if (background) {
-            const entry = processRegistry.start(command, workdir, ctx.sessionId);
-            if (securityConfig?.logCommands) {
-                logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), true, `Started in background: ${entry.id} (PID ${entry.pid})`);
-            }
-            const explicit = args.background === true;
-            return {
-                success: true,
-                output: `${t("proc.started", {
-                    id: entry.id,
-                    pid: entry.pid,
-                    command,
-                })}${explicit ? "" : `\n${t("proc.detected_hint")}`}\n${t("proc.manage_hint", {
-                    id: entry.id,
-                })}`,
-            };
-        }
-        try {
-            const res = await runCommand(command, {
-                cwd: workdir,
-                callId: ctx.activeCallId,
-                timeoutMs: BASH_TIMEOUT_MS,
-            });
-            const parts = [res.stdout.trimEnd(), res.stderr.trimEnd()].filter(Boolean);
-            let output = parts.join("\n");
-            if (res.timedOut) {
-                output = `${output ? output + "\n" : ""}${t("proc.timed_out", {
-                    ms: BASH_TIMEOUT_MS,
-                })}`;
-            }
-            else if (!output && res.code !== 0) {
-                output = `(exit code ${res.code})`;
-            }
-            // On Windows, hint about Unix commands that don't work
-            if (platform() === 'win32' && res.code !== 0) {
-                const firstWord = command.trim().split(/\s+/)[0]?.split(/[\\/]/).pop();
-                const hint = firstWord ? UNIX_TO_WIN_HINTS[firstWord] : undefined;
-                if (hint) {
-                    output = `${output}\n\nHint: "${firstWord}" may not work on Windows. ${hint}`;
-                }
-            }
-            // Update audit log with result
-            if (securityConfig?.logCommands) {
-                logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), res.code === 0, `Working directory: ${workdir}, Output length: ${res.stdout.length}`);
-            }
-            const lines = output.split('\n');
-            if (lines.length > MAX_PREVIEW_LINES) {
-                output = lines.slice(0, MAX_PREVIEW_LINES).join('\n') + `\n... (${lines.length - MAX_PREVIEW_LINES} more lines)`;
-            }
-            return { success: res.code === 0, output };
-        }
-        catch (e) {
-            // Update audit log with failure
-            if (securityConfig?.logCommands) {
-                logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), false, `Working directory: ${workdir}, Error: ${e.message?.slice(0, 100) || ""}`);
-            }
-            return { success: false, output: e.message || String(e) };
-        }
-    },
-};

package/dist/tools/browser.js

@@ -1,97 +0,0 @@
-import { BrowserSession } from '../modules/browser/session';
-import { DEFAULT_BROWSER_CONFIG } from '../modules/browser/types';
-import { t } from '../i18n/index';
-import { join } from 'path';
-let session = null;
-function getSession(ctx) {
-    if (!session) {
-        const cookieDir = join(ctx.baseDir, '.mma', 'browser');
-        session = new BrowserSession({
-            ...DEFAULT_BROWSER_CONFIG,
-            headless: ctx.config.browser?.headless ?? true,
-            maxElements: ctx.config.browser?.maxElements ?? 30,
-            navigationTimeout: ctx.config.browser?.navigationTimeout ?? 15000,
-            viewportWidth: ctx.config.browser?.viewportWidth ?? 1280,
-            viewportHeight: ctx.config.browser?.viewportHeight ?? 720,
-            cookieDir,
-        });
-    }
-    return session;
-}
-export function formatScreenshotForTextModel(snapshot) {
-    return `${t('tool.screenshot_unavailable')}\n\n${snapshot}`;
-}
-export function formatScreenshotResult(snapshot, screenshot, supportsVision) {
-    if (!supportsVision) {
-        return formatScreenshotForTextModel(snapshot);
-    }
-    const base64 = screenshot.toString('base64');
-    return `${snapshot}\n\n[Screenshot: data:image/png;base64,${base64}]`;
-}
-export function createBrowserTool() {
-    return {
-        name: 'browser',
-        tags: ['browser', 'vision'],
-        description: [
-            'Control a headless browser. Navigate pages, click elements, type text, scroll, take screenshots.',
-            'Returns a numbered list of interactive elements — use element numbers as targets for click/type.',
-            'Actions: open (url), click (target), type (target, text), scroll (direction), back, forward, screenshot, snapshot, close, wait (ms).',
-        ].join(' '),
-        parameters: {
-            type: 'object',
-            properties: {
-                action: {
-                    type: 'string',
-                    enum: ['open', 'click', 'type', 'scroll', 'back', 'forward', 'screenshot', 'snapshot', 'close', 'wait'],
-                    description: 'Browser action to perform',
-                },
-                url: {
-                    type: 'string',
-                    description: 'URL to open (for action "open")',
-                },
-                target: {
-                    type: 'number',
-                    description: 'Element number from snapshot (for action "click" or "type")',
-                },
-                text: {
-                    type: 'string',
-                    description: 'Text to type (for action "type")',
-                },
-                direction: {
-                    type: 'string',
-                    enum: ['up', 'down', 'top', 'bottom'],
-                    description: 'Scroll direction (for action "scroll", default "down")',
-                },
-                ms: {
-                    type: 'number',
-                    description: 'Milliseconds to wait (for action "wait", default 1000)',
-                },
-            },
-            required: ['action'],
-        },
-        handler: async (ctx, args) => {
-            const action = String(args.action || '');
-            if (!action) {
-                return { success: false, output: t('tool.action_required') };
-            }
-            const s = getSession(ctx);
-            const result = await s.execute(action, args);
-            const supportsVision = ctx.config.model.includes('vision') ||
-                ctx.config.model.includes('gpt-4o') ||
-                ctx.config.model.includes('claude');
-            if (result.screenshot) {
-                return {
-                    success: result.success,
-                    output: formatScreenshotResult(result.output, result.screenshot, supportsVision),
-                };
-            }
-            return { success: result.success, output: result.output };
-        },
-    };
-}
-export function closeBrowserSession() {
-    if (session) {
-        session.close().catch(() => { });
-        session = null;
-    }
-}

package/dist/tools/create-dir.js

@@ -1,56 +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");
-        ctx.trackCreatedPath?.(path);
-        return { success: true, output: t("file.created", { path }) };
-    },
-};

package/dist/tools/delete-file.js

@@ -1,63 +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);
-        ctx.trackDeletedPath?.(path);
-        return { success: true, output: t("file.deleted", { path }), diff };
-    },
-};

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 };
-    },
-};