ownkey 0.2.1 → 0.5.0

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();

package/src/core/scanner.ts

@@ -1,174 +0,0 @@
-import ignore, { Ignore } from 'ignore';
-import { readFile, stat, readdir } from 'fs/promises';
-import { join, relative, extname } from 'path';
-import { existsSync } from 'fs';
-import { FileMetadata, FileContent, ScanResult } from '../types/index.js';
-import { logger } from '../utils/logger.js';
-import { DEFAULT_EXCLUDES, BINARY_EXTENSIONS, MAX_FILE_SIZE_BYTES } from '../config/defaults.js';
-
-export class FileScanner {
-    private ig: Ignore;
-    private maxFileSize: number;
-    private rootPath: string;
-    private skippedFiles: string[] = [];
-    private warnings: string[] = [];
-
-    constructor(rootPath: string, maxFileSize: number = MAX_FILE_SIZE_BYTES) {
-        this.rootPath = rootPath;
-        this.maxFileSize = maxFileSize;
-        this.ig = ignore();
-        this.ig.add(DEFAULT_EXCLUDES);
-    }
-
-    async initialize(): Promise<void> {
-        // Load .gitignore
-        const gitignorePath = join(this.rootPath, '.gitignore');
-        if (existsSync(gitignorePath)) {
-            const content = await readFile(gitignorePath, 'utf-8');
-            this.ig.add(content);
-            logger.verbose('Loaded .gitignore patterns');
-        }
-
-        // Load .ownkeyignore
-        const ownkeyignorePath = join(this.rootPath, '.ownkeyignore');
-        if (existsSync(ownkeyignorePath)) {
-            const content = await readFile(ownkeyignorePath, 'utf-8');
-            this.ig.add(content);
-            logger.verbose('Loaded .ownkeyignore patterns');
-        }
-    }
-
-    async scan(): Promise<ScanResult> {
-        await this.initialize();
-
-        const files: FileMetadata[] = [];
-        let totalSize = 0;
-
-        await this.scanDirectory(this.rootPath, files);
-
-        for (const file of files) {
-            totalSize += file.size;
-        }
-
-        logger.verbose(`Scanned ${files.length} files (${this.formatBytes(totalSize)})`);
-
-        if (this.skippedFiles.length > 0) {
-            logger.verbose(`Skipped ${this.skippedFiles.length} files`);
-        }
-
-        return {
-            files,
-            totalSize,
-            skippedFiles: this.skippedFiles,
-            warnings: this.warnings,
-        };
-    }
-
-    private async scanDirectory(dirPath: string, files: FileMetadata[]): Promise<void> {
-        let entries;
-        try {
-            entries = await readdir(dirPath, { withFileTypes: true });
-        } catch (error) {
-            this.warnings.push(`Cannot read directory: ${dirPath}`);
-            return;
-        }
-
-        for (const entry of entries) {
-            const fullPath = join(dirPath, entry.name);
-            const relativePath = relative(this.rootPath, fullPath);
-
-            // Check if ignored
-            if (this.ig.ignores(relativePath)) {
-                logger.debug(`Ignored: ${relativePath}`);
-                continue;
-            }
-
-            if (entry.isDirectory()) {
-                await this.scanDirectory(fullPath, files);
-            } else if (entry.isFile()) {
-                await this.processFile(fullPath, relativePath, files);
-            }
-        }
-    }
-
-    private async processFile(
-        fullPath: string,
-        relativePath: string,
-        files: FileMetadata[]
-    ): Promise<void> {
-        try {
-            const stats = await stat(fullPath);
-
-            // Check file size
-            if (stats.size > this.maxFileSize) {
-                this.skippedFiles.push(`${relativePath} (too large: ${this.formatBytes(stats.size)})`);
-                return;
-            }
-
-            // Check if binary
-            const ext = extname(fullPath).toLowerCase();
-            if (BINARY_EXTENSIONS.includes(ext)) {
-                this.skippedFiles.push(`${relativePath} (binary file)`);
-                return;
-            }
-
-            // Check if file is actually text (simple heuristic)
-            if (!(await this.isTextFile(fullPath))) {
-                this.skippedFiles.push(`${relativePath} (binary content)`);
-                return;
-            }
-
-            files.push({
-                path: fullPath,
-                relativePath,
-                size: stats.size,
-                lastModified: stats.mtime,
-                extension: ext,
-            });
-        } catch (error) {
-            this.warnings.push(`Cannot process file: ${relativePath}`);
-        }
-    }
-
-    private async isTextFile(filePath: string): Promise<boolean> {
-        try {
-            const buffer = await readFile(filePath);
-            const sample = buffer.subarray(0, Math.min(8000, buffer.length));
-
-            // Check for null bytes (common in binary files)
-            for (let i = 0; i < sample.length; i++) {
-                if (sample[i] === 0) {
-                    return false;
-                }
-            }
-
-            return true;
-        } catch {
-            return false;
-        }
-    }
-
-    async loadFileContents(files: FileMetadata[]): Promise<FileContent[]> {
-        const contents: FileContent[] = [];
-
-        for (const file of files) {
-            try {
-                const content = await readFile(file.path, 'utf-8');
-                contents.push({
-                    ...file,
-                    content,
-                });
-            } catch (error) {
-                logger.warn(`Failed to read file: ${file.relativePath}`);
-            }
-        }
-
-        return contents;
-    }
-
-    private 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`;
-    }
-}