@vellumai/assistant 0.5.6 → 0.5.8

package/src/commands/cc-command-registry.ts

@@ -1,248 +0,0 @@
-import {
-  closeSync,
-  existsSync,
-  openSync,
-  readdirSync,
-  readFileSync,
-  readSync,
-} from "node:fs";
-import { basename, dirname, join, resolve } from "node:path";
-
-import { FRONTMATTER_REGEX } from "../skills/frontmatter.js";
-import { getLogger } from "../util/logger.js";
-
-const log = getLogger("cc-commands");
-
-// ─── Types ───────────────────────────────────────────────────────────────────
-
-export interface CCCommandEntry {
-  /** Command name: basename without .md extension. */
-  name: string;
-  /** First non-empty line after frontmatter, stripped of heading markers. */
-  summary: string;
-  /** Absolute path to the .md file. */
-  filePath: string;
-  /** Directory containing the `.claude/commands/` folder. */
-  source: string;
-}
-
-export interface CCCommandRegistry {
-  /** Commands keyed by lowercase name. */
-  entries: Map<string, CCCommandEntry>;
-  /** Timestamp (ms) when discovery was performed. */
-  discoveredAt: number;
-}
-
-// ─── Constants ───────────────────────────────────────────────────────────────
-
-const COMMAND_NAME_REGEX = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-const DEFAULT_CACHE_TTL_MS = 30_000;
-const MAX_SUMMARY_LENGTH = 100;
-
-/**
- * Maximum bytes to read from each command file during discovery.
- * 1 KiB is enough for frontmatter (typically < 200 B) plus several content
- * lines, which is all we need to extract a one-line summary.
- */
-const SUMMARY_READ_BYTES = 1024;
-
-// ─── Cache ───────────────────────────────────────────────────────────────────
-
-const cache = new Map<string, CCCommandRegistry>();
-
-/** Clear all cached registries. */
-export function invalidateCCCommandCache(): void {
-  cache.clear();
-  log.debug("CC command cache invalidated");
-}
-
-// ─── Partial I/O ─────────────────────────────────────────────────────────────
-
-/**
- * Read at most `maxBytes` from the beginning of a file.
- * Uses low-level `openSync`/`readSync` so we never pull the entire file into
- * memory — important when command templates are large but we only need the
- * first few lines for summary extraction.
- */
-function readFileHead(filePath: string, maxBytes: number): string {
-  const fd = openSync(filePath, "r");
-  try {
-    const buf = Buffer.alloc(maxBytes);
-    const bytesRead = readSync(fd, buf, 0, maxBytes, 0);
-    return buf.toString("utf-8", 0, bytesRead);
-  } finally {
-    closeSync(fd);
-  }
-}
-
-// ─── Summary extraction ──────────────────────────────────────────────────────
-
-/**
- * Extract a one-line summary from the beginning of a markdown file.
- * Skips YAML frontmatter if present, then returns the first non-empty line
- * with leading `#` heading markers stripped. Truncates to 100 chars.
- */
-function extractSummary(content: string): string {
-  // Strip frontmatter if present
-  let body = content;
-  const fmMatch = content.match(FRONTMATTER_REGEX);
-  if (fmMatch) {
-    body = content.slice(fmMatch[0].length);
-  } else if (/^---\r?\n/.test(content)) {
-    if (Buffer.byteLength(content, "utf-8") >= SUMMARY_READ_BYTES) {
-      // Content starts with a frontmatter opening delimiter but the closing
-      // delimiter was not found. The content length reached SUMMARY_READ_BYTES,
-      // so the read was likely truncated — the missing closing `---` is
-      // probably just beyond the read boundary. Return empty rather than
-      // surfacing partial frontmatter fields as a summary.
-      return "";
-    }
-    // Small file that starts with `---` (thematic break or unclosed
-    // frontmatter opener). Skip the leading `---` line and extract the
-    // first real content line from the remainder.
-    body = content.replace(/^---\r?\n/, "");
-  }
-
-  // Find first non-empty line
-  const lines = body.split(/\r?\n/);
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-
-    // Strip leading # heading markers
-    const stripped = trimmed.replace(/^#+\s*/, "");
-    if (!stripped) continue;
-
-    // Truncate if needed
-    if (stripped.length > MAX_SUMMARY_LENGTH) {
-      return stripped.slice(0, MAX_SUMMARY_LENGTH);
-    }
-    return stripped;
-  }
-
-  return "";
-}
-
-// ─── Discovery ───────────────────────────────────────────────────────────────
-
-/**
- * Discover `.claude/commands/*.md` files by walking up from `cwd`.
- * Nearest directory wins on name collisions (child overrides parent).
- * Results are cached per cwd with a 30-second TTL.
- */
-export function discoverCCCommands(
-  cwd: string,
-  ttlMs: number = DEFAULT_CACHE_TTL_MS,
-): CCCommandRegistry {
-  const resolvedCwd = resolve(cwd);
-
-  // Check cache
-  const cached = cache.get(resolvedCwd);
-  if (cached && Date.now() - cached.discoveredAt < ttlMs) {
-    log.debug({ cwd: resolvedCwd }, "CC command cache hit");
-    return cached;
-  }
-
-  log.debug(
-    { cwd: resolvedCwd },
-    "CC command cache miss, discovering commands",
-  );
-
-  const entries = new Map<string, CCCommandEntry>();
-  let current = resolvedCwd;
-
-  // Walk up the directory tree; collect commands from each level.
-  // Since child directories should win on name collisions, we only add entries
-  // that haven't been seen yet (first occurrence = nearest ancestor).
-  while (true) {
-    const commandsDir = join(current, ".claude", "commands");
-
-    if (existsSync(commandsDir)) {
-      try {
-        const files = readdirSync(commandsDir, { withFileTypes: true });
-        for (const file of files) {
-          if (!file.isFile()) continue;
-          if (!file.name.endsWith(".md")) continue;
-
-          const nameWithoutExt = basename(file.name, ".md");
-
-          // Validate command name
-          if (!COMMAND_NAME_REGEX.test(nameWithoutExt)) {
-            log.warn(
-              { fileName: file.name, dir: commandsDir },
-              "Skipping invalid CC command filename",
-            );
-            continue;
-          }
-
-          const key = nameWithoutExt.toLowerCase();
-
-          // Child directories win — skip if already discovered from a closer ancestor
-          if (entries.has(key)) continue;
-
-          const filePath = join(commandsDir, file.name);
-
-          let summary = "";
-          try {
-            const head = readFileHead(filePath, SUMMARY_READ_BYTES);
-            summary = extractSummary(head);
-          } catch (err) {
-            log.warn(
-              { err, filePath },
-              "Failed to read CC command file for summary extraction",
-            );
-          }
-
-          entries.set(key, {
-            name: nameWithoutExt,
-            summary,
-            filePath,
-            source: current,
-          });
-        }
-      } catch (err) {
-        log.warn({ err, commandsDir }, "Failed to read CC commands directory");
-      }
-    }
-
-    const parent = dirname(current);
-    if (parent === current) break; // reached filesystem root
-    current = parent;
-  }
-
-  log.debug(
-    { cwd: resolvedCwd, count: entries.size },
-    "CC command discovery complete",
-  );
-
-  const registry: CCCommandRegistry = {
-    entries,
-    discoveredAt: Date.now(),
-  };
-
-  cache.set(resolvedCwd, registry);
-  return registry;
-}
-
-// ─── Lookup ──────────────────────────────────────────────────────────────────
-
-/**
- * Look up a single CC command by name (case-insensitive).
- */
-export function getCCCommand(
-  cwd: string,
-  name: string,
-): CCCommandEntry | undefined {
-  const registry = discoverCCCommands(cwd);
-  return registry.entries.get(name.toLowerCase());
-}
-
-// ─── Template loading ────────────────────────────────────────────────────────
-
-/**
- * Load the full markdown content of a CC command file.
- * This is deferred to execution time to avoid reading full files during discovery.
- */
-export function loadCCCommandTemplate(entry: CCCommandEntry): string {
-  return readFileSync(entry.filePath, "utf-8");
-}

package/src/config/bundled-skills/claude-code/SKILL.md

@@ -1,53 +0,0 @@
----
-name: claude-code
-description: Delegate coding tasks to Claude Code
-compatibility: "Designed for Vellum personal assistants"
-metadata:
-  emoji: "💻"
-  vellum:
-    display-name: "Claude Code"
----
-
-You are delegating a coding task to Claude Code, an autonomous AI coding agent. Use this skill when the user needs hands-on software engineering work done.
-
-## Capabilities
-
-Claude Code can:
-- Read, write, and edit files across a codebase
-- Run shell commands (build, test, lint, deploy scripts)
-- Perform multi-step engineering tasks autonomously (refactoring, implementing features, debugging)
-- Search codebases for patterns, definitions, and usage
-- Work with git repositories (commits, branches, diffs)
-
-## When to Delegate
-
-Delegate to Claude Code when the task involves:
-- Writing or modifying source code
-- Running build/test/lint commands and iterating on failures
-- Exploring a codebase to answer architectural questions
-- Multi-file refactors or migrations
-- Debugging issues that require reading code and running tests
-- Any task that benefits from direct filesystem and shell access
-
-Do NOT delegate when:
-- The user just wants a conversational answer or explanation
-- The task is pure information retrieval with no code changes needed
-- The user explicitly wants to discuss an approach before implementation
-
-## Guardrails
-
-- Claude Code runs in a sandboxed environment with approval flows for destructive actions
-- File writes, edits, and shell commands that modify state require user confirmation (unless auto-approved by trust rules)
-- Read-only operations (file reads, searches, web fetches) are auto-approved
-- The working directory defaults to the current conversation's working directory but can be overridden
-
-## Worker Profiles
-
-Claude Code supports scoped worker profiles that restrict tool access:
-
-- **general** (default) - Full access to all tools.
-- **researcher** - Read-only access. Can search, read files, and browse the web but cannot write or execute commands.
-- **coder** - Full read/write/execute access optimized for implementation tasks.
-- **reviewer** - Read-only access tailored for code review, with emphasis on analysis and feedback.
-
-Select the profile that best matches the task to enforce least-privilege access.

package/src/config/bundled-skills/claude-code/TOOLS.json

@@ -1,47 +0,0 @@
-{
-  "version": 1,
-  "tools": [
-    {
-      "name": "claude_code",
-      "description": "Delegate a coding task to Claude Code, an AI-powered coding agent that can read, write, and edit files, run shell commands, and perform complex multi-step software engineering tasks autonomously.",
-      "category": "coding",
-      "risk": "medium",
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "prompt": {
-            "type": "string",
-            "description": "The coding task or question for Claude Code to work on. Use this for free-form tasks. Mutually exclusive with command."
-          },
-          "command": {
-            "type": "string",
-            "description": "Name of a .claude/commands/*.md command template to execute. The template will be loaded and $ARGUMENTS substituted before execution. Use this instead of prompt when invoking a named CC command."
-          },
-          "arguments": {
-            "type": "string",
-            "description": "Arguments to substitute into the command template ($ARGUMENTS placeholder). Only used with the command input."
-          },
-          "working_dir": {
-            "type": "string",
-            "description": "Working directory for Claude Code (defaults to conversation working directory)"
-          },
-          "resume": {
-            "type": "string",
-            "description": "Claude Code session ID to resume a previous session"
-          },
-          "model": {
-            "type": "string",
-            "description": "Model to use (defaults to claude-sonnet-4-6)"
-          },
-          "profile": {
-            "type": "string",
-            "enum": ["general", "researcher", "coder", "reviewer"],
-            "description": "Worker profile that scopes tool access. Defaults to general."
-          }
-        }
-      },
-      "executor": "tools/claude-code.ts",
-      "execution_target": "host"
-    }
-  ]
-}

package/src/config/bundled-skills/claude-code/tools/claude-code.ts

@@ -1,12 +0,0 @@
-import { claudeCodeTool } from "../../../../tools/claude-code/claude-code.js";
-import type {
-  ToolContext,
-  ToolExecutionResult,
-} from "../../../../tools/types.js";
-
-export async function run(
-  input: Record<string, unknown>,
-  context: ToolContext,
-): Promise<ToolExecutionResult> {
-  return claudeCodeTool.execute(input, context);
-}

package/src/config/bundled-skills/orchestration/SKILL.md

@@ -1,33 +0,0 @@
----
-name: orchestration
-description: Decompose complex tasks into parallel specialist subtasks
-compatibility: "Designed for Vellum personal assistants"
-metadata:
-  emoji: "\U0001F500"
-  vellum:
-    display-name: "Orchestration"
-    activation-hints:
-      - "Multiple independent work streams that benefit from parallel execution"
-    avoid-when:
-      - "Single-focus tasks -- work directly"
----
-
-Use `swarm_delegate` when facing complex multi-part tasks that benefit from parallel execution. The tool decomposes an objective into independent specialist subtasks, runs them concurrently, and synthesises the results.
-
-## When to use
-
-- The request involves **multiple independent work streams** (e.g. research + coding + review).
-- Tasks can run in parallel without sequential dependencies.
-- The combined work would take significantly longer if done serially.
-
-## When NOT to use
-
-- Simple single-step requests - just do them directly.
-- Tasks that are inherently sequential (each step depends on the previous result).
-- Requests where the user is asking for a quick answer, not a deep workflow.
-
-## Tips
-
-- Provide a clear, specific `objective`. The planner uses it to decompose the work.
-- Pass relevant `context` about the codebase or project when available.
-- The `max_workers` parameter caps concurrency (1-6); the default comes from config.

package/src/config/bundled-skills/orchestration/TOOLS.json

@@ -1,35 +0,0 @@
-{
-  "version": 1,
-  "tools": [
-    {
-      "name": "swarm_delegate",
-      "description": "Decompose a complex task into parallel specialist subtasks and execute them concurrently. Use this for multi-part tasks that benefit from parallel research, coding, and review.",
-      "category": "orchestration",
-      "risk": "medium",
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "objective": {
-            "type": "string",
-            "description": "The complex task to decompose and execute in parallel"
-          },
-          "context": {
-            "type": "string",
-            "description": "Optional additional context about the task or codebase"
-          },
-          "max_workers": {
-            "type": "number",
-            "description": "Maximum concurrent workers (1-6, default from config)"
-          },
-          "activity": {
-            "type": "string",
-            "description": "Brief non-technical explanation of what you are doing and why, shown to the user as a status update. Use simple language a non-technical person would understand."
-          }
-        },
-        "required": ["objective"]
-      },
-      "executor": "tools/swarm-delegate.ts",
-      "execution_target": "host"
-    }
-  ]
-}

package/src/config/bundled-skills/orchestration/tools/swarm-delegate.ts

@@ -1,12 +0,0 @@
-import { swarmDelegateTool } from "../../../../tools/swarm/delegate.js";
-import type {
-  ToolContext,
-  ToolExecutionResult,
-} from "../../../../tools/types.js";
-
-export async function run(
-  input: Record<string, unknown>,
-  context: ToolContext,
-): Promise<ToolExecutionResult> {
-  return swarmDelegateTool.execute(input, context);
-}

package/src/config/schemas/swarm.ts

@@ -1,82 +0,0 @@
-import { z } from "zod";
-
-export const SwarmConfigSchema = z
-  .object({
-    enabled: z
-      .boolean({ error: "swarm.enabled must be a boolean" })
-      .default(true)
-      .describe("Whether swarm (parallel multi-agent) execution is enabled"),
-    maxWorkers: z
-      .number({ error: "swarm.maxWorkers must be a number" })
-      .int("swarm.maxWorkers must be an integer")
-      .positive("swarm.maxWorkers must be a positive integer")
-      .max(6, "swarm.maxWorkers must be at most 6")
-      .default(3)
-      .describe("Maximum number of concurrent swarm workers"),
-    maxTasks: z
-      .number({ error: "swarm.maxTasks must be a number" })
-      .int("swarm.maxTasks must be an integer")
-      .positive("swarm.maxTasks must be a positive integer")
-      .max(20, "swarm.maxTasks must be at most 20")
-      .default(8)
-      .describe("Maximum number of tasks a single swarm can execute"),
-    maxRetriesPerTask: z
-      .number({ error: "swarm.maxRetriesPerTask must be a number" })
-      .int("swarm.maxRetriesPerTask must be an integer")
-      .nonnegative("swarm.maxRetriesPerTask must be a non-negative integer")
-      .max(3, "swarm.maxRetriesPerTask must be at most 3")
-      .default(1)
-      .describe("Maximum number of retries for a failed swarm task"),
-    workerTimeoutSec: z
-      .number({ error: "swarm.workerTimeoutSec must be a number" })
-      .int("swarm.workerTimeoutSec must be an integer")
-      .positive("swarm.workerTimeoutSec must be a positive integer")
-      .default(900)
-      .describe("Timeout for a single swarm worker in seconds"),
-    roleTimeoutsSec: z
-      .object({
-        router: z
-          .number()
-          .int()
-          .positive()
-          .optional()
-          .describe("Timeout override for router workers (seconds)"),
-        researcher: z
-          .number()
-          .int()
-          .positive()
-          .optional()
-          .describe("Timeout override for researcher workers (seconds)"),
-        coder: z
-          .number()
-          .int()
-          .positive()
-          .optional()
-          .describe("Timeout override for coder workers (seconds)"),
-        reviewer: z
-          .number()
-          .int()
-          .positive()
-          .optional()
-          .describe("Timeout override for reviewer workers (seconds)"),
-      })
-      .default({})
-      .describe("Per-role timeout overrides for swarm workers"),
-    plannerModelIntent: z
-      .enum(["latency-optimized", "quality-optimized", "vision-optimized"], {
-        error: "swarm.plannerModelIntent must be a valid model intent",
-      })
-      .default("latency-optimized")
-      .describe("Model selection strategy for the swarm planning phase"),
-    synthesizerModelIntent: z
-      .enum(["latency-optimized", "quality-optimized", "vision-optimized"], {
-        error: "swarm.synthesizerModelIntent must be a valid model intent",
-      })
-      .default("quality-optimized")
-      .describe(
-        "Model selection strategy for the swarm synthesis (result-combining) phase",
-      ),
-  })
-  .describe("Swarm configuration — parallel multi-agent task execution");
-
-export type SwarmConfig = z.infer<typeof SwarmConfigSchema>;

package/src/logfire.ts

@@ -1,135 +0,0 @@
-import { getLogfireToken } from "./config/env.js";
-import type {
-  Message,
-  Provider,
-  ProviderResponse,
-  SendMessageOptions,
-  ToolDefinition,
-} from "./providers/types.js";
-import { getLogger } from "./util/logger.js";
-import { APP_VERSION } from "./version.js";
-
-const log = getLogger("logfire");
-
-type LogfireModule = typeof import("@pydantic/logfire-node");
-
-let logfireEnabled: boolean = !!getLogfireToken();
-
-let logfireInstance: LogfireModule | null = null;
-
-/**
- * Initialize Logfire for LLM observability.
- * Dynamically imports @pydantic/logfire-node only when enabled.
- * Non-fatal on failure (logs warning and continues).
- */
-export async function initLogfire(): Promise<void> {
-  if (!logfireEnabled) return;
-
-  try {
-    const logfire = await import("@pydantic/logfire-node");
-    logfire.configure({
-      token: getLogfireToken(),
-      serviceName: "vellum-assistant",
-      serviceVersion: APP_VERSION,
-    });
-    logfireInstance = logfire;
-    log.info("Logfire initialized");
-  } catch (err) {
-    log.warn(
-      { err },
-      "Failed to initialize Logfire — LLM observability disabled",
-    );
-  }
-}
-
-/**
- * Disable Logfire after early initialization. Called when the user has opted
- * out via the feature flag. Nulls out the instance so future wrapWithLogfire
- * calls become no-ops.
- */
-export function disableLogfire(): void {
-  logfireEnabled = false;
-  logfireInstance = null;
-  log.info("Logfire disabled by feature flag");
-}
-
-/**
- * Wraps a provider with Logfire tracing spans.
- * When logfireEnabled is false, returns the provider as-is (no wrapper allocated).
- */
-export function wrapWithLogfire(provider: Provider): Provider {
-  if (!logfireEnabled) return provider;
-  return new LogfireProvider(provider);
-}
-
-/**
- * Wrapper provider that instruments each sendMessage call with a Logfire span.
- * When Logfire is not initialized, acts as a pure pass-through with zero overhead.
- */
-class LogfireProvider implements Provider {
-  public readonly name: string;
-
-  constructor(private readonly inner: Provider) {
-    this.name = inner.name;
-  }
-
-  async sendMessage(
-    messages: Message[],
-    tools?: ToolDefinition[],
-    systemPrompt?: string,
-    options?: SendMessageOptions,
-  ): Promise<ProviderResponse> {
-    if (!logfireInstance) {
-      return this.inner.sendMessage(messages, tools, systemPrompt, options);
-    }
-
-    const start = Date.now();
-
-    return logfireInstance.span(
-      `llm.${this.name}`,
-      {
-        "llm.provider": this.name,
-        "llm.message_count": messages.length,
-        "llm.tool_count": tools?.length ?? 0,
-      },
-      {},
-      async (span) => {
-        try {
-          const response = await this.inner.sendMessage(
-            messages,
-            tools,
-            systemPrompt,
-            options,
-          );
-          const durationMs = Date.now() - start;
-
-          span.setAttributes({
-            "llm.model": response.model,
-            "llm.stop_reason": response.stopReason,
-            "llm.usage.input_tokens": response.usage.inputTokens,
-            "llm.usage.output_tokens": response.usage.outputTokens,
-            "llm.usage.cache_creation_input_tokens":
-              response.usage.cacheCreationInputTokens ?? 0,
-            "llm.usage.cache_read_input_tokens":
-              response.usage.cacheReadInputTokens ?? 0,
-            "llm.duration_ms": durationMs,
-            "llm.success": true,
-          });
-
-          return response;
-        } catch (error) {
-          const durationMs = Date.now() - start;
-          span.setAttributes({
-            "llm.duration_ms": durationMs,
-            "llm.success": false,
-            "llm.error.type":
-              error instanceof Error ? error.constructor.name : "Unknown",
-            "llm.error.message":
-              error instanceof Error ? error.message : String(error),
-          });
-          throw error;
-        }
-      },
-    );
-  }
-}