macro-agent 0.2.5 → 0.2.6

package/src/workspace/recovery/__tests__/auto-resolve-integration.test.ts

@@ -1,127 +0,0 @@
-/**
- * AutoResolveStrategy integration tests.
- *
- * Creates a real merge conflict in a temp git repo and verifies the strategy
- * replays the merge with `ours`/`theirs` and commits the resolution.
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { execSync } from 'child_process';
-import { AutoResolveStrategy } from '../auto-resolve.js';
-import type { WorkspaceManager } from '../../types.js';
-import type { ConflictContext } from '../types.js';
-
-function mockWorkspaceManager(): WorkspaceManager {
-  return {
-    resolveConflict: vi.fn(),
-  } as unknown as WorkspaceManager;
-}
-
-function sh(cmd: string, cwd: string): string {
-  return execSync(cmd, { cwd, stdio: ['pipe', 'pipe', 'pipe'], encoding: 'utf-8' }).trim();
-}
-
-describe('AutoResolveStrategy (real git)', () => {
-  let tempDir: string;
-  let repoPath: string;
-
-  beforeEach(() => {
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'auto-resolve-'));
-    repoPath = path.join(tempDir, 'repo');
-    fs.mkdirSync(repoPath);
-
-    sh('git init -b main', repoPath);
-    sh('git config user.email "t@t.com"', repoPath);
-    sh('git config user.name "T"', repoPath);
-
-    // Base commit
-    fs.writeFileSync(path.join(repoPath, 'f.txt'), 'base\n');
-    sh('git add .', repoPath);
-    sh('git commit -m "base"', repoPath);
-
-    // Branch A (main) with change
-    fs.writeFileSync(path.join(repoPath, 'f.txt'), 'main-change\n');
-    sh('git add .', repoPath);
-    sh('git commit -m "main change"', repoPath);
-
-    // Branch B with conflicting change
-    sh('git checkout -b feature HEAD~1', repoPath);
-    fs.writeFileSync(path.join(repoPath, 'f.txt'), 'feature-change\n');
-    sh('git add .', repoPath);
-    sh('git commit -m "feature change"', repoPath);
-
-    // Checkout main + attempt merge (conflicts)
-    sh('git checkout main', repoPath);
-    try {
-      sh('git merge feature --no-edit', repoPath);
-    } catch {
-      // Expected — creates the conflict state
-    }
-    // Abort so AutoResolve starts from a clean state; it will re-trigger
-    // the merge via `git merge -X <strategy>`.
-    sh('git merge --abort', repoPath);
-  });
-
-  afterEach(() => {
-    if (fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  it('resolves with -X ours — keeps main-change', async () => {
-    const strat = new AutoResolveStrategy();
-    const ws = mockWorkspaceManager();
-
-    const ctx: ConflictContext = {
-      conflictId: 'c-test',
-      streamId: 's-1',
-      paths: ['f.txt'],
-      operation: 'merge',
-      worktree: repoPath,
-      sourceCommit: 'feature',
-      recoveryDepth: 0,
-      strategyConfig: { strategy: 'ours' },
-      workspaceManager: ws,
-    };
-
-    const result = await strat.recover(ctx);
-
-    expect(result.kind).toBe('resolved');
-    if (result.kind === 'resolved') {
-      expect(result.resolutionCommit).toMatch(/^[0-9a-f]+$/);
-    }
-
-    // Verify file has the 'ours' version
-    expect(fs.readFileSync(path.join(repoPath, 'f.txt'), 'utf-8')).toBe('main-change\n');
-
-    // WorkspaceManager.resolveConflict was notified
-    expect(ws.resolveConflict).toHaveBeenCalledWith(
-      expect.objectContaining({ conflictId: 'c-test' })
-    );
-  });
-
-  it('resolves with -X theirs — keeps feature-change', async () => {
-    const strat = new AutoResolveStrategy();
-    const ws = mockWorkspaceManager();
-
-    const ctx: ConflictContext = {
-      conflictId: 'c-test',
-      streamId: 's-1',
-      paths: ['f.txt'],
-      operation: 'merge',
-      worktree: repoPath,
-      sourceCommit: 'feature',
-      recoveryDepth: 0,
-      strategyConfig: { strategy: 'theirs' },
-      workspaceManager: ws,
-    };
-
-    const result = await strat.recover(ctx);
-
-    expect(result.kind).toBe('resolved');
-    expect(fs.readFileSync(path.join(repoPath, 'f.txt'), 'utf-8')).toBe('feature-change\n');
-  });
-});

package/src/workspace/recovery/__tests__/spawn-resolver.test.ts

@@ -1,139 +0,0 @@
-/**
- * SpawnResolverStrategy tests (Phase 7b).
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import {
-  SpawnResolverStrategy,
-  createSpawnResolverStrategy,
-} from '../spawn-resolver.js';
-import type { ConflictContext } from '../types.js';
-import type { WorkspaceManager } from '../../types.js';
-import type { AgentManager } from '../../../agent/agent-manager.js';
-
-type EventListener = (event: { type: string; data: Record<string, unknown> }) => void;
-
-function mockManagers(): {
-  ws: WorkspaceManager;
-  am: AgentManager;
-  triggerResolved: (conflictId: string, commit: string) => void;
-} {
-  const listeners = new Set<EventListener>();
-
-  const ws = {
-    onEvent: vi.fn((cb: EventListener) => {
-      listeners.add(cb);
-      return () => listeners.delete(cb);
-    }),
-  } as unknown as WorkspaceManager;
-
-  const am = {
-    spawn: vi.fn().mockResolvedValue({ id: 'resolver-agent-1' }),
-  } as unknown as AgentManager;
-
-  const triggerResolved = (conflictId: string, commit: string) => {
-    for (const listener of listeners) {
-      listener({
-        type: 'conflict:resolved',
-        data: { conflictId, resolutionCommit: commit },
-      });
-    }
-  };
-
-  return { ws, am, triggerResolved };
-}
-
-function mockContext(ws: WorkspaceManager, overrides: Partial<ConflictContext> = {}): ConflictContext {
-  return {
-    conflictId: 'c-1',
-    streamId: 'stream-1',
-    paths: ['a.ts'],
-    operation: 'merge',
-    recoveryDepth: 0,
-    workspaceManager: ws,
-    ...overrides,
-  };
-}
-
-describe('SpawnResolverStrategy', () => {
-  it('spawns a resolver with the configured role and awaits resolve', async () => {
-    const { ws, am, triggerResolved } = mockManagers();
-    const strat = createSpawnResolverStrategy({ agentManager: am });
-
-    const ctx = mockContext(ws, {
-      strategyConfig: { role: 'resolver', timeout_ms: 5000 },
-    });
-
-    const recoveryPromise = strat.recover(ctx);
-
-    // Allow spawn + onEvent registration to complete
-    await new Promise((r) => setTimeout(r, 10));
-
-    expect(am.spawn).toHaveBeenCalledWith(
-      expect.objectContaining({
-        role: 'resolver',
-        capabilities: expect.arrayContaining(['workspace.resolve']),
-      })
-    );
-
-    // Simulate resolver agent calling resolve_conflict
-    triggerResolved('c-1', 'abc123');
-
-    const resolution = await recoveryPromise;
-    expect(resolution.kind).toBe('resolved');
-    if (resolution.kind === 'resolved') {
-      expect(resolution.resolutionCommit).toBe('abc123');
-    }
-  });
-
-  it('escalates on timeout', async () => {
-    const { ws, am } = mockManagers();
-    const strat = createSpawnResolverStrategy({
-      agentManager: am,
-      defaultTimeoutMs: 50, // short timeout for test
-    });
-
-    const ctx = mockContext(ws);
-    const resolution = await strat.recover(ctx);
-
-    expect(resolution.kind).toBe('escalated');
-    if (resolution.kind === 'escalated') {
-      expect(resolution.escalatedTo).toBe('human');
-    }
-  });
-
-  it('returns retry-after when max_concurrent exceeded', async () => {
-    const { ws, am, triggerResolved } = mockManagers();
-    const strat = createSpawnResolverStrategy({
-      agentManager: am,
-      defaultMaxConcurrent: 1,
-      defaultTimeoutMs: 5000,
-    });
-
-    // First resolver is still pending
-    const first = strat.recover(mockContext(ws));
-    await new Promise((r) => setTimeout(r, 10));
-
-    // Second try — exceeds max
-    const second = await strat.recover(mockContext(ws));
-    expect(second.kind).toBe('retry-after');
-
-    // Resolve the first so it cleans up
-    triggerResolved('c-1', 'commit');
-    await first;
-  });
-
-  it('returns failed when spawn itself fails', async () => {
-    const { ws } = mockManagers();
-    const am = {
-      spawn: vi.fn().mockRejectedValue(new Error('spawn boom')),
-    } as unknown as AgentManager;
-    const strat = new SpawnResolverStrategy({ agentManager: am });
-
-    const resolution = await strat.recover(mockContext(ws));
-    expect(resolution.kind).toBe('failed');
-    if (resolution.kind === 'failed') {
-      expect(resolution.error).toMatch(/spawn boom/);
-    }
-  });
-});

package/src/workspace/recovery/__tests__/strategies.test.ts

@@ -1,145 +0,0 @@
-/**
- * Conflict recovery strategy tests (Phase 7).
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import {
-  DeferStrategy,
-  AbandonStrategy,
-  EscalateStrategy,
-  AutoResolveStrategy,
-  buildBuiltinRecoveryRegistry,
-} from '../index.js';
-import type { ConflictContext } from '../types.js';
-import type { WorkspaceManager } from '../../types.js';
-
-function mockContext(overrides: Partial<ConflictContext> = {}): ConflictContext {
-  const ws = {
-    abandonStream: vi.fn(),
-    pauseStream: vi.fn(),
-  } as unknown as WorkspaceManager;
-  return {
-    conflictId: 'c-1',
-    streamId: 'stream-1',
-    paths: ['a.ts'],
-    operation: 'merge',
-    recoveryDepth: 0,
-    workspaceManager: ws,
-    ...overrides,
-  };
-}
-
-describe('conflict recovery strategies', () => {
-  describe('DeferStrategy', () => {
-    it('returns { kind: deferred }', async () => {
-      const strat = new DeferStrategy();
-      const res = await strat.recover(mockContext());
-      expect(res.kind).toBe('deferred');
-    });
-  });
-
-  describe('AbandonStrategy', () => {
-    it('abandons the stream and returns { kind: abandoned }', async () => {
-      const strat = new AbandonStrategy();
-      const ctx = mockContext();
-      const res = await strat.recover(ctx);
-      expect(res.kind).toBe('abandoned');
-      expect(ctx.workspaceManager.abandonStream).toHaveBeenCalledWith(
-        'stream-1',
-        expect.objectContaining({ reason: expect.stringContaining('c-1') })
-      );
-    });
-
-    it('returns { kind: failed } on abandon error', async () => {
-      const strat = new AbandonStrategy();
-      const ctx = mockContext();
-      (ctx.workspaceManager.abandonStream as any) = vi.fn(() => {
-        throw new Error('boom');
-      });
-      const res = await strat.recover(ctx);
-      expect(res.kind).toBe('failed');
-      if (res.kind === 'failed') {
-        expect(res.error).toContain('boom');
-      }
-    });
-  });
-
-  describe('EscalateStrategy', () => {
-    it('pauses the stream and returns { kind: escalated }', async () => {
-      const strat = new EscalateStrategy();
-      const ctx = mockContext();
-      const res = await strat.recover(ctx);
-      expect(res.kind).toBe('escalated');
-      expect(ctx.workspaceManager.pauseStream).toHaveBeenCalledWith(
-        'stream-1',
-        expect.any(String)
-      );
-    });
-
-    it('uses notify config when provided', async () => {
-      const strat = new EscalateStrategy();
-      const ctx = mockContext({
-        strategyConfig: { notify: 'team:alpha' },
-      });
-      const res = await strat.recover(ctx);
-      expect(res.kind).toBe('escalated');
-      if (res.kind === 'escalated') {
-        expect(res.escalatedTo).toBe('team:alpha');
-      }
-    });
-  });
-
-  describe('AutoResolveStrategy', () => {
-    it('canHandle requires merge operation + worktree', () => {
-      const strat = new AutoResolveStrategy();
-      expect(
-        strat.canHandle!(mockContext({ operation: 'merge', worktree: '/tmp/wt' }))
-      ).toBe(true);
-      expect(strat.canHandle!(mockContext({ operation: 'merge' }))).toBe(false);
-      expect(
-        strat.canHandle!(mockContext({ operation: 'rebase', worktree: '/tmp/wt' }))
-      ).toBe(false);
-    });
-
-    it('returns failed for non-merge operations', async () => {
-      const strat = new AutoResolveStrategy();
-      const res = await strat.recover(mockContext({ operation: 'rebase' }));
-      expect(res.kind).toBe('failed');
-    });
-
-    it('returns failed without worktree', async () => {
-      const strat = new AutoResolveStrategy();
-      const res = await strat.recover(mockContext({ operation: 'merge' }));
-      expect(res.kind).toBe('failed');
-      if (res.kind === 'failed') {
-        expect(res.error).toMatch(/worktree/);
-      }
-    });
-
-    it('rejects unsupported strategies', async () => {
-      const strat = new AutoResolveStrategy();
-      const res = await strat.recover(
-        mockContext({
-          operation: 'merge',
-          worktree: '/tmp/wt',
-          strategyConfig: { strategy: 'bogus' },
-        })
-      );
-      expect(res.kind).toBe('failed');
-      if (res.kind === 'failed') {
-        expect(res.error).toMatch(/unsupported strategy/);
-      }
-    });
-  });
-
-  describe('buildBuiltinRecoveryRegistry', () => {
-    it('includes 4 built-in strategies', () => {
-      const registry = buildBuiltinRecoveryRegistry();
-      expect(registry.has('defer')).toBe(true);
-      expect(registry.has('abandon')).toBe(true);
-      expect(registry.has('escalate')).toBe(true);
-      expect(registry.has('auto-resolve')).toBe(true);
-      expect(registry.has('spawn-resolver')).toBe(false); // Phase 7b
-    });
-  });
-});

package/src/workspace/recovery/abandon.ts

@@ -1,51 +0,0 @@
-/**
- * `abandon` conflict recovery strategy.
- *
- * Abandons the conflicted stream. Throwaway-exploration teams; CI-driven
- * flows where broken work is discarded rather than resolved.
- *
- * @module workspace/recovery/abandon
- */
-
-import type {
-  ConflictContext,
-  ConflictRecoveryStrategy,
-  ConflictResolution,
-} from './types.js';
-
-export class AbandonStrategy implements ConflictRecoveryStrategy {
-  readonly name = 'abandon';
-  readonly mode = 'sync' as const;
-
-  async recover(ctx: ConflictContext): Promise<ConflictResolution> {
-    try {
-      // Mark the conflict resolved (method='abandoned') so the OpenHive hub
-      // moves cascade_conflicts.status from pending → resolved instead of
-      // showing it stuck pending forever.
-      try {
-        ctx.workspaceManager.resolveConflict({
-          conflictId: ctx.conflictId,
-          resolvedBy: 'system:abandon',
-          method: 'abandoned',
-          summary: `stream abandoned: ${ctx.streamId}`,
-        });
-      } catch {
-        // Non-fatal — abandonStream below still runs
-      }
-
-      ctx.workspaceManager.abandonStream(ctx.streamId, {
-        reason: `abandon strategy: conflict ${ctx.conflictId}`,
-      });
-      return {
-        kind: 'abandoned',
-        streamId: ctx.streamId,
-        reason: `conflict ${ctx.conflictId}`,
-      };
-    } catch (err) {
-      return {
-        kind: 'failed',
-        error: err instanceof Error ? err.message : String(err),
-      };
-    }
-  }
-}

package/src/workspace/recovery/auto-resolve.ts

@@ -1,119 +0,0 @@
-/**
- * `auto-resolve` conflict recovery strategy.
- *
- * Replays the failed merge in the agent's worktree with a git strategy
- * option (`-X ours` / `-X theirs` / `-s union` via `-X`), commits the
- * resolution, and returns the resulting commit hash.
- *
- * Strategy config:
- * - `strategy`: 'ours' | 'theirs' | 'union' (default: 'ours')
- * - `commit_message`: string (default: `resolve: ${conflictId} via <strategy>`)
- *
- * Scope limits:
- * - Only handles `operation: 'merge'`. Rebase conflicts need different tooling.
- * - Requires `ctx.worktree` to be set. If absent, returns `failed`.
- * - Requires `ctx.sourceCommit` to identify what to replay. If absent,
- *   tries `HEAD^2` (the merge commit's incoming side).
- *
- * @module workspace/recovery/auto-resolve
- */
-
-import { execSync } from 'child_process';
-import type {
-  ConflictContext,
-  ConflictRecoveryStrategy,
-  ConflictResolution,
-} from './types.js';
-
-export class AutoResolveStrategy implements ConflictRecoveryStrategy {
-  readonly name = 'auto-resolve';
-  readonly mode = 'sync' as const;
-
-  canHandle(ctx: ConflictContext): boolean {
-    return ctx.operation === 'merge' && !!ctx.worktree;
-  }
-
-  async recover(ctx: ConflictContext): Promise<ConflictResolution> {
-    if (ctx.operation !== 'merge') {
-      return {
-        kind: 'failed',
-        error: `auto-resolve only handles merge conflicts, not ${ctx.operation}`,
-      };
-    }
-
-    if (!ctx.worktree) {
-      return {
-        kind: 'failed',
-        error: 'auto-resolve requires ctx.worktree',
-      };
-    }
-
-    const strategy = (ctx.strategyConfig?.strategy as string | undefined) ?? 'ours';
-    if (strategy !== 'ours' && strategy !== 'theirs' && strategy !== 'union') {
-      return {
-        kind: 'failed',
-        error: `auto-resolve: unsupported strategy "${strategy}" (use ours | theirs | union)`,
-      };
-    }
-
-    const sourceRef = ctx.sourceCommit ?? 'MERGE_HEAD';
-    const commitMessage =
-      (ctx.strategyConfig?.commit_message as string | undefined) ??
-      `resolve: ${ctx.conflictId} via ${strategy}`;
-
-    try {
-      // Abort any in-progress merge state first (safety — merge may have
-      // left the index in a partial state)
-      try {
-        execSync('git merge --abort', {
-          cwd: ctx.worktree,
-          stdio: 'pipe',
-        });
-      } catch {
-        // No merge in progress — that's fine
-      }
-
-      // Replay the merge with the chosen strategy
-      execSync(
-        `git merge -X ${strategy} --no-edit -m ${quote(commitMessage)} ${quote(sourceRef)}`,
-        {
-          cwd: ctx.worktree,
-          stdio: 'pipe',
-        }
-      );
-
-      // Capture the new HEAD as the resolution commit
-      const resolutionCommit = execSync('git rev-parse HEAD', {
-        cwd: ctx.worktree,
-        encoding: 'utf-8',
-      }).trim();
-
-      // Notify the WorkspaceManager so downstream consumers see the resolution
-      try {
-        ctx.workspaceManager.resolveConflict({
-          conflictId: ctx.conflictId,
-          resolvedBy: ctx.landingAgentId ?? 'system:auto-resolve',
-          resolutionCommit,
-          method: 'auto-resolve',
-          summary: `merged with -X ${strategy}`,
-        });
-      } catch {
-        // Non-fatal — resolution is recorded via return value regardless
-      }
-
-      return { kind: 'resolved', resolutionCommit };
-    } catch (err) {
-      return {
-        kind: 'failed',
-        error: `auto-resolve (strategy=${strategy}): ${
-          err instanceof Error ? err.message : String(err)
-        }`,
-      };
-    }
-  }
-}
-
-/** Minimal shell-safe single-quoting for commit messages / refs. */
-function quote(s: string): string {
-  return `'${s.replace(/'/g, "'\\''")}'`;
-}

package/src/workspace/recovery/defer.ts

@@ -1,23 +0,0 @@
-/**
- * `defer` conflict recovery strategy — no-op.
- *
- * Leaves the conflict record in place; stream stays `conflicted`. Something
- * else (human, external process, scheduled recovery) resolves later.
- *
- * @module workspace/recovery/defer
- */
-
-import type {
-  ConflictContext,
-  ConflictRecoveryStrategy,
-  ConflictResolution,
-} from './types.js';
-
-export class DeferStrategy implements ConflictRecoveryStrategy {
-  readonly name = 'defer';
-  readonly mode = 'sync' as const;
-
-  async recover(_ctx: ConflictContext): Promise<ConflictResolution> {
-    return { kind: 'deferred', reason: 'no recovery strategy configured' };
-  }
-}

package/src/workspace/recovery/escalate.ts

@@ -1,30 +0,0 @@
-/**
- * `escalate` conflict recovery strategy — human-in-the-loop.
- *
- * Pauses the stream and emits an escalation marker. External systems (UI,
- * on-call agent, operator) resolve the conflict manually, then call
- * `resolve_conflict` MCP tool to unblock.
- *
- * @module workspace/recovery/escalate
- */
-
-import type {
-  ConflictContext,
-  ConflictRecoveryStrategy,
-  ConflictResolution,
-} from './types.js';
-
-export class EscalateStrategy implements ConflictRecoveryStrategy {
-  readonly name = 'escalate';
-  readonly mode = 'async' as const;
-
-  async recover(ctx: ConflictContext): Promise<ConflictResolution> {
-    try {
-      ctx.workspaceManager.pauseStream(ctx.streamId, 'awaiting human resolution');
-    } catch {
-      // Non-fatal — stream may already be in a paused/conflicted state
-    }
-    const target = (ctx.strategyConfig?.notify as string | undefined) ?? 'human';
-    return { kind: 'escalated', escalatedTo: target as 'human' };
-  }
-}

package/src/workspace/recovery/index.ts

@@ -1,58 +0,0 @@
-/**
- * Conflict recovery strategies.
- *
- * Register via `WorkspaceManager.registerConflictRecoveryStrategy` (Phase 7b).
- * Selected via per-role YAML `on_conflict_recovery` or team default.
- *
- * Built-ins:
- * - `defer`        — no-op; leave conflict record for external resolution
- * - `abandon`      — abandon the conflicted stream
- * - `escalate`     — pause stream; notify human
- * - `auto-resolve` — git strategies (ours/theirs/union) — scaffold only
- * - `spawn-resolver` — LLM resolver agent (Phase 7b; requires AgentManager)
- *
- * @module workspace/recovery
- * @see docs/conflict-recovery.md
- */
-
-export type {
-  ConflictContext,
-  ConflictRecoveryStrategy,
-  ConflictResolution,
-  ConflictResolutionMode,
-} from './types.js';
-
-export { DeferStrategy } from './defer.js';
-export { AbandonStrategy } from './abandon.js';
-export { EscalateStrategy } from './escalate.js';
-export { AutoResolveStrategy } from './auto-resolve.js';
-export {
-  SpawnResolverStrategy,
-  createSpawnResolverStrategy,
-  type SpawnResolverStrategyOptions,
-} from './spawn-resolver.js';
-
-import { DeferStrategy } from './defer.js';
-import { AbandonStrategy } from './abandon.js';
-import { EscalateStrategy } from './escalate.js';
-import { AutoResolveStrategy } from './auto-resolve.js';
-import type { ConflictRecoveryStrategy } from './types.js';
-
-/**
- * Build a registry of built-in conflict recovery strategies.
- *
- * Returns a Map keyed by strategy name. Callers plug this into their dispatch
- * layer (Phase 7b). `spawn-resolver` is not included — it requires
- * AgentManager injection and is added by the consumer.
- */
-export function buildBuiltinRecoveryRegistry(): Map<string, ConflictRecoveryStrategy> {
-  const map = new Map<string, ConflictRecoveryStrategy>();
-  const strategies: ConflictRecoveryStrategy[] = [
-    new DeferStrategy(),
-    new AbandonStrategy(),
-    new EscalateStrategy(),
-    new AutoResolveStrategy(),
-  ];
-  for (const s of strategies) map.set(s.name, s);
-  return map;
-}