ownkey 0.2.0 → 0.5.0

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

package/src/types/index.ts

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

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

package/src/utils/logger.ts

@@ -1,111 +0,0 @@
-import chalk from 'chalk';
-import { LogLevel } from '../types/index.js';
-import { mkdir, appendFile } from 'fs/promises';
-import { join } from 'path';
-import { homedir } from 'os';
-import { existsSync } from 'fs';
-
-class Logger {
-    private level: LogLevel = 'normal';
-    private logDir: string;
-    private logFile: string;
-
-    constructor() {
-        this.logDir = join(homedir(), '.ownkey', 'logs');
-        const date = new Date().toISOString().split('T')[0];
-        this.logFile = join(this.logDir, `ownkey-${date}.log`);
-    }
-
-    async init(): Promise<void> {
-        if (!existsSync(this.logDir)) {
-            await mkdir(this.logDir, { recursive: true });
-        }
-    }
-
-    setLevel(level: LogLevel): void {
-        this.level = level;
-    }
-
-    getLevel(): LogLevel {
-        return this.level;
-    }
-
-    private shouldLog(messageLevel: LogLevel): boolean {
-        const levels: LogLevel[] = ['quiet', 'normal', 'verbose', 'debug'];
-        const currentIndex = levels.indexOf(this.level);
-        const messageIndex = levels.indexOf(messageLevel);
-        return messageIndex <= currentIndex;
-    }
-
-    private async writeToFile(message: string, level: string): Promise<void> {
-        try {
-            const timestamp = new Date().toISOString();
-            const logEntry = JSON.stringify({ timestamp, level, message }) + '\n';
-            await appendFile(this.logFile, logEntry);
-        } catch (error) {
-            // Silently fail if we can't write to log file
-        }
-    }
-
-    info(message: string): void {
-        if (this.shouldLog('normal')) {
-            console.log(chalk.blue('ℹ'), message);
-        }
-        this.writeToFile(message, 'info');
-    }
-
-    success(message: string): void {
-        if (this.shouldLog('normal')) {
-            console.log(chalk.green('✓'), message);
-        }
-        this.writeToFile(message, 'success');
-    }
-
-    warn(message: string): void {
-        if (this.shouldLog('normal')) {
-            console.log(chalk.yellow('⚠'), message);
-        }
-        this.writeToFile(message, 'warn');
-    }
-
-    error(message: string, error?: Error): void {
-        if (this.shouldLog('quiet')) {
-            console.error(chalk.red('✗'), message);
-            if (error && this.level === 'debug') {
-                console.error(chalk.gray(error.stack || error.message));
-            }
-        }
-        this.writeToFile(`${message} ${error?.message || ''}`, 'error');
-    }
-
-    verbose(message: string): void {
-        if (this.shouldLog('verbose')) {
-            console.log(chalk.gray('→'), message);
-        }
-        this.writeToFile(message, 'verbose');
-    }
-
-    debug(message: string, data?: any): void {
-        if (this.shouldLog('debug')) {
-            console.log(chalk.magenta('🐛'), message);
-            if (data) {
-                console.log(chalk.gray(JSON.stringify(data, null, 2)));
-            }
-        }
-        this.writeToFile(`${message} ${data ? JSON.stringify(data) : ''}`, 'debug');
-    }
-
-    spinner(message: string): { succeed: (msg: string) => void; fail: (msg: string) => void } {
-        // Simple spinner replacement for ora
-        if (this.shouldLog('normal')) {
-            console.log(chalk.cyan('⏳'), message);
-        }
-        return {
-            succeed: (msg: string) => this.success(msg),
-            fail: (msg: string) => this.error(msg),
-        };
-    }
-}
-
-// Singleton instance
-export const logger = new Logger();

package/tsconfig.json

@@ -1,33 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "ES2022",
-        "module": "ESNext",
-        "lib": [
-            "ES2022"
-        ],
-        "moduleResolution": "bundler",
-        "rootDir": "./src",
-        "outDir": "./dist",
-        "declaration": true,
-        "declarationMap": true,
-        "sourceMap": true,
-        "strict": true,
-        "esModuleInterop": true,
-        "skipLibCheck": true,
-        "forceConsistentCasingInFileNames": true,
-        "resolveJsonModule": true,
-        "allowSyntheticDefaultImports": true,
-        "noUnusedLocals": true,
-        "noUnusedParameters": true,
-        "noImplicitReturns": true,
-        "noFallthroughCasesInSwitch": true
-    },
-    "include": [
-        "src/**/*"
-    ],
-    "exclude": [
-        "node_modules",
-        "dist",
-        "tests"
-    ]
-}