archicore 0.2.0 → 0.2.1

package/dist/server/services/cache.js

@@ -0,0 +1,245 @@
+/**
+ * ArchiCore Redis Cache Service
+ *
+ * Provides caching for API responses to improve performance
+ */
+import Redis from 'ioredis';
+import { Logger } from '../../utils/logger.js';
+const DEFAULT_TTL = 300; // 5 minutes
+const CACHE_PREFIX = 'archicore:';
+class CacheService {
+    client = null;
+    enabled = false;
+    memoryCache = new Map();
+    async connect() {
+        const redisUrl = process.env.REDIS_URL || 'redis://localhost:6379';
+        try {
+            this.client = new Redis(redisUrl, {
+                maxRetriesPerRequest: 3,
+                retryStrategy: (times) => {
+                    if (times > 3) {
+                        Logger.warn('Redis connection failed, using memory cache fallback');
+                        return null;
+                    }
+                    return Math.min(times * 100, 3000);
+                },
+                lazyConnect: true,
+            });
+            await this.client.connect();
+            this.client.on('error', (err) => {
+                Logger.error('Redis error:', err.message);
+                this.enabled = false;
+            });
+            this.client.on('connect', () => {
+                Logger.info('Redis connected');
+                this.enabled = true;
+            });
+            this.client.on('close', () => {
+                Logger.warn('Redis connection closed');
+                this.enabled = false;
+            });
+            // Test connection
+            await this.client.ping();
+            this.enabled = true;
+            Logger.success('Redis cache enabled');
+        }
+        catch (error) {
+            Logger.warn('Redis not available, using memory cache');
+            this.enabled = false;
+            this.client = null;
+        }
+    }
+    getKey(key, prefix) {
+        return `${CACHE_PREFIX}${prefix || ''}${key}`;
+    }
+    /**
+     * Get value from cache
+     */
+    async get(key, prefix) {
+        const fullKey = this.getKey(key, prefix);
+        // Try Redis first
+        if (this.enabled && this.client) {
+            try {
+                const data = await this.client.get(fullKey);
+                if (data) {
+                    return JSON.parse(data);
+                }
+            }
+            catch (error) {
+                Logger.error('Cache get error:', error);
+            }
+        }
+        // Fallback to memory cache
+        const cached = this.memoryCache.get(fullKey);
+        if (cached && cached.expires > Date.now()) {
+            return cached.data;
+        }
+        // Clean up expired entry
+        if (cached) {
+            this.memoryCache.delete(fullKey);
+        }
+        return null;
+    }
+    /**
+     * Set value in cache
+     */
+    async set(key, value, options = {}) {
+        const fullKey = this.getKey(key, options.prefix);
+        const ttl = options.ttl || DEFAULT_TTL;
+        const serialized = JSON.stringify(value);
+        // Try Redis first
+        if (this.enabled && this.client) {
+            try {
+                await this.client.setex(fullKey, ttl, serialized);
+                return;
+            }
+            catch (error) {
+                Logger.error('Cache set error:', error);
+            }
+        }
+        // Fallback to memory cache
+        this.memoryCache.set(fullKey, {
+            data: value,
+            expires: Date.now() + (ttl * 1000),
+        });
+        // Clean up old memory cache entries periodically
+        if (this.memoryCache.size > 1000) {
+            this.cleanupMemoryCache();
+        }
+    }
+    /**
+     * Delete value from cache
+     */
+    async del(key, prefix) {
+        const fullKey = this.getKey(key, prefix);
+        if (this.enabled && this.client) {
+            try {
+                await this.client.del(fullKey);
+            }
+            catch (error) {
+                Logger.error('Cache del error:', error);
+            }
+        }
+        this.memoryCache.delete(fullKey);
+    }
+    /**
+     * Delete all keys matching pattern
+     */
+    async delPattern(pattern) {
+        const fullPattern = this.getKey(pattern);
+        if (this.enabled && this.client) {
+            try {
+                const keys = await this.client.keys(fullPattern);
+                if (keys.length > 0) {
+                    await this.client.del(...keys);
+                }
+            }
+            catch (error) {
+                Logger.error('Cache delPattern error:', error);
+            }
+        }
+        // Clean memory cache matching pattern
+        const regex = new RegExp(fullPattern.replace(/\*/g, '.*'));
+        for (const key of this.memoryCache.keys()) {
+            if (regex.test(key)) {
+                this.memoryCache.delete(key);
+            }
+        }
+    }
+    /**
+     * Clear all cache
+     */
+    async flush() {
+        if (this.enabled && this.client) {
+            try {
+                const keys = await this.client.keys(`${CACHE_PREFIX}*`);
+                if (keys.length > 0) {
+                    await this.client.del(...keys);
+                }
+            }
+            catch (error) {
+                Logger.error('Cache flush error:', error);
+            }
+        }
+        this.memoryCache.clear();
+    }
+    /**
+     * Get or set cache with callback
+     */
+    async getOrSet(key, callback, options = {}) {
+        const cached = await this.get(key, options.prefix);
+        if (cached !== null) {
+            return cached;
+        }
+        const value = await callback();
+        await this.set(key, value, options);
+        return value;
+    }
+    /**
+     * Check if cache is available
+     */
+    isEnabled() {
+        return this.enabled;
+    }
+    /**
+     * Get cache stats
+     */
+    async getStats() {
+        let keys = 0;
+        if (this.enabled && this.client) {
+            try {
+                const allKeys = await this.client.keys(`${CACHE_PREFIX}*`);
+                keys = allKeys.length;
+            }
+            catch (error) {
+                Logger.error('Cache stats error:', error);
+            }
+            return { enabled: true, type: 'redis', keys };
+        }
+        return {
+            enabled: false,
+            type: 'memory',
+            keys: this.memoryCache.size
+        };
+    }
+    /**
+     * Cleanup expired memory cache entries
+     */
+    cleanupMemoryCache() {
+        const now = Date.now();
+        for (const [key, value] of this.memoryCache.entries()) {
+            if (value.expires < now) {
+                this.memoryCache.delete(key);
+            }
+        }
+    }
+    /**
+     * Disconnect from Redis
+     */
+    async disconnect() {
+        if (this.client) {
+            await this.client.quit();
+            this.client = null;
+            this.enabled = false;
+        }
+    }
+}
+// Singleton instance
+export const cache = new CacheService();
+// Cache key generators
+export const cacheKeys = {
+    project: (projectId) => `project:${projectId}`,
+    projectAnalysis: (projectId) => `analysis:${projectId}`,
+    projectMetrics: (projectId) => `metrics:${projectId}`,
+    projectSearch: (projectId, query) => `search:${projectId}:${query}`,
+    user: (userId) => `user:${userId}`,
+    userProjects: (userId) => `user-projects:${userId}`,
+};
+// TTL presets (in seconds)
+export const cacheTTL = {
+    short: 60, // 1 minute
+    medium: 300, // 5 minutes
+    long: 3600, // 1 hour
+    day: 86400, // 24 hours
+};
+//# sourceMappingURL=cache.js.map

package/dist/server/services/database.d.ts

@@ -0,0 +1,43 @@
+/**
+ * PostgreSQL Database Service for ArchiCore
+ *
+ * Connection pooling and schema management
+ */
+import pg from 'pg';
+declare class DatabaseService {
+    private pool;
+    private initialized;
+    private initPromise;
+    /**
+     * Initialize database connection pool
+     */
+    init(): Promise<void>;
+    private _init;
+    /**
+     * Initialize database schema
+     */
+    private initSchema;
+    /**
+     * Check if database is available
+     */
+    isAvailable(): boolean;
+    /**
+     * Get a client from the pool
+     */
+    getClient(): Promise<pg.PoolClient>;
+    /**
+     * Execute a query
+     */
+    query<T extends pg.QueryResultRow = any>(text: string, params?: any[]): Promise<pg.QueryResult<T>>;
+    /**
+     * Execute a transaction
+     */
+    transaction<T>(callback: (client: pg.PoolClient) => Promise<T>): Promise<T>;
+    /**
+     * Close the connection pool
+     */
+    close(): Promise<void>;
+}
+export declare const db: DatabaseService;
+export {};
+//# sourceMappingURL=database.d.ts.map

package/dist/server/services/database.js

@@ -0,0 +1,221 @@
+/**
+ * PostgreSQL Database Service for ArchiCore
+ *
+ * Connection pooling and schema management
+ */
+import pg from 'pg';
+import { Logger } from '../../utils/logger.js';
+const { Pool } = pg;
+// Database schema version for migrations
+const SCHEMA_VERSION = 1;
+// SQL schema for ArchiCore
+const SCHEMA_SQL = `
+-- Users table
+CREATE TABLE IF NOT EXISTS users (
+  id VARCHAR(64) PRIMARY KEY,
+  email VARCHAR(255) UNIQUE NOT NULL,
+  username VARCHAR(100) NOT NULL,
+  password_hash VARCHAR(255),
+  avatar TEXT,
+  tier VARCHAR(20) NOT NULL DEFAULT 'free',
+  provider VARCHAR(20) NOT NULL DEFAULT 'email',
+  provider_id VARCHAR(255),
+  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+  last_login_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+
+  -- Usage tracking (reset daily)
+  requests_today INTEGER DEFAULT 0,
+  full_analysis_today INTEGER DEFAULT 0,
+  projects_today INTEGER DEFAULT 0,
+  usage_reset_date DATE DEFAULT CURRENT_DATE,
+
+  -- Subscription info
+  subscription_id VARCHAR(64),
+  subscription_status VARCHAR(20),
+  subscription_end_date TIMESTAMP WITH TIME ZONE
+);
+
+-- Sessions table
+CREATE TABLE IF NOT EXISTS sessions (
+  token VARCHAR(128) PRIMARY KEY,
+  user_id VARCHAR(64) NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  expires_at TIMESTAMP WITH TIME ZONE NOT NULL,
+  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- Audit logs table
+CREATE TABLE IF NOT EXISTS audit_logs (
+  id VARCHAR(64) PRIMARY KEY,
+  user_id VARCHAR(64) REFERENCES users(id) ON DELETE SET NULL,
+  username VARCHAR(100),
+  action VARCHAR(50) NOT NULL,
+  severity VARCHAR(20) NOT NULL DEFAULT 'info',
+  ip VARCHAR(45),
+  user_agent TEXT,
+  details JSONB,
+  success BOOLEAN DEFAULT true,
+  error_message TEXT,
+  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- Projects table (for future use)
+CREATE TABLE IF NOT EXISTS projects (
+  id VARCHAR(64) PRIMARY KEY,
+  user_id VARCHAR(64) NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  name VARCHAR(255) NOT NULL,
+  description TEXT,
+  repo_url TEXT,
+  repo_provider VARCHAR(20),
+  repo_id VARCHAR(255),
+  webhook_secret TEXT,
+  last_analyzed_at TIMESTAMP WITH TIME ZONE,
+  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+  updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- Schema version tracking
+CREATE TABLE IF NOT EXISTS schema_version (
+  version INTEGER PRIMARY KEY,
+  applied_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- Indexes for performance
+CREATE INDEX IF NOT EXISTS idx_sessions_user_id ON sessions(user_id);
+CREATE INDEX IF NOT EXISTS idx_sessions_expires_at ON sessions(expires_at);
+CREATE INDEX IF NOT EXISTS idx_audit_logs_user_id ON audit_logs(user_id);
+CREATE INDEX IF NOT EXISTS idx_audit_logs_action ON audit_logs(action);
+CREATE INDEX IF NOT EXISTS idx_audit_logs_created_at ON audit_logs(created_at);
+CREATE INDEX IF NOT EXISTS idx_projects_user_id ON projects(user_id);
+CREATE INDEX IF NOT EXISTS idx_users_email ON users(email);
+CREATE INDEX IF NOT EXISTS idx_users_provider ON users(provider, provider_id);
+`;
+class DatabaseService {
+    pool = null;
+    initialized = false;
+    initPromise = null;
+    /**
+     * Initialize database connection pool
+     */
+    async init() {
+        if (this.initialized)
+            return;
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = this._init();
+        return this.initPromise;
+    }
+    async _init() {
+        const databaseUrl = process.env.DATABASE_URL;
+        if (!databaseUrl) {
+            Logger.warn('DATABASE_URL not set - using JSON file storage');
+            return;
+        }
+        try {
+            this.pool = new Pool({
+                connectionString: databaseUrl,
+                max: 20, // Maximum pool size
+                idleTimeoutMillis: 30000,
+                connectionTimeoutMillis: 5000,
+            });
+            // Test connection
+            const client = await this.pool.connect();
+            await client.query('SELECT NOW()');
+            client.release();
+            // Initialize schema
+            await this.initSchema();
+            this.initialized = true;
+            Logger.success('PostgreSQL connected with connection pool (max: 20)');
+        }
+        catch (error) {
+            Logger.error('PostgreSQL connection failed:', error);
+            this.pool = null;
+            throw error;
+        }
+    }
+    /**
+     * Initialize database schema
+     */
+    async initSchema() {
+        if (!this.pool)
+            return;
+        try {
+            // Create schema
+            await this.pool.query(SCHEMA_SQL);
+            // Check/update schema version
+            const result = await this.pool.query('SELECT version FROM schema_version ORDER BY version DESC LIMIT 1');
+            if (result.rows.length === 0) {
+                await this.pool.query('INSERT INTO schema_version (version) VALUES ($1)', [SCHEMA_VERSION]);
+                Logger.info(`Database schema initialized (v${SCHEMA_VERSION})`);
+            }
+            else {
+                const currentVersion = result.rows[0].version;
+                if (currentVersion < SCHEMA_VERSION) {
+                    // Run migrations here if needed
+                    await this.pool.query('INSERT INTO schema_version (version) VALUES ($1)', [SCHEMA_VERSION]);
+                    Logger.info(`Database schema migrated to v${SCHEMA_VERSION}`);
+                }
+            }
+        }
+        catch (error) {
+            Logger.error('Schema initialization failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Check if database is available
+     */
+    isAvailable() {
+        return this.pool !== null && this.initialized;
+    }
+    /**
+     * Get a client from the pool
+     */
+    async getClient() {
+        if (!this.pool) {
+            throw new Error('Database not initialized');
+        }
+        return this.pool.connect();
+    }
+    /**
+     * Execute a query
+     */
+    async query(text, params) {
+        if (!this.pool) {
+            throw new Error('Database not initialized');
+        }
+        return this.pool.query(text, params);
+    }
+    /**
+     * Execute a transaction
+     */
+    async transaction(callback) {
+        const client = await this.getClient();
+        try {
+            await client.query('BEGIN');
+            const result = await callback(client);
+            await client.query('COMMIT');
+            return result;
+        }
+        catch (error) {
+            await client.query('ROLLBACK');
+            throw error;
+        }
+        finally {
+            client.release();
+        }
+    }
+    /**
+     * Close the connection pool
+     */
+    async close() {
+        if (this.pool) {
+            await this.pool.end();
+            this.pool = null;
+            this.initialized = false;
+            Logger.info('Database connection pool closed');
+        }
+    }
+}
+// Export singleton instance
+export const db = new DatabaseService();
+//# sourceMappingURL=database.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archicore",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "AI Software Architect - code analysis, impact prediction, semantic search",
   "main": "dist/index.js",
   "type": "module",
@@ -25,7 +25,17 @@
     "cli": "tsx src/cli.ts",
     "index": "tsx src/cli.ts index",
     "analyze": "tsx src/cli.ts analyze",
-    "impact": "tsx src/cli.ts impact"
+    "impact": "tsx src/cli.ts impact",
+    "docker:build": "docker build -t archicore .",
+    "docker:up": "docker compose up -d",
+    "docker:down": "docker compose down",
+    "docker:logs": "docker compose logs -f archicore",
+    "docker:dev": "docker compose -f docker-compose.dev.yml up -d",
+    "docker:dev:down": "docker compose -f docker-compose.dev.yml down",
+    "typecheck": "tsc --noEmit",
+    "docs": "npm --prefix docs-public run start",
+    "docs:build": "npm --prefix docs-public run build",
+    "docs:install": "npm --prefix docs-public install"
   },
   "keywords": [
     "ai",
@@ -42,6 +52,7 @@
     "@qdrant/js-client-rest": "^1.11.0",
     "@types/unzipper": "^0.10.11",
     "adm-zip": "^0.5.16",
+    "bcrypt": "^5.1.1",
     "boxen": "^8.0.1",
     "chalk": "^5.4.1",
     "cli-progress": "^3.12.0",
@@ -55,10 +66,12 @@
     "figures": "^6.1.0",
     "glob": "^11.0.0",
     "helmet": "^8.0.0",
+    "ioredis": "^5.9.1",
     "mime-types": "^3.0.2",
     "morgan": "^1.10.1",
     "multer": "^2.0.2",
     "openai": "^4.73.0",
+    "pg": "^8.13.0",
     "ora": "^8.1.1",
     "tree-sitter": "^0.21.1",
     "tree-sitter-javascript": "^0.21.4",
@@ -70,6 +83,7 @@
   },
   "devDependencies": {
     "@types/adm-zip": "^0.5.7",
+    "@types/bcrypt": "^5.0.2",
     "@types/cli-progress": "^3.11.6",
     "@types/compression": "^1.7.5",
     "@types/cors": "^2.8.19",
@@ -78,6 +92,7 @@
     "@types/morgan": "^1.9.10",
     "@types/multer": "^2.0.0",
     "@types/node": "^22.10.2",
+    "@types/pg": "^8.11.6",
     "tsx": "^4.19.2",
     "typescript": "^5.7.2"
   }