ownkey 0.2.0 → 0.5.0

package/src/commands/config.ts

@@ -1,154 +0,0 @@
-import { Command } from 'commander';
-import inquirer from 'inquirer';
-import { configManager } from '../config/manager.js';
-import { logger } from '../utils/logger.js';
-import { AIProvider } from '../types/index.js';
-import chalk from 'chalk';
-
-export const configCommand = new Command('config')
-    .description('Configure OwnKey CLI (Supabase, AI providers)')
-    .option('--supabase-url <url>', 'Supabase project URL')
-    .option('--supabase-key <key>', 'Supabase service role key')
-    .option('--provider <provider>', 'AI provider (openai, anthropic, ollama)')
-    .option('--api-key <key>', 'API key for the provider')
-    .option('--model <model>', 'Model name to use')
-    .option('--reset', 'Reset configuration to defaults')
-    .action(async (options) => {
-        try {
-            // Handle reset
-            if (options.reset) {
-                const { confirm } = await inquirer.prompt([
-                    {
-                        type: 'confirm',
-                        name: 'confirm',
-                        message: 'Are you sure you want to reset configuration?',
-                        default: false,
-                    },
-                ]);
-
-                if (confirm) {
-                    await configManager.reset();
-                    logger.success('Configuration reset successfully');
-                }
-                return;
-            }
-
-            // If flags provided, use them
-            if (options.supabaseUrl || options.provider) {
-                await handleFlagBasedConfig(options);
-                return;
-            }
-
-            // Otherwise, run interactive wizard
-            await runInteractiveWizard();
-        } catch (error) {
-            logger.error('Configuration failed', error as Error);
-            process.exit(1);
-        }
-    });
-
-async function handleFlagBasedConfig(options: any): Promise<void> {
-    // Configure Supabase
-    if (options.supabaseUrl && options.supabaseKey) {
-        await configManager.setSupabase(options.supabaseUrl, options.supabaseKey);
-        logger.success('Supabase configured');
-    }
-
-    // Configure AI provider
-    if (options.provider && options.apiKey) {
-        const provider = options.provider as AIProvider;
-        await configManager.setProvider(provider, options.apiKey, options.model);
-        logger.success(`${provider} provider configured`);
-    }
-}
-
-async function runInteractiveWizard(): Promise<void> {
-    console.log(chalk.cyan('\n🔧 OwnKey Configuration Wizard\n'));
-
-    // Step 1: Supabase configuration
-    console.log(chalk.bold('Step 1: Supabase Database (Optional)'));
-    console.log(chalk.gray('Supabase stores your analysis history and suggestions.'));
-    console.log(chalk.gray('You can skip this and run in local-only mode.\n'));
-
-    const { configureSupabase } = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'configureSupabase',
-            message: 'Configure Supabase database?',
-            default: true,
-        },
-    ]);
-
-    if (configureSupabase) {
-        const supabaseAnswers = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'url',
-                message: 'Supabase URL:',
-                validate: (input) => {
-                    if (!input) return 'URL is required';
-                    if (!input.startsWith('postgresql://')) {
-                        return 'URL should start with postgresql://';
-                    }
-                    return true;
-                },
-            },
-            {
-                type: 'password',
-                name: 'key',
-                message: 'Supabase Service Role Key:',
-                validate: (input) => (input ? true : 'Service role key is required'),
-            },
-        ]);
-
-        await configManager.setSupabase(supabaseAnswers.url, supabaseAnswers.key);
-        logger.success('Supabase configured');
-    } else {
-        logger.info('Skipping Supabase. You can configure it later.');
-    }
-
-    // Step 2: AI Provider configuration
-    console.log(chalk.bold('\nStep 2: AI Provider'));
-    console.log(chalk.gray('Choose your AI provider for code analysis.\n'));
-
-    const { provider } = await inquirer.prompt([
-        {
-            type: 'list',
-            name: 'provider',
-            message: 'Choose AI provider:',
-            choices: [
-                { name: 'OpenAI (GPT-4)', value: 'openai' },
-                { name: 'Anthropic (Claude)', value: 'anthropic' },
-                { name: 'Ollama (Local)', value: 'ollama' },
-            ],
-        },
-    ]);
-
-    // Get API key (not needed for Ollama)
-    if (provider !== 'ollama') {
-        const { apiKey } = await inquirer.prompt([
-            {
-                type: 'password',
-                name: 'apiKey',
-                message: `${provider === 'openai' ? 'OpenAI' : 'Anthropic'} API Key:`,
-                validate: (input) => (input ? true : 'API key is required'),
-            },
-        ]);
-
-        await configManager.setProvider(provider, apiKey);
-    } else {
-        // For Ollama, just set it as active provider
-        const config = await configManager.load();
-        config.activeProvider = 'ollama';
-        await configManager.save(config);
-        logger.success('Ollama configured (using local endpoint)');
-    }
-
-    // Step 3: Test connection (optional)
-    console.log(chalk.bold('\n✓ Configuration Complete!\n'));
-    console.log(chalk.green('You can now use OwnKey to analyze your codebase.\n'));
-    console.log(chalk.cyan('Next steps:'));
-    console.log(chalk.gray('  1. ownkey scan <path>    - Scan your project'));
-    console.log(chalk.gray('  2. ownkey suggest <path> - Get AI suggestions'));
-    console.log(chalk.gray('  3. ownkey apply <id>     - Apply a suggestion\n'));
-}

package/src/commands/scan.ts

@@ -1,114 +0,0 @@
-import { Command } from 'commander';
-import { resolve } from 'path';
-import { existsSync } from 'fs';
-import { logger } from '../utils/logger.js';
-import { FileScanner } from '../core/scanner.js';
-import { dbOps } from '../db/operations.js';
-import { dbClient } from '../db/client.js';
-import chalk from 'chalk';
-
-export const scanCommand = new Command('scan')
-    .description('Scan a project directory')
-    .argument('[path]', 'Path to scan', '.')
-    .option('--max-file-size <size>', 'Maximum file size (e.g., 500kb, 1mb)', '500kb')
-    .option('--ignore <patterns...>', 'Additional ignore patterns')
-    .action(async (path: string, options) => {
-        try {
-            const targetPath = resolve(path);
-
-            // Validate path
-            if (!existsSync(targetPath)) {
-                logger.error(`Path does not exist: ${targetPath}`);
-                process.exit(1);
-            }
-
-            logger.info(`Scanning: ${chalk.cyan(targetPath)}`);
-
-            // Parse max file size
-            const maxFileSize = parseFileSize(options.maxFileSize);
-
-            // Create scanner
-            const scanner = new FileScanner(targetPath, maxFileSize);
-
-            // Scan
-            const startTime = Date.now();
-            const result = await scanner.scan();
-            const duration = ((Date.now() - startTime) / 1000).toFixed(2);
-
-            // Display results
-            console.log(chalk.bold('\n📊 Scan Results:\n'));
-            console.log(`  Files found:    ${chalk.green(result.files.length)}`);
-            console.log(`  Total size:     ${formatBytes(result.totalSize)}`);
-            console.log(`  Skipped files:  ${result.skippedFiles.length}`);
-            console.log(`  Duration:       ${duration}s\n`);
-
-            if (result.warnings.length > 0) {
-                console.log(chalk.yellow(`⚠️  ${result.warnings.length} warnings:`));
-                result.warnings.slice(0, 5).forEach((w) => console.log(chalk.gray(`  - ${w}`)));
-                if (result.warnings.length > 5) {
-                    console.log(chalk.gray(`  ... and ${result.warnings.length - 5} more`));
-                }
-                console.log();
-            }
-
-            // Store in database if connected
-            if (dbClient.isConnected()) {
-                const projectName = targetPath.split(/[/\\]/).pop() || 'unknown';
-                let project = await dbOps.getProjectByPath(targetPath);
-
-                if (!project) {
-                    project = await dbOps.createProject(projectName, targetPath);
-                    logger.verbose('Created project record in database');
-                }
-
-                if (project) {
-                    const run = await dbOps.createRun(project.id, `scan ${path}`);
-                    if (run) {
-                        await dbOps.updateRunStatus(
-                            run.id,
-                            'completed',
-                            `Scanned ${result.files.length} files`
-                        );
-                    }
-                }
-            }
-
-            logger.success('Scan complete');
-
-            // Show next steps
-            console.log(chalk.cyan('Next step:'));
-            console.log(chalk.gray(`  ownkey suggest ${path}\n`));
-        } catch (error) {
-            logger.error('Scan failed', error as Error);
-            process.exit(1);
-        }
-    });
-
-function parseFileSize(sizeStr: string): number {
-    const match = sizeStr.match(/^(\d+(?:\.\d+)?)(kb|mb|gb)?$/i);
-    if (!match) {
-        throw new Error(`Invalid file size format: ${sizeStr}`);
-    }
-
-    const value = parseFloat(match[1]);
-    const unit = (match[2] || 'b').toLowerCase();
-
-    switch (unit) {
-        case 'b':
-            return value;
-        case 'kb':
-            return value * 1024;
-        case 'mb':
-            return value * 1024 * 1024;
-        case 'gb':
-            return value * 1024 * 1024 * 1024;
-        default:
-            return value;
-    }
-}
-
-function formatBytes(bytes: number): string {
-    if (bytes < 1024) return `${bytes} B`;
-    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}

package/src/commands/suggest.ts

@@ -1,37 +0,0 @@
-import { Command } from 'commander';
-import { resolve } from 'path';
-import { existsSync } from 'fs';
-import { logger } from '../utils/logger.js';
-import chalk from 'chalk';
-
-export const suggestCommand = new Command('suggest')
-    .description('Generate AI-powered suggestions for your code')
-    .argument('[path]', 'Path to analyze', '.')
-    .option('--type <type>', 'Filter by suggestion type (bug, security, performance, etc.)')
-    .option('--severity <severity>', 'Minimum severity (critical, high, medium, low, info)')
-    .action(async (path: string) => {
-        try {
-            const targetPath = resolve(path);
-
-            if (!existsSync(targetPath)) {
-                logger.error(`Path does not exist: ${targetPath}`);
-                process.exit(1);
-            }
-
-            logger.info(`Analyzing: ${chalk.cyan(targetPath)}`);
-
-            // TODO: Implement AI analysis
-            // For now, show a placeholder message
-            console.log(chalk.yellow('\n⚠️  AI provider integration coming in v0.5.0\n'));
-            console.log('This command will:');
-            console.log(chalk.gray('  1. Load project context'));
-            console.log(chalk.gray('  2. Send to AI provider for analysis'));
-            console.log(chalk.gray('  3. Display suggestions'));
-            console.log(chalk.gray('  4. Store in database\n'));
-
-            logger.info('Suggest command placeholder - full implementation coming soon');
-        } catch (error) {
-            logger.error('Suggest failed', error as Error);
-            process.exit(1);
-        }
-    });

package/src/config/defaults.ts

@@ -1,80 +0,0 @@
-import { Config, LogLevel } from '../types/index.js';
-
-export const DEFAULT_CONFIG: Config = {
-    providers: {
-        openai: {
-            model: 'gpt-4-turbo',
-        },
-        anthropic: {
-            model: 'claude-3-sonnet-20240229',
-        },
-        ollama: {
-            endpoint: 'http://localhost:11434',
-            model: 'codellama',
-        },
-    },
-    defaults: {
-        maxFileSize: '500kb',
-        logLevel: 'normal' as LogLevel,
-    },
-};
-
-export const CONFIG_DIR = '.ownkey';
-export const CONFIG_FILE = 'config.json';
-export const KEYS_FILE = 'keys.enc';
-export const LOGS_DIR = 'logs';
-
-export const DEFAULT_EXCLUDES = [
-    '.git',
-    'node_modules',
-    'dist',
-    'build',
-    'target',
-    'out',
-    'vendor',
-    '.cache',
-    '.next',
-    '.nuxt',
-    'coverage',
-    '.env',
-    '*.lock',
-    '*.min.js',
-    '*.min.css',
-];
-
-export const BINARY_EXTENSIONS = [
-    '.jpg',
-    '.jpeg',
-    '.png',
-    '.gif',
-    '.bmp',
-    '.ico',
-    '.svg',
-    '.webp',
-    '.mp4',
-    '.avi',
-    '.mov',
-    '.mp3',
-    '.wav',
-    '.zip',
-    '.tar',
-    '.gz',
-    '.rar',
-    '.7z',
-    '.exe',
-    '.dll',
-    '.so',
-    '.dylib',
-    '.pdf',
-    '.doc',
-    '.docx',
-    '.xls',
-    '.xlsx',
-    '.ppt',
-    '.pptx',
-];
-
-export const MAX_FILE_SIZE_BYTES = 500 * 1024; // 500KB
-
-export const BACKUP_EXTENSION = '.ownkey.bak';
-export const MAX_BACKUPS_PER_FILE = 3;

package/src/config/keychain.ts

@@ -1,125 +0,0 @@
-import { AIProvider } from '../types/index.js';
-import { readFile, writeFile, mkdir } from 'fs/promises';
-import { existsSync } from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
-import { logger } from '../utils/logger.js';
-import { Encryption } from '../utils/encryption.js';
-import { KEYS_FILE, CONFIG_DIR } from './defaults.js';
-
-// Try to use keytar, but fallback gracefully if not available
-let keytar: any = null;
-try {
-    keytar = await import('keytar');
-} catch (error) {
-    logger.verbose('Keytar not available, using encrypted file storage for API keys');
-}
-
-const SERVICE_NAME = 'ownkey-cli';
-const ENCRYPTION_PASSWORD = 'ownkey-local-encryption-key'; // In production, derive from machine ID
-
-export class KeychainManager {
-    private keysFilePath: string;
-    private useKeychain: boolean;
-
-    constructor() {
-        this.keysFilePath = join(homedir(), CONFIG_DIR, KEYS_FILE);
-        this.useKeychain = keytar !== null;
-    }
-
-    private async ensureKeysDir(): Promise<void> {
-        const dir = join(homedir(), CONFIG_DIR);
-        if (!existsSync(dir)) {
-            await mkdir(dir, { recursive: true });
-        }
-    }
-
-    async setApiKey(provider: AIProvider, apiKey: string): Promise<void> {
-        const accountName = `${provider}-api-key`;
-
-        if (this.useKeychain) {
-            try {
-                await keytar.setPassword(SERVICE_NAME, accountName, apiKey);
-                logger.verbose(`Stored ${provider} API key in system keychain`);
-                return;
-            } catch (error) {
-                logger.warn(`Failed to store in keychain, falling back to encrypted file`);
-                this.useKeychain = false;
-            }
-        }
-
-        // Fallback to encrypted file
-        await this.ensureKeysDir();
-        const keys = await this.loadKeysFromFile();
-        keys[provider] = apiKey;
-        await this.saveKeysToFile(keys);
-        logger.verbose(`Stored ${provider} API key in encrypted file`);
-    }
-
-    async getApiKey(provider: AIProvider): Promise<string | null> {
-        const accountName = `${provider}-api-key`;
-
-        if (this.useKeychain) {
-            try {
-                const key = await keytar.getPassword(SERVICE_NAME, accountName);
-                if (key) {
-                    logger.verbose(`Retrieved ${provider} API key from system keychain`);
-                    return key;
-                }
-            } catch (error) {
-                logger.warn(`Failed to retrieve from keychain, trying encrypted file`);
-                this.useKeychain = false;
-            }
-        }
-
-        // Fallback to encrypted file
-        const keys = await this.loadKeysFromFile();
-        const key = keys[provider] || null;
-        if (key) {
-            logger.verbose(`Retrieved ${provider} API key from encrypted file`);
-        }
-        return key;
-    }
-
-    async deleteApiKey(provider: AIProvider): Promise<void> {
-        const accountName = `${provider}-api-key`;
-
-        if (this.useKeychain) {
-            try {
-                await keytar.deletePassword(SERVICE_NAME, accountName);
-                logger.verbose(`Deleted ${provider} API key from system keychain`);
-            } catch (error) {
-                // Ignore errors
-            }
-        }
-
-        // Also delete from file
-        const keys = await this.loadKeysFromFile();
-        delete keys[provider];
-        await this.saveKeysToFile(keys);
-        logger.verbose(`Deleted ${provider} API key from encrypted file`);
-    }
-
-    private async loadKeysFromFile(): Promise<Record<string, string>> {
-        if (!existsSync(this.keysFilePath)) {
-            return {};
-        }
-
-        try {
-            const encryptedData = await readFile(this.keysFilePath, 'utf-8');
-            const decrypted = await Encryption.decrypt(encryptedData, ENCRYPTION_PASSWORD);
-            return JSON.parse(decrypted);
-        } catch (error) {
-            logger.warn('Failed to decrypt keys file, starting fresh');
-            return {};
-        }
-    }
-
-    private async saveKeysToFile(keys: Record<string, string>): Promise<void> {
-        const json = JSON.stringify(keys);
-        const encrypted = await Encryption.encrypt(json, ENCRYPTION_PASSWORD);
-        await writeFile(this.keysFilePath, encrypted, 'utf-8');
-    }
-}
-
-export const keychainManager = new KeychainManager();

package/src/config/manager.ts

@@ -1,166 +0,0 @@
-import { Config, ConfigError, AIProvider } from '../types/index.js';
-import { readFile, writeFile, mkdir } from 'fs/promises';
-import { existsSync } from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
-import { logger } from '../utils/logger.js';
-import { keychainManager } from './keychain.js';
-import { DEFAULT_CONFIG, CONFIG_DIR, CONFIG_FILE } from './defaults.js';
-
-export class ConfigManager {
-    private configPath: string;
-    private config: Config | null = null;
-
-    constructor() {
-        this.configPath = join(homedir(), CONFIG_DIR, CONFIG_FILE);
-    }
-
-    async ensureConfigDir(): Promise<void> {
-        const dir = join(homedir(), CONFIG_DIR);
-        if (!existsSync(dir)) {
-            await mkdir(dir, { recursive: true });
-            logger.verbose(`Created config directory: ${dir}`);
-        }
-    }
-
-    async exists(): Promise<boolean> {
-        return existsSync(this.configPath);
-    }
-
-    async load(): Promise<Config> {
-        if (this.config) {
-            return this.config;
-        }
-
-        if (!existsSync(this.configPath)) {
-            logger.verbose('No config file found, using defaults');
-            this.config = { ...DEFAULT_CONFIG };
-            return this.config;
-        }
-
-        try {
-            const content = await readFile(this.configPath, 'utf-8');
-            const loaded = JSON.parse(content);
-
-            // Merge with defaults to ensure all fields exist
-            this.config = {
-                ...DEFAULT_CONFIG,
-                ...loaded,
-                providers: {
-                    ...DEFAULT_CONFIG.providers,
-                    ...loaded.providers,
-                },
-                defaults: {
-                    ...DEFAULT_CONFIG.defaults,
-                    ...loaded.defaults,
-                },
-            };
-
-            logger.verbose('Loaded configuration from file');
-            return this.config!;
-        } catch (error) {
-            throw new ConfigError('Failed to load configuration file', error);
-        }
-    }
-
-    async save(config: Config): Promise<void> {
-        await this.ensureConfigDir();
-
-        try {
-            const content = JSON.stringify(config, null, 2);
-            await writeFile(this.configPath, content, 'utf-8');
-            this.config = config;
-            logger.verbose('Saved configuration to file');
-        } catch (error) {
-            throw new ConfigError('Failed to save configuration file', error);
-        }
-    }
-
-    async update(updates: Partial<Config>): Promise<void> {
-        const current = await this.load();
-        const updated = {
-            ...current,
-            ...updates,
-            providers: {
-                ...current.providers,
-                ...updates.providers,
-            },
-            defaults: {
-                ...current.defaults,
-                ...updates.defaults,
-            },
-        };
-        await this.save(updated);
-    }
-
-    async setSupabase(url: string, serviceRoleKey: string): Promise<void> {
-        const config = await this.load();
-        config.supabaseUrl = url;
-        config.supabaseServiceRoleKey = serviceRoleKey;
-        await this.save(config);
-        logger.success('Supabase configuration saved');
-    }
-
-    async setProvider(provider: AIProvider, apiKey: string, model?: string): Promise<void> {
-        const config = await this.load();
-        config.activeProvider = provider;
-
-        if (model) {
-            if (!config.providers[provider]) {
-                config.providers[provider] = {};
-            }
-            config.providers[provider]!.model = model;
-        }
-
-        await this.save(config);
-        await keychainManager.setApiKey(provider, apiKey);
-        logger.success(`${provider} provider configured`);
-    }
-
-    async getApiKey(provider?: AIProvider): Promise<string | null> {
-        const config = await this.load();
-        const targetProvider = provider || config.activeProvider;
-
-        if (!targetProvider) {
-            return null;
-        }
-
-        return await keychainManager.getApiKey(targetProvider);
-    }
-
-    async validate(): Promise<{ valid: boolean; errors: string[] }> {
-        const errors: string[] = [];
-
-        try {
-            const config = await this.load();
-
-            // Check if at least one provider is configured
-            if (!config.activeProvider) {
-                errors.push('No active AI provider configured. Run: ownkey config');
-            }
-
-            // Check if API key exists for active provider
-            if (config.activeProvider) {
-                const apiKey = await this.getApiKey(config.activeProvider);
-                if (!apiKey) {
-                    errors.push(`No API key found for ${config.activeProvider}`);
-                }
-            }
-
-            return { valid: errors.length === 0, errors };
-        } catch (error) {
-            errors.push('Failed to load configuration');
-            return { valid: false, errors };
-        }
-    }
-
-    async reset(): Promise<void> {
-        this.config = null;
-        if (existsSync(this.configPath)) {
-            await writeFile(this.configPath, JSON.stringify(DEFAULT_CONFIG, null, 2), 'utf-8');
-            logger.success('Configuration reset to defaults');
-        }
-    }
-}
-
-export const configManager = new ConfigManager();