agentic-orchestrator 0.1.0

package/apps/control-plane/test/merge-service.spec.ts

@@ -0,0 +1,357 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const rmMock = vi.hoisted(() => vi.fn(async () => undefined));
+
+vi.mock('node:fs/promises', () => ({
+  default: {
+    rm: rmMock
+  }
+}));
+
+vi.mock('../src/core/git.js', () => ({
+  runGit: vi.fn()
+}));
+
+import { MergeService } from '../src/application/services/merge-service.js';
+import { GATE_RESULT, STATUS } from '../src/core/constants.js';
+import { ERROR_CODES } from '../src/core/error-codes.js';
+import { runGit } from '../src/core/git.js';
+
+type AnyRecord = Record<string, any>;
+
+function commandResult(overrides: Partial<Awaited<ReturnType<typeof runGit>>> = {}) {
+  return {
+    code: 0,
+    signal: null,
+    stdout: '',
+    stderr: '',
+    timeout: false,
+    ...overrides
+  };
+}
+
+function clone<T>(value: T): T {
+  return JSON.parse(JSON.stringify(value)) as T;
+}
+
+function makeHarness(options: {
+  stateOverrides?: AnyRecord;
+  policyOverrides?: AnyRecord;
+} = {}) {
+  const state = {
+    frontMatter: {
+      feature_id: 'feature_merge',
+      version: 3,
+      status: STATUS.READY_TO_MERGE,
+      gates: {
+        fast: GATE_RESULT.PASS,
+        full: GATE_RESULT.PASS
+      },
+      locks: {
+        held: ['openapi', 'db_migrations']
+      },
+      evidence: {},
+      ...(options.stateOverrides ?? {})
+    },
+    body: '# State\n'
+  };
+
+  const policy = {
+    merge_policy: {
+      allowed_strategies: ['merge_commit', 'squash', 'rebase'],
+      require_user_approval: false
+    },
+    required_modes: ['fast'],
+    required_merge_mode: 'full',
+    worktree: {
+      base_branch: 'main'
+    },
+    ...(options.policyOverrides ?? {})
+  };
+
+  let index: AnyRecord = {
+    version: 5,
+    active: ['feature_merge'],
+    blocked: ['feature_merge'],
+    merged: [],
+    blocked_queue: [{ feature_id: 'feature_merge' }, { feature_id: 'other' }],
+    runtime_sessions: {
+      feature_sessions: {
+        feature_merge: {
+          planner_session_id: 'planner-a',
+          builder_session_id: 'builder-a',
+          qa_session_id: 'qa-a'
+        },
+        other: {
+          planner_session_id: 'planner-b',
+          builder_session_id: 'builder-b',
+          qa_session_id: 'qa-b'
+        }
+      }
+    }
+  };
+
+  const locksRelease = vi.fn(async () => ({ data: { released: true } }));
+
+  const service = new MergeService({
+    getRepoRoot: () => '/repo',
+    getPolicySnapshot: () => clone(policy),
+    featurePath: (featureId: string) => `/repo/.aop/features/${featureId}`,
+    readState: async () => clone(state),
+    worktreePath: (featureId: string) => `/repo/.worktrees/${featureId}`,
+    updateState: async (_featureId: string, expectedVersion: number | null, updater: any) => {
+      if (expectedVersion != null && expectedVersion !== state.frontMatter.version) {
+        throw new Error('unexpected_version_conflict');
+      }
+      const next = await updater(clone(state.frontMatter), state.body);
+      state.frontMatter = {
+        ...state.frontMatter,
+        ...(next.frontMatter ?? {}),
+        version: state.frontMatter.version + 1
+      };
+      state.body = next.body ?? state.body;
+      return clone(state.frontMatter);
+    },
+    locksRelease,
+    withIndexLock: async <T>(operation: () => Promise<T>) => await operation(),
+    readIndex: async () => clone(index),
+    writeIndex: async (nextIndex: AnyRecord) => {
+      index = clone(nextIndex);
+    }
+  });
+
+  return {
+    service,
+    state,
+    locksRelease,
+    getIndex: () => clone(index)
+  };
+}
+
+describe('MergeService', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    rmMock.mockClear();
+  });
+
+  it('GIVEN_strategy_not_allowed_WHEN_feature_ready_to_merge_THEN_returns_merge_disabled_error', async () => {
+    const harness = makeHarness({
+      policyOverrides: {
+        merge_policy: {
+          allowed_strategies: ['merge_commit'],
+          require_user_approval: false
+        }
+      }
+    });
+
+    await expect(
+      harness.service.featureReadyToMerge('feature_merge', 'merge', 'squash', null)
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.MERGE_DISABLED
+        }
+      }
+    });
+    expect(runGit).not.toHaveBeenCalled();
+  });
+
+  it('GIVEN_user_approval_required_without_token_WHEN_feature_ready_to_merge_THEN_returns_user_approval_required_error', async () => {
+    const harness = makeHarness({
+      policyOverrides: {
+        merge_policy: {
+          allowed_strategies: ['merge_commit', 'squash', 'rebase'],
+          require_user_approval: true
+        }
+      }
+    });
+
+    await expect(
+      harness.service.featureReadyToMerge('feature_merge', 'merge', 'merge_commit', null)
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.USER_APPROVAL_REQUIRED
+        }
+      }
+    });
+    expect(runGit).not.toHaveBeenCalled();
+  });
+
+  it('GIVEN_feature_not_ready_or_required_gates_missing_WHEN_feature_ready_to_merge_THEN_returns_precondition_errors', async () => {
+    const invalidStatus = makeHarness({
+      stateOverrides: {
+        status: STATUS.BUILDING
+      }
+    });
+    await expect(
+      invalidStatus.service.featureReadyToMerge('feature_merge', 'merge', 'merge_commit', 'approved')
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.INVALID_STATUS_TRANSITION
+        }
+      }
+    });
+
+    const missingGate = makeHarness({
+      stateOverrides: {
+        gates: {
+          fast: GATE_RESULT.PASS,
+          full: GATE_RESULT.FAIL
+        }
+      }
+    });
+    await expect(
+      missingGate.service.featureReadyToMerge('feature_merge', 'merge', 'merge_commit', 'approved')
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.MERGE_DISABLED,
+          details: {
+            mode: 'full'
+          }
+        }
+      }
+    });
+  });
+
+  it('GIVEN_git_add_or_commit_failures_WHEN_feature_ready_to_merge_THEN_returns_git_failure_error', async () => {
+    const addFailure = makeHarness();
+    vi.mocked(runGit).mockResolvedValueOnce(commandResult({ code: 1, stderr: 'add failed' }));
+
+    await expect(
+      addFailure.service.featureReadyToMerge('feature_merge', 'merge', 'merge_commit', 'approved')
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.GIT_FAILURE
+        }
+      }
+    });
+
+    const commitFailure = makeHarness();
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult())
+      .mockResolvedValueOnce(commandResult({ code: 1, stderr: 'commit failed' }));
+
+    await expect(
+      commitFailure.service.featureReadyToMerge('feature_merge', 'merge', 'merge_commit', 'approved')
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.GIT_FAILURE
+        }
+      }
+    });
+  });
+
+  it('GIVEN_checkout_or_rebase_failures_WHEN_feature_ready_to_merge_THEN_returns_human_required_git_failure', async () => {
+    const checkoutFailure = makeHarness();
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult())
+      .mockResolvedValueOnce(commandResult({ code: 1, stderr: 'nothing to commit' }))
+      .mockResolvedValueOnce(commandResult({ code: 1, stderr: 'checkout failed' }));
+
+    await expect(
+      checkoutFailure.service.featureReadyToMerge('feature_merge', 'merge', 'merge_commit', 'approved')
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.GIT_FAILURE,
+          details: {
+            requires_human: true
+          }
+        }
+      }
+    });
+
+    const rebaseFailure = makeHarness();
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult())
+      .mockResolvedValueOnce(commandResult())
+      .mockResolvedValueOnce(commandResult())
+      .mockResolvedValueOnce(commandResult({ code: 1, stderr: 'rebase failed' }));
+
+    await expect(
+      rebaseFailure.service.featureReadyToMerge('feature_merge', 'merge', 'rebase', 'approved')
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.GIT_FAILURE,
+          details: {
+            requires_human: true
+          }
+        }
+      }
+    });
+  });
+
+  it('GIVEN_squash_merge_commit_fails_WHEN_feature_ready_to_merge_THEN_returns_merge_failed_error', async () => {
+    const harness = makeHarness();
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult())
+      .mockResolvedValueOnce(commandResult({ code: 1, stderr: 'nothing to commit' }))
+      .mockResolvedValueOnce(commandResult())
+      .mockResolvedValueOnce(commandResult())
+      .mockResolvedValueOnce(commandResult({ code: 1, stderr: 'squash commit failed' }));
+
+    await expect(
+      harness.service.featureReadyToMerge('feature_merge', 'merge', 'squash', 'approved')
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.GIT_FAILURE,
+          details: {
+            requires_human: true
+          }
+        }
+      }
+    });
+  });
+
+  it('GIVEN_rebase_strategy_succeeds_WHEN_feature_ready_to_merge_THEN_updates_state_releases_locks_and_updates_index', async () => {
+    const harness = makeHarness({
+      stateOverrides: {
+        locks: {
+          held: ['openapi', 42]
+        }
+      }
+    });
+
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult())
+      .mockResolvedValueOnce(commandResult())
+      .mockResolvedValueOnce(commandResult())
+      .mockResolvedValueOnce(commandResult())
+      .mockResolvedValueOnce(commandResult())
+      .mockResolvedValueOnce(commandResult({ stdout: 'abc123\n' }));
+
+    const result = await harness.service.featureReadyToMerge('feature_merge', 'merge', 'rebase', 'approved');
+
+    expect(result.data).toMatchObject({
+      feature_id: 'feature_merge',
+      merge_sha: 'abc123',
+      merge_strategy: 'rebase',
+      status: STATUS.MERGED
+    });
+    expect(harness.state.frontMatter.status).toBe(STATUS.MERGED);
+    expect((harness.state.frontMatter.evidence as AnyRecord).merge_strategy).toBe('rebase');
+    expect(harness.locksRelease).toHaveBeenCalledTimes(1);
+    expect(harness.locksRelease).toHaveBeenCalledWith('openapi', 'feature_merge');
+
+    const index = harness.getIndex();
+    expect(index.active).toEqual([]);
+    expect(index.blocked).toEqual([]);
+    expect(index.merged).toEqual(['feature_merge']);
+    expect(index.blocked_queue).toEqual([{ feature_id: 'other' }]);
+    expect(index.runtime_sessions.feature_sessions).not.toHaveProperty('feature_merge');
+    expect(index.runtime_sessions.feature_sessions.other).toMatchObject({
+      planner_session_id: 'planner-b'
+    });
+    expect(rmMock).toHaveBeenCalledWith('/repo/.aop/features/feature_merge', {
+      recursive: true,
+      force: true
+    });
+  });
+});

package/apps/control-plane/test/plan-service.spec.ts

@@ -0,0 +1,195 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { ERROR_CODES } from '../src/core/error-codes.js';
+import type * as FsModule from '../src/core/fs.js';
+
+vi.mock('../src/core/fs.js', async () => {
+  const actual = await vi.importActual<typeof FsModule>('../src/core/fs.js');
+  return {
+    ...actual,
+    nowIso: () => '2026-01-01T00:00:00.000Z'
+  };
+});
+
+import { PlanService } from '../src/application/services/plan-service.js';
+
+type AnyRecord = Record<string, any>;
+
+function makePlan(featureId: string, overrides: AnyRecord = {}): AnyRecord {
+  return {
+    feature_id: featureId,
+    plan_version: 1,
+    summary: `${featureId} summary`,
+    allowed_areas: ['apps/control-plane/src'],
+    forbidden_areas: [],
+    base_ref: 'main',
+    files: {
+      create: [],
+      modify: ['apps/control-plane/src/shared.ts'],
+      delete: []
+    },
+    contracts: {
+      openapi: 'none',
+      events: 'none',
+      db: 'none'
+    },
+    acceptance_criteria: ['works'],
+    gate_profile: 'default',
+    revision_of: null,
+    ...overrides
+  };
+}
+
+async function writePlan(repoRoot: string, featureId: string, plan: AnyRecord): Promise<void> {
+  const featureDir = path.join(repoRoot, featureId);
+  await fs.mkdir(featureDir, { recursive: true });
+  await fs.writeFile(path.join(featureDir, 'plan.json'), JSON.stringify(plan, null, 2), 'utf8');
+}
+
+async function createHarness(options: {
+  collisionPolicy?: 'block' | 'reject';
+  specs?: string[];
+  stateLocks?: string[];
+}) {
+  const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-plan-service-'));
+  const specs = options.specs ?? ['feature_a', 'feature_ref'];
+  const stateLocks = options.stateLocks ?? ['openapi', 'events', 'db_migrations'];
+  const writes: AnyRecord[] = [];
+  const stateUpdates: AnyRecord[] = [];
+  let index: AnyRecord = {
+    version: 1,
+    active: [],
+    blocked: [],
+    merged: [],
+    locks: {},
+    lock_leases: {},
+    blocked_queue: [],
+    runtime_sessions: {}
+  };
+
+  const service = new PlanService({
+    getPolicySnapshot: () => ({
+      collision_policy: options.collisionPolicy ?? 'block',
+      locks: {
+        contract_to_resource: {
+          openapi: 'openapi',
+          events: 'events',
+          db: 'db_migrations'
+        }
+      }
+    }),
+    planPath: (featureId: string) => path.join(repoRoot, featureId, 'plan.json'),
+    featureDiscoverSpecs: async () => ({ data: { specs: specs.map((feature_id) => ({ feature_id })) } }),
+    readState: async () => ({
+      frontMatter: {
+        status: 'planning',
+        locks: {
+          held: stateLocks
+        },
+        gates: {}
+      }
+    }),
+    validateSchema: async () => ({ valid: true }),
+    withFeatureLock: async <T>(_featureId: string, operation: () => Promise<T>) => await operation(),
+    withIndexLock: async <T>(operation: () => Promise<T>) => await operation(),
+    readIndex: async () => JSON.parse(JSON.stringify(index)),
+    writeIndex: async (nextIndex: AnyRecord) => {
+      index = JSON.parse(JSON.stringify(nextIndex));
+      writes.push(JSON.parse(JSON.stringify(nextIndex)));
+    },
+    updateState: async (_featureId: string, _expectedVersion: number | null, updater: any) => {
+      const existing = { status: 'planning', gates: {} };
+      const updated = await updater(existing, '');
+      stateUpdates.push(updated);
+      return updated.frontMatter ?? existing;
+    }
+  });
+
+  return {
+    repoRoot,
+    service,
+    writes,
+    stateUpdates,
+    getIndex: () => JSON.parse(JSON.stringify(index)),
+    cleanup: async () => await fs.rm(repoRoot, { recursive: true, force: true })
+  };
+}
+
+describe('PlanService', () => {
+  const cleanups: Array<() => Promise<void>> = [];
+
+  afterEach(async () => {
+    await Promise.all(cleanups.map((cleanup) => cleanup()));
+    cleanups.length = 0;
+  });
+
+  it('GIVEN_blocking_collisions_WHEN_queueing_multiple_features_THEN_sorts_queue_deterministically_and_captures_required_resources', async () => {
+    const harness = await createHarness({ specs: ['feature_a', 'feature_z', 'feature_ref'] });
+    cleanups.push(harness.cleanup);
+
+    await writePlan(harness.repoRoot, 'feature_ref', makePlan('feature_ref'));
+
+    const featureZPlan = makePlan('feature_z', {
+      contracts: { openapi: 'modify', events: 'modify', db: 'migration' }
+    });
+    const featureAPlan = makePlan('feature_a', {
+      contracts: { openapi: 'modify', events: 'none', db: 'migration' }
+    });
+
+    await expect(harness.service.planSubmit('feature_z', featureZPlan, null)).rejects.toMatchObject({
+      normalizedResponse: {
+        ok: false,
+        error: {
+          code: ERROR_CODES.BLOCKED_BY_COLLISION_POLICY
+        }
+      }
+    });
+    await expect(harness.service.planSubmit('feature_a', featureAPlan, null)).rejects.toMatchObject({
+      normalizedResponse: {
+        ok: false,
+        error: {
+          code: ERROR_CODES.BLOCKED_BY_COLLISION_POLICY
+        }
+      }
+    });
+
+    const queue = harness.getIndex().blocked_queue;
+    expect(queue.map((entry: AnyRecord) => entry.feature_id)).toEqual(['feature_a', 'feature_z']);
+    expect(queue[0]?.required_resources).toEqual(['db_migrations', 'openapi']);
+    expect(queue[1]?.required_resources).toEqual(['db_migrations', 'events', 'openapi']);
+    expect(harness.writes).toHaveLength(2);
+  });
+
+  it('GIVEN_blocked_collision_then_conflict_resolved_WHEN_resubmitting_same_plan_THEN_accepts_retry', async () => {
+    const harness = await createHarness({ specs: ['feature_a', 'feature_ref'] });
+    cleanups.push(harness.cleanup);
+
+    const referencePlan = makePlan('feature_ref');
+    const candidatePlan = makePlan('feature_a');
+    await writePlan(harness.repoRoot, 'feature_ref', referencePlan);
+
+    await expect(harness.service.planSubmit('feature_a', candidatePlan, null)).rejects.toMatchObject({
+      normalizedResponse: {
+        ok: false,
+        error: { code: ERROR_CODES.BLOCKED_BY_COLLISION_POLICY }
+      }
+    });
+
+    await fs.rm(path.join(harness.repoRoot, 'feature_ref', 'plan.json'));
+
+    const accepted = await harness.service.planSubmit('feature_a', candidatePlan, null);
+    expect(accepted).toMatchObject({
+      data: {
+        feature_id: 'feature_a',
+        accepted: true,
+        plan_version: 1
+      }
+    });
+
+    const savedPlan = JSON.parse(await fs.readFile(path.join(harness.repoRoot, 'feature_a', 'plan.json'), 'utf8'));
+    expect(savedPlan.feature_id).toBe('feature_a');
+    expect(harness.stateUpdates.length).toBe(1);
+  });
+});