@pixel-point/toolcraft 0.0.14 → 0.0.15

package/src/generate.mjs

@@ -1,16 +1,21 @@
-import crypto from "node:crypto";
+import { execFile } from "node:child_process";
 import fsSync from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
 
 import {
   assertDirectory,
   copyDirectory,
-  ensureWritableTargetDirectory,
   pathExists,
   removeDirectory,
 } from "./copy-recursive.mjs";
+import {
+  abortGenerationTransaction,
+  commitGenerationTransaction,
+  prepareGenerationTransaction,
+} from "./generation-transaction.mjs";
 import {
   DEFAULT_PACKAGE_MANAGER,
   normalizePackageManager,
@@ -21,10 +26,14 @@ import {
   createGeneratedTsConfig,
   normalizeProjectTitle,
 } from "./package-json.mjs";
+import { writeGeneratedIntegrityManifest } from "./generated-integrity-manifest.mjs";
+import { isGeneratedTestSupportPath } from "./generated-source-policy.mjs";
+import { assertTargetIsNotGeneratedApp } from "./generated-target-policy.mjs";
 import { rewriteGeneratedText, rewriteTextFiles } from "./rewrite-imports.mjs";
 
 const PACKAGE_ROOT = path.resolve(fileURLToPath(new URL("..", import.meta.url)));
 const REPO_ROOT = path.resolve(fileURLToPath(new URL("../..", import.meta.url)));
+const execFileAsync = promisify(execFile);
 
 function writeJson(filePath, value) {
   return fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`);
@@ -45,11 +54,6 @@ async function readJson(filePath) {
   return JSON.parse(await fs.readFile(filePath, "utf8"));
 }
 
-async function hashFile(filePath) {
-  const buffer = await fs.readFile(filePath);
-  return crypto.createHash("sha256").update(buffer).digest("hex");
-}
-
 function createRelativePath(fromDir, toDir) {
   const relativePath = path.relative(fromDir, toDir);
   return relativePath === "" ? "." : relativePath;
@@ -78,7 +82,10 @@ function rewriteGeneratedAppText(
       : rewrittenSource;
 
   return commandSource
+    .replaceAll("starterComposition", "appComposition")
+    .replaceAll("starter-composition", "app-composition")
     .replaceAll("starterAcceptance", "appAcceptance")
+    .replaceAll("starterControlSectionInventory", "appControlSectionInventory")
     .replaceAll("starter-acceptance", "app-acceptance")
     .replaceAll("starterProductReadiness", "appProductReadiness")
     .replaceAll("starterTransferMode", "appTransferMode")
@@ -91,42 +98,19 @@ function rewriteGeneratedAppText(
 }
 
 async function renameGeneratedAppFiles(targetDir) {
-  const starterSchemaPath = path.join(targetDir, "src/app/starter-schema.ts");
-  const appSchemaPath = path.join(targetDir, "src/app/app-schema.ts");
-  const starterSchemaTestPath = path.join(targetDir, "src/app/starter-schema.test.ts");
-  const appSchemaTestPath = path.join(targetDir, "src/app/app-schema.test.ts");
-  const starterAcceptancePath = path.join(targetDir, "src/app/starter-acceptance.ts");
-  const appAcceptancePath = path.join(targetDir, "src/app/app-acceptance.ts");
-  const starterAcceptanceTestPath = path.join(targetDir, "src/app/starter-acceptance.test.ts");
-  const appAcceptanceTestPath = path.join(targetDir, "src/app/app-acceptance.test.ts");
-  const starterPerformancePath = path.join(targetDir, "src/app/starter-performance.ts");
-  const appPerformancePath = path.join(targetDir, "src/app/app-performance.ts");
-  const starterPerformanceTestPath = path.join(targetDir, "src/app/starter-performance.test.ts");
-  const appPerformanceTestPath = path.join(targetDir, "src/app/app-performance.test.ts");
-
-  if (await pathExists(starterSchemaPath)) {
-    await fs.rename(starterSchemaPath, appSchemaPath);
-  }
-
-  if (await pathExists(starterSchemaTestPath)) {
-    await fs.rename(starterSchemaTestPath, appSchemaTestPath);
-  }
-
-  if (await pathExists(starterAcceptancePath)) {
-    await fs.rename(starterAcceptancePath, appAcceptancePath);
-  }
-
-  if (await pathExists(starterAcceptanceTestPath)) {
-    await fs.rename(starterAcceptanceTestPath, appAcceptanceTestPath);
-  }
-
-  if (await pathExists(starterPerformancePath)) {
-    await fs.rename(starterPerformancePath, appPerformancePath);
-  }
-
-  if (await pathExists(starterPerformanceTestPath)) {
-    await fs.rename(starterPerformanceTestPath, appPerformanceTestPath);
-  }
+  const appDir = path.join(targetDir, "src/app");
+  const entries = await fs.readdir(appDir, { withFileTypes: true });
+
+  await Promise.all(
+    entries
+      .filter((entry) => entry.isFile() && entry.name.startsWith("starter-"))
+      .map((entry) =>
+        fs.rename(
+          path.join(appDir, entry.name),
+          path.join(appDir, entry.name.replace(/^starter-/, "app-")),
+        ),
+      ),
+  );
 }
 
 async function restoreGeneratedGitignore(targetDir) {
@@ -141,6 +125,20 @@ async function restoreGeneratedGitignore(targetDir) {
   await fs.rename(npmSafeGitignorePath, gitignorePath);
 }
 
+async function removeObsoleteGeneratedFiles(targetDir) {
+  const obsoleteRelativePaths = [
+    "src/app/acceptance/defaults.ts",
+    "src/app/app-acceptance.test.ts",
+    "src/app/app-acceptance.output-export.test.ts",
+  ];
+
+  await Promise.all(
+    obsoleteRelativePaths.map((relativePath) =>
+      fs.rm(path.join(targetDir, relativePath), { force: true }),
+    ),
+  );
+}
+
 async function writeGeneratedProjectTitle(targetDir, title) {
   const indexPath = path.join(targetDir, "index.html");
   const source = await fs.readFile(indexPath, "utf8");
@@ -160,19 +158,24 @@ async function writeGeneratedProjectTitle(targetDir, title) {
   await fs.writeFile(indexPath, nextSource);
 }
 
-async function removeToolcraftTestFiles(toolcraftRoot) {
-  async function visit(currentDir) {
+async function removeGeneratedTestSupportFiles(toolcraftRoot) {
+  async function visit(currentDir, relativeDir = "") {
     const entries = await fs.readdir(currentDir, { withFileTypes: true });
 
     for (const entry of entries) {
       const filePath = path.join(currentDir, entry.name);
+      const relativePath = path.posix.join(relativeDir, entry.name);
 
       if (entry.isDirectory()) {
-        await visit(filePath);
+        if (isGeneratedTestSupportPath(relativePath)) {
+          await fs.rm(filePath, { force: true, recursive: true });
+        } else {
+          await visit(filePath, relativePath);
+        }
         continue;
       }
 
-      if (entry.isFile() && /\.(test|spec)\.[cm]?[jt]sx?$/.test(entry.name)) {
+      if (entry.isFile() && isGeneratedTestSupportPath(relativePath)) {
         await fs.rm(filePath);
       }
     }
@@ -181,38 +184,6 @@ async function removeToolcraftTestFiles(toolcraftRoot) {
   await visit(toolcraftRoot);
 }
 
-async function writeToolcraftIntegrityManifest(toolcraftRoot) {
-  const files = {};
-
-  async function visit(currentDir) {
-    const entries = await fs.readdir(currentDir, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const filePath = path.join(currentDir, entry.name);
-
-      if (entry.isDirectory()) {
-        await visit(filePath);
-        continue;
-      }
-
-      if (entry.isFile() && entry.name !== ".toolcraft-manifest.json") {
-        const relativePath = path.relative(toolcraftRoot, filePath).split(path.sep).join("/");
-        files[relativePath] = await hashFile(filePath);
-      }
-    }
-  }
-
-  await visit(toolcraftRoot);
-  await writeJson(path.join(toolcraftRoot, ".toolcraft-manifest.json"), {
-    description:
-      "Integrity manifest for copied Toolcraft sources. Generated apps should not edit src/toolcraft.",
-    files: Object.fromEntries(
-      Object.entries(files).sort(([left], [right]) => left.localeCompare(right)),
-    ),
-    version: 1,
-  });
-}
-
 function allDirectoriesExist(paths) {
   return Object.values(paths).every((directoryPath) => {
     try {
@@ -223,7 +194,10 @@ function allDirectoriesExist(paths) {
   });
 }
 
-export function getDefaultSourcePaths(repoRoot = REPO_ROOT) {
+export function getDefaultSourcePaths(
+  repoRoot = REPO_ROOT,
+  packageRoot = PACKAGE_ROOT,
+) {
   const monorepoPaths = {
     toolcraftSrc: path.join(repoRoot, "packages/toolcraft-runtime/src"),
     starterDir: path.join(repoRoot, "starter"),
@@ -235,33 +209,84 @@ export function getDefaultSourcePaths(repoRoot = REPO_ROOT) {
   }
 
   return {
-    toolcraftSrc: path.join(PACKAGE_ROOT, "templates/runtime"),
-    starterDir: path.join(PACKAGE_ROOT, "templates/starter"),
-    uiSrc: path.join(PACKAGE_ROOT, "templates/ui"),
+    toolcraftSrc: path.join(packageRoot, "templates/runtime"),
+    starterDir: path.join(packageRoot, "templates/starter"),
+    uiSrc: path.join(packageRoot, "templates/ui"),
   };
 }
 
-export async function generateToolcraft(options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const targetDir = path.resolve(cwd, options.targetDir ?? ".");
-  const packageManager = normalizePackageManager(options.packageManager ?? DEFAULT_PACKAGE_MANAGER);
-  const sourcePaths = options.sourcePaths ?? getDefaultSourcePaths(options.repoRoot ?? REPO_ROOT);
+async function assertGeneratedFile(targetDir, relativePath) {
+  const filePath = path.join(targetDir, relativePath);
+  let stats;
 
-  await assertDirectory(sourcePaths.starterDir, "Starter app");
-  await assertDirectory(sourcePaths.uiSrc, "UI package source");
-  await assertDirectory(sourcePaths.toolcraftSrc, "Toolcraft template runtime package source");
-  const starterPackageJson = await readJson(path.join(sourcePaths.starterDir, "package.json"));
-  const packageJson = createGeneratedPackageJson({
-    name: options.name ?? path.basename(targetDir),
-    packageManager,
-    starterPackageJson,
-  });
-  const projectTitle = normalizeProjectTitle(packageJson.name);
+  try {
+    stats = await fs.stat(filePath);
+  } catch {
+    throw new Error(`Generated staging file is missing: ${relativePath}`);
+  }
 
-  await ensureWritableTargetDirectory(targetDir, { force: options.force });
+  if (!stats.isFile()) {
+    throw new Error(`Generated staging path must be a file: ${relativePath}`);
+  }
+}
 
+async function validateGeneratedStaging(targetDir) {
+  await Promise.all([
+    assertGeneratedFile(targetDir, "AGENTS.md"),
+    assertGeneratedFile(targetDir, "index.html"),
+    assertGeneratedFile(targetDir, "package.json"),
+    assertGeneratedFile(targetDir, "src/app/app-composition.tsx"),
+    assertGeneratedFile(targetDir, "src/app/app-schema.ts"),
+    assertGeneratedFile(targetDir, "src/toolcraft/.toolcraft-manifest.json"),
+    assertGeneratedFile(targetDir, "tsconfig.json"),
+    assertDirectory(path.join(targetDir, "src/toolcraft/runtime"), "Generated runtime"),
+    assertDirectory(path.join(targetDir, "src/toolcraft/ui"), "Generated UI"),
+  ]);
+
+  await Promise.all([
+    readJson(path.join(targetDir, "package.json")),
+    readJson(path.join(targetDir, "src/toolcraft/.toolcraft-manifest.json")),
+  ]);
+
+  const validationCommands = [
+    {
+      args: [path.join(targetDir, "scripts/check-toolcraft-docs.mjs")],
+      label: "local contract docs",
+    },
+    {
+      args: [
+        path.join(targetDir, "scripts/check-toolcraft-integrity.mjs"),
+        "--platform-only",
+      ],
+      label: "signed platform integrity",
+    },
+  ];
+
+  for (const validation of validationCommands) {
+    try {
+      await execFileAsync(process.execPath, validation.args, {
+        cwd: targetDir,
+        maxBuffer: 10 * 1024 * 1024,
+      });
+    } catch (error) {
+      throw new Error(
+        `Generated staging validation failed for ${validation.label}.`,
+        { cause: error },
+      );
+    }
+  }
+}
+
+async function assembleGeneratedToolcraft({
+  packageJson,
+  packageManager,
+  projectTitle,
+  sourcePaths,
+  targetDir,
+}) {
   await copyDirectory(sourcePaths.starterDir, targetDir);
   await restoreGeneratedGitignore(targetDir);
+  await removeObsoleteGeneratedFiles(targetDir);
   await renameGeneratedAppFiles(targetDir);
 
   const toolcraftRoot = path.join(targetDir, "src/toolcraft");
@@ -269,17 +294,72 @@ export async function generateToolcraft(options = {}) {
   await fs.mkdir(toolcraftRoot, { recursive: true });
   await copyDirectory(sourcePaths.uiSrc, path.join(toolcraftRoot, "ui"));
   await copyDirectory(sourcePaths.toolcraftSrc, path.join(toolcraftRoot, "runtime"));
-  await removeToolcraftTestFiles(toolcraftRoot);
+  await removeGeneratedTestSupportFiles(toolcraftRoot);
 
   const changedFiles = await rewriteTextFiles(targetDir, (source, filePath) =>
     rewriteGeneratedAppText(source, filePath, { packageManager, targetDir }),
   );
   await writeGeneratedProjectTitle(targetDir, projectTitle);
-  await writeToolcraftIntegrityManifest(toolcraftRoot);
-
   await writeJson(path.join(targetDir, "package.json"), packageJson);
   await writeJson(path.join(targetDir, "tsconfig.json"), createGeneratedTsConfig());
+  await writeGeneratedIntegrityManifest({
+    appRoot: targetDir,
+    packageScripts: packageJson.scripts,
+    starterRoot: sourcePaths.starterDir,
+    toolcraftRoot,
+  });
+
   await fs.rm(path.join(targetDir, "pnpm-lock.yaml"), { force: true });
+  await validateGeneratedStaging(targetDir);
+
+  return changedFiles;
+}
+
+export async function generateToolcraft(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const targetDir = path.resolve(cwd, options.targetDir ?? ".");
+  const packageManager = normalizePackageManager(options.packageManager ?? DEFAULT_PACKAGE_MANAGER);
+  const sourcePaths =
+    options.sourcePaths ??
+    getDefaultSourcePaths(
+      options.repoRoot ?? REPO_ROOT,
+      options.packageRoot ?? PACKAGE_ROOT,
+    );
+
+  await assertDirectory(sourcePaths.starterDir, "Starter app");
+  await assertDirectory(sourcePaths.uiSrc, "UI package source");
+  await assertDirectory(sourcePaths.toolcraftSrc, "Toolcraft template runtime package source");
+  await assertTargetIsNotGeneratedApp(targetDir);
+  const starterPackageJson = await readJson(path.join(sourcePaths.starterDir, "package.json"));
+  const packageJson = createGeneratedPackageJson({
+    name: options.name ?? path.basename(targetDir),
+    packageManager,
+    starterPackageJson,
+  });
+  const projectTitle = normalizeProjectTitle(packageJson.name);
+  const transaction = await prepareGenerationTransaction({
+    force: options.force,
+    targetDir,
+  });
+  let stagedChangedFiles;
+
+  try {
+    stagedChangedFiles = await assembleGeneratedToolcraft({
+      packageJson,
+      packageManager,
+      projectTitle,
+      sourcePaths,
+      targetDir: transaction.stagingDir,
+    });
+    await commitGenerationTransaction(transaction, options.transactionHooks);
+  } catch (error) {
+    await abortGenerationTransaction(transaction);
+    throw error;
+  }
+
+  const changedFiles = stagedChangedFiles.map((filePath) =>
+    path.join(targetDir, path.relative(transaction.stagingDir, filePath)),
+  );
 
   return {
     changedFiles,