@vellumai/assistant 0.6.3 → 0.6.4

package/src/workspace/migrations/032-tts-provider-unification.ts

@@ -0,0 +1,227 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Backfill `services.tts.provider` and `services.tts.providers.*` from
+ * legacy config keys, then remove the legacy keys.
+ *
+ * Legacy keys consulted:
+ *  - `calls.voice.ttsProvider`  -> `services.tts.provider`
+ *  - `elevenlabs.*`             -> `services.tts.providers.elevenlabs.*`
+ *  - `fishAudio.*`              -> `services.tts.providers.fish-audio.*`
+ *
+ * In mixed legacy states, `calls.voice.ttsProvider` wins as the selected
+ * provider. Provider-specific values are copied from the legacy top-level
+ * sections into their canonical `services.tts.providers.*` locations.
+ *
+ * After copying, legacy fields are removed so no compatibility shim is
+ * required in the runtime resolver.
+ *
+ * Idempotent: re-running the migration on an already-migrated config
+ * produces no changes.
+ */
+export const ttsProviderUnificationMigration: WorkspaceMigration = {
+  id: "032-tts-provider-unification",
+  description:
+    "Backfill services.tts.provider and services.tts.providers.* from legacy TTS config keys, then remove legacy keys",
+  run(workspaceDir: string): void {
+    const configPath = join(workspaceDir, "config.json");
+    if (!existsSync(configPath)) return;
+
+    let config: Record<string, unknown>;
+    try {
+      const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+      config = raw as Record<string, unknown>;
+    } catch {
+      return; // Malformed config — skip
+    }
+
+    // Resolve legacy TTS provider from calls.voice.ttsProvider
+    const legacyProvider = resolveLegacyProvider(config);
+
+    // Resolve legacy provider-specific configs
+    const legacyElevenlabs = extractLegacyElevenlabs(config);
+    const legacyFishAudio = extractLegacyFishAudio(config);
+
+    // If no legacy data exists, nothing to migrate
+    if (!legacyProvider && !legacyElevenlabs && !legacyFishAudio) return;
+
+    // Ensure services.tts exists
+    const services = ensureObj(config, "services");
+    const tts = ensureObj(services, "tts");
+
+    // Set provider if not already explicitly set
+    if (!("provider" in tts) && legacyProvider) {
+      tts.provider = legacyProvider;
+    }
+
+    // Set mode to your-own (always)
+    if (!("mode" in tts)) {
+      tts.mode = "your-own";
+    }
+
+    // Backfill providers map
+    const providers = ensureObj(tts, "providers");
+
+    if (legacyElevenlabs) {
+      const elTarget = ensureObj(providers, "elevenlabs");
+      // Only copy keys that are not already present in canonical
+      for (const [key, value] of Object.entries(legacyElevenlabs)) {
+        if (!(key in elTarget)) {
+          elTarget[key] = value;
+        }
+      }
+    }
+
+    if (legacyFishAudio) {
+      const faTarget = ensureObj(providers, "fish-audio");
+      for (const [key, value] of Object.entries(legacyFishAudio)) {
+        if (!(key in faTarget)) {
+          faTarget[key] = value;
+        }
+      }
+    }
+
+    // Clean up legacy fields — canonical paths are now fully materialised.
+    // Remove calls.voice.ttsProvider (but preserve the rest of calls.voice)
+    removeLegacyTtsProvider(config);
+    // Remove top-level elevenlabs and fishAudio sections
+    delete config.elevenlabs;
+    delete config.fishAudio;
+
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+  down(workspaceDir: string): void {
+    const configPath = join(workspaceDir, "config.json");
+    if (!existsSync(configPath)) return;
+
+    let config: Record<string, unknown>;
+    try {
+      const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+      config = raw as Record<string, unknown>;
+    } catch {
+      return;
+    }
+
+    // Restore legacy keys from canonical services.tts before removing it.
+    const services = config.services;
+    if (services && typeof services === "object" && !Array.isArray(services)) {
+      const servicesObj = services as Record<string, unknown>;
+      const tts = servicesObj.tts;
+      if (tts && typeof tts === "object" && !Array.isArray(tts)) {
+        const ttsObj = tts as Record<string, unknown>;
+
+        // Restore calls.voice.ttsProvider from services.tts.provider
+        const provider = ttsObj.provider;
+        if (typeof provider === "string") {
+          const calls = ensureObj(config, "calls");
+          const voice = ensureObj(calls, "voice");
+          voice.ttsProvider = provider;
+        }
+
+        // Restore top-level elevenlabs and fishAudio from providers map
+        const providers = ttsObj.providers;
+        if (
+          providers &&
+          typeof providers === "object" &&
+          !Array.isArray(providers)
+        ) {
+          const providersObj = providers as Record<string, unknown>;
+
+          const elConfig = providersObj.elevenlabs;
+          if (
+            elConfig &&
+            typeof elConfig === "object" &&
+            !Array.isArray(elConfig)
+          ) {
+            config.elevenlabs = { ...(elConfig as Record<string, unknown>) };
+          }
+
+          const faConfig = providersObj["fish-audio"];
+          if (
+            faConfig &&
+            typeof faConfig === "object" &&
+            !Array.isArray(faConfig)
+          ) {
+            config.fishAudio = { ...(faConfig as Record<string, unknown>) };
+          }
+        }
+      }
+
+      delete servicesObj.tts;
+    }
+
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function ensureObj(
+  parent: Record<string, unknown>,
+  key: string,
+): Record<string, unknown> {
+  if (
+    !(key in parent) ||
+    parent[key] == null ||
+    typeof parent[key] !== "object" ||
+    Array.isArray(parent[key])
+  ) {
+    parent[key] = {};
+  }
+  return parent[key] as Record<string, unknown>;
+}
+
+/** Extract legacy provider selection from calls.voice.ttsProvider. */
+function resolveLegacyProvider(config: Record<string, unknown>): string | null {
+  const calls = config.calls;
+  if (!calls || typeof calls !== "object" || Array.isArray(calls)) return null;
+  const callsObj = calls as Record<string, unknown>;
+
+  const voice = callsObj.voice;
+  if (!voice || typeof voice !== "object" || Array.isArray(voice)) return null;
+  const voiceObj = voice as Record<string, unknown>;
+
+  const provider = voiceObj.ttsProvider;
+  return typeof provider === "string" ? provider : null;
+}
+
+/** Remove calls.voice.ttsProvider from config while preserving other voice fields. */
+function removeLegacyTtsProvider(config: Record<string, unknown>): void {
+  const calls = config.calls;
+  if (!calls || typeof calls !== "object" || Array.isArray(calls)) return;
+  const callsObj = calls as Record<string, unknown>;
+
+  const voice = callsObj.voice;
+  if (!voice || typeof voice !== "object" || Array.isArray(voice)) return;
+  const voiceObj = voice as Record<string, unknown>;
+
+  delete voiceObj.ttsProvider;
+}
+
+/** Extract legacy ElevenLabs config from top-level elevenlabs object. */
+function extractLegacyElevenlabs(
+  config: Record<string, unknown>,
+): Record<string, unknown> | null {
+  const el = config.elevenlabs;
+  if (!el || typeof el !== "object" || Array.isArray(el)) return null;
+  const obj = el as Record<string, unknown>;
+  // Only return if there are non-empty keys
+  return Object.keys(obj).length > 0 ? { ...obj } : null;
+}
+
+/** Extract legacy Fish Audio config from top-level fishAudio object. */
+function extractLegacyFishAudio(
+  config: Record<string, unknown>,
+): Record<string, unknown> | null {
+  const fa = config.fishAudio;
+  if (!fa || typeof fa !== "object" || Array.isArray(fa)) return null;
+  const obj = fa as Record<string, unknown>;
+  return Object.keys(obj).length > 0 ? { ...obj } : null;
+}

package/src/workspace/migrations/033-stt-service-explicit-config.ts

@@ -0,0 +1,122 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Materialize explicit `services.stt` configuration on disk.
+ *
+ * Prior to this migration the STT block was only populated at runtime via
+ * Zod `.default()` values in the schema. This meant existing workspaces had
+ * no `services.stt` in their `config.json` at all, making it invisible
+ * to users and tooling that inspects config on disk.
+ *
+ * This migration writes a canonical `services.stt` block when missing or
+ * partial, backfilling only structural fields:
+ *
+ *   - `services.stt.mode`      -> `"your-own"`
+ *   - `services.stt.provider`  -> `"deepgram"`
+ *   - `services.stt.providers` -> `{}` (empty object — sparse map)
+ *
+ * It does NOT seed per-provider entries (`openai-whisper`, `deepgram`, etc.)
+ * — the providers map is sparse and only holds entries the user explicitly
+ * configures. Adding a new provider ID does not require a migration.
+ *
+ * It never clobbers user-defined STT values — only fills in what is missing.
+ *
+ * Idempotent: re-running the migration on an already-migrated config
+ * produces no changes.
+ */
+export const sttServiceExplicitConfigMigration: WorkspaceMigration = {
+  id: "033-stt-service-explicit-config",
+  description:
+    "Materialize explicit services.stt provider settings on disk (mode, provider, providers)",
+  run(workspaceDir: string): void {
+    const configPath = join(workspaceDir, "config.json");
+    if (!existsSync(configPath)) return;
+
+    let config: Record<string, unknown>;
+    try {
+      const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+      config = raw as Record<string, unknown>;
+    } catch {
+      return; // Malformed JSON — skip
+    }
+
+    // Ensure services.stt exists as an object
+    const services = ensureObj(config, "services");
+    const stt = ensureObj(services, "stt");
+
+    let changed = false;
+
+    // Backfill mode
+    if (!("mode" in stt)) {
+      stt.mode = "your-own";
+      changed = true;
+    }
+
+    // Backfill provider
+    if (!("provider" in stt)) {
+      stt.provider = "deepgram";
+      changed = true;
+    }
+
+    // Ensure providers map exists as an object (sparse — no per-provider seeding)
+    if (
+      !("providers" in stt) ||
+      stt.providers == null ||
+      typeof stt.providers !== "object" ||
+      Array.isArray(stt.providers)
+    ) {
+      stt.providers = {};
+      changed = true;
+    }
+
+    // Only write when something actually changed
+    if (changed) {
+      writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    }
+  },
+  down(workspaceDir: string): void {
+    const configPath = join(workspaceDir, "config.json");
+    if (!existsSync(configPath)) return;
+
+    let config: Record<string, unknown>;
+    try {
+      const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+      config = raw as Record<string, unknown>;
+    } catch {
+      return;
+    }
+
+    // Remove services.stt entirely.
+    const services = config.services;
+    if (services && typeof services === "object" && !Array.isArray(services)) {
+      const servicesObj = services as Record<string, unknown>;
+      delete servicesObj.stt;
+    }
+
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Helpers (self-contained per migration AGENTS.md)
+// ---------------------------------------------------------------------------
+
+function ensureObj(
+  parent: Record<string, unknown>,
+  key: string,
+): Record<string, unknown> {
+  if (
+    !(key in parent) ||
+    parent[key] == null ||
+    typeof parent[key] !== "object" ||
+    Array.isArray(parent[key])
+  ) {
+    parent[key] = {};
+  }
+  return parent[key] as Record<string, unknown>;
+}

package/src/workspace/migrations/034-remove-calls-voice-transcription-provider.ts

@@ -0,0 +1,215 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Remove `calls.voice.transcriptionProvider` (and `calls.voice.speechModel`)
+ * from persisted workspace configs, preserving user preferences by copying
+ * them to `services.stt.provider` before deletion.
+ *
+ * Migration 033 backfilled `services.stt.provider` to `"deepgram"`
+ * unconditionally. Users who had `calls.voice.transcriptionProvider: "Google"`
+ * were silently switched to Deepgram STT. This migration corrects that by
+ * reading the old value before removing it:
+ *
+ *   - If `calls.voice.transcriptionProvider` is `"Google"` and
+ *     `services.stt.provider` is still `"deepgram"` (the 033 default),
+ *     set `services.stt.provider` to `"google-gemini"`.
+ *   - If `calls.voice.transcriptionProvider` is `"Deepgram"` or missing,
+ *     no change needed.
+ *   - If `calls.voice.speechModel` was set and the provider is being
+ *     corrected to `"google-gemini"`, clear the speechModel since
+ *     Deepgram-specific models (e.g. "nova-3") are not valid for Google.
+ *
+ * After copying, the migration removes `calls.voice.transcriptionProvider`
+ * and `calls.voice.speechModel` from the persisted config.
+ *
+ * Idempotent: re-running the migration on an already-migrated config
+ * produces no changes.
+ */
+export const removeCallsVoiceTranscriptionProviderMigration: WorkspaceMigration =
+  {
+    id: "034-remove-calls-voice-transcription-provider",
+    description:
+      "Copy calls.voice.transcriptionProvider to services.stt.provider and remove legacy keys",
+    run(workspaceDir: string): void {
+      const configPath = join(workspaceDir, "config.json");
+      if (!existsSync(configPath)) return;
+
+      let config: Record<string, unknown>;
+      try {
+        const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+        config = raw as Record<string, unknown>;
+      } catch {
+        return; // Malformed JSON — skip
+      }
+
+      let changed = false;
+
+      // ── Read legacy values ──────────────────────────────────────────────
+
+      const calls = getObj(config, "calls");
+      const voice = calls ? getObj(calls, "voice") : null;
+
+      const legacyProvider =
+        voice && typeof voice.transcriptionProvider === "string"
+          ? voice.transcriptionProvider
+          : null;
+
+      // ── Copy preference to services.stt.provider if needed ─────────────
+
+      if (legacyProvider === "Google") {
+        const services = getObj(config, "services");
+        const stt = services ? getObj(services, "stt") : null;
+
+        if (stt && typeof stt.provider === "string") {
+          // Only overwrite if services.stt looks like the untouched 033 default.
+          // Migration 033 backfilled { mode: "your-own", provider: "deepgram",
+          // providers: {} }. If the user later customized the section (changed
+          // mode, added provider-specific config, or set a different provider),
+          // we treat it as an intentional choice and leave it alone. Checking
+          // for extra keys beyond the 033 structural set avoids overriding a
+          // user who explicitly chose deepgram after 033 ran and then tweaked
+          // provider settings.
+          if (stt.provider === "deepgram" && looksLike033Default(stt)) {
+            stt.provider = "google-gemini";
+            changed = true;
+          }
+        }
+      }
+
+      // ── Remove legacy keys from calls.voice ────────────────────────────
+
+      if (voice) {
+        if ("transcriptionProvider" in voice) {
+          delete voice.transcriptionProvider;
+          changed = true;
+        }
+        if ("speechModel" in voice) {
+          delete voice.speechModel;
+          changed = true;
+        }
+      }
+
+      // Only write when something actually changed
+      if (changed) {
+        writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+      }
+    },
+    down(workspaceDir: string): void {
+      // The down migration restores `calls.voice.transcriptionProvider`
+      // from `services.stt.provider` where possible.
+      const configPath = join(workspaceDir, "config.json");
+      if (!existsSync(configPath)) return;
+
+      let config: Record<string, unknown>;
+      try {
+        const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+        config = raw as Record<string, unknown>;
+      } catch {
+        return;
+      }
+
+      const services = getObj(config, "services");
+      const stt = services ? getObj(services, "stt") : null;
+      const sttProvider =
+        stt && typeof stt.provider === "string" ? stt.provider : null;
+
+      // Reverse-map canonical provider ID to legacy enum value
+      const legacyProvider = reverseMapProvider(sttProvider);
+
+      if (!legacyProvider) return;
+
+      const calls = ensureObj(config, "calls");
+      const voice = ensureObj(calls, "voice");
+
+      if (!("transcriptionProvider" in voice)) {
+        voice.transcriptionProvider = legacyProvider;
+        writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+      }
+    },
+  };
+
+// ---------------------------------------------------------------------------
+// Helpers (self-contained per migration AGENTS.md)
+// ---------------------------------------------------------------------------
+
+/**
+ * Safely get a nested object value. Returns null if the key is missing
+ * or the value is not a plain object.
+ */
+function getObj(
+  parent: Record<string, unknown>,
+  key: string,
+): Record<string, unknown> | null {
+  const val = parent[key];
+  if (val && typeof val === "object" && !Array.isArray(val)) {
+    return val as Record<string, unknown>;
+  }
+  return null;
+}
+
+/**
+ * Ensure a nested key is an object. Creates it if missing or non-object.
+ */
+function ensureObj(
+  parent: Record<string, unknown>,
+  key: string,
+): Record<string, unknown> {
+  if (
+    !(key in parent) ||
+    parent[key] == null ||
+    typeof parent[key] !== "object" ||
+    Array.isArray(parent[key])
+  ) {
+    parent[key] = {};
+  }
+  return parent[key] as Record<string, unknown>;
+}
+
+/**
+ * Check whether `services.stt` contains only the structural keys that
+ * migration 033 backfilled (`mode`, `provider`, `providers`) with their
+ * default values. If any other key is present or if `mode`/`providers`
+ * differ from the 033 defaults, the user has actively configured this
+ * section and we should not override their provider choice.
+ */
+function looksLike033Default(stt: Record<string, unknown>): boolean {
+  const keys033 = new Set(["mode", "provider", "providers"]);
+  for (const key of Object.keys(stt)) {
+    if (!keys033.has(key)) return false;
+  }
+  // Verify the other structural values match the 033 defaults
+  if ("mode" in stt && stt.mode !== "your-own") return false;
+  if ("providers" in stt) {
+    const providers = stt.providers;
+    if (
+      !providers ||
+      typeof providers !== "object" ||
+      Array.isArray(providers) ||
+      Object.keys(providers as Record<string, unknown>).length > 0
+    ) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Map canonical `services.stt.provider` ID back to legacy
+ * `calls.voice.transcriptionProvider` enum value for the down migration.
+ */
+function reverseMapProvider(sttProvider: string | null): string | null {
+  if (!sttProvider) return null;
+  switch (sttProvider) {
+    case "deepgram":
+      return "Deepgram";
+    case "google-gemini":
+      return "Google";
+    default:
+      return null;
+  }
+}

package/src/workspace/migrations/035-seed-slack-channel-persona.ts

@@ -0,0 +1,50 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+// Inlined template snapshot so this migration is self-contained even if
+// the bundled template file changes or moves in a future release.
+const SLACK_CHANNEL_PERSONA_TEMPLATE = `_ Lines starting with _ are comments - they won't appear in the system prompt
+_ This file shapes how you behave when responding in Slack. Edit it freely.
+
+# Slack
+
+## Delivery
+
+Skip the research narration. In Slack, every message you send before your final answer posts as a separate visible message - not a live stream. "Let me look that up" and "Researching now..." just add noise. Use your tools, then deliver the result.
+
+Your personality, warmth, humor, and opinions are welcome. Just don't narrate the process of finding the answer.
+
+## Formatting
+
+Never use markdown tables (pipe-delimited). Slack cannot render them. Use bullet points with bold labels instead.
+
+When presenting information from web search, cite sources as inline hyperlinks woven into your text (e.g., "the round closed at $122B, [per CNBC](url)"). Don't dump a references list at the end.
+
+## Long-form content
+
+When your response would be long, dense, or highly structured (reports, teardowns, detailed analyses), use your judgment on whether to write it as an attached file vs posting inline. Consider what reads better in Slack - a wall of text with "See more" truncation often doesn't.
+`;
+
+export const seedSlackChannelPersonaMigration: WorkspaceMigration = {
+  id: "035-seed-slack-channel-persona",
+  description: "Seed channels/slack.md persona template for Slack responses",
+
+  down(_workspaceDir: string): void {
+    // No-op: we don't delete user-editable files on rollback.
+  },
+
+  run(workspaceDir: string): void {
+    const channelsDir = join(workspaceDir, "channels");
+    mkdirSync(channelsDir, { recursive: true });
+
+    const slackPath = join(channelsDir, "slack.md");
+    if (existsSync(slackPath)) {
+      // Don't overwrite user customizations.
+      return;
+    }
+
+    writeFileSync(slackPath, SLACK_CHANNEL_PERSONA_TEMPLATE, "utf-8");
+  },
+};

package/src/workspace/migrations/036-update-pkb-index-bar.ts

@@ -0,0 +1,37 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+// Original bar seeded by earlier versions of migration 029.
+const ORIGINAL_BAR = `**Remember aggressively.** When you learn ANY fact — a preference, a name, a date, a habit, a plan, an opinion — call \`remember\` immediately. Don't filter, don't judge importance. Remembering too much costs nothing. Forgetting something that mattered costs trust.`;
+
+// Target bar. Some installations were seeded with this text directly; this
+// migration normalizes the ORIGINAL_BAR population to match.
+const NEW_BAR = `**Remember aggressively.** Capture anything concrete about your user — preferences, names, dates, habits, plans, opinions, health details, commitments. Default to remembering; only skip obvious noise (small talk, hypotheticals). Don't judge importance — filing decides that later. Call \`remember\` immediately, multiple times per conversation. Remembering too much costs nothing. Forgetting something that mattered costs trust.`;
+
+export const updatePkbIndexBarMigration: WorkspaceMigration = {
+  id: "036-update-pkb-index-bar",
+  description:
+    "Normalize pkb/INDEX.md 'Remember aggressively' bar across both variants previously seeded by migration 029",
+
+  down(_workspaceDir: string): void {
+    // No-op: don't revert user-editable file content on rollback.
+  },
+
+  run(workspaceDir: string): void {
+    const indexPath = join(workspaceDir, "pkb", "INDEX.md");
+    if (!existsSync(indexPath)) return;
+
+    const current = readFileSync(indexPath, "utf-8");
+
+    if (current.includes(NEW_BAR)) return;
+
+    if (current.includes(ORIGINAL_BAR)) {
+      const updated = current.replace(ORIGINAL_BAR, NEW_BAR);
+      writeFileSync(indexPath, updated, "utf-8");
+      return;
+    }
+    // User-edited or unknown variant — leave alone.
+  },
+};