macro-agent 0.1.7 → 0.1.10

package/src/workspace/__tests__/standalone-mode.test.ts

@@ -0,0 +1,118 @@
+/**
+ * Standalone-mode regression test (G11).
+ *
+ * Asserts that GitCascadeAdapter (and the cascade event flow it drives)
+ * works correctly when no MAP sidecar / cascade bridge is configured —
+ * i.e., macro-agent runs without an OpenHive hub.
+ *
+ * The contract: cascade emits its own structured event stream regardless,
+ * and operations succeed without any hub roundtrip. If a future change
+ * accidentally introduces a hard dependency on the bridge or sidecar
+ * (e.g., awaiting a hub call inside cascade), this test catches it.
+ */
+
+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 { GitCascadeAdapter } from "../git-cascade-adapter.js";
+import type { GitCascadeEvent } from "../git-cascade-adapter.js";
+
+function mkTempRepo(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "macro-standalone-"));
+  execSync("git init", { cwd: dir, stdio: "pipe" });
+  execSync('git config user.email "test@test.com"', { cwd: dir, stdio: "pipe" });
+  execSync('git config user.name "Test"', { cwd: dir, stdio: "pipe" });
+  fs.writeFileSync(path.join(dir, ".gitignore"), ".git-cascade/\n");
+  fs.writeFileSync(path.join(dir, "README.md"), "# test\n");
+  execSync("git add .", { cwd: dir, stdio: "pipe" });
+  execSync('git commit -m "init"', { cwd: dir, stdio: "pipe" });
+  fs.mkdirSync(path.join(dir, ".git-cascade"), { recursive: true });
+  return dir;
+}
+
+describe("standalone mode: GitCascadeAdapter without sidecar/bridge", () => {
+  let repoPath: string;
+  let adapter: GitCascadeAdapter;
+
+  beforeEach(() => {
+    repoPath = mkTempRepo();
+    // Construct the adapter with no MAP sidecar — same shape as boot-v2 when
+    // `config.map?.enabled !== true`. No CascadeBridge is ever wired.
+    adapter = new GitCascadeAdapter({ repoPath });
+  });
+
+  afterEach(() => {
+    fs.rmSync(repoPath, { recursive: true, force: true });
+  });
+
+  it("runs full stream lifecycle without errors and produces local events", () => {
+    const events: GitCascadeEvent[] = [];
+    adapter.onEvent((e) => events.push(e));
+
+    // Open a stream
+    const streamId = adapter.createStream({
+      name: "standalone-feat",
+      agentId: "a1",
+    });
+    expect(streamId).toBeTruthy();
+
+    // Create worktree + commit through tracker
+    const wt = path.join(repoPath, ".worktrees", "a1");
+    adapter.createWorktree({
+      agentId: "a1",
+      path: wt,
+      branch: `stream/${streamId}`,
+    });
+    fs.writeFileSync(path.join(wt, "x.txt"), "hi\n");
+    execSync("git add .", { cwd: wt, stdio: "pipe" });
+    const result = adapter.commitChanges({
+      streamId,
+      agentId: "a1",
+      worktree: wt,
+      message: "feat: add x",
+      metadata: { task_ref: { resource_id: "r", node_id: "n" } },
+    });
+    expect(result.commit).toBeTruthy();
+    expect(result.changeId).toBeTruthy();
+
+    // Abandon
+    adapter.abandonStream(streamId, { reason: "test" });
+
+    // Verify expected events fired locally (no hub involved)
+    const types = events.map((e) => e.type);
+    expect(types).toContain("stream:created");
+    expect(types).toContain("stream:committed");
+    expect(types).toContain("stream:abandoned");
+  });
+
+  it("does not throw when no event listener is attached", () => {
+    // No onEvent subscribers — adapter must not assume any.
+    const streamId = adapter.createStream({ name: "lonely", agentId: "a" });
+    expect(streamId).toBeTruthy();
+    adapter.abandonStream(streamId, { reason: "test" });
+  });
+
+  it("preserves Change-Id even with no hub forwarding", () => {
+    // Confirms the tracker's emit hook works locally even when nothing
+    // forwards events — the Change-Id is computed by git-cascade itself, not
+    // by the bridge.
+    const streamId = adapter.createStream({ name: "chgid", agentId: "a" });
+    const wt = path.join(repoPath, ".worktrees", "a");
+    adapter.createWorktree({
+      agentId: "a",
+      path: wt,
+      branch: `stream/${streamId}`,
+    });
+    fs.writeFileSync(path.join(wt, "y.txt"), "y\n");
+    execSync("git add .", { cwd: wt, stdio: "pipe" });
+    const { changeId } = adapter.commitChanges({
+      streamId,
+      agentId: "a",
+      worktree: wt,
+      message: "test",
+    });
+    expect(changeId).toMatch(/^c-/);
+  });
+});

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

@@ -0,0 +1,245 @@
+/**
+ * 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

@@ -0,0 +1,210 @@
+/**
+ * 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,7 +1,7 @@
 /**
  * Workspace Configuration Types
  *
- * Configuration for dataplane integration and workspace management.
+ * Configuration for git-cascade integration and workspace management.
  *
  * @module workspace/config
  */
@@ -9,11 +9,11 @@
 import type Database from 'better-sqlite3';
 
 /**
- * Configuration for dataplane integration
+ * Configuration for git-cascade integration
  */
-export interface DataplaneConfig {
+export interface GitCascadeConfig {
   /**
-   * Whether dataplane is enabled.
+   * Whether the git-cascade adapter is enabled.
    * When disabled, workspace operations are no-ops.
    */
   enabled: boolean;
@@ -25,21 +25,21 @@ export interface DataplaneConfig {
   repoPath?: string;
 
   /**
-   * Table prefix for dataplane tables in shared SQLite database.
-   * Defaults to 'dataplane_'.
+   * 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>/.dataplane/tracker.db`.
+   * `<repoPath>/.git-cascade/tracker.db`.
    */
   dbPath?: string;
 
   /**
    * Existing database connection to share.
-   * If provided, dataplane will use this connection instead of creating its own.
+   * If provided, the adapter will use this connection instead of creating its own.
    * The caller is responsible for closing this connection.
    */
   db?: Database.Database;
@@ -57,11 +57,11 @@ export interface DataplaneConfig {
 }
 
 /**
- * Default dataplane configuration
+ * Default git-cascade configuration
  */
-export const DEFAULT_DATAPLANE_CONFIG: Partial<DataplaneConfig> = {
+export const DEFAULT_GIT_CASCADE_CONFIG: Partial<GitCascadeConfig> = {
   enabled: true,
-  tablePrefix: 'dataplane_',
+  tablePrefix: 'git_cascade_',
   verbose: false,
   skipRecovery: false,
 };