@pugi/cli 0.1.0-alpha.9 → 0.1.0-beta.10

package/dist/runtime/commands/lsp.js

@@ -0,0 +1,206 @@
+/**
+ * `pugi lsp <op> <file> [args...]` — α7.7 Phase 1.
+ *
+ * Direct LSP queries from the CLI surface. Operators use this for
+ * debugging and scripting; the agent loop reaches the same operations
+ * via the `lsp_hover` / `lsp_definition` / `lsp_references` /
+ * `lsp_diagnostics` tool wrappers in `src/tools/lsp-tools.ts`.
+ *
+ * Supported subcommands:
+ *
+ *   pugi lsp hover <file> <line> <col> [--lang ts|js|py|go|rust]
+ *   pugi lsp definition <file> <line> <col> [--lang ...]
+ *   pugi lsp references <file> <line> <col> [--lang ...]
+ *   pugi lsp diagnostics <file> [--lang ...]
+ *
+ * When `--lang` is omitted we infer from the file extension. An unknown
+ * extension surfaces `language_unsupported` so the operator can specify
+ * the language explicitly.
+ *
+ * Lifecycle: we spawn an LSP server per invocation and stop it before
+ * returning. This is slow on cold start (TS server takes ~2-3s the
+ * first time) but the single-shot scripting path doesn't need a
+ * persistent daemon. Future work (α7.7b) wires a per-REPL daemon.
+ *
+ * Brand voice: ASCII only, no emoji, no banned words.
+ */
+import { extname } from 'node:path';
+import { startLspClient } from '../../core/lsp/client.js';
+export async function runLspCommand(args, opts) {
+    const [op, file, ...rest] = args;
+    if (!op || !file) {
+        return usage();
+    }
+    if (!['hover', 'definition', 'references', 'diagnostics'].includes(op)) {
+        return {
+            ok: false,
+            text: `unknown lsp operation: ${op}. Supported: hover, definition, references, diagnostics`,
+            exitCode: 2,
+        };
+    }
+    const { lang: explicitLang, positional } = pullLangFlag(rest);
+    const lang = explicitLang ?? 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,
+        };
+    }
+    const clientResult = await startLspClient(lang, { cwd: opts.cwd });
+    if (!clientResult.ok) {
+        return {
+            ok: false,
+            text: `lsp_unavailable: ${clientResult.detail}`,
+            exitCode: 1,
+        };
+    }
+    const client = clientResult.value;
+    // R1 fix (2026-05-26, PR #413 r1, P2 #12): propagate SIGINT/SIGTERM
+    // to the LSP child process. Without this, ^C in the middle of a
+    // hung definition request would kill the CLI but leave the spawned
+    // language server orphaned (especially expensive for rust-analyzer
+    // / pyright which hold workspace indices in memory). We register
+    // listeners narrowly scoped to this single command invocation and
+    // tear them down in the `finally` block.
+    let interrupted = false;
+    const signalHandler = () => {
+        interrupted = true;
+        void client.stop();
+    };
+    process.once('SIGINT', signalHandler);
+    process.once('SIGTERM', signalHandler);
+    try {
+        if (op === 'diagnostics') {
+            const result = await client.diagnostics(file);
+            if (!result.ok) {
+                return { ok: false, text: `${result.reason}: ${result.detail}`, exitCode: 1 };
+            }
+            if (opts.json) {
+                return { ok: true, text: JSON.stringify(result.value, null, 2), exitCode: 0 };
+            }
+            if (result.value.length === 0) {
+                return { ok: true, text: `${file}: no diagnostics`, exitCode: 0 };
+            }
+            const lines = result.value.map((d) => `${d.severityLabel}\t${file}:${d.range.start.line + 1}:${d.range.start.character + 1}\t${d.message}`);
+            return { ok: true, text: lines.join('\n'), exitCode: 0 };
+        }
+        const line = Number.parseInt(positional[0] ?? '', 10);
+        const col = Number.parseInt(positional[1] ?? '', 10);
+        if (!Number.isFinite(line) || !Number.isFinite(col)) {
+            return {
+                ok: false,
+                text: `lsp ${op} requires <line> <col> arguments (1-based)`,
+                exitCode: 2,
+            };
+        }
+        // LSP positions are 0-based; we accept 1-based input from the CLI
+        // (matches every other editor convention) and convert here.
+        const pos = { line: Math.max(0, line - 1), character: Math.max(0, col - 1) };
+        if (op === 'hover') {
+            const result = await client.hover(file, pos);
+            if (!result.ok) {
+                return { ok: false, text: `${result.reason}: ${result.detail}`, exitCode: 1 };
+            }
+            if (opts.json) {
+                return { ok: true, text: JSON.stringify(result.value ?? null, null, 2), exitCode: 0 };
+            }
+            if (!result.value) {
+                return { ok: true, text: `${file}:${line}:${col}: no hover available`, exitCode: 0 };
+            }
+            return { ok: true, text: result.value.content, exitCode: 0 };
+        }
+        if (op === 'definition') {
+            const result = await client.definition(file, pos);
+            if (!result.ok) {
+                return { ok: false, text: `${result.reason}: ${result.detail}`, exitCode: 1 };
+            }
+            if (opts.json) {
+                return { ok: true, text: JSON.stringify(result.value, null, 2), 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') || 'no definition', exitCode: 0 };
+        }
+        // references
+        const result = await client.references(file, pos);
+        if (!result.ok) {
+            return { ok: false, text: `${result.reason}: ${result.detail}`, exitCode: 1 };
+        }
+        if (opts.json) {
+            return { ok: true, text: JSON.stringify(result.value, null, 2), 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') || 'no references', exitCode: 0 };
+    }
+    finally {
+        process.removeListener('SIGINT', signalHandler);
+        process.removeListener('SIGTERM', signalHandler);
+        await client.stop();
+        if (interrupted) {
+            // Propagate the interruption so the shell sees a sensible exit
+            // code on ^C rather than the last successful result code.
+            // 130 is the canonical "terminated by SIGINT" exit value.
+            return { ok: false, text: 'lsp aborted by signal', exitCode: 130 };
+        }
+    }
+}
+function usage() {
+    return {
+        ok: false,
+        text: 'Usage: pugi lsp <op> <file> [line] [col] [--lang ts|js|py|go|rust]\n' +
+            '  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>',
+        exitCode: 2,
+    };
+}
+function pullLangFlag(args) {
+    let lang;
+    const positional = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i] ?? '';
+        if (arg === '--lang') {
+            const value = args[i + 1];
+            if (isLspLanguage(value))
+                lang = value;
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith('--lang=')) {
+            const value = arg.slice('--lang='.length);
+            if (isLspLanguage(value))
+                lang = value;
+            continue;
+        }
+        positional.push(arg);
+    }
+    return { lang, positional };
+}
+function isLspLanguage(value) {
+    return value === 'ts' || value === 'js' || value === 'py' || value === 'go' || value === 'rust';
+}
+export function inferLanguage(file) {
+    const ext = extname(file).toLowerCase();
+    switch (ext) {
+        case '.ts':
+        case '.tsx':
+            return 'ts';
+        case '.js':
+        case '.jsx':
+        case '.mjs':
+        case '.cjs':
+            return 'js';
+        case '.py':
+        case '.pyi':
+            return 'py';
+        case '.go':
+            return 'go';
+        case '.rs':
+            return 'rust';
+        default:
+            return undefined;
+    }
+}
+//# sourceMappingURL=lsp.js.map

package/dist/runtime/commands/patch.js

@@ -0,0 +1,128 @@
+/**
+ * `pugi patch` — α7.7 Phase 1.
+ *
+ * Apply a unified-diff patch from stdin or a file. The dominant use is
+ * the `pugi patch < patch.diff` shell pattern that lets external tools
+ * (Codex, manual `git diff`) hand off changes through pugi's same
+ * security gate the layers use.
+ *
+ * Surface:
+ *
+ *   pugi patch                  # read patch from stdin
+ *   pugi patch <file.diff>      # read patch from file
+ *   pugi patch --dry-run        # run --check only, report
+ *   pugi patch --3way --base=<sha>  # enable git apply --3way fuzz
+ *
+ * Exit codes:
+ *
+ *   0  patch applied (or dry-run check passed)
+ *   1  patch rejected (any non-security reason)
+ *   2  usage error
+ *   3  security gate refused the patch (path traversal / protected file / symlink escape)
+ *
+ * Distinct exit codes let CI loops differentiate "operator typo" from
+ * "model produced a hostile patch" — the latter is a security event
+ * worth alerting on.
+ *
+ * Brand voice: ASCII only, no emoji, no banned words.
+ */
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { applyPatch } from '../../tools/apply-patch.js';
+import { FileReadCache } from '../../core/file-cache.js';
+import { openSession } from '../../core/session.js';
+import { loadSettings } from '../../core/settings.js';
+const SECURITY_REASONS = new Set(['path_outside_workspace', 'protected_file', 'symlink_escape']);
+export async function runPatchCommand(args, opts) {
+    const positional = [];
+    const applyOpts = {};
+    // Seed from caller-supplied options first; arg-flag parsing below
+    // overrides when present.
+    if (opts.dryRun)
+        applyOpts.dryRun = true;
+    if (opts.baseSha)
+        applyOpts.baseSha = opts.baseSha;
+    let threeWaySeen = false;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i] ?? '';
+        if (arg === '--dry-run')
+            applyOpts.dryRun = true;
+        else if (arg === '--3way') {
+            // honored only when --base is also supplied
+            threeWaySeen = true;
+        }
+        else if (arg === '--base') {
+            const next = args[i + 1];
+            if (next)
+                applyOpts.baseSha = next;
+            i += 1;
+        }
+        else if (arg.startsWith('--base=')) {
+            applyOpts.baseSha = arg.slice('--base='.length);
+        }
+        else if (arg === '--json') {
+            // already parsed by the outer CLI
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    // R1 fix (2026-05-26, PR #413 r1, P2 #14): `--3way` without `--base`
+    // is meaningless because `git apply --3way` falls back to the index,
+    // which a CLI-side `pugi patch` invocation does not have populated
+    // with the patch's pre-image. Warn the operator instead of dropping
+    // the flag silently.
+    if (threeWaySeen && !applyOpts.baseSha) {
+        const warn = opts.warn ?? ((m) => console.warn(m));
+        warn('warning: --3way ignored without --base=<sha>; pass --base or drop --3way');
+    }
+    let patch;
+    try {
+        patch = await readPatchSource(positional[0], opts);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return failure({ ok: false, filesChanged: [], reason: 'invalid_patch', detail: message }, opts.json, 2);
+    }
+    const ctx = {
+        root: opts.cwd,
+        settings: loadSettings(opts.cwd),
+        session: openSession(opts.cwd),
+        readCache: new FileReadCache(),
+    };
+    const result = applyPatch(ctx, patch, applyOpts);
+    if (!result.ok) {
+        const exitCode = result.reason && SECURITY_REASONS.has(result.reason) ? 3 : 1;
+        return failure(result, opts.json, exitCode);
+    }
+    const text = opts.json
+        ? JSON.stringify(result, null, 2)
+        : `applied ${result.filesChanged.length} files:\n  ${result.filesChanged.join('\n  ')}`;
+    return { ok: true, text, exitCode: 0, result };
+}
+function failure(result, json, exitCode) {
+    const text = json
+        ? JSON.stringify(result, null, 2)
+        : `patch refused: ${result.reason ?? 'unknown'}${result.detail ? `\n  ${result.detail}` : ''}`;
+    return { ok: false, text, exitCode, result };
+}
+async function readPatchSource(filePath, opts) {
+    if (filePath) {
+        const resolved = resolve(opts.cwd, filePath);
+        return readFileSync(resolved, 'utf8');
+    }
+    if (opts.stdinOverride !== undefined)
+        return opts.stdinOverride;
+    // Read all of stdin. The process pipe is the canonical CLI handoff
+    // for inbound diffs (e.g. `git diff origin/main | pugi patch`).
+    return new Promise((resolveFn, rejectFn) => {
+        let body = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => {
+            body += chunk;
+        });
+        process.stdin.on('end', () => resolveFn(body));
+        process.stdin.on('error', (error) => rejectFn(error));
+    });
+}
+//# sourceMappingURL=patch.js.map