micro-models-agent 0.28.9 → 0.28.17

package/dist/tools/executor.js

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

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

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

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

@@ -0,0 +1,86 @@
+import { execFileSync } 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.
+            // Using execFileSync with array args avoids shell injection.
+            try {
+                const grepArgs = ["-rn", pattern, searchPath];
+                if (args.include) {
+                    grepArgs.push("--include", String(args.include));
+                }
+                const output = execFileSync("grep", grepArgs, {
+                    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

@@ -0,0 +1,67 @@
+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";
+// questionTool and approveTool removed — interactive menus are too disruptive for small models.
+// The model should ask questions as plain text in its response instead.
+// 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, 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,
+        pipelineRunTool,
+        mcpCallTool,
+        searchHistoryTool,
+        attachImageTool,
+    ];
+    if (skillsModule) {
+        tools.push(createLoadSkillTool(skillsModule));
+    }
+    for (const tool of tools) {
+        registry.register(tool);
+    }
+}

package/dist/tools/list-dir.js

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

@@ -0,0 +1,44 @@
+import { t } from "../i18n/index";
+export function createLoadSkillTool(skillsModule) {
+    return {
+        name: "load_skill",
+        tags: ["core"],
+        description: "Load a skill by name. Skills provide specialized instructions and workflows. When loaded, the skill content is injected into the system prompt (not conversation history) so it persists through context compaction. Only use when the task clearly requires domain-specific knowledge.",
+        parameters: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "Exact skill name to load (see [Available Skills] for names)",
+                },
+            },
+            required: ["name"],
+        },
+        handler: async (_ctx, args) => {
+            const name = args.name ? String(args.name) : undefined;
+            if (!name) {
+                return { success: false, output: t("tool.invalid_params") };
+            }
+            const result = skillsModule.loadByName(name);
+            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 budget = skillsModule.getBudget();
+            const tokens = result.skill
+                ? Math.ceil(result.skill.content.length / 4)
+                : 0;
+            return {
+                success: true,
+                output: t("tool.skill_budget", {
+                    name,
+                    tokens,
+                    remaining: budget.remaining,
+                }),
+            };
+        },
+    };
+}

package/dist/tools/mcp-call.js

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

@@ -0,0 +1,85 @@
+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";
+import { safeResolvePath } from "./path-utils";
+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 = safeResolvePath(baseDir, normalize(fromPath));
+        const toResolved = safeResolvePath(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

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