mono-pilot 0.2.9 → 0.2.12

package/dist/src/lsp/server.js

@@ -0,0 +1,242 @@
+import { spawn, execSync } from "node:child_process";
+import { createRequire } from "node:module";
+import path from "node:path";
+import os from "node:os";
+import fs from "node:fs/promises";
+import { Filesystem, Log, LspState } from "./runtime.js";
+export var LSPServer;
+(function (LSPServer) {
+    const log = Log.create({ service: "lsp.server" });
+    // Directory for npm-installed LSP servers
+    const binDir = path.join(os.homedir(), ".mono-pilot", "lsp");
+    function which(cmd) {
+        const w = process.platform === "win32" ? "where" : "which";
+        try {
+            return execSync(`${w} ${cmd}`, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] })
+                .trim()
+                .split("\n")[0] || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    function xcrunFind(cmd) {
+        if (process.platform !== "darwin")
+            return undefined;
+        try {
+            return execSync(`xcrun --find ${cmd}`, {
+                encoding: "utf8",
+                stdio: ["pipe", "pipe", "pipe"],
+            })
+                .trim()
+                .split("\n")[0] || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async function npmInstall(...pkgs) {
+        await fs.mkdir(binDir, { recursive: true });
+        await new Promise((resolve, reject) => {
+            const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+            const proc = spawn(npm, ["install", "--prefix", binDir, ...pkgs], { stdio: "pipe" });
+            proc.on("exit", (code) => code === 0 ? resolve() : reject(new Error(`npm install ${pkgs.join(" ")} failed (exit ${code})`)));
+            proc.on("error", reject);
+        });
+    }
+    const NearestRoot = (includePatterns, excludePatterns) => {
+        return async (file) => {
+            const dir = path.dirname(file);
+            const stop = LspState.directory;
+            if (excludePatterns) {
+                const gen = Filesystem.up({ targets: excludePatterns, start: dir, stop });
+                const first = await gen.next();
+                await gen.return(undefined);
+                if (first.value)
+                    return undefined;
+            }
+            const gen = Filesystem.up({ targets: includePatterns, start: dir, stop });
+            const first = await gen.next();
+            await gen.return(undefined);
+            if (!first.value)
+                return stop;
+            return path.dirname(first.value);
+        };
+    };
+    LSPServer.Typescript = {
+        id: "typescript",
+        extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
+        root: NearestRoot(["package-lock.json", "package.json", "yarn.lock", "pnpm-lock.yaml"], ["deno.json", "deno.jsonc"]),
+        async spawn(root) {
+            // Try to find the project's tsserver.js for initialization
+            const req = createRequire(path.join(root, "_"));
+            let tsserver;
+            try {
+                tsserver = req.resolve("typescript/lib/tsserver.js");
+            }
+            catch {
+                // TypeScript not in project node_modules; server will use its own
+            }
+            let bin = which("typescript-language-server");
+            if (!bin) {
+                const local = path.join(binDir, "node_modules", ".bin", "typescript-language-server");
+                if (!(await Filesystem.exists(local))) {
+                    log.info("installing typescript-language-server");
+                    try {
+                        await npmInstall("typescript-language-server", "typescript");
+                    }
+                    catch (e) {
+                        log.error("failed to install typescript-language-server", { error: String(e) });
+                        return;
+                    }
+                }
+                if (await Filesystem.exists(local))
+                    bin = local;
+            }
+            if (!bin) {
+                log.error("typescript-language-server not found");
+                return;
+            }
+            return {
+                process: spawn(bin, ["--stdio"], { cwd: root }),
+                initialization: tsserver ? { tsserver: { path: tsserver } } : undefined,
+            };
+        },
+    };
+    LSPServer.Pyright = {
+        id: "pyright",
+        extensions: [".py", ".pyi"],
+        root: NearestRoot([
+            "pyproject.toml",
+            "setup.py",
+            "setup.cfg",
+            "requirements.txt",
+            "Pipfile",
+            "pyrightconfig.json",
+        ]),
+        async spawn(root) {
+            let bin = which("pyright-langserver");
+            if (!bin) {
+                const local = path.join(binDir, "node_modules", ".bin", "pyright-langserver");
+                if (!(await Filesystem.exists(local))) {
+                    log.info("installing pyright");
+                    try {
+                        await npmInstall("pyright");
+                    }
+                    catch (e) {
+                        log.error("failed to install pyright", { error: String(e) });
+                        return;
+                    }
+                }
+                if (await Filesystem.exists(local))
+                    bin = local;
+            }
+            if (!bin) {
+                log.error("pyright-langserver not found");
+                return;
+            }
+            // Detect virtualenv for python path initialization
+            const initialization = {};
+            const venvPaths = [
+                process.env["VIRTUAL_ENV"],
+                path.join(root, ".venv"),
+                path.join(root, "venv"),
+            ].filter((p) => p !== undefined);
+            for (const venv of venvPaths) {
+                const python = process.platform === "win32"
+                    ? path.join(venv, "Scripts", "python.exe")
+                    : path.join(venv, "bin", "python");
+                if (await Filesystem.exists(python)) {
+                    initialization["pythonPath"] = python;
+                    break;
+                }
+            }
+            return {
+                process: spawn(bin, ["--stdio"], { cwd: root }),
+                initialization,
+            };
+        },
+    };
+    LSPServer.Gopls = {
+        id: "gopls",
+        extensions: [".go"],
+        root: async (file) => {
+            const work = await NearestRoot(["go.work"])(file);
+            if (work)
+                return work;
+            return NearestRoot(["go.mod", "go.sum"])(file);
+        },
+        async spawn(root) {
+            const bin = which("gopls");
+            if (!bin) {
+                log.error("gopls not found. Install with: go install golang.org/x/tools/gopls@latest");
+                return;
+            }
+            return { process: spawn(bin, { cwd: root }) };
+        },
+    };
+    LSPServer.RustAnalyzer = {
+        id: "rust",
+        extensions: [".rs"],
+        root: async (file) => {
+            const crate = await NearestRoot(["Cargo.toml", "Cargo.lock"])(file);
+            if (!crate)
+                return undefined;
+            // Walk up to find workspace-level Cargo.toml
+            let current = crate;
+            while (true) {
+                const content = await fs.readFile(path.join(current, "Cargo.toml"), "utf8").catch(() => "");
+                if (content.includes("[workspace]"))
+                    return current;
+                const parent = path.dirname(current);
+                if (parent === current || !parent.startsWith(LspState.directory))
+                    break;
+                current = parent;
+            }
+            return crate;
+        },
+        async spawn(root) {
+            const bin = which("rust-analyzer");
+            if (!bin) {
+                log.error("rust-analyzer not found. Install with: rustup component add rust-analyzer");
+                return;
+            }
+            return { process: spawn(bin, { cwd: root }) };
+        },
+    };
+    LSPServer.SourcekitLsp = {
+        id: "sourcekit-lsp",
+        extensions: [".swift"],
+        root: NearestRoot(["Package.swift"]),
+        async spawn(root) {
+            const bin = which("sourcekit-lsp") ?? xcrunFind("sourcekit-lsp");
+            if (!bin) {
+                log.error("sourcekit-lsp not found. Install with Xcode or a Swift toolchain.");
+                return;
+            }
+            return { process: spawn(bin, { cwd: root }) };
+        },
+    };
+    LSPServer.Clangd = {
+        id: "clangd",
+        extensions: [".c", ".cpp", ".cxx", ".cc", ".c++", ".h", ".hpp", ".hxx", ".hh"],
+        // compile_commands.json is the gold standard; fall back to CMake/Makefile markers
+        root: NearestRoot([
+            "compile_commands.json",
+            "compile_flags.txt",
+            ".clangd",
+            "CMakeLists.txt",
+            "Makefile",
+        ]),
+        async spawn(root) {
+            const bin = which("clangd");
+            if (!bin) {
+                log.error("clangd not found. Install with: brew install llvm, or apt install clangd");
+                return;
+            }
+            return {
+                process: spawn(bin, ["--background-index", "--clang-tidy"], { cwd: root }),
+            };
+        },
+    };
+})(LSPServer || (LSPServer = {}));

package/dist/src/mcp/config.js

@@ -0,0 +1,112 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+export const MCP_CONFIG_RELATIVE_PATH = join(".pi", "mcp.json");
+export function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+export function toNonEmptyString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        return undefined;
+    return trimmed;
+}
+export function toBoolean(value) {
+    if (typeof value === "boolean")
+        return value;
+    return undefined;
+}
+export function formatErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}
+export function getMcpConfigCandidates(workspaceCwd) {
+    return [resolve(workspaceCwd, MCP_CONFIG_RELATIVE_PATH), resolve(homedir(), MCP_CONFIG_RELATIVE_PATH)];
+}
+export function resolveMcpConfigSources(workspaceCwd) {
+    const projectPath = resolve(workspaceCwd, MCP_CONFIG_RELATIVE_PATH);
+    const userPath = resolve(homedir(), MCP_CONFIG_RELATIVE_PATH);
+    const sources = [];
+    if (existsSync(projectPath))
+        sources.push({ scope: "project", path: projectPath });
+    if (existsSync(userPath))
+        sources.push({ scope: "user", path: userPath });
+    return sources;
+}
+export async function loadMcpConfig(workspaceCwd) {
+    const sources = resolveMcpConfigSources(workspaceCwd);
+    if (sources.length === 0)
+        return undefined;
+    const servers = {};
+    const sourceByServer = {};
+    for (const source of sources) {
+        const parsed = await parseMcpConfig(source.path);
+        for (const [serverName, serverConfig] of Object.entries(parsed)) {
+            if (sourceByServer[serverName])
+                continue;
+            servers[serverName] = serverConfig;
+            sourceByServer[serverName] = source;
+        }
+    }
+    return { servers, sources, sourceByServer };
+}
+async function parseMcpConfig(configPath) {
+    const rawText = await readFile(configPath, "utf-8");
+    let parsed;
+    try {
+        parsed = JSON.parse(rawText);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON in MCP config: ${formatErrorMessage(error)}`);
+    }
+    if (!isRecord(parsed)) {
+        throw new Error("MCP config root must be a JSON object.");
+    }
+    const serversValue = parsed.mcpServers;
+    if (!isRecord(serversValue))
+        return {};
+    const result = {};
+    for (const [serverName, serverConfig] of Object.entries(serversValue)) {
+        if (!isRecord(serverConfig))
+            continue;
+        result[serverName] = serverConfig;
+    }
+    return result;
+}
+export function isServerEnabled(config) {
+    const disabled = toBoolean(config.disabled);
+    if (disabled === true)
+        return false;
+    const enabled = toBoolean(config.enabled);
+    if (enabled === false)
+        return false;
+    return true;
+}
+export function inferTransport(config) {
+    if (toNonEmptyString(config.url))
+        return "remote";
+    if (toNonEmptyString(config.command))
+        return "stdio";
+    return "unknown";
+}
+export function extractStringHeaders(rawHeaders) {
+    if (!isRecord(rawHeaders))
+        return {};
+    const headers = {};
+    for (const [key, value] of Object.entries(rawHeaders)) {
+        const headerName = key.trim();
+        if (!headerName)
+            continue;
+        if (typeof value === "string")
+            headers[headerName] = value;
+    }
+    return headers;
+}
+export function getHeaderKeys(headers) {
+    const keys = Object.keys(headers).sort((a, b) => a.localeCompare(b));
+    return keys.length > 0 ? keys : undefined;
+}

package/dist/src/{utils/mcp-client.js → mcp/protocol.js}

@@ -1,107 +1,8 @@
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { isAbsolute, join, resolve } from "node:path";
-import process from "node:process";
-export const MCP_CONFIG_RELATIVE_PATH = join(".pi", "mcp.json");
+import { isRecord, toNonEmptyString } from "./config.js";
 export const MCP_PROTOCOL_VERSION = "2025-03-26";
 export const MCP_CLIENT_NAME = "mono-pilot";
 export const MCP_CLIENT_VERSION = "0.1.0";
 export const MCP_REQUEST_TIMEOUT_MS = 20_000;
-export function isRecord(value) {
-    return typeof value === "object" && value !== null;
-}
-export function toNonEmptyString(value) {
-    if (typeof value !== "string")
-        return undefined;
-    const trimmed = value.trim();
-    if (trimmed.length === 0)
-        return undefined;
-    return trimmed;
-}
-export function toBoolean(value) {
-    if (typeof value === "boolean")
-        return value;
-    return undefined;
-}
-export function formatErrorMessage(error) {
-    if (error instanceof Error)
-        return error.message;
-    return String(error);
-}
-export function resolveMcpConfigPath(workspaceCwd) {
-    const envOverride = toNonEmptyString(process.env.MONOPILOT_MCP_CONFIG);
-    const candidates = [];
-    if (envOverride) {
-        candidates.push(isAbsolute(envOverride) ? resolve(envOverride) : resolve(workspaceCwd, envOverride));
-    }
-    candidates.push(resolve(workspaceCwd, MCP_CONFIG_RELATIVE_PATH));
-    candidates.push(resolve(homedir(), MCP_CONFIG_RELATIVE_PATH));
-    for (const candidate of candidates) {
-        if (existsSync(candidate))
-            return candidate;
-    }
-    return undefined;
-}
-export async function parseMcpConfig(configPath) {
-    const rawText = await readFile(configPath, "utf-8");
-    return _parseMcpConfigContent(rawText, configPath);
-}
-function _parseMcpConfigContent(rawText, configPath) {
-    let parsed;
-    try {
-        parsed = JSON.parse(rawText);
-    }
-    catch (error) {
-        throw new Error(`Invalid JSON in MCP config: ${formatErrorMessage(error)}`);
-    }
-    if (!isRecord(parsed)) {
-        throw new Error("MCP config root must be a JSON object.");
-    }
-    const serversValue = parsed.mcpServers;
-    if (!isRecord(serversValue))
-        return {};
-    const result = {};
-    for (const [serverName, serverConfig] of Object.entries(serversValue)) {
-        if (!isRecord(serverConfig))
-            continue;
-        result[serverName] = serverConfig;
-    }
-    return result;
-}
-export function isServerEnabled(config) {
-    const disabled = toBoolean(config.disabled);
-    if (disabled === true)
-        return false;
-    const enabled = toBoolean(config.enabled);
-    if (enabled === false)
-        return false;
-    return true;
-}
-export function inferTransport(config) {
-    if (toNonEmptyString(config.url))
-        return "remote";
-    if (toNonEmptyString(config.command))
-        return "stdio";
-    return "unknown";
-}
-export function extractStringHeaders(rawHeaders) {
-    if (!isRecord(rawHeaders))
-        return {};
-    const headers = {};
-    for (const [key, value] of Object.entries(rawHeaders)) {
-        const headerName = key.trim();
-        if (!headerName)
-            continue;
-        if (typeof value === "string")
-            headers[headerName] = value;
-    }
-    return headers;
-}
-export function getHeaderKeys(headers) {
-    const keys = Object.keys(headers).sort((a, b) => a.localeCompare(b));
-    return keys.length > 0 ? keys : undefined;
-}
 export function parseSseJsonPayload(rawBody) {
     const lines = rawBody.split(/\r?\n/);
     const events = [];

package/dist/src/mcp/servers.js

@@ -0,0 +1,90 @@
+import { extractStringHeaders, formatErrorMessage, getMcpConfigCandidates, inferTransport, isServerEnabled, loadMcpConfig, resolveMcpConfigSources, toNonEmptyString, } from "./config.js";
+/** Thrown when no MCP config files are found or config fails to parse. */
+export class McpConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "McpConfigError";
+    }
+}
+/** Thrown when a specific server can't be used (not found, disabled, wrong transport, etc.). */
+export class McpServerError extends Error {
+    transport;
+    configPaths;
+    constructor(message, transport, configPaths) {
+        super(message);
+        this.transport = transport;
+        this.configPaths = configPaths;
+        this.name = "McpServerError";
+    }
+}
+async function loadRequiredMcpConfig(cwd) {
+    const sources = resolveMcpConfigSources(cwd);
+    if (sources.length === 0) {
+        const candidates = getMcpConfigCandidates(cwd);
+        throw new McpConfigError(`MCP config not found. Checked:\n- ${candidates.join("\n- ")}`);
+    }
+    let config;
+    try {
+        config = await loadMcpConfig(cwd);
+    }
+    catch (error) {
+        throw new McpConfigError(formatErrorMessage(error));
+    }
+    if (!config) {
+        const candidates = getMcpConfigCandidates(cwd);
+        throw new McpConfigError(`MCP config not found. Checked:\n- ${candidates.join("\n- ")}`);
+    }
+    return config;
+}
+/**
+ * For list-style tools (ListMcpTools, ListMcpResources).
+ * Returns all enabled remote servers matching the optional name filter.
+ * Throws McpConfigError on config load failure.
+ */
+export async function resolveTargetServers(cwd, serverFilter) {
+    const config = await loadRequiredMcpConfig(cwd);
+    const configPaths = config.sources.map((source) => source.path);
+    const servers = [];
+    for (const [serverName, serverConfig] of Object.entries(config.servers)) {
+        if (serverFilter && serverName !== serverFilter)
+            continue;
+        if (!isServerEnabled(serverConfig))
+            continue;
+        if (inferTransport(serverConfig) !== "remote")
+            continue;
+        const serverUrl = toNonEmptyString(serverConfig.url);
+        if (!serverUrl)
+            continue;
+        servers.push({ name: serverName, url: serverUrl, headers: extractStringHeaders(serverConfig.headers) });
+    }
+    return { servers, sources: config.sources, configPaths };
+}
+/**
+ * For single-server tools (CallMcpTool, FetchMcpResource).
+ * Returns the resolved remote server or throws McpConfigError / McpServerError.
+ */
+export async function resolveTargetServer(cwd, serverName) {
+    const config = await loadRequiredMcpConfig(cwd);
+    const configPaths = config.sources.map((source) => source.path);
+    const serverConfig = config.servers[serverName];
+    if (!serverConfig) {
+        throw new McpServerError(`MCP server '${serverName}' not found in configured MCP sources.`, undefined, configPaths);
+    }
+    if (!isServerEnabled(serverConfig)) {
+        throw new McpServerError(`MCP server '${serverName}' is disabled in config.`, inferTransport(serverConfig), configPaths);
+    }
+    const transport = inferTransport(serverConfig);
+    if (transport === "stdio") {
+        const command = toNonEmptyString(serverConfig.command);
+        const message = `MCP stdio transport is not supported yet.` + (command ? ` Configured command: ${command}` : "");
+        throw new McpServerError(message, transport, configPaths);
+    }
+    const serverUrl = toNonEmptyString(serverConfig.url);
+    if (!serverUrl) {
+        throw new McpServerError(`MCP server '${serverName}' is missing a remote URL.`, transport, configPaths);
+    }
+    return {
+        server: { name: serverName, url: serverUrl, headers: extractStringHeaders(serverConfig.headers) },
+        configPaths,
+    };
+}

package/dist/src/memory/build-memory.js

@@ -0,0 +1,103 @@
+import { loadResolvedMemorySearchConfig } from "./config/loader.js";
+import { closeMemorySearchManagers, peekMemorySearchManager, getDefaultEmbeddingProvider } from "./runtime/index.js";
+import { getMemoryIndexPath } from "./paths.js";
+import { MemoryIndexManager } from "./index-manager.js";
+import { deriveAgentId } from "../agents-paths.js";
+import { openSqliteDatabase } from "./store/sqlite.js";
+import { ensureMemoryIndexSchema, CHUNKS_TABLE, FILES_TABLE, FTS_TABLE, VECTOR_TABLE } from "./store/schema.js";
+import { memoryLog } from "./log.js";
+export async function buildMemoryIndex(params) {
+    const settings = await loadResolvedMemorySearchConfig();
+    if (!settings.enabled) {
+        return { ok: false, message: "Memory search is disabled in config.", agents: [] };
+    }
+    if (!settings.sources.includes("memory") && !settings.sources.includes("sessions")) {
+        return { ok: false, message: "Config sources do not include 'memory' or 'sessions'.", agents: [] };
+    }
+    if (params.mode === "full") {
+        return await buildFull(params, settings);
+    }
+    return await buildDirty(params);
+}
+async function buildFull(params, settings) {
+    // Release cached managers so DB files are not locked
+    await closeMemorySearchManagers();
+    const agentId = deriveAgentId(params.workspaceDir);
+    const provider = getDefaultEmbeddingProvider();
+    memoryLog.info("build full start", { agentId });
+    await clearAgentPartition(agentId, settings);
+    const manager = new MemoryIndexManager({
+        agentId,
+        workspaceDir: params.workspaceDir,
+        settings,
+        embedFn: provider?.embedBatch,
+        embedModel: provider?.model,
+    });
+    try {
+        await manager.sync({ reason: "build-full", force: true });
+    }
+    finally {
+        await manager.close();
+    }
+    memoryLog.info("build full complete", { agentId });
+    return {
+        ok: true,
+        message: `Full rebuild completed for agent ${agentId}.`,
+        agents: [agentId],
+    };
+}
+async function buildDirty(params) {
+    const agentId = deriveAgentId(params.workspaceDir);
+    const manager = peekMemorySearchManager({ agentId });
+    memoryLog.info("build dirty start", { agentId });
+    if (!manager) {
+        memoryLog.info("build dirty skipped", { agentId, reason: "no manager" });
+        return { ok: true, message: "No active memory manager found. Nothing to sync.", agents: [] };
+    }
+    if (!manager.isDirty?.()) {
+        memoryLog.info("build dirty skipped", { agentId, reason: "not dirty" });
+        return { ok: true, message: "Memory index is up to date (not dirty).", agents: [] };
+    }
+    if (manager.syncDirty) {
+        const synced = await manager.syncDirty();
+        memoryLog.info("build dirty complete", { agentId, syncedCount: synced.length });
+        return {
+            ok: true,
+            message: synced.length > 0
+                ? `Dirty sync completed for ${synced.length} agent(s).`
+                : "No dirty agents found.",
+            agents: synced,
+        };
+    }
+    if (manager.sync) {
+        await manager.sync({ reason: "build-dirty" });
+    }
+    memoryLog.info("build dirty complete", { agentId });
+    return {
+        ok: true,
+        message: "Dirty sync completed.",
+        agents: [agentId],
+    };
+}
+async function clearAgentPartition(agentId, settings) {
+    const indexPath = getMemoryIndexPath();
+    const db = openSqliteDatabase(indexPath, true);
+    try {
+        ensureMemoryIndexSchema({ db, ftsEnabled: true });
+        if (settings.store.vector.enabled) {
+            try {
+                db.prepare(`DELETE FROM ${VECTOR_TABLE} WHERE id IN (SELECT id FROM ${CHUNKS_TABLE} WHERE agent_id = ?)`).run(agentId);
+            }
+            catch { }
+        }
+        try {
+            db.prepare(`DELETE FROM ${FTS_TABLE} WHERE id IN (SELECT id FROM ${CHUNKS_TABLE} WHERE agent_id = ?)`).run(agentId);
+        }
+        catch { }
+        db.prepare(`DELETE FROM ${CHUNKS_TABLE} WHERE agent_id = ?`).run(agentId);
+        db.prepare(`DELETE FROM ${FILES_TABLE} WHERE agent_id = ?`).run(agentId);
+    }
+    finally {
+        db.close();
+    }
+}