@vellumai/assistant 0.6.0 → 0.6.2

package/src/__tests__/cli-memory.test.ts

@@ -1,377 +0,0 @@
-import { rmSync } from "node:fs";
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
-
-import { Command } from "commander";
-import { eq, like } from "drizzle-orm";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../memory/qdrant-client.js", () => ({
-  getQdrantClient: () => ({
-    searchWithFilter: async () => [],
-    hybridSearch: async () => [],
-    upsertPoints: async () => {},
-    deletePoints: async () => {},
-  }),
-  initQdrantClient: () => {},
-}));
-
-// Controllable mock for buildCliProgram
-let mockCommands: { name: string; description: string }[] = [];
-
-function makeMockProgram(): Command {
-  const program = new Command();
-  for (const cmd of mockCommands) {
-    program.command(cmd.name).description(cmd.description);
-  }
-  return program;
-}
-
-mock.module("../cli/program.js", () => ({
-  buildCliProgram: () => makeMockProgram(),
-}));
-
-import { DEFAULT_CONFIG } from "../config/defaults.js";
-
-const TEST_CONFIG = {
-  ...DEFAULT_CONFIG,
-  memory: {
-    ...DEFAULT_CONFIG.memory,
-    enabled: true,
-    extraction: {
-      ...DEFAULT_CONFIG.memory.extraction,
-      useLLM: false,
-    },
-  },
-};
-
-mock.module("../config/loader.js", () => ({
-  loadConfig: () => TEST_CONFIG,
-  getConfig: () => TEST_CONFIG,
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-  invalidateConfigCache: () => {},
-}));
-
-import {
-  buildCliCapabilityStatement,
-  seedCliCommandMemories,
-  upsertCliCapabilityMemory,
-} from "../cli/cli-memory.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
-import { memoryGraphNodes, memoryJobs } from "../memory/schema.js";
-import { ensureDataDir, getDbPath } from "../util/platform.js";
-
-ensureDataDir();
-initializeDb();
-
-afterAll(() => {
-  resetDb();
-});
-
-function resetTables() {
-  const db = getDb();
-  db.run("DELETE FROM memory_embeddings");
-  db.run("DELETE FROM memory_graph_nodes");
-  db.run("DELETE FROM memory_jobs");
-}
-
-// ─── buildCliCapabilityStatement ────────────────────────────────────────────
-
-describe("buildCliCapabilityStatement", () => {
-  test("includes 'assistant' prefix, name, and description", () => {
-    const result = buildCliCapabilityStatement("doctor", "Run diagnostic checks");
-    expect(result).toContain('"assistant doctor"');
-    expect(result).toContain("Run diagnostic checks");
-  });
-
-  test("truncates long statements to 500 chars", () => {
-    const longDesc = "x".repeat(600);
-    const result = buildCliCapabilityStatement("test", longDesc);
-    expect(result.length).toBe(500);
-  });
-});
-
-// ─── upsertCliCapabilityMemory ──────────────────────────────────────────────
-
-describe("upsertCliCapabilityMemory", () => {
-  beforeEach(resetTables);
-
-  test("inserts with correct type, content, confidence, significance", () => {
-    upsertCliCapabilityMemory("doctor", "Run diagnostic checks");
-
-    const db = getDb();
-    const items = db.select().from(memoryGraphNodes).all();
-    expect(items).toHaveLength(1);
-    expect(items[0].type).toBe("procedural");
-    expect(items[0].content).toMatch(/^cli:doctor\n/);
-    expect(items[0].confidence).toBe(1.0);
-    expect(items[0].significance).toBe(0.7);
-    expect(items[0].fidelity).toBe("vivid");
-    expect(items[0].scopeId).toBe("default");
-
-    // Should also enqueue an embed_graph_node job
-    const jobs = db.select().from(memoryJobs).all();
-    expect(jobs).toHaveLength(1);
-    expect(jobs[0].type).toBe("embed_graph_node");
-  });
-
-  test("is idempotent (same entry only touches lastAccessed)", () => {
-    upsertCliCapabilityMemory("doctor", "Run diagnostic checks");
-
-    const db = getDb();
-    const before = db.select().from(memoryGraphNodes).all();
-    expect(before).toHaveLength(1);
-    const originalLastAccessed = before[0].lastAccessed;
-
-    // Upsert again
-    upsertCliCapabilityMemory("doctor", "Run diagnostic checks");
-
-    const after = db.select().from(memoryGraphNodes).all();
-    expect(after).toHaveLength(1);
-    // Same content, so only lastAccessed changes
-    expect(after[0].content).toBe(before[0].content);
-    expect(after[0].lastAccessed).toBeGreaterThanOrEqual(originalLastAccessed);
-
-    // Should NOT enqueue a second embed job (only 1 from initial insert)
-    const jobs = db.select().from(memoryJobs).all();
-    expect(jobs).toHaveLength(1);
-  });
-
-  test("updates content when description changes", () => {
-    upsertCliCapabilityMemory("doctor", "Original description");
-
-    const db = getDb();
-    const before = db.select().from(memoryGraphNodes).all();
-    expect(before).toHaveLength(1);
-    expect(before[0].content).toContain("Original description");
-
-    // Change description
-    upsertCliCapabilityMemory("doctor", "Updated description");
-
-    const after = db.select().from(memoryGraphNodes).all();
-    expect(after).toHaveLength(1);
-    expect(after[0].content).toContain("Updated description");
-    expect(after[0].content).not.toBe(before[0].content);
-
-    // Should enqueue a second embed job
-    const jobs = db.select().from(memoryJobs).all();
-    expect(jobs).toHaveLength(2);
-  });
-
-  test("reactivates soft-deleted items", () => {
-    upsertCliCapabilityMemory("doctor", "Run diagnostic checks");
-
-    const db = getDb();
-    // Soft-delete the item
-    db.update(memoryGraphNodes)
-      .set({ fidelity: "gone" })
-      .where(like(memoryGraphNodes.content, "cli:doctor\n%"))
-      .run();
-
-    const deleted = db.select().from(memoryGraphNodes).all();
-    expect(deleted[0].fidelity).toBe("gone");
-
-    // Clear jobs from initial insert
-    db.run("DELETE FROM memory_jobs");
-
-    // Upsert again — should reactivate
-    upsertCliCapabilityMemory("doctor", "Run diagnostic checks");
-
-    const reactivated = db.select().from(memoryGraphNodes).all();
-    expect(reactivated).toHaveLength(1);
-    expect(reactivated[0].fidelity).toBe("vivid");
-
-    // Should enqueue embed job for reactivated item
-    const jobs = db.select().from(memoryJobs).all();
-    expect(jobs).toHaveLength(1);
-    expect(jobs[0].type).toBe("embed_graph_node");
-  });
-
-  test("does not throw on DB error", () => {
-    resetDb();
-    const db = getDb();
-    db.run("DROP TABLE IF EXISTS memory_graph_nodes");
-
-    expect(() => {
-      upsertCliCapabilityMemory("doctor", "Run diagnostic checks");
-    }).not.toThrow();
-
-    // Restore DB state for subsequent tests.
-    resetDb();
-    const dbPath = getDbPath();
-    for (const ext of ["", "-wal", "-shm"]) {
-      rmSync(`${dbPath}${ext}`, { force: true });
-    }
-    initializeDb();
-  });
-});
-
-// ─── seedCliCommandMemories ─────────────────────────────────────────────────
-
-describe("seedCliCommandMemories", () => {
-  beforeEach(() => {
-    resetTables();
-    // Reset mock commands
-    mockCommands = [];
-  });
-
-  test("upserts capability memories for all commands", () => {
-    mockCommands = [
-      { name: "doctor", description: "Run diagnostic checks" },
-      { name: "config", description: "Manage configuration" },
-      { name: "keys", description: "Manage API keys" },
-    ];
-
-    seedCliCommandMemories();
-
-    const db = getDb();
-    const items = db
-      .select()
-      .from(memoryGraphNodes)
-      .where(eq(memoryGraphNodes.type, "procedural"))
-      .all();
-    expect(items).toHaveLength(3);
-
-    const contentPrefixes = items.map((i) => i.content.split("\n")[0]).sort();
-    expect(contentPrefixes).toEqual([
-      "cli:config",
-      "cli:doctor",
-      "cli:keys",
-    ]);
-
-    // All should be vivid
-    for (const item of items) {
-      expect(item.fidelity).toBe("vivid");
-    }
-  });
-
-  test("prunes stale capabilities for commands no longer registered", () => {
-    // First seed with three commands
-    mockCommands = [
-      { name: "doctor", description: "Run diagnostic checks" },
-      { name: "config", description: "Manage configuration" },
-      { name: "keys", description: "Manage API keys" },
-    ];
-    seedCliCommandMemories();
-
-    const db = getDb();
-    const beforeItems = db
-      .select()
-      .from(memoryGraphNodes)
-      .where(eq(memoryGraphNodes.type, "procedural"))
-      .all();
-    expect(beforeItems).toHaveLength(3);
-    expect(beforeItems.every((i) => i.fidelity === "vivid")).toBe(true);
-
-    // Now seed with only doctor — config and keys should be pruned
-    mockCommands = [
-      { name: "doctor", description: "Run diagnostic checks" },
-    ];
-    seedCliCommandMemories();
-
-    const afterItems = db
-      .select()
-      .from(memoryGraphNodes)
-      .where(eq(memoryGraphNodes.type, "procedural"))
-      .all();
-    expect(afterItems).toHaveLength(3); // still 3 rows, but 2 are soft-deleted
-
-    const active = afterItems.filter((i) => i.fidelity === "vivid");
-    const deleted = afterItems.filter((i) => i.fidelity === "gone");
-
-    expect(active).toHaveLength(1);
-    expect(active[0].content).toMatch(/^cli:doctor\n/);
-
-    expect(deleted).toHaveLength(2);
-    const deletedPrefixes = deleted.map((i) => i.content.split("\n")[0]).sort();
-    expect(deletedPrefixes).toEqual(["cli:config", "cli:keys"]);
-  });
-
-  test("handles empty command list without errors", () => {
-    // Pre-populate a CLI command so we can verify it gets pruned
-    upsertCliCapabilityMemory("old-command", "An old command");
-
-    const db = getDb();
-    const beforeItems = db.select().from(memoryGraphNodes).all();
-    expect(beforeItems).toHaveLength(1);
-    expect(beforeItems[0].fidelity).toBe("vivid");
-
-    // Seed with empty commands
-    mockCommands = [];
-    seedCliCommandMemories();
-
-    // The existing command should be pruned (soft-deleted)
-    const afterItems = db.select().from(memoryGraphNodes).all();
-    expect(afterItems).toHaveLength(1);
-    expect(afterItems[0].fidelity).toBe("gone");
-  });
-
-  test("does not prune non-cli capability memories", () => {
-    // Pre-insert a skill capability memory directly into the DB
-    const db = getDb();
-    const now = Date.now();
-    db.insert(memoryGraphNodes)
-      .values({
-        id: "skill-test-item",
-        type: "procedural",
-        content: "skill:test-skill\nThe test skill does things.",
-        fidelity: "vivid",
-        confidence: 1.0,
-        significance: 0.7,
-        sourceType: "inferred",
-        scopeId: "default",
-        created: now,
-        lastAccessed: now,
-        lastConsolidated: now,
-        emotionalCharge: '{"valence":0,"intensity":0.1,"decayCurve":"linear","decayRate":0.05,"originalIntensity":0.1}',
-        stability: 14,
-        reinforcementCount: 0,
-        lastReinforced: now,
-        sourceConversations: "[]",
-        narrativeRole: null,
-        partOfStory: null,
-      })
-      .run();
-
-    // Seed with empty commands — CLI pruner runs but should skip skill:* items
-    mockCommands = [];
-    seedCliCommandMemories();
-
-    const item = db
-      .select()
-      .from(memoryGraphNodes)
-      .where(like(memoryGraphNodes.content, "skill:test-skill\n%"))
-      .get();
-    expect(item).toBeDefined();
-    expect(item!.fidelity).toBe("vivid");
-  });
-
-  test("does not throw on error", () => {
-    mockCommands = [
-      { name: "doctor", description: "Run diagnostic checks" },
-    ];
-
-    // Drop memory_graph_nodes to force a DB error during the prune phase
-    resetDb();
-    const db = getDb();
-    db.run("DROP TABLE IF EXISTS memory_graph_nodes");
-
-    expect(() => {
-      seedCliCommandMemories();
-    }).not.toThrow();
-
-    // Restore DB state for subsequent tests.
-    resetDb();
-    const dbPath = getDbPath();
-    for (const ext of ["", "-wal", "-shm"]) {
-      rmSync(`${dbPath}${ext}`, { force: true });
-    }
-    initializeDb();
-  });
-});

package/src/__tests__/clipboard.test.ts

@@ -1,88 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  extractLastCodeBlock,
-  formatConversationForExport,
-} from "../util/clipboard.js";
-
-describe("formatConversationForExport", () => {
-  test("formats user and assistant messages", () => {
-    const messages = [
-      { role: "user", text: "Hello" },
-      { role: "assistant", text: "Hi there!" },
-    ];
-    expect(formatConversationForExport(messages)).toBe(
-      "you> Hello\n\nassistant> Hi there!",
-    );
-  });
-
-  test("handles a single message", () => {
-    const messages = [{ role: "user", text: "Just me" }];
-    expect(formatConversationForExport(messages)).toBe("you> Just me");
-  });
-
-  test("handles empty messages array", () => {
-    expect(formatConversationForExport([])).toBe("");
-  });
-
-  test("preserves multiline message text", () => {
-    const messages = [{ role: "assistant", text: "Line 1\nLine 2\nLine 3" }];
-    expect(formatConversationForExport(messages)).toBe(
-      "assistant> Line 1\nLine 2\nLine 3",
-    );
-  });
-});
-
-describe("extractLastCodeBlock", () => {
-  test("extracts a simple code block", () => {
-    const text = "```\nhello world\n```";
-    expect(extractLastCodeBlock(text)).toBe("hello world");
-  });
-
-  test("extracts code block with language tag", () => {
-    const text = "```typescript\nconst x = 1;\n```";
-    expect(extractLastCodeBlock(text)).toBe("const x = 1;");
-  });
-
-  test("returns the last code block when multiple exist", () => {
-    const text = "```\nfirst\n```\nsome text\n```\nsecond\n```";
-    expect(extractLastCodeBlock(text)).toBe("second");
-  });
-
-  test("handles empty code blocks", () => {
-    const text = "```\n```";
-    expect(extractLastCodeBlock(text)).toBe("");
-  });
-
-  test("handles empty code blocks with language tag", () => {
-    const text = "```python\n```";
-    expect(extractLastCodeBlock(text)).toBe("");
-  });
-
-  test("does not match inline backticks as closing fence", () => {
-    const text = '```\nconst s = "```"\n```';
-    expect(extractLastCodeBlock(text)).toBe('const s = "```"');
-  });
-
-  test("handles multi-line code blocks", () => {
-    const text = "```js\nfunction foo() {\n  return 42;\n}\n```";
-    expect(extractLastCodeBlock(text)).toBe(
-      "function foo() {\n  return 42;\n}",
-    );
-  });
-
-  test("returns null when no code blocks exist", () => {
-    expect(extractLastCodeBlock("no code here")).toBeNull();
-    expect(extractLastCodeBlock("`inline code`")).toBeNull();
-  });
-
-  test("extracts last block when separated by text", () => {
-    const text = "```\nfirst\n```\nSome explanation\n```\nsecond\n```";
-    expect(extractLastCodeBlock(text)).toBe("second");
-  });
-
-  test("handles non-empty block followed by empty block with text between", () => {
-    const text = "```\nreal code\n```\nSome text\n```\n```";
-    expect(extractLastCodeBlock(text)).toBe("");
-  });
-});

package/src/cli/cli-memory.ts

@@ -1,179 +0,0 @@
-import { and, eq, like, sql } from "drizzle-orm";
-import { v4 as uuid } from "uuid";
-
-import { getDb } from "../memory/db.js";
-import { enqueueMemoryJob } from "../memory/jobs-store.js";
-import { memoryGraphNodes } from "../memory/schema.js";
-import { getLogger } from "../util/logger.js";
-import { buildCliProgram } from "./program.js";
-
-const log = getLogger("cli-memory");
-
-/**
- * Build a capability statement for a CLI command.
- * Truncated to 500 chars max (matching the limit used by memory item extraction).
- */
-export function buildCliCapabilityStatement(
-  name: string,
-  description: string,
-): string {
-  let statement = `The "assistant ${name}" CLI command is available. ${description}.`;
-
-  // Truncate to 500 chars max
-  if (statement.length > 500) {
-    statement = statement.slice(0, 500);
-  }
-
-  return statement;
-}
-
-/** Default emotional charge for capability graph nodes. */
-const DEFAULT_EMOTIONAL_CHARGE = JSON.stringify({
-  valence: 0,
-  intensity: 0.1,
-  decayCurve: "linear",
-  decayRate: 0.05,
-  originalIntensity: 0.1,
-});
-
-/**
- * Upsert a capability memory graph node for a CLI command.
- * Best-effort: errors are logged but never thrown.
- */
-export function upsertCliCapabilityMemory(
-  commandName: string,
-  description: string,
-): void {
-  try {
-    const db = getDb();
-    const statement = buildCliCapabilityStatement(commandName, description);
-    const content = `cli:${commandName}\n${statement}`;
-    const scopeId = "default";
-    const now = Date.now();
-
-    const existing = db
-      .select()
-      .from(memoryGraphNodes)
-      .where(
-        and(
-          eq(memoryGraphNodes.type, "procedural"),
-          like(memoryGraphNodes.content, `cli:${commandName}\n%`),
-          eq(memoryGraphNodes.scopeId, scopeId),
-        ),
-      )
-      .get();
-
-    if (existing) {
-      if (
-        existing.content === content &&
-        existing.fidelity !== "gone"
-      ) {
-        // Same content — just touch lastAccessed
-        db.update(memoryGraphNodes)
-          .set({ lastAccessed: now })
-          .where(eq(memoryGraphNodes.id, existing.id))
-          .run();
-        return;
-      }
-
-      if (existing.fidelity !== "gone") {
-        // Content changed — update content
-        db.update(memoryGraphNodes)
-          .set({
-            content,
-            lastAccessed: now,
-          })
-          .where(eq(memoryGraphNodes.id, existing.id))
-          .run();
-        enqueueMemoryJob("embed_graph_node", { nodeId: existing.id });
-        return;
-      }
-
-      // fidelity === "gone" — reactivate
-      db.update(memoryGraphNodes)
-        .set({
-          fidelity: "vivid",
-          content,
-          created: now,
-          lastAccessed: now,
-        })
-        .where(eq(memoryGraphNodes.id, existing.id))
-        .run();
-      enqueueMemoryJob("embed_graph_node", { nodeId: existing.id });
-      return;
-    }
-
-    // No existing — insert new graph node
-    const id = uuid();
-    db.insert(memoryGraphNodes)
-      .values({
-        id,
-        content,
-        type: "procedural",
-        created: now,
-        lastAccessed: now,
-        lastConsolidated: now,
-        emotionalCharge: DEFAULT_EMOTIONAL_CHARGE,
-        fidelity: "vivid",
-        confidence: 1.0,
-        significance: 0.7,
-        stability: 14,
-        reinforcementCount: 0,
-        lastReinforced: now,
-        sourceConversations: JSON.stringify([]),
-        sourceType: "inferred",
-        narrativeRole: null,
-        partOfStory: null,
-        scopeId,
-      })
-      .run();
-    enqueueMemoryJob("embed_graph_node", { nodeId: id });
-  } catch (err) {
-    log.warn({ err, commandName }, "Failed to upsert CLI capability memory");
-  }
-}
-
-/**
- * Seed capability memory graph nodes for all CLI commands.
- * Prunes stale entries whose commands are no longer registered.
- * Best-effort: errors are logged but never thrown.
- */
-export function seedCliCommandMemories(): void {
-  try {
-    const program = buildCliProgram();
-    const commandNames = new Set<string>();
-
-    for (const cmd of program.commands) {
-      commandNames.add(cmd.name());
-      upsertCliCapabilityMemory(cmd.name(), cmd.description());
-    }
-
-    // Prune stale capability memories for commands no longer registered
-    const db = getDb();
-    const allCapabilities = db
-      .select()
-      .from(memoryGraphNodes)
-      .where(
-        and(
-          eq(memoryGraphNodes.type, "procedural"),
-          eq(memoryGraphNodes.scopeId, "default"),
-          sql`${memoryGraphNodes.fidelity} != 'gone'`,
-        ),
-      )
-      .all();
-
-    const now = Date.now();
-    for (const item of allCapabilities) {
-      if (!item.content.startsWith("cli:")) continue;
-      const itemCommandName = item.content.split("\n")[0].replace("cli:", "");
-      if (!commandNames.has(itemCommandName)) {
-        db.update(memoryGraphNodes)
-          .set({ fidelity: "gone", lastAccessed: now })
-          .where(eq(memoryGraphNodes.id, item.id))
-          .run();
-      }
-    }
-  } catch (err) {
-    log.warn({ err }, "Failed to seed CLI command memories");
-  }
-}

package/src/util/clipboard.ts

@@ -1,34 +0,0 @@
-import { execSync } from "node:child_process";
-
-import { PlatformError } from "./errors.js";
-import { getClipboardCommand } from "./platform.js";
-
-export function copyToClipboard(text: string): void {
-  const cmd = getClipboardCommand();
-  if (!cmd) {
-    throw new PlatformError("Clipboard not supported on this platform");
-  }
-  execSync(cmd, { input: text, stdio: ["pipe", "ignore", "ignore"] });
-}
-
-export function formatConversationForExport(
-  messages: Array<{ role: string; text: string }>,
-): string {
-  return messages
-    .map((m) => {
-      const label = m.role === "user" ? "you" : "assistant";
-      return `${label}> ${m.text}`;
-    })
-    .join("\n\n");
-}
-
-export function extractLastCodeBlock(text: string): string | null {
-  const re = /```[^\n]*\n((?:[\s\S]*?\n)?)```/g;
-  let last: RegExpExecArray | null = null;
-  let m: RegExpExecArray | null;
-  while ((m = re.exec(text)) != null) {
-    last = m;
-  }
-  if (!last) return null;
-  return last[1].trimEnd();
-}