@pugi/cli 0.1.0-beta.3 → 0.1.0-beta.31

package/dist/core/lsp/cache.js

@@ -0,0 +1,105 @@
+/**
+ * Per-process LSP client cache — Leak L15.
+ *
+ * The α7.7 `runtime/commands/lsp.ts` CLI surface spawns one LSP server
+ * per invocation and stops it at the end. That is correct for the
+ * one-shot `pugi lsp hover ...` shape but wrong for L15's
+ * post-edit auto-diagnostics: every successful `edit`/`write` would
+ * otherwise pay the ~2-3s cold-start of `typescript-language-server`,
+ * which is unusable inside an agent loop.
+ *
+ * This module owns a singleton map keyed by `LspLanguage` with lazy
+ * initialization (`getOrStart`). The first edit of a TS file in a
+ * session pays cold-start; every subsequent edit of any TS/TSX file
+ * in the same workspace reuses the warm client.
+ *
+ * Lifecycle:
+ *   - `getOrStart(lang, cwd)` — spawn if missing, return cached otherwise.
+ *   - `stopAll()` — graceful shutdown of every cached client. Called from
+ *     `runCli` exit so a Ctrl-C never leaves zombie LSP processes behind.
+ *   - `reset()` — test-only escape hatch, drops the cache without
+ *     touching child processes (specs inject stubs that own their own
+ *     lifecycle).
+ *
+ * Failure handling: a startup failure is NOT cached. The next call
+ * tries again. This keeps the cache from poisoning a session when the
+ * operator installs the missing LSP binary mid-session and re-edits.
+ *
+ * Brand voice: ASCII only, no emoji, no banned words.
+ */
+import { isLspLanguageDisabled, startLspClient, } from './client.js';
+const cache = new Map();
+/**
+ * Return a warm client for `lang`, starting one if needed. The
+ * workspace `cwd` is captured at cache-insert time; if a subsequent
+ * call asks for the same language with a different `cwd` we tear
+ * down the old client and start a fresh one. This handles the
+ * agent-worktree case where the same process hops between workspace
+ * roots inside one Node lifetime.
+ */
+export async function getOrStartLspClient(lang, opts) {
+    // β7 L9: respect the per-language disable toggle BEFORE we attempt to
+    // spawn. The check is cheap and keeps the disabled path from paying
+    // the `npx --yes` warmup cost on first use.
+    if (isLspLanguageDisabled(lang, opts.lspSettings)) {
+        return {
+            ok: false,
+            reason: 'lsp_disabled',
+            detail: `${lang} is disabled via .pugi/settings.json::lsp`,
+        };
+    }
+    const existing = cache.get(lang);
+    if (existing && existing.cwd === opts.cwd) {
+        return { ok: true, client: existing.client };
+    }
+    if (existing && existing.cwd !== opts.cwd) {
+        // Workspace switched — stop the old client and fall through to spawn.
+        try {
+            await existing.client.stop();
+        }
+        catch {
+            // best effort; stop() is idempotent + swallow-safe
+        }
+        cache.delete(lang);
+    }
+    const result = await startLspClient(lang, opts);
+    if (!result.ok) {
+        return { ok: false, reason: result.reason, detail: result.detail };
+    }
+    cache.set(lang, { client: result.value, cwd: opts.cwd });
+    return { ok: true, client: result.value };
+}
+/** Look up the cached client without starting one. Returns undefined when missing. */
+export function peekLspClient(lang) {
+    return cache.get(lang)?.client;
+}
+/** Snapshot of currently-cached languages — used by `pugi lsp status` debug output. */
+export function listCachedLanguages() {
+    return Array.from(cache.keys());
+}
+/**
+ * Stop every cached client and clear the cache. Called from `runCli`
+ * exit and from specs that own the lifecycle of their stub servers.
+ */
+export async function stopAllLspClients() {
+    const snapshot = Array.from(cache.values());
+    cache.clear();
+    await Promise.all(snapshot.map(async (entry) => {
+        try {
+            await entry.client.stop();
+        }
+        catch {
+            // best effort — shutting down anyway
+        }
+    }));
+}
+/**
+ * Test-only: drop the cache map WITHOUT calling stop on the children.
+ * Specs that inject stub servers manage the stub lifecycle themselves;
+ * this lets a spec swap a stub mid-test without the cache holding a
+ * stale reference to a torn-down process.
+ */
+export function __resetLspCacheForTests() {
+    cache.clear();
+}
+//# sourceMappingURL=cache.js.map

package/dist/core/lsp/client.js

@@ -62,7 +62,7 @@
  */
 import { spawn, spawnSync } from 'node:child_process';
 import { pathToFileURL } from 'node:url';
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { resolve, sep } from 'node:path';
 import { OperatorAbortedError } from '../../tools/file-tools.js';
 const LANGUAGE_SERVERS = {
@@ -130,6 +130,13 @@ export class LspClient {
             child.stderr.on('data', () => { });
         }
         child.on('exit', () => this.onExit());
+        // R1 fix (2026-05-26, PR #413 r1, P2 #11): mirror onExit for the
+        // 'error' event. A late-fired spawn error (EIO, ENOMEM, etc.) or
+        // any unhandled child-process error would otherwise leave
+        // in-flight pending requests dangling until their per-request
+        // timer fired, which can be up to `requestTimeoutMs` later.
+        // Failing fast here matches the exit-time semantics.
+        child.on('error', () => this.onExit());
     }
     /**
      * Send `shutdown` + `exit`, then SIGKILL after a 1s grace window so
@@ -253,6 +260,35 @@ export class LspClient {
                 detail: error instanceof Error ? error.message : String(error),
             };
         }
+        // R1 fix (2026-05-26, PR #413 r1, Fix 8): realpath containment.
+        // Without this gate, a workspace-local symlink (e.g. `alias` ->
+        // `/etc/passwd`) passed the lexical `absPath.startsWith(cwd)`
+        // check, then `readFileSync(absPath, 'utf8')` happily followed the
+        // symlink and shipped `/etc/passwd` into the LSP `textDocument/didOpen`
+        // payload. Parity with `applySecurityGate`'s symlink-escape rule:
+        // when the file exists, the realpath MUST stay inside the workspace
+        // realpath. Missing files (newly-typed paths the operator is
+        // querying) skip the check — there's no symlink target to escape.
+        if (existsSync(absPath)) {
+            try {
+                const realRoot = realpathSync.native(this.cwd);
+                const realTarget = realpathSync.native(absPath);
+                if (realTarget !== realRoot && !realTarget.startsWith(realRoot + sep)) {
+                    return {
+                        ok: false,
+                        reason: 'lsp_error',
+                        detail: `symlink escapes workspace: ${file} -> ${realTarget}`,
+                    };
+                }
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    reason: 'lsp_error',
+                    detail: `cannot realpath ${file}: ${error instanceof Error ? error.message : String(error)}`,
+                };
+            }
+        }
         const uri = pathToFileURL(absPath).toString();
         if (!this.openedFiles.has(uri)) {
             try {
@@ -349,8 +385,22 @@ export class LspClient {
             const headerText = this.buffer.subarray(0, headerEnd).toString('ascii');
             const lengthMatch = headerText.match(/Content-Length:\s*(\d+)/i);
             if (!lengthMatch || lengthMatch[1] === undefined) {
-                // Malformed header — drop the buffer and resync at the next message.
-                this.buffer = Buffer.alloc(0);
+                // R1 fix (2026-05-26, PR #413 r1, Fix 7): malformed header —
+                // instead of nuking the entire buffer (which would discard ANY
+                // subsequent valid messages already queued in `this.buffer`),
+                // scan forward for the next `Content-Length:` marker and resync
+                // from there. A misbehaving server that emits one bad header
+                // followed by a normal stream of responses must not freeze the
+                // client. When no recoverable next marker is in the buffer, we
+                // keep the buffer as-is and wait for more data — the broken
+                // bytes will be re-evaluated on the next chunk.
+                const nextHeaderIdx = this.buffer.indexOf(Buffer.from('Content-Length:'), 1);
+                if (nextHeaderIdx > 0) {
+                    this.buffer = this.buffer.subarray(nextHeaderIdx);
+                    continue;
+                }
+                // No next marker visible — wait for more data, do not nuke the
+                // buffer. A subsequent chunk may complete a valid header.
                 return;
             }
             const length = Number.parseInt(lengthMatch[1], 10);
@@ -415,14 +465,59 @@ export class LspClient {
         }
     }
 }
+/**
+ * Map a short LSP language slug to the settings.json key. β7 L9 — the
+ * settings schema spells out the full language name (`typescript`,
+ * `python`, ...) for human readability; the short slug (`ts`, `py`) is
+ * what every internal call site uses. Keep this map narrow and explicit.
+ */
+const SETTINGS_KEY_BY_LANG = {
+    ts: 'typescript',
+    js: 'javascript',
+    py: 'python',
+    go: 'go',
+    rust: 'rust',
+};
+/**
+ * Report whether the operator has explicitly disabled this language via
+ * `.pugi/settings.json::lsp.<language> = false`. Absent section or
+ * absent key means "enabled by default" — backwards-compatible with the
+ * α7.7 surface that ignored settings entirely. Returns true ONLY when
+ * the operator explicitly set the value to false.
+ */
+export function isLspLanguageDisabled(lang, lspSettings) {
+    if (!lspSettings)
+        return false;
+    const key = SETTINGS_KEY_BY_LANG[lang];
+    return lspSettings[key] === false;
+}
+/**
+ * Probe every registered language server. Operator-facing helper for
+ * `pugi lsp servers` — returns one row per language with the binary
+ * name, whether it was found on PATH, and whether the settings toggle
+ * has explicitly disabled it.
+ */
+export function inspectLspServers(lspSettings) {
+    const out = [];
+    for (const lang of Object.keys(LANGUAGE_SERVERS)) {
+        const server = LANGUAGE_SERVERS[lang];
+        out.push({
+            language: lang,
+            command: server.command + (server.args.length > 0 ? ` ${server.args.join(' ')}` : ''),
+            available: detectBinary(server.probe),
+            enabled: !isLspLanguageDisabled(lang, lspSettings),
+        });
+    }
+    return out;
+}
 /**
  * Start an LSP client for the given language. Returns either an `LspClient`
  * ready to use, or a structured failure (`lsp_unavailable`,
  * `language_unsupported`).
  *
- * The returned client requires `await client.initialize()` BEFORE any
- * operation. We do not inline the initialize into the spawn so test
- * harnesses can intercept the handshake and assert on its contents.
+ * β7 L9: respects `.pugi/settings.json::lsp.<language> = false` —
+ * a disabled language reports `lsp_disabled` so the caller surface can
+ * tell the operator the binary IS available but settings says no.
  */
 export async function startLspClient(lang, opts) {
     const server = opts.serverOverride ?? LANGUAGE_SERVERS[lang];
@@ -433,6 +528,14 @@ export async function startLspClient(lang, opts) {
             detail: `no LSP server registered for language: ${lang}`,
         };
     }
+    if (!opts.serverOverride && isLspLanguageDisabled(lang, opts.lspSettings)) {
+        return {
+            ok: false,
+            reason: 'lsp_disabled',
+            detail: `${lang} is disabled in .pugi/settings.json::lsp.${SETTINGS_KEY_BY_LANG[lang]}. ` +
+                `Remove the override (or set it to true) to enable.`,
+        };
+    }
     if (!opts.serverOverride) {
         const available = detectBinary(server.probe);
         if (!available) {
@@ -459,12 +562,51 @@ export async function startLspClient(lang, opts) {
             detail: `failed to spawn ${server.command}: ${error instanceof Error ? error.message : String(error)}`,
         };
     }
+    // `child_process.spawn` reports a missing binary asynchronously via
+    // the 'error' event, NOT via a synchronous throw — the synchronous
+    // spawn returns a ChildProcess object even when the binary does not
+    // exist. Attach an error listener immediately so the missing-binary
+    // case never becomes an uncaught exception. Wait one microtask tick
+    // for the event-loop to fire the 'error' event before we attempt
+    // the handshake; if the spawn failed, return early with
+    // `lsp_unavailable`.
+    let spawnError = null;
+    child.on('error', (err) => {
+        spawnError = err;
+    });
+    // Yield one tick so Node's spawn-error path lands before we
+    // proceed. The error event lives on the same nextTick queue as the
+    // initial spawn handshake, so a single setImmediate-equivalent
+    // delay is enough to observe it.
+    await new Promise((resolveFn) => {
+        setImmediate(resolveFn);
+    });
+    if (spawnError) {
+        try {
+            child.kill('SIGKILL');
+        }
+        catch {
+            // ignore — process never started
+        }
+        return {
+            ok: false,
+            reason: 'lsp_unavailable',
+            detail: `failed to spawn ${server.command}: ${spawnError.message}`,
+        };
+    }
     const client = new LspClient(child, server, opts);
     try {
         await initializeHandshake(client, opts.cwd);
     }
     catch (error) {
         await client.stop();
+        if (spawnError) {
+            return {
+                ok: false,
+                reason: 'lsp_unavailable',
+                detail: `failed to spawn ${server.command}: ${spawnError.message}`,
+            };
+        }
         return {
             ok: false,
             reason: 'lsp_error',
@@ -475,10 +617,11 @@ export async function startLspClient(lang, opts) {
 }
 async function initializeHandshake(client, cwd) {
     const rootUri = pathToFileURL(cwd).toString();
-    // Use the public sendRequest path via a method call. We piggyback on
-    // `LspClient`'s internal `sendRequest` by exposing a single test-grade
-    // surface (`__lspRaw__`); production callers never need this.
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // Reach the private send-request / send-notification surface through
+    // a typed accessor cast. The two methods are intentionally not part
+    // of the public class surface (callers should use `hover`/`definition`
+    // etc.), but the handshake is a single-shot bootstrap and exposing
+    // the raw methods would weaken the type story.
     const internal = client;
     await internal.sendRequest('initialize', {
         processId: process.pid,
@@ -520,27 +663,29 @@ function normalizeHover(raw) {
     const obj = raw;
     const range = parseRange(obj.range);
     const body = obj.contents;
-    if (typeof body === 'string') {
-        return { content: body, range, raw };
-    }
-    if (Array.isArray(body)) {
-        const parts = [];
-        for (const item of body) {
-            if (typeof item === 'string')
-                parts.push(item);
-            else if (item && typeof item === 'object' && 'value' in item) {
-                const value = item.value;
-                if (typeof value === 'string')
-                    parts.push(value);
+    const result = (() => {
+        if (typeof body === 'string')
+            return { content: body, raw, ...(range ? { range } : {}) };
+        if (Array.isArray(body)) {
+            const parts = [];
+            for (const item of body) {
+                if (typeof item === 'string')
+                    parts.push(item);
+                else if (item && typeof item === 'object' && 'value' in item) {
+                    const value = item.value;
+                    if (typeof value === 'string')
+                        parts.push(value);
+                }
             }
+            return { content: parts.join('\n'), raw, ...(range ? { range } : {}) };
         }
-        return { content: parts.join('\n'), range, raw };
-    }
-    if (body && typeof body === 'object' && 'value' in body) {
-        const value = body.value;
-        return { content: typeof value === 'string' ? value : '', range, raw };
-    }
-    return { content: '', range, raw };
+        if (body && typeof body === 'object' && 'value' in body) {
+            const value = body.value;
+            return { content: typeof value === 'string' ? value : '', raw, ...(range ? { range } : {}) };
+        }
+        return { content: '', raw, ...(range ? { range } : {}) };
+    })();
+    return result;
 }
 function normalizeLocations(raw, cwd) {
     if (!raw)

package/dist/core/lsp/language-detect.js

@@ -0,0 +1,66 @@
+/**
+ * Language-from-extension detection — Leak L15.
+ *
+ * Single source of truth for "given a file path, which `LspLanguage`
+ * slug do we route to". The α7.7 `runtime/commands/lsp.ts` shipped its
+ * own inline `inferLanguage` switch; L15 (post-edit auto-diagnostics)
+ * needs the same lookup from `core/engine/tool-bridge.ts`, so we lift
+ * the table into a dedicated module to avoid a second copy drifting
+ * out of sync.
+ *
+ * Returning `undefined` is the calling code's signal to silently skip
+ * LSP — an unsupported extension is NOT an error, it just means "no
+ * diagnostics for this file". The tool-bridge hook treats this as a
+ * no-op envelope tail.
+ *
+ * Adding a new language requires THREE coordinated changes:
+ *   1. Add the `LspLanguage` slug + server descriptor in `client.ts`.
+ *   2. Map its extensions here.
+ *   3. Add a `lsp-language-matrix` spec row exercising the new ext.
+ *
+ * Brand voice: ASCII only, no emoji, no banned words.
+ */
+import { extname } from 'node:path';
+/**
+ * Lower-case extension (including the dot) → LSP language slug.
+ * Mirror of the switch in `runtime/commands/lsp.ts::inferLanguage`.
+ * The table form lets tests assert coverage and lets new languages
+ * land with one edit instead of two.
+ */
+export const EXTENSION_TO_LANGUAGE = {
+    '.ts': 'ts',
+    '.tsx': 'ts',
+    '.mts': 'ts',
+    '.cts': 'ts',
+    '.js': 'js',
+    '.jsx': 'js',
+    '.mjs': 'js',
+    '.cjs': 'js',
+    '.py': 'py',
+    '.pyi': 'py',
+    '.go': 'go',
+    '.rs': 'rust',
+};
+/**
+ * Infer the `LspLanguage` for a workspace-relative or absolute path.
+ * Returns `undefined` for unmapped extensions — the caller decides
+ * whether that is silently skipped (post-edit hook) or surfaced as
+ * `language_unsupported` (`pugi lsp` CLI).
+ */
+export function languageForFile(file) {
+    const ext = extname(file).toLowerCase();
+    if (!ext)
+        return undefined;
+    return EXTENSION_TO_LANGUAGE[ext];
+}
+/**
+ * Return every extension currently mapped to the given language.
+ * Used by the matrix spec to assert coverage without re-typing the
+ * extension list.
+ */
+export function extensionsForLanguage(lang) {
+    return Object.entries(EXTENSION_TO_LANGUAGE)
+        .filter(([, value]) => value === lang)
+        .map(([ext]) => ext);
+}
+//# sourceMappingURL=language-detect.js.map

package/dist/core/lsp/post-edit-diagnostics.js

@@ -0,0 +1,171 @@
+/**
+ * Post-edit diagnostics — Leak L15.
+ *
+ * Claude Code's leak intel surfaced this pattern: after a `FileEdit` /
+ * `Write` tool call lands, an LSP diagnostic pass runs on the touched
+ * file and the result is appended to the tool envelope before the
+ * model sees it. The model then self-corrects in the same turn —
+ * "TS2304: Cannot find name 'undef'" comes back, the model fixes the
+ * typo in the next tool call, no operator round-trip needed.
+ *
+ * This module is the Pugi side of that pattern:
+ *
+ *   1. The tool-bridge calls `runPostEditDiagnostics(path, ctx)` after
+ *      a successful `edit` / `write` / `multi_edit`.
+ *   2. We infer the language from the extension (`language-detect`).
+ *      Unsupported extension → `{ skip: true }` and the bridge appends
+ *      nothing.
+ *   3. We borrow (or lazily start) the per-language cached client
+ *      from `cache.ts`. A spawn failure → `{ skip: true }` and the
+ *      envelope stays clean. Silence on failure is intentional: an
+ *      operator who has not installed `typescript-language-server`
+ *      should not see an LSP nag on every edit.
+ *   4. We pull diagnostics with a hard 5s ceiling. A timeout logs a
+ *      warning on stderr (gated on `PUGI_LSP_DEBUG=1`) and skips —
+ *      the envelope is never blocked on LSP.
+ *   5. We format the surviving diagnostics into a readable tail
+ *      mirroring the leak format:
+ *
+ *         LSP DIAGNOSTICS (typescript):
+ *           foo.ts:42:5 error TS2304: Cannot find name 'undef'.
+ *           foo.ts:51:1 warn  TS6133: 'unused' is declared.
+ *
+ * The bridge concatenates this tail onto its existing `wrote ...` /
+ * `edited ...` body with a single newline separator. When there are
+ * zero diagnostics we return `{ skip: true }` so the existing body
+ * is unchanged — the "no news is good news" path stays terse.
+ *
+ * Brand voice: ASCII only, no emoji, no banned words.
+ */
+import { isAbsolute, relative, resolve } from 'node:path';
+import { getOrStartLspClient } from './cache.js';
+import { languageForFile } from './language-detect.js';
+const DEFAULT_TIMEOUT_MS = 5_000;
+/**
+ * Hard cap on how many diagnostics we surface to the model. A file
+ * with 200 errors after a broken bulk edit would otherwise blow the
+ * context window; the model can re-run `pugi lsp diagnostics` if
+ * it needs the full list.
+ */
+const MAX_DIAGNOSTICS = 25;
+export async function runPostEditDiagnostics(filePath, opts) {
+    const lang = languageForFile(filePath);
+    if (!lang) {
+        return { skip: true, reason: 'unsupported_language' };
+    }
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const clientResult = await loadClient(lang, opts);
+    if (!clientResult.ok) {
+        return { skip: true, reason: mapStartFailure(clientResult.reason) };
+    }
+    // Run diagnostics with a hard timeout. The underlying LspClient has
+    // its own per-request timeout (5s default) but a slow handshake
+    // can blow past it; we belt-and-suspenders here so the agent loop
+    // never blocks on LSP.
+    const relPath = toWorkspaceRelative(filePath, opts.cwd);
+    const diagnosticsPromise = clientResult.client.diagnostics(relPath);
+    let timer;
+    const timeoutPromise = new Promise((resolveFn) => {
+        timer = setTimeout(() => resolveFn({ timedOut: true }), timeoutMs);
+        timer.unref();
+    });
+    const race = await Promise.race([
+        diagnosticsPromise.then((value) => ({ timedOut: false, value })),
+        timeoutPromise,
+    ]);
+    if (timer)
+        clearTimeout(timer);
+    if (race.timedOut) {
+        const writeFn = opts.debugWrite ?? ((line) => {
+            if (process.env.PUGI_LSP_DEBUG === '1')
+                process.stderr.write(`${line}\n`);
+        });
+        writeFn(`[pugi-lsp] post-edit diagnostics for ${relPath} timed out after ${timeoutMs}ms (lang=${lang})`);
+        return { skip: true, reason: 'timeout' };
+    }
+    const diag = race.value;
+    if (!diag.ok) {
+        return { skip: true, reason: 'lsp_error' };
+    }
+    if (diag.value.length === 0) {
+        return { skip: true, reason: 'no_diagnostics' };
+    }
+    const tail = formatDiagnosticsTail(relPath, lang, diag.value);
+    return { skip: false, tail, count: diag.value.length, language: lang };
+}
+async function loadClient(lang, opts) {
+    if (opts.clientLoader) {
+        return opts.clientLoader(lang);
+    }
+    const { cwd, timeoutMs, clientLoader: _ignoredA, debugWrite: _ignoredB, ...rest } = opts;
+    const result = await getOrStartLspClient(lang, { cwd, ...rest });
+    if (!result.ok) {
+        return { ok: false, reason: result.reason, detail: result.detail };
+    }
+    return { ok: true, client: result.client };
+}
+function mapStartFailure(reason) {
+    if (reason === 'lsp_unavailable' || reason === 'language_unsupported')
+        return 'lsp_unavailable';
+    if (reason === 'lsp_disabled')
+        return 'lsp_disabled';
+    return 'lsp_error';
+}
+/**
+ * Convert an absolute or workspace-relative path into the form the
+ * LSP client expects — same shape as `runtime/commands/lsp.ts` uses.
+ */
+function toWorkspaceRelative(filePath, cwd) {
+    if (!isAbsolute(filePath))
+        return filePath;
+    const rel = relative(cwd, resolve(cwd, filePath));
+    return rel || filePath;
+}
+/**
+ * Format diagnostics into the leak-shaped envelope tail. Pure function
+ * exported for unit tests to assert the line format independent of
+ * any LSP plumbing.
+ */
+export function formatDiagnosticsTail(relPath, lang, diagnostics) {
+    const visible = diagnostics.slice(0, MAX_DIAGNOSTICS);
+    const truncated = diagnostics.length > visible.length;
+    const lines = [`LSP DIAGNOSTICS (${LANGUAGE_LABELS[lang]}):`];
+    for (const diag of visible) {
+        const line = diag.range.start.line + 1; // LSP is zero-based; humans expect 1-based.
+        const col = diag.range.start.character + 1;
+        const severity = SEVERITY_LABELS[diag.severityLabel];
+        const code = diag.code !== undefined && diag.code !== '' ? ` ${diag.code}` : '';
+        const source = diag.source ? `${diag.source}` : '';
+        const head = source ? `${severity}${code} (${source}):` : `${severity}${code}:`;
+        lines.push(`  ${relPath}:${line}:${col} ${head} ${diag.message}`);
+    }
+    if (truncated) {
+        lines.push(`  ... ${diagnostics.length - visible.length} more diagnostic(s) — re-run pugi lsp diagnostics ${relPath} for the full list`);
+    }
+    return lines.join('\n');
+}
+const LANGUAGE_LABELS = {
+    ts: 'typescript',
+    js: 'javascript',
+    py: 'python',
+    go: 'go',
+    rust: 'rust',
+};
+/**
+ * Map LSP severity label → the short token the leak envelope uses.
+ * "warn" is shorter than "warning" and matches Claude Code's leak
+ * verbatim; the rest mirror LSP terminology.
+ */
+const SEVERITY_LABELS = {
+    error: 'error',
+    warning: 'warn ',
+    info: 'info ',
+    hint: 'hint ',
+};
+/** Test-only surface so specs can poke the pure helpers without LSP. */
+export const __test__ = {
+    formatDiagnosticsTail,
+    MAX_DIAGNOSTICS,
+    DEFAULT_TIMEOUT_MS,
+};
+//# sourceMappingURL=post-edit-diagnostics.js.map