ownkey 0.2.0 → 0.5.0

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`;
-    }
-}

package/src/db/client.ts

@@ -1,151 +0,0 @@
-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/operations.ts

@@ -1,217 +0,0 @@
-import { eq, desc } from 'drizzle-orm';
-import { dbClient } from './client.js';
-import * as schema from './schema.js';
-import {
-    Project,
-    Run,
-    SuggestionRecord,
-    RunStatus,
-    SuggestionAction,
-} from '../types/index.js';
-import { logger } from '../utils/logger.js';
-
-export class DatabaseOperations {
-    // Projects
-    async createProject(name: string, rootPath: string): Promise<Project | null> {
-        if (dbClient.isLocalOnlyMode()) {
-            logger.verbose('Skipping project creation (local-only mode)');
-            return null;
-        }
-
-        const db = dbClient.getDb();
-        const [project] = await db
-            .insert(schema.projects)
-            .values({ name, rootPath })
-            .returning();
-
-        return {
-            id: project.id,
-            name: project.name,
-            rootPath: project.rootPath,
-            createdAt: project.createdAt,
-            updatedAt: project.updatedAt,
-        };
-    }
-
-    async getProjectByPath(rootPath: string): Promise<Project | null> {
-        if (dbClient.isLocalOnlyMode()) {
-            return null;
-        }
-
-        const db = dbClient.getDb();
-        const [project] = await db
-            .select()
-            .from(schema.projects)
-            .where(eq(schema.projects.rootPath, rootPath))
-            .limit(1);
-
-        if (!project) return null;
-
-        return {
-            id: project.id,
-            name: project.name,
-            rootPath: project.rootPath,
-            createdAt: project.createdAt,
-            updatedAt: project.updatedAt,
-        };
-    }
-
-    // Runs
-    async createRun(projectId: string, command: string): Promise<Run | null> {
-        if (dbClient.isLocalOnlyMode()) {
-            logger.verbose('Skipping run creation (local-only mode)');
-            return null;
-        }
-
-        const db = dbClient.getDb();
-        const [run] = await db
-            .insert(schema.runs)
-            .values({ projectId, command, status: 'running' })
-            .returning();
-
-        return {
-            id: run.id,
-            projectId: run.projectId,
-            command: run.command,
-            status: run.status as RunStatus,
-            summary: run.summary || undefined,
-            startedAt: run.startedAt,
-            finishedAt: run.finishedAt || undefined,
-        };
-    }
-
-    async updateRunStatus(
-        runId: string,
-        status: RunStatus,
-        summary?: string
-    ): Promise<void> {
-        if (dbClient.isLocalOnlyMode()) {
-            return;
-        }
-
-        const db = dbClient.getDb();
-        await db
-            .update(schema.runs)
-            .set({ status, summary, finishedAt: new Date() })
-            .where(eq(schema.runs.id, runId));
-    }
-
-    async getRecentRuns(limit: number = 10): Promise<Run[]> {
-        if (dbClient.isLocalOnlyMode()) {
-            return [];
-        }
-
-        const db = dbClient.getDb();
-        const runs = await db
-            .select()
-            .from(schema.runs)
-            .orderBy(desc(schema.runs.startedAt))
-            .limit(limit);
-
-        return runs.map((run) => ({
-            id: run.id,
-            projectId: run.projectId,
-            command: run.command,
-            status: run.status as RunStatus,
-            summary: run.summary || undefined,
-            startedAt: run.startedAt,
-            finishedAt: run.finishedAt || undefined,
-        }));
-    }
-
-    // Suggestions
-    async createSuggestion(
-        projectId: string,
-        suggestion: Omit<SuggestionRecord, 'id' | 'projectId' | 'createdAt'>
-    ): Promise<SuggestionRecord | null> {
-        if (dbClient.isLocalOnlyMode()) {
-            logger.verbose('Skipping suggestion storage (local-only mode)');
-            return null;
-        }
-
-        const db = dbClient.getDb();
-        const [created] = await db
-            .insert(schema.suggestions)
-            .values({
-                projectId,
-                type: suggestion.type,
-                severity: suggestion.severity,
-                content: suggestion.content,
-                diff: suggestion.diff,
-                filePath: suggestion.filePath,
-                rationale: suggestion.rationale,
-                tags: suggestion.tags,
-            })
-            .returning();
-
-        return {
-            id: created.id,
-            projectId: created.projectId,
-            type: created.type as any,
-            severity: created.severity as any,
-            content: created.content,
-            diff: created.diff,
-            filePath: created.filePath,
-            rationale: created.rationale,
-            tags: created.tags as any,
-            createdAt: created.createdAt,
-        };
-    }
-
-    async getSuggestionById(id: string): Promise<SuggestionRecord | null> {
-        if (dbClient.isLocalOnlyMode()) {
-            return null;
-        }
-
-        const db = dbClient.getDb();
-        const [suggestion] = await db
-            .select()
-            .from(schema.suggestions)
-            .where(eq(schema.suggestions.id, id))
-            .limit(1);
-
-        if (!suggestion) return null;
-
-        return {
-            id: suggestion.id,
-            projectId: suggestion.projectId,
-            type: suggestion.type as any,
-            severity: suggestion.severity as any,
-            content: suggestion.content,
-            diff: suggestion.diff,
-            filePath: suggestion.filePath,
-            rationale: suggestion.rationale,
-            tags: suggestion.tags as any,
-            createdAt: suggestion.createdAt,
-        };
-    }
-
-    async linkRunSuggestion(runId: string, suggestionId: string): Promise<void> {
-        if (dbClient.isLocalOnlyMode()) {
-            return;
-        }
-
-        const db = dbClient.getDb();
-        await db.insert(schema.runSuggestions).values({ runId, suggestionId });
-    }
-
-    // Suggestion History
-    async recordSuggestionAction(
-        suggestionId: string,
-        action: SuggestionAction,
-        details?: string
-    ): Promise<void> {
-        if (dbClient.isLocalOnlyMode()) {
-            return;
-        }
-
-        const db = dbClient.getDb();
-        await db.insert(schema.suggestionHistory).values({
-            suggestionId,
-            action,
-            details,
-        });
-    }
-}
-
-export const dbOps = new DatabaseOperations();

package/src/db/schema.ts

@@ -1,118 +0,0 @@
-import { pgTable, uuid, text, timestamp, jsonb, integer } from 'drizzle-orm/pg-core';
-import { relations } from 'drizzle-orm';
-
-// Projects table
-export const projects = pgTable('projects', {
-    id: uuid('id').primaryKey().defaultRandom(),
-    name: text('name').notNull(),
-    rootPath: text('root_path').notNull(),
-    createdAt: timestamp('created_at').defaultNow().notNull(),
-    updatedAt: timestamp('updated_at').defaultNow().notNull(),
-});
-
-// Runs table
-export const runs = pgTable('runs', {
-    id: uuid('id').primaryKey().defaultRandom(),
-    projectId: uuid('project_id')
-        .references(() => projects.id)
-        .notNull(),
-    command: text('command').notNull(),
-    status: text('status').notNull(), // 'running' | 'completed' | 'failed'
-    summary: text('summary'),
-    startedAt: timestamp('started_at').defaultNow().notNull(),
-    finishedAt: timestamp('finished_at'),
-});
-
-// Suggestions table
-export const suggestions = pgTable('suggestions', {
-    id: uuid('id').primaryKey().defaultRandom(),
-    projectId: uuid('project_id')
-        .references(() => projects.id)
-        .notNull(),
-    type: text('type').notNull(), // 'bug' | 'security' | 'performance' | etc.
-    severity: text('severity').notNull(), // 'critical' | 'high' | 'medium' | 'low' | 'info'
-    content: text('content').notNull(),
-    diff: text('diff').notNull(),
-    filePath: text('file_path').notNull(),
-    rationale: text('rationale').notNull(),
-    tags: jsonb('tags'),
-    createdAt: timestamp('created_at').defaultNow().notNull(),
-});
-
-// Suggestion history table
-export const suggestionHistory = pgTable('suggestion_history', {
-    id: uuid('id').primaryKey().defaultRandom(),
-    suggestionId: uuid('suggestion_id')
-        .references(() => suggestions.id)
-        .notNull(),
-    action: text('action').notNull(), // 'applied' | 'rejected' | 'undone'
-    details: text('details'),
-    actedAt: timestamp('acted_at').defaultNow().notNull(),
-});
-
-// Run suggestions junction table
-export const runSuggestions = pgTable('run_suggestions', {
-    runId: uuid('run_id')
-        .references(() => runs.id)
-        .notNull(),
-    suggestionId: uuid('suggestion_id')
-        .references(() => suggestions.id)
-        .notNull(),
-});
-
-// User API keys table (for fingerprints only)
-export const userApiKeys = pgTable('user_api_keys', {
-    id: uuid('id').primaryKey().defaultRandom(),
-    projectId: uuid('project_id').references(() => projects.id),
-    provider: text('provider').notNull(),
-    keyFingerprint: text('key_fingerprint').notNull(),
-    addedAt: timestamp('added_at').defaultNow().notNull(),
-});
-
-// Schema migrations table
-export const schemaMigrations = pgTable('schema_migrations', {
-    version: integer('version').primaryKey(),
-    appliedAt: timestamp('applied_at').defaultNow().notNull(),
-});
-
-// Relations
-export const projectsRelations = relations(projects, ({ many }) => ({
-    runs: many(runs),
-    suggestions: many(suggestions),
-    apiKeys: many(userApiKeys),
-}));
-
-export const runsRelations = relations(runs, ({ one, many }) => ({
-    project: one(projects, {
-        fields: [runs.projectId],
-        references: [projects.id],
-    }),
-    runSuggestions: many(runSuggestions),
-}));
-
-export const suggestionsRelations = relations(suggestions, ({ one, many }) => ({
-    project: one(projects, {
-        fields: [suggestions.projectId],
-        references: [projects.id],
-    }),
-    history: many(suggestionHistory),
-    runSuggestions: many(runSuggestions),
-}));
-
-export const suggestionHistoryRelations = relations(suggestionHistory, ({ one }) => ({
-    suggestion: one(suggestions, {
-        fields: [suggestionHistory.suggestionId],
-        references: [suggestions.id],
-    }),
-}));
-
-export const runSuggestionsRelations = relations(runSuggestions, ({ one }) => ({
-    run: one(runs, {
-        fields: [runSuggestions.runId],
-        references: [runs.id],
-    }),
-    suggestion: one(suggestions, {
-        fields: [runSuggestions.suggestionId],
-        references: [suggestions.id],
-    }),
-}));