@eddacraft/anvil-runtime 0.1.0

package/dist/concurrency/types.d.ts

@@ -0,0 +1,382 @@
+/**
+ * Multi-Agent Concurrency Types
+ *
+ * Type definitions for agent registration, locking, and queuing systems
+ * to handle concurrent AI agent operations across multiple processes.
+ */
+import { z } from 'zod';
+/**
+ * Agent type enumeration
+ */
+export declare const AgentTypeSchema: z.ZodEnum<{
+    unknown: "unknown";
+    ci: "ci";
+    cursor: "cursor";
+    copilot: "copilot";
+    claude: "claude";
+    aider: "aider";
+    continue: "continue";
+    codeium: "codeium";
+    human: "human";
+}>;
+export type AgentType = z.infer<typeof AgentTypeSchema>;
+/**
+ * Agent information schema
+ */
+export declare const AgentInfoSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodDefault<z.ZodEnum<{
+        unknown: "unknown";
+        ci: "ci";
+        cursor: "cursor";
+        copilot: "copilot";
+        claude: "claude";
+        aider: "aider";
+        continue: "continue";
+        codeium: "codeium";
+        human: "human";
+    }>>;
+    pid: z.ZodOptional<z.ZodNumber>;
+    name: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    parentAgentId: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type AgentInfo = z.infer<typeof AgentInfoSchema>;
+/**
+ * Registered agent record in the registry
+ */
+export declare const AgentRegistrationSchema: z.ZodObject<{
+    agent: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodDefault<z.ZodEnum<{
+            unknown: "unknown";
+            ci: "ci";
+            cursor: "cursor";
+            copilot: "copilot";
+            claude: "claude";
+            aider: "aider";
+            continue: "continue";
+            codeium: "codeium";
+            human: "human";
+        }>>;
+        pid: z.ZodOptional<z.ZodNumber>;
+        name: z.ZodOptional<z.ZodString>;
+        sessionId: z.ZodOptional<z.ZodString>;
+        parentAgentId: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+    registeredAt: z.ZodString;
+    lastHeartbeat: z.ZodString;
+    heartbeatCount: z.ZodDefault<z.ZodNumber>;
+    state: z.ZodDefault<z.ZodEnum<{
+        active: "active";
+        idle: "idle";
+        stale: "stale";
+        terminated: "terminated";
+    }>>;
+    currentOperation: z.ZodOptional<z.ZodString>;
+    workspaceRoot: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AgentRegistration = z.infer<typeof AgentRegistrationSchema>;
+/**
+ * Agent registry file schema (.anvil/agents/registry.json)
+ */
+export declare const AgentRegistrySchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodString>;
+    updatedAt: z.ZodString;
+    agents: z.ZodRecord<z.ZodString, z.ZodObject<{
+        agent: z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodDefault<z.ZodEnum<{
+                unknown: "unknown";
+                ci: "ci";
+                cursor: "cursor";
+                copilot: "copilot";
+                claude: "claude";
+                aider: "aider";
+                continue: "continue";
+                codeium: "codeium";
+                human: "human";
+            }>>;
+            pid: z.ZodOptional<z.ZodNumber>;
+            name: z.ZodOptional<z.ZodString>;
+            sessionId: z.ZodOptional<z.ZodString>;
+            parentAgentId: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>;
+        registeredAt: z.ZodString;
+        lastHeartbeat: z.ZodString;
+        heartbeatCount: z.ZodDefault<z.ZodNumber>;
+        state: z.ZodDefault<z.ZodEnum<{
+            active: "active";
+            idle: "idle";
+            stale: "stale";
+            terminated: "terminated";
+        }>>;
+        currentOperation: z.ZodOptional<z.ZodString>;
+        workspaceRoot: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AgentRegistry = z.infer<typeof AgentRegistrySchema>;
+/**
+ * Lock type enumeration
+ */
+export declare const LockTypeSchema: z.ZodEnum<{
+    cache: "cache";
+    watch: "watch";
+    action: "action";
+    state: "state";
+    task: "task";
+}>;
+export type LockType = z.infer<typeof LockTypeSchema>;
+/**
+ * Lock record schema
+ */
+export declare const LockRecordSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        cache: "cache";
+        watch: "watch";
+        action: "action";
+        state: "state";
+        task: "task";
+    }>;
+    resource: z.ZodString;
+    agentId: z.ZodString;
+    agentType: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        ci: "ci";
+        cursor: "cursor";
+        copilot: "copilot";
+        claude: "claude";
+        aider: "aider";
+        continue: "continue";
+        codeium: "codeium";
+        human: "human";
+    }>>;
+    pid: z.ZodOptional<z.ZodNumber>;
+    acquiredAt: z.ZodString;
+    expiresAt: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+    renewCount: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type LockRecord = z.infer<typeof LockRecordSchema>;
+/**
+ * Lock file schema (.anvil/locks/{type}-{resource-hash}.lock)
+ */
+export declare const LockFileSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodString>;
+    lock: z.ZodObject<{
+        type: z.ZodEnum<{
+            cache: "cache";
+            watch: "watch";
+            action: "action";
+            state: "state";
+            task: "task";
+        }>;
+        resource: z.ZodString;
+        agentId: z.ZodString;
+        agentType: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            ci: "ci";
+            cursor: "cursor";
+            copilot: "copilot";
+            claude: "claude";
+            aider: "aider";
+            continue: "continue";
+            codeium: "codeium";
+            human: "human";
+        }>>;
+        pid: z.ZodOptional<z.ZodNumber>;
+        acquiredAt: z.ZodString;
+        expiresAt: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+        renewCount: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    history: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        acquiredAt: z.ZodString;
+        releasedAt: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type LockFile = z.infer<typeof LockFileSchema>;
+/**
+ * Lock acquisition result
+ */
+export interface LockAcquisitionResult {
+    /** Whether lock was acquired */
+    acquired: boolean;
+    /** Lock record if acquired */
+    lock?: LockRecord;
+    /** Error message if not acquired */
+    error?: string;
+    /** Existing lock holder info (if lock is held by another) */
+    heldBy?: {
+        agentId: string;
+        agentType?: AgentType;
+        acquiredAt: string;
+        expiresAt: string;
+        pid?: number;
+    };
+    /** Position in queue (if queued) */
+    queuePosition?: number;
+}
+/**
+ * Lock release result
+ */
+export interface LockReleaseResult {
+    /** Whether lock was released */
+    released: boolean;
+    /** Error message if not released */
+    error?: string;
+    /** Whether lock was held by a different agent */
+    wasHeldByOther?: boolean;
+}
+/**
+ * Queue entry schema
+ */
+export declare const QueueEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    agentId: z.ZodString;
+    agentType: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        ci: "ci";
+        cursor: "cursor";
+        copilot: "copilot";
+        claude: "claude";
+        aider: "aider";
+        continue: "continue";
+        codeium: "codeium";
+        human: "human";
+    }>>;
+    lockType: z.ZodEnum<{
+        cache: "cache";
+        watch: "watch";
+        action: "action";
+        state: "state";
+        task: "task";
+    }>;
+    resource: z.ZodString;
+    queuedAt: z.ZodString;
+    priority: z.ZodDefault<z.ZodNumber>;
+    timeoutAt: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+    callbackPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type QueueEntry = z.infer<typeof QueueEntrySchema>;
+/**
+ * Queue file schema (.anvil/queue/{resource-hash}.json)
+ */
+export declare const QueueFileSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodString>;
+    resource: z.ZodString;
+    lockType: z.ZodEnum<{
+        cache: "cache";
+        watch: "watch";
+        action: "action";
+        state: "state";
+        task: "task";
+    }>;
+    updatedAt: z.ZodString;
+    entries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        agentId: z.ZodString;
+        agentType: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            ci: "ci";
+            cursor: "cursor";
+            copilot: "copilot";
+            claude: "claude";
+            aider: "aider";
+            continue: "continue";
+            codeium: "codeium";
+            human: "human";
+        }>>;
+        lockType: z.ZodEnum<{
+            cache: "cache";
+            watch: "watch";
+            action: "action";
+            state: "state";
+            task: "task";
+        }>;
+        resource: z.ZodString;
+        queuedAt: z.ZodString;
+        priority: z.ZodDefault<z.ZodNumber>;
+        timeoutAt: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+        callbackPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type QueueFile = z.infer<typeof QueueFileSchema>;
+/**
+ * Queue join result
+ */
+export interface QueueJoinResult {
+    /** Entry ID */
+    entryId: string;
+    /** Position in queue (1-based) */
+    position: number;
+    /** Estimated wait time in ms (if calculable) */
+    estimatedWaitMs?: number;
+    /** Whether already in queue (entry updated) */
+    alreadyQueued: boolean;
+}
+/**
+ * Queue status result
+ */
+export interface QueueStatusResult {
+    /** Total entries in queue */
+    totalEntries: number;
+    /** Your position (if in queue, 1-based) */
+    yourPosition?: number;
+    /** Your entry (if in queue) */
+    yourEntry?: QueueEntry;
+    /** Current lock holder */
+    currentHolder?: {
+        agentId: string;
+        agentType?: AgentType;
+        acquiredAt: string;
+        expiresAt: string;
+    };
+}
+/**
+ * Coordination event types
+ */
+export type CoordinationEventType = 'agent:registered' | 'agent:heartbeat' | 'agent:terminated' | 'agent:stale' | 'lock:acquired' | 'lock:released' | 'lock:expired' | 'lock:denied' | 'queue:joined' | 'queue:advanced' | 'queue:timeout' | 'queue:removed';
+/**
+ * Coordination event
+ */
+export interface CoordinationEvent {
+    /** Event type */
+    type: CoordinationEventType;
+    /** Timestamp */
+    timestamp: string;
+    /** Agent involved */
+    agentId: string;
+    /** Resource involved (if applicable) */
+    resource?: string;
+    /** Additional details */
+    details?: Record<string, unknown>;
+}
+/**
+ * Concurrency configuration schema
+ */
+export declare const ConcurrencyConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    lockTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    heartbeatIntervalMs: z.ZodDefault<z.ZodNumber>;
+    staleThresholdMs: z.ZodDefault<z.ZodNumber>;
+    queueTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    maxQueueSize: z.ZodDefault<z.ZodNumber>;
+    autoAcquireFromStale: z.ZodDefault<z.ZodBoolean>;
+    lockDir: z.ZodDefault<z.ZodString>;
+    queueDir: z.ZodDefault<z.ZodString>;
+    registryPath: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type ConcurrencyConfig = z.infer<typeof ConcurrencyConfigSchema>;
+/**
+ * Get default concurrency config
+ */
+export declare function getDefaultConcurrencyConfig(): ConcurrencyConfig;
+//# sourceMappingURL=types.d.ts.map

package/dist/concurrency/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/concurrency/types.ts"],"names":[],"mappings":"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"}

package/dist/concurrency/types.js

@@ -0,0 +1,204 @@
+/**
+ * Multi-Agent Concurrency Types
+ *
+ * Type definitions for agent registration, locking, and queuing systems
+ * to handle concurrent AI agent operations across multiple processes.
+ */
+import { z } from 'zod';
+// ============================================================================
+// Agent Identification
+// ============================================================================
+/**
+ * Agent type enumeration
+ */
+export const AgentTypeSchema = z.enum([
+    'claude', // Claude Code / Anthropic Claude
+    'cursor', // Cursor AI
+    'copilot', // GitHub Copilot
+    'aider', // Aider
+    'continue', // Continue.dev
+    'codeium', // Codeium
+    'human', // Human developer
+    'ci', // CI/CD system
+    'unknown', // Unknown/unidentified
+]);
+/**
+ * Agent information schema
+ */
+export const AgentInfoSchema = z.object({
+    /** Unique agent ID (UUID or custom identifier) */
+    id: z.string().min(1),
+    /** Type of agent */
+    type: AgentTypeSchema.default('unknown'),
+    /** Process ID (if available) */
+    pid: z.number().optional(),
+    /** Human-readable name/label */
+    name: z.string().optional(),
+    /** Session ID (for tracking related operations) */
+    sessionId: z.string().optional(),
+    /** Parent agent ID (for hierarchical agent setups) */
+    parentAgentId: z.string().optional(),
+    /** Custom metadata */
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+/**
+ * Registered agent record in the registry
+ */
+export const AgentRegistrationSchema = z.object({
+    /** Agent info */
+    agent: AgentInfoSchema,
+    /** ISO timestamp when registered */
+    registeredAt: z.string(),
+    /** ISO timestamp of last heartbeat */
+    lastHeartbeat: z.string(),
+    /** Number of heartbeats received */
+    heartbeatCount: z.number().default(0),
+    /** Current state */
+    state: z.enum(['active', 'idle', 'stale', 'terminated']).default('active'),
+    /** Current operation (if any) */
+    currentOperation: z.string().optional(),
+    /** Workspace being operated on */
+    workspaceRoot: z.string().optional(),
+});
+/**
+ * Agent registry file schema (.anvil/agents/registry.json)
+ */
+export const AgentRegistrySchema = z.object({
+    /** Schema version */
+    version: z.string().default('1.0.0'),
+    /** Last updated timestamp */
+    updatedAt: z.string(),
+    /** Registered agents by ID */
+    agents: z.record(z.string(), AgentRegistrationSchema),
+});
+// ============================================================================
+// Lock Management
+// ============================================================================
+/**
+ * Lock type enumeration
+ */
+export const LockTypeSchema = z.enum([
+    'watch', // Watch mode lock (only one watcher per workspace)
+    'action', // Action execution lock (gate, validate, check)
+    'cache', // Cache write lock
+    'state', // State file lock
+    'task', // Task execution lock (specific task)
+]);
+/**
+ * Lock record schema
+ */
+export const LockRecordSchema = z.object({
+    /** Lock type */
+    type: LockTypeSchema,
+    /** Resource being locked (e.g., file path, task ID) */
+    resource: z.string(),
+    /** Agent holding the lock */
+    agentId: z.string(),
+    /** Agent type (for display) */
+    agentType: AgentTypeSchema.optional(),
+    /** Process ID holding the lock */
+    pid: z.number().optional(),
+    /** ISO timestamp when lock was acquired */
+    acquiredAt: z.string(),
+    /** ISO timestamp when lock expires (for auto-release) */
+    expiresAt: z.string(),
+    /** Lock reason/description */
+    reason: z.string().optional(),
+    /** Number of times lock was renewed */
+    renewCount: z.number().default(0),
+});
+/**
+ * Lock file schema (.anvil/locks/{type}-{resource-hash}.lock)
+ */
+export const LockFileSchema = z.object({
+    /** Schema version */
+    version: z.string().default('1.0.0'),
+    /** Lock record */
+    lock: LockRecordSchema,
+    /** Lock acquisition history (for debugging) */
+    history: z
+        .array(z.object({
+        agentId: z.string(),
+        acquiredAt: z.string(),
+        releasedAt: z.string().optional(),
+        reason: z.string().optional(),
+    }))
+        .default([]),
+});
+// ============================================================================
+// Queue Management
+// ============================================================================
+/**
+ * Queue entry schema
+ */
+export const QueueEntrySchema = z.object({
+    /** Unique entry ID */
+    id: z.string(),
+    /** Agent requesting the resource */
+    agentId: z.string(),
+    /** Agent type */
+    agentType: AgentTypeSchema.optional(),
+    /** Lock type being requested */
+    lockType: LockTypeSchema,
+    /** Resource being requested */
+    resource: z.string(),
+    /** ISO timestamp when queued */
+    queuedAt: z.string(),
+    /** Priority (lower = higher priority, default: 100) */
+    priority: z.number().default(100),
+    /** Timeout for queue entry (auto-remove after this) */
+    timeoutAt: z.string(),
+    /** Reason for request */
+    reason: z.string().optional(),
+    /** Callback URL/path for notification (optional) */
+    callbackPath: z.string().optional(),
+});
+/**
+ * Queue file schema (.anvil/queue/{resource-hash}.json)
+ */
+export const QueueFileSchema = z.object({
+    /** Schema version */
+    version: z.string().default('1.0.0'),
+    /** Resource identifier */
+    resource: z.string(),
+    /** Lock type */
+    lockType: LockTypeSchema,
+    /** Last updated timestamp */
+    updatedAt: z.string(),
+    /** Queued entries (ordered by priority then queuedAt) */
+    entries: z.array(QueueEntrySchema),
+});
+// ============================================================================
+// Configuration
+// ============================================================================
+/**
+ * Concurrency configuration schema
+ */
+export const ConcurrencyConfigSchema = z.object({
+    /** Enable multi-agent mode */
+    enabled: z.boolean().default(true),
+    /** Lock timeout in ms (default: 5 minutes) */
+    lockTimeoutMs: z.number().min(1000).max(3600000).default(300000),
+    /** Heartbeat interval in ms (default: 10 seconds) */
+    heartbeatIntervalMs: z.number().min(1000).max(60000).default(10000),
+    /** Stale agent threshold in ms (3x heartbeat) */
+    staleThresholdMs: z.number().min(3000).max(180000).default(30000),
+    /** Queue timeout in ms (default: 10 minutes) */
+    queueTimeoutMs: z.number().min(5000).max(3600000).default(600000),
+    /** Maximum queue size per resource */
+    maxQueueSize: z.number().min(1).max(100).default(20),
+    /** Whether to auto-acquire lock from stale agents */
+    autoAcquireFromStale: z.boolean().default(true),
+    /** Lock directory path (relative to workspace) */
+    lockDir: z.string().default('.anvil/locks'),
+    /** Queue directory path (relative to workspace) */
+    queueDir: z.string().default('.anvil/queue'),
+    /** Agent registry path (relative to workspace) */
+    registryPath: z.string().default('.anvil/agents/registry.json'),
+});
+/**
+ * Get default concurrency config
+ */
+export function getDefaultConcurrencyConfig() {
+    return ConcurrencyConfigSchema.parse({});
+}