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

package/dist/core/edits/layer-d-ast.js

@@ -1,572 +0,0 @@
-/**
- * Layer D AST-aware diff applicator — β7 .
- *
- * Replaces the stub. Implements structural edits that cannot be
- * expressed safely as text-level Layer A/B/C diffs:
- *
- *  - `rename_symbol`    — rename every reference to a symbol inside a
- *                          single file, respecting language identifier
- *                          boundaries. Cross-file rename is handled by
- *                          the engine loop dispatching one Layer D edit
- *                          per affected file (see multi_edit tool).
- *  - `add_import`       — add an `import`/`use`/`from` statement at
- *                          the canonical location for the file's
- *                          language. Idempotent: re-adding an existing
- *                          import is a no-op success.
- *  - `remove_import`    — remove an `import`/`use`/`from` statement
- *                          when present; no-op success when absent.
- *  - `extract_function` — currently surfaces `not_supported` (real
- *                          tree-sitter integration deferred to β8).
- *  - `inline_variable`  — same; deferred to β8.
- *
- * Why not tree-sitter (yet):
- *
- *  The + posture for `apps/pugi-cli` keeps the dep tree intentionally
- *  lean (zod + ink + react + undici + tar). Pulling
- *  `tree-sitter` + per-language grammars (5 native binding packages,
- *  each ~5-15 MiB compiled) would balloon install size from ~80 MiB to
- *  ~250 MiB and require native rebuild on every Node major bump. We
- *  ship the operations we can do CORRECTLY with a language-aware
- *  regex+lexer approach today (rename/add_import/remove_import on
- *  identifier boundaries — see `identifierBoundaryReplace` below), and
- *  keep the deferred operations behind a structured `not_supported`
- *  reason instead of a bogus tree-sitter dep.
- *
- *  The grammar of identifiers + import statements is small enough across
- *  TS/JS/Python/Go/Rust that the regex approach (with language-aware
- *  boundary characters) catches every realistic in-file rename target
- *  without false positives — string literals and comments are skipped
- *  by a tiny per-language tokenizer. The approach matches what most
- *  "find-and-replace symbol" IDEs do for the same operation when no
- *  LSP server is available.
- *
- * Security: every operation routes through `applySecurityGate`. Atomic
- * writes via `atomicWrite` (same pattern as Layer A).
- *
- * Spec source: `docs/research/2026-05-21-pugi-cli-architecture.md` §4.4
- * and `docs/research/2026-05-26-pugi-cli-consolidated-sprint-plan.md` β7.
- */
-import { existsSync, readFileSync, renameSync, writeFileSync, unlinkSync } from 'node:fs';
-import { extname } from 'node:path';
-import { applySecurityGate } from './security-gate.js';
-/**
- * Sentinel error type the dispatcher recognises. Kept for back-compat
- * with callers — never thrown by the new implementation; deferred
- * operations now surface as structured `not_supported` results.
- */
-export class LayerDDeferredError extends Error {
-    code = 'LAYER_D_DEFERRED';
-    operation;
-    constructor(operation) {
-        super(`Layer D operation ${operation} is not yet supported.`);
-        this.name = 'LayerDDeferredError';
-        this.operation = operation;
-    }
-}
-export function detectLanguage(file) {
-    const ext = extname(file).toLowerCase();
-    if (ext === '.ts' || ext === '.tsx')
-        return 'ts';
-    if (ext === '.js' || ext === '.jsx' || ext === '.mjs' || ext === '.cjs')
-        return 'js';
-    if (ext === '.py' || ext === '.pyi')
-        return 'py';
-    if (ext === '.go')
-        return 'go';
-    if (ext === '.rs')
-        return 'rust';
-    return 'other';
-}
-/**
- * Apply a Layer D structural edit. Returns the standard `ApplyResult`
- * shape so the dispatcher can treat all four layers uniformly.
- */
-export async function applyLayerD(edit, opts) {
-    // SECURITY GATE — fail-fast before ANY filesystem read/write. Same
-    // chokepoint Layer A/B/C goes through.
-    let gateResult;
-    try {
-        gateResult = applySecurityGate(edit.file, { cwd: opts.cwd, toolName: 'layer-c' });
-    }
-    catch (error) {
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: 'write_error',
-            absPath: edit.file,
-            detail: error instanceof Error ? error.message : String(error),
-        };
-    }
-    if (!gateResult.ok) {
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: gateResult.reason,
-            absPath: edit.file,
-            detail: gateResult.detail,
-        };
-    }
-    const absPath = gateResult.absPath;
-    if (!existsSync(absPath)) {
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: 'file_missing',
-            absPath,
-            detail: `file does not exist: ${edit.file}`,
-        };
-    }
-    let body;
-    try {
-        body = readFileSync(absPath, 'utf8');
-    }
-    catch (error) {
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: 'write_error',
-            absPath,
-            detail: error instanceof Error ? error.message : String(error),
-        };
-    }
-    const lang = detectLanguage(edit.file);
-    switch (edit.operation) {
-        case 'rename_symbol':
-            return await renameSymbol(edit, body, absPath, lang, opts);
-        case 'add_import':
-            return await addImport(edit, body, absPath, lang, opts);
-        case 'remove_import':
-            return await removeImport(edit, body, absPath, lang, opts);
-        case 'extract_function':
-        case 'inline_variable':
-            return {
-                ok: false,
-                bytesWritten: 0,
-                reason: 'write_error',
-                absPath,
-                detail: `Layer D operation ${edit.operation} is not yet supported. ` +
-                    `Use Layer A/B/C for the equivalent text edit, or wait for the ` +
-                    `β8 tree-sitter integration.`,
-            };
-    }
-}
-/* ------------------------------------------------------------------ */
-/* rename_symbol                                                     */
-/* ------------------------------------------------------------------ */
-async function renameSymbol(edit, body, absPath, lang, opts) {
-    const params = parseRenameParams(edit.params);
-    if (!params) {
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: 'write_error',
-            absPath,
-            detail: 'rename_symbol: params must be { from: string, to: string }',
-        };
-    }
-    if (!isValidIdentifier(params.from, lang) || !isValidIdentifier(params.to, lang)) {
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: 'write_error',
-            absPath,
-            detail: `rename_symbol: identifier validation failed for language ${lang}. ` +
-                `Both 'from' and 'to' must be valid identifiers.`,
-        };
-    }
-    if (params.from === params.to) {
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: 'identical_replacement',
-            absPath,
-            detail: 'rename_symbol: from and to are identical',
-        };
-    }
-    const { result, count } = identifierBoundaryReplace(body, params.from, params.to, lang);
-    if (count === 0) {
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: 'no_match',
-            matchCount: 0,
-            absPath,
-            detail: `rename_symbol: no references to '${params.from}' found in ${edit.file}`,
-        };
-    }
-    if (opts.dryRun) {
-        return { ok: true, bytesWritten: 0, matchCount: count, absPath };
-    }
-    try {
-        atomicWrite(absPath, result);
-    }
-    catch (error) {
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: 'write_error',
-            absPath,
-            detail: error instanceof Error ? error.message : String(error),
-        };
-    }
-    return {
-        ok: true,
-        bytesWritten: Buffer.byteLength(result, 'utf8'),
-        matchCount: count,
-        absPath,
-    };
-}
-function parseRenameParams(params) {
-    const from = params['from'];
-    const to = params['to'];
-    if (typeof from !== 'string' || typeof to !== 'string')
-        return null;
-    if (from.length === 0 || to.length === 0)
-        return null;
-    return { from, to };
-}
-/**
- * Replace every standalone identifier occurrence of `from` with `to`.
- * Identifier boundaries are language-aware: in Python `foo.bar` and
- * `foo_bar` are distinct identifiers; in Rust `foo::bar` likewise.
- * Tokens inside string literals and comments are skipped.
- *
- * Returns both the rewritten body and the replacement count so the
- * dispatcher can report `matchCount`.
- */
-export function identifierBoundaryReplace(body, from, to, lang) {
-    const tokens = tokenize(body, lang);
-    const parts = [];
-    let count = 0;
-    for (const tok of tokens) {
-        if (tok.kind === 'ident' && tok.text === from) {
-            parts.push(to);
-            count += 1;
-        }
-        else {
-            parts.push(tok.text);
-        }
-    }
-    return { result: parts.join(''), count };
-}
-/* ------------------------------------------------------------------ */
-/* add_import / remove_import                                        */
-/* ------------------------------------------------------------------ */
-async function addImport(edit, body, absPath, lang, opts) {
-    const statement = parseImportStatement(edit.params);
-    if (statement === null) {
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: 'write_error',
-            absPath,
-            detail: 'add_import: params must be { statement: string } (single-line)',
-        };
-    }
-    // Idempotency — a verbatim line match counts as already-applied.
-    const lines = body.split('\n');
-    if (lines.some((line) => line === statement)) {
-        if (opts.dryRun) {
-            return { ok: true, bytesWritten: 0, absPath, matchCount: 1 };
-        }
-        return { ok: true, bytesWritten: 0, absPath, matchCount: 1 };
-    }
-    const insertAt = findImportInsertIndex(lines, lang);
-    const next = [...lines.slice(0, insertAt), statement, ...lines.slice(insertAt)];
-    const result = next.join('\n');
-    if (opts.dryRun) {
-        return { ok: true, bytesWritten: 0, absPath, matchCount: 1 };
-    }
-    try {
-        atomicWrite(absPath, result);
-    }
-    catch (error) {
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: 'write_error',
-            absPath,
-            detail: error instanceof Error ? error.message : String(error),
-        };
-    }
-    return {
-        ok: true,
-        bytesWritten: Buffer.byteLength(result, 'utf8'),
-        absPath,
-        matchCount: 1,
-    };
-}
-async function removeImport(edit, body, absPath, _lang, opts) {
-    const statement = parseImportStatement(edit.params);
-    if (statement === null) {
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: 'write_error',
-            absPath,
-            detail: 'remove_import: params must be { statement: string } (single-line)',
-        };
-    }
-    const lines = body.split('\n');
-    const filtered = lines.filter((line) => line !== statement);
-    if (filtered.length === lines.length) {
-        // No-op success — idempotent removal.
-        return { ok: true, bytesWritten: 0, absPath, matchCount: 0 };
-    }
-    const result = filtered.join('\n');
-    if (opts.dryRun) {
-        return {
-            ok: true,
-            bytesWritten: 0,
-            absPath,
-            matchCount: lines.length - filtered.length,
-        };
-    }
-    try {
-        atomicWrite(absPath, result);
-    }
-    catch (error) {
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: 'write_error',
-            absPath,
-            detail: error instanceof Error ? error.message : String(error),
-        };
-    }
-    return {
-        ok: true,
-        bytesWritten: Buffer.byteLength(result, 'utf8'),
-        absPath,
-        matchCount: lines.length - filtered.length,
-    };
-}
-function parseImportStatement(params) {
-    const statement = params['statement'];
-    if (typeof statement !== 'string')
-        return null;
-    if (statement.length === 0)
-        return null;
-    // Single-line invariant: imports SHOULD fit one line. Multi-line
-    // import payloads are out of scope (use Layer A/B with explicit
-    // anchors instead).
-    if (statement.includes('\n'))
-        return null;
-    return statement;
-}
-/**
- * Pick the line index at which a new import should land. The heuristic
- * is conservative: after every leading shebang / module-doc comment /
- * existing import line, before the first non-import non-comment line.
- *
- * Per-language nuance is intentionally light — every supported language
- * accepts an import anywhere at file scope; we aim for "next to the
- * other imports" which is what every formatter expects.
- */
-export function findImportInsertIndex(lines, _lang) {
-    // Skip leading shebang.
-    let i = 0;
-    if (i < lines.length && lines[i].startsWith('#!'))
-        i += 1;
-    // Skip leading single-line comments / blank lines / module docstring
-    // openers. Conservative — never crosses an `import` block boundary
-    // because the import check below catches them.
-    while (i < lines.length) {
-        const line = lines[i];
-        const trimmed = line.trim();
-        if (trimmed === '') {
-            i += 1;
-            continue;
-        }
-        if (isCommentLine(trimmed)) {
-            i += 1;
-            continue;
-        }
-        break;
-    }
-    // Walk past existing import block. We stop at the first non-import
-    // non-comment line so the new statement lands tail-of-imports.
-    while (i < lines.length) {
-        const line = lines[i];
-        const trimmed = line.trim();
-        if (trimmed === '' || isCommentLine(trimmed) || isImportLine(trimmed)) {
-            i += 1;
-            continue;
-        }
-        break;
-    }
-    // Trim trailing blank lines from the insertion index so the new
-    // import lands directly under the existing imports rather than after
-    // a stray gap.
-    while (i > 0 && lines[i - 1].trim() === '')
-        i -= 1;
-    return i;
-}
-function isCommentLine(trimmed) {
-    return (trimmed.startsWith('//') ||
-        trimmed.startsWith('#') ||
-        trimmed.startsWith('/*') ||
-        trimmed.startsWith('*') ||
-        trimmed.startsWith('"""') ||
-        trimmed.startsWith("'''"));
-}
-function isImportLine(trimmed) {
-    return (trimmed.startsWith('import ') ||
-        trimmed.startsWith('from ') ||
-        trimmed.startsWith('use ') ||
-        trimmed.startsWith('extern crate ') ||
-        trimmed.startsWith('const ') && trimmed.includes('require(') ||
-        trimmed.startsWith('require ') ||
-        trimmed.startsWith('package '));
-}
-/**
- * Tiny tokenizer that splits a source body into identifier tokens vs.
- * everything else. Skips string-literal interiors and comments so the
- * rename pass never rewrites a string mention of the symbol.
- *
- * Per-language config:
- *  - line comment prefix
- *  - block comment delimiters
- *  - string literal openers (with backslash-escape awareness)
- *  - triple-quoted strings (Python)
- *  - identifier character set
- *
- * The tokenizer is character-stream linear; complexity O(n).
- */
-export function tokenize(src, lang) {
-    const out = [];
-    let buf = '';
-    let i = 0;
-    const flushOther = () => {
-        if (buf.length > 0) {
-            out.push({ kind: 'other', text: buf });
-            buf = '';
-        }
-    };
-    const lineComment = lang === 'py' ? '#' : '//';
-    const tripleQuote = lang === 'py';
-    while (i < src.length) {
-        const ch = src[i];
-        const next = src[i + 1] ?? '';
-        // Line comment.
-        if (ch === lineComment[0] && (lineComment.length === 1 || next === lineComment[1])) {
-            flushOther();
-            const start = i;
-            while (i < src.length && src[i] !== '\n')
-                i += 1;
-            out.push({ kind: 'other', text: src.slice(start, i) });
-            continue;
-        }
-        // C-style block comment (TS/JS/Go/Rust). Python uses """ instead.
-        if (lang !== 'py' && ch === '/' && next === '*') {
-            flushOther();
-            const start = i;
-            i += 2;
-            while (i < src.length - 1 && !(src[i] === '*' && src[i + 1] === '/'))
-                i += 1;
-            i = Math.min(i + 2, src.length);
-            out.push({ kind: 'other', text: src.slice(start, i) });
-            continue;
-        }
-        // Triple-quoted string (Python).
-        if (tripleQuote && (ch === '"' || ch === "'") && next === ch && src[i + 2] === ch) {
-            flushOther();
-            const quote = ch;
-            const start = i;
-            i += 3;
-            while (i < src.length - 2 &&
-                !(src[i] === quote && src[i + 1] === quote && src[i + 2] === quote)) {
-                i += 1;
-            }
-            i = Math.min(i + 3, src.length);
-            out.push({ kind: 'other', text: src.slice(start, i) });
-            continue;
-        }
-        // Regular string literal.
-        if (ch === '"' || ch === "'" || (lang !== 'py' && ch === '`')) {
-            flushOther();
-            const quote = ch;
-            const start = i;
-            i += 1;
-            while (i < src.length) {
-                if (src[i] === '\\') {
-                    i += 2;
-                    continue;
-                }
-                if (src[i] === quote) {
-                    i += 1;
-                    break;
-                }
-                i += 1;
-            }
-            out.push({ kind: 'other', text: src.slice(start, i) });
-            continue;
-        }
-        // Identifier — sequence of identifier characters.
-        if (isIdentStart(ch)) {
-            flushOther();
-            const start = i;
-            while (i < src.length && isIdentCont(src[i]))
-                i += 1;
-            out.push({ kind: 'ident', text: src.slice(start, i) });
-            continue;
-        }
-        buf += ch;
-        i += 1;
-    }
-    flushOther();
-    return out;
-}
-function isIdentStart(ch) {
-    return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch === '_' || ch === '$';
-}
-function isIdentCont(ch) {
-    return isIdentStart(ch) || (ch >= '0' && ch <= '9');
-}
-export function isValidIdentifier(name, lang) {
-    if (name.length === 0)
-        return false;
-    if (!isIdentStart(name[0]))
-        return false;
-    for (let i = 1; i < name.length; i += 1) {
-        if (!isIdentCont(name[i]))
-            return false;
-    }
-    // Per-language reserved-word check is intentionally light — the dispatcher
-    // is the trust boundary; the operator (or model) supplies the new name
-    // and is responsible for it not clashing with a keyword. Catching the
-    // obvious cases here would only mask a bigger upstream bug.
-    // R7 P2 (Codex): a future refinement could load a per-language
-    // reserved-word list from `framework_*` RAG; tracked under β8.
-    return name.length <= 128;
-}
-/**
- * Atomic write helper — mirrors Layer A's pattern (writeFileSync to
- * tmp + rename). See `layer-a-apply.ts::atomicWrite` for the rationale.
- */
-function atomicWrite(absPath, contents) {
-    const suffix = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    const tmp = `${absPath}.pugi-tmp-${suffix}`;
-    try {
-        writeFileSync(tmp, contents, { encoding: 'utf8', mode: 0o600 });
-        renameSync(tmp, absPath);
-    }
-    catch (error) {
-        try {
-            unlinkSync(tmp);
-        }
-        catch {
-            // tmp file may not exist if writeFileSync itself failed.
-        }
-        throw error;
-    }
-}
-/** Test-only surface for the spec suite. */
-export const __test__ = {
-    tokenize,
-    identifierBoundaryReplace,
-    findImportInsertIndex,
-    isValidIdentifier,
-    detectLanguage,
-};
-//# sourceMappingURL=layer-d-ast.js.map