archicore 0.1.0

package/dist/watcher/index.js

@@ -0,0 +1,397 @@
+/**
+ * Real-time File Watcher
+ *
+ * Мониторинг изменений файлов:
+ * - Автоматическая переиндексация при изменениях
+ * - Debounce для избежания лишних обновлений
+ * - Поддержка .gitignore паттернов
+ * - События для уведомления о изменениях
+ */
+import { EventEmitter } from 'events';
+import * as fs from 'fs';
+import * as path from 'path';
+import { Logger } from '../utils/logger.js';
+const DEFAULT_CONFIG = {
+    debounceMs: 300,
+    ignorePatterns: [
+        'node_modules',
+        '.git',
+        'dist',
+        'build',
+        'coverage',
+        '.next',
+        '.nuxt',
+        '__pycache__',
+        '*.log',
+        '*.lock',
+        '.DS_Store',
+        'Thumbs.db'
+    ],
+    watchExtensions: [
+        '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+        '.py', '.java', '.go', '.rs', '.cpp', '.c', '.h',
+        '.cs', '.rb', '.php', '.swift', '.kt', '.scala',
+        '.vue', '.svelte', '.astro'
+    ],
+    recursive: true
+};
+export class FileWatcher extends EventEmitter {
+    config;
+    watchers = new Map();
+    pendingChanges = new Map();
+    debounceTimers = new Map();
+    stats = {
+        watchedFiles: 0,
+        watchedDirectories: 0,
+        totalChanges: 0,
+        isWatching: false
+    };
+    rootPath = '';
+    constructor(config = {}) {
+        super();
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Начать мониторинг директории
+     */
+    async watch(dirPath) {
+        this.rootPath = path.resolve(dirPath);
+        if (!fs.existsSync(this.rootPath)) {
+            throw new Error(`Directory not found: ${this.rootPath}`);
+        }
+        Logger.progress(`Starting file watcher on: ${this.rootPath}`);
+        // Загружаем .gitignore если есть
+        await this.loadGitignore();
+        // Сканируем и устанавливаем watchers
+        await this.setupWatchers(this.rootPath);
+        this.stats.isWatching = true;
+        Logger.success(`Watching ${this.stats.watchedDirectories} directories, ${this.stats.watchedFiles} files`);
+        this.emit('ready', this.stats);
+    }
+    /**
+     * Остановить мониторинг
+     */
+    stop() {
+        Logger.progress('Stopping file watcher...');
+        // Очищаем все таймеры
+        for (const timer of this.debounceTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.debounceTimers.clear();
+        // Закрываем все watchers
+        for (const watcher of this.watchers.values()) {
+            watcher.close();
+        }
+        this.watchers.clear();
+        this.stats.isWatching = false;
+        this.emit('stopped');
+        Logger.success('File watcher stopped');
+    }
+    /**
+     * Получить статистику
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Загрузка паттернов из .gitignore
+     */
+    async loadGitignore() {
+        const gitignorePath = path.join(this.rootPath, '.gitignore');
+        if (fs.existsSync(gitignorePath)) {
+            try {
+                const content = fs.readFileSync(gitignorePath, 'utf-8');
+                const patterns = content
+                    .split('\n')
+                    .map(line => line.trim())
+                    .filter(line => line && !line.startsWith('#'));
+                this.config.ignorePatterns = [
+                    ...new Set([...this.config.ignorePatterns, ...patterns])
+                ];
+                Logger.info(`Loaded ${patterns.length} patterns from .gitignore`);
+            }
+            catch (error) {
+                Logger.warn('Failed to load .gitignore');
+            }
+        }
+    }
+    /**
+     * Установка watchers рекурсивно
+     */
+    async setupWatchers(dirPath) {
+        if (this.shouldIgnore(dirPath)) {
+            return;
+        }
+        try {
+            const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+            // Создаём watcher для директории
+            this.createDirectoryWatcher(dirPath);
+            for (const entry of entries) {
+                const fullPath = path.join(dirPath, entry.name);
+                if (entry.isDirectory()) {
+                    if (this.config.recursive) {
+                        await this.setupWatchers(fullPath);
+                    }
+                }
+                else if (entry.isFile()) {
+                    if (this.shouldWatchFile(fullPath)) {
+                        this.stats.watchedFiles++;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            Logger.warn(`Cannot access directory: ${dirPath}`);
+        }
+    }
+    /**
+     * Создание watcher для директории
+     */
+    createDirectoryWatcher(dirPath) {
+        if (this.watchers.has(dirPath)) {
+            return;
+        }
+        try {
+            const watcher = fs.watch(dirPath, { persistent: true }, (eventType, filename) => {
+                if (filename) {
+                    const fullPath = path.join(dirPath, filename);
+                    this.handleFileEvent(eventType, fullPath);
+                }
+            });
+            watcher.on('error', (error) => {
+                Logger.warn(`Watcher error for ${dirPath}: ${error.message}`);
+                this.watchers.delete(dirPath);
+            });
+            this.watchers.set(dirPath, watcher);
+            this.stats.watchedDirectories++;
+        }
+        catch (error) {
+            Logger.warn(`Failed to watch directory: ${dirPath}`);
+        }
+    }
+    /**
+     * Обработка события файла
+     */
+    handleFileEvent(eventType, filePath) {
+        if (this.shouldIgnore(filePath)) {
+            return;
+        }
+        // Определяем тип события
+        let changeType;
+        if (!fs.existsSync(filePath)) {
+            changeType = 'delete';
+        }
+        else {
+            const stat = fs.statSync(filePath);
+            if (stat.isDirectory()) {
+                // Новая директория - добавляем watcher
+                if (!this.watchers.has(filePath)) {
+                    this.setupWatchers(filePath);
+                }
+                return;
+            }
+            if (!this.shouldWatchFile(filePath)) {
+                return;
+            }
+            // Проверяем, новый ли файл
+            changeType = eventType === 'rename' ? 'add' : 'change';
+        }
+        const event = {
+            type: changeType,
+            path: filePath,
+            timestamp: new Date()
+        };
+        // Debounce
+        this.debounceEvent(event);
+    }
+    /**
+     * Debounce обработки события
+     */
+    debounceEvent(event) {
+        const key = event.path;
+        // Отменяем предыдущий таймер
+        const existingTimer = this.debounceTimers.get(key);
+        if (existingTimer) {
+            clearTimeout(existingTimer);
+        }
+        // Сохраняем событие
+        this.pendingChanges.set(key, event);
+        // Устанавливаем новый таймер
+        const timer = setTimeout(() => {
+            this.processPendingChange(key);
+        }, this.config.debounceMs);
+        this.debounceTimers.set(key, timer);
+    }
+    /**
+     * Обработка отложенного изменения
+     */
+    processPendingChange(key) {
+        const event = this.pendingChanges.get(key);
+        if (!event)
+            return;
+        this.pendingChanges.delete(key);
+        this.debounceTimers.delete(key);
+        // Обновляем статистику
+        this.stats.totalChanges++;
+        this.stats.lastChangeTime = event.timestamp;
+        // Если файл удалён, обновляем счётчик
+        if (event.type === 'delete') {
+            this.stats.watchedFiles = Math.max(0, this.stats.watchedFiles - 1);
+        }
+        else if (event.type === 'add') {
+            this.stats.watchedFiles++;
+        }
+        // Эмитим событие
+        this.emit('change', event);
+        this.emit(event.type, event);
+        Logger.info(`File ${event.type}: ${path.relative(this.rootPath, event.path)}`);
+    }
+    /**
+     * Проверка, нужно ли игнорировать путь
+     */
+    shouldIgnore(filePath) {
+        const relativePath = path.relative(this.rootPath, filePath);
+        const parts = relativePath.split(path.sep);
+        for (const pattern of this.config.ignorePatterns) {
+            // Простая проверка паттернов
+            if (pattern.startsWith('*.')) {
+                // Расширение файла
+                const ext = pattern.slice(1);
+                if (filePath.endsWith(ext))
+                    return true;
+            }
+            else if (pattern.includes('*')) {
+                // Glob паттерн (упрощённый)
+                const regex = new RegExp('^' + pattern.replace(/\*/g, '.*').replace(/\?/g, '.') + '$');
+                if (parts.some(p => regex.test(p)))
+                    return true;
+            }
+            else {
+                // Точное совпадение с любой частью пути
+                if (parts.includes(pattern))
+                    return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Проверка, нужно ли отслеживать файл
+     */
+    shouldWatchFile(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        return this.config.watchExtensions.includes(ext);
+    }
+    /**
+     * Добавить паттерн для игнорирования
+     */
+    addIgnorePattern(pattern) {
+        if (!this.config.ignorePatterns.includes(pattern)) {
+            this.config.ignorePatterns.push(pattern);
+        }
+    }
+    /**
+     * Удалить паттерн игнорирования
+     */
+    removeIgnorePattern(pattern) {
+        const index = this.config.ignorePatterns.indexOf(pattern);
+        if (index !== -1) {
+            this.config.ignorePatterns.splice(index, 1);
+        }
+    }
+    /**
+     * Получить все отслеживаемые файлы
+     */
+    getWatchedFiles() {
+        const files = [];
+        const scanDir = (dirPath) => {
+            if (this.shouldIgnore(dirPath))
+                return;
+            try {
+                const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dirPath, entry.name);
+                    if (entry.isDirectory()) {
+                        scanDir(fullPath);
+                    }
+                    else if (entry.isFile() && this.shouldWatchFile(fullPath)) {
+                        files.push(fullPath);
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        };
+        scanDir(this.rootPath);
+        return files;
+    }
+}
+/**
+ * Менеджер автоматической переиндексации
+ */
+export class AutoReindexManager {
+    watcher;
+    reindexCallback;
+    batchTimeout;
+    pendingReindex = false;
+    batchDelayMs;
+    constructor(batchDelayMs = 1000) {
+        this.watcher = new FileWatcher();
+        this.batchDelayMs = batchDelayMs;
+        // Подписываемся на изменения
+        this.watcher.on('change', () => this.scheduleReindex());
+        this.watcher.on('add', () => this.scheduleReindex());
+        this.watcher.on('delete', () => this.scheduleReindex());
+    }
+    /**
+     * Запуск мониторинга с callback для переиндексации
+     */
+    async start(dirPath, reindexCallback) {
+        this.reindexCallback = reindexCallback;
+        await this.watcher.watch(dirPath);
+    }
+    /**
+     * Остановка мониторинга
+     */
+    stop() {
+        if (this.batchTimeout) {
+            clearTimeout(this.batchTimeout);
+        }
+        this.watcher.stop();
+    }
+    /**
+     * Планирование переиндексации (с батчингом)
+     */
+    scheduleReindex() {
+        this.pendingReindex = true;
+        if (this.batchTimeout) {
+            clearTimeout(this.batchTimeout);
+        }
+        this.batchTimeout = setTimeout(async () => {
+            if (this.pendingReindex && this.reindexCallback) {
+                this.pendingReindex = false;
+                Logger.progress('Auto-reindexing triggered...');
+                try {
+                    await this.reindexCallback();
+                    Logger.success('Auto-reindex completed');
+                }
+                catch (error) {
+                    Logger.error(`Auto-reindex failed: ${error}`);
+                }
+            }
+        }, this.batchDelayMs);
+    }
+    /**
+     * Получить статистику watcher'а
+     */
+    getStats() {
+        return this.watcher.getStats();
+    }
+    /**
+     * Получить экземпляр watcher'а
+     */
+    getWatcher() {
+        return this.watcher;
+    }
+}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "archicore",
+  "version": "0.1.0",
+  "description": "AI Software Architect - code analysis, impact prediction, semantic search",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "archicore": "./dist/cli.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx watch src/index.ts",
+    "start": "node dist/index.js",
+    "server": "tsx src/server/index.ts",
+    "server:dev": "tsx watch src/server/index.ts",
+    "cli": "tsx src/cli.ts",
+    "index": "tsx src/cli.ts index",
+    "analyze": "tsx src/cli.ts analyze",
+    "impact": "tsx src/cli.ts impact"
+  },
+  "keywords": [
+    "ai",
+    "architecture",
+    "code-analysis",
+    "ast",
+    "vector-db",
+    "impact-analysis"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.32.0",
+    "@qdrant/js-client-rest": "^1.11.0",
+    "adm-zip": "^0.5.16",
+    "boxen": "^8.0.1",
+    "chalk": "^5.4.1",
+    "cli-table3": "^0.6.5",
+    "commander": "^12.1.0",
+    "figures": "^6.1.0",
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.7",
+    "express": "^5.2.1",
+    "glob": "^11.0.0",
+    "mime-types": "^3.0.2",
+    "multer": "^2.0.2",
+    "openai": "^4.73.0",
+    "ora": "^8.1.1",
+    "tree-sitter": "^0.21.1",
+    "tree-sitter-javascript": "^0.21.4",
+    "tree-sitter-python": "^0.21.0",
+    "tree-sitter-typescript": "^0.21.2",
+    "uuid": "^11.0.3",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/adm-zip": "^0.5.7",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
+    "@types/mime-types": "^3.0.1",
+    "@types/multer": "^2.0.0",
+    "@types/node": "^22.10.2",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  }
+}