@alexkroman1/aai-cli 13.2.0 → 14.0.0

package/dist/{_workflow-determinism-f9J-5Zlj.mjs → _workflow-determinism-CvpqMpdh.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import path from "node:path";
 import { readFile, readdir } from "node:fs/promises";
-//#region _workflow-determinism.ts
+//#region src/_workflow-determinism.ts
 /**
 * A COMPUTED step identity in the project's own `workflows/`.
 *
@@ -24,12 +24,12 @@ import { readFile, readdir } from "node:fs/promises";
 * compiling every fence in this repo's shipped docs:
 *
 * ```ts
-* import type { WorkflowCtx } from "@alexkroman1/aai";
+* import type { WorkflowContext } from "@alexkroman1/aai";
 *
 * declare const charge: () => Promise<string>;
 *
-* export async function body(ctx: WorkflowCtx, coin: string): Promise<void> {
-*   // No error. The banned shape, against the real `WorkflowCtx`.
+* export async function body(ctx: WorkflowContext, coin: string): Promise<void> {
+*   // No error. The banned shape, against the real `WorkflowContext`.
 *   await ctx.step(`charge-${coin}`, charge);
 * }
 * ```
@@ -81,19 +81,6 @@ import { readFile, readdir } from "node:fs/promises";
 * @module
 */
 /**
-* The three `ctx` methods whose first argument is a journal identity.
-*
-* All three key a journal row by it — `name#occurrence` for a step,
-* `sleep!<label>#<n>` and `hook!<token>#<n>` for the waits — so a computed one
-* mints a row no earlier walk reached in exactly the same way. Kept as a list
-* so the message can name the method that was called.
-*/
-const IDENTITY_METHODS = [
-	"step",
-	"sleep",
-	"waitFor"
-];
-/**
 * A `ctx.<method>(` immediately followed by a BACKTICK.
 *
 * The whole check, and its narrowness is the point. A quoted literal is
@@ -104,8 +91,17 @@ const IDENTITY_METHODS = [
 * The receiver is not pinned to `ctx` — a body may destructure or rename it —
 * and a `.step(` on anything else taking a template-literal first argument is
 * not a shape worth excluding.
+*
+* Shared rather than built per call, which is safe ONLY because the single
+* reader is `matchAll`: that method species-constructs its own clone and never
+* advances this object's `lastIndex`. A `.exec` or `.test` added against a `/g`
+* regex would carry state between lines — build a fresh one there.
 */
-const identityPattern = () => new RegExp(`\\.(${IDENTITY_METHODS.join("|")})\\(\``, "g");
+const IDENTITY_PATTERN = new RegExp(`\\.(${[
+	"step",
+	"sleep",
+	"waitFor"
+].join("|")})\\(\``, "g");
 /** Whether a template literal actually INTERPOLATES, or is merely quoted oddly. */
 const INTERPOLATES = /\$\{/;
 /**
@@ -132,7 +128,7 @@ function findComputedIdentities(source, file) {
 	const findings = [];
 	for (const [n, line] of source.split("\n").entries()) {
 		if (isCommentOnly(line)) continue;
-		for (const match of line.matchAll(identityPattern())) {
+		for (const match of line.matchAll(IDENTITY_PATTERN)) {
 			const method = match[1];
 			if (method === void 0) continue;
 			if (!INTERPOLATES.test(line.slice((match.index ?? 0) + match[0].length))) continue;
@@ -169,17 +165,13 @@ async function workflowFiles(cwd) {
 * warning pass beside a typecheck that has already run on the same tree.
 */
 async function scanWorkflowDeterminism(cwd) {
-	const findings = [];
-	for (const rel of await workflowFiles(cwd)) {
-		let source;
+	return (await Promise.all((await workflowFiles(cwd)).map(async (rel) => {
 		try {
-			source = await readFile(path.join(cwd, rel), "utf-8");
+			return findComputedIdentities(await readFile(path.join(cwd, rel), "utf-8"), rel);
 		} catch {
-			continue;
+			return [];
 		}
-		findings.push(...findComputedIdentities(source, rel));
-	}
-	return findings;
+	}))).flat();
 }
 /**
 * The remedy, once, however many findings there are.

package/dist/_workflow-determinism.d.ts

@@ -20,12 +20,12 @@
  * compiling every fence in this repo's shipped docs:
  *
  * ```ts
- * import type { WorkflowCtx } from "@alexkroman1/aai";
+ * import type { WorkflowContext } from "@alexkroman1/aai";
  *
  * declare const charge: () => Promise<string>;
  *
- * export async function body(ctx: WorkflowCtx, coin: string): Promise<void> {
- *   // No error. The banned shape, against the real `WorkflowCtx`.
+ * export async function body(ctx: WorkflowContext, coin: string): Promise<void> {
+ *   // No error. The banned shape, against the real `WorkflowContext`.
  *   await ctx.step(`charge-${coin}`, charge);
  * }
  * ```

package/dist/build-Mxk8gWvX.mjs

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+import { a as ok, t as CliError } from "./_output-DBP9Op_d.mjs";
+import { n as log, r as notify } from "./_ui-DCt4qZrk.mjs";
+import { r as evalWorkerBundle, t as buildAgentBundle } from "./_bundler-DolUCMxu.mjs";
+import { assertTypechecks } from "./_typecheck-gate-U3jcil8L.mjs";
+import { n as scanWorkflowDeterminism, t as determinismWarnings } from "./_workflow-determinism-CvpqMpdh.mjs";
+import { TEST_FILES, classifyVitestError, runVitest } from "./test-D032V2cA.mjs";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { agentConfigWarnings } from "@alexkroman1/aai/manifest";
+import { DEFAULT_SYSTEM_PROMPT } from "@alexkroman1/aai";
+//#region src/build.ts
+/**
+* `aai build` — bundle the agent without deploying, behind the same gates
+* deploy runs (tests, then typecheck), so the command previews the deploy
+* artifact and its failures alike.
+*
+* It also LEAVES that artifact on disk, at {@link WORKER_ARTIFACT_REL}, which is
+* what makes self-hosting work: `server.mjs` loads the built worker rather than
+* `agent.ts`, because a tool is discovered by the bundler enumerating `tools/`
+* and no un-bundled loader can see that directory. See the scaffold's own
+* `server.mjs` and "Self-hosting runs the built worker" in
+* `packages/aai-templates/CLAUDE.md`.
+*/
+/**
+* Where the built worker lands, relative to the project root — under `.aai/`,
+* beside the built client, so one gitignore rule covers every build output.
+*
+* `server.mjs` hardcodes this path: it is a plain `.mjs` file in a user's
+* project and may not import from the CLI (which a deployed project does not
+* install at all). The pair is covered end-to-end by the `npm start` leg of
+* `e2e.test.ts` — the only tier that runs both halves as a user does.
+*/
+const WORKER_ARTIFACT_REL = path.join(".aai", "worker.mjs");
+/**
+* The prose slot, named by convention. Mirrors `worker-bundler.ts`'s constant of
+* the same name — the two cannot share one without an import cycle
+* (`build.ts` → `_bundler.ts` → `worker-bundler.ts`), so `_build.test.ts` pins
+* the pair end to end instead: a build whose prompt really came from the file
+* has to report the file.
+*/
+const SYSTEM_PROMPT_FILE = "system-prompt.md";
+/** What {@link systemPromptSource} reports when nothing declared a prompt. */
+const FRAMEWORK_DEFAULT_PROMPT_SOURCE = "the framework default (DEFAULT_SYSTEM_PROMPT)";
+/**
+* Which of the three possible authors of this agent's system prompt actually
+* wrote the one in the bundle.
+*
+* `aai build` reported `name` and `workerBytes` and nothing about the prompt,
+* and the prompt is the one field that can change COMPLETELY without any
+* config changing: deleting `system-prompt.md` swaps in
+* `DEFAULT_SYSTEM_PROMPT` — a total personality change — with exit 0 and no
+* line anywhere. `withSystemPrompt` refuses the case where a file exists and
+* nothing reads it; it cannot refuse a file that is simply GONE, because that
+* is what an agent with no file legitimately looks like. So this is a report
+* rather than a check.
+*
+* Decided by comparing VALUES against the built agent's resolved prompt, which
+* is the same method `withSystemPrompt` uses and for the same reason — the
+* alternative asks the bundler's module graph a question, and the author may
+* have imported the file and composed it, which is neither "the file" nor
+* "agent.ts" alone.
+*/
+async function systemPromptSource(cwd, resolved) {
+	if (resolved === DEFAULT_SYSTEM_PROMPT) return FRAMEWORK_DEFAULT_PROMPT_SOURCE;
+	const trimmed = (await fs.readFile(path.join(cwd, SYSTEM_PROMPT_FILE), "utf-8").catch(() => void 0))?.trim();
+	if (trimmed === void 0 || trimmed === "" || !resolved.includes(trimmed)) return "agent.ts";
+	return resolved.trim() === trimmed ? SYSTEM_PROMPT_FILE : `agent.ts (composing ${SYSTEM_PROMPT_FILE})`;
+}
+/**
+* Map a {@link runVitest} failure to a CliError — distinguishing a real test
+* failure (test_failed) from the runner not spawning (spawn_failed) instead
+* of a generic command_failed.
+*/
+function testGateError(err) {
+	const { code, message } = classifyVitestError(err);
+	return new CliError(code, message, "Re-run with --skipTests to build without tests", { cause: err });
+}
+async function executeBuild(opts) {
+	const { cwd } = opts;
+	if (!opts.skipTests) try {
+		runVitest(cwd, {
+			candidates: TEST_FILES,
+			all: true
+		});
+	} catch (err) {
+		throw testGateError(err);
+	}
+	await assertTypechecks(cwd, { skip: opts.skipTypecheck });
+	const bundle = await buildAgentBundle(cwd, { minify: true });
+	const agentDef = await evalWorkerBundle(bundle.worker);
+	for (const warning of agentConfigWarnings(agentDef)) notify("warn", warning);
+	for (const warning of determinismWarnings(await scanWorkflowDeterminism(cwd))) notify("warn", warning);
+	const worker = path.join(cwd, WORKER_ARTIFACT_REL);
+	await fs.mkdir(path.dirname(worker), { recursive: true });
+	await fs.writeFile(worker, bundle.worker, "utf-8");
+	const systemPrompt = await systemPromptSource(cwd, agentDef.systemPrompt);
+	log.info(`System prompt: ${systemPrompt}`);
+	log.success("Build complete");
+	return ok({
+		name: agentDef.name,
+		workerBytes: bundle.worker.length,
+		worker,
+		systemPrompt
+	});
+}
+//#endregion
+export { executeBuild };

package/dist/build.d.ts

@@ -26,6 +26,11 @@ type BuildData = {
     workerBytes: number;
     /** Absolute path of the worker written — what `npm start` boots. */
     worker: string;
+    /**
+     * WHERE the prompt this bundle carries came from — see
+     * {@link systemPromptSource}.
+     */
+    systemPrompt: string;
 };
 export declare function executeBuild(opts: {
     cwd: string;