@vellumai/assistant 0.8.3 → 0.8.5

package/src/documents/document-store.ts

@@ -240,6 +240,99 @@ export function deleteDocument(surfaceId: string): boolean {
   }
 }
 
+// ---------------------------------------------------------------------------
+// In-document search (grep)
+// ---------------------------------------------------------------------------
+
+export interface FindMatch {
+  lineNumber: number;
+  lineContent: string;
+  matchStart: number;
+  matchEnd: number;
+  matchText: string;
+}
+
+export interface FindResult {
+  surfaceId: string;
+  totalMatches: number;
+  matches: FindMatch[];
+}
+
+const MAX_FIND_MATCHES = 50;
+
+/**
+ * Search for text or a regex pattern within a document's content.
+ * Returns matching lines with line numbers and match positions.
+ * Results are capped at {@link MAX_FIND_MATCHES} to avoid oversized responses.
+ */
+export function findInDocument(
+  surfaceId: string,
+  query: string,
+  options: { regex?: boolean; caseSensitive?: boolean } = {},
+): FindResult | null {
+  try {
+    const row = rawGet<{ content: string }>(
+      /*sql*/ `SELECT content FROM documents WHERE surface_id = ?`,
+      surfaceId,
+    );
+    if (!row) return null;
+
+    const lines = row.content.split("\n");
+    const matches: FindMatch[] = [];
+    let uncappedTotal = 0;
+
+    if (options.regex) {
+      const flags = options.caseSensitive ? "g" : "gi";
+      const re = new RegExp(query, flags);
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        re.lastIndex = 0;
+        let m: RegExpExecArray | null;
+        while ((m = re.exec(line)) !== null) {
+          uncappedTotal++;
+          if (matches.length < MAX_FIND_MATCHES) {
+            matches.push({
+              lineNumber: i + 1,
+              lineContent: line,
+              matchStart: m.index,
+              matchEnd: m.index + m[0].length,
+              matchText: m[0],
+            });
+          }
+          if (m[0].length === 0) re.lastIndex++;
+        }
+      }
+    } else {
+      const needle = options.caseSensitive ? query : query.toLowerCase();
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const haystack = options.caseSensitive ? line : line.toLowerCase();
+        let startPos = 0;
+        while (startPos <= haystack.length) {
+          const idx = haystack.indexOf(needle, startPos);
+          if (idx === -1) break;
+          uncappedTotal++;
+          if (matches.length < MAX_FIND_MATCHES) {
+            matches.push({
+              lineNumber: i + 1,
+              lineContent: line,
+              matchStart: idx,
+              matchEnd: idx + needle.length,
+              matchText: line.slice(idx, idx + needle.length),
+            });
+          }
+          startPos = idx + Math.max(needle.length, 1);
+        }
+      }
+    }
+
+    return { surfaceId, totalMatches: uncappedTotal, matches };
+  } catch (error) {
+    log.error({ err: error, surfaceId }, "Find-in-document error");
+    return null;
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Document persistence
 // ---------------------------------------------------------------------------
@@ -297,6 +390,115 @@ export function saveDocument(params: {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Find-and-replace
+// ---------------------------------------------------------------------------
+
+export interface ReplaceInDocumentOptions {
+  regex?: boolean;
+  caseSensitive?: boolean;
+  maxReplacements?: number;
+}
+
+export type ReplaceInDocumentResult =
+  | { success: true; replacements_made: number; content_changed: boolean }
+  | { success: false; error: string };
+
+function escapeRegExpChars(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Find and replace text within a document — like sed.
+ * Supports literal text and regex patterns with optional backreferences.
+ */
+export function replaceInDocument(
+  surfaceId: string,
+  find: string,
+  replace: string,
+  options: ReplaceInDocumentOptions = {},
+): ReplaceInDocumentResult {
+  try {
+    const row = rawGet<{ content: string }>(
+      /*sql*/ `SELECT content FROM documents WHERE surface_id = ?`,
+      surfaceId,
+    );
+    if (!row) {
+      return { success: false, error: "Document not found" };
+    }
+
+    const flags = "g" + (options.caseSensitive === true ? "" : "i");
+    const pattern = options.regex
+      ? new RegExp(find, flags)
+      : new RegExp(escapeRegExpChars(find), flags);
+
+    const totalMatches = [...row.content.matchAll(pattern)].length;
+    if (
+      totalMatches === 0 ||
+      (options.maxReplacements != null && options.maxReplacements <= 0)
+    ) {
+      return { success: true, replacements_made: 0, content_changed: false };
+    }
+
+    let newContent: string;
+    let replacementsMade: number;
+
+    if (
+      options.maxReplacements != null &&
+      options.maxReplacements < totalMatches
+    ) {
+      // Iterative replacement up to maxReplacements using manual exec loop
+      // so backreferences in the replacement string work correctly.
+      const limit = options.maxReplacements;
+      let count = 0;
+      let result = "";
+      let lastIndex = 0;
+      let m: RegExpExecArray | null;
+      while ((m = pattern.exec(row.content)) !== null) {
+        if (count >= limit) break;
+        result += row.content.slice(lastIndex, m.index);
+        const singleMatchPattern = new RegExp(
+          pattern.source,
+          pattern.flags.replace("g", ""),
+        );
+        result += m[0].replace(singleMatchPattern, replace);
+        lastIndex = m.index + m[0].length;
+        count++;
+        if (m[0].length === 0) pattern.lastIndex++;
+      }
+      result += row.content.slice(lastIndex);
+      newContent = result;
+      replacementsMade = count;
+    } else {
+      newContent = row.content.replace(pattern, replace);
+      replacementsMade = totalMatches;
+    }
+
+    const wordCount = newContent
+      .split(/\s+/)
+      .filter((w) => w.length > 0).length;
+    rawRun(
+      /*sql*/ `UPDATE documents SET content = ?, word_count = ?, updated_at = ? WHERE surface_id = ?`,
+      newContent,
+      wordCount,
+      Date.now(),
+      surfaceId,
+    );
+    log.info({ surfaceId, replacementsMade }, "Replaced text in document");
+    return {
+      success: true,
+      replacements_made: replacementsMade,
+      content_changed: true,
+    };
+  } catch (error) {
+    log.error({ err: error, surfaceId }, "Replace-in-document error");
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+    };
+  }
+}
+
 /** Update persisted document content (append or replace). */
 export function updateDocumentContent(
   surfaceId: string,

package/src/events/relationship-state-updated.ts

@@ -0,0 +1,25 @@
+/**
+ * `relationship_state_updated` SSE event.
+ *
+ * Broadcast by the daemon after a successful write of
+ * `relationship-state.json` to disk. Subscribers refetch
+ * `GET /v1/home/state` to read the new state — payload here just
+ * carries the new `updatedAt` for cache-tag comparison.
+ *
+ * Canonical wire-contract source. Daemon code imports the type
+ * directly from this file; external consumers import via
+ * `@vellumai/assistant-api`.
+ */
+
+import { z } from "zod";
+
+export const RelationshipStateUpdatedSchema = z
+  .object({
+    type: z.literal("relationship_state_updated"),
+    updatedAt: z.string(),
+  })
+  .strict();
+
+export type RelationshipStateUpdated = z.infer<
+  typeof RelationshipStateUpdatedSchema
+>;

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

@@ -14,6 +14,7 @@ mock.module("../../runtime/assistant-event-hub.js", () => ({
     publish: publishSpy,
     subscribe: () => () => {},
   },
+  broadcastMessage: () => {},
 }));
 
 // Stub workspace prompt reads so the heartbeat service doesn't try to
@@ -35,7 +36,6 @@ mock.module("../../util/platform.js", () => ({
   getEmbeddingModelsDir: () => join(workspaceDir ?? fallbackDir, "models"),
   getSandboxRootDir: () => join(workspaceDir ?? fallbackDir, "sandbox"),
   getSandboxWorkingDir: () => join(workspaceDir ?? fallbackDir, "sandbox/work"),
-  getInterfacesDir: () => join(workspaceDir ?? fallbackDir, "interfaces"),
   getSoundsDir: () => join(workspaceDir ?? fallbackDir, "sounds"),
   getAvatarDir: () => join(workspaceDir ?? fallbackDir, "avatar"),
   AVATAR_IMAGE_FILENAME: "avatar-image.png",
@@ -100,7 +100,6 @@ mock.module("../../prompts/persona-resolver.js", () => ({
 }));
 mock.module("../../prompts/system-prompt.js", () => ({
   isTemplateContent: () => false,
-  SYSTEM_PROMPT_CACHE_BOUNDARY: "<<CACHE_BOUNDARY>>",
   buildCoreIdentityContext: () => "",
   buildSystemPrompt: () => "",
   ensurePromptFiles: () => {},

package/src/heartbeat/heartbeat-service.ts

@@ -686,6 +686,7 @@ export class HeartbeatService {
       callSite: "heartbeatAgent",
       timeoutMs: HEARTBEAT_TIMEOUT_MS,
       origin: "heartbeat",
+      deferNotifications: true,
       onConversationCreated: (newConversationId) => {
         conversationId = newConversationId;
         this.deps.onConversationCreated?.({

package/src/home/__tests__/suggested-prompts.test.ts

@@ -5,8 +5,6 @@ import { describe, expect, mock, test } from "bun:test";
 let mockConnectedProviders = new Set<string>();
 
 mock.module("../../oauth/oauth-store.js", () => ({
-  isProviderConnected: async (provider: string) =>
-    mockConnectedProviders.has(provider),
   listProviders: () => [
     { provider: "google" },
     { provider: "slack" },
@@ -16,6 +14,11 @@ mock.module("../../oauth/oauth-store.js", () => ({
   ],
 }));
 
+mock.module("../../schedule/integration-status.js", () => ({
+  isOAuthProviderConnected: async (provider: string) =>
+    mockConnectedProviders.has(provider),
+}));
+
 mock.module("../../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -23,6 +26,34 @@ mock.module("../../util/logger.js", () => ({
     }),
 }));
 
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({ llm: {} }),
+}));
+
+mock.module("../../config/llm-resolver.js", () => ({
+  resolveCallSiteConfig: () => ({ provider: "mock" }),
+}));
+
+mock.module("../../providers/provider-send-message.js", () => ({
+  getConfiguredProvider: async () => ({}),
+}));
+
+mock.module("../../prompts/persona-resolver.js", () => ({
+  resolvePersonaContext: () => ({
+    userPersona: null,
+    userSlug: null,
+    channelPersona: null,
+  }),
+}));
+
+mock.module("../../prompts/system-prompt.js", () => ({
+  buildSystemPrompt: () => "mock system prompt",
+}));
+
+mock.module("../../runtime/btw-sidechain.js", () => ({
+  runBtwSidechain: async () => ({ text: "" }),
+}));
+
 const { getSuggestedPrompts } = await import("../suggested-prompts.js");
 
 // ─── Tests ─────────────────────────────────────────────────────────────

package/src/home/feed-types.ts

@@ -106,7 +106,12 @@ export interface FeedItem {
   actions?: FeedAction[];
   /** Visual urgency treatment — controls badge color independently of sort priority. */
   urgency?: FeedItemUrgency;
-  /** Optional conversation this feed item is associated with. */
+  /**
+   * Source conversation that emitted this notification, when known. Used by
+   * the "Go to Thread" affordance in the detail panel. Omitted when the
+   * source context is not a navigable conversation (scheduler job ids,
+   * watcher event ids, CLI tool-call ids).
+   */
   conversationId?: string;
   /** Server-driven detail panel descriptor; when present, the client opens this panel kind. */
   detailPanel?: FeedItemDetailPanel;

package/src/home/home-content-refresh.ts

@@ -0,0 +1,52 @@
+/**
+ * Background refresh timer for LLM-generated home page content.
+ *
+ * Keeps the personalized greeting and assistant-generated suggestion
+ * prompts warm in their caches so the GET handler never triggers LLM
+ * calls or database writes (see `src/runtime/AGENTS.md` — GET handler
+ * idempotency rule).
+ *
+ * Call `startHomeContentRefresh()` once during daemon startup; the
+ * timer handles periodic re-generation automatically.
+ */
+
+import { getLogger } from "../util/logger.js";
+import { refreshPersonalizedGreeting } from "./home-greeting.js";
+import { refreshAssistantSuggestedPrompts } from "./suggested-prompts.js";
+
+const log = getLogger("home-content-refresh");
+
+const REFRESH_INTERVAL_MS = 30 * 60 * 1000; // 30 minutes
+
+let refreshTimer: ReturnType<typeof setInterval> | null = null;
+
+async function refreshAll(): Promise<void> {
+  await Promise.all([
+    refreshPersonalizedGreeting(),
+    refreshAssistantSuggestedPrompts(),
+  ]);
+}
+
+/**
+ * Start periodic background refresh of home page LLM content.
+ * Runs an initial generation immediately (fire-and-forget) and
+ * schedules re-generation every 30 minutes.
+ */
+export function startHomeContentRefresh(): void {
+  void refreshAll().catch((err) =>
+    log.warn({ err }, "Initial home content refresh failed"),
+  );
+
+  refreshTimer = setInterval(() => {
+    void refreshAll().catch((err) =>
+      log.warn({ err }, "Periodic home content refresh failed"),
+    );
+  }, REFRESH_INTERVAL_MS);
+}
+
+export function stopHomeContentRefresh(): void {
+  if (refreshTimer) {
+    clearInterval(refreshTimer);
+    refreshTimer = null;
+  }
+}

package/src/home/home-greeting-cache.ts

@@ -0,0 +1,69 @@
+/**
+ * Caching layer for the LLM-generated personalized home greeting.
+ *
+ * The greeting (a short persona-flavored "here's what's been going on" line)
+ * is generated via `runBtwSidechain` and displayed at the top of the Home
+ * page. To avoid redundant LLM calls on every feed fetch, we cache the
+ * result for 4 hours with content-hash-based invalidation: when IDENTITY.md,
+ * SOUL.md, or the guardian persona change, the cache is busted.
+ *
+ * Storage uses the existing `memory_checkpoints` table (simple key-value store).
+ */
+
+import {
+  getMemoryCheckpoint,
+  setMemoryCheckpoint,
+} from "../memory/checkpoints.js";
+import { computeIdentityContentHash } from "../runtime/routes/identity-intro-cache.js";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const CACHE_TTL_MS = 4 * 60 * 60 * 1000; // 4 hours
+
+const CHECKPOINT_KEY_TEXT = "home:greeting:text";
+const CHECKPOINT_KEY_HASH = "home:greeting:content_hash";
+const CHECKPOINT_KEY_TIMESTAMP = "home:greeting:cached_at";
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export function getCachedHomeGreeting(): string | null {
+  try {
+    const text = getMemoryCheckpoint(CHECKPOINT_KEY_TEXT);
+    const hash = getMemoryCheckpoint(CHECKPOINT_KEY_HASH);
+    const timestampStr = getMemoryCheckpoint(CHECKPOINT_KEY_TIMESTAMP);
+
+    if (!text || !hash || !timestampStr) {
+      return null;
+    }
+
+    const cachedAt = Number(timestampStr);
+    if (isNaN(cachedAt) || Date.now() - cachedAt > CACHE_TTL_MS) {
+      return null;
+    }
+
+    const currentHash = computeIdentityContentHash();
+    if (currentHash !== hash) {
+      return null;
+    }
+
+    return text;
+  } catch {
+    return null;
+  }
+}
+
+export function setCachedHomeGreeting(text: string): void {
+  try {
+    const hash = computeIdentityContentHash();
+    const now = String(Date.now());
+    setMemoryCheckpoint(CHECKPOINT_KEY_TEXT, text);
+    setMemoryCheckpoint(CHECKPOINT_KEY_HASH, hash);
+    setMemoryCheckpoint(CHECKPOINT_KEY_TIMESTAMP, now);
+  } catch {
+    // Cache write failure is non-fatal — next request will regenerate.
+  }
+}

package/src/home/home-greeting.ts

@@ -0,0 +1,85 @@
+/**
+ * Personalized home-page greeting generator.
+ *
+ * Produces a short greeting in the assistant's tone/persona for the
+ * Home page header. Uses the BTW side-chain for LLM generation and
+ * caches the result for 4 hours (busted when identity files change).
+ *
+ * The GET handler reads only from cache (`getPersonalizedGreeting`).
+ * Generation runs in the background via `refreshPersonalizedGreeting`,
+ * called at daemon startup and periodically by the home-content
+ * refresh timer.
+ */
+
+import { resolveCallSiteConfig } from "../config/llm-resolver.js";
+import { getConfig } from "../config/loader.js";
+import { buildSystemPrompt } from "../prompts/system-prompt.js";
+import { getConfiguredProvider } from "../providers/provider-send-message.js";
+import { runBtwSidechain } from "../runtime/btw-sidechain.js";
+import { getLogger } from "../util/logger.js";
+import {
+  getCachedHomeGreeting,
+  setCachedHomeGreeting,
+} from "./home-greeting-cache.js";
+
+const log = getLogger("home-greeting");
+
+const GENERATION_TIMEOUT_MS = 5_000;
+
+/**
+ * Return the cached personalized greeting, or `null` when none is
+ * available yet. This is a synchronous cache read — safe for GET
+ * handlers.
+ */
+export function getPersonalizedGreeting(): string | null {
+  return getCachedHomeGreeting();
+}
+
+/**
+ * Generate a personalized greeting via LLM and write it to cache.
+ * No-ops when the cache is still fresh. Intended for background
+ * invocation (daemon startup / periodic refresh), not the GET path.
+ */
+export async function refreshPersonalizedGreeting(): Promise<void> {
+  const cached = getCachedHomeGreeting();
+  if (cached) {
+    return;
+  }
+
+  try {
+    const config = getConfig();
+    const resolved = resolveCallSiteConfig("homeGreeting", config.llm);
+
+    const provider = await getConfiguredProvider("homeGreeting");
+    if (!provider) {
+      return;
+    }
+
+    const systemPrompt = buildSystemPrompt({
+      excludeBootstrap: true,
+      excludeCustomPrefix: true,
+    });
+
+    const result = await runBtwSidechain({
+      content:
+        "Generate a short, casual greeting for the home page (max 10 words). " +
+        "It should convey the meaning of 'here's what's been going on' but in " +
+        "your unique tone and personality. Just output the greeting text, nothing else. " +
+        "No quotes, no preamble.",
+      provider,
+      systemPrompt,
+      messages: [],
+      tools: [],
+      callSite: "homeGreeting",
+      maxTokens: resolved.maxTokens,
+      timeoutMs: GENERATION_TIMEOUT_MS,
+    });
+
+    const text = result.text.trim();
+    if (text) {
+      setCachedHomeGreeting(text);
+    }
+  } catch (err) {
+    log.warn({ err }, "Failed to generate personalized home greeting");
+  }
+}