macro-agent 0.2.4 → 0.2.6

package/test_fixtures/harness/timing/event-stepper.ts

@@ -1,344 +0,0 @@
-/**
- * EventStepper - Deterministic stepping for multi-simulator coordination
- *
- * Provides controlled execution of multiple simulators for testing.
- *
- * @see s-1zcx Multi-Agent Orchestration Testing Strategy
- * @see i-3bdo Phase 2: Behavior Execution Engine
- */
-
-import type { AgentSimulator, StepResult } from "../simulator/types.js";
-
-/**
- * Result of stepping all simulators
- */
-export interface StepAllResult {
-  /** Results from each simulator that executed a step */
-  results: Map<string, StepResult>;
-
-  /** Number of simulators that executed a step */
-  steppedCount: number;
-
-  /** Number of simulators still waiting */
-  waitingCount: number;
-
-  /** Number of simulators that are done */
-  doneCount: number;
-
-  /** Whether all simulators are idle (waiting or done) */
-  allIdle: boolean;
-}
-
-/**
- * Condition function for waitForCondition
- */
-export type ConditionFn = (
-  simulators: Map<string, AgentSimulator>
-) => boolean | Promise<boolean>;
-
-/**
- * EventStepper manages deterministic execution of multiple simulators
- */
-export class EventStepper {
-  private simulators: Map<string, AgentSimulator> = new Map();
-  private stepCount = 0;
-  private maxSteps = 10000; // Safety limit
-
-  /**
-   * Register a simulator for stepping
-   */
-  register(simulator: AgentSimulator): void {
-    this.simulators.set(simulator.agentId, simulator);
-  }
-
-  /**
-   * Unregister a simulator
-   */
-  unregister(agentId: string): void {
-    this.simulators.delete(agentId);
-  }
-
-  /**
-   * Get a registered simulator
-   */
-  get(agentId: string): AgentSimulator | undefined {
-    return this.simulators.get(agentId);
-  }
-
-  /**
-   * Get all registered simulators
-   */
-  getAll(): AgentSimulator[] {
-    return Array.from(this.simulators.values());
-  }
-
-  /**
-   * Get count of registered simulators
-   */
-  get count(): number {
-    return this.simulators.size;
-  }
-
-  /**
-   * Get total step count
-   */
-  get totalSteps(): number {
-    return this.stepCount;
-  }
-
-  /**
-   * Set maximum steps before timeout
-   */
-  setMaxSteps(max: number): void {
-    this.maxSteps = max;
-  }
-
-  /**
-   * Step a specific simulator once
-   */
-  async stepOne(agentId: string): Promise<StepResult | undefined> {
-    const simulator = this.simulators.get(agentId);
-    if (!simulator || !simulator.isRunning()) {
-      return undefined;
-    }
-
-    this.stepCount++;
-    return simulator.stepOnce();
-  }
-
-  /**
-   * Step all simulators that have pending work
-   *
-   * Each simulator executes at most one step.
-   * Also steps child simulators spawned via spawn_child behavior.
-   */
-  async stepAll(): Promise<StepAllResult> {
-    const results = new Map<string, StepResult>();
-    let waitingCount = 0;
-    let doneCount = 0;
-
-    // Collect all simulators including children (recursively)
-    const allSimulators = this.collectAllSimulators();
-
-    for (const [agentId, simulator] of allSimulators) {
-      if (!simulator.isRunning()) {
-        doneCount++;
-        continue;
-      }
-
-      if (simulator.hasPendingSteps()) {
-        this.stepCount++;
-        const result = await simulator.stepOnce();
-        results.set(agentId, result);
-
-        if (result.status === "done") {
-          doneCount++;
-        }
-      } else {
-        waitingCount++;
-      }
-    }
-
-    return {
-      results,
-      steppedCount: results.size,
-      waitingCount,
-      doneCount,
-      allIdle: results.size === 0,
-    };
-  }
-
-  /**
-   * Collect all simulators including children spawned via spawn_child
-   */
-  private collectAllSimulators(): Map<string, AgentSimulator> {
-    const all = new Map<string, AgentSimulator>();
-
-    const collectRecursive = (simulator: AgentSimulator) => {
-      if (all.has(simulator.agentId)) return;
-      all.set(simulator.agentId, simulator);
-
-      // Collect children if the simulator has started
-      try {
-        const context = simulator.getContext();
-        for (const child of context.children) {
-          collectRecursive(child);
-        }
-      } catch {
-        // Simulator not started yet, no children to collect
-      }
-    };
-
-    for (const simulator of this.simulators.values()) {
-      collectRecursive(simulator);
-    }
-
-    return all;
-  }
-
-  /**
-   * Run until all simulators are idle (waiting or done)
-   *
-   * @param maxIterations Maximum number of stepAll() calls
-   * @returns Final step result
-   */
-  async runUntilIdle(maxIterations = 1000): Promise<StepAllResult> {
-    let iterations = 0;
-    let result: StepAllResult;
-
-    do {
-      result = await this.stepAll();
-      iterations++;
-
-      if (iterations >= maxIterations) {
-        throw new Error(
-          `runUntilIdle exceeded ${maxIterations} iterations - possible infinite loop`
-        );
-      }
-
-      if (this.stepCount >= this.maxSteps) {
-        throw new Error(
-          `runUntilIdle exceeded ${this.maxSteps} total steps - safety limit`
-        );
-      }
-    } while (!result.allIdle);
-
-    return result;
-  }
-
-  /**
-   * Run until a condition is met
-   *
-   * @param condition Function that returns true when condition is met
-   * @param options Configuration options
-   */
-  async waitForCondition(
-    condition: ConditionFn,
-    options: {
-      /** Maximum time to wait in milliseconds */
-      timeoutMs?: number;
-      /** Maximum step iterations */
-      maxIterations?: number;
-      /** Polling interval in milliseconds */
-      pollIntervalMs?: number;
-    } = {}
-  ): Promise<void> {
-    const {
-      timeoutMs = 30000,
-      maxIterations = 10000,
-      pollIntervalMs = 0,
-    } = options;
-
-    const startTime = Date.now();
-    let iterations = 0;
-
-    while (true) {
-      // Check condition
-      const met = await condition(this.simulators);
-      if (met) {
-        return;
-      }
-
-      // Check timeout
-      if (Date.now() - startTime >= timeoutMs) {
-        throw new Error(
-          `waitForCondition timed out after ${timeoutMs}ms`
-        );
-      }
-
-      // Check iterations
-      if (iterations >= maxIterations) {
-        throw new Error(
-          `waitForCondition exceeded ${maxIterations} iterations`
-        );
-      }
-
-      // Step simulators
-      await this.stepAll();
-      iterations++;
-
-      // Optional delay
-      if (pollIntervalMs > 0) {
-        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
-      }
-    }
-  }
-
-  /**
-   * Wait for a specific simulator to complete (searches in all simulators including children)
-   */
-  async waitForSimulator(
-    agentId: string,
-    options?: { timeoutMs?: number; maxIterations?: number }
-  ): Promise<void> {
-    await this.waitForCondition(
-      () => {
-        const all = this.collectAllSimulators();
-        const simulator = all.get(agentId);
-        return !simulator || !simulator.isRunning();
-      },
-      options
-    );
-  }
-
-  /**
-   * Wait for all simulators to complete (including children)
-   */
-  async waitForAll(
-    options?: { timeoutMs?: number; maxIterations?: number }
-  ): Promise<void> {
-    await this.waitForCondition(
-      () => {
-        const all = this.collectAllSimulators();
-        for (const simulator of all.values()) {
-          if (simulator.isRunning()) {
-            return false;
-          }
-        }
-        return true;
-      },
-      options
-    );
-  }
-
-  /**
-   * Check if any simulator is running (including children)
-   */
-  hasRunningSimulators(): boolean {
-    const all = this.collectAllSimulators();
-    for (const simulator of all.values()) {
-      if (simulator.isRunning()) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /**
-   * Check if any simulator has pending work (including children)
-   */
-  hasPendingWork(): boolean {
-    const all = this.collectAllSimulators();
-    for (const simulator of all.values()) {
-      if (simulator.isRunning() && simulator.hasPendingSteps()) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /**
-   * Reset the stepper (unregisters all simulators)
-   */
-  reset(): void {
-    this.simulators.clear();
-    this.stepCount = 0;
-  }
-}
-
-/**
- * Create a new event stepper
- */
-export function createEventStepper(): EventStepper {
-  return new EventStepper();
-}

package/test_fixtures/harness/timing/index.ts

@@ -1,8 +0,0 @@
-/**
- * Timing control exports
- *
- * @see s-1zcx Multi-Agent Orchestration Testing Strategy
- * @see i-3bdo Phase 2: Behavior Execution Engine
- */
-
-export * from "./event-stepper.js";

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "lib": ["ES2022"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "resolveJsonModule": true,
-    "types": ["node", "better-sqlite3", "express", "js-yaml", "supertest", "ws"]
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts"]
-}

package/vitest.config.ts

@@ -1,30 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    watch: false,
-    globals: true,
-    environment: "node",
-    setupFiles: ["./vitest.setup.ts"],
-    include: ["src/**/*.test.ts", "test_fixtures/**/*.test.ts"],
-    exclude: [
-      "**/node_modules/**",
-      // E2E tests are run separately via vitest.e2e.config.ts
-      "**/*.e2e.test.ts",
-      "**/e2e/**",
-    ],
-    // Use forks instead of threads to avoid segfaults with better-sqlite3
-    // Native modules can cause memory access issues during thread cleanup
-    pool: "forks",
-    coverage: {
-      provider: "v8",
-      reporter: ["text", "json", "html"],
-    },
-    server: {
-      deps: {
-        // Force inline external packages to avoid Node.js type stripping issues
-        inline: [/@sudocode-ai\/.*/],
-      },
-    },
-  },
-});

package/vitest.e2e.config.ts

@@ -1,28 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    watch: false,
-    globals: true,
-    environment: "node",
-    setupFiles: ["./vitest.setup.ts"],
-    // Run all e2e tests
-    include: [
-      "src/**/*.e2e.test.ts",
-      "src/**/e2e/**/*.test.ts",
-    ],
-    // Use forks instead of threads to avoid segfaults with better-sqlite3
-    pool: "forks",
-    // Longer timeout for e2e tests that start servers or run git operations
-    testTimeout: 30000,
-    hookTimeout: 30000,
-    // Run tests sequentially to avoid server port conflicts
-    fileParallelism: false,
-    server: {
-      deps: {
-        // Force inline external packages to avoid Node.js type stripping issues
-        inline: [/@sudocode-ai\/.*/],
-      },
-    },
-  },
-});

package/vitest.setup.ts

@@ -1,12 +0,0 @@
-/**
- * Vitest Global Setup
- *
- * This file runs before all tests to set up safeguards and global configuration.
- */
-
-import { beforeAll, vi } from "vitest";
-
-beforeAll(() => {
-  // Set up the environment to make it clear we're in a test
-  process.env.NODE_ENV = "test";
-});