agentic-orchestrator 0.1.2 → 0.1.4

package/apps/control-plane/test/multi-project.spec.ts

@@ -0,0 +1,372 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+// ── hoisted mocks ─────────────────────────────────────────────────────────────
+
+const ensureLoadedMock = vi.hoisted(() => vi.fn(async () => undefined));
+const createToolingRuntimeMock = vi.hoisted(() => vi.fn(async () => ({ runtime: 'ok' })));
+const resolveToolClientMock = vi.hoisted(() => vi.fn());
+const kernelCtorMock = vi.hoisted(() => vi.fn());
+const toolCallMock = vi.hoisted(() =>
+  vi.fn(async () => ({
+    ok: true,
+    data: { features: [{ feature_id: 'feat-a', status: 'planning' }] }
+  }))
+);
+
+vi.mock('../src/core/kernel.js', () => {
+  class AopKernel {
+    private readonly repoRoot: string;
+
+    constructor(repoRoot: string, _instanceId?: string, configOverrides?: Record<string, unknown>) {
+      this.repoRoot = repoRoot;
+      kernelCtorMock(repoRoot, configOverrides);
+    }
+
+    async ensureLoaded() {
+      await ensureLoadedMock();
+    }
+
+    getRepoRoot() {
+      return this.repoRoot;
+    }
+
+    getAgentsConfig() {
+      return {};
+    }
+
+    getRbacPolicy() {
+      return {};
+    }
+
+    getPolicySnapshot() {
+      return {};
+    }
+  }
+
+  return { AopKernel };
+});
+
+vi.mock('../src/mcp/runtime-factory.js', () => ({
+  createToolingRuntime: createToolingRuntimeMock,
+  resolveToolClient: resolveToolClientMock
+}));
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+async function writeMultiProjectYaml(dir: string, content: string): Promise<void> {
+  const configDir = path.join(dir, 'agentic', 'orchestrator');
+  await fs.mkdir(configDir, { recursive: true });
+  await fs.writeFile(path.join(configDir, 'multi-project.yaml'), content, 'utf8');
+}
+
+async function writeSchemaFile(dir: string): Promise<void> {
+  const schemasDir = path.join(dir, 'agentic', 'orchestrator', 'schemas');
+  await fs.mkdir(schemasDir, { recursive: true });
+  // Resolve repo root: test/ -> control-plane/ -> apps/ -> repo root
+  const repoRoot = path.resolve(import.meta.dirname, '../../../');
+  const srcSchema = path.join(repoRoot, 'agentic', 'orchestrator', 'schemas', 'multi-project.schema.json');
+  const destSchema = path.join(schemasDir, 'multi-project.schema.json');
+  await fs.copyFile(srcSchema, destSchema);
+}
+
+function asJsonWrites(spy: ReturnType<typeof vi.spyOn>): unknown[] {
+  return spy.mock.calls.flatMap((call) => {
+    try {
+      const arg = call[0];
+      if (typeof arg === 'string') {
+        return [JSON.parse(arg)];
+      }
+      return [];
+    } catch {
+      return [];
+    }
+  });
+}
+
+// ── tests ─────────────────────────────────────────────────────────────────────
+
+describe('multi-project loader', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-multi-project-'));
+    await writeSchemaFile(tmpDir);
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('GIVEN_valid_multi_project_yaml_WHEN_loaded_THEN_all_projects_parsed', async () => {
+    await writeMultiProjectYaml(
+      tmpDir,
+      `
+version: "1.0"
+projects:
+  - name: alpha
+    path: /tmp/alpha
+  - name: beta
+    path: ~/projects/beta
+    repo: https://github.com/org/beta
+`
+    );
+
+    const { MultiProjectLoader } = await import('../src/application/multi-project-loader.js');
+    const loader = new MultiProjectLoader();
+    const config = await loader.load(tmpDir);
+
+    expect(config).not.toBeNull();
+    expect(config?.version).toBe('1.0');
+    expect(config?.projects).toHaveLength(2);
+    expect(config?.projects[0].name).toBe('alpha');
+    expect(config?.projects[0].path).toBe('/tmp/alpha');
+    // ~ should be resolved
+    expect(config?.projects[1].path).toBe(path.join(os.homedir(), 'projects/beta'));
+    expect(config?.projects[1].repo).toBe('https://github.com/org/beta');
+  });
+
+  it('GIVEN_missing_multi_project_yaml_WHEN_loaded_THEN_returns_null', async () => {
+    const { MultiProjectLoader } = await import('../src/application/multi-project-loader.js');
+    const loader = new MultiProjectLoader();
+    const config = await loader.load(tmpDir);
+    expect(config).toBeNull();
+  });
+
+  it('GIVEN_invalid_multi_project_yaml_WHEN_loaded_THEN_throws_validation_error', async () => {
+    await writeMultiProjectYaml(
+      tmpDir,
+      `
+version: "1.0"
+projects: []
+`
+    );
+
+    const { MultiProjectLoader } = await import('../src/application/multi-project-loader.js');
+    const loader = new MultiProjectLoader();
+    await expect(loader.load(tmpDir)).rejects.toThrow(/validation failed/i);
+  });
+
+  it('GIVEN_loaded_config_WHEN_getProject_called_with_known_name_THEN_returns_project', async () => {
+    await writeMultiProjectYaml(
+      tmpDir,
+      `
+version: "1.0"
+projects:
+  - name: alpha
+    path: /tmp/alpha
+  - name: beta
+    path: /tmp/beta
+`
+    );
+    const { MultiProjectLoader } = await import('../src/application/multi-project-loader.js');
+    const loader = new MultiProjectLoader();
+    const config = await loader.load(tmpDir);
+    expect(config).not.toBeNull();
+    if (config == null) {
+      throw new Error('expected config to be loaded');
+    }
+    const found = loader.getProject(config, 'alpha');
+    expect(found?.name).toBe('alpha');
+    const missing = loader.getProject(config, 'unknown');
+    expect(missing).toBeNull();
+  });
+});
+
+describe('multi-project CLI integration', () => {
+  let tmpDir: string;
+  let stdoutSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-multi-cli-'));
+    resolveToolClientMock.mockReturnValue({ call: toolCallMock });
+    toolCallMock.mockClear();
+    ensureLoadedMock.mockClear();
+    createToolingRuntimeMock.mockClear();
+    kernelCtorMock.mockClear();
+    stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+  });
+
+  afterEach(async () => {
+    stdoutSpy.mockRestore();
+    await fs.rm(tmpDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it('GIVEN_unknown_project_name_WHEN_project_flag_used_THEN_error_returned', async () => {
+    await writeSchemaFile(tmpDir);
+    await writeMultiProjectYaml(
+      tmpDir,
+      `
+version: "1.0"
+projects:
+  - name: alpha
+    path: /tmp/alpha
+`
+    );
+
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['status', '--project', 'nonexistent'], {
+      cwd: tmpDir,
+      env: process.env
+    });
+
+    const writes = asJsonWrites(stdoutSpy);
+    expect(code).toBe(1);
+    expect(writes[0]).toMatchObject({
+      ok: false,
+      error: expect.objectContaining({ message: expect.stringContaining('nonexistent') })
+    });
+  });
+
+  it('GIVEN_project_flag_WHEN_run_THEN_repo_root_set_to_project_path', async () => {
+    const projectPath = path.join(tmpDir, 'project-alpha');
+    await fs.mkdir(path.join(projectPath, '.aop', 'features'), { recursive: true });
+
+    await writeSchemaFile(tmpDir);
+    await writeMultiProjectYaml(
+      tmpDir,
+      `
+version: "1.0"
+projects:
+  - name: alpha
+    path: ${projectPath}
+`
+    );
+
+    const capturedRoots: string[] = [];
+    createToolingRuntimeMock.mockImplementation(async (...args: unknown[]) => {
+      const root = args[0] as string;
+      capturedRoots.push(root);
+      return { runtime: 'ok' };
+    });
+
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    await runCli(['status', '--project', 'alpha'], { cwd: tmpDir, env: process.env });
+
+    expect(capturedRoots.some((r) => r === projectPath)).toBe(true);
+  });
+
+  it('GIVEN_multiple_projects_and_cwd_inside_one_WHEN_project_omitted_THEN_selects_matching_project', async () => {
+    const projectAlpha = path.join(tmpDir, 'project-alpha');
+    const projectBeta = path.join(tmpDir, 'project-beta');
+    await fs.mkdir(path.join(projectAlpha, '.aop', 'features'), { recursive: true });
+    await fs.mkdir(path.join(projectBeta, '.aop', 'features'), { recursive: true });
+
+    await writeSchemaFile(tmpDir);
+    await writeMultiProjectYaml(
+      tmpDir,
+      `
+version: "1.0"
+projects:
+  - name: alpha
+    path: ${projectAlpha}
+  - name: beta
+    path: ${projectBeta}
+`
+    );
+
+    const capturedRoots: string[] = [];
+    createToolingRuntimeMock.mockImplementation(async (...args: unknown[]) => {
+      capturedRoots.push(args[0] as string);
+      return { runtime: 'ok' };
+    });
+
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['status'], { cwd: projectBeta, env: process.env });
+
+    expect(code).toBe(0);
+    expect(capturedRoots).toContain(projectBeta);
+    expect(capturedRoots).not.toContain(projectAlpha);
+  });
+
+  it('GIVEN_default_project_in_defaults_WHEN_project_omitted_THEN_uses_default_project', async () => {
+    const projectAlpha = path.join(tmpDir, 'project-alpha');
+    const projectBeta = path.join(tmpDir, 'project-beta');
+    await fs.mkdir(path.join(projectAlpha, '.aop', 'features'), { recursive: true });
+    await fs.mkdir(path.join(projectBeta, '.aop', 'features'), { recursive: true });
+
+    await writeSchemaFile(tmpDir);
+    await writeMultiProjectYaml(
+      tmpDir,
+      `
+version: "1.0"
+defaults:
+  default_project: alpha
+projects:
+  - name: alpha
+    path: ${projectAlpha}
+  - name: beta
+    path: ${projectBeta}
+`
+    );
+
+    const capturedRoots: string[] = [];
+    createToolingRuntimeMock.mockImplementation(async (...args: unknown[]) => {
+      capturedRoots.push(args[0] as string);
+      return { runtime: 'ok' };
+    });
+
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['status'], { cwd: tmpDir, env: process.env });
+
+    expect(code).toBe(0);
+    expect(capturedRoots).toContain(projectAlpha);
+    expect(capturedRoots).not.toContain(projectBeta);
+  });
+
+  it('GIVEN_status_all_flag_WHEN_no_multi_project_yaml_THEN_single_project_reported', async () => {
+    await fs.mkdir(path.join(tmpDir, '.aop', 'features'), { recursive: true });
+
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['status', '--all'], { cwd: tmpDir, env: process.env });
+
+    // Should fall through to normal single-project status (toolCall invoked once)
+    expect(code).toBe(0);
+    expect(toolCallMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('GIVEN_defaults_policy_and_gates_WHEN_project_selected_THEN_kernel_uses_project_scoped_override_paths', async () => {
+    const projectAlpha = path.join(tmpDir, 'project-alpha');
+    await fs.mkdir(path.join(projectAlpha, '.aop', 'features'), { recursive: true });
+    await writeSchemaFile(tmpDir);
+    await writeMultiProjectYaml(
+      tmpDir,
+      `
+version: "1.0"
+defaults:
+  policy: agentic/orchestrator/policy.yaml
+  gates: agentic/orchestrator/gates.yaml
+projects:
+  - name: alpha
+    path: ${projectAlpha}
+`
+    );
+
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['status', '--project', 'alpha'], {
+      cwd: tmpDir,
+      env: process.env
+    });
+
+    expect(code).toBe(0);
+    expect(kernelCtorMock).toHaveBeenCalledWith(
+      projectAlpha,
+      expect.objectContaining({
+        policyPath: path.join(projectAlpha, 'agentic', 'orchestrator', 'policy.yaml'),
+        gatesPath: path.join(projectAlpha, 'agentic', 'orchestrator', 'gates.yaml')
+      })
+    );
+  });
+});
+
+describe('MultiProjectLoader.exists', () => {
+  it('GIVEN_missing_yaml_WHEN_exists_called_THEN_returns_false', async () => {
+    const { MultiProjectLoader } = await import('../src/application/multi-project-loader.js');
+    const loader = new MultiProjectLoader();
+    const result = await loader.exists('/nonexistent/path/that/does/not/exist');
+    expect(result).toBe(false);
+  });
+});