archicore 0.2.0 → 0.2.1

package/dist/cli/commands/interactive.js

@@ -444,7 +444,7 @@ async function handleIndexCommand() {
 async function handleAnalyzeCommand(args) {
     if (!state.projectId) {
         printError('No project selected');
-        printInfo('Use /projects select <id> first');
+        printInfo('Use /index first');
         return;
     }
     const description = args.join(' ') || 'General analysis';
@@ -465,15 +465,20 @@ async function handleAnalyzeCommand(args) {
         const data = await response.json();
         spinner.succeed('Analysis complete');
         printSection('Impact Analysis');
-        const impact = data.impact;
-        // Affected components
-        const affected = impact.affectedNodes || [];
+        // Handle various response formats
+        const impact = data.impact || data.result || data || {};
+        const affected = impact.affectedNodes || impact.affected || impact.nodes || [];
         console.log(`  ${colors.highlight('Affected Components:')} ${affected.length}`);
+        if (affected.length === 0) {
+            printInfo('No components affected by this change');
+            showTokenUsage();
+            return;
+        }
         const byLevel = {
-            critical: affected.filter((n) => n.impactLevel === 'critical'),
-            high: affected.filter((n) => n.impactLevel === 'high'),
-            medium: affected.filter((n) => n.impactLevel === 'medium'),
-            low: affected.filter((n) => n.impactLevel === 'low'),
+            critical: affected.filter((n) => n.impactLevel === 'critical' || n.level === 'critical'),
+            high: affected.filter((n) => n.impactLevel === 'high' || n.level === 'high'),
+            medium: affected.filter((n) => n.impactLevel === 'medium' || n.level === 'medium'),
+            low: affected.filter((n) => n.impactLevel === 'low' || n.level === 'low'),
         };
         if (byLevel.critical.length > 0) {
             console.log(`  ${colors.critical(`${icons.severityCritical} Critical: ${byLevel.critical.length}`)}`);
@@ -487,27 +492,47 @@ async function handleAnalyzeCommand(args) {
         if (byLevel.low.length > 0) {
             console.log(`  ${colors.low(`${icons.severityLow} Low: ${byLevel.low.length}`)}`);
         }
+        // Show top affected files
+        if (affected.length > 0) {
+            console.log();
+            console.log(`  ${colors.highlight('Top affected:')}`);
+            for (const node of affected.slice(0, 5)) {
+                const name = node.name || node.symbol || 'unknown';
+                const file = node.filePath || node.file || '';
+                const level = node.impactLevel || node.level || 'unknown';
+                const levelColor = level === 'critical' ? colors.critical :
+                    level === 'high' ? colors.high :
+                        level === 'medium' ? colors.medium : colors.muted;
+                console.log(`    ${levelColor(`[${level}]`)} ${name}`);
+                if (file)
+                    console.log(`      ${colors.dim(file)}`);
+            }
+        }
         // Risks
-        if (impact.risks?.length > 0) {
+        const risks = impact.risks || [];
+        if (risks.length > 0) {
             console.log();
             console.log(`  ${colors.highlight('Risks:')}`);
-            for (const risk of impact.risks.slice(0, 5)) {
-                console.log(`  ${colors.warning(icons.warning)} ${risk.description}`);
+            for (const risk of risks.slice(0, 5)) {
+                const desc = risk.description || risk.message || risk;
+                console.log(`  ${colors.warning(icons.warning)} ${desc}`);
             }
         }
         // Recommendations
-        if (impact.recommendations?.length > 0) {
+        const recommendations = impact.recommendations || [];
+        if (recommendations.length > 0) {
             console.log();
             console.log(`  ${colors.highlight('Recommendations:')}`);
-            for (const rec of impact.recommendations.slice(0, 3)) {
-                console.log(`  ${colors.info(icons.info)} ${rec.description}`);
+            for (const rec of recommendations.slice(0, 3)) {
+                const desc = rec.description || rec.message || rec;
+                console.log(`  ${colors.info(icons.info)} ${desc}`);
             }
         }
         showTokenUsage();
     }
     catch (error) {
         spinner.fail('Analysis failed');
-        throw error;
+        printFormattedError(error, { operation: 'Impact analysis' });
     }
 }
 async function handleSearchCommand(query) {
@@ -923,13 +948,20 @@ async function handleRulesCommand() {
         console.log();
         for (const v of violations.slice(0, 10)) {
             const severity = v.severity || 'warning';
-            const rule = v.rule || v.name || 'Unknown rule';
+            const rule = v.rule || v.type || v.name || '';
             const message = v.message || v.description || '';
+            const file = v.file || v.filePath || '';
             const severityColor = severity === 'error' ? colors.error :
                 severity === 'warning' ? colors.warning : colors.muted;
-            console.log(`    ${severityColor(icons.error)} ${rule}: ${message}`);
-            if (v.file || v.filePath) {
-                console.log(`      ${colors.dim(v.file || v.filePath)}`);
+            // Format: show rule type if present, otherwise just message
+            if (rule && message) {
+                console.log(`    ${severityColor(icons.error)} [${rule}] ${message}`);
+            }
+            else {
+                console.log(`    ${severityColor(icons.error)} ${message || rule}`);
+            }
+            if (file) {
+                console.log(`      ${colors.dim(file)}`);
             }
         }
     }

package/dist/github/github-service.d.ts

@@ -96,9 +96,13 @@ export declare class GitHubService {
      */
     private deleteWebhook;
     /**
-     * Verify webhook signature
+     * Verify webhook signature (HMAC-SHA256)
      */
     verifyWebhookSignature(payload: string, signature: string, secret: string): boolean;
+    /**
+     * Get decrypted webhook secret
+     */
+    getWebhookSecret(encryptedSecret: string): string;
     /**
      * Find repository by webhook payload
      */

package/dist/github/github-service.js

@@ -3,7 +3,7 @@
  *
  * Handles OAuth, API calls, webhooks, and repository management
  */
-import { randomBytes, createHash, createHmac, createCipheriv, createDecipheriv } from 'crypto';
+import { randomBytes, createHash, createHmac, createCipheriv, createDecipheriv, timingSafeEqual } from 'crypto';
 import { readFile, writeFile, mkdir } from 'fs/promises';
 import { join } from 'path';
 import { Logger } from '../utils/logger.js';
@@ -483,12 +483,30 @@ export class GitHubService {
         });
     }
     /**
-     * Verify webhook signature
+     * Verify webhook signature (HMAC-SHA256)
      */
     verifyWebhookSignature(payload, signature, secret) {
         const hmac = createHmac('sha256', secret);
         const digest = 'sha256=' + hmac.update(payload).digest('hex');
-        return signature === digest;
+        // Use timing-safe comparison to prevent timing attacks
+        if (signature.length !== digest.length) {
+            return false;
+        }
+        // Convert to buffers for timing-safe comparison
+        const signatureBuffer = Buffer.from(signature);
+        const digestBuffer = Buffer.from(digest);
+        try {
+            return timingSafeEqual(signatureBuffer, digestBuffer);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get decrypted webhook secret
+     */
+    getWebhookSecret(encryptedSecret) {
+        return this.decrypt(encryptedSecret);
     }
     /**
      * Find repository by webhook payload

package/dist/semantic-memory/embedding-service.d.ts

@@ -7,11 +7,17 @@ export declare class EmbeddingService {
     private config;
     private initialized;
     private _isAvailable;
-    private jinaApiKey?;
+    private jinaApiKeys;
+    private currentKeyIndex;
+    private keyFailures;
     private embeddingDimension;
     constructor(config: EmbeddingConfig);
     getEmbeddingDimension(): number;
     private ensureInitialized;
+    private getCurrentJinaKey;
+    private rotateToNextKey;
+    private shouldSkipKey;
+    private findWorkingKeyIndex;
     isAvailable(): boolean;
     generateEmbedding(text: string): Promise<number[]>;
     private generateJinaEmbedding;
@@ -19,6 +25,7 @@ export declare class EmbeddingService {
      * Generate embeddings for multiple texts - uses true batch API when available
      */
     generateBatchEmbeddings(texts: string[], progressCallback?: (current: number, total: number) => void): Promise<number[][]>;
+    private generateJinaBatchWithRetry;
     private generateOpenAIEmbedding;
     prepareCodeForEmbedding(code: string, context?: string): string;
     generateCodeEmbedding(code: string, metadata: {

package/dist/semantic-memory/embedding-service.js

@@ -5,7 +5,9 @@ export class EmbeddingService {
     config;
     initialized = false;
     _isAvailable = false;
-    jinaApiKey;
+    jinaApiKeys = [];
+    currentKeyIndex = 0;
+    keyFailures = new Map();
     embeddingDimension = 1024; // Jina default, OpenAI small = 1536
     constructor(config) {
         this.config = config;
@@ -23,16 +25,21 @@ export class EmbeddingService {
         }
         try {
             if (this.config.provider === 'jina') {
-                // Jina AI - free embeddings
-                this.jinaApiKey = process.env.JINA_API_KEY;
-                if (!this.jinaApiKey) {
-                    Logger.warn('JINA_API_KEY not set - semantic search disabled');
+                // Jina AI - free embeddings with key rotation support
+                // Support multiple keys: JINA_API_KEYS (comma-separated) or JINA_API_KEY (single)
+                const keysEnv = process.env.JINA_API_KEYS || process.env.JINA_API_KEY || '';
+                this.jinaApiKeys = keysEnv
+                    .split(',')
+                    .map(k => k.trim())
+                    .filter(k => k.length > 0);
+                if (this.jinaApiKeys.length === 0) {
+                    Logger.warn('JINA_API_KEY(S) not set - semantic search disabled');
                     Logger.info('Get free API key at: https://jina.ai/embeddings/');
                     return;
                 }
                 this.embeddingDimension = 1024;
                 this._isAvailable = true;
-                Logger.success('Jina AI embeddings enabled');
+                Logger.success(`Jina AI embeddings enabled (${this.jinaApiKeys.length} key${this.jinaApiKeys.length > 1 ? 's' : ''} configured)`);
             }
             else {
                 // OpenAI embeddings
@@ -51,6 +58,45 @@ export class EmbeddingService {
             Logger.warn('Embedding init failed: ' + error);
         }
     }
+    getCurrentJinaKey() {
+        if (this.jinaApiKeys.length === 0)
+            return undefined;
+        return this.jinaApiKeys[this.currentKeyIndex];
+    }
+    rotateToNextKey() {
+        if (this.jinaApiKeys.length <= 1)
+            return false;
+        const oldIndex = this.currentKeyIndex;
+        this.currentKeyIndex = (this.currentKeyIndex + 1) % this.jinaApiKeys.length;
+        // Track failure for old key
+        const failure = this.keyFailures.get(oldIndex) || { count: 0, lastFail: new Date() };
+        failure.count++;
+        failure.lastFail = new Date();
+        this.keyFailures.set(oldIndex, failure);
+        Logger.warn(`Jina API key ${oldIndex + 1} exhausted/failed, rotating to key ${this.currentKeyIndex + 1}`);
+        return true;
+    }
+    shouldSkipKey(index) {
+        const failure = this.keyFailures.get(index);
+        if (!failure)
+            return false;
+        // Skip key if it failed recently (within 5 minutes) and has many failures
+        const fiveMinutesAgo = new Date(Date.now() - 5 * 60 * 1000);
+        return failure.count >= 3 && failure.lastFail > fiveMinutesAgo;
+    }
+    findWorkingKeyIndex() {
+        const startIndex = this.currentKeyIndex;
+        for (let i = 0; i < this.jinaApiKeys.length; i++) {
+            const index = (startIndex + i) % this.jinaApiKeys.length;
+            if (!this.shouldSkipKey(index)) {
+                return index;
+            }
+        }
+        // All keys are marked as failed, reset failures and try first key
+        Logger.warn('All Jina API keys marked as failed, resetting failure counters');
+        this.keyFailures.clear();
+        return 0;
+    }
     isAvailable() {
         this.ensureInitialized();
         return this._isAvailable;
@@ -60,7 +106,7 @@ export class EmbeddingService {
         if (!this._isAvailable)
             return new Array(this.embeddingDimension).fill(0);
         try {
-            if (this.config.provider === 'jina' && this.jinaApiKey) {
+            if (this.config.provider === 'jina' && this.jinaApiKeys.length > 0) {
                 return await this.generateJinaEmbedding(text);
             }
             else if (this.openai) {
@@ -73,28 +119,51 @@ export class EmbeddingService {
             return new Array(this.embeddingDimension).fill(0);
         }
     }
-    async generateJinaEmbedding(text) {
-        if (!this.jinaApiKey)
+    async generateJinaEmbedding(text, retryCount = 0) {
+        const maxRetries = this.jinaApiKeys.length;
+        // Find a working key index before first attempt
+        if (retryCount === 0) {
+            this.currentKeyIndex = this.findWorkingKeyIndex();
+        }
+        const apiKey = this.getCurrentJinaKey();
+        if (!apiKey)
             throw new Error('Jina API key not set');
-        const response = await fetch('https://api.jina.ai/v1/embeddings', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${this.jinaApiKey}`
-            },
-            body: JSON.stringify({
-                model: this.config.model || 'jina-embeddings-v3',
-                task: 'text-matching',
-                dimensions: 1024,
-                input: [text.substring(0, 8000)]
-            })
-        });
-        if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Jina API error: ${response.status} ${error}`);
+        try {
+            const response = await fetch('https://api.jina.ai/v1/embeddings', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${apiKey}`
+                },
+                body: JSON.stringify({
+                    model: this.config.model || 'jina-embeddings-v3',
+                    task: 'text-matching',
+                    dimensions: 1024,
+                    input: [text.substring(0, 8000)]
+                })
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                // Check for rate limit or auth errors - try next key
+                if (response.status === 429 || response.status === 401 || response.status === 403) {
+                    if (retryCount < maxRetries - 1 && this.rotateToNextKey()) {
+                        Logger.warn(`Jina API key error (${response.status}), trying next key...`);
+                        return this.generateJinaEmbedding(text, retryCount + 1);
+                    }
+                }
+                throw new Error(`Jina API error: ${response.status} ${errorText}`);
+            }
+            const data = await response.json();
+            return data.data[0].embedding;
+        }
+        catch (error) {
+            // Network error or other issue - try next key
+            if (retryCount < maxRetries - 1 && this.rotateToNextKey()) {
+                Logger.warn(`Jina API request failed, trying next key...`);
+                return this.generateJinaEmbedding(text, retryCount + 1);
+            }
+            throw error;
         }
-        const data = await response.json();
-        return data.data[0].embedding;
     }
     /**
      * Generate embeddings for multiple texts - uses true batch API when available
@@ -110,30 +179,13 @@ export class EmbeddingService {
         Logger.progress(`Generating embeddings for ${texts.length} texts...`);
         try {
             // Use true batch API for Jina (much faster!)
-            if (this.config.provider === 'jina' && this.jinaApiKey) {
+            if (this.config.provider === 'jina' && this.jinaApiKeys.length > 0) {
                 const BATCH_SIZE = 500;
                 const allEmbeddings = [];
                 for (let i = 0; i < texts.length; i += BATCH_SIZE) {
                     const batch = texts.slice(i, i + BATCH_SIZE).map(t => t.substring(0, 8000));
-                    const response = await fetch('https://api.jina.ai/v1/embeddings', {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json',
-                            'Authorization': `Bearer ${this.jinaApiKey}`
-                        },
-                        body: JSON.stringify({
-                            model: this.config.model || 'jina-embeddings-v3',
-                            task: 'text-matching',
-                            dimensions: 1024,
-                            input: batch
-                        })
-                    });
-                    if (!response.ok) {
-                        const error = await response.text();
-                        throw new Error(`Jina API error: ${response.status} ${error}`);
-                    }
-                    const data = await response.json();
-                    allEmbeddings.push(...data.data.map(d => d.embedding));
+                    const batchEmbeddings = await this.generateJinaBatchWithRetry(batch);
+                    allEmbeddings.push(...batchEmbeddings);
                     if (progressCallback) {
                         progressCallback(Math.min(i + BATCH_SIZE, texts.length), texts.length);
                     }
@@ -161,6 +213,48 @@ export class EmbeddingService {
             return texts.map(() => new Array(this.embeddingDimension).fill(0));
         }
     }
+    async generateJinaBatchWithRetry(batch, retryCount = 0) {
+        const maxRetries = this.jinaApiKeys.length;
+        const apiKey = this.getCurrentJinaKey();
+        if (!apiKey)
+            throw new Error('Jina API key not set');
+        try {
+            const response = await fetch('https://api.jina.ai/v1/embeddings', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${apiKey}`
+                },
+                body: JSON.stringify({
+                    model: this.config.model || 'jina-embeddings-v3',
+                    task: 'text-matching',
+                    dimensions: 1024,
+                    input: batch
+                })
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                // Check for rate limit or auth errors - try next key
+                if (response.status === 429 || response.status === 401 || response.status === 403) {
+                    if (retryCount < maxRetries - 1 && this.rotateToNextKey()) {
+                        Logger.warn(`Jina API batch error (${response.status}), trying next key...`);
+                        return this.generateJinaBatchWithRetry(batch, retryCount + 1);
+                    }
+                }
+                throw new Error(`Jina API error: ${response.status} ${errorText}`);
+            }
+            const data = await response.json();
+            return data.data.map(d => d.embedding);
+        }
+        catch (error) {
+            // Network error or other issue - try next key
+            if (retryCount < maxRetries - 1 && this.rotateToNextKey()) {
+                Logger.warn(`Jina API batch request failed, trying next key...`);
+                return this.generateJinaBatchWithRetry(batch, retryCount + 1);
+            }
+            throw error;
+        }
+    }
     async generateOpenAIEmbedding(text) {
         if (!this.openai)
             throw new Error('OpenAI client not initialized');

package/dist/server/index.js

@@ -25,6 +25,9 @@ import { adminRouter } from './routes/admin.js';
 import { developerRouter } from './routes/developer.js';
 import { githubRouter } from './routes/github.js';
 import deviceAuthRouter from './routes/device-auth.js';
+import { cache } from './services/cache.js';
+import { db } from './services/database.js';
+import { AuthService } from './services/auth-service.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 // CORS whitelist - настройте под свои домены
@@ -156,6 +159,7 @@ export class ArchiCoreServer {
         this.app.use(express.static(publicPath, {
             maxAge: process.env.NODE_ENV === 'production' ? '1d' : 0,
             etag: true,
+            index: false, // Отключаем автоматический index.html - используем явные маршруты
         }));
     }
     setupRoutes() {
@@ -187,7 +191,54 @@ export class ArchiCoreServer {
             const deviceAuthPath = path.join(__dirname, '../../public/device-auth.html');
             res.sendFile(deviceAuthPath);
         });
-        // SPA fallback - все остальные маршруты отдают index.html
+        // Clean URL routing
+        // Landing page (главная)
+        this.app.get('/', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/landing.html'));
+        });
+        // Dashboard (после авторизации)
+        this.app.get('/dashboard', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/index.html'));
+        });
+        // Add new project page
+        this.app.get('/new', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/index.html'));
+        });
+        // Pricing page
+        this.app.get('/pricing', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/pricing.html'));
+        });
+        // API Dashboard page
+        this.app.get('/api-dashboard', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/api-dashboard.html'));
+        });
+        // Auth page
+        this.app.get('/auth', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/auth.html'));
+        });
+        // Login alias
+        this.app.get('/login', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/auth.html'));
+        });
+        // Register alias
+        this.app.get('/register', (_req, res) => {
+            res.redirect('/auth?mode=register');
+        });
+        // Admin page
+        this.app.get('/admin', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/admin.html'));
+        });
+        // Legal pages
+        this.app.get('/privacy', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/privacy.html'));
+        });
+        this.app.get('/terms', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/terms.html'));
+        });
+        this.app.get('/security', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/security.html'));
+        });
+        // SPA fallback - все остальные маршруты отдают index.html (dashboard)
         this.app.get('/*splat', (_req, res) => {
             const indexPath = path.join(__dirname, '../../public/index.html');
             res.sendFile(indexPath);
@@ -208,6 +259,17 @@ export class ArchiCoreServer {
         });
     }
     async start() {
+        // Initialize database
+        try {
+            await db.init();
+            const authService = AuthService.getInstance();
+            await authService.initDatabase();
+        }
+        catch (error) {
+            Logger.warn('Database initialization failed, using JSON fallback:', error);
+        }
+        // Initialize cache
+        await cache.connect();
         return new Promise((resolve) => {
             this.server = createServer(this.app);
             const host = this.config.host || '0.0.0.0';
@@ -221,6 +283,9 @@ export class ArchiCoreServer {
         });
     }
     async stop() {
+        // Disconnect cache and database
+        await cache.disconnect();
+        await db.close();
         return new Promise((resolve) => {
             if (this.server) {
                 this.server.close(() => {