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

package/dist/core/edits/layer-b-apply.js

@@ -1,211 +0,0 @@
-/**
- * Layer B diff applicator — diff escalation Phase 1.
- *
- * Layer B is the multi-edit primitive: an ordered list of
- * `{oldString, newString}` blocks against a single file, applied
- * ALL-OR-NOTHING. Each block must satisfy the same uniqueness
- * invariant as Layer A, but evaluated against the WORKING buffer
- * after the prior blocks land — not the original disk contents. This
- * lets the model emit edits like "rename `foo` to `bar`, then add a
- * call to `bar(42)`" without the second edit failing because `foo`
- * no longer exists.
- *
- * Atomicity story:
- *
- *  1. We mutate a single in-memory string buffer.
- *  2. Every block runs through `applyOneToBuffer` and either advances
- *     the buffer or returns a structured failure.
- *  3. On ANY block failure we discard the buffer and write nothing.
- *     The on-disk file remains exactly as it was on entry.
- *  4. On total success we hand the final buffer to the same atomic
- *     tmp+rename writer Layer A uses, so a crash mid-write can never
- *     leave a partially-edited file.
- *
- * Roll-back is therefore in-memory — no need to track per-block undo
- * because nothing touched the disk until the final write.
- */
-import { existsSync, readFileSync, renameSync, writeFileSync, unlinkSync } from 'node:fs';
-import { countOccurrences, } from './layer-a-apply.js';
-import { applySecurityGate } from './security-gate.js';
-export async function applyLayerB(batch, opts) {
-    // SECURITY GATE — see security-gate.ts. Identical responsibilities
-    // to Layer A: workspace path scoping, protected-basename deny,
-    // symlink-escape re-check. Runs BEFORE the empty-batch fast-path so
-    // a maliciously empty batch targeting `.env` still surfaces the
-    // protected-file rejection rather than the no-edits one.
-    let gateResult;
-    try {
-        gateResult = applySecurityGate(batch.file, { cwd: opts.cwd, toolName: 'layer-b' });
-    }
-    catch (error) {
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: 'write_error',
-            absPath: batch.file,
-            detail: error instanceof Error ? error.message : String(error),
-            appliedCount: 0,
-        };
-    }
-    if (!gateResult.ok) {
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: gateResult.reason,
-            absPath: batch.file,
-            detail: gateResult.detail,
-            appliedCount: 0,
-        };
-    }
-    const absPath = gateResult.absPath;
-    if (batch.edits.length === 0) {
-        // An empty edit array is almost always a bug in the marker parser
-        // or the model prompt. Fail loud rather than no-op success.
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: 'no_match',
-            absPath,
-            detail: 'Layer B batch contains zero sub-edits',
-            appliedCount: 0,
-        };
-    }
-    if (!existsSync(absPath)) {
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: 'file_missing',
-            absPath,
-            detail: `file does not exist: ${batch.file}`,
-            appliedCount: 0,
-        };
-    }
-    const original = readFileSync(absPath, 'utf8');
-    let buffer = original;
-    let appliedCount = 0;
-    for (let i = 0; i < batch.edits.length; i += 1) {
-        const sub = batch.edits[i];
-        if (!sub)
-            continue;
-        const stepResult = applyOneToBuffer(buffer, sub);
-        if (!stepResult.ok) {
-            return {
-                ok: false,
-                bytesWritten: 0,
-                reason: stepResult.reason,
-                absPath,
-                matchCount: stepResult.matchCount,
-                detail: `Layer B aborted at sub-edit ${i}: ${stepResult.detail}`,
-                appliedCount,
-                subFailures: [
-                    {
-                        index: i,
-                        reason: stepResult.reason,
-                        matchCount: stepResult.matchCount,
-                        detail: stepResult.detail,
-                    },
-                ],
-            };
-        }
-        buffer = stepResult.buffer;
-        appliedCount += 1;
-    }
-    // No-op detection: if every sub-edit was an identical-replacement,
-    // `appliedCount` would be 0 above because applyOneToBuffer rejects
-    // those. A zero-byte diff with appliedCount === batch.edits.length
-    // is technically possible if the edits cancel each other out; we
-    // accept that quietly because the model presumably knows.
-    if (buffer === original) {
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: 'identical_replacement',
-            absPath,
-            detail: 'Layer B batch produced no net change to the file',
-            appliedCount,
-        };
-    }
-    if (opts.dryRun) {
-        return {
-            ok: true,
-            bytesWritten: 0,
-            absPath,
-            matchCount: appliedCount,
-            appliedCount,
-        };
-    }
-    try {
-        atomicWrite(absPath, buffer);
-    }
-    catch (error) {
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: 'write_error',
-            absPath,
-            detail: error instanceof Error ? error.message : String(error),
-            appliedCount,
-        };
-    }
-    return {
-        ok: true,
-        bytesWritten: Buffer.byteLength(buffer, 'utf8'),
-        absPath,
-        matchCount: appliedCount,
-        appliedCount,
-    };
-}
-function applyOneToBuffer(buffer, sub) {
-    if (sub.oldString === sub.newString) {
-        return {
-            ok: false,
-            reason: 'identical_replacement',
-            detail: 'oldString and newString are identical',
-        };
-    }
-    const count = countOccurrences(buffer, sub.oldString);
-    if (count === 0) {
-        return {
-            ok: false,
-            reason: 'no_match',
-            matchCount: 0,
-            detail: 'oldString not found in current buffer',
-        };
-    }
-    if (count > 1) {
-        return {
-            ok: false,
-            reason: 'ambiguous_match',
-            matchCount: count,
-            detail: `oldString matches ${count} times in current buffer`,
-        };
-    }
-    const idx = buffer.indexOf(sub.oldString);
-    const next = buffer.slice(0, idx) + sub.newString + buffer.slice(idx + sub.oldString.length);
-    return { ok: true, buffer: next };
-}
-/**
- * Atomic write helper — duplicated from `layer-a-apply.ts` (not exported
- * to keep the dependency direction one-way: A is the primitive, B
- * happens to reuse the same disk-write pattern but is otherwise
- * independent). Both helpers are intentionally small enough that
- * duplication is cheaper than dragging in a shared util module.
- */
-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 {
-            // ignore — tmp may not exist yet.
-        }
-        throw error;
-    }
-}
-//# sourceMappingURL=layer-b-apply.js.map

package/dist/core/edits/layer-c-apply.js

@@ -1,160 +0,0 @@
-/**
- * Layer C diff applicator — diff escalation Phase 1.
- *
- * Layer C is the full-file rewrite escape hatch. The model emits the
- * complete new file contents plus a sha256 of the file as it was when
- * the model READ it. We compute the current sha256 of the on-disk
- * file, compare, and either:
- *
- *  - Match — atomically write the new contents.
- *  - Mismatch — refuse with `base_sha_mismatch`. The model must
- *    re-read the file and resubmit; the disk version changed between
- *    read and write (filewatcher event, parallel edit, human typing).
- *
- * This is the "I rewrote the entire file" path. It is the heaviest
- * Layer because the wire payload is the full file body, but it is also
- * the safest for sweeping refactors that touch most lines — Layer A
- * would emit dozens of fragile blocks and Layer B's atomicity goes
- * out the window past ~10 blocks.
- *
- * The sha256 gate is the load-bearing safety. Without it, Layer C
- * silently overwrites concurrent edits; with it, the operator
- * (and Pugi) sees a clean `mismatch` event and can resolve manually.
- */
-import { createHash } from 'node:crypto';
-import { existsSync, readFileSync, renameSync, writeFileSync, unlinkSync } from 'node:fs';
-import { applySecurityGate } from './security-gate.js';
-export async function applyLayerC(edit, opts) {
-    // SECURITY GATE — see security-gate.ts. Layer C is the most
-    // dangerous layer (full-file rewrite) so the gate runs FIRST, ahead
-    // of the baseSha check. A missing baseSha on an attempted `.env`
-    // rewrite should surface as `protected_file`, not `write_error`.
-    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 (edit.baseSha256.length === 0) {
-        // An empty baseSha is almost always a marker-parser bug. Refuse
-        // rather than write blind.
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: 'write_error',
-            absPath,
-            detail: 'Layer C requires a non-empty baseSha256',
-        };
-    }
-    if (!existsSync(absPath)) {
-        // Layer C is a REWRITE, not a CREATE. Use Layer A's sibling
-        // `write` tool to create files. Failing loud keeps the layer
-        // semantics honest: Layer C's gate is "file was X when I read
-        // it"; a non-existent file violates the read invariant.
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: 'file_missing',
-            absPath,
-            detail: `file does not exist: ${edit.file}; Layer C does not create files`,
-        };
-    }
-    const current = readFileSync(absPath, 'utf8');
-    const actualSha = sha256OfUtf8(current);
-    if (actualSha !== edit.baseSha256) {
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: 'base_sha_mismatch',
-            absPath,
-            detail: `file changed since model read: expected sha256 ${edit.baseSha256.slice(0, 12)}…, ` +
-                `got ${actualSha.slice(0, 12)}…`,
-            expectedSha256: edit.baseSha256,
-            actualSha256: actualSha,
-        };
-    }
-    if (current === edit.newContents) {
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: 'identical_replacement',
-            absPath,
-            detail: 'newContents is identical to current file',
-            expectedSha256: edit.baseSha256,
-            actualSha256: actualSha,
-        };
-    }
-    if (opts.dryRun) {
-        return {
-            ok: true,
-            bytesWritten: 0,
-            absPath,
-            expectedSha256: edit.baseSha256,
-            actualSha256: actualSha,
-        };
-    }
-    try {
-        atomicWrite(absPath, edit.newContents);
-    }
-    catch (error) {
-        return {
-            ok: false,
-            bytesWritten: 0,
-            reason: 'write_error',
-            absPath,
-            detail: error instanceof Error ? error.message : String(error),
-            expectedSha256: edit.baseSha256,
-            actualSha256: actualSha,
-        };
-    }
-    return {
-        ok: true,
-        bytesWritten: Buffer.byteLength(edit.newContents, 'utf8'),
-        absPath,
-        expectedSha256: edit.baseSha256,
-        actualSha256: actualSha,
-    };
-}
-/**
- * Sha256 of a UTF-8 string. Hex output, lowercased. Centralised so the
- * apply-side hash and the dispatcher-side hash (when computing the
- * baseSha for the model on read) agree byte-for-byte.
- */
-export function sha256OfUtf8(contents) {
-    return createHash('sha256').update(contents, 'utf8').digest('hex');
-}
-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 {
-            // ignore — tmp may not exist.
-        }
-        throw error;
-    }
-}
-//# sourceMappingURL=layer-c-apply.js.map