@shrkcrft/generator 0.1.0-alpha.1

package/dist/synthetic-plan.js

@@ -0,0 +1,123 @@
+/**
+ * Synthetic plan evaluation.
+ *
+ * Some plans (e.g. plugin-lifecycle rename/remove) are produced by code that
+ * is not a template — there is nothing to "regenerate" against. They carry
+ * their structural intent in `ISavedPlan.expectedChanges[].operation` plus
+ * `ISavedPlan.folderOps[]`.
+ *
+ * `evaluateSavedPlanInPlace` evaluates every operation against the live file
+ * system and builds an `IGenerationPlan` shaped like a normal one so the
+ * apply pipeline can write the resulting changes through the same path.
+ *
+ * Synthetic plans are identified by a `__`-prefixed templateId so existing
+ * template-driven plans are unaffected.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { evaluatePlannedChange } from "./planned-change.js";
+import { FileChangeType } from "./file-change.js";
+export const SYNTHETIC_TEMPLATE_PREFIX = '__';
+export function isSyntheticTemplateId(templateId) {
+    return templateId.startsWith(SYNTHETIC_TEMPLATE_PREFIX);
+}
+export function evaluateSavedPlanInPlace(plan, projectRoot) {
+    const changes = [];
+    const warnings = [];
+    let hasConflicts = false;
+    const expected = plan.expectedChanges ?? [];
+    for (const e of expected) {
+        if (!e.operation) {
+            // Without an operation we cannot reconstruct contents — surface as
+            // conflict so apply refuses the write. This is the safe default for
+            // synthetic plans missing intent.
+            changes.push({
+                type: FileChangeType.Conflict,
+                absolutePath: nodePath.resolve(projectRoot, e.relativePath),
+                relativePath: e.relativePath,
+                contents: '',
+                reason: 'synthetic-plan: expected change has no operation intent',
+                sizeBytes: 0,
+            });
+            hasConflicts = true;
+            continue;
+        }
+        const change = applyOperation(projectRoot, e.relativePath, e.operation);
+        if (change.type === FileChangeType.Conflict)
+            hasConflicts = true;
+        changes.push(change);
+    }
+    const out = {
+        templateId: plan.templateId,
+        templateName: plan.templateId,
+        changes,
+        totalFiles: changes.length,
+        hasConflicts,
+        warnings,
+        postGenerationNotes: [],
+    };
+    if (plan.folderOps && plan.folderOps.length > 0) {
+        out.folderOps = plan.folderOps;
+    }
+    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,
+        existing,
+    });
+}
+/**
+ * Write evaluated changes from a synthetic plan directly. The caller
+ * is responsible for verifying signature / divergence / folder-op safety
+ * before invoking this.
+ */
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { AppErrorImpl, ERROR_CODES, err, ok } from '@shrkcrft/core';
+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;
+    for (const change of plan.changes) {
+        if (change.type === FileChangeType.Skip) {
+            skipped += 1;
+            continue;
+        }
+        if (!isWriteableSyntheticChange(change.type))
+            continue;
+        try {
+            mkdirSync(nodePath.dirname(change.absolutePath), { recursive: true });
+            writeFileSync(change.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 ok({
+        summary: { written: written.length, skipped, conflicts: 0, totalBytes },
+        written,
+    });
+}
+function isWriteableSyntheticChange(type) {
+    switch (type) {
+        case FileChangeType.Create:
+        case FileChangeType.Update:
+        case FileChangeType.Append:
+        case FileChangeType.InsertAfter:
+        case FileChangeType.InsertBefore:
+        case FileChangeType.Replace:
+        case FileChangeType.Export:
+            return true;
+        default:
+            return false;
+    }
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@shrkcrft/generator",
+  "version": "0.1.0-alpha.1",
+  "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.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sharkcraft/sharkcraft.git",
+    "directory": "packages/generator"
+  },
+  "homepage": "https://github.com/sharkcraft/sharkcraft",
+  "bugs": {
+    "url": "https://github.com/sharkcraft/sharkcraft/issues"
+  },
+  "keywords": [
+    "sharkcraft",
+    "generator",
+    "codegen",
+    "dry-run"
+  ],
+  "engines": {
+    "bun": ">=1.1.0",
+    "node": ">=18"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "@shrkcrft/core": "^0.1.0-alpha.1",
+    "@shrkcrft/templates": "^0.1.0-alpha.1",
+    "@shrkcrft/rules": "^0.1.0-alpha.1",
+    "@shrkcrft/paths": "^0.1.0-alpha.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}