@akanjs/devkit 3.0.0-beta.19 → 3.0.0-beta.20

package/platformTest/PlatformTestTarget.ts

@@ -36,6 +36,15 @@ export interface PlatformRunContext {
 export abstract class PlatformTestTarget {
   static readonly installIdleMs = 5 * 60_000;
   static readonly testIdleMs = 2 * 60_000;
+  protected static readonly gitIdentityEnv = {
+    GIT_AUTHOR_NAME: "akan-test",
+    GIT_AUTHOR_EMAIL: "akan-test@localhost",
+    GIT_COMMITTER_NAME: "akan-test",
+    GIT_COMMITTER_EMAIL: "akan-test@localhost",
+    GIT_CONFIG_COUNT: "1",
+    GIT_CONFIG_KEY_0: "init.defaultBranch",
+    GIT_CONFIG_VALUE_0: "main",
+  };
 
   abstract readonly platform: RemoteTestPlatform;
   abstract readonly policy: PlatformGatePolicy;
@@ -103,8 +112,7 @@ export abstract class PlatformTestTarget {
     const tolerable =
       failedScripts.length > 0 && failedScripts.every((pkg) => this.tolerateScriptFailures.includes(pkg));
     if (!tolerable) throw new Error(`bun install failed — see ${logPath}`);
-    //* A failed lifecycle script makes bun skip linking the workspace root's `.bin`, so every tool the suites
-    //* spawn from there disappears; a second pass without scripts links them.
+    //* A failed lifecycle script makes bun skip linking the root `.bin`; a second pass without scripts links it.
     envWarnings.push(`install script failed for ${failedScripts.join(", ")} — tolerated on ${this.platform}`);
     const relink = await this.exec(
       "bun install --frozen-lockfile --ignore-scripts",
@@ -117,4 +125,18 @@ export abstract class PlatformTestTarget {
   #logPath(context: PlatformRunContext, name: string) {
     return path.join(context.logDir, this.platform, `${name}.log`);
   }
+
+  protected static async spawnText(command: string[], stdin?: string) {
+    const proc = Bun.spawn(command, {
+      stdin: stdin === undefined ? "ignore" : new Response(stdin),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ]);
+    return { stdout, stderr, exitCode };
+  }
 }

package/platformTest/TestSnapshot.test.ts

@@ -1,10 +1,10 @@
-import { afterAll, describe, expect, test } from "bun:test";
-import { mkdir, mkdtemp, rm, unlink, writeFile } from "node:fs/promises";
-import os from "node:os";
+import { describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
 import path from "node:path";
+import { tempDirs, writeText } from "../testHelpers";
 import { TestSnapshot } from "./TestSnapshot";
 
-const roots: string[] = [];
+const makeRoot = tempDirs("akan-snapshot-");
 const git = async (cwd: string, ...args: string[]) => {
   const proc = Bun.spawn(["git", ...args], {
     cwd,
@@ -20,13 +20,9 @@ const git = async (cwd: string, ...args: string[]) => {
   });
   expect(await proc.exited).toBe(0);
 };
-const write = async (root: string, file: string, content: string) => {
-  await mkdir(path.dirname(path.join(root, file)), { recursive: true });
-  await writeFile(path.join(root, file), content);
-};
+const write = async (root: string, file: string, content: string) => await writeText(path.join(root, file), content);
 const makeRepo = async () => {
-  const root = await mkdtemp(path.join(os.tmpdir(), "akan-snapshot-"));
-  roots.push(root);
+  const root = await makeRoot();
   await git(root, "init", "-q");
   await write(root, ".gitignore", "ignored/\nlocal/\n.env\n");
   await write(root, "tracked.ts", "export {};\n");
@@ -44,10 +40,6 @@ const tarEntries = async (tarPath: string) => {
   return (await new Response(proc.stdout).text()).split(/\r?\n/).filter(Boolean).sort();
 };
 
-afterAll(async () => {
-  await Promise.all(roots.map((root) => rm(root, { recursive: true, force: true })));
-});
-
 describe("TestSnapshot", () => {
   test("packs what git would show — tracked and untracked, never ignored or deleted", async () => {
     const root = await makeRepo();

package/platformTest/TestSnapshot.ts

@@ -7,11 +7,7 @@ export interface SnapshotDrift {
   removed: string[];
 }
 
-/**
- * The exact bytes a platform run tests: every tracked file plus every untracked one git would show, which is
- * what `akan deploy-akan` goes on to build and publish. The per-file hashes are kept so the tree can be
- * compared again before publishing — a test run is only a gate if nothing changed underneath it.
- */
+//? Per-file hashes are kept so the tree is re-checked before publishing: a run gates only if nothing changed under it.
 export class TestSnapshot {
   static readonly #secretPatterns = [
     /(^|\/)\.env(\.(?!(template|example|sample)$)[^/]+)?$/,

package/platformTest/WindowsSshTarget.ts

@@ -48,7 +48,7 @@ export class WindowsSshTarget extends PlatformTestTarget {
       [context.snapshot.tarPath, "src.tar"],
       [context.envPath, "env"],
     ] as const) {
-      const copied = await WindowsSshTarget.#run([
+      const copied = await WindowsSshTarget.spawnText([
         ...this.#scpBase(),
         local,
         this.#remoteScpPath(`${runDir}\\${remoteName}`),
@@ -71,13 +71,7 @@ export class WindowsSshTarget extends PlatformTestTarget {
       "$ProgressPreference = 'SilentlyContinue'",
       "[Console]::OutputEncoding = [Text.Encoding]::UTF8",
       "'PID=' + $PID",
-      "$env:GIT_AUTHOR_NAME = 'akan-test'",
-      "$env:GIT_AUTHOR_EMAIL = 'akan-test@localhost'",
-      "$env:GIT_COMMITTER_NAME = 'akan-test'",
-      "$env:GIT_COMMITTER_EMAIL = 'akan-test@localhost'",
-      "$env:GIT_CONFIG_COUNT = '1'",
-      "$env:GIT_CONFIG_KEY_0 = 'init.defaultBranch'",
-      "$env:GIT_CONFIG_VALUE_0 = 'main'",
+      ...Object.entries(PlatformTestTarget.gitIdentityEnv).map(([key, value]) => `$env:${key} = '${value}'`),
       `Set-Location -LiteralPath '${runDir}\\w'`,
       `cmd /c "${command} 2>&1"`,
       "exit $LASTEXITCODE",
@@ -112,10 +106,10 @@ export class WindowsSshTarget extends PlatformTestTarget {
     const vm = this.#config.utmVm;
     if (!vm || !existsSync(WindowsSshTarget.utmctlPath))
       throw new Error(`cannot reach ${this.#config.user}@${this.#host} over ssh`);
-    const status = (await WindowsSshTarget.#run([WindowsSshTarget.utmctlPath, "status", vm])).stdout.trim();
-    if (status !== "started") await WindowsSshTarget.#run([WindowsSshTarget.utmctlPath, "start", vm]);
+    const status = (await WindowsSshTarget.spawnText([WindowsSshTarget.utmctlPath, "status", vm])).stdout.trim();
+    if (status !== "started") await WindowsSshTarget.spawnText([WindowsSshTarget.utmctlPath, "start", vm]);
     for (let attempt = 0; attempt < 24; attempt++) {
-      const addresses = (await WindowsSshTarget.#run([WindowsSshTarget.utmctlPath, "ip-address", vm])).stdout;
+      const addresses = (await WindowsSshTarget.spawnText([WindowsSshTarget.utmctlPath, "ip-address", vm])).stdout;
       const ipv4 = addresses.split(/\s+/).find((address) => /^\d+\.\d+\.\d+\.\d+$/.test(address));
       if (ipv4) this.#host = ipv4;
       if ((await this.#ssh("exit 0")).exitCode === 0) return;
@@ -152,16 +146,6 @@ export class WindowsSshTarget extends PlatformTestTarget {
   }
 
   async #ssh(script: string) {
-    return await WindowsSshTarget.#run([...this.#sshBase(), script]);
-  }
-
-  static async #run(command: string[]) {
-    const proc = Bun.spawn(command, { stdin: "ignore", stdout: "pipe", stderr: "pipe" });
-    const [stdout, stderr, exitCode] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-      proc.exited,
-    ]);
-    return { stdout, stderr, exitCode };
+    return await WindowsSshTarget.spawnText([...this.#sshBase(), script]);
   }
 }

package/prompter.ts

@@ -1,7 +1,7 @@
 import fsPromise from "node:fs/promises";
 import { input, select } from "@inquirer/prompts";
 
-import { getDirname } from "./getDirname";
+import { getDirname } from "./fileSys";
 
 interface FileUpdateRequestProps {
   context: string;
@@ -33,11 +33,8 @@ export class Prompter {
     const guidelineRoot = await Prompter.#getGuidelineRoot();
     return (await fsPromise.readdir(guidelineRoot)).filter((name) => !name.startsWith("_")).sort();
   }
-  /**
-   * The name is checked against the directory listing rather than interpolated straight into a path:
-   * it arrives from an MCP tool argument, and an unknown one has to name the valid set instead of
-   * surfacing an ENOENT that carries the host's own paths.
-   */
+  // Checked against the listing, not interpolated into a path: the name is an MCP tool argument, and an unknown one
+  // must not surface an ENOENT carrying the host's paths.
   static async getInstruction(guideName: string): Promise<string> {
     const guideNames = await Prompter.listGuidelines();
     if (!guideNames.includes(guideName))

package/qualityScanner.test.ts

@@ -1,30 +1,21 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
+import { describe, expect, test } from "bun:test";
 import path from "node:path";
 import { AbstractDoc } from "./abstractDoc";
 import { AkanQualityScanner, type QualityScanResult } from "./qualityScanner";
+import { tempDirs, writeText } from "./testHelpers";
 
-const tempRoots: string[] = [];
+const makeTempRoot = tempDirs("akan-quality-scanner-");
 
 const makeWorkspace = async (files: Record<string, string>) => {
-  const root = await mkdtemp(path.join(os.tmpdir(), "akan-quality-scanner-"));
-  tempRoots.push(root);
-  for (const [filePath, content] of Object.entries({ ".gitignore": "node_modules\n", ...files })) {
-    const absolutePath = path.join(root, filePath);
-    await mkdir(path.dirname(absolutePath), { recursive: true });
-    await writeFile(absolutePath, content);
-  }
+  const root = await makeTempRoot();
+  for (const [filePath, content] of Object.entries({ ".gitignore": "node_modules\n", ...files }))
+    await writeText(path.join(root, filePath), content);
   return root;
 };
 
 const abstractOf = (lineNum: number) =>
   ["# post Abstract", ...Array.from({ length: lineNum - 1 }, (_, idx) => `- rule ${idx}`)].join("\n");
 
-afterEach(async () => {
-  await Promise.all(tempRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
-});
-
 describe("AkanQualityScanner abstract rule", () => {
   test("warns on an abstract over the line limit and says how to trim it", async () => {
     const root = await makeWorkspace({
@@ -185,15 +176,6 @@ describe("AkanQualityScanner ssr rules", () => {
   });
 });
 
-const signalOf = (entries: string) =>
-  [
-    `import { endpoint, slice } from "akanjs/signal";`,
-    `export class PostSlice extends slice(srv.post, { guards: {}, mcp: { get: true } }, (init) => ({`,
-    entries,
-    `})) {}`,
-    "",
-  ].join("\n");
-
 describe("AkanQualityScanner layout rules", () => {
   test("flags an unknown app root file but not a facet entrypoint", async () => {
     const root = await makeWorkspace({