archicore 0.1.6 → 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}] `)
@@ -367,7 +369,64 @@ async function handleIndexCommand() {
         });
         if (!response.ok) {
             const errorData = await response.json().catch(() => ({}));
-            throw new Error(errorData.error || 'Upload failed');
+            // If access denied, re-register project with current user
+            if (response.status === 403 && errorData.error?.includes('Access denied')) {
+                indexSpinner.update('Re-registering project with current user...');
+                // Clear old project ID and re-register
+                const reRegisterResponse = await fetch(`${config.serverUrl}/api/projects`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${config.accessToken}`,
+                    },
+                    body: JSON.stringify({ name: state.projectName, path: state.projectPath }),
+                });
+                if (reRegisterResponse.ok) {
+                    const reData = await reRegisterResponse.json();
+                    state.projectId = reData.id || reData.project?.id;
+                    // Retry upload with new project ID
+                    indexSpinner.update('Uploading to server...');
+                    const retryResponse = await fetch(`${config.serverUrl}/api/projects/${state.projectId}/upload-index`, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'Authorization': `Bearer ${config.accessToken}`,
+                        },
+                        body: JSON.stringify({
+                            asts: astsArray,
+                            symbols: symbolsArray,
+                            graph: graphData,
+                            fileContents,
+                            statistics: {
+                                totalFiles: asts.size,
+                                totalSymbols: symbols.size,
+                            },
+                        }),
+                    });
+                    if (!retryResponse.ok) {
+                        throw new Error('Upload failed after re-registration');
+                    }
+                    // Use retry response for data
+                    const retryData = await retryResponse.json();
+                    indexSpinner.succeed('Project re-registered and indexed');
+                    printKeyValue('Files', String(retryData.statistics?.filesCount || asts.size));
+                    printKeyValue('Symbols', String(retryData.statistics?.symbolsCount || symbols.size));
+                    // Update local config with new project ID
+                    const localProjectRetry = await getLocalProject(state.projectPath);
+                    if (localProjectRetry && state.projectId) {
+                        localProjectRetry.id = state.projectId;
+                        localProjectRetry.indexed = true;
+                        await fs.writeFile(pathModule.default.join(state.projectPath, '.archicore', 'project.json'), JSON.stringify(localProjectRetry, null, 2));
+                    }
+                    return; // Exit early - already handled
+                }
+                else {
+                    throw new Error('Failed to re-register project');
+                }
+            }
+            else {
+                throw new Error(errorData.error || 'Upload failed');
+            }
         }
         const data = await response.json();
         indexSpinner.succeed('Project indexed and uploaded');

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

@@ -78,12 +78,17 @@ apiRouter.get('/projects/:id', authMiddleware, async (req, res) => {
 async function checkProjectAccess(req, res, next) {
     const { id } = req.params;
     const userId = getUserId(req);
+    Logger.info(`checkProjectAccess: projectId=${id}, userId=${userId}`);
     if (!userId) {
         res.status(401).json({ error: 'Authentication required' });
         return;
     }
     const isOwner = await projectService.isProjectOwner(id, userId);
+    Logger.info(`checkProjectAccess: isOwner=${isOwner}`);
     if (!isOwner) {
+        // Log project details for debugging
+        const project = await projectService.getProject(id);
+        Logger.warn(`Access denied: userId=${userId}, project.ownerId=${project?.ownerId}`);
         res.status(403).json({ error: 'Access denied to this project' });
         return;
     }
@@ -104,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.6",
+  "version": "0.1.8",
   "description": "AI Software Architect - code analysis, impact prediction, semantic search",
   "main": "dist/index.js",
   "type": "module",