mcoda 0.1.0

package/packages/core/src/services/agents/__tests__/RoutingService.test.ts

@@ -0,0 +1,267 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Agent, RoutingPreview } from "@mcoda/shared";
+import { RoutingService } from "../RoutingService.js";
+
+class StubAgentService {
+  agents = new Map<string, Agent>();
+  capabilities = new Map<string, string[]>();
+
+  register(agent: Agent) {
+    this.agents.set(agent.id, agent);
+    this.agents.set(agent.slug, agent);
+  }
+
+  async resolveAgent(idOrSlug: string): Promise<Agent> {
+    const agent = this.agents.get(idOrSlug);
+    if (!agent) {
+      throw new Error(`Agent ${idOrSlug} not found`);
+    }
+    return agent;
+  }
+
+  async getCapabilities(agentId: string): Promise<string[]> {
+    return this.capabilities.get(agentId) ?? [];
+  }
+}
+
+class StubRoutingApi {
+  defaults = new Map<string, Map<string, string>>();
+  previews: RoutingPreview[] = [];
+  agents = new Map<string, Agent>();
+  health = new Map<string, any>();
+
+  constructor(private capabilityLookup: (agentId: string) => Promise<string[]>) {}
+
+  async getWorkspaceDefaults(workspaceId: string) {
+    const map = this.defaults.get(workspaceId);
+    if (!map) return [];
+    return Array.from(map.entries()).map(([commandName, agentId]) => ({
+      workspaceId,
+      commandName,
+      agentId,
+      updatedAt: "now",
+    }));
+  }
+
+  async updateWorkspaceDefaults(workspaceId: string, defaults: any) {
+    const map = new Map<string, string>();
+    if (Array.isArray(defaults)) {
+      defaults.forEach((d) => {
+        if (d.agentId) map.set(d.commandName, d.agentId);
+      });
+    } else if (defaults?.set) {
+      Object.entries(defaults.set as Record<string, string>).forEach(([commandName, agentId]) => {
+        map.set(commandName, agentId);
+      });
+    }
+    this.defaults.set(workspaceId, map);
+    return defaults;
+  }
+
+  async listAgents(): Promise<Agent[]> {
+    return Array.from(this.agents.values()).map((a) => ({
+      ...a,
+      capabilities: a.capabilities,
+      health: this.health.get(a.id),
+    }));
+  }
+
+  async getAgent(idOrSlug: string): Promise<Agent | undefined> {
+    const agent = this.agents.get(idOrSlug);
+    return agent ? { ...agent, health: this.health.get(agent.id) } : undefined;
+  }
+
+  async preview(request: any) {
+    const map = this.defaults.get(request.workspaceId) ?? new Map<string, string>();
+    const global = this.defaults.get("__GLOBAL__") ?? new Map<string, string>();
+    const agentId = request.agentOverride ?? map.get(request.commandName) ?? global.get(request.commandName);
+    if (!agentId) throw new Error(`No routing defaults or overrides found for command ${request.commandName}`);
+    const provenance = request.agentOverride
+      ? "override"
+      : map.has(request.commandName)
+        ? "workspace_default"
+        : "global_default";
+    const capabilities = await this.capabilityLookup(agentId);
+    const missingCapabilities = (request.requiredCapabilities ?? []).filter((cap: string) => !capabilities.includes(cap));
+    const stored = await this.getAgent(agentId);
+    const candidate = {
+      agent: (stored ?? { id: agentId, slug: agentId, adapter: "local-model", createdAt: "t", updatedAt: "t" }) as Agent,
+      agentId,
+      agentSlug: agentId,
+      source: provenance as any,
+      capabilities,
+      missingCapabilities: missingCapabilities.length ? missingCapabilities : undefined,
+    };
+    const preview: RoutingPreview = {
+      workspaceId: request.workspaceId,
+      commandName: request.commandName,
+      resolvedAgent: candidate.agent,
+      provenance,
+      requiredCapabilities: request.requiredCapabilities,
+      candidates: [candidate],
+    };
+    this.previews.push(preview);
+    return preview;
+  }
+}
+
+const workspace = {
+  workspaceId: "ws-1",
+  id: "ws-1",
+  workspaceRoot: "/tmp/ws-1",
+  workspaceDbPath: "/tmp/ws-1/.mcoda/mcoda.db",
+  globalDbPath: "/tmp/global/mcoda.db",
+  mcodaDir: "/tmp/ws-1/.mcoda",
+  legacyWorkspaceIds: [],
+};
+
+const agent = (id: string, slug: string): Agent => ({
+  id,
+  slug,
+  adapter: "local-model",
+  createdAt: new Date().toISOString(),
+  updatedAt: new Date().toISOString(),
+});
+
+test("resolves override before workspace and global defaults", async () => {
+  const agents = new StubAgentService();
+  const routingApi = new StubRoutingApi((id) => agents.getCapabilities(id));
+  routingApi.agents.set("a-global", agent("a-global", "global"));
+  routingApi.agents.set("a-workspace", agent("a-workspace", "workspace"));
+  routingApi.agents.set("a-override", agent("a-override", "override"));
+  agents.register(agent("a-global", "global"));
+  agents.register(agent("a-workspace", "workspace"));
+  agents.register(agent("a-override", "override"));
+  routingApi.defaults.set("__GLOBAL__", new Map([["work-on-tasks", "a-global"]]));
+  routingApi.defaults.set(workspace.workspaceId, new Map([["work-on-tasks", "a-workspace"]]));
+  agents.capabilities.set("a-global", ["code_write"]);
+  agents.capabilities.set("a-workspace", ["code_write"]);
+  agents.capabilities.set("a-override", ["code_write"]);
+  const service = new RoutingService({ routingApi: routingApi as any, agentService: agents as any });
+
+  const resolved = await service.resolveAgentForCommand({
+    workspace: workspace as any,
+    commandName: "work-on-tasks",
+  });
+  assert.equal(resolved.agentId, "a-workspace");
+  assert.equal(resolved.source, "workspace_default");
+
+  const override = await service.resolveAgentForCommand({
+    workspace: workspace as any,
+    commandName: "work-on-tasks",
+    overrideAgentSlug: "override",
+  });
+  assert.equal(override.agentId, "a-override");
+  assert.equal(override.source, "override");
+});
+
+test("falls back when workspace default lacks required capabilities", async () => {
+  const agents = new StubAgentService();
+  const routingApi = new StubRoutingApi((id) => agents.getCapabilities(id));
+  routingApi.agents.set("a-global", agent("a-global", "global"));
+  routingApi.agents.set("a-workspace", agent("a-workspace", "workspace"));
+  agents.register(agent("a-global", "global"));
+  agents.register(agent("a-workspace", "workspace"));
+  agents.capabilities.set("a-global", ["code_write"]);
+  agents.capabilities.set("a-workspace", []);
+  routingApi.defaults.set("__GLOBAL__", new Map([["work-on-tasks", "a-global"]]));
+  routingApi.defaults.set(workspace.workspaceId, new Map([["work-on-tasks", "a-workspace"]]));
+
+  const service = new RoutingService({ routingApi: routingApi as any, agentService: agents as any });
+  const resolved = await service.resolveAgentForCommand({
+    workspace: workspace as any,
+    commandName: "work-on-tasks",
+  });
+
+  assert.equal(resolved.agentId, "a-global");
+  assert.equal(resolved.source, "global_default");
+});
+
+test("skips unhealthy or incapable agents and falls back", async () => {
+  const agents = new StubAgentService();
+  const routingApi = new StubRoutingApi((id) => agents.getCapabilities(id));
+  routingApi.agents.set("a1", agent("a1", "agent1"));
+  routingApi.agents.set("a2", agent("a2", "agent2"));
+  agents.register(agent("a1", "agent1"));
+  agents.register(agent("a2", "agent2"));
+  routingApi.health.set("a2", { agentId: "a2", status: "unreachable", lastCheckedAt: "t" } as any);
+  routingApi.health.set("a1", { agentId: "a1", status: "healthy", lastCheckedAt: "t" } as any);
+  routingApi.defaults.set("__GLOBAL__", new Map([["code-review", "a2"], ["default", "a1"]]));
+  agents.capabilities.set("a2", ["code_review"]);
+  agents.capabilities.set("a1", ["code_review"]);
+  const service = new RoutingService({ routingApi: routingApi as any, agentService: agents as any });
+
+  const resolved = await service.resolveAgentForCommand({
+    workspace: workspace as any,
+    commandName: "code-review",
+  });
+  assert.equal(resolved.agentId, "a1");
+  assert.equal(resolved.source, "global_default");
+  assert.equal(resolved.healthStatus, "healthy");
+});
+
+test("throws when no defaults are configured", async () => {
+  const agents = new StubAgentService();
+  const routingApi = new StubRoutingApi((id) => agents.getCapabilities(id));
+  routingApi.agents.set("a1", agent("a1", "agent1"));
+  agents.register(agent("a1", "agent1"));
+  agents.capabilities.set("a1", ["plan"]);
+  // ensure QA/docdex profiles are optional and validated upstream
+  const service = new RoutingService({ routingApi: routingApi as any, agentService: agents as any });
+  await assert.rejects(
+    () =>
+      service.resolveAgentForCommand({
+        workspace: workspace as any,
+        commandName: "create-tasks",
+      }),
+    /No routing defaults/,
+  );
+});
+
+test("updateWorkspaceDefaults validates capabilities and profiles", async () => {
+  const agents = new StubAgentService();
+  const routingApi = new StubRoutingApi((id) => agents.getCapabilities(id));
+  routingApi.agents.set("codex", agent("codex", "codex"));
+  agents.register(agent("codex", "codex"));
+  agents.capabilities.set("codex", ["plan", "docdex_query"]);
+  const service = new RoutingService({ routingApi: routingApi as any, agentService: agents as any });
+
+  await assert.rejects(
+    () => service.updateWorkspaceDefaults("ws", { set: { "qa-tasks": "codex" } }),
+    /missing required capabilities/i,
+  );
+
+  await service.updateWorkspaceDefaults("ws", { set: { "create-tasks": "codex" }, qaProfile: "integration" });
+});
+
+test("uses API agent capabilities when present", async () => {
+  const routingApi = new StubRoutingApi(async () => []);
+  const apiAgent = agent("api-agent", "api-agent");
+  apiAgent.capabilities = ["code_write"];
+  routingApi.agents.set(apiAgent.id, apiAgent);
+  routingApi.defaults.set("__GLOBAL__", new Map([["work-on-tasks", apiAgent.id]]));
+  const service = new RoutingService({ routingApi: routingApi as any });
+
+  const resolved = await service.resolveAgentForCommand({
+    workspace: workspace as any,
+    commandName: "work-on-tasks",
+  });
+  assert.equal(resolved.agentId, apiAgent.id);
+  assert.deepEqual(resolved.capabilities, ["code_write"]);
+});
+
+test("accepts ollama-remote agents in routing", async () => {
+  const routingApi = new StubRoutingApi(async (id) => (id === "ollama" ? ["plan", "code_write"] : []));
+  const remoteAgent = { ...agent("ollama", "ollama"), adapter: "ollama-remote", capabilities: ["plan", "code_write"] };
+  routingApi.agents.set(remoteAgent.id, remoteAgent);
+  routingApi.defaults.set("__GLOBAL__", new Map([["create-tasks", remoteAgent.id]]));
+  const service = new RoutingService({ routingApi: routingApi as any });
+
+  const resolved = await service.resolveAgentForCommand({
+    workspace: workspace as any,
+    commandName: "create-tasks",
+  });
+  assert.equal(resolved.agentId, remoteAgent.id);
+  assert.equal(resolved.agent.adapter, "ollama-remote");
+});

package/packages/core/src/services/agents/generated/RoutingApiClient.ts

@@ -0,0 +1,89 @@
+import {
+  Agent,
+  RoutingDefaults,
+  RoutingDefaultsUpdate,
+  RoutingPreview,
+} from "@mcoda/shared";
+
+const pickBaseUrl = (): string => {
+  const base = process.env.MCODA_ROUTING_API_URL ?? process.env.MCODA_API_BASE_URL;
+  if (!base) {
+    throw new Error("MCODA_API_BASE_URL (or MCODA_ROUTING_API_URL) is required for routing operations per SDS.");
+  }
+  return base;
+};
+
+const handleResponse = async <T>(resp: Response): Promise<T | undefined> => {
+  if (resp.status === 404) return undefined;
+  if (!resp.ok) {
+    const text = await resp.text();
+    throw new Error(`Routing API request failed (${resp.status}): ${text}`);
+  }
+  if (resp.status === 204) return undefined;
+  return (await resp.json()) as T;
+};
+
+export interface RoutingPreviewRequest {
+  workspaceId: string;
+  commandName: string;
+  agentOverride?: string;
+  taskType?: string;
+  projectKey?: string;
+  requiredCapabilities?: string[];
+}
+
+export class RoutingApiClient {
+  constructor(private baseUrl: string = pickBaseUrl()) {}
+
+  static create(): RoutingApiClient {
+    return new RoutingApiClient();
+  }
+
+  private build(pathname: string): string {
+    return new URL(pathname, this.baseUrl).toString();
+  }
+
+  async getWorkspaceDefaults(workspaceId: string): Promise<RoutingDefaults | undefined> {
+    const resp = await fetch(this.build(`/workspaces/${encodeURIComponent(workspaceId)}/defaults`), {
+      headers: { accept: "application/json" },
+    });
+    return handleResponse<RoutingDefaults>(resp);
+  }
+
+  async updateWorkspaceDefaults(workspaceId: string, update: RoutingDefaultsUpdate): Promise<RoutingDefaults | undefined> {
+    const resp = await fetch(this.build(`/workspaces/${encodeURIComponent(workspaceId)}/defaults`), {
+      method: "PUT",
+      headers: { accept: "application/json", "content-type": "application/json" },
+      body: JSON.stringify(update),
+    });
+    return handleResponse<RoutingDefaults>(resp);
+  }
+
+  async preview(request: RoutingPreviewRequest): Promise<RoutingPreview | undefined> {
+    const resp = await fetch(this.build("/routing/preview"), {
+      method: "POST",
+      headers: { accept: "application/json", "content-type": "application/json" },
+      body: JSON.stringify({
+        workspaceId: request.workspaceId,
+        commandName: request.commandName,
+        agentOverride: request.agentOverride,
+        taskType: request.taskType,
+        projectKey: request.projectKey,
+        requiredCapabilities: request.requiredCapabilities,
+      }),
+    });
+    return handleResponse<RoutingPreview>(resp);
+  }
+
+  async listAgents(): Promise<Agent[] | undefined> {
+    const resp = await fetch(this.build("/agents"), { headers: { accept: "application/json" } });
+    return handleResponse<Agent[]>(resp);
+  }
+
+  async getAgent(idOrSlug: string): Promise<Agent | undefined> {
+    const resp = await fetch(this.build(`/agents/${encodeURIComponent(idOrSlug)}`), {
+      headers: { accept: "application/json" },
+    });
+    return handleResponse<Agent>(resp);
+  }
+}