@company-semantics/contracts 9.1.0 → 9.2.0

package/src/mcp/__tests__/capability-graph.test.ts

@@ -1,6 +1,6 @@
-import { describe, it, expect } from 'vitest'
-import { buildCapabilityGraph } from '../capability-graph'
-import type { MCPToolDescriptor } from '../index'
+import { describe, it, expect } from "vitest";
+import { buildCapabilityGraph } from "../capability-graph";
+import type { MCPToolDescriptor } from "../index";
 
 /**
  * Helper to create minimal MCPToolDescriptor for testing.
@@ -10,412 +10,412 @@ function makeTool(
   overrides: Partial<MCPToolDescriptor> & { id: string; name: string },
 ): MCPToolDescriptor {
   return {
-    category: 'system',
-    description: '',
-    effectClass: 'pure',
-    invocationMode: 'manual',
-    visibility: 'user',
+    category: "system",
+    description: "",
+    effectClass: "pure",
+    invocationMode: "manual",
+    visibility: "user",
     requiresConfirmation: false,
-    domain: 'system',
-    risk: 'none',
-    intent: 'read',
-    stability: 'stable',
-    complexity: 'trivial',
+    domain: "system",
+    risk: "none",
+    intent: "read",
+    stability: "stable",
+    complexity: "trivial",
     schemaVersion: 1,
     ...overrides,
-  }
+  };
 }
 
-describe('buildCapabilityGraph', () => {
-  it('returns empty graph for empty tools array', () => {
-    const graph = buildCapabilityGraph([])
-    expect(graph.edges).toEqual([])
-    expect(graph.workflows).toEqual([])
-  })
+describe("buildCapabilityGraph", () => {
+  it("returns empty graph for empty tools array", () => {
+    const graph = buildCapabilityGraph([]);
+    expect(graph.edges).toEqual([]);
+    expect(graph.workflows).toEqual([]);
+  });
 
-  it('produces no edges for tools with no produces/consumes', () => {
+  it("produces no edges for tools with no produces/consumes", () => {
     const tools = [
-      makeTool({ id: 'a', name: 'a' }),
-      makeTool({ id: 'b', name: 'b' }),
-    ]
-    const graph = buildCapabilityGraph(tools)
-    expect(graph.edges).toEqual([])
-  })
+      makeTool({ id: "a", name: "a" }),
+      makeTool({ id: "b", name: "b" }),
+    ];
+    const graph = buildCapabilityGraph(tools);
+    expect(graph.edges).toEqual([]);
+  });
 
-  it('creates one edge for single producer → consumer with correct domain', () => {
+  it("creates one edge for single producer → consumer with correct domain", () => {
     const tools = [
-      makeTool({ id: 'a', name: 'a', produces: ['integration.connection'] }),
-      makeTool({ id: 'b', name: 'b', consumes: ['integration.connection'] }),
-    ]
-    const graph = buildCapabilityGraph(tools)
-    expect(graph.edges).toHaveLength(1)
+      makeTool({ id: "a", name: "a", produces: ["integration.connection"] }),
+      makeTool({ id: "b", name: "b", consumes: ["integration.connection"] }),
+    ];
+    const graph = buildCapabilityGraph(tools);
+    expect(graph.edges).toHaveLength(1);
     expect(graph.edges[0]).toEqual({
-      from: 'a',
-      to: 'b',
-      resource: 'integration.connection',
-      domain: 'integration',
-    })
-  })
+      from: "a",
+      to: "b",
+      resource: "integration.connection",
+      domain: "integration",
+    });
+  });
 
-  it('creates multiple edges for multiple producers of same resource', () => {
+  it("creates multiple edges for multiple producers of same resource", () => {
     const tools = [
-      makeTool({ id: 'a', name: 'a', produces: ['integration.connection'] }),
-      makeTool({ id: 'b', name: 'b', produces: ['integration.connection'] }),
-      makeTool({ id: 'c', name: 'c', consumes: ['integration.connection'] }),
-    ]
-    const graph = buildCapabilityGraph(tools)
-    expect(graph.edges).toHaveLength(2)
+      makeTool({ id: "a", name: "a", produces: ["integration.connection"] }),
+      makeTool({ id: "b", name: "b", produces: ["integration.connection"] }),
+      makeTool({ id: "c", name: "c", consumes: ["integration.connection"] }),
+    ];
+    const graph = buildCapabilityGraph(tools);
+    expect(graph.edges).toHaveLength(2);
     expect(graph.edges).toContainEqual({
-      from: 'a',
-      to: 'c',
-      resource: 'integration.connection',
-      domain: 'integration',
-    })
+      from: "a",
+      to: "c",
+      resource: "integration.connection",
+      domain: "integration",
+    });
     expect(graph.edges).toContainEqual({
-      from: 'b',
-      to: 'c',
-      resource: 'integration.connection',
-      domain: 'integration',
-    })
-  })
+      from: "b",
+      to: "c",
+      resource: "integration.connection",
+      domain: "integration",
+    });
+  });
 
-  it('derives workflow for linear chain > 2 steps', () => {
+  it("derives workflow for linear chain > 2 steps", () => {
     const tools = [
       makeTool({
-        id: 'step1',
-        name: 'step1',
-        produces: ['integration.connection'],
+        id: "step1",
+        name: "step1",
+        produces: ["integration.connection"],
       }),
       makeTool({
-        id: 'step2',
-        name: 'step2',
-        consumes: ['integration.connection'],
-        produces: ['slack.channel'],
+        id: "step2",
+        name: "step2",
+        consumes: ["integration.connection"],
+        produces: ["slack.channel"],
       }),
       makeTool({
-        id: 'step3',
-        name: 'step3',
-        consumes: ['slack.channel'],
-        produces: ['slack.channel_scope'],
+        id: "step3",
+        name: "step3",
+        consumes: ["slack.channel"],
+        produces: ["slack.channel_scope"],
       }),
       makeTool({
-        id: 'step4',
-        name: 'step4',
-        consumes: ['slack.channel_scope'],
+        id: "step4",
+        name: "step4",
+        consumes: ["slack.channel_scope"],
       }),
-    ]
-    const graph = buildCapabilityGraph(tools)
-    expect(graph.workflows).toHaveLength(1)
+    ];
+    const graph = buildCapabilityGraph(tools);
+    expect(graph.workflows).toHaveLength(1);
     expect(graph.workflows[0].steps).toEqual([
-      'step1',
-      'step2',
-      'step3',
-      'step4',
-    ])
-  })
+      "step1",
+      "step2",
+      "step3",
+      "step4",
+    ]);
+  });
 
-  it('does NOT derive workflow for short chain (2 steps, 1 edge)', () => {
+  it("does NOT derive workflow for short chain (2 steps, 1 edge)", () => {
     const tools = [
-      makeTool({ id: 'a', name: 'a', produces: ['integration.connection'] }),
-      makeTool({ id: 'b', name: 'b', consumes: ['integration.connection'] }),
-    ]
-    const graph = buildCapabilityGraph(tools)
-    expect(graph.workflows).toEqual([])
-  })
+      makeTool({ id: "a", name: "a", produces: ["integration.connection"] }),
+      makeTool({ id: "b", name: "b", consumes: ["integration.connection"] }),
+    ];
+    const graph = buildCapabilityGraph(tools);
+    expect(graph.workflows).toEqual([]);
+  });
 
-  it('does not form single workflow from branching nodes', () => {
+  it("does not form single workflow from branching nodes", () => {
     const tools = [
       makeTool({
-        id: 'root',
-        name: 'root',
-        produces: ['integration.connection'],
+        id: "root",
+        name: "root",
+        produces: ["integration.connection"],
       }),
       makeTool({
-        id: 'branch1',
-        name: 'branch1',
-        consumes: ['integration.connection'],
-        produces: ['slack.channel'],
+        id: "branch1",
+        name: "branch1",
+        consumes: ["integration.connection"],
+        produces: ["slack.channel"],
       }),
       makeTool({
-        id: 'branch2',
-        name: 'branch2',
-        consumes: ['integration.connection'],
-        produces: ['slack.coverage'],
+        id: "branch2",
+        name: "branch2",
+        consumes: ["integration.connection"],
+        produces: ["slack.coverage"],
       }),
-    ]
-    const graph = buildCapabilityGraph(tools)
+    ];
+    const graph = buildCapabilityGraph(tools);
     // root has 2 outgoing edges → not a linear chain
-    expect(graph.workflows).toEqual([])
-  })
+    expect(graph.workflows).toEqual([]);
+  });
 
-  describe('full 17-tool integration test', () => {
+  describe("full 17-tool integration test", () => {
     const allTools: MCPToolDescriptor[] = [
       // Organization
       makeTool({
-        id: 'cs_get_org_status',
-        name: 'cs_get_org_status',
-        domain: 'organization',
-        produces: ['org.status'],
+        id: "cs_get_org_status",
+        name: "cs_get_org_status",
+        domain: "organization",
+        produces: ["org.status"],
       }),
       makeTool({
-        id: 'cs_update_org',
-        name: 'cs_update_org',
-        domain: 'organization',
-        intent: 'mutate',
+        id: "cs_update_org",
+        name: "cs_update_org",
+        domain: "organization",
+        intent: "mutate",
       }),
       // Identity
       makeTool({
-        id: 'cs_update_profile',
-        name: 'cs_update_profile',
-        domain: 'identity',
-        intent: 'mutate',
+        id: "cs_update_profile",
+        name: "cs_update_profile",
+        domain: "identity",
+        intent: "mutate",
       }),
       // Integrations
       makeTool({
-        id: 'cs_start_slack_auth',
-        name: 'cs_start_slack_auth',
-        domain: 'integrations',
-        integrations: ['slack'],
-        produces: ['integration.connection'],
+        id: "cs_start_slack_auth",
+        name: "cs_start_slack_auth",
+        domain: "integrations",
+        integrations: ["slack"],
+        produces: ["integration.connection"],
       }),
       makeTool({
-        id: 'cs_start_google_auth',
-        name: 'cs_start_google_auth',
-        domain: 'integrations',
-        integrations: ['google'],
-        produces: ['integration.connection'],
+        id: "cs_start_google_auth",
+        name: "cs_start_google_auth",
+        domain: "integrations",
+        integrations: ["google"],
+        produces: ["integration.connection"],
       }),
       makeTool({
-        id: 'cs_start_zoom_auth',
-        name: 'cs_start_zoom_auth',
-        domain: 'integrations',
-        integrations: ['zoom'],
-        produces: ['integration.connection'],
+        id: "cs_start_zoom_auth",
+        name: "cs_start_zoom_auth",
+        domain: "integrations",
+        integrations: ["zoom"],
+        produces: ["integration.connection"],
       }),
       makeTool({
-        id: 'cs_list_connections',
-        name: 'cs_list_connections',
-        domain: 'integrations',
-        produces: ['integration.connection'],
+        id: "cs_list_connections",
+        name: "cs_list_connections",
+        domain: "integrations",
+        produces: ["integration.connection"],
       }),
       makeTool({
-        id: 'cs_cleanup_connections',
-        name: 'cs_cleanup_connections',
-        domain: 'integrations',
-        consumes: ['integration.connection'],
+        id: "cs_cleanup_connections",
+        name: "cs_cleanup_connections",
+        domain: "integrations",
+        consumes: ["integration.connection"],
       }),
       makeTool({
-        id: 'cs_propose_integration_action',
-        name: 'cs_propose_integration_action',
-        domain: 'integrations',
-        consumes: ['integration.connection'],
+        id: "cs_propose_integration_action",
+        name: "cs_propose_integration_action",
+        domain: "integrations",
+        consumes: ["integration.connection"],
       }),
       // Discovery
       makeTool({
-        id: 'cs_discover_slack',
-        name: 'cs_discover_slack',
-        domain: 'discovery',
-        integrations: ['slack'],
-        produces: ['slack.channel'],
-        consumes: ['integration.connection'],
+        id: "cs_discover_slack",
+        name: "cs_discover_slack",
+        domain: "discovery",
+        integrations: ["slack"],
+        produces: ["slack.channel"],
+        consumes: ["integration.connection"],
       }),
       makeTool({
-        id: 'cs_get_slack_coverage',
-        name: 'cs_get_slack_coverage',
-        domain: 'discovery',
-        integrations: ['slack'],
-        produces: ['slack.coverage'],
-        consumes: ['integration.connection'],
+        id: "cs_get_slack_coverage",
+        name: "cs_get_slack_coverage",
+        domain: "discovery",
+        integrations: ["slack"],
+        produces: ["slack.coverage"],
+        consumes: ["integration.connection"],
       }),
       makeTool({
-        id: 'cs_list_fingerprints',
-        name: 'cs_list_fingerprints',
-        domain: 'discovery',
-        produces: ['knowledge.fingerprint'],
+        id: "cs_list_fingerprints",
+        name: "cs_list_fingerprints",
+        domain: "discovery",
+        produces: ["knowledge.fingerprint"],
       }),
       // Ingestion
       makeTool({
-        id: 'cs_manage_channel_scope',
-        name: 'cs_manage_channel_scope',
-        domain: 'ingestion',
-        integrations: ['slack'],
-        produces: ['slack.channel_scope'],
-        consumes: ['slack.channel'],
+        id: "cs_manage_channel_scope",
+        name: "cs_manage_channel_scope",
+        domain: "ingestion",
+        integrations: ["slack"],
+        produces: ["slack.channel_scope"],
+        consumes: ["slack.channel"],
       }),
       makeTool({
-        id: 'cs_ingest_slack_channel',
-        name: 'cs_ingest_slack_channel',
-        domain: 'ingestion',
-        integrations: ['slack'],
-        produces: ['ingestion.job'],
-        consumes: ['slack.channel_scope'],
+        id: "cs_ingest_slack_channel",
+        name: "cs_ingest_slack_channel",
+        domain: "ingestion",
+        integrations: ["slack"],
+        produces: ["ingestion.job"],
+        consumes: ["slack.channel_scope"],
       }),
       makeTool({
-        id: 'cs_get_ingestion_status',
-        name: 'cs_get_ingestion_status',
-        domain: 'ingestion',
-        produces: ['ingestion.job'],
-        consumes: ['ingestion.job'],
+        id: "cs_get_ingestion_status",
+        name: "cs_get_ingestion_status",
+        domain: "ingestion",
+        produces: ["ingestion.job"],
+        consumes: ["ingestion.job"],
       }),
       // System
       makeTool({
-        id: 'cs_system_status',
-        name: 'cs_system_status',
-        domain: 'system',
-        produces: ['system.status'],
+        id: "cs_system_status",
+        name: "cs_system_status",
+        domain: "system",
+        produces: ["system.status"],
       }),
       makeTool({
-        id: 'cs_help',
-        name: 'cs_help',
-        domain: 'system',
+        id: "cs_help",
+        name: "cs_help",
+        domain: "system",
       }),
-    ]
+    ];
 
-    it('includes Slack ingestion chain edges', () => {
-      const graph = buildCapabilityGraph(allTools)
+    it("includes Slack ingestion chain edges", () => {
+      const graph = buildCapabilityGraph(allTools);
 
       expect(graph.edges).toContainEqual({
-        from: 'cs_start_slack_auth',
-        to: 'cs_discover_slack',
-        resource: 'integration.connection',
-        domain: 'integration',
-      })
+        from: "cs_start_slack_auth",
+        to: "cs_discover_slack",
+        resource: "integration.connection",
+        domain: "integration",
+      });
       expect(graph.edges).toContainEqual({
-        from: 'cs_discover_slack',
-        to: 'cs_manage_channel_scope',
-        resource: 'slack.channel',
-        domain: 'slack',
-      })
+        from: "cs_discover_slack",
+        to: "cs_manage_channel_scope",
+        resource: "slack.channel",
+        domain: "slack",
+      });
       expect(graph.edges).toContainEqual({
-        from: 'cs_manage_channel_scope',
-        to: 'cs_ingest_slack_channel',
-        resource: 'slack.channel_scope',
-        domain: 'slack',
-      })
+        from: "cs_manage_channel_scope",
+        to: "cs_ingest_slack_channel",
+        resource: "slack.channel_scope",
+        domain: "slack",
+      });
       expect(graph.edges).toContainEqual({
-        from: 'cs_ingest_slack_channel',
-        to: 'cs_get_ingestion_status',
-        resource: 'ingestion.job',
-        domain: 'ingestion',
-      })
-    })
+        from: "cs_ingest_slack_channel",
+        to: "cs_get_ingestion_status",
+        resource: "ingestion.job",
+        domain: "ingestion",
+      });
+    });
 
-    it('produces correct total edge count', () => {
-      const graph = buildCapabilityGraph(allTools)
+    it("produces correct total edge count", () => {
+      const graph = buildCapabilityGraph(allTools);
       // integration.connection: 4 producers × 4 consumers = 16 edges
       // slack.channel: 1 edge (discover_slack → manage_channel_scope)
       // slack.channel_scope: 1 edge (manage_channel_scope → ingest_slack_channel)
       // ingestion.job: 2 edges (ingest → status, status → status self-loop)
-      expect(graph.edges).toHaveLength(20)
-    })
+      expect(graph.edges).toHaveLength(20);
+    });
 
-    it('does not derive workflows from branching graph', () => {
-      const graph = buildCapabilityGraph(allTools)
+    it("does not derive workflows from branching graph", () => {
+      const graph = buildCapabilityGraph(allTools);
       // With all 17 tools, auth tools have 4 outgoing edges each (branching),
       // and consumers like discover_slack have 4 incoming edges.
       // No linear chain starts are walkable → no workflows.
-      expect(graph.workflows).toEqual([])
-    })
-  })
+      expect(graph.workflows).toEqual([]);
+    });
+  });
 
-  describe('slack_ingestion workflow derivation', () => {
-    it('derives slack_ingestion workflow from Slack chain tools', () => {
+  describe("slack_ingestion workflow derivation", () => {
+    it("derives slack_ingestion workflow from Slack chain tools", () => {
       // Isolated Slack chain without branching from other auth tools
       const slackChainTools = [
         makeTool({
-          id: 'cs_start_slack_auth',
-          name: 'cs_start_slack_auth',
-          integrations: ['slack'],
-          produces: ['integration.connection'],
+          id: "cs_start_slack_auth",
+          name: "cs_start_slack_auth",
+          integrations: ["slack"],
+          produces: ["integration.connection"],
         }),
         makeTool({
-          id: 'cs_discover_slack',
-          name: 'cs_discover_slack',
-          integrations: ['slack'],
-          produces: ['slack.channel'],
-          consumes: ['integration.connection'],
+          id: "cs_discover_slack",
+          name: "cs_discover_slack",
+          integrations: ["slack"],
+          produces: ["slack.channel"],
+          consumes: ["integration.connection"],
         }),
         makeTool({
-          id: 'cs_manage_channel_scope',
-          name: 'cs_manage_channel_scope',
-          integrations: ['slack'],
-          produces: ['slack.channel_scope'],
-          consumes: ['slack.channel'],
+          id: "cs_manage_channel_scope",
+          name: "cs_manage_channel_scope",
+          integrations: ["slack"],
+          produces: ["slack.channel_scope"],
+          consumes: ["slack.channel"],
         }),
         makeTool({
-          id: 'cs_ingest_slack_channel',
-          name: 'cs_ingest_slack_channel',
-          integrations: ['slack'],
-          consumes: ['slack.channel_scope'],
+          id: "cs_ingest_slack_channel",
+          name: "cs_ingest_slack_channel",
+          integrations: ["slack"],
+          consumes: ["slack.channel_scope"],
         }),
-      ]
-      const graph = buildCapabilityGraph(slackChainTools)
-      expect(graph.workflows).toHaveLength(1)
-      expect(graph.workflows[0].name).toBe('slack_ingestion')
+      ];
+      const graph = buildCapabilityGraph(slackChainTools);
+      expect(graph.workflows).toHaveLength(1);
+      expect(graph.workflows[0].name).toBe("slack_ingestion");
       expect(graph.workflows[0].steps).toEqual([
-        'cs_start_slack_auth',
-        'cs_discover_slack',
-        'cs_manage_channel_scope',
-        'cs_ingest_slack_channel',
-      ])
-      expect(graph.workflows[0].description).toContain('start_slack_auth')
-      expect(graph.workflows[0].description).toContain('ingest_slack_channel')
-    })
+        "cs_start_slack_auth",
+        "cs_discover_slack",
+        "cs_manage_channel_scope",
+        "cs_ingest_slack_channel",
+      ]);
+      expect(graph.workflows[0].description).toContain("start_slack_auth");
+      expect(graph.workflows[0].description).toContain("ingest_slack_channel");
+    });
 
-    it('extends Slack chain through cs_get_ingestion_status when isolated', () => {
+    it("extends Slack chain through cs_get_ingestion_status when isolated", () => {
       const slackChainWithStatus = [
         makeTool({
-          id: 'cs_start_slack_auth',
-          name: 'cs_start_slack_auth',
-          integrations: ['slack'],
-          produces: ['integration.connection'],
+          id: "cs_start_slack_auth",
+          name: "cs_start_slack_auth",
+          integrations: ["slack"],
+          produces: ["integration.connection"],
         }),
         makeTool({
-          id: 'cs_discover_slack',
-          name: 'cs_discover_slack',
-          integrations: ['slack'],
-          produces: ['slack.channel'],
-          consumes: ['integration.connection'],
+          id: "cs_discover_slack",
+          name: "cs_discover_slack",
+          integrations: ["slack"],
+          produces: ["slack.channel"],
+          consumes: ["integration.connection"],
         }),
         makeTool({
-          id: 'cs_manage_channel_scope',
-          name: 'cs_manage_channel_scope',
-          integrations: ['slack'],
-          produces: ['slack.channel_scope'],
-          consumes: ['slack.channel'],
+          id: "cs_manage_channel_scope",
+          name: "cs_manage_channel_scope",
+          integrations: ["slack"],
+          produces: ["slack.channel_scope"],
+          consumes: ["slack.channel"],
         }),
         makeTool({
-          id: 'cs_ingest_slack_channel',
-          name: 'cs_ingest_slack_channel',
-          integrations: ['slack'],
-          produces: ['ingestion.job'],
-          consumes: ['slack.channel_scope'],
+          id: "cs_ingest_slack_channel",
+          name: "cs_ingest_slack_channel",
+          integrations: ["slack"],
+          produces: ["ingestion.job"],
+          consumes: ["slack.channel_scope"],
         }),
         makeTool({
-          id: 'cs_get_ingestion_status',
-          name: 'cs_get_ingestion_status',
-          produces: ['ingestion.job'],
-          consumes: ['ingestion.job'],
+          id: "cs_get_ingestion_status",
+          name: "cs_get_ingestion_status",
+          produces: ["ingestion.job"],
+          consumes: ["ingestion.job"],
         }),
-      ]
-      const graph = buildCapabilityGraph(slackChainWithStatus)
+      ];
+      const graph = buildCapabilityGraph(slackChainWithStatus);
 
-      expect(graph.workflows).toHaveLength(1)
+      expect(graph.workflows).toHaveLength(1);
       // Chain stops at cs_ingest_slack_channel because cs_get_ingestion_status
       // has 2 incoming edges (from ingest + self-loop)
-      expect(graph.workflows[0].steps).toContain('cs_start_slack_auth')
-      expect(graph.workflows[0].steps).toContain('cs_discover_slack')
-      expect(graph.workflows[0].steps).toContain('cs_manage_channel_scope')
-      expect(graph.workflows[0].steps).toContain('cs_ingest_slack_channel')
-    })
-  })
+      expect(graph.workflows[0].steps).toContain("cs_start_slack_auth");
+      expect(graph.workflows[0].steps).toContain("cs_discover_slack");
+      expect(graph.workflows[0].steps).toContain("cs_manage_channel_scope");
+      expect(graph.workflows[0].steps).toContain("cs_ingest_slack_channel");
+    });
+  });
 
-  it('extracts domain from resource namespace prefix', () => {
+  it("extracts domain from resource namespace prefix", () => {
     const tools = [
-      makeTool({ id: 'a', name: 'a', produces: ['slack.channel'] }),
-      makeTool({ id: 'b', name: 'b', consumes: ['slack.channel'] }),
-    ]
-    const graph = buildCapabilityGraph(tools)
-    expect(graph.edges[0].domain).toBe('slack')
-  })
-})
+      makeTool({ id: "a", name: "a", produces: ["slack.channel"] }),
+      makeTool({ id: "b", name: "b", consumes: ["slack.channel"] }),
+    ];
+    const graph = buildCapabilityGraph(tools);
+    expect(graph.edges[0].domain).toBe("slack");
+  });
+});