@vellumai/cli 0.4.35 → 0.4.37

package/src/commands/autonomy.ts

@@ -1,320 +0,0 @@
-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/config.ts

@@ -1,178 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-
-import { syncConfigToLockfile } from "../lib/assistant-config";
-import {
-  getAllowlistPath,
-  getNestedValue,
-  loadRawConfig,
-  saveRawConfig,
-  setNestedValue,
-} from "../lib/config";
-
-interface AllowlistConfig {
-  values?: string[];
-  prefixes?: string[];
-  patterns?: string[];
-}
-
-interface AllowlistValidationError {
-  index: number;
-  pattern: string;
-  message: string;
-}
-
-function validateAllowlist(
-  allowlistConfig: AllowlistConfig,
-): AllowlistValidationError[] {
-  const errors: AllowlistValidationError[] = [];
-  if (!allowlistConfig.patterns) return errors;
-  if (!Array.isArray(allowlistConfig.patterns)) {
-    errors.push({
-      index: -1,
-      pattern: String(allowlistConfig.patterns),
-      message: '"patterns" must be an array',
-    });
-    return errors;
-  }
-
-  for (let i = 0; i < allowlistConfig.patterns.length; i++) {
-    const p = allowlistConfig.patterns[i];
-    if (typeof p !== "string") {
-      errors.push({
-        index: i,
-        pattern: String(p),
-        message: "Pattern is not a string",
-      });
-      continue;
-    }
-    try {
-      new RegExp(p);
-    } catch (err) {
-      errors.push({
-        index: i,
-        pattern: p,
-        message: (err as Error).message,
-      });
-    }
-  }
-  return errors;
-}
-
-function validateAllowlistFile(): AllowlistValidationError[] | null {
-  const filePath = getAllowlistPath();
-  if (!existsSync(filePath)) return null;
-
-  const raw = readFileSync(filePath, "utf-8");
-  const allowlistConfig: AllowlistConfig = JSON.parse(raw) as AllowlistConfig;
-  return validateAllowlist(allowlistConfig);
-}
-
-function printUsage(): void {
-  console.log("Usage: vellum config <subcommand> [options]");
-  console.log("");
-  console.log("Subcommands:");
-  console.log(
-    "  get <key>              Get a config value (supports dotted paths)",
-  );
-  console.log(
-    "  set <key> <value>      Set a config value (supports dotted paths like apiKeys.anthropic)",
-  );
-  console.log("  list                   List all config values");
-  console.log(
-    "  validate-allowlist     Validate regex patterns in secret-allowlist.json",
-  );
-}
-
-export function config(): void {
-  const args = process.argv.slice(3);
-  const subcommand = args[0];
-
-  if (!subcommand || subcommand === "--help" || subcommand === "-h") {
-    printUsage();
-    return;
-  }
-
-  switch (subcommand) {
-    case "set": {
-      const key = args[1];
-      const value = args[2];
-      if (!key || value === undefined) {
-        console.error("Usage: vellum config set <key> <value>");
-        process.exit(1);
-      }
-      const raw = loadRawConfig();
-      let parsed: unknown = value;
-      try {
-        parsed = JSON.parse(value);
-      } catch {
-        // keep as string
-      }
-      setNestedValue(raw, key, parsed);
-      saveRawConfig(raw);
-      syncConfigToLockfile();
-      console.log(`Set ${key} = ${JSON.stringify(parsed)}`);
-      break;
-    }
-
-    case "get": {
-      const key = args[1];
-      if (!key) {
-        console.error("Usage: vellum config get <key>");
-        process.exit(1);
-      }
-      const raw = loadRawConfig();
-      const val = getNestedValue(raw, key);
-      if (val === undefined) {
-        console.log("(not set)");
-      } else {
-        console.log(
-          typeof val === "object" ? JSON.stringify(val, null, 2) : String(val),
-        );
-      }
-      break;
-    }
-
-    case "list": {
-      const raw = loadRawConfig();
-      if (Object.keys(raw).length === 0) {
-        console.log("No configuration set");
-      } else {
-        console.log(JSON.stringify(raw, null, 2));
-      }
-      break;
-    }
-
-    case "validate-allowlist": {
-      try {
-        const errors = validateAllowlistFile();
-        if (errors === null) {
-          console.log("No secret-allowlist.json file found");
-          return;
-        }
-        if (errors.length === 0) {
-          console.log("All patterns in secret-allowlist.json are valid");
-          return;
-        }
-        console.error(
-          `Found ${errors.length} invalid pattern(s) in secret-allowlist.json:`,
-        );
-        for (const e of errors) {
-          console.error(`  [${e.index}] "${e.pattern}": ${e.message}`);
-        }
-        process.exit(1);
-      } catch (err) {
-        console.error(
-          `Failed to read secret-allowlist.json: ${(err as Error).message}`,
-        );
-        process.exit(1);
-      }
-      break;
-    }
-
-    default: {
-      console.error(`Unknown config subcommand: ${subcommand}`);
-      printUsage();
-      process.exit(1);
-    }
-  }
-}