@vibeframe/cli 0.27.0 → 0.30.0

package/src/config/config.test.ts

@@ -1,197 +0,0 @@
-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

@@ -1,125 +0,0 @@
-/**
- * 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

@@ -1,82 +0,0 @@
-/**
- * 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

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