@vellumai/assistant 0.6.0 → 0.6.2

package/src/__tests__/file-list-tool.test.ts

@@ -0,0 +1,219 @@
+import {
+  mkdirSync,
+  mkdtempSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, test } from "bun:test";
+
+import {
+  isToolActiveForContext,
+  type SkillProjectionContext,
+  SUBAGENT_ONLY_TOOL_NAMES,
+} from "../daemon/conversation-tool-setup.js";
+import { fileListTool } from "../tools/filesystem/list.js";
+import {
+  FileSystemOps,
+  type PathPolicy,
+} from "../tools/shared/filesystem/file-ops-service.js";
+import { sandboxPolicy } from "../tools/shared/filesystem/path-policy.js";
+import type { ToolContext } from "../tools/types.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const testDirs: string[] = [];
+
+function makeTempDir(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "file-list-test-")));
+  testDirs.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  for (const dir of testDirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+/** Build a sandbox-bound PathPolicy for the given directory. */
+function sandboxPolicyFor(boundary: string): PathPolicy {
+  return (rawPath, options) => sandboxPolicy(rawPath, boundary, options);
+}
+
+// ---------------------------------------------------------------------------
+// listDirSafe
+// ---------------------------------------------------------------------------
+
+describe("FileSystemOps.listDirSafe", () => {
+  test("lists directory contents with type indicators (dirs end with /)", () => {
+    const dir = makeTempDir();
+    mkdirSync(join(dir, "subdir-a"));
+    mkdirSync(join(dir, "subdir-b"));
+    writeFileSync(join(dir, "file-a.txt"), "hello");
+    writeFileSync(join(dir, "file-b.md"), "world");
+
+    const ops = new FileSystemOps(sandboxPolicyFor(dir));
+    const result = ops.listDirSafe({ path: dir });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+
+    const lines = result.value.listing.split("\n");
+    // Directories first with trailing /
+    expect(lines[0]).toBe("subdir-a/");
+    expect(lines[1]).toBe("subdir-b/");
+    // Files after directories, with size info
+    expect(lines[2]).toMatch(/^file-a\.txt\s+\d+\s*B$/);
+    expect(lines[3]).toMatch(/^file-b\.md\s+\d+\s*B$/);
+  });
+
+  test("glob filtering works (e.g. '*.md' only returns .md files)", () => {
+    const dir = makeTempDir();
+    writeFileSync(join(dir, "readme.md"), "# Title");
+    writeFileSync(join(dir, "notes.md"), "some notes");
+    writeFileSync(join(dir, "app.ts"), "console.log('hi')");
+    writeFileSync(join(dir, "config.json"), "{}");
+
+    const ops = new FileSystemOps(sandboxPolicyFor(dir));
+    const result = ops.listDirSafe({ path: dir, glob: "*.md" });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+
+    const lines = result.value.listing.split("\n");
+    expect(lines.length).toBe(2);
+    expect(lines[0]).toMatch(/^notes\.md/);
+    expect(lines[1]).toMatch(/^readme\.md/);
+  });
+
+  test("returns NOT_A_DIRECTORY error for file paths", () => {
+    const dir = makeTempDir();
+    writeFileSync(join(dir, "regular-file.txt"), "content");
+
+    const ops = new FileSystemOps(sandboxPolicyFor(dir));
+    const result = ops.listDirSafe({ path: join(dir, "regular-file.txt") });
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error.code).toBe("NOT_A_DIRECTORY");
+  });
+
+  test("returns NOT_FOUND error for nonexistent paths", () => {
+    const dir = makeTempDir();
+
+    const ops = new FileSystemOps(sandboxPolicyFor(dir));
+    const result = ops.listDirSafe({ path: join(dir, "nonexistent") });
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error.code).toBe("NOT_FOUND");
+  });
+
+  test("sandbox policy rejects paths outside boundary", () => {
+    const dir = makeTempDir();
+
+    const ops = new FileSystemOps(sandboxPolicyFor(dir));
+    const result = ops.listDirSafe({ path: "../../../etc" });
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error.code).toBe("PATH_OUT_OF_BOUNDS");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// FileListTool integration tests
+// ---------------------------------------------------------------------------
+
+/** Build a minimal ToolContext with the given workingDir. */
+function makeToolContext(workingDir: string): ToolContext {
+  return {
+    workingDir,
+    conversationId: "test-conv",
+    trustClass: "guardian",
+  };
+}
+
+describe("FileListTool", () => {
+  test("execute() returns formatted listing for a temp directory", async () => {
+    const dir = makeTempDir();
+    mkdirSync(join(dir, "src"));
+    writeFileSync(join(dir, "README.md"), "# Hello");
+    writeFileSync(join(dir, "index.ts"), "export {}");
+
+    const result = await fileListTool.execute(
+      { path: dir, activity: "listing test dir" },
+      makeToolContext(dir),
+    );
+
+    expect(result.isError).toBe(false);
+    const lines = result.content.split("\n");
+    // Directory first with trailing /
+    expect(lines[0]).toBe("src/");
+    // Files after (alphabetical), with size info
+    expect(lines[1]).toMatch(/^index\.ts\s+\d+\s*B$/);
+    expect(lines[2]).toMatch(/^README\.md\s+\d+\s*B$/);
+  });
+
+  test("execute() returns error for invalid path input", async () => {
+    const dir = makeTempDir();
+    const result = await fileListTool.execute(
+      { path: 123, activity: "test" },
+      makeToolContext(dir),
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("path is required and must be a string");
+  });
+
+  test("execute() returns error for nonexistent directory", async () => {
+    const dir = makeTempDir();
+    const result = await fileListTool.execute(
+      { path: join(dir, "nope"), activity: "test" },
+      makeToolContext(dir),
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("not found");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Subagent-only visibility
+// ---------------------------------------------------------------------------
+
+describe("file_list subagent visibility", () => {
+  test("file_list is in SUBAGENT_ONLY_TOOL_NAMES", () => {
+    expect(SUBAGENT_ONLY_TOOL_NAMES.has("file_list")).toBe(true);
+  });
+
+  test("isToolActiveForContext hides file_list when isSubagent is false", () => {
+    const ctx: SkillProjectionContext = {
+      skillProjectionState: new Map(),
+      skillProjectionCache: {},
+      coreToolNames: new Set(["file_list"]),
+      toolsDisabledDepth: 0,
+    };
+    expect(isToolActiveForContext("file_list", ctx)).toBe(false);
+  });
+
+  test("isToolActiveForContext hides file_list when isSubagent is undefined", () => {
+    const ctx: SkillProjectionContext = {
+      skillProjectionState: new Map(),
+      skillProjectionCache: {},
+      coreToolNames: new Set(["file_list"]),
+      toolsDisabledDepth: 0,
+      isSubagent: undefined,
+    };
+    expect(isToolActiveForContext("file_list", ctx)).toBe(false);
+  });
+
+  test("isToolActiveForContext shows file_list when isSubagent is true", () => {
+    const ctx: SkillProjectionContext = {
+      skillProjectionState: new Map(),
+      skillProjectionCache: {},
+      coreToolNames: new Set(["file_list"]),
+      toolsDisabledDepth: 0,
+      isSubagent: true,
+    };
+    expect(isToolActiveForContext("file_list", ctx)).toBe(true);
+  });
+});

package/src/__tests__/first-greeting.test.ts

@@ -53,7 +53,7 @@ describe("first-greeting", () => {
       const greeting = getCannedFirstGreeting();
       expect(greeting).toBe(CANNED_FIRST_GREETING);
       expect(greeting).toContain("brand new");
-      expect(greeting).toContain("no name, no memories");
+      expect(greeting).toContain("No name, no memories");
     });
   });
 });

package/src/__tests__/heartbeat-service.test.ts

@@ -1,4 +1,4 @@
-import { rmSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -18,6 +18,9 @@ let mockConfig = {
 mock.module("../config/loader.js", () => ({
   getConfig: () => mockConfig,
   loadConfig: () => mockConfig,
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  invalidateConfigCache: () => {},
 }));
 
 // Mock conversation store
@@ -43,6 +46,7 @@ mock.module("../memory/conversation-crud.js", () => ({
     totalEstimatedCost: 0,
     title: null,
   }),
+  getMessageById: () => null,
   provenanceFromTrustContext: () => ({
     source: "user",
     trustContext: undefined,
@@ -72,7 +76,16 @@ mock.module("../memory/conversation-title-service.js", () => ({
 }));
 
 // Import after mocks are set up
-const { HeartbeatService } = await import("../heartbeat/heartbeat-service.js");
+const { HeartbeatService, isShallowProfile } =
+  await import("../heartbeat/heartbeat-service.js");
+
+// Read the bundled template files so we can write them into the test workspace
+const templatesDir = join(import.meta.dirname!, "..", "prompts", "templates");
+const IDENTITY_TEMPLATE = readFileSync(
+  join(templatesDir, "IDENTITY.md"),
+  "utf-8",
+);
+const USER_TEMPLATE = readFileSync(join(templatesDir, "USER.md"), "utf-8");
 
 describe("HeartbeatService", () => {
   let processMessageCalls: Array<{
@@ -83,8 +96,11 @@ describe("HeartbeatService", () => {
   let alerterCalls: Array<{ type: string; title: string; body: string }>;
 
   afterEach(() => {
-    // Clean up HEARTBEAT.md between tests so file-existence tests don't leak
+    // Clean up workspace files between tests so file-existence tests don't leak
     rmSync(join(testWorkspaceDir, "HEARTBEAT.md"), { force: true });
+    rmSync(join(testWorkspaceDir, "IDENTITY.md"), { force: true });
+    rmSync(join(testWorkspaceDir, "USER.md"), { force: true });
+    rmSync(join(testWorkspaceDir, ".reengagement-ts"), { force: true });
   });
 
   beforeEach(() => {
@@ -228,6 +244,24 @@ describe("HeartbeatService", () => {
     expect(processMessageCalls).toHaveLength(0);
   });
 
+  test("active hours skip still advances nextRunAt", async () => {
+    mockConfig.heartbeat.activeHoursStart = 9;
+    mockConfig.heartbeat.activeHoursEnd = 17;
+
+    const service = createService({ getCurrentHour: () => 3 });
+    service.start();
+
+    const before = Date.now();
+    await service.runOnce();
+
+    expect(processMessageCalls).toHaveLength(0);
+    expect(service.nextRunAt).not.toBeNull();
+    expect(service.nextRunAt!).toBeGreaterThanOrEqual(
+      before + mockConfig.heartbeat.intervalMs,
+    );
+    service.stop();
+  });
+
   test("active hours guard allows within window", async () => {
     mockConfig.heartbeat.activeHoursStart = 9;
     mockConfig.heartbeat.activeHoursEnd = 17;
@@ -360,6 +394,22 @@ describe("HeartbeatService", () => {
     expect(alerterCalls[0].body).toBe("LLM timeout");
   });
 
+  test("successful run updates lastRunAt and nextRunAt", async () => {
+    const service = createService();
+    expect(service.lastRunAt).toBeNull();
+    expect(service.nextRunAt).toBeNull();
+
+    const before = Date.now();
+    await service.runOnce();
+
+    expect(service.lastRunAt).not.toBeNull();
+    expect(service.lastRunAt!).toBeGreaterThanOrEqual(before);
+    expect(service.nextRunAt).not.toBeNull();
+    expect(service.nextRunAt!).toBeGreaterThanOrEqual(
+      before + mockConfig.heartbeat.intervalMs,
+    );
+  });
+
   test("alerts on conversation creation failure", async () => {
     // Override createConversation to throw via a fresh import trick:
     // Since createConversation is mocked at module level, we simulate
@@ -442,4 +492,131 @@ describe("HeartbeatService", () => {
     expect(processMessageCalls).toHaveLength(1);
     expect(processMessageCalls[0].options?.speed).toBe("fast");
   });
+
+  describe("isShallowProfile", () => {
+    test("returns true when both IDENTITY.md and USER.md are unmodified templates", () => {
+      writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), IDENTITY_TEMPLATE);
+      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+
+      expect(isShallowProfile()).toBe(true);
+    });
+
+    test("returns false when IDENTITY.md has been customized", () => {
+      writeFileSync(
+        join(testWorkspaceDir, "IDENTITY.md"),
+        "# IDENTITY.md\n\n- **Name:** Jarvis\n",
+      );
+      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+
+      expect(isShallowProfile()).toBe(false);
+    });
+
+    test("returns false when USER.md has been customized", () => {
+      writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), IDENTITY_TEMPLATE);
+      writeFileSync(
+        join(testWorkspaceDir, "USER.md"),
+        "# USER.md\n\n- Preferred name/reference: Alice\n",
+      );
+
+      expect(isShallowProfile()).toBe(false);
+    });
+
+    test("returns false when neither file exists", () => {
+      expect(isShallowProfile()).toBe(false);
+    });
+  });
+
+  describe("relationship-depth prompt injection", () => {
+    test("includes <relationship-depth> when profile is shallow", () => {
+      writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), IDENTITY_TEMPLATE);
+      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+
+      const service = createService();
+      const { prompt, includedReengagement } =
+        service.buildPrompt("- Check things");
+
+      expect(prompt).toContain("<relationship-depth>");
+      expect(prompt).toContain("profile is still sparse");
+      expect(includedReengagement).toBe(true);
+    });
+
+    test("omits <relationship-depth> when profile is not shallow", () => {
+      writeFileSync(
+        join(testWorkspaceDir, "IDENTITY.md"),
+        "# IDENTITY.md\n\n- **Name:** Jarvis\n",
+      );
+      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+
+      const service = createService();
+      const { prompt, includedReengagement } =
+        service.buildPrompt("- Check things");
+
+      expect(prompt).not.toContain("<relationship-depth>");
+      expect(includedReengagement).toBe(false);
+    });
+
+    test("omits <relationship-depth> when cooldown has not elapsed", () => {
+      writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), IDENTITY_TEMPLATE);
+      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+      // Write a recent timestamp to simulate cooldown not elapsed
+      writeFileSync(
+        join(testWorkspaceDir, ".reengagement-ts"),
+        Date.now().toString(),
+      );
+
+      const service = createService();
+      const { prompt, includedReengagement } =
+        service.buildPrompt("- Check things");
+
+      expect(prompt).not.toContain("<relationship-depth>");
+      expect(includedReengagement).toBe(false);
+    });
+
+    test("includes <relationship-depth> when cooldown has elapsed", () => {
+      writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), IDENTITY_TEMPLATE);
+      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+      // Write a timestamp from 19 hours ago
+      const nineteenHoursAgo = Date.now() - 19 * 60 * 60 * 1000;
+      writeFileSync(
+        join(testWorkspaceDir, ".reengagement-ts"),
+        nineteenHoursAgo.toString(),
+      );
+
+      const service = createService();
+      const { prompt, includedReengagement } =
+        service.buildPrompt("- Check things");
+
+      expect(prompt).toContain("<relationship-depth>");
+      expect(includedReengagement).toBe(true);
+    });
+
+    test("does not record timestamp when processMessage fails", async () => {
+      writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), IDENTITY_TEMPLATE);
+      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+
+      const service = createService({
+        processMessage: async () => {
+          throw new Error("LLM timeout");
+        },
+      });
+
+      await service.runOnce();
+
+      // The reengagement timestamp file should NOT exist since delivery failed
+      const tsPath = join(testWorkspaceDir, ".reengagement-ts");
+      expect(existsSync(tsPath)).toBe(false);
+    });
+
+    test("records timestamp after successful delivery", async () => {
+      writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), IDENTITY_TEMPLATE);
+      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+
+      const service = createService();
+      await service.runOnce();
+
+      // The reengagement timestamp file should exist after successful delivery
+      const tsPath = join(testWorkspaceDir, ".reengagement-ts");
+      expect(existsSync(tsPath)).toBe(true);
+    });
+  });
 });