macro-agent 0.2.5 → 0.2.6

package/src/map/cascade-diff-server.ts

@@ -1,404 +0,0 @@
-/**
- * Cascade Diff Server — services `cascade/diff.request` notifications.
- *
- * The OpenHive hub fetches unified diffs from this runtime on demand. Flow:
- *
- *   1. Hub sends `cascade/diff.request` with `request_id`, `stream_id`,
- *      `head`, optional `base` / `file_paths` / `files_only`.
- *   2. This handler resolves a worktree path from the stream id (falling
- *      back to the bare repo when no live worktree is checked out on the
- *      stream), shells out to `git show` or `git diff`, and produces a
- *      unified diff blob (or a name-only list when `files_only: true`).
- *   3. Response is emitted as a `cascade/diff.response` notification —
- *      inline when ≤ 512 KB, streamed via N `cascade/diff.chunk`
- *      notifications when larger.
- *
- * The 50 MB raw cap (`MAX_DIFF_BYTES`) defends against runaway monorepo
- * diffs. Errors fold into the same `cascade/diff.response` method via the
- * `error` shape (mirrors trajectory/content.response).
- *
- * @module map/cascade-diff-server
- */
-
-import { spawn } from 'child_process';
-import { createHash, randomBytes } from 'crypto';
-import { existsSync } from 'fs';
-import type { GitCascadeAdapter } from '../workspace/git-cascade-adapter.js';
-
-const REQUEST_METHOD = 'cascade/diff.request';
-const RESPONSE_METHOD = 'cascade/diff.response';
-const CHUNK_METHOD = 'cascade/diff.chunk';
-
-const INLINE_THRESHOLD_BYTES = 512 * 1024;
-const CHUNK_SIZE_BYTES = 1024 * 1024;
-const MAX_DIFF_BYTES = 50 * 1024 * 1024;
-const GIT_TIMEOUT_MS = 30_000;
-
-export interface CascadeDiffServerConnection {
-  onNotification(
-    method: string,
-    handler: (params: unknown) => void | Promise<void>,
-  ): void;
-  offNotification(
-    method: string,
-    handler: (params: unknown) => void | Promise<void>,
-  ): void;
-  /** Send a JSON-RPC notification back to the hub. */
-  sendNotification(method: string, params: Record<string, unknown>): void | Promise<void>;
-}
-
-export interface CascadeDiffRequestParams {
-  request_id: string;
-  stream_id: string;
-  head: string;
-  base?: string;
-  file_paths?: string[];
-  files_only?: boolean;
-  format?: 'unified';
-}
-
-type DiffErrorCode =
-  | 'not_found'
-  | 'bad_request'
-  | 'integrity_failed'
-  | 'internal';
-
-interface ProduceResult {
-  blob: Buffer;
-  filesTouched: string[];
-  truncated: boolean;
-}
-
-/**
- * Register the cascade/diff.request handler on the connection.
- * Returns a cleanup function that removes the registration.
- */
-export function setupCascadeDiffServer(
-  connection: CascadeDiffServerConnection,
-  adapter: GitCascadeAdapter,
-): () => void {
-  const handler = async (params: unknown): Promise<void> => {
-    const req = params as CascadeDiffRequestParams | null;
-    if (!req?.request_id || typeof req.request_id !== 'string') return;
-    if (!req.stream_id || !req.head) {
-      await sendError(
-        connection,
-        req.request_id,
-        'bad_request',
-        'missing stream_id or head',
-      );
-      return;
-    }
-
-    const workdir = resolveWorkdir(adapter, req.stream_id);
-    if (!workdir) {
-      await sendError(
-        connection,
-        req.request_id,
-        'not_found',
-        `no worktree or repo path for stream ${req.stream_id}`,
-      );
-      return;
-    }
-
-    let produced: ProduceResult;
-    try {
-      produced = await runGit({
-        workdir,
-        head: req.head,
-        base: req.base,
-        filePaths: req.file_paths,
-        filesOnly: req.files_only === true,
-      });
-    } catch (err) {
-      await sendError(
-        connection,
-        req.request_id,
-        'internal',
-        `git failed: ${(err as Error).message}`,
-      );
-      return;
-    }
-
-    if (produced.blob.length <= INLINE_THRESHOLD_BYTES) {
-      await connection.sendNotification(RESPONSE_METHOD, {
-        request_id: req.request_id,
-        streaming: false,
-        diff: produced.blob.toString('utf-8'),
-        files_touched: produced.filesTouched,
-        truncated: produced.truncated,
-      });
-      return;
-    }
-
-    await streamLargeBlob(
-      connection,
-      req.request_id,
-      produced.blob,
-      produced.filesTouched,
-      produced.truncated,
-    );
-  };
-
-  connection.onNotification(REQUEST_METHOD, handler);
-  return () => {
-    try {
-      connection.offNotification(REQUEST_METHOD, handler);
-    } catch {
-      /* non-fatal */
-    }
-  };
-}
-
-// ============================================================================
-// Worktree resolution
-// ============================================================================
-
-function resolveWorkdir(
-  adapter: GitCascadeAdapter,
-  streamId: string,
-): string | null {
-  // Prefer a live worktree currently checked out on this stream.
-  try {
-    const match = adapter
-      .listWorktrees()
-      .find((wt) => wt.currentStream === streamId);
-    if (match?.path && existsSync(match.path)) return match.path;
-  } catch {
-    /* fall through to repo-path fallback */
-  }
-
-  // Fallback: bare repo path. `git show <sha>` works repo-wide.
-  try {
-    const repoPath = adapter.repoPath;
-    if (repoPath && existsSync(repoPath)) return repoPath;
-  } catch {
-    /* fall through */
-  }
-  return null;
-}
-
-// ============================================================================
-// Git shell-out
-// ============================================================================
-
-interface RunGitArgs {
-  workdir: string;
-  head: string;
-  base?: string;
-  filePaths?: string[];
-  filesOnly: boolean;
-}
-
-async function runGit(args: RunGitArgs): Promise<ProduceResult> {
-  const gitArgs = buildGitArgs(args);
-  const buf = await spawnCapped(args.workdir, gitArgs);
-
-  if (args.filesOnly) {
-    const files = parseNameOnly(buf.data);
-    return { blob: Buffer.from(''), filesTouched: files, truncated: buf.truncated };
-  }
-
-  // Extract files_touched from the diff blob headers. Cheap regex; the
-  // sidecar can avoid a second git invocation.
-  const files = extractFilesFromDiffHeaders(buf.data);
-  return { blob: buf.data, filesTouched: files, truncated: buf.truncated };
-}
-
-function buildGitArgs(args: RunGitArgs): string[] {
-  // --no-textconv: don't apply textconv filters (force raw bytes).
-  // -U3: 3 lines of context (default unified-diff window).
-  // --binary suppressed: default "Binary files differ" markers are fine.
-  if (args.filesOnly) {
-    if (args.base) {
-      return ['diff', '--name-only', `${args.base}..${args.head}`, '--', ...(args.filePaths ?? [])];
-    }
-    return [
-      'show',
-      '--no-textconv',
-      '--format=',
-      '--name-only',
-      args.head,
-      '--',
-      ...(args.filePaths ?? []),
-    ];
-  }
-  if (args.base) {
-    return [
-      'diff',
-      '--no-textconv',
-      '-U3',
-      `${args.base}..${args.head}`,
-      '--',
-      ...(args.filePaths ?? []),
-    ];
-  }
-  return [
-    'show',
-    '--no-textconv',
-    '-U3',
-    '--format=',
-    args.head,
-    '--',
-    ...(args.filePaths ?? []),
-  ];
-}
-
-interface CappedSpawnResult {
-  data: Buffer;
-  truncated: boolean;
-}
-
-/**
- * Spawn git, capture stdout up to `MAX_DIFF_BYTES`. Beyond that, drain
- * the rest into /dev/null and mark `truncated: true`. Always returns
- * (no rejection on overflow); rejects only on spawn / non-zero exit.
- */
-function spawnCapped(cwd: string, args: string[]): Promise<CappedSpawnResult> {
-  return new Promise((resolve, reject) => {
-    const proc = spawn('git', args, {
-      cwd,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-
-    const parts: Buffer[] = [];
-    let total = 0;
-    let truncated = false;
-    let killTimer: ReturnType<typeof setTimeout> | null = null;
-    let stderrBuf = '';
-
-    proc.stdout.on('data', (chunk: Buffer) => {
-      if (truncated) return;
-      if (total + chunk.length > MAX_DIFF_BYTES) {
-        const remaining = MAX_DIFF_BYTES - total;
-        if (remaining > 0) parts.push(chunk.subarray(0, remaining));
-        total = MAX_DIFF_BYTES;
-        truncated = true;
-        return;
-      }
-      parts.push(chunk);
-      total += chunk.length;
-    });
-
-    proc.stderr.on('data', (chunk: Buffer) => {
-      // Cap stderr so a flood doesn't OOM us.
-      if (stderrBuf.length < 8192) {
-        stderrBuf += chunk.toString('utf-8');
-      }
-    });
-
-    killTimer = setTimeout(() => {
-      truncated = true;
-      try { proc.kill('SIGKILL'); } catch { /* nothing to kill */ }
-    }, GIT_TIMEOUT_MS);
-
-    proc.on('error', (err) => {
-      if (killTimer) clearTimeout(killTimer);
-      reject(err);
-    });
-
-    proc.on('close', (code) => {
-      if (killTimer) clearTimeout(killTimer);
-      if (code !== 0 && !truncated) {
-        reject(
-          new Error(
-            `git ${args.join(' ')} exited ${code}: ${stderrBuf.trim().slice(0, 200)}`,
-          ),
-        );
-        return;
-      }
-      resolve({ data: Buffer.concat(parts), truncated });
-    });
-  });
-}
-
-// ============================================================================
-// Output parsing
-// ============================================================================
-
-function parseNameOnly(buf: Buffer): string[] {
-  return buf
-    .toString('utf-8')
-    .split('\n')
-    .map((s) => s.trim())
-    .filter((s) => s.length > 0);
-}
-
-/**
- * Pull file paths out of the per-file header pair `--- a/X` / `+++ b/Y`.
- *
- * The `diff --git a/X b/Y` line is ambiguous for filenames containing
- * ` b/` (the regex can't tell where the a-side ends and the b-side
- * begins, and git only quotes paths containing control chars / quotes /
- * backslash, not plain spaces). The `--- ` and `+++ ` lines are
- * unambiguous: each appears once per file, anchored at line start, with
- * the full path running to end-of-line.
- *
- * Handles renames (different a/ and b/ paths → both surfaced as touched),
- * new files (`--- /dev/null` → skipped, `+++ b/X` → X), and deletions
- * (`--- a/X` → X, `+++ /dev/null` → skipped). Dedup via Set.
- */
-function extractFilesFromDiffHeaders(buf: Buffer): string[] {
-  const seen = new Set<string>();
-  const text = buf.toString('utf-8');
-  const regex = /^[-+]{3} (?:a|b)\/(.+)$/gm;
-  let m: RegExpExecArray | null;
-  while ((m = regex.exec(text)) !== null) {
-    seen.add(m[1]);
-  }
-  return Array.from(seen);
-}
-
-// ============================================================================
-// Streaming
-// ============================================================================
-
-async function streamLargeBlob(
-  connection: CascadeDiffServerConnection,
-  requestId: string,
-  blob: Buffer,
-  filesTouched: string[],
-  truncated: boolean,
-): Promise<void> {
-  // `request_id` is already unique per-request from the hub, but we add
-  // a random nonce so two sidecars routing through the same hub can't
-  // collide on the hub-side `chunkStreamToRequest` map even in the
-  // unlikely case the same request_id arrives twice (e.g. on retries).
-  const chunkStreamId = `cdiff-${requestId}-${randomBytes(6).toString('hex')}`;
-
-  await connection.sendNotification(RESPONSE_METHOD, {
-    request_id: requestId,
-    streaming: true,
-    chunk_stream_id: chunkStreamId,
-    total_size: blob.length,
-    files_touched: filesTouched,
-  });
-
-  const sha = createHash('sha256').update(blob).digest('hex');
-  const totalChunks = Math.ceil(blob.length / CHUNK_SIZE_BYTES);
-
-  for (let i = 0; i < totalChunks; i++) {
-    const start = i * CHUNK_SIZE_BYTES;
-    const end = Math.min(start + CHUNK_SIZE_BYTES, blob.length);
-    const slice = blob.subarray(start, end);
-    const isFinal = i === totalChunks - 1;
-    await connection.sendNotification(CHUNK_METHOD, {
-      chunk_stream_id: chunkStreamId,
-      seq: i,
-      data: slice.toString('base64'),
-      ...(isFinal ? { final: true, sha256: sha, truncated } : {}),
-    });
-  }
-}
-
-async function sendError(
-  connection: CascadeDiffServerConnection,
-  requestId: string,
-  code: DiffErrorCode,
-  message: string,
-): Promise<void> {
-  await connection.sendNotification(RESPONSE_METHOD, {
-    request_id: requestId,
-    error: { code, message },
-  });
-}

package/src/map/cc-swarm-hooks.ts

@@ -1,242 +0,0 @@
-/**
- * cc-swarm Hook Integration
- *
- * Wraps cc-swarm's shell command hooks as programmatic HookCallback functions
- * that can be passed via acp-factory's agentMeta.claudeCode.options.hooks.
- *
- * This enables cc-swarm's MAP sidecar, trajectory reporting, and task bridging
- * for agents spawned by macro-agent via acp-factory.
- *
- * @module map/cc-swarm-hooks
- */
-
-import { spawn } from "node:child_process";
-import * as path from "node:path";
-import * as fs from "node:fs";
-
-/**
- * Resolve the cc-swarm plugin directory.
- * Checks common installation paths.
- */
-function findCCSwarmDir(): string | null {
-  const home = process.env.HOME ?? "";
-
-  // Check plugin cache (Claude Code plugin system)
-  // Plugins are cached at ~/.claude/plugins/cache/{publisher}/{name}/{version}/
-  const cacheDir = path.join(home, ".claude/plugins/cache/claude-code-swarm/claude-code-swarm");
-  if (fs.existsSync(cacheDir)) {
-    // Find the latest version
-    try {
-      const versions = fs.readdirSync(cacheDir)
-        .filter((v) => /^\d+\.\d+\.\d+$/.test(v))
-        .sort((a, b) => {
-          const [aMaj, aMin, aPat] = a.split(".").map(Number);
-          const [bMaj, bMin, bPat] = b.split(".").map(Number);
-          return bMaj - aMaj || bMin - aMin || bPat - aPat;
-        });
-      if (versions.length > 0) {
-        const latest = path.join(cacheDir, versions[0]);
-        if (fs.existsSync(path.join(latest, "scripts", "bootstrap.mjs"))) {
-          return latest;
-        }
-      }
-    } catch {
-      // Can't read cache directory
-    }
-  }
-
-  // Check marketplace plugin
-  const marketplace = path.join(home, ".claude/plugins/marketplaces/claude-code-swarm");
-  if (fs.existsSync(path.join(marketplace, "scripts", "bootstrap.mjs"))) {
-    return marketplace;
-  }
-
-  // Check references (development)
-  const references = path.resolve(__dirname, "../../references/claude-code-swarm");
-  if (fs.existsSync(path.join(references, "scripts", "bootstrap.mjs"))) {
-    return references;
-  }
-
-  return null;
-}
-
-/**
- * Create a programmatic hook callback that executes a cc-swarm script.
- *
- * The hook spawns a child process running the specified script,
- * pipes the hook input via stdin, and captures stdout output.
- */
-function createShellHook(
-  scriptPath: string,
-  args: string[] = [],
-  env?: Record<string, string>,
-): (input: any, toolUseId: string | undefined, options: { signal: AbortSignal }) => Promise<{ async: boolean; output?: string }> {
-  return async (input, _toolUseId, { signal }) => {
-    return new Promise((resolve) => {
-      const proc = spawn(process.execPath, [scriptPath, ...args], {
-        env: { ...process.env, ...env },
-        stdio: ["pipe", "pipe", "inherit"],
-        timeout: 30000,
-        signal,
-      });
-
-      let output = "";
-      proc.stdout?.on("data", (chunk: Buffer) => {
-        output += chunk.toString();
-      });
-
-      proc.on("close", () => {
-        resolve({
-          async: false,
-          ...(output.trim() ? { output: output.trim() } : {}),
-        });
-      });
-
-      proc.on("error", () => {
-        resolve({ async: false });
-      });
-
-      // Pipe hook input via stdin
-      try {
-        proc.stdin?.write(JSON.stringify(input), () => {
-          proc.stdin?.end();
-        });
-      } catch {
-        proc.stdin?.end();
-      }
-    });
-  };
-}
-
-/**
- * Directly start the cc-swarm MAP sidecar for an agent.
- *
- * Instead of relying on Claude Code's SessionStart hook (which may not fire
- * for programmatic sessions), this spawns the sidecar process directly.
- * The sidecar connects to macro-agent's MAP server and starts sending
- * trajectory checkpoints.
- *
- * Returns the spawned process, or null if cc-swarm is not installed.
- */
-export function startCCSwarmSidecar(
-  mapServerUrl: string,
-  agentScope: string,
-  sessionId: string,
-  cwd: string,
-): { pid: number } | null {
-  const ccSwarmDir = findCCSwarmDir();
-  if (!ccSwarmDir) return null;
-
-  const sidecarScript = path.join(ccSwarmDir, "scripts", "map-sidecar.mjs");
-  if (!fs.existsSync(sidecarScript)) return null;
-
-  try {
-    const proc = spawn(process.execPath, [sidecarScript], {
-      detached: true,
-      stdio: "ignore",
-      cwd,
-      env: {
-        ...process.env,
-        SWARM_MAP_SERVER: mapServerUrl,
-        SWARM_MAP_ENABLED: "true",
-        SWARM_MAP_SCOPE: agentScope,
-        SWARM_SESSIONLOG_ENABLED: "true",
-        SWARM_SESSIONLOG_SYNC: "metrics",
-        CLAUDE_PLUGIN_ROOT: ccSwarmDir,
-        NODE_PATH: process.env.NODE_PATH ?? "",
-      },
-    });
-    proc.unref();
-    return { pid: proc.pid ?? 0 };
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Build cc-swarm hooks configuration for a spawned agent.
- *
- * Returns a hooks object compatible with Claude Code's programmatic API:
- * ```
- * { SessionStart: [...], Stop: [...], PostToolUse: [...], ... }
- * ```
- *
- * Returns null if cc-swarm is not installed.
- */
-export function buildCCSwarmHooks(
-  mapServerUrl: string,
-  agentScope: string,
-): Record<string, any[]> | null {
-  const ccSwarmDir = findCCSwarmDir();
-  if (!ccSwarmDir) return null;
-
-  const bootstrapScript = path.join(ccSwarmDir, "scripts", "bootstrap.mjs");
-  const mapHookScript = path.join(ccSwarmDir, "scripts", "map-hook.mjs");
-
-  if (!fs.existsSync(bootstrapScript) || !fs.existsSync(mapHookScript)) {
-    return null;
-  }
-
-  const hookEnv: Record<string, string> = {
-    SWARM_MAP_SERVER: mapServerUrl,
-    SWARM_MAP_ENABLED: "true",
-    SWARM_MAP_SCOPE: agentScope,
-    SWARM_SESSIONLOG_ENABLED: "true",
-    SWARM_SESSIONLOG_SYNC: "metrics",
-    CLAUDE_PLUGIN_ROOT: ccSwarmDir,
-  };
-
-  return {
-    SessionStart: [
-      {
-        matcher: "",
-        hooks: [createShellHook(bootstrapScript, [], hookEnv)],
-      },
-    ],
-    Stop: [
-      {
-        matcher: "",
-        hooks: [
-          createShellHook(mapHookScript, ["turn-completed"], hookEnv),
-          createShellHook(mapHookScript, ["sessionlog-sync"], hookEnv),
-        ],
-      },
-    ],
-    SubagentStart: [
-      {
-        matcher: "",
-        hooks: [
-          createShellHook(mapHookScript, ["subagent-start"], hookEnv),
-        ],
-      },
-    ],
-    SubagentStop: [
-      {
-        matcher: "",
-        hooks: [
-          createShellHook(mapHookScript, ["subagent-stop"], hookEnv),
-        ],
-      },
-    ],
-    PostToolUse: [
-      {
-        matcher: "TaskCreate",
-        hooks: [
-          createShellHook(mapHookScript, ["native-task-created"], hookEnv),
-        ],
-      },
-      {
-        matcher: "TaskUpdate",
-        hooks: [
-          createShellHook(mapHookScript, ["native-task-updated"], hookEnv),
-        ],
-      },
-    ],
-    UserPromptSubmit: [
-      {
-        matcher: "",
-        hooks: [createShellHook(mapHookScript, ["inject"], hookEnv)],
-      },
-    ],
-  };
-}