@codemcp/ade 0.2.0

package/packages/core/src/registry.spec.ts

@@ -0,0 +1,145 @@
+import { describe, it, expect, vi } from "vitest";
+import {
+  createRegistry,
+  registerProvisionWriter,
+  registerAgentWriter,
+  getProvisionWriter,
+  getAgentWriter,
+  createDefaultRegistry
+} from "./registry.js";
+import type {
+  ProvisionWriterDef,
+  AgentWriterDef,
+  LogicalConfig,
+  ResolutionContext
+} from "./types.js";
+
+describe("registry", () => {
+  describe("createRegistry", () => {
+    it("returns a registry with empty provisions and agents maps", () => {
+      const registry = createRegistry();
+      expect(registry.provisions.size).toBe(0);
+      expect(registry.agents.size).toBe(0);
+    });
+  });
+
+  describe("registerProvisionWriter / getProvisionWriter", () => {
+    it("registers a provision writer and retrieves it by id", async () => {
+      const registry = createRegistry();
+
+      const mockFragment: Partial<LogicalConfig> = {
+        instructions: ["use typescript strict mode"]
+      };
+
+      const writer: ProvisionWriterDef = {
+        id: "skills",
+        write: vi.fn().mockResolvedValue(mockFragment)
+      };
+
+      registerProvisionWriter(registry, writer);
+
+      const found = getProvisionWriter(registry, "skills");
+      expect(found).toBeDefined();
+      expect(found!.id).toBe("skills");
+
+      // Behavioral: actually call write() and verify the result
+      const context: ResolutionContext = { resolved: {} };
+      const result = await found!.write({ lang: "ts" }, context);
+      expect(result).toEqual(mockFragment);
+      expect(writer.write).toHaveBeenCalledWith({ lang: "ts" }, context);
+    });
+
+    it("overwrites a writer when registering with the same id", async () => {
+      const registry = createRegistry();
+
+      const first: ProvisionWriterDef = {
+        id: "workflows",
+        write: vi.fn().mockResolvedValue({ instructions: ["first"] })
+      };
+      const second: ProvisionWriterDef = {
+        id: "workflows",
+        write: vi.fn().mockResolvedValue({ instructions: ["second"] })
+      };
+
+      registerProvisionWriter(registry, first);
+      registerProvisionWriter(registry, second);
+
+      const found = getProvisionWriter(registry, "workflows");
+      const result = await found!.write({}, { resolved: {} });
+      expect(result).toEqual({ instructions: ["second"] });
+      expect(first.write).not.toHaveBeenCalled();
+    });
+
+    it("returns undefined for a non-existent provision writer", () => {
+      const registry = createRegistry();
+      const found = getProvisionWriter(registry, "does-not-exist");
+      expect(found).toBeUndefined();
+    });
+  });
+
+  describe("registerAgentWriter / getAgentWriter", () => {
+    it("registers an agent writer and can call install()", async () => {
+      const registry = createRegistry();
+
+      const mockInstall = vi.fn().mockResolvedValue(undefined);
+      const agent: AgentWriterDef = {
+        id: "opencode",
+        install: mockInstall
+      };
+
+      registerAgentWriter(registry, agent);
+
+      const found = getAgentWriter(registry, "opencode");
+      expect(found).toBeDefined();
+      expect(found!.id).toBe("opencode");
+
+      // Behavioral: call install() and verify it was invoked correctly
+      const config: LogicalConfig = {
+        mcp_servers: [],
+        instructions: ["be helpful"],
+        cli_actions: [],
+        knowledge_sources: [],
+        skills: [],
+        git_hooks: [],
+        setup_notes: []
+      };
+      await found!.install(config, "/tmp/my-project");
+      expect(mockInstall).toHaveBeenCalledWith(config, "/tmp/my-project");
+    });
+
+    it("returns undefined for a non-existent agent writer", () => {
+      const registry = createRegistry();
+      const found = getAgentWriter(registry, "nope");
+      expect(found).toBeUndefined();
+    });
+  });
+
+  describe("createDefaultRegistry", () => {
+    it("has all built-in provision writer IDs registered", () => {
+      const registry = createDefaultRegistry();
+      const expectedIds = [
+        "workflows",
+        "skills",
+        "knowledge",
+        "mcp-server",
+        "instruction",
+        "installable",
+        "git-hooks",
+        "setup-note",
+        "permission-policy"
+      ];
+      for (const id of expectedIds) {
+        expect(
+          getProvisionWriter(registry, id),
+          `expected provision writer "${id}" to be registered`
+        ).toBeDefined();
+      }
+      expect(registry.provisions.size).toBe(expectedIds.length);
+    });
+
+    it("has no agent writers by default (moved to @ade/harnesses)", () => {
+      const registry = createDefaultRegistry();
+      expect(registry.agents.size).toBe(0);
+    });
+  });
+});

package/packages/core/src/registry.ts

@@ -0,0 +1,70 @@
+import type {
+  WriterRegistry,
+  ProvisionWriterDef,
+  AgentWriterDef
+} from "./types.js";
+import { instructionWriter } from "./writers/instruction.js";
+import { workflowsWriter } from "./writers/workflows.js";
+import { skillsWriter } from "./writers/skills.js";
+import { knowledgeWriter } from "./writers/knowledge.js";
+import { gitHooksWriter } from "./writers/git-hooks.js";
+import { setupNoteWriter } from "./writers/setup-note.js";
+import { permissionPolicyWriter } from "./writers/permission-policy.js";
+
+export function createRegistry(): WriterRegistry {
+  return {
+    provisions: new Map(),
+    agents: new Map()
+  };
+}
+
+export function registerProvisionWriter(
+  registry: WriterRegistry,
+  writer: ProvisionWriterDef
+): void {
+  registry.provisions.set(writer.id, writer);
+}
+
+export function getProvisionWriter(
+  registry: WriterRegistry,
+  id: string
+): ProvisionWriterDef | undefined {
+  return registry.provisions.get(id);
+}
+
+export function registerAgentWriter(
+  registry: WriterRegistry,
+  agent: AgentWriterDef
+): void {
+  registry.agents.set(agent.id, agent);
+}
+
+export function getAgentWriter(
+  registry: WriterRegistry,
+  id: string
+): AgentWriterDef | undefined {
+  return registry.agents.get(id);
+}
+
+export function createDefaultRegistry(): WriterRegistry {
+  const registry = createRegistry();
+
+  registerProvisionWriter(registry, instructionWriter);
+  registerProvisionWriter(registry, workflowsWriter);
+  registerProvisionWriter(registry, skillsWriter);
+
+  registerProvisionWriter(registry, knowledgeWriter);
+  registerProvisionWriter(registry, gitHooksWriter);
+  registerProvisionWriter(registry, setupNoteWriter);
+  registerProvisionWriter(registry, permissionPolicyWriter);
+
+  // Stub writers for types not yet implemented
+  for (const id of ["mcp-server", "installable"]) {
+    registerProvisionWriter(registry, {
+      id,
+      write: async () => ({})
+    });
+  }
+
+  return registry;
+}