agentic-orchestrator 0.1.0

package/apps/control-plane/test/collision-queue.spec.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { AopKernel } from '../src/core/kernel.js';
+import { CollisionQueueService } from '../src/application/services/collision-queue-service.js';
+import { makeTempRepo } from './helpers.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+describe('Collision Queue Re-Drive Service', () => {
+  let tempDir: string;
+  let kernel: AopKernel;
+  let collisionQueueService: CollisionQueueService;
+
+  beforeEach(async () => {
+    tempDir = await makeTempRepo(process.cwd());
+    
+    // Update policy.yaml to use block collision policy for these tests
+    const policyPath = path.join(tempDir, 'agentic', 'orchestrator', 'policy.yaml');
+    const policyContent = await fs.readFile(policyPath, 'utf8');
+    const updatedPolicy = policyContent.replace(/collision_policy:\s*reject/, 'collision_policy: block');
+    await fs.writeFile(policyPath, updatedPolicy, 'utf8');
+    
+    kernel = new AopKernel(tempDir);
+    await kernel.ensureLoaded();
+    collisionQueueService = new CollisionQueueService(kernel);
+  });
+
+  it('should return zero when collision_policy is not block', async () => {
+    kernel.policy.collision_policy = 'reject';
+    
+    const result = await collisionQueueService.reDriveBlockedQueue();
+    
+    expect(result.data.processed).toBe(0);
+    expect(result.data.retried).toBe(0);
+    expect(result.data.still_blocked).toBe(0);
+  });
+
+  it('should return zero when blocked_queue is empty', async () => {
+    const result = await collisionQueueService.reDriveBlockedQueue();
+    
+    expect(result.data.processed).toBe(0);
+    expect(result.data.retried).toBe(0);
+    expect(result.data.still_blocked).toBe(0);
+  });
+
+  it('should process queue entries in deterministic order', async () => {
+    await kernel.featureInit('feature-a');
+    await kernel.featureInit('feature-b');
+
+    const index = await kernel.readIndex();
+    index.blocked_queue = [
+      {
+        feature_id: 'feature-b',
+        plan_version: 1,
+        detected_at: '2026-02-28T12:00:00Z',
+        collision_fingerprint: 'hash-b',
+        required_resources: []
+      },
+      {
+        feature_id: 'feature-a',
+        plan_version: 1,
+        detected_at: '2026-02-28T11:00:00Z',
+        collision_fingerprint: 'hash-a',
+        required_resources: []
+      }
+    ];
+    await kernel.writeIndex(index);
+
+    const result = await collisionQueueService.reDriveBlockedQueue();
+
+    expect(result.data.processed).toBe(2);
+  });
+
+  it('should keep entry in queue if plan is missing', async () => {
+    await kernel.featureInit('feature-missing');
+    
+    const index = await kernel.readIndex();
+    index.blocked_queue = [
+      {
+        feature_id: 'feature-missing',
+        plan_version: 1,
+        detected_at: '2026-02-28T12:00:00Z',
+        collision_fingerprint: 'hash-missing',
+        required_resources: []
+      }
+    ];
+    await kernel.writeIndex(index);
+
+    const result = await collisionQueueService.reDriveBlockedQueue();
+
+    expect(result.data.processed).toBe(1);
+    expect(result.data.retried).toBe(0);
+    expect(result.data.still_blocked).toBe(1);
+  });
+
+  it('should keep entry in queue if locks not held', async () => {
+    await kernel.featureInit('feature-locked');
+    
+    await fs.mkdir(path.join(tempDir, '.aop', 'features', 'feature-locked'), { recursive: true });
+    
+    const plan = {
+      feature_id: 'feature-locked',
+      plan_version: 1,
+      summary: 'Test plan requiring lock',
+      files: { create: [], modify: [], delete: [] },
+      contracts: { openapi: 'modify', events: 'none', db: 'none' }
+    };
+
+    await fs.writeFile(
+      path.join(tempDir, '.aop', 'features', 'feature-locked', 'plan.json'),
+      JSON.stringify(plan, null, 2)
+    );
+
+    const index = await kernel.readIndex();
+    index.blocked_queue = [
+      {
+        feature_id: 'feature-locked',
+        plan_version: 1,
+        detected_at: '2026-02-28T12:00:00Z',
+        collision_fingerprint: 'hash-locked',
+        required_resources: ['openapi']
+      }
+    ];
+    await kernel.writeIndex(index);
+
+    const result = await collisionQueueService.reDriveBlockedQueue();
+
+    expect(result.data.processed).toBe(1);
+    expect(result.data.retried).toBe(0);
+    expect(result.data.still_blocked).toBe(1);
+  });
+
+  it('should remove cleared entry from queue', async () => {
+    await kernel.featureInit('feature-clear');
+    
+    const index = await kernel.readIndex();
+    index.blocked_queue = [
+      {
+        feature_id: 'feature-clear',
+        plan_version: 1,
+        detected_at: '2026-02-28T12:00:00Z',
+        collision_fingerprint: 'hash-clear',
+        required_resources: []
+      }
+    ];
+    await kernel.writeIndex(index);
+
+    const clearResult = await collisionQueueService.clearQueueEntry('feature-clear');
+    expect(clearResult.data.removed).toBe(true);
+
+    const updatedIndex = await kernel.readIndex();
+    expect(updatedIndex.blocked_queue).toHaveLength(0);
+  });
+
+  it('should not remove non-existent entry', async () => {
+    const clearResult = await collisionQueueService.clearQueueEntry('non-existent');
+    expect(clearResult.data.removed).toBe(false);
+  });
+});

package/apps/control-plane/test/collisions.spec.ts

@@ -0,0 +1,138 @@
+import { describe, expect, it } from 'vitest';
+import { detectPlanCollisions } from '../src/core/collisions.js';
+
+describe('detectPlanCollisions', () => {
+  it('GIVEN_disjoint_plans_WHEN_detecting_THEN_reports_no_collisions', () => {
+    const result = detectPlanCollisions(
+      {
+        feature_id: 'feature_a',
+        files: { modify: ['src/a.ts'] },
+        allowed_areas: ['src/a'],
+        contracts: { openapi: 'none', events: 'none', db: 'none' }
+      },
+      [
+        {
+          feature_id: 'feature_b',
+          files: { modify: ['src/b.ts'] },
+          allowed_areas: ['src/b'],
+          contracts: { openapi: 'none', events: 'none', db: 'none' }
+        }
+      ],
+      {
+        exclusive_areas: ['libs/core'],
+        protected_areas: ['agentic/orchestrator/policy.yaml']
+      }
+    );
+
+    expect(result.hasCollisions).toBe(false);
+    expect(result.collisions).toEqual({
+      files: [],
+      areas: [],
+      contracts: []
+    });
+    expect(result.fingerprint).toBeNull();
+  });
+
+  it('GIVEN_overlapping_files_WHEN_detecting_THEN_reports_file_collision_and_fingerprint', () => {
+    const result = detectPlanCollisions(
+      {
+        feature_id: 'feature_a',
+        files: { create: ['src/shared.ts'] }
+      },
+      [
+        {
+          feature_id: 'feature_b',
+          files: { modify: ['src/shared.ts'] }
+        }
+      ],
+      {}
+    );
+
+    expect(result.hasCollisions).toBe(true);
+    expect(result.collisions.files).toEqual([
+      {
+        with_feature_id: 'feature_b',
+        paths: ['src/shared.ts']
+      }
+    ]);
+    expect(typeof result.fingerprint).toBe('string');
+  });
+
+  it('GIVEN_overlapping_exclusive_or_protected_areas_WHEN_detecting_THEN_reports_area_collision', () => {
+    const result = detectPlanCollisions(
+      {
+        feature_id: 'feature_a',
+        allowed_areas: ['libs/core/module_a', 'agentic/orchestrator/schemas']
+      },
+      [
+        {
+          feature_id: 'feature_b',
+          allowed_areas: ['libs/core']
+        },
+        {
+          feature_id: 'feature_c',
+          allowed_areas: ['agentic/orchestrator']
+        }
+      ],
+      {
+        exclusive_areas: ['libs/core'],
+        protected_areas: ['agentic/orchestrator']
+      }
+    );
+
+    expect(result.hasCollisions).toBe(true);
+    expect(result.collisions.areas).toContainEqual({
+      with_feature_id: 'feature_b',
+      overlaps: [['libs/core/module_a', 'libs/core']]
+    });
+    expect(result.collisions.areas).toContainEqual({
+      with_feature_id: 'feature_c',
+      overlaps: [['agentic/orchestrator/schemas', 'agentic/orchestrator']]
+    });
+  });
+
+  it('GIVEN_shared_contract_mutations_WHEN_detecting_THEN_reports_contract_collision', () => {
+    const result = detectPlanCollisions(
+      {
+        feature_id: 'feature_a',
+        contracts: { openapi: 'modify', events: 'none', db: 'none' }
+      },
+      [
+        {
+          feature_id: 'feature_b',
+          contracts: { openapi: 'modify', events: 'none', db: 'none' }
+        }
+      ],
+      {}
+    );
+
+    expect(result.hasCollisions).toBe(true);
+    expect(result.collisions.contracts).toEqual([
+      {
+        with_feature_id: 'feature_b',
+        contract: 'openapi',
+        candidate_mode: 'modify',
+        other_mode: 'modify'
+      }
+    ]);
+  });
+
+  it('GIVEN_same_feature_in_accepted_plans_WHEN_detecting_THEN_ignores_self_collision', () => {
+    const result = detectPlanCollisions(
+      {
+        feature_id: 'feature_a',
+        files: { modify: ['src/same.ts'] }
+      },
+      [
+        {
+          feature_id: 'feature_a',
+          files: { modify: ['src/same.ts'] }
+        }
+      ],
+      {}
+    );
+
+    expect(result.hasCollisions).toBe(false);
+    expect(result.fingerprint).toBeNull();
+  });
+});

package/apps/control-plane/test/core-utils.spec.ts

@@ -0,0 +1,102 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { parseFrontMatter, buildFrontMatter } from '../src/core/frontmatter.js';
+import { anyAreaMatch, areaMatches, normalizeRepoPath, sortResourcesDeterministically } from '../src/core/path-rules.js';
+import { parseUnifiedDiff, touchedPathsFromDiff } from '../src/core/patch.js';
+
+describe('core utility branches', () => {
+  it('covers frontmatter parsing and serialization edge cases', () => {
+    expect(parseFrontMatter('plain text')).toEqual({ frontMatter: {}, body: 'plain text' });
+    expect(parseFrontMatter('---\nkey: value\nno_end_marker')).toEqual({
+      frontMatter: {},
+      body: '---\nkey: value\nno_end_marker'
+    });
+
+    const parsed = parseFrontMatter('---\nfeature_id: abc\nversion: 1\n---\n\nBody');
+    expect(parsed.frontMatter).toMatchObject({ feature_id: 'abc', version: 1 });
+    expect(parsed.body).toBe('\nBody');
+
+    const serialized = buildFrontMatter({ feature_id: 'abc', version: 2 }, '\nBody');
+    expect(serialized).toContain('feature_id: abc');
+    expect(serialized).toContain('\n---\nBody');
+  });
+
+  it('covers path normalization and matching modes', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-path-rules-'));
+    const nested = path.join(repoRoot, 'src', 'a.ts');
+    await fs.mkdir(path.dirname(nested), { recursive: true });
+    await fs.writeFile(nested, 'export const a = 1;\n', 'utf8');
+
+    await expect(normalizeRepoPath(repoRoot, nested)).resolves.toBe('src/a.ts');
+    await expect(normalizeRepoPath(repoRoot, path.join(repoRoot, '../outside.txt'))).rejects.toThrow(
+      'path_out_of_bounds'
+    );
+    await expect(normalizeRepoPath(repoRoot, nested, true)).resolves.toBe('src/a.ts');
+
+    expect(areaMatches('src/a.ts', 'src')).toBe(true);
+    expect(areaMatches('src/a.ts', 'src/*.ts', 'glob')).toBe(true);
+    expect(anyAreaMatch('src/a.ts', ['docs', 'src'])).toBe(true);
+    expect(anyAreaMatch('src/a.ts', ['docs', 'tests'])).toBe(false);
+
+    expect(sortResourcesDeterministically(['db', 'openapi', 'db'])).toEqual(['db', 'openapi']);
+  });
+
+  it('covers unified diff parsing branches for add/delete/rename and touched paths', () => {
+    const diff = [
+      'diff --git a/src/renamed.ts b/src/new-name.ts',
+      'rename from src/renamed.ts',
+      'rename to src/new-name.ts',
+      '@@ -1 +1 @@',
+      '-old',
+      '+new',
+      'diff --git a/src/deleted.ts b/src/deleted.ts',
+      'deleted file mode 100644',
+      '--- a/src/deleted.ts',
+      '+++ /dev/null',
+      '@@ -2,2 +0,0 @@',
+      '-a',
+      '-b',
+      'diff --git a/src/added.ts b/src/added.ts',
+      'new file mode 100644',
+      '--- /dev/null',
+      '+++ b/src/added.ts',
+      '@@ -0,0 +4,2 @@',
+      '+x',
+      '+y'
+    ].join('\n');
+
+    const parsed = parseUnifiedDiff(diff);
+    expect(parsed).toHaveLength(3);
+    expect(parsed[0]).toMatchObject({
+      oldPath: 'src/renamed.ts',
+      newPath: 'src/new-name.ts',
+      changeType: 'modify'
+    });
+    expect(parsed[1]).toMatchObject({
+      oldPath: 'src/deleted.ts',
+      newPath: 'src/deleted.ts',
+      changeType: 'delete'
+    });
+    expect(parsed[2]).toMatchObject({
+      oldPath: 'src/added.ts',
+      newPath: 'src/added.ts',
+      changeType: 'add'
+    });
+
+    expect(parsed[1].hunks[0]).toEqual({
+      start_line: 2,
+      end_line: 3,
+      change_type: 'delete'
+    });
+    expect(parsed[2].hunks[0]).toEqual({
+      start_line: 4,
+      end_line: 5,
+      change_type: 'add'
+    });
+
+    const touched = touchedPathsFromDiff(parsed);
+    expect(touched).toEqual(['src/renamed.ts', 'src/new-name.ts', 'src/deleted.ts', 'src/added.ts']);
+  });
+});

package/apps/control-plane/test/delete-command-handler.spec.ts

@@ -0,0 +1,202 @@
+import { describe, expect, it, vi } from 'vitest';
+import { DeleteCommandHandler } from '../src/cli/delete-command-handler.js';
+import { ERROR_CODES } from '../src/core/error-codes.js';
+import { TOOLS } from '../src/core/constants.js';
+
+type ToolClientCall = ReturnType<typeof vi.fn>;
+
+function makeHandler(callImpl: ToolClientCall = vi.fn(async () => ({ ok: true, data: { feature_id: 'feature_a' } }))) {
+  const toolClient = {
+    call: callImpl
+  };
+  const handler = new DeleteCommandHandler(toolClient as never, 'run:test');
+  return { handler, toolClient };
+}
+
+describe('DeleteCommandHandler', () => {
+  it('GIVEN_valid_defaults_WHEN_execute_called_THEN_calls_feature_delete_in_preview_mode', async () => {
+    const call = vi.fn(async () => ({ ok: true, data: { feature_id: 'feature_a', dry_run: true } }));
+    const { handler, toolClient } = makeHandler(call);
+
+    const result = await handler.execute({
+      command: 'delete',
+      feature_id: 'feature_a'
+    });
+
+    expect(toolClient.call).toHaveBeenCalledWith(
+      TOOLS.FEATURE_DELETE,
+      expect.objectContaining({
+        feature_id: 'feature_a',
+        dry_run: true,
+        confirm: false,
+        remove_worktree: true,
+        remove_branch: 'none',
+        operation_id: expect.any(String)
+      }),
+      expect.objectContaining({
+        run_id: 'run:test',
+        actor_type: 'system'
+      })
+    );
+    expect(result).toMatchObject({
+      ok: true,
+      data: {
+        command: 'delete',
+        feature_id: 'feature_a',
+        dry_run: true
+      }
+    });
+  });
+
+  it('GIVEN_yes_without_dry_run_WHEN_execute_called_THEN_runs_destructive_mode_by_default', async () => {
+    const call = vi.fn(async () => ({ ok: true, data: { feature_id: 'feature_a', dry_run: false } }));
+    const { handler, toolClient } = makeHandler(call);
+
+    await handler.execute({
+      command: 'delete',
+      feature_id: 'feature_a',
+      yes: true
+    });
+
+    expect(toolClient.call).toHaveBeenCalledWith(
+      TOOLS.FEATURE_DELETE,
+      expect.objectContaining({
+        dry_run: false,
+        confirm: true
+      }),
+      expect.any(Object)
+    );
+  });
+
+  it('GIVEN_yes_with_explicit_flags_WHEN_execute_called_THEN_uses_provided_delete_options', async () => {
+    const call = vi.fn(async () => ({ ok: true, data: { feature_id: 'feature_a' } }));
+    const { handler, toolClient } = makeHandler(call);
+
+    await handler.execute({
+      command: 'delete',
+      feature_id: 'feature_a',
+      yes: true,
+      dry_run: true,
+      remove_worktree: false,
+      remove_branch: 'force'
+    });
+
+    expect(toolClient.call).toHaveBeenCalledWith(
+      TOOLS.FEATURE_DELETE,
+      expect.objectContaining({
+        dry_run: true,
+        confirm: true,
+        remove_worktree: false,
+        remove_branch: 'force'
+      }),
+      expect.any(Object)
+    );
+  });
+
+  it('GIVEN_missing_feature_id_WHEN_execute_called_THEN_throws_invalid_cli_args', async () => {
+    const { handler } = makeHandler();
+
+    await expect(
+      handler.execute({
+        command: 'delete'
+      })
+    ).rejects.toMatchObject({
+      code: ERROR_CODES.INVALID_CLI_ARGS,
+      details: expect.objectContaining({
+        reason: '--feature-id is required for delete'
+      })
+    });
+  });
+
+  it('GIVEN_invalid_feature_id_WHEN_execute_called_THEN_throws_invalid_cli_args', async () => {
+    const { handler } = makeHandler();
+
+    await expect(
+      handler.execute({
+        command: 'delete',
+        feature_id: 'FeatureBad'
+      })
+    ).rejects.toMatchObject({
+      code: ERROR_CODES.INVALID_CLI_ARGS,
+      details: expect.objectContaining({
+        reason: 'Invalid --feature-id value'
+      })
+    });
+  });
+
+  it('GIVEN_invalid_remove_branch_mode_WHEN_execute_called_THEN_throws_invalid_cli_args', async () => {
+    const { handler } = makeHandler();
+
+    await expect(
+      handler.execute({
+        command: 'delete',
+        feature_id: 'feature_a',
+        remove_branch: 'hard'
+      })
+    ).rejects.toMatchObject({
+      code: ERROR_CODES.INVALID_CLI_ARGS,
+      details: expect.objectContaining({
+        reason: 'Invalid --remove-branch value'
+      })
+    });
+  });
+
+  it('GIVEN_destructive_dry_run_false_without_yes_WHEN_execute_called_THEN_throws_invalid_cli_args', async () => {
+    const { handler } = makeHandler();
+
+    await expect(
+      handler.execute({
+        command: 'delete',
+        feature_id: 'feature_a',
+        dry_run: false,
+        yes: false
+      })
+    ).rejects.toMatchObject({
+      code: ERROR_CODES.INVALID_CLI_ARGS,
+      details: expect.objectContaining({
+        reason: 'Destructive delete requires --yes'
+      })
+    });
+  });
+
+  it('GIVEN_tool_failure_response_WHEN_execute_called_THEN_surfaces_normalized_error', async () => {
+    const call = vi.fn(async () => ({
+      ok: false,
+      error: {
+        code: ERROR_CODES.RUN_ALREADY_ACTIVE,
+        message: 'run active',
+        details: { stale: false }
+      }
+    }));
+    const { handler } = makeHandler(call);
+
+    await expect(
+      handler.execute({
+        command: 'delete',
+        feature_id: 'feature_a'
+      })
+    ).rejects.toMatchObject({
+      code: ERROR_CODES.RUN_ALREADY_ACTIVE,
+      details: {
+        stale: false
+      }
+    });
+  });
+
+  it('GIVEN_success_without_data_payload_WHEN_execute_called_THEN_returns_command_envelope_only', async () => {
+    const call = vi.fn(async () => ({ ok: true, data: undefined }));
+    const { handler } = makeHandler(call);
+
+    const result = await handler.execute({
+      command: 'delete',
+      feature_id: 'feature_a'
+    });
+
+    expect(result).toEqual({
+      ok: true,
+      data: {
+        command: 'delete'
+      }
+    });
+  });
+});