@runa-ai/runa-cli 0.5.26

package/dist/commands/hotfix/machine.d.ts

@@ -0,0 +1,242 @@
+/**
+ * AI HINT: Hotfix XState Machine - Emergency Fix Workflow
+ *
+ * Purpose: Orchestrate hotfix workflow from creation to completion
+ * Pattern: CLI-centric state machine with observable behavior
+ * Location: CLI owns workflow orchestration
+ *
+ * State Flow:
+ * loading → idle → creating → inProgress → deploying → deployed → completing → completed
+ *                                        ↘ cancelling → cancelled
+ *
+ * The E2E Rule:
+ * - Each state produces observable behavior (log output, file changes)
+ * - Exit codes: 0=success, 1=failure, 2=cancelled
+ * - All transitions are testable via snapshot assertions
+ *
+ * E2E Test Mapping (CLI observable behavior):
+ * - loading → expect(log).toContain('Loading hotfix metadata')
+ * - idle → expect(log).toContain('No active hotfix')
+ * - creating → expect(file('.hotfix/metadata.json')).toExist()
+ * - inProgress → expect(log).toContain('Hotfix in progress')
+ * - deploying → expect(log).toContain('Deploying hotfix')
+ * - deployed → expect(log).toContain('Hotfix deployed')
+ * - completing → expect(log).toContain('Completing hotfix')
+ * - completed → expect(exitCode).toBe(0)
+ * - cancelled → expect(exitCode).toBe(2)
+ *
+ * Usage:
+ * ```ts
+ * import { runMachine } from '../../internal/machines/index.js';
+ * import { hotfixMachine } from './machine.js';
+ *
+ * const result = await runMachine({
+ *   machine: hotfixMachine,
+ *   input: { targetDir: process.cwd() },
+ *   logger,
+ * });
+ * ```
+ */
+import { type SnapshotFrom } from 'xstate';
+import * as actors from './actors.js';
+import type { HotfixMetadata } from './contract.js';
+export interface HotfixContext {
+    targetDir: string;
+    metadata: HotfixMetadata | null;
+    prUrl?: string;
+    error?: string;
+}
+export type HotfixEvent = {
+    type: 'CREATE';
+    name: string;
+    base?: string;
+    skipSnapshot?: boolean;
+} | {
+    type: 'DEPLOY';
+    autoApprove?: boolean;
+    skipChecks?: boolean;
+} | {
+    type: 'COMPLETE';
+    noPr?: boolean;
+    autoApprove?: boolean;
+} | {
+    type: 'CANCEL';
+} | {
+    type: 'RESTORE';
+};
+export declare const hotfixMachine: import("xstate").StateMachine<HotfixContext, {
+    type: "CREATE";
+    name: string;
+    base?: string;
+    skipSnapshot?: boolean;
+} | {
+    type: "DEPLOY";
+    autoApprove?: boolean;
+    skipChecks?: boolean;
+} | {
+    type: "COMPLETE";
+    noPr?: boolean;
+    autoApprove?: boolean;
+} | {
+    type: "CANCEL";
+} | {
+    type: "RESTORE";
+}, {
+    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<{
+        metadata: {
+            branch: string;
+            base: string;
+            createdAt: string;
+            createdBy: string;
+            status: "cancelled" | "deployed" | "in_progress" | "completed";
+            snapshot?: string | undefined;
+            deployedAt?: string | undefined;
+            completedAt?: string | undefined;
+        };
+        snapshotFile?: string | undefined;
+    }, actors.CreateHotfixInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<{
+        deployedAt: string;
+    }, actors.DeployHotfixInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<{
+        prUrl: string;
+        completedAt: string;
+    }, actors.CompleteHotfixInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<void, actors.CancelHotfixInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<{
+        branch: string;
+        base: string;
+        createdAt: string;
+        createdBy: string;
+        status: "cancelled" | "deployed" | "in_progress" | "completed";
+        snapshot?: string | undefined;
+        deployedAt?: string | undefined;
+        completedAt?: string | undefined;
+    } | null, actors.LoadMetadataInput, import("xstate").EventObject>> | undefined;
+}, {
+    src: "createHotfix";
+    logic: import("xstate").PromiseActorLogic<{
+        metadata: {
+            branch: string;
+            base: string;
+            createdAt: string;
+            createdBy: string;
+            status: "cancelled" | "deployed" | "in_progress" | "completed";
+            snapshot?: string | undefined;
+            deployedAt?: string | undefined;
+            completedAt?: string | undefined;
+        };
+        snapshotFile?: string | undefined;
+    }, actors.CreateHotfixInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "deployHotfix";
+    logic: import("xstate").PromiseActorLogic<{
+        deployedAt: string;
+    }, actors.DeployHotfixInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "completeHotfix";
+    logic: import("xstate").PromiseActorLogic<{
+        prUrl: string;
+        completedAt: string;
+    }, actors.CompleteHotfixInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "cancelHotfix";
+    logic: import("xstate").PromiseActorLogic<void, actors.CancelHotfixInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "loadMetadata";
+    logic: import("xstate").PromiseActorLogic<{
+        branch: string;
+        base: string;
+        createdAt: string;
+        createdBy: string;
+        status: "cancelled" | "deployed" | "in_progress" | "completed";
+        snapshot?: string | undefined;
+        deployedAt?: string | undefined;
+        completedAt?: string | undefined;
+    } | null, actors.LoadMetadataInput, import("xstate").EventObject>;
+    id: string | undefined;
+}, {
+    type: "setMetadata";
+    params: {
+        metadata: HotfixMetadata;
+    };
+} | {
+    type: "setError";
+    params: {
+        error: string;
+    };
+} | {
+    type: "setPrUrl";
+    params: {
+        prUrl: string;
+    };
+} | {
+    type: "clearError";
+    params: import("xstate").NonReducibleUnknown;
+}, {
+    type: "hasActiveHotfix";
+    params: unknown;
+} | {
+    type: "isInProgress";
+    params: unknown;
+} | {
+    type: "isDeployed";
+    params: unknown;
+}, never, "idle" | "cancelled" | "deployed" | "completed" | "inProgress" | "creating" | "deploying" | "cancelling" | "completing" | "loading", string, {
+    targetDir?: string | undefined;
+    existingMetadata?: {
+        branch: string;
+        base: string;
+        createdAt: string;
+        createdBy: string;
+        status: "cancelled" | "deployed" | "in_progress" | "completed";
+        snapshot?: string | undefined;
+        deployedAt?: string | undefined;
+        completedAt?: string | undefined;
+    } | null | undefined;
+}, {
+    success: boolean;
+    exitCode: 0 | 1 | 2;
+    finalState: string;
+    metadata: {
+        branch: string;
+        base: string;
+        createdAt: string;
+        createdBy: string;
+        status: "cancelled" | "deployed" | "in_progress" | "completed";
+        snapshot?: string | undefined;
+        deployedAt?: string | undefined;
+        completedAt?: string | undefined;
+    } | null;
+    prUrl?: string | undefined;
+    error?: string | undefined;
+}, import("xstate").EventObject, import("xstate").MetaObject, {
+    id: "hotfix";
+    states: {
+        readonly loading: {};
+        readonly idle: {};
+        readonly creating: {};
+        readonly inProgress: {};
+        readonly deploying: {};
+        readonly deployed: {};
+        readonly completing: {};
+        readonly cancelling: {};
+        readonly completed: {};
+        readonly cancelled: {};
+    };
+}>;
+export type HotfixMachine = typeof hotfixMachine;
+export type HotfixSnapshot = SnapshotFrom<typeof hotfixMachine>;
+/**
+ * Get current state name from snapshot
+ */
+export declare function getHotfixStateName(snapshot: HotfixSnapshot): string;
+/**
+ * Check if machine is in a final state
+ */
+export declare function isHotfixComplete(snapshot: HotfixSnapshot): boolean;
+/**
+ * Get available events for current state
+ */
+export declare function getAvailableHotfixEvents(snapshot: HotfixSnapshot): string[];
+//# sourceMappingURL=machine.d.ts.map

package/dist/commands/hotfix/machine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"machine.d.ts","sourceRoot":"","sources":["../../../src/commands/hotfix/machine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,EAAU,KAAK,YAAY,EAAS,MAAM,QAAQ,CAAC;AAE1D,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AACtC,OAAO,KAAK,EAGV,cAAc,EAEf,MAAM,eAAe,CAAC;AAuIvB,MAAM,WAAW,aAAa;IAE5B,SAAS,EAAE,MAAM,CAAC;IAElB,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAC;IAEhC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAMD,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,OAAO,CAAA;CAAE,GACvE;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,OAAO,CAAA;CAAE,GAC/D;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,OAAO,CAAA;CAAE,GAC3D;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAAC;AAMxB,eAAO,MAAM,aAAa;UAVd,QAAQ;UAAQ,MAAM;WAAS,MAAM;mBAAiB,OAAO;;UAC7D,QAAQ;kBAAgB,OAAO;iBAAe,OAAO;;UACrD,UAAU;WAAS,OAAO;kBAAgB,OAAO;;UACjD,QAAQ;;UACR,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA2BmB,cAAc;;;;;eAGpB,MAAM;;;;;eAGN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4OtC,CAAC;AAMH,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC;AACjD,MAAM,MAAM,cAAc,GAAG,YAAY,CAAC,OAAO,aAAa,CAAC,CAAC;AAEhE;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,CAEnE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAElE;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,EAAE,CAY3E"}

package/dist/commands/hotfix/metadata.d.ts

@@ -0,0 +1,37 @@
+import { type CreateHotfixMetadataInput, type GetHotfixInput, type HotfixMetadata, type ListArchivedHotfixesInput, type ListArchivedHotfixesOutput, type UpdateHotfixInput } from './contract.js';
+export type { HotfixMetadata, HotfixStatus } from './contract.js';
+/**
+ * Get current hotfix metadata
+ */
+export declare function getHotfixMetadata(input?: GetHotfixInput): Promise<HotfixMetadata | null>;
+/**
+ * Check if there's an active hotfix
+ */
+export declare function hasActiveHotfix(targetDir?: string): Promise<boolean>;
+/**
+ * Create hotfix metadata
+ *
+ * @param input - Validated input with branch name (use validateHotfixName first)
+ */
+export declare function createHotfixMetadata(input: CreateHotfixMetadataInput): Promise<HotfixMetadata>;
+/**
+ * Update hotfix status
+ */
+export declare function updateHotfixStatus(input: UpdateHotfixInput): Promise<HotfixMetadata>;
+/**
+ * Archive current hotfix and clear active state
+ */
+export declare function archiveHotfix(targetDir?: string): Promise<HotfixMetadata>;
+/**
+ * Cancel current hotfix
+ */
+export declare function cancelHotfix(targetDir?: string): Promise<HotfixMetadata>;
+/**
+ * List archived hotfixes
+ */
+export declare function listArchivedHotfixes(input?: ListArchivedHotfixesInput): Promise<ListArchivedHotfixesOutput>;
+/**
+ * Validate hotfix branch name
+ */
+export declare function validateHotfixName(name: string): string;
+//# sourceMappingURL=metadata.d.ts.map

package/dist/commands/hotfix/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../../src/commands/hotfix/metadata.ts"],"names":[],"mappings":"AAqBA,OAAO,EACL,KAAK,yBAAyB,EAE9B,KAAK,cAAc,EAEnB,KAAK,cAAc,EAEnB,KAAK,yBAAyB,EAE9B,KAAK,0BAA0B,EAE/B,KAAK,iBAAiB,EAEvB,MAAM,eAAe,CAAC;AAMvB,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AA8BlE;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,KAAK,GAAE,cAAmB,GACzB,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAWhC;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAG1E;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,yBAAyB,GAC/B,OAAO,CAAC,cAAc,CAAC,CAmBzB;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,cAAc,CAAC,CAoB1F;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CA6B/E;AAED;;GAEG;AACH,wBAAsB,YAAY,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAU9E;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,GAAE,yBAA8B,GACpC,OAAO,CAAC,0BAA0B,CAAC,CA+BrC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAYvD"}

package/dist/commands/hotfix/utils/hotfix-machine-helper.d.ts

@@ -0,0 +1,58 @@
+/**
+ * AI HINT: Hotfix Machine CLI Integration Helper
+ *
+ * Purpose: Shared utilities for CLI commands to interact with hotfixMachine
+ * Pattern: Create actor → Wait for loading → Send events → Wait for transitions
+ *
+ * Key Functions:
+ * - createHotfixActor: Create and start machine, wait for initial state
+ * - waitForStateTransition: Wait for machine to reach target state(s)
+ * - getHotfixState: Get current machine state info
+ */
+import { type ActorRefFrom } from 'xstate';
+import { type HotfixEvent, type HotfixSnapshot, hotfixMachine } from '../machine.js';
+export type HotfixActor = ActorRefFrom<typeof hotfixMachine>;
+/**
+ * Create and start a hotfix actor, waiting for initial state loading to complete
+ */
+export declare function createHotfixActor(targetDir?: string, options?: {
+    timeout?: number;
+}): Promise<HotfixActor>;
+/**
+ * Wait for the machine to reach one of the target states
+ * Returns the snapshot when target state is reached, or throws on error/timeout
+ */
+export declare function waitForStateTransition(actor: HotfixActor, targetStates: string[], options?: {
+    timeout?: number;
+    errorStates?: string[];
+}): Promise<HotfixSnapshot>;
+/**
+ * Send an event to the actor and wait for a target state
+ */
+export declare function sendAndWait(actor: HotfixActor, event: HotfixEvent, targetStates: string[], options?: {
+    timeout?: number;
+    transitionStates?: string[];
+}): Promise<HotfixSnapshot>;
+/**
+ * Get current state information from snapshot
+ */
+export interface HotfixStateInfo {
+    state: string;
+    isComplete: boolean;
+    availableEvents: string[];
+    metadata: {
+        branch?: string;
+        base?: string;
+        status?: string;
+        createdAt?: string;
+        deployedAt?: string;
+    } | null;
+    error?: string;
+    prUrl?: string;
+}
+export declare function getHotfixState(snapshot: HotfixSnapshot): HotfixStateInfo;
+/**
+ * Check if a specific event is available in current state
+ */
+export declare function canSendEvent(snapshot: HotfixSnapshot, eventType: string): boolean;
+//# sourceMappingURL=hotfix-machine-helper.d.ts.map

package/dist/commands/hotfix/utils/hotfix-machine-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hotfix-machine-helper.d.ts","sourceRoot":"","sources":["../../../../src/commands/hotfix/utils/hotfix-machine-helper.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,KAAK,YAAY,EAAe,MAAM,QAAQ,CAAC;AACxD,OAAO,EAGL,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,aAAa,EAEd,MAAM,eAAe,CAAC;AAEvB,MAAM,MAAM,WAAW,GAAG,YAAY,CAAC,OAAO,aAAa,CAAC,CAAC;AAE7D;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,GAAE,MAAsB,EACjC,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GACjC,OAAO,CAAC,WAAW,CAAC,CA0BtB;AAuCD;;;GAGG;AACH,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,WAAW,EAClB,YAAY,EAAE,MAAM,EAAE,EACtB,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;CAAO,GACzD,OAAO,CAAC,cAAc,CAAC,CA2CzB;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,WAAW,EAClB,YAAY,EAAE,MAAM,EAAE,EACtB,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CAAO,GAC9D,OAAO,CAAC,cAAc,CAAC,CA4CzB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,QAAQ,EAAE;QACR,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,GAAG,IAAI,CAAC;IACT,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,cAAc,GAAG,eAAe,CAiBxE;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAEjF"}

package/dist/commands/init.d.ts

@@ -0,0 +1,21 @@
+/**
+ * AI HINT: runa init command
+ *
+ * Purpose: Initialize pj-repo with runa configuration
+ * Design: Uses CLIError for error handling (no process.exit)
+ *
+ * Generates:
+ * - .github/workflows/runa.yml (CI/CD workflow)
+ * - runa.config.ts (project configuration)
+ * - AGENTS.md (AI development guidelines)
+ * - CLAUDE.md (Claude Code guide)
+ * - .claude/ (Claude Code configuration - rules, skills, commands)
+ * - .husky/_common.sh (shared shell functions)
+ * - .husky/pre-commit (typecheck, lint)
+ * - .husky/pre-push (Layer 0 tests)
+ * - biome.json (formatter)
+ * - .npmrc (GitHub Packages registry)
+ */
+import { Command } from 'commander';
+export declare const initCommand: Command;
+//# sourceMappingURL=init.d.ts.map

package/dist/commands/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAcH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAqYpC,eAAO,MAAM,WAAW,SAgKpB,CAAC"}

package/dist/commands/inject-test-attrs/action.d.ts

@@ -0,0 +1,14 @@
+/**
+ * AI HINT: inject-test-attrs Shared Action
+ *
+ * Purpose: Shared action logic for the inject-test-attrs command
+ * Pattern: Extract action logic from CLI entry point for testability
+ *
+ * Commands: runa inject-test-attrs (or via runa build which calls this internally)
+ */
+import type { Command } from 'commander';
+/**
+ * Shared action handler for inject-test-attrs and manifest commands
+ */
+export declare function injectTestAttrsAction(rawOptions: Record<string, unknown>, command: Command): Promise<void>;
+//# sourceMappingURL=action.d.ts.map

package/dist/commands/inject-test-attrs/action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.d.ts","sourceRoot":"","sources":["../../../src/commands/inject-test-attrs/action.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAuFzC;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,IAAI,CAAC,CAgDf"}

package/dist/commands/inject-test-attrs/commands/inject-test-attrs.d.ts

@@ -0,0 +1,16 @@
+/**
+ * AI HINT: inject-test-attrs CLI Entry Point
+ *
+ * Purpose: CLI interface for XState test attribute injection
+ * Pattern: Source-injection (git-managed output, like drizzle-kit)
+ *
+ * Usage:
+ *   runa inject-test-attrs           # Inject attributes to source files
+ *   runa inject-test-attrs --check   # Check if files need injection (CI)
+ *   runa inject-test-attrs --verbose # Show detailed output
+ *
+ * Note: Consider using `runa manifest` for cleaner build integration.
+ */
+import { Command } from 'commander';
+export declare const injectTestAttrsCommand: Command;
+//# sourceMappingURL=inject-test-attrs.d.ts.map

package/dist/commands/inject-test-attrs/commands/inject-test-attrs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-test-attrs.d.ts","sourceRoot":"","sources":["../../../../src/commands/inject-test-attrs/commands/inject-test-attrs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,eAAO,MAAM,sBAAsB,SAuB/B,CAAC"}

package/dist/commands/inject-test-attrs/contract.d.ts

@@ -0,0 +1,52 @@
+/**
+ * AI HINT: inject-test-attrs Contract
+ *
+ * Purpose: Zod schemas for inject-test-attrs I/O validation
+ * Pattern: Contract-first design - all inputs/outputs strictly typed
+ *
+ * Flow: discover → filter → transform → write → format
+ */
+import { z } from 'zod';
+export declare const InjectTestAttrsInputSchema: z.ZodObject<{
+    check: z.ZodDefault<z.ZodBoolean>;
+    force: z.ZodDefault<z.ZodBoolean>;
+    verbose: z.ZodDefault<z.ZodBoolean>;
+    include: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    manifest: z.ZodDefault<z.ZodBoolean>;
+    manifestDir: z.ZodDefault<z.ZodString>;
+    resolveSchemas: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const FileChangeSchema: z.ZodObject<{
+    filePath: z.ZodString;
+    injectedCount: z.ZodNumber;
+    machineIds: z.ZodArray<z.ZodString>;
+    changed: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const MachineWithoutE2EMetaSchema: z.ZodObject<{
+    id: z.ZodString;
+    sourceFile: z.ZodString;
+}, z.core.$strip>;
+export declare const InjectTestAttrsOutputSchema: z.ZodObject<{
+    totalFiles: z.ZodNumber;
+    changedFiles: z.ZodNumber;
+    totalInjections: z.ZodNumber;
+    changes: z.ZodArray<z.ZodObject<{
+        filePath: z.ZodString;
+        injectedCount: z.ZodNumber;
+        machineIds: z.ZodArray<z.ZodString>;
+        changed: z.ZodBoolean;
+    }, z.core.$strip>>;
+    exitCode: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+    manifestPath: z.ZodOptional<z.ZodString>;
+    manifestMachineCount: z.ZodOptional<z.ZodNumber>;
+    machinesWithoutE2EMeta: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sourceFile: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strict>;
+export type InjectTestAttrsInput = z.infer<typeof InjectTestAttrsInputSchema>;
+export type InjectTestAttrsOutput = z.infer<typeof InjectTestAttrsOutputSchema>;
+export type FileChange = z.infer<typeof FileChangeSchema>;
+export type MachineWithoutE2EMeta = z.infer<typeof MachineWithoutE2EMetaSchema>;
+//# sourceMappingURL=contract.d.ts.map

package/dist/commands/inject-test-attrs/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../src/commands/inject-test-attrs/contract.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,0BAA0B;;;;;;;;;kBA8B5B,CAAC;AAGZ,eAAO,MAAM,gBAAgB;;;;;iBAK3B,CAAC;AAGH,eAAO,MAAM,2BAA2B;;;iBAGtC,CAAC;AAGH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;kBAc7B,CAAC;AAGZ,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/commands/inject-test-attrs/formatter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * AI HINT: inject-test-attrs Formatter
+ *
+ * Purpose: Format transformed files with Biome
+ * Pattern: Run biome format on batch of files
+ *
+ * Security: Uses execa with array arguments to prevent command injection
+ */
+/**
+ * Format files with Biome
+ */
+export declare function formatFilesWithBiome(files: string[], cwd: string): Promise<void>;
+//# sourceMappingURL=formatter.d.ts.map

package/dist/commands/inject-test-attrs/formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../../../src/commands/inject-test-attrs/formatter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH;;GAEG;AACH,wBAAsB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAgBtF"}

package/dist/commands/inject-test-attrs/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * AI HINT: inject-test-attrs Barrel Export
+ *
+ * Purpose: Export CLI command and processor for external use
+ */
+export { injectTestAttrsCommand } from './commands/inject-test-attrs.js';
+export type { FileChange, InjectTestAttrsInput, InjectTestAttrsOutput } from './contract.js';
+export { type ProcessorOptions, processFiles } from './processor.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/inject-test-attrs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/inject-test-attrs/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AACzE,YAAY,EAAE,UAAU,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAC7F,OAAO,EAAE,KAAK,gBAAgB,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/commands/inject-test-attrs/manifest-generator.d.ts

@@ -0,0 +1,21 @@
+/**
+ * AI HINT: inject-test-attrs Manifest Generator
+ *
+ * Purpose: Generate E2E selector manifest and API contracts
+ * Pattern: Build unified manifest from XState machines and Hono routes
+ */
+import type { MachineWithoutE2EMeta } from './contract.js';
+/**
+ * Generate and write manifest files with enhanced metadata
+ *
+ * @param manifestDir - Directory for manifest output
+ * @param repoRoot - Repository root directory
+ * @param verbose - Enable verbose logging
+ * @param resolveSchemas - Whether to resolve Zod schemas to JSON Schema (v7+)
+ */
+export declare function generateManifestFiles(manifestDir: string, repoRoot: string, verbose: boolean, resolveSchemas?: boolean): Promise<{
+    manifestPath: string;
+    machineCount: number;
+    machinesWithoutE2EMeta: MachineWithoutE2EMeta[];
+}>;
+//# sourceMappingURL=manifest-generator.d.ts.map

package/dist/commands/inject-test-attrs/manifest-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest-generator.d.ts","sourceRoot":"","sources":["../../../src/commands/inject-test-attrs/manifest-generator.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAkEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAkY3D;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CACzC,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,EAChB,cAAc,GAAE,OAAe,GAC9B,OAAO,CAAC;IACT,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,sBAAsB,EAAE,qBAAqB,EAAE,CAAC;CACjD,CAAC,CAyHD"}

package/dist/commands/inject-test-attrs/processor-utils.d.ts

@@ -0,0 +1,76 @@
+/**
+ * AI HINT: inject-test-attrs Processor Utilities
+ *
+ * Purpose: Utility functions for test attribute injection
+ * Pattern: Pure functions for code analysis and attribute extraction
+ */
+import type { ProcessFileResult } from './types.js';
+/** Marker comment to detect CLI-injected files */
+export declare const CLI_INJECTION_MARKER = "@xstate-test-attrs-injected";
+/**
+ * Check if a file path should be excluded from manifest collection
+ * Prevents template/internal files from mixing with actual app code
+ *
+ * Used for:
+ * - Routes (pages, layouts, API routes)
+ * - Machine definitions
+ * - Any file that shouldn't appear in the manifest
+ */
+export declare function isExcludedScope(filePath: string): boolean;
+/**
+ * Attribute patterns for test attribute extraction/stripping
+ * Centralized to ensure consistency between extraction and stripping operations
+ */
+export declare const ATTRIBUTE_PATTERNS: {
+    /** Pattern to match data-action attribute */
+    readonly action: RegExp;
+    /** Pattern to match data-field attribute */
+    readonly field: RegExp;
+    /** Pattern to match data-testid attribute */
+    readonly testId: RegExp;
+    /** Pattern to match data-machine-id attribute */
+    readonly machineId: RegExp;
+};
+/**
+ * Quick check if code might contain machine hooks
+ * Used as pre-filter before expensive AST parsing
+ */
+export declare function mightContainMachineHooks(code: string): boolean;
+/**
+ * Quick check if code might contain JSX
+ */
+export declare function mightContainJsx(code: string): boolean;
+/**
+ * Strip existing test attributes from code.
+ */
+export declare function stripInjectedAttributes(code: string): string;
+/**
+ * Extract attribute values from code using a pattern
+ * Helper function to reduce duplication in extractInjectedAttributes
+ */
+export declare function extractAttributeValues(code: string, pattern: RegExp): string[];
+/**
+ * Extract actions, fields, and testIds from transformed code
+ * Uses centralized ATTRIBUTE_PATTERNS for consistency
+ */
+export declare function extractInjectedAttributes(code: string): {
+    actions: string[];
+    fields: string[];
+    testIds: string[];
+};
+/**
+ * Collect route info for unified manifest
+ * This is called for ALL files, not just those with machine hooks
+ */
+export declare function collectRouteInfo(relativePath: string, code: string, _verbose: boolean): void;
+/** Empty result for skipped files */
+export declare function emptyResult(filePath: string): ProcessFileResult;
+/**
+ * Ensure a directory exists, creating it if necessary.
+ */
+export declare function ensureDirectoryExists(dirPath: string): void;
+/**
+ * Get SDK version for manifest
+ */
+export declare function getGeneratorVersion(): string;
+//# sourceMappingURL=processor-utils.d.ts.map

package/dist/commands/inject-test-attrs/processor-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processor-utils.d.ts","sourceRoot":"","sources":["../../../src/commands/inject-test-attrs/processor-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAgBH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,kDAAkD;AAClD,eAAO,MAAM,oBAAoB,gCAAgC,CAAC;AAkBlE;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;GAGG;AACH,eAAO,MAAM,kBAAkB;IAC7B,6CAA6C;;IAE7C,4CAA4C;;IAE5C,6CAA6C;;IAE7C,iDAAiD;;CAEzC,CAAC;AAEX;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAI9D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAU5D;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ9E;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG;IACvD,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAMA;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI,CA+B5F;AAED,qCAAqC;AACrC,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,CAU/D;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAI3D;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAY5C"}

package/dist/commands/inject-test-attrs/processor.d.ts

@@ -0,0 +1,35 @@
+/**
+ * AI HINT: inject-test-attrs Processor
+ *
+ * Purpose: Core processing logic for XState test attribute injection
+ * Pattern: Reuses transformer from xstate-test-plugin, writes to source files
+ *
+ * Flow:
+ * 1. Discover files via glob
+ * 2. Pre-filter (quick check for useMachine/useActor)
+ * 3. Transform using xstate-test-plugin core
+ * 4. Write transformed code back to source
+ * 5. Format with biome
+ * 6. Generate E2E selector manifest (optional)
+ *
+ * Module Structure:
+ * - processor.ts (this file): Core processing orchestration
+ * - processor-utils.ts: Utility functions (extraction, filtering)
+ * - manifest-generator.ts: Manifest generation logic
+ * - types.ts: Shared type definitions
+ */
+import type { InjectTestAttrsInput, InjectTestAttrsOutput } from './contract.js';
+export interface ProcessorOptions extends InjectTestAttrsInput {
+    /** Repository root directory */
+    repoRoot: string;
+}
+/**
+ * Process all files and inject test attributes
+ *
+ * Three-pass approach for complete manifest + cross-component detection:
+ * 1. Pre-pass: Collect machine definitions (for manifest without hooks/JSX)
+ * 2. First pass: Process files with machine hooks (to populate prop-event registry)
+ * 3. Second pass: Process files with JSX but no machine hooks (to inject from registry)
+ */
+export declare function processFiles(options: ProcessorOptions): Promise<InjectTestAttrsOutput>;
+//# sourceMappingURL=processor.d.ts.map

package/dist/commands/inject-test-attrs/processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processor.d.ts","sourceRoot":"","sources":["../../../src/commands/inject-test-attrs/processor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAcH,OAAO,KAAK,EACV,oBAAoB,EACpB,qBAAqB,EAEtB,MAAM,eAAe,CAAC;AAmBvB,MAAM,WAAW,gBAAiB,SAAQ,oBAAoB;IAC5D,gCAAgC;IAChC,QAAQ,EAAE,MAAM,CAAC;CAClB;AA+RD;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAiF5F"}