macro-agent 0.2.5 → 0.2.6

package/src/workspace/__tests__/workspace-manager-v3.test.ts

@@ -1,245 +0,0 @@
-/**
- * WorkspaceManager V3 surface tests (Phase 1).
- *
- * Covers the stream-first methods added alongside the legacy role-shaped API.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { execSync } from 'child_process';
-import { createGitCascadeAdapter, type GitCascadeAdapter } from '../git-cascade-adapter.js';
-import {
-  DefaultWorkspaceManager,
-  createWorkspaceManagerWithAdapter,
-} from '../workspace-manager.js';
-
-describe('WorkspaceManager V3 surface', () => {
-  let tempDir: string;
-  let repoPath: string;
-  let dbPath: string;
-  let adapter: GitCascadeAdapter;
-  let manager: DefaultWorkspaceManager;
-
-  beforeEach(() => {
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ws-v3-test-'));
-    repoPath = path.join(tempDir, 'repo');
-    dbPath = path.join(tempDir, 'test.db');
-    fs.mkdirSync(repoPath);
-
-    execSync('git init -b main', { cwd: repoPath, stdio: 'pipe' });
-    execSync('git config user.email "test@test.com"', { cwd: repoPath, stdio: 'pipe' });
-    execSync('git config user.name "Test User"', { cwd: repoPath, stdio: 'pipe' });
-    fs.writeFileSync(path.join(repoPath, 'README.md'), '# Test');
-    execSync('git add .', { cwd: repoPath, stdio: 'pipe' });
-    execSync('git commit -m "init"', { cwd: repoPath, stdio: 'pipe' });
-
-    adapter = createGitCascadeAdapter({
-      enabled: true,
-      repoPath,
-      dbPath,
-      skipRecovery: true,
-    });
-    manager = createWorkspaceManagerWithAdapter(adapter, {
-      worktreeBaseDir: path.join(tempDir, 'worktrees'),
-    }) as DefaultWorkspaceManager;
-  });
-
-  afterEach(() => {
-    manager.close();
-    adapter.close();
-    if (tempDir && fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  describe('streams', () => {
-    it('creates a stream with a pseudo-principal owner', () => {
-      const streamId = manager.createStreamV3({
-        name: 'team-root',
-        ownerId: 'team:peer-swarm',
-        forkFrom: 'main',
-      });
-      expect(streamId).toBeDefined();
-    });
-
-    it('forks a child stream off a parent', () => {
-      const parent = manager.createStreamV3({
-        name: 'parent',
-        ownerId: 'team:solo-stack',
-      });
-      const child = manager.forkStream({
-        parentStreamId: parent,
-        name: 'child',
-        ownerId: 'agent-1',
-      });
-      const childStream = adapter.getStream(child);
-      expect(childStream?.parentStream).toBe(parent);
-    });
-
-    it('emits stream:created and stream:forked events', () => {
-      const events: string[] = [];
-      manager.onEvent((e) => events.push(e.type));
-
-      const parent = manager.createStreamV3({ name: 'parent', ownerId: 'team:x' });
-      manager.forkStream({ parentStreamId: parent, name: 'child', ownerId: 'agent-1' });
-
-      expect(events).toContain('stream:created');
-      expect(events).toContain('stream:forked');
-    });
-
-    it('pauses and resumes a stream with events', () => {
-      const streamId = manager.createStreamV3({ name: 'x', ownerId: 'agent-1' });
-      const events: string[] = [];
-      manager.onEvent((e) => events.push(e.type));
-
-      manager.pauseStream(streamId, 'manual');
-      expect(adapter.getStream(streamId)?.status).toBe('paused');
-      expect(events).toContain('stream:paused');
-
-      manager.resumeStream(streamId);
-      expect(adapter.getStream(streamId)?.status).toBe('active');
-      expect(events).toContain('stream:resumed');
-    });
-
-    it('lists streams by owner', () => {
-      manager.createStreamV3({ name: 'a', ownerId: 'agent-1' });
-      manager.createStreamV3({ name: 'b', ownerId: 'agent-2' });
-      const owned = manager.listStreams({ ownerId: 'agent-1' });
-      expect(owned.length).toBe(1);
-      expect(owned[0].name).toBe('a');
-    });
-  });
-
-  describe('worktree allocation', () => {
-    it('allocates a worktree attached to a stream', () => {
-      const streamId = manager.createStreamV3({ name: 'feat', ownerId: 'agent-1' });
-      const wt = manager.allocateWorktree({
-        agentId: 'agent-1',
-        streamId,
-      });
-      expect(wt.path).toContain('agent-1');
-      expect(wt.agentId).toBe('agent-1');
-    });
-
-    it('shares a worktree between two agents (ref-counted)', () => {
-      const streamId = manager.createStreamV3({ name: 'feat', ownerId: 'agent-1' });
-      const primary = manager.allocateWorktree({ agentId: 'agent-1', streamId });
-
-      const shared = manager.allocateWorktree({
-        agentId: 'agent-2',
-        sharedWithAgent: 'agent-1',
-      });
-
-      expect(shared.path).toBe(primary.path);
-    });
-
-    it('throws when sharing from an unallocated agent', () => {
-      expect(() =>
-        manager.allocateWorktree({ agentId: 'agent-x', sharedWithAgent: 'nonexistent' })
-      ).toThrow(/has no allocated worktree/);
-    });
-
-    it('emits worktree:allocated and worktree:shared events', () => {
-      const streamId = manager.createStreamV3({ name: 'feat', ownerId: 'agent-1' });
-      const events: string[] = [];
-      manager.onEvent((e) => events.push(e.type));
-
-      manager.allocateWorktree({ agentId: 'agent-1', streamId });
-      manager.allocateWorktree({ agentId: 'agent-2', sharedWithAgent: 'agent-1' });
-
-      expect(events).toContain('worktree:allocated');
-      expect(events).toContain('worktree:shared');
-    });
-  });
-
-  describe('changes (Change-Id tracking)', () => {
-    it('commits via commitChanges and assigns a Change-Id', () => {
-      const streamId = manager.createStreamV3({ name: 'feat', ownerId: 'agent-1' });
-      const wt = manager.allocateWorktree({ agentId: 'agent-1', streamId });
-
-      fs.writeFileSync(path.join(wt.path, 'hello.txt'), 'hi');
-
-      const result = manager.commitChanges({
-        agentId: 'agent-1',
-        streamId,
-        worktree: wt.path,
-        message: 'add hello',
-      });
-
-      expect(result.commit).toBeDefined();
-      expect(result.changeId).toBeDefined();
-      expect(result.changeId.startsWith('c-')).toBe(true);
-
-      const change = manager.getChangeByCommit(result.commit);
-      expect(change?.id).toBe(result.changeId);
-    });
-
-    it('emits stream:committed event on commit', () => {
-      const streamId = manager.createStreamV3({ name: 'feat', ownerId: 'agent-1' });
-      const wt = manager.allocateWorktree({ agentId: 'agent-1', streamId });
-
-      fs.writeFileSync(path.join(wt.path, 'x.txt'), 'x');
-
-      const events: Array<{ type: string; data: Record<string, unknown> }> = [];
-      manager.onEvent((e) => events.push(e));
-
-      manager.commitChanges({
-        agentId: 'agent-1',
-        streamId,
-        worktree: wt.path,
-        message: 'x',
-      });
-
-      const committed = events.find((e) => e.type === 'stream:committed');
-      expect(committed).toBeDefined();
-      expect(committed?.data.streamId).toBe(streamId);
-    });
-
-    it('marks changes merged and emits events', () => {
-      const streamId = manager.createStreamV3({ name: 'feat', ownerId: 'agent-1' });
-      const wt = manager.allocateWorktree({ agentId: 'agent-1', streamId });
-      fs.writeFileSync(path.join(wt.path, 'x.txt'), 'x');
-      const { changeId } = manager.commitChanges({
-        agentId: 'agent-1',
-        streamId,
-        worktree: wt.path,
-        message: 'x',
-      });
-
-      const events: string[] = [];
-      manager.onEvent((e) => events.push(e.type));
-
-      manager.markChangesMerged([changeId]);
-      expect(events).toContain('change:merged');
-    });
-  });
-
-  describe('landing strategy registry', () => {
-    it('registers landing strategies', () => {
-      const mockStrategy = {
-        name: 'test-strategy',
-        async land() {
-          return { success: true };
-        },
-      };
-      manager.registerLandingStrategy(mockStrategy);
-      // Registration is internal; successful if no throw. Full integration
-      // covered in Phase 5.
-      expect(true).toBe(true);
-    });
-  });
-
-  describe('reconcileV3', () => {
-    it('returns a MacroReconcileResult with zero issues on a clean db', () => {
-      manager.createStreamV3({ name: 'a', ownerId: 'agent-1' });
-      const result = manager.reconcileV3();
-
-      expect(result).toBeDefined();
-      expect(result.errors.length).toBe(0);
-      // Fresh streams are in sync → no fixes needed
-      expect(result.worktreesOrphaned).toBe(0);
-    });
-  });
-});

package/src/workspace/__tests__/yaml-schema.test.ts

@@ -1,210 +0,0 @@
-/**
- * YAML schema validation tests (Phase 2).
- */
-
-import { describe, it, expect } from 'vitest';
-import {
-  parseTeamWorkspaceConfig,
-  extractWorkspaceConfig,
-  TeamWorkspaceConfigSchema,
-  RoleWorkspaceConfigSchema,
-} from '../yaml-schema.js';
-
-describe('YAML schema', () => {
-  describe('parseTeamWorkspaceConfig', () => {
-    it('returns null when input is undefined', () => {
-      expect(parseTeamWorkspaceConfig(undefined)).toBeNull();
-      expect(parseTeamWorkspaceConfig(null)).toBeNull();
-    });
-
-    it('accepts a minimal peer-swarm-style config', () => {
-      const config = parseTeamWorkspaceConfig({
-        roles: {
-          peer: {
-            workspace: 'new_stream',
-            stream_lineage: 'fork_from_team_root',
-            landing: 'merge_to_parent_stream',
-          },
-        },
-      });
-      expect(config).not.toBeNull();
-      expect(config!.on_team_complete).toBe('keep'); // default
-      expect(config!.roles.peer.workspace).toBe('new_stream');
-    });
-
-    it('applies defaults for default_stream', () => {
-      const config = parseTeamWorkspaceConfig({
-        default_stream: {},
-        roles: { x: { workspace: 'none' } },
-      });
-      expect(config!.default_stream?.fork_from).toBe('main');
-      expect(config!.default_stream?.change_id_tracking).toBe(true);
-    });
-
-    it('requires share_with when workspace is share_with_agent', () => {
-      expect(() =>
-        parseTeamWorkspaceConfig({
-          roles: {
-            reviewer: { workspace: 'share_with_agent' },
-          },
-        })
-      ).toThrow(/share_with is required/);
-    });
-
-    it('requires track_branch when stream_lineage is track_existing_branch', () => {
-      expect(() =>
-        parseTeamWorkspaceConfig({
-          roles: {
-            resolver: {
-              workspace: 'new_stream',
-              stream_lineage: 'track_existing_branch',
-            },
-          },
-        })
-      ).toThrow(/track_branch is required/);
-    });
-
-    it('requires stream_lineage when workspace is new_stream', () => {
-      expect(() =>
-        parseTeamWorkspaceConfig({
-          roles: {
-            x: { workspace: 'new_stream' },
-          },
-        })
-      ).toThrow(/stream_lineage is required/);
-    });
-
-    it('accepts triad shape with queue_to_branch + merge_queue.drain', () => {
-      const config = parseTeamWorkspaceConfig({
-        on_team_complete: 'keep',
-        roles: {
-          coordinator: { workspace: 'attach_to_team_root' },
-          worker: {
-            workspace: 'new_stream',
-            stream_lineage: 'fork_from_parent',
-            landing: 'queue_to_branch',
-            landing_config: { target: 'team_root' },
-            capabilities: ['workspace.commit', 'workspace.land'],
-          },
-          integrator: {
-            workspace: 'attach_to_team_root',
-            capabilities: ['workspace.merge', 'merge_queue.drain'],
-          },
-        },
-      });
-      expect(config).not.toBeNull();
-      expect(config!.roles.worker.landing).toBe('queue_to_branch');
-      expect(config!.roles.integrator.capabilities).toContain('merge_queue.drain');
-    });
-
-    it('accepts pipeline shape with share_with_agent', () => {
-      const config = parseTeamWorkspaceConfig({
-        roles: {
-          planner: { workspace: 'none' },
-          coder: {
-            workspace: 'new_stream',
-            stream_lineage: 'fork_from_team_root',
-            landing: 'queue_to_branch',
-          },
-          reviewer: {
-            workspace: 'share_with_agent',
-            share_with: 'coder',
-            capabilities: ['workspace.read'],
-          },
-        },
-      });
-      expect(config!.roles.reviewer.share_with).toBe('coder');
-    });
-
-    it('accepts long-lived feature config with cascade + auto-sync', () => {
-      const config = parseTeamWorkspaceConfig({
-        roles: {
-          feature_owner: {
-            workspace: 'new_stream',
-            stream_lineage: 'fork_from_team_root',
-            landing: 'merge_to_parent_stream',
-            cascade_on_parent_update: true,
-            on_parent_advanced: 'sync_with_parent',
-          },
-          subtask: {
-            workspace: 'new_stream',
-            stream_lineage: 'fork_from_parent',
-            landing: 'merge_to_parent_stream',
-          },
-        },
-      });
-      expect(config!.roles.feature_owner.cascade_on_parent_update).toBe(true);
-      expect(config!.roles.feature_owner.on_parent_advanced).toBe('sync_with_parent');
-    });
-
-    it('accepts conflict_recovery team defaults', () => {
-      const config = parseTeamWorkspaceConfig({
-        roles: { peer: { workspace: 'none' } },
-        conflict_recovery: {
-          default_strategy: 'spawn-resolver',
-          default_config: { role: 'resolver', timeout_ms: 1200000 },
-          max_recovery_depth: 5,
-        },
-      });
-      expect(config!.conflict_recovery?.default_strategy).toBe('spawn-resolver');
-      expect(config!.conflict_recovery?.max_recovery_depth).toBe(5);
-    });
-
-    it('rejects unknown workspace kinds', () => {
-      expect(() =>
-        parseTeamWorkspaceConfig({
-          roles: { x: { workspace: 'made-up' } },
-        })
-      ).toThrow();
-    });
-
-    it('rejects unknown landing strategy names', () => {
-      expect(() =>
-        parseTeamWorkspaceConfig({
-          roles: {
-            x: {
-              workspace: 'new_stream',
-              stream_lineage: 'fork_from_team_root',
-              landing: 'unknown-strategy',
-            },
-          },
-        })
-      ).toThrow();
-    });
-  });
-
-  describe('extractWorkspaceConfig', () => {
-    it('extracts workspace block from a manifest with macro_agent.workspace', () => {
-      const manifest = {
-        macro_agent: {
-          workspace: {
-            roles: { x: { workspace: 'none' } },
-          },
-        },
-      };
-      const config = extractWorkspaceConfig(manifest);
-      expect(config).not.toBeNull();
-    });
-
-    it('returns null when macro_agent.workspace is absent', () => {
-      const manifest = { macro_agent: { integration: { strategy: 'trunk' } } };
-      expect(extractWorkspaceConfig(manifest)).toBeNull();
-    });
-
-    it('returns null when macro_agent is absent', () => {
-      expect(extractWorkspaceConfig({})).toBeNull();
-    });
-  });
-
-  describe('schema shape', () => {
-    it('TeamWorkspaceConfigSchema is a zod object', () => {
-      expect(TeamWorkspaceConfigSchema).toBeDefined();
-      expect(typeof TeamWorkspaceConfigSchema.safeParse).toBe('function');
-    });
-
-    it('RoleWorkspaceConfigSchema is a zod schema', () => {
-      expect(RoleWorkspaceConfigSchema).toBeDefined();
-      expect(typeof RoleWorkspaceConfigSchema.safeParse).toBe('function');
-    });
-  });
-});

package/src/workspace/config.ts

@@ -1,165 +0,0 @@
-/**
- * Workspace Configuration Types
- *
- * Configuration for git-cascade integration and workspace management.
- *
- * @module workspace/config
- */
-
-import type Database from 'better-sqlite3';
-
-/**
- * Configuration for git-cascade integration
- */
-export interface GitCascadeConfig {
-  /**
-   * Whether the git-cascade adapter is enabled.
-   * When disabled, workspace operations are no-ops.
-   */
-  enabled: boolean;
-
-  /**
-   * Path to the git repository.
-   * Defaults to current working directory.
-   */
-  repoPath?: string;
-
-  /**
-   * Table prefix for git-cascade tables in shared SQLite database.
-   * Defaults to 'git_cascade_'.
-   */
-  tablePrefix?: string;
-
-  /**
-   * Path to SQLite database file.
-   * If not provided and db is not provided, creates database at
-   * `<repoPath>/.git-cascade/tracker.db`.
-   */
-  dbPath?: string;
-
-  /**
-   * Existing database connection to share.
-   * If provided, the adapter will use this connection instead of creating its own.
-   * The caller is responsible for closing this connection.
-   */
-  db?: Database.Database;
-
-  /**
-   * Enable verbose logging for debugging.
-   */
-  verbose?: boolean;
-
-  /**
-   * Skip recovery process on startup.
-   * Useful for testing or when recovery is handled externally.
-   */
-  skipRecovery?: boolean;
-}
-
-/**
- * Default git-cascade configuration
- */
-export const DEFAULT_GIT_CASCADE_CONFIG: Partial<GitCascadeConfig> = {
-  enabled: true,
-  tablePrefix: 'git_cascade_',
-  verbose: false,
-  skipRecovery: false,
-};
-
-/**
- * Workspace directory configuration
- */
-export interface WorkspaceDirectoryConfig {
-  /**
-   * Base directory for worktrees.
-   * Defaults to `<repoPath>/.worktrees`.
-   */
-  worktreeDir?: string;
-
-  /**
-   * Maximum number of concurrent worktrees.
-   * Defaults to 50.
-   */
-  maxWorktrees?: number;
-
-  /**
-   * Use themed names for worktree directories.
-   * If false, uses numeric slots (worker-01, worker-02, etc.).
-   */
-  useThemedNames?: boolean;
-
-  /**
-   * Custom themed names for worktree directories.
-   * Only used if useThemedNames is true.
-   */
-  themedNames?: string[];
-}
-
-/**
- * Strategy for handling allocation when pool is exhausted.
- *
- * - `reject`: Immediately reject the request (default)
- * - `queue`: Wait for a worktree to become available
- * - `steal`: Forcibly take a worktree from another agent
- */
-export type AllocationStrategy = 'reject' | 'queue' | 'steal';
-
-/**
- * Configuration for the shared worktree pool.
- */
-export interface WorktreePoolConfig {
-  /**
-   * Whether to use the shared worktree pool.
-   * When enabled, worktrees are managed by the pool and reused.
-   * Defaults to false for backward compatibility.
-   */
-  enabled: boolean;
-
-  /**
-   * Maximum number of worktrees in the pool.
-   * Defaults to 50.
-   */
-  maxSize?: number;
-
-  /**
-   * Default strategy when pool is exhausted.
-   * Defaults to 'reject'.
-   */
-  defaultStrategy?: AllocationStrategy;
-
-  /**
-   * Whether to recover orphaned worktrees on startup.
-   * Defaults to true.
-   */
-  recoverOrphans?: boolean;
-
-  /**
-   * Use themed names for pool slots.
-   * Defaults to false.
-   */
-  useThemedNames?: boolean;
-
-  /**
-   * Custom themed names for pool slots.
-   */
-  themedNames?: string[];
-}
-
-/**
- * Default worktree pool configuration.
- */
-export const DEFAULT_POOL_CONFIG: WorktreePoolConfig = {
-  enabled: false,
-  maxSize: 50,
-  defaultStrategy: 'reject',
-  recoverOrphans: true,
-  useThemedNames: false,
-};
-
-/**
- * Default workspace directory configuration
- */
-export const DEFAULT_WORKSPACE_DIR_CONFIG: WorkspaceDirectoryConfig = {
-  maxWorktrees: 50,
-  useThemedNames: false,
-};