@pixel-point/toolcraft 0.0.15 → 0.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pixel-point/toolcraft",
-  "version": "0.0.15",
+  "version": "0.0.16",
   "license": "SEE LICENSE IN LICENSE.md",
   "type": "module",
   "bin": {

package/src/cli-package-manager-flow.test.mjs

@@ -73,9 +73,16 @@ describe("runToolcraftCli package manager flows", () => {
       await fs.readFile(path.join(tempRoot, "install-app/package.json"), "utf8"),
     );
     assert.equal(
-      packageJson.scripts["verify:final"],
-      "npm run ai:check && npm run test && npm run build && npm run test:browser && npm run verify:receipt",
+      packageJson.scripts["verify:delivery"],
+      "node scripts/run-delivery-verification.mjs",
     );
+    assert.equal(
+      packageJson.scripts["verify:perf"],
+      "node scripts/run-browser-performance.mjs",
+    );
+    assert.equal(packageJson.scripts["verify:quick"], undefined);
+    assert.equal(packageJson.scripts["verify:ui"], undefined);
+    assert.equal(packageJson.scripts["verify:final"], undefined);
 
     const playwrightConfigSource = await fs.readFile(
       path.join(tempRoot, "install-app/playwright.config.ts"),

package/src/cli.test.mjs

@@ -340,22 +340,17 @@ describe("runToolcraftCli", () => {
 
     assert.deepEqual(commands, []);
 
-    const cleanHome = path.join(tempRoot, "clean-home");
-    await fs.mkdir(cleanHome, { recursive: true });
-    const aiCheck = await execFileAsync("npm", ["run", "ai:check"], {
-      cwd: path.join(tempRoot, "no-skills-app"),
-      env: {
-        ...process.env,
-        CLAUDE_HOME: path.join(cleanHome, ".claude"),
-        CODEX_HOME: path.join(cleanHome, ".codex"),
-        HOME: cleanHome,
-        XDG_CONFIG_HOME: path.join(cleanHome, ".config"),
-      },
-    });
-
-    assert.match(aiCheck.stdout, /Toolcraft code health check passed/);
-    assert.match(aiCheck.stderr, /Optional AI workflow skills are not installed/);
-    assert.match(aiCheck.stderr, /Continue with the local Toolcraft workflow/);
+    await assert.rejects(
+      fs.stat(
+        path.join(
+          tempRoot,
+          "no-skills-app",
+          "scripts",
+          "check-ai-skills.mjs",
+        ),
+      ),
+      { code: "ENOENT" },
+    );
   });
 
   it("prints create help with the npx command", async () => {

package/src/create-command.mjs

@@ -8,7 +8,10 @@ import { installGeneratedAppDependencies } from "./dependency-install.mjs";
 import { generateToolcraft } from "./generate.mjs";
 import { resolveCreateOptions } from "./create-options.mjs";
 import { canUseClack, getStdout, runCommand, runWithSpinner, writeLine } from "./cli-io.mjs";
-import { createRunScriptCommand, detectPackageManager } from "./package-manager.mjs";
+import {
+  createRunScriptCommand,
+  detectPackageManagerForDirectory,
+} from "./package-manager.mjs";
 
 const PACKAGE_ROOT = path.resolve(fileURLToPath(new URL("..", import.meta.url)));
 const require = createRequire(import.meta.url);
@@ -100,9 +103,12 @@ export async function runCreateCommand(parsedOptions, context = {}) {
   const cwd = path.resolve(context.cwd ?? process.cwd());
   const stdout = getStdout(context);
   const usingClack = canUseClack(context);
-  const packageManager = detectPackageManager({
-    ...process.env,
-    ...(context.env ?? {}),
+  const packageManager = await detectPackageManagerForDirectory({
+    cwd,
+    env: {
+      ...process.env,
+      ...(context.env ?? {}),
+    },
   });
 
   if (usingClack) {

package/src/generate-demand-only-lifecycle.test.mjs

@@ -0,0 +1,102 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import {
+  assertGeneratedFreshDemandOnlyLifecycle,
+} from "./generate-test-demand-only-lifecycle.mjs";
+import {
+  createManagedExecFileRunner,
+} from "./generate-test-managed-process.mjs";
+import {
+  loadGeneratedProofModule,
+} from "./generate-test-dependency-sandbox.mjs";
+import {
+  installGeneratedAppDependencies,
+} from "./dependency-install.mjs";
+import { generateToolcraft } from "./generate.mjs";
+
+test("fresh generated app runs initial proof then one semantic material delivery", async (t) => {
+  const tempRoot = await fs.mkdtemp(
+    path.join(os.tmpdir(), "toolcraft-demand-only-lifecycle-"),
+  );
+  const targetDir = path.join(tempRoot, "generated-demand-only-app");
+  const runner = createManagedExecFileRunner();
+  let testPort;
+  t.after(async () => {
+    try {
+      await runner.cleanup();
+      if (testPort !== undefined) {
+        const { waitForPortAvailable } = await loadGeneratedProofModule(
+          targetDir,
+          "scripts/toolcraft-port.mjs",
+        );
+        assert.equal(
+          await waitForPortAvailable(testPort, { timeoutMs: 5_000 }),
+          true,
+          `Generated lifecycle left exact port ${testPort} occupied.`,
+        );
+      }
+    } finally {
+      await fs.rm(tempRoot, { force: true, recursive: true });
+    }
+  });
+
+  await generateToolcraft({
+    cwd: tempRoot,
+    force: true,
+    name: "Generated Demand Only App",
+    packageManager: "pnpm",
+    targetDir: "generated-demand-only-app",
+  });
+
+  const { findAvailablePort } = await loadGeneratedProofModule(
+    targetDir,
+    "scripts/toolcraft-port.mjs",
+  );
+  testPort = await findAvailablePort(
+    39_000 + (process.pid % 10_000),
+  );
+  await assert.rejects(
+    fs.stat(path.join(targetDir, "node_modules")),
+    /ENOENT/u,
+  );
+  await installGeneratedAppDependencies({
+    context: {
+      env: { CI: "1" },
+      runCommand: runner.execFile,
+    },
+    packageManager: "pnpm",
+    result: { targetDir },
+    skillsRequested: false,
+    stdout: { write() {} },
+  });
+  assert.ok(await fs.stat(path.join(targetDir, "node_modules")));
+
+  await assertGeneratedFreshDemandOnlyLifecycle({
+    browserEnv: {
+      TOOLCRAFT_RESOLVED_TEST_PORT: String(testPort),
+      TOOLCRAFT_TEST_PORT: String(testPort),
+    },
+    execFileAsync: runner.execFile,
+    targetDir,
+  });
+  assert.deepEqual(runner.getInvocations(), [
+    { args: ["install"], command: "pnpm" },
+    {
+      args: [
+        "exec",
+        "playwright",
+        "test",
+        "--list",
+        "--grep",
+        "browser perf:",
+      ],
+      command: "pnpm",
+    },
+    { args: ["verify:delivery"], command: "pnpm" },
+    { args: ["verify:delivery"], command: "pnpm" },
+  ]);
+});

package/src/generate-performance-iteration-execution.test.mjs

@@ -0,0 +1,105 @@
+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 test from "node:test";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { promisify } from "node:util";
+
+import { generateToolcraft } from "./generate.mjs";
+
+const execFileAsync = promisify(execFile);
+const repoRoot = path.resolve(
+  fileURLToPath(new URL("../..", import.meta.url)),
+);
+
+test("generated standalone app preserves authority-bound performance iteration lifecycle tests", async (t) => {
+  const tempRoot = await fs.mkdtemp(
+    path.join(os.tmpdir(), "toolcraft-generated-performance-"),
+  );
+  t.after(() => fs.rm(tempRoot, { force: true, recursive: true }));
+  const targetDir = path.join(tempRoot, "generated-app");
+
+  await generateToolcraft({
+    cwd: tempRoot,
+    force: true,
+    name: "Generated Performance App",
+    packageManager: "pnpm",
+    targetDir: "generated-app",
+  });
+  const [
+    checkpointModule,
+    planModule,
+    receiptModule,
+    targetedReportModule,
+  ] = await Promise.all(
+    [
+      "toolcraft-checkpoint-bundle.mjs",
+      "toolcraft-delivery-plan.mjs",
+      "toolcraft-delivery-receipt.mjs",
+      "toolcraft-targeted-performance-report.mjs",
+    ].map((fileName) =>
+      import(pathToFileURL(path.join(targetDir, "scripts", fileName)).href),
+    ),
+  );
+  assert.deepEqual(
+    [
+      checkpointModule.TOOLCRAFT_CHECKPOINT_BUNDLE_VERSION,
+      planModule.TOOLCRAFT_DELIVERY_PLAN_VERSION,
+      receiptModule.TOOLCRAFT_DELIVERY_RECEIPT_VERSION,
+      targetedReportModule.TOOLCRAFT_TARGETED_PERFORMANCE_REPORT_VERSION,
+    ],
+    [1, 4, 7, 3],
+  );
+  const authorityPolicySource = await fs.readFile(
+    path.join(
+      targetDir,
+      "scripts",
+      "toolcraft-performance-authority-policy.mjs",
+    ),
+    "utf8",
+  );
+  assert.doesNotMatch(authorityPolicySource, /@repo\//u);
+  assert.match(
+    authorityPolicySource,
+    /\.\.\/src\/toolcraft\/runtime\/testing\/performance-path-codec\.mjs/u,
+  );
+  assert.match(
+    authorityPolicySource,
+    /\.\.\/src\/toolcraft\/runtime\/contracts\/performance-request-evidence-policy\.mjs/u,
+  );
+  await fs.symlink(
+    path.join(repoRoot, "starter", "node_modules"),
+    path.join(targetDir, "node_modules"),
+    process.platform === "win32" ? "junction" : "dir",
+  );
+
+  const childEnv = { ...process.env };
+  delete childEnv.NODE_TEST_CONTEXT;
+  let stderr;
+  let stdout;
+  try {
+    ({ stderr, stdout } = await execFileAsync(
+      process.execPath,
+      [
+        "--test",
+        "--test-reporter=tap",
+        "scripts/toolcraft-delivery-plan-authority.test.mjs",
+        "scripts/toolcraft-delivery-performance-iteration-lifecycle.test.mjs",
+      ],
+      {
+        cwd: targetDir,
+        env: childEnv,
+        maxBuffer: 20 * 1024 * 1024,
+      },
+    ));
+  } catch (error) {
+    assert.fail(`${error.stdout ?? ""}\n${error.stderr ?? String(error)}`);
+  }
+  const output = `${stdout}\n${stderr}`;
+  assert.doesNotMatch(output, /ERR_MODULE_NOT_FOUND/u);
+  assert.match(output, /^# tests 9$/mu);
+  assert.match(output, /^# pass 9$/mu);
+  assert.match(output, /^# fail 0$/mu);
+});

package/src/generate-test-assertions.mjs

@@ -12,11 +12,13 @@ import {
   assertGeneratedGitignore,
   assertGeneratedIdentity,
   assertGeneratedPackageJson,
+  assertGeneratedPersistenceBoundary,
 } from "./generate-test-package-assertions.mjs";
 
 export async function assertGeneratedStandaloneApp({ execFileAsync, targetDir }) {
   await assertGeneratedPackageJson(targetDir);
   await assertGeneratedIdentity(targetDir);
+  await assertGeneratedPersistenceBoundary(targetDir);
   await assertGeneratedFiles(targetDir);
   await assertGeneratedGitignore(targetDir);
   await assertGeneratedAppPerformance(targetDir);

package/src/generate-test-browser-execution-ledger.mjs

@@ -0,0 +1,138 @@
+import assert from "node:assert/strict";
+import { randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import {
+  runGeneratedScript,
+} from "./generate-test-dependency-sandbox.mjs";
+
+function compareCodeUnits(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+function canonicalFunctionalRows(rows) {
+  return rows
+    .map(({ file, leafTitle }) => ({ file, leafTitle }))
+    .sort((left, right) =>
+      compareCodeUnits(
+        `${left.file}\0${left.leafTitle}`,
+        `${right.file}\0${right.leafTitle}`,
+      ),
+    );
+}
+
+function assertGeneratedBrowserExecutionLedgers({
+  ledgers,
+  nonce,
+}) {
+  assert.ok(ledgers.length > 0);
+  const tests = [];
+  for (const ledger of ledgers) {
+    assert.equal(ledger.version, 1);
+    assert.equal(ledger.nonce, nonce);
+    assert.equal(ledger.status, "passed");
+    tests.push(...ledger.tests);
+  }
+  assert.equal(
+    new Set(tests.map(({ fullTitle }) => fullTitle)).size,
+    tests.length,
+    "Browser execution ledgers contain a title collision.",
+  );
+  return tests;
+}
+
+export function assertGeneratedExecutionLedger({
+  expectedFunctionalRows,
+  expectedPerformanceEvidence,
+  tests,
+}) {
+  const unmatchedFunctional = canonicalFunctionalRows(
+    expectedFunctionalRows.map(({ file, testName }) => ({
+      file,
+      leafTitle: testName,
+    })),
+  );
+  const unmatchedPerformance = [...expectedPerformanceEvidence]
+    .map(({ fullTitle, leafTitle }) => ({ fullTitle, leafTitle }))
+    .sort((left, right) =>
+      compareCodeUnits(left.fullTitle, right.fullTitle),
+    );
+  for (const test of tests) {
+    assert.equal(test.status, "passed");
+    const functionalIndex = unmatchedFunctional.findIndex(
+      ({ file, leafTitle }) =>
+        file === test.file && leafTitle === test.leafTitle,
+    );
+    const performanceIndex = unmatchedPerformance.findIndex(
+      ({ fullTitle, leafTitle }) =>
+        fullTitle === test.fullTitle && leafTitle === test.leafTitle,
+    );
+    assert.equal(
+      Number(functionalIndex >= 0) + Number(performanceIndex >= 0),
+      1,
+      `Browser execution ledger contains unplanned or ambiguous test "${test.fullTitle}".`,
+    );
+    if (functionalIndex >= 0) {
+      unmatchedFunctional.splice(functionalIndex, 1);
+    } else {
+      unmatchedPerformance.splice(performanceIndex, 1);
+    }
+  }
+  assert.deepEqual(
+    {
+      functional: unmatchedFunctional,
+      performance: unmatchedPerformance,
+    },
+    { functional: [], performance: [] },
+  );
+}
+
+export async function runGeneratedDeliveryWithLedger({
+  env = {},
+  execFileAsync,
+  targetDir,
+}) {
+  const nonce = randomUUID();
+  const ledgerDirectory = path.join(
+    targetDir,
+    ".toolcraft",
+    "verification",
+    `browser-execution-${nonce}`,
+  );
+  await fs.rm(ledgerDirectory, { force: true, recursive: true });
+  try {
+    const result = await runGeneratedScript(
+      execFileAsync,
+      targetDir,
+      "verify:delivery",
+      {
+        env: {
+          ...env,
+          TOOLCRAFT_BROWSER_EXECUTION_LEDGER_DIRECTORY:
+            ledgerDirectory,
+          TOOLCRAFT_BROWSER_EXECUTION_LEDGER_NONCE: nonce,
+        },
+      },
+    );
+    const ledgers = await Promise.all(
+      (await fs.readdir(ledgerDirectory))
+        .sort(compareCodeUnits)
+        .map(async (fileName) =>
+          JSON.parse(
+            await fs.readFile(
+              path.join(ledgerDirectory, fileName),
+              "utf8",
+            ),
+          ),
+        ),
+    );
+    const tests = assertGeneratedBrowserExecutionLedgers({
+      ledgers,
+      nonce,
+    });
+    return { ledgers, result, tests };
+  } finally {
+    await fs.rm(ledgerDirectory, { force: true, recursive: true });
+  }
+}

package/src/generate-test-browser-execution-ledger.test.mjs

@@ -0,0 +1,87 @@
+import assert from "node:assert/strict";
+import { it } from "node:test";
+
+import {
+  assertGeneratedExecutionLedger,
+} from "./generate-test-browser-execution-ledger.mjs";
+
+const functional = Object.freeze({
+  file: "e2e/app-controls.spec.ts",
+  fullTitle:
+    "e2e/app-controls.spec.ts › browser: output changes",
+  leafTitle: "browser: output changes",
+  status: "passed",
+});
+const performance = Object.freeze({
+  file: "e2e/app-performance.spec.ts",
+  fullTitle:
+    "e2e/app-performance.spec.ts › browser perf: preview path",
+  leafTitle: "browser perf: preview path",
+  status: "passed",
+});
+
+it("accepts the exact functional and performance execution union", () => {
+  assert.doesNotThrow(() =>
+    assertGeneratedExecutionLedger({
+      expectedFunctionalRows: [
+        {
+          file: functional.file,
+          testName: functional.leafTitle,
+        },
+      ],
+      expectedPerformanceEvidence: [
+        {
+          fullTitle: performance.fullTitle,
+          leafTitle: performance.leafTitle,
+        },
+      ],
+      tests: [functional, performance],
+    }),
+  );
+});
+
+it("rejects a known unrelated acceptance outside the exact subset", () => {
+  const unrelatedAcceptance = {
+    file: "e2e/unrelated.spec.ts",
+    fullTitle:
+      "unrelated.spec.ts › browser: unrelated acceptance",
+    leafTitle: "browser: unrelated acceptance",
+    status: "passed",
+  };
+  assert.throws(
+    () =>
+      assertGeneratedExecutionLedger({
+        expectedFunctionalRows: [
+          {
+            file: functional.file,
+            testName: functional.leafTitle,
+          },
+        ],
+        expectedPerformanceEvidence: [],
+        tests: [functional, unrelatedAcceptance],
+      }),
+    /unplanned or ambiguous test/u,
+  );
+});
+
+it("rejects missing expected execution from either proof set", () => {
+  assert.throws(
+    () =>
+      assertGeneratedExecutionLedger({
+        expectedFunctionalRows: [
+          {
+            file: functional.file,
+            testName: functional.leafTitle,
+          },
+        ],
+        expectedPerformanceEvidence: [
+          {
+            fullTitle: performance.fullTitle,
+            leafTitle: performance.leafTitle,
+          },
+        ],
+        tests: [functional],
+      }),
+    /Expected values to be strictly deep-equal/u,
+  );
+});

package/src/generate-test-delivery-architecture-assertions.mjs

@@ -0,0 +1,137 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+export const deliveryArchitecturePaths = Object.freeze([
+  "e2e/toolcraft-delivery-catalog-reporter.ts",
+  "scripts/run-delivery-verification.mjs",
+  "scripts/toolcraft-delivery-anchor.mjs",
+  "scripts/toolcraft-delivery-executor.mjs",
+  "scripts/toolcraft-delivery-functional-context.d.mts",
+  "scripts/toolcraft-delivery-functional-context.mjs",
+  "scripts/toolcraft-delivery-plan-construction.mjs",
+  "scripts/toolcraft-delivery-plan.mjs",
+  "scripts/toolcraft-functional-proof-model.d.mts",
+  "scripts/toolcraft-functional-proof-model.mjs",
+  "scripts/toolcraft-functional-proof-primitives.d.mts",
+  "scripts/toolcraft-functional-proof-primitives.mjs",
+  "scripts/toolcraft-proof-process.mjs",
+  "scripts/toolcraft-verification-impact-inventory.d.mts",
+  "scripts/toolcraft-verification-impact-inventory.mjs",
+  "scripts/toolcraft-verification-impact.mjs",
+  "scripts/toolcraft-verification-input-roles.d.mts",
+  "scripts/toolcraft-verification-input-roles.mjs",
+]);
+
+async function readGeneratedScript(targetDir, relativePath) {
+  return fs.readFile(path.join(targetDir, "scripts", relativePath), "utf8");
+}
+
+async function assertGeneratedInputRoleBehavior(targetDir) {
+  const scriptsDir = path.join(targetDir, "scripts");
+  const [
+    { toolcraftVerificationInputRootFamilies },
+    { createToolcraftProductVerificationContext },
+  ] = await Promise.all([
+    import(
+      pathToFileURL(
+        path.join(
+          scriptsDir,
+          "toolcraft-verification-input-roles.mjs",
+        ),
+      ).href
+    ),
+    import(
+      pathToFileURL(
+        path.join(scriptsDir, "toolcraft-verification-impact.mjs"),
+      ).href
+    ),
+  ]);
+  const { generated, starter } = toolcraftVerificationInputRootFamilies;
+  const generatedPaths = [
+    ...generated.runtimeRootPaths,
+    ...generated.semanticProofRootPaths,
+  ];
+  const starterPaths = [
+    ...starter.runtimeRootPaths,
+    ...starter.semanticProofRootPaths,
+  ];
+  assert.equal(
+    generatedPaths.some((repoPath) => starterPaths.includes(repoPath)),
+    false,
+    "Generated and starter semantic root families must stay distinct.",
+  );
+  const { inputRoles: roles } =
+    await createToolcraftProductVerificationContext(targetDir);
+  assert.equal(roles.rootFamily, generated.name);
+  assert.equal(
+    roles.impactInventoryPath,
+    generated.impactInventoryPath,
+  );
+  assert.equal(
+    roles.runtimeProductionPaths.includes(generated.compositionPath),
+    true,
+  );
+}
+
+export async function assertGeneratedDeliveryArchitecture(targetDir) {
+  for (const relativePath of deliveryArchitecturePaths) {
+    assert.ok(
+      await fs.stat(path.join(targetDir, relativePath)),
+      `Generated output must contain ${relativePath}.`,
+    );
+  }
+
+  const sources = {
+    catalog: await readGeneratedScript(
+      targetDir,
+      "playwright-test-title-selection.mjs",
+    ),
+    impact: await readGeneratedScript(
+      targetDir,
+      "toolcraft-verification-impact-inventory.mjs",
+    ),
+    model: await readGeneratedScript(
+      targetDir,
+      "toolcraft-functional-proof-model.mjs",
+    ),
+    plan: await readGeneratedScript(
+      targetDir,
+      "toolcraft-delivery-plan.mjs",
+    ),
+    receipt: await readGeneratedScript(
+      targetDir,
+      "toolcraft-delivery-receipt.mjs",
+    ),
+    resolution: await readGeneratedScript(
+      targetDir,
+      "toolcraft-verification-impact-resolution.mjs",
+    ),
+  };
+
+  assert.match(sources.catalog, /Delivery catalog\.version must be 2/);
+  assert.match(
+    sources.impact,
+    /TOOLCRAFT_VERIFICATION_IMPACT_VERSION = 3/,
+  );
+  assert.match(
+    sources.model,
+    /TOOLCRAFT_FUNCTIONAL_PROOF_MODEL_VERSION = 1/,
+  );
+  assert.match(sources.plan, /TOOLCRAFT_DELIVERY_PLAN_VERSION = 4/);
+  assert.match(sources.receipt, /TOOLCRAFT_DELIVERY_RECEIPT_VERSION = 7/);
+  assert.doesNotMatch(
+    sources.resolution,
+    /createCompleteCurrentProof|requiresCompleteCurrentProofForPath/,
+  );
+  assert.doesNotMatch(
+    sources.plan,
+    /TOOLCRAFT_DELIVERY_PLAN_VERSION = [123]\b/,
+  );
+  assert.doesNotMatch(
+    sources.receipt,
+    /TOOLCRAFT_DELIVERY_RECEIPT_VERSION = [1-6]\b/,
+  );
+  await assertGeneratedInputRoleBehavior(targetDir);
+}