@vellumai/assistant 0.6.4 → 0.6.5

package/src/cli/commands/memory.ts

@@ -2,6 +2,7 @@ import type { Command } from "commander";
 
 import {
   cleanupShortSegments,
+  compactLongMemoryNodes,
   findReextractTarget,
   findReextractTargets,
   getMemorySystemStatus,
@@ -35,7 +36,7 @@ Key concepts:
 Examples:
   $ assistant memory status
   $ assistant memory query "What is the project deadline?"
-  $ assistant memory backfill`
+  $ assistant memory backfill`,
   );
 
   memory
@@ -57,7 +58,7 @@ Fields shown:
   jobs               Status of background jobs (backfill, cleanup, rebuild-index)
 
 Examples:
-  $ assistant memory status`
+  $ assistant memory status`,
     )
     .action(async () => {
       initializeDb();
@@ -97,7 +98,7 @@ useful after bulk imports or if the incremental state has become inconsistent.
 
 Examples:
   $ assistant memory backfill
-  $ assistant memory backfill --force`
+  $ assistant memory backfill --force`,
     )
     .action((opts: { force?: boolean }) => {
       initializeDb();
@@ -121,20 +122,20 @@ existing short segments that were stored before the filter was added.
 
 Examples:
   $ assistant memory cleanup-segments
-  $ assistant memory cleanup-segments --dry-run`
+  $ assistant memory cleanup-segments --dry-run`,
     )
     .action(async (opts: { dryRun?: boolean }) => {
       initializeDb();
       const result = await cleanupShortSegments({ dryRun: opts.dryRun });
       if (opts.dryRun) {
         log.info(
-          `Dry run: ${result.dryRunCount} short segment(s) would be removed.`
+          `Dry run: ${result.dryRunCount} short segment(s) would be removed.`,
         );
       } else {
         log.info(`Removed ${result.removed} short segment(s).`);
         if (result.failed > 0) {
           log.warn(
-            `${result.failed} segment(s) skipped — Qdrant deletion failed. Re-run when Qdrant is available.`
+            `${result.failed} segment(s) skipped — Qdrant deletion failed. Re-run when Qdrant is available.`,
           );
         }
       }
@@ -143,7 +144,7 @@ Examples:
   memory
     .command("query <text>")
     .description(
-      "Run a memory recall query and print the injected memory payload"
+      "Run a memory recall query and print the injected memory payload",
     )
     .option("-c, --conversation <id>", "Optional conversation ID")
     .addHelpText(
@@ -164,7 +165,7 @@ context-aware recall. If omitted, the most recent conversation is used.
 Examples:
   $ assistant memory query "What is the project deadline?"
   $ assistant memory query "preferred communication style" --conversation conv_abc123
-  $ assistant memory query "API rate limits"`
+  $ assistant memory query "API rate limits"`,
     )
     .action(async (text: string, opts?: { conversation?: string }) => {
       initializeDb();
@@ -181,8 +182,8 @@ Examples:
         for (const r of result.results) {
           log.info(
             `[${r.type}] (confidence: ${r.confidence.toFixed(
-              2
-            )}, score: ${r.score.toFixed(3)})`
+              2,
+            )}, score: ${r.score.toFixed(3)})`,
           );
           log.info(r.content);
           log.info("");
@@ -208,7 +209,7 @@ status" to monitor job progress.
 
 Examples:
   $ assistant memory rebuild-index
-  $ assistant memory status`
+  $ assistant memory status`,
     )
     .action(() => {
       initializeDb();
@@ -219,13 +220,13 @@ Examples:
   memory
     .command("re-extract")
     .description(
-      "Re-extract memories from conversations using the latest extraction prompt"
+      "Re-extract memories from conversations using the latest extraction prompt",
     )
     .option(
       "-c, --conversation <id>",
       "Target a specific conversation by ID (repeatable)",
       (val: string, prev: string[]) => [...prev, val],
-      [] as string[]
+      [] as string[],
     )
     .option("-t, --top <n>", "Auto-select top N conversations by message count")
     .option("--dry-run", "Show what would be re-extracted without doing it")
@@ -248,7 +249,7 @@ background worker).
 Examples:
   $ assistant memory re-extract --top 20
   $ assistant memory re-extract --conversation conv_abc123
-  $ assistant memory re-extract --top 10 --dry-run`
+  $ assistant memory re-extract --top 10 --dry-run`,
     )
     .action(
       (opts: { conversation?: string[]; top?: string; dryRun?: boolean }) => {
@@ -288,7 +289,7 @@ Examples:
 
         if (targets.length === 0) {
           log.info(
-            "No targets specified. Use --conversation <id> or --top <n>."
+            "No targets specified. Use --conversation <id> or --top <n>.",
           );
           return;
         }
@@ -307,8 +308,117 @@ Examples:
 
         const { jobIds } = requestReextract(targets);
         log.info(
-          `\nQueued ${jobIds.length} re-extraction job(s). The assistant will process them in the background.`
+          `\nQueued ${jobIds.length} re-extraction job(s). The assistant will process them in the background.`,
         );
-      }
+      },
+    );
+
+  memory
+    .command("compact")
+    .description(
+      "Rewrite memory nodes whose content exceeds the length cap (backfill)",
+    )
+    .option(
+      "--threshold <n>",
+      "Content length threshold — nodes longer than this are candidates (default: 400)",
+      (v: string) => Number.parseInt(v, 10),
+      400,
+    )
+    .option(
+      "--limit <n>",
+      "Maximum number of candidates to process (default: no limit)",
+      (v: string) => Number.parseInt(v, 10),
+    )
+    .option("--apply", "Rewrite content (default is a candidate-only preview)")
+    .addHelpText(
+      "after",
+      `
+One-off backfill for memory graphs that accumulated over-long content before
+the extraction prompt was tightened to enforce the 1-3 sentence / ~300
+character cap. Scans memory_graph_nodes (skipping fidelity=gone) for entries
+whose content length exceeds --threshold, then either lists them (default)
+or rewrites each via the memoryConsolidation LLM call site (--apply).
+
+Only the content field is rewritten; significance, emotionalCharge, edges,
+triggers, and image_refs are preserved. Each rewrite is logged in
+memory_graph_node_edits with source="manual" so it is reversible.
+
+Start with a bounded spot-check before processing the whole graph:
+
+  $ assistant memory compact --limit 3 --apply
+
+Examples:
+  $ assistant memory compact                     # preview candidates
+  $ assistant memory compact --threshold 500     # tighter threshold
+  $ assistant memory compact --limit 5 --apply   # rewrite first 5
+  $ assistant memory compact --apply             # rewrite everything`,
+    )
+    .action(
+      async (opts: { threshold: number; limit?: number; apply?: boolean }) => {
+        initializeDb();
+        const apply = Boolean(opts.apply);
+
+        if (!Number.isFinite(opts.threshold) || opts.threshold <= 0) {
+          log.info("--threshold must be a positive integer");
+          return;
+        }
+        if (
+          opts.limit !== undefined &&
+          (!Number.isFinite(opts.limit) || opts.limit <= 0)
+        ) {
+          log.info("--limit must be a positive integer");
+          return;
+        }
+
+        log.info(
+          `Scanning memory_graph_nodes for content > ${opts.threshold} chars${
+            apply ? "" : " (preview — no changes will be written)"
+          }...`,
+        );
+
+        const result = await compactLongMemoryNodes({
+          threshold: opts.threshold,
+          limit: opts.limit,
+          apply,
+          onCandidates: (candidates) => {
+            log.info(`Found ${candidates.length} candidate node(s)`);
+            if (!apply) {
+              for (const c of candidates) {
+                log.info(`  ${c.id}  ${c.beforeLen} chars`);
+              }
+            }
+          },
+          onProgress: (evt) => {
+            const tag = `[${evt.action}]`;
+            log.info(
+              `${tag} ${evt.nodeId}: ${evt.beforeLen} → ${evt.afterLen} chars${
+                evt.reason ? ` (${evt.reason})` : ""
+              }`,
+            );
+            if (evt.newContent && evt.action === "compacted") {
+              log.info(`  new: ${evt.newContent}`);
+            }
+          },
+        });
+
+        log.info("");
+        log.info(`Scanned above threshold: ${result.scanned}`);
+        log.info(`Processed:               ${result.processed}`);
+        if (apply) {
+          log.info(`Compacted:               ${result.compacted}`);
+          log.info(`Skipped:                 ${result.skipped}`);
+          log.info(`Failures:                ${result.failures}`);
+          if (result.processed > 0) {
+            log.info(
+              `Chars: ${result.beforeChars} → ${result.afterChars} (saved ${
+                result.beforeChars - result.afterChars
+              })`,
+            );
+          }
+        } else if (result.processed > 0) {
+          log.info("");
+          log.info("Preview only. Re-run with --apply to rewrite.");
+        }
+      },
     );
 }

package/src/cli/commands/platform/__tests__/callback-routes-list.test.ts

@@ -32,7 +32,6 @@ mock.module("../../../lib/daemon-credential-client.js", () => ({
   getSecureKeyViaDaemon: async () => undefined,
   deleteSecureKeyViaDaemon: async () => "not-found" as const,
   setSecureKeyViaDaemon: async () => false,
-  getProviderKeyViaDaemon: async () => undefined,
   getSecureKeyResultViaDaemon: async () => ({
     value: undefined,
     unreachable: false,

package/src/cli/commands/platform/__tests__/connect.test.ts

@@ -21,7 +21,6 @@ mock.module("../../../lib/daemon-credential-client.js", () => ({
     mockGetSecureKeyViaDaemon(account),
   deleteSecureKeyViaDaemon: async () => "not-found" as const,
   setSecureKeyViaDaemon: async () => true,
-  getProviderKeyViaDaemon: async () => undefined,
   getSecureKeyResultViaDaemon: async () => ({
     value: undefined,
     unreachable: false,

package/src/cli/commands/platform/__tests__/disconnect.test.ts

@@ -57,7 +57,6 @@ mock.module("../../../lib/daemon-credential-client.js", () => ({
     return mockDeleteSecureKeyViaDaemonResult;
   },
   setSecureKeyViaDaemon: async () => false,
-  getProviderKeyViaDaemon: async () => undefined,
   getSecureKeyResultViaDaemon: async () => ({
     value: undefined,
     unreachable: false,

package/src/cli/commands/platform/__tests__/status.test.ts

@@ -37,7 +37,6 @@ mock.module("../../../lib/daemon-credential-client.js", () => ({
     mockGetSecureKeyViaDaemon(account),
   deleteSecureKeyViaDaemon: async () => "not-found" as const,
   setSecureKeyViaDaemon: async () => false,
-  getProviderKeyViaDaemon: async () => undefined,
   getSecureKeyResultViaDaemon: async () => ({
     value: undefined,
     unreachable: false,

package/src/cli/commands/stt.ts

@@ -0,0 +1,339 @@
+/**
+ * CLI command group: `assistant stt`
+ *
+ * Speech-to-text operations using the configured STT provider.
+ * Stateless, request-response commands — no daemon dependency.
+ */
+
+import { randomUUID } from "node:crypto";
+import { access, mkdir, readdir, readFile, rm, unlink } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { extname, join } from "node:path";
+
+import type { Command } from "commander";
+
+import { listProviderIds } from "../../providers/speech-to-text/provider-catalog.js";
+import { resolveBatchTranscriber } from "../../providers/speech-to-text/resolve.js";
+import type { BatchTranscriber } from "../../stt/types.js";
+import {
+  FFMPEG_TRANSCODE_TIMEOUT_MS,
+  FFPROBE_TIMEOUT_MS,
+  spawnWithTimeout,
+} from "../../util/spawn.js";
+import { log } from "../logger.js";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const VIDEO_EXTENSIONS = new Set([
+  ".mp4",
+  ".mov",
+  ".avi",
+  ".mkv",
+  ".webm",
+  ".m4v",
+  ".mpeg",
+  ".mpg",
+]);
+const AUDIO_EXTENSIONS = new Set([
+  ".mp3",
+  ".wav",
+  ".m4a",
+  ".aac",
+  ".ogg",
+  ".flac",
+  ".aiff",
+  ".wma",
+]);
+
+/** Max file size for a single STT chunk request (25MB). */
+const STT_CHUNK_MAX_BYTES = 25 * 1024 * 1024;
+
+/** Duration per chunk when splitting for large files (10 minutes). */
+const CHUNK_DURATION_SECS = 600;
+
+/** Timeout for a single STT transcription request. */
+const STT_REQUEST_TIMEOUT_MS = 300_000;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+async function getAudioDuration(audioPath: string): Promise<number> {
+  const result = await spawnWithTimeout(
+    [
+      "ffprobe",
+      "-v",
+      "error",
+      "-show_entries",
+      "format=duration",
+      "-of",
+      "csv=p=0",
+      audioPath,
+    ],
+    FFPROBE_TIMEOUT_MS,
+  );
+  if (result.exitCode !== 0) return 0;
+  return parseFloat(result.stdout.trim()) || 0;
+}
+
+async function splitAudio(
+  audioPath: string,
+  chunkDir: string,
+  chunkDurationSecs: number,
+): Promise<string[]> {
+  const chunkPattern = join(chunkDir, "chunk-%03d.wav");
+  const result = await spawnWithTimeout(
+    [
+      "ffmpeg",
+      "-y",
+      "-i",
+      audioPath,
+      "-f",
+      "segment",
+      "-segment_time",
+      String(chunkDurationSecs),
+      "-acodec",
+      "pcm_s16le",
+      "-ar",
+      "16000",
+      "-ac",
+      "1",
+      chunkPattern,
+    ],
+    FFMPEG_TRANSCODE_TIMEOUT_MS,
+  );
+  if (result.exitCode !== 0) {
+    throw new Error(`Failed to split audio: ${result.stderr.slice(0, 300)}`);
+  }
+  const files = await readdir(chunkDir);
+  return files
+    .filter((f) => f.startsWith("chunk-") && f.endsWith(".wav"))
+    .sort()
+    .map((f) => join(chunkDir, f));
+}
+
+/** Convert source to 16kHz mono WAV for consistent processing. */
+async function toWav(inputPath: string, isVideo: boolean): Promise<string> {
+  const wavPath = join(tmpdir(), `vellum-transcribe-${randomUUID()}.wav`);
+  const args = ["ffmpeg", "-y", "-i", inputPath];
+  if (isVideo) args.push("-vn");
+  args.push("-acodec", "pcm_s16le", "-ar", "16000", "-ac", "1", wavPath);
+  const result = await spawnWithTimeout(args, FFMPEG_TRANSCODE_TIMEOUT_MS);
+  if (result.exitCode !== 0) {
+    throw new Error(`ffmpeg failed: ${result.stderr.slice(0, 500)}`);
+  }
+  return wavPath;
+}
+
+async function transcribeWithProvider(
+  audioPath: string,
+  transcriber: BatchTranscriber,
+): Promise<string> {
+  const duration = await getAudioDuration(audioPath);
+  const fileSize = Bun.file(audioPath).size;
+
+  // If small enough, send directly
+  if (fileSize <= STT_CHUNK_MAX_BYTES) {
+    const audioBuffer = await readFile(audioPath);
+    const result = await transcriber.transcribe({
+      audio: audioBuffer,
+      mimeType: "audio/wav",
+      signal: AbortSignal.timeout(STT_REQUEST_TIMEOUT_MS),
+    });
+    return result.text;
+  }
+
+  // Split into chunks for large files
+  const chunkDir = join(tmpdir(), `vellum-transcribe-chunks-${randomUUID()}`);
+  await mkdir(chunkDir, { recursive: true });
+
+  try {
+    process.stderr.write(
+      `Large file (${Math.round(duration / 60)}min) - splitting into chunks...\n`,
+    );
+    const chunks = await splitAudio(audioPath, chunkDir, CHUNK_DURATION_SECS);
+    const parts: string[] = [];
+
+    for (let i = 0; i < chunks.length; i++) {
+      process.stderr.write(
+        `  Transcribing chunk ${i + 1}/${chunks.length}...\n`,
+      );
+      const audioBuffer = await readFile(chunks[i]);
+      const result = await transcriber.transcribe({
+        audio: audioBuffer,
+        mimeType: "audio/wav",
+        signal: AbortSignal.timeout(STT_REQUEST_TIMEOUT_MS),
+      });
+      if (result.text) parts.push(result.text);
+    }
+
+    return parts.join(" ");
+  } finally {
+    await rm(chunkDir, { recursive: true, force: true }).catch(() => {});
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Command registration
+// ---------------------------------------------------------------------------
+
+export function registerSttCommand(program: Command): void {
+  const sttCmd = program
+    .command("stt")
+    .description("Speech-to-text operations");
+
+  const supportedProviders = listProviderIds().join(", ");
+
+  sttCmd.addHelpText(
+    "after",
+    `
+Speech-to-text commands use your configured STT provider to transcribe
+audio and video files. The provider is set via:
+
+  $ assistant config set services.stt.provider <provider>
+
+Supported providers: ${supportedProviders}.
+
+Examples:
+  $ assistant stt transcribe --file /path/to/meeting.wav
+  $ assistant stt transcribe --file /path/to/video.mp4 --json`,
+  );
+
+  // ── transcribe ──────────────────────────────────────────────────────
+
+  sttCmd
+    .command("transcribe")
+    .description("Transcribe an audio or video file to text")
+    .requiredOption("--file <path>", "Absolute path to the audio/video file")
+    .option("--json", "Output structured JSON instead of plain transcript text")
+    .addHelpText(
+      "after",
+      `
+Transcribes an audio or video file using the configured speech-to-text
+provider. Video files automatically have their audio extracted via ffmpeg.
+Large files (>25MB as WAV) are automatically split into chunks and
+transcribed sequentially.
+
+Supported audio formats: .mp3, .wav, .m4a, .aac, .ogg, .flac, .aiff, .wma
+Supported video formats: .mp4, .mov, .avi, .mkv, .webm, .m4v, .mpeg, .mpg
+
+Requires ffmpeg and ffprobe to be installed and on PATH.
+
+Examples:
+  $ assistant stt transcribe --file /path/to/recording.wav
+  $ assistant stt transcribe --file /path/to/meeting.mp4
+  $ assistant stt transcribe --file /path/to/podcast.mp3 --json`,
+    )
+    .action(async (opts: { file: string; json?: boolean }) => {
+      const filePath = opts.file;
+      const jsonOutput = opts.json ?? false;
+
+      // Validate file exists
+      try {
+        await access(filePath);
+      } catch {
+        const msg = `File not found: ${filePath}`;
+        if (jsonOutput) {
+          process.stdout.write(
+            JSON.stringify({ ok: false, error: msg }) + "\n",
+          );
+        } else {
+          log.error(msg);
+        }
+        process.exitCode = 1;
+        return;
+      }
+
+      // Validate file extension
+      const ext = extname(filePath).toLowerCase();
+      const isVideo = VIDEO_EXTENSIONS.has(ext);
+      const isAudio = AUDIO_EXTENSIONS.has(ext);
+      if (!isVideo && !isAudio) {
+        const msg = `Unsupported file type: ${ext}. Only audio and video files can be transcribed.`;
+        if (jsonOutput) {
+          process.stdout.write(
+            JSON.stringify({ ok: false, error: msg }) + "\n",
+          );
+        } else {
+          log.error(msg);
+        }
+        process.exitCode = 1;
+        return;
+      }
+
+      // Resolve STT provider
+      const transcriber = await resolveBatchTranscriber();
+      if (!transcriber) {
+        const msg =
+          "No speech-to-text provider is configured. Run 'assistant config set services.stt.provider <provider>' to set one up.";
+        if (jsonOutput) {
+          process.stdout.write(
+            JSON.stringify({ ok: false, error: msg }) + "\n",
+          );
+        } else {
+          log.error(msg);
+        }
+        process.exitCode = 1;
+        return;
+      }
+
+      let wavPath: string | null = null;
+      try {
+        // Convert to WAV
+        wavPath = await toWav(filePath, isVideo);
+
+        const startTime = Date.now();
+        const text = await transcribeWithProvider(wavPath, transcriber);
+        const durationSeconds = (Date.now() - startTime) / 1000;
+
+        if (!text.trim()) {
+          if (jsonOutput) {
+            process.stdout.write(
+              JSON.stringify({
+                ok: true,
+                transcript: "",
+                provider: transcriber.providerId,
+                durationSeconds,
+              }) + "\n",
+            );
+          } else {
+            process.stdout.write("No speech detected in the audio.\n");
+          }
+          return;
+        }
+
+        if (jsonOutput) {
+          process.stdout.write(
+            JSON.stringify({
+              ok: true,
+              transcript: text,
+              provider: transcriber.providerId,
+              durationSeconds,
+            }) + "\n",
+          );
+        } else {
+          process.stdout.write(text + "\n");
+        }
+      } catch (err) {
+        const msg = `Transcription failed: ${(err as Error).message}`;
+        if (jsonOutput) {
+          process.stdout.write(
+            JSON.stringify({ ok: false, error: msg }) + "\n",
+          );
+        } else {
+          log.error(msg);
+        }
+        process.exitCode = 1;
+      } finally {
+        if (wavPath) {
+          try {
+            await unlink(wavPath);
+          } catch {
+            /* ignore */
+          }
+        }
+      }
+    });
+}