mono-pilot 0.2.9 → 0.2.12

package/dist/src/extensions/user-message.js

@@ -1,16 +1,25 @@
-import { existsSync } from "node:fs";
-import { readdir, readFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { readFile } from "node:fs/promises";
+import { basename, dirname, resolve } from "node:path";
 import process from "node:process";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { buildRuntimeEnvelope, createModeStateData, modeRuntimeStore, MODE_STATE_ENTRY_TYPE, ASK_MODE_SWITCH_REMINDER, PLAN_MODE_STILL_ACTIVE_REMINDER, } from "./mode-runtime.js";
-import { createRpcRequestId, extractStringHeaders, isRecord, isServerEnabled, parseMcpConfig, postJsonRpcRequest, resolveMcpConfigPath, toNonEmptyString, MCP_PROTOCOL_VERSION, MCP_CLIENT_NAME, MCP_CLIENT_VERSION, } from "../utils/mcp-client.js";
+import { getBriefReflectionReminder } from "../brief/reflection.js";
+import { createRpcRequestId, postJsonRpcRequest, MCP_PROTOCOL_VERSION, MCP_CLIENT_NAME, MCP_CLIENT_VERSION, } from "../mcp/protocol.js";
+import { extractStringHeaders, isRecord, isServerEnabled, loadMcpConfig, toNonEmptyString, } from "../mcp/config.js";
+import { discoverRules } from "../rules/discovery.js";
 const PLAN_MODE_REMINDER_PATH = fileURLToPath(new URL("../../tools/plan-mode-reminder.md", import.meta.url));
 const ASK_MODE_REMINDER_PATH = fileURLToPath(new URL("../../tools/ask-mode-reminder.md", import.meta.url));
-const RULES_RELATIVE_DIR = join(".pi", "rules");
 const MCP_INSTRUCTIONS_DESCRIPTION = "Instructions provided by MCP servers to help use them properly";
 const USER_QUERY_RENDER_PATCH_FLAG = "__monoPilotUserQueryRenderPatched__";
+const USER_MESSAGE_MODULE_PATH = fileURLToPath(import.meta.url);
+const CURRENT_DATE_TIME_REMINDER_PREFIX = "Current date and time:";
+const DEV_RUNTIME_TOOL_EFFICIENCY_REMINDER = `<system_reminder>
+Detected development runtime (extension loaded from src/*.ts with runtime transpilation).
+Always keep the current task goal first; only focus on tool-usage efficiency when the task is blocked or clear inefficiency appears.
+When inefficiency is directly related to the current task, tool changes are allowed, but must be incremental: add observability/visibility first, then apply the smallest necessary logic adjustment.
+Keep changes scoped, avoid unrelated refactors, and keep behavior verifiable; run npm run check after edits (and run npm run build when src changes).
+If user intent or change boundaries are unclear, ask before modifying.
+</system_reminder>`;
 function extractUserQueryForTuiDisplay(text) {
     const startIndex = text.indexOf("<user_query>");
     if (startIndex === -1)
@@ -52,6 +61,61 @@ function normalizeServerLabel(value) {
         return undefined;
     return normalized;
 }
+function escapeXml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/\"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+function buildPlanFileReminder(planFilePath) {
+    const escapedPath = escapeXml(planFilePath);
+    return [
+        "<system_reminder>",
+        `Plan file path: ${escapedPath}`,
+        "While Plan mode is active, create or update this plan file as needed during collaboration with the user.",
+        "You may modify this plan file in Plan mode; do not modify other files unless the mode changes.",
+        "</system_reminder>",
+    ].join("\n");
+}
+function appendPlanFileReminder(reminder, snapshot) {
+    if (snapshot.activeMode !== "plan") {
+        return reminder;
+    }
+    const planFilePath = snapshot.planFilePath?.trim();
+    if (!planFilePath) {
+        return reminder;
+    }
+    const planFileReminder = buildPlanFileReminder(planFilePath);
+    if (!reminder) {
+        return planFileReminder;
+    }
+    return `${reminder}\n\n${planFileReminder}`;
+}
+function isDevRuntimeModulePath(modulePath) {
+    const normalized = modulePath.replace(/\\/g, "/");
+    return normalized.includes("/src/") && normalized.endsWith(".ts");
+}
+function appendDevRuntimeToolEfficiencyReminder(reminder) {
+    if (!isDevRuntimeModulePath(USER_MESSAGE_MODULE_PATH)) {
+        return reminder;
+    }
+    if (!reminder) {
+        return DEV_RUNTIME_TOOL_EFFICIENCY_REMINDER;
+    }
+    return `${reminder}\n\n${DEV_RUNTIME_TOOL_EFFICIENCY_REMINDER}`;
+}
+function buildCurrentDateTimeReminder(now = new Date()) {
+    return `<system_reminder>\n${CURRENT_DATE_TIME_REMINDER_PREFIX} ${now.toString()}\n</system_reminder>`;
+}
+function appendCurrentDateTimeReminder(reminder, now = new Date()) {
+    const dateTimeReminder = buildCurrentDateTimeReminder(now);
+    if (!reminder) {
+        return dateTimeReminder;
+    }
+    return `${reminder}\n\n${dateTimeReminder}`;
+}
 async function fetchServerInstructions(serverUrl, serverHeaders, serverName) {
     try {
         const initializeResponse = await postJsonRpcRequest({
@@ -85,17 +149,16 @@ async function fetchServerInstructions(serverUrl, serverHeaders, serverName) {
     }
 }
 async function buildMcpInstructionsEnvelope(workspaceCwd) {
-    const configPath = resolveMcpConfigPath(workspaceCwd);
-    if (!configPath)
-        return undefined;
-    let servers;
+    let config;
     try {
-        servers = await parseMcpConfig(configPath);
+        config = await loadMcpConfig(workspaceCwd);
     }
     catch {
         return undefined;
     }
-    const serverEntries = Object.entries(servers)
+    if (!config)
+        return undefined;
+    const serverEntries = Object.entries(config.servers)
         .filter(([, config]) => isServerEnabled(config))
         .map(([name, config]) => {
         const serverName = normalizeServerLabel(name);
@@ -138,49 +201,26 @@ async function buildMcpInstructionsEnvelope(workspaceCwd) {
     return lines.join("\n");
 }
 async function buildRulesEnvelope(workspaceCwd) {
-    const rulesDirPath = resolve(workspaceCwd, RULES_RELATIVE_DIR);
-    const userRulesDirPath = resolve(homedir(), RULES_RELATIVE_DIR);
-    const loadRulesFromDir = async (dirPath) => {
-        if (!existsSync(dirPath))
-            return new Map();
-        let directoryEntries;
+    const { userRules, projectRules } = await discoverRules(workspaceCwd);
+    const allRulePaths = [...userRules, ...projectRules];
+    if (allRulePaths.length === 0)
+        return undefined;
+    const ruleEntries = [];
+    for (const filePath of allRulePaths) {
         try {
-            directoryEntries = await readdir(dirPath, { withFileTypes: true, encoding: "utf8" });
+            const content = await readFile(filePath, "utf-8");
+            const normalized = content.trim();
+            if (normalized.length > 0) {
+                ruleEntries.push({ filename: basename(filePath), content: normalized });
+            }
         }
         catch {
-            return new Map();
+            // Ignore unreadable rule files.
         }
-        const ruleFileNames = directoryEntries
-            .filter((entry) => entry.isFile() && entry.name.endsWith(".rule.txt"))
-            .map((entry) => entry.name)
-            .sort((a, b) => a.localeCompare(b));
-        const rules = new Map();
-        for (const ruleFileName of ruleFileNames) {
-            const ruleFilePath = resolve(dirPath, ruleFileName);
-            try {
-                const content = await readFile(ruleFilePath, "utf-8");
-                const normalized = content.trim();
-                if (normalized.length > 0) {
-                    rules.set(ruleFileName, normalized);
-                }
-            }
-            catch {
-                // Ignore unreadable rule files.
-            }
-        }
-        return rules;
-    };
-    const userRules = await loadRulesFromDir(userRulesDirPath);
-    const workspaceRules = await loadRulesFromDir(rulesDirPath);
-    const mergedRules = new Map(userRules);
-    for (const [fileName, content] of workspaceRules) {
-        mergedRules.set(fileName, content);
     }
-    if (mergedRules.size === 0)
+    if (ruleEntries.length === 0)
         return undefined;
-    const rules = Array.from(mergedRules.entries())
-        .sort(([a], [b]) => a.localeCompare(b))
-        .map(([, content]) => content);
+    const rules = ruleEntries.sort((a, b) => a.filename.localeCompare(b.filename)).map((e) => e.content);
     const lines = ["<rules>"];
     for (const rule of rules) {
         lines.push("<user_rule>");
@@ -281,12 +321,16 @@ export default function runtimeEnvelopeExtension(pi) {
             getRulesEnvelope(),
         ]);
         const { reminder, changed, snapshot } = modeRuntimeStore.consumeReminder(planEntryReminder, askEntryReminder);
+        const reminderWithPlanFile = appendPlanFileReminder(reminder, snapshot);
+        const reminderWithDevToolEfficiency = appendDevRuntimeToolEfficiencyReminder(reminderWithPlanFile);
+        const reminderWithCurrentDateTime = appendCurrentDateTimeReminder(reminderWithDevToolEfficiency);
         if (changed) {
             pi.appendEntry(MODE_STATE_ENTRY_TYPE, createModeStateData(snapshot));
         }
+        const briefReminder = getBriefReflectionReminder();
         return {
             action: "transform",
-            text: buildRuntimeEnvelope(event.text, reminder, mcpInstructions, rulesEnvelope),
+            text: buildRuntimeEnvelope(event.text, reminderWithCurrentDateTime, mcpInstructions, rulesEnvelope, briefReminder),
             images: event.images,
         };
     });

package/dist/src/lsp/client.js

@@ -0,0 +1,235 @@
+import { Bus, BusEvent, Filesystem, Log, LspState, withTimeout } from "./runtime.js";
+import path from "node:path";
+import { pathToFileURL, fileURLToPath } from "node:url";
+import { createMessageConnection, StreamMessageReader, StreamMessageWriter, } from "vscode-jsonrpc/lib/node/main.js";
+const LANGUAGE_EXTENSIONS = {
+    ".abap": "abap",
+    ".bat": "bat",
+    ".bib": "bibtex",
+    ".bibtex": "bibtex",
+    ".clj": "clojure",
+    ".cljs": "clojure",
+    ".cljc": "clojure",
+    ".edn": "clojure",
+    ".coffee": "coffeescript",
+    ".c": "c",
+    ".cpp": "cpp",
+    ".cxx": "cpp",
+    ".cc": "cpp",
+    ".c++": "cpp",
+    ".cs": "csharp",
+    ".css": "css",
+    ".d": "d",
+    ".pas": "pascal",
+    ".pascal": "pascal",
+    ".diff": "diff",
+    ".patch": "diff",
+    ".dart": "dart",
+    ".dockerfile": "dockerfile",
+    ".ex": "elixir",
+    ".exs": "elixir",
+    ".erl": "erlang",
+    ".hrl": "erlang",
+    ".fs": "fsharp",
+    ".fsi": "fsharp",
+    ".fsx": "fsharp",
+    ".fsscript": "fsharp",
+    ".go": "go",
+    ".groovy": "groovy",
+    ".hs": "haskell",
+    ".lhs": "haskell",
+    ".html": "html",
+    ".htm": "html",
+    ".ini": "ini",
+    ".java": "java",
+    ".jl": "julia",
+    ".js": "javascript",
+    ".kt": "kotlin",
+    ".kts": "kotlin",
+    ".jsx": "javascriptreact",
+    ".json": "json",
+    ".tex": "latex",
+    ".latex": "latex",
+    ".less": "less",
+    ".lua": "lua",
+    ".makefile": "makefile",
+    "makefile": "makefile",
+    ".md": "markdown",
+    ".markdown": "markdown",
+    ".m": "objective-c",
+    ".mm": "objective-cpp",
+    ".pl": "perl",
+    ".pm": "perl",
+    ".php": "php",
+    ".ps1": "powershell",
+    ".psm1": "powershell",
+    ".py": "python",
+    ".r": "r",
+    ".rb": "ruby",
+    ".rake": "ruby",
+    ".rs": "rust",
+    ".scss": "scss",
+    ".sass": "sass",
+    ".scala": "scala",
+    ".sh": "shellscript",
+    ".bash": "shellscript",
+    ".zsh": "shellscript",
+    ".ksh": "shellscript",
+    ".sql": "sql",
+    ".svelte": "svelte",
+    ".swift": "swift",
+    ".ts": "typescript",
+    ".tsx": "typescriptreact",
+    ".mts": "typescript",
+    ".cts": "typescript",
+    ".xml": "xml",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".vue": "vue",
+    ".zig": "zig",
+    ".ml": "ocaml",
+    ".mli": "ocaml",
+    ".tf": "terraform",
+    ".tfvars": "terraform-vars",
+    ".nix": "nix",
+};
+const DIAGNOSTICS_DEBOUNCE_MS = 150;
+export var LSPClient;
+(function (LSPClient) {
+    const log = Log.create({ service: "lsp.client" });
+    LSPClient.Event = {
+        Diagnostics: BusEvent.define("lsp.client.diagnostics", null),
+    };
+    async function create(input) {
+        const l = log.clone().tag("serverID", input.serverID);
+        l.info("starting client");
+        const connection = createMessageConnection(new StreamMessageReader(input.server.process.stdout), new StreamMessageWriter(input.server.process.stdin));
+        const diagnostics = new Map();
+        connection.onNotification("textDocument/publishDiagnostics", (params) => {
+            const filePath = Filesystem.normalizePath(fileURLToPath(params.uri));
+            const existed = diagnostics.has(filePath);
+            diagnostics.set(filePath, params.diagnostics);
+            // TypeScript sends empty diagnostics on first open; skip until we have a prior entry
+            if (!existed && input.serverID === "typescript")
+                return;
+            Bus.publish(LSPClient.Event.Diagnostics, { path: filePath, serverID: input.serverID });
+        });
+        connection.onRequest("window/workDoneProgress/create", () => null);
+        connection.onRequest("workspace/configuration", async () => [input.server.initialization ?? {}]);
+        connection.onRequest("client/registerCapability", async () => { });
+        connection.onRequest("client/unregisterCapability", async () => { });
+        connection.onRequest("workspace/workspaceFolders", async () => [
+            { name: "workspace", uri: pathToFileURL(input.root).href },
+        ]);
+        connection.listen();
+        l.info("sending initialize");
+        await withTimeout(connection.sendRequest("initialize", {
+            rootUri: pathToFileURL(input.root).href,
+            processId: input.server.process.pid,
+            workspaceFolders: [{ name: "workspace", uri: pathToFileURL(input.root).href }],
+            initializationOptions: { ...input.server.initialization },
+            capabilities: {
+                window: { workDoneProgress: true },
+                workspace: {
+                    configuration: true,
+                    didChangeWatchedFiles: { dynamicRegistration: true },
+                },
+                textDocument: {
+                    synchronization: { didOpen: true, didChange: true },
+                    publishDiagnostics: { versionSupport: true },
+                },
+            },
+        }), 45_000).catch((err) => {
+            const e = new Error(`LSP initialize failed: ${input.serverID}`);
+            e.cause = err;
+            throw e;
+        });
+        await connection.sendNotification("initialized", {});
+        if (input.server.initialization) {
+            await connection.sendNotification("workspace/didChangeConfiguration", {
+                settings: input.server.initialization,
+            });
+        }
+        const files = {};
+        const result = {
+            root: input.root,
+            get serverID() {
+                return input.serverID;
+            },
+            get connection() {
+                return connection;
+            },
+            notify: {
+                async open(inp) {
+                    const p = path.isAbsolute(inp.path)
+                        ? inp.path
+                        : path.resolve(LspState.directory, inp.path);
+                    const text = await Filesystem.readText(p);
+                    const ext = path.extname(p);
+                    const languageId = LANGUAGE_EXTENSIONS[ext] ?? "plaintext";
+                    const uri = pathToFileURL(p).href;
+                    const version = files[p];
+                    if (version !== undefined) {
+                        await connection.sendNotification("workspace/didChangeWatchedFiles", {
+                            changes: [{ uri, type: 2 }],
+                        });
+                        const next = version + 1;
+                        files[p] = next;
+                        await connection.sendNotification("textDocument/didChange", {
+                            textDocument: { uri, version: next },
+                            contentChanges: [{ text }],
+                        });
+                        return;
+                    }
+                    await connection.sendNotification("workspace/didChangeWatchedFiles", {
+                        changes: [{ uri, type: 1 }],
+                    });
+                    diagnostics.delete(p);
+                    await connection.sendNotification("textDocument/didOpen", {
+                        textDocument: { uri, languageId, version: 0, text },
+                    });
+                    files[p] = 0;
+                },
+            },
+            get diagnostics() {
+                return diagnostics;
+            },
+            async waitForDiagnostics(inp) {
+                const normalized = Filesystem.normalizePath(path.isAbsolute(inp.path)
+                    ? inp.path
+                    : path.resolve(LspState.directory, inp.path));
+                let unsub;
+                let timer;
+                return withTimeout(new Promise((resolve) => {
+                    unsub = Bus.subscribe(LSPClient.Event.Diagnostics, (event) => {
+                        if (event.properties.path === normalized &&
+                            event.properties.serverID === result.serverID) {
+                            if (timer)
+                                clearTimeout(timer);
+                            timer = setTimeout(() => {
+                                unsub?.();
+                                resolve();
+                            }, DIAGNOSTICS_DEBOUNCE_MS);
+                        }
+                    });
+                }), 3000)
+                    .catch(() => { })
+                    .finally(() => {
+                    if (timer)
+                        clearTimeout(timer);
+                    unsub?.();
+                });
+            },
+            async shutdown() {
+                connection.end();
+                connection.dispose();
+                input.server.process.kill();
+            },
+        };
+        l.info("initialized");
+        return result;
+    }
+    LSPClient.create = create;
+})(LSPClient || (LSPClient = {}));

package/dist/src/lsp/index.js

@@ -0,0 +1,165 @@
+import { Log, LspState } from "./runtime.js";
+import { LSPClient } from "./client.js";
+import { LSPServer } from "./server.js";
+import path from "node:path";
+export var LSP;
+(function (LSP) {
+    const log = Log.create({ service: "lsp" });
+    let _state;
+    function getState() {
+        if (!_state) {
+            _state = {
+                clients: [],
+                servers: {
+                    typescript: LSPServer.Typescript,
+                    pyright: LSPServer.Pyright,
+                    gopls: LSPServer.Gopls,
+                    rust: LSPServer.RustAnalyzer,
+                    sourcekit: LSPServer.SourcekitLsp,
+                    clangd: LSPServer.Clangd,
+                },
+                broken: new Set(),
+                spawning: new Map(),
+            };
+        }
+        return _state;
+    }
+    function init(directory) {
+        LspState.directory = directory;
+        log.info("LSP initialized", { directory });
+    }
+    LSP.init = init;
+    async function shutdown() {
+        if (!_state)
+            return;
+        await Promise.all(_state.clients.map((c) => c.shutdown()));
+        _state = undefined;
+    }
+    LSP.shutdown = shutdown;
+    async function getClients(file) {
+        const s = getState();
+        const ext = path.parse(file).ext || file;
+        const result = [];
+        async function schedule(server, root, key) {
+            const handle = await server
+                .spawn(root)
+                .then((v) => {
+                if (!v)
+                    s.broken.add(key);
+                return v;
+            })
+                .catch((err) => {
+                s.broken.add(key);
+                log.error(`failed to spawn ${server.id}`, { error: String(err) });
+                return undefined;
+            });
+            if (!handle)
+                return undefined;
+            const client = await LSPClient.create({
+                serverID: server.id,
+                server: handle,
+                root,
+            }).catch((err) => {
+                s.broken.add(key);
+                handle.process.kill();
+                log.error(`failed to init ${server.id}`, { error: String(err) });
+                return undefined;
+            });
+            if (!client) {
+                handle.process.kill();
+                return undefined;
+            }
+            // Race condition guard: another concurrent call may have added the same client
+            const existing = s.clients.find((x) => x.root === root && x.serverID === server.id);
+            if (existing) {
+                handle.process.kill();
+                return existing;
+            }
+            s.clients.push(client);
+            return client;
+        }
+        for (const server of Object.values(s.servers)) {
+            if (server.extensions.length && !server.extensions.includes(ext))
+                continue;
+            const root = await server.root(file);
+            if (!root)
+                continue;
+            const key = root + server.id;
+            if (s.broken.has(key))
+                continue;
+            const match = s.clients.find((x) => x.root === root && x.serverID === server.id);
+            if (match) {
+                result.push(match);
+                continue;
+            }
+            const inflight = s.spawning.get(key);
+            if (inflight) {
+                const c = await inflight;
+                if (c)
+                    result.push(c);
+                continue;
+            }
+            const task = schedule(server, root, key);
+            s.spawning.set(key, task);
+            task.finally(() => {
+                if (s.spawning.get(key) === task)
+                    s.spawning.delete(key);
+            });
+            const client = await task;
+            if (client)
+                result.push(client);
+        }
+        return result;
+    }
+    async function touchFile(file, wait) {
+        const clients = await getClients(file);
+        await Promise.all(clients.map(async (client) => {
+            const pending = wait
+                ? client.waitForDiagnostics({ path: file })
+                : Promise.resolve();
+            await client.notify.open({ path: file });
+            return pending;
+        })).catch((err) => log.error("failed to touch file", { err: String(err), file }));
+    }
+    LSP.touchFile = touchFile;
+    async function diagnostics() {
+        const s = getState();
+        const results = {};
+        for (const client of s.clients) {
+            for (const [p, diags] of client.diagnostics.entries()) {
+                results[p] = [...(results[p] ?? []), ...diags];
+            }
+        }
+        return results;
+    }
+    LSP.diagnostics = diagnostics;
+    async function workspaceSymbol(query) {
+        const s = getState();
+        // Filter to meaningful symbol kinds: Class(5), Method(6), Enum(10), Interface(11), Function(12)
+        const meaningful = new Set([5, 6, 10, 11, 12, 13, 14, 23]);
+        const tasks = s.clients.map((c) => c.connection
+            .sendRequest("workspace/symbol", { query })
+            .then((r) => (r ?? [])
+            .filter((x) => meaningful.has(x.kind))
+            .slice(0, 10))
+            .catch(() => []));
+        return (await Promise.all(tasks)).flat();
+    }
+    LSP.workspaceSymbol = workspaceSymbol;
+    let Diagnostic;
+    (function (Diagnostic) {
+        const severityLabel = {
+            1: "ERROR",
+            2: "WARN",
+            3: "INFO",
+            4: "HINT",
+        };
+        function pretty(d) {
+            const sev = severityLabel[d.severity ?? 1] ?? "ERROR";
+            const line = d.range.start.line + 1;
+            const col = d.range.start.character + 1;
+            return `${sev} [${line}:${col}] ${d.message}`;
+        }
+        Diagnostic.pretty = pretty;
+    })(Diagnostic = LSP.Diagnostic || (LSP.Diagnostic = {}));
+})(LSP || (LSP = {}));

package/dist/src/lsp/runtime.js

@@ -0,0 +1,67 @@
+import { EventEmitter } from "node:events";
+import fs from "node:fs/promises";
+import path from "node:path";
+export const Log = {
+    create: (_meta) => ({
+        info: (_msg, _data) => { },
+        error: (msg, data) => console.error(`[lsp] ${msg}`, data ?? ""),
+        clone() {
+            return this;
+        },
+        tag(_k, _v) {
+            return this;
+        },
+    }),
+};
+let dir = process.cwd();
+export const LspState = {
+    get directory() {
+        return dir;
+    },
+    set directory(d) {
+        dir = d;
+    },
+};
+const exists = (p) => fs.access(p).then(() => true).catch(() => false);
+async function* filesUp(opts) {
+    let current = opts.start;
+    while (true) {
+        for (const target of opts.targets) {
+            const p = path.join(current, target);
+            if (await exists(p))
+                yield p;
+        }
+        if (current === opts.stop || !current.startsWith(opts.stop))
+            break;
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+}
+export const Filesystem = {
+    readText: (p) => fs.readFile(p, "utf8"),
+    exists,
+    normalizePath: (p) => path.normalize(p),
+    up: filesUp,
+};
+export function withTimeout(promise, ms) {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout after ${ms}ms`)), ms)),
+    ]);
+}
+const emitter = new EventEmitter();
+emitter.setMaxListeners(200);
+export const BusEvent = {
+    define: (type, _schema) => ({ type }),
+};
+export const Bus = {
+    publish: (event, props) => {
+        emitter.emit(event.type, { properties: props });
+    },
+    subscribe: (event, handler) => {
+        emitter.on(event.type, handler);
+        return () => emitter.off(event.type, handler);
+    },
+};