@pugi/cli 0.1.0-beta.11 → 0.1.0-beta.13

package/dist/runtime/commands/lsp.js

@@ -25,16 +25,63 @@
  * Brand voice: ASCII only, no emoji, no banned words.
  */
 import { extname } from 'node:path';
-import { startLspClient } from '../../core/lsp/client.js';
+import { inspectLspServers, startLspClient } from '../../core/lsp/client.js';
+import { loadSettings } from '../../core/settings.js';
 export async function runLspCommand(args, opts) {
     const [op, file, ...rest] = args;
-    if (!op || !file) {
+    if (!op) {
         return usage();
     }
+    // β7 L9: introspection subcommand. `pugi lsp servers` reports the
+    // language matrix — binary-on-PATH + enabled-via-settings — so the
+    // operator can debug `lsp_unavailable` vs `lsp_disabled` without
+    // re-running an actual hover.
+    if (op === 'servers' || op === 'status') {
+        const settings = loadSettings(opts.cwd);
+        const lspSettings = settings.lsp;
+        const rows = inspectLspServers(lspSettings);
+        if (opts.json) {
+            return { ok: true, text: JSON.stringify(rows, null, 2), exitCode: 0 };
+        }
+        const lines = ['language\tcommand\tavailable\tenabled'];
+        for (const r of rows) {
+            lines.push(`${r.language}\t${r.command}\t${r.available ? 'yes' : 'no'}\t${r.enabled ? 'yes' : 'no'}`);
+        }
+        return { ok: true, text: lines.join('\n'), exitCode: 0 };
+    }
+    if (!file) {
+        return usage();
+    }
+    // β7 L6: `find_definition` convenience subcommand. Identical wire to
+    // `definition` but takes `<symbol>` instead of <line> <col>. We grep
+    // the workspace for the first hit on `<symbol>` (whole-word match) to
+    // recover a position, then route through LSP. Falls back cleanly when
+    // the symbol is not present in the file.
+    if (op === 'find_definition' || op === 'find-definition') {
+        const { lang: explicitLangFD, positional: positionalFD } = pullLangFlag(rest);
+        const symbol = positionalFD[0];
+        if (!symbol) {
+            return {
+                ok: false,
+                text: 'Usage: pugi lsp find_definition <file> <symbol> [--lang ts|js|py|go|rust]',
+                exitCode: 2,
+            };
+        }
+        const lang = explicitLangFD ?? inferLanguage(file);
+        if (!lang) {
+            return {
+                ok: false,
+                text: `cannot infer language from ${file}; pass --lang ts|js|py|go|rust. ` +
+                    `Supported extensions: .ts/.tsx, .js/.jsx/.mjs, .py, .go, .rs`,
+                exitCode: 2,
+            };
+        }
+        return await findDefinition(file, symbol, lang, opts);
+    }
     if (!['hover', 'definition', 'references', 'diagnostics'].includes(op)) {
         return {
             ok: false,
-            text: `unknown lsp operation: ${op}. Supported: hover, definition, references, diagnostics`,
+            text: `unknown lsp operation: ${op}. Supported: hover, definition, references, diagnostics, find_definition, servers`,
             exitCode: 2,
         };
     }
@@ -48,7 +95,11 @@ export async function runLspCommand(args, opts) {
             exitCode: 2,
         };
     }
-    const clientResult = await startLspClient(lang, { cwd: opts.cwd });
+    const settings = loadSettings(opts.cwd);
+    const clientResult = await startLspClient(lang, {
+        cwd: opts.cwd,
+        ...(settings.lsp ? { lspSettings: settings.lsp } : {}),
+    });
     if (!clientResult.ok) {
         return {
             ok: false,
@@ -152,10 +203,119 @@ function usage() {
             '  pugi lsp hover <file> <line> <col>\n' +
             '  pugi lsp definition <file> <line> <col>\n' +
             '  pugi lsp references <file> <line> <col>\n' +
-            '  pugi lsp diagnostics <file>',
+            '  pugi lsp diagnostics <file>\n' +
+            '  pugi lsp find_definition <file> <symbol>\n' +
+            '  pugi lsp servers',
         exitCode: 2,
     };
 }
+/**
+ * β7 L6: find_definition convenience.
+ *
+ * Reads the file, walks line-by-line looking for the first whole-word
+ * match of `<symbol>`, then runs `lsp definition` at that position.
+ * The result is a normal location array — empty when the LSP server
+ * can't resolve the symbol (typically because the workspace TS server
+ * hasn't indexed the import yet).
+ *
+ * "Whole-word match" uses the same identifier-boundary rules as Layer
+ * D's tokenizer: matches inside string literals / comments / partial
+ * identifiers are skipped. This keeps the result aligned with what the
+ * operator means by "where is foo defined" — not "any character sequence
+ * spelling foo".
+ */
+async function findDefinition(file, symbol, lang, opts) {
+    const { readFileSync, existsSync } = await import('node:fs');
+    const { resolve } = await import('node:path');
+    const abs = resolve(opts.cwd, file);
+    if (!existsSync(abs)) {
+        return { ok: false, text: `file not found: ${file}`, exitCode: 1 };
+    }
+    let body;
+    try {
+        body = readFileSync(abs, 'utf8');
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        return { ok: false, text: `cannot read ${file}: ${detail}`, exitCode: 1 };
+    }
+    const position = locateIdentifier(body, symbol);
+    if (!position) {
+        return {
+            ok: false,
+            text: `symbol '${symbol}' not found in ${file}`,
+            exitCode: 1,
+        };
+    }
+    const settings = loadSettings(opts.cwd);
+    const clientResult = await startLspClient(lang, {
+        cwd: opts.cwd,
+        ...(settings.lsp ? { lspSettings: settings.lsp } : {}),
+    });
+    if (!clientResult.ok) {
+        return { ok: false, text: `${clientResult.reason}: ${clientResult.detail}`, exitCode: 1 };
+    }
+    const client = clientResult.value;
+    try {
+        const result = await client.definition(file, position);
+        if (!result.ok) {
+            return { ok: false, text: `${result.reason}: ${result.detail}`, exitCode: 1 };
+        }
+        if (opts.json) {
+            return {
+                ok: true,
+                text: JSON.stringify({
+                    symbol,
+                    file,
+                    sourcePosition: { line: position.line + 1, character: position.character + 1 },
+                    definitions: result.value,
+                }, null, 2),
+                exitCode: 0,
+            };
+        }
+        if (result.value.length === 0) {
+            return { ok: true, text: `no definition for ${symbol}`, exitCode: 0 };
+        }
+        const lines = result.value.map((loc) => `${loc.path || loc.uri}:${loc.range.start.line + 1}:${loc.range.start.character + 1}`);
+        return { ok: true, text: lines.join('\n'), exitCode: 0 };
+    }
+    finally {
+        await client.stop();
+    }
+}
+/**
+ * Find the first whole-word occurrence of `symbol` in `body`. Returns
+ * the 0-based LSP position (line + character) or null when absent.
+ * Uses the same identifier boundary rule as Layer D's tokenizer to
+ * avoid matching inside larger identifiers.
+ */
+export function locateIdentifier(body, symbol) {
+    const lines = body.split('\n');
+    // Build the boundary regex once. We can't use `\b` directly because
+    // it treats `$` as a word boundary and TS/JS allow `$` in identifiers;
+    // implement the boundary check with a manual lookaround.
+    const isIdent = (ch) => {
+        if (!ch)
+            return false;
+        return /[A-Za-z0-9_$]/.test(ch);
+    };
+    for (let line = 0; line < lines.length; line += 1) {
+        const text = lines[line];
+        let from = 0;
+        while (from < text.length) {
+            const idx = text.indexOf(symbol, from);
+            if (idx === -1)
+                break;
+            const before = idx > 0 ? text[idx - 1] : undefined;
+            const after = idx + symbol.length < text.length ? text[idx + symbol.length] : undefined;
+            if (!isIdent(before) && !isIdent(after)) {
+                return { line, character: idx };
+            }
+            from = idx + symbol.length;
+        }
+    }
+    return null;
+}
 function pullLangFlag(args) {
     let lang;
     const positional = [];