monoai 0.2.6 → 0.2.8

package/README.md

@@ -56,4 +56,19 @@ coverage
 *.log
 ```
 
+## .monoaiwhitelist (optional, include-only)
+
+`monoai push` can also read `.monoaiwhitelist` as an include-only filter.
+When this file exists and has rules, only matched paths are scanned and uploaded.
+
+Use this when you run `monoai push` from a monorepo root but want to sync only one app (for example `step4.vite-web-migration`).
+
+```gitignore
+# Example: sync only step4 project
+step4.vite-web-migration/**
+```
+
+Behavior summary:
+- `.monoaiwhitelist` limits scope first (include-only).
+- `.gitignore` and `.monoaiignore` still exclude paths inside that scope.
 

package/dist/commands/login.js

@@ -11,25 +11,25 @@ const CONVEX_SITE_URL = process.env.MONOAI_CONVEX_SITE_URL ||
     'https://majestic-crane-609.convex.site';
 const WEB_URL = 'https://monoai.space';
 export const loginCommand = new Command('login')
-    .description('Authenticate with MonoAI')
+    .description('Sign in to MonoAI')
     .action(async () => {
-    console.log(chalk.blue('🔐 Starting MonoAI Login...'));
+    console.log(chalk.blue('🔐 Starting sign-in...'));
     try {
         // 1. Init Session
-        const initSpinner = ora('Initializing auth session...').start();
+        const initSpinner = ora('Preparing secure sign-in...').start();
         const initRes = await axios.post(`${CONVEX_SITE_URL}/cli/auth/init`, {
             deviceDescription: process.platform
         });
         initSpinner.succeed();
         const { tempCode } = initRes.data;
         const loginUrl = `${WEB_URL}/auth/cli?code=${tempCode}`;
-        console.log(chalk.yellow(`\n👉 Verification Code: ${chalk.bold(tempCode)}`));
-        console.log(chalk.dim(`   Opening browser... if it doesn't open, visit:`));
+        console.log(chalk.yellow(`\n👉 Verification code: ${chalk.bold(tempCode)}`));
+        console.log(chalk.dim(`   Opening your browser. If it does not open, visit:`));
         console.log(chalk.underline(loginUrl));
         console.log('\n');
         await open(loginUrl);
         // 2. Poll Status
-        const pollSpinner = ora('Waiting for approval in browser...').start();
+        const pollSpinner = ora('Waiting for approval in your browser...').start();
         let attempts = 0;
         const maxAttempts = 60; // 2 minutes (2s * 60)
         const pollInterval = setInterval(async () => {
@@ -41,30 +41,30 @@ export const loginCommand = new Command('login')
                     config.set('auth_token', token);
                     config.set('user_id', userId);
                     config.set('convex_url', CONVEX_SITE_URL); // Store for future use
-                    pollSpinner.succeed(chalk.green('✅ Login Successful!'));
-                    console.log(chalk.dim(`   Token saved to ${config.path}`));
+                    pollSpinner.succeed(chalk.green('✅ Sign-in complete.'));
+                    console.log(chalk.dim(`   Credentials saved to ${config.path}`));
                     process.exit(0);
                 }
                 else if (status === 'expired' || status === 'rejected') {
                     clearInterval(pollInterval);
-                    pollSpinner.fail(chalk.red(`❌ Session ${status}. Please try again.`));
+                    pollSpinner.fail(chalk.red(`❌ Sign-in ${status}. Please try again.`));
                     process.exit(1);
                 }
                 else {
                     attempts++;
                     if (attempts >= maxAttempts) {
                         clearInterval(pollInterval);
-                        pollSpinner.fail(chalk.red('❌ Timed out.'));
+                        pollSpinner.fail(chalk.red('❌ Sign-in timed out.'));
                         process.exit(1);
                     }
                 }
             }
             catch (err) {
-                // Ignore poll errors (network blips)
+                // Ignore temporary polling errors
             }
         }, 2000);
     }
     catch (error) {
-        console.error(chalk.red('\n❌ Login failed:'), error.message);
+        console.error(chalk.red('\n❌ Sign-in failed:'), error.message);
     }
 });

package/dist/commands/push.js

@@ -10,6 +10,7 @@ import { extractSkeleton } from '../utils/ast-extractor.js';
 const git = simpleGit();
 const config = new Conf({ projectName: 'monoai' });
 const MONOAIIGNORE_FILENAME = '.monoaiignore';
+const MONOAIWHITELIST_FILENAME = '.monoaiwhitelist';
 const DEFAULT_MONOAIIGNORE = `# MonoAI AST scan ignore rules
 # Uses .gitignore-style patterns.
 
@@ -26,67 +27,180 @@ coverage
 **/.agent/**
 *.log
 `;
+function loadMonoaiWhitelist(cwd) {
+    const whitelistPath = path.join(cwd, MONOAIWHITELIST_FILENAME);
+    if (!fs.existsSync(whitelistPath)) {
+        return { matcher: null, ruleCount: 0 };
+    }
+    const rules = fs.readFileSync(whitelistPath, 'utf8')
+        .split(/\r?\n/g)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && !line.startsWith('#'));
+    if (rules.length === 0) {
+        return { matcher: null, ruleCount: 0 };
+    }
+    return {
+        matcher: ignore().add(rules),
+        ruleCount: rules.length,
+    };
+}
+function normalizeGitFilePath(value) {
+    return String(value || "")
+        .trim()
+        .replace(/\\/g, "/")
+        .replace(/^\.?\//, "");
+}
+function scopePrefix(filePath, depth) {
+    const parts = normalizeGitFilePath(filePath).split("/").filter(Boolean);
+    if (parts.length === 0)
+        return "";
+    return parts.slice(0, Math.min(depth, parts.length)).join("/");
+}
+function asNumber(value) {
+    const n = Number(value);
+    if (!Number.isFinite(n))
+        return 0;
+    return Math.max(0, Math.round(n));
+}
+function buildChangedFileSignals(diffFiles) {
+    const rows = Array.isArray(diffFiles) ? diffFiles : [];
+    return rows
+        .map((file) => {
+        const normalizedPath = normalizeGitFilePath(String(file?.file || ""));
+        if (!normalizedPath)
+            return null;
+        const insertions = asNumber(file?.insertions);
+        const deletions = asNumber(file?.deletions);
+        const changes = Math.max(asNumber(file?.changes), insertions + deletions);
+        const ext = path.extname(normalizedPath).replace(".", "").toLowerCase() || "none";
+        return {
+            path: normalizedPath,
+            insertions,
+            deletions,
+            changes,
+            scope1: scopePrefix(normalizedPath, 1),
+            scope2: scopePrefix(normalizedPath, 2),
+            extension: ext,
+        };
+    })
+        .filter(Boolean);
+}
+function buildGraphInsightsFromChanges(files) {
+    if (!Array.isArray(files) || files.length === 0)
+        return [];
+    const byScope = new Map();
+    const byExtension = new Map();
+    for (const row of files) {
+        const scope = row.scope2 || row.scope1 || "root";
+        const churn = Math.max(1, row.changes);
+        const currentScope = byScope.get(scope) || { files: 0, churn: 0 };
+        currentScope.files += 1;
+        currentScope.churn += churn;
+        byScope.set(scope, currentScope);
+        const extCount = byExtension.get(row.extension) || 0;
+        byExtension.set(row.extension, extCount + 1);
+    }
+    const hotFiles = files
+        .slice()
+        .sort((a, b) => b.changes - a.changes)
+        .slice(0, 8)
+        .map((row) => `changed_file:${row.path} (+${row.insertions}/-${row.deletions})`);
+    const hotScopes = Array.from(byScope.entries())
+        .sort((a, b) => {
+        if (b[1].churn !== a[1].churn)
+            return b[1].churn - a[1].churn;
+        return b[1].files - a[1].files;
+    })
+        .slice(0, 6)
+        .map(([scope, stat]) => `changed_scope:${scope} files=${stat.files} churn=${stat.churn}`);
+    const extensionMix = Array.from(byExtension.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 4)
+        .map(([ext, count]) => `extension_mix:${ext}=${count}`);
+    return Array.from(new Set([
+        `changed_total_files:${files.length}`,
+        ...hotScopes,
+        ...hotFiles,
+        ...extensionMix,
+    ])).slice(0, 24);
+}
 export const pushCommand = new Command('push')
-    .description('Push codebase integrity and AST skeleton to MonoAI')
-    .action(async () => {
+    .description('Sync your codebase structure to MonoAI')
+    .option('-v, --verbose', 'Show internal pipeline logs')
+    .option('-f, --force', 'Force sync even if the same commit was already uploaded')
+    .action(async (options) => {
+    const verbose = !!options?.verbose;
+    const force = !!options?.force;
     const totalStart = Date.now();
     const stageTimes = [];
+    const logDetail = (message) => {
+        if (verbose)
+            console.log(chalk.dim(message));
+    };
     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`));
+            logDetail(`   ⏱ ${stage}: ${(ms / 1000).toFixed(2)}s`);
             return result;
         });
     };
     try {
-        console.log(chalk.blue('🏎️  Starting MonoAI Strategic Push...'));
+        console.log(chalk.blue('🏎️  Starting codebase sync...'));
         // 0. Auth Check
         const token = config.get('auth_token');
         if (!token) {
-            console.error(chalk.red('❌ Not Authenticated. Please run:'));
+            console.error(chalk.red('❌ You are not signed in. Please run:'));
             console.error(chalk.white('   npx monoai login'));
             return;
         }
         const isRepo = await git.checkIsRepo();
         if (!isRepo) {
-            console.error(chalk.red('❌ Not a git repository.'));
+            console.error(chalk.red('❌ This folder is not a Git repository.'));
             return;
         }
+        const { matcher: whitelistMatcher, ruleCount: whitelistRuleCount } = loadMonoaiWhitelist(process.cwd());
+        const isWhitelisted = (relativePath) => !whitelistMatcher || whitelistMatcher.ignores(normalizeGitFilePath(relativePath));
+        if (whitelistMatcher) {
+            console.log(chalk.blue(`🎯 Applying ${MONOAIWHITELIST_FILENAME} (${whitelistRuleCount} rule${whitelistRuleCount > 1 ? 's' : ''})`));
+        }
         // 1. Git Metadata (Zero-HITL Intent)
-        const { lastCommit, branch, changedScopes } = await track('git metadata', async () => {
+        const { lastCommit, branch, changedScopes, graphInsights } = 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 = [];
+            let changedFiles = [];
             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;
-                })));
+                changedFiles = buildChangedFileSignals(diffSummary?.files || []);
             }
             catch {
-                changedScopes = [];
+                changedFiles = [];
             }
-            return { lastCommit, branch, changedScopes };
+            changedFiles = changedFiles.filter((row) => isWhitelisted(row.path));
+            const changedScopes = Array.from(new Set(changedFiles
+                .flatMap((row) => [row.scope2, row.scope1])
+                .map((row) => String(row || "").trim())
+                .filter(Boolean))).slice(0, 24);
+            const graphInsights = buildGraphInsightsFromChanges(changedFiles);
+            return { lastCommit, branch, changedScopes, graphInsights };
         });
         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(shortCommitId)}`));
-        // 2. Scan & Extract AST Skeleton
-        console.log(chalk.blue('🔍 Analyzing structural integrity (AST)...'));
-        const { skeleton } = await track('ast extraction', async () => {
+        logDetail(`   Branch: ${chalk.white(branch)}`);
+        logDetail(`   Commit: ${chalk.white(shortCommitId)}`);
+        // 2. Scan and extract source structure
+        console.log(chalk.blue('🔍 Scanning codebase structure...'));
+        const { skeleton } = await track('structure scan', 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`));
+                logDetail(`   Created ${MONOAIIGNORE_FILENAME} template`);
             }
             if (fs.existsSync('.gitignore')) {
                 ig.add(fs.readFileSync('.gitignore').toString());
@@ -101,30 +215,32 @@ export const pushCommand = new Command('push')
                 const items = fs.readdirSync(dir);
                 for (const item of items) {
                     const fullPath = path.join(dir, item);
-                    const relativePath = path.relative(process.cwd(), fullPath);
+                    const relativePath = normalizeGitFilePath(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)) {
+                        if (!isWhitelisted(relativePath))
+                            continue;
                         filesToAnalyze.push(fullPath);
                     }
                 }
             };
             scanDir(process.cwd());
             const skeleton = extractSkeleton(filesToAnalyze);
-            console.log(chalk.dim(`   Files analyzed: ${filesToAnalyze.length}`));
+            console.log(chalk.dim(`   Files scanned: ${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...'));
+        // 3. AST-only upload. Knowledge Graph processing is handled server-side.
+        console.log(chalk.blue('📦 Preparing data...'));
         // 4. Payload Construction
-        const payload = await track('payload build', async () => ({
+        const payload = {
             name: path.basename(process.cwd()),
             snapshotId,
             branch: branch,
@@ -132,13 +248,15 @@ export const pushCommand = new Command('push')
             commitMessage: lastCommit.message,
             structure: JSON.stringify(skeleton), // Structured AST
             changedScopes,
+            graphInsights,
             syncStatus: 'processing',
-        }));
+        };
         // 5. Send to Navigator (Convex)
-        console.log(chalk.blue('📡 Transmitting to Value Engine...'));
+        console.log(chalk.blue('📡 Uploading to MonoAI...'));
         const transmitResult = await track('transmit', async () => {
             const response = await axios.post(`${CONVEX_SITE_URL}/cli/git-commit`, {
-                codebaseData: payload
+                codebaseData: payload,
+                force,
             }, {
                 headers: {
                     'Authorization': `Bearer ${token}`
@@ -146,12 +264,24 @@ export const pushCommand = new Command('push')
             });
             return response.data;
         });
+        if (transmitResult?.deduped) {
+            console.log(chalk.yellow('⚠ This commit was already synced. No new snapshot was created.'));
+            if (transmitResult.message && verbose) {
+                console.log(chalk.dim(`   ${transmitResult.message}`));
+            }
+            const totalMs = Date.now() - totalStart;
+            console.log(chalk.blue(`⏱ Total time: ${(totalMs / 1000).toFixed(2)}s`));
+            return;
+        }
+        if (force) {
+            logDetail('   Force mode enabled: duplicate commit dedupe was bypassed.');
+        }
         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})`));
+            console.log(chalk.blue('🧠 Building Knowledge Graph...'));
             let lastStatus = 'uploaded';
             let finalJob = null;
             while (Date.now() - waitStart < timeoutMs) {
@@ -160,54 +290,59 @@ export const pushCommand = new Command('push')
                 if (!job)
                     break;
                 finalJob = job;
-                if (job.status !== lastStatus) {
-                    console.log(chalk.dim(`   ↳ KG status: ${job.status}`));
-                    lastStatus = job.status;
+                if (job.status !== lastStatus && verbose) {
+                    console.log(chalk.dim(`   ↳ Knowledge Graph 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`));
+            stageTimes.push({ stage: 'knowledge graph wait', ms: waitMs });
+            logDetail(`   ⏱ knowledge graph 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 (verbose) {
+                    console.log(chalk.blue('📊 Knowledge Graph timing'));
+                    console.log(chalk.dim(`   - queue wait: ${fmt(finalJob.queueWaitMs)}`));
+                    console.log(chalk.dim(`   - graph build: ${fmt(finalJob.cogneeMs)}`));
+                    console.log(chalk.dim(`   - callback: ${fmt(finalJob.callbackMs)}`));
+                    console.log(chalk.dim(`   - service total: ${fmt(finalJob.workerTotalMs)}`));
+                    console.log(chalk.dim(`   - total service time: ${fmt(finalJob.totalPipelineMs)}`));
+                }
                 if (finalJob.status === 'error' && finalJob.error) {
-                    console.log(chalk.red(`   - pipeline error: ${finalJob.error}`));
+                    console.log(chalk.red(`❌ Could not build Knowledge Graph: ${finalJob.error}`));
+                }
+                if (finalJob.status === 'done') {
+                    console.log(chalk.green('✅ Knowledge Graph is ready.'));
                 }
             }
             else {
-                console.log(chalk.yellow('   ⚠ KG timing unavailable (job status not returned)'));
+                console.log(chalk.yellow('⚠ Knowledge Graph status is unavailable. It may still be processing in the background.'));
             }
         }
-        console.log(chalk.green('✨ [Navigator] Push complete! Check your dashboard for Alignment Analysis.'));
-        console.log(chalk.dim(`   Message: ${lastCommit.message.split('\n')[0]}`));
+        console.log(chalk.green('✨ Sync complete. Check your dashboard for updated insights.'));
+        logDetail(`   Message: ${lastCommit.message.split('\n')[0]}`);
         const totalMs = Date.now() - totalStart;
-        console.log(chalk.blue(`⏱ Total: ${(totalMs / 1000).toFixed(2)}s`));
+        console.log(chalk.blue(`⏱ Total time: ${(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.red('❌ Your sign-in has expired. Please run:'));
             console.error(chalk.white('   npx monoai login'));
         }
         else {
             console.error(chalk.red('❌ Sync failed:'), error.message);
         }
-        if (stageTimes.length > 0) {
-            console.log(chalk.yellow('\n⏱ Stage timing summary'));
+        if (verbose && stageTimes.length > 0) {
+            console.log(chalk.yellow('\n⏱ Stage timing details'));
             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`));
+        console.log(chalk.blue(`⏱ Total time: ${(totalMs / 1000).toFixed(2)}s`));
     }
 });

package/dist/index.js

@@ -6,7 +6,7 @@ const program = new Command();
 program
     .name('monoai')
     .description('MonoAI CLI - Strategic Navigator')
-    .version('0.2.4');
+    .version('0.2.6');
 program.addCommand(loginCommand);
 program.addCommand(pushCommand);
 program.parse();

package/dist/utils/ast-extractor.js

@@ -7,6 +7,29 @@ const SECRET_PATTERNS = [
     /AIza[0-9A-Za-z-_]{35}/g, // Google Cloud style
     /ghp_[a-zA-Z0-9]{36}/g // GitHub Personal Access Token
 ];
+function toRepoRelativePath(rawPath) {
+    const normalized = String(rawPath || "").replace(/\\/g, "/").trim();
+    if (!normalized)
+        return "";
+    const cwd = process.cwd().replace(/\\/g, "/");
+    if (normalized.startsWith(cwd + "/")) {
+        return normalized.slice(cwd.length + 1);
+    }
+    if (normalized === cwd) {
+        return ".";
+    }
+    const relative = path.relative(process.cwd(), rawPath).replace(/\\/g, "/");
+    if (relative && !relative.startsWith("../") && relative !== "..") {
+        return relative.replace(/^\.?\//, "");
+    }
+    // Fallback for older absolute paths captured under this mono repo.
+    const repoMarker = "/Web_AIChat/";
+    const markerIdx = normalized.lastIndexOf(repoMarker);
+    if (markerIdx >= 0) {
+        return normalized.slice(markerIdx + repoMarker.length).replace(/^\.?\//, "");
+    }
+    return normalized.replace(/^\.?\//, "");
+}
 export function extractSkeleton(filePaths) {
     const project = new Project();
     // 🛡️ Security: File Filter
@@ -46,7 +69,7 @@ export function extractSkeleton(filePaths) {
                 }
             }
         });
-        const filePath = sourceFile.getFilePath();
+        const filePath = toRepoRelativePath(sourceFile.getFilePath());
         const skeleton = {
             functions: [],
             classes: [],

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "monoai",
   "type": "module",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "MonoAI CLI for syncing codebase history",
   "main": "dist/index.js",
   "bin": {
-    "monoai": "./dist/index.js"
+    "monoai": "dist/index.js"
   },
   "files": [
     "dist",
@@ -22,6 +22,7 @@
     "commander": "^11.1.0",
     "conf": "^15.1.0",
     "ignore": "^7.0.5",
+    "monoai": "^0.2.7",
     "open": "^9.1.0",
     "ora": "^7.0.1",
     "simple-git": "^3.21.0",