macro-agent 0.0.11 → 0.0.12

package/src/config/project-config.ts

@@ -0,0 +1,107 @@
+/**
+ * Project Configuration Loader
+ *
+ * Reads .macro-agent/config.json for project-level settings.
+ *
+ * @module config/project-config
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+
+// =============================================================================
+// Types
+// =============================================================================
+
+/**
+ * Project-level configuration schema.
+ *
+ * Loaded from .macro-agent/config.json in the project root.
+ */
+export interface ProjectConfig {
+  /** Team template name to load on startup */
+  team?: string;
+
+  /** Additional project-level settings (extensible) */
+  [key: string]: unknown;
+}
+
+// =============================================================================
+// Constants
+// =============================================================================
+
+/** Config directory name */
+export const CONFIG_DIR = ".macro-agent";
+
+/** Config file name */
+export const CONFIG_FILE = "config.json";
+
+// =============================================================================
+// Loader
+// =============================================================================
+
+/**
+ * Get the project config file path.
+ *
+ * @param projectPath - Project root directory (default: process.cwd())
+ * @returns Absolute path to .macro-agent/config.json
+ */
+export function getProjectConfigPath(projectPath?: string): string {
+  const root = projectPath ?? process.cwd();
+  return path.join(root, CONFIG_DIR, CONFIG_FILE);
+}
+
+/**
+ * Load project configuration from .macro-agent/config.json.
+ *
+ * Returns empty config if the file doesn't exist.
+ * Throws on invalid JSON.
+ *
+ * @param projectPath - Project root directory (default: process.cwd())
+ * @returns Parsed ProjectConfig
+ */
+export function loadProjectConfig(projectPath?: string): ProjectConfig {
+  const configPath = getProjectConfigPath(projectPath);
+
+  if (!fs.existsSync(configPath)) {
+    return {};
+  }
+
+  const raw = fs.readFileSync(configPath, "utf-8");
+
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new ProjectConfigError(
+        `Config must be a JSON object, got ${Array.isArray(parsed) ? "array" : typeof parsed}`,
+        "INVALID_FORMAT",
+        configPath
+      );
+    }
+    return parsed as ProjectConfig;
+  } catch (error) {
+    if (error instanceof ProjectConfigError) throw error;
+    throw new ProjectConfigError(
+      `Failed to parse ${configPath}: ${error instanceof Error ? error.message : String(error)}`,
+      "PARSE_ERROR",
+      configPath
+    );
+  }
+}
+
+// =============================================================================
+// Errors
+// =============================================================================
+
+export type ProjectConfigErrorCode = "PARSE_ERROR" | "INVALID_FORMAT";
+
+export class ProjectConfigError extends Error {
+  constructor(
+    message: string,
+    public readonly code: ProjectConfigErrorCode,
+    public readonly configPath: string
+  ) {
+    super(message);
+    this.name = "ProjectConfigError";
+  }
+}

package/src/lifecycle/cascade.ts

@@ -30,7 +30,7 @@ import { attemptMerge, abortMerge, getCurrentBranch } from "./cleanup.js";
  */
 export interface CascadeAgent {
   id: AgentId;
-  state: "running" | "spawning" | "stopped";
+  state: "running" | "spawning" | "stopped" | "failed";
   parent?: AgentId | null;
 }
 

package/src/lifecycle/handlers/index.ts

@@ -55,6 +55,12 @@ export interface AllHandlerDeps {
 
   /** Optional workspace path resolver for integrators */
   getWorkspacePath?: (agentId: string) => string | undefined;
+
+  /** Optional integration strategy (from team config) */
+  integrationStrategy?: import("../../workspace/strategies/types.js").IntegrationStrategy;
+
+  /** Optional task mode from team config */
+  taskMode?: "push" | "pull";
 }
 
 // =============================================================================
@@ -75,6 +81,8 @@ export function createHandlerRegistry(
     agentManager: deps.agentManager,
     mergeQueue: deps.mergeQueue,
     getWorkspacePath: deps.getWorkspacePath,
+    integrationStrategy: deps.integrationStrategy,
+    taskMode: deps.taskMode,
   };
   registry.set("worker", (context, args, cleanupStatus) =>
     handleWorkerDone(context, args, cleanupStatus, workerDeps)

package/src/lifecycle/handlers/worker.ts

@@ -60,6 +60,12 @@ export interface WorkerHandlerDeps {
 
   /** Get workspace path for an agent (for resolver → integrator inline merge) */
   getWorkspacePath?: (agentId: string) => string | undefined;
+
+  /** Optional integration strategy (from team config) */
+  integrationStrategy?: import("../../workspace/strategies/types.js").IntegrationStrategy;
+
+  /** Optional task mode from team config */
+  taskMode?: "push" | "pull";
 }
 
 // =============================================================================
@@ -326,9 +332,42 @@ export async function handleWorkerDone(
             `Failed to emit RESOLVER_DONE: ${error instanceof Error ? error.message : "unknown"}`,
           );
         }
+      } else if (deps.integrationStrategy) {
+        // ───────────────────────────────────────────────────────────────────────
+        // Strategy-based integration (team config)
+        // ───────────────────────────────────────────────────────────────────────
+        try {
+          const landResult = await deps.integrationStrategy.land({
+            sourceBranch,
+            targetBranch,
+            workspacePath: context.workspacePath!,
+            agentId: context.agentId,
+            taskId: context.taskId,
+            streamId: context.streamId,
+          });
+
+          if (landResult.status === "landed") {
+            cleanupActions.push(
+              `Strategy '${deps.integrationStrategy.name}' landed ${sourceBranch} → ${targetBranch}${landResult.commitHash ? ` (${landResult.commitHash.slice(0, 8)})` : ""}${landResult.mergeRequestId ? ` (MR: ${landResult.mergeRequestId})` : ""}`,
+            );
+            signalsEmitted.push("WORKER_INTEGRATED");
+          } else if (landResult.status === "conflict") {
+            warnings.push(
+              `Strategy '${deps.integrationStrategy.name}' conflict: ${landResult.error ?? "unknown conflict"}`,
+            );
+          } else {
+            warnings.push(
+              `Strategy '${deps.integrationStrategy.name}' failed: ${landResult.error ?? "unknown error"}`,
+            );
+          }
+        } catch (strategyError) {
+          warnings.push(
+            `Integration strategy error: ${strategyError instanceof Error ? strategyError.message : "unknown"}`,
+          );
+        }
       } else {
         // ───────────────────────────────────────────────────────────────────────
-        // Regular workers emit MERGE_REQUEST and submit to queue
+        // Regular workers emit MERGE_REQUEST and submit to queue (fallback)
         // ───────────────────────────────────────────────────────────────────────
         try {
           // Emit the signal for notification
@@ -449,11 +488,17 @@ export async function handleWorkerDone(
   }
 
   // ─────────────────────────────────────────────────────────────────────────────
-  // Return result - shouldTerminate=true for completed/failed workers
+  // Return result
   // ─────────────────────────────────────────────────────────────────────────────
 
+  // In pull mode, completed workers stay alive to claim more tasks
+  const shouldTerminate =
+    deps.taskMode === "pull" && args.status === "completed"
+      ? false
+      : true;
+
   return {
-    shouldTerminate: true,
+    shouldTerminate,
     signalsEmitted,
     cleanupActions,
     warnings: warnings.length > 0 ? warnings : undefined,

package/src/map/adapter/__tests__/extensions.test.ts

@@ -10,12 +10,18 @@ import {
   unregisterWakeExtension,
   registerWorkspaceExtension,
   unregisterWorkspaceExtension,
+  registerResumeExtension,
+  unregisterResumeExtension,
+  registerAgentDetectionExtensions,
+  unregisterAgentDetectionExtensions,
   registerMacroExtensions,
   MACRO_EXTENSION_METHODS,
   EXTENSION_CAPABILITIES,
   type TaskExtensionServices,
   type WakeExtensionServices,
   type WorkspaceExtensionServices,
+  type ResumeExtensionServices,
+  type AgentDetectionExtensionServices,
 } from "../extensions/index.js";
 import type { MAPAdapter, ExtensionHandler, ExtensionContext } from "../interface.js";
 import type { ParticipantCapabilities } from "../types.js";
@@ -550,6 +556,341 @@ describe("Workspace Extension", () => {
   });
 });
 
+// =============================================================================
+// Resume Extension Tests
+// =============================================================================
+
+describe("Resume Extension", () => {
+  let adapter: MAPAdapter & { handlers: Map<string, ExtensionHandler> };
+  let services: ResumeExtensionServices;
+
+  beforeEach(() => {
+    adapter = createMockAdapter();
+
+    services = {
+      getAgent: vi.fn().mockReturnValue({
+        id: "agent-1" as AgentId,
+        state: "stopped",
+        session_id: "session-1",
+      }),
+      resume: vi.fn().mockResolvedValue({
+        id: "agent-1" as AgentId,
+        session_id: "session-1",
+      }),
+    };
+  });
+
+  describe("registration", () => {
+    it("registers resume method", () => {
+      registerResumeExtension(adapter, services);
+      expect(adapter.handlers.has("_macro/resume")).toBe(true);
+    });
+
+    it("unregisters resume method", () => {
+      registerResumeExtension(adapter, services);
+      unregisterResumeExtension(adapter);
+      expect(adapter.handlers.has("_macro/resume")).toBe(false);
+    });
+  });
+
+  describe("_macro/resume", () => {
+    it("resumes a stopped agent", async () => {
+      registerResumeExtension(adapter, services);
+      const handler = adapter.handlers.get("_macro/resume")!;
+
+      const result = await handler(createMockContext(), { agentId: "agent-1" });
+
+      expect(services.resume).toHaveBeenCalledWith("agent-1");
+      expect(result).toEqual({
+        success: true,
+        agentId: "agent-1",
+        sessionId: "session-1",
+      });
+    });
+
+    it("resumes a failed agent", async () => {
+      (services.getAgent as ReturnType<typeof vi.fn>).mockReturnValue({
+        id: "agent-1",
+        state: "failed",
+        session_id: "session-1",
+      });
+
+      registerResumeExtension(adapter, services);
+      const handler = adapter.handlers.get("_macro/resume")!;
+
+      const result = await handler(createMockContext(), { agentId: "agent-1" });
+
+      expect(services.resume).toHaveBeenCalledWith("agent-1");
+      expect(result).toHaveProperty("success", true);
+    });
+
+    it("throws for missing agentId", async () => {
+      registerResumeExtension(adapter, services);
+      const handler = adapter.handlers.get("_macro/resume")!;
+
+      await expect(handler(createMockContext(), {})).rejects.toThrow("agentId is required");
+    });
+
+    it("throws for non-existent agent", async () => {
+      (services.getAgent as ReturnType<typeof vi.fn>).mockReturnValue(undefined);
+
+      registerResumeExtension(adapter, services);
+      const handler = adapter.handlers.get("_macro/resume")!;
+
+      await expect(
+        handler(createMockContext(), { agentId: "missing" })
+      ).rejects.toThrow("not found");
+    });
+
+    it("throws for running agent", async () => {
+      (services.getAgent as ReturnType<typeof vi.fn>).mockReturnValue({
+        id: "agent-1",
+        state: "running",
+      });
+
+      registerResumeExtension(adapter, services);
+      const handler = adapter.handlers.get("_macro/resume")!;
+
+      await expect(
+        handler(createMockContext(), { agentId: "agent-1" })
+      ).rejects.toThrow("only stopped or failed");
+    });
+  });
+});
+
+// =============================================================================
+// Agent Detection Extension Tests
+// =============================================================================
+
+describe("Agent Detection Extensions", () => {
+  let adapter: MAPAdapter & { handlers: Map<string, ExtensionHandler> };
+  let services: AgentDetectionExtensionServices;
+
+  const mockDetectionResult = {
+    agents: [
+      {
+        id: "claude-code",
+        name: "Claude Code",
+        installed: true,
+        version: "1.2.3",
+        path: "/usr/local/bin/claude",
+        definition: {
+          id: "claude-code",
+          name: "Claude Code",
+          description: "Anthropic Claude Code CLI",
+          binary: "claude",
+          versionArgs: ["--version"],
+          headless: { promptFlag: "-p", defaultFlags: ["--output-format", "stream-json"] },
+          vendor: "Anthropic",
+        },
+        detectedAt: 1000,
+      },
+      {
+        id: "codex",
+        name: "Codex CLI",
+        installed: false,
+        definition: {
+          id: "codex",
+          name: "Codex CLI",
+          description: "OpenAI Codex CLI",
+          binary: "codex",
+          versionArgs: ["--version"],
+          headless: { subcommand: "exec", promptFlag: "", defaultFlags: ["--full-auto"] },
+          vendor: "OpenAI",
+        },
+        detectedAt: 1000,
+      },
+    ],
+    scanned: 2,
+    durationMs: 150,
+  };
+
+  beforeEach(() => {
+    adapter = createMockAdapter();
+
+    services = {
+      getAvailableAgents: vi.fn().mockResolvedValue(mockDetectionResult),
+      isDetecting: vi.fn().mockReturnValue(false),
+      getCachedResult: vi.fn().mockReturnValue(null),
+    };
+  });
+
+  describe("registration", () => {
+    it("registers both agent detection methods", () => {
+      registerAgentDetectionExtensions(adapter, services);
+
+      expect(adapter.handlers.has("_macro/agents/available")).toBe(true);
+      expect(adapter.handlers.has("_macro/agents/refresh")).toBe(true);
+    });
+
+    it("unregisters both agent detection methods", () => {
+      registerAgentDetectionExtensions(adapter, services);
+      unregisterAgentDetectionExtensions(adapter);
+
+      expect(adapter.handlers.has("_macro/agents/available")).toBe(false);
+      expect(adapter.handlers.has("_macro/agents/refresh")).toBe(false);
+    });
+  });
+
+  describe("_macro/agents/available", () => {
+    it("returns detected agents when no cache exists", async () => {
+      registerAgentDetectionExtensions(adapter, services);
+      const handler = adapter.handlers.get("_macro/agents/available")!;
+
+      const result = await handler(createMockContext(), {});
+
+      expect(services.getAvailableAgents).toHaveBeenCalledWith({
+        includeNotInstalled: false,
+      });
+      expect(result).toHaveProperty("agents");
+      expect(result).toHaveProperty("scanned", 2);
+      expect(result).toHaveProperty("durationMs", 150);
+      expect(result).toHaveProperty("cached", false);
+    });
+
+    it("filters out not-installed agents by default", async () => {
+      registerAgentDetectionExtensions(adapter, services);
+      const handler = adapter.handlers.get("_macro/agents/available")!;
+
+      const result = await handler(createMockContext(), {});
+
+      expect(services.getAvailableAgents).toHaveBeenCalledWith({
+        includeNotInstalled: false,
+      });
+    });
+
+    it("includes not-installed agents when requested", async () => {
+      registerAgentDetectionExtensions(adapter, services);
+      const handler = adapter.handlers.get("_macro/agents/available")!;
+
+      const result = await handler(createMockContext(), {
+        includeNotInstalled: true,
+      });
+
+      // No cache, so falls through to getAvailableAgents
+      expect(services.getAvailableAgents).toHaveBeenCalledWith({
+        includeNotInstalled: true,
+      });
+    });
+
+    it("uses cached results when available", async () => {
+      (services.getCachedResult as ReturnType<typeof vi.fn>).mockReturnValue(
+        mockDetectionResult
+      );
+
+      registerAgentDetectionExtensions(adapter, services);
+      const handler = adapter.handlers.get("_macro/agents/available")!;
+
+      const result = await handler(createMockContext(), {});
+
+      // Should use cache, not call getAvailableAgents
+      expect(services.getAvailableAgents).not.toHaveBeenCalled();
+      expect(result).toHaveProperty("cached", true);
+      // Default excludes not-installed, so only 1 agent
+      expect((result as any).agents).toHaveLength(1);
+      expect((result as any).agents[0].id).toBe("claude-code");
+    });
+
+    it("returns all agents from cache when includeNotInstalled is true", async () => {
+      (services.getCachedResult as ReturnType<typeof vi.fn>).mockReturnValue(
+        mockDetectionResult
+      );
+
+      registerAgentDetectionExtensions(adapter, services);
+      const handler = adapter.handlers.get("_macro/agents/available")!;
+
+      const result = await handler(createMockContext(), {
+        includeNotInstalled: true,
+      });
+
+      expect((result as any).agents).toHaveLength(2);
+      expect(result).toHaveProperty("cached", true);
+    });
+
+    it("strips binary paths from results", async () => {
+      registerAgentDetectionExtensions(adapter, services);
+      const handler = adapter.handlers.get("_macro/agents/available")!;
+
+      const result = await handler(createMockContext(), {});
+
+      const agents = (result as any).agents;
+      for (const agent of agents) {
+        expect(agent).not.toHaveProperty("path");
+        expect(agent).not.toHaveProperty("definition");
+        expect(agent).not.toHaveProperty("detectedAt");
+      }
+    });
+
+    it("includes vendor and description in results", async () => {
+      registerAgentDetectionExtensions(adapter, services);
+      const handler = adapter.handlers.get("_macro/agents/available")!;
+
+      const result = await handler(createMockContext(), {});
+
+      const agents = (result as any).agents;
+      expect(agents[0]).toHaveProperty("vendor", "Anthropic");
+      expect(agents[0]).toHaveProperty("description", "Anthropic Claude Code CLI");
+    });
+
+    it("handles empty params", async () => {
+      registerAgentDetectionExtensions(adapter, services);
+      const handler = adapter.handlers.get("_macro/agents/available")!;
+
+      const result = await handler(createMockContext(), null);
+
+      expect(result).toHaveProperty("agents");
+    });
+  });
+
+  describe("_macro/agents/refresh", () => {
+    it("forces a fresh detection scan", async () => {
+      registerAgentDetectionExtensions(adapter, services);
+      const handler = adapter.handlers.get("_macro/agents/refresh")!;
+
+      const result = await handler(createMockContext(), {});
+
+      expect(services.getAvailableAgents).toHaveBeenCalledWith({
+        refresh: true,
+        includeNotInstalled: true,
+      });
+      expect(result).toHaveProperty("agents");
+      expect(result).toHaveProperty("scanned", 2);
+      expect(result).toHaveProperty("durationMs", 150);
+    });
+
+    it("always returns all agents including not-installed", async () => {
+      registerAgentDetectionExtensions(adapter, services);
+      const handler = adapter.handlers.get("_macro/agents/refresh")!;
+
+      const result = await handler(createMockContext(), {});
+
+      expect((result as any).agents).toHaveLength(2);
+    });
+
+    it("does not include a cached flag", async () => {
+      registerAgentDetectionExtensions(adapter, services);
+      const handler = adapter.handlers.get("_macro/agents/refresh")!;
+
+      const result = await handler(createMockContext(), {});
+
+      expect(result).not.toHaveProperty("cached");
+    });
+
+    it("strips binary paths from results", async () => {
+      registerAgentDetectionExtensions(adapter, services);
+      const handler = adapter.handlers.get("_macro/agents/refresh")!;
+
+      const result = await handler(createMockContext(), {});
+
+      const agents = (result as any).agents;
+      for (const agent of agents) {
+        expect(agent).not.toHaveProperty("path");
+        expect(agent).not.toHaveProperty("definition");
+      }
+    });
+  });
+});
+
 // =============================================================================
 // Combined Registration Tests
 // =============================================================================
@@ -588,11 +929,23 @@ describe("registerMacroExtensions", () => {
         getWorkspace: vi.fn(),
         agentExists: vi.fn(),
       },
+      resume: {
+        getAgent: vi.fn(),
+        resume: vi.fn(),
+      },
+      agentDetection: {
+        getAvailableAgents: vi.fn(),
+        isDetecting: vi.fn(),
+        getCachedResult: vi.fn(),
+      },
     });
 
     expect(adapter.handlers.has("_macro/task/list")).toBe(true);
     expect(adapter.handlers.has("_macro/wake")).toBe(true);
     expect(adapter.handlers.has("_macro/workspace/info")).toBe(true);
+    expect(adapter.handlers.has("_macro/resume")).toBe(true);
+    expect(adapter.handlers.has("_macro/agents/available")).toBe(true);
+    expect(adapter.handlers.has("_macro/agents/refresh")).toBe(true);
   });
 });
 
@@ -606,6 +959,9 @@ describe("MACRO_EXTENSION_METHODS", () => {
     expect(MACRO_EXTENSION_METHODS).toContain("_macro/task/send");
     expect(MACRO_EXTENSION_METHODS).toContain("_macro/wake");
     expect(MACRO_EXTENSION_METHODS).toContain("_macro/workspace/info");
+    expect(MACRO_EXTENSION_METHODS).toContain("_macro/resume");
+    expect(MACRO_EXTENSION_METHODS).toContain("_macro/agents/available");
+    expect(MACRO_EXTENSION_METHODS).toContain("_macro/agents/refresh");
   });
 });
 
@@ -616,5 +972,8 @@ describe("EXTENSION_CAPABILITIES", () => {
     expect(EXTENSION_CAPABILITIES["_macro/task/send"]).toBe("canMessage");
     expect(EXTENSION_CAPABILITIES["_macro/wake"]).toBe("canMessage");
     expect(EXTENSION_CAPABILITIES["_macro/workspace/info"]).toBe("canQuery");
+    expect(EXTENSION_CAPABILITIES["_macro/resume"]).toBe("canManageLifecycle");
+    expect(EXTENSION_CAPABILITIES["_macro/agents/available"]).toBe("canQuery");
+    expect(EXTENSION_CAPABILITIES["_macro/agents/refresh"]).toBe("canQuery");
   });
 });