@cubis/foundry 0.3.62 → 0.3.64

package/mcp/src/index.ts

@@ -12,6 +12,7 @@
  */
 
 import { loadServerConfig } from "./config/index.js";
+import { loadGeneratedRouteManifest } from "./routes/loadGeneratedRouteManifest.js";
 import { scanVaultRoots } from "./vault/scanner.js";
 import { buildManifest, enrichWithDescriptions } from "./vault/manifest.js";
 import { createServer } from "./server.js";
@@ -169,6 +170,7 @@ async function main(): Promise<void> {
   const skills = await scanVaultRoots(serverConfig.vault.roots, basePath);
   const charsPerToken = serverConfig.telemetry.charsPerToken;
   const manifest = buildManifest(skills, charsPerToken);
+  const routeManifest = await loadGeneratedRouteManifest(basePath);
 
   // Enrich with descriptions for faster browse/search at runtime
   await enrichWithDescriptions(
@@ -216,6 +218,7 @@ async function main(): Promise<void> {
       const server = await createServer({
         config: serverConfig,
         manifest,
+        routeManifest,
         defaultConfigScope: args.scope,
       });
       await server.connect(transport);
@@ -240,6 +243,7 @@ async function main(): Promise<void> {
     const mcpServer = await createServer({
       config: serverConfig,
       manifest,
+      routeManifest,
       defaultConfigScope: args.scope,
     });
     const transport = createStdioTransport();

package/mcp/src/routes/loadGeneratedRouteManifest.ts

@@ -0,0 +1,45 @@
+/**
+ * Cubis Foundry MCP Server – generated route manifest loader.
+ */
+
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import type { RouteManifest } from "./types.js";
+import { logger } from "../utils/logger.js";
+
+export function createEmptyRouteManifest(): RouteManifest {
+  return {
+    $schema: "cubis-foundry-route-manifest-v1",
+    generatedAt: new Date(0).toISOString(),
+    contentHash: "missing",
+    summary: {
+      totalRoutes: 0,
+      workflows: 0,
+      agents: 0,
+    },
+    routes: [],
+  };
+}
+
+export async function loadGeneratedRouteManifest(
+  mcpPackageRoot: string,
+): Promise<RouteManifest> {
+  const filePath = path.resolve(
+    mcpPackageRoot,
+    "../workflows/workflows/agent-environment-setup/generated/route-manifest.json",
+  );
+
+  try {
+    const raw = await readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw) as RouteManifest;
+    if (!Array.isArray(parsed.routes)) {
+      throw new Error("missing routes array");
+    }
+    return parsed;
+  } catch (error) {
+    logger.warn(
+      `Generated route manifest unavailable at ${filePath}: ${String(error)}`,
+    );
+    return createEmptyRouteManifest();
+  }
+}

package/mcp/src/routes/types.ts

@@ -0,0 +1,41 @@
+/**
+ * Cubis Foundry MCP Server – generated route manifest types.
+ */
+
+export interface RoutePlatformArtifacts {
+  workflowFile?: string;
+  promptFile?: string;
+  commandFile?: string;
+  agentFile?: string;
+  compatibilityAlias?: string;
+}
+
+export interface RouteEntry {
+  kind: "workflow" | "agent";
+  id: string;
+  command: string | null;
+  displayName: string;
+  description: string;
+  triggers: string[];
+  primaryAgent: string;
+  supportingAgents: string[];
+  primarySkills: string[];
+  supportingSkills: string[];
+  artifacts: {
+    codex?: RoutePlatformArtifacts;
+    copilot?: RoutePlatformArtifacts;
+    antigravity?: RoutePlatformArtifacts;
+  };
+}
+
+export interface RouteManifest {
+  $schema: string;
+  generatedAt: string;
+  contentHash: string;
+  summary: {
+    totalRoutes: number;
+    workflows: number;
+    agents: number;
+  };
+  routes: RouteEntry[];
+}

package/mcp/src/server.ts

@@ -10,6 +10,7 @@ import { z } from "zod";
 import type { ServerConfig } from "./config/schema.js";
 import type { ConfigScope } from "./cbxConfig/types.js";
 import type { VaultManifest } from "./vault/types.js";
+import type { RouteManifest } from "./routes/types.js";
 import { TOOL_REGISTRY, type ToolRuntimeContext } from "./tools/registry.js";
 import {
   callUpstreamTool,
@@ -20,6 +21,7 @@ import { logger } from "./utils/logger.js";
 export interface CreateServerOptions {
   config: ServerConfig;
   manifest: VaultManifest;
+  routeManifest: RouteManifest;
   defaultConfigScope?: ConfigScope | "auto";
 }
 
@@ -54,6 +56,7 @@ function toolCallErrorResult({
 export async function createServer({
   config,
   manifest,
+  routeManifest,
   defaultConfigScope = "auto",
 }: CreateServerOptions): Promise<McpServer> {
   const server = new McpServer({
@@ -65,6 +68,7 @@ export async function createServer({
 
   const runtimeCtx: ToolRuntimeContext = {
     manifest,
+    routeManifest,
     charsPerToken: config.telemetry?.charsPerToken ?? 4,
     summaryMaxLength: config.vault.summaryMaxLength,
     defaultConfigScope,

package/mcp/src/tools/index.ts

@@ -19,6 +19,13 @@ export {
   type ToolRuntimeContext,
 } from "./registry.js";
 
+export {
+  routeResolveName,
+  routeResolveDescription,
+  routeResolveSchema,
+  handleRouteResolve,
+} from "./routeResolve.js";
+
 export {
   skillListCategoriesName,
   skillListCategoriesDescription,
@@ -40,6 +47,13 @@ export {
   handleSkillSearch,
 } from "./skillSearch.js";
 
+export {
+  skillValidateName,
+  skillValidateDescription,
+  skillValidateSchema,
+  handleSkillValidate,
+} from "./skillValidate.js";
+
 export {
   skillGetName,
   skillGetDescription,
@@ -47,6 +61,13 @@ export {
   handleSkillGet,
 } from "./skillGet.js";
 
+export {
+  skillGetReferenceName,
+  skillGetReferenceDescription,
+  skillGetReferenceSchema,
+  handleSkillGetReference,
+} from "./skillGetReference.js";
+
 export {
   skillBudgetReportName,
   skillBudgetReportDescription,

package/mcp/src/tools/registry.test.ts

@@ -8,6 +8,7 @@ import {
   type ToolRuntimeContext,
 } from "./registry.js";
 import type { VaultManifest } from "../vault/types.js";
+import type { RouteManifest } from "../routes/types.js";
 
 function createTestContext(): ToolRuntimeContext {
   const manifest: VaultManifest = {
@@ -23,9 +24,35 @@ function createTestContext(): ToolRuntimeContext {
     fullCatalogBytes: 100,
     fullCatalogEstimatedTokens: 25,
   };
+  const routeManifest: RouteManifest = {
+    $schema: "cubis-foundry-route-manifest-v1",
+    generatedAt: new Date(0).toISOString(),
+    contentHash: "test",
+    summary: { totalRoutes: 1, workflows: 1, agents: 0 },
+    routes: [
+      {
+        kind: "workflow",
+        id: "mobile",
+        command: "/mobile",
+        displayName: "mobile",
+        description: "Mobile workflow",
+        triggers: ["mobile", "flutter"],
+        primaryAgent: "mobile-developer",
+        supportingAgents: [],
+        primarySkills: ["flutter-expert"],
+        supportingSkills: [],
+        artifacts: {
+          codex: { workflowFile: "mobile.md", compatibilityAlias: "$workflow-mobile" },
+          copilot: { workflowFile: "mobile.md", promptFile: "workflow-mobile.prompt.md" },
+          antigravity: { workflowFile: "mobile.md", commandFile: "mobile.toml" },
+        },
+      },
+    ],
+  };
 
   return {
     manifest,
+    routeManifest,
     charsPerToken: 4,
     summaryMaxLength: 200,
     defaultConfigScope: "auto",
@@ -35,10 +62,13 @@ function createTestContext(): ToolRuntimeContext {
 describe("tool registry", () => {
   it("contains all expected built-in tools", () => {
     const names = getRegisteredToolNames();
+    expect(names).toContain("route_resolve");
     expect(names).toContain("skill_list_categories");
     expect(names).toContain("skill_browse_category");
     expect(names).toContain("skill_search");
+    expect(names).toContain("skill_validate");
     expect(names).toContain("skill_get");
+    expect(names).toContain("skill_get_reference");
     expect(names).toContain("skill_budget_report");
     expect(names).toContain("postman_get_mode");
     expect(names).toContain("postman_set_mode");
@@ -48,8 +78,8 @@ describe("tool registry", () => {
     expect(names).toContain("stitch_get_status");
   });
 
-  it("has exactly 11 built-in tools", () => {
-    expect(TOOL_REGISTRY).toHaveLength(11);
+  it("has exactly 14 built-in tools", () => {
+    expect(TOOL_REGISTRY).toHaveLength(14);
   });
 
   it("has no duplicate tool names", () => {
@@ -63,14 +93,17 @@ describe("tool registry", () => {
       expect(entry.name).toBeTruthy();
       expect(entry.description).toBeTruthy();
       expect(entry.schema).toBeTruthy();
-      expect(entry.category).toMatch(/^(skill|postman|stitch)$/);
+      expect(entry.category).toMatch(/^(skill|route|postman|stitch)$/);
       expect(typeof entry.createHandler).toBe("function");
     }
   });
 
   it("filters by category", () => {
+    const routeTools = getToolsByCategory("route");
+    expect(routeTools).toHaveLength(1);
+
     const skillTools = getToolsByCategory("skill");
-    expect(skillTools).toHaveLength(5);
+    expect(skillTools).toHaveLength(7);
     expect(skillTools.every((t) => t.category === "skill")).toBe(true);
 
     const postmanTools = getToolsByCategory("postman");
@@ -103,11 +136,13 @@ describe("tool registry", () => {
 
   it("buildRegistrySummary produces correct structure", () => {
     const summary = buildRegistrySummary();
-    expect(summary.totalTools).toBe(11);
+    expect(summary.totalTools).toBe(14);
+    expect(summary.categories).toHaveProperty("route");
     expect(summary.categories).toHaveProperty("skill");
     expect(summary.categories).toHaveProperty("postman");
     expect(summary.categories).toHaveProperty("stitch");
-    expect(summary.categories.skill.tools).toHaveLength(5);
+    expect(summary.categories.route.tools).toHaveLength(1);
+    expect(summary.categories.skill.tools).toHaveLength(7);
     expect(summary.categories.postman.tools).toHaveLength(3);
     expect(summary.categories.stitch.tools).toHaveLength(3);
   });

package/mcp/src/tools/registry.ts

@@ -13,11 +13,12 @@
 
 import { z } from "zod";
 import type { VaultManifest } from "../vault/types.js";
+import type { RouteManifest } from "../routes/types.js";
 import type { ConfigScope } from "../cbxConfig/types.js";
 
 // ─── Core types ─────────────────────────────────────────────
 
-export type ToolCategory = "skill" | "postman" | "stitch";
+export type ToolCategory = "skill" | "route" | "postman" | "stitch";
 
 export interface ToolRegistryEntry {
   /** Tool name exposed to MCP clients. */
@@ -39,6 +40,7 @@ export interface ToolRegistryEntry {
 
 export interface ToolRuntimeContext {
   manifest: VaultManifest;
+  routeManifest: RouteManifest;
   charsPerToken: number;
   summaryMaxLength: number;
   defaultConfigScope: ConfigScope | "auto";
@@ -46,6 +48,13 @@ export interface ToolRuntimeContext {
 
 // ─── Tool imports ───────────────────────────────────────────
 
+import {
+  routeResolveName,
+  routeResolveDescription,
+  routeResolveSchema,
+  handleRouteResolve,
+} from "./routeResolve.js";
+
 import {
   skillListCategoriesName,
   skillListCategoriesDescription,
@@ -67,6 +76,13 @@ import {
   handleSkillSearch,
 } from "./skillSearch.js";
 
+import {
+  skillValidateName,
+  skillValidateDescription,
+  skillValidateSchema,
+  handleSkillValidate,
+} from "./skillValidate.js";
+
 import {
   skillGetName,
   skillGetDescription,
@@ -74,6 +90,13 @@ import {
   handleSkillGet,
 } from "./skillGet.js";
 
+import {
+  skillGetReferenceName,
+  skillGetReferenceDescription,
+  skillGetReferenceSchema,
+  handleSkillGetReference,
+} from "./skillGetReference.js";
+
 import {
   skillBudgetReportName,
   skillBudgetReportDescription,
@@ -140,6 +163,19 @@ function withDefaultScope(
 // ─── Registry ───────────────────────────────────────────────
 
 export const TOOL_REGISTRY: readonly ToolRegistryEntry[] = [
+  // ── Route tools ───────────────────────────────────────────
+  {
+    name: routeResolveName,
+    description: routeResolveDescription,
+    schema: routeResolveSchema,
+    category: "route",
+    createHandler: (ctx) => async (args) =>
+      handleRouteResolve(
+        args as z.infer<typeof routeResolveSchema>,
+        ctx.routeManifest,
+      ),
+  },
+
   // ── Skill vault tools ─────────────────────────────────────
   {
     name: skillListCategoriesName,
@@ -175,6 +211,18 @@ export const TOOL_REGISTRY: readonly ToolRegistryEntry[] = [
         ctx.charsPerToken,
       ),
   },
+  {
+    name: skillValidateName,
+    description: skillValidateDescription,
+    schema: skillValidateSchema,
+    category: "skill",
+    createHandler: (ctx) => async (args) =>
+      handleSkillValidate(
+        args as z.infer<typeof skillValidateSchema>,
+        ctx.manifest,
+        ctx.charsPerToken,
+      ),
+  },
   {
     name: skillGetName,
     description: skillGetDescription,
@@ -187,6 +235,18 @@ export const TOOL_REGISTRY: readonly ToolRegistryEntry[] = [
         ctx.charsPerToken,
       ),
   },
+  {
+    name: skillGetReferenceName,
+    description: skillGetReferenceDescription,
+    schema: skillGetReferenceSchema,
+    category: "skill",
+    createHandler: (ctx) => async (args) =>
+      handleSkillGetReference(
+        args as z.infer<typeof skillGetReferenceSchema>,
+        ctx.manifest,
+        ctx.charsPerToken,
+      ),
+  },
   {
     name: skillBudgetReportName,
     description: skillBudgetReportDescription,