archicore 0.3.3 → 0.3.5

package/dist/cli/commands/auth.js

@@ -32,7 +32,14 @@ export async function getCurrentUser() {
             return null;
         }
         const data = await response.json();
-        return data.user;
+        if (!data.user)
+            return null;
+        return {
+            id: data.user.id,
+            email: data.user.email,
+            name: data.user.name || data.user.username,
+            tier: data.user.tier || 'free'
+        };
     }
     catch {
         return null;

package/dist/cli/commands/interactive.js

@@ -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/cli/ui/autocomplete.js

@@ -244,7 +244,7 @@ export function createSimpleAutocomplete(rl, commands, prompt) {
         }
         return [[], line];
     };
-    // Return the completer function
+    // Return the completer function (accessing internal Node.js readline property)
     rl._completer = completer;
 }
 //# sourceMappingURL=autocomplete.js.map

package/dist/cli/utils/project-selector.js

@@ -22,7 +22,7 @@ export async function fetchUserProjects() {
         if (!response.ok)
             return [];
         const data = await response.json();
-        return (data.projects || data || []).map((p) => ({
+        return (data.projects || []).map((p) => ({
             id: p.id,
             name: p.name,
             path: p.path,

package/dist/server/config/passport.js

@@ -50,12 +50,14 @@ if (process.env.GITHUB_OAUTH_CLIENT_ID && process.env.GITHUB_OAUTH_CLIENT_SECRET
         try {
             Logger.info(`[OAuth] GitHub authentication for user: ${profile.username}`);
             // GitHub might not provide email in profile, check emails array
-            const email = profile.emails?.[0]?.value || profile._json?.email || '';
+            // _json contains raw GitHub API response (not typed in passport-github2)
+            const rawProfile = profile;
+            const email = profile.emails?.[0]?.value || rawProfile._json?.email || '';
             const oauthProfile = {
                 id: profile.id,
                 email,
                 displayName: profile.displayName || profile.username || '',
-                avatar: profile.photos?.[0]?.value || profile._json?.avatar_url,
+                avatar: profile.photos?.[0]?.value || rawProfile._json?.avatar_url,
                 provider: 'github',
             };
             // Validate email

package/dist/server/index.js

@@ -172,7 +172,7 @@ export class ArchiCoreServer {
                         scriptSrcAttr: ["'unsafe-inline'", "'unsafe-hashes'"],
                         imgSrc: ["'self'", "data:", "https:"],
                         fontSrc: ["'self'", "https://fonts.gstatic.com"],
-                        connectSrc: ["'self'", "https://api.jina.ai", "https://api.openai.com", "https://api.anthropic.com"],
+                        connectSrc: ["'self'", "https://api.jina.ai", "https://api.openai.com", "https://api.anthropic.com", "https://cdn.jsdelivr.net"],
                     },
                 },
                 crossOriginResourcePolicy: { policy: 'cross-origin' },

package/dist/server/routes/admin.js

@@ -90,6 +90,7 @@ adminRouter.get('/users/:id', async (req, res) => {
             res.status(404).json({ error: 'User not found' });
             return;
         }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
         const { passwordHash, ...sanitized } = user;
         res.json({ user: sanitized });
     }
@@ -434,6 +435,7 @@ adminRouter.get('/export/all', async (_req, res) => {
         const auditLogs = await auditService.query({ limit: 1000, offset: 0 });
         // Sanitize user data (remove passwords)
         const sanitizedUsers = users.map(u => {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
             const { passwordHash, ...safe } = u;
             return safe;
         });

package/dist/server/routes/api.js

@@ -333,7 +333,7 @@ apiRouter.post('/projects/:id/upload-index/finalize', authMiddleware, checkProje
         }
         Logger.info(`Finalizing chunked upload ${uploadId}: ${upload.asts.length} ASTs, ${upload.symbols.length} symbols`);
         // Собираем все данные и отправляем в projectService
-        // Type cast because chunked data comes as unknown from JSON
+        // Type cast needed: chunked data comes as serialized JSON, types match at runtime
         const result = await projectService.uploadIndexedData(id, {
             asts: upload.asts,
             symbols: upload.symbols,

package/dist/server/routes/gitlab.js

@@ -21,6 +21,152 @@ 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 - try direct fetch first (works for private repos)
+        let project;
+        try {
+            // GitLab API accepts URL-encoded path like "owner%2Frepo"
+            project = await gitlabService.getProject(req.user.id, instance.id, repoPath);
+        }
+        catch (e) {
+            // If direct fetch fails, try searching
+            Logger.debug(`Direct project fetch failed, trying search: ${e}`);
+            const projects = await gitlabService.listProjects(req.user.id, instance.id, {
+                search: repoPath.split('/').pop(), // Search by repo name only
+                membership: false // Include all accessible repos
+            });
+            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}. Make sure the path is correct (e.g., "owner/repo") and your token has access to it.`
+            });
+            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/dist/server/services/project-service.js

@@ -536,7 +536,7 @@ export class ProjectService {
                 graphNodes.set(key, {
                     id: node.id,
                     name: node.name,
-                    type: node.type || 'file',
+                    type: (node.type || 'file'),
                     filePath: node.filePath,
                     metadata: node.metadata || {}
                 });
@@ -630,7 +630,7 @@ export class ProjectService {
                 graphNodes.set(key, {
                     id: node.id,
                     name: node.name,
-                    type: node.type || 'file',
+                    type: (node.type || 'file'),
                     filePath: node.filePath,
                     metadata: node.metadata || {}
                 });

package/dist/types/api.d.ts

@@ -282,5 +282,92 @@ export interface UserProfileResponse {
     };
     error?: string;
 }
+/** Generic error response from API */
+export interface ErrorResponse {
+    error?: string;
+    message?: string;
+    success?: boolean;
+}
+/** Project data from API */
+export interface ProjectData {
+    id: string;
+    name: string;
+    path: string;
+    status?: string;
+    indexed?: boolean;
+    lastAccess?: string;
+    updatedAt?: string;
+    lastIndexed?: string;
+    statistics?: {
+        codeIndex?: {
+            totalFiles?: number;
+            totalSymbols?: number;
+        };
+    };
+    stats?: {
+        filesCount?: number;
+        symbolsCount?: number;
+    };
+}
+/** Projects list response */
+export interface ProjectsListData {
+    projects?: ProjectData[];
+    success?: boolean;
+    error?: string;
+}
+/** Single project response */
+export interface ProjectDetailData {
+    project?: ProjectData;
+    success?: boolean;
+    error?: string;
+}
+/** User response from profile endpoint */
+export interface UserData {
+    id: string;
+    email: string;
+    username?: string;
+    tier?: string;
+    provider?: string;
+    avatar?: string;
+}
+/** User profile response */
+export interface UserProfileData {
+    user?: UserData;
+    success?: boolean;
+    error?: string;
+}
+/** Export response */
+export interface ExportData {
+    success?: boolean;
+    export?: unknown;
+    error?: string;
+}
+/** Graph node for visualization */
+export interface GraphNodeData {
+    id: string;
+    label?: string;
+    type?: string;
+    filePath?: string;
+    kind?: string;
+    size?: number;
+    group?: string;
+}
+/** Graph edge for visualization */
+export interface GraphEdgeData {
+    from: string;
+    to: string;
+    type?: string;
+}
+/** Symbol data */
+export interface SymbolData {
+    id: string;
+    name: string;
+    kind: string;
+    filePath: string;
+    startLine: number;
+    endLine: number;
+    references?: string[];
+    modifiers?: string[];
+}
 export declare const DEFAULT_RATE_LIMITS: Record<string, RateLimitConfig>;
 //# sourceMappingURL=api.d.ts.map

package/package.json

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