@compilr-dev/cli 0.4.0

package/dist/ui/types.d.ts

@@ -0,0 +1,103 @@
+/**
+ * UI Types and Interfaces
+ *
+ * Shared types used across all UI modules.
+ */
+export interface UserMessage {
+    type: 'user';
+    content: string;
+    timestamp: Date;
+}
+export interface AssistantMessage {
+    type: 'assistant';
+    content: string;
+    timestamp: Date;
+}
+export interface ToolMessage {
+    type: 'tool';
+    name: string;
+    args?: string;
+    result?: string;
+    timestamp: Date;
+}
+export type ConversationMessage = UserMessage | AssistantMessage | ToolMessage;
+export interface TodoItem {
+    content: string;
+    status: 'pending' | 'in_progress' | 'completed';
+    activeForm?: string;
+}
+export interface SpinnerState {
+    text: string;
+    tool?: string;
+    tokens: number;
+    startTime: number;
+}
+export interface CommandOption {
+    command: string;
+    description: string;
+}
+export interface AutocompleteState {
+    options: CommandOption[];
+    selectedIndex: number;
+    inputPrefix: string;
+}
+export type InputResult = {
+    action: 'submit';
+    value: string;
+} | {
+    action: 'command';
+    command: string;
+    args: string;
+} | {
+    action: 'cancel';
+} | {
+    action: 'continue';
+};
+export interface PhysicalLayout {
+    lines: string[];
+    cursorRow: number;
+    cursorCol: number;
+    totalRows: number;
+}
+export interface ContextStats {
+    tokens: number;
+    maxTokens: number;
+    messages: number;
+    turns: number;
+    utilization: number;
+}
+export type PermissionResult = 'allow' | 'deny' | 'allow-always';
+/**
+ * Agent execution modes (cycle with Shift+Tab)
+ *
+ * - normal: Ask permission for dangerous operations (default)
+ * - auto-accept: Execute all operations without asking
+ * - plan: Generate plan only, don't execute (placeholder for now)
+ */
+export type AgentMode = 'normal' | 'auto-accept' | 'plan';
+/**
+ * Mode display info
+ */
+export interface ModeInfo {
+    mode: AgentMode;
+    label: string;
+    description: string;
+}
+/**
+ * Get display info for a mode
+ */
+export declare const MODE_INFO: Record<AgentMode, ModeInfo>;
+/**
+ * Get next mode in cycle
+ */
+export declare function getNextMode(current: AgentMode): AgentMode;
+export interface REPLState {
+    conversationHistory: ConversationMessage[];
+    spinner: SpinnerState | null;
+    todos: TodoItem[];
+    pendingMessages: string[];
+    isAgentRunning: boolean;
+    currentModel: string;
+    inputHistory: string[];
+    allowedTools: Set<string>;
+}

package/dist/ui/types.js

@@ -0,0 +1,33 @@
+/**
+ * UI Types and Interfaces
+ *
+ * Shared types used across all UI modules.
+ */
+/**
+ * Get display info for a mode
+ */
+export const MODE_INFO = {
+    'normal': {
+        mode: 'normal',
+        label: 'Normal',
+        description: 'Ask permission for dangerous operations',
+    },
+    'auto-accept': {
+        mode: 'auto-accept',
+        label: 'Auto-accept',
+        description: 'Execute all operations without asking',
+    },
+    'plan': {
+        mode: 'plan',
+        label: 'Plan',
+        description: 'Generate plan only (coming soon)',
+    },
+};
+/**
+ * Get next mode in cycle
+ */
+export function getNextMode(current) {
+    const modes = ['normal', 'auto-accept', 'plan'];
+    const currentIndex = modes.indexOf(current);
+    return modes[(currentIndex + 1) % modes.length];
+}

package/dist/utils/credentials.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Credentials Management
+ *
+ * Securely stores API keys using AES-256-GCM encryption.
+ * Encryption key is derived from:
+ * - Machine-specific identifiers (hostname, username)
+ * - A random "mk" value stored in settings.json
+ */
+export type ProviderKey = 'anthropic' | 'openai' | 'google' | 'ollama';
+export interface StoredCredentials {
+    anthropic?: string;
+    openai?: string;
+    google?: string;
+}
+/**
+ * Get API key for a provider
+ * Priority: Environment variable > Stored credential
+ */
+export declare function getApiKey(provider: ProviderKey): string | null;
+/**
+ * Set API key for a provider (stores encrypted)
+ */
+export declare function setApiKey(provider: ProviderKey, key: string): void;
+/**
+ * Delete API key for a provider
+ */
+export declare function deleteApiKey(provider: ProviderKey): void;
+/**
+ * Check if API key exists for a provider
+ */
+export declare function hasApiKey(provider: ProviderKey): boolean;
+/**
+ * Get masked version of API key for display
+ * Shows first 7 and last 4 characters
+ */
+export declare function getMaskedKey(provider: ProviderKey): string | null;
+/**
+ * Check if key is from environment variable
+ */
+export declare function isKeyFromEnv(provider: ProviderKey): boolean;
+/**
+ * Get all provider statuses
+ */
+export declare function getAllProviderStatuses(): Array<{
+    provider: ProviderKey;
+    name: string;
+    hasKey: boolean;
+    masked: string | null;
+    fromEnv: boolean;
+    keyUrl: string;
+}>;
+/**
+ * Map provider type from settings to credential provider key
+ */
+export declare function settingsProviderToCredentialKey(provider: 'auto' | 'claude' | 'openai' | 'gemini' | 'ollama'): ProviderKey;

package/dist/utils/credentials.js

@@ -0,0 +1,268 @@
+/**
+ * Credentials Management
+ *
+ * Securely stores API keys using AES-256-GCM encryption.
+ * Encryption key is derived from:
+ * - Machine-specific identifiers (hostname, username)
+ * - A random "mk" value stored in settings.json
+ */
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+// =============================================================================
+// Constants
+// =============================================================================
+const CONFIG_DIR = path.join(os.homedir(), '.compilr-dev');
+const SETTINGS_FILE = path.join(CONFIG_DIR, 'settings.json');
+const CREDENTIALS_FILE = path.join(CONFIG_DIR, 'credentials.enc');
+const ALGORITHM = 'aes-256-gcm';
+const SALT = 'compilr-dev-v1';
+// =============================================================================
+// Master Key Management
+// =============================================================================
+/**
+ * Get or create the master key ("mk") from settings.json
+ */
+function getMasterKey() {
+    try {
+        // Ensure config directory exists
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        // Load settings
+        let settings = {};
+        if (fs.existsSync(SETTINGS_FILE)) {
+            const parsed = JSON.parse(fs.readFileSync(SETTINGS_FILE, 'utf-8'));
+            if (parsed && typeof parsed === 'object') {
+                settings = parsed;
+            }
+        }
+        // Check if mk exists
+        if (settings.mk && typeof settings.mk === 'string' && settings.mk.length === 64) {
+            return settings.mk;
+        }
+        // Generate new mk (32 bytes = 64 hex chars)
+        const mk = crypto.randomBytes(32).toString('hex');
+        settings.mk = mk;
+        // Save back to settings
+        fs.writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2), 'utf-8');
+        return mk;
+    }
+    catch (error) {
+        throw new Error(`Failed to manage master key: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Derive encryption key from master key + machine identifiers
+ */
+function deriveKey() {
+    const mk = getMasterKey();
+    const machineId = `${os.hostname()}:${os.userInfo().username}`;
+    // Use scrypt for key derivation (secure, slow by design)
+    return crypto.scryptSync(`${mk}:${machineId}`, SALT, 32);
+}
+// =============================================================================
+// Encryption/Decryption
+// =============================================================================
+/**
+ * Encrypt data using AES-256-GCM
+ */
+function encrypt(data) {
+    const key = deriveKey();
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+    let encrypted = cipher.update(data, 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+    const authTag = cipher.getAuthTag();
+    // Format: iv:authTag:encrypted
+    return `${iv.toString('hex')}:${authTag.toString('hex')}:${encrypted}`;
+}
+/**
+ * Decrypt data using AES-256-GCM
+ */
+function decrypt(encryptedData) {
+    const key = deriveKey();
+    const parts = encryptedData.split(':');
+    if (parts.length !== 3) {
+        throw new Error('Invalid encrypted data format');
+    }
+    const iv = Buffer.from(parts[0], 'hex');
+    const authTag = Buffer.from(parts[1], 'hex');
+    const encrypted = parts[2];
+    const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+    decipher.setAuthTag(authTag);
+    let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+    decrypted += decipher.final('utf8');
+    return decrypted;
+}
+// =============================================================================
+// Credentials Storage
+// =============================================================================
+/**
+ * Load all stored credentials
+ */
+function loadCredentials() {
+    try {
+        if (!fs.existsSync(CREDENTIALS_FILE)) {
+            return {};
+        }
+        const encryptedData = fs.readFileSync(CREDENTIALS_FILE, 'utf-8');
+        const decrypted = decrypt(encryptedData);
+        return JSON.parse(decrypted);
+    }
+    catch {
+        // If decryption fails (e.g., key changed), return empty
+        return {};
+    }
+}
+/**
+ * Save all credentials
+ */
+function saveCredentials(credentials) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    const encrypted = encrypt(JSON.stringify(credentials));
+    fs.writeFileSync(CREDENTIALS_FILE, encrypted, 'utf-8');
+}
+// =============================================================================
+// Public API
+// =============================================================================
+/**
+ * Get API key for a provider
+ * Priority: Environment variable > Stored credential
+ */
+export function getApiKey(provider) {
+    // Check environment variable first
+    const envVarMap = {
+        anthropic: 'ANTHROPIC_API_KEY',
+        openai: 'OPENAI_API_KEY',
+        google: 'GOOGLE_API_KEY',
+        ollama: '', // No key needed
+    };
+    const envVar = envVarMap[provider];
+    if (envVar && process.env[envVar]) {
+        return process.env[envVar] ?? null;
+    }
+    // Check stored credentials
+    if (provider === 'ollama') {
+        return 'local'; // Ollama doesn't need a key
+    }
+    const credentials = loadCredentials();
+    return credentials[provider] ?? null;
+}
+/**
+ * Set API key for a provider (stores encrypted)
+ */
+export function setApiKey(provider, key) {
+    if (provider === 'ollama') {
+        return; // Ollama doesn't need a key
+    }
+    const credentials = loadCredentials();
+    credentials[provider] = key;
+    saveCredentials(credentials);
+}
+/**
+ * Delete API key for a provider
+ */
+export function deleteApiKey(provider) {
+    const credentials = loadCredentials();
+    // Remove the key by setting to undefined and then filtering
+    if (provider === 'anthropic') {
+        delete credentials.anthropic;
+    }
+    else if (provider === 'openai') {
+        delete credentials.openai;
+    }
+    else if (provider === 'google') {
+        delete credentials.google;
+    }
+    saveCredentials(credentials);
+}
+/**
+ * Check if API key exists for a provider
+ */
+export function hasApiKey(provider) {
+    return getApiKey(provider) !== null;
+}
+/**
+ * Get masked version of API key for display
+ * Shows first 7 and last 4 characters
+ */
+export function getMaskedKey(provider) {
+    const key = getApiKey(provider);
+    if (!key || key === 'local') {
+        return key;
+    }
+    if (key.length <= 15) {
+        return '***';
+    }
+    return `${key.substring(0, 7)}...${key.substring(key.length - 4)}`;
+}
+/**
+ * Check if key is from environment variable
+ */
+export function isKeyFromEnv(provider) {
+    const envVarMap = {
+        anthropic: 'ANTHROPIC_API_KEY',
+        openai: 'OPENAI_API_KEY',
+        google: 'GOOGLE_API_KEY',
+        ollama: '',
+    };
+    const envVar = envVarMap[provider];
+    return !!(envVar && process.env[envVar]);
+}
+/**
+ * Get all provider statuses
+ */
+export function getAllProviderStatuses() {
+    return [
+        {
+            provider: 'anthropic',
+            name: 'Anthropic (Claude)',
+            hasKey: hasApiKey('anthropic'),
+            masked: getMaskedKey('anthropic'),
+            fromEnv: isKeyFromEnv('anthropic'),
+            keyUrl: 'https://console.anthropic.com/settings/keys',
+        },
+        {
+            provider: 'openai',
+            name: 'OpenAI',
+            hasKey: hasApiKey('openai'),
+            masked: getMaskedKey('openai'),
+            fromEnv: isKeyFromEnv('openai'),
+            keyUrl: 'https://platform.openai.com/api-keys',
+        },
+        {
+            provider: 'google',
+            name: 'Google AI (Gemini)',
+            hasKey: hasApiKey('google'),
+            masked: getMaskedKey('google'),
+            fromEnv: isKeyFromEnv('google'),
+            keyUrl: 'https://aistudio.google.com/apikey',
+        },
+        {
+            provider: 'ollama',
+            name: 'Ollama (Local)',
+            hasKey: true, // Always available
+            masked: 'local',
+            fromEnv: false,
+            keyUrl: 'https://ollama.ai',
+        },
+    ];
+}
+/**
+ * Map provider type from settings to credential provider key
+ */
+export function settingsProviderToCredentialKey(provider) {
+    switch (provider) {
+        case 'claude':
+            return 'anthropic';
+        case 'gemini':
+            return 'google';
+        case 'openai':
+            return 'openai';
+        case 'ollama':
+            return 'ollama';
+        case 'auto':
+        default:
+            return 'anthropic'; // Default to anthropic for auto
+    }
+}

package/dist/utils/model-tiers.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Model Tier Detection
+ *
+ * Categorizes LLM models by capability tier (small/medium/large)
+ * and provides upgrade suggestions within the same provider.
+ *
+ * Used by commands like /design to warn users about model limitations
+ * and suggest alternatives.
+ */
+export type TierLevel = 'small' | 'medium' | 'large';
+export interface ModelTier {
+    tier: TierLevel;
+    provider: string;
+    suggestedUpgrade?: string;
+}
+/**
+ * Get the tier information for a model.
+ * Handles versioned model names (e.g., claude-3-5-sonnet-20241022)
+ */
+export declare function getModelTier(modelId: string): ModelTier;
+/**
+ * Get the minimum tier required for a command.
+ */
+export declare function getCommandMinTier(command: string): TierLevel;
+/**
+ * Compare two tier levels.
+ * Returns: -1 if a < b, 0 if a == b, 1 if a > b
+ */
+export declare function compareTiers(a: TierLevel, b: TierLevel): number;
+/**
+ * Check if a model meets the minimum tier requirement for a command.
+ */
+export declare function modelMeetsTier(modelId: string, command: string): boolean;
+/**
+ * Get a friendly display name for a tier.
+ */
+export declare function getTierDisplayName(tier: TierLevel): string;

package/dist/utils/model-tiers.js

@@ -0,0 +1,118 @@
+/**
+ * Model Tier Detection
+ *
+ * Categorizes LLM models by capability tier (small/medium/large)
+ * and provides upgrade suggestions within the same provider.
+ *
+ * Used by commands like /design to warn users about model limitations
+ * and suggest alternatives.
+ */
+// =============================================================================
+// Model Tier Mappings
+// =============================================================================
+const MODEL_TIERS = {
+    // Claude (Anthropic)
+    'claude-3-opus': { tier: 'large', provider: 'anthropic' },
+    'claude-opus-4': { tier: 'large', provider: 'anthropic' },
+    'claude-sonnet-4': { tier: 'large', provider: 'anthropic' },
+    'claude-3-5-sonnet': { tier: 'large', provider: 'anthropic' },
+    'claude-3-sonnet': { tier: 'large', provider: 'anthropic' },
+    'claude-3-5-haiku': { tier: 'medium', provider: 'anthropic', suggestedUpgrade: 'claude-sonnet-4-20250514' },
+    'claude-3-haiku': { tier: 'medium', provider: 'anthropic', suggestedUpgrade: 'claude-sonnet-4-20250514' },
+    // OpenAI
+    'gpt-4o': { tier: 'large', provider: 'openai' },
+    'gpt-4-turbo': { tier: 'large', provider: 'openai' },
+    'gpt-4': { tier: 'large', provider: 'openai' },
+    'gpt-4o-mini': { tier: 'medium', provider: 'openai', suggestedUpgrade: 'gpt-4o' },
+    'gpt-3.5-turbo': { tier: 'small', provider: 'openai', suggestedUpgrade: 'gpt-4o-mini' },
+    'o1': { tier: 'large', provider: 'openai' },
+    'o1-mini': { tier: 'medium', provider: 'openai', suggestedUpgrade: 'o1' },
+    'o1-preview': { tier: 'large', provider: 'openai' },
+    // Google (Gemini)
+    'gemini-1.5-pro': { tier: 'large', provider: 'google' },
+    'gemini-2.0-flash': { tier: 'large', provider: 'google' },
+    'gemini-2.5-pro': { tier: 'large', provider: 'google' },
+    'gemini-2.5-flash': { tier: 'medium', provider: 'google', suggestedUpgrade: 'gemini-2.5-pro' },
+    'gemini-1.5-flash': { tier: 'medium', provider: 'google', suggestedUpgrade: 'gemini-1.5-pro' },
+    'gemini-2.0-flash-lite': { tier: 'small', provider: 'google', suggestedUpgrade: 'gemini-2.0-flash' },
+    // Ollama / Local models (common ones)
+    'llama3.2': { tier: 'small', provider: 'ollama', suggestedUpgrade: 'llama3.1:70b' },
+    'llama3.1': { tier: 'medium', provider: 'ollama', suggestedUpgrade: 'llama3.1:70b' },
+    'llama3.1:70b': { tier: 'large', provider: 'ollama' },
+    'mistral': { tier: 'small', provider: 'ollama' },
+    'mixtral': { tier: 'medium', provider: 'ollama' },
+    'codellama': { tier: 'medium', provider: 'ollama' },
+    'deepseek-coder': { tier: 'medium', provider: 'ollama' },
+    'qwen2.5-coder': { tier: 'medium', provider: 'ollama' },
+};
+// =============================================================================
+// Functions
+// =============================================================================
+/**
+ * Get the tier information for a model.
+ * Handles versioned model names (e.g., claude-3-5-sonnet-20241022)
+ */
+export function getModelTier(modelId) {
+    // Check exact match first
+    if (modelId in MODEL_TIERS) {
+        return MODEL_TIERS[modelId];
+    }
+    // Check partial match (for versioned models like claude-3-5-sonnet-20241022)
+    for (const [key, value] of Object.entries(MODEL_TIERS)) {
+        if (modelId.startsWith(key)) {
+            return value;
+        }
+    }
+    // Ollama/local models - assume small unless known
+    if (modelId.includes('ollama') || modelId.includes('localhost')) {
+        return { tier: 'small', provider: 'ollama' };
+    }
+    // Unknown - assume medium (safer than assuming small)
+    return { tier: 'medium', provider: 'unknown' };
+}
+/**
+ * Get the minimum tier required for a command.
+ */
+export function getCommandMinTier(command) {
+    const requirements = {
+        '/design': 'large',
+        '/refine': 'large',
+        '/arch': 'large',
+        '/build': 'medium',
+        '/prd': 'medium',
+        '/sketch': 'small', // Simplified version - works with any model
+        '/init': 'small',
+        '/backlog': 'small',
+        '/note': 'small',
+    };
+    return requirements[command] ?? 'small';
+}
+/**
+ * Compare two tier levels.
+ * Returns: -1 if a < b, 0 if a == b, 1 if a > b
+ */
+export function compareTiers(a, b) {
+    const order = { small: 0, medium: 1, large: 2 };
+    return order[a] - order[b];
+}
+/**
+ * Check if a model meets the minimum tier requirement for a command.
+ */
+export function modelMeetsTier(modelId, command) {
+    const modelTier = getModelTier(modelId);
+    const minTier = getCommandMinTier(command);
+    return compareTiers(modelTier.tier, minTier) >= 0;
+}
+/**
+ * Get a friendly display name for a tier.
+ */
+export function getTierDisplayName(tier) {
+    switch (tier) {
+        case 'small':
+            return 'Small';
+        case 'medium':
+            return 'Medium';
+        case 'large':
+            return 'Large';
+    }
+}

package/dist/utils/project-memory.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Project Memory Loader
+ *
+ * Loads project-level instructions from COMPILR.md or CLAUDE.md files.
+ * Provides size guards and warnings for large files.
+ */
+export interface ProjectMemoryResult {
+    /** Whether a memory file was found */
+    found: boolean;
+    /** The loaded content (may be truncated) */
+    content: string;
+    /** Path to the file that was loaded */
+    filePath: string | null;
+    /** Original file size in bytes */
+    originalSize: number;
+    /** Whether the content was truncated */
+    truncated: boolean;
+    /** Estimated token count (chars / 4) */
+    estimatedTokens: number;
+}
+export interface ProjectMemoryOptions {
+    /** Maximum content size in bytes before truncation (default: 100KB) */
+    maxSize?: number;
+    /** Size threshold for warning (default: 30KB) */
+    warnSize?: number;
+    /** Custom search directory (default: process.cwd()) */
+    cwd?: string;
+}
+/**
+ * Load project memory from COMPILR.md or CLAUDE.md
+ *
+ * @param options - Configuration options
+ * @returns Result with content and metadata
+ */
+export declare function loadProjectMemory(options?: ProjectMemoryOptions): ProjectMemoryResult;
+/**
+ * Check if a project memory file exists without loading it
+ */
+export declare function hasProjectMemory(cwd?: string): boolean;
+/**
+ * Get the size category for display purposes
+ */
+export declare function getSizeCategory(bytes: number): 'small' | 'medium' | 'large';
+/**
+ * Format bytes as human-readable string
+ */
+export declare function formatBytes(bytes: number): string;