archicore 0.1.7 → 0.1.8

package/dist/cli/commands/interactive.js

@@ -126,6 +126,8 @@ export async function startInteractiveMode() {
         output: process.stdout,
         terminal: true,
     });
+    // Keep the process alive
+    rl.ref?.();
     const prompt = () => {
         const prefix = state.projectName
             ? colors.muted(`[${state.projectName}] `)

package/dist/cli/ui/spinner.js

@@ -10,6 +10,7 @@ export class Spinner {
             text: colors.muted(text),
             spinner: 'dots',
             color: 'magenta',
+            discardStdin: false, // Important: don't interfere with stdin (fixes CLI exit bug on Linux)
         });
     }
     start(text) {

package/dist/index.js

@@ -22,7 +22,11 @@ export class AIArhitector {
     constructor(config) {
         this.config = config;
         this.codeIndex = new CodeIndex();
-        this.semanticMemory = new SemanticMemory({ provider: config.llm.provider }, config.vectorStore);
+        // Determine embedding provider: Jina (free) > OpenAI
+        const embeddingProvider = process.env.JINA_API_KEY ? 'jina'
+            : process.env.OPENAI_API_KEY ? 'openai'
+                : 'none';
+        this.semanticMemory = new SemanticMemory({ provider: embeddingProvider }, config.vectorStore);
         this.architecture = new ArchitectureKnowledge(config.architectureConfigPath || '.aiarhitector/architecture.json');
         this.impactEngine = new ImpactEngine();
         this.orchestrator = new LLMOrchestrator(config.llm);

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

@@ -1,5 +1,5 @@
 export interface EmbeddingConfig {
-    provider: 'anthropic' | 'openai' | 'deepseek' | 'none';
+    provider: 'openai' | 'jina' | 'none';
     model?: string;
 }
 export declare class EmbeddingService {
@@ -7,10 +7,14 @@ export declare class EmbeddingService {
     private config;
     private initialized;
     private _isAvailable;
+    private jinaApiKey?;
+    private embeddingDimension;
     constructor(config: EmbeddingConfig);
+    getEmbeddingDimension(): number;
     private ensureInitialized;
     isAvailable(): boolean;
     generateEmbedding(text: string): Promise<number[]>;
+    private generateJinaEmbedding;
     generateBatchEmbeddings(texts: string[]): Promise<number[][]>;
     private generateOpenAIEmbedding;
     prepareCodeForEmbedding(code: string, context?: string): string;

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

@@ -5,9 +5,14 @@ export class EmbeddingService {
     config;
     initialized = false;
     _isAvailable = false;
+    jinaApiKey;
+    embeddingDimension = 1024; // Jina default, OpenAI small = 1536
     constructor(config) {
         this.config = config;
     }
+    getEmbeddingDimension() {
+        return this.embeddingDimension;
+    }
     ensureInitialized() {
         if (this.initialized)
             return;
@@ -17,26 +22,29 @@ export class EmbeddingService {
             return;
         }
         try {
-            if (this.config.provider === 'deepseek') {
-                const apiKey = process.env.DEEPSEEK_API_KEY;
-                if (!apiKey) {
-                    Logger.warn('DEEPSEEK_API_KEY not set - semantic search disabled');
+            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');
+                    Logger.info('Get free API key at: https://jina.ai/embeddings/');
                     return;
                 }
-                this.openai = new OpenAI({
-                    apiKey,
-                    baseURL: 'https://api.deepseek.com'
-                });
+                this.embeddingDimension = 1024;
                 this._isAvailable = true;
+                Logger.success('Jina AI embeddings enabled');
             }
             else {
+                // OpenAI embeddings
                 const apiKey = process.env.OPENAI_API_KEY;
                 if (!apiKey) {
                     Logger.warn('OPENAI_API_KEY not set - semantic search disabled');
                     return;
                 }
                 this.openai = new OpenAI({ apiKey });
+                this.embeddingDimension = 1536;
                 this._isAvailable = true;
+                Logger.success('OpenAI embeddings enabled');
             }
         }
         catch (error) {
@@ -50,23 +58,49 @@ export class EmbeddingService {
     async generateEmbedding(text) {
         this.ensureInitialized();
         if (!this._isAvailable)
-            return new Array(1536).fill(0);
+            return new Array(this.embeddingDimension).fill(0);
         try {
-            if (this.openai) {
+            if (this.config.provider === 'jina' && this.jinaApiKey) {
+                return await this.generateJinaEmbedding(text);
+            }
+            else if (this.openai) {
                 return await this.generateOpenAIEmbedding(text);
             }
-            return new Array(1536).fill(0);
+            return new Array(this.embeddingDimension).fill(0);
         }
         catch (error) {
             Logger.error('Failed to generate embedding', error);
-            return new Array(1536).fill(0);
+            return new Array(this.embeddingDimension).fill(0);
+        }
+    }
+    async generateJinaEmbedding(text) {
+        if (!this.jinaApiKey)
+            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}`);
         }
+        const data = await response.json();
+        return data.data[0].embedding;
     }
     async generateBatchEmbeddings(texts) {
         this.ensureInitialized();
         if (!this._isAvailable) {
             Logger.warn('Embedding service not available, skipping');
-            return texts.map(() => new Array(1536).fill(0));
+            return texts.map(() => new Array(this.embeddingDimension).fill(0));
         }
         Logger.progress('Generating embeddings for ' + texts.length + ' texts...');
         const embeddings = [];

package/dist/semantic-memory/index.js

@@ -19,8 +19,10 @@ export class SemanticMemory {
     }
     async initialize() {
         Logger.info('Initializing Semantic Memory...');
-        await this.vectorStore.initialize();
-        Logger.success('Semantic Memory initialized');
+        // Pass the correct embedding dimension based on provider (Jina=1024, OpenAI=1536)
+        const dimension = this.embeddingService.getEmbeddingDimension();
+        await this.vectorStore.initialize(dimension);
+        Logger.success(`Semantic Memory initialized (dimension: ${dimension})`);
     }
     async indexSymbols(symbols, asts) {
         Logger.progress('Indexing symbols into semantic memory...');

package/dist/semantic-memory/vector-store.js

@@ -1,5 +1,15 @@
 import { QdrantClient } from '@qdrant/js-client-rest';
+import { createHash } from 'crypto';
 import { Logger } from '../utils/logger.js';
+/**
+ * Convert string ID to UUID format for Qdrant
+ * Uses MD5 hash to create deterministic UUID from any string
+ */
+function stringToUuid(str) {
+    const hash = createHash('md5').update(str).digest('hex');
+    // Format as UUID: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+    return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-${hash.slice(12, 16)}-${hash.slice(16, 20)}-${hash.slice(20, 32)}`;
+}
 export class VectorStore {
     client;
     collectionName;
@@ -44,9 +54,10 @@ export class VectorStore {
             await this.client.upsert(this.collectionName, {
                 points: [
                     {
-                        id: chunk.id,
+                        id: stringToUuid(chunk.id), // Convert string ID to UUID
                         vector: chunk.embedding,
                         payload: {
+                            originalId: chunk.id, // Store original ID
                             content: chunk.content,
                             metadata: chunk.metadata
                         }
@@ -69,9 +80,10 @@ export class VectorStore {
             const batch = chunks.slice(i, i + batchSize);
             await this.client.upsert(this.collectionName, {
                 points: batch.map(chunk => ({
-                    id: chunk.id,
+                    id: stringToUuid(chunk.id), // Convert string ID to UUID
                     vector: chunk.embedding,
                     payload: {
+                        originalId: chunk.id, // Store original ID
                         content: chunk.content,
                         metadata: chunk.metadata
                     }
@@ -93,7 +105,7 @@ export class VectorStore {
             });
             return response.map(point => ({
                 chunk: {
-                    id: String(point.id),
+                    id: point.payload?.originalId || String(point.id), // Use original ID
                     content: point.payload?.content || '',
                     embedding: [],
                     metadata: point.payload?.metadata || {
@@ -119,7 +131,7 @@ export class VectorStore {
             return;
         try {
             await this.client.delete(this.collectionName, {
-                points: [id]
+                points: [stringToUuid(id)] // Convert to UUID
             });
         }
         catch (error) {

package/dist/server/routes/api.js

@@ -109,6 +109,22 @@ apiRouter.post('/projects/:id/index', authMiddleware, checkProjectAccess, async
         res.status(500).json({ error: 'Failed to index project' });
     }
 });
+/**
+ * POST /api/projects/:id/reindex-embeddings
+ * Переиндексировать embeddings из сохранённых данных
+ * Используется когда добавили JINA_API_KEY или OPENAI_API_KEY
+ */
+apiRouter.post('/projects/:id/reindex-embeddings', authMiddleware, checkProjectAccess, async (req, res) => {
+    try {
+        const { id } = req.params;
+        const result = await projectService.reindexEmbeddings(id);
+        res.json(result);
+    }
+    catch (error) {
+        Logger.error('Failed to reindex embeddings:', error);
+        res.status(500).json({ error: String(error) });
+    }
+});
 /**
  * POST /api/projects/:id/upload-index
  * Загрузить индексированные данные с CLI

package/dist/server/services/project-service.d.ts

@@ -105,6 +105,14 @@ export declare class ProjectService {
      * Загрузить сохранённые индексные данные с диска
      */
     loadIndexedDataFromDisk(projectId: string): Promise<boolean>;
+    /**
+     * Переиндексировать embeddings из сохранённых данных
+     * Используется когда добавили API ключ для embeddings
+     */
+    reindexEmbeddings(projectId: string): Promise<{
+        success: boolean;
+        indexed: number;
+    }>;
     /**
      * Получить метрики кода
      */

package/dist/server/services/project-service.js

@@ -121,24 +121,33 @@ export class ProjectService {
             maxTokens: 4096,
             baseURL: 'https://api.deepseek.com'
         };
-        // SemanticMemory опционален - DeepSeek не поддерживает embeddings
+        // SemanticMemory - поддержка Jina (бесплатно) или OpenAI
         let semanticMemory = null;
-        // Только если есть OpenAI ключ - используем embeddings
-        if (process.env.OPENAI_API_KEY) {
+        const vectorStoreConfig = {
+            url: process.env.QDRANT_URL || 'http://localhost:6333',
+            apiKey: process.env.QDRANT_API_KEY,
+            collectionName: `archicore_${projectId.replace(/-/g, '_')}`
+        };
+        // Приоритет: JINA_API_KEY (бесплатный) > OPENAI_API_KEY
+        if (process.env.JINA_API_KEY) {
+            const embeddingConfig = {
+                provider: 'jina',
+                model: 'jina-embeddings-v3'
+            };
+            semanticMemory = new SemanticMemory(embeddingConfig, vectorStoreConfig);
+            Logger.info('SemanticMemory enabled (Jina AI embeddings - free)');
+        }
+        else if (process.env.OPENAI_API_KEY) {
             const embeddingConfig = {
                 provider: 'openai',
                 model: 'text-embedding-3-small'
             };
-            const vectorStoreConfig = {
-                url: process.env.QDRANT_URL || 'http://localhost:6333',
-                apiKey: process.env.QDRANT_API_KEY,
-                collectionName: `archicore_${projectId.replace(/-/g, '_')}`
-            };
             semanticMemory = new SemanticMemory(embeddingConfig, vectorStoreConfig);
             Logger.info('SemanticMemory enabled (OpenAI embeddings)');
         }
         else {
-            Logger.warn('SemanticMemory disabled - no OPENAI_API_KEY. Semantic search unavailable.');
+            Logger.warn('SemanticMemory disabled - no JINA_API_KEY or OPENAI_API_KEY');
+            Logger.info('Get free Jina API key at: https://jina.ai/embeddings/');
         }
         const data = {
             codeIndex: new CodeIndex(project.path),
@@ -547,6 +556,33 @@ export class ProjectService {
             return false;
         }
     }
+    /**
+     * Переиндексировать embeddings из сохранённых данных
+     * Используется когда добавили API ключ для embeddings
+     */
+    async reindexEmbeddings(projectId) {
+        const project = this.projects.get(projectId);
+        if (!project) {
+            throw new Error(`Project not found: ${projectId}`);
+        }
+        // Загружаем данные с диска если ещё не загружены
+        const loaded = await this.loadIndexedDataFromDisk(projectId);
+        if (!loaded) {
+            throw new Error('No indexed data found. Please index project first via CLI.');
+        }
+        const data = await this.getProjectData(projectId);
+        if (!data.symbols || !data.asts) {
+            throw new Error('No symbols/ASTs found. Please re-index via CLI.');
+        }
+        if (!data.semanticMemory) {
+            throw new Error('SemanticMemory not available. Check JINA_API_KEY or OPENAI_API_KEY.');
+        }
+        Logger.progress(`Re-indexing embeddings for: ${project.name}`);
+        await data.semanticMemory.initialize();
+        await data.semanticMemory.indexSymbols(data.symbols, data.asts);
+        Logger.success(`Embeddings indexed: ${data.symbols.size} symbols`);
+        return { success: true, indexed: data.symbols.size };
+    }
     /**
      * Получить метрики кода
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archicore",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "AI Software Architect - code analysis, impact prediction, semantic search",
   "main": "dist/index.js",
   "type": "module",