archicore 0.3.2 → 0.3.4

package/dist/cli/commands/interactive.js

@@ -554,7 +554,7 @@ async function handleIndexCommand() {
             });
             if (response.ok) {
                 const data = await response.json();
-                state.projectId = data.id || data.project?.id ?? null;
+                state.projectId = data.id || (data.project && data.project.id) || null;
                 registerSpinner.succeed('Project registered');
             }
             else {
@@ -693,7 +693,7 @@ async function handleIndexCommand() {
                         });
                         if (reRegisterResponse.ok) {
                             const reData = await reRegisterResponse.json();
-                            state.projectId = reData.id || reData.project?.id ?? null;
+                            state.projectId = reData.id || (reData.project && reData.project.id) || null;
                             printInfo('Project re-registered. Run /index again to complete indexing.');
                             // Обновляем локальный конфиг
                             const localProjectRetry = await getLocalProject(state.projectPath);

package/dist/server/routes/gitlab.js

@@ -21,6 +21,140 @@ export const gitlabRouter = Router();
 const gitlabService = new GitLabService();
 const projectService = new ProjectService();
 const authService = AuthService.getInstance();
+// ===== SIMPLIFIED CONNECT (for frontend) =====
+/**
+ * POST /api/gitlab/connect
+ * Simplified endpoint to connect a GitLab repository in one step
+ * Creates instance if needed, then connects repository
+ */
+gitlabRouter.post('/connect', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        const { gitlabUrl, repoPath, branch, token, autoAnalyze, analyzeMRs } = req.body;
+        if (!repoPath) {
+            res.status(400).json({ error: 'Repository path is required (e.g., owner/repo)' });
+            return;
+        }
+        const instanceUrl = gitlabUrl || 'https://gitlab.com';
+        // Check if we have an existing instance for this URL
+        let instances = await gitlabService.getInstances(req.user.id);
+        let instance = instances.find(i => i.instanceUrl === instanceUrl);
+        // If no instance and no token provided, return error
+        if (!instance && !token) {
+            res.status(400).json({
+                error: 'GitLab access token required for first connection',
+                message: 'Please provide a Personal Access Token with api scope'
+            });
+            return;
+        }
+        // Create instance if needed
+        if (!instance && token) {
+            try {
+                instance = await gitlabService.addInstance(req.user.id, instanceUrl, token, { name: instanceUrl.replace('https://', '').replace('http://', '') });
+                Logger.info(`Created GitLab instance for ${instanceUrl}`);
+            }
+            catch (e) {
+                Logger.error('Failed to create GitLab instance:', e);
+                res.status(400).json({
+                    error: 'Failed to connect to GitLab',
+                    message: e instanceof Error ? e.message : 'Invalid token or GitLab URL'
+                });
+                return;
+            }
+        }
+        if (!instance) {
+            res.status(400).json({ error: 'No GitLab instance available' });
+            return;
+        }
+        // Find the project by path
+        const projects = await gitlabService.listProjects(req.user.id, instance.id, { search: repoPath });
+        const project = projects.find(p => p.path_with_namespace === repoPath);
+        if (!project) {
+            res.status(404).json({
+                error: 'Repository not found',
+                message: `Could not find repository "${repoPath}" on ${instanceUrl}`
+            });
+            return;
+        }
+        // Check usage limit
+        const usageResult = await authService.checkAndUpdateUsage(req.user.id, 'project');
+        if (!usageResult.allowed) {
+            res.status(429).json({
+                error: 'Project limit reached',
+                message: `You have reached your daily project limit (${usageResult.limit})`,
+                usage: { used: usageResult.limit, limit: usageResult.limit, remaining: 0 }
+            });
+            return;
+        }
+        // Connect repository
+        const connectedRepo = await gitlabService.connectRepository(req.user.id, instance.id, project.id, { autoAnalyze: autoAnalyze !== false, analyzeMRs: analyzeMRs !== false });
+        // Download and create ArchiCore project
+        const targetBranch = branch || project.default_branch || 'main';
+        Logger.progress(`Downloading GitLab repository: ${project.path_with_namespace} (branch: ${targetBranch})`);
+        const zipBuffer = await gitlabService.downloadRepository(req.user.id, instance.id, project.id, targetBranch);
+        // Create projects directory
+        const projectsDir = process.env.PROJECTS_DIR || join('.archicore', 'projects');
+        await mkdir(projectsDir, { recursive: true });
+        // Extract to project directory
+        const projectPath = join(projectsDir, project.name);
+        await mkdir(projectPath, { recursive: true });
+        const zip = new AdmZip(zipBuffer);
+        const zipEntries = zip.getEntries();
+        // Extract files
+        for (const entry of zipEntries) {
+            if (entry.isDirectory) {
+                const dirPath = join(projectPath, entry.entryName);
+                await mkdir(dirPath, { recursive: true });
+            }
+            else {
+                const filePath = join(projectPath, entry.entryName);
+                const fileDir = join(projectPath, entry.entryName.split('/').slice(0, -1).join('/'));
+                await mkdir(fileDir, { recursive: true });
+                const content = entry.getData();
+                const { writeFile } = await import('fs/promises');
+                await writeFile(filePath, content);
+            }
+        }
+        // GitLab creates a folder like "project-branch" inside, find it
+        const { readdir, stat } = await import('fs/promises');
+        const contents = await readdir(projectPath);
+        let actualPath = projectPath;
+        if (contents.length === 1) {
+            const innerPath = join(projectPath, contents[0]);
+            const stats = await stat(innerPath);
+            if (stats.isDirectory()) {
+                actualPath = innerPath;
+            }
+        }
+        Logger.success(`Downloaded and extracted to: ${actualPath}`);
+        // Create ArchiCore project
+        const archiProject = await projectService.createProject(project.name, actualPath, req.user.id);
+        // Update connected repo with project ID
+        await gitlabService.updateRepositoryProjectId(connectedRepo.id, archiProject.id);
+        await gitlabService.updateRepositoryStatus(connectedRepo.id, 'active');
+        res.json({
+            success: true,
+            project: {
+                id: archiProject.id,
+                name: archiProject.name,
+                path: actualPath
+            },
+            repository: {
+                id: connectedRepo.id,
+                fullPath: project.path_with_namespace,
+                branch: targetBranch
+            }
+        });
+    }
+    catch (error) {
+        Logger.error('GitLab connect error:', error);
+        const message = error instanceof Error ? error.message : 'Failed to connect GitLab repository';
+        res.status(500).json({ error: message });
+    }
+});
 // ===== INSTANCE MANAGEMENT =====
 /**
  * POST /api/gitlab/instances

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archicore",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "AI Software Architect - code analysis, impact prediction, semantic search",
   "main": "dist/index.js",
   "type": "module",