archicore 0.1.0

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

@@ -0,0 +1,120 @@
+import OpenAI from 'openai';
+import { Logger } from '../utils/logger.js';
+export class EmbeddingService {
+    openai;
+    config;
+    initialized = false;
+    _isAvailable = false;
+    constructor(config) {
+        this.config = config;
+    }
+    ensureInitialized() {
+        if (this.initialized)
+            return;
+        this.initialized = true;
+        if (this.config.provider === 'none') {
+            Logger.warn('Embedding service disabled');
+            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');
+                    return;
+                }
+                this.openai = new OpenAI({
+                    apiKey,
+                    baseURL: 'https://api.deepseek.com'
+                });
+                this._isAvailable = true;
+            }
+            else {
+                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._isAvailable = true;
+            }
+        }
+        catch (error) {
+            Logger.warn('Embedding init failed: ' + error);
+        }
+    }
+    isAvailable() {
+        this.ensureInitialized();
+        return this._isAvailable;
+    }
+    async generateEmbedding(text) {
+        this.ensureInitialized();
+        if (!this._isAvailable)
+            return new Array(1536).fill(0);
+        try {
+            if (this.openai) {
+                return await this.generateOpenAIEmbedding(text);
+            }
+            return new Array(1536).fill(0);
+        }
+        catch (error) {
+            Logger.error('Failed to generate embedding', error);
+            return new Array(1536).fill(0);
+        }
+    }
+    async generateBatchEmbeddings(texts) {
+        this.ensureInitialized();
+        if (!this._isAvailable) {
+            Logger.warn('Embedding service not available, skipping');
+            return texts.map(() => new Array(1536).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);
+        }
+        Logger.success('Generated ' + embeddings.length + ' embeddings');
+        return embeddings;
+    }
+    async generateOpenAIEmbedding(text) {
+        if (!this.openai)
+            throw new Error('OpenAI client not initialized');
+        const response = await this.openai.embeddings.create({
+            model: this.config.model || 'text-embedding-3-small',
+            input: text.substring(0, 8000)
+        });
+        return response.data[0].embedding;
+    }
+    prepareCodeForEmbedding(code, context) {
+        let text = '';
+        if (context) {
+            text += 'Context: ' + context + '\n\n';
+        }
+        const cleaned = code
+            .replace(/\/\*[\s\S]*?\*\//g, '')
+            .replace(/\/\/.*/g, '')
+            .replace(/\s+/g, ' ')
+            .trim();
+        text += cleaned;
+        return text.substring(0, 8000);
+    }
+    async generateCodeEmbedding(code, metadata) {
+        let context = '';
+        if (metadata.filePath) {
+            context += 'File: ' + metadata.filePath + '\n';
+        }
+        if (metadata.symbolName) {
+            context += 'Symbol: ' + (metadata.symbolType || 'unknown') + ' ' + metadata.symbolName + '\n';
+        }
+        if (metadata.purpose) {
+            context += 'Purpose: ' + metadata.purpose + '\n';
+        }
+        const text = this.prepareCodeForEmbedding(code, context);
+        return await this.generateEmbedding(text);
+    }
+}
+//# sourceMappingURL=embedding-service.js.map

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

@@ -0,0 +1,45 @@
+/**
+ * Semantic Memory Module
+ *
+ * Семантическая память системы - векторная БД для понимания кода:
+ * - Генерация embeddings из кода
+ * - Хранение в векторной БД (Qdrant)
+ * - Семантический поиск по коду
+ * - Долговременная память о назначении компонентов
+ */
+import { EmbeddingService, EmbeddingConfig } from './embedding-service.js';
+import { VectorStore, VectorStoreConfig } from './vector-store.js';
+import { SemanticSearchResult, Symbol, ASTNode } from '../types/index.js';
+export declare class SemanticMemory {
+    private embeddingService;
+    private vectorStore;
+    constructor(embeddingConfig: EmbeddingConfig, vectorStoreConfig: VectorStoreConfig);
+    initialize(): Promise<void>;
+    indexSymbols(symbols: Map<string, Symbol>, asts: Map<string, ASTNode>): Promise<void>;
+    indexModules(asts: Map<string, ASTNode>): Promise<void>;
+    searchByQuery(query: string, limit?: number): Promise<SemanticSearchResult[]>;
+    searchSimilarCode(code: string, metadata?: {
+        filePath?: string;
+        symbolType?: string;
+    }, limit?: number): Promise<SemanticSearchResult[]>;
+    findRelatedComponents(componentName: string, limit?: number): Promise<SemanticSearchResult[]>;
+    findByPurpose(purpose: string, limit?: number): Promise<SemanticSearchResult[]>;
+    updateSymbol(symbol: Symbol, code: string): Promise<void>;
+    deleteFile(filePath: string): Promise<void>;
+    getStatistics(): Promise<{
+        name: string;
+        vectorsCount: number;
+        pointsCount: number | null | undefined;
+        status: "green" | "yellow" | "grey" | "red";
+    } | null>;
+    private createChunkFromSymbol;
+    private createChunkFromModule;
+    private extractFunctionChunks;
+    private createFunctionChunk;
+    private extractSymbolCode;
+    private extractModuleDescription;
+    private mapSymbolKindToChunkType;
+    private extractDomain;
+}
+export { EmbeddingService, VectorStore };
+//# sourceMappingURL=index.d.ts.map

package/dist/semantic-memory/index.js

@@ -0,0 +1,206 @@
+/**
+ * Semantic Memory Module
+ *
+ * Семантическая память системы - векторная БД для понимания кода:
+ * - Генерация embeddings из кода
+ * - Хранение в векторной БД (Qdrant)
+ * - Семантический поиск по коду
+ * - Долговременная память о назначении компонентов
+ */
+import { EmbeddingService } from './embedding-service.js';
+import { VectorStore } from './vector-store.js';
+import { Logger } from '../utils/logger.js';
+export class SemanticMemory {
+    embeddingService;
+    vectorStore;
+    constructor(embeddingConfig, vectorStoreConfig) {
+        this.embeddingService = new EmbeddingService(embeddingConfig);
+        this.vectorStore = new VectorStore(vectorStoreConfig);
+    }
+    async initialize() {
+        Logger.info('Initializing Semantic Memory...');
+        await this.vectorStore.initialize();
+        Logger.success('Semantic Memory initialized');
+    }
+    async indexSymbols(symbols, asts) {
+        Logger.progress('Indexing symbols into semantic memory...');
+        const chunks = [];
+        for (const symbol of symbols.values()) {
+            const ast = asts.get(symbol.filePath);
+            if (!ast)
+                continue;
+            const code = this.extractSymbolCode(symbol, ast);
+            const chunk = await this.createChunkFromSymbol(symbol, code);
+            chunks.push(chunk);
+        }
+        await this.vectorStore.upsertChunks(chunks);
+        Logger.success(`Indexed ${chunks.length} symbols`);
+    }
+    async indexModules(asts) {
+        Logger.progress('Indexing modules into semantic memory...');
+        const chunks = [];
+        for (const [filePath, ast] of asts) {
+            const moduleChunk = await this.createChunkFromModule(filePath, ast);
+            chunks.push(moduleChunk);
+            const functionChunks = await this.extractFunctionChunks(filePath, ast);
+            chunks.push(...functionChunks);
+        }
+        await this.vectorStore.upsertChunks(chunks);
+        Logger.success(`Indexed ${chunks.length} module chunks`);
+    }
+    async searchByQuery(query, limit = 10) {
+        const queryEmbedding = await this.embeddingService.generateEmbedding(query);
+        return await this.vectorStore.search(queryEmbedding, limit);
+    }
+    async searchSimilarCode(code, metadata, limit = 10) {
+        const embedding = await this.embeddingService.generateCodeEmbedding(code, metadata || {});
+        return await this.vectorStore.search(embedding, limit);
+    }
+    async findRelatedComponents(componentName, limit = 5) {
+        const query = `Find components related to ${componentName}`;
+        return await this.searchByQuery(query, limit);
+    }
+    async findByPurpose(purpose, limit = 5) {
+        const query = `Code that handles ${purpose}`;
+        return await this.searchByQuery(query, limit);
+    }
+    async updateSymbol(symbol, code) {
+        const chunk = await this.createChunkFromSymbol(symbol, code);
+        await this.vectorStore.upsertChunk(chunk);
+        Logger.success(`Updated symbol: ${symbol.name}`);
+    }
+    async deleteFile(filePath) {
+        await this.vectorStore.deleteByFilter({
+            'metadata.filePath': filePath
+        });
+        Logger.success(`Deleted chunks for file: ${filePath}`);
+    }
+    async getStatistics() {
+        return await this.vectorStore.getCollectionInfo();
+    }
+    async createChunkFromSymbol(symbol, code) {
+        const embedding = await this.embeddingService.generateCodeEmbedding(code, {
+            filePath: symbol.filePath,
+            symbolName: symbol.name,
+            symbolType: symbol.kind
+        });
+        const metadata = {
+            filePath: symbol.filePath,
+            startLine: symbol.location.startLine,
+            endLine: symbol.location.endLine,
+            type: this.mapSymbolKindToChunkType(symbol.kind),
+            symbols: [symbol.name],
+            tags: [symbol.kind, this.extractDomain(symbol.filePath)]
+        };
+        return {
+            id: symbol.id,
+            content: code,
+            embedding,
+            metadata
+        };
+    }
+    async createChunkFromModule(filePath, ast) {
+        const moduleDescription = this.extractModuleDescription(ast);
+        const embedding = await this.embeddingService.generateCodeEmbedding(moduleDescription, { filePath });
+        const metadata = {
+            filePath,
+            startLine: 0,
+            endLine: ast.endLine,
+            type: 'module',
+            symbols: [],
+            tags: [this.extractDomain(filePath)]
+        };
+        return {
+            id: `module:${filePath}`,
+            content: moduleDescription,
+            embedding,
+            metadata
+        };
+    }
+    async extractFunctionChunks(filePath, ast) {
+        const chunks = [];
+        const extractFunctions = async (node) => {
+            if (node.type === 'function_declaration' ||
+                node.type === 'method_definition') {
+                chunks.push(await this.createFunctionChunk(filePath, node));
+            }
+            for (const child of node.children) {
+                await extractFunctions(child);
+            }
+        };
+        await extractFunctions(ast);
+        return chunks;
+    }
+    async createFunctionChunk(filePath, node) {
+        const code = node.metadata.text;
+        const embedding = await this.embeddingService.generateCodeEmbedding(code, {
+            filePath,
+            symbolName: node.name,
+            symbolType: 'function'
+        });
+        const metadata = {
+            filePath,
+            startLine: node.startLine,
+            endLine: node.endLine,
+            type: 'function',
+            symbols: [node.name],
+            tags: ['function', this.extractDomain(filePath)]
+        };
+        return {
+            id: `${filePath}:${node.name}:${node.startLine}`,
+            content: code,
+            embedding,
+            metadata
+        };
+    }
+    extractSymbolCode(symbol, ast) {
+        const findNode = (node) => {
+            if (node.startLine === symbol.location.startLine &&
+                node.name === symbol.name) {
+                return node;
+            }
+            for (const child of node.children) {
+                const found = findNode(child);
+                if (found)
+                    return found;
+            }
+            return null;
+        };
+        const node = findNode(ast);
+        return node?.metadata.text || '';
+    }
+    extractModuleDescription(ast) {
+        const comments = [];
+        const exports = [];
+        const extract = (node) => {
+            if (node.type === 'comment') {
+                comments.push(node.metadata.text);
+            }
+            if (node.type === 'export_statement') {
+                exports.push(node.name);
+            }
+            for (const child of node.children) {
+                extract(child);
+            }
+        };
+        extract(ast);
+        let description = comments.join('\n');
+        if (exports.length > 0) {
+            description += `\nExports: ${exports.join(', ')}`;
+        }
+        return description || 'Module without description';
+    }
+    mapSymbolKindToChunkType(kind) {
+        if (kind === 'function')
+            return 'function';
+        if (kind === 'class')
+            return 'class';
+        return 'module';
+    }
+    extractDomain(filePath) {
+        const parts = filePath.split('/');
+        return parts[parts.length - 2] || 'unknown';
+    }
+}
+export { EmbeddingService, VectorStore };
+//# sourceMappingURL=index.js.map

package/dist/semantic-memory/vector-store.d.ts

@@ -0,0 +1,27 @@
+import { SemanticChunk, SemanticSearchResult } from '../types/index.js';
+export interface VectorStoreConfig {
+    url: string;
+    apiKey?: string;
+    collectionName: string;
+}
+export declare class VectorStore {
+    private client;
+    private collectionName;
+    private _isAvailable;
+    constructor(config: VectorStoreConfig);
+    isAvailable(): boolean;
+    initialize(vectorSize?: number): Promise<void>;
+    upsertChunk(chunk: SemanticChunk): Promise<void>;
+    upsertChunks(chunks: SemanticChunk[]): Promise<void>;
+    search(query: number[], limit?: number, filter?: Record<string, unknown>): Promise<SemanticSearchResult[]>;
+    deleteChunk(id: string): Promise<void>;
+    deleteByFilter(filter: Record<string, unknown>): Promise<void>;
+    getCollectionInfo(): Promise<{
+        name: string;
+        vectorsCount: number;
+        pointsCount: number | null | undefined;
+        status: "green" | "yellow" | "grey" | "red";
+    } | null>;
+    private extractContext;
+}
+//# sourceMappingURL=vector-store.d.ts.map

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

@@ -0,0 +1,166 @@
+import { QdrantClient } from '@qdrant/js-client-rest';
+import { Logger } from '../utils/logger.js';
+export class VectorStore {
+    client;
+    collectionName;
+    _isAvailable = false;
+    constructor(config) {
+        this.client = new QdrantClient({
+            url: config.url,
+            apiKey: config.apiKey
+        });
+        this.collectionName = config.collectionName;
+    }
+    isAvailable() {
+        return this._isAvailable;
+    }
+    async initialize(vectorSize = 1536) {
+        try {
+            const collections = await this.client.getCollections();
+            const exists = collections.collections.some(c => c.name === this.collectionName);
+            if (!exists) {
+                await this.client.createCollection(this.collectionName, {
+                    vectors: {
+                        size: vectorSize,
+                        distance: 'Cosine'
+                    }
+                });
+                Logger.success(`Created collection: ${this.collectionName}`);
+            }
+            else {
+                Logger.info(`Collection already exists: ${this.collectionName}`);
+            }
+            this._isAvailable = true;
+        }
+        catch (error) {
+            Logger.warn("Vector store not available - Qdrant not running");
+            this._isAvailable = false;
+        }
+    }
+    async upsertChunk(chunk) {
+        if (!this._isAvailable)
+            return;
+        try {
+            await this.client.upsert(this.collectionName, {
+                points: [
+                    {
+                        id: chunk.id,
+                        vector: chunk.embedding,
+                        payload: {
+                            content: chunk.content,
+                            metadata: chunk.metadata
+                        }
+                    }
+                ]
+            });
+        }
+        catch (error) {
+            Logger.error(`Failed to upsert chunk ${chunk.id}`, error);
+        }
+    }
+    async upsertChunks(chunks) {
+        if (!this._isAvailable) {
+            Logger.warn('Vector store not available, skipping upsert');
+            return;
+        }
+        Logger.progress(`Upserting ${chunks.length} chunks...`);
+        const batchSize = 100;
+        for (let i = 0; i < chunks.length; i += batchSize) {
+            const batch = chunks.slice(i, i + batchSize);
+            await this.client.upsert(this.collectionName, {
+                points: batch.map(chunk => ({
+                    id: chunk.id,
+                    vector: chunk.embedding,
+                    payload: {
+                        content: chunk.content,
+                        metadata: chunk.metadata
+                    }
+                }))
+            });
+            Logger.debug(`Upserted ${Math.min(i + batchSize, chunks.length)}/${chunks.length}`);
+        }
+        Logger.success(`Upserted ${chunks.length} chunks successfully`);
+    }
+    async search(query, limit = 10, filter) {
+        if (!this._isAvailable)
+            return [];
+        try {
+            const response = await this.client.search(this.collectionName, {
+                vector: query,
+                limit,
+                filter,
+                with_payload: true
+            });
+            return response.map(point => ({
+                chunk: {
+                    id: String(point.id),
+                    content: point.payload?.content || '',
+                    embedding: [],
+                    metadata: point.payload?.metadata || {
+                        filePath: '',
+                        startLine: 0,
+                        endLine: 0,
+                        type: 'module',
+                        symbols: [],
+                        tags: []
+                    }
+                },
+                score: point.score,
+                context: this.extractContext(point.payload?.content)
+            }));
+        }
+        catch (error) {
+            Logger.error('Search failed', error);
+            return [];
+        }
+    }
+    async deleteChunk(id) {
+        if (!this._isAvailable)
+            return;
+        try {
+            await this.client.delete(this.collectionName, {
+                points: [id]
+            });
+        }
+        catch (error) {
+            Logger.error(`Failed to delete chunk ${id}`, error);
+        }
+    }
+    async deleteByFilter(filter) {
+        if (!this._isAvailable)
+            return;
+        try {
+            await this.client.delete(this.collectionName, {
+                filter
+            });
+            Logger.success('Deleted chunks by filter');
+        }
+        catch (error) {
+            Logger.error('Failed to delete by filter', error);
+        }
+    }
+    async getCollectionInfo() {
+        if (!this._isAvailable)
+            return null;
+        try {
+            const info = await this.client.getCollection(this.collectionName);
+            return {
+                name: this.collectionName,
+                vectorsCount: info.indexed_vectors_count ?? 0,
+                pointsCount: info.points_count,
+                status: info.status
+            };
+        }
+        catch (error) {
+            Logger.error('Failed to get collection info', error);
+            return null;
+        }
+    }
+    extractContext(content, contextLength = 200) {
+        if (content.length <= contextLength) {
+            return content;
+        }
+        return content.substring(0, contextLength) + '...';
+    }
+}
+//# sourceMappingURL=vector-store.js.map

package/dist/server/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * ArchiCore Web Server
+ *
+ * HTTP API для Architecture Digital Twin:
+ * - Индексация проектов
+ * - Визуализация архитектуры
+ * - Анализ влияния изменений
+ * - Симуляция изменений
+ */
+import 'dotenv/config';
+import express from 'express';
+export interface ServerConfig {
+    port: number;
+    host?: string;
+}
+export declare class ArchiCoreServer {
+    private app;
+    private server;
+    private config;
+    constructor(config: ServerConfig);
+    private setupMiddleware;
+    private setupRoutes;
+    private setupErrorHandling;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getApp(): express.Application;
+}
+//# sourceMappingURL=index.d.ts.map