@vibeframe/cli 0.27.0

package/src/config/config.test.ts

@@ -0,0 +1,197 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { resolve } from "node:path";
+import { rm, mkdir, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import {
+  createDefaultConfig,
+  PROVIDER_NAMES,
+  PROVIDER_ENV_VARS,
+  type VibeConfig,
+} from "./schema.js";
+
+// Mock homedir for tests
+const TEST_HOME = resolve(tmpdir(), `vibe-config-test-${Date.now()}`);
+
+vi.mock("node:os", async () => {
+  const actual = await vi.importActual("node:os");
+  return {
+    ...(actual as object),
+    homedir: () => TEST_HOME,
+  };
+});
+
+// Import after mock
+const { loadConfig, saveConfig, isConfigured, CONFIG_DIR, CONFIG_PATH } = await import("./index.js");
+
+describe("Config Schema", () => {
+  describe("createDefaultConfig", () => {
+    it("creates a valid default configuration", () => {
+      const config = createDefaultConfig();
+
+      expect(config.version).toBe("1.0.0");
+      expect(config.llm.provider).toBe("claude");
+      expect(config.providers).toEqual({});
+      expect(config.defaults.aspectRatio).toBe("16:9");
+      expect(config.defaults.exportQuality).toBe("standard");
+      expect(config.repl.autoSave).toBe(true);
+    });
+  });
+
+  describe("PROVIDER_NAMES", () => {
+    it("has display names for all providers", () => {
+      expect(PROVIDER_NAMES.claude).toBe("Claude (Anthropic)");
+      expect(PROVIDER_NAMES.openai).toBe("GPT-4 (OpenAI)");
+      expect(PROVIDER_NAMES.gemini).toBe("Gemini (Google)");
+      expect(PROVIDER_NAMES.ollama).toBe("Ollama (Local)");
+    });
+  });
+
+  describe("PROVIDER_ENV_VARS", () => {
+    it("has environment variables for all providers", () => {
+      expect(PROVIDER_ENV_VARS.anthropic).toBe("ANTHROPIC_API_KEY");
+      expect(PROVIDER_ENV_VARS.openai).toBe("OPENAI_API_KEY");
+      expect(PROVIDER_ENV_VARS.google).toBe("GOOGLE_API_KEY");
+      expect(PROVIDER_ENV_VARS.elevenlabs).toBe("ELEVENLABS_API_KEY");
+      expect(PROVIDER_ENV_VARS.runway).toBe("RUNWAY_API_SECRET");
+      expect(PROVIDER_ENV_VARS.kling).toBe("KLING_API_KEY");
+      expect(PROVIDER_ENV_VARS.replicate).toBe("REPLICATE_API_TOKEN");
+    });
+  });
+});
+
+describe("Config Loader", () => {
+  beforeEach(async () => {
+    // Clean up test directory
+    try {
+      await rm(TEST_HOME, { recursive: true, force: true });
+    } catch {
+      // Ignore
+    }
+  });
+
+  afterEach(async () => {
+    // Clean up test directory
+    try {
+      await rm(TEST_HOME, { recursive: true, force: true });
+    } catch {
+      // Ignore
+    }
+  });
+
+  describe("loadConfig", () => {
+    it("returns null when config does not exist", async () => {
+      const config = await loadConfig();
+      expect(config).toBeNull();
+    });
+
+    it("loads existing config", async () => {
+      // Create config directory and file
+      await mkdir(CONFIG_DIR, { recursive: true });
+      const testConfig: VibeConfig = {
+        version: "1.0.0",
+        llm: { provider: "openai" },
+        providers: { openai: "test-key" },
+        defaults: { aspectRatio: "9:16", exportQuality: "high" },
+        repl: { autoSave: false },
+      };
+
+      const { writeFile: fsWrite } = await import("node:fs/promises");
+      const { stringify } = await import("yaml");
+      await fsWrite(CONFIG_PATH, stringify(testConfig), "utf-8");
+
+      const loaded = await loadConfig();
+      expect(loaded).not.toBeNull();
+      expect(loaded?.llm.provider).toBe("openai");
+      expect(loaded?.providers.openai).toBe("test-key");
+      expect(loaded?.defaults.aspectRatio).toBe("9:16");
+      expect(loaded?.repl.autoSave).toBe(false);
+    });
+
+    it("merges with defaults for missing fields", async () => {
+      await mkdir(CONFIG_DIR, { recursive: true });
+      const partialConfig = {
+        version: "1.0.0",
+        llm: { provider: "gemini" },
+        providers: {},
+        defaults: {},
+        repl: {},
+      };
+
+      const { writeFile: fsWrite } = await import("node:fs/promises");
+      const { stringify } = await import("yaml");
+      await fsWrite(CONFIG_PATH, stringify(partialConfig), "utf-8");
+
+      const loaded = await loadConfig();
+      expect(loaded?.llm.provider).toBe("gemini");
+      expect(loaded?.defaults.aspectRatio).toBe("16:9"); // Default
+      expect(loaded?.repl.autoSave).toBe(true); // Default
+    });
+  });
+
+  describe("saveConfig", () => {
+    it("creates config directory and file", async () => {
+      const config = createDefaultConfig();
+      config.llm.provider = "openai";
+      config.providers.openai = "sk-test-123";
+
+      await saveConfig(config);
+
+      const content = await readFile(CONFIG_PATH, "utf-8");
+      expect(content).toContain("provider: openai");
+      expect(content).toContain("openai: sk-test-123");
+    });
+
+    it("overwrites existing config", async () => {
+      const config1 = createDefaultConfig();
+      config1.llm.provider = "claude";
+      await saveConfig(config1);
+
+      const config2 = createDefaultConfig();
+      config2.llm.provider = "gemini";
+      await saveConfig(config2);
+
+      const loaded = await loadConfig();
+      expect(loaded?.llm.provider).toBe("gemini");
+    });
+  });
+
+  describe("isConfigured", () => {
+    it("returns false when no config exists", async () => {
+      const configured = await isConfigured();
+      expect(configured).toBe(false);
+    });
+
+    it("returns false when config exists but no API key", async () => {
+      const config = createDefaultConfig();
+      await saveConfig(config);
+
+      const configured = await isConfigured();
+      expect(configured).toBe(false);
+    });
+
+    it("returns true when API key is in config", async () => {
+      const config = createDefaultConfig();
+      config.llm.provider = "claude";
+      config.providers.anthropic = "test-key";
+      await saveConfig(config);
+
+      const configured = await isConfigured();
+      expect(configured).toBe(true);
+    });
+
+    it("returns true when API key is in environment", async () => {
+      const config = createDefaultConfig();
+      config.llm.provider = "openai";
+      await saveConfig(config);
+
+      // Set environment variable
+      process.env.OPENAI_API_KEY = "test-env-key";
+
+      const configured = await isConfigured();
+      expect(configured).toBe(true);
+
+      // Clean up
+      delete process.env.OPENAI_API_KEY;
+    });
+  });
+});

package/src/config/index.ts

@@ -0,0 +1,125 @@
+/**
+ * Configuration loader/saver for VibeFrame CLI
+ * Config stored at ~/.vibeframe/config.yaml
+ */
+
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+import { readFile, writeFile, mkdir, access } from "node:fs/promises";
+import { parse, stringify } from "yaml";
+import { type VibeConfig, createDefaultConfig, PROVIDER_ENV_VARS } from "./schema.js";
+
+/** Config directory path */
+export const CONFIG_DIR = resolve(homedir(), ".vibeframe");
+
+/** Config file path */
+export const CONFIG_PATH = resolve(CONFIG_DIR, "config.yaml");
+
+/**
+ * Load configuration from ~/.vibeframe/config.yaml
+ * Returns null if config doesn't exist
+ */
+export async function loadConfig(): Promise<VibeConfig | null> {
+  try {
+    await access(CONFIG_PATH);
+    const content = await readFile(CONFIG_PATH, "utf-8");
+    const config = parse(content) as VibeConfig;
+
+    // Merge with defaults to ensure all fields exist
+    const defaults = createDefaultConfig();
+    return {
+      ...defaults,
+      ...config,
+      llm: { ...defaults.llm, ...config.llm },
+      providers: { ...defaults.providers, ...config.providers },
+      defaults: { ...defaults.defaults, ...config.defaults },
+      repl: { ...defaults.repl, ...config.repl },
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Save configuration to ~/.vibeframe/config.yaml
+ */
+export async function saveConfig(config: VibeConfig): Promise<void> {
+  // Ensure config directory exists
+  await mkdir(CONFIG_DIR, { recursive: true });
+
+  // Write config as YAML
+  const content = stringify(config, {
+    indent: 2,
+    lineWidth: 0, // Don't wrap lines
+  });
+
+  await writeFile(CONFIG_PATH, content, "utf-8");
+}
+
+/**
+ * Check if configuration exists and has required API key
+ */
+export async function isConfigured(): Promise<boolean> {
+  const config = await loadConfig();
+  if (!config) return false;
+
+  // Check if primary LLM provider has API key
+  const provider = config.llm.provider;
+  const providerKey = provider === "gemini" ? "google" : provider === "claude" ? "anthropic" : provider;
+
+  // Check config first, then environment
+  if (config.providers[providerKey as keyof typeof config.providers]) {
+    return true;
+  }
+
+  const envVar = PROVIDER_ENV_VARS[providerKey];
+  if (envVar && process.env[envVar]) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Get API key from config, then environment
+ * @param providerKey Provider key (e.g., "anthropic", "openai")
+ * @returns API key or undefined
+ */
+export async function getApiKeyFromConfig(
+  providerKey: string
+): Promise<string | undefined> {
+  const config = await loadConfig();
+
+  // Check config first
+  if (config?.providers[providerKey as keyof typeof config.providers]) {
+    return config.providers[providerKey as keyof typeof config.providers];
+  }
+
+  // Fall back to environment variable
+  const envVar = PROVIDER_ENV_VARS[providerKey];
+  if (envVar) {
+    return process.env[envVar];
+  }
+
+  return undefined;
+}
+
+/**
+ * Update a specific provider API key in config
+ */
+export async function updateProviderKey(
+  providerKey: string,
+  apiKey: string
+): Promise<void> {
+  let config = await loadConfig();
+  if (!config) {
+    config = createDefaultConfig();
+  }
+
+  config.providers[providerKey as keyof typeof config.providers] = apiKey;
+  await saveConfig(config);
+}
+
+// Re-export types
+export type { VibeConfig, LLMProvider } from "./schema.js";
+export { createDefaultConfig, PROVIDER_NAMES, PROVIDER_ENV_VARS } from "./schema.js";

package/src/config/schema.ts

@@ -0,0 +1,82 @@
+/**
+ * Configuration schema for VibeFrame CLI
+ * Stored at ~/.vibeframe/config.yaml
+ */
+
+export type LLMProvider = "claude" | "openai" | "gemini" | "ollama" | "xai";
+
+export interface VibeConfig {
+  /** Config file version */
+  version: string;
+
+  /** LLM provider settings */
+  llm: {
+    /** Primary LLM provider for AI commands */
+    provider: LLMProvider;
+  };
+
+  /** API keys for various providers */
+  providers: {
+    anthropic?: string;
+    openai?: string;
+    google?: string;
+    elevenlabs?: string;
+    runway?: string;
+    kling?: string;
+    imgbb?: string;
+    replicate?: string;
+    xai?: string;
+  };
+
+  /** Default settings for new projects */
+  defaults: {
+    aspectRatio: "16:9" | "9:16" | "1:1" | "4:5";
+    exportQuality: "draft" | "standard" | "high" | "ultra";
+  };
+
+  /** REPL settings */
+  repl: {
+    /** Auto-save project after each command */
+    autoSave: boolean;
+  };
+}
+
+/** Provider display names */
+export const PROVIDER_NAMES: Record<LLMProvider, string> = {
+  claude: "Claude (Anthropic)",
+  openai: "GPT-4 (OpenAI)",
+  gemini: "Gemini (Google)",
+  ollama: "Ollama (Local)",
+  xai: "Grok (xAI)",
+};
+
+/** Environment variable mappings */
+export const PROVIDER_ENV_VARS: Record<string, string> = {
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  google: "GOOGLE_API_KEY",
+  elevenlabs: "ELEVENLABS_API_KEY",
+  runway: "RUNWAY_API_SECRET",
+  kling: "KLING_API_KEY",
+  imgbb: "IMGBB_API_KEY",
+  replicate: "REPLICATE_API_TOKEN",
+  xai: "XAI_API_KEY",
+};
+
+/** Default configuration */
+export function createDefaultConfig(): VibeConfig {
+  return {
+    version: "1.0.0",
+    llm: {
+      provider: "claude",
+    },
+    providers: {},
+    defaults: {
+      aspectRatio: "16:9",
+      exportQuality: "standard",
+    },
+    repl: {
+      autoSave: true,
+    },
+  };
+}

package/src/engine/index.ts

@@ -0,0 +1,2 @@
+export { Project, generateId } from "./project.js";
+export type { ProjectFile } from "./project.js";