@pugi/cli 0.1.0-beta.4 → 0.1.0-beta.41

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

@@ -1,29 +1,572 @@
 /**
- * Sentinel error type the dispatcher recognises. Distinct from the
- * generic `Error` so the dispatcher can render a friendly
- * "AST edits land in α6.6b" message rather than a stack trace.
+ * Layer D AST-aware diff applicator — β7 (2026-05-26).
  *
- * Caller convention: catch `LayerDDeferredError` explicitly; rethrow
- * any other error as before.
+ * Replaces the α6.6 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 α6.6+ 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 α6.6 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 (AST) edits land in α6.6b — attempted operation: ${operation}. ` +
-            'Use Layer A / B / C until the AST engine ships.');
+        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;
+}
 /**
- * Stub applicator. Always rejects with `LayerDDeferredError`. Returns
- * the standard `ApplyResult` shape on the (impossible) success path
- * so the dispatcher can treat all four layers uniformly once Layer D
- * lights up.
+ * 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.
  */
-// eslint-disable-next-line @typescript-eslint/require-await
-export async function applyLayerD(edit, _opts) {
-    throw new LayerDDeferredError(edit.operation);
+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 2026-05-26): 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