monoai 0.2.4 → 0.2.6

package/README.md

@@ -38,5 +38,22 @@ npx monoai login
 npx monoai push
 ```
 
+## .monoaiignore (optional)
+
+`monoai push` reads both `.gitignore` and `.monoaiignore`.
+If `.monoaiignore` does not exist, MonoAI creates a starter template automatically.
+
+Use it to exclude files/directories from AST scanning:
+
+```gitignore
+# Example
+node_modules
+dist
+build
+coverage
+**/_generated/**
+**/.agent/**
+*.log
+```
 
 

package/dist/commands/login.js

@@ -5,8 +5,10 @@ import chalk from 'chalk';
 import open from 'open';
 import ora from 'ora';
 const config = new Conf({ projectName: 'monoai' });
-// Production URLs
-const CONVEX_SITE_URL = 'https://majestic-crane-609.convex.site';
+// Production URLs (single source of truth)
+const CONVEX_SITE_URL = process.env.MONOAI_CONVEX_SITE_URL ||
+    process.env.MONOAI_CONVEX_URL ||
+    'https://majestic-crane-609.convex.site';
 const WEB_URL = 'https://monoai.space';
 export const loginCommand = new Command('login')
     .description('Authenticate with MonoAI')

package/dist/commands/push.js

@@ -7,13 +7,39 @@ import path from 'path';
 import ignore from 'ignore';
 import Conf from 'conf';
 import { extractSkeleton } from '../utils/ast-extractor.js';
-import { execSync } from 'child_process';
-import { fileURLToPath } from 'url';
 const git = simpleGit();
 const config = new Conf({ projectName: 'monoai' });
+const MONOAIIGNORE_FILENAME = '.monoaiignore';
+const DEFAULT_MONOAIIGNORE = `# MonoAI AST scan ignore rules
+# Uses .gitignore-style patterns.
+
+# Dependencies / build
+node_modules
+dist
+build
+coverage
+.next
+.turbo
+
+# Generated / local artifacts
+**/_generated/**
+**/.agent/**
+*.log
+`;
 export const pushCommand = new Command('push')
     .description('Push codebase integrity and AST skeleton to MonoAI')
     .action(async () => {
+    const totalStart = Date.now();
+    const stageTimes = [];
+    const track = (stage, fn) => {
+        const start = Date.now();
+        return fn().then((result) => {
+            const ms = Date.now() - start;
+            stageTimes.push({ stage, ms });
+            console.log(chalk.dim(`   ⏱ ${stage}: ${(ms / 1000).toFixed(2)}s`));
+            return result;
+        });
+    };
     try {
         console.log(chalk.blue('🏎️  Starting MonoAI Strategic Push...'));
         // 0. Auth Check
@@ -29,104 +55,146 @@ export const pushCommand = new Command('push')
             return;
         }
         // 1. Git Metadata (Zero-HITL Intent)
-        const log = await git.log({ maxCount: 1 });
-        const lastCommit = log.latest;
-        const branch = await git.revparse(['--abbrev-ref', 'HEAD']);
-        if (!lastCommit) {
-            console.error(chalk.red('❌ No commits found.'));
-            return;
-        }
+        const { lastCommit, branch, changedScopes } = await track('git metadata', async () => {
+            const log = await git.log({ maxCount: 1 });
+            const lastCommit = log.latest;
+            const branch = await git.revparse(['--abbrev-ref', 'HEAD']);
+            if (!lastCommit) {
+                throw new Error('No commits found.');
+            }
+            let changedScopes = [];
+            try {
+                const diffSummary = await git.diffSummary(['HEAD~1', 'HEAD']);
+                changedScopes = Array.from(new Set(diffSummary.files.map((f) => {
+                    const parts = f.file.split('/');
+                    return parts.length > 1 ? parts[0] : f.file;
+                })));
+            }
+            catch {
+                changedScopes = [];
+            }
+            return { lastCommit, branch, changedScopes };
+        });
+        const shortCommitId = lastCommit.hash.substring(0, 7);
+        const snapshotId = `${branch}@${shortCommitId}`;
         console.log(chalk.dim(`   Branch: ${chalk.white(branch)}`));
-        console.log(chalk.dim(`   Commit: ${chalk.white(lastCommit.hash.substring(0, 7))}`));
+        console.log(chalk.dim(`   Commit: ${chalk.white(shortCommitId)}`));
         // 2. Scan & Extract AST Skeleton
         console.log(chalk.blue('🔍 Analyzing structural integrity (AST)...'));
-        const ig = ignore();
-        if (fs.existsSync('.gitignore')) {
-            ig.add(fs.readFileSync('.gitignore').toString());
-        }
-        // Hardcoded safety
-        ig.add(['node_modules', '.git', 'dist', '.env', 'build']);
-        const filesToAnalyze = [];
-        const scanDir = (dir) => {
-            const items = fs.readdirSync(dir);
-            for (const item of items) {
-                const fullPath = path.join(dir, item);
-                const relativePath = path.relative(process.cwd(), fullPath);
-                if (ig.ignores(relativePath))
-                    continue;
-                if (fs.statSync(fullPath).isDirectory()) {
-                    scanDir(fullPath);
-                }
-                else if (/\.(ts|tsx|js|jsx)$/.test(item)) {
-                    filesToAnalyze.push(fullPath);
-                }
+        const { skeleton } = await track('ast extraction', async () => {
+            const ig = ignore();
+            const monoaiIgnorePath = path.join(process.cwd(), MONOAIIGNORE_FILENAME);
+            if (!fs.existsSync(monoaiIgnorePath)) {
+                fs.writeFileSync(monoaiIgnorePath, DEFAULT_MONOAIIGNORE, 'utf8');
+                console.log(chalk.dim(`   Created ${MONOAIIGNORE_FILENAME} template`));
             }
-        };
-        scanDir(process.cwd());
-        const skeleton = extractSkeleton(filesToAnalyze);
-        const CONVEX_SITE_URL = config.get('convex_url') || 'https://majestic-crane-609.convex.site';
-        // 3. Central System Intelligence (Auth required)
-        console.log(chalk.blue('🔑 Retrieving system intelligence credentials...'));
-        let centralKey = '';
-        try {
-            const keyResponse = await axios.post(`${CONVEX_SITE_URL}/cli/system/key`, {}, {
-                headers: { 'Authorization': `Bearer ${token}` }
-            });
-            centralKey = keyResponse.data.key;
-        }
-        catch (err) {
-            console.warn(chalk.yellow('⚠️  Failed to fetch central key, using local settings if available.'));
-        }
-        // 4. Cognee Knowledge Graph Bridge
-        let graphData = { nodes: [], edges: [] };
-        if (centralKey) {
-            console.log(chalk.blue('🧠 Building Knowledge Graph via Cognee...'));
-            try {
-                const tempDir = path.join(process.cwd(), '.monoai_temp');
-                if (!fs.existsSync(tempDir))
-                    fs.mkdirSync(tempDir);
-                const astPath = path.join(tempDir, 'ast_skeleton.json');
-                fs.writeFileSync(astPath, JSON.stringify(skeleton));
-                // Locate bridge script (assuming it's in the same package)
-                const bridgePath = path.join(path.dirname(fileURLToPath(import.meta.url)), '../../scripts/cognee_bridge.py');
-                // Fallback to project root scripts if not found in package
-                const finalBridgePath = fs.existsSync(bridgePath) ? bridgePath : 'scripts/cognee_bridge.py';
-                console.log(chalk.dim(`   Running Cognee on ${filesToAnalyze.length} files...`));
-                const output = execSync(`python3 ${finalBridgePath} ${astPath} ${centralKey}`, { encoding: 'utf8' });
-                graphData = JSON.parse(output);
-                // Cleanup
-                fs.unlinkSync(astPath);
-                if (graphData.status === 'success') {
-                    console.log(chalk.green('✅ Knowledge Graph constructed successfully.'));
-                }
+            if (fs.existsSync('.gitignore')) {
+                ig.add(fs.readFileSync('.gitignore').toString());
             }
-            catch (err) {
-                console.warn(chalk.yellow('⚠️  Cognee analysis skipped or failed:'), err.message);
+            if (fs.existsSync(monoaiIgnorePath)) {
+                ig.add(fs.readFileSync(monoaiIgnorePath).toString());
             }
-        }
-        // 5. Payload Construction
-        const payload = {
+            // Hardcoded safety
+            ig.add(['node_modules', '.git', 'dist', '.env', 'build']);
+            const filesToAnalyze = [];
+            const scanDir = (dir) => {
+                const items = fs.readdirSync(dir);
+                for (const item of items) {
+                    const fullPath = path.join(dir, item);
+                    const relativePath = path.relative(process.cwd(), fullPath);
+                    if (ig.ignores(relativePath))
+                        continue;
+                    if (fs.statSync(fullPath).isDirectory()) {
+                        scanDir(fullPath);
+                    }
+                    else if (/\.(ts|tsx|js|jsx)$/.test(item)) {
+                        filesToAnalyze.push(fullPath);
+                    }
+                }
+            };
+            scanDir(process.cwd());
+            const skeleton = extractSkeleton(filesToAnalyze);
+            console.log(chalk.dim(`   Files analyzed: ${filesToAnalyze.length}`));
+            return { skeleton };
+        });
+        const CONVEX_SITE_URL = process.env.MONOAI_CONVEX_SITE_URL ||
+            process.env.MONOAI_CONVEX_URL ||
+            config.get('convex_url') ||
+            'https://majestic-crane-609.convex.site';
+        // 3. AST-only upload. Knowledge graph processing is handled server-side.
+        console.log(chalk.blue('📦 Preparing AST payload for server-side graph pipeline...'));
+        // 4. Payload Construction
+        const payload = await track('payload build', async () => ({
             name: path.basename(process.cwd()),
+            snapshotId,
             branch: branch,
-            commitId: lastCommit.hash.substring(0, 7),
+            commitId: shortCommitId,
             commitMessage: lastCommit.message,
             structure: JSON.stringify(skeleton), // Structured AST
-            graphData: graphData, // Knowledge Graph Data
-            syncStatus: 'success',
-        };
-        // 6. Send to Navigator (Convex)
+            changedScopes,
+            syncStatus: 'processing',
+        }));
+        // 5. Send to Navigator (Convex)
         console.log(chalk.blue('📡 Transmitting to Value Engine...'));
-        await axios.post(`${CONVEX_SITE_URL}/cli/git-commit`, {
-            codebaseData: payload
-        }, {
-            headers: {
-                'Authorization': `Bearer ${token}`
-            }
+        const transmitResult = await track('transmit', async () => {
+            const response = await axios.post(`${CONVEX_SITE_URL}/cli/git-commit`, {
+                codebaseData: payload
+            }, {
+                headers: {
+                    'Authorization': `Bearer ${token}`
+                }
+            });
+            return response.data;
         });
+        if (transmitResult?.graphJobId) {
+            const terminalStatuses = new Set(['done', 'error']);
+            const waitStart = Date.now();
+            const timeoutMs = 180000;
+            const pollIntervalMs = 2000;
+            console.log(chalk.blue(`🧠 Waiting for KG pipeline... (job: ${transmitResult.graphJobId})`));
+            let lastStatus = 'uploaded';
+            let finalJob = null;
+            while (Date.now() - waitStart < timeoutMs) {
+                const res = await axios.post(`${CONVEX_SITE_URL}/cli/graph-job-status`, { jobId: transmitResult.graphJobId }, { headers: { Authorization: `Bearer ${token}` } });
+                const job = res.data?.job;
+                if (!job)
+                    break;
+                finalJob = job;
+                if (job.status !== lastStatus) {
+                    console.log(chalk.dim(`   ↳ KG status: ${job.status}`));
+                    lastStatus = job.status;
+                }
+                if (terminalStatuses.has(job.status)) {
+                    break;
+                }
+                await new Promise((r) => setTimeout(r, pollIntervalMs));
+            }
+            const waitMs = Date.now() - waitStart;
+            stageTimes.push({ stage: 'kg pipeline wait', ms: waitMs });
+            console.log(chalk.dim(`   ⏱ kg pipeline wait: ${(waitMs / 1000).toFixed(2)}s`));
+            if (finalJob) {
+                const fmt = (v) => (typeof v === 'number' ? `${(v / 1000).toFixed(2)}s` : 'n/a');
+                console.log(chalk.blue('📊 KG timing'));
+                console.log(chalk.dim(`   - queue wait: ${fmt(finalJob.queueWaitMs)}`));
+                console.log(chalk.dim(`   - cognee/graph build: ${fmt(finalJob.cogneeMs)}`));
+                console.log(chalk.dim(`   - callback: ${fmt(finalJob.callbackMs)}`));
+                console.log(chalk.dim(`   - worker total: ${fmt(finalJob.workerTotalMs)}`));
+                console.log(chalk.dim(`   - pipeline total: ${fmt(finalJob.totalPipelineMs)}`));
+                if (finalJob.status === 'error' && finalJob.error) {
+                    console.log(chalk.red(`   - pipeline error: ${finalJob.error}`));
+                }
+            }
+            else {
+                console.log(chalk.yellow('   ⚠ KG timing unavailable (job status not returned)'));
+            }
+        }
         console.log(chalk.green('✨ [Navigator] Push complete! Check your dashboard for Alignment Analysis.'));
         console.log(chalk.dim(`   Message: ${lastCommit.message.split('\n')[0]}`));
+        const totalMs = Date.now() - totalStart;
+        console.log(chalk.blue(`⏱ Total: ${(totalMs / 1000).toFixed(2)}s`));
     }
     catch (error) {
+        const totalMs = Date.now() - totalStart;
         if (error.response?.status === 401) {
             console.error(chalk.red('❌ Authentication Expired. Please run:'));
             console.error(chalk.white('   npx monoai login'));
@@ -134,5 +202,12 @@ export const pushCommand = new Command('push')
         else {
             console.error(chalk.red('❌ Sync failed:'), error.message);
         }
+        if (stageTimes.length > 0) {
+            console.log(chalk.yellow('\n⏱ Stage timing summary'));
+            for (const item of stageTimes) {
+                console.log(chalk.dim(`   - ${item.stage}: ${(item.ms / 1000).toFixed(2)}s`));
+            }
+        }
+        console.log(chalk.blue(`⏱ Total: ${(totalMs / 1000).toFixed(2)}s`));
     }
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "monoai",
   "type": "module",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "MonoAI CLI for syncing codebase history",
   "main": "dist/index.js",
   "bin": {
@@ -31,4 +31,4 @@
     "@types/node": "^20.19.31",
     "typescript": "^5.3.2"
   }
-}
+}

package/scripts/cognee_bridge.py

@@ -16,6 +16,32 @@ except ImportError:
     }))
     sys.exit(0)
 
+def _normalize_files(ast_data: Dict):
+    # v1 format: {"files":[{"path":"...","items":[...]}]}
+    if isinstance(ast_data.get("files"), list):
+        return ast_data.get("files", [])
+
+    # current monoai ts-morph output: {"/abs/path.ts": {"functions":[],"classes":[]...}, ...}
+    files = []
+    for file_path, skeleton in ast_data.items():
+        if not isinstance(skeleton, dict):
+            continue
+        items = []
+        for key in ("functions", "classes", "interfaces", "types"):
+            for item in skeleton.get(key, []):
+                if not isinstance(item, dict):
+                    continue
+                items.append({
+                    "type": key[:-1] if key.endswith("s") else key,
+                    "name": item.get("name") or "anonymous",
+                    "dependencies": []
+                })
+        files.append({
+            "path": file_path,
+            "items": items
+        })
+    return files
+
 async def process_ast_to_graph(ast_data: Dict, api_key: str):
     """
     AST JSON 데이터를 Cognee 지식 그래프로 변환하고 분석합니다.
@@ -30,7 +56,7 @@ async def process_ast_to_graph(ast_data: Dict, api_key: str):
     edges = []
     
     # AST 데이터 파싱 (ts-morph 추출본 기준)
-    files = ast_data.get("files", [])
+    files = _normalize_files(ast_data)
     
     for file in files:
         file_id = file.get("path")