ownkey 0.1.1 → 0.2.0

package/src/config/manager.ts

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

@@ -0,0 +1,174 @@
+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`;
+    }
+}

package/src/db/client.ts

@@ -0,0 +1,151 @@
+import postgres from 'postgres';
+import { drizzle } from 'drizzle-orm/postgres-js';
+import { readFile } from 'fs/promises';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { DatabaseError } from '../types/index.js';
+import { logger } from '../utils/logger.js';
+import { configManager } from '../config/manager.js';
+import * as schema from './schema.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export class DatabaseClient {
+    private sql: postgres.Sql | null = null;
+    private db: ReturnType<typeof drizzle> | null = null;
+    private isLocalOnly: boolean = false;
+
+    async connect(localOnly: boolean = false): Promise<void> {
+        if (localOnly) {
+            this.isLocalOnly = true;
+            logger.info('Running in local-only mode (no database persistence)');
+            return;
+        }
+
+        try {
+            const config = await configManager.load();
+
+            if (!config.supabaseUrl || !config.supabaseServiceRoleKey) {
+                logger.warn('Supabase not configured. Running in local-only mode.');
+                logger.info('Run "ownkey config" to set up database persistence.');
+                this.isLocalOnly = true;
+                return;
+            }
+
+            // Create connection string
+            const connectionString = `${config.supabaseUrl}?sslmode=require`;
+
+            this.sql = postgres(connectionString, {
+                password: config.supabaseServiceRoleKey,
+                max: 10,
+                idle_timeout: 20,
+                connect_timeout: 10,
+            });
+
+            this.db = drizzle(this.sql, { schema });
+
+            // Test connection
+            await this.sql`SELECT 1`;
+            logger.verbose('Database connection established');
+
+            // Run migrations
+            await this.runMigrations();
+        } catch (error) {
+            logger.warn('Failed to connect to database. Running in local-only mode.');
+            logger.debug('Database error:', error);
+            this.isLocalOnly = true;
+            this.sql = null;
+            this.db = null;
+        }
+    }
+
+    async disconnect(): Promise<void> {
+        if (this.sql) {
+            await this.sql.end();
+            this.sql = null;
+            this.db = null;
+            logger.verbose('Database connection closed');
+        }
+    }
+
+    getDb(): ReturnType<typeof drizzle> {
+        if (this.isLocalOnly) {
+            throw new DatabaseError('Database not available in local-only mode');
+        }
+        if (!this.db) {
+            throw new DatabaseError('Database not connected');
+        }
+        return this.db;
+    }
+
+    isConnected(): boolean {
+        return this.db !== null && !this.isLocalOnly;
+    }
+
+    isLocalOnlyMode(): boolean {
+        return this.isLocalOnly;
+    }
+
+    private async runMigrations(): Promise<void> {
+        if (!this.sql) {
+            return;
+        }
+
+        try {
+            logger.verbose('Checking database migrations...');
+
+            // Check if migrations table exists
+            const tableExists = await this.sql`
+        SELECT EXISTS (
+          SELECT FROM information_schema.tables 
+          WHERE table_name = 'schema_migrations'
+        );
+      `;
+
+            if (!tableExists[0]?.exists) {
+                logger.info('Initializing database schema...');
+                await this.runMigration(1);
+                logger.success('Database schema initialized');
+                return;
+            }
+
+            // Check current version
+            const currentVersion = await this.sql`
+        SELECT MAX(version) as version FROM schema_migrations;
+      `;
+
+            const version = currentVersion[0]?.version || 0;
+            logger.verbose(`Current schema version: ${version}`);
+
+            // Run pending migrations
+            const latestVersion = 1; // Update this as we add more migrations
+            if (version < latestVersion) {
+                for (let v = version + 1; v <= latestVersion; v++) {
+                    await this.runMigration(v);
+                    logger.success(`Applied migration ${v}`);
+                }
+            }
+        } catch (error) {
+            throw new DatabaseError('Failed to run migrations', error);
+        }
+    }
+
+    private async runMigration(version: number): Promise<void> {
+        if (!this.sql) {
+            return;
+        }
+
+        const migrationFile = join(__dirname, 'migrations', `${String(version).padStart(3, '0')}_init.sql`);
+
+        try {
+            const migrationSql = await readFile(migrationFile, 'utf-8');
+            await this.sql.unsafe(migrationSql);
+            logger.verbose(`Migration ${version} applied successfully`);
+        } catch (error) {
+            throw new DatabaseError(`Failed to apply migration ${version}`, error);
+        }
+    }
+}
+
+export const dbClient = new DatabaseClient();

package/src/db/migrations/001_init.sql

@@ -0,0 +1,80 @@
+-- OwnKey CLI Initial Schema Migration
+-- Version: 001
+-- Description: Create all initial tables for OwnKey CLI
+
+-- Projects table
+CREATE TABLE IF NOT EXISTS projects (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  name TEXT NOT NULL,
+  root_path TEXT NOT NULL,
+  created_at TIMESTAMP DEFAULT NOW() NOT NULL,
+  updated_at TIMESTAMP DEFAULT NOW() NOT NULL
+);
+
+-- Runs table
+CREATE TABLE IF NOT EXISTS runs (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  project_id UUID NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  command TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('running', 'completed', 'failed')),
+  summary TEXT,
+  started_at TIMESTAMP DEFAULT NOW() NOT NULL,
+  finished_at TIMESTAMP
+);
+
+-- Suggestions table
+CREATE TABLE IF NOT EXISTS suggestions (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  project_id UUID NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  type TEXT NOT NULL CHECK (type IN ('bug', 'security', 'performance', 'refactor', 'style', 'architecture', 'test', 'documentation')),
+  severity TEXT NOT NULL CHECK (severity IN ('critical', 'high', 'medium', 'low', 'info')),
+  content TEXT NOT NULL,
+  diff TEXT NOT NULL,
+  file_path TEXT NOT NULL,
+  rationale TEXT NOT NULL,
+  tags JSONB,
+  created_at TIMESTAMP DEFAULT NOW() NOT NULL
+);
+
+-- Suggestion history table
+CREATE TABLE IF NOT EXISTS suggestion_history (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  suggestion_id UUID NOT NULL REFERENCES suggestions(id) ON DELETE CASCADE,
+  action TEXT NOT NULL CHECK (action IN ('applied', 'rejected', 'undone')),
+  details TEXT,
+  acted_at TIMESTAMP DEFAULT NOW() NOT NULL
+);
+
+-- Run suggestions junction table
+CREATE TABLE IF NOT EXISTS run_suggestions (
+  run_id UUID NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+  suggestion_id UUID NOT NULL REFERENCES suggestions(id) ON DELETE CASCADE,
+  PRIMARY KEY (run_id, suggestion_id)
+);
+
+-- User API keys table (fingerprints only)
+CREATE TABLE IF NOT EXISTS user_api_keys (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  project_id UUID REFERENCES projects(id) ON DELETE CASCADE,
+  provider TEXT NOT NULL,
+  key_fingerprint TEXT NOT NULL,
+  added_at TIMESTAMP DEFAULT NOW() NOT NULL
+);
+
+-- Schema migrations table
+CREATE TABLE IF NOT EXISTS schema_migrations (
+  version INTEGER PRIMARY KEY,
+  applied_at TIMESTAMP DEFAULT NOW() NOT NULL
+);
+
+-- Create indexes for better query performance
+CREATE INDEX IF NOT EXISTS idx_runs_project_id ON runs(project_id);
+CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status);
+CREATE INDEX IF NOT EXISTS idx_suggestions_project_id ON suggestions(project_id);
+CREATE INDEX IF NOT EXISTS idx_suggestions_type ON suggestions(type);
+CREATE INDEX IF NOT EXISTS idx_suggestions_severity ON suggestions(severity);
+CREATE INDEX IF NOT EXISTS idx_suggestion_history_suggestion_id ON suggestion_history(suggestion_id);
+CREATE INDEX IF NOT EXISTS idx_user_api_keys_project_id ON user_api_keys(project_id);
+
+-- Insert migration record
+INSERT INTO schema_migrations (version) VALUES (1) ON CONFLICT (version) DO NOTHING;