@vellumai/cli 0.3.11 → 0.3.12

package/src/commands/autonomy.ts

@@ -0,0 +1,321 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+// ---------------------------------------------------------------------------
+// Types & constants (ported from assistant/src/autonomy/types.ts)
+// ---------------------------------------------------------------------------
+
+type AutonomyTier = "auto" | "draft" | "notify";
+
+const AUTONOMY_TIERS: readonly AutonomyTier[] = ["auto", "draft", "notify"];
+
+interface AutonomyConfig {
+  defaultTier: AutonomyTier;
+  channelDefaults: Record<string, AutonomyTier>;
+  categoryOverrides: Record<string, AutonomyTier>;
+  contactOverrides: Record<string, AutonomyTier>;
+}
+
+const DEFAULT_AUTONOMY_CONFIG: AutonomyConfig = {
+  defaultTier: "notify",
+  channelDefaults: {},
+  categoryOverrides: {},
+  contactOverrides: {},
+};
+
+// ---------------------------------------------------------------------------
+// Config persistence (ported from assistant/src/autonomy/autonomy-store.ts)
+// ---------------------------------------------------------------------------
+
+function getConfigPath(): string {
+  const root = join(
+    process.env.BASE_DATA_DIR?.trim() || homedir(),
+    ".vellum",
+  );
+  return join(root, "workspace", "autonomy.json");
+}
+
+function isValidTier(value: unknown): value is AutonomyTier {
+  return (
+    typeof value === "string" &&
+    AUTONOMY_TIERS.includes(value as AutonomyTier)
+  );
+}
+
+function validateTierRecord(raw: unknown): Record<string, AutonomyTier> {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+  const result: Record<string, AutonomyTier> = {};
+  for (const [key, value] of Object.entries(
+    raw as Record<string, unknown>,
+  )) {
+    if (isValidTier(value)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+function validateConfig(raw: unknown): AutonomyConfig {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return structuredClone(DEFAULT_AUTONOMY_CONFIG);
+  }
+  const obj = raw as Record<string, unknown>;
+  return {
+    defaultTier: isValidTier(obj.defaultTier)
+      ? obj.defaultTier
+      : DEFAULT_AUTONOMY_CONFIG.defaultTier,
+    channelDefaults: validateTierRecord(obj.channelDefaults),
+    categoryOverrides: validateTierRecord(obj.categoryOverrides),
+    contactOverrides: validateTierRecord(obj.contactOverrides),
+  };
+}
+
+function loadConfig(): AutonomyConfig {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    return structuredClone(DEFAULT_AUTONOMY_CONFIG);
+  }
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    return validateConfig(JSON.parse(raw));
+  } catch {
+    console.error("Warning: failed to parse autonomy config; using defaults");
+    return structuredClone(DEFAULT_AUTONOMY_CONFIG);
+  }
+}
+
+function saveConfig(config: AutonomyConfig): void {
+  const configPath = getConfigPath();
+  mkdirSync(dirname(configPath), { recursive: true });
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+
+function applyUpdate(updates: Partial<AutonomyConfig>): AutonomyConfig {
+  const current = loadConfig();
+  if (updates.defaultTier !== undefined) {
+    current.defaultTier = updates.defaultTier;
+  }
+  if (updates.channelDefaults !== undefined) {
+    current.channelDefaults = {
+      ...current.channelDefaults,
+      ...updates.channelDefaults,
+    };
+  }
+  if (updates.categoryOverrides !== undefined) {
+    current.categoryOverrides = {
+      ...current.categoryOverrides,
+      ...updates.categoryOverrides,
+    };
+  }
+  if (updates.contactOverrides !== undefined) {
+    current.contactOverrides = {
+      ...current.contactOverrides,
+      ...updates.contactOverrides,
+    };
+  }
+  saveConfig(current);
+  return current;
+}
+
+// ---------------------------------------------------------------------------
+// Output helpers
+// ---------------------------------------------------------------------------
+
+function output(data: unknown, json: boolean): void {
+  process.stdout.write(
+    json ? JSON.stringify(data) + "\n" : JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function formatConfigForHuman(config: AutonomyConfig): string {
+  const lines: string[] = [`  Default tier: ${config.defaultTier}`];
+
+  const channelEntries = Object.entries(config.channelDefaults);
+  if (channelEntries.length > 0) {
+    lines.push("  Channel defaults:");
+    for (const [channel, tier] of channelEntries) {
+      lines.push(`    ${channel}: ${tier}`);
+    }
+  } else {
+    lines.push("  Channel defaults: (none)");
+  }
+
+  const categoryEntries = Object.entries(config.categoryOverrides);
+  if (categoryEntries.length > 0) {
+    lines.push("  Category overrides:");
+    for (const [category, tier] of categoryEntries) {
+      lines.push(`    ${category}: ${tier}`);
+    }
+  } else {
+    lines.push("  Category overrides: (none)");
+  }
+
+  const contactEntries = Object.entries(config.contactOverrides);
+  if (contactEntries.length > 0) {
+    lines.push("  Contact overrides:");
+    for (const [contactId, tier] of contactEntries) {
+      lines.push(`    ${contactId}: ${tier}`);
+    }
+  } else {
+    lines.push("  Contact overrides: (none)");
+  }
+
+  return lines.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Arg parsing helpers
+// ---------------------------------------------------------------------------
+
+function hasFlag(args: string[], flag: string): boolean {
+  return args.includes(flag);
+}
+
+function getFlagValue(args: string[], flag: string): string | undefined {
+  const idx = args.indexOf(flag);
+  if (idx === -1 || idx + 1 >= args.length) return undefined;
+  return args[idx + 1];
+}
+
+// ---------------------------------------------------------------------------
+// Usage
+// ---------------------------------------------------------------------------
+
+function printUsage(): void {
+  console.log("Usage: vellum autonomy <subcommand> [options]");
+  console.log("");
+  console.log("Subcommands:");
+  console.log("  get                              Show current autonomy configuration");
+  console.log("  set --default <tier>             Set the global default tier");
+  console.log("  set --channel <ch> --tier <t>    Set tier for a channel");
+  console.log("  set --category <cat> --tier <t>  Set tier for a category");
+  console.log("  set --contact <id> --tier <t>    Set tier for a contact");
+  console.log("");
+  console.log("Options:");
+  console.log("  --json    Machine-readable JSON output");
+  console.log("");
+  console.log("Tiers: auto, draft, notify");
+}
+
+// ---------------------------------------------------------------------------
+// Command entry point
+// ---------------------------------------------------------------------------
+
+export function autonomy(): void {
+  const args = process.argv.slice(3);
+  const subcommand = args[0];
+  const json = hasFlag(args, "--json");
+
+  if (!subcommand || subcommand === "--help" || subcommand === "-h") {
+    printUsage();
+    return;
+  }
+
+  switch (subcommand) {
+    case "get": {
+      const config = loadConfig();
+      if (json) {
+        output({ ok: true, config }, true);
+      } else {
+        process.stdout.write("Autonomy configuration:\n\n");
+        process.stdout.write(formatConfigForHuman(config) + "\n");
+      }
+      break;
+    }
+
+    case "set": {
+      const defaultTier = getFlagValue(args, "--default");
+      const channel = getFlagValue(args, "--channel");
+      const category = getFlagValue(args, "--category");
+      const contact = getFlagValue(args, "--contact");
+      const tier = getFlagValue(args, "--tier");
+
+      if (defaultTier) {
+        if (!isValidTier(defaultTier)) {
+          output(
+            {
+              ok: false,
+              error: `Invalid tier "${defaultTier}". Must be one of: ${AUTONOMY_TIERS.join(", ")}`,
+            },
+            true,
+          );
+          process.exitCode = 1;
+          return;
+        }
+        const config = applyUpdate({ defaultTier });
+        if (json) {
+          output({ ok: true, config }, true);
+        } else {
+          console.log(`Set global default tier to "${defaultTier}".`);
+        }
+        return;
+      }
+
+      if (!tier) {
+        output(
+          { ok: false, error: "Missing --tier. Use --tier <auto|draft|notify>." },
+          true,
+        );
+        process.exitCode = 1;
+        return;
+      }
+      if (!isValidTier(tier)) {
+        output(
+          {
+            ok: false,
+            error: `Invalid tier "${tier}". Must be one of: ${AUTONOMY_TIERS.join(", ")}`,
+          },
+          true,
+        );
+        process.exitCode = 1;
+        return;
+      }
+
+      if (channel) {
+        const config = applyUpdate({ channelDefaults: { [channel]: tier } });
+        if (json) {
+          output({ ok: true, config }, true);
+        } else {
+          console.log(`Set channel "${channel}" default to "${tier}".`);
+        }
+        return;
+      }
+
+      if (category) {
+        const config = applyUpdate({
+          categoryOverrides: { [category]: tier },
+        });
+        if (json) {
+          output({ ok: true, config }, true);
+        } else {
+          console.log(`Set category "${category}" override to "${tier}".`);
+        }
+        return;
+      }
+
+      if (contact) {
+        const config = applyUpdate({ contactOverrides: { [contact]: tier } });
+        if (json) {
+          output({ ok: true, config }, true);
+        } else {
+          console.log(`Set contact "${contact}" override to "${tier}".`);
+        }
+        return;
+      }
+
+      console.error(
+        "Specify one of: --default <tier>, --channel <channel> --tier <tier>, " +
+          "--category <category> --tier <tier>, or --contact <contactId> --tier <tier>.",
+      );
+      process.exitCode = 1;
+      break;
+    }
+
+    default: {
+      console.error(`Unknown autonomy subcommand: ${subcommand}`);
+      printUsage();
+      process.exit(1);
+    }
+  }
+}

package/src/commands/client.ts

@@ -1,10 +1,15 @@
 import { readFileSync } from "fs";
 import { join } from "path";
 
-import { ANSI, renderChatApp } from "../components/DefaultMainScreen";
 import { findAssistantByName, loadLatestAssistant } from "../lib/assistant-config";
 import { GATEWAY_PORT, type Species } from "../lib/constants";
 
+const ANSI = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+};
+
 const FALLBACK_RUNTIME_URL = `http://127.0.0.1:${GATEWAY_PORT}`;
 const FALLBACK_ASSISTANT_ID = "default";
 
@@ -80,10 +85,10 @@ function parseArgs(): ParsedArgs {
 }
 
 function printUsage(): void {
-  console.log(`${ANSI.bold}vellum-cli client${ANSI.reset} - Connect to a hatched assistant
+  console.log(`${ANSI.bold}vellum client${ANSI.reset} - Connect to a hatched assistant
 
 ${ANSI.bold}USAGE:${ANSI.reset}
-    vellum-cli client [name] [options]
+    vellum client [name] [options]
 
 ${ANSI.bold}ARGUMENTS:${ANSI.reset}
     [name]                     Instance name (default: latest)
@@ -94,20 +99,22 @@ ${ANSI.bold}OPTIONS:${ANSI.reset}
     -h, --help                 Show this help message
 
 ${ANSI.bold}DEFAULTS:${ANSI.reset}
-    Reads from ~/.vellum.lock.json (created by vellum-cli hatch).
+    Reads from ~/.vellum.lock.json (created by vellum hatch).
     Override with flags above or env vars RUNTIME_URL / ASSISTANT_ID.
 
 ${ANSI.bold}EXAMPLES:${ANSI.reset}
-    vellum-cli client
-    vellum-cli client vellum-assistant-foo
-    vellum-cli client --url http://34.56.78.90:${GATEWAY_PORT}
-    vellum-cli client vellum-assistant-foo --url http://localhost:${GATEWAY_PORT}
+    vellum client
+    vellum client vellum-assistant-foo
+    vellum client --url http://34.56.78.90:${GATEWAY_PORT}
+    vellum client vellum-assistant-foo --url http://localhost:${GATEWAY_PORT}
 `);
 }
 
 export async function client(): Promise<void> {
   const { runtimeUrl, assistantId, species, bearerToken, project, zone } = parseArgs();
 
+  const { renderChatApp } = await import("../components/DefaultMainScreen");
+
   process.stdout.write("\x1b[2J\x1b[H");
 
   const app = renderChatApp(

package/src/commands/contacts.ts

@@ -0,0 +1,265 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import { loadLatestAssistant } from "../lib/assistant-config";
+
+// ---------------------------------------------------------------------------
+// Runtime API client
+// ---------------------------------------------------------------------------
+
+function getRuntimeUrl(): string {
+  const entry = loadLatestAssistant();
+  if (entry?.runtimeUrl) return entry.runtimeUrl;
+  return "http://localhost:7821";
+}
+
+function getBearerToken(): string | undefined {
+  const entry = loadLatestAssistant();
+  if (entry?.bearerToken) return entry.bearerToken;
+  try {
+    const tokenPath = join(
+      process.env.BASE_DATA_DIR?.trim() || homedir(),
+      ".vellum",
+      "http-token",
+    );
+    if (existsSync(tokenPath)) {
+      const token = readFileSync(tokenPath, "utf-8").trim();
+      if (token) return token;
+    }
+  } catch {
+    // ignore
+  }
+  return undefined;
+}
+
+function buildHeaders(): Record<string, string> {
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+  };
+  const token = getBearerToken();
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  return headers;
+}
+
+async function apiGet(path: string): Promise<unknown> {
+  const url = `${getRuntimeUrl()}/v1/${path}`;
+  const response = await fetch(url, { headers: buildHeaders() });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`API error ${response.status}: ${text}`);
+  }
+  return response.json();
+}
+
+async function apiPost(
+  path: string,
+  body: unknown,
+): Promise<unknown> {
+  const url = `${getRuntimeUrl()}/v1/${path}`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: buildHeaders(),
+    body: JSON.stringify(body),
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`API error ${response.status}: ${text}`);
+  }
+  return response.json();
+}
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+interface ContactChannel {
+  type: string;
+  address: string;
+  isPrimary: boolean;
+}
+
+interface Contact {
+  id: string;
+  displayName: string;
+  relationship: string | null;
+  importance: number;
+  responseExpectation: string | null;
+  preferredTone: string | null;
+  lastInteraction: number | null;
+  interactionCount: number;
+  channels: ContactChannel[];
+}
+
+// ---------------------------------------------------------------------------
+// Output helpers
+// ---------------------------------------------------------------------------
+
+function hasFlag(args: string[], flag: string): boolean {
+  return args.includes(flag);
+}
+
+function getFlagValue(args: string[], flag: string): string | undefined {
+  const idx = args.indexOf(flag);
+  if (idx === -1 || idx + 1 >= args.length) return undefined;
+  return args[idx + 1];
+}
+
+function formatContact(c: Contact): string {
+  const lines = [
+    `  ID:           ${c.id}`,
+    `  Name:         ${c.displayName}`,
+    `  Relationship: ${c.relationship ?? "(none)"}`,
+    `  Importance:   ${c.importance.toFixed(2)}`,
+    `  Response:     ${c.responseExpectation ?? "(none)"}`,
+    `  Tone:         ${c.preferredTone ?? "(none)"}`,
+    `  Interactions: ${c.interactionCount}`,
+  ];
+  if (c.lastInteraction) {
+    lines.push(`  Last seen:    ${new Date(c.lastInteraction).toISOString()}`);
+  }
+  if (c.channels.length > 0) {
+    lines.push("  Channels:");
+    for (const ch of c.channels) {
+      const primary = ch.isPrimary ? " (primary)" : "";
+      lines.push(`    - ${ch.type}: ${ch.address}${primary}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Usage
+// ---------------------------------------------------------------------------
+
+function printUsage(): void {
+  console.log("Usage: vellum contacts <subcommand> [options]");
+  console.log("");
+  console.log("Subcommands:");
+  console.log("  list [--limit N]               List all contacts");
+  console.log("  get <id>                       Get a contact by ID");
+  console.log("  merge <keepId> <mergeId>       Merge two contacts");
+  console.log("");
+  console.log("Options:");
+  console.log("  --json    Machine-readable JSON output");
+}
+
+// ---------------------------------------------------------------------------
+// Command entry point
+// ---------------------------------------------------------------------------
+
+export async function contacts(): Promise<void> {
+  const args = process.argv.slice(3);
+  const subcommand = args[0];
+  const json = hasFlag(args, "--json");
+
+  if (!subcommand || subcommand === "--help" || subcommand === "-h") {
+    printUsage();
+    return;
+  }
+
+  switch (subcommand) {
+    case "list": {
+      const limit = getFlagValue(args, "--limit") ?? "50";
+      const data = (await apiGet(`contacts?limit=${limit}`)) as {
+        ok: boolean;
+        contacts: Contact[];
+      };
+
+      if (json) {
+        console.log(JSON.stringify(data));
+        return;
+      }
+
+      if (data.contacts.length === 0) {
+        console.log("No contacts found.");
+        return;
+      }
+
+      console.log(`Contacts (${data.contacts.length}):\n`);
+      for (const c of data.contacts) {
+        console.log(formatContact(c) + "\n");
+      }
+      break;
+    }
+
+    case "get": {
+      const id = args[1];
+      if (!id || id.startsWith("--")) {
+        console.error("Usage: vellum contacts get <id>");
+        process.exit(1);
+      }
+
+      try {
+        const data = (await apiGet(`contacts/${encodeURIComponent(id)}`)) as {
+          ok: boolean;
+          contact: Contact;
+        };
+
+        if (json) {
+          console.log(JSON.stringify(data));
+        } else {
+          console.log(formatContact(data.contact));
+        }
+      } catch {
+        if (json) {
+          console.log(
+            JSON.stringify({
+              ok: false,
+              error: `Contact "${id}" not found`,
+            }),
+          );
+        } else {
+          console.error(`Contact "${id}" not found.`);
+        }
+        process.exitCode = 1;
+      }
+      break;
+    }
+
+    case "merge": {
+      const keepId = args[1];
+      const mergeId = args[2];
+      if (
+        !keepId ||
+        !mergeId ||
+        keepId.startsWith("--") ||
+        mergeId.startsWith("--")
+      ) {
+        console.error("Usage: vellum contacts merge <keepId> <mergeId>");
+        process.exit(1);
+      }
+
+      try {
+        const data = (await apiPost("contacts/merge", {
+          keepId,
+          mergeId,
+        })) as { ok: boolean; contact: Contact };
+
+        if (json) {
+          console.log(JSON.stringify(data));
+        } else {
+          console.log(`Merged contact "${mergeId}" into "${keepId}".\n`);
+          console.log(formatContact(data.contact));
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (json) {
+          console.log(JSON.stringify({ ok: false, error: msg }));
+        } else {
+          console.error(`Error: ${msg}`);
+        }
+        process.exitCode = 1;
+      }
+      break;
+    }
+
+    default: {
+      console.error(`Unknown contacts subcommand: ${subcommand}`);
+      printUsage();
+      process.exit(1);
+    }
+  }
+}