agentic-orchestrator 0.1.26 → 0.1.28

package/apps/control-plane/test/repo-operations-service.spec.ts

@@ -0,0 +1,339 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const pathExistsMock = vi.hoisted(() => vi.fn(async () => false));
+const ensureDirMock = vi.hoisted(() => vi.fn(async () => {}));
+const runGitMock = vi.hoisted(() => vi.fn());
+const runCommandMock = vi.hoisted(() => vi.fn());
+const normalizeRepoPathMock = vi.hoisted(() => vi.fn(async (_root: string, p: string) => p));
+const normalizeFromWorktreeMock = vi.hoisted(() =>
+  vi.fn((_worktree: string, _root: string, p: string) => p),
+);
+const applyWorktreeSymlinksMock = vi.hoisted(() => vi.fn(async () => {}));
+const runWorktreePostCreateMock = vi.hoisted(() => vi.fn(async () => {}));
+const formatWorkspaceHookWarningMock = vi.hoisted(() => vi.fn(() => 'hook warning'));
+const fsReadFileMock = vi.hoisted(() => vi.fn(async () => 'file content'));
+
+vi.mock('../src/core/fs.js', () => ({
+  pathExists: pathExistsMock,
+  ensureDir: ensureDirMock,
+}));
+
+vi.mock('../src/core/git.js', () => ({
+  runGit: runGitMock,
+  runCommand: runCommandMock,
+}));
+
+vi.mock('../src/core/path-rules.js', () => ({
+  normalizeRepoPath: normalizeRepoPathMock,
+}));
+
+vi.mock('../src/core/utils/path-normalizers.js', () => ({
+  normalizeFromWorktree: normalizeFromWorktreeMock,
+}));
+
+vi.mock('../src/core/workspace-hooks.js', () => ({
+  applyWorktreeSymlinks: applyWorktreeSymlinksMock,
+  runWorktreePostCreate: runWorktreePostCreateMock,
+  formatWorkspaceHookWarning: formatWorkspaceHookWarningMock,
+}));
+
+vi.mock('node:fs/promises', () => ({
+  default: {
+    readFile: fsReadFileMock,
+  },
+}));
+
+import {
+  RepoOperationsService,
+  type RepoOperationsServicePort,
+} from '../src/application/services/repo-operations-service.js';
+
+function commandResult(
+  overrides: Partial<{
+    code: number;
+    signal: NodeJS.Signals | null;
+    stdout: string;
+    stderr: string;
+    timeout: boolean;
+  }> = {},
+) {
+  return { code: 0, signal: null, stdout: '', stderr: '', timeout: false, ...overrides };
+}
+
+function makePort(overrides: Partial<RepoOperationsServicePort> = {}): RepoOperationsServicePort {
+  return {
+    getRepoRoot: vi.fn(() => '/repo'),
+    worktreePath: vi.fn((_featureId: string) => '/repo/.worktrees/feat1'),
+    getPolicySnapshot: vi.fn(() => ({
+      worktree: {
+        base_branch: 'main',
+        symlinks: [],
+        post_create: [],
+      },
+      path_rules: { allow_symlink_traversal: false },
+    })),
+    evidenceLatest: vi.fn(async () => ({ data: { latest: null } })),
+    ...overrides,
+  };
+}
+
+describe('RepoOperationsService.repoEnsureWorktree', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    ensureDirMock.mockResolvedValue(undefined);
+  });
+
+  it('GIVEN_worktree_already_exists_WHEN_repoEnsureWorktree_THEN_returns_existed_true', async () => {
+    pathExistsMock.mockResolvedValue(true);
+    const service = new RepoOperationsService(makePort());
+    const result = await service.repoEnsureWorktree('feat1');
+    expect(result.data.existed).toBe(true);
+    expect(result.data.feature_id).toBe('feat1');
+    expect(runGitMock).not.toHaveBeenCalled();
+  });
+
+  it('GIVEN_worktree_not_exists_base_branch_valid_branch_new_WHEN_repoEnsureWorktree_THEN_creates_worktree', async () => {
+    pathExistsMock.mockResolvedValue(false);
+    runGitMock
+      .mockResolvedValueOnce(commandResult({ code: 0 })) // rev-parse base_branch → valid
+      .mockResolvedValueOnce(commandResult({ code: 1 })) // rev-parse branch → not found
+      .mockResolvedValueOnce(commandResult({ code: 0 })) // branch create → success
+      .mockResolvedValueOnce(commandResult({ code: 0 })); // worktree add → success
+
+    const service = new RepoOperationsService(makePort());
+    const result = await service.repoEnsureWorktree('feat1');
+    expect(result.data.existed).toBe(false);
+    expect(result.data.feature_id).toBe('feat1');
+  });
+
+  it('GIVEN_worktree_not_exists_branch_already_exists_WHEN_repoEnsureWorktree_THEN_skips_branch_create', async () => {
+    pathExistsMock.mockResolvedValue(false);
+    runGitMock
+      .mockResolvedValueOnce(commandResult({ code: 0 })) // rev-parse base_branch → valid
+      .mockResolvedValueOnce(commandResult({ code: 0 })) // rev-parse branch → exists
+      .mockResolvedValueOnce(commandResult({ code: 0 })); // worktree add → success
+
+    const service = new RepoOperationsService(makePort());
+    const result = await service.repoEnsureWorktree('feat1');
+    expect(result.data.existed).toBe(false);
+  });
+
+  it('GIVEN_base_branch_invalid_WHEN_repoEnsureWorktree_THEN_uses_HEAD_as_base', async () => {
+    pathExistsMock.mockResolvedValue(false);
+    runGitMock
+      .mockResolvedValueOnce(commandResult({ code: 1 })) // rev-parse base_branch → invalid → use HEAD
+      .mockResolvedValueOnce(commandResult({ code: 1 })) // rev-parse branch → not found
+      .mockResolvedValueOnce(commandResult({ code: 0 })) // branch create → success
+      .mockResolvedValueOnce(commandResult({ code: 0 })); // worktree add → success
+
+    const service = new RepoOperationsService(makePort());
+    const result = await service.repoEnsureWorktree('feat1');
+    expect(result.data.existed).toBe(false);
+    // verify HEAD was used as base
+    expect(runGitMock).toHaveBeenCalledWith('/repo', ['branch', 'feat1', 'HEAD']);
+  });
+
+  it('GIVEN_branch_create_fails_WHEN_repoEnsureWorktree_THEN_throws_GIT_FAILURE', async () => {
+    pathExistsMock.mockResolvedValue(false);
+    runGitMock
+      .mockResolvedValueOnce(commandResult({ code: 0 })) // rev-parse base_branch → valid
+      .mockResolvedValueOnce(commandResult({ code: 1 })) // rev-parse branch → not found
+      .mockResolvedValueOnce(commandResult({ code: 1, stderr: 'branch error' })); // branch create fails
+
+    const service = new RepoOperationsService(makePort());
+    await expect(service.repoEnsureWorktree('feat1')).rejects.toMatchObject({
+      normalizedResponse: expect.objectContaining({ ok: false }),
+    });
+  });
+
+  it('GIVEN_worktree_add_fails_WHEN_repoEnsureWorktree_THEN_throws_GIT_FAILURE', async () => {
+    pathExistsMock.mockResolvedValue(false);
+    runGitMock
+      .mockResolvedValueOnce(commandResult({ code: 0 })) // rev-parse base_branch → valid
+      .mockResolvedValueOnce(commandResult({ code: 0 })) // rev-parse branch → exists
+      .mockResolvedValueOnce(commandResult({ code: 1, stderr: 'worktree error' })); // worktree add fails
+
+    const service = new RepoOperationsService(makePort());
+    await expect(service.repoEnsureWorktree('feat1')).rejects.toMatchObject({
+      normalizedResponse: expect.objectContaining({ ok: false }),
+    });
+  });
+
+  it('GIVEN_policy_has_symlinks_WHEN_repoEnsureWorktree_THEN_applies_symlinks', async () => {
+    pathExistsMock.mockResolvedValue(false);
+    runGitMock
+      .mockResolvedValueOnce(commandResult({ code: 0 }))
+      .mockResolvedValueOnce(commandResult({ code: 0 }))
+      .mockResolvedValueOnce(commandResult({ code: 0 }));
+
+    const port = makePort({
+      getPolicySnapshot: vi.fn(() => ({
+        worktree: {
+          base_branch: 'main',
+          symlinks: ['.env'],
+          post_create: [],
+        },
+        path_rules: { allow_symlink_traversal: false },
+      })),
+    });
+
+    const service = new RepoOperationsService(port);
+    await service.repoEnsureWorktree('feat1');
+    expect(applyWorktreeSymlinksMock).toHaveBeenCalled();
+  });
+
+  it('GIVEN_policy_has_post_create_WHEN_repoEnsureWorktree_THEN_runs_post_create', async () => {
+    pathExistsMock.mockResolvedValue(false);
+    runGitMock
+      .mockResolvedValueOnce(commandResult({ code: 0 }))
+      .mockResolvedValueOnce(commandResult({ code: 0 }))
+      .mockResolvedValueOnce(commandResult({ code: 0 }));
+
+    const port = makePort({
+      getPolicySnapshot: vi.fn(() => ({
+        worktree: {
+          base_branch: 'main',
+          symlinks: [],
+          post_create: ['npm ci'],
+        },
+        path_rules: { allow_symlink_traversal: false },
+      })),
+    });
+
+    const service = new RepoOperationsService(port);
+    await service.repoEnsureWorktree('feat1');
+    expect(runWorktreePostCreateMock).toHaveBeenCalled();
+  });
+});
+
+describe('RepoOperationsService.repoReadFile', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    normalizeRepoPathMock.mockImplementation(async (_root: string, p: string) => p);
+    normalizeFromWorktreeMock.mockImplementation(
+      (_worktree: string, _root: string, p: string) => p,
+    );
+  });
+
+  it('GIVEN_file_not_found_WHEN_repoReadFile_THEN_throws_FILE_NOT_FOUND', async () => {
+    pathExistsMock.mockResolvedValue(false);
+    const service = new RepoOperationsService(makePort());
+    await expect(service.repoReadFile('feat1', 'src/missing.ts')).rejects.toMatchObject({
+      normalizedResponse: expect.objectContaining({ ok: false }),
+    });
+  });
+
+  it('GIVEN_file_exists_WHEN_repoReadFile_THEN_returns_content', async () => {
+    pathExistsMock.mockResolvedValue(true);
+    fsReadFileMock.mockResolvedValue('file contents here');
+    const service = new RepoOperationsService(makePort());
+    const result = await service.repoReadFile('feat1', 'src/file.ts');
+    expect(result.data.content).toBe('file contents here');
+    expect(result.data.feature_id).toBe('feat1');
+  });
+});
+
+describe('RepoOperationsService.repoSearch', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('GIVEN_ripgrep_not_found_WHEN_repoSearch_THEN_throws_rg_not_found', async () => {
+    runCommandMock.mockResolvedValue(commandResult({ code: 127, stderr: 'rg: not found' }));
+    const service = new RepoOperationsService(makePort());
+    await expect(service.repoSearch('feat1', 'TODO')).rejects.toMatchObject({
+      normalizedResponse: expect.objectContaining({ ok: false }),
+    });
+  });
+
+  it('GIVEN_search_fails_with_non_zero_non_one_WHEN_repoSearch_THEN_throws_search_failed', async () => {
+    runCommandMock.mockResolvedValue(commandResult({ code: 2, stderr: 'error' }));
+    const service = new RepoOperationsService(makePort());
+    await expect(service.repoSearch('feat1', 'TODO')).rejects.toMatchObject({
+      normalizedResponse: expect.objectContaining({ ok: false }),
+    });
+  });
+
+  it('GIVEN_search_with_code_1_no_matches_WHEN_repoSearch_THEN_returns_empty_matches', async () => {
+    runCommandMock.mockResolvedValue(commandResult({ code: 1, stdout: '' }));
+    const service = new RepoOperationsService(makePort());
+    const result = await service.repoSearch('feat1', 'TODO');
+    expect(result.data.matches).toEqual([]);
+  });
+
+  it('GIVEN_search_succeeds_WHEN_repoSearch_THEN_returns_parsed_matches', async () => {
+    const stdout = 'src/foo.ts:10:const x = 1;\nsrc/bar.ts:20:const y = 2;';
+    runCommandMock.mockResolvedValue(commandResult({ code: 0, stdout }));
+    const service = new RepoOperationsService(makePort());
+    const result = await service.repoSearch('feat1', 'const');
+    expect(result.data.matches).toHaveLength(2);
+    expect(result.data.matches[0]).toMatchObject({
+      path: 'src/foo.ts',
+      line: 10,
+      snippet: 'const x = 1;',
+    });
+  });
+
+  it('GIVEN_match_line_without_colons_WHEN_repoSearch_THEN_returns_raw_entry', async () => {
+    runCommandMock.mockResolvedValue(commandResult({ code: 0, stdout: 'linewithoutseparator' }));
+    const service = new RepoOperationsService(makePort());
+    const result = await service.repoSearch('feat1', 'test');
+    expect(result.data.matches[0]).toMatchObject({ raw: 'linewithoutseparator' });
+  });
+});
+
+describe('RepoOperationsService.repoStatus', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('GIVEN_feature_id_WHEN_repoStatus_THEN_returns_status_and_branch', async () => {
+    runGitMock
+      .mockResolvedValueOnce(commandResult({ code: 0, stdout: ' M src/file.ts\n' }))
+      .mockResolvedValueOnce(commandResult({ code: 0, stdout: 'feat1\n' }));
+    const service = new RepoOperationsService(makePort());
+    const result = await service.repoStatus('feat1');
+    expect(result.data.branch).toBe('feat1');
+    expect(result.data.feature_id).toBe('feat1');
+  });
+});
+
+describe('RepoOperationsService.repoDiff', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('GIVEN_feature_id_WHEN_repoDiff_THEN_returns_diff', async () => {
+    runGitMock.mockResolvedValue(commandResult({ code: 0, stdout: 'diff output' }));
+    const service = new RepoOperationsService(makePort());
+    const result = await service.repoDiff('feat1', ['--stat']);
+    expect(result.data.diff).toBe('diff output');
+  });
+
+  it('GIVEN_options_without_dashes_WHEN_repoDiff_THEN_filters_invalid_options', async () => {
+    runGitMock.mockResolvedValue(commandResult({ code: 0, stdout: '' }));
+    const service = new RepoOperationsService(makePort());
+    await service.repoDiff('feat1', ['--stat', 'badoption']);
+    // badoption should be filtered out
+    expect(runGitMock).toHaveBeenCalledWith('/repo', ['diff', '--stat'], expect.any(Object));
+  });
+});
+
+describe('RepoOperationsService.repoDiffBundle', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('GIVEN_feature_id_WHEN_repoDiffBundle_THEN_returns_bundle', async () => {
+    runGitMock
+      .mockResolvedValueOnce(commandResult({ code: 0, stdout: 'stat output' }))
+      .mockResolvedValueOnce(commandResult({ code: 0, stdout: 'full diff' }))
+      .mockResolvedValueOnce(commandResult({ code: 0, stdout: 'src/a.ts\nsrc/b.ts\n' }));
+
+    const service = new RepoOperationsService(makePort());
+    const result = await service.repoDiffBundle('feat1');
+    expect(result.data.diff_stat).toBe('stat output');
+    expect(result.data.diff).toBe('full diff');
+    expect(result.data.touched_files).toEqual(['src/a.ts', 'src/b.ts']);
+  });
+});

package/apps/control-plane/test/resume-command.spec.ts

@@ -51,6 +51,10 @@ vi.mock('../src/providers/worker-provider-factory.js', () => ({
   },
   resolveWorkerProviderMode: vi.fn(() => 'live'),
   resolveWorkerProviderPolicy: vi.fn(() => ({ require_live_provider_for_run: true })),
+  resolveWorkerProviderObservability: vi.fn(() => ({
+    raw_agent_logs_enabled: false,
+    raw_agent_logs_retention_days: 60,
+  })),
   resolveWorkerProviderRuntime: vi.fn(() => ({
     worker_response_timeout_ms: 120000,
     max_consecutive_no_progress_iterations: 2,
@@ -271,6 +275,35 @@ describe('ResumeCommandHandler', () => {
 
     expect(result.ok).toBe(true);
   });
+
+  it('GIVEN_resume_feature_id_filter_WHEN_execute_THEN_targets_only_requested_feature', async () => {
+    const kernel = makeKernel({
+      readIndex: vi.fn(async () => ({
+        active: ['feature_a', 'feature_b'],
+        blocked: [],
+        blocked_queue: [],
+      })),
+      featureStateGet: vi.fn(async (featureId: string) => ({
+        data: {
+          front_matter: {
+            status: featureId === 'feature_b' ? STATUS.BUILDING : STATUS.PLANNING,
+          },
+        },
+      })),
+    });
+    const handler = new ResumeCommandHandler();
+    const context = makeContext(kernel);
+    context.options = { feature_id: 'feature_b' } as any;
+    const result = (await handler.execute(context)) as any;
+
+    expect(result.ok).toBe(true);
+    expect(result.data.resumed).toBe(true);
+    expect(result.data.resumed_features).toEqual([
+      expect.objectContaining({ feature_id: 'feature_b' }),
+    ]);
+    expect(kernel.featureStateGet).toHaveBeenCalledTimes(1);
+    expect(kernel.featureStateGet).toHaveBeenCalledWith('feature_b');
+  });
 });
 
 describe('ResumeCommandHandler additional branches', () => {

package/apps/control-plane/test/review-workspace-logic.spec.ts

@@ -0,0 +1,130 @@
+import { describe, expect, it } from 'vitest';
+import {
+  appendCappedLogEntries,
+  isConsoleSendAllowed,
+  stepHunkIndex,
+} from '../../../packages/web-dashboard/src/lib/review-workspace-logic.js';
+import { isEditableTarget } from '../../../packages/web-dashboard/src/lib/review-contracts.js';
+import type {
+  AgentLogEntry,
+  AgentSessionCluster,
+} from '../../../packages/web-dashboard/src/lib/types.js';
+
+function makeEntry(index: number): AgentLogEntry {
+  return {
+    id: `entry-${index}`,
+    timestamp: new Date(1_700_000_000_000 + index).toISOString(),
+    actor: 'builder:feature_checkout',
+    role: 'builder',
+    text: `message ${index}`,
+  };
+}
+
+function activeCluster(): AgentSessionCluster {
+  return {
+    orchestrator_session_id: 'orch-1',
+    planner_session_id: 'planner-1',
+    builder_session_id: 'builder-1',
+    qa_session_id: 'qa-1',
+  };
+}
+
+describe('review workspace logic', () => {
+  it('caps streamed log entries to a fixed buffer size', () => {
+    const current = [makeEntry(1), makeEntry(2)];
+    const incoming = [makeEntry(3), makeEntry(4), makeEntry(5)];
+
+    const result = appendCappedLogEntries(current, incoming, 3);
+
+    expect(result.map((entry) => entry.id)).toEqual(['entry-3', 'entry-4', 'entry-5']);
+  });
+
+  it('allows console send only for active non-terminal sessions and valid interval', () => {
+    expect(
+      isConsoleSendAllowed({
+        status: 'qa',
+        cluster: activeCluster(),
+        hasActiveRuntimeSession: true,
+        submitting: false,
+        message: 'Please re-run gate',
+        nowMs: 2_000,
+        lastMessageSentAtMs: 500,
+      }),
+    ).toBe(true);
+
+    expect(
+      isConsoleSendAllowed({
+        status: 'merged',
+        cluster: activeCluster(),
+        hasActiveRuntimeSession: true,
+        submitting: false,
+        message: 'Should not send',
+        nowMs: 2_000,
+        lastMessageSentAtMs: 0,
+      }),
+    ).toBe(false);
+
+    expect(
+      isConsoleSendAllowed({
+        status: 'qa',
+        cluster: {
+          orchestrator_session_id: 'unknown',
+          planner_session_id: 'unknown',
+          builder_session_id: 'unknown',
+          qa_session_id: 'unknown',
+        },
+        hasActiveRuntimeSession: true,
+        submitting: false,
+        message: 'Should not send',
+        nowMs: 2_000,
+        lastMessageSentAtMs: 0,
+      }),
+    ).toBe(false);
+
+    expect(
+      isConsoleSendAllowed({
+        status: 'qa',
+        cluster: activeCluster(),
+        hasActiveRuntimeSession: false,
+        submitting: false,
+        message: 'No runtime',
+        nowMs: 2_000,
+        lastMessageSentAtMs: 0,
+      }),
+    ).toBe(false);
+
+    expect(
+      isConsoleSendAllowed({
+        status: 'qa',
+        cluster: activeCluster(),
+        hasActiveRuntimeSession: true,
+        submitting: false,
+        message: 'Rate limited',
+        nowMs: 1_200,
+        lastMessageSentAtMs: 500,
+      }),
+    ).toBe(false);
+  });
+
+  it('clamps hunk index movement', () => {
+    expect(stepHunkIndex(0, -1, 5)).toBe(0);
+    expect(stepHunkIndex(3, -1, 5)).toBe(2);
+    expect(stepHunkIndex(0, 1, 1)).toBe(0);
+    expect(stepHunkIndex(3, 1, 5)).toBe(4);
+    expect(stepHunkIndex(4, 1, 5)).toBe(4);
+  });
+
+  it('marks editable event targets for shortcut suppression', () => {
+    expect(isEditableTarget({ tagName: 'INPUT' } as unknown as EventTarget)).toBe(true);
+    expect(isEditableTarget({ tagName: 'textarea' } as unknown as EventTarget)).toBe(true);
+    expect(isEditableTarget({ isContentEditable: true } as unknown as EventTarget)).toBe(true);
+    expect(
+      isEditableTarget({
+        closest: (selector: string) => (selector === '.monaco-editor' ? {} : null),
+      } as unknown as EventTarget),
+    ).toBe(true);
+    expect(
+      isEditableTarget({ tagName: 'div', isContentEditable: false } as unknown as EventTarget),
+    ).toBe(false);
+  });
+});