archicore 0.3.1 → 0.3.2

package/dist/code-index/index.js

@@ -10,20 +10,64 @@
 import { ASTParser } from './ast-parser.js';
 import { SymbolExtractor } from './symbol-extractor.js';
 import { DependencyGraphBuilder } from './dependency-graph.js';
+import { SourceMapExtractor } from './source-map-extractor.js';
 import { Logger } from '../utils/logger.js';
 export class CodeIndex {
     astParser;
     symbolExtractor;
     graphBuilder;
+    sourceMapExtractor;
     rootDir;
     asts = new Map();
     symbols = new Map();
     graph = null;
+    virtualFiles = [];
     constructor(rootDir) {
         this.rootDir = rootDir || process.cwd();
         this.astParser = new ASTParser();
         this.symbolExtractor = new SymbolExtractor();
         this.graphBuilder = new DependencyGraphBuilder();
+        this.sourceMapExtractor = new SourceMapExtractor();
+    }
+    /**
+     * Проверяет, является ли проект bundled (содержит source maps)
+     */
+    async isBundledProject() {
+        return this.sourceMapExtractor.isBundledProject(this.rootDir);
+    }
+    /**
+     * Извлекает исходный код из source maps (для bundled проектов)
+     */
+    async extractFromSourceMaps() {
+        const result = await this.sourceMapExtractor.extractFromProject(this.rootDir);
+        this.virtualFiles = result.files;
+        return result;
+    }
+    /**
+     * Парсит виртуальные файлы из source maps
+     */
+    parseVirtualFiles(files, progressCallback) {
+        const asts = new Map();
+        const totalFiles = files.length;
+        Logger.progress(`Parsing ${totalFiles} virtual files from source maps...`);
+        for (let i = 0; i < totalFiles; i++) {
+            const file = files[i];
+            if (progressCallback) {
+                progressCallback(i + 1, totalFiles, file.path);
+            }
+            const ast = this.astParser.parseContent(file.content, file.path);
+            if (ast) {
+                asts.set(file.path, ast);
+            }
+        }
+        Logger.success(`Parsed ${asts.size} virtual files successfully`);
+        return asts;
+    }
+    /**
+     * Получает виртуальные файлы (для передачи на сервер)
+     */
+    getVirtualFiles() {
+        return this.virtualFiles;
     }
     async indexProject(rootDir) {
         const dir = rootDir || this.rootDir;
@@ -120,5 +164,5 @@ export class CodeIndex {
         return counts;
     }
 }
-export { ASTParser, SymbolExtractor, DependencyGraphBuilder };
+export { ASTParser, SymbolExtractor, DependencyGraphBuilder, SourceMapExtractor };
 //# sourceMappingURL=index.js.map

package/dist/code-index/source-map-extractor.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Source Map Extractor
+ *
+ * Извлекает оригинальный исходный код из source map файлов.
+ * Позволяет индексировать bundled/minified проекты.
+ */
+export interface VirtualFile {
+    /** Виртуальный путь файла (восстановленный из source map) */
+    path: string;
+    /** Содержимое файла */
+    content: string;
+    /** Оригинальный source map файл */
+    sourceMapPath: string;
+}
+export interface SourceMapData {
+    version: number;
+    file?: string;
+    sourceRoot?: string;
+    sources: string[];
+    sourcesContent?: (string | null)[];
+    names?: string[];
+    mappings: string;
+}
+export interface ExtractionResult {
+    /** Извлечённые виртуальные файлы */
+    files: VirtualFile[];
+    /** Статистика извлечения */
+    stats: {
+        sourceMapCount: number;
+        totalSources: number;
+        extractedFiles: number;
+        skippedFiles: number;
+    };
+}
+export declare class SourceMapExtractor {
+    private processedMaps;
+    /**
+     * Проверяет, является ли проект bundled (содержит source maps)
+     */
+    isBundledProject(projectPath: string): Promise<boolean>;
+    /**
+     * Находит все .map файлы в проекте
+     */
+    findSourceMaps(projectPath: string): Promise<string[]>;
+    /**
+     * Извлекает все исходные файлы из source maps проекта
+     */
+    extractFromProject(projectPath: string): Promise<ExtractionResult>;
+    /**
+     * Извлекает исходные файлы из одного source map
+     */
+    extractFromSourceMap(mapPath: string): Promise<VirtualFile[]>;
+    /**
+     * Нормализует путь из source map
+     * webpack://project/./src/file.vue → src/file.vue
+     */
+    private normalizePath;
+    /**
+     * Проверяет, нужно ли пропустить этот источник
+     */
+    private shouldSkipSource;
+    /**
+     * Проверяет, является ли файл исходным кодом
+     */
+    private isSourceFile;
+    /**
+     * Очищает кэш обработанных map файлов
+     */
+    clearCache(): void;
+}
+//# sourceMappingURL=source-map-extractor.d.ts.map

package/dist/code-index/source-map-extractor.js

@@ -0,0 +1,194 @@
+/**
+ * Source Map Extractor
+ *
+ * Извлекает оригинальный исходный код из source map файлов.
+ * Позволяет индексировать bundled/minified проекты.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { Logger } from '../utils/logger.js';
+export class SourceMapExtractor {
+    processedMaps = new Set();
+    /**
+     * Проверяет, является ли проект bundled (содержит source maps)
+     */
+    async isBundledProject(projectPath) {
+        const mapFiles = await this.findSourceMaps(projectPath);
+        return mapFiles.length > 0;
+    }
+    /**
+     * Находит все .map файлы в проекте
+     */
+    async findSourceMaps(projectPath) {
+        const mapFiles = [];
+        const scanDir = async (dir, depth = 0) => {
+            // Ограничиваем глубину сканирования
+            if (depth > 5)
+                return;
+            try {
+                const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        // Пропускаем node_modules и скрытые папки
+                        if (entry.name === 'node_modules' || entry.name.startsWith('.')) {
+                            continue;
+                        }
+                        await scanDir(fullPath, depth + 1);
+                    }
+                    else if (entry.isFile() && entry.name.endsWith('.js.map')) {
+                        mapFiles.push(fullPath);
+                    }
+                }
+            }
+            catch {
+                // Игнорируем ошибки доступа
+            }
+        };
+        await scanDir(projectPath);
+        return mapFiles;
+    }
+    /**
+     * Извлекает все исходные файлы из source maps проекта
+     */
+    async extractFromProject(projectPath) {
+        const mapFiles = await this.findSourceMaps(projectPath);
+        const allFiles = [];
+        const seenPaths = new Set();
+        let totalSources = 0;
+        let skippedFiles = 0;
+        Logger.info(`Found ${mapFiles.length} source map files`);
+        for (const mapFile of mapFiles) {
+            try {
+                const extracted = await this.extractFromSourceMap(mapFile);
+                totalSources += extracted.length;
+                for (const file of extracted) {
+                    // Дедупликация по пути
+                    if (seenPaths.has(file.path)) {
+                        skippedFiles++;
+                        continue;
+                    }
+                    seenPaths.add(file.path);
+                    allFiles.push(file);
+                }
+            }
+            catch (error) {
+                Logger.warn(`Failed to extract from ${mapFile}: ${error}`);
+            }
+        }
+        Logger.success(`Extracted ${allFiles.length} source files from ${mapFiles.length} source maps`);
+        return {
+            files: allFiles,
+            stats: {
+                sourceMapCount: mapFiles.length,
+                totalSources,
+                extractedFiles: allFiles.length,
+                skippedFiles
+            }
+        };
+    }
+    /**
+     * Извлекает исходные файлы из одного source map
+     */
+    async extractFromSourceMap(mapPath) {
+        if (this.processedMaps.has(mapPath)) {
+            return [];
+        }
+        this.processedMaps.add(mapPath);
+        const content = await fs.promises.readFile(mapPath, 'utf-8');
+        const sourceMap = JSON.parse(content);
+        if (!sourceMap.sources || !sourceMap.sourcesContent) {
+            Logger.debug(`Source map ${mapPath} has no embedded sources`);
+            return [];
+        }
+        const files = [];
+        for (let i = 0; i < sourceMap.sources.length; i++) {
+            const sourcePath = sourceMap.sources[i];
+            const sourceContent = sourceMap.sourcesContent[i];
+            // Пропускаем null/пустые источники
+            if (!sourceContent) {
+                continue;
+            }
+            // Пропускаем node_modules и внешние зависимости
+            if (this.shouldSkipSource(sourcePath)) {
+                continue;
+            }
+            // Нормализуем путь
+            const normalizedPath = this.normalizePath(sourcePath, sourceMap.sourceRoot);
+            // Проверяем, что это исходный код (не ассеты)
+            if (!this.isSourceFile(normalizedPath)) {
+                continue;
+            }
+            files.push({
+                path: normalizedPath,
+                content: sourceContent,
+                sourceMapPath: mapPath
+            });
+        }
+        return files;
+    }
+    /**
+     * Нормализует путь из source map
+     * webpack://project/./src/file.vue → src/file.vue
+     */
+    normalizePath(sourcePath, sourceRoot) {
+        let normalized = sourcePath;
+        // Убираем webpack:// префикс
+        if (normalized.startsWith('webpack://')) {
+            // webpack://project-name/./src/file.ts → ./src/file.ts
+            normalized = normalized.replace(/^webpack:\/\/[^/]+\//, '');
+        }
+        // Убираем ./ префикс
+        if (normalized.startsWith('./')) {
+            normalized = normalized.substring(2);
+        }
+        // Применяем sourceRoot если есть
+        if (sourceRoot && !normalized.startsWith(sourceRoot)) {
+            normalized = path.posix.join(sourceRoot, normalized);
+        }
+        // Убираем query strings (?xxxx)
+        normalized = normalized.replace(/\?[a-f0-9]+$/, '');
+        // Заменяем обратные слеши на прямые
+        normalized = normalized.replace(/\\/g, '/');
+        return normalized;
+    }
+    /**
+     * Проверяет, нужно ли пропустить этот источник
+     */
+    shouldSkipSource(sourcePath) {
+        const skipPatterns = [
+            'node_modules/',
+            '/node_modules/',
+            'webpack/runtime',
+            'webpack/bootstrap',
+            '(webpack)',
+            '__webpack',
+            'ignored|',
+            '/external ',
+            'polyfill',
+            '.css', // CSS в JS обычно не нужен
+        ];
+        const lowerPath = sourcePath.toLowerCase();
+        return skipPatterns.some(pattern => lowerPath.includes(pattern.toLowerCase()));
+    }
+    /**
+     * Проверяет, является ли файл исходным кодом
+     */
+    isSourceFile(filePath) {
+        const sourceExtensions = [
+            '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+            '.vue', '.svelte', '.astro',
+            '.py', '.rb', '.go', '.rs', '.java', '.kt', '.scala',
+            '.php', '.cs', '.swift', '.dart'
+        ];
+        const ext = path.extname(filePath).toLowerCase();
+        return sourceExtensions.includes(ext);
+    }
+    /**
+     * Очищает кэш обработанных map файлов
+     */
+    clearCache() {
+        this.processedMaps.clear();
+    }
+}
+//# sourceMappingURL=source-map-extractor.js.map

package/dist/gitlab/gitlab-service.d.ts

@@ -0,0 +1,162 @@
+/**
+ * GitLab Integration Service
+ *
+ * Manages GitLab connections with support for:
+ * - Multiple GitLab instances (self-hosted + gitlab.com)
+ * - Personal Access Token (PAT) authentication
+ * - Private repositories access
+ * - Branch listing and selection
+ * - Webhooks for auto-analysis
+ * - Merge Request analysis
+ */
+import { GitLabInstance, GitLabProject, GitLabBranch, ConnectedGitLabRepository, GitLabMergeRequest, GitLabMRChange, ConnectGitLabRepositoryOptions, GitLabServiceConfig } from '../types/gitlab.js';
+export declare class GitLabService {
+    private instances;
+    private repositories;
+    private initialized;
+    private dataDir;
+    constructor(config?: GitLabServiceConfig);
+    private ensureInitialized;
+    private loadInstances;
+    private saveInstances;
+    private loadRepositories;
+    private saveRepositories;
+    private encrypt;
+    private decrypt;
+    /**
+     * Add a new GitLab instance connection
+     */
+    addInstance(userId: string, instanceUrl: string, accessToken: string, options?: {
+        name?: string;
+        rejectUnauthorizedSSL?: boolean;
+    }): Promise<GitLabInstance>;
+    /**
+     * Get instance display name from URL
+     */
+    private getInstanceName;
+    /**
+     * Get all GitLab instances for a user
+     */
+    getInstances(userId: string): Promise<GitLabInstance[]>;
+    /**
+     * Get a specific instance by ID
+     */
+    getInstance(instanceId: string): Promise<GitLabInstance | null>;
+    /**
+     * Remove a GitLab instance connection
+     */
+    removeInstance(userId: string, instanceId: string): Promise<boolean>;
+    /**
+     * Make authenticated request to GitLab API
+     */
+    private gitlabFetch;
+    /**
+     * Fetch current GitLab user info
+     */
+    private fetchGitLabUser;
+    /**
+     * Get token scopes (by testing API endpoints)
+     */
+    private getTokenScopes;
+    /**
+     * List all accessible projects from a GitLab instance
+     */
+    listProjects(userId: string, instanceId: string, options?: {
+        search?: string;
+        membership?: boolean;
+        owned?: boolean;
+        page?: number;
+        perPage?: number;
+    }): Promise<GitLabProject[]>;
+    /**
+     * Get a specific project by ID
+     */
+    getProject(userId: string, instanceId: string, projectId: number | string): Promise<GitLabProject>;
+    /**
+     * List branches for a project
+     */
+    listBranches(userId: string, instanceId: string, projectId: number | string): Promise<GitLabBranch[]>;
+    /**
+     * Connect a GitLab repository to ArchiCore
+     */
+    connectRepository(userId: string, instanceId: string, projectId: number, options?: ConnectGitLabRepositoryOptions): Promise<ConnectedGitLabRepository>;
+    /**
+     * Get all connected repositories for a user
+     */
+    getConnectedRepositories(userId: string): Promise<ConnectedGitLabRepository[]>;
+    /**
+     * Get a specific connected repository
+     */
+    getConnectedRepository(repoId: string): Promise<ConnectedGitLabRepository | null>;
+    /**
+     * Disconnect a repository
+     */
+    disconnectRepository(userId: string, repoId: string): Promise<boolean>;
+    /**
+     * Update repository's ArchiCore project ID
+     */
+    updateRepositoryProjectId(repoId: string, projectId: string): Promise<void>;
+    /**
+     * Update repository status
+     */
+    updateRepositoryStatus(repoId: string, status: ConnectedGitLabRepository['status'], error?: string): Promise<void>;
+    /**
+     * Update last analyzed timestamp
+     */
+    updateLastAnalyzed(repoId: string): Promise<void>;
+    /**
+     * Download repository archive
+     */
+    downloadRepository(userId: string, instanceId: string, projectId: number | string, ref?: string): Promise<Buffer>;
+    /**
+     * Get file content from repository
+     */
+    getFileContent(userId: string, instanceId: string, projectId: number | string, filePath: string, ref?: string): Promise<string>;
+    /**
+     * Get merge request details
+     */
+    getMergeRequest(userId: string, instanceId: string, projectId: number | string, mrIid: number): Promise<GitLabMergeRequest>;
+    /**
+     * Get merge request changes (diff)
+     */
+    getMergeRequestChanges(userId: string, instanceId: string, projectId: number | string, mrIid: number): Promise<GitLabMRChange[]>;
+    /**
+     * Post a comment on merge request
+     */
+    postMRComment(userId: string, instanceId: string, projectId: number | string, mrIid: number, body: string): Promise<{
+        id: number;
+    }>;
+    /**
+     * Create webhook for repository
+     */
+    createWebhook(userId: string, instanceId: string, projectId: number): Promise<{
+        id: number;
+        secret: string;
+    }>;
+    /**
+     * Delete webhook
+     */
+    deleteWebhook(userId: string, instanceId: string, projectId: number, hookId: number): Promise<void>;
+    /**
+     * Verify webhook token
+     */
+    verifyWebhookToken(token: string, expectedToken: string): boolean;
+    /**
+     * Find repository by webhook (for incoming webhooks)
+     */
+    findRepositoryByWebhook(fullPath: string): Promise<ConnectedGitLabRepository | null>;
+    /**
+     * Get instance for repository (used in webhook handling)
+     */
+    getInstanceForRepository(repo: ConnectedGitLabRepository): Promise<GitLabInstance | null>;
+    /**
+     * Get decrypted webhook secret
+     */
+    getWebhookSecret(encryptedSecret: string): string;
+    /**
+     * Disconnect repository by ArchiCore project ID
+     */
+    disconnectRepositoryByProjectId(projectId: string): Promise<boolean>;
+}
+export default GitLabService;
+//# sourceMappingURL=gitlab-service.d.ts.map