archicore 0.1.2 → 0.1.3

package/dist/cli/commands/auth.d.ts

@@ -0,0 +1,38 @@
+/**
+ * ArchiCore CLI - Authentication
+ *
+ * Device authorization flow for CLI
+ */
+interface TokenResponse {
+    accessToken: string;
+    refreshToken?: string;
+    expiresIn: number;
+    user: {
+        id: string;
+        email: string;
+        name?: string;
+        tier: string;
+    };
+}
+/**
+ * Check if user is authenticated
+ */
+export declare function isAuthenticated(): Promise<boolean>;
+/**
+ * Get current user info
+ */
+export declare function getCurrentUser(): Promise<TokenResponse['user'] | null>;
+/**
+ * Login via device flow
+ */
+export declare function login(): Promise<boolean>;
+/**
+ * Logout - clear stored tokens
+ */
+export declare function logout(): Promise<void>;
+/**
+ * Require authentication - prompt login if needed
+ */
+export declare function requireAuth(): Promise<TokenResponse['user'] | null>;
+export {};
+//# sourceMappingURL=auth.d.ts.map

package/dist/cli/commands/auth.js

@@ -0,0 +1,164 @@
+/**
+ * ArchiCore CLI - Authentication
+ *
+ * Device authorization flow for CLI
+ */
+import { loadConfig, saveConfig } from '../utils/config.js';
+import { colors, createSpinner, printSuccess, printError, printInfo } from '../ui/index.js';
+/**
+ * Check if user is authenticated
+ */
+export async function isAuthenticated() {
+    const config = await loadConfig();
+    return !!config.accessToken;
+}
+/**
+ * Get current user info
+ */
+export async function getCurrentUser() {
+    const config = await loadConfig();
+    if (!config.accessToken) {
+        return null;
+    }
+    try {
+        const response = await fetch(`${config.serverUrl}/api/auth/me`, {
+            headers: {
+                'Authorization': `Bearer ${config.accessToken}`,
+            },
+        });
+        if (!response.ok) {
+            // Token expired or invalid
+            await saveConfig({ accessToken: undefined, refreshToken: undefined });
+            return null;
+        }
+        const data = await response.json();
+        return data.user;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Login via device flow
+ */
+export async function login() {
+    const config = await loadConfig();
+    console.log();
+    const spinner = createSpinner('Requesting authorization...').start();
+    try {
+        // Step 1: Request device code
+        const codeResponse = await fetch(`${config.serverUrl}/api/auth/device/code`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+        });
+        if (!codeResponse.ok) {
+            spinner.fail('Failed to start authorization');
+            return false;
+        }
+        const codeData = await codeResponse.json();
+        spinner.stop();
+        // Step 2: Show user the code and URL
+        console.log();
+        console.log(colors.primary.bold('  Authorization Required'));
+        console.log();
+        console.log(`  ${colors.muted('1.')} Open this URL in your browser:`);
+        console.log();
+        console.log(`     ${colors.accent.bold(codeData.verificationUrl)}`);
+        console.log();
+        console.log(`  ${colors.muted('2.')} Enter this code:`);
+        console.log();
+        console.log(`     ${colors.highlight.bold(codeData.userCode)}`);
+        console.log();
+        // Step 3: Poll for token
+        const pollSpinner = createSpinner('Waiting for authorization...').start();
+        const token = await pollForToken(config.serverUrl, codeData.deviceCode, codeData.interval * 1000, codeData.expiresIn * 1000);
+        if (!token) {
+            pollSpinner.fail('Authorization timed out or was denied');
+            return false;
+        }
+        // Step 4: Save token
+        await saveConfig({
+            accessToken: token.accessToken,
+            refreshToken: token.refreshToken,
+        });
+        pollSpinner.succeed('Authorized!');
+        console.log();
+        printSuccess(`Welcome, ${token.user.name || token.user.email}!`);
+        printInfo(`Plan: ${token.user.tier}`);
+        console.log();
+        return true;
+    }
+    catch (error) {
+        spinner.fail('Authorization failed');
+        printError(String(error));
+        return false;
+    }
+}
+/**
+ * Poll for token after user authorizes
+ */
+async function pollForToken(serverUrl, deviceCode, interval, timeout) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+        await sleep(interval);
+        try {
+            const response = await fetch(`${serverUrl}/api/auth/device/token`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ deviceCode }),
+            });
+            if (response.ok) {
+                return await response.json();
+            }
+            const error = await response.json();
+            if (error.error === 'authorization_pending') {
+                // User hasn't authorized yet, keep polling
+                continue;
+            }
+            if (error.error === 'slow_down') {
+                // Slow down polling
+                interval += 1000;
+                continue;
+            }
+            if (error.error === 'expired_token' || error.error === 'access_denied') {
+                return null;
+            }
+        }
+        catch {
+            // Network error, keep trying
+        }
+    }
+    return null;
+}
+/**
+ * Logout - clear stored tokens
+ */
+export async function logout() {
+    await saveConfig({
+        accessToken: undefined,
+        refreshToken: undefined,
+    });
+    console.log();
+    printSuccess('Logged out successfully');
+    console.log();
+}
+/**
+ * Require authentication - prompt login if needed
+ */
+export async function requireAuth() {
+    const user = await getCurrentUser();
+    if (user) {
+        return user;
+    }
+    console.log();
+    printInfo('Please log in to continue');
+    const success = await login();
+    if (!success) {
+        return null;
+    }
+    return getCurrentUser();
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=auth.js.map

package/dist/cli/commands/index.d.ts

@@ -5,4 +5,5 @@ export { registerAnalyzerCommands } from './analyzers.js';
 export { registerExportCommand } from './export.js';
 export { startInteractiveMode } from './interactive.js';
 export { initProject, isInitialized, getLocalProject } from './init.js';
+export { login, logout, isAuthenticated, getCurrentUser, requireAuth } from './auth.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/cli/commands/index.js

@@ -5,4 +5,5 @@ export { registerAnalyzerCommands } from './analyzers.js';
 export { registerExportCommand } from './export.js';
 export { startInteractiveMode } from './interactive.js';
 export { initProject, isInitialized, getLocalProject } from './init.js';
+export { login, logout, isAuthenticated, getCurrentUser, requireAuth } from './auth.js';
 //# sourceMappingURL=index.js.map

package/dist/cli/commands/interactive.js

@@ -7,6 +7,7 @@ import * as readline from 'readline';
 import { loadConfig } from '../utils/config.js';
 import { checkServerConnection } from '../utils/session.js';
 import { isInitialized, getLocalProject } from './init.js';
+import { requireAuth, logout } from './auth.js';
 import { colors, icons, createSpinner, printHelp, printGoodbye, printSection, printSuccess, printError, printWarning, printInfo, printKeyValue, header, } from '../ui/index.js';
 const state = {
     running: true,
@@ -14,6 +15,7 @@ const state = {
     projectName: null,
     projectPath: process.cwd(),
     history: [],
+    user: null,
 };
 export async function startInteractiveMode() {
     // Check if initialized in current directory
@@ -37,13 +39,21 @@ export async function startInteractiveMode() {
     const connected = await checkServerConnection();
     if (!connected) {
         spinner.fail('Cannot connect to ArchiCore server');
-        printError('Make sure the server is running: npm run server');
+        printError('Make sure the server is running');
         process.exit(1);
     }
     spinner.succeed('Connected');
+    // Require authentication
+    const user = await requireAuth();
+    if (!user) {
+        printError('Authentication required');
+        process.exit(1);
+    }
+    state.user = user;
     // Print welcome
     console.log();
     console.log(header('ArchiCore', 'AI Software Architect'));
+    console.log(colors.muted(`  User: ${colors.primary(user.name || user.email)} (${user.tier})`));
     if (state.projectName) {
         console.log(colors.muted(`  Project: ${colors.primary(state.projectName)}`));
     }
@@ -159,36 +169,54 @@ async function handleCommand(input) {
         case 'stats':
             await handleMetricsCommand();
             break;
+        case 'duplication':
+        case 'duplicates':
+            await handleDuplicationCommand();
+            break;
+        case 'refactoring':
+        case 'refactor':
+            await handleRefactoringCommand();
+            break;
+        case 'rules':
+            await handleRulesCommand();
+            break;
         case 'export':
             await handleExportCommand(args);
             break;
         case 'status':
             await handleStatusCommand();
             break;
+        case 'logout':
+            await logout();
+            state.running = false;
+            break;
         default:
             printError(`Unknown command: /${command}`);
             printInfo('Use /help to see available commands');
     }
 }
 async function handleIndexCommand() {
+    const config = await loadConfig();
+    // Регистрируем проект на сервере если ещё нет ID
     if (!state.projectId) {
-        // Try to register project first
-        const spinner = createSpinner('Registering project...').start();
+        const registerSpinner = createSpinner('Registering project...').start();
         try {
-            const config = await loadConfig();
             const response = await fetch(`${config.serverUrl}/api/projects`, {
                 method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${config.accessToken}`,
+                },
                 body: JSON.stringify({ name: state.projectName, path: state.projectPath }),
             });
             if (response.ok) {
                 const data = await response.json();
                 state.projectId = data.id || data.project?.id;
             }
-            spinner.stop();
+            registerSpinner.succeed('Project registered');
         }
         catch {
-            spinner.fail('Failed to register project');
+            registerSpinner.fail('Failed to register project');
             return;
         }
     }
@@ -196,32 +224,81 @@ async function handleIndexCommand() {
         printError('Failed to register project with server');
         return;
     }
-    const spinner = createSpinner('Indexing project...').start();
+    // Локальная индексация
+    const indexSpinner = createSpinner('Parsing local files...').start();
     try {
-        const config = await loadConfig();
-        const response = await fetch(`${config.serverUrl}/api/projects/${state.projectId}/index`, {
+        // Динамический импорт CodeIndex
+        const { CodeIndex } = await import('../../code-index/index.js');
+        const fs = await import('fs/promises');
+        const pathModule = await import('path');
+        const codeIndex = new CodeIndex(state.projectPath);
+        // Парсим AST
+        const asts = await codeIndex.parseProject();
+        indexSpinner.update(`Parsed ${asts.size} files, extracting symbols...`);
+        // Извлекаем символы
+        const symbols = codeIndex.extractSymbols(asts);
+        indexSpinner.update(`Found ${symbols.size} symbols, building graph...`);
+        // Строим граф зависимостей
+        const graph = codeIndex.buildDependencyGraph(asts, symbols);
+        indexSpinner.update('Reading file contents...');
+        // Читаем содержимое файлов
+        const fileContents = [];
+        for (const [filePath] of asts) {
+            try {
+                const fullPath = pathModule.default.isAbsolute(filePath)
+                    ? filePath
+                    : pathModule.default.join(state.projectPath, filePath);
+                const content = await fs.readFile(fullPath, 'utf-8');
+                fileContents.push([filePath, content]);
+            }
+            catch {
+                // Игнорируем ошибки чтения
+            }
+        }
+        indexSpinner.update('Uploading to server...');
+        // Конвертируем Maps в массивы для JSON
+        const astsArray = Array.from(asts.entries());
+        const symbolsArray = Array.from(symbols.entries());
+        const graphData = {
+            nodes: Array.from(graph.nodes.entries()),
+            edges: Array.from(graph.edges.entries()),
+        };
+        // Отправляем на сервер
+        const response = await fetch(`${config.serverUrl}/api/projects/${state.projectId}/upload-index`, {
             method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${config.accessToken}`,
+            },
+            body: JSON.stringify({
+                asts: astsArray,
+                symbols: symbolsArray,
+                graph: graphData,
+                fileContents,
+                statistics: {
+                    totalFiles: asts.size,
+                    totalSymbols: symbols.size,
+                },
+            }),
         });
         if (!response.ok) {
-            throw new Error('Indexing failed');
+            const errorData = await response.json().catch(() => ({}));
+            throw new Error(errorData.error || 'Upload failed');
         }
         const data = await response.json();
-        spinner.succeed('Project indexed');
-        printKeyValue('Files', String(data.statistics?.totalFiles || 0));
-        printKeyValue('Symbols', String(data.statistics?.totalSymbols || 0));
-        // Update local config
-        const { getLocalProject } = await import('./init.js');
+        indexSpinner.succeed('Project indexed and uploaded');
+        printKeyValue('Files', String(data.statistics?.filesCount || asts.size));
+        printKeyValue('Symbols', String(data.statistics?.symbolsCount || symbols.size));
+        // Обновляем локальный конфиг
         const localProject = await getLocalProject(state.projectPath);
         if (localProject) {
             localProject.id = state.projectId;
             localProject.indexed = true;
-            const fs = await import('fs/promises');
-            const path = await import('path');
-            await fs.writeFile(path.join(state.projectPath, '.archicore', 'project.json'), JSON.stringify(localProject, null, 2));
+            await fs.writeFile(pathModule.default.join(state.projectPath, '.archicore', 'project.json'), JSON.stringify(localProject, null, 2));
         }
     }
     catch (error) {
-        spinner.fail('Indexing failed');
+        indexSpinner.fail('Indexing failed');
         printError(String(error));
     }
 }
@@ -512,6 +589,36 @@ async function handleStatusCommand() {
     const connected = await checkServerConnection();
     console.log(`  Server: ${connected ? colors.success('Connected') : colors.error('Disconnected')}`);
     console.log(`  URL: ${colors.muted(config.serverUrl)}`);
+    if (state.user) {
+        console.log(`  User: ${colors.primary(state.user.name || state.user.email)}`);
+        console.log(`  Plan: ${colors.highlight(state.user.tier)}`);
+        // Get subscription details
+        try {
+            const response = await fetch(`${config.serverUrl}/api/auth/subscription`, {
+                headers: { 'Authorization': `Bearer ${config.accessToken}` },
+            });
+            if (response.ok) {
+                const data = await response.json();
+                if (data.expiresAt) {
+                    const expiresDate = new Date(data.expiresAt);
+                    const now = new Date();
+                    const daysLeft = Math.ceil((expiresDate.getTime() - now.getTime()) / (1000 * 60 * 60 * 24));
+                    if (daysLeft > 0) {
+                        console.log(`  Expires: ${colors.muted(expiresDate.toLocaleDateString())} (${daysLeft} days left)`);
+                    }
+                    else {
+                        console.log(`  Expires: ${colors.error('Expired')}`);
+                    }
+                }
+                if (data.usage) {
+                    console.log(`  Usage: ${data.usage.used}/${data.usage.limit} requests today`);
+                }
+            }
+        }
+        catch {
+            // Ignore subscription fetch errors
+        }
+    }
     if (state.projectId) {
         console.log(`  Project: ${colors.primary(state.projectName || state.projectId)}`);
     }
@@ -519,4 +626,122 @@ async function handleStatusCommand() {
         console.log(`  Project: ${colors.muted('None selected')}`);
     }
 }
+async function handleDuplicationCommand() {
+    if (!state.projectId) {
+        printError('No project indexed');
+        printInfo('Use /index first');
+        return;
+    }
+    const spinner = createSpinner('Analyzing code duplication...').start();
+    try {
+        const config = await loadConfig();
+        const response = await fetch(`${config.serverUrl}/api/projects/${state.projectId}/duplication`);
+        if (!response.ok)
+            throw new Error('Analysis failed');
+        const data = await response.json();
+        const result = data.duplication;
+        spinner.succeed('Analysis complete');
+        printSection('Code Duplication');
+        console.log(`  Code clones: ${result.clones?.length || 0}`);
+        console.log(`  Duplication rate: ${(result.duplicationRate || 0).toFixed(1)}%`);
+        console.log(`  Duplicated lines: ${result.duplicatedLines || 0}`);
+        if (result.clones?.length > 0) {
+            console.log();
+            console.log(colors.muted('  Top duplicates:'));
+            for (const clone of result.clones.slice(0, 5)) {
+                console.log(`    ${colors.warning(icons.warning)} ${clone.files?.length || 2} files, ${clone.lines || 0} lines`);
+                if (clone.files) {
+                    for (const f of clone.files.slice(0, 2)) {
+                        console.log(`      ${colors.dim(f)}`);
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        spinner.fail('Analysis failed');
+        throw error;
+    }
+}
+async function handleRefactoringCommand() {
+    if (!state.projectId) {
+        printError('No project indexed');
+        printInfo('Use /index first');
+        return;
+    }
+    const spinner = createSpinner('Generating refactoring suggestions...').start();
+    try {
+        const config = await loadConfig();
+        const response = await fetch(`${config.serverUrl}/api/projects/${state.projectId}/refactoring`);
+        if (!response.ok)
+            throw new Error('Analysis failed');
+        const data = await response.json();
+        const suggestions = data.refactoring?.suggestions || [];
+        spinner.succeed('Analysis complete');
+        printSection('Refactoring Suggestions');
+        if (suggestions.length === 0) {
+            printSuccess('No refactoring needed!');
+            return;
+        }
+        console.log(`  Total suggestions: ${suggestions.length}`);
+        const critical = suggestions.filter((s) => s.priority === 'critical');
+        const high = suggestions.filter((s) => s.priority === 'high');
+        if (critical.length > 0) {
+            console.log(`  ${colors.critical(`Critical: ${critical.length}`)}`);
+        }
+        if (high.length > 0) {
+            console.log(`  ${colors.high(`High: ${high.length}`)}`);
+        }
+        console.log();
+        console.log(colors.muted('  Top suggestions:'));
+        for (const s of suggestions.slice(0, 5)) {
+            const priorityColor = s.priority === 'critical' ? colors.critical :
+                s.priority === 'high' ? colors.high : colors.muted;
+            console.log(`    ${priorityColor(`[${s.priority}]`)} ${s.type}: ${s.description}`);
+            if (s.file) {
+                console.log(`      ${colors.dim(s.file)}`);
+            }
+        }
+    }
+    catch (error) {
+        spinner.fail('Analysis failed');
+        throw error;
+    }
+}
+async function handleRulesCommand() {
+    if (!state.projectId) {
+        printError('No project indexed');
+        printInfo('Use /index first');
+        return;
+    }
+    const spinner = createSpinner('Checking architectural rules...').start();
+    try {
+        const config = await loadConfig();
+        const response = await fetch(`${config.serverUrl}/api/projects/${state.projectId}/rules`);
+        if (!response.ok)
+            throw new Error('Analysis failed');
+        const data = await response.json();
+        const violations = data.rules?.violations || [];
+        spinner.succeed('Analysis complete');
+        printSection('Architectural Rules');
+        if (violations.length === 0) {
+            printSuccess('All rules passed!');
+            return;
+        }
+        console.log(`  Violations: ${violations.length}`);
+        console.log();
+        for (const v of violations.slice(0, 10)) {
+            const severityColor = v.severity === 'error' ? colors.error :
+                v.severity === 'warning' ? colors.warning : colors.muted;
+            console.log(`    ${severityColor(icons.error)} ${v.rule}: ${v.message}`);
+            if (v.file) {
+                console.log(`      ${colors.dim(v.file)}`);
+            }
+        }
+    }
+    catch (error) {
+        spinner.fail('Analysis failed');
+        throw error;
+    }
+}
 //# sourceMappingURL=interactive.js.map

package/dist/cli/ui/prompt.js

@@ -75,8 +75,12 @@ export function printHelp() {
         ['/dead-code', 'Find dead code'],
         ['/security', 'Security analysis'],
         ['/metrics', 'Code metrics'],
+        ['/duplication', 'Find code duplicates'],
+        ['/refactoring', 'Refactoring suggestions'],
+        ['/rules', 'Check architecture rules'],
         ['/export [format]', 'Export (json/html/md)'],
         ['/status', 'Show current status'],
+        ['/logout', 'Log out'],
         ['/clear', 'Clear screen'],
         ['/help', 'Show this help'],
         ['/exit', 'Exit ArchiCore'],

package/dist/cli/utils/config.d.ts

@@ -5,6 +5,8 @@ export interface CLIConfig {
     activeProjectId?: string;
     activeProjectPath?: string;
     serverUrl: string;
+    accessToken?: string;
+    refreshToken?: string;
     colorOutput: boolean;
     verboseOutput: boolean;
     llmProvider?: 'openai' | 'anthropic' | 'deepseek';

package/dist/server/index.js

@@ -20,6 +20,7 @@ import { authRouter } from './routes/auth.js';
 import { adminRouter } from './routes/admin.js';
 import { developerRouter } from './routes/developer.js';
 import { githubRouter } from './routes/github.js';
+import deviceAuthRouter from './routes/device-auth.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 export class ArchiCoreServer {
@@ -55,6 +56,8 @@ export class ArchiCoreServer {
     setupRoutes() {
         // Auth routes
         this.app.use('/api/auth', authRouter);
+        // Device auth for CLI
+        this.app.use('/api/auth/device', deviceAuthRouter);
         // Admin routes
         this.app.use('/api/admin', adminRouter);
         // Developer API routes (for API key management and public API)

package/dist/server/routes/api.js

@@ -64,7 +64,7 @@ apiRouter.get('/projects/:id', async (req, res) => {
 });
 /**
  * POST /api/projects/:id/index
- * Запустить индексацию проекта
+ * Запустить индексацию проекта (только для локальных проектов на сервере)
  */
 apiRouter.post('/projects/:id/index', async (req, res) => {
     try {
@@ -77,6 +77,33 @@ apiRouter.post('/projects/:id/index', async (req, res) => {
         res.status(500).json({ error: 'Failed to index project' });
     }
 });
+/**
+ * POST /api/projects/:id/upload-index
+ * Загрузить индексированные данные с CLI
+ * CLI выполняет индексацию локально и отправляет результаты сюда
+ */
+apiRouter.post('/projects/:id/upload-index', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const { asts, symbols, graph, fileContents, statistics } = req.body;
+        if (!asts || !symbols || !graph) {
+            res.status(400).json({ error: 'asts, symbols, and graph are required' });
+            return;
+        }
+        const result = await projectService.uploadIndexedData(id, {
+            asts,
+            symbols,
+            graph,
+            fileContents,
+            statistics
+        });
+        res.json(result);
+    }
+    catch (error) {
+        Logger.error('Failed to upload indexed data:', error);
+        res.status(500).json({ error: 'Failed to upload indexed data' });
+    }
+});
 /**
  * GET /api/projects/:id/architecture
  * Получить архитектурную модель (Digital Twin)

package/dist/server/routes/auth.js

@@ -188,4 +188,47 @@ authRouter.get('/usage', authMiddleware, async (req, res) => {
         res.status(500).json({ error: 'Failed to get usage' });
     }
 });
+/**
+ * GET /api/auth/subscription
+ * Get current user's subscription details (for CLI /status)
+ */
+authRouter.get('/subscription', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        const user = await authService.getUser(req.user.id);
+        if (!user) {
+            res.status(404).json({ error: 'User not found' });
+            return;
+        }
+        // Определяем лимиты по тарифу
+        const tierLimits = {
+            free: { requests: 50, projects: 2 },
+            pro: { requests: 500, projects: 10 },
+            team: { requests: 2000, projects: 50 },
+            enterprise: { requests: -1, projects: -1 }, // unlimited
+            admin: { requests: -1, projects: -1 }, // unlimited
+        };
+        const limits = tierLimits[user.tier] || tierLimits.free;
+        res.json({
+            tier: user.tier,
+            expiresAt: user.subscription?.endDate || null,
+            status: user.subscription?.status || 'active',
+            usage: {
+                used: user.usage?.requestsToday || 0,
+                limit: limits.requests,
+            },
+            limits: {
+                requestsPerDay: limits.requests,
+                maxProjects: limits.projects,
+            },
+        });
+    }
+    catch (error) {
+        Logger.error('Get subscription error:', error);
+        res.status(500).json({ error: 'Failed to get subscription' });
+    }
+});
 //# sourceMappingURL=auth.js.map

package/dist/server/routes/device-auth.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Device Authorization Flow for CLI
+ *
+ * OAuth 2.0 Device Authorization Grant (RFC 8628)
+ */
+declare const router: import("express-serve-static-core").Router;
+export default router;
+//# sourceMappingURL=device-auth.d.ts.map

package/dist/server/routes/device-auth.js

@@ -0,0 +1,149 @@
+/**
+ * Device Authorization Flow for CLI
+ *
+ * OAuth 2.0 Device Authorization Grant (RFC 8628)
+ */
+import { Router } from 'express';
+import { randomBytes } from 'crypto';
+const router = Router();
+const pendingAuths = new Map();
+// Generate random codes
+function generateDeviceCode() {
+    return randomBytes(32).toString('hex');
+}
+function generateUserCode() {
+    // User-friendly code: XXXX-XXXX
+    const chars = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789'; // Exclude confusing chars
+    let code = '';
+    for (let i = 0; i < 8; i++) {
+        if (i === 4)
+            code += '-';
+        code += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return code;
+}
+// Clean up expired codes
+function cleanupExpired() {
+    const now = Date.now();
+    for (const [code, auth] of pendingAuths.entries()) {
+        if (auth.expiresAt < now) {
+            pendingAuths.delete(code);
+        }
+    }
+}
+/**
+ * POST /api/auth/device/code
+ * Request a new device code
+ */
+router.post('/code', (_req, res) => {
+    cleanupExpired();
+    const deviceCode = generateDeviceCode();
+    const userCode = generateUserCode();
+    const expiresIn = 600; // 10 minutes
+    const auth = {
+        deviceCode,
+        userCode,
+        expiresAt: Date.now() + expiresIn * 1000,
+        interval: 5,
+        status: 'pending',
+    };
+    pendingAuths.set(deviceCode, auth);
+    // Also index by user code for lookup
+    pendingAuths.set(userCode, auth);
+    const serverUrl = process.env.PUBLIC_URL || `http://${process.env.HOST || 'localhost'}:${process.env.PORT || 3000}`;
+    res.json({
+        deviceCode,
+        userCode,
+        verificationUrl: `${serverUrl}/auth/device?code=${userCode}`,
+        expiresIn,
+        interval: auth.interval,
+    });
+});
+/**
+ * POST /api/auth/device/token
+ * Poll for token (called by CLI)
+ */
+router.post('/token', (req, res) => {
+    const { deviceCode } = req.body;
+    if (!deviceCode) {
+        res.status(400).json({ error: 'invalid_request', message: 'Missing device_code' });
+        return;
+    }
+    const auth = pendingAuths.get(deviceCode);
+    if (!auth) {
+        res.status(400).json({ error: 'invalid_grant', message: 'Invalid or expired device code' });
+        return;
+    }
+    if (auth.expiresAt < Date.now()) {
+        pendingAuths.delete(deviceCode);
+        res.status(400).json({ error: 'expired_token', message: 'Device code expired' });
+        return;
+    }
+    if (auth.status === 'denied') {
+        pendingAuths.delete(deviceCode);
+        pendingAuths.delete(auth.userCode);
+        res.status(400).json({ error: 'access_denied', message: 'User denied authorization' });
+        return;
+    }
+    if (auth.status === 'pending') {
+        res.status(400).json({ error: 'authorization_pending', message: 'Waiting for user authorization' });
+        return;
+    }
+    // Authorized - return token
+    pendingAuths.delete(deviceCode);
+    pendingAuths.delete(auth.userCode);
+    res.json({
+        accessToken: auth.accessToken,
+        expiresIn: 86400 * 30, // 30 days
+        user: {
+            id: auth.userId,
+            email: 'user@example.com', // TODO: Get from user service
+            tier: 'free', // TODO: Get from user service
+        },
+    });
+});
+/**
+ * GET /api/auth/device/verify
+ * Get device auth info by user code (for web page)
+ */
+router.get('/verify/:userCode', (req, res) => {
+    const { userCode } = req.params;
+    const auth = pendingAuths.get(userCode.toUpperCase());
+    if (!auth || auth.expiresAt < Date.now()) {
+        res.status(404).json({ error: 'not_found', message: 'Invalid or expired code' });
+        return;
+    }
+    res.json({
+        userCode: auth.userCode,
+        status: auth.status,
+        expiresIn: Math.floor((auth.expiresAt - Date.now()) / 1000),
+    });
+});
+/**
+ * POST /api/auth/device/authorize
+ * Authorize device (called from web after user logs in)
+ */
+router.post('/authorize', (req, res) => {
+    const { userCode, userId, accessToken, action } = req.body;
+    if (!userCode) {
+        res.status(400).json({ error: 'invalid_request', message: 'Missing user_code' });
+        return;
+    }
+    const auth = pendingAuths.get(userCode.toUpperCase());
+    if (!auth || auth.expiresAt < Date.now()) {
+        res.status(404).json({ error: 'not_found', message: 'Invalid or expired code' });
+        return;
+    }
+    if (action === 'deny') {
+        auth.status = 'denied';
+        res.json({ success: true, message: 'Authorization denied' });
+        return;
+    }
+    // Authorize
+    auth.status = 'authorized';
+    auth.userId = userId;
+    auth.accessToken = accessToken;
+    res.json({ success: true, message: 'Device authorized' });
+});
+export default router;
+//# sourceMappingURL=device-auth.js.map

package/dist/server/services/project-service.d.ts

@@ -4,7 +4,7 @@
  * Сервис для управления проектами в ArchiCore.
  * Связывает API с основными модулями системы.
  */
-import { ChangeImpact } from '../../types/index.js';
+import { ChangeImpact, Symbol, ASTNode } from '../../types/index.js';
 import { RulesCheckResult } from '../../rules-engine/index.js';
 import { ProjectMetrics } from '../../metrics/index.js';
 import { DeadCodeResult } from '../../analyzers/dead-code.js';
@@ -76,6 +76,30 @@ export declare class ProjectService {
         memoryStats: unknown;
     }>;
     deleteProject(projectId: string): Promise<void>;
+    /**
+     * Загрузить индексированные данные с CLI
+     * CLI выполняет парсинг локально и отправляет результаты на сервер
+     */
+    uploadIndexedData(projectId: string, indexedData: {
+        asts: Array<[string, ASTNode]>;
+        symbols: Array<[string, Symbol]>;
+        graph: {
+            nodes: Array<[string, unknown]>;
+            edges: Array<[string, unknown[]]>;
+        };
+        fileContents?: Array<[string, string]>;
+        statistics: {
+            totalFiles: number;
+            totalSymbols: number;
+        };
+    }): Promise<{
+        success: boolean;
+        statistics: ProjectStats;
+    }>;
+    /**
+     * Загрузить сохранённые индексные данные с диска
+     */
+    loadIndexedDataFromDisk(projectId: string): Promise<boolean>;
     /**
      * Получить метрики кода
      */
@@ -117,6 +141,8 @@ export declare class ProjectService {
     }>;
     /**
      * Получить содержимое файлов проекта
+     * Сначала пробуем загрузить из сохранённого файла (для CLI),
+     * затем пробуем читать из файловой системы (для локальных проектов)
      */
     private getFileContents;
 }

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

@@ -371,6 +371,150 @@ export class ProjectService {
         await this.saveProjects();
         Logger.info(`Deleted project: ${projectId}`);
     }
+    /**
+     * Загрузить индексированные данные с CLI
+     * CLI выполняет парсинг локально и отправляет результаты на сервер
+     */
+    async uploadIndexedData(projectId, indexedData) {
+        const project = this.projects.get(projectId);
+        if (!project) {
+            throw new Error(`Project not found: ${projectId}`);
+        }
+        project.status = 'indexing';
+        await this.saveProjects();
+        try {
+            const data = await this.getProjectData(projectId);
+            Logger.progress(`Uploading indexed data for project: ${project.name}`);
+            // Восстанавливаем Maps из массивов
+            const asts = new Map(indexedData.asts);
+            const symbols = new Map(indexedData.symbols);
+            // Восстанавливаем граф с правильными типами
+            const graphNodes = new Map();
+            for (const [key, value] of indexedData.graph.nodes) {
+                const node = value;
+                graphNodes.set(key, {
+                    id: node.id,
+                    name: node.name,
+                    type: node.type || 'file',
+                    filePath: node.filePath,
+                    metadata: node.metadata || {}
+                });
+            }
+            const graphEdges = new Map();
+            for (const [key, edges] of indexedData.graph.edges) {
+                graphEdges.set(key, edges.map(e => ({
+                    from: key,
+                    to: e.to,
+                    type: e.type,
+                    weight: e.weight || 1
+                })));
+            }
+            const graph = {
+                nodes: graphNodes,
+                edges: graphEdges
+            };
+            // Сохраняем в данные проекта
+            data.asts = asts;
+            data.symbols = symbols;
+            data.graph = graph;
+            // Сохраняем содержимое файлов если передано
+            if (indexedData.fileContents) {
+                const fileContentsMap = new Map(indexedData.fileContents);
+                // Сохраняем в файловую систему сервера для анализаторов
+                const projectDataDir = path.join(this.dataDir, projectId);
+                if (!existsSync(projectDataDir)) {
+                    await mkdir(projectDataDir, { recursive: true });
+                }
+                await writeFile(path.join(projectDataDir, 'file-contents.json'), JSON.stringify(Array.from(fileContentsMap.entries())));
+            }
+            // Индексация в семантическую память (если доступна)
+            if (data.semanticMemory) {
+                await data.semanticMemory.initialize();
+                await data.semanticMemory.indexSymbols(symbols, asts);
+            }
+            // Сохраняем индексные данные на диск
+            const projectDataDir = path.join(this.dataDir, projectId);
+            if (!existsSync(projectDataDir)) {
+                await mkdir(projectDataDir, { recursive: true });
+            }
+            await writeFile(path.join(projectDataDir, 'asts.json'), JSON.stringify(indexedData.asts));
+            await writeFile(path.join(projectDataDir, 'symbols.json'), JSON.stringify(indexedData.symbols));
+            await writeFile(path.join(projectDataDir, 'graph.json'), JSON.stringify(indexedData.graph));
+            // Обновляем статус и статистику
+            const stats = {
+                filesCount: indexedData.statistics.totalFiles,
+                symbolsCount: indexedData.statistics.totalSymbols,
+                nodesCount: graph.nodes.size,
+                edgesCount: Array.from(graph.edges.values()).reduce((sum, edges) => sum + edges.length, 0)
+            };
+            project.status = 'ready';
+            project.lastIndexedAt = new Date().toISOString();
+            project.stats = stats;
+            await this.saveProjects();
+            Logger.success(`Index uploaded: ${stats.filesCount} files, ${stats.symbolsCount} symbols`);
+            return { success: true, statistics: stats };
+        }
+        catch (error) {
+            project.status = 'error';
+            await this.saveProjects();
+            Logger.error('Upload indexing failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Загрузить сохранённые индексные данные с диска
+     */
+    async loadIndexedDataFromDisk(projectId) {
+        const project = this.projects.get(projectId);
+        if (!project)
+            return false;
+        const projectDataDir = path.join(this.dataDir, projectId);
+        const astsPath = path.join(projectDataDir, 'asts.json');
+        const symbolsPath = path.join(projectDataDir, 'symbols.json');
+        const graphPath = path.join(projectDataDir, 'graph.json');
+        if (!existsSync(astsPath) || !existsSync(symbolsPath) || !existsSync(graphPath)) {
+            return false;
+        }
+        try {
+            const data = await this.getProjectData(projectId);
+            const astsData = JSON.parse(await readFile(astsPath, 'utf-8'));
+            const symbolsData = JSON.parse(await readFile(symbolsPath, 'utf-8'));
+            const graphData = JSON.parse(await readFile(graphPath, 'utf-8'));
+            data.asts = new Map(astsData);
+            data.symbols = new Map(symbolsData);
+            // Восстанавливаем граф с правильными типами
+            const graphNodes = new Map();
+            for (const [key, value] of graphData.nodes) {
+                const node = value;
+                graphNodes.set(key, {
+                    id: node.id,
+                    name: node.name,
+                    type: node.type || 'file',
+                    filePath: node.filePath,
+                    metadata: node.metadata || {}
+                });
+            }
+            const graphEdges = new Map();
+            for (const [key, edges] of graphData.edges) {
+                graphEdges.set(key, edges.map(e => ({
+                    from: key,
+                    to: e.to,
+                    type: e.type,
+                    weight: e.weight || 1
+                })));
+            }
+            data.graph = {
+                nodes: graphNodes,
+                edges: graphEdges
+            };
+            Logger.info(`Loaded indexed data from disk for project: ${project.name}`);
+            return true;
+        }
+        catch (error) {
+            Logger.error('Failed to load indexed data from disk:', error);
+            return false;
+        }
+    }
     /**
      * Получить метрики кода
      */
@@ -503,12 +647,28 @@ export class ProjectService {
     }
     /**
      * Получить содержимое файлов проекта
+     * Сначала пробуем загрузить из сохранённого файла (для CLI),
+     * затем пробуем читать из файловой системы (для локальных проектов)
      */
     async getFileContents(projectId) {
         const project = this.projects.get(projectId);
         if (!project) {
             throw new Error(`Project not found: ${projectId}`);
         }
+        // Сначала пробуем загрузить из сохранённого файла (для CLI проектов)
+        const projectDataDir = path.join(this.dataDir, projectId);
+        const savedContentsPath = path.join(projectDataDir, 'file-contents.json');
+        if (existsSync(savedContentsPath)) {
+            try {
+                const contents = JSON.parse(await readFile(savedContentsPath, 'utf-8'));
+                Logger.debug(`Loaded file contents from saved data for project: ${project.name}`);
+                return new Map(contents);
+            }
+            catch {
+                Logger.warn('Failed to load saved file contents, trying filesystem');
+            }
+        }
+        // Fallback: читаем из файловой системы (для локальных проектов на сервере)
         const data = await this.getProjectData(projectId);
         const fileContents = new Map();
         if (data.asts) {

package/package.json

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