@alexkroman1/aai-cli 5.1.1 → 5.3.0

package/dist/templates/dispatch-center/tools/incident_create.ts

@@ -0,0 +1,79 @@
+import { tool } from "@alexkroman1/aai";
+import { z } from "zod";
+import {
+  calculateTriageScore,
+  createIncident,
+  getApplicableProtocols,
+  recommendResources,
+  recommendSeverity,
+  recommendType,
+  resourceBrief,
+  updateState,
+} from "../shared.ts";
+
+export const incidentCreate = tool({
+  description: "Create a new incident from an incoming emergency call.",
+  parameters: z.object({
+    location: z.string().max(300).describe("Address or location description"),
+    description: z.string().max(2000).describe("Nature of the emergency as described by caller"),
+    callerName: z.string().max(120).describe("Caller's name").optional(),
+    callerPhone: z.string().max(40).describe("Callback number").optional(),
+    estimatedCasualties: z
+      .number()
+      .int()
+      .nonnegative()
+      .describe("Estimated number of casualties if known")
+      .optional(),
+    hazards: z
+      .array(z.string().max(100))
+      .max(20)
+      .describe("Known hazards: fire, chemical, electrical, structural, weapons")
+      .optional(),
+  }),
+  async execute(args, ctx) {
+    return updateState(ctx, (state) => {
+      const recSeverity = recommendSeverity(args.description);
+      const recType = recommendType(args.description);
+      const triageScore = calculateTriageScore(
+        recSeverity,
+        recType,
+        args.estimatedCasualties ?? 0,
+        args.hazards?.length ?? 0,
+      );
+
+      const incident = createIncident(state, {
+        type: recType,
+        severity: recSeverity,
+        location: args.location,
+        description: args.description,
+        callerName: args.callerName ?? "Unknown",
+        callerPhone: args.callerPhone ?? "Unknown",
+        triageScore,
+        timeline: [{ time: Date.now(), event: `Incident created: ${args.description}` }],
+        casualties: {
+          confirmed: 0,
+          estimated: args.estimatedCasualties ?? 0,
+          treated: 0,
+        },
+        hazards: args.hazards ?? [],
+      });
+      const id = incident.id;
+
+      const protocols = getApplicableProtocols(recType, recSeverity);
+      const recommended = recommendResources(recType, recSeverity, state);
+
+      return {
+        incidentId: id,
+        recommendedSeverity: recSeverity,
+        recommendedType: recType,
+        triageScore,
+        applicableProtocols: protocols.map((p) => p.name),
+        recommendedResources: recommended.map(resourceBrief),
+        message:
+          recSeverity === "critical"
+            ? `PRIORITY ONE — ${id} created. Immediate dispatch recommended. ${protocols.length} protocol(s) applicable.`
+            : `${id} created. Triage score ${triageScore}. ${recommended.length} resource(s) recommended.`,
+      };
+    });
+  },
+});

package/dist/templates/dispatch-center/tools/incident_escalate.ts

@@ -0,0 +1,88 @@
+import { tool } from "@alexkroman1/aai";
+import { z } from "zod";
+import {
+  assertNotResolved,
+  calculateTriageScore,
+  findIncident,
+  logEvent,
+  recommendResources,
+  updateState,
+} from "../shared.ts";
+
+export const incidentEscalate = tool({
+  description: "Escalate an incident when it exceeds current capacity or severity increases.",
+  parameters: z.object({
+    incidentId: z.string().max(20).describe("The incident ID"),
+    reason: z.string().max(1000).describe("Reason for escalation"),
+    requestMutualAid: z
+      .boolean()
+      .describe("Whether to request mutual aid from neighboring jurisdictions")
+      .optional(),
+    newSeverity: z.enum(["critical", "urgent"]).describe("Escalated severity level").optional(),
+  }),
+  async execute(args, ctx) {
+    return updateState(ctx, (state) => {
+      const inc = findIncident(state, args.incidentId);
+      if ("error" in inc) return inc;
+      const blocked = assertNotResolved(inc, "escalate");
+      if (blocked) return blocked;
+
+      inc.escalationLevel++;
+      if (args.newSeverity) inc.severity = args.newSeverity;
+      inc.status = "escalated";
+      logEvent(inc, `ESCALATED (Level ${inc.escalationLevel}): ${args.reason}`);
+
+      if (args.requestMutualAid) {
+        logEvent(inc, "Mutual aid requested from neighboring jurisdictions");
+        // Counter-based ids/callsigns: Date.now() collides across rapid
+        // escalations, and duplicate callsigns break dispatch-by-callsign.
+        const medicN = ++state.mutualAidCounter;
+        const engineN = ++state.mutualAidCounter;
+        state.resources.push(
+          {
+            id: `MA-${medicN}`,
+            type: "ambulance",
+            callsign: `Mutual-Aid-Medic-${medicN}`,
+            status: "available",
+            assignedIncident: null,
+            eta: null,
+            capabilities: ["als"],
+          },
+          {
+            id: `MA-${engineN}`,
+            type: "fire_engine",
+            callsign: `Mutual-Aid-Engine-${engineN}`,
+            status: "available",
+            assignedIncident: null,
+            eta: null,
+            capabilities: ["structural"],
+          },
+        );
+      }
+
+      inc.triageScore = calculateTriageScore(
+        inc.severity,
+        inc.type,
+        inc.casualties.estimated,
+        inc.hazards.length,
+      );
+
+      const additionalResources = recommendResources(inc.type, inc.severity, state).filter(
+        (r) => !inc.assignedResources.includes(r.id),
+      );
+
+      return {
+        incidentId: args.incidentId,
+        escalationLevel: inc.escalationLevel,
+        newSeverity: inc.severity,
+        newTriageScore: inc.triageScore,
+        mutualAidRequested: args.requestMutualAid ?? false,
+        additionalResourcesAvailable: additionalResources.map((r) => ({
+          callsign: r.callsign,
+          type: r.type,
+        })),
+        message: `ESCALATION CONFIRMED — ${args.incidentId} now Level ${inc.escalationLevel}. ${additionalResources.length} additional resource(s) available for dispatch.`,
+      };
+    });
+  },
+});

package/dist/templates/dispatch-center/tools/incident_get.ts

@@ -0,0 +1,36 @@
+import { tool } from "@alexkroman1/aai";
+import { z } from "zod";
+import { findIncident, getApplicableProtocols, getState, incidentAgeMinutes } from "../shared.ts";
+
+export const incidentGet = tool({
+  description: "Get full details on a specific incident including timeline and assigned resources.",
+  parameters: z.object({
+    incidentId: z.string().max(20).describe("The incident ID"),
+  }),
+  async execute(args, ctx) {
+    const state = getState(ctx);
+    const inc = findIncident(state, args.incidentId);
+    if ("error" in inc) return inc;
+
+    const assignedResourceDetails = inc.assignedResources
+      .map((rId) => {
+        const r = state.resources.find((r) => r.id === rId);
+        return r
+          ? {
+              callsign: r.callsign,
+              type: r.type,
+              status: r.status,
+              eta: r.eta,
+            }
+          : null;
+      })
+      .filter(Boolean);
+
+    return {
+      ...inc,
+      ageMinutes: incidentAgeMinutes(inc),
+      assignedResourceDetails,
+      applicableProtocols: getApplicableProtocols(inc.type, inc.severity).map((p) => p.name),
+    };
+  },
+});

package/dist/templates/dispatch-center/tools/incident_triage.ts

@@ -0,0 +1,78 @@
+import { tool } from "@alexkroman1/aai";
+import { z } from "zod";
+import {
+  assertNotResolved,
+  calculateTriageScore,
+  findIncident,
+  getApplicableProtocols,
+  INCIDENT_TYPES,
+  logEvent,
+  recommendResources,
+  SEVERITIES,
+  updateState,
+} from "../shared.ts";
+
+export const incidentTriage = tool({
+  description:
+    "Triage an incident — confirm or override severity, type, hazards, and casualty count.",
+  parameters: z.object({
+    incidentId: z.string().max(20).describe("The incident ID"),
+    severity: z.enum(SEVERITIES).describe("Confirmed severity after triage").optional(),
+    type: z.enum(INCIDENT_TYPES).describe("Confirmed incident type").optional(),
+    additionalHazards: z
+      .array(z.string().max(100))
+      .max(20)
+      .describe("Any additional hazards identified")
+      .optional(),
+    casualtyUpdate: z.number().int().nonnegative().describe("Updated casualty count").optional(),
+    notes: z.string().max(1000).describe("Triage notes").optional(),
+  }),
+  async execute(args, ctx) {
+    return updateState(ctx, (state) => {
+      const inc = findIncident(state, args.incidentId);
+      if ("error" in inc) return inc;
+      const blocked = assertNotResolved(inc, "triage");
+      if (blocked) return blocked;
+
+      if (args.severity) inc.severity = args.severity;
+      if (args.type) inc.type = args.type;
+      for (const hazard of args.additionalHazards ?? []) {
+        if (!inc.hazards.includes(hazard)) inc.hazards.push(hazard);
+      }
+      if (args.casualtyUpdate !== undefined) {
+        inc.casualties.estimated = args.casualtyUpdate;
+      }
+      if (args.notes) logEvent(inc, `Triage note: ${args.notes}`);
+
+      inc.triageScore = calculateTriageScore(
+        inc.severity,
+        inc.type,
+        inc.casualties.estimated,
+        inc.hazards.length,
+      );
+      inc.status = "triaged";
+      logEvent(inc, `Triaged: ${inc.severity} ${inc.type}, score ${inc.triageScore}`);
+
+      const protocols = getApplicableProtocols(inc.type, inc.severity);
+      const recommended = recommendResources(inc.type, inc.severity, state);
+
+      return {
+        incidentId: args.incidentId,
+        severity: inc.severity,
+        type: inc.type,
+        triageScore: inc.triageScore,
+        hazards: inc.hazards,
+        estimatedCasualties: inc.casualties.estimated,
+        protocols: protocols.map((p) => ({
+          name: p.name,
+          steps: p.steps,
+          requiredResources: p.requiredResources,
+        })),
+        recommendedResources: recommended.map((r) => ({
+          callsign: r.callsign,
+          type: r.type,
+        })),
+      };
+    });
+  },
+});

package/dist/templates/dispatch-center/tools/incident_update_status.ts

@@ -0,0 +1,68 @@
+import { tool } from "@alexkroman1/aai";
+import { z } from "zod";
+import { assertNotResolved, findIncident, logEvent, updateState } from "../shared.ts";
+
+export const incidentUpdateStatus = tool({
+  description: "Update an incident's status (en_route, on_scene, resolved, escalated).",
+  parameters: z.object({
+    incidentId: z.string().max(20).describe("The incident ID"),
+    status: z.enum(["en_route", "on_scene", "resolved", "escalated"]).describe("New status"),
+    notes: z.string().max(1000).describe("Status update notes").optional(),
+    casualtyUpdate: z
+      .object({
+        confirmed: z.number().int().nonnegative().optional(),
+        treated: z.number().int().nonnegative().optional(),
+      })
+      .describe("Updated casualty numbers")
+      .optional(),
+  }),
+  async execute(args, ctx) {
+    return updateState(ctx, (state) => {
+      const inc = findIncident(state, args.incidentId);
+      if ("error" in inc) return inc;
+      const blocked = assertNotResolved(inc, `set status to ${args.status}`);
+      if (blocked) return blocked;
+
+      inc.status = args.status;
+      logEvent(inc, `Status → ${args.status}${args.notes ? `: ${args.notes}` : ""}`);
+
+      if (args.casualtyUpdate) {
+        if (args.casualtyUpdate.confirmed !== undefined) {
+          inc.casualties.confirmed = args.casualtyUpdate.confirmed;
+        }
+        if (args.casualtyUpdate.treated !== undefined) {
+          inc.casualties.treated = args.casualtyUpdate.treated;
+        }
+      }
+
+      // Only touch resources still assigned to THIS incident — a unit that
+      // radioed available and was re-dispatched elsewhere belongs to its
+      // new incident now.
+      const ownResources = state.resources.filter((r) => r.assignedIncident === inc.id);
+
+      if (args.status === "resolved") {
+        for (const r of ownResources) {
+          r.status = "returning";
+          r.assignedIncident = null;
+          r.eta = null;
+        }
+        inc.assignedResources = [];
+        logEvent(inc, "All resources released — incident closed");
+      }
+
+      if (args.status === "en_route" || args.status === "on_scene") {
+        for (const r of ownResources) {
+          r.status = args.status;
+          if (args.status === "on_scene") r.eta = null;
+        }
+      }
+
+      return {
+        incidentId: args.incidentId,
+        newStatus: args.status,
+        timeline: inc.timeline.slice(-5).map((t) => t.event),
+        casualties: inc.casualties,
+      };
+    });
+  },
+});

package/dist/templates/dispatch-center/tools/ops_dashboard.ts

@@ -0,0 +1,52 @@
+import { tool } from "@alexkroman1/aai";
+import { getState, incidentAgeMinutes, resourceBrief, resourceUtilization } from "../shared.ts";
+
+export const opsDashboard = tool({
+  description:
+    "Get the full operational dashboard: alert level, resource utilization, active incidents, and available resources.",
+  async execute(_args, ctx) {
+    const state = getState(ctx);
+
+    const activeIncidents = Object.values(state.incidents)
+      .filter((i) => i.status !== "resolved")
+      .sort((a, b) => b.triageScore - a.triageScore);
+
+    const resolvedCount = Object.values(state.incidents).filter(
+      (i) => i.status === "resolved",
+    ).length;
+
+    const resourceSummary = {
+      total: state.resources.length,
+      available: state.resources.filter((r) => r.status === "available").length,
+      dispatched: state.resources.filter((r) => r.status === "dispatched").length,
+      enRoute: state.resources.filter((r) => r.status === "en_route").length,
+      onScene: state.resources.filter((r) => r.status === "on_scene").length,
+      returning: state.resources.filter((r) => r.status === "returning").length,
+    };
+
+    const utilization = Math.round(resourceUtilization(state) * 100);
+
+    return {
+      systemAlertLevel: state.alertLevel,
+      mutualAidActive: state.mutualAidRequested,
+      resourceUtilization: `${utilization}%`,
+      resourceSummary,
+      activeIncidentCount: activeIncidents.length,
+      resolvedIncidentCount: resolvedCount,
+      activeIncidents: activeIncidents.map((i) => ({
+        id: i.id,
+        type: i.type,
+        severity: i.severity,
+        status: i.status,
+        location: i.location,
+        triageScore: i.triageScore,
+        assignedResourceCount: i.assignedResources.length,
+        ageMinutes: incidentAgeMinutes(i),
+        casualties: i.casualties,
+      })),
+      availableResources: state.resources
+        .filter((r) => r.status === "available")
+        .map(resourceBrief),
+    };
+  },
+});

package/dist/templates/dispatch-center/tools/ops_protocols.ts

@@ -0,0 +1,27 @@
+import { tool } from "@alexkroman1/aai";
+import { z } from "zod";
+import { getApplicableProtocols, INCIDENT_TYPES, SEVERITIES } from "../shared.ts";
+
+export const opsProtocols = tool({
+  description: "Look up step-by-step response protocols for a given incident type and severity.",
+  parameters: z.object({
+    incidentType: z.enum(INCIDENT_TYPES).describe("Type of incident"),
+    severity: z.enum(SEVERITIES).describe("Severity level"),
+  }),
+  async execute(args) {
+    const protocols = getApplicableProtocols(args.incidentType, args.severity);
+    if (protocols.length === 0) {
+      return {
+        message: "No specific protocols for this combination. Use standard operating procedures.",
+        protocols: [],
+      };
+    }
+    return {
+      protocols: protocols.map((p) => ({
+        name: p.name,
+        steps: p.steps,
+        requiredResources: p.requiredResources,
+      })),
+    };
+  },
+});

package/dist/templates/dispatch-center/tools/ops_run_scenario.ts

@@ -0,0 +1,149 @@
+import { tool } from "@alexkroman1/aai";
+import { z } from "zod";
+import type { Incident, IncidentType, Severity } from "../shared.ts";
+import { calculateTriageScore, createIncident, updateState } from "../shared.ts";
+
+type ScenarioIncident = Pick<Incident, "location" | "description" | "type" | "severity">;
+type ScenarioDef = { narrative: string; incidents: ScenarioIncident[] };
+
+const inc = (
+  location: string,
+  description: string,
+  type: IncidentType,
+  severity: Severity,
+): ScenarioIncident => ({ location, description, type, severity });
+
+// `satisfies` keeps the keys literal, so the tool's enum below is derived —
+// adding a scenario here is the only edit needed.
+const scenarios = {
+  mass_casualty: {
+    narrative:
+      "Bus crash at Main and 5th. School bus vs delivery truck. Multiple pediatric patients. Fuel spill.",
+    incidents: [
+      inc(
+        "Main St and 5th Ave intersection",
+        "School bus collision with delivery truck, multiple children injured, bus on its side, fuel leaking",
+        "traffic",
+        "critical",
+      ),
+      inc(
+        "Main St and 5th Ave — fuel spill",
+        "Diesel fuel spill from delivery truck spreading toward storm drain, ~50 gallons",
+        "hazmat",
+        "urgent",
+      ),
+    ],
+  },
+  multi_alarm_fire: {
+    narrative:
+      "Working structure fire at 200 Industrial Parkway. 3-story warehouse, heavy smoke. Workers possibly trapped.",
+    incidents: [
+      inc(
+        "200 Industrial Parkway",
+        "3-story warehouse fully involved, possible trapped occupants on 2nd/3rd floor",
+        "fire",
+        "critical",
+      ),
+      inc(
+        "200 Industrial Parkway — medical",
+        "2 workers with smoke inhalation, one with burns",
+        "medical",
+        "urgent",
+      ),
+    ],
+  },
+  active_shooter: {
+    narrative:
+      "Active shooter at Riverside Mall. Multiple shots fired, crowds fleeing. At least 3 victims down in food court.",
+    incidents: [
+      inc(
+        "Riverside Mall, 1500 River Road — food court",
+        "Active shooter, multiple shots, at least 3 victims down, shooter moving toward west entrance",
+        "crime",
+        "critical",
+      ),
+      inc(
+        "Riverside Mall parking lot",
+        "Crowd crush injuries, several trampled near east exit",
+        "medical",
+        "urgent",
+      ),
+    ],
+  },
+  natural_disaster: {
+    narrative:
+      "EF-3 tornado in residential area. Oak Street corridor. Multiple structures collapsed. Power lines down.",
+    incidents: [
+      inc(
+        "Oak Street between 10th and 15th",
+        "Tornado damage, homes collapsed, people trapped, gas lines ruptured",
+        "natural_disaster",
+        "critical",
+      ),
+      inc(
+        "Oak Street Elementary School",
+        "School roof partially collapsed, staff sheltering students",
+        "natural_disaster",
+        "critical",
+      ),
+      inc(
+        "Oak Street and 12th — utility",
+        "Downed power lines sparking, gas main rupture, area needs isolation",
+        "utility",
+        "urgent",
+      ),
+    ],
+  },
+  highway_pileup: {
+    narrative:
+      "20+ vehicle pileup on I-95 southbound mile marker 42. Fog. Multiple entrapments. Tanker truck involved.",
+    incidents: [
+      inc(
+        "I-95 southbound mile marker 42",
+        "Multi-vehicle pileup, 20+ vehicles, multiple entrapments, tanker with unknown cargo, heavy fog",
+        "traffic",
+        "critical",
+      ),
+      inc(
+        "I-95 southbound — hazmat",
+        "Tanker leaking unknown liquid, placards not visible, exclusion zone being set up",
+        "hazmat",
+        "critical",
+      ),
+    ],
+  },
+} satisfies Record<string, ScenarioDef>;
+
+type ScenarioName = keyof typeof scenarios;
+const SCENARIO_NAMES = Object.keys(scenarios) as [ScenarioName, ...ScenarioName[]];
+
+export const opsRunScenario = tool({
+  description: "Run a training scenario that creates simulated incidents for dispatch practice.",
+  parameters: z.object({
+    scenario: z.enum(SCENARIO_NAMES).describe("Scenario type to simulate"),
+  }),
+  async execute(args, ctx) {
+    return updateState(ctx, (state) => {
+      const s = scenarios[args.scenario];
+
+      const created: string[] = [];
+      for (const scenarioInc of s.incidents) {
+        const fullInc = createIncident(state, {
+          ...scenarioInc,
+          callerName: "Scenario",
+          callerPhone: "N/A",
+          triageScore: calculateTriageScore(scenarioInc.severity, scenarioInc.type, 0, 0),
+          timeline: [{ time: Date.now(), event: `SCENARIO: ${scenarioInc.description}` }],
+        });
+        created.push(fullInc.id);
+      }
+
+      return {
+        scenario: args.scenario,
+        narrative: s.narrative,
+        incidentsCreated: created,
+        message: `SCENARIO ACTIVE: ${s.narrative}. ${created.length} incidents created. Awaiting dispatch orders.`,
+      };
+    });
+  },
+});

package/dist/templates/dispatch-center/tools/resources_dispatch.ts

@@ -0,0 +1,97 @@
+import { tool } from "@alexkroman1/aai";
+import { z } from "zod";
+import type { Resource } from "../shared.ts";
+import {
+  assertNotResolved,
+  findIncident,
+  logEvent,
+  recommendResources,
+  updateState,
+} from "../shared.ts";
+
+export const resourcesDispatch = tool({
+  description:
+    "Dispatch units to an incident. Can auto-dispatch recommended resources or manually specify callsigns.",
+  parameters: z.object({
+    incidentId: z.string().max(20).describe("The incident ID"),
+    callsigns: z
+      .array(z.string().max(50))
+      .max(20)
+      .describe(
+        "Resource callsigns to dispatch, or the single entry 'auto' for system-recommended resources.",
+      )
+      .optional(),
+    autoDispatch: z
+      .boolean()
+      .describe("If true, automatically dispatch recommended resources")
+      .optional(),
+    priority: z
+      .enum(["routine", "priority", "emergency"])
+      .describe("Dispatch priority — affects simulated ETA")
+      .optional(),
+  }),
+  async execute(args, ctx) {
+    return updateState(ctx, (state) => {
+      const inc = findIncident(state, args.incidentId);
+      if ("error" in inc) return inc;
+      const blocked = assertNotResolved(inc, "dispatch resources");
+      if (blocked) return blocked;
+
+      const dispatched: { callsign: string; type: string; eta: number }[] = [];
+      const failed: { callsign: string; reason: string }[] = [];
+
+      // The literal "auto" callsign means the same thing as autoDispatch.
+      const wantsAuto =
+        args.autoDispatch || args.callsigns?.some((cs) => cs.toLowerCase() === "auto");
+
+      let resourcesToDispatch: Resource[] = [];
+
+      if (wantsAuto) {
+        resourcesToDispatch = recommendResources(inc.type, inc.severity, state);
+      } else if (args.callsigns) {
+        for (const cs of args.callsigns) {
+          const r = state.resources.find((r) => r.callsign.toLowerCase() === cs.toLowerCase());
+          if (!r) {
+            failed.push({ callsign: cs, reason: "Not found" });
+            continue;
+          }
+          if (r.status !== "available") {
+            failed.push({ callsign: cs, reason: `Currently ${r.status}` });
+            continue;
+          }
+          resourcesToDispatch.push(r);
+        }
+      }
+
+      const etaBase = args.priority === "emergency" ? 3 : args.priority === "priority" ? 6 : 10;
+
+      for (const r of resourcesToDispatch) {
+        const eta = etaBase + Math.floor(Math.random() * 5);
+        r.status = "dispatched";
+        r.assignedIncident = args.incidentId;
+        r.eta = eta;
+        inc.assignedResources.push(r.id);
+        dispatched.push({ callsign: r.callsign, type: r.type, eta });
+        logEvent(inc, `Dispatched ${r.callsign} — ETA ${eta} min`);
+      }
+
+      if (dispatched.length > 0) {
+        inc.status = "dispatched";
+      }
+
+      const availableCount = state.resources.filter((r) => r.status === "available").length;
+
+      return {
+        incidentId: args.incidentId,
+        dispatched,
+        failed: failed.length > 0 ? failed : undefined,
+        totalAssignedToIncident: inc.assignedResources.length,
+        remainingAvailableResources: availableCount,
+        capacityWarning:
+          availableCount <= 3
+            ? "WARNING: Resource capacity critically low. Consider mutual aid."
+            : undefined,
+      };
+    });
+  },
+});