monoai 0.2.7 → 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/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,11 +27,110 @@ 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('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) => {
@@ -60,26 +160,34 @@ export const pushCommand = new Command('push')
             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}`;
@@ -107,13 +215,15 @@ 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);
                     }
                 }
@@ -138,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('📡 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}`
@@ -152,6 +264,18 @@ 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();
@@ -185,8 +309,8 @@ export const pushCommand = new Command('push')
                     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(`   - worker total: ${fmt(finalJob.workerTotalMs)}`));
-                    console.log(chalk.dim(`   - total pipeline: ${fmt(finalJob.totalPipelineMs)}`));
+                    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(`❌ Could not build Knowledge Graph: ${finalJob.error}`));

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,7 +1,7 @@
 {
   "name": "monoai",
   "type": "module",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "MonoAI CLI for syncing codebase history",
   "main": "dist/index.js",
   "bin": {
@@ -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",