archicore 0.1.5 → 0.1.7

package/dist/server/services/project-service.js

@@ -21,6 +21,7 @@ import { DeadCodeDetector } from '../../analyzers/dead-code.js';
 import { DuplicationDetector } from '../../analyzers/duplication.js';
 import { SecurityAnalyzer } from '../../analyzers/security.js';
 import { RefactoringEngine } from '../../refactoring/index.js';
+import { GitHubService } from '../../github/github-service.js';
 // Singleton instance
 let instance = null;
 export class ProjectService {
@@ -65,15 +66,21 @@ export class ProjectService {
             Logger.error('Could not save projects:', error);
         }
     }
-    async listProjects() {
-        return Array.from(this.projects.values());
+    async listProjects(userId) {
+        const projects = Array.from(this.projects.values());
+        // Filter by userId if provided
+        if (userId) {
+            return projects.filter(p => p.ownerId === userId);
+        }
+        return projects;
     }
-    async createProject(name, projectPath) {
+    async createProject(name, projectPath, ownerId) {
         const id = uuidv4();
         const project = {
             id,
             name,
             path: projectPath,
+            ownerId,
             createdAt: new Date().toISOString(),
             status: 'pending'
         };
@@ -81,11 +88,25 @@ export class ProjectService {
         await this.saveProjects();
         // Инициализируем данные проекта
         await this.initializeProjectData(id);
-        Logger.success(`Created project: ${name} (${id})`);
+        Logger.success(`Created project: ${name} (${id}) for user ${ownerId}`);
+        return project;
+    }
+    async getProject(id, userId) {
+        const project = this.projects.get(id);
+        if (!project)
+            return null;
+        // Check ownership if userId provided
+        if (userId && project.ownerId !== userId) {
+            return null;
+        }
         return project;
     }
-    async getProject(id) {
-        return this.projects.get(id) || null;
+    /**
+     * Check if user owns project
+     */
+    async isProjectOwner(projectId, userId) {
+        const project = this.projects.get(projectId);
+        return project?.ownerId === userId;
     }
     async initializeProjectData(projectId) {
         const project = this.projects.get(projectId);
@@ -213,8 +234,8 @@ export class ProjectService {
             label: node.name,
             type: node.type,
             filePath: node.filePath,
-            // Для визуализации - группировка по папкам
-            group: node.filePath.split('/').slice(-2, -1)[0] || 'root'
+            // Для визуализации - группировка по папкам (кроссплатформенно)
+            group: node.filePath.split(/[/\\]/).slice(-2, -1)[0] || 'root'
         }));
         const edges = [];
         for (const [from, edgeList] of graph.edges) {
@@ -366,6 +387,17 @@ export class ProjectService {
         };
     }
     async deleteProject(projectId) {
+        // Disconnect GitHub repository if connected
+        try {
+            const githubService = new GitHubService();
+            const disconnected = await githubService.disconnectRepositoryByProjectId(projectId);
+            if (disconnected) {
+                Logger.info(`Disconnected GitHub repository for project: ${projectId}`);
+            }
+        }
+        catch (err) {
+            Logger.warn(`Failed to disconnect GitHub repository for project ${projectId}:`, err);
+        }
         this.projects.delete(projectId);
         this.projectData.delete(projectId);
         await this.saveProjects();
@@ -689,5 +721,125 @@ export class ProjectService {
         }
         return fileContents;
     }
+    /**
+     * Генерация документации по коду проекта
+     */
+    async generateDocumentation(projectId, options = {}) {
+        const project = this.projects.get(projectId);
+        if (!project) {
+            throw new Error(`Project not found: ${projectId}`);
+        }
+        const data = await this.getProjectData(projectId);
+        const fileContents = await this.getFileContents(projectId);
+        const format = options.format || 'markdown';
+        const language = options.language || 'en';
+        Logger.progress(`Generating ${format} documentation for: ${project.name}`);
+        // Собираем информацию о проекте
+        const stats = project.stats;
+        const symbols = data.symbols ? Array.from(data.symbols.values()) : [];
+        // graph is available via data.graph if needed for more detailed docs
+        // Группируем символы по типу (kind)
+        const classes = symbols.filter(s => s.kind === 'class');
+        const functions = symbols.filter(s => s.kind === 'function');
+        const interfaces = symbols.filter(s => s.kind === 'interface');
+        // Формируем структуру файлов
+        const files = fileContents ? Array.from(fileContents.keys()) : [];
+        const fileStructure = this.buildFileStructure(files);
+        // Генерируем документацию
+        let documentation = '';
+        if (format === 'markdown') {
+            const title = language === 'ru' ? 'Документация проекта' : 'Project Documentation';
+            const overview = language === 'ru' ? 'Обзор' : 'Overview';
+            const structure = language === 'ru' ? 'Структура проекта' : 'Project Structure';
+            const classesTitle = language === 'ru' ? 'Классы' : 'Classes';
+            const functionsTitle = language === 'ru' ? 'Функции' : 'Functions';
+            const interfacesTitle = language === 'ru' ? 'Интерфейсы' : 'Interfaces';
+            documentation = `# ${title}: ${project.name}
+
+## ${overview}
+
+- **Files:** ${stats?.filesCount || files.length}
+- **Symbols:** ${stats?.symbolsCount || symbols.length}
+- **Classes:** ${classes.length}
+- **Functions:** ${functions.length}
+- **Interfaces:** ${interfaces.length}
+
+## ${structure}
+
+\`\`\`
+${fileStructure}
+\`\`\`
+
+${classes.length > 0 ? `## ${classesTitle}
+
+${classes.slice(0, 20).map(c => `### ${c.name}
+
+- **File:** \`${c.filePath}\`
+- **Line:** ${c.location?.startLine || 'N/A'}
+`).join('\n')}
+` : ''}
+
+${interfaces.length > 0 ? `## ${interfacesTitle}
+
+${interfaces.slice(0, 20).map(i => `### ${i.name}
+
+- **File:** \`${i.filePath}\`
+- **Line:** ${i.location?.startLine || 'N/A'}
+`).join('\n')}
+` : ''}
+
+${functions.length > 0 ? `## ${functionsTitle}
+
+${functions.slice(0, 30).map(f => `- \`${f.name}\` - ${f.filePath}:${f.location?.startLine || 'N/A'}`).join('\n')}
+` : ''}
+
+---
+*Generated by ArchiCore*
+`;
+        }
+        else {
+            // JSON format
+            documentation = JSON.stringify({
+                project: project.name,
+                stats,
+                classes: classes.map(c => ({ name: c.name, file: c.filePath, line: c.location?.startLine })),
+                functions: functions.map(f => ({ name: f.name, file: f.filePath, line: f.location?.startLine })),
+                interfaces: interfaces.map(i => ({ name: i.name, file: i.filePath, line: i.location?.startLine })),
+                files
+            }, null, 2);
+        }
+        Logger.success('Documentation generated');
+        return { documentation, format };
+    }
+    /**
+     * Построить текстовое представление структуры файлов
+     */
+    buildFileStructure(files) {
+        const tree = {};
+        for (const file of files) {
+            const parts = file.split(/[/\\]/);
+            let current = tree;
+            for (const part of parts) {
+                if (!current[part]) {
+                    current[part] = {};
+                }
+                current = current[part];
+            }
+        }
+        const renderTree = (node, prefix = '') => {
+            const entries = Object.entries(node);
+            return entries.map(([name, children], i) => {
+                const isLast = i === entries.length - 1;
+                const connector = isLast ? '└── ' : '├── ';
+                const childPrefix = isLast ? '    ' : '│   ';
+                const childKeys = Object.keys(children);
+                if (childKeys.length === 0) {
+                    return `${prefix}${connector}${name}`;
+                }
+                return `${prefix}${connector}${name}\n${renderTree(children, prefix + childPrefix)}`;
+            }).join('\n');
+        };
+        return renderTree(tree);
+    }
 }
 //# sourceMappingURL=project-service.js.map

package/dist/utils/file-utils.js

@@ -1,6 +1,7 @@
 import { readFile, stat } from 'fs/promises';
-import { join, relative, extname } from 'path';
+import { join, relative, extname, resolve } from 'path';
 import { glob } from 'glob';
+import { Logger } from './logger.js';
 const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB max file size for parsing
 export class FileUtils {
     static async readFileContent(filePath) {
@@ -20,12 +21,38 @@ export class FileUtils {
         '**/*.php', // PHP
         '**/*.rb', // Ruby
         '**/*.cs', // C#
-        '**/*.cpp', '**/*.c', '**/*.h', '**/*.hpp' // C/C++
+        '**/*.cpp', '**/*.c', '**/*.h', '**/*.hpp', // C/C++
+        '**/*.html', '**/*.htm', // HTML
+        '**/*.css', '**/*.scss', '**/*.sass', '**/*.less', // CSS
+        '**/*.json', // JSON
+        '**/*.yaml', '**/*.yml', // YAML
+        '**/*.xml', // XML
+        '**/*.sql', // SQL
+        '**/*.sh', '**/*.bash', // Shell
+        '**/*.md', '**/*.markdown' // Markdown (for documentation)
     ]) {
+        // Resolve to absolute path
+        const resolvedPath = resolve(rootDir);
+        // Normalize for glob (use forward slashes on all platforms)
+        const absoluteRootDir = resolvedPath.replace(/\\/g, '/');
+        Logger.info(`getAllFiles: rootDir=${rootDir}, resolvedPath=${resolvedPath}, absoluteRootDir=${absoluteRootDir}`);
+        // Check if directory exists and is accessible
+        try {
+            const dirStats = await stat(resolvedPath);
+            if (!dirStats.isDirectory()) {
+                Logger.error(`getAllFiles: ${resolvedPath} is not a directory`);
+                return [];
+            }
+            Logger.info(`getAllFiles: Directory exists and is accessible`);
+        }
+        catch (err) {
+            Logger.error(`getAllFiles: Cannot access directory ${resolvedPath}: ${err}`);
+            return [];
+        }
         const files = [];
         for (const pattern of patterns) {
             const matches = await glob(pattern, {
-                cwd: rootDir,
+                cwd: absoluteRootDir,
                 nodir: true, // Exclude directories that match file patterns (e.g., "404.php/")
                 dot: true, // Include files in hidden directories (e.g., ".default/")
                 ignore: [
@@ -96,6 +123,28 @@ export class FileUtils {
             });
             files.push(...matches);
         }
+        Logger.info(`getAllFiles: glob found ${files.length} raw matches`);
+        // If no files found, list directory contents for debugging
+        if (files.length === 0) {
+            try {
+                const { readdir } = await import('fs/promises');
+                const contents = await readdir(resolvedPath, { withFileTypes: true });
+                const listing = contents.map(d => `${d.isDirectory() ? '[DIR]' : '[FILE]'} ${d.name}`);
+                Logger.warn(`getAllFiles: No files found! Directory contents: ${listing.join(', ') || '(empty)'}`);
+                // If there's a single directory inside, it might be a GitHub ZIP inner folder
+                const dirs = contents.filter(d => d.isDirectory());
+                if (dirs.length === 1) {
+                    Logger.info(`getAllFiles: Found single subdirectory "${dirs[0].name}", trying to scan inside...`);
+                    const innerPath = join(resolvedPath, dirs[0].name);
+                    const innerContents = await readdir(innerPath, { withFileTypes: true });
+                    const innerListing = innerContents.slice(0, 10).map(d => `${d.isDirectory() ? '[DIR]' : '[FILE]'} ${d.name}`);
+                    Logger.info(`getAllFiles: Inner directory contents (first 10): ${innerListing.join(', ')}`);
+                }
+            }
+            catch (listErr) {
+                Logger.error(`getAllFiles: Failed to list directory: ${listErr}`);
+            }
+        }
         // Filter out large files and directories
         const filteredFiles = [];
         for (const file of [...new Set(files)]) {
@@ -113,10 +162,17 @@ export class FileUtils {
                 // Skip files we can't stat
             }
         }
+        Logger.info(`getAllFiles: returning ${filteredFiles.length} files after filtering`);
+        if (filteredFiles.length > 0 && filteredFiles.length <= 20) {
+            Logger.info(`Files found: ${filteredFiles.join(', ')}`);
+        }
+        else if (filteredFiles.length > 20) {
+            Logger.info(`First 20 files: ${filteredFiles.slice(0, 20).join(', ')}`);
+        }
         return filteredFiles;
     }
     static getLanguageFromExtension(filePath) {
-        const ext = extname(filePath);
+        const ext = extname(filePath).toLowerCase();
         const map = {
             '.ts': 'typescript',
             '.tsx': 'typescript',
@@ -133,7 +189,22 @@ export class FileUtils {
             '.cpp': 'cpp',
             '.c': 'c',
             '.h': 'c',
-            '.hpp': 'cpp'
+            '.hpp': 'cpp',
+            '.html': 'html',
+            '.htm': 'html',
+            '.css': 'css',
+            '.scss': 'scss',
+            '.sass': 'sass',
+            '.less': 'less',
+            '.json': 'json',
+            '.yaml': 'yaml',
+            '.yml': 'yaml',
+            '.xml': 'xml',
+            '.sql': 'sql',
+            '.sh': 'shell',
+            '.bash': 'shell',
+            '.md': 'markdown',
+            '.markdown': 'markdown'
         };
         return map[ext] || 'unknown';
     }
@@ -154,7 +225,8 @@ export class FileUtils {
                 size: stats.size,
                 lastModified: stats.mtime
             });
-            const dirPath = join(rootDir, rel.split('/').slice(0, -1).join('/'));
+            const parts = rel.split(/[/\\]/);
+            const dirPath = join(rootDir, ...parts.slice(0, -1));
             structure.directories.add(dirPath);
         }
         return structure;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archicore",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "AI Software Architect - code analysis, impact prediction, semantic search",
   "main": "dist/index.js",
   "type": "module",
@@ -40,15 +40,16 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.32.0",
     "@qdrant/js-client-rest": "^1.11.0",
+    "@types/unzipper": "^0.10.11",
     "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",
+    "figures": "^6.1.0",
     "glob": "^11.0.0",
     "mime-types": "^3.0.2",
     "multer": "^2.0.2",
@@ -58,6 +59,7 @@
     "tree-sitter-javascript": "^0.21.4",
     "tree-sitter-python": "^0.21.0",
     "tree-sitter-typescript": "^0.21.2",
+    "unzipper": "^0.12.3",
     "uuid": "^11.0.3",
     "zod": "^3.24.1"
   },