archicore 0.1.9 → 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) {
@@ -603,23 +628,33 @@ async function handleDeadCodeCommand() {
         if (!response.ok)
             throw new Error('Analysis failed');
         const data = await response.json();
-        const result = data.deadCode;
+        // Handle various response formats
+        const result = data.deadCode || data.result || data || {};
         spinner.succeed('Analysis complete');
         printSection('Dead Code');
-        console.log(`  Unused exports: ${result.unusedExports?.length || 0}`);
-        console.log(`  Unused variables: ${result.unusedVariables?.length || 0}`);
-        console.log(`  Unreachable code: ${result.unreachableCode?.length || 0}`);
-        if (result.unusedExports?.length > 0) {
+        const unusedExports = result.unusedExports || [];
+        const unusedVariables = result.unusedVariables || [];
+        const unreachableCode = result.unreachableCode || [];
+        console.log(`  Unused exports: ${unusedExports.length}`);
+        console.log(`  Unused variables: ${unusedVariables.length}`);
+        console.log(`  Unreachable code: ${unreachableCode.length}`);
+        if (unusedExports.length === 0 && unusedVariables.length === 0 && unreachableCode.length === 0) {
+            printSuccess('No dead code found!');
+            return;
+        }
+        if (unusedExports.length > 0) {
             console.log();
             console.log(colors.muted('  Top unused exports:'));
-            for (const item of result.unusedExports.slice(0, 5)) {
-                console.log(`    ${colors.warning(icons.warning)} ${item.name} ${colors.dim(`(${item.filePath})`)}`);
+            for (const item of unusedExports.slice(0, 5)) {
+                const name = item.name || item.symbol || 'unknown';
+                const file = item.filePath || item.file || '';
+                console.log(`    ${colors.warning(icons.warning)} ${name} ${colors.dim(`(${file})`)}`);
             }
         }
     }
     catch (error) {
         spinner.fail('Analysis failed');
-        throw error;
+        printFormattedError(error, { operation: 'Dead code analysis' });
     }
 }
 async function handleSecurityCommand() {
@@ -634,7 +669,9 @@ async function handleSecurityCommand() {
         if (!response.ok)
             throw new Error('Analysis failed');
         const data = await response.json();
-        const vulns = data.security?.vulnerabilities || [];
+        // Handle various response formats
+        const security = data.security || data.result || data || {};
+        const vulns = security.vulnerabilities || security.issues || [];
         spinner.succeed('Analysis complete');
         printSection('Security');
         if (vulns.length === 0) {
@@ -655,13 +692,15 @@ async function handleSecurityCommand() {
             console.log();
             console.log(colors.muted('  Critical/High issues:'));
             for (const v of vulns.filter((v) => v.severity === 'critical' || v.severity === 'high').slice(0, 5)) {
-                console.log(`    ${colors.error(icons.error)} ${v.type}: ${v.description}`);
+                const type = v.type || v.category || 'Issue';
+                const desc = v.description || v.message || 'No description';
+                console.log(`    ${colors.error(icons.error)} ${type}: ${desc}`);
             }
         }
     }
     catch (error) {
         spinner.fail('Analysis failed');
-        throw error;
+        printFormattedError(error, { operation: 'Security analysis' });
     }
 }
 async function handleMetricsCommand() {
@@ -676,19 +715,38 @@ async function handleMetricsCommand() {
         if (!response.ok)
             throw new Error('Analysis failed');
         const data = await response.json();
-        const metrics = data.metrics;
+        // Handle various response formats
+        const metrics = data.metrics || data.result || data || {};
+        const summary = metrics.summary || metrics || {};
         spinner.succeed('Metrics calculated');
         printSection('Code Metrics');
-        if (metrics.summary) {
-            console.log(`  Files: ${metrics.summary.totalFiles || 0}`);
-            console.log(`  Lines: ${metrics.summary.totalLines || 0}`);
-            console.log(`  Avg Complexity: ${(metrics.summary.avgComplexity || 0).toFixed(2)}`);
-            console.log(`  Avg Maintainability: ${(metrics.summary.avgMaintainability || 0).toFixed(1)}`);
+        // Display available metrics
+        const totalFiles = summary.totalFiles || summary.files || metrics.totalFiles || 0;
+        const totalLines = summary.totalLines || summary.lines || metrics.totalLines || 0;
+        const avgComplexity = summary.avgComplexity || summary.complexity || metrics.avgComplexity || 0;
+        const avgMaintainability = summary.avgMaintainability || summary.maintainability || metrics.avgMaintainability || 0;
+        console.log(`  Files: ${totalFiles}`);
+        console.log(`  Lines: ${totalLines}`);
+        if (avgComplexity > 0) {
+            console.log(`  Avg Complexity: ${Number(avgComplexity).toFixed(2)}`);
+        }
+        if (avgMaintainability > 0) {
+            console.log(`  Avg Maintainability: ${Number(avgMaintainability).toFixed(1)}`);
+        }
+        // Show additional metrics if available
+        if (metrics.functions || summary.functions) {
+            console.log(`  Functions: ${metrics.functions || summary.functions}`);
+        }
+        if (metrics.classes || summary.classes) {
+            console.log(`  Classes: ${metrics.classes || summary.classes}`);
+        }
+        if (totalFiles === 0 && totalLines === 0) {
+            printWarning('No metrics data available. Make sure project is indexed.');
         }
     }
     catch (error) {
         spinner.fail('Analysis failed');
-        throw error;
+        printFormattedError(error, { operation: 'Metrics calculation' });
     }
 }
 async function handleExportCommand(args) {
@@ -781,28 +839,37 @@ async function handleDuplicationCommand() {
         if (!response.ok)
             throw new Error('Analysis failed');
         const data = await response.json();
-        const result = data.duplication;
+        // Handle various response formats
+        const result = data.duplication || data.result || data || {};
+        const clones = result.clones || [];
+        const duplicationRate = result.duplicationRate || result.rate || 0;
+        const duplicatedLines = result.duplicatedLines || result.lines || 0;
         spinner.succeed('Analysis complete');
         printSection('Code Duplication');
-        console.log(`  Code clones: ${result.clones?.length || 0}`);
-        console.log(`  Duplication rate: ${(result.duplicationRate || 0).toFixed(1)}%`);
-        console.log(`  Duplicated lines: ${result.duplicatedLines || 0}`);
-        if (result.clones?.length > 0) {
-            console.log();
-            console.log(colors.muted('  Top duplicates:'));
-            for (const clone of result.clones.slice(0, 5)) {
-                console.log(`    ${colors.warning(icons.warning)} ${clone.files?.length || 2} files, ${clone.lines || 0} lines`);
-                if (clone.files) {
-                    for (const f of clone.files.slice(0, 2)) {
-                        console.log(`      ${colors.dim(f)}`);
-                    }
+        console.log(`  Code clones: ${clones.length}`);
+        console.log(`  Duplication rate: ${Number(duplicationRate).toFixed(1)}%`);
+        console.log(`  Duplicated lines: ${duplicatedLines}`);
+        if (clones.length === 0) {
+            printSuccess('No code duplication found!');
+            return;
+        }
+        console.log();
+        console.log(colors.muted('  Top duplicates:'));
+        for (const clone of clones.slice(0, 5)) {
+            const files = clone.files || clone.locations || [];
+            const lines = clone.lines || clone.lineCount || 0;
+            console.log(`    ${colors.warning(icons.warning)} ${files.length || 2} files, ${lines} lines`);
+            if (files.length > 0) {
+                for (const f of files.slice(0, 2)) {
+                    const filePath = typeof f === 'string' ? f : f.file || f.path || '';
+                    console.log(`      ${colors.dim(filePath)}`);
                 }
             }
         }
     }
     catch (error) {
         spinner.fail('Analysis failed');
-        throw error;
+        printFormattedError(error, { operation: 'Duplication analysis' });
     }
 }
 async function handleRefactoringCommand() {
@@ -818,7 +885,9 @@ async function handleRefactoringCommand() {
         if (!response.ok)
             throw new Error('Analysis failed');
         const data = await response.json();
-        const suggestions = data.refactoring?.suggestions || [];
+        // Handle various response formats
+        const refactoring = data.refactoring || data.result || data || {};
+        const suggestions = refactoring.suggestions || refactoring.items || [];
         spinner.succeed('Analysis complete');
         printSection('Refactoring Suggestions');
         if (suggestions.length === 0) {
@@ -837,17 +906,20 @@ async function handleRefactoringCommand() {
         console.log();
         console.log(colors.muted('  Top suggestions:'));
         for (const s of suggestions.slice(0, 5)) {
-            const priorityColor = s.priority === 'critical' ? colors.critical :
-                s.priority === 'high' ? colors.high : colors.muted;
-            console.log(`    ${priorityColor(`[${s.priority}]`)} ${s.type}: ${s.description}`);
-            if (s.file) {
-                console.log(`      ${colors.dim(s.file)}`);
+            const priority = s.priority || 'medium';
+            const type = s.type || s.category || 'Suggestion';
+            const desc = s.description || s.message || '';
+            const priorityColor = priority === 'critical' ? colors.critical :
+                priority === 'high' ? colors.high : colors.muted;
+            console.log(`    ${priorityColor(`[${priority}]`)} ${type}: ${desc}`);
+            if (s.file || s.filePath) {
+                console.log(`      ${colors.dim(s.file || s.filePath)}`);
             }
         }
     }
     catch (error) {
         spinner.fail('Analysis failed');
-        throw error;
+        printFormattedError(error, { operation: 'Refactoring analysis' });
     }
 }
 async function handleRulesCommand() {
@@ -863,7 +935,9 @@ async function handleRulesCommand() {
         if (!response.ok)
             throw new Error('Analysis failed');
         const data = await response.json();
-        const violations = data.rules?.violations || [];
+        // Handle various response formats
+        const rules = data.rules || data.result || data || {};
+        const violations = rules.violations || rules.issues || [];
         spinner.succeed('Analysis complete');
         printSection('Architectural Rules');
         if (violations.length === 0) {
@@ -873,17 +947,27 @@ async function handleRulesCommand() {
         console.log(`  Violations: ${violations.length}`);
         console.log();
         for (const v of violations.slice(0, 10)) {
-            const severityColor = v.severity === 'error' ? colors.error :
-                v.severity === 'warning' ? colors.warning : colors.muted;
-            console.log(`    ${severityColor(icons.error)} ${v.rule}: ${v.message}`);
-            if (v.file) {
-                console.log(`      ${colors.dim(v.file)}`);
+            const severity = v.severity || 'warning';
+            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;
+            // 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)}`);
             }
         }
     }
     catch (error) {
         spinner.fail('Analysis failed');
-        throw error;
+        printFormattedError(error, { operation: 'Rules check' });
     }
 }
 async function handleDocsCommand(args) {

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: {