@shrkcrft/generator 0.1.0-alpha.3 → 0.1.0-alpha.30

package/dist/synthetic-plan.js

@@ -15,6 +15,7 @@
  */
 import { existsSync, readFileSync } from 'node:fs';
 import * as nodePath from 'node:path';
+import { safeResolveTargetPath } from '@shrkcrft/core';
 import { evaluatePlannedChange } from "./planned-change.js";
 import { FileChangeType } from "./file-change.js";
 export const SYNTHETIC_TEMPLATE_PREFIX = '__';
@@ -26,6 +27,14 @@ export function evaluateSavedPlanInPlace(plan, projectRoot) {
     const warnings = [];
     let hasConflicts = false;
     const expected = plan.expectedChanges ?? [];
+    // Per-file content overlay so MULTIPLE ops on the SAME file COMPOSE: each op
+    // sees the cumulative result of the prior ops on that path rather than the
+    // original on-disk bytes. Mirrors the template path in dry-run.ts. Without
+    // it, [append A, append B] loses A (the writer's last same-path write
+    // clobbers earlier ones) and create-then-modify on one NEW path
+    // false-conflicts (op2 reads stale disk). Keyed by absolute path → the
+    // cumulative content after the prior op(s).
+    const overlay = new Map();
     for (const e of expected) {
         if (!e.operation) {
             // Without an operation we cannot reconstruct contents — surface as
@@ -42,7 +51,7 @@ export function evaluateSavedPlanInPlace(plan, projectRoot) {
             hasConflicts = true;
             continue;
         }
-        const change = applyOperation(projectRoot, e.relativePath, e.operation);
+        const change = applyOperation(projectRoot, e.relativePath, e.operation, overlay);
         if (change.type === FileChangeType.Conflict)
             hasConflicts = true;
         changes.push(change);
@@ -61,15 +70,44 @@ export function evaluateSavedPlanInPlace(plan, projectRoot) {
     }
     return out;
 }
-function applyOperation(projectRoot, relativePath, operation) {
-    const absolutePath = nodePath.resolve(projectRoot, relativePath);
-    const existing = existsSync(absolutePath) ? readFileSync(absolutePath, 'utf8') : null;
-    return evaluatePlannedChange({
-        change: { targetPath: relativePath, operation },
-        absolutePath,
-        relativePath,
+function applyOperation(projectRoot, relativePath, operation, overlay) {
+    // Route through the single generator chokepoint instead of a bare resolve, so
+    // a traversal / absolute `relativePath` in a hand-crafted or tampered plan
+    // can't write OUTSIDE the project root. An unsafe path becomes a Conflict,
+    // which writeSyntheticPlan refuses (matching the template path in dry-run.ts).
+    let safe;
+    try {
+        safe = safeResolveTargetPath(relativePath, projectRoot);
+    }
+    catch (e) {
+        const pathErr = e;
+        return {
+            type: FileChangeType.Conflict,
+            absolutePath: pathErr.rawPath,
+            relativePath: pathErr.rawPath,
+            contents: '',
+            reason: `Refused unsafe target path (${pathErr.code}): ${pathErr.message}`,
+            sizeBytes: 0,
+        };
+    }
+    // Prefer the overlay (the cumulative result of prior same-file ops) over the
+    // on-disk bytes so op N sees the result of ops 1..N-1. Falls back to the live
+    // file, then to absent (`null`) for a brand-new path.
+    const existing = overlay.has(safe.absolutePath)
+        ? (overlay.get(safe.absolutePath) ?? null)
+        : existsSync(safe.absolutePath)
+            ? readFileSync(safe.absolutePath, 'utf8')
+            : null;
+    const result = evaluatePlannedChange({
+        change: { targetPath: safe.relativePath, operation },
+        absolutePath: safe.absolutePath,
+        relativePath: safe.relativePath,
         existing,
     });
+    // Record the cumulative content (Skip/Conflict carry the unchanged bytes,
+    // which is exactly what a later op on the same file should see).
+    overlay.set(safe.absolutePath, result.contents);
+    return result;
 }
 /**
  * Write evaluated changes from a synthetic plan directly. The caller
@@ -78,30 +116,63 @@ function applyOperation(projectRoot, relativePath, operation) {
  */
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { AppErrorImpl, ERROR_CODES, err, ok } from '@shrkcrft/core';
+/**
+ * A CCR retrieval marker (`<<ccr:<hex>…>>`) is a pointer into the compress
+ * cache — a LOSSY/compressed view, never apply-grade source. If one ever
+ * reaches a write (e.g. a compressed diff fed into a `create`/`replace` op), it
+ * would corrupt the file. This detector enforces, at the write chokepoint, the
+ * invariant that the compression layer only documents in a comment.
+ */
+const CCR_MARKER_RE = /<<ccr:[0-9a-f]{8,}/;
 export function writeSyntheticPlan(plan) {
     if (plan.hasConflicts) {
         return err(new AppErrorImpl(ERROR_CODES.TARGET_FILE_EXISTS, 'Synthetic plan refused: conflicts present', { details: { conflicts: plan.changes.filter((c) => c.type === FileChangeType.Conflict) } }));
     }
-    const written = [];
-    let totalBytes = 0;
-    let skipped = 0;
+    // Refuse the WHOLE plan if any writeable change carries a CCR marker — a
+    // compressed/lossy blob must never be written as source.
     for (const change of plan.changes) {
-        if (change.type === FileChangeType.Skip) {
-            skipped += 1;
-            continue;
-        }
         if (!isWriteableSyntheticChange(change.type))
             continue;
+        if (CCR_MARKER_RE.test(change.contents)) {
+            return err(new AppErrorImpl(ERROR_CODES.INVALID_INPUT, `Refused to write ${change.relativePath}: contents carry a <<ccr:…>> marker (a compressed/lossy blob is not apply-grade source).`, { details: { path: change.relativePath } }));
+        }
+    }
+    // Compose multiple ops on the SAME path into ONE write. `evaluateSavedPlanInPlace`
+    // threads an overlay, so the LAST writeable change for a path already carries
+    // the cumulative result of every prior same-path op (any trailing Skip leaves
+    // those bytes unchanged). Writing that once — instead of every op's contents
+    // in order, last-write-wins — avoids redundant writes and keeps the success
+    // count honest: `written` and `summary.written` count DISTINCT paths.
+    const lastWriteableByPath = new Map();
+    const skipPaths = new Set();
+    for (const change of plan.changes) {
+        if (isWriteableSyntheticChange(change.type)) {
+            lastWriteableByPath.set(change.absolutePath, change);
+        }
+        else if (change.type === FileChangeType.Skip) {
+            skipPaths.add(change.absolutePath);
+        }
+    }
+    const written = [];
+    let totalBytes = 0;
+    for (const [absolutePath, change] of lastWriteableByPath) {
         try {
-            mkdirSync(nodePath.dirname(change.absolutePath), { recursive: true });
-            writeFileSync(change.absolutePath, change.contents, 'utf8');
+            mkdirSync(nodePath.dirname(absolutePath), { recursive: true });
+            writeFileSync(absolutePath, change.contents, 'utf8');
             written.push(change);
             totalBytes += change.sizeBytes;
         }
         catch (e) {
-            return err(new AppErrorImpl(ERROR_CODES.FILE_WRITE_ERROR, `Failed to write ${change.absolutePath}`, { details: { path: change.absolutePath }, cause: e }));
+            return err(new AppErrorImpl(ERROR_CODES.FILE_WRITE_ERROR, `Failed to write ${absolutePath}`, { details: { path: absolutePath }, cause: e }));
         }
     }
+    // A path counts as skipped only when EVERY op on it resolved to Skip (a path
+    // that was also written is not a skip).
+    let skipped = 0;
+    for (const p of skipPaths) {
+        if (!lastWriteableByPath.has(p))
+            skipped += 1;
+    }
     return ok({
         summary: { written: written.length, skipped, conflicts: 0, totalBytes },
         written,

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@shrkcrft/generator",
-  "version": "0.1.0-alpha.3",
+  "version": "0.1.0-alpha.30",
   "description": "SharkCraft plan-first generator: GenerationPlan, FileChange, dry-run, safe writes.",
   "license": "MIT",
   "author": "SharkCraft contributors",
   "type": "module",
   "main": "./dist/index.js",
-  "types": "./dist/index.d.d.ts",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -43,10 +43,10 @@
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@shrkcrft/core": "^0.1.0-alpha.2",
-    "@shrkcrft/templates": "^0.1.0-alpha.2",
-    "@shrkcrft/rules": "^0.1.0-alpha.2",
-    "@shrkcrft/paths": "^0.1.0-alpha.2"
+    "@shrkcrft/core": "^0.1.0-alpha.30",
+    "@shrkcrft/templates": "^0.1.0-alpha.30",
+    "@shrkcrft/rules": "^0.1.0-alpha.30",
+    "@shrkcrft/paths": "^0.1.0-alpha.30"
   },
   "publishConfig": {
     "access": "public"