archicore 0.1.8 → 0.2.0

package/dist/cli/utils/error-handler.js

@@ -0,0 +1,234 @@
+/**
+ * ArchiCore CLI - Error Handler
+ *
+ * User-friendly error messages with suggestions
+ */
+import { colors, icons } from '../ui/colors.js';
+const KNOWN_ERRORS = [
+    // Network errors
+    {
+        pattern: /ECONNREFUSED|Failed to fetch|NetworkError/i,
+        title: 'Connection refused',
+        suggestion: 'Make sure the ArchiCore server is running',
+        details: 'Run `npm run server` or check if the server is accessible',
+    },
+    {
+        pattern: /ETIMEDOUT|timeout/i,
+        title: 'Connection timeout',
+        suggestion: 'Check your network connection or server status',
+        details: 'The server might be overloaded or unreachable',
+    },
+    {
+        pattern: /ENOTFOUND|DNS/i,
+        title: 'Server not found',
+        suggestion: 'Check the server URL in your configuration',
+        details: 'Run `archicore config` to update server settings',
+    },
+    // Auth errors
+    {
+        pattern: /401|Unauthorized|Invalid token/i,
+        title: 'Authentication failed',
+        suggestion: 'Your session may have expired',
+        details: 'Run `archicore login` to authenticate again',
+    },
+    {
+        pattern: /403|Forbidden|Access denied/i,
+        title: 'Access denied',
+        suggestion: 'You don\'t have permission for this operation',
+        details: 'Check your subscription or contact support',
+    },
+    {
+        pattern: /429|Too many requests|rate limit/i,
+        title: 'Rate limit exceeded',
+        suggestion: 'Wait a moment before trying again',
+        details: 'Upgrade your plan for higher limits',
+    },
+    // Project errors
+    {
+        pattern: /Project not found|No project/i,
+        title: 'Project not found',
+        suggestion: 'Make sure the project exists and is indexed',
+        details: 'Run `archicore init` in your project directory',
+    },
+    {
+        pattern: /Not indexed|Index required/i,
+        title: 'Project not indexed',
+        suggestion: 'Index your project first',
+        details: 'Run `/index` command in interactive mode',
+    },
+    {
+        pattern: /No files found|Empty project/i,
+        title: 'No files found',
+        suggestion: 'Check that your project has source files',
+        details: 'Make sure .ts, .js, or .py files exist in the directory',
+    },
+    // Qdrant/Vector DB errors
+    {
+        pattern: /Qdrant|vector.*error|embedding/i,
+        title: 'Vector database error',
+        suggestion: 'Check if Qdrant is running',
+        details: 'Run `docker-compose up -d qdrant` or check Qdrant status',
+    },
+    // LLM/API errors
+    {
+        pattern: /OpenAI|Anthropic|DeepSeek|API key/i,
+        title: 'AI provider error',
+        suggestion: 'Check your API keys in .env file',
+        details: 'Make sure OPENAI_API_KEY, ANTHROPIC_API_KEY, or DEEPSEEK_API_KEY is set',
+    },
+    {
+        pattern: /quota|credits|billing/i,
+        title: 'API quota exceeded',
+        suggestion: 'Check your AI provider billing',
+        details: 'You may have run out of credits on OpenAI/Anthropic/DeepSeek',
+    },
+    // File errors
+    {
+        pattern: /ENOENT|file not found|no such file/i,
+        title: 'File not found',
+        suggestion: 'Check the file path',
+        details: 'Make sure the file exists and is accessible',
+    },
+    {
+        pattern: /EACCES|permission denied/i,
+        title: 'Permission denied',
+        suggestion: 'Check file permissions',
+        details: 'You may need to run with elevated privileges',
+    },
+    // Parse errors
+    {
+        pattern: /Syntax error|Parse error|Invalid JSON/i,
+        title: 'Parse error',
+        suggestion: 'Check the file for syntax errors',
+        details: 'Run your linter or IDE to find syntax issues',
+    },
+];
+/**
+ * Format error for CLI display
+ */
+export function formatError(error, context) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const statusCode = context?.statusCode;
+    // Find matching known error
+    const knownError = KNOWN_ERRORS.find(ke => {
+        if (typeof ke.pattern === 'string') {
+            return errorMessage.toLowerCase().includes(ke.pattern.toLowerCase());
+        }
+        return ke.pattern.test(errorMessage);
+    });
+    const lines = [];
+    // Title line
+    const title = knownError?.title || context?.operation || 'Error';
+    lines.push(colors.error(`  ${icons.error} ${title}`));
+    // Error message
+    if (knownError) {
+        lines.push(colors.muted(`  ${errorMessage}`));
+    }
+    else {
+        lines.push(`  ${errorMessage}`);
+    }
+    // Status code if available
+    if (statusCode && statusCode >= 400) {
+        lines.push(colors.dim(`  HTTP ${statusCode}`));
+    }
+    // Suggestion
+    const suggestion = context?.suggestion || knownError?.suggestion;
+    if (suggestion) {
+        lines.push('');
+        lines.push(colors.info(`  ${icons.info} ${suggestion}`));
+    }
+    // Details
+    const details = context?.details || knownError?.details;
+    if (details) {
+        lines.push(colors.dim(`  ${details}`));
+    }
+    return lines.join('\n');
+}
+/**
+ * Print error with formatting
+ */
+export function printFormattedError(error, context) {
+    console.log();
+    console.log(formatError(error, context));
+    console.log();
+}
+/**
+ * Wrap async operation with error handling
+ */
+export async function withErrorHandler(operation, context) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        printFormattedError(error, context);
+        return null;
+    }
+}
+/**
+ * Create contextual error handler
+ */
+export function createErrorHandler(defaultContext) {
+    return {
+        handle: (error, additionalContext) => {
+            printFormattedError(error, { ...defaultContext, ...additionalContext });
+        },
+        wrap: async (operation, additionalContext) => {
+            return withErrorHandler(operation, { ...defaultContext, ...additionalContext });
+        },
+    };
+}
+/**
+ * HTTP response error handler
+ */
+export async function handleResponseError(response, operation) {
+    let errorMessage = `HTTP ${response.status}`;
+    try {
+        const data = await response.json();
+        errorMessage = data.error || data.message || errorMessage;
+    }
+    catch {
+        // Use status text if JSON parsing fails
+        errorMessage = response.statusText || errorMessage;
+    }
+    const error = new Error(errorMessage);
+    printFormattedError(error, {
+        statusCode: response.status,
+        operation,
+    });
+    throw error;
+}
+/**
+ * Print startup errors nicely
+ */
+export function printStartupError(error) {
+    console.log();
+    console.log(colors.error.bold('  ArchiCore failed to start'));
+    console.log();
+    const message = error instanceof Error ? error.message : String(error);
+    // Check for common startup issues
+    if (message.includes('ECONNREFUSED') || message.includes('Cannot connect')) {
+        console.log(colors.warning(`  ${icons.warning} Server connection failed`));
+        console.log();
+        console.log(colors.muted('  Possible solutions:'));
+        console.log(colors.dim('  1. Start the server: npm run server'));
+        console.log(colors.dim('  2. Check server URL in .archicore/config.json'));
+        console.log(colors.dim('  3. Make sure port 3000 is not blocked'));
+    }
+    else if (message.includes('not initialized')) {
+        console.log(colors.warning(`  ${icons.warning} Project not initialized`));
+        console.log();
+        console.log(colors.muted('  Run this command to initialize:'));
+        console.log(colors.primary('  archicore init'));
+    }
+    else if (message.includes('Authentication') || message.includes('token')) {
+        console.log(colors.warning(`  ${icons.warning} Authentication required`));
+        console.log();
+        console.log(colors.muted('  Run this command to login:'));
+        console.log(colors.primary('  archicore login'));
+    }
+    else {
+        console.log(colors.muted(`  ${message}`));
+    }
+    console.log();
+}
+//# sourceMappingURL=error-handler.js.map

package/dist/cli/utils/index.d.ts

@@ -3,4 +3,6 @@
  */
 export * from './config.js';
 export * from './session.js';
+export { fetchUserProjects, selectProject as selectProjectInteractive, quickProjectSwitch, displayProjectInfo, searchProjects, type ProjectInfo as ProjectSelectorInfo, } from './project-selector.js';
+export * from './error-handler.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/cli/utils/index.js

@@ -3,4 +3,7 @@
  */
 export * from './config.js';
 export * from './session.js';
+// project-selector has renamed exports to avoid conflicts with session.js
+export { fetchUserProjects, selectProject as selectProjectInteractive, quickProjectSwitch, displayProjectInfo, searchProjects, } from './project-selector.js';
+export * from './error-handler.js';
 //# sourceMappingURL=index.js.map

package/dist/cli/utils/project-selector.d.ts

@@ -0,0 +1,33 @@
+/**
+ * ArchiCore CLI - Project Selector
+ *
+ * Auto-suggest projects when starting CLI
+ */
+export interface ProjectInfo {
+    id: string;
+    name: string;
+    path?: string;
+    indexed?: boolean;
+    lastAccess?: string;
+}
+/**
+ * Fetch user's projects from server
+ */
+export declare function fetchUserProjects(): Promise<ProjectInfo[]>;
+/**
+ * Interactive project selector
+ */
+export declare function selectProject(projects: ProjectInfo[]): Promise<ProjectInfo | null>;
+/**
+ * Quick project switcher (for use during session)
+ */
+export declare function quickProjectSwitch(currentProjectId: string | null): Promise<ProjectInfo | null>;
+/**
+ * Display project info in a nice format
+ */
+export declare function displayProjectInfo(project: ProjectInfo): void;
+/**
+ * Search projects by name
+ */
+export declare function searchProjects(projects: ProjectInfo[], query: string): ProjectInfo[];
+//# sourceMappingURL=project-selector.d.ts.map

package/dist/cli/utils/project-selector.js

@@ -0,0 +1,148 @@
+/**
+ * ArchiCore CLI - Project Selector
+ *
+ * Auto-suggest projects when starting CLI
+ */
+import * as readline from 'readline';
+import { colors, icons } from '../ui/colors.js';
+import { loadConfig } from './config.js';
+/**
+ * Fetch user's projects from server
+ */
+export async function fetchUserProjects() {
+    try {
+        const config = await loadConfig();
+        if (!config.accessToken)
+            return [];
+        const response = await fetch(`${config.serverUrl}/api/projects`, {
+            headers: {
+                'Authorization': `Bearer ${config.accessToken}`,
+            },
+        });
+        if (!response.ok)
+            return [];
+        const data = await response.json();
+        return (data.projects || data || []).map((p) => ({
+            id: p.id,
+            name: p.name,
+            path: p.path,
+            indexed: p.indexed,
+            lastAccess: p.lastAccess || p.updatedAt,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Interactive project selector
+ */
+export async function selectProject(projects) {
+    if (projects.length === 0) {
+        return null;
+    }
+    if (projects.length === 1) {
+        console.log(colors.muted(`  Using project: ${colors.primary(projects[0].name)}`));
+        return projects[0];
+    }
+    // Sort by last access
+    const sorted = [...projects].sort((a, b) => {
+        if (!a.lastAccess)
+            return 1;
+        if (!b.lastAccess)
+            return -1;
+        return new Date(b.lastAccess).getTime() - new Date(a.lastAccess).getTime();
+    });
+    console.log();
+    console.log(colors.primary.bold('  Select a project:'));
+    console.log();
+    sorted.forEach((project, index) => {
+        const num = colors.secondary(`  ${index + 1}.`);
+        const name = colors.highlight(project.name);
+        const indexed = project.indexed
+            ? colors.success(` ${icons.success}`)
+            : colors.muted(' (not indexed)');
+        const path = project.path ? colors.dim(` ${project.path}`) : '';
+        console.log(`${num} ${name}${indexed}${path}`);
+    });
+    console.log();
+    console.log(colors.muted('  Press number to select, Enter for first, or 0 to skip'));
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: true,
+        });
+        // Set up timeout for auto-select (5 seconds)
+        const timeout = setTimeout(() => {
+            console.log(colors.muted(`  Auto-selecting: ${sorted[0].name}`));
+            rl.close();
+            resolve(sorted[0]);
+        }, 5000);
+        rl.question(colors.primary(`  ${icons.arrow} `), (answer) => {
+            clearTimeout(timeout);
+            rl.close();
+            const trimmed = answer.trim();
+            if (!trimmed) {
+                // Default to first project
+                resolve(sorted[0]);
+                return;
+            }
+            if (trimmed === '0') {
+                resolve(null);
+                return;
+            }
+            const index = parseInt(trimmed) - 1;
+            if (index >= 0 && index < sorted.length) {
+                resolve(sorted[index]);
+            }
+            else {
+                console.log(colors.warning('  Invalid selection, using first project'));
+                resolve(sorted[0]);
+            }
+        });
+    });
+}
+/**
+ * Quick project switcher (for use during session)
+ */
+export async function quickProjectSwitch(currentProjectId) {
+    const projects = await fetchUserProjects();
+    if (projects.length === 0) {
+        console.log(colors.warning('  No projects found'));
+        return null;
+    }
+    // Filter out current project
+    const available = projects.filter(p => p.id !== currentProjectId);
+    if (available.length === 0) {
+        console.log(colors.muted('  No other projects available'));
+        return null;
+    }
+    return selectProject(available);
+}
+/**
+ * Display project info in a nice format
+ */
+export function displayProjectInfo(project) {
+    console.log();
+    console.log(colors.primary.bold(`  ${icons.lightning} ${project.name}`));
+    if (project.path) {
+        console.log(colors.muted(`  Path: ${project.path}`));
+    }
+    if (project.indexed) {
+        console.log(colors.success(`  Status: Indexed ${icons.success}`));
+    }
+    else {
+        console.log(colors.warning(`  Status: Not indexed (run /index)`));
+    }
+    console.log();
+}
+/**
+ * Search projects by name
+ */
+export function searchProjects(projects, query) {
+    const lower = query.toLowerCase();
+    return projects.filter(p => p.name.toLowerCase().includes(lower) ||
+        p.path?.toLowerCase().includes(lower));
+}
+//# sourceMappingURL=project-selector.js.map

package/dist/cli.js

@@ -12,7 +12,7 @@ import chalk from 'chalk';
 import ora from 'ora';
 import { writeFile } from 'fs/promises';
 // Import new CLI modules
-import { registerAnalyzerCommands, registerExportCommand, startInteractiveMode, initProject, } from './cli/index.js';
+import { registerAnalyzerCommands, registerExportCommand, registerProjectsCommand, registerAuthCommands, startInteractiveMode, initProject, } from './cli/index.js';
 const program = new Command();
 program
     .name('archicore')
@@ -29,6 +29,8 @@ program
 // Register modular commands
 registerAnalyzerCommands(program);
 registerExportCommand(program);
+registerProjectsCommand(program);
+registerAuthCommands(program);
 // Interactive mode (default when no command)
 program
     .command('chat', { isDefault: false })

package/dist/code-index/ast-parser.d.ts

@@ -8,7 +8,7 @@ export declare class ASTParser {
     private parseWithRegex;
     private inferTypeFromPattern;
     private extractVueScript;
-    parseProject(rootDir: string): Promise<Map<string, ASTNode>>;
+    parseProject(rootDir: string, progressCallback?: (current: number, total: number, file: string) => void): Promise<Map<string, ASTNode>>;
     private convertToASTNode;
     private extractName;
     extractLocation(node: Parser.SyntaxNode, filePath: string): Location;

package/dist/code-index/ast-parser.js

@@ -278,11 +278,17 @@ export class ASTParser {
             isTypeScript
         };
     }
-    async parseProject(rootDir) {
+    async parseProject(rootDir, progressCallback) {
         const files = await FileUtils.getAllFiles(rootDir);
         const asts = new Map();
-        Logger.progress(`Parsing ${files.length} files...`);
-        for (const file of files) {
+        const totalFiles = files.length;
+        Logger.progress(`Parsing ${totalFiles} files...`);
+        for (let i = 0; i < totalFiles; i++) {
+            const file = files[i];
+            // Emit progress
+            if (progressCallback) {
+                progressCallback(i + 1, totalFiles, file);
+            }
             const ast = await this.parseFile(file);
             if (ast) {
                 asts.set(file, ast);

package/dist/code-index/index.d.ts

@@ -21,7 +21,7 @@ export declare class CodeIndex {
     private graph;
     constructor(rootDir?: string);
     indexProject(rootDir?: string): Promise<void>;
-    parseProject(): Promise<Map<string, ASTNode>>;
+    parseProject(progressCallback?: (current: number, total: number, file: string) => void): Promise<Map<string, ASTNode>>;
     extractSymbols(asts: Map<string, ASTNode>): Map<string, Symbol>;
     buildDependencyGraph(asts: Map<string, ASTNode>, symbols: Map<string, Symbol>): DependencyGraph;
     getGraph(): DependencyGraph | null;

package/dist/code-index/index.js

@@ -35,8 +35,8 @@ export class CodeIndex {
         Logger.success('Project indexed successfully');
     }
     // Методы для использования в ProjectService
-    async parseProject() {
-        this.asts = await this.astParser.parseProject(this.rootDir);
+    async parseProject(progressCallback) {
+        this.asts = await this.astParser.parseProject(this.rootDir, progressCallback);
         return this.asts;
     }
     extractSymbols(asts) {

package/dist/github/github-service.js

@@ -103,7 +103,11 @@ export class GitHubService {
             state,
             allow_signup: 'true'
         });
-        return `https://github.com/login/oauth/authorize?${params.toString()}`;
+        const url = `https://github.com/login/oauth/authorize?${params.toString()}`;
+        Logger.info(`GitHub OAuth URL: ${url}`);
+        Logger.info(`Requested scopes: ${scopes.join(', ')}`);
+        Logger.info(`Redirect URI: ${this.redirectUri}`);
+        return url;
     }
     /**
      * Exchange authorization code for access token
@@ -126,6 +130,9 @@ export class GitHubService {
             throw new Error('Failed to exchange code for token');
         }
         const data = await response.json();
+        // Debug: log full token response (without sensitive data)
+        Logger.info(`GitHub token response keys: ${Object.keys(data).join(', ')}`);
+        Logger.info(`GitHub token response scope field: "${data.scope}" (type: ${typeof data.scope})`);
         if (data.error) {
             throw new Error(data.error_description || data.error);
         }

package/dist/orchestrator/index.js

@@ -11,6 +11,33 @@ import Anthropic from '@anthropic-ai/sdk';
 import OpenAI from 'openai';
 import { Logger } from '../utils/logger.js';
 import { DeepSeekOptimizer } from './deepseek-optimizer.js';
+/**
+ * Sanitize file paths to hide server directories
+ * Converts absolute paths to relative project paths
+ */
+function sanitizePath(filePath) {
+    if (!filePath)
+        return filePath;
+    // Common server path patterns to strip
+    const serverPatterns = [
+        /^\/scripts\/archicore\/.archicore\/projects\/[^/]+\//,
+        /^\/home\/[^/]+\/[^/]+\/.archicore\/projects\/[^/]+\//,
+        /^C:\\[^\\]+\\[^\\]+\\.archicore\\projects\\[^\\]+\\/i,
+        /^\/var\/[^/]+\/.archicore\/projects\/[^/]+\//,
+        /^.*\.archicore[\/\\]projects[\/\\][^\/\\]+[\/\\]/
+    ];
+    for (const pattern of serverPatterns) {
+        if (pattern.test(filePath)) {
+            return filePath.replace(pattern, '');
+        }
+    }
+    // If path contains .archicore/projects, strip everything before the actual project path
+    const archiMatch = filePath.match(/\.archicore[\/\\]projects[\/\\][^\/\\]+[\/\\](.+)/);
+    if (archiMatch) {
+        return archiMatch[1];
+    }
+    return filePath;
+}
 export class LLMOrchestrator {
     anthropic;
     openai;
@@ -291,7 +318,8 @@ ABSOLUTE RULES:
         if (context?.semanticMemory && context.semanticMemory.length > 0) {
             prompt += '\n\n###PROJECT FILES (ONLY reference these - nothing else exists)###\n';
             for (const result of context.semanticMemory.slice(0, 10)) {
-                prompt += `\nФайл: ${result.chunk.metadata.filePath}\n`;
+                const cleanPath = sanitizePath(result.chunk.metadata.filePath);
+                prompt += `\nФайл: ${cleanPath}\n`;
                 prompt += `${result.context}\n`;
             }
             prompt += '\n###END PROJECT FILES###';

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

@@ -15,7 +15,10 @@ export declare class EmbeddingService {
     isAvailable(): boolean;
     generateEmbedding(text: string): Promise<number[]>;
     private generateJinaEmbedding;
-    generateBatchEmbeddings(texts: string[]): Promise<number[][]>;
+    /**
+     * Generate embeddings for multiple texts - uses true batch API when available
+     */
+    generateBatchEmbeddings(texts: string[], progressCallback?: (current: number, total: number) => void): Promise<number[][]>;
     private generateOpenAIEmbedding;
     prepareCodeForEmbedding(code: string, context?: string): string;
     generateCodeEmbedding(code: string, metadata: {

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

@@ -96,23 +96,70 @@ export class EmbeddingService {
         const data = await response.json();
         return data.data[0].embedding;
     }
-    async generateBatchEmbeddings(texts) {
+    /**
+     * Generate embeddings for multiple texts - uses true batch API when available
+     */
+    async generateBatchEmbeddings(texts, progressCallback) {
         this.ensureInitialized();
         if (!this._isAvailable) {
             Logger.warn('Embedding service not available, skipping');
             return texts.map(() => new Array(this.embeddingDimension).fill(0));
         }
-        Logger.progress('Generating embeddings for ' + texts.length + ' texts...');
-        const embeddings = [];
-        const batchSize = 100;
-        for (let i = 0; i < texts.length; i += batchSize) {
-            const batch = texts.slice(i, i + batchSize);
-            const batchEmbeddings = await Promise.all(batch.map(text => this.generateEmbedding(text)));
-            embeddings.push(...batchEmbeddings);
-            Logger.debug('Processed ' + Math.min(i + batchSize, texts.length) + '/' + texts.length);
+        if (texts.length === 0)
+            return [];
+        Logger.progress(`Generating embeddings for ${texts.length} texts...`);
+        try {
+            // Use true batch API for Jina (much faster!)
+            if (this.config.provider === 'jina' && this.jinaApiKey) {
+                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));
+                    if (progressCallback) {
+                        progressCallback(Math.min(i + BATCH_SIZE, texts.length), texts.length);
+                    }
+                }
+                Logger.success(`Generated ${allEmbeddings.length} embeddings (batch mode)`);
+                return allEmbeddings;
+            }
+            // Fallback: parallel individual calls for OpenAI
+            const embeddings = [];
+            const CONCURRENT_LIMIT = 10; // Limit concurrent requests
+            for (let i = 0; i < texts.length; i += CONCURRENT_LIMIT) {
+                const batch = texts.slice(i, i + CONCURRENT_LIMIT);
+                const batchEmbeddings = await Promise.all(batch.map(text => this.generateEmbedding(text)));
+                embeddings.push(...batchEmbeddings);
+                if (progressCallback) {
+                    progressCallback(Math.min(i + CONCURRENT_LIMIT, texts.length), texts.length);
+                }
+            }
+            Logger.success(`Generated ${embeddings.length} embeddings`);
+            return embeddings;
+        }
+        catch (error) {
+            Logger.error('Batch embedding failed:', error);
+            // Return zero vectors on error
+            return texts.map(() => new Array(this.embeddingDimension).fill(0));
         }
-        Logger.success('Generated ' + embeddings.length + ' embeddings');
-        return embeddings;
     }
     async generateOpenAIEmbedding(text) {
         if (!this.openai)

package/dist/semantic-memory/index.d.ts

@@ -15,7 +15,7 @@ export declare class SemanticMemory {
     private vectorStore;
     constructor(embeddingConfig: EmbeddingConfig, vectorStoreConfig: VectorStoreConfig);
     initialize(): Promise<void>;
-    indexSymbols(symbols: Map<string, Symbol>, asts: Map<string, ASTNode>): Promise<void>;
+    indexSymbols(symbols: Map<string, Symbol>, asts: Map<string, ASTNode>, progressCallback?: (current: number, total: number) => void): Promise<void>;
     indexModules(asts: Map<string, ASTNode>): Promise<void>;
     searchByQuery(query: string, limit?: number): Promise<SemanticSearchResult[]>;
     searchSimilarCode(code: string, metadata?: {