@cubis/foundry 0.3.82 → 0.3.84

package/mcp/src/tools/routeResolve.ts

@@ -1,457 +0,0 @@
-/**
- * Cubis Foundry MCP Server – route_resolve tool.
- *
- * Resolves workflows and custom agents before skill discovery.
- */
-
-import path from "node:path";
-import process from "node:process";
-import { promises as fs } from "node:fs";
-import { z } from "zod";
-import type { RouteEntry, RouteManifest } from "../routes/types.js";
-
-export const routeResolveName = "route_resolve";
-
-export const routeResolveDescription =
-  "Resolve an explicit workflow command, explicit custom agent, compatibility alias, or free-text intent into one workflow/agent route before skill loading.";
-
-export const routeResolveSchema = z.object({
-  intent: z
-    .string()
-    .min(1)
-    .describe(
-      "Explicit workflow command (/mobile), explicit agent (@mobile-developer), compatibility alias ($workflow-mobile / $agent-mobile-developer), or free-text user intent",
-    ),
-});
-
-const ROUTE_STOP_WORDS = new Set([
-  "a",
-  "an",
-  "and",
-  "app",
-  "for",
-  "help",
-  "i",
-  "in",
-  "is",
-  "me",
-  "of",
-  "on",
-  "or",
-  "please",
-  "the",
-  "to",
-  "with",
-]);
-
-const SKILL_CREATOR_OBJECT_SIGNALS = [
-  "skill",
-  "skills",
-  "skill authoring",
-  "skill-authoring",
-  "skill creator",
-  "skill-creator",
-  "skill.md",
-  "power.md",
-  "frontmatter",
-  "metadata",
-  "reference",
-  "references",
-  "sidecar",
-  "sidecars",
-  "mirror",
-  "mirrors",
-];
-
-const SKILL_CREATOR_ACTION_SIGNALS = [
-  "adapt",
-  "author",
-  "build",
-  "check",
-  "create",
-  "design",
-  "fix",
-  "maintain",
-  "migrate",
-  "normalize",
-  "plan",
-  "repair",
-  "review",
-  "scaffold",
-  "spec",
-  "update",
-  "validate",
-  "wire",
-];
-
-const SKILL_CREATOR_PLAN_SIGNALS = ["design", "plan", "spec"];
-const SKILL_CREATOR_REVIEW_SIGNALS = ["audit", "check", "review", "validate"];
-const SKILL_CREATOR_ORCHESTRATE_SIGNALS = [
-  "all platform",
-  "all platforms",
-  "cross platform",
-  "cross-platform",
-  "every platform",
-  "generator",
-  "mirror",
-  "mirrors",
-];
-
-const LANGUAGE_SIGNAL_FILES: Array<{ skillId: string; files: string[] }> = [
-  { skillId: "typescript-pro", files: ["tsconfig.json", "tsconfig.base.json", "deno.json"] },
-  { skillId: "javascript-pro", files: ["package.json"] },
-  { skillId: "python-pro", files: ["pyproject.toml", "requirements.txt", "requirements-dev.txt"] },
-  { skillId: "golang-pro", files: ["go.mod"] },
-  { skillId: "rust-pro", files: ["Cargo.toml"] },
-  { skillId: "csharp-pro", files: [".sln", ".csproj"] },
-  { skillId: "java-pro", files: ["pom.xml", "build.gradle"] },
-  { skillId: "kotlin-pro", files: ["build.gradle.kts", "settings.gradle.kts"] },
-  { skillId: "dart-pro", files: ["pubspec.yaml"] },
-  { skillId: "php-pro", files: ["composer.json"] },
-  { skillId: "ruby-pro", files: ["Gemfile"] },
-  { skillId: "swift-pro", files: ["Package.swift"] },
-];
-
-const LEGACY_WORKFLOW_ALIASES: Record<string, string> = {
-  brainstorm: "plan",
-  qa: "test",
-  incident: "devops",
-  postman: "backend",
-};
-
-const LEGACY_AGENT_ALIASES: Record<string, string> = {
-  "penetration-tester": "security-auditor",
-  "qa-automation-engineer": "test-engineer",
-  "product-owner": "product-manager",
-  "explorer-agent": "code-archaeologist",
-};
-
-function normalize(value: string): string {
-  return value.toLowerCase().replace(/[^a-z0-9@/$+-]+/g, " ").trim();
-}
-
-function tokenize(value: string): string[] {
-  const seen = new Set<string>();
-  return normalize(value)
-    .split(/\s+/)
-    .filter((token) => token.length >= 2 && !ROUTE_STOP_WORDS.has(token))
-    .filter((token) => {
-      if (seen.has(token)) return false;
-      seen.add(token);
-      return true;
-    });
-}
-
-function countTokenMatches(haystack: string, tokens: string[]): number {
-  let matches = 0;
-  for (const token of tokens) {
-    if (haystack.includes(token)) matches += 1;
-  }
-  return matches;
-}
-
-function includesAnyPhrase(normalizedIntent: string, phrases: string[]): boolean {
-  return phrases.some((phrase) => normalizedIntent.includes(phrase));
-}
-
-function isSkillCreatorIntent(intent: string): boolean {
-  const normalizedIntent = normalize(intent);
-  const hasObjectSignal = includesAnyPhrase(
-    normalizedIntent,
-    SKILL_CREATOR_OBJECT_SIGNALS,
-  );
-  if (!hasObjectSignal) return false;
-
-  return includesAnyPhrase(normalizedIntent, SKILL_CREATOR_ACTION_SIGNALS);
-}
-
-function chooseSkillCreatorRoute(
-  intent: string,
-  manifest: RouteManifest,
-): RouteEntry | null {
-  if (!isSkillCreatorIntent(intent)) return null;
-
-  const normalizedIntent = normalize(intent);
-  let preferredRouteId = "create";
-  if (includesAnyPhrase(normalizedIntent, SKILL_CREATOR_REVIEW_SIGNALS)) {
-    preferredRouteId = "review";
-  } else if (includesAnyPhrase(normalizedIntent, SKILL_CREATOR_PLAN_SIGNALS)) {
-    preferredRouteId = "plan";
-  } else if (
-    includesAnyPhrase(normalizedIntent, SKILL_CREATOR_ORCHESTRATE_SIGNALS)
-  ) {
-    preferredRouteId = "orchestrate";
-  }
-
-  return (
-    manifest.routes.find(
-      (entry) => entry.kind === "workflow" && entry.id === preferredRouteId,
-    ) || null
-  );
-}
-
-function buildSearchText(route: RouteEntry): string {
-  return normalize(
-    [
-      route.kind,
-      route.id,
-      route.command || "",
-      route.displayName,
-      route.description,
-      route.primaryAgent,
-      ...route.supportingAgents,
-      ...route.triggers,
-      ...route.primarySkills,
-      ...route.supportingSkills,
-      route.artifacts.codex?.compatibilityAlias || "",
-      route.artifacts.antigravity?.commandFile || "",
-      route.artifacts.copilot?.promptFile || "",
-      route.artifacts.claude?.workflowFile || "",
-      route.artifacts.claude?.agentFile || "",
-    ].join(" "),
-  );
-}
-
-function findExplicitRoute(
-  intent: string,
-  manifest: RouteManifest,
-): { route: RouteEntry; matchedBy: string } | null {
-  const trimmed = intent.trim();
-
-  if (trimmed.startsWith("/")) {
-    const route = manifest.routes.find(
-      (entry) =>
-        entry.kind === "workflow" &&
-        entry.command?.toLowerCase() === trimmed.toLowerCase(),
-    );
-    if (route) return { route, matchedBy: "explicit-workflow-command" };
-
-    const legacyWorkflowId = LEGACY_WORKFLOW_ALIASES[trimmed.slice(1).toLowerCase()];
-    if (legacyWorkflowId) {
-      const legacyRoute = manifest.routes.find(
-        (entry) => entry.kind === "workflow" && entry.id === legacyWorkflowId,
-      );
-      if (legacyRoute) return { route: legacyRoute, matchedBy: "legacy-workflow-alias" };
-    }
-  }
-
-  if (trimmed.startsWith("@")) {
-    const normalizedAgent = trimmed.slice(1).toLowerCase();
-    const route = manifest.routes.find(
-      (entry) => entry.kind === "agent" && entry.id.toLowerCase() === normalizedAgent,
-    );
-    if (route) return { route, matchedBy: "explicit-agent" };
-
-    const legacyAgentId = LEGACY_AGENT_ALIASES[normalizedAgent];
-    if (legacyAgentId) {
-      const legacyRoute = manifest.routes.find(
-        (entry) => entry.kind === "agent" && entry.id.toLowerCase() === legacyAgentId,
-      );
-      if (legacyRoute) return { route: legacyRoute, matchedBy: "legacy-agent-alias" };
-    }
-  }
-
-  if (trimmed.startsWith("$")) {
-    const normalizedAlias = trimmed.toLowerCase();
-    const route = manifest.routes.find(
-      (entry) =>
-        entry.artifacts.codex?.compatibilityAlias?.toLowerCase() === normalizedAlias,
-    );
-    if (route) return { route, matchedBy: "compatibility-alias" };
-  }
-
-  return null;
-}
-
-function resolveByIntent(
-  intent: string,
-  manifest: RouteManifest,
-): { route: RouteEntry; matchedBy: string; score: number } | null {
-  const normalizedIntent = normalize(intent);
-  const tokens = tokenize(intent);
-
-  let best:
-    | { route: RouteEntry; matchedBy: string; score: number; tokenMatches: number }
-    | null = null;
-
-  for (const route of manifest.routes) {
-    const searchText = buildSearchText(route);
-    const phraseMatch =
-      normalizedIntent.length > 0 && searchText.includes(normalizedIntent);
-    const tokenMatches = countTokenMatches(searchText, tokens);
-    const triggerMatches = route.triggers.reduce((sum, trigger) => {
-      return sum + (normalizedIntent.includes(normalize(trigger)) ? 1 : 0);
-    }, 0);
-    const score =
-      (phraseMatch ? 500 : 0) +
-      triggerMatches * 120 +
-      tokenMatches * 40 +
-      (route.kind === "workflow" ? 10 : 0);
-
-    if (score <= 0) continue;
-    if (
-      !best ||
-      score > best.score ||
-      (score === best.score && route.id.localeCompare(best.route.id) < 0)
-    ) {
-      best = {
-        route,
-        matchedBy: triggerMatches > 0 ? "trigger-match" : "intent-match",
-        score,
-        tokenMatches,
-      };
-    }
-  }
-
-  if (!best) return null;
-  if (best.score < 80 && best.tokenMatches < 2) return null;
-  return best;
-}
-
-function buildResolvedPayload(
-  input: string,
-  route: RouteEntry,
-  matchedBy: string,
-  detectedLanguageSkill: string | null,
-) {
-  const primarySkillHint = isSkillCreatorIntent(input)
-    ? "skill-creator"
-    : route.primarySkills[0] || null;
-  return {
-    input,
-    resolved: true,
-    kind: route.kind,
-    id: route.id,
-    command: route.command,
-    agent: route.primaryAgent,
-    primarySkillHint,
-    primarySkills: route.primarySkills,
-    supportingSkills: route.supportingSkills,
-    detectedLanguageSkill,
-    fallbackSkillSearchRecommended: false,
-    matchedBy,
-    explanation:
-      matchedBy === "explicit-workflow-command"
-        ? `Matched explicit workflow command ${route.command}.`
-        : matchedBy === "explicit-agent"
-          ? `Matched explicit agent @${route.id}.`
-          : matchedBy === "legacy-workflow-alias"
-            ? `Matched legacy workflow alias and routed to canonical workflow '${route.id}'.`
-            : matchedBy === "legacy-agent-alias"
-              ? `Matched legacy agent alias and routed to canonical agent @${route.id}.`
-          : matchedBy === "compatibility-alias"
-            ? `Matched compatibility alias ${route.artifacts.codex?.compatibilityAlias}.`
-            : matchedBy === "skill-creator-intent"
-              ? `Matched workflow '${route.id}' and selected skill-creator as the primary skill hint for skill package work.`
-              : `Matched ${route.kind} '${route.id}' from installed route metadata.`,
-    artifacts: route.artifacts,
-  };
-}
-
-async function fileExists(target: string) {
-  try {
-    await fs.stat(target);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function detectLanguageSkillHint() {
-  const cwd = process.cwd();
-  const candidates: string[] = await fs.readdir(cwd).catch(() => []);
-  const has = (fileName: string) => candidates.includes(fileName);
-
-  for (const entry of LANGUAGE_SIGNAL_FILES) {
-    for (const fileName of entry.files) {
-      if (fileName === ".sln" || fileName === ".csproj") {
-        if (candidates.some((item) => item.endsWith(fileName))) {
-          return "csharp-pro";
-        }
-        continue;
-      }
-      if (has(fileName) || (await fileExists(path.join(cwd, fileName)))) {
-        if (entry.skillId === "javascript-pro") {
-          const tsSignals = ["tsconfig.json", "tsconfig.base.json", "deno.json"];
-          if (tsSignals.some((signal) => has(signal))) {
-            return "typescript-pro";
-          }
-        }
-        return entry.skillId;
-      }
-    }
-  }
-  return null;
-}
-
-export async function handleRouteResolve(
-  args: z.infer<typeof routeResolveSchema>,
-  routeManifest: RouteManifest,
-) {
-  const { intent } = args;
-  const detectedLanguageSkill = await detectLanguageSkillHint();
-  const explicit = findExplicitRoute(intent, routeManifest);
-  if (explicit) {
-    const payload = buildResolvedPayload(
-      intent,
-      explicit.route,
-      explicit.matchedBy,
-      detectedLanguageSkill,
-    );
-    return {
-      content: [{ type: "text" as const, text: JSON.stringify(payload, null, 2) }],
-      structuredContent: payload,
-    };
-  }
-
-  const skillCreatorRoute = chooseSkillCreatorRoute(intent, routeManifest);
-  if (skillCreatorRoute) {
-    const payload = buildResolvedPayload(
-      intent,
-      skillCreatorRoute,
-      "skill-creator-intent",
-      detectedLanguageSkill,
-    );
-    return {
-      content: [{ type: "text" as const, text: JSON.stringify(payload, null, 2) }],
-      structuredContent: payload,
-    };
-  }
-
-  const inferred = resolveByIntent(intent, routeManifest);
-  if (inferred) {
-    const payload = buildResolvedPayload(
-      intent,
-      inferred.route,
-      inferred.matchedBy,
-      detectedLanguageSkill,
-    );
-    return {
-      content: [{ type: "text" as const, text: JSON.stringify(payload, null, 2) }],
-      structuredContent: payload,
-    };
-  }
-
-  const payload = {
-    input: intent,
-    resolved: false,
-    kind: null,
-    id: null,
-    command: null,
-    agent: null,
-    primarySkillHint: null,
-    primarySkills: [],
-    supportingSkills: [],
-    detectedLanguageSkill,
-    fallbackSkillSearchRecommended: true,
-    matchedBy: "none",
-    explanation:
-      "No workflow or custom agent matched the current intent. Inspect locally first, then use one narrow skill_search only if the domain is still unclear.",
-    artifacts: null,
-  };
-
-  return {
-    content: [{ type: "text" as const, text: JSON.stringify(payload, null, 2) }],
-    structuredContent: payload,
-  };
-}

package/mcp/src/tools/skillBrowseCategory.ts

@@ -1,83 +0,0 @@
-/**
- * Cubis Foundry MCP Server – skill_browse_category tool.
- *
- * Returns all skills in a given category with truncated descriptions.
- */
-
-import { z } from "zod";
-import type { VaultManifest } from "../vault/types.js";
-import { notFound } from "../utils/errors.js";
-import {
-  buildSkillToolMetrics,
-  estimateTokensFromBytes,
-  estimateTokensFromText,
-} from "../telemetry/tokenBudget.js";
-
-export const skillBrowseCategoryName = "skill_browse_category";
-
-export const skillBrowseCategoryDescription =
-  "Browse skills within a specific category. Returns skill IDs and short descriptions.";
-
-export const skillBrowseCategorySchema = z.object({
-  category: z
-    .string()
-    .describe("The category name to browse (from skill_list_categories)"),
-});
-
-function summarizeDescription(
-  description: string | undefined,
-  maxLength: number,
-): string {
-  const text = String(description || "").trim();
-  if (!text) return "(no description)";
-  if (text.length <= maxLength) return text;
-  return `${text.slice(0, Math.max(0, maxLength - 3))}...`;
-}
-
-export async function handleSkillBrowseCategory(
-  args: z.infer<typeof skillBrowseCategorySchema>,
-  manifest: VaultManifest,
-  summaryMaxLength: number,
-  charsPerToken: number,
-) {
-  const { category } = args;
-
-  if (!manifest.categories.includes(category)) {
-    notFound("Category", category);
-  }
-
-  const matching = manifest.skills.filter((s) => s.category === category);
-  const skills = matching.map((s) => ({
-    id: s.id,
-    description: summarizeDescription(s.description, summaryMaxLength),
-  }));
-  const payload = { category, skills, count: skills.length };
-  const text = JSON.stringify(payload, null, 2);
-  const selectedSkillsEstimatedTokens = matching.reduce(
-    (sum, skill) =>
-      sum + estimateTokensFromBytes(skill.fileBytes, charsPerToken),
-    0,
-  );
-  const metrics = buildSkillToolMetrics({
-    charsPerToken,
-    fullCatalogEstimatedTokens: manifest.fullCatalogEstimatedTokens,
-    responseEstimatedTokens: estimateTokensFromText(text, charsPerToken),
-    selectedSkillsEstimatedTokens,
-    responseCharacterCount: text.length,
-  });
-
-  return {
-    content: [
-      {
-        type: "text" as const,
-        text,
-      },
-    ],
-    structuredContent: {
-      metrics,
-    },
-    _meta: {
-      metrics,
-    },
-  };
-}

package/mcp/src/tools/skillBudgetReport.ts

@@ -1,141 +0,0 @@
-/**
- * Cubis Foundry MCP Server – skill_budget_report tool.
- *
- * Aggregates selected/loaded skill IDs into a deterministic context budget
- * summary using estimated token counts.
- */
-
-import { z } from "zod";
-import type { VaultManifest } from "../vault/types.js";
-import {
-  TOKEN_ESTIMATOR_VERSION,
-  estimateSavings,
-  estimateTokensFromBytes,
-} from "../telemetry/tokenBudget.js";
-
-export const skillBudgetReportName = "skill_budget_report";
-
-export const skillBudgetReportDescription =
-  "Report estimated context/token budget for selected and loaded skills compared to the full skill catalog.";
-
-export const skillBudgetReportSchema = z.object({
-  selectedSkillIds: z
-    .array(z.string())
-    .default([])
-    .describe("Skill IDs selected after search/browse."),
-  loadedSkillIds: z
-    .array(z.string())
-    .default([])
-    .describe("Skill IDs loaded via skill_get."),
-});
-
-function uniqueStrings(values: string[]): string[] {
-  return [...new Set(values.map((value) => String(value)))];
-}
-
-export function handleSkillBudgetReport(
-  args: z.infer<typeof skillBudgetReportSchema>,
-  manifest: VaultManifest,
-  charsPerToken: number,
-) {
-  const selectedSkillIds = uniqueStrings(args.selectedSkillIds ?? []);
-  const loadedSkillIds = uniqueStrings(args.loadedSkillIds ?? []);
-  const skillById = new Map(manifest.skills.map((skill) => [skill.id, skill]));
-
-  const selectedSkills = selectedSkillIds
-    .map((id) => {
-      const skill = skillById.get(id);
-      if (!skill) return null;
-      return {
-        id: skill.id,
-        category: skill.category,
-        estimatedTokens: estimateTokensFromBytes(
-          skill.fileBytes,
-          charsPerToken,
-        ),
-      };
-    })
-    .filter((item): item is NonNullable<typeof item> => Boolean(item));
-
-  const loadedSkills = loadedSkillIds
-    .map((id) => {
-      const skill = skillById.get(id);
-      if (!skill) return null;
-      return {
-        id: skill.id,
-        category: skill.category,
-        estimatedTokens: estimateTokensFromBytes(
-          skill.fileBytes,
-          charsPerToken,
-        ),
-      };
-    })
-    .filter((item): item is NonNullable<typeof item> => Boolean(item));
-
-  const unknownSelectedSkillIds = selectedSkillIds.filter(
-    (id) => !skillById.has(id),
-  );
-  const unknownLoadedSkillIds = loadedSkillIds.filter(
-    (id) => !skillById.has(id),
-  );
-
-  const selectedSkillsEstimatedTokens = selectedSkills.reduce(
-    (sum, skill) => sum + skill.estimatedTokens,
-    0,
-  );
-  const loadedSkillsEstimatedTokens = loadedSkills.reduce(
-    (sum, skill) => sum + skill.estimatedTokens,
-    0,
-  );
-
-  const usedEstimatedTokens =
-    loadedSkills.length > 0
-      ? loadedSkillsEstimatedTokens
-      : selectedSkillsEstimatedTokens;
-  const savings = estimateSavings(
-    manifest.fullCatalogEstimatedTokens,
-    usedEstimatedTokens,
-  );
-
-  const selectedIdSet = new Set(selectedSkills.map((skill) => skill.id));
-  const loadedIdSet = new Set(loadedSkills.map((skill) => skill.id));
-  const skippedSkills = manifest.skills
-    .filter(
-      (skill) => !selectedIdSet.has(skill.id) && !loadedIdSet.has(skill.id),
-    )
-    .map((skill) => skill.id)
-    .sort((a, b) => a.localeCompare(b));
-
-  const payload = {
-    skillLog: {
-      selectedSkills,
-      loadedSkills,
-      skippedSkills,
-      unknownSelectedSkillIds,
-      unknownLoadedSkillIds,
-    },
-    contextBudget: {
-      estimatorVersion: TOKEN_ESTIMATOR_VERSION,
-      charsPerToken,
-      fullCatalogEstimatedTokens: manifest.fullCatalogEstimatedTokens,
-      selectedSkillsEstimatedTokens,
-      loadedSkillsEstimatedTokens,
-      estimatedSavingsTokens: savings.estimatedSavingsTokens,
-      estimatedSavingsPercent: savings.estimatedSavingsPercent,
-      estimated: true,
-    },
-  };
-
-  const text = JSON.stringify(payload, null, 2);
-
-  return {
-    content: [
-      {
-        type: "text" as const,
-        text,
-      },
-    ],
-    structuredContent: payload,
-    _meta: payload,
-  };
-}