ownkey 0.1.1 → 0.2.0

package/src/db/operations.ts

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

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

@@ -0,0 +1,74 @@
+#!/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();

package/src/types/index.ts

@@ -0,0 +1,198 @@
+// Core type definitions for OwnKey CLI
+
+export type LogLevel = 'quiet' | 'normal' | 'verbose' | 'debug';
+
+export type AIProvider = 'openai' | 'anthropic' | 'ollama';
+
+export type SuggestionType =
+    | 'bug'
+    | 'security'
+    | 'performance'
+    | 'refactor'
+    | 'style'
+    | 'architecture'
+    | 'test'
+    | 'documentation';
+
+export type Severity = 'critical' | 'high' | 'medium' | 'low' | 'info';
+
+export type RunStatus = 'running' | 'completed' | 'failed';
+
+export type SuggestionAction = 'applied' | 'rejected' | 'undone';
+
+// Configuration types
+export interface Config {
+    supabaseUrl?: string;
+    supabaseServiceRoleKey?: string;
+    providers: {
+        openai?: {
+            model?: string;
+        };
+        anthropic?: {
+            model?: string;
+        };
+        ollama?: {
+            endpoint?: string;
+            model?: string;
+        };
+    };
+    activeProvider?: AIProvider;
+    defaults: {
+        maxFileSize: string;
+        logLevel: LogLevel;
+    };
+}
+
+// File scanning types
+export interface FileMetadata {
+    path: string;
+    relativePath: string;
+    size: number;
+    lastModified: Date;
+    extension: string;
+}
+
+export interface FileContent extends FileMetadata {
+    content: string;
+}
+
+export interface ScanResult {
+    files: FileMetadata[];
+    totalSize: number;
+    skippedFiles: string[];
+    warnings: string[];
+}
+
+// Code context types
+export interface CodeContext {
+    files: FileContent[];
+    projectInfo: ProjectMetadata;
+    totalTokens?: number;
+}
+
+export interface ProjectMetadata {
+    name: string;
+    rootPath: string;
+    fileCount: number;
+    language?: string;
+    framework?: string;
+}
+
+// AI provider types
+export interface Suggestion {
+    type: SuggestionType;
+    severity: Severity;
+    content: string;
+    diff: string;
+    filePath: string;
+    rationale: string;
+    tags?: Record<string, any>;
+}
+
+export interface AnalyzeOptions {
+    streaming?: boolean;
+    maxTokens?: number;
+    temperature?: number;
+}
+
+export interface AIProviderInterface {
+    analyze(context: CodeContext, options?: AnalyzeOptions): AsyncGenerator<Suggestion>;
+    testConnection(): Promise<boolean>;
+}
+
+// Database types
+export interface Project {
+    id: string;
+    name: string;
+    rootPath: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+export interface Run {
+    id: string;
+    projectId: string;
+    command: string;
+    status: RunStatus;
+    summary?: string;
+    startedAt: Date;
+    finishedAt?: Date;
+}
+
+export interface SuggestionRecord extends Suggestion {
+    id: string;
+    projectId: string;
+    createdAt: Date;
+}
+
+export interface SuggestionHistory {
+    id: string;
+    suggestionId: string;
+    action: SuggestionAction;
+    details?: string;
+    actedAt: Date;
+}
+
+// Diff types
+export interface DiffResult {
+    filePath: string;
+    hunks: DiffHunk[];
+    additions: number;
+    deletions: number;
+}
+
+export interface DiffHunk {
+    oldStart: number;
+    oldLines: number;
+    newStart: number;
+    newLines: number;
+    lines: string[];
+}
+
+// Backup types
+export interface BackupInfo {
+    filePath: string;
+    backupPath: string;
+    timestamp: Date;
+    size: number;
+}
+
+// Error types
+export class OwnKeyError extends Error {
+    constructor(
+        message: string,
+        public code: string,
+        public details?: any
+    ) {
+        super(message);
+        this.name = 'OwnKeyError';
+    }
+}
+
+export class ConfigError extends OwnKeyError {
+    constructor(message: string, details?: any) {
+        super(message, 'CONFIG_ERROR', details);
+        this.name = 'ConfigError';
+    }
+}
+
+export class DatabaseError extends OwnKeyError {
+    constructor(message: string, details?: any) {
+        super(message, 'DATABASE_ERROR', details);
+        this.name = 'DatabaseError';
+    }
+}
+
+export class AIProviderError extends OwnKeyError {
+    constructor(message: string, details?: any) {
+        super(message, 'AI_PROVIDER_ERROR', details);
+        this.name = 'AIProviderError';
+    }
+}
+
+export class ScanError extends OwnKeyError {
+    constructor(message: string, details?: any) {
+        super(message, 'SCAN_ERROR', details);
+        this.name = 'ScanError';
+    }
+}

package/src/utils/encryption.ts

@@ -0,0 +1,54 @@
+import { createCipheriv, createDecipheriv, randomBytes, scrypt } from 'crypto';
+import { promisify } from 'util';
+
+const scryptAsync = promisify(scrypt);
+
+const ALGORITHM = 'aes-256-gcm';
+const KEY_LENGTH = 32;
+const IV_LENGTH = 16;
+const SALT_LENGTH = 32;
+const TAG_LENGTH = 16;
+
+export class Encryption {
+    private static async deriveKey(password: string, salt: Buffer): Promise<Buffer> {
+        return (await scryptAsync(password, salt, KEY_LENGTH)) as Buffer;
+    }
+
+    static async encrypt(text: string, password: string): Promise<string> {
+        const salt = randomBytes(SALT_LENGTH);
+        const iv = randomBytes(IV_LENGTH);
+        const key = await this.deriveKey(password, salt);
+
+        const cipher = createCipheriv(ALGORITHM, key, iv);
+        let encrypted = cipher.update(text, 'utf8', 'hex');
+        encrypted += cipher.final('hex');
+
+        const tag = cipher.getAuthTag();
+
+        // Combine salt + iv + tag + encrypted
+        const result = Buffer.concat([salt, iv, tag, Buffer.from(encrypted, 'hex')]);
+        return result.toString('base64');
+    }
+
+    static async decrypt(encryptedData: string, password: string): Promise<string> {
+        const buffer = Buffer.from(encryptedData, 'base64');
+
+        const salt = buffer.subarray(0, SALT_LENGTH);
+        const iv = buffer.subarray(SALT_LENGTH, SALT_LENGTH + IV_LENGTH);
+        const tag = buffer.subarray(
+            SALT_LENGTH + IV_LENGTH,
+            SALT_LENGTH + IV_LENGTH + TAG_LENGTH
+        );
+        const encrypted = buffer.subarray(SALT_LENGTH + IV_LENGTH + TAG_LENGTH);
+
+        const key = await this.deriveKey(password, salt);
+
+        const decipher = createDecipheriv(ALGORITHM, key, iv);
+        decipher.setAuthTag(tag);
+
+        let decrypted = decipher.update(encrypted.toString('hex'), 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
+
+        return decrypted;
+    }
+}