codelocal 1.5.0-beta.1

package/dist/log.js

@@ -0,0 +1,235 @@
+const LOG_LEVEL = (process.env.CODELOCAL_LOG_LEVEL ?? "info").toLowerCase();
+const LOG_FORMAT = (process.env.CODELOCAL_LOG_FORMAT ?? "json").toLowerCase();
+const ranks = { debug: 10, info: 20, warn: 30, error: 40 };
+const configuredRank = ranks[(LOG_LEVEL in ranks ? LOG_LEVEL : "info")];
+const ansi = {
+    reset: "\u001b[0m",
+    bold: "\u001b[1m",
+    dim: "\u001b[2m",
+    gray: "\u001b[90m",
+    cyan: "\u001b[36m",
+    green: "\u001b[32m",
+    yellow: "\u001b[33m",
+    red: "\u001b[31m",
+    magenta: "\u001b[35m",
+};
+function colorEnabled() {
+    return process.env.NO_COLOR == null && process.env.TERM !== "dumb" && !!process.stdout.isTTY;
+}
+function paint(code, value) {
+    const text = String(value ?? "");
+    return colorEnabled() ? `${code}${text}${ansi.reset}` : text;
+}
+function bold(value) { return paint(ansi.bold, value); }
+function dim(value) { return paint(ansi.gray, value); }
+function redactText(input) {
+    let value = input;
+    value = value.replace(/(authorization\s*:\s*bearer\s+)[^\s\"']+/gi, "$1[REDACTED]");
+    value = value.replace(/((?:api[_-]?key|access[_-]?token|auth[_-]?token|password|secret)\s*[=:]\s*)[^\s\"']+/gi, "$1[REDACTED]");
+    value = value.replace(/(--(?:token|password|secret|api-key|apikey)\s+)([^\s]+)/gi, "$1[REDACTED]");
+    value = value.replace(/((?:OPENAI_API_KEY|CODEX_API_KEY|AWS_SECRET_ACCESS_KEY|GITHUB_TOKEN|GH_TOKEN)=)([^\s]+)/gi, "$1[REDACTED]");
+    value = value.replace(/(https?:\/\/[^\s:@/]+:)[^\s@/]+@/gi, "$1[REDACTED]@");
+    return value;
+}
+function sanitize(value) {
+    if (value instanceof Error)
+        return { name: value.name, message: redactText(value.message) };
+    if (Array.isArray(value))
+        return value.map(sanitize);
+    if (!value || typeof value !== "object")
+        return typeof value === "string" ? redactText(value) : value;
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (/token|secret|password|authorization|cookie/i.test(key))
+            out[key] = "[redacted]";
+        else if (/content|patch|oldText|newText|input/i.test(key) && typeof item === "string")
+            out[key] = `[${Buffer.byteLength(item, "utf8")} bytes]`;
+        else if (typeof item === "string")
+            out[key] = redactText(item);
+        else
+            out[key] = sanitize(item);
+    }
+    return out;
+}
+function duration(value) {
+    const ms = Number(value);
+    if (!Number.isFinite(ms))
+        return "";
+    if (ms < 1000)
+        return `${Math.max(0, Math.round(ms))}ms`;
+    return `${(ms / 1000).toFixed(ms < 10_000 ? 1 : 0)}s`;
+}
+function compact(value, max = 76) {
+    const text = redactText(String(value ?? "")).replace(/\s+/g, " ").trim();
+    return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+function toolDetail(args) {
+    if (!args || typeof args !== "object")
+        return "";
+    const value = args;
+    if (typeof value.command === "string")
+        return `$ ${compact(value.command, 64)}`;
+    if (typeof value.path === "string") {
+        const lines = value.startLine != null ? `  L${value.startLine}${value.endLine != null ? `–${value.endLine}` : ""}` : "";
+        return `${compact(value.path, 58)}${lines}`;
+    }
+    if (Array.isArray(value.paths))
+        return `${value.paths.length} file${value.paths.length === 1 ? "" : "s"}`;
+    if (typeof value.query === "string")
+        return `“${compact(value.query, 58)}”`;
+    if (typeof value.name === "string")
+        return compact(value.name, 58);
+    if (typeof value.processId === "string")
+        return `process ${value.processId.slice(0, 8)}`;
+    if (typeof value.cwd === "string" && value.cwd !== ".")
+        return `in ${compact(value.cwd, 58)}`;
+    return "";
+}
+function terminalIcon(tone) {
+    if (tone === "success")
+        return paint(ansi.green, "●");
+    if (tone === "accent")
+        return paint(ansi.magenta, "◆");
+    if (tone === "warn")
+        return paint(ansi.yellow, "▲");
+    if (tone === "error")
+        return paint(ansi.red, "✕");
+    if (tone === "muted")
+        return paint(ansi.gray, "◌");
+    return paint(ansi.cyan, "◇");
+}
+export function terminalStatus(tone, label, detail = "") {
+    const padded = `${label}`.padEnd(12, " ");
+    console.log(`  ${terminalIcon(tone)} ${bold(padded)} ${detail}`.trimEnd());
+}
+export function terminalHeader(title = "CodeLocal", subtitle = "Local runtime for ChatGPT") {
+    const width = 48;
+    const top = `╭${"─".repeat(width - 2)}╮`;
+    const bottom = `╰${"─".repeat(width - 2)}╯`;
+    const row = (text) => `│  ${text}${" ".repeat(Math.max(0, width - 4 - text.length))}│`;
+    console.log("");
+    console.log(paint(ansi.magenta, top));
+    console.log(paint(ansi.magenta, row(`◆ ${title}`)));
+    console.log(paint(ansi.gray, row(subtitle)));
+    console.log(paint(ansi.magenta, bottom));
+    console.log("");
+}
+export function mirrorProcessOutput(stream, text) {
+    if (LOG_FORMAT !== "pretty") {
+        process.stdout.write(text);
+        return;
+    }
+    const marker = stream === "stderr" ? paint(ansi.yellow, "│") : paint(ansi.gray, "│");
+    const lines = text.replace(/\r/g, "").split("\n");
+    const trailingNewline = text.endsWith("\n");
+    const rendered = lines
+        .filter((line, index) => line.length > 0 || index < lines.length - 1)
+        .map((line) => `     ${marker} ${line}`)
+        .join("\n");
+    if (rendered)
+        process.stdout.write(rendered + (trailingNewline ? "\n" : ""));
+}
+function prettyLog(level, event, fields) {
+    const tool = compact(fields.tool ?? "", 42);
+    const elapsed = duration(fields.durationMs);
+    if (event === "workspace.watcher_configured") {
+        terminalStatus("info", "Watcher", `${fields.backend ?? "native"} ${dim(`· fallback ${fields.fallbackBackend ?? "bounded"}`)}`);
+        return;
+    }
+    if (event === "mcp.cloud_sync") {
+        const reason = fields.reason ? ` · ${fields.reason}` : "";
+        terminalStatus(fields.skipped ? "muted" : "success", "MCP sync", `${fields.skipped ? "Skipped" : "Ready"}${dim(reason)}`);
+        return;
+    }
+    if (event === "mcp.cloud_sync_failed") {
+        terminalStatus("warn", "MCP sync", compact(fields.error ?? "Cloud sync unavailable"));
+        return;
+    }
+    if (event === "client.started") {
+        terminalStatus("accent", "Workspace", `${fields.workspaceId ?? "workspace"} ${dim(`· approval ${fields.approvalMode ?? "prompt"}`)}`);
+        return;
+    }
+    if (event === "client.connecting") {
+        terminalStatus("info", "Cloud", "Connecting…");
+        return;
+    }
+    if (event === "client.registered") {
+        terminalStatus("success", "Cloud", `Connected ${dim(`· protocol v${fields.protocolVersion ?? "?"}`)}`);
+        console.log("");
+        terminalStatus("muted", "Status", "Waiting for ChatGPT…");
+        return;
+    }
+    if (event === "client.disconnected") {
+        terminalStatus("warn", "Cloud", `Disconnected ${dim(`· retry ${duration(fields.reconnectInMs)}`)}`);
+        return;
+    }
+    if (event === "client.socket_error") {
+        const error = fields.error;
+        terminalStatus("error", "Cloud", compact(error?.message ?? "Connection error"));
+        return;
+    }
+    if (event === "tool.received") {
+        const detail = toolDetail(fields.args);
+        console.log(`  ${paint(ansi.magenta, "◆")} ${paint(ansi.cyan, bold(tool || "tool"))}${detail ? `  ${dim(detail)}` : ""}`);
+        return;
+    }
+    if (event === "tool.completed") {
+        console.log(`  ${paint(ansi.green, "✓")} ${bold(tool || "tool")}  ${dim(elapsed || "done")}`);
+        return;
+    }
+    if (event === "tool.failed") {
+        const error = fields.error;
+        console.error(`  ${paint(ansi.red, "✕")} ${bold(tool || "tool")}  ${dim(elapsed)}${error?.message ? `  ${paint(ansi.red, compact(error.message, 72))}` : ""}`);
+        return;
+    }
+    const detail = Object.entries(fields)
+        .filter(([key]) => !["requestId", "tool"].includes(key))
+        .slice(0, 3)
+        .map(([key, value]) => `${key}=${compact(typeof value === "object" ? JSON.stringify(value) : value, 38)}`)
+        .join("  ");
+    const tone = level === "error" ? "error" : level === "warn" ? "warn" : level === "debug" ? "muted" : "info";
+    terminalStatus(tone, event.replace(/^client\.|^workspace\./, ""), detail);
+}
+export function log(level, event, fields = {}) {
+    if (ranks[level] < configuredRank)
+        return;
+    const cleanFields = sanitize(fields);
+    if (LOG_FORMAT === "pretty") {
+        prettyLog(level, event, cleanFields);
+        return;
+    }
+    const entry = {
+        ts: new Date().toISOString(),
+        level,
+        event,
+        ...cleanFields,
+    };
+    const line = JSON.stringify(entry);
+    if (level === "error")
+        console.error(line);
+    else if (level === "warn")
+        console.warn(line);
+    else
+        console.log(line);
+}
+export function summarizeToolArgs(tool, args) {
+    if (!args || typeof args !== "object")
+        return {};
+    const source = args;
+    const summary = {};
+    for (const key of ["path", "paths", "cwd", "processId", "cursor", "cached", "maxDepth", "maxResults", "fixedStrings", "yieldMs", "timeoutMs", "signal", "includeIgnored", "expectedHash", "startLine", "endLine", "limit", "name", "ref"]) {
+        if (key in source)
+            summary[key] = source[key];
+    }
+    if (typeof source.command === "string")
+        summary.command = redactText(source.command.slice(0, 500));
+    if (typeof source.query === "string")
+        summary.query = redactText(source.query.slice(0, 300));
+    if (typeof source.content === "string")
+        summary.contentBytes = Buffer.byteLength(source.content, "utf8");
+    if (typeof source.patch === "string")
+        summary.patchBytes = Buffer.byteLength(source.patch, "utf8");
+    if (typeof source.input === "string")
+        summary.inputBytes = Buffer.byteLength(source.input, "utf8");
+    return summary;
+}

package/dist/lsp.js

@@ -0,0 +1,288 @@
+import { spawn } from "node:child_process";
+import { pathToFileURL } from "node:url";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+function uri(file) {
+    return pathToFileURL(file).toString();
+}
+function languageId(file) {
+    const ext = path.extname(file).toLowerCase();
+    const map = {
+        ".ts": "typescript", ".tsx": "typescriptreact", ".js": "javascript", ".jsx": "javascriptreact",
+        ".mts": "typescript", ".cts": "typescript", ".mjs": "javascript", ".cjs": "javascript",
+        ".py": "python", ".rs": "rust", ".go": "go", ".c": "c", ".h": "c", ".cc": "cpp", ".cpp": "cpp", ".cxx": "cpp", ".hpp": "cpp",
+        ".java": "java", ".kt": "kotlin", ".kts": "kotlin", ".cs": "csharp", ".php": "php", ".rb": "ruby", ".lua": "lua",
+        ".swift": "swift", ".dart": "dart", ".ex": "elixir", ".exs": "elixir", ".zig": "zig", ".sol": "solidity",
+    };
+    return map[ext] ?? (ext.replace(/^\./, "") || "plaintext");
+}
+function inside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+export async function commandExists(command) {
+    if (path.isAbsolute(command) || command.includes(path.sep)) {
+        try {
+            await fs.access(command);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    const pathEntries = (process.env.PATH ?? "").split(path.delimiter).filter(Boolean);
+    const suffixes = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
+    for (const dir of pathEntries) {
+        for (const suffix of suffixes) {
+            try {
+                await fs.access(path.join(dir, `${command}${suffix}`));
+                return true;
+            }
+            catch { }
+        }
+    }
+    return false;
+}
+export async function resolveLspRoot(workspaceRoot, file, spec) {
+    const root = path.resolve(workspaceRoot);
+    const absolute = path.resolve(file);
+    let current = path.dirname(absolute);
+    const markers = spec.rootMarkers ?? [];
+    if (!markers.length)
+        return root;
+    while (inside(root, current)) {
+        for (const marker of markers) {
+            try {
+                await fs.access(path.join(current, marker));
+                return current;
+            }
+            catch { }
+        }
+        if (current === root)
+            break;
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return root;
+}
+export class LspClient {
+    root;
+    spec;
+    child = null;
+    sequence = 1;
+    buffer = Buffer.alloc(0);
+    pending = new Map();
+    opened = new Map();
+    publishedDiagnostics = new Map();
+    initialized = false;
+    startPromise = null;
+    constructor(root, spec) {
+        this.root = root;
+        this.spec = spec;
+    }
+    async available() {
+        return commandExists(this.spec.command);
+    }
+    async start() {
+        if (this.initialized && this.child)
+            return;
+        if (this.startPromise)
+            return this.startPromise;
+        this.startPromise = this.startInternal().finally(() => { this.startPromise = null; });
+        return this.startPromise;
+    }
+    async startInternal() {
+        if (!(await this.available()))
+            throw new Error(`${this.spec.id} is not installed.`);
+        const child = spawn(this.spec.command, this.spec.args, {
+            cwd: this.root,
+            env: { ...process.env },
+            stdio: "pipe",
+        });
+        this.child = child;
+        this.buffer = Buffer.alloc(0);
+        this.opened.clear();
+        this.publishedDiagnostics.clear();
+        child.stdout.on("data", (chunk) => this.onData(chunk));
+        child.stderr.on("data", () => undefined);
+        child.on("error", (error) => this.failAll(error));
+        child.on("close", () => this.failAll(new Error(`${this.spec.id} exited.`)));
+        const rootUri = uri(this.root);
+        try {
+            await this.request("initialize", {
+                processId: process.pid,
+                clientInfo: { name: "CodeLocal", version: "1.2" },
+                rootUri,
+                workspaceFolders: [{ uri: rootUri, name: path.basename(this.root) }],
+                capabilities: {
+                    workspace: { symbol: {}, workspaceFolders: true },
+                    textDocument: {
+                        synchronization: { didSave: true, dynamicRegistration: false },
+                        definition: {}, references: {}, implementation: {}, hover: {}, documentSymbol: {}, publishDiagnostics: {},
+                        callHierarchy: {},
+                    },
+                },
+                initializationOptions: this.spec.initializationOptions,
+            }, 25_000);
+            this.notify("initialized", {});
+            this.initialized = true;
+        }
+        catch (error) {
+            try {
+                child.kill("SIGTERM");
+            }
+            catch { }
+            if (this.child === child)
+                this.child = null;
+            this.opened.clear();
+            this.publishedDiagnostics.clear();
+            throw error;
+        }
+    }
+    failAll(error) {
+        for (const [id, pending] of this.pending) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+            this.pending.delete(id);
+        }
+        this.initialized = false;
+        this.child = null;
+        this.opened.clear();
+        this.publishedDiagnostics.clear();
+        this.buffer = Buffer.alloc(0);
+    }
+    send(payload) {
+        if (!this.child)
+            throw new Error(`${this.spec.id} is not running.`);
+        const json = JSON.stringify(payload);
+        this.child.stdin.write(`Content-Length: ${Buffer.byteLength(json, "utf8")}\r\n\r\n${json}`);
+    }
+    request(method, params, timeoutMs = 15_000) {
+        const id = this.sequence++;
+        const promise = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`${this.spec.id} LSP request timed out: ${method}`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+        });
+        this.send({ jsonrpc: "2.0", id, method, params });
+        return promise;
+    }
+    notify(method, params) {
+        this.send({ jsonrpc: "2.0", method, params });
+    }
+    onData(chunk) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        while (true) {
+            const headerEnd = this.buffer.indexOf("\r\n\r\n");
+            if (headerEnd < 0)
+                return;
+            const header = this.buffer.subarray(0, headerEnd).toString("ascii");
+            const match = /Content-Length:\s*(\d+)/i.exec(header);
+            if (!match) {
+                this.buffer = this.buffer.subarray(headerEnd + 4);
+                continue;
+            }
+            const length = Number(match[1]);
+            const bodyStart = headerEnd + 4;
+            if (this.buffer.length < bodyStart + length)
+                return;
+            const body = this.buffer.subarray(bodyStart, bodyStart + length).toString("utf8");
+            this.buffer = this.buffer.subarray(bodyStart + length);
+            try {
+                this.onMessage(JSON.parse(body));
+            }
+            catch { }
+        }
+    }
+    onMessage(message) {
+        if (typeof message?.id === "number" && this.pending.has(message.id)) {
+            const pending = this.pending.get(message.id);
+            this.pending.delete(message.id);
+            clearTimeout(pending.timer);
+            if (message.error)
+                pending.reject(new Error(message.error.message ?? "LSP error"));
+            else
+                pending.resolve(message.result);
+            return;
+        }
+        if (message?.method === "textDocument/publishDiagnostics") {
+            this.publishedDiagnostics.set(String(message.params?.uri ?? ""), Array.isArray(message.params?.diagnostics) ? message.params.diagnostics : []);
+        }
+    }
+    async openDocument(file) {
+        await this.start();
+        const absolute = path.resolve(file);
+        const text = await fs.readFile(absolute, "utf8");
+        const version = (this.opened.get(absolute) ?? 0) + 1;
+        this.opened.set(absolute, version);
+        const textDocument = { uri: uri(absolute), languageId: languageId(absolute), version, text };
+        if (version === 1)
+            this.notify("textDocument/didOpen", { textDocument });
+        else
+            this.notify("textDocument/didChange", { textDocument: { uri: textDocument.uri, version }, contentChanges: [{ text }] });
+        return { absolute, version };
+    }
+    async positionRequest(method, file, line, column, extra = {}) {
+        await this.openDocument(file);
+        return this.request(method, {
+            textDocument: { uri: uri(path.resolve(file)) },
+            position: { line: Math.max(0, line - 1), character: Math.max(0, column - 1) },
+            ...extra,
+        });
+    }
+    async workspaceSymbols(query) {
+        await this.start();
+        return this.request("workspace/symbol", { query });
+    }
+    async documentSymbols(file) {
+        await this.openDocument(file);
+        return this.request("textDocument/documentSymbol", { textDocument: { uri: uri(path.resolve(file)) } });
+    }
+    async diagnostics(file, waitMs = 350) {
+        await this.openDocument(file);
+        await new Promise((resolve) => setTimeout(resolve, waitMs));
+        return this.publishedDiagnostics.get(uri(path.resolve(file))) ?? [];
+    }
+    async callHierarchy(file, line, column, direction) {
+        await this.openDocument(file);
+        const textDocument = { uri: uri(path.resolve(file)) };
+        const position = { line: Math.max(0, line - 1), character: Math.max(0, column - 1) };
+        const items = await this.request("textDocument/prepareCallHierarchy", { textDocument, position }).catch(() => []);
+        const prepared = Array.isArray(items) ? items.slice(0, 4) : [];
+        if (!prepared.length)
+            return [];
+        const method = direction === "incoming" ? "callHierarchy/incomingCalls" : "callHierarchy/outgoingCalls";
+        const results = await Promise.all(prepared.map((item) => this.request(method, { item }).catch(() => [])));
+        return results.flat().filter(Boolean);
+    }
+    status() {
+        return { id: this.spec.id, root: this.root, initialized: this.initialized, pid: this.child?.pid ?? null };
+    }
+    async stop() {
+        const child = this.child;
+        if (!child)
+            return;
+        try {
+            await this.request("shutdown", null, 2000);
+        }
+        catch { }
+        try {
+            this.notify("exit", null);
+        }
+        catch { }
+        try {
+            child.kill("SIGTERM");
+        }
+        catch { }
+        if (this.child === child)
+            this.child = null;
+        this.initialized = false;
+        this.opened.clear();
+        this.publishedDiagnostics.clear();
+        this.buffer = Buffer.alloc(0);
+    }
+}

package/dist/mcp-cloud-sync.js

@@ -0,0 +1,3 @@
+export async function syncCloudMcpInstallations(_workspaceRoot, _entries) {
+    return { applied: 0, skipped: true, reason: "MCP configuration is local-only" };
+}