@intentius/chant 0.124.12 → 0.124.14

package/dist/cli/handlers/serve.js

@@ -0,0 +1,32 @@
+import { formatError } from "../format.js";
+export async function runServeLsp(ctx) {
+    const { LspServer } = await import("../lsp/server.js");
+    const server = new LspServer(ctx.plugins);
+    await server.start();
+    await new Promise(() => { });
+    return 0; // unreachable
+}
+export async function runServeMcp(ctx) {
+    const { McpServer } = await import("../mcp/server.js");
+    // #2700 — main() hands over no plugins only at a workspace root with no
+    // lexicon of its own (anywhere else it refuses first). There the lexicons
+    // are the chant members', and the server says which loaded.
+    let plugins = ctx.plugins;
+    let instructions;
+    if (plugins.length === 0) {
+        const { loadWorkspacePlugins } = await import("../mcp/workspace-plugins.js");
+        ({ plugins, instructions } = await loadWorkspacePlugins(process.cwd()));
+    }
+    // #2707 — at or inside a declared workspace, the workspace tools are served too.
+    const server = new McpServer(plugins, { instructions, workspace: { cwd: process.cwd() } });
+    await server.start();
+    await new Promise(() => { });
+    return 0; // unreachable
+}
+export async function runServeUnknown(ctx) {
+    console.error(formatError({
+        message: `Unknown serve subcommand: ${ctx.args.path}`,
+        hint: "Available: chant serve lsp, chant serve mcp",
+    }));
+    return 1;
+}

package/dist/cli/handlers/vendor.js

@@ -0,0 +1,154 @@
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { vendorPull, vendorCheck, MANIFEST_FILE } from "../commands/vendor.js";
+import { formatError, formatSuccess, formatWarning } from "../format.js";
+/**
+ * Where the lineage lock lives (`../../workspace/lineage-lock.ts` owns the
+ * constant). Repeated here so that finding out whether a lock exists loads no
+ * workspace module: a project with only `vendor.json` must see today's
+ * `chant vendor` exactly (#2525 rule 2).
+ */
+const LOCK_FILE = ".chant/workspace.lock.json";
+/**
+ * `chant vendor [pull|check|migrate]` — pull pinned, checksummed patterns into
+ * the repo, check vendored targets against their pin, or move `vendor.json`
+ * into the lineage lock. Defaults to `pull`.
+ *
+ * `vendor.json` and the lock both live in the current directory. With no lock,
+ * `pull` and `check` read `vendor.json` exactly as before. With a lock, its
+ * vendor scopes are pulled file by file (local edits are kept, conflicts
+ * become manual steps), and any `vendor.json` entries not yet migrated are
+ * still pulled the old way (#2540).
+ */
+export async function runVendor(ctx) {
+    const { args } = ctx;
+    // `chant vendor` → pull; `chant vendor pull|check|migrate [name]`.
+    const sub = args.path === "." ? "pull" : args.path;
+    const manifestDir = resolve(".");
+    try {
+        if (sub === "migrate")
+            return await runMigrate(manifestDir);
+        const locked = await hasVendorScopes(manifestDir);
+        if (sub === "pull")
+            return locked ? await runLockedPull(manifestDir, args.extraPositional) : await runPull(manifestDir, args.extraPositional);
+        if (sub === "check")
+            return locked ? await runLockedCheck(manifestDir) : runCheck(manifestDir);
+    }
+    catch (err) {
+        console.error(formatError({ message: err instanceof Error ? err.message : String(err) }));
+        return 1;
+    }
+    console.error(formatError({
+        message: `Unknown vendor subcommand: ${sub}`,
+        hint: "Available: chant vendor pull [name], chant vendor check, chant vendor migrate",
+    }));
+    return 1;
+}
+/**
+ * Whether the lock holds any vendor scope. Without a lock file this loads
+ * nothing; a lock with no vendor scope (say, one `chant init --template`
+ * wrote) leaves `chant vendor` on `vendor.json` as before.
+ */
+async function hasVendorScopes(root) {
+    if (!existsSync(join(root, LOCK_FILE)))
+        return false;
+    const { readLock } = await import("../../workspace/lineage-lock.js");
+    const lock = readLock(root);
+    return !!lock && Object.values(lock.scopes).some((l) => l.kind === "vendor");
+}
+// ── vendor.json only: unchanged ──────────────────────────────────────────────
+async function runPull(manifestDir, only) {
+    const result = await vendorPull(manifestDir, only);
+    if (!result.success) {
+        console.error(formatError({ message: result.output }));
+        return 1;
+    }
+    console.log(result.output);
+    console.error(formatSuccess(`Vendored ${result.pulled.length} artifact(s)`));
+    return 0;
+}
+function runCheck(manifestDir) {
+    const result = vendorCheck(manifestDir);
+    console.log(result.output);
+    if (!result.drift) {
+        console.error(formatSuccess("All vendored artifacts match their pin"));
+        return 0;
+    }
+    // Drift is allowed (you may edit vendored files); fail only in CI so a
+    // pipeline catches unrecorded changes, warn locally.
+    if (process.env.CI) {
+        console.error(formatError({ message: "Vendored content drifted from the manifest pin" }));
+        return 1;
+    }
+    console.error(formatWarning({ message: "Vendored content drifted from the manifest pin (run `chant vendor pull` to re-pin)" }));
+    return 0;
+}
+// ── With a lineage lock ──────────────────────────────────────────────────────
+const MIGRATE_HINT = `${MANIFEST_FILE} entries are not in ${LOCK_FILE} yet, and pull still overwrites their targets. Run \`chant vendor migrate\` to move them.`;
+async function runLockedPull(root, only) {
+    const lv = await import("../../workspace/lineage-vendor.js");
+    const hasManifest = lv.manifestPresent(root);
+    const legacy = hasManifest ? (await import("../commands/vendor.js")).loadManifest(root).manifest.vendored : [];
+    const legacyMatch = only ? legacy.some((e) => e.name === only) : legacy.length > 0;
+    const pulled = await lv.pullLockedScopes(root, only);
+    if (only && pulled.length === 0 && !legacyMatch) {
+        console.error(formatError({ message: `no vendored entry named "${only}"` }));
+        return 1;
+    }
+    const lines = pulled.map(lv.formatLockedPull);
+    let count = pulled.length;
+    if (legacyMatch) {
+        const result = await vendorPull(root, only);
+        lines.push(result.output);
+        count += result.pulled.length;
+    }
+    if (lines.length > 0)
+        console.log(lines.join("\n"));
+    if (legacyMatch)
+        console.error(formatWarning({ message: MIGRATE_HINT }));
+    const steps = pulled.reduce((n, p) => n + p.manualSteps.length, 0);
+    if (steps > 0) {
+        console.error(formatWarning({
+            message: `Vendored ${count} artifact(s); ${steps} file(s) changed both here and upstream were left as they are`,
+        }));
+        console.error("  Merge each by hand, then run `chant workspace lineage resolve <path>`.");
+        return 0;
+    }
+    console.error(formatSuccess(`Vendored ${count} artifact(s)`));
+    return 0;
+}
+async function runLockedCheck(root) {
+    const lv = await import("../../workspace/lineage-vendor.js");
+    const checks = lv.checkLockedScopes(root);
+    const lines = checks.map(lv.formatLockedCheck);
+    let drift = checks.some(lv.lockedCheckFails);
+    if (lv.manifestPresent(root)) {
+        const legacy = vendorCheck(root);
+        if (legacy.output)
+            lines.push(legacy.output);
+        drift || (drift = legacy.drift);
+        console.error(formatWarning({ message: MIGRATE_HINT }));
+    }
+    if (lines.length > 0)
+        console.log(lines.join("\n"));
+    if (!drift) {
+        console.error(formatSuccess("All vendored artifacts match their pin, or carry local edits"));
+        return 0;
+    }
+    const message = "Vendored content has open manual steps or missing targets";
+    if (process.env.CI) {
+        console.error(formatError({ message }));
+        return 1;
+    }
+    console.error(formatWarning({ message: `${message} (see \`chant workspace lineage\`)` }));
+    return 0;
+}
+async function runMigrate(root) {
+    const { migrateVendorManifest } = await import("../../workspace/lineage-vendor.js");
+    const result = await migrateVendorManifest(root);
+    for (const m of result.migrated) {
+        console.log(`  ${m.name} → ${m.target} (${m.pinned ? `${m.files} file(s)` : "unpinned"})`);
+    }
+    console.error(formatSuccess(`Moved ${result.migrated.length} vendored artifact(s) from ${MANIFEST_FILE} into ${LOCK_FILE}${result.lockCreated ? " (created)" : ""}; ${MANIFEST_FILE} removed`));
+    return 0;
+}

package/dist/cli/index.js

@@ -0,0 +1,3 @@
+export { parseArgs } from "./main.js";
+export { loadPlugin, loadPlugins, resolveProjectLexicons } from "./plugins.js";
+export { checkConflicts } from "./conflict-check.js";

package/dist/cli/is-entry-point.js

@@ -0,0 +1,23 @@
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+/**
+ * True when the module identified by `importMetaUrl` is the process entry point
+ * (`process.argv[1]`) — i.e. run directly, not imported.
+ *
+ * A naive `import.meta.url === \`file://${process.argv[1]}\`` is a false negative
+ * whenever the invocation path crosses a symlink (pnpm, global bins, a symlinked
+ * checkout, the npm `.bin` shim, `/tmp`→`/private/tmp`): the loader canonicalises
+ * `import.meta.url` to the realpath while `argv[1]` keeps the symlink, so the CLI
+ * silently exits 0 having done nothing. Canonicalise both sides so the entry
+ * point is detected regardless of how the path was spelled.
+ */
+export function isEntryPoint(argv1, importMetaUrl) {
+    if (!argv1)
+        return false;
+    try {
+        return realpathSync(argv1) === realpathSync(fileURLToPath(importMetaUrl));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/cli/lsp/capabilities.js

@@ -0,0 +1,28 @@
+/**
+ * Compute LSP capabilities based on which plugins implement providers.
+ */
+export function computeCapabilities(plugins) {
+    const hasCompletion = plugins.some((p) => p.completionProvider !== undefined);
+    const hasHover = plugins.some((p) => p.hoverProvider !== undefined);
+    const hasCodeAction = plugins.some((p) => p.codeActionProvider !== undefined);
+    const capabilities = {
+        // Full sync — client sends full document content on open/change
+        textDocumentSync: 1,
+        diagnosticProvider: {
+            interFileDependencies: false,
+            workspaceDiagnostics: false,
+        },
+    };
+    if (hasCompletion) {
+        capabilities.completionProvider = {
+            triggerCharacters: [".", " ", '"', "'", "`", "("],
+        };
+    }
+    if (hasHover) {
+        capabilities.hoverProvider = true;
+    }
+    if (hasCodeAction) {
+        capabilities.codeActionProvider = true;
+    }
+    return capabilities;
+}

package/dist/cli/lsp/diagnostics.js

@@ -0,0 +1,34 @@
+/**
+ * Map chant severity to LSP DiagnosticSeverity (1=Error, 2=Warning, 3=Info, 4=Hint)
+ */
+function toLspSeverity(severity) {
+    switch (severity) {
+        case "error":
+            return 1;
+        case "warning":
+            return 2;
+        case "info":
+            return 3;
+    }
+}
+/**
+ * Convert chant LintDiagnostics to LSP diagnostics.
+ * Converts 1-based lines/columns to 0-based.
+ */
+export function toLspDiagnostics(diagnostics) {
+    return diagnostics.map((d) => {
+        const line = Math.max(0, d.line - 1);
+        const character = Math.max(0, d.column - 1);
+        return {
+            range: {
+                start: { line, character },
+                end: { line, character },
+            },
+            severity: toLspSeverity(d.severity),
+            code: d.ruleId,
+            source: "chant",
+            message: d.message,
+            data: d.fix ? { ruleId: d.ruleId, fix: d.fix } : { ruleId: d.ruleId },
+        };
+    });
+}

package/dist/cli/lsp/server.js

@@ -0,0 +1,329 @@
+import { computeCapabilities } from "./capabilities.js";
+import { toLspDiagnostics } from "./diagnostics.js";
+/**
+ * stdio LSP server using Content-Length framing.
+ * Delegates completions, hover, and code actions to lexicon plugins.
+ */
+export class LspServer {
+    constructor(plugins, options) {
+        this.openDocuments = new Map();
+        this.buffer = "";
+        /** Captured notifications for testing — only populated when captureNotifications is true */
+        this.sentNotifications = [];
+        this.captureNotifications = false;
+        this.plugins = plugins;
+        this.captureNotifications = options?.captureNotifications ?? false;
+    }
+    /**
+     * Start reading from stdin with Content-Length framing
+     */
+    async start() {
+        process.stdin.setEncoding("utf-8");
+        process.stdin.on("data", (chunk) => {
+            this.buffer += chunk;
+            this.processBuffer();
+        });
+    }
+    /**
+     * Process the incoming buffer, extracting complete messages
+     */
+    processBuffer() {
+        while (true) {
+            const headerEnd = this.buffer.indexOf("\r\n\r\n");
+            if (headerEnd === -1)
+                break;
+            const header = this.buffer.slice(0, headerEnd);
+            const match = header.match(/Content-Length:\s*(\d+)/i);
+            if (!match) {
+                // Skip malformed header
+                this.buffer = this.buffer.slice(headerEnd + 4);
+                continue;
+            }
+            const contentLength = parseInt(match[1], 10);
+            const messageStart = headerEnd + 4;
+            const messageEnd = messageStart + contentLength;
+            if (this.buffer.length < messageEnd)
+                break; // Wait for more data
+            const body = this.buffer.slice(messageStart, messageEnd);
+            this.buffer = this.buffer.slice(messageEnd);
+            try {
+                const message = JSON.parse(body);
+                if ("id" in message) {
+                    this.handleRequest(message);
+                }
+                else {
+                    this.handleNotification(message);
+                }
+            }
+            catch {
+                // Ignore malformed JSON
+            }
+        }
+    }
+    /**
+     * Send a request and return the response directly (for testing).
+     */
+    async sendRequest(method, params) {
+        try {
+            const result = await this.dispatch(method, params ?? {});
+            return { jsonrpc: "2.0", id: 0, result };
+        }
+        catch (error) {
+            return {
+                jsonrpc: "2.0",
+                id: 0,
+                error: {
+                    code: -32603,
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            };
+        }
+    }
+    /**
+     * Handle a JSON-RPC request (has id, expects response)
+     */
+    async handleRequest(request) {
+        try {
+            const result = await this.dispatch(request.method, request.params ?? {});
+            this.sendResponse({ jsonrpc: "2.0", id: request.id, result });
+        }
+        catch (error) {
+            this.sendResponse({
+                jsonrpc: "2.0",
+                id: request.id,
+                error: {
+                    code: -32603,
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    /**
+     * Handle a JSON-RPC notification (no id, no response).
+     * Public to allow direct testing without stdio.
+     */
+    handleNotification(notification) {
+        switch (notification.method) {
+            case "initialized":
+                // Client acknowledged initialization
+                break;
+            case "textDocument/didOpen": {
+                const params = notification.params;
+                this.openDocuments.set(params.textDocument.uri, params.textDocument.text);
+                this.publishDiagnostics(params.textDocument.uri, params.textDocument.text);
+                break;
+            }
+            case "textDocument/didChange": {
+                const params = notification.params;
+                // Full sync: take the last content change
+                const text = params.contentChanges[params.contentChanges.length - 1]?.text ?? "";
+                this.openDocuments.set(params.textDocument.uri, text);
+                this.publishDiagnostics(params.textDocument.uri, text);
+                break;
+            }
+            case "textDocument/didClose": {
+                const params = notification.params;
+                this.openDocuments.delete(params.textDocument.uri);
+                // Clear diagnostics for closed document
+                this.sendNotification("textDocument/publishDiagnostics", {
+                    uri: params.textDocument.uri,
+                    diagnostics: [],
+                });
+                break;
+            }
+        }
+    }
+    /**
+     * Dispatch request to appropriate handler
+     */
+    async dispatch(method, params) {
+        switch (method) {
+            case "initialize":
+                return this.handleInitialize();
+            case "textDocument/completion":
+                return this.handleCompletion(params);
+            case "textDocument/hover":
+                return this.handleHover(params);
+            case "textDocument/codeAction":
+                return this.handleCodeAction(params);
+            case "textDocument/diagnostic":
+                return this.handleDiagnostic(params);
+            case "shutdown":
+                return null;
+            default:
+                return null;
+        }
+    }
+    /**
+     * Handle initialize request
+     */
+    handleInitialize() {
+        return {
+            capabilities: computeCapabilities(this.plugins),
+            serverInfo: {
+                name: "chant",
+                version: "0.1.0",
+            },
+        };
+    }
+    /**
+     * Handle textDocument/completion
+     */
+    handleCompletion(params) {
+        const textDocument = params.textDocument;
+        const position = params.position;
+        const content = this.openDocuments.get(textDocument.uri) ?? "";
+        const lines = content.split("\n");
+        const line = lines[position.line] ?? "";
+        const linePrefix = line.slice(0, position.character);
+        // Extract word at cursor
+        const wordMatch = linePrefix.match(/(\w+)$/);
+        const wordAtCursor = wordMatch?.[1] ?? "";
+        const ctx = {
+            uri: textDocument.uri,
+            content,
+            position,
+            wordAtCursor,
+            linePrefix,
+        };
+        const items = [];
+        for (const plugin of this.plugins) {
+            if (plugin.completionProvider) {
+                items.push(...plugin.completionProvider(ctx));
+            }
+        }
+        return { isIncomplete: false, items };
+    }
+    /**
+     * Handle textDocument/hover
+     */
+    handleHover(params) {
+        const textDocument = params.textDocument;
+        const position = params.position;
+        const content = this.openDocuments.get(textDocument.uri) ?? "";
+        const lines = content.split("\n");
+        const lineText = lines[position.line] ?? "";
+        // Extract word at position
+        let start = position.character;
+        let end = position.character;
+        while (start > 0 && /\w/.test(lineText[start - 1]))
+            start--;
+        while (end < lineText.length && /\w/.test(lineText[end]))
+            end++;
+        const word = lineText.slice(start, end);
+        const ctx = {
+            uri: textDocument.uri,
+            content,
+            position,
+            word,
+            lineText,
+        };
+        // First plugin to return info wins
+        for (const plugin of this.plugins) {
+            if (plugin.hoverProvider) {
+                const info = plugin.hoverProvider(ctx);
+                if (info) {
+                    return {
+                        contents: { kind: "markdown", value: info.contents },
+                        range: info.range,
+                    };
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Handle textDocument/codeAction
+     */
+    handleCodeAction(params) {
+        const textDocument = params.textDocument;
+        const range = params.range;
+        const context = params.context;
+        const content = this.openDocuments.get(textDocument.uri) ?? "";
+        const ctx = {
+            uri: textDocument.uri,
+            content,
+            range,
+            diagnostics: (context?.diagnostics ?? []).map((d) => ({
+                range: d.range,
+                message: d.message,
+                ruleId: typeof d.code === "string" ? d.code : undefined,
+                severity: d.severity === 1 ? "error" : d.severity === 2 ? "warning" : "info",
+            })),
+        };
+        const actions = [];
+        for (const plugin of this.plugins) {
+            if (plugin.codeActionProvider) {
+                actions.push(...plugin.codeActionProvider(ctx));
+            }
+        }
+        return actions;
+    }
+    /**
+     * Handle textDocument/diagnostic (pull model)
+     */
+    async handleDiagnostic(params) {
+        const textDocument = params.textDocument;
+        const content = this.openDocuments.get(textDocument.uri) ?? "";
+        const diagnostics = await this.computeDiagnostics(textDocument.uri, content);
+        return { kind: "full", items: diagnostics };
+    }
+    /**
+     * Publish diagnostics for a document (push model)
+     */
+    async publishDiagnostics(uri, content) {
+        const diagnostics = await this.computeDiagnostics(uri, content);
+        this.sendNotification("textDocument/publishDiagnostics", {
+            uri,
+            diagnostics,
+        });
+    }
+    /**
+     * Run lint engine and convert to LSP diagnostics
+     */
+    async computeDiagnostics(uri, content) {
+        // Only lint .ts files
+        const filePath = uri.startsWith("file://") ? uri.slice(7) : uri;
+        if (!filePath.endsWith(".ts"))
+            return [];
+        try {
+            const { runLint } = await import("../../lint/engine.js");
+            const rules = [];
+            // chant #1106 — the same active plugins' registered intrinsics, so
+            // EVL001 answers exactly like `fold()` does for a registered,
+            // opted-in call instead of flagging every call as a violation.
+            const intrinsics = [];
+            for (const plugin of this.plugins) {
+                rules.push(...(plugin.lintRules?.() ?? []));
+                intrinsics.push(...(plugin.intrinsics?.() ?? []));
+            }
+            if (rules.length === 0)
+                return [];
+            const { diagnostics } = await runLint([filePath], rules, undefined, intrinsics);
+            return toLspDiagnostics(diagnostics);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Send a JSON-RPC response with Content-Length framing
+     */
+    sendResponse(response) {
+        const body = JSON.stringify(response);
+        const header = `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n`;
+        process.stdout.write(header + body);
+    }
+    /**
+     * Send a JSON-RPC notification with Content-Length framing
+     */
+    sendNotification(method, params) {
+        if (this.captureNotifications) {
+            this.sentNotifications.push({ method, params });
+            return;
+        }
+        const body = JSON.stringify({ jsonrpc: "2.0", method, params });
+        const header = `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n`;
+        process.stdout.write(header + body);
+    }
+}

package/dist/cli/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":";AAMA,OAAO,EAAkB,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AA2G9E;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU,CA4rBpD;AAm8BD;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAuBzE;AAID;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,EAAE,UAAU,EA2KvC,CAAC;AAqLF;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAuB5E"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":";AAKA,OAAO,EAAkB,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AA+L9E;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU,CA4rBpD;AAm8BD;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAuBzE;AAID;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,EAAE,UAAU,EA2KvC,CAAC;AAgMF;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAuB5E"}