vellum 0.0.16 → 0.2.0

package/drizzle/meta/_journal.json

@@ -0,0 +1,13 @@
+{
+  "version": "7",
+  "dialect": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "6",
+      "when": 1771173839136,
+      "tag": "0000_dizzy_maggott",
+      "breakpoints": true
+    }
+  ]
+}

package/drizzle.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'drizzle-kit';
+
+export default defineConfig({
+  schema: './src/memory/schema.ts',
+  out: './drizzle',
+  dialect: 'sqlite',
+});

package/eslint.config.mjs

@@ -0,0 +1,17 @@
+import { defineConfig, globalIgnores } from "eslint/config";
+import tseslint from "typescript-eslint";
+
+const eslintConfig = defineConfig([
+  ...tseslint.configs.recommended,
+  globalIgnores(["dist/**", "drizzle/**"]),
+  {
+    rules: {
+      "@typescript-eslint/no-unused-vars": [
+        "error",
+        { argsIgnorePattern: "^_", varsIgnorePattern: "^_" },
+      ],
+    },
+  },
+]);
+
+export default eslintConfig;

package/hook-templates/debug-prompt-logger/hook.json

@@ -0,0 +1,7 @@
+{
+  "name": "debug-prompt-logger",
+  "description": "Logs system prompt and conversation history to stderr when VELLUM_DEBUG=1",
+  "version": "1.0.0",
+  "events": ["pre-llm-call"],
+  "script": "run.sh"
+}

package/hook-templates/debug-prompt-logger/run.sh

@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+# Debug Prompt Logger — prints the system prompt and conversation
+# history before each LLM call. Only active when VELLUM_DEBUG=1.
+
+[ "$VELLUM_DEBUG" != "1" ] && exit 0
+
+data=$(cat)
+
+echo "" >&2
+echo "════════════════════════════════════════════════════════════════" >&2
+echo "  PRE-LLM-CALL" >&2
+echo "════════════════════════════════════════════════════════════════" >&2
+echo "" >&2
+
+# Total output cap (bytes) — prevents unbounded stderr when jq is missing.
+MAX_OUTPUT=200000
+
+if ! command -v jq >/dev/null 2>&1; then
+  echo "(jq not found — install jq for formatted output)" >&2
+  printf '%s' "$data" | head -c "$MAX_OUTPUT" >&2
+  echo "" >&2
+  echo "════════════════════════════════════════════════════════════════" >&2
+  echo "" >&2
+  exit 0
+fi
+
+# System prompt (capped at 5000 chars to avoid flooding stderr)
+echo "── System Prompt ──────────────────────────────────────────────" >&2
+printf '%s' "$data" | jq -r '.systemPrompt // "N/A" | if length > 5000 then .[:5000] + "\n…[truncated]" else . end' >&2
+echo "" >&2
+echo "" >&2
+
+# Message count and model
+model=$(printf '%s' "$data" | jq -r '.model // "unknown"')
+msgCount=$(printf '%s' "$data" | jq '.messages | length')
+toolCount=$(printf '%s' "$data" | jq -r '.toolCount // 0')
+echo "Model: $model | Messages: $msgCount | Tools: $toolCount" >&2
+echo "" >&2
+
+# All messages — truncate per-field to keep output bounded.
+# Max chars per text/tool field (images/files already capped at 1000).
+MAX_FIELD=2000
+
+echo "── Messages ───────────────────────────────────────────────────" >&2
+printf '%s' "$data" | jq -r --argjson maxf "$MAX_FIELD" '
+  def trunc(n): if length > n then .[:n] + "…[truncated]" else . end;
+  .messages[] |
+  "\(.role): " + (
+    if (.content | type) == "string" then
+      .content | trunc($maxf)
+    elif (.content | type) == "array" then
+      [.content[] |
+        if .type == "text" then (.text | trunc($maxf))
+        elif .type == "image" then "[image: \(.source.media_type // "unknown")] \(.source.data[:1000])..."
+        elif .type == "file" then "[file: \(.source.filename // "unknown")] \(.source.data[:1000])..."
+        elif .type == "tool_use" then "[tool_use: \(.name)] \(.input | tostring | trunc($maxf))"
+        elif .type == "tool_result" then "[tool_result: \(.content // "" | tostring | trunc($maxf))]"
+        else "[" + .type + "] " + (. | tostring | trunc($maxf))
+        end
+      ] | join(" | ")
+    else
+      "(empty)"
+    end
+  )
+' >&2
+echo "" >&2
+echo "════════════════════════════════════════════════════════════════" >&2
+echo "" >&2

package/knip.json

@@ -0,0 +1,9 @@
+{
+  "project": [
+    "src/**/*.ts",
+    "scripts/**/*.ts"
+  ],
+  "ignore": [
+    "src/**/__tests__/**"
+  ]
+}

package/package.json

@@ -1,19 +1,69 @@
 {
   "name": "vellum",
-  "version": "0.0.16",
-  "description": "",
-  "main": "dist/cli.js",
+  "version": "0.2.0",
+  "type": "module",
   "bin": {
-    "vellum": "dist/cli.js"
+    "vellum": "./src/index.ts"
   },
-  "files": [
-    "dist"
-  ],
   "scripts": {
-    "build": "bun build src/cli.ts --outfile dist/cli.js --target bun"
+    "dev": "bun run src/index.ts",
+    "db:generate": "drizzle-kit generate",
+    "db:push": "drizzle-kit push",
+    "ipc:inventory": "bun run scripts/ipc/check-contract-inventory.ts",
+    "ipc:inventory:update": "bun run scripts/ipc/check-contract-inventory.ts --update",
+    "generate:ipc": "bun run scripts/ipc/generate-swift.ts",
+    "check:ipc-generated": "bun run scripts/ipc/generate-swift.ts --check",
+    "ipc:check-swift-drift": "bun run scripts/ipc/check-swift-decoder-drift.ts",
+    "lint": "eslint",
+    "typecheck": "bunx tsc --noEmit",
+    "test": "bash scripts/test.sh",
+    "test:stable": "EXCLUDE_EXPERIMENTAL=true bash scripts/test.sh",
+    "test:filesystem-tools": "bash scripts/test-filesystem-tools.sh"
   },
-  "license": "GPL-3.0",
   "dependencies": {
-    "dotenv": "^17.3.1"
+    "@anthropic-ai/claude-agent-sdk": "^0.2.42",
+    "@anthropic-ai/sdk": "^0.39.0",
+    "@google/genai": "^1.40.0",
+    "@huggingface/transformers": "^3.8.1",
+    "@qdrant/js-client-rest": "^1.16.2",
+    "@sentry/node": "^10.38.0",
+    "@vellumai/cli": "0.1.1",
+    "@vellumai/vellum-gateway": "^0.1.7",
+    "agentmail": "^0.1.0",
+    "archiver": "^7.0.1",
+    "commander": "^13.1.0",
+    "croner": "^10.0.1",
+    "dotenv": "^17.3.1",
+    "drizzle-orm": "^0.38.4",
+    "ink": "^6.7.0",
+    "jszip": "^3.10.1",
+    "minimatch": "^10.1.2",
+    "openai": "^6.18.0",
+    "pino": "^9.6.0",
+    "pino-pretty": "^13.1.3",
+    "playwright": "^1.58.2",
+    "postgres": "^3.4.8",
+    "react": "^19.2.4",
+    "tldts": "^7.0.23",
+    "tree-sitter-bash": "0.25.1",
+    "uuid": "^11.1.0",
+    "web-tree-sitter": "0.26.5",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@pydantic/logfire-node": "^0.13.0",
+    "@types/archiver": "^7.0.0",
+    "@types/bun": "^1.2.4",
+    "@types/node": "^25.2.2",
+    "@types/react": "^19.2.14",
+    "@types/uuid": "^10.0.0",
+    "drizzle-kit": "^0.30.4",
+    "eslint": "^10.0.0",
+    "fast-check": "^4.5.3",
+    "knip": "^5.83.1",
+    "quicktype-core": "^23.2.6",
+    "typescript": "^5.7.3",
+    "typescript-eslint": "^8.54.0",
+    "typescript-json-schema": "^0.67.1"
   }
 }

package/scripts/ipc/check-contract-inventory.ts

@@ -0,0 +1,104 @@
+/**
+ * Contract inventory snapshot and drift checker.
+ *
+ * Parses ipc-contract.ts to extract the sorted member lists of the
+ * ClientMessage and ServerMessage union types, then compares them
+ * against a checked-in snapshot JSON.
+ *
+ * Usage:
+ *   bun run ipc:inventory          # check for drift (CI / pre-commit)
+ *   bun run ipc:inventory:update   # regenerate the snapshot
+ */
+
+import * as path from 'path';
+import * as fs from 'fs';
+import { extractInventory, type ContractInventory } from '../../src/daemon/ipc-contract-inventory.js';
+
+const CONTRACT_PATH = path.resolve(
+  import.meta.dirname ?? __dirname,
+  '../../src/daemon/ipc-contract.ts',
+);
+
+const SNAPSHOT_PATH = path.resolve(
+  import.meta.dirname ?? __dirname,
+  '../../src/daemon/ipc-contract-inventory.json',
+);
+
+/** Load the checked-in snapshot. Returns null if no snapshot exists. */
+function loadSnapshot(): ContractInventory | null {
+  if (!fs.existsSync(SNAPSHOT_PATH)) {
+    return null;
+  }
+  return JSON.parse(fs.readFileSync(SNAPSHOT_PATH, 'utf-8')) as ContractInventory;
+}
+
+/** Write the snapshot to disk. */
+function writeSnapshot(inventory: ContractInventory): void {
+  fs.writeFileSync(SNAPSHOT_PATH, JSON.stringify(inventory, null, 2) + '\n', 'utf-8');
+}
+
+/** Compute a diff between two sorted string arrays. */
+function diffArrays(
+  label: string,
+  expected: string[],
+  actual: string[],
+): string[] {
+  const lines: string[] = [];
+  const expectedSet = new Set(expected);
+  const actualSet = new Set(actual);
+
+  for (const name of actual) {
+    if (!expectedSet.has(name)) {
+      lines.push(`  + ${label} added: ${name}`);
+    }
+  }
+  for (const name of expected) {
+    if (!actualSet.has(name)) {
+      lines.push(`  - ${label} removed: ${name}`);
+    }
+  }
+
+  return lines;
+}
+
+// --- CLI entry point ---
+
+const isUpdate = process.argv.includes('--update');
+
+const inventory = extractInventory(CONTRACT_PATH);
+
+if (isUpdate) {
+  writeSnapshot(inventory);
+  console.log(`Snapshot updated: ${path.relative(process.cwd(), SNAPSHOT_PATH)}`);
+  console.log(`  ClientMessage members: ${inventory.clientMessageTypes.length}`);
+  console.log(`  ServerMessage members: ${inventory.serverMessageTypes.length}`);
+  process.exit(0);
+}
+
+// Check mode
+const snapshot = loadSnapshot();
+
+if (!snapshot) {
+  console.error(
+    'No snapshot found. Run `bun run ipc:inventory:update` to create one.',
+  );
+  process.exit(1);
+}
+
+const diffs: string[] = [
+  ...diffArrays('ClientMessage', snapshot.clientMessageTypes, inventory.clientMessageTypes),
+  ...diffArrays('ServerMessage', snapshot.serverMessageTypes, inventory.serverMessageTypes),
+];
+
+if (diffs.length > 0) {
+  console.error('IPC contract inventory drift detected:\n');
+  for (const line of diffs) {
+    console.error(line);
+  }
+  console.error(
+    '\nRun `bun run ipc:inventory:update` to update the snapshot.',
+  );
+  process.exit(1);
+}
+
+console.log('IPC contract inventory is up to date.');

package/scripts/ipc/check-swift-decoder-drift.ts

@@ -0,0 +1,163 @@
+/**
+ * TS-contract ↔ Swift-decoder drift checker.
+ *
+ * Compares server wire type literals from the IPC contract against
+ * the decode `case "..."` entries in IPCMessages.swift's ServerMessage enum.
+ * Reports any types present in one side but not the other.
+ *
+ * An allowlist covers contract types that the Swift client intentionally
+ * does not decode (e.g. daemon-internal or CLI-only message types).
+ *
+ * Usage:
+ *   bun run ipc:check-swift-drift    # check for drift
+ */
+
+import * as path from 'path';
+import * as fs from 'fs';
+import { extractInventory } from '../../src/daemon/ipc-contract-inventory.js';
+
+const ROOT = path.resolve(import.meta.dirname ?? __dirname, '../..');
+const CONTRACT_PATH = path.join(ROOT, 'src/daemon/ipc-contract.ts');
+const SWIFT_PATH = path.resolve(
+  ROOT,
+  '../clients/shared/IPC/IPCMessages.swift',
+);
+
+/**
+ * Contract server wire types that the Swift client intentionally does NOT
+ * decode. These are daemon-internal, CLI-only, or not relevant to the
+ * macOS client. Add entries here with a comment explaining why.
+ */
+const SWIFT_OMIT_ALLOWLIST = new Set<string>([
+  // Server-internal events not surfaced to macOS client
+  'context_compacted',
+  'memory_recalled',
+  'model_info',
+  'secret_detected',
+  'sessions_clear_response',
+  'usage_response',
+  'usage_update',
+  // Gallery and cloud sharing — not yet consumed by the macOS client
+  'gallery_install_response',
+  'gallery_list_response',
+  'share_app_cloud_response',
+  // Page publishing — not yet consumed by the macOS client
+  'publish_page_response',
+  'unpublish_page_response',
+  // Watcher messages — not yet consumed by the macOS client
+  'watcher_escalation',
+  'watcher_notification',
+  // Browser handoff — not yet consumed by the macOS client
+  'browser_handoff_request',
+  // Work item messages — not yet consumed by the macOS client
+  'work_item_create_response',
+  'work_item_get_response',
+  'work_item_run_task_response',
+  'work_item_status_changed',
+  'work_item_update_response',
+  'work_items_list_response',
+]);
+
+/**
+ * Valid contract wire types that the inventory extractor cannot parse
+ * because the contract type is a union alias (not a single interface).
+ * These are still legitimate and decoded in Swift.
+ */
+const INVENTORY_UNEXTRACTABLE = new Set<string>([
+  // UiSurfaceShow is a union of UiSurfaceShowCard | UiSurfaceShowForm | ...
+  // The shared wire type 'ui_surface_show' comes from UiSurfaceShowBase.
+  'ui_surface_show',
+]);
+
+/**
+ * Wire types decoded in Swift that don't yet have a corresponding
+ * contract type. These are client-side preparations for upcoming
+ * daemon features.
+ */
+const SWIFT_AHEAD_ALLOWLIST = new Set<string>([
+  // Defined in Swift LayoutConfig.swift ahead of daemon implementation
+  'ui_layout_config',
+]);
+
+// --- Extract Swift decode cases ---
+
+/** Parse `case "wire_type":` patterns from the ServerMessage decoder. */
+function extractSwiftDecodeCases(swiftSource: string): Set<string> {
+  const cases = new Set<string>();
+  // Match: case "some_wire_type":
+  const re = /case\s+"([^"]+)":/g;
+  let match: RegExpExecArray | null;
+
+  // Only scan inside the ServerMessage init(from decoder:) block
+  const decoderStart = swiftSource.indexOf('public init(from decoder: Decoder) throws');
+  if (decoderStart === -1) {
+    throw new Error('Could not find ServerMessage decoder in IPCMessages.swift');
+  }
+
+  const decoderSection = swiftSource.slice(decoderStart);
+
+  while ((match = re.exec(decoderSection)) !== null) {
+    cases.add(match[1]);
+  }
+
+  return cases;
+}
+
+// --- Main ---
+
+const inventory = extractInventory(CONTRACT_PATH);
+// Combine extractable wire types with known-unextractable ones
+const contractServerTypes = new Set([
+  ...inventory.serverWireTypes,
+  ...INVENTORY_UNEXTRACTABLE,
+]);
+
+const swiftSource = fs.readFileSync(SWIFT_PATH, 'utf-8');
+const swiftDecodeCases = extractSwiftDecodeCases(swiftSource);
+
+const diffs: string[] = [];
+
+// Types in contract but not decoded in Swift (and not in omit allowlist)
+for (const wireType of contractServerTypes) {
+  if (!swiftDecodeCases.has(wireType) && !SWIFT_OMIT_ALLOWLIST.has(wireType)) {
+    diffs.push(`  + Contract has "${wireType}" but Swift does not decode it`);
+  }
+}
+
+// Types decoded in Swift but not in contract
+for (const wireType of swiftDecodeCases) {
+  if (!contractServerTypes.has(wireType) && !SWIFT_AHEAD_ALLOWLIST.has(wireType)) {
+    diffs.push(`  - Swift decodes "${wireType}" but it is not in the contract`);
+  }
+}
+
+// Stale allowlist entries
+for (const wireType of SWIFT_OMIT_ALLOWLIST) {
+  if (!contractServerTypes.has(wireType)) {
+    diffs.push(`  ? Omit-allowlist entry "${wireType}" is not in the contract (stale?)`);
+  }
+}
+for (const wireType of INVENTORY_UNEXTRACTABLE) {
+  if (!swiftDecodeCases.has(wireType)) {
+    diffs.push(`  ? Unextractable entry "${wireType}" is not decoded in Swift (stale?)`);
+  }
+}
+for (const wireType of SWIFT_AHEAD_ALLOWLIST) {
+  if (contractServerTypes.has(wireType)) {
+    diffs.push(`  ? Ahead-allowlist entry "${wireType}" is now in the contract (remove from allowlist)`);
+  }
+}
+
+if (diffs.length > 0) {
+  console.error('IPC Swift decoder drift detected:\n');
+  for (const line of diffs) {
+    console.error(line);
+  }
+  console.error(
+    '\nFix: update IPCMessages.swift decode cases, the contract, or the',
+    'allowlist in check-swift-decoder-drift.ts.',
+  );
+  process.exit(1);
+}
+
+console.log('IPC Swift decoder is in sync with the contract.');