@vellumai/assistant 0.8.0 → 0.8.1

package/src/cli/commands/conversations-defer.ts

@@ -1,82 +1,24 @@
 import type { Command } from "commander";
 
 import { cliIpcCall } from "../../ipc/cli-client.js";
+import { registerCommand } from "../lib/register-command.js";
 import { log } from "../logger.js";
+import { resolveConversationId } from "../utils/conversation-id.js";
+import { parseDuration } from "../utils/parse-duration.js";
 
-// ---------------------------------------------------------------------------
-// Duration parser
-// ---------------------------------------------------------------------------
-
-/**
- * Parse a human-friendly duration string into seconds.
- *
- * Accepted formats:
- *   "60"     → 60   (bare number = seconds)
- *   "60s"    → 60
- *   "5m"     → 300
- *   "1h"     → 3600
- *   "1h30m"  → 5400
- *   "90s"    → 90
- */
-export function parseDuration(input: string): number {
-  if (/^\d+$/.test(input)) return parseInt(input, 10);
-
-  let total = 0;
-  const re = /(\d+)(h|m|s)/g;
-  let match;
-  while ((match = re.exec(input)) !== null) {
-    const val = parseInt(match[1], 10);
-    switch (match[2]) {
-      case "h":
-        total += val * 3600;
-        break;
-      case "m":
-        total += val * 60;
-        break;
-      case "s":
-        total += val;
-        break;
-    }
-  }
-  if (total === 0) throw new Error(`Invalid duration: "${input}"`);
-  return total;
-}
-
-// ---------------------------------------------------------------------------
-// Conversation ID resolution
-// ---------------------------------------------------------------------------
-
-function resolveConversationId(positionalArg?: string): string {
-  if (positionalArg) return positionalArg;
-
-  const skillCtxRaw = process.env.__SKILL_CONTEXT_JSON;
-  if (skillCtxRaw) {
-    try {
-      const ctx = JSON.parse(skillCtxRaw) as Record<string, unknown>;
-      if (typeof ctx.conversationId === "string" && ctx.conversationId) {
-        return ctx.conversationId;
-      }
-    } catch {
-      // Ignore malformed JSON
-    }
-  }
-
-  const envConvId = process.env.__CONVERSATION_ID;
-  if (envConvId) return envConvId;
-
-  throw new Error(
-    "No conversation ID provided. Pass it as an argument, or set $__SKILL_CONTEXT_JSON or $__CONVERSATION_ID.",
-  );
-}
+export { parseDuration };
 
 // ---------------------------------------------------------------------------
 // Registration
 // ---------------------------------------------------------------------------
 
 export function registerConversationsDeferCommand(parent: Command): void {
-  const defer = parent
-    .command("defer [conversationId]")
-    .description("Create a deferred wake for a conversation")
+  registerCommand(parent, {
+    name: "defer [conversationId]",
+    transport: "ipc",
+    description: "Create a deferred wake for a conversation",
+    build: (defer) => {
+      defer
     .option("--in <duration>", "Delay before firing (e.g. 60, 60s, 5m, 1h)")
     .option("--at <iso8601>", "Absolute ISO 8601 fire time")
     .option("--hint <text>", "Hint message for the wake")
@@ -110,7 +52,11 @@ Examples:
       ) => {
         let conversationId: string;
         try {
-          conversationId = resolveConversationId(conversationIdArg);
+          conversationId = resolveConversationId({
+            explicit: conversationIdArg,
+            failureHelp:
+              "No conversation ID provided. Pass it as an argument, or set $__SKILL_CONTEXT_JSON or $__CONVERSATION_ID.",
+          });
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
           if (opts.json) {
@@ -361,4 +307,6 @@ Examples:
         }
       },
     );
+    },
+  });
 }

package/src/cli/commands/conversations-import.ts

@@ -1,29 +1,12 @@
 import { existsSync, readFileSync } from "node:fs";
 
 import type { Command } from "commander";
-import { eq } from "drizzle-orm";
 
-import { getConfig } from "../../config/loader.js";
-import {
-  addMessage,
-  createConversation,
-} from "../../memory/conversation-crud.js";
-import {
-  getConversationByKey,
-  setConversationKey,
-} from "../../memory/conversation-key-store.js";
-import { getDb } from "../../memory/db-connection.js";
-import { indexMessageNow } from "../../memory/indexer.js";
-import {
-  conversations as conversationsTable,
-  messages as messagesTable,
-} from "../../memory/schema.js";
-import { getLogger } from "../../util/logger.js";
+import { cliIpcCall, exitFromIpcResult } from "../../ipc/cli-client.js";
+import { registerCommand } from "../lib/register-command.js";
 import { log } from "../logger.js";
 
-const importLog = getLogger("conversations-import");
-
-// -- Import payload schema --
+// -- Import payload schema (local, no daemon imports) --
 
 interface ImportMessage {
   role: string;
@@ -55,7 +38,7 @@ interface ImportResult {
   }>;
 }
 
-// -- Validation --
+// -- Validation (pure logic, no daemon imports) --
 
 function validatePayload(raw: unknown): ImportPayload {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
@@ -68,9 +51,7 @@ function validatePayload(raw: unknown): ImportPayload {
   for (let i = 0; i < obj.conversations.length; i++) {
     const conv = obj.conversations[i] as Record<string, unknown>;
     if (!conv.title || typeof conv.title !== "string") {
-      throw new Error(
-        `conversations[${i}].title is required and must be a string`,
-      );
+      throw new Error(`conversations[${i}].title is required and must be a string`);
     }
     if (!Array.isArray(conv.messages) || conv.messages.length === 0) {
       throw new Error(`conversations[${i}].messages must be a non-empty array`);
@@ -81,174 +62,27 @@ function validatePayload(raw: unknown): ImportPayload {
         throw new Error(`conversations[${i}].messages[${j}].role is required`);
       }
       if (msg.content === undefined || msg.content === null) {
-        throw new Error(
-          `conversations[${i}].messages[${j}].content is required`,
-        );
+        throw new Error(`conversations[${i}].messages[${j}].content is required`);
       }
     }
   }
   return obj as unknown as ImportPayload;
 }
 
-// -- Timestamp resolution --
-
-function resolveTimestamps(conv: ImportConversation): {
-  convCreatedAt: number;
-  convUpdatedAt: number;
-  messageTimestamps: number[];
-} {
-  const now = Date.now();
-  const convCreatedAt = conv.createdAt ?? now;
-  const convUpdatedAt = conv.updatedAt ?? conv.createdAt ?? now;
-
-  const messageTimestamps = conv.messages.map((msg, i) => {
-    if (msg.createdAt != null) return msg.createdAt;
-    return convCreatedAt + i;
-  });
-
-  return { convCreatedAt, convUpdatedAt, messageTimestamps };
-}
-
-// -- Core import logic --
-
-async function importConversations(
-  payload: ImportPayload,
-): Promise<ImportResult> {
-  const db = getDb();
-  const memoryConfig = getConfig().memory;
-
-  let imported = 0;
-  let skipped = 0;
-  let totalMessages = 0;
-  const errors: ImportResult["errors"] = [];
-
-  for (let idx = 0; idx < payload.conversations.length; idx++) {
-    const conv = payload.conversations[idx];
-
-    try {
-      // Dedup via sourceKey
-      if (conv.sourceKey) {
-        const existing = getConversationByKey(conv.sourceKey);
-        if (existing) {
-          skipped++;
-          continue;
-        }
-      }
-
-      const { convCreatedAt, convUpdatedAt, messageTimestamps } =
-        resolveTimestamps(conv);
-
-      // Create conversation
-      const conversation = createConversation(conv.title);
-
-      // Insert messages with skipIndexing (timestamps will be overridden)
-      for (const msg of conv.messages) {
-        const contentStr =
-          typeof msg.content === "string"
-            ? msg.content
-            : JSON.stringify(msg.content);
-
-        await addMessage(conversation.id, msg.role, contentStr, undefined, {
-          skipIndexing: true,
-        });
-      }
-
-      // Override conversation timestamps to match originals
-      db.update(conversationsTable)
-        .set({
-          createdAt: convCreatedAt,
-          updatedAt: convUpdatedAt,
-          lastMessageAt: messageTimestamps[messageTimestamps.length - 1],
-        })
-        .where(eq(conversationsTable.id, conversation.id))
-        .run();
-
-      // Override message timestamps to match originals
-      const dbMessages = db
-        .select({ id: messagesTable.id })
-        .from(messagesTable)
-        .where(eq(messagesTable.conversationId, conversation.id))
-        .orderBy(messagesTable.createdAt)
-        .all();
-
-      for (
-        let i = 0;
-        i < dbMessages.length && i < messageTimestamps.length;
-        i++
-      ) {
-        db.update(messagesTable)
-          .set({ createdAt: messageTimestamps[i] })
-          .where(eq(messagesTable.id, dbMessages[i].id))
-          .run();
-      }
-
-      // Index messages with original timestamps (non-fatal on failure)
-      for (let i = 0; i < dbMessages.length && i < conv.messages.length; i++) {
-        const msg = conv.messages[i];
-        const contentStr =
-          typeof msg.content === "string"
-            ? msg.content
-            : JSON.stringify(msg.content);
-
-        try {
-          await indexMessageNow(
-            {
-              messageId: dbMessages[i].id,
-              conversationId: conversation.id,
-              role: msg.role,
-              content: contentStr,
-              createdAt: messageTimestamps[i],
-            },
-            memoryConfig,
-          );
-        } catch (err) {
-          importLog.warn(
-            "Failed to index imported message %s in conversation %s: %s",
-            dbMessages[i].id,
-            conversation.id,
-            err instanceof Error ? err.message : String(err),
-          );
-        }
-      }
-
-      // Register sourceKey for dedup
-      if (conv.sourceKey) {
-        setConversationKey(conv.sourceKey, conversation.id);
-      }
-
-      imported++;
-      totalMessages += conv.messages.length;
-    } catch (err) {
-      errors.push({
-        index: idx,
-        sourceKey: conv.sourceKey,
-        error: err instanceof Error ? err.message : String(err),
-      });
-    }
-  }
-
-  return {
-    ok: errors.length === 0,
-    imported,
-    skipped,
-    messages: totalMessages,
-    errors,
-  };
-}
-
 // -- CLI registration --
 
-export function registerConversationsImportCommand(
-  conversations: Command,
-): void {
-  conversations
-    .command("import")
-    .description("Import conversations from a standard JSON format")
-    .option("--file <path>", "Read JSON from file instead of stdin")
-    .option("--json", "Output result as machine-readable JSON")
-    .addHelpText(
-      "after",
-      `
+export function registerConversationsImportCommand(conversations: Command): void {
+  registerCommand(conversations, {
+    name: "import",
+    transport: "ipc",
+    description: "Import conversations from a standard JSON format",
+    build: (cmd) => {
+      cmd
+        .option("--file <path>", "Read JSON from file instead of stdin")
+        .option("--json", "Output result as machine-readable JSON")
+        .addHelpText(
+          "after",
+          `
 Imports conversations into the assistant from a standard JSON format.
 Reads from stdin by default, or from a file with --file.
 
@@ -270,77 +104,80 @@ Examples:
   $ bun run scripts/parse-export.ts --file export.zip | assistant conversations import --json
   $ assistant conversations import --file import.json --json
   $ cat data.json | assistant conversations import`,
-    )
-    .action(async (opts: { file?: string; json?: boolean }) => {
-      let raw: string;
-      try {
-        if (opts.file) {
-          if (!existsSync(opts.file)) {
-            throw new Error(`File not found: ${opts.file}`);
+        )
+        .action(async (opts: { file?: string; json?: boolean }) => {
+          let raw: string;
+          try {
+            if (opts.file) {
+              if (!existsSync(opts.file)) {
+                throw new Error(`File not found: ${opts.file}`);
+              }
+              raw = readFileSync(opts.file, "utf-8");
+            } else {
+              if (process.stdin.isTTY) {
+                throw new Error(
+                  "No input provided. Pipe JSON into stdin or use --file <path>.",
+                );
+              }
+              raw = readFileSync("/dev/stdin", "utf-8");
+            }
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (opts.json) {
+              log.info(JSON.stringify({ ok: false, error: msg }));
+            } else {
+              log.error(`Error: ${msg}`);
+            }
+            process.exitCode = 1;
+            return;
           }
-          raw = readFileSync(opts.file, "utf-8");
-        } else {
-          if (process.stdin.isTTY) {
-            throw new Error(
-              "No input provided. Pipe JSON into stdin or use --file <path>.",
-            );
-          }
-          raw = readFileSync("/dev/stdin", "utf-8");
-        }
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        if (opts.json) {
-          log.info(JSON.stringify({ ok: false, error: msg }));
-        } else {
-          log.error(`Error: ${msg}`);
-        }
-        process.exitCode = 1;
-        return;
-      }
-
-      let payload: ImportPayload;
-      try {
-        const parsed = JSON.parse(raw);
-        payload = validatePayload(parsed);
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        if (opts.json) {
-          log.info(JSON.stringify({ ok: false, error: msg }));
-        } else {
-          log.error(`Error: ${msg}`);
-        }
-        process.exitCode = 1;
-        return;
-      }
 
-      if (payload.conversations.length === 0) {
-        const result = { ok: true, imported: 0, skipped: 0, messages: 0 };
-        if (opts.json) {
-          log.info(JSON.stringify(result));
-        } else {
-          log.info("No conversations to import.");
-        }
-        return;
-      }
+          let payload: ImportPayload;
+          try {
+            const parsed = JSON.parse(raw);
+            payload = validatePayload(parsed);
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (opts.json) {
+              log.info(JSON.stringify({ ok: false, error: msg }));
+            } else {
+              log.error(`Error: ${msg}`);
+            }
+            process.exitCode = 1;
+            return;
+          }
 
-      getDb();
-      const result = await importConversations(payload);
+          if (payload.conversations.length === 0) {
+            const result = { ok: true, imported: 0, skipped: 0, messages: 0 };
+            if (opts.json) {
+              log.info(JSON.stringify(result));
+            } else {
+              log.info("No conversations to import.");
+            }
+            return;
+          }
 
-      if (opts.json) {
-        log.info(JSON.stringify(result));
-      } else {
-        const lines = [
-          `Imported ${result.imported} conversation(s) with ${result.messages} message(s).`,
-        ];
-        if (result.skipped > 0) {
-          lines.push(
-            `Skipped ${result.skipped} already-imported conversation(s).`,
-          );
-        }
-        if (result.errors.length > 0) {
-          lines.push(`Failed: ${result.errors.length} conversation(s).`);
-        }
-        log.info(lines.join("\n"));
-      }
-    });
+          const r = await cliIpcCall<ImportResult>("conversations_import", {
+            body: { conversations: payload.conversations as unknown as Record<string, unknown>[] },
+          });
+          if (!r.ok) return exitFromIpcResult(r as { ok: false; error?: string; statusCode?: number });
+
+          const result = r.result!;
+          if (opts.json) {
+            log.info(JSON.stringify(result));
+          } else {
+            const lines = [
+              `Imported ${result.imported} conversation(s) with ${result.messages} message(s).`,
+            ];
+            if (result.skipped > 0) {
+              lines.push(`Skipped ${result.skipped} already-imported conversation(s).`);
+            }
+            if (result.errors.length > 0) {
+              lines.push(`Failed: ${result.errors.length} conversation(s).`);
+            }
+            log.info(lines.join("\n"));
+          }
+        });
+    },
+  });
 }