@vellumai/assistant 0.4.11 → 0.4.13

package/src/__tests__/skill-mirror-parity.test.ts

@@ -1,176 +0,0 @@
-/**
- * Drift guard: asserts parity between mirrored first-party skill directories.
- *
- * Skills that exist in both `assistant/src/config/vellum-skills/` (embedded in
- * the runtime) and `skills/` (top-level repo, fetched from GitHub at runtime)
- * must have identical SKILL.md content. The catalog.json entries for shared
- * skills must also match.
- *
- * This test prevents silent drift between the two copies. When a skill is
- * updated in one location but not the other, this test fails with a clear
- * message indicating which skill and file diverged.
- */
-
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-
-import { describe, expect, test } from 'bun:test';
-
-// ---------------------------------------------------------------------------
-// Paths
-// ---------------------------------------------------------------------------
-
-const ASSISTANT_DIR = resolve(__dirname, '..', '..');
-const REPO_ROOT = resolve(ASSISTANT_DIR, '..');
-
-const EMBEDDED_SKILLS_DIR = join(ASSISTANT_DIR, 'src', 'config', 'vellum-skills');
-const TOPLEVEL_SKILLS_DIR = join(REPO_ROOT, 'skills');
-
-const EMBEDDED_CATALOG = join(EMBEDDED_SKILLS_DIR, 'catalog.json');
-const TOPLEVEL_CATALOG = join(TOPLEVEL_SKILLS_DIR, 'catalog.json');
-
-// ---------------------------------------------------------------------------
-// Skills that exist only in the top-level `skills/` directory and have no
-// embedded source in `assistant/src/config/vellum-skills/`. These are
-// community/third-party skills maintained outside the assistant runtime.
-// ---------------------------------------------------------------------------
-
-const TOPLEVEL_ONLY_SKILLS = new Set([
-  'doordash',
-  'google-oauth-setup',
-  'notion',
-  'notion-oauth-setup',
-  'oauth-setup',
-]);
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-interface CatalogEntry {
-  id: string;
-  name: string;
-  description: string;
-  emoji: string;
-  includes?: string[];
-}
-
-interface Catalog {
-  description: string;
-  version: number;
-  skills: CatalogEntry[];
-}
-
-/** List subdirectories (skill directories) in a given parent. */
-function listSkillDirs(parent: string): string[] {
-  if (!existsSync(parent)) return [];
-  return readdirSync(parent).filter((entry) => {
-    const full = join(parent, entry);
-    return statSync(full).isDirectory();
-  });
-}
-
-/** Find skill IDs that exist as directories in both locations. */
-function findSharedSkills(): string[] {
-  const embedded = new Set(listSkillDirs(EMBEDDED_SKILLS_DIR));
-  const toplevel = new Set(listSkillDirs(TOPLEVEL_SKILLS_DIR));
-  return [...embedded].filter((id) => toplevel.has(id)).sort();
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('Skill mirror parity — embedded ↔ top-level', () => {
-  const sharedSkills = findSharedSkills();
-
-  test('at least one shared skill exists (sanity check)', () => {
-    expect(sharedSkills.length).toBeGreaterThan(0);
-  });
-
-  // ── Every top-level skill must have an embedded source ──────────────────
-
-  test('every top-level skill directory has a corresponding embedded directory', () => {
-    const embedded = new Set(listSkillDirs(EMBEDDED_SKILLS_DIR));
-    const toplevel = listSkillDirs(TOPLEVEL_SKILLS_DIR);
-
-    const missingFromEmbedded = toplevel.filter(
-      (id) => !embedded.has(id) && !TOPLEVEL_ONLY_SKILLS.has(id),
-    );
-
-    expect(missingFromEmbedded).toEqual([]);
-  });
-
-  // ── SKILL.md content parity ─────────────────────────────────────────────
-
-  for (const skillId of sharedSkills) {
-    test(`${skillId}/SKILL.md content matches between embedded and top-level`, () => {
-      const embeddedPath = join(EMBEDDED_SKILLS_DIR, skillId, 'SKILL.md');
-      const toplevelPath = join(TOPLEVEL_SKILLS_DIR, skillId, 'SKILL.md');
-
-      const embeddedExists = existsSync(embeddedPath);
-      const toplevelExists = existsSync(toplevelPath);
-
-      if (!embeddedExists && !toplevelExists) {
-        // Neither has a SKILL.md — acceptable, no parity violation
-        return;
-      }
-
-      // If one exists but not the other, that is a drift violation
-      expect(embeddedExists).toBe(
-        toplevelExists,
-      );
-
-      if (!embeddedExists || !toplevelExists) return;
-
-      const embeddedContent = readFileSync(embeddedPath, 'utf-8');
-      const toplevelContent = readFileSync(toplevelPath, 'utf-8');
-
-      expect(embeddedContent).toBe(toplevelContent);
-    });
-  }
-
-  // ── Every top-level catalog entry must have an embedded source ──────────
-
-  test('every top-level catalog entry exists in the embedded catalog', () => {
-    expect(existsSync(EMBEDDED_CATALOG)).toBe(true);
-    expect(existsSync(TOPLEVEL_CATALOG)).toBe(true);
-
-    const embeddedCatalog: Catalog = JSON.parse(readFileSync(EMBEDDED_CATALOG, 'utf-8'));
-    const toplevelCatalog: Catalog = JSON.parse(readFileSync(TOPLEVEL_CATALOG, 'utf-8'));
-
-    const embeddedIds = new Set(embeddedCatalog.skills.map((s) => s.id));
-    const toplevelIds = toplevelCatalog.skills.map((s) => s.id);
-
-    const missingFromEmbedded = toplevelIds.filter(
-      (id) => !embeddedIds.has(id) && !TOPLEVEL_ONLY_SKILLS.has(id),
-    );
-
-    expect(missingFromEmbedded).toEqual([]);
-  });
-
-  // ── Catalog entry parity for shared skills ──────────────────────────────
-
-  test('catalog.json entries match for all shared skills', () => {
-    expect(existsSync(EMBEDDED_CATALOG)).toBe(true);
-    expect(existsSync(TOPLEVEL_CATALOG)).toBe(true);
-
-    const embeddedCatalog: Catalog = JSON.parse(readFileSync(EMBEDDED_CATALOG, 'utf-8'));
-    const toplevelCatalog: Catalog = JSON.parse(readFileSync(TOPLEVEL_CATALOG, 'utf-8'));
-
-    const embeddedMap = new Map(embeddedCatalog.skills.map((s) => [s.id, s]));
-    const toplevelMap = new Map(toplevelCatalog.skills.map((s) => [s.id, s]));
-
-    // Only compare entries that exist in both catalogs
-    const sharedIds = [...embeddedMap.keys()].filter((id) => toplevelMap.has(id));
-
-    expect(sharedIds.length).toBeGreaterThan(0);
-
-    for (const id of sharedIds) {
-      const embedded = embeddedMap.get(id)!;
-      const toplevel = toplevelMap.get(id)!;
-
-      expect(embedded).toEqual(toplevel);
-    }
-  });
-});

package/src/config/vellum-skills/catalog.json

@@ -1,63 +0,0 @@
-{
-  "description": "Manifest of first-party Vellum skills. Fetched from GitHub at runtime so the assistant can discover and install new skills maintained by Vellum.",
-  "version": 1,
-  "skills": [
-    {
-      "id": "chatgpt-import",
-      "name": "ChatGPT Import",
-      "description": "Import conversation history from ChatGPT into Vellum",
-      "emoji": "\ud83d\udce5"
-    },
-    {
-      "id": "deploy-fullstack-vercel",
-      "name": "Deploy Fullstack to Vercel",
-      "description": "Build and deploy a full-stack app (React frontend + Python/FastAPI backend) to Vercel as a serverless demo with seeded data",
-      "emoji": "\ud83d\ude80"
-    },
-    {
-      "id": "document-writer",
-      "name": "Document Writer",
-      "description": "Create and edit long-form documents like blog posts, articles, essays, and reports using the built-in rich text editor",
-      "emoji": "\ud83d\udcdd"
-    },
-    {
-      "id": "slack-oauth-setup",
-      "name": "Slack OAuth Setup",
-      "description": "Create Slack App and OAuth credentials for Slack integration using browser automation",
-      "emoji": "\ud83d\udd11",
-      "includes": ["browser", "public-ingress"]
-    },
-    {
-      "id": "telegram-setup",
-      "name": "Telegram Setup",
-      "description": "Connect a Telegram bot to the Vellum Assistant gateway with automated webhook registration and credential storage",
-      "emoji": "\ud83e\udd16",
-      "includes": ["public-ingress"]
-    },
-    {
-      "id": "twilio-setup",
-      "name": "Twilio Setup",
-      "description": "Configure Twilio credentials and phone numbers for voice calls and SMS messaging",
-      "emoji": "\ud83d\udcf1",
-      "includes": ["public-ingress"]
-    },
-    {
-      "id": "sms-setup",
-      "name": "SMS Setup",
-      "description": "Set up and troubleshoot SMS messaging with guided Twilio configuration, compliance, and verification",
-      "emoji": "\ud83d\udce8"
-    },
-    {
-      "id": "guardian-verify-setup",
-      "name": "Guardian Verify Setup",
-      "description": "Set up guardian verification for SMS, voice, or Telegram channels via outbound verification flow",
-      "emoji": "\ud83d\udd10"
-    },
-    {
-      "id": "trusted-contacts",
-      "name": "Trusted Contacts",
-      "description": "Manage trusted contacts and Telegram invite links \u2014 list, allow, revoke, block users, and create/list/revoke shareable invite links",
-      "emoji": "\ud83d\udc65"
-    }
-  ]
-}

package/src/config/vellum-skills/chatgpt-import/tools/chatgpt-import.ts

@@ -1,295 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-
-import { eq } from 'drizzle-orm';
-import { v4 as uuid } from 'uuid';
-
-import { addMessage, createConversation, setConversationOriginInterfaceIfUnset } from '../../../../memory/conversation-store.js';
-import { getDb } from '../../../../memory/db.js';
-import { conversationKeys,conversations, messages as messagesTable } from '../../../../memory/schema.js';
-import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
-
-// -- ChatGPT export format types --
-
-interface ChatGPTContent {
-  content_type: string;
-  parts?: (string | null | Record<string, unknown>)[];
-}
-
-interface ChatGPTNode {
-  message: {
-    author: { role: string };
-    content: ChatGPTContent;
-    create_time?: number | null;
-  } | null;
-  parent: string | null;
-  children: string[];
-}
-
-interface ChatGPTConversation {
-  id?: string;
-  title: string;
-  create_time: number;
-  update_time: number;
-  current_node: string;
-  mapping: Record<string, ChatGPTNode>;
-}
-
-interface ImportedMessage {
-  role: string;
-  content: Array<{ type: string; text: string }>;
-  createdAt: number;
-}
-
-interface ImportedConversation {
-  sourceId: string;
-  title: string;
-  createdAt: number;
-  updatedAt: number;
-  messages: ImportedMessage[];
-}
-
-// -- Tool entry point --
-
-export async function run(
-  input: Record<string, unknown>,
-  _context: ToolContext,
-): Promise<ToolExecutionResult> {
-  const filePath = input.file_path as string;
-
-  if (!filePath) {
-    return { content: 'Error: file_path is required', isError: true };
-  }
-
-  if (!filePath.endsWith('.zip')) {
-    return { content: 'Error: Only ZIP files are accepted. Please provide the ChatGPT export ZIP file.', isError: true };
-  }
-
-  if (!existsSync(filePath)) {
-    return { content: `Error: File not found: ${filePath}`, isError: true };
-  }
-
-  let imported: ImportedConversation[];
-  try {
-    imported = parseChatGPTExport(filePath);
-  } catch (err) {
-    return {
-      content: `Error parsing export file: ${err instanceof Error ? err.message : String(err)}`,
-      isError: true,
-    };
-  }
-
-  if (imported.length === 0) {
-    return { content: 'No conversations found in the export file.', isError: false };
-  }
-
-  const db = getDb();
-  let importedCount = 0;
-  let skippedCount = 0;
-  let messageCount = 0;
-
-  for (const conv of imported) {
-    const convKey = `chatgpt:${conv.sourceId}`;
-
-    const existing = db
-      .select()
-      .from(conversationKeys)
-      .where(eq(conversationKeys.conversationKey, convKey))
-      .get();
-
-    if (existing) {
-      skippedCount++;
-      continue;
-    }
-
-    const conversation = createConversation(conv.title);
-    const importChannelMetadata = {
-      userMessageChannel: 'vellum',
-      assistantMessageChannel: 'vellum',
-      userMessageInterface: 'vellum',
-      assistantMessageInterface: 'vellum',
-    } as const;
-
-    for (const msg of conv.messages) {
-      await addMessage(conversation.id, msg.role, JSON.stringify(msg.content), importChannelMetadata);
-    }
-
-    // addMessage auto-fills originChannel but not originInterface, so set it explicitly
-    setConversationOriginInterfaceIfUnset(conversation.id, 'vellum');
-
-    // Override timestamps to match ChatGPT originals
-    db.update(conversations)
-      .set({ createdAt: conv.createdAt, updatedAt: conv.updatedAt })
-      .where(eq(conversations.id, conversation.id))
-      .run();
-
-    // Update message timestamps to match ChatGPT originals
-    const dbMessages = db
-      .select({ id: messagesTable.id })
-      .from(messagesTable)
-      .where(eq(messagesTable.conversationId, conversation.id))
-      .orderBy(messagesTable.createdAt)
-      .all();
-
-    for (let i = 0; i < dbMessages.length && i < conv.messages.length; i++) {
-      db.update(messagesTable)
-        .set({ createdAt: conv.messages[i].createdAt })
-        .where(eq(messagesTable.id, dbMessages[i].id))
-        .run();
-    }
-
-    db.insert(conversationKeys)
-      .values({
-        id: uuid(),
-        conversationKey: convKey,
-        conversationId: conversation.id,
-        createdAt: Date.now(),
-      })
-      .run();
-
-    importedCount++;
-    messageCount += conv.messages.length;
-  }
-
-  const lines = [`Imported ${importedCount} conversation(s) with ${messageCount} message(s).`];
-  if (skippedCount > 0) {
-    lines.push(`Skipped ${skippedCount} already-imported conversation(s).`);
-  }
-  return { content: lines.join('\n'), isError: false };
-}
-
-// -- Parser --
-
-function parseChatGPTExport(zipPath: string): ImportedConversation[] {
-  const jsonContent = extractConversationsJsonFromZip(zipPath);
-
-  const raw = JSON.parse(jsonContent);
-  if (!Array.isArray(raw)) {
-    throw new Error('Expected conversations.json to contain a JSON array');
-  }
-
-  const results: ImportedConversation[] = [];
-  for (const conv of raw as ChatGPTConversation[]) {
-    const imported = parseConversation(conv);
-    if (imported) {
-      results.push(imported);
-    }
-  }
-  return results;
-}
-
-function parseConversation(conv: ChatGPTConversation): ImportedConversation | null {
-  const { mapping, current_node } = conv;
-  if (!mapping || !current_node || !mapping[current_node]) return null;
-
-  // Walk from current_node to root via parent pointers, then reverse for chronological order
-  const nodeIds: string[] = [];
-  let nodeId: string | null = current_node;
-  while (nodeId) {
-    nodeIds.push(nodeId);
-    nodeId = mapping[nodeId]?.parent ?? null;
-  }
-  nodeIds.reverse();
-
-  const messages: ImportedMessage[] = [];
-  for (const id of nodeIds) {
-    const node = mapping[id];
-    if (!node?.message) continue;
-
-    const { author, content, create_time } = node.message;
-    const role = author?.role;
-    if (role !== 'user' && role !== 'assistant') continue;
-
-    const text = extractText(content);
-    if (!text) continue;
-
-    messages.push({
-      role,
-      content: [{ type: 'text', text }],
-      createdAt: create_time ? Math.round(create_time * 1000) : Math.round(conv.create_time * 1000),
-    });
-  }
-
-  if (messages.length === 0) return null;
-
-  return {
-    sourceId: conv.id ?? `${conv.title}-${conv.create_time}`,
-    title: conv.title || 'Untitled',
-    createdAt: Math.round(conv.create_time * 1000),
-    updatedAt: Math.round(conv.update_time * 1000),
-    messages,
-  };
-}
-
-function extractText(content: ChatGPTContent): string {
-  if (!content?.parts) return '';
-  return content.parts.filter((p): p is string => typeof p === 'string').join('');
-}
-
-// -- ZIP extraction --
-
-function extractConversationsJsonFromZip(zipPath: string): string {
-  const buffer = readFileSync(zipPath);
-
-  // Find end of central directory record (EOCD signature: 0x06054b50)
-  let eocdOffset = -1;
-  for (let i = buffer.length - 22; i >= 0; i--) {
-    if (buffer[i] === 0x50 && buffer[i + 1] === 0x4b && buffer[i + 2] === 0x05 && buffer[i + 3] === 0x06) {
-      eocdOffset = i;
-      break;
-    }
-  }
-  if (eocdOffset === -1) {
-    throw new Error('Invalid ZIP file: could not find end of central directory');
-  }
-
-  const centralDirOffset = buffer.readUInt32LE(eocdOffset + 16);
-  const centralDirEntries = buffer.readUInt16LE(eocdOffset + 10);
-
-  // Walk central directory to find conversations.json
-  let offset = centralDirOffset;
-  for (let i = 0; i < centralDirEntries; i++) {
-    if (buffer[offset] !== 0x50 || buffer[offset + 1] !== 0x4b || buffer[offset + 2] !== 0x01 || buffer[offset + 3] !== 0x02) {
-      throw new Error('Invalid ZIP central directory entry');
-    }
-
-    const cdCompressedSize = buffer.readUInt32LE(offset + 20);
-    const fileNameLength = buffer.readUInt16LE(offset + 28);
-    const extraLength = buffer.readUInt16LE(offset + 30);
-    const commentLength = buffer.readUInt16LE(offset + 32);
-    const localHeaderOffset = buffer.readUInt32LE(offset + 42);
-    const fileName = buffer.subarray(offset + 46, offset + 46 + fileNameLength).toString('utf-8');
-
-    if (fileName === 'conversations.json' || fileName.endsWith('/conversations.json')) {
-      return extractLocalFile(buffer, localHeaderOffset, cdCompressedSize);
-    }
-
-    offset += 46 + fileNameLength + extraLength + commentLength;
-  }
-
-  throw new Error('conversations.json not found in ZIP file');
-}
-
-function extractLocalFile(buffer: Buffer, offset: number, cdCompressedSize: number): string {
-  if (buffer[offset] !== 0x50 || buffer[offset + 1] !== 0x4b || buffer[offset + 2] !== 0x03 || buffer[offset + 3] !== 0x04) {
-    throw new Error('Invalid ZIP local file header');
-  }
-
-  const compressionMethod = buffer.readUInt16LE(offset + 8);
-  const localCompressedSize = buffer.readUInt32LE(offset + 18);
-  const compressedSize = cdCompressedSize > 0 ? cdCompressedSize : localCompressedSize;
-  const fileNameLength = buffer.readUInt16LE(offset + 26);
-  const extraLength = buffer.readUInt16LE(offset + 28);
-
-  const dataOffset = offset + 30 + fileNameLength + extraLength;
-  const fileData = buffer.subarray(dataOffset, dataOffset + compressedSize);
-
-  if (compressionMethod === 0) {
-    return fileData.toString('utf-8');
-  } else if (compressionMethod === 8) {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const { inflateRawSync } = require('node:zlib') as typeof import('node:zlib');
-    return inflateRawSync(fileData).toString('utf-8');
-  } else {
-    throw new Error(`Unsupported ZIP compression method: ${compressionMethod}`);
-  }
-}

package/src/skills/vellum-catalog-remote.ts

@@ -1,166 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { gunzipSync } from 'node:zlib';
-
-import type { CatalogEntry } from '../tools/skills/vellum-catalog.js';
-import { getLogger } from '../util/logger.js';
-import { readPlatformToken } from '../util/platform.js';
-
-const log = getLogger('vellum-catalog-remote');
-
-const PLATFORM_URL = process.env.VELLUM_ASSISTANT_PLATFORM_URL ?? 'https://assistant.vellum.ai';
-
-const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
-
-interface CatalogManifest {
-  version: number;
-  skills: CatalogEntry[];
-}
-
-let cachedEntries: CatalogEntry[] | null = null;
-let cacheTimestamp = 0;
-
-function getBundledCatalogPath(): string {
-  return join(import.meta.dir, '..', 'config', 'vellum-skills', 'catalog.json');
-}
-
-function loadBundledCatalog(): CatalogEntry[] {
-  try {
-    const raw = readFileSync(getBundledCatalogPath(), 'utf-8');
-    const manifest: CatalogManifest = JSON.parse(raw);
-    return manifest.skills ?? [];
-  } catch (err) {
-    log.warn({ err }, 'Failed to read bundled catalog.json');
-    return [];
-  }
-}
-
-function getBundledSkillContent(skillId: string): string | null {
-  try {
-    const skillPath = join(import.meta.dir, '..', 'config', 'vellum-skills', skillId, 'SKILL.md');
-    return readFileSync(skillPath, 'utf-8');
-  } catch {
-    return null;
-  }
-}
-
-/** Build request headers, including platform token when available. */
-function buildPlatformHeaders(): Record<string, string> {
-  const headers: Record<string, string> = {};
-  const token = readPlatformToken();
-  if (token) {
-    headers['X-Session-Token'] = token;
-  }
-  return headers;
-}
-
-/**
- * Fetch catalog entries from the platform API. Falls back to bundled copy.
- * Reads the platform token from ~/.vellum/platform-token automatically.
- */
-export async function fetchCatalogEntries(): Promise<CatalogEntry[]> {
-  const now = Date.now();
-  if (cachedEntries && now - cacheTimestamp < CACHE_TTL_MS) {
-    return cachedEntries;
-  }
-
-  try {
-    const url = `${PLATFORM_URL}/v1/skills/`;
-    const response = await fetch(url, {
-      headers: buildPlatformHeaders(),
-      signal: AbortSignal.timeout(5000),
-    });
-
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-    }
-
-    const manifest: CatalogManifest = await response.json();
-    const skills = manifest.skills;
-    if (!Array.isArray(skills) || skills.length === 0) {
-      throw new Error('Platform catalog has invalid or empty skills array');
-    }
-    cachedEntries = skills;
-    cacheTimestamp = now;
-    log.info({ count: cachedEntries.length }, 'Fetched vellum-skills catalog from platform API');
-    return cachedEntries;
-  } catch (err) {
-    log.warn({ err }, 'Failed to fetch catalog from platform API, falling back to bundled copy');
-    const bundled = loadBundledCatalog();
-    // Cache the bundled result too so we don't re-fetch on every call during outage
-    cachedEntries = bundled;
-    cacheTimestamp = now;
-    return bundled;
-  }
-}
-
-/**
- * Extract SKILL.md content from a tar archive (uncompressed).
- * Tar format: 512-byte header blocks followed by file data blocks.
- */
-function extractSkillMdFromTar(tarBuffer: Buffer): string | null {
-  let offset = 0;
-  while (offset + 512 <= tarBuffer.length) {
-    const header = tarBuffer.subarray(offset, offset + 512);
-
-    // Check for end-of-archive (two consecutive zero blocks)
-    if (header.every((b) => b === 0)) break;
-
-    // Extract filename (bytes 0-99, null-terminated)
-    const nameEnd = header.indexOf(0, 0);
-    const name = header.subarray(0, Math.min(nameEnd >= 0 ? nameEnd : 100, 100)).toString('utf-8');
-
-    // Extract file size (bytes 124-135, octal string)
-    const sizeStr = header.subarray(124, 136).toString('utf-8').trim();
-    const size = parseInt(sizeStr, 8) || 0;
-
-    offset += 512; // move past header
-
-    if (name.endsWith('SKILL.md') || name === 'SKILL.md') {
-      return tarBuffer.subarray(offset, offset + size).toString('utf-8');
-    }
-
-    // Skip to next header (data blocks are padded to 512 bytes)
-    offset += Math.ceil(size / 512) * 512;
-  }
-  return null;
-}
-
-/**
- * Fetch a skill's SKILL.md content from the platform tar API.
- * GET /v1/skills/{skill_id}/ returns a tar.gz archive containing all skill files.
- * Falls back to bundled copy on failure.
- */
-export async function fetchSkillContent(skillId: string): Promise<string | null> {
-  try {
-    const url = `${PLATFORM_URL}/v1/skills/${encodeURIComponent(skillId)}/`;
-    const response = await fetch(url, {
-      headers: buildPlatformHeaders(),
-      signal: AbortSignal.timeout(15000),
-    });
-
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-    }
-
-    const gzipBuffer = Buffer.from(await response.arrayBuffer());
-    const tarBuffer = gunzipSync(gzipBuffer);
-    const skillMd = extractSkillMdFromTar(tarBuffer);
-
-    if (skillMd) {
-      return skillMd;
-    }
-
-    log.warn({ skillId }, 'SKILL.md not found in platform tar archive, falling back to bundled');
-  } catch (err) {
-    log.warn({ err, skillId }, 'Failed to fetch skill content from platform API, falling back to bundled');
-  }
-
-  return getBundledSkillContent(skillId);
-}
-
-/** Check if a skill ID exists in the catalog. */
-export async function checkVellumSkill(skillId: string): Promise<boolean> {
-  const entries = await fetchCatalogEntries();
-  return entries.some((e) => e.id === skillId);
-}