archicore 0.1.0

package/dist/types/index.js

@@ -0,0 +1,32 @@
+/**
+ * Основные типы системы ИИ-архитектор
+ */
+export var SymbolKind;
+(function (SymbolKind) {
+    SymbolKind["Function"] = "function";
+    SymbolKind["Class"] = "class";
+    SymbolKind["Interface"] = "interface";
+    SymbolKind["Variable"] = "variable";
+    SymbolKind["Constant"] = "constant";
+    SymbolKind["Type"] = "type";
+    SymbolKind["Module"] = "module";
+    SymbolKind["Namespace"] = "namespace";
+})(SymbolKind || (SymbolKind = {}));
+export var EdgeType;
+(function (EdgeType) {
+    EdgeType["Import"] = "import";
+    EdgeType["Call"] = "call";
+    EdgeType["Inheritance"] = "inheritance";
+    EdgeType["Composition"] = "composition";
+    EdgeType["DataFlow"] = "data_flow";
+})(EdgeType || (EdgeType = {}));
+export var RefactoringType;
+(function (RefactoringType) {
+    RefactoringType["ExtractFunction"] = "extract_function";
+    RefactoringType["RenameSymbol"] = "rename_symbol";
+    RefactoringType["MoveFile"] = "move_file";
+    RefactoringType["InlineVariable"] = "inline_variable";
+    RefactoringType["ExtractInterface"] = "extract_interface";
+    RefactoringType["OptimizeImports"] = "optimize_imports";
+})(RefactoringType || (RefactoringType = {}));
+//# sourceMappingURL=index.js.map

package/dist/types/user.d.ts

@@ -0,0 +1,69 @@
+/**
+ * User and Subscription Types for ArchiCore
+ */
+export type SubscriptionTier = 'free' | 'mid' | 'pro' | 'admin';
+export interface TierLimits {
+    requestsPerDay: number;
+    fullAnalysisPerDay: number;
+    projectsPerDay: number;
+    maxFileSizeMB: number;
+    retentionDays: number;
+    price: number;
+    priceYearly: number;
+}
+export declare const TIER_LIMITS: Record<SubscriptionTier, TierLimits>;
+export interface User {
+    id: string;
+    email: string;
+    username: string;
+    passwordHash?: string;
+    avatar?: string;
+    tier: SubscriptionTier;
+    provider: 'email' | 'github' | 'google';
+    providerId?: string;
+    createdAt: Date;
+    lastLoginAt: Date;
+    usage: UserUsage;
+    subscription?: Subscription;
+}
+export interface UserUsage {
+    requestsToday: number;
+    fullAnalysisToday: number;
+    projectsToday: number;
+    lastResetDate: string;
+}
+export interface Subscription {
+    id: string;
+    tier: SubscriptionTier;
+    status: 'active' | 'cancelled' | 'expired' | 'trial';
+    startDate: Date;
+    endDate: Date;
+    autoRenew: boolean;
+    paymentMethod?: string;
+}
+export interface AuthSession {
+    token: string;
+    userId: string;
+    expiresAt: Date;
+}
+export interface LoginRequest {
+    email: string;
+    password: string;
+}
+export interface RegisterRequest {
+    email: string;
+    username: string;
+    password: string;
+}
+export interface OAuthRequest {
+    provider: 'github' | 'google';
+    code: string;
+    redirectUri: string;
+}
+export interface AuthResponse {
+    success: boolean;
+    token?: string;
+    user?: Omit<User, 'passwordHash'>;
+    error?: string;
+}
+//# sourceMappingURL=user.d.ts.map

package/dist/types/user.js

@@ -0,0 +1,42 @@
+/**
+ * User and Subscription Types for ArchiCore
+ */
+export const TIER_LIMITS = {
+    free: {
+        requestsPerDay: 10,
+        fullAnalysisPerDay: 1,
+        projectsPerDay: 3,
+        maxFileSizeMB: 10,
+        retentionDays: 7,
+        price: 0,
+        priceYearly: 0
+    },
+    mid: {
+        requestsPerDay: 50,
+        fullAnalysisPerDay: 5,
+        projectsPerDay: 10,
+        maxFileSizeMB: 30,
+        retentionDays: 14,
+        price: 39,
+        priceYearly: 390 // ~2 months free
+    },
+    pro: {
+        requestsPerDay: 150,
+        fullAnalysisPerDay: 15,
+        projectsPerDay: 20,
+        maxFileSizeMB: 60,
+        retentionDays: 30,
+        price: 99,
+        priceYearly: 990 // ~2 months free
+    },
+    admin: {
+        requestsPerDay: Infinity,
+        fullAnalysisPerDay: Infinity,
+        projectsPerDay: Infinity,
+        maxFileSizeMB: 500,
+        retentionDays: 365,
+        price: 0,
+        priceYearly: 0
+    }
+};
+//# sourceMappingURL=user.js.map

package/dist/utils/file-utils.d.ts

@@ -0,0 +1,20 @@
+export declare class FileUtils {
+    static readFileContent(filePath: string): Promise<string>;
+    static getFileSize(filePath: string): Promise<number>;
+    static getAllFiles(rootDir: string, patterns?: string[]): Promise<string[]>;
+    static getLanguageFromExtension(filePath: string): string;
+    static getProjectStructure(rootDir: string): Promise<ProjectStructure>;
+}
+export interface ProjectStructure {
+    rootDir: string;
+    files: FileInfo[];
+    directories: Set<string>;
+}
+export interface FileInfo {
+    path: string;
+    relativePath: string;
+    language: string;
+    size: number;
+    lastModified: Date;
+}
+//# sourceMappingURL=file-utils.d.ts.map

package/dist/utils/file-utils.js

@@ -0,0 +1,163 @@
+import { readFile, stat } from 'fs/promises';
+import { join, relative, extname } from 'path';
+import { glob } from 'glob';
+const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB max file size for parsing
+export class FileUtils {
+    static async readFileContent(filePath) {
+        return await readFile(filePath, 'utf-8');
+    }
+    static async getFileSize(filePath) {
+        const stats = await stat(filePath);
+        return stats.size;
+    }
+    static async getAllFiles(rootDir, patterns = [
+        '**/*.ts', '**/*.js', '**/*.tsx', '**/*.jsx', // JS/TS
+        '**/*.vue', // Vue
+        '**/*.py', // Python
+        '**/*.go', // Go
+        '**/*.rs', // Rust
+        '**/*.java', // Java
+        '**/*.php', // PHP
+        '**/*.rb', // Ruby
+        '**/*.cs', // C#
+        '**/*.cpp', '**/*.c', '**/*.h', '**/*.hpp' // C/C++
+    ]) {
+        const files = [];
+        for (const pattern of patterns) {
+            const matches = await glob(pattern, {
+                cwd: rootDir,
+                nodir: true, // Exclude directories that match file patterns (e.g., "404.php/")
+                dot: true, // Include files in hidden directories (e.g., ".default/")
+                ignore: [
+                    // Package managers (always third-party, never user code)
+                    'node_modules/**',
+                    '**/node_modules/**',
+                    'bower_components/**',
+                    '**/bower_components/**',
+                    'jspm_packages/**',
+                    // Build/Generated output
+                    'dist/**',
+                    '**/dist/**',
+                    '.next/**',
+                    '.nuxt/**',
+                    '.output/**',
+                    // Version control
+                    '.git/**',
+                    '.svn/**',
+                    '.hg/**',
+                    // IDE/Editor
+                    '.idea/**',
+                    '.vscode/**',
+                    // Test coverage (generated reports)
+                    'coverage/**',
+                    '.nyc_output/**',
+                    'htmlcov/**',
+                    // Python virtual environments
+                    'venv/**',
+                    '.venv/**',
+                    '**/site-packages/**',
+                    '**/__pycache__/**',
+                    '**/*.pyc',
+                    '*.egg-info/**',
+                    '.eggs/**',
+                    '.tox/**',
+                    // Minified/bundled files (generated, not source)
+                    '**/*.min.js',
+                    '**/*.min.css',
+                    '**/*.bundle.js',
+                    '**/*.chunk.js',
+                    '**/*-min.js',
+                    '**/*.packed.js',
+                    // Rich text editors (always third-party)
+                    '**/tinymce/**',
+                    '**/ckeditor/**',
+                    '**/ckeditor5/**',
+                    '**/codemirror/**',
+                    '**/ace-builds/**',
+                    '**/monaco-editor/**',
+                    '**/quill/**',
+                    '**/froala-editor/**',
+                    // Lock files (generated, not code)
+                    'package-lock.json',
+                    'yarn.lock',
+                    'pnpm-lock.yaml',
+                    'composer.lock',
+                    'Gemfile.lock',
+                    'poetry.lock',
+                    'Pipfile.lock',
+                    'Cargo.lock',
+                    // Cache directories
+                    '.cache/**',
+                    '**/.cache/**',
+                    '.parcel-cache/**',
+                    '.turbo/**'
+                ],
+                absolute: true
+            });
+            files.push(...matches);
+        }
+        // Filter out large files and directories
+        const filteredFiles = [];
+        for (const file of [...new Set(files)]) {
+            try {
+                const stats = await stat(file);
+                // Skip directories (e.g., folders named "404.php")
+                if (!stats.isFile()) {
+                    continue;
+                }
+                if (stats.size <= MAX_FILE_SIZE) {
+                    filteredFiles.push(file);
+                }
+            }
+            catch {
+                // Skip files we can't stat
+            }
+        }
+        return filteredFiles;
+    }
+    static getLanguageFromExtension(filePath) {
+        const ext = extname(filePath);
+        const map = {
+            '.ts': 'typescript',
+            '.tsx': 'typescript',
+            '.js': 'javascript',
+            '.jsx': 'javascript',
+            '.vue': 'vue',
+            '.py': 'python',
+            '.go': 'go',
+            '.rs': 'rust',
+            '.java': 'java',
+            '.php': 'php',
+            '.rb': 'ruby',
+            '.cs': 'csharp',
+            '.cpp': 'cpp',
+            '.c': 'c',
+            '.h': 'c',
+            '.hpp': 'cpp'
+        };
+        return map[ext] || 'unknown';
+    }
+    static async getProjectStructure(rootDir) {
+        const files = await this.getAllFiles(rootDir);
+        const structure = {
+            rootDir,
+            files: [],
+            directories: new Set()
+        };
+        for (const file of files) {
+            const rel = relative(rootDir, file);
+            const stats = await stat(file);
+            structure.files.push({
+                path: file,
+                relativePath: rel,
+                language: this.getLanguageFromExtension(file),
+                size: stats.size,
+                lastModified: stats.mtime
+            });
+            const dirPath = join(rootDir, rel.split('/').slice(0, -1).join('/'));
+            structure.directories.add(dirPath);
+        }
+        return structure;
+    }
+}
+//# sourceMappingURL=file-utils.js.map

package/dist/utils/logger.d.ts

@@ -0,0 +1,17 @@
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3
+}
+export declare class Logger {
+    private static level;
+    static setLevel(level: LogLevel): void;
+    static debug(message: string, data?: unknown): void;
+    static info(message: string, data?: unknown): void;
+    static warn(message: string, data?: unknown): void;
+    static error(message: string, error?: unknown): void;
+    static success(message: string): void;
+    static progress(message: string): void;
+}
+//# sourceMappingURL=logger.d.ts.map

package/dist/utils/logger.js

@@ -0,0 +1,41 @@
+import chalk from 'chalk';
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+})(LogLevel || (LogLevel = {}));
+export class Logger {
+    static level = LogLevel.INFO;
+    static setLevel(level) {
+        this.level = level;
+    }
+    static debug(message, data) {
+        if (this.level <= LogLevel.DEBUG) {
+            console.log(chalk.gray(`[DEBUG] ${message}`), data || '');
+        }
+    }
+    static info(message, data) {
+        if (this.level <= LogLevel.INFO) {
+            console.log(chalk.blue(`[INFO] ${message}`), data || '');
+        }
+    }
+    static warn(message, data) {
+        if (this.level <= LogLevel.WARN) {
+            console.warn(chalk.yellow(`[WARN] ${message}`), data || '');
+        }
+    }
+    static error(message, error) {
+        if (this.level <= LogLevel.ERROR) {
+            console.error(chalk.red(`[ERROR] ${message}`), error || '');
+        }
+    }
+    static success(message) {
+        console.log(chalk.green(`✓ ${message}`));
+    }
+    static progress(message) {
+        console.log(chalk.cyan(`⟳ ${message}`));
+    }
+}
+//# sourceMappingURL=logger.js.map

package/dist/watcher/index.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Real-time File Watcher
+ *
+ * Мониторинг изменений файлов:
+ * - Автоматическая переиндексация при изменениях
+ * - Debounce для избежания лишних обновлений
+ * - Поддержка .gitignore паттернов
+ * - События для уведомления о изменениях
+ */
+import { EventEmitter } from 'events';
+export interface WatcherConfig {
+    debounceMs: number;
+    ignorePatterns: string[];
+    watchExtensions: string[];
+    recursive: boolean;
+}
+export interface FileChangeEvent {
+    type: 'add' | 'change' | 'delete';
+    path: string;
+    timestamp: Date;
+}
+export interface WatcherStats {
+    watchedFiles: number;
+    watchedDirectories: number;
+    totalChanges: number;
+    lastChangeTime?: Date;
+    isWatching: boolean;
+}
+export declare class FileWatcher extends EventEmitter {
+    private config;
+    private watchers;
+    private pendingChanges;
+    private debounceTimers;
+    private stats;
+    private rootPath;
+    constructor(config?: Partial<WatcherConfig>);
+    /**
+     * Начать мониторинг директории
+     */
+    watch(dirPath: string): Promise<void>;
+    /**
+     * Остановить мониторинг
+     */
+    stop(): void;
+    /**
+     * Получить статистику
+     */
+    getStats(): WatcherStats;
+    /**
+     * Загрузка паттернов из .gitignore
+     */
+    private loadGitignore;
+    /**
+     * Установка watchers рекурсивно
+     */
+    private setupWatchers;
+    /**
+     * Создание watcher для директории
+     */
+    private createDirectoryWatcher;
+    /**
+     * Обработка события файла
+     */
+    private handleFileEvent;
+    /**
+     * Debounce обработки события
+     */
+    private debounceEvent;
+    /**
+     * Обработка отложенного изменения
+     */
+    private processPendingChange;
+    /**
+     * Проверка, нужно ли игнорировать путь
+     */
+    private shouldIgnore;
+    /**
+     * Проверка, нужно ли отслеживать файл
+     */
+    private shouldWatchFile;
+    /**
+     * Добавить паттерн для игнорирования
+     */
+    addIgnorePattern(pattern: string): void;
+    /**
+     * Удалить паттерн игнорирования
+     */
+    removeIgnorePattern(pattern: string): void;
+    /**
+     * Получить все отслеживаемые файлы
+     */
+    getWatchedFiles(): string[];
+}
+/**
+ * Менеджер автоматической переиндексации
+ */
+export declare class AutoReindexManager {
+    private watcher;
+    private reindexCallback?;
+    private batchTimeout?;
+    private pendingReindex;
+    private batchDelayMs;
+    constructor(batchDelayMs?: number);
+    /**
+     * Запуск мониторинга с callback для переиндексации
+     */
+    start(dirPath: string, reindexCallback: () => Promise<void>): Promise<void>;
+    /**
+     * Остановка мониторинга
+     */
+    stop(): void;
+    /**
+     * Планирование переиндексации (с батчингом)
+     */
+    private scheduleReindex;
+    /**
+     * Получить статистику watcher'а
+     */
+    getStats(): WatcherStats;
+    /**
+     * Получить экземпляр watcher'а
+     */
+    getWatcher(): FileWatcher;
+}
+//# sourceMappingURL=index.d.ts.map