monoai 0.2.8 → 0.3.0

package/dist/commands/push.js

@@ -124,6 +124,82 @@ function buildGraphInsightsFromChanges(files) {
         ...extensionMix,
     ])).slice(0, 24);
 }
+function compactLine(value, max = 180) {
+    const normalized = String(value || '').replace(/\s+/g, ' ').trim();
+    if (!normalized)
+        return '';
+    if (normalized.length <= max)
+        return normalized;
+    return `${normalized.slice(0, max)}...`;
+}
+function summarizeRawSnippet(filePath) {
+    try {
+        const abs = path.resolve(process.cwd(), filePath);
+        if (!fs.existsSync(abs))
+            return '';
+        const raw = fs.readFileSync(abs, 'utf8');
+        const lines = raw
+            .split(/\r?\n/g)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0 && !line.startsWith('//') && !line.startsWith('*'))
+            .slice(0, 8)
+            .map((line) => compactLine(line, 120))
+            .filter(Boolean);
+        return lines.join(' / ');
+    }
+    catch {
+        return '';
+    }
+}
+function buildTargetRawInsights(skeleton, changedFiles, limit = 18) {
+    const byFile = new Map(Object.entries(skeleton || {}));
+    const seeds = changedFiles
+        .map((row) => normalizeGitFilePath(row.path))
+        .filter(Boolean)
+        .slice(0, 24);
+    const hop1Set = new Set();
+    const hop2Set = new Set();
+    const importListOf = (filePath) => {
+        const row = byFile.get(filePath);
+        const imports = Array.isArray(row?.fileImports) ? row.fileImports : [];
+        return imports
+            .map((v) => normalizeGitFilePath(String(v || '')))
+            .filter((v) => v.length > 0);
+    };
+    for (const seed of seeds) {
+        for (const dep of importListOf(seed))
+            hop1Set.add(dep);
+    }
+    for (const dep1 of hop1Set) {
+        for (const dep2 of importListOf(dep1))
+            hop2Set.add(dep2);
+    }
+    const orderedTargets = Array.from(new Set([
+        ...seeds.slice(0, 12),
+        ...Array.from(hop1Set).slice(0, 16),
+        ...Array.from(hop2Set).slice(0, 16),
+    ])).slice(0, Math.max(8, limit));
+    const rows = [];
+    for (const filePath of orderedTargets) {
+        const snippet = summarizeRawSnippet(filePath);
+        if (!snippet)
+            continue;
+        rows.push(`target_raw:${filePath} :: ${snippet}`);
+        if (rows.length >= limit)
+            break;
+    }
+    return rows;
+}
+async function fetchLastSyncedCommit(params) {
+    try {
+        const res = await axios.post(`${params.convexSiteUrl}/cli/git-last-sync`, { branch: params.branch }, { headers: { Authorization: `Bearer ${params.token}` } });
+        const commitId = String(res?.data?.latest?.commitId || '').trim();
+        return commitId || null;
+    }
+    catch {
+        return null;
+    }
+}
 export const pushCommand = new Command('push')
     .description('Sync your codebase structure to MonoAI')
     .option('-v, --verbose', 'Show internal pipeline logs')
@@ -165,29 +241,58 @@ export const pushCommand = new Command('push')
         if (whitelistMatcher) {
             console.log(chalk.blue(`🎯 Applying ${MONOAIWHITELIST_FILENAME} (${whitelistRuleCount} rule${whitelistRuleCount > 1 ? 's' : ''})`));
         }
+        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';
         // 1. Git Metadata (Zero-HITL Intent)
-        const { lastCommit, branch, changedScopes, graphInsights } = await track('git metadata', async () => {
+        const { lastCommit, branch, changedScopes, changedFiles } = 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 changedFiles = [];
+            let changedRows = [];
+            const maxDiffCommits = Math.max(1, Math.min(Number(process.env.MONOAI_DIFF_MAX_COMMITS || 30), 200));
+            const lastSyncedCommit = force
+                ? null
+                : await fetchLastSyncedCommit({
+                    convexSiteUrl: CONVEX_SITE_URL,
+                    token: String(token),
+                    branch,
+                });
             try {
-                const diffSummary = await git.diffSummary(['HEAD~1', 'HEAD']);
-                changedFiles = buildChangedFileSignals(diffSummary?.files || []);
+                let diffSummary = null;
+                if (lastSyncedCommit) {
+                    try {
+                        const rangeCountRaw = await git.raw(['rev-list', '--count', `${lastSyncedCommit}..HEAD`]);
+                        const rangeCount = Number(String(rangeCountRaw || '').trim());
+                        if (Number.isFinite(rangeCount) && rangeCount > maxDiffCommits) {
+                            diffSummary = await git.diffSummary([`HEAD~${maxDiffCommits}`, 'HEAD']);
+                        }
+                        else {
+                            diffSummary = await git.diffSummary([`${lastSyncedCommit}..HEAD`]);
+                        }
+                    }
+                    catch {
+                        diffSummary = await git.diffSummary(['HEAD~1', 'HEAD']);
+                    }
+                }
+                else {
+                    diffSummary = await git.diffSummary(['HEAD~1', 'HEAD']);
+                }
+                changedRows = buildChangedFileSignals(diffSummary?.files || []);
             }
             catch {
-                changedFiles = [];
+                changedRows = [];
             }
-            changedFiles = changedFiles.filter((row) => isWhitelisted(row.path));
-            const changedScopes = Array.from(new Set(changedFiles
+            changedRows = changedRows.filter((row) => isWhitelisted(row.path));
+            const changedScopes = Array.from(new Set(changedRows
                 .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 };
+            return { lastCommit, branch, changedScopes, changedFiles: changedRows };
         });
         const shortCommitId = lastCommit.hash.substring(0, 7);
         const snapshotId = `${branch}@${shortCommitId}`;
@@ -229,14 +334,14 @@ export const pushCommand = new Command('push')
                 }
             };
             scanDir(process.cwd());
-            const skeleton = extractSkeleton(filesToAnalyze);
+            const skeleton = extractSkeleton(filesToAnalyze, isWhitelisted);
             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';
+        const graphInsights = Array.from(new Set([
+            ...buildGraphInsightsFromChanges(changedFiles),
+            ...buildTargetRawInsights(skeleton, changedFiles, 18),
+        ])).slice(0, 48);
         // 3. AST-only upload. Knowledge Graph processing is handled server-side.
         console.log(chalk.blue('📦 Preparing data...'));
         // 4. Payload Construction

package/dist/index.js

@@ -1,12 +1,15 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
+import { createRequire } from 'module';
 import { pushCommand } from './commands/push.js';
 import { loginCommand } from './commands/login.js';
 const program = new Command();
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json');
 program
     .name('monoai')
     .description('MonoAI CLI - Strategic Navigator')
-    .version('0.2.6');
+    .version(version);
 program.addCommand(loginCommand);
 program.addCommand(pushCommand);
 program.parse();

package/dist/utils/ast-extractor.js

@@ -1,3 +1,4 @@
+import fs from 'fs';
 import { Project, SyntaxKind } from 'ts-morph';
 import path from 'path';
 // 🛡️ Security: Redaction Patterns
@@ -30,7 +31,98 @@ function toRepoRelativePath(rawPath) {
     }
     return normalized.replace(/^\.?\//, "");
 }
-export function extractSkeleton(filePaths) {
+function normalizePathToken(value) {
+    return String(value || '').replace(/\\/g, '/').replace(/^\.?\//, '').trim();
+}
+function isLikelySourceFile(value) {
+    const normalized = normalizePathToken(value);
+    if (!normalized)
+        return false;
+    if (normalized.includes('/'))
+        return true;
+    return /^[A-Za-z0-9_.-]+\.[A-Za-z0-9]+$/.test(normalized);
+}
+function compactText(value, max = 120) {
+    const normalized = String(value || '').replace(/\s+/g, ' ').trim();
+    if (!normalized)
+        return '';
+    if (normalized.length <= max)
+        return normalized;
+    return `${normalized.slice(0, max)}...`;
+}
+function uniqueStrings(values, maxItems, maxLength = 180) {
+    const seen = new Set();
+    const out = [];
+    for (const raw of values) {
+        const normalized = String(raw || '').trim();
+        if (!normalized || normalized.length > maxLength)
+            continue;
+        if (seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        out.push(normalized);
+        if (out.length >= maxItems)
+            break;
+    }
+    return out;
+}
+function uniqueDependencyEdges(edges, maxItems = 12) {
+    const seen = new Set();
+    const out = [];
+    for (const edge of edges) {
+        const target = normalizePathToken(edge?.target || '');
+        const relationType = edge?.relationType;
+        if (!target || !relationType)
+            continue;
+        const key = `${relationType}::${target}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push({ target, relationType });
+        if (out.length >= maxItems)
+            break;
+    }
+    return out;
+}
+function resolveLocalImportPath(fromFilePath, moduleSpecifier) {
+    const spec = String(moduleSpecifier || '').trim();
+    if (!spec || !spec.startsWith('.'))
+        return '';
+    const fromDir = path.dirname(fromFilePath);
+    const base = path.resolve(fromDir, spec);
+    const candidates = [
+        base,
+        `${base}.ts`,
+        `${base}.tsx`,
+        `${base}.js`,
+        `${base}.jsx`,
+        `${base}.mjs`,
+        `${base}.cjs`,
+        path.join(base, 'index.ts'),
+        path.join(base, 'index.tsx'),
+        path.join(base, 'index.js'),
+        path.join(base, 'index.jsx'),
+        path.join(base, 'index.mjs'),
+        path.join(base, 'index.cjs'),
+    ];
+    for (const candidate of candidates) {
+        if (!fs.existsSync(candidate))
+            continue;
+        const resolved = toRepoRelativePath(candidate);
+        if (isLikelySourceFile(resolved))
+            return resolved;
+    }
+    const fallback = toRepoRelativePath(base);
+    return isLikelySourceFile(fallback) ? fallback : '';
+}
+function redactSecrets(raw) {
+    let result = raw;
+    for (const pattern of SECRET_PATTERNS) {
+        result = result.replace(pattern, '[REDACTED_SECRET]');
+    }
+    return result;
+}
+export function extractSkeleton(filePaths, isWhitelisted) {
     const project = new Project();
     // 🛡️ Security: File Filter
     const safePaths = filePaths.filter(p => {
@@ -74,11 +166,79 @@ export function extractSkeleton(filePaths) {
             functions: [],
             classes: [],
             interfaces: [],
-            types: []
+            types: [],
+            fileImports: [],
+            rawHints: [],
+        };
+        const importAliasToTarget = new Map();
+        const fileImportTargets = [];
+        const sourceFilePathAbs = sourceFile.getFilePath();
+        sourceFile.getImportDeclarations().forEach((imp) => {
+            const moduleSpecifier = imp.getModuleSpecifierValue();
+            const resolved = resolveLocalImportPath(sourceFilePathAbs, moduleSpecifier);
+            if (!resolved)
+                return;
+            const relationType = imp.isTypeOnly() ? 'type_ref' : 'imports';
+            fileImportTargets.push(resolved);
+            const defaultImport = imp.getDefaultImport();
+            if (defaultImport) {
+                importAliasToTarget.set(defaultImport.getText(), { target: resolved, relationType });
+            }
+            const namespaceImport = imp.getNamespaceImport();
+            if (namespaceImport) {
+                importAliasToTarget.set(namespaceImport.getText(), { target: resolved, relationType });
+            }
+            for (const named of imp.getNamedImports()) {
+                const alias = named.getAliasNode()?.getText() || named.getName();
+                if (!alias)
+                    continue;
+                importAliasToTarget.set(alias, { target: resolved, relationType });
+            }
+        });
+        skeleton.fileImports = uniqueStrings(fileImportTargets, 40, 180);
+        const localFunctionNames = new Set(sourceFile
+            .getFunctions()
+            .map((fn) => String(fn.getName() || '').trim())
+            .filter(Boolean));
+        const collectNodeDependencies = (node, nodeText) => {
+            const deps = [];
+            const compactNodeText = String(nodeText || '').slice(0, 12000);
+            for (const [alias, meta] of importAliasToTarget.entries()) {
+                const aliasPattern = new RegExp(`\\b${alias.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`);
+                if (aliasPattern.test(compactNodeText)) {
+                    deps.push({ target: meta.target, relationType: meta.relationType });
+                }
+            }
+            for (const callExpr of node.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+                const exprText = String(callExpr.getExpression().getText() || '');
+                const rootName = exprText.split('.')[0]?.trim();
+                if (!rootName)
+                    continue;
+                const imported = importAliasToTarget.get(rootName);
+                if (imported) {
+                    deps.push({ target: imported.target, relationType: 'calls' });
+                    continue;
+                }
+                if (localFunctionNames.has(rootName)) {
+                    deps.push({ target: `${filePath}:${rootName}`, relationType: 'calls' });
+                }
+            }
+            for (const typeRef of node.getDescendantsOfKind(SyntaxKind.TypeReference)) {
+                const typeText = String(typeRef.getTypeName().getText() || '');
+                const rootName = typeText.split('.')[0]?.trim();
+                if (!rootName)
+                    continue;
+                const imported = importAliasToTarget.get(rootName);
+                if (imported) {
+                    deps.push({ target: imported.target, relationType: 'type_ref' });
+                }
+            }
+            return uniqueDependencyEdges(deps, 16);
         };
         // Extract Functions
         sourceFile.getFunctions().forEach(f => {
             if (f.isExported()) {
+                const deps = collectNodeDependencies(f, f.getText());
                 skeleton.functions.push({
                     name: f.getName(),
                     parameters: f.getParameters().map(p => ({
@@ -86,13 +246,28 @@ export function extractSkeleton(filePaths) {
                         type: p.getType().getText()
                     })),
                     returnType: f.getReturnType().getText(),
-                    jsDoc: f.getJsDocs().map(d => d.getCommentText()).join('\n')
+                    jsDoc: f.getJsDocs().map(d => d.getCommentText()).join('\n'),
+                    dependencies: deps,
                 });
             }
         });
         // Extract Classes
         sourceFile.getClasses().forEach(c => {
             if (c.isExported()) {
+                const deps = collectNodeDependencies(c, c.getText());
+                const extendsNode = c.getExtends();
+                if (extendsNode) {
+                    const baseName = String(extendsNode.getExpression().getText() || '').split('.')[0]?.trim();
+                    const imported = baseName ? importAliasToTarget.get(baseName) : undefined;
+                    if (imported)
+                        deps.push({ target: imported.target, relationType: 'extends' });
+                }
+                for (const impl of c.getImplements()) {
+                    const implName = String(impl.getExpression().getText() || '').split('.')[0]?.trim();
+                    const imported = implName ? importAliasToTarget.get(implName) : undefined;
+                    if (imported)
+                        deps.push({ target: imported.target, relationType: 'implements' });
+                }
                 skeleton.classes.push({
                     name: c.getName(),
                     methods: c.getMethods().map(m => ({
@@ -103,27 +278,44 @@ export function extractSkeleton(filePaths) {
                         })),
                         returnType: m.getReturnType().getText()
                     })),
-                    jsDoc: c.getJsDocs().map(d => d.getCommentText()).join('\n')
+                    jsDoc: c.getJsDocs().map(d => d.getCommentText()).join('\n'),
+                    dependencies: uniqueDependencyEdges(deps, 20),
                 });
             }
         });
         // Extract Interfaces
         sourceFile.getInterfaces().forEach(i => {
             if (i.isExported()) {
+                const deps = collectNodeDependencies(i, i.getText());
                 skeleton.interfaces.push({
                     name: i.getName(),
-                    jsDoc: i.getJsDocs().map(d => d.getCommentText()).join('\n')
+                    jsDoc: i.getJsDocs().map(d => d.getCommentText()).join('\n'),
+                    dependencies: deps,
                 });
             }
         });
         // Extract Types
         sourceFile.getTypeAliases().forEach(t => {
             if (t.isExported()) {
+                const deps = collectNodeDependencies(t, t.getText());
                 skeleton.types.push({
                     name: t.getName(),
+                    dependencies: deps,
                 });
             }
         });
+        const fullText = sourceFile.getFullText();
+        const rawHints = fullText
+            .split(/\r?\n/g)
+            .map((line) => compactText(line, 140))
+            .filter((line) => line.length >= 12)
+            .filter((line) => !line.startsWith('//') && !line.startsWith('*'))
+            .slice(0, 12);
+        skeleton.rawHints = uniqueStrings(rawHints, 8, 140);
+        // whitelist 파일만 raw_content 포함 (시크릿 제거 후 최대 3000자)
+        if (isWhitelisted && isWhitelisted(filePath)) {
+            skeleton.raw_content = redactSecrets(fullText).slice(0, 3000);
+        }
         result[filePath] = skeleton;
     });
     // 🛡️ Security: Payload Size Limit (DoS Prevention)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "monoai",
   "type": "module",
-  "version": "0.2.8",
+  "version": "0.3.0",
   "description": "MonoAI CLI for syncing codebase history",
   "main": "dist/index.js",
   "bin": {