ownkey 0.2.1 → 0.5.0

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],
-    }),
-}));

package/src/index.ts

@@ -1,74 +0,0 @@
-#!/usr/bin/env node
-
-import { Command } from 'commander';
-import { logger } from './utils/logger.js';
-import { configManager } from './config/manager.js';
-import { dbClient } from './db/client.js';
-import chalk from 'chalk';
-
-// Import commands
-import { configCommand } from './commands/config.js';
-import { scanCommand } from './commands/scan.js';
-import { suggestCommand } from './commands/suggest.js';
-import { applyCommand } from './commands/apply.js';
-
-const program = new Command();
-
-program
-    .name('ownkey')
-    .description('Local-first AI coding agent for intelligent codebase analysis')
-    .version('0.2.0');
-
-// Global options
-program.option('--local-only', 'Run without database persistence');
-program.option('--verbose', 'Enable verbose logging');
-program.option('--debug', 'Enable debug logging');
-program.option('--quiet', 'Suppress non-essential output');
-
-// Commands
-program.addCommand(configCommand);
-program.addCommand(scanCommand);
-program.addCommand(suggestCommand);
-program.addCommand(applyCommand);
-
-// Pre-parse hook to set up logging and check config
-program.hook('preAction', async (thisCommand) => {
-    await logger.init();
-
-    const opts = thisCommand.opts();
-
-    // Set log level
-    if (opts.debug) {
-        logger.setLevel('debug');
-    } else if (opts.verbose) {
-        logger.setLevel('verbose');
-    } else if (opts.quiet) {
-        logger.setLevel('quiet');
-    }
-
-    // Check if this is the config command
-    const isConfigCommand = thisCommand.name() === 'config';
-
-    // For non-config commands, check if config exists
-    if (!isConfigCommand) {
-        const configExists = await configManager.exists();
-
-        if (!configExists) {
-            console.log(chalk.yellow('\n⚠️  No configuration found.\n'));
-            console.log('OwnKey needs to be configured before use.');
-            console.log(chalk.cyan('\nRun: ownkey config\n'));
-            process.exit(1);
-        }
-
-        // Connect to database (or enter local-only mode)
-        await dbClient.connect(opts.localOnly);
-    }
-});
-
-// Post-action hook to clean up
-program.hook('postAction', async () => {
-    await dbClient.disconnect();
-});
-
-// Parse arguments
-program.parse();