@alexkroman1/aai-cli 5.1.1 → 5.3.0

package/dist/scaffold/global.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/dist/scaffold/package.json

@@ -0,0 +1,32 @@
+{
+  "type": "module",
+  "packageManager": "pnpm@10.29.3",
+  "engines": {
+    "node": ">=24 <27"
+  },
+  "scripts": {
+    "dev": "aai dev",
+    "build": "aai build",
+    "test": "aai test",
+    "deploy": "aai deploy"
+  },
+  "dependencies": {
+    "@alexkroman1/aai": "^5.3.0",
+    "@alexkroman1/aai-ui": "^5.3.0",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8",
+    "tailwindcss": "^4.0.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@alexkroman1/aai-cli": "^5.3.0",
+    "@tailwindcss/vite": "^4.3.3",
+    "@types/node": "^26.1.1",
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.4",
+    "typescript": "^7.0.2",
+    "vite": "^8.1.5",
+    "vitest": "^4.1.10"
+  }
+}

package/dist/scaffold/pnpm-workspace.yaml

@@ -0,0 +1,13 @@
+# esbuild's postinstall must stay approved or pnpm fails the install
+# (unapproved build scripts). @alexkroman1/aai-cli no longer depends on it
+# directly (its dev bundler runs on Rolldown, prebuilt binaries, no
+# postinstall), but esbuild is an optional peer of vite: any project whose
+# lockfile ever resolved it (an upgrade from an older CLI, or a reinstall
+# over an existing lockfile) keeps it installed, and pnpm then blocks its
+# build script without this entry. pnpm 10 reads `onlyBuiltDependencies`;
+# pnpm 11 renamed it to `allowBuilds` and ignores the old key, so both are
+# declared. This file also marks the project as its own pnpm workspace root.
+onlyBuiltDependencies:
+  - esbuild
+allowBuilds:
+  esbuild: true

package/dist/scaffold/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2024",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "noImplicitAny": false,
+    "useUnknownInCatchVariables": false,
+    "verbatimModuleSyntax": true,
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "types": ["vitest/globals"],
+    "resolveJsonModule": true,
+    "jsx": "react-jsx",
+    "jsxImportSource": "react",
+    "lib": ["ES2024", "DOM", "DOM.Iterable"]
+  }
+}

package/dist/scaffold/vite.config.ts

@@ -0,0 +1,14 @@
+import react from "@vitejs/plugin-react";
+import tailwindcss from "@tailwindcss/vite";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  plugins: [react(), tailwindcss()],
+  build: {
+    target: "es2022",
+    minify: true,
+  },
+  ssr: {
+    noExternal: true,
+  },
+});

package/dist/scaffold/vitest.config.ts

@@ -0,0 +1,24 @@
+import { defineConfig } from "vitest/config";
+
+/**
+ * Test config, deliberately separate from vite.config.ts.
+ *
+ * Vitest prefers this file, which is the point. `vite.config.ts` imports the
+ * React and Tailwind plugins for the CLIENT build — neither has anything to
+ * do with running an agent's tests, but loading them is a way for the test
+ * run to fail. Measured in the studio: an agent's own test suite failed to
+ * load because `defineConfig` came back undefined from an unresolved plugin
+ * import, reported as `TypeError: default is not a function` with zero tests
+ * collected. The agent then spent a build round "fixing" a test that was
+ * fine.
+ *
+ * `globals: true` so `describe`/`test`/`expect` work with or without an
+ * explicit `import { test } from "vitest"`. Both spellings are common, both
+ * are correct, and tsconfig's `types: ["vitest/globals"]` already promises
+ * the un-imported one — this makes the runtime match the types.
+ */
+export default defineConfig({
+  test: {
+    globals: true,
+  },
+});

package/dist/secret.d.ts

@@ -0,0 +1,25 @@
+import { type CommandResult } from "./_output.ts";
+/**
+ * The one `no_input` failure for `secret put`, shared by the JSON-mode stdin
+ * path (cli.ts) and the TTY prompt path below so the two can't drift.
+ */
+export declare const NO_INPUT: readonly ["no_input", "No value provided", "Pipe secret value to stdin"];
+/** Read secret value from stdin (for non-TTY / piped input). */
+export declare function readStdin(): Promise<string>;
+type SecretPutData = {
+    name: string;
+};
+type SecretDeleteData = {
+    name: string;
+};
+type SecretListData = {
+    secrets: string[];
+};
+/**
+ * Execute secret put. If `value` is provided, use it directly (non-TTY path).
+ * If not provided, prompt interactively (TTY path).
+ */
+export declare function executeSecretPut(cwd: string, name: string, value: string | undefined, server: string | undefined): Promise<CommandResult<SecretPutData>>;
+export declare function executeSecretDelete(cwd: string, name: string, server: string | undefined): Promise<CommandResult<SecretDeleteData>>;
+export declare function executeSecretList(cwd: string, server: string | undefined): Promise<CommandResult<SecretListData>>;
+export {};

package/dist/storage.d.ts

@@ -0,0 +1,22 @@
+import { type CommandResult } from "./_output.ts";
+type StorageStatusData = {
+    slug: string;
+    enabled: boolean;
+};
+export declare function executeStorageStatus(cwd: string, server: string | undefined): Promise<CommandResult<StorageStatusData>>;
+export declare function executeStorageEnable(cwd: string, server: string | undefined): Promise<CommandResult<StorageStatusData>>;
+export type StorageDisableOpts = {
+    server?: string | undefined;
+    /** Skip the confirmation prompt (required in non-interactive runs). */
+    force?: boolean | undefined;
+    /** TTY override for testing. Defaults to real stdin+stdout TTY state. */
+    isTTY?: boolean | undefined;
+};
+/**
+ * Disable storage — destructive: the server DROPS the app's database schema
+ * and all its data. On a TTY this requires interactive confirmation; without
+ * a TTY it refuses unless `--force` is passed, so a script can never drop
+ * data by accident.
+ */
+export declare function executeStorageDisable(cwd: string, opts?: StorageDisableOpts): Promise<CommandResult<StorageStatusData>>;
+export {};

package/dist/templates/code-interpreter/agent.ts

@@ -0,0 +1,11 @@
+import { agent, assemblyAIPipeline } from "@alexkroman1/aai";
+import systemPrompt from "./system-prompt.md?raw";
+
+export default agent({
+  name: "Coda",
+  ...assemblyAIPipeline(),
+  systemPrompt,
+  greeting:
+    "Hey, I'm Coda. I solve problems by writing and running code. Try asking me something like, what's the 50th fibonacci number, or what day of the week was January 1st 2000.",
+  builtinTools: ["run_code"],
+});

package/dist/templates/code-interpreter/system-prompt.md

@@ -0,0 +1,18 @@
+You are Coda, a problem-solving assistant who answers questions by writing and running JavaScript code.
+
+CRITICAL RULES:
+- You MUST use the run_code tool for ANY question involving math, counting, string manipulation, data processing, logic, or anything that benefits from exact computation.
+- NEVER do mental math or estimate. Always write code and report the exact result.
+- Use console.log() to output intermediate steps. The last expression is captured automatically.
+- If the code throws an error, fix it and try again.
+- Explain what the code does briefly, then give the answer.
+- Keep your spoken responses short — just say what the code found.
+
+Examples of questions you MUST use code for:
+- "What is 127 times 849?" → run_code
+- "How many prime numbers are there below 1000?" → run_code
+- "Reverse the string 'hello world'" → run_code
+- "What's the 50th fibonacci number?" → run_code
+- "Sort these numbers: 42, 17, 93, 8, 55" → run_code
+- "What day of the week was January 1st, 2000?" → run_code
+- "Convert 255 to binary" → run_code

package/dist/templates/dispatch-center/agent.test.ts

@@ -0,0 +1,153 @@
+import type { ToolContext } from "@alexkroman1/aai";
+import { describe, expect, test } from "vitest";
+import { getState } from "./shared.ts";
+import { incidentCreate } from "./tools/incident_create.ts";
+import { incidentEscalate } from "./tools/incident_escalate.ts";
+import { incidentTriage } from "./tools/incident_triage.ts";
+import { incidentUpdateStatus } from "./tools/incident_update_status.ts";
+import { resourcesDispatch } from "./tools/resources_dispatch.ts";
+import { resourcesUpdateStatus } from "./tools/resources_update_status.ts";
+
+let sessionCounter = 0;
+
+/** ToolContext stub — the dispatch board lives in ctx.state, one per session. */
+function makeCtx(): { ctx: ToolContext } {
+  const sessionId = `test-session-${++sessionCounter}`;
+  const ctx = {
+    sessionId,
+    send: () => {},
+    env: {},
+    state: {},
+    messages: [],
+  } as unknown as ToolContext;
+  return { ctx };
+}
+
+async function createIncidentFor(
+  ctx: ToolContext,
+  description = "structure fire with heavy smoke",
+): Promise<string> {
+  const result = (await incidentCreate.execute(
+    { location: "400 Oak Street", description },
+    ctx,
+  )) as { incidentId: string };
+  return result.incidentId;
+}
+
+describe("dispatch-center template", () => {
+  test("resolving an incident does not yank a reassigned unit off its new incident", async () => {
+    const { ctx } = makeCtx();
+
+    const inc1 = await createIncidentFor(ctx);
+    await resourcesDispatch.execute({ incidentId: inc1, callsigns: ["Medic-1"] }, ctx);
+
+    // Medic-1 radios available, then is dispatched to a second incident.
+    await resourcesUpdateStatus.execute({ callsign: "Medic-1", status: "available" }, ctx);
+    const inc2 = await createIncidentFor(ctx, "cardiac arrest, not breathing");
+    await resourcesDispatch.execute({ incidentId: inc2, callsigns: ["Medic-1"] }, ctx);
+
+    // Resolving the first incident must not touch Medic-1 anymore.
+    await incidentUpdateStatus.execute({ incidentId: inc1, status: "resolved" }, ctx);
+
+    const state = getState(ctx);
+    const medic1 = state.resources.find((r) => r.callsign === "Medic-1");
+    expect(medic1?.status).toBe("dispatched");
+    expect(medic1?.assignedIncident).toBe(inc2);
+    expect(state.incidents[inc2]?.assignedResources).toContain("R1");
+    expect(state.incidents[inc1]?.assignedResources).not.toContain("R1");
+  });
+
+  test("callsigns: ['auto'] triggers auto-dispatch as the description promises", async () => {
+    const { ctx } = makeCtx();
+    const incidentId = await createIncidentFor(ctx, "cardiac arrest, patient not breathing");
+
+    const result = (await resourcesDispatch.execute({ incidentId, callsigns: ["auto"] }, ctx)) as {
+      dispatched: { callsign: string }[];
+      failed?: { callsign: string; reason: string }[];
+    };
+
+    expect(result.failed).toBeUndefined();
+    expect(result.dispatched.length).toBeGreaterThan(0);
+  });
+
+  test("concurrent tool calls are serialized — no lost updates", async () => {
+    const { ctx } = makeCtx();
+
+    // Parallel tool calls in one LLM turn run concurrently. The per-session
+    // mutex in updateState makes each one run against the previous one's
+    // finished state, so neither incident's changes are half-applied when
+    // the other's mutator runs.
+    const [a, b] = (await Promise.all([
+      incidentCreate.execute({ location: "1 First St", description: "gas leak" }, ctx),
+      incidentCreate.execute({ location: "2 Second St", description: "vehicle crash" }, ctx),
+    ])) as { incidentId: string }[];
+
+    const state = getState(ctx);
+    expect(a?.incidentId).not.toBe(b?.incidentId);
+    expect(state.incidentCounter).toBe(2);
+    expect(Object.keys(state.incidents)).toHaveLength(2);
+  });
+
+  test("negative casualty counts are rejected by the parameter schemas", () => {
+    expect(
+      incidentTriage.parameters?.safeParse({ incidentId: "INC-0001", casualtyUpdate: -5 }).success,
+    ).toBe(false);
+    expect(
+      incidentCreate.parameters?.safeParse({
+        location: "1 First St",
+        description: "fire",
+        estimatedCasualties: -1,
+      }).success,
+    ).toBe(false);
+    expect(
+      incidentUpdateStatus.parameters?.safeParse({
+        incidentId: "INC-0001",
+        status: "on_scene",
+        casualtyUpdate: { confirmed: -2 },
+      }).success,
+    ).toBe(false);
+  });
+
+  test("mutual-aid units get unique ids and callsigns across escalations", async () => {
+    const { ctx } = makeCtx();
+    const incidentId = await createIncidentFor(ctx);
+
+    await incidentEscalate.execute(
+      { incidentId, reason: "spreading", requestMutualAid: true },
+      ctx,
+    );
+    await incidentEscalate.execute(
+      { incidentId, reason: "still spreading", requestMutualAid: true },
+      ctx,
+    );
+
+    const state = getState(ctx);
+    const mutualAid = state.resources.filter((r) => r.id.startsWith("MA-"));
+    expect(mutualAid).toHaveLength(4);
+    expect(new Set(mutualAid.map((r) => r.id)).size).toBe(4);
+    expect(new Set(mutualAid.map((r) => r.callsign)).size).toBe(4);
+  });
+
+  test("resolved is terminal: no escalation, re-resolution, or dispatch", async () => {
+    const { ctx } = makeCtx();
+    const incidentId = await createIncidentFor(ctx);
+    await incidentUpdateStatus.execute({ incidentId, status: "resolved" }, ctx);
+
+    const escalated = (await incidentEscalate.execute({ incidentId, reason: "flare-up" }, ctx)) as {
+      error?: string;
+    };
+    expect(escalated.error).toMatch(/resolved/);
+
+    const reResolved = (await incidentUpdateStatus.execute(
+      { incidentId, status: "resolved" },
+      ctx,
+    )) as { error?: string };
+    expect(reResolved.error).toMatch(/resolved/);
+
+    const dispatchedTo = (await resourcesDispatch.execute(
+      { incidentId, callsigns: ["Medic-1"] },
+      ctx,
+    )) as { error?: string };
+    expect(dispatchedTo.error).toMatch(/resolved/);
+  });
+});

package/dist/templates/dispatch-center/agent.ts

@@ -0,0 +1,50 @@
+import { agent, assemblyAIPipeline } from "@alexkroman1/aai";
+import { assemblyAI } from "@alexkroman1/aai/stt";
+import { dashboardView } from "./shared.ts";
+import systemPrompt from "./system-prompt.md?raw";
+import { incidentAddNote } from "./tools/incident_add_note.ts";
+import { incidentCreate } from "./tools/incident_create.ts";
+import { incidentEscalate } from "./tools/incident_escalate.ts";
+import { incidentGet } from "./tools/incident_get.ts";
+import { incidentTriage } from "./tools/incident_triage.ts";
+import { incidentUpdateStatus } from "./tools/incident_update_status.ts";
+import { opsDashboard } from "./tools/ops_dashboard.ts";
+import { opsProtocols } from "./tools/ops_protocols.ts";
+import { opsRunScenario } from "./tools/ops_run_scenario.ts";
+import { resourcesDispatch } from "./tools/resources_dispatch.ts";
+import { resourcesGetAvailable } from "./tools/resources_get_available.ts";
+import { resourcesUpdateStatus } from "./tools/resources_update_status.ts";
+
+export default agent({
+  name: "Dispatch Command Center",
+  ...assemblyAIPipeline(),
+  // One projection replaces eleven `ctx.send("incidents", ...)` calls, and
+  // is the single place that decides caller PII stays server-side.
+  syncState: dashboardView,
+  // Overriding the STT stage: a dispatcher reads addresses and unit numbers
+  // in bursts with pauses inside one message, so end-of-turn silence has to
+  // be longer than the default or "unit twelve … respond to" splits in two.
+  stt: assemblyAI({ minTurnSilenceMs: 2200 }),
+  systemPrompt,
+  greeting:
+    "Dispatch Command Center online. Restoring operational state. I'm ready to take incoming calls, manage active incidents, or run dispatch operations. Say 'dashboard' for a full status report. What do we have.",
+
+  // The system prompt instructs the model to use web_search and run_code, so
+  // they must be enabled here — the default builtin set does not include them.
+  builtinTools: ["think", "remember", "recall", "calculate", "web_search", "run_code"],
+
+  tools: {
+    incident_add_note: incidentAddNote,
+    incident_create: incidentCreate,
+    incident_escalate: incidentEscalate,
+    incident_get: incidentGet,
+    incident_triage: incidentTriage,
+    incident_update_status: incidentUpdateStatus,
+    ops_dashboard: opsDashboard,
+    ops_protocols: opsProtocols,
+    ops_run_scenario: opsRunScenario,
+    resources_dispatch: resourcesDispatch,
+    resources_get_available: resourcesGetAvailable,
+    resources_update_status: resourcesUpdateStatus,
+  },
+});