@pugi/cli 0.1.0-beta.99 → 1.0.0-alpha.1

package/dist/core/ledger/results-tsv.js

@@ -1,142 +0,0 @@
-import { promises as fs } from 'node:fs';
-const HEADER = 'ts\trun_id\tscope\tkey\tvalue\tmodel\tprompt_hash\tnotes\n';
-const appendLocks = new Map();
-export class ResultsLedger {
-    path;
-    constructor(path) {
-        this.path = path;
-    }
-    async append(row) {
-        const previous = appendLocks.get(this.path) ?? Promise.resolve();
-        const next = previous
-            .catch(() => undefined)
-            .then(async () => {
-            if (await this.needsHeader()) {
-                await fs.appendFile(this.path, HEADER, 'utf8');
-            }
-            await fs.appendFile(this.path, `${this.formatRow(row)}\n`, 'utf8');
-        });
-        appendLocks.set(this.path, next);
-        try {
-            await next;
-        }
-        finally {
-            if (appendLocks.get(this.path) === next) {
-                appendLocks.delete(this.path);
-            }
-        }
-    }
-    async query(filter) {
-        const rows = await this.readRows();
-        return rows.filter((row) => {
-            return Object.entries(filter).every(([field, expected]) => {
-                if (expected === undefined) {
-                    return true;
-                }
-                const value = row[field];
-                return value !== undefined && String(value) === String(expected);
-            });
-        });
-    }
-    async aggregate(scope, key, op) {
-        const rows = await this.query({ scope, key });
-        if (op === 'count') {
-            return rows.length;
-        }
-        const values = rows
-            .map((row) => Number(row.value))
-            .filter((value) => Number.isFinite(value));
-        if (values.length === 0) {
-            return 0;
-        }
-        if (op === 'sum') {
-            return values.reduce((sum, value) => sum + value, 0);
-        }
-        if (op === 'avg') {
-            return values.reduce((sum, value) => sum + value, 0) / values.length;
-        }
-        if (op === 'min') {
-            return Math.min(...values);
-        }
-        return Math.max(...values);
-    }
-    async needsHeader() {
-        try {
-            const stat = await fs.stat(this.path);
-            return stat.size === 0;
-        }
-        catch (error) {
-            if (isNodeError(error) && error.code === 'ENOENT') {
-                return true;
-            }
-            throw error;
-        }
-    }
-    async readRows() {
-        let data;
-        try {
-            data = await fs.readFile(this.path, 'utf8');
-        }
-        catch (error) {
-            if (isNodeError(error) && error.code === 'ENOENT') {
-                return [];
-            }
-            throw error;
-        }
-        if (!data.endsWith('\n')) {
-            data = data.slice(0, data.lastIndexOf('\n') + 1);
-        }
-        const lines = data.split('\n').filter((line) => line.length > 0);
-        const dataLines = lines[0] === HEADER.trimEnd() ? lines.slice(1) : lines;
-        return dataLines.flatMap((line) => {
-            const cells = line.split('\t');
-            if (cells.length !== 8) {
-                return [];
-            }
-            const ts = cells[0];
-            const run_id = cells[1];
-            const scope = cells[2];
-            const key = cells[3];
-            const value = cells[4];
-            const model = cells[5];
-            const prompt_hash = cells[6];
-            const notes = cells[7];
-            if (!ts || !run_id || !scope || !key || value === undefined) {
-                return [];
-            }
-            return [
-                {
-                    ts,
-                    run_id,
-                    scope,
-                    key,
-                    value,
-                    ...(model ? { model } : {}),
-                    ...(prompt_hash ? { prompt_hash } : {}),
-                    ...(notes ? { notes } : {}),
-                },
-            ];
-        });
-    }
-    formatRow(row) {
-        return [
-            row.ts,
-            row.run_id,
-            row.scope,
-            row.key,
-            row.value,
-            row.model ?? '',
-            row.prompt_hash ?? '',
-            row.notes ?? '',
-        ]
-            .map((value) => cleanCell(value))
-            .join('\t');
-    }
-}
-function cleanCell(value) {
-    return String(value).replace(/\r?\n/g, ' ').replace(/\t/g, ' ');
-}
-function isNodeError(error) {
-    return error instanceof Error && 'code' in error;
-}
-//# sourceMappingURL=results-tsv.js.map

package/dist/core/log-discipline/stdout-redirect.js

@@ -1,51 +0,0 @@
-import { randomBytes } from 'node:crypto';
-import { join } from 'node:path';
-function stripQuotes(s) {
-    return s
-        .replace(/"(?:\\.|[^"\\])*"/g, '""')
-        .replace(/'(?:\\.|[^'\\])*'/g, "''");
-}
-function hasRedirect(stripped) {
-    const noLogical = stripped.replace(/\|\|/g, ' ').replace(/&&/g, ' ');
-    if (/>\s*\S/.test(noLogical))
-        return true;
-    if (/2>&1/.test(noLogical))
-        return true;
-    if (/\|\s*tee\b/.test(noLogical))
-        return true;
-    if (/\|/.test(noLogical))
-        return true;
-    return false;
-}
-function isCompound(stripped) {
-    return /&&|\|\||;|\|/.test(stripped);
-}
-function shellQuote(s) {
-    return `'${s.replace(/'/g, `'\\''`)}'`;
-}
-function genLogPath(logDir) {
-    const rand = randomBytes(6).toString('hex');
-    return join(logDir, `cmd-${rand}.log`);
-}
-export function redirectCommand(command, options) {
-    if (!options.workspaceRoot || typeof options.workspaceRoot !== 'string') {
-        throw new Error('redirectCommand: workspaceRoot is required');
-    }
-    const logDir = options.logDir ?? join(options.workspaceRoot, '.pugi', 'logs');
-    const logPath = genLogPath(logDir);
-    const trimmed = command.trim();
-    if (trimmed.length === 0) {
-        return { command: trimmed, logPath, alreadyRedirected: false };
-    }
-    const stripped = stripQuotes(trimmed);
-    const already = hasRedirect(stripped);
-    if (already && !options.forceRedirect) {
-        return { command, logPath, alreadyRedirected: true };
-    }
-    const compound = isCompound(stripped);
-    const transformed = compound
-        ? `sh -c ${shellQuote(trimmed)} > ${logPath} 2>&1`
-        : `${trimmed} > ${logPath} 2>&1`;
-    return { command: transformed, logPath, alreadyRedirected: already };
-}
-//# sourceMappingURL=stdout-redirect.js.map

package/dist/core/lsp/cache.js

@@ -1,105 +0,0 @@
-/**
- * Per-process LSP client cache — .
- *
- * The `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