@vellumai/assistant 0.9.0 → 0.9.1-staging.1

package/src/memory/__tests__/preloaded-apps.test.ts

@@ -1,85 +0,0 @@
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import { setOverridesForTesting } from "../../__tests__/feature-flag-test-helpers.js";
-import type { AssistantConfig } from "../../config/schema.js";
-import { getAppsDir } from "../app-store.js";
-import {
-  ACTIVATION_FLOW_FLAG,
-  PERSONAL_PAGE_APP_ID,
-  PERSONAL_PAGE_ARM,
-  seedPreloadedApps,
-} from "../preloaded-apps.js";
-
-// The flag resolver reads the override cache and registry; the config
-// argument is part of the signature but not consulted for resolution.
-const config = {} as AssistantConfig;
-
-function definitionPath(): string {
-  return join(getAppsDir(), `${PERSONAL_PAGE_APP_ID}.json`);
-}
-
-function appDir(): string {
-  return join(getAppsDir(), PERSONAL_PAGE_APP_ID);
-}
-
-beforeEach(() => {
-  setOverridesForTesting({});
-});
-
-afterEach(() => {
-  setOverridesForTesting({});
-  rmSync(definitionPath(), { force: true });
-  rmSync(appDir(), { recursive: true, force: true });
-});
-
-describe("seedPreloadedApps gating", () => {
-  test("does not seed on the control arm", async () => {
-    setOverridesForTesting({ [ACTIVATION_FLOW_FLAG]: "control" });
-    await seedPreloadedApps(config);
-    expect(existsSync(definitionPath())).toBe(false);
-    expect(existsSync(appDir())).toBe(false);
-  });
-
-  test("does not seed on other treatment arms", async () => {
-    setOverridesForTesting({ [ACTIVATION_FLOW_FLAG]: "variant-a" });
-    await seedPreloadedApps(config);
-    expect(existsSync(definitionPath())).toBe(false);
-  });
-
-  test("does not seed when the flag resolves to the registry default", async () => {
-    // No override → declared default "control".
-    await seedPreloadedApps(config);
-    expect(existsSync(definitionPath())).toBe(false);
-  });
-
-  test("leaves an already-seeded, compiled app untouched", async () => {
-    setOverridesForTesting({ [ACTIVATION_FLOW_FLAG]: PERSONAL_PAGE_ARM });
-
-    const sentinelDefinition = JSON.stringify({
-      id: PERSONAL_PAGE_APP_ID,
-      userEdited: true,
-    });
-    mkdirSync(join(appDir(), "dist"), { recursive: true });
-    writeFileSync(definitionPath(), sentinelDefinition, "utf-8");
-    writeFileSync(
-      join(appDir(), "dist", "index.html"),
-      "<!-- compiled -->",
-      "utf-8",
-    );
-
-    await seedPreloadedApps(config);
-
-    // Seeding must not re-copy the template or rewrite the definition once
-    // the app exists — its content is considered user-owned.
-    expect(readFileSync(definitionPath(), "utf-8")).toBe(sentinelDefinition);
-    expect(existsSync(join(appDir(), "src"))).toBe(false);
-  });
-});

package/src/memory/preloaded-apps.ts

@@ -1,116 +0,0 @@
-/**
- * Seeds preloaded apps into the workspace apps directory at daemon startup.
- *
- * A preloaded app ships as plain source files under
- * `src/config/preloaded-apps/<dirName>/` and is copied into
- * `data/apps/<dirName>/` with a fixed, well-known app id, then compiled.
- * The assistant later populates it by overwriting designated content files
- * (e.g. the personal page's `src/profile-data.ts`) and calling app_refresh —
- * it never authors the layout itself.
- *
- * Seeding is idempotent and deliberately conservative: once the definition
- * JSON exists the app is considered user-owned (its content may have been
- * populated) and the template is never re-copied. A missing `dist/` triggers
- * a recompile only.
- *
- * Seeding is gated on the activation-flow experiment: only assistants in the
- * personal-page treatment arm get the app. The gate is evaluated once per
- * daemon startup — an assistant moved into the arm later picks it up on its
- * next restart, and an already-seeded app is never removed when the
- * assistant leaves the arm (it is user-owned by then).
- */
-
-import { cpSync, existsSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-import { compileApp } from "../bundler/app-compiler.js";
-import {
-  getAssistantFeatureFlagValue,
-  initFeatureFlagOverrides,
-} from "../config/assistant-feature-flags.js";
-import type { AssistantConfig } from "../config/schema.js";
-import { resolveBundledDir } from "../util/bundled-asset.js";
-import { getLogger } from "../util/logger.js";
-import { getAppsDir } from "./app-store.js";
-
-const log = getLogger("preloaded-apps");
-
-/** Well-known id (and dirName) of the personal landing page app. */
-export const PERSONAL_PAGE_APP_ID = "personal-page";
-
-/** Multivariate activation-flow experiment flag (scope "both"). */
-export const ACTIVATION_FLOW_FLAG = "experiment-activation-flow-2026-06-03";
-
-/** Arm of the activation-flow experiment that gets the preseeded page. */
-export const PERSONAL_PAGE_ARM = "personal-page";
-
-export async function seedPreloadedApps(
-  config: AssistantConfig,
-): Promise<void> {
-  // The lifecycle hook fires this early in startup, possibly before the
-  // gateway override fetch has completed. Await it here (no-op when already
-  // cached; bounded retries otherwise) so the arm read below sees the
-  // platform-assigned value rather than the registry default.
-  await initFeatureFlagOverrides();
-
-  const arm = getAssistantFeatureFlagValue(ACTIVATION_FLOW_FLAG, config);
-  if (arm !== PERSONAL_PAGE_ARM) return;
-
-  await seedPersonalPageApp();
-}
-
-async function seedPersonalPageApp(): Promise<void> {
-  const appsDir = getAppsDir();
-  const definitionPath = join(appsDir, `${PERSONAL_PAGE_APP_ID}.json`);
-  const appDir = join(appsDir, PERSONAL_PAGE_APP_ID);
-  const alreadySeeded = existsSync(definitionPath);
-
-  if (alreadySeeded && existsSync(join(appDir, "dist", "index.html"))) {
-    return;
-  }
-
-  if (!alreadySeeded) {
-    const templateDir = resolveBundledDir(
-      import.meta.dirname ?? __dirname,
-      "../config/preloaded-apps/personal-page",
-      "preloaded-apps/personal-page",
-    );
-    if (!existsSync(join(templateDir, "src"))) {
-      log.warn(
-        { templateDir },
-        "Personal page template not found — skipping preloaded app seeding",
-      );
-      return;
-    }
-
-    cpSync(join(templateDir, "src"), join(appDir, "src"), { recursive: true });
-    // Multifile (formatVersion 2) apps keep an empty root index.html; the
-    // real entrypoint is src/index.html compiled into dist/. Matches the
-    // on-disk shape produced by createApp().
-    writeFileSync(join(appDir, "index.html"), "", "utf-8");
-
-    const now = Date.now();
-    const definition = {
-      id: PERSONAL_PAGE_APP_ID,
-      name: "Your Page",
-      description:
-        "A personal landing page the assistant fills in with what it learns about you.",
-      icon: "✨",
-      schemaJson: "{}",
-      createdAt: now,
-      updatedAt: now,
-      formatVersion: 2,
-      dirName: PERSONAL_PAGE_APP_ID,
-    };
-    writeFileSync(definitionPath, JSON.stringify(definition, null, 2), "utf-8");
-    log.info({ appDir }, "Seeded personal page app");
-  }
-
-  const result = await compileApp(appDir);
-  if (!result.ok) {
-    log.warn(
-      { errors: result.errors },
-      "Personal page app failed to compile after seeding",
-    );
-  }
-}

package/src/runtime/routes/identity-intro-cache.ts

@@ -1,172 +0,0 @@
-/**
- * Caching layer for identity greetings.
- *
- * Greetings are sourced from (in priority order):
- * 1. A `## Greetings` section in SOUL.md (user-defined bullet list)
- * 2. A cached greetings array (populated by the empty-state greeting callsite)
- * 3. A generic fallback when generation is unavailable
- *
- * Cache invalidation is intentionally TTL-only. User-authored SOUL.md
- * greetings are read before cache, so manual overrides still take priority
- * without coupling cache validity to prompt-file edits.
- *
- * Storage uses the existing `memory_checkpoints` table (simple key-value store).
- */
-
-import { existsSync, readFileSync } from "node:fs";
-
-import {
-  getMemoryCheckpoint,
-  setMemoryCheckpoint,
-} from "../../memory/checkpoints.js";
-import { getWorkspacePromptPath } from "../../util/platform.js";
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-const CACHE_TTL_MS = 4 * 60 * 60 * 1000; // 4 hours
-
-const CHECKPOINT_KEY_GREETINGS = "identity:intro:greetings";
-const CHECKPOINT_KEY_TIMESTAMP = "identity:intro:cached_at";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/** Read a workspace prompt file, returning empty string if missing. */
-function readWorkspaceFile(name: string): string {
-  try {
-    const path = getWorkspacePromptPath(name);
-    if (!existsSync(path)) return "";
-    return readFileSync(path, "utf-8");
-  } catch {
-    return "";
-  }
-}
-
-function parseIdentityIntroSection(content: string): string | null {
-  let inSection = false;
-
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (/^#+\s/.test(trimmed)) {
-      inSection = trimmed.toLowerCase().includes("identity intro");
-      continue;
-    }
-    if (inSection && trimmed.length > 0) {
-      return trimmed;
-    }
-  }
-
-  return null;
-}
-
-/**
- * Read the explicit `## Identity Intro` section from workspace prompt files.
- *
- * BOOTSTRAP.md instructs the assistant to write this section in IDENTITY.md.
- * SOUL.md remains a fallback for older workspaces that stored the intro there.
- */
-export function readWorkspaceIdentityIntro(): string | null {
-  return (
-    parseIdentityIntroSection(readWorkspaceFile("IDENTITY.md")) ??
-    parseIdentityIntroSection(readWorkspaceFile("SOUL.md"))
-  );
-}
-
-/**
- * Parse the `## Greetings` section from SOUL.md. Returns bullet items as an
- * array of strings, or `null` if the section is missing or empty.
- */
-export function parseGreetingsSection(content: string): string[] | null {
-  let inSection = false;
-  let sectionLevel: number | null = null;
-  const greetings: string[] = [];
-
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    const heading = /^(#{1,6})\s+(.+?)\s*#*$/.exec(trimmed);
-    if (heading) {
-      const level = heading[1]!.length;
-      const title = heading[2]!.trim();
-      if (inSection) {
-        if (sectionLevel !== null && level <= sectionLevel) break;
-        continue;
-      }
-      if (level === 2 && /^greetings$/i.test(title)) {
-        inSection = true;
-        sectionLevel = level;
-      }
-      continue;
-    }
-    if (!inSection) continue;
-    const bullet = /^(?:[-*+]\s+|\d+[.)]\s+)(.+)$/.exec(trimmed);
-    const greeting = bullet?.[1]?.trim();
-    if (greeting) {
-      greetings.push(greeting);
-    }
-  }
-
-  return greetings.length > 0 ? greetings : null;
-}
-
-/**
- * Read user-defined greetings from the `## Greetings` section of SOUL.md.
- */
-export function readWorkspaceGreetings(): string[] | null {
-  const soulContent = readWorkspaceFile("SOUL.md");
-  if (!soulContent) return null;
-  return parseGreetingsSection(soulContent);
-}
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-export interface CachedIntro {
-  greetings: string[];
-}
-
-/**
- * Retrieve the cached greetings array if it exists and is within the TTL
- * window.
- *
- * Returns `null` when the cache is missing or expired.
- */
-export function getCachedIntro(): CachedIntro | null {
-  try {
-    const raw = getMemoryCheckpoint(CHECKPOINT_KEY_GREETINGS);
-    const timestampStr = getMemoryCheckpoint(CHECKPOINT_KEY_TIMESTAMP);
-
-    if (!raw || !timestampStr) return null;
-
-    // TTL check
-    const cachedAt = Number(timestampStr);
-    if (isNaN(cachedAt) || Date.now() - cachedAt > CACHE_TTL_MS) return null;
-
-    // Parse stored value — handles both JSON array and legacy single string
-    let greetings: string[];
-    try {
-      const parsed = JSON.parse(raw);
-      greetings = Array.isArray(parsed) ? parsed : [raw];
-    } catch {
-      greetings = [raw];
-    }
-
-    return { greetings };
-  } catch {
-    return null;
-  }
-}
-
-/** Store a greetings array in the cache along with the current timestamp. */
-export function setCachedIntro(greetings: string[]): void {
-  try {
-    const now = String(Date.now());
-    setMemoryCheckpoint(CHECKPOINT_KEY_GREETINGS, JSON.stringify(greetings));
-    setMemoryCheckpoint(CHECKPOINT_KEY_TIMESTAMP, now);
-  } catch {
-    // Cache write failure is non-fatal — next request will regenerate.
-  }
-}