@cubis/foundry 0.3.82 → 0.3.84

package/mcp/src/vault/scanner.test.ts

@@ -1,135 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { scanVaultRoots } from "./scanner.js";
-
-const tempDirs: string[] = [];
-
-function createTempDir(prefix: string): string {
-  const dir = mkdtempSync(path.join(os.tmpdir(), prefix));
-  tempDirs.push(dir);
-  return dir;
-}
-
-function createSkill(root: string, id: string): void {
-  const skillDir = path.join(root, id);
-  mkdirSync(skillDir, { recursive: true });
-  writeFileSync(
-    path.join(skillDir, "SKILL.md"),
-    `---\nname: ${id}\ndescription: ${id} description\n---\n`,
-    "utf8",
-  );
-}
-
-function createSkillFromContent(root: string, id: string, content: string): void {
-  const skillDir = path.join(root, id);
-  mkdirSync(skillDir, { recursive: true });
-  writeFileSync(path.join(skillDir, "SKILL.md"), content, "utf8");
-}
-
-afterEach(() => {
-  while (tempDirs.length > 0) {
-    const dir = tempDirs.pop();
-    if (dir) {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  }
-});
-
-describe("scanVaultRoots", () => {
-  it("discovers skill pointers and derives categories from skill ids", async () => {
-    const root = createTempDir("mcp-vault-");
-    createSkill(root, "react-expert");
-    createSkill(root, "database-design");
-    createSkill(root, "custom-skill");
-
-    // Hidden directory should be skipped.
-    const hidden = path.join(root, ".hidden");
-    mkdirSync(hidden, { recursive: true });
-    writeFileSync(path.join(hidden, "SKILL.md"), "ignored", "utf8");
-
-    const skills = await scanVaultRoots([root], "/unused");
-    const byId = Object.fromEntries(
-      skills.map((skill) => [skill.id, skill.category]),
-    );
-
-    expect(skills).toHaveLength(3);
-    expect(byId["react-expert"]).toBe("frontend");
-    expect(byId["database-design"]).toBe("data");
-    expect(byId["custom-skill"]).toBe("general");
-    expect(skills.every((skill) => skill.fileBytes > 0)).toBe(true);
-  });
-
-  it("skips missing roots and continues scanning valid roots", async () => {
-    const validRoot = createTempDir("mcp-vault-valid-");
-    createSkill(validRoot, "qa-automation-engineer");
-
-    const skills = await scanVaultRoots(
-      ["/definitely/missing/root", validRoot],
-      "/unused",
-    );
-
-    expect(skills).toHaveLength(1);
-    expect(skills[0].id).toBe("qa-automation-engineer");
-    expect(skills[0].category).toBe("testing");
-  });
-
-  it("excludes codex wrapper skills from vault discovery", async () => {
-    const root = createTempDir("mcp-vault-wrapper-");
-
-    createSkill(root, "lint-and-validate");
-    createSkill(root, "tdd-workflow");
-    createSkill(root, "workflow-implement-track");
-    createSkill(root, "agent-backend-specialist");
-    createSkillFromContent(
-      root,
-      "custom-wrapper-id",
-      [
-        "---",
-        "name: custom-wrapper-id",
-        "description: Wrapper by metadata only",
-        "metadata:",
-        "  wrapper: workflow",
-        "---",
-        "",
-        "# wrapper",
-        "",
-      ].join("\n"),
-    );
-
-    const skills = await scanVaultRoots([root], "/unused");
-    const ids = skills.map((s) => s.id).sort();
-
-    expect(ids).toEqual(["lint-and-validate", "tdd-workflow"]);
-  });
-
-  it("synthesizes compatibility aliases from canonical metadata", async () => {
-    const root = createTempDir("mcp-vault-alias-");
-    createSkillFromContent(
-      root,
-      "react-best-practices",
-      [
-        "---",
-        "name: react-best-practices",
-        "description: React review checklist",
-        "metadata:",
-        "  aliases: [nextjs-react-expert]",
-        "---",
-        "# Skill",
-      ].join("\n"),
-    );
-
-    const skills = await scanVaultRoots([root], "/unused");
-    const canonical = skills.find((skill) => skill.id === "react-best-practices");
-    const alias = skills.find((skill) => skill.id === "nextjs-react-expert");
-
-    expect(canonical?.canonicalId).toBeUndefined();
-    expect(alias).toMatchObject({
-      id: "nextjs-react-expert",
-      canonicalId: "react-best-practices",
-      category: "frontend",
-      path: canonical?.path,
-    });
-  });
-});

package/mcp/src/vault/scanner.ts

@@ -1,349 +0,0 @@
-/**
- * Cubis Foundry MCP Server – vault scanner.
- *
- * Startup scan: stores only category/name/path metadata (lazy – no full SKILL.md read).
- * Description extraction is deferred to browse/search operations.
- */
-
-import { open, readdir, stat } from "node:fs/promises";
-import path from "node:path";
-import { logger } from "../utils/logger.js";
-import type { SkillPointer } from "./types.js";
-
-/**
- * Scan vault root directories for SKILL.md files.
- * Returns metadata-only pointers; does NOT read file content.
- */
-export async function scanVaultRoots(
-  roots: string[],
-  basePath: string,
-): Promise<SkillPointer[]> {
-  const skillsById = new Map<string, SkillPointer>();
-
-  for (const rootRel of roots) {
-    const rootAbs = path.resolve(basePath, rootRel);
-    let entries: string[];
-    try {
-      entries = await readdir(rootAbs);
-    } catch {
-      logger.warn(`Vault root not found, skipping: ${rootAbs}`);
-      continue;
-    }
-
-    for (const entry of entries) {
-      if (entry.startsWith(".")) continue;
-      const entryPath = path.join(rootAbs, entry);
-      const entryStat = await stat(entryPath).catch(() => null);
-      if (!entryStat?.isDirectory()) continue;
-
-      const skillFile = path.join(entryPath, "SKILL.md");
-      const skillStat = await stat(skillFile).catch(() => null);
-      if (!skillStat?.isFile()) continue;
-
-      // Skip empty SKILL.md files — they provide no instructions
-      if (skillStat.size === 0) {
-        logger.warn(`Skipping empty SKILL.md: ${skillFile}`);
-        continue;
-      }
-
-      const rawPreview = await readFrontmatterPreview(skillFile);
-      const frontmatter = rawPreview ? parseFrontmatter(rawPreview) : null;
-      const wrapperKind = detectWrapperKind(entry, frontmatter);
-      if (wrapperKind) {
-        logger.debug(
-          `Skipping wrapper skill ${entry} (${wrapperKind}) at ${skillFile}`,
-        );
-        continue;
-      }
-
-      const skillPointer: SkillPointer = {
-        id: entry,
-        category: deriveCategory(entry),
-        path: skillFile,
-        fileBytes: skillStat.size,
-      };
-      registerSkillPointer(skillsById, skillPointer);
-
-      for (const aliasId of extractMetadataAliases(frontmatter)) {
-        if (aliasId === entry) continue;
-        registerSkillPointer(skillsById, {
-          id: aliasId,
-          canonicalId: entry,
-          category: skillPointer.category,
-          path: skillFile,
-          fileBytes: skillStat.size,
-        });
-      }
-    }
-  }
-
-  const skills = [...skillsById.values()].sort((a, b) => a.id.localeCompare(b.id));
-  logger.info(`Vault scan complete: ${skills.length} skills discovered`);
-  return skills;
-}
-
-const WRAPPER_PREFIXES = ["workflow-", "agent-"] as const;
-const WRAPPER_KINDS = new Set(["workflow", "agent"]);
-const FRONTMATTER_PREVIEW_BYTES = 8192;
-
-function extractWrapperKindFromId(
-  skillId: string,
-): "workflow" | "agent" | null {
-  const lower = skillId.toLowerCase();
-  if (lower.startsWith(WRAPPER_PREFIXES[0])) return "workflow";
-  if (lower.startsWith(WRAPPER_PREFIXES[1])) return "agent";
-  return null;
-}
-
-async function readFrontmatterPreview(
-  skillFile: string,
-): Promise<string | null> {
-  const handle = await open(skillFile, "r").catch(() => null);
-  if (!handle) return null;
-
-  try {
-    // Read only a small head chunk; wrapper metadata lives in frontmatter.
-    const buffer = Buffer.alloc(FRONTMATTER_PREVIEW_BYTES);
-    const { bytesRead } = await handle.read(
-      buffer,
-      0,
-      FRONTMATTER_PREVIEW_BYTES,
-      0,
-    );
-    return buffer.toString("utf8", 0, bytesRead);
-  } finally {
-    await handle.close();
-  }
-}
-
-function parseFrontmatter(rawPreview: string): string | null {
-  const match = rawPreview.match(/^---\s*\n([\s\S]*?)\n---/);
-  return match?.[1] ?? null;
-}
-
-function parseInlineList(raw: string): string[] {
-  return String(raw || "")
-    .split(",")
-    .map((item) => item.trim().replace(/^['"]|['"]$/g, ""))
-    .filter(Boolean);
-}
-
-function extractMetadataWrapper(frontmatter: string): string | null {
-  const lines = frontmatter.split(/\r?\n/);
-  let inMetadata = false;
-
-  for (const line of lines) {
-    if (!inMetadata) {
-      if (/^\s*metadata\s*:\s*$/.test(line)) {
-        inMetadata = true;
-      }
-      continue;
-    }
-
-    if (!line.trim()) continue;
-    if (!/^\s+/.test(line)) break;
-
-    const match = line.match(/^\s+wrapper\s*:\s*(.+)\s*$/);
-    if (!match) continue;
-
-    const value = match[1]
-      .trim()
-      .replace(/^['"]|['"]$/g, "")
-      .toLowerCase();
-    if (WRAPPER_KINDS.has(value)) {
-      return value;
-    }
-  }
-
-  return null;
-}
-
-function extractMetadataAliases(frontmatter: string | null): string[] {
-  if (!frontmatter) return [];
-  const lines = frontmatter.split(/\r?\n/);
-  let inMetadata = false;
-  const aliases: string[] = [];
-
-  for (let i = 0; i < lines.length; i += 1) {
-    const line = lines[i];
-    if (!inMetadata) {
-      if (/^\s*metadata\s*:\s*$/.test(line)) {
-        inMetadata = true;
-      }
-      continue;
-    }
-
-    if (!line.trim()) continue;
-    if (!/^\s+/.test(line)) break;
-
-    const inlineMatch = line.match(/^\s+aliases\s*:\s*(.+)\s*$/);
-    if (!inlineMatch) continue;
-
-    const rest = inlineMatch[1].trim();
-    if (rest.startsWith("[") && rest.endsWith("]")) {
-      aliases.push(...parseInlineList(rest.slice(1, -1)));
-      break;
-    }
-
-    if (rest) {
-      aliases.push(...parseInlineList(rest));
-      break;
-    }
-
-    for (let j = i + 1; j < lines.length; j += 1) {
-      const next = lines[j];
-      if (!next.trim()) continue;
-      if (/^\s+[A-Za-z0-9_-]+\s*:/.test(next)) {
-        i = j - 1;
-        break;
-      }
-
-      const bullet = next.match(/^\s+-\s*(.+)$/);
-      if (bullet) {
-        aliases.push(bullet[1].trim().replace(/^['"]|['"]$/g, ""));
-      }
-
-      if (j === lines.length - 1) {
-        i = j;
-      }
-    }
-  }
-
-  return [...new Set(aliases.filter(Boolean))];
-}
-
-function registerSkillPointer(
-  skillsById: Map<string, SkillPointer>,
-  pointer: SkillPointer,
-) {
-  const key = pointer.id.toLowerCase();
-  if (!skillsById.has(key)) {
-    skillsById.set(key, pointer);
-    return;
-  }
-
-  const existing = skillsById.get(key);
-  if (!existing) {
-    skillsById.set(key, pointer);
-    return;
-  }
-
-  // Prefer concrete canonical skills over synthetic aliases on collisions.
-  if (existing.canonicalId && !pointer.canonicalId) {
-    skillsById.set(key, pointer);
-    return;
-  }
-
-  if (existing.path !== pointer.path || existing.canonicalId !== pointer.canonicalId) {
-    logger.warn(
-      `Duplicate skill id '${pointer.id}' discovered; keeping first registration at ${existing.path}`,
-    );
-  }
-}
-
-function detectWrapperKind(
-  skillId: string,
-  frontmatter: string | null,
-): "workflow" | "agent" | null {
-  const byId = extractWrapperKindFromId(skillId);
-  if (byId) return byId;
-
-  if (!frontmatter) return null;
-
-  const byMetadata = extractMetadataWrapper(frontmatter);
-  if (byMetadata === "workflow" || byMetadata === "agent") {
-    return byMetadata;
-  }
-
-  return null;
-}
-
-/**
- * Simple category derivation from skill ID conventions.
- * Skills with common prefixes are grouped together.
- */
-function deriveCategory(skillId: string): string {
-  const categoryMap: Record<string, string> = {
-    flutter: "mobile",
-    drift: "mobile",
-    gorouter: "mobile",
-    riverpod: "mobile",
-    react: "frontend",
-    next: "frontend",
-    nextjs: "frontend",
-    tailwind: "frontend",
-    vue: "frontend",
-    frontend: "frontend",
-    nestjs: "backend",
-    fastapi: "backend",
-    fastify: "backend",
-    nodejs: "backend",
-    golang: "backend",
-    rust: "backend",
-    python: "backend",
-    javascript: "backend",
-    typescript: "backend",
-    java: "backend",
-    kotlin: "backend",
-    csharp: "backend",
-    database: "data",
-    graphql: "data",
-    api: "api",
-    openapi: "api",
-    devops: "devops",
-    terraform: "devops",
-    deployment: "devops",
-    vercel: "devops",
-    security: "security",
-    penetration: "security",
-    "red-team": "security",
-    vulnerability: "security",
-    secure: "security",
-    test: "testing",
-    playwright: "testing",
-    qa: "testing",
-    tdd: "testing",
-    "find-bugs": "testing",
-    "fix-review": "testing",
-    monitoring: "observability",
-    sentry: "observability",
-    datadog: "observability",
-    performance: "performance",
-    "web-perf": "performance",
-    git: "tooling",
-    lint: "tooling",
-    cli: "tooling",
-    "clean-code": "practices",
-    plan: "practices",
-    brainstorm: "practices",
-    behavioral: "practices",
-    refactor: "practices",
-    architecture: "architecture",
-    microservices: "architecture",
-    "design-system": "design",
-    "mobile-design": "design",
-    "ui-ux": "design",
-    "web-design": "design",
-    "ux-ui": "design",
-    accessibility: "design",
-    documentation: "documentation",
-    "code-documenter": "documentation",
-    changelog: "documentation",
-    game: "game-dev",
-    seo: "marketing",
-    geo: "marketing",
-    i18n: "localization",
-    mcp: "mcp",
-    prompt: "ai",
-    "vercel-ai": "ai",
-    stripe: "payments",
-    saas: "saas",
-  };
-
-  // Match longest prefix first
-  const lower = skillId.toLowerCase();
-  for (const [prefix, category] of Object.entries(categoryMap)) {
-    if (lower.startsWith(prefix)) return category;
-  }
-  return "general";
-}

package/mcp/src/vault/types.ts

@@ -1,33 +0,0 @@
-/**
- * Cubis Foundry MCP Server – vault types.
- */
-
-export interface SkillPointer {
-  /** Skill identifier (directory name). */
-  id: string;
-  /** Canonical skill identifier when this pointer is a compatibility alias. */
-  canonicalId?: string;
-  /** Category derived from parent directory or frontmatter. */
-  category: string;
-  /** Absolute path to the SKILL.md file. */
-  path: string;
-  /** Skill file size in bytes. */
-  fileBytes: number;
-  /** Short description extracted from frontmatter (truncated). */
-  description?: string;
-  /** Structured keywords from the generated manifest. */
-  keywords?: string[];
-  /** Structured triggers from the generated manifest. */
-  triggers?: string[];
-}
-
-export interface VaultManifest {
-  /** All categories discovered. */
-  categories: string[];
-  /** All skill pointers (metadata only – no full content). */
-  skills: SkillPointer[];
-  /** Total bytes across all discovered SKILL.md files. */
-  fullCatalogBytes: number;
-  /** Estimated full-catalog token usage (deterministic estimator). */
-  fullCatalogEstimatedTokens: number;
-}

package/mcp/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "lib": ["ES2022"],
-    "outDir": "dist",
-    "rootDir": "src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true
-  },
-  "include": ["src"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts"]
-}

package/src/cli/build/commands.ts

@@ -1,39 +0,0 @@
-import type { Command } from "commander";
-import type { WorkflowAction } from "../types.js";
-
-export interface BuildCommandDeps {
-  runBuildArchitecture: WorkflowAction;
-}
-
-export function registerBuildCommands(
-  program: Command,
-  deps: BuildCommandDeps,
-) {
-  const buildCommand = program
-    .command("build")
-    .description("Run strict platform-native build helpers");
-
-  buildCommand
-    .command("architecture")
-    .description(
-      "Refresh docs/foundation backbone docs and ADR scaffolds via a strict platform-native CLI subprocess",
-    )
-    .requiredOption(
-      "--platform <platform>",
-      "architecture build platform: codex|claude|gemini|copilot",
-    )
-    .option(
-      "--research <mode>",
-      "research mode: auto|always|never",
-      "auto",
-    )
-    .option("--check", "report managed architecture-doc drift without writing")
-    .option("--overwrite", "overwrite existing managed scaffolding when needed")
-    .option("--dry-run", "probe the target CLI and print the planned invocation")
-    .option("--json", "output JSON")
-    .action(deps.runBuildArchitecture);
-
-  buildCommand.action(() => {
-    buildCommand.help();
-  });
-}