@pixel-point/toolcraft 0.0.14 → 0.0.15

package/src/package-json.test.mjs

@@ -29,11 +29,13 @@ describe("createGeneratedPackageJson", () => {
     const packageJson = createGeneratedPackageJson({
       name: "Generated App",
       starterPackageJson: {
-        license: "SEE LICENSE IN LICENSE.md",
+        license: "MIT",
         type: "module",
         scripts: {
           dev: "vite dev",
           test: "vitest run",
+          "test:generated": "node scripts/check-toolcraft-integrity.mjs && vitest run",
+          "verify:receipt": "node scripts/toolcraft-verification-receipt.mjs validate",
         },
         dependencies: {
           "@repo/toolcraft-runtime": "workspace:*",
@@ -53,13 +55,14 @@ describe("createGeneratedPackageJson", () => {
     assert.deepEqual(packageJson, {
       name: "generated-app",
       private: true,
-      license: "SEE LICENSE IN LICENSE.md",
+      license: "MIT",
       type: "module",
       scripts: {
         dev: "vite dev",
-        test: "vitest run",
+        test: "node scripts/check-toolcraft-integrity.mjs && vitest run",
+        "verify:receipt": "node scripts/toolcraft-verification-receipt.mjs validate",
         "verify:final":
-          "npm run ai:check && npm run test && npm run build && npm run test:browser",
+          "npm run ai:check && npm run test && npm run build && npm run test:browser && npm run verify:receipt",
         "verify:perf": "npm run test:browser:perf",
         "verify:perf:playwright": "npm run test:browser:perf",
         "verify:quick": "npm run ai:check && npm run test",
@@ -84,6 +87,32 @@ describe("createGeneratedPackageJson", () => {
     );
   });
 
+  it("rejects starter manifests without the generated integrity test command", () => {
+    assert.throws(
+      () =>
+        createGeneratedPackageJson({
+          name: "Generated App",
+          starterPackageJson: { scripts: { test: "vitest run" } },
+        }),
+      /scripts\.test:generated is required/,
+    );
+  });
+
+  it("rejects starter manifests without the performance receipt validator", () => {
+    assert.throws(
+      () =>
+        createGeneratedPackageJson({
+          name: "Generated App",
+          starterPackageJson: {
+            scripts: {
+              "test:generated": "node scripts/check-toolcraft-integrity.mjs && vitest run",
+            },
+          },
+        }),
+      /scripts\.verify:receipt is required/,
+    );
+  });
+
   it("generates verification scripts for the selected package manager", () => {
     const packageJson = createGeneratedPackageJson({
       name: "Generated App",
@@ -91,13 +120,17 @@ describe("createGeneratedPackageJson", () => {
       starterPackageJson: {
         scripts: {
           dev: "vite dev",
+          "test:generated": "node scripts/check-toolcraft-integrity.mjs && vitest run",
+          "verify:receipt": "node scripts/toolcraft-verification-receipt.mjs validate",
         },
       },
     });
 
     assert.deepEqual(packageJson.scripts, {
       dev: "vite dev",
-      "verify:final": "pnpm ai:check && pnpm test && pnpm build && pnpm test:browser",
+      test: "node scripts/check-toolcraft-integrity.mjs && vitest run",
+      "verify:receipt": "node scripts/toolcraft-verification-receipt.mjs validate",
+      "verify:final": "pnpm ai:check && pnpm test && pnpm build && pnpm test:browser && pnpm verify:receipt",
       "verify:perf": "pnpm test:browser:perf",
       "verify:perf:playwright": "pnpm test:browser:perf",
       "verify:quick": "pnpm ai:check && pnpm test",

package/src/package-manager.mjs

@@ -39,6 +39,7 @@ const GENERATED_SCRIPT_COMMANDS = [
   "verify:perf",
   "verify:perf:playwright",
   "verify:quick",
+  "verify:receipt",
   "verify:ui",
 ];
 
@@ -101,6 +102,7 @@ export function createVerificationScripts(packageManager) {
       createRunScriptCommand(packageManager, "test"),
       createRunScriptCommand(packageManager, "build"),
       createRunScriptCommand(packageManager, "test:browser"),
+      createRunScriptCommand(packageManager, "verify:receipt"),
     ].join(" && "),
   };
 }

package/src/package-manager.test.mjs

@@ -42,7 +42,7 @@ describe("package manager commands", () => {
     assert.equal(createExecCommand("npm", "vite", ["dev"]), "npm exec -- vite dev");
     assert.deepEqual(createVerificationScripts("npm"), {
       "verify:final":
-        "npm run ai:check && npm run test && npm run build && npm run test:browser",
+        "npm run ai:check && npm run test && npm run build && npm run test:browser && npm run verify:receipt",
       "verify:perf": "npm run test:browser:perf",
       "verify:perf:playwright": "npm run test:browser:perf",
       "verify:quick": "npm run ai:check && npm run test",
@@ -60,6 +60,8 @@ describe("package manager commands", () => {
       "pnpm install",
       "pnpm verify:final",
       "pnpm verify:perf",
+      "pnpm verify:perf:record-exemption -- --tier=2",
+      "pnpm verify:receipt",
       "pnpm test:browser",
       "pnpm dev",
       "pnpm exec vite dev --host 127.0.0.1",
@@ -71,6 +73,8 @@ describe("package manager commands", () => {
         "npm install",
         "npm run verify:final",
         "npm run verify:perf",
+        "npm run verify:perf:record-exemption -- --tier=2",
+        "npm run verify:receipt",
         "npm run test:browser",
         "npm run dev",
         "npm exec -- vite dev --host 127.0.0.1",

package/src/packaged-template-fallback.test.mjs

@@ -0,0 +1,126 @@
+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 { it } from "node:test";
+
+import { copyDirectory } from "./copy-recursive.mjs";
+
+const execFileAsync = promisify(execFile);
+const cliSrcDir = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(cliSrcDir, "../..");
+
+async function stagePackageRepository(stagedRepoRoot) {
+  await Promise.all([
+    copyDirectory(path.join(repoRoot, "cli"), path.join(stagedRepoRoot, "cli")),
+    copyDirectory(path.join(repoRoot, "starter"), path.join(stagedRepoRoot, "starter")),
+    copyDirectory(
+      path.join(repoRoot, "packages/ui/src"),
+      path.join(stagedRepoRoot, "packages/ui/src"),
+    ),
+    copyDirectory(
+      path.join(repoRoot, "packages/toolcraft-runtime/src"),
+      path.join(stagedRepoRoot, "packages/toolcraft-runtime/src"),
+    ),
+  ]);
+}
+
+async function linkPackagedCliDependencies(packageRoot) {
+  const packageJson = JSON.parse(
+    await fs.readFile(path.join(packageRoot, "package.json"), "utf8"),
+  );
+
+  for (const packageName of Object.keys(packageJson.dependencies ?? {})) {
+    const sourcePath = await fs.realpath(
+      path.join(repoRoot, "cli/node_modules", packageName),
+    );
+    const targetPath = path.join(packageRoot, "node_modules", packageName);
+    await fs.mkdir(path.dirname(targetPath), { recursive: true });
+    await fs.symlink(sourcePath, targetPath, "dir");
+  }
+}
+
+it("packs, executes, and verifies the isolated npm package fallback", async () => {
+  const tempRoot = await fs.mkdtemp(
+    path.join(os.tmpdir(), "toolcraft-packaged-fallback-"),
+  );
+  const stagedRepoRoot = path.join(tempRoot, "staged-repository");
+  const stagedCliRoot = path.join(stagedRepoRoot, "cli");
+  const tarballRoot = path.join(tempRoot, "tarballs");
+  const extractedRoot = path.join(tempRoot, "extracted");
+  const outputRoot = path.join(tempRoot, "output");
+
+  try {
+    await stagePackageRepository(stagedRepoRoot);
+    await Promise.all([
+      fs.mkdir(tarballRoot, { recursive: true }),
+      fs.mkdir(extractedRoot, { recursive: true }),
+      fs.mkdir(outputRoot, { recursive: true }),
+    ]);
+
+    const packResult = await execFileAsync(
+      "npm",
+      ["pack", "--silent", "--json", "--pack-destination", tarballRoot],
+      { cwd: stagedCliRoot },
+    );
+    const [packedArtifact] = JSON.parse(packResult.stdout);
+    assert.ok(packedArtifact?.filename, "npm pack must report its tarball filename.");
+
+    const tarballPath = path.join(tarballRoot, packedArtifact.filename);
+    await execFileAsync("tar", ["-xzf", tarballPath, "-C", extractedRoot]);
+    const packageRoot = path.join(extractedRoot, "package");
+    const packagedFiles = [
+      "bin/create-toolcraft-app.mjs",
+      "bin/toolcraft.mjs",
+      "templates/starter/package.json",
+      "templates/runtime/index.ts",
+      "templates/ui/index.ts",
+    ];
+    for (const relativePath of packagedFiles) {
+      assert.equal(
+        (await fs.stat(path.join(packageRoot, relativePath))).isFile(),
+        true,
+        `Missing packaged file: ${relativePath}`,
+      );
+    }
+
+    await linkPackagedCliDependencies(packageRoot);
+    await execFileAsync(
+      process.execPath,
+      [
+        path.join(packageRoot, "bin/toolcraft.mjs"),
+        "create",
+        "packaged-app",
+        "--name",
+        "Packaged App",
+        "--yes",
+        "--force",
+        "--no-install",
+        "--no-skills",
+      ],
+      { cwd: outputRoot },
+    );
+    const compatibilityHelp = await execFileAsync(
+      process.execPath,
+      [path.join(packageRoot, "bin/create-toolcraft-app.mjs"), "--help"],
+      { cwd: outputRoot },
+    );
+    assert.match(compatibilityHelp.stdout, /Usage:/);
+
+    const targetDir = path.join(outputRoot, "packaged-app");
+    const integrityResult = await execFileAsync(
+      process.execPath,
+      [
+        path.join(targetDir, "scripts/check-toolcraft-integrity.mjs"),
+        "--platform-only",
+      ],
+      { cwd: targetDir },
+    );
+    assert.match(integrityResult.stdout, /Toolcraft integrity check passed/);
+  } finally {
+    await fs.rm(tempRoot, { force: true, recursive: true });
+  }
+});

package/src/prepare-pack-templates.mjs

@@ -0,0 +1,34 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { copyDirectory, removeDirectory } from "./copy-recursive.mjs";
+
+export async function preparePackTemplates({ packageRoot, repoRoot }) {
+  const templatesRoot = path.join(packageRoot, "templates");
+  const sources = [
+    {
+      from: path.join(repoRoot, "starter"),
+      to: path.join(templatesRoot, "starter"),
+    },
+    {
+      from: path.join(repoRoot, "packages/ui/src"),
+      to: path.join(templatesRoot, "ui"),
+    },
+    {
+      from: path.join(repoRoot, "packages/toolcraft-runtime/src"),
+      to: path.join(templatesRoot, "runtime"),
+    },
+  ];
+
+  await removeDirectory(templatesRoot);
+  for (const source of sources) {
+    await copyDirectory(source.from, source.to);
+  }
+
+  await fs.copyFile(
+    path.join(templatesRoot, "starter/.gitignore"),
+    path.join(templatesRoot, "starter/gitignore"),
+  );
+
+  return templatesRoot;
+}

package/templates/runtime/contracts/component-contract-builders.ts

@@ -0,0 +1,95 @@
+import type {
+  ToolcraftControlDecisionCatalog,
+  ToolcraftLabelPolicy,
+  ToolcraftPanelPlacement,
+  ToolcraftPanelSnapEdge,
+  ToolcraftSectionLayout,
+} from "./types";
+
+export function decisionCatalog(
+  catalog: ToolcraftControlDecisionCatalog,
+): ToolcraftControlDecisionCatalog {
+  return catalog;
+}
+
+export function control<
+  const Id extends string,
+  const VisualComponent extends string,
+  const SectionLayout extends ToolcraftSectionLayout,
+  const LabelPolicy extends ToolcraftLabelPolicy,
+>(
+  id: Id,
+  visualComponent: VisualComponent,
+  defaultSectionLayout: SectionLayout,
+  labelPolicy: LabelPolicy,
+): {
+  readonly defaultSectionLayout: SectionLayout;
+  readonly historyPolicy: "patch";
+  readonly id: Id;
+  readonly kind: "control";
+  readonly labelPolicy: LabelPolicy;
+  readonly schemaType: Id;
+  readonly stateMode: "controlled";
+  readonly visualComponent: VisualComponent;
+} {
+  return {
+    defaultSectionLayout,
+    historyPolicy: "patch",
+    id,
+    kind: "control",
+    labelPolicy,
+    schemaType: id,
+    stateMode: "controlled",
+    visualComponent,
+  };
+}
+
+export function panel<
+  const Id extends string,
+  const VisualComponent extends string,
+  const Placement extends ToolcraftPanelPlacement,
+  const SnapEdges extends readonly ToolcraftPanelSnapEdge[],
+  const DragMode extends "handle" | "panel",
+>(
+  id: Id,
+  visualComponent: VisualComponent,
+  defaultPlacement: Placement,
+  snapEdges: SnapEdges,
+  dragMode: DragMode,
+): {
+  readonly aiUsageRules: readonly [`Render ${VisualComponent} only through PanelHost.`];
+  readonly capabilities: readonly [
+    "draggable",
+    "snap",
+    "doubleClickReset",
+    `dragMode:${DragMode}`,
+  ];
+  readonly defaultPlacement: Placement;
+  readonly historyPolicy: "optional";
+  readonly id: Id;
+  readonly kind: "panel";
+  readonly requiredWrapper: "PanelHost";
+  readonly schemaType: Id;
+  readonly snapEdges: SnapEdges;
+  readonly stateMode: "runtime-owned";
+  readonly visualComponent: VisualComponent;
+} {
+  return {
+    aiUsageRules: [`Render ${visualComponent} only through PanelHost.`],
+    capabilities: [
+      "draggable",
+      "snap",
+      "doubleClickReset",
+      `dragMode:${dragMode}` as const,
+    ],
+    defaultPlacement,
+    historyPolicy: "optional",
+    id,
+    kind: "panel",
+    requiredWrapper: "PanelHost",
+    schemaType: id,
+    snapEdges,
+    stateMode: "runtime-owned",
+    visualComponent,
+  };
+}