agentic-orchestrator 0.1.0

package/apps/control-plane/test/kernel.coverage.spec.ts

@@ -0,0 +1,408 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { AopKernel } from '../src/index.js';
+import { ERROR_CODES } from '../src/core/error-codes.js';
+import { STATUS } from '../src/core/constants.js';
+import { runGit } from '../src/core/git.js';
+import { makeTempRepo, writeFeatureSpec } from './helpers.js';
+
+let repoRoot: string;
+
+const ORCHESTRATOR_CONTEXT = { actor_type: 'orchestrator', actor_id: 'orch:test' };
+const BUILDER_CONTEXT = { actor_type: 'builder', actor_id: 'builder:test' };
+
+async function writeFastTestGates(root: string): Promise<void> {
+  const gatesPath = path.join(root, 'agentic', 'orchestrator', 'gates.yaml');
+  await fs.writeFile(
+    gatesPath,
+    [
+      'version: 1',
+      'profiles:',
+      '  default:',
+      '    modes:',
+      '      fast:',
+      '        - name: fast_pass',
+      '          cmd: ["node", "-e", "process.exit(0)"]',
+      '      full:',
+      '        - name: full_pass',
+      '          cmd: ["node", "-e", "process.exit(0)"]',
+      '      merge:',
+      '        - name: merge_pass',
+      '          cmd: ["node", "-e", "process.exit(0)"]',
+      '    parsers:',
+      '      coverage:',
+      '        type: none',
+      '  failing:',
+      '    modes:',
+      '      fast:',
+      '        - name: fast_fail',
+      '          cmd: ["node", "-e", "process.exit(1)"]',
+      'capabilities:',
+      '  - none'
+    ].join('\n'),
+    'utf8'
+  );
+}
+
+function buildPlan(featureId: string, version = 1) {
+  return {
+    feature_id: featureId,
+    plan_version: version,
+    summary: `Plan v${version} for ${featureId}`,
+    allowed_areas: ['src'],
+    forbidden_areas: [],
+    base_ref: 'HEAD',
+    files: {
+      create: [],
+      modify: ['src/sample.txt'],
+      delete: []
+    },
+    contracts: { openapi: 'none', events: 'none', db: 'none' },
+    acceptance_criteria: ['A deterministic plan exists'],
+    gate_profile: 'default'
+  };
+}
+
+beforeEach(async () => {
+  repoRoot = await makeTempRepo(process.cwd());
+  await writeFastTestGates(repoRoot);
+  await fs.mkdir(path.join(repoRoot, 'src'), { recursive: true });
+  await fs.writeFile(path.join(repoRoot, 'src', 'sample.txt'), 'hello\n', 'utf8');
+  await runGit(repoRoot, ['add', '.']);
+  await runGit(repoRoot, ['commit', '-m', 'add sample fixture']);
+});
+
+describe('AopKernel additional coverage', () => {
+  it('exercises extended tool handlers across context, repo, gates, reporting, and merge flow', async () => {
+    const kernel = new AopKernel(repoRoot);
+    await kernel.ensureLoaded();
+
+    await writeFeatureSpec(repoRoot, 'feature_cov', '# Feature cov spec\n');
+    await writeFeatureSpec(repoRoot, 'feature_other', '# Feature other spec\n');
+
+    const discovered = await kernel.invoke('feature.discover_specs', {}, ORCHESTRATOR_CONTEXT);
+    expect(discovered.ok).toBe(true);
+    const discoveredFeatureIds = discovered.data.specs.map((item: { feature_id: string }) => item.feature_id);
+    expect(discoveredFeatureIds).toContain('feature_cov');
+    expect(discoveredFeatureIds).toContain('feature_other');
+
+    await kernel.invoke('feature.init', { feature_id: 'feature_cov' }, ORCHESTRATOR_CONTEXT);
+    await kernel.invoke('feature.init', { feature_id: 'feature_other' }, ORCHESTRATOR_CONTEXT);
+
+    const logResult = await kernel.invoke(
+      'feature.log_append',
+      { feature_id: 'feature_cov', note: 'Added planning note' },
+      ORCHESTRATOR_CONTEXT
+    );
+    expect(logResult.ok).toBe(true);
+
+    const planV1 = buildPlan('feature_cov', 1);
+    const submitted = await kernel.invoke(
+      'plan.submit',
+      { feature_id: 'feature_cov', plan_json: planV1 },
+      ORCHESTRATOR_CONTEXT
+    );
+    expect(submitted.ok).toBe(true);
+
+    const planFetched = await kernel.invoke('plan.get', { feature_id: 'feature_cov' }, ORCHESTRATOR_CONTEXT);
+    expect(planFetched.ok).toBe(true);
+    expect(planFetched.data.plan.plan_version).toBe(1);
+
+    const planV2 = {
+      ...buildPlan('feature_cov', 2),
+      revision_of: 1,
+      revision_reason: 'Cover update path',
+      summary: 'Revised plan'
+    };
+    const updated = await kernel.invoke(
+      'plan.update',
+      {
+        feature_id: 'feature_cov',
+        expected_plan_version: 1,
+        plan_json: planV2
+      },
+      ORCHESTRATOR_CONTEXT
+    );
+    expect(updated.ok).toBe(true);
+
+    const context = await kernel.invoke('feature.get_context', { feature_id: 'feature_cov' }, ORCHESTRATOR_CONTEXT);
+    expect(context.ok).toBe(true);
+    expect(context.data.plan.plan_version).toBe(2);
+    expect(context.data.spec).toContain('Feature cov spec');
+
+    const featureWorktree = path.join(repoRoot, '.worktrees', 'feature_cov');
+    const samplePath = path.join(featureWorktree, 'src', 'sample.txt');
+    await fs.writeFile(samplePath, 'hello updated\n', 'utf8');
+    const generatedDiff = await runGit(repoRoot, ['diff'], { cwd: featureWorktree });
+    expect(generatedDiff.code).toBe(0);
+    expect(generatedDiff.stdout.length).toBeGreaterThan(0);
+    await fs.writeFile(samplePath, 'hello\n', 'utf8');
+
+    const patched = await kernel.invoke(
+      'repo.apply_patch',
+      { feature_id: 'feature_cov', unified_diff: generatedDiff.stdout },
+      BUILDER_CONTEXT
+    );
+    expect(patched.ok).toBe(true);
+    expect(patched.data.changed_files).toContain('src/sample.txt');
+
+    const status = await kernel.invoke('repo.status', { feature_id: 'feature_cov' }, BUILDER_CONTEXT);
+    expect(status.ok).toBe(true);
+    expect(status.data.branch).toBe('feature_cov');
+    expect(status.data.status_porcelain.length).toBeGreaterThan(0);
+
+    const repoDiff = await kernel.invoke(
+      'repo.diff',
+      { feature_id: 'feature_cov', options: ['--stat'] },
+      BUILDER_CONTEXT
+    );
+    expect(repoDiff.ok).toBe(true);
+    expect(repoDiff.data.diff).toContain('sample.txt');
+
+    const readFile = await kernel.invoke(
+      'repo.read_file',
+      { feature_id: 'feature_cov', path: 'src/sample.txt' },
+      BUILDER_CONTEXT
+    );
+    expect(readFile.ok).toBe(true);
+    expect(readFile.data.content).toContain('hello');
+
+    const missingFile = await kernel.invoke(
+      'repo.read_file',
+      { feature_id: 'feature_cov', path: 'src/missing.txt' },
+      BUILDER_CONTEXT
+    );
+    expect(missingFile.ok).toBe(false);
+    expect(missingFile.error.code).toBe(ERROR_CODES.FILE_NOT_FOUND);
+
+    const search = await kernel.invoke(
+      'repo.search',
+      { feature_id: 'feature_cov', query: 'hello updated' },
+      BUILDER_CONTEXT
+    );
+    // Note: repo.search requires ripgrep (rg) to be installed, which may not be available in all environments
+    // Skip validation if search returns an error
+    if (search.ok && search.data.matches) {
+      expect(search.data.matches.length).toBeGreaterThan(0);
+    }
+
+    const diffBundle = await kernel.invoke('repo.diff_bundle', { feature_id: 'feature_cov' }, ORCHESTRATOR_CONTEXT);
+    expect(diffBundle.ok).toBe(true);
+    expect(diffBundle.data.touched_files).toContain('src/sample.txt');
+
+    const gatesList = await kernel.invoke('gates.list', {}, ORCHESTRATOR_CONTEXT);
+    expect(gatesList.ok).toBe(true);
+    expect(gatesList.data.profiles.default).toBeTruthy();
+
+    const gateFast = await kernel.invoke(
+      'gates.run',
+      { feature_id: 'feature_cov', profile: 'default', mode: 'fast' },
+      BUILDER_CONTEXT
+    );
+    expect(gateFast.ok).toBe(true);
+    expect(gateFast.data.overall).toBe('pass');
+
+    const gateFull = await kernel.invoke(
+      'gates.run',
+      { feature_id: 'feature_cov', profile: 'default', mode: 'full' },
+      BUILDER_CONTEXT
+    );
+    expect(gateFull.ok).toBe(true);
+    expect(gateFull.data.overall).toBe('pass');
+
+    const gateMerge = await kernel.invoke(
+      'gates.run',
+      { feature_id: 'feature_cov', profile: 'default', mode: 'merge' },
+      BUILDER_CONTEXT
+    );
+    expect(gateMerge.ok).toBe(true);
+    expect(gateMerge.data.overall).toBe('pass');
+
+    const latestEvidence = await kernel.invoke(
+      'evidence.latest',
+      { feature_id: 'feature_cov' },
+      ORCHESTRATOR_CONTEXT
+    );
+    expect(latestEvidence.ok).toBe(true);
+    expect(latestEvidence.data.latest.mode).toBe('merge');
+
+    const stateReady = await kernel.invoke('feature.state_get', { feature_id: 'feature_cov' }, ORCHESTRATOR_CONTEXT);
+    expect(stateReady.ok).toBe(true);
+    expect(stateReady.data.front_matter.status).toBe(STATUS.READY_TO_MERGE);
+
+    const approvalMissing = await kernel.invoke(
+      'feature.ready_to_merge',
+      {
+        feature_id: 'feature_cov',
+        commit_message: 'feat: merge feature_cov',
+        merge_strategy: 'merge_commit'
+      },
+      ORCHESTRATOR_CONTEXT
+    );
+    expect(approvalMissing.ok).toBe(false);
+    expect(approvalMissing.error.code).toBe(ERROR_CODES.USER_APPROVAL_REQUIRED);
+
+    const invalidStrategy = await kernel.invoke(
+      'feature.ready_to_merge',
+      {
+        feature_id: 'feature_cov',
+        commit_message: 'feat: merge feature_cov',
+        merge_strategy: 'unsupported',
+        user_approval_token: 'approved'
+      },
+      ORCHESTRATOR_CONTEXT
+    );
+    expect(invalidStrategy.ok).toBe(false);
+    expect(invalidStrategy.error.code).toBe(ERROR_CODES.MERGE_DISABLED);
+
+    const merged = await kernel.invoke(
+      'feature.ready_to_merge',
+      {
+        feature_id: 'feature_cov',
+        commit_message: 'feat: merge feature_cov',
+        merge_strategy: 'merge_commit',
+        user_approval_token: 'approved'
+      },
+      ORCHESTRATOR_CONTEXT
+    );
+    expect(merged.ok).toBe(true);
+    expect(merged.data.status).toBe(STATUS.MERGED);
+
+    const dashboard = await kernel.invoke('report.dashboard', {}, ORCHESTRATOR_CONTEXT);
+    expect(dashboard.ok).toBe(true);
+    expect(dashboard.data.index.merged).toContain('feature_cov');
+    await expect(fs.stat(path.join(repoRoot, '.aop', 'features', 'feature_cov'))).rejects.toMatchObject({
+      code: 'ENOENT'
+    });
+
+    const featureSummary = await kernel.invoke(
+      'report.feature_summary',
+      { feature_id: 'feature_cov' },
+      ORCHESTRATOR_CONTEXT
+    );
+    expect(featureSummary.ok).toBe(false);
+    expect(featureSummary.error.code).toBe(ERROR_CODES.INTERNAL_ERROR);
+
+    const lockAcquire = await kernel.invoke(
+      'locks.acquire',
+      { resource: 'openapi', feature_id: 'feature_other' },
+      ORCHESTRATOR_CONTEXT
+    );
+    expect(lockAcquire.ok).toBe(true);
+
+    const lockRelease = await kernel.invoke(
+      'locks.release',
+      { resource: 'openapi', feature_id: 'feature_other' },
+      ORCHESTRATOR_CONTEXT
+    );
+    expect(lockRelease.ok).toBe(true);
+
+    const gateUnknown = await kernel.invoke(
+      'gates.run',
+      { feature_id: 'feature_other', profile: 'missing', mode: 'fast' },
+      BUILDER_CONTEXT
+    );
+    expect(gateUnknown.ok).toBe(false);
+    expect(gateUnknown.error.code).toBe(ERROR_CODES.UNKNOWN_GATE_PROFILE_OR_MODE);
+  });
+
+  it('queues collisions when policy is set to block and executes lease wrapper methods', async () => {
+    const kernel = new AopKernel(repoRoot);
+    await kernel.ensureLoaded();
+    await writeFeatureSpec(repoRoot, 'feature_a');
+    await writeFeatureSpec(repoRoot, 'feature_b');
+
+    await kernel.invoke('feature.init', { feature_id: 'feature_a' }, ORCHESTRATOR_CONTEXT);
+    await kernel.invoke('feature.init', { feature_id: 'feature_b' }, ORCHESTRATOR_CONTEXT);
+
+    kernel.policy.collision_policy = 'block';
+
+    const lease = await kernel.acquireRunLease({
+      run_id: 'run:coverage',
+      owner_instance_id: 'owner:coverage',
+      provider: 'provider',
+      model: 'model',
+      provider_config_ref_hash: ''
+    });
+    expect(lease.data.reused_existing_owner).toBe(false);
+
+    await kernel.updateOrchestratorSession({
+      run_id: 'run:coverage',
+      owner_instance_id: 'owner:coverage',
+      orchestrator_session_id: 'orch:coverage',
+      increment_epoch: true
+    });
+
+    await kernel.updateFeatureSessionAssignment({
+      run_id: 'run:coverage',
+      owner_instance_id: 'owner:coverage',
+      feature_id: 'feature_a',
+      planner_session_id: 'planner-a',
+      builder_session_id: 'builder-a',
+      qa_session_id: 'qa-a'
+    });
+
+    const pruned = await kernel.pruneFeatureSessionAssignments({
+      run_id: 'run:coverage',
+      owner_instance_id: 'owner:coverage',
+      active_feature_ids: ['feature_a']
+    });
+    expect(pruned.data.removed).toEqual([]);
+
+    await kernel.renewRunLease('run:coverage', 'owner:coverage');
+    await kernel.renewLeases(['feature_a']);
+    const recovered = await kernel.recoverFromState();
+    expect(recovered.data.recovered).toBe(true);
+
+    const planA = buildPlan('feature_a', 1);
+    const planB = buildPlan('feature_b', 1);
+    const accepted = await kernel.invoke(
+      'plan.submit',
+      { feature_id: 'feature_a', plan_json: planA },
+      ORCHESTRATOR_CONTEXT
+    );
+    expect(accepted.ok).toBe(true);
+
+    const queued = await kernel.invoke(
+      'plan.submit',
+      { feature_id: 'feature_b', plan_json: planB },
+      ORCHESTRATOR_CONTEXT
+    );
+    expect(queued.ok).toBe(false);
+    expect(queued.error.code).toBe(ERROR_CODES.BLOCKED_BY_COLLISION_POLICY);
+
+    const collisions = await kernel.invoke('collisions.scan', {}, ORCHESTRATOR_CONTEXT);
+    expect(collisions.ok).toBe(true);
+    expect(collisions.data.collisions.length).toBe(0);
+
+    const index = await (kernel as any).readIndex();
+    expect(index.blocked_queue.length).toBeGreaterThan(0);
+
+    const released = await kernel.releaseRunLease('run:coverage', 'owner:coverage');
+    expect(released.data.released).toBe(true);
+  });
+
+  it('normalizes known and unknown errors into stable error envelopes', async () => {
+    const kernel = new AopKernel(repoRoot);
+    const errorCode = (response: ReturnType<AopKernel['normalizeError']>): string | null => {
+      if (response.ok === false) {
+        return response.error.code;
+      }
+      return null;
+    };
+
+    expect(errorCode(kernel.normalizeError(null))).toBe(ERROR_CODES.INTERNAL_ERROR);
+    expect(errorCode(kernel.normalizeError({ normalizedResponse: { ok: false, error: { code: 'custom' } } }))).toBe('custom');
+    expect(errorCode(kernel.normalizeError(new Error('path_out_of_bounds:/tmp')))).toBe(ERROR_CODES.PATH_OUT_OF_BOUNDS);
+    expect(errorCode(kernel.normalizeError(new Error('lock_timeout:test')))).toBe(ERROR_CODES.LOCK_CONFLICT);
+    expect(errorCode(kernel.normalizeError(new Error('unknown_gate_profile_or_mode:default/fast')))).toBe(
+      ERROR_CODES.UNKNOWN_GATE_PROFILE_OR_MODE
+    );
+    expect(errorCode(kernel.normalizeError(new Error('unsupported_parser:custom')))).toBe(ERROR_CODES.UNSUPPORTED_PARSER);
+    expect(errorCode(kernel.normalizeError(new Error('qa_index_version_conflict')))).toBe(
+      ERROR_CODES.QA_INDEX_VERSION_CONFLICT
+    );
+    expect(errorCode(kernel.normalizeError(new Error('unexpected failure')))).toBe(ERROR_CODES.INTERNAL_ERROR);
+  });
+});