@pixel-point/toolcraft 0.0.2

package/src/cli.test.mjs

@@ -0,0 +1,284 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { after, describe, it } from "node:test";
+
+import { parseCreateArgs, resolveCreateOptions, runToolcraftCli } from "./cli.mjs";
+
+const execFileAsync = promisify(execFile);
+const packageRoot = path.resolve(fileURLToPath(new URL("..", import.meta.url)));
+const tempRoots = [];
+
+after(async () => {
+  await Promise.all(
+    tempRoots.map((tempRoot) => fs.rm(tempRoot, { force: true, recursive: true })),
+  );
+});
+
+function createWritableCapture() {
+  return {
+    text: "",
+    write(chunk) {
+      this.text += String(chunk);
+    },
+  };
+}
+
+async function createTempRoot() {
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "toolcraft-cli-run-"));
+  tempRoots.push(tempRoot);
+  return tempRoot;
+}
+
+describe("parseCreateArgs", () => {
+  it("parses create options for scripted usage", () => {
+    assert.deepEqual(
+      parseCreateArgs([
+        "generated-app",
+        "--name",
+        "Generated App",
+        "--force",
+        "--yes",
+        "--no-install",
+      ]),
+      {
+        force: true,
+        help: false,
+        install: false,
+        name: "Generated App",
+        targetDir: "generated-app",
+        yes: true,
+      },
+    );
+  });
+
+  it("parses --dir as the target directory", () => {
+    assert.equal(parseCreateArgs(["--dir", "target-app"]).targetDir, "target-app");
+  });
+
+  it("rejects duplicate target directory values", () => {
+    assert.throws(
+      () => parseCreateArgs(["target-app", "--dir", "other-app"]),
+      /Pass either a positional target directory or --dir/,
+    );
+  });
+});
+
+describe("resolveCreateOptions", () => {
+  it("defaults missing target directory and package name to the current directory", async () => {
+    const tempRoot = await createTempRoot();
+    const options = await resolveCreateOptions(parseCreateArgs(["--yes", "--no-install"]), {
+      cwd: tempRoot,
+      env: {},
+    });
+
+    assert.deepEqual(options, {
+      force: false,
+      install: false,
+      name: path.basename(tempRoot).toLowerCase(),
+      targetDir: ".",
+    });
+  });
+
+  it("uses the prompted project name as the target folder from a non-empty parent directory", async () => {
+    const tempRoot = await createTempRoot();
+    await fs.writeFile(path.join(tempRoot, "README.md"), "existing");
+    let confirmCalled = false;
+
+    const options = await resolveCreateOptions(parseCreateArgs([]), {
+      cwd: tempRoot,
+      env: {},
+      prompts: {
+        async text({ label, defaultValue }) {
+          assert.equal(label, "Project name");
+          assert.equal(defaultValue, path.basename(tempRoot).toLowerCase());
+          return "Prompted App";
+        },
+        async confirm({ label, defaultValue }) {
+          confirmCalled = true;
+          throw new Error(`Unexpected confirmation: ${label} ${defaultValue}`);
+        },
+      },
+    });
+
+    assert.deepEqual(options, {
+      force: false,
+      install: true,
+      name: "prompted-app",
+      targetDir: "./prompted-app",
+    });
+    assert.equal(confirmCalled, false);
+  });
+
+  it("confirms when the prompted project target folder is non-empty", async () => {
+    const tempRoot = await createTempRoot();
+    const targetDir = path.join(tempRoot, "prompted-app");
+    await fs.mkdir(targetDir);
+    await fs.writeFile(path.join(targetDir, "README.md"), "existing");
+
+    const options = await resolveCreateOptions(parseCreateArgs([]), {
+      cwd: tempRoot,
+      env: {},
+      prompts: {
+        async text({ label }) {
+          assert.equal(label, "Project name");
+          return "Prompted App";
+        },
+        async confirm({ label, defaultValue }) {
+          assert.equal(label, "Directory is not empty. Continue?");
+          assert.equal(defaultValue, false);
+          return true;
+        },
+      },
+    });
+
+    assert.deepEqual(options, {
+      force: true,
+      install: true,
+      name: "prompted-app",
+      targetDir: "./prompted-app",
+    });
+  });
+
+  it("does not force non-empty folders when --yes is used without --force", async () => {
+    const tempRoot = await createTempRoot();
+    const targetDir = path.join(tempRoot, "existing-app");
+    await fs.mkdir(targetDir);
+    await fs.writeFile(path.join(targetDir, "README.md"), "existing");
+
+    await assert.rejects(
+      () =>
+        resolveCreateOptions(parseCreateArgs(["existing-app", "--yes"]), {
+          cwd: tempRoot,
+          env: {},
+        }),
+      /Use --force/,
+    );
+  });
+});
+
+describe("runToolcraftCli", () => {
+  it("creates in the current directory when no command or target is passed", async () => {
+    const tempRoot = await createTempRoot();
+    const stdout = createWritableCapture();
+    const stderr = createWritableCapture();
+
+    const result = await runToolcraftCli(["--no-install"], {
+      cwd: tempRoot,
+      env: {},
+      stderr,
+      stdout,
+      throwOnError: true,
+    });
+
+    assert.equal(result.ok, true);
+    assert.ok(await fs.stat(path.join(tempRoot, "src/app/app-schema.ts")));
+    assert.match(stdout.text, new RegExp(`Created ${path.basename(tempRoot).toLowerCase()}`));
+    assert.doesNotMatch(stdout.text, /cd /);
+    assert.match(stdout.text, /pnpm dev/);
+    assert.equal(stderr.text, "");
+  });
+
+  it("creates a standalone app through toolcraft create without installing in tests", async () => {
+    const tempRoot = await createTempRoot();
+    const stdout = createWritableCapture();
+    const stderr = createWritableCapture();
+
+    const result = await runToolcraftCli(
+      [
+        "create",
+        "generated-app",
+        "--name",
+        "Generated App",
+        "--yes",
+        "--force",
+        "--no-install",
+      ],
+      {
+        cwd: tempRoot,
+        env: {},
+        stderr,
+        stdout,
+        throwOnError: true,
+      },
+    );
+
+    assert.equal(result.ok, true);
+    assert.ok(await fs.stat(path.join(tempRoot, "generated-app/src/app/app-schema.ts")));
+    assert.match(stdout.text, /Created generated-app/);
+    assert.match(stdout.text, /cd generated-app/);
+    assert.match(stdout.text, /pnpm dev/);
+    assert.doesNotMatch(stdout.text, /pnpm verify:final/);
+    assert.equal(stderr.text, "");
+  });
+
+  it("runs pnpm install by default after creating the app", async () => {
+    const tempRoot = await createTempRoot();
+    const stdout = createWritableCapture();
+    const installs = [];
+
+    await runToolcraftCli(["create", "install-app", "--name", "Install App", "--yes", "--force"], {
+      cwd: tempRoot,
+      env: {},
+      stdout,
+      throwOnError: true,
+      async runCommand(command, args, options) {
+        installs.push({ args, command, cwd: options.cwd });
+      },
+    });
+
+    assert.deepEqual(installs, [
+      {
+        args: ["install"],
+        command: "pnpm",
+        cwd: path.join(tempRoot, "install-app"),
+      },
+    ]);
+    assert.match(stdout.text, /Installing dependencies with pnpm/);
+    assert.match(stdout.text, /pnpm dev/);
+  });
+
+  it("prints create help with the npx command", async () => {
+    const stdout = createWritableCapture();
+
+    const result = await runToolcraftCli(["create", "--help"], {
+      stdout,
+      throwOnError: true,
+    });
+
+    assert.equal(result.ok, true);
+    assert.match(stdout.text, /npx @pixel-point\/toolcraft create/);
+    assert.match(stdout.text, /--no-install/);
+  });
+
+  it("keeps create-toolcraft-app as a compatibility wrapper", async () => {
+    const tempRoot = await createTempRoot();
+    const binPath = path.join(packageRoot, "bin/create-toolcraft-app.mjs");
+
+    const { stdout } = await execFileAsync(
+      process.execPath,
+      [
+        binPath,
+        "wrapped-app",
+        "--name",
+        "Wrapped App",
+        "--yes",
+        "--force",
+        "--no-install",
+      ],
+      {
+        cwd: tempRoot,
+        env: {
+          ...process.env,
+        },
+      },
+    );
+
+    assert.match(stdout, /Created wrapped-app/);
+    assert.ok(await fs.stat(path.join(tempRoot, "wrapped-app/src/app/app-schema.ts")));
+  });
+});

package/src/copy-recursive.mjs

@@ -0,0 +1,86 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const DEFAULT_IGNORED_NAMES = new Set([
+  ".DS_Store",
+  ".git",
+  ".turbo",
+  "dist",
+  "node_modules",
+  "playwright-report",
+  "test-results",
+]);
+
+export async function pathExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function assertDirectory(directoryPath, label) {
+  let stats;
+
+  try {
+    stats = await fs.stat(directoryPath);
+  } catch {
+    throw new Error(`${label} was not found: ${directoryPath}`);
+  }
+
+  if (!stats.isDirectory()) {
+    throw new Error(`${label} must be a directory: ${directoryPath}`);
+  }
+}
+
+export async function ensureWritableTargetDirectory(targetDir, { force = false } = {}) {
+  await fs.mkdir(targetDir, { recursive: true });
+
+  const entries = await fs.readdir(targetDir);
+  const meaningfulEntries = entries.filter((entry) => entry !== ".DS_Store");
+
+  if (meaningfulEntries.length > 0 && !force) {
+    throw new Error(
+      `Target directory is not empty: ${targetDir}. Use --force to write into it.`,
+    );
+  }
+}
+
+export async function copyDirectory(sourceDir, targetDir, options = {}) {
+  const ignoredNames = options.ignoredNames ?? DEFAULT_IGNORED_NAMES;
+
+  await assertDirectory(sourceDir, "Source directory");
+  await fs.mkdir(targetDir, { recursive: true });
+
+  const entries = await fs.readdir(sourceDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (ignoredNames.has(entry.name)) {
+      continue;
+    }
+
+    const sourcePath = path.join(sourceDir, entry.name);
+    const targetPath = path.join(targetDir, entry.name);
+
+    if (entry.isDirectory()) {
+      await copyDirectory(sourcePath, targetPath, { ignoredNames });
+      continue;
+    }
+
+    if (entry.isSymbolicLink()) {
+      const linkTarget = await fs.readlink(sourcePath);
+      await fs.rm(targetPath, { force: true, recursive: true });
+      await fs.symlink(linkTarget, targetPath);
+      continue;
+    }
+
+    if (entry.isFile()) {
+      await fs.copyFile(sourcePath, targetPath);
+    }
+  }
+}
+
+export async function removeDirectory(directoryPath) {
+  await fs.rm(directoryPath, { force: true, recursive: true });
+}

package/src/generate.mjs

@@ -0,0 +1,212 @@
+import crypto from "node:crypto";
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  assertDirectory,
+  copyDirectory,
+  ensureWritableTargetDirectory,
+  pathExists,
+  removeDirectory,
+} from "./copy-recursive.mjs";
+import { createGeneratedPackageJson, createGeneratedTsConfig } from "./package-json.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)));
+
+function writeJson(filePath, value) {
+  return fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+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;
+}
+
+function rewriteGeneratedAppText(source) {
+  return rewriteGeneratedText(source)
+    .replaceAll("starterAcceptance", "appAcceptance")
+    .replaceAll("starter-acceptance", "app-acceptance")
+    .replaceAll("starterProductReadiness", "appProductReadiness")
+    .replaceAll("starterTransferMode", "appTransferMode")
+    .replaceAll("starterPerformance", "appPerformance")
+    .replaceAll("starter-performance", "app-performance")
+    .replaceAll("starterSchema", "appSchema")
+    .replaceAll("starter-schema", "app-schema")
+    .replaceAll("StarterHome", "AppHome")
+    .replaceAll("Toolcraft Starter", "Toolcraft App Template");
+}
+
+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);
+  }
+}
+
+async function removeToolcraftTestFiles(toolcraftRoot) {
+  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() && /\.(test|spec)\.[cm]?[jt]sx?$/.test(entry.name)) {
+        await fs.rm(filePath);
+      }
+    }
+  }
+
+  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 {
+      return fsSync.statSync(directoryPath).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+}
+
+export function getDefaultSourcePaths(repoRoot = REPO_ROOT) {
+  const monorepoPaths = {
+    toolcraftSrc: path.join(repoRoot, "packages/toolcraft-runtime/src"),
+    starterDir: path.join(repoRoot, "starter"),
+    uiSrc: path.join(repoRoot, "packages/ui/src"),
+  };
+
+  if (allDirectoriesExist(monorepoPaths)) {
+    return monorepoPaths;
+  }
+
+  return {
+    toolcraftSrc: path.join(PACKAGE_ROOT, "templates/runtime"),
+    starterDir: path.join(PACKAGE_ROOT, "templates/starter"),
+    uiSrc: path.join(PACKAGE_ROOT, "templates/ui"),
+  };
+}
+
+export async function generateToolcraft(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const targetDir = path.resolve(cwd, options.targetDir ?? ".");
+  const sourcePaths = options.sourcePaths ?? getDefaultSourcePaths(options.repoRoot ?? REPO_ROOT);
+
+  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"));
+  await ensureWritableTargetDirectory(targetDir, { force: options.force });
+
+  await copyDirectory(sourcePaths.starterDir, targetDir);
+  await renameGeneratedAppFiles(targetDir);
+
+  const toolcraftRoot = path.join(targetDir, "src/toolcraft");
+  await removeDirectory(toolcraftRoot);
+  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);
+
+  const changedFiles = await rewriteTextFiles(targetDir, (source) =>
+    rewriteGeneratedAppText(source),
+  );
+  await writeToolcraftIntegrityManifest(toolcraftRoot);
+  const packageJson = createGeneratedPackageJson({
+    name: options.name ?? path.basename(targetDir),
+    starterPackageJson,
+  });
+
+  await writeJson(path.join(targetDir, "package.json"), packageJson);
+  await writeJson(path.join(targetDir, "tsconfig.json"), createGeneratedTsConfig());
+  await fs.rm(path.join(targetDir, "pnpm-lock.yaml"), { force: true });
+
+  return {
+    changedFiles,
+    packageName: packageJson.name,
+    relativeTargetDir: createRelativePath(cwd, targetDir),
+    targetDir,
+  };
+}