@vellumai/assistant 0.6.0 → 0.6.1

package/src/__tests__/identity-routes.test.ts

@@ -0,0 +1,328 @@
+/**
+ * Tests for identity/health route handlers, focusing on profiler metadata
+ * in /v1/health and /v1/healthz responses.
+ *
+ * Proves:
+ * - Backward compatibility: health endpoints return expected shape when
+ *   profiler mode is off (no env vars).
+ * - Profiler payload: when profiler env vars are set, the response includes
+ *   a `profiler` object with the expected structure and budget state.
+ * - Artifact detection: when run manifests and Bun summary files exist,
+ *   the response correctly reports artifact counts and lastCompletedRun.
+ */
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// Silence logger before any imports that use it
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import { handleDetailedHealth } from "../runtime/routes/identity-routes.js";
+import { getWorkspaceDir } from "../util/platform.js";
+
+// ── Env helpers ─────────────────────────────────────────────────────────
+
+let savedEnv: Record<string, string | undefined>;
+
+const PROFILER_ENV_KEYS = [
+  "VELLUM_PROFILER_RUN_ID",
+  "VELLUM_PROFILER_MODE",
+  "VELLUM_PROFILER_MAX_BYTES",
+  "VELLUM_PROFILER_MAX_RUNS",
+  "VELLUM_PROFILER_MIN_FREE_MB",
+] as const;
+
+function clearProfilerEnv(): void {
+  for (const key of PROFILER_ENV_KEYS) {
+    delete process.env[key];
+  }
+}
+
+function setProfilerEnv(
+  mode: string,
+  runId: string,
+  opts?: { maxBytes?: number; maxRuns?: number; minFreeMb?: number },
+): void {
+  process.env.VELLUM_PROFILER_RUN_ID = runId;
+  process.env.VELLUM_PROFILER_MODE = mode;
+  if (opts?.maxBytes !== undefined) {
+    process.env.VELLUM_PROFILER_MAX_BYTES = String(opts.maxBytes);
+  }
+  if (opts?.maxRuns !== undefined) {
+    process.env.VELLUM_PROFILER_MAX_RUNS = String(opts.maxRuns);
+  }
+  if (opts?.minFreeMb !== undefined) {
+    process.env.VELLUM_PROFILER_MIN_FREE_MB = String(opts.minFreeMb);
+  }
+}
+
+// ── Filesystem helpers ──────────────────────────────────────────────────
+
+function ensureProfilerRunDir(runId: string): string {
+  const wsDir = getWorkspaceDir();
+  const runDir = join(wsDir, "data", "profiler", "runs", runId);
+  mkdirSync(runDir, { recursive: true });
+  return runDir;
+}
+
+function writeRunManifest(
+  runId: string,
+  manifest: {
+    status: "active" | "completed";
+    createdAt?: string;
+    updatedAt?: string;
+    completedAt?: string;
+    totalBytes?: number;
+  },
+): void {
+  const runDir = ensureProfilerRunDir(runId);
+  const m: Record<string, unknown> = {
+    runId,
+    status: manifest.status,
+    createdAt: manifest.createdAt ?? new Date().toISOString(),
+    updatedAt: manifest.updatedAt ?? new Date().toISOString(),
+    totalBytes: manifest.totalBytes ?? 0,
+  };
+  if (manifest.completedAt) {
+    m.completedAt = manifest.completedAt;
+  }
+  writeFileSync(join(runDir, "manifest.json"), JSON.stringify(m, null, 2));
+}
+
+function writeArtifactFile(
+  runId: string,
+  filename: string,
+  sizeBytes: number,
+): void {
+  const runDir = ensureProfilerRunDir(runId);
+  writeFileSync(join(runDir, filename), Buffer.alloc(sizeBytes));
+}
+
+// ── Setup / teardown ────────────────────────────────────────────────────
+
+beforeEach(() => {
+  savedEnv = {};
+  for (const key of PROFILER_ENV_KEYS) {
+    savedEnv[key] = process.env[key];
+  }
+  clearProfilerEnv();
+
+  // Clean up any profiler run directories from previous tests so
+  // rescanRuns() doesn't pick up stale state in the shared workspace.
+  const profilerRunsDir = join(getWorkspaceDir(), "data", "profiler", "runs");
+  if (existsSync(profilerRunsDir)) {
+    rmSync(profilerRunsDir, { recursive: true, force: true });
+  }
+});
+
+afterEach(() => {
+  for (const [key, value] of Object.entries(savedEnv)) {
+    if (value === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+});
+
+// ── Tests ───────────────────────────────────────────────────────────────
+
+describe("identity routes — health endpoint", () => {
+  describe("backward compatibility (profiler disabled)", () => {
+    test("/v1/health returns expected shape without profiler key when env vars are absent", async () => {
+      const res = handleDetailedHealth();
+      expect(res.status).toBe(200);
+
+      const body = (await res.json()) as Record<string, unknown>;
+      expect(body.status).toBe("healthy");
+      expect(body.timestamp).toBeDefined();
+      expect(body.version).toBeDefined();
+      expect(body.disk).toBeDefined();
+      expect(body.memory).toBeDefined();
+      expect(body.cpu).toBeDefined();
+      expect(body.migrations).toBeDefined();
+
+      // Profiler should either be absent or show enabled: false
+      if ("profiler" in body) {
+        const profiler = body.profiler as Record<string, unknown>;
+        expect(profiler.enabled).toBe(false);
+        expect(profiler.mode).toBeNull();
+        expect(profiler.runId).toBeNull();
+        expect(profiler.budget).toBeNull();
+      }
+    });
+
+    test("/v1/healthz returns the same shape as /v1/health", async () => {
+      // Both endpoints call handleDetailedHealth, so the shape must match
+      const res = handleDetailedHealth();
+      const body = (await res.json()) as Record<string, unknown>;
+
+      expect(body.status).toBe("healthy");
+      expect(body.timestamp).toBeDefined();
+      expect(body.migrations).toBeDefined();
+    });
+  });
+
+  describe("profiler payload (profiler enabled)", () => {
+    test("returns profiler object with enabled=true when env vars are set", async () => {
+      setProfilerEnv("cpu", "run-health-test-1", {
+        maxBytes: 10_000_000,
+        minFreeMb: 10,
+      });
+      ensureProfilerRunDir("run-health-test-1");
+
+      const res = handleDetailedHealth();
+      const body = (await res.json()) as Record<string, unknown>;
+
+      expect(body.profiler).toBeDefined();
+      const profiler = body.profiler as Record<string, unknown>;
+      expect(profiler.enabled).toBe(true);
+      expect(profiler.mode).toBe("cpu");
+      expect(profiler.runId).toBe("run-health-test-1");
+      expect(profiler.runDir).toContain("run-health-test-1");
+      expect(typeof profiler.totalBytes).toBe("number");
+      expect(typeof profiler.artifactCount).toBe("number");
+    });
+
+    test("includes budget block with expected fields", async () => {
+      setProfilerEnv("heap", "run-budget-test", {
+        maxBytes: 50_000_000,
+        minFreeMb: 100,
+      });
+      ensureProfilerRunDir("run-budget-test");
+
+      const res = handleDetailedHealth();
+      const body = (await res.json()) as Record<string, unknown>;
+      const profiler = body.profiler as Record<string, unknown>;
+      const budget = profiler.budget as Record<string, unknown>;
+
+      expect(budget).toBeDefined();
+      expect(budget.maxBytes).toBe(50_000_000);
+      expect(typeof budget.remainingBytes).toBe("number");
+      expect(budget.minFreeMb).toBe(100);
+      expect(typeof budget.freeMb).toBe("number");
+      expect(typeof budget.overBudget).toBe("boolean");
+    });
+
+    test("reports artifact count from .cpuprofile files", async () => {
+      setProfilerEnv("cpu", "run-artifact-count", {
+        maxBytes: 100_000_000,
+        minFreeMb: 0,
+      });
+      writeArtifactFile("run-artifact-count", "profile-1.cpuprofile", 1024);
+      writeArtifactFile("run-artifact-count", "profile-2.cpuprofile", 2048);
+      // Non-artifact file should not count
+      writeArtifactFile("run-artifact-count", "log.txt", 512);
+
+      const res = handleDetailedHealth();
+      const body = (await res.json()) as Record<string, unknown>;
+      const profiler = body.profiler as Record<string, unknown>;
+
+      expect(profiler.artifactCount).toBe(2);
+    });
+
+    test("detects over-budget state when total bytes exceed maxBytes", async () => {
+      setProfilerEnv("cpu+heap", "run-over-budget", {
+        maxBytes: 100, // Very small budget
+        minFreeMb: 0,
+      });
+      // Write a file larger than the budget
+      writeArtifactFile("run-over-budget", "big.cpuprofile", 5000);
+
+      const res = handleDetailedHealth();
+      const body = (await res.json()) as Record<string, unknown>;
+      const profiler = body.profiler as Record<string, unknown>;
+      const budget = profiler.budget as Record<string, unknown>;
+
+      expect(budget.overBudget).toBe(true);
+      expect(budget.remainingBytes).toBe(0);
+    });
+  });
+
+  describe("lastCompletedRun", () => {
+    test("returns null when no completed runs exist", async () => {
+      setProfilerEnv("cpu", "run-no-completed", {
+        maxBytes: 100_000_000,
+        minFreeMb: 0,
+      });
+      ensureProfilerRunDir("run-no-completed");
+
+      const res = handleDetailedHealth();
+      const body = (await res.json()) as Record<string, unknown>;
+      const profiler = body.profiler as Record<string, unknown>;
+
+      expect(profiler.lastCompletedRun).toBeNull();
+    });
+
+    test("returns completed run summary with artifact count and hasSummaries", async () => {
+      setProfilerEnv("cpu", "active-run-xyz", {
+        maxBytes: 100_000_000,
+        minFreeMb: 0,
+      });
+      ensureProfilerRunDir("active-run-xyz");
+
+      // Create a completed run with artifacts and a summary file
+      const completedId = "completed-run-abc";
+      const expectedCompletedAt = "2025-06-01T00:30:00Z";
+      writeRunManifest(completedId, {
+        status: "completed",
+        createdAt: "2025-06-01T00:00:00Z",
+        updatedAt: "2025-06-01T01:00:00Z",
+        completedAt: expectedCompletedAt,
+        totalBytes: 4096,
+      });
+      writeArtifactFile(completedId, "profile.cpuprofile", 3072);
+      writeArtifactFile(completedId, "summary.md", 256);
+
+      const res = handleDetailedHealth();
+      const body = (await res.json()) as Record<string, unknown>;
+      const profiler = body.profiler as Record<string, unknown>;
+      const last = profiler.lastCompletedRun as Record<string, unknown>;
+
+      expect(last).toBeDefined();
+      expect(last.runId).toBe(completedId);
+      expect(last.artifactCount).toBe(1); // Only .cpuprofile counts
+      expect(last.hasSummaries).toBe(true);
+      expect(typeof last.totalBytes).toBe("number");
+      // completedAt should reflect the manifest's completedAt value,
+      // not the current time or updatedAt.
+      expect(last.completedAt).toBe(expectedCompletedAt);
+    });
+
+    test("selects the most recent completed run when multiple exist", async () => {
+      setProfilerEnv("heap", "active-multi", {
+        maxBytes: 100_000_000,
+        maxRuns: 100,
+        minFreeMb: 0,
+      });
+      ensureProfilerRunDir("active-multi");
+
+      writeRunManifest("older-completed", {
+        status: "completed",
+        createdAt: "2025-01-01T00:00:00Z",
+        updatedAt: "2025-01-01T01:00:00Z",
+      });
+      writeArtifactFile("older-completed", "old.heapsnapshot", 512);
+
+      writeRunManifest("newer-completed", {
+        status: "completed",
+        createdAt: "2025-06-15T00:00:00Z",
+        updatedAt: "2025-06-15T01:00:00Z",
+      });
+      writeArtifactFile("newer-completed", "new.heapsnapshot", 1024);
+
+      const res = handleDetailedHealth();
+      const body = (await res.json()) as Record<string, unknown>;
+      const profiler = body.profiler as Record<string, unknown>;
+      const last = profiler.lastCompletedRun as Record<string, unknown>;
+
+      expect(last).toBeDefined();
+      expect(last.runId).toBe("newer-completed");
+    });
+  });
+});

package/src/__tests__/injection-block.test.ts

@@ -125,6 +125,18 @@ describe("assembleInjectionBlock", () => {
     expect(result).toContain("[skill]");
     expect(result).toContain("→ use skill_load to activate");
   });
+
+  test("assembleInjectionBlock omits skill_load suffix for CLI commands", () => {
+    const node = makeScoredNode({
+      type: "procedural",
+      content:
+        'cli:bash\nThe "assistant bash" CLI command is available. Execute a shell command.',
+    });
+    const result = assembleInjectionBlock([node]);
+    expect(result).not.toContain("[skill]");
+    expect(result).not.toContain("skill_load to activate");
+    expect(result).toContain("CLI command is available");
+  });
 });
 
 describe("assembleContextBlock — procedural nodes", () => {
@@ -139,6 +151,18 @@ describe("assembleContextBlock — procedural nodes", () => {
     expect(result).toContain("use skill_load to activate");
   });
 
+  test("omits skill_load suffix for CLI commands", () => {
+    const node = makeScoredNode({
+      type: "procedural",
+      content:
+        'cli:bash\nThe "assistant bash" CLI command is available. Execute a shell command.',
+    });
+    const result = assembleContextBlock([node]);
+    expect(result).toContain("### Skills You Can Use");
+    expect(result).not.toContain("skill_load to activate");
+    expect(result).toContain("CLI command is available");
+  });
+
   test("strips skill: prefix from old-format content", () => {
     const node = makeScoredNode({
       type: "procedural",

package/src/__tests__/install-skill-routing.test.ts

@@ -32,7 +32,7 @@ const mockInstallExternalSkill = mock(
 );
 const mockGetCatalog = mock(async () => []);
 const mockInstallSkillLocally = mock(async () => {});
-const mockSeedCatalogSkillMemories = mock(() => {});
+const mockSeedSkillGraphNodes = mock(() => {});
 const mockEnsureSkillEntry = mock(
   (_raw: Record<string, unknown>, _id: string) => ({
     enabled: false,
@@ -115,9 +115,10 @@ mock.module("../skills/managed-store.js", () => ({
   removeSkillsIndexEntry: () => {},
   validateManagedSkillId: () => null,
 }));
-mock.module("../skills/skill-memory.js", () => ({
-  deleteSkillCapabilityMemory: () => {},
-  seedCatalogSkillMemories: mockSeedCatalogSkillMemories,
+mock.module("../memory/graph/capability-seed.js", () => ({
+  deleteSkillCapabilityNode: () => {},
+  seedSkillGraphNodes: mockSeedSkillGraphNodes,
+  seedUninstalledCatalogSkillMemories: async () => {},
 }));
 mock.module("../util/platform.js", () => ({
   getWorkspaceSkillsDir: () => "/tmp/test-skills",
@@ -158,7 +159,7 @@ describe("installSkill routing", () => {
     mockInstallExternalSkill.mockReset();
     mockGetCatalog.mockReset();
     mockInstallSkillLocally.mockReset();
-    mockSeedCatalogSkillMemories.mockReset();
+    mockSeedSkillGraphNodes.mockReset();
     mockEnsureSkillEntry.mockReset();
 
     // Defaults
@@ -167,7 +168,7 @@ describe("installSkill routing", () => {
     mockInstallExternalSkill.mockResolvedValue(undefined);
     mockGetCatalog.mockResolvedValue([]);
     mockInstallSkillLocally.mockResolvedValue(undefined);
-    mockSeedCatalogSkillMemories.mockReturnValue(undefined);
+    mockSeedSkillGraphNodes.mockReturnValue(undefined);
     mockEnsureSkillEntry.mockReturnValue({ enabled: false });
   });
 

package/src/__tests__/jobs-store-qdrant-breaker.test.ts

@@ -37,15 +37,15 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
 
   test("claims embed jobs when circuit breaker is closed (healthy)", () => {
     enqueueMemoryJob("embed_segment", { segmentId: "seg-1" });
-    enqueueMemoryJob("embed_item", { itemId: "item-1" });
-    enqueueMemoryJob("extract_items", { conversationId: "conv-1" });
+    enqueueMemoryJob("embed_graph_node", { nodeId: "node-1" });
+    enqueueMemoryJob("graph_extract", { conversationId: "conv-1" });
 
     const claimed = claimMemoryJobs(10);
     const types = claimed.map((j) => j.type);
 
     expect(types).toContain("embed_segment");
-    expect(types).toContain("embed_item");
-    expect(types).toContain("extract_items");
+    expect(types).toContain("embed_graph_node");
+    expect(types).toContain("graph_extract");
     expect(claimed).toHaveLength(3);
   });
 
@@ -62,9 +62,9 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
     }
 
     enqueueMemoryJob("embed_segment", { segmentId: "seg-1" });
-    enqueueMemoryJob("embed_item", { itemId: "item-1" });
+    enqueueMemoryJob("embed_graph_node", { nodeId: "node-1" });
     enqueueMemoryJob("embed_summary", { summaryId: "sum-1" });
-    enqueueMemoryJob("extract_items", { conversationId: "conv-1" });
+    enqueueMemoryJob("graph_extract", { conversationId: "conv-1" });
     enqueueMemoryJob("build_conversation_summary", {
       conversationId: "conv-1",
     });
@@ -73,10 +73,10 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
     const types = claimed.map((j) => j.type);
 
     // Only non-embed jobs should be claimed
-    expect(types).toContain("extract_items");
+    expect(types).toContain("graph_extract");
     expect(types).toContain("build_conversation_summary");
     expect(types).not.toContain("embed_segment");
-    expect(types).not.toContain("embed_item");
+    expect(types).not.toContain("embed_graph_node");
     expect(types).not.toContain("embed_summary");
     expect(claimed).toHaveLength(2);
   });
@@ -95,7 +95,7 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
 
     // Verify embed jobs are skipped while open
     enqueueMemoryJob("embed_segment", { segmentId: "seg-1" });
-    enqueueMemoryJob("extract_items", { conversationId: "conv-1" });
+    enqueueMemoryJob("graph_extract", { conversationId: "conv-1" });
 
     const claimedWhileOpen = claimMemoryJobs(10);
     expect(claimedWhileOpen.map((j) => j.type)).not.toContain("embed_segment");
@@ -104,21 +104,22 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
     _resetQdrantBreaker();
 
     // Re-enqueue an embed job (the previous one is now "running")
-    enqueueMemoryJob("embed_item", { itemId: "item-2" });
+    enqueueMemoryJob("embed_graph_node", { nodeId: "node-2" });
 
     const claimedAfterClose = claimMemoryJobs(10);
     const types = claimedAfterClose.map((j) => j.type);
 
-    expect(types).toContain("embed_item");
+    expect(types).toContain("embed_graph_node");
   });
 
   test("all embed job types are skipped when breaker is open", async () => {
     const embedTypes: MemoryJobType[] = [
       "embed_segment",
-      "embed_item",
       "embed_summary",
       "embed_media",
       "embed_attachment",
+      "embed_graph_node",
+      "graph_trigger_embed",
     ];
 
     // Trip the circuit breaker
@@ -137,13 +138,13 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
       enqueueMemoryJob(type, { id: `test-${type}` });
     }
     // Also enqueue a non-embed job
-    enqueueMemoryJob("extract_entities", { conversationId: "conv-1" });
+    enqueueMemoryJob("graph_consolidate", { conversationId: "conv-1" });
 
     const claimed = claimMemoryJobs(20);
     const types = claimed.map((j) => j.type);
 
     // Only the non-embed job should be claimed
     expect(claimed).toHaveLength(1);
-    expect(types).toEqual(["extract_entities"]);
+    expect(types).toEqual(["graph_consolidate"]);
   });
 });