monoai 0.2.9 → 0.4.0

package/README.md

@@ -1,52 +1,44 @@
 # MonoAI CLI
 
-MonoAI CLI is a strategic guide tool that measures alignment between product requirements and implementation, proposing a **list of issues the user should address right now**.
+Builds a structural map of your TypeScript codebase and syncs it to monoai.space.
+Analyzes alignment between your code and PRD, then surfaces the issues you should focus on next.
 
-## Why This Pipeline?
+## Product Flow
 
-**This pipeline enables the AI to support your strategic decisions with clear, factual evidence by providing a pre-computed "decision baseline" of your system's reality.**
-
-### 1. Deterministic Structure (via ts-morph)
-We distill the codebase into its fundamental structural skeleton. By focusing on interfaces and dependency trees rather than fluctuating implementation details, we provide a deterministic foundation that eliminates AI hallucinations.
+```
+monoai push → AST + KG + change signals
+PRD + structure → grounded issues
+```
 
-### 2. Relational Knowledge Graph (via Cognee)
-We transform individual code entities into a connected graph. This maps the logical flow of your system, ensuring that every product intent is not just present, but structurally integrated and executable within the codebase.
 
-## Key Features
+## Why a Knowledge Graph
 
-### 1. monoai login
-- Authenticate via [monoai.space](https://monoai.space) to access the central intelligence system.
+For issues to be grounded in actual code structure,
+you need **structured data refined from code** — not raw files.
 
-### 2. monoai push
-- **Evidence Extraction**: Automatically triggers AST extraction and Knowledge Graph construction to transmit clear evidence of the current implementation state.
-- **Foundation for Issue Derivation**: Establishes the structural context required to analyze alignment with the active PRD, enabling the central engine to propose a prioritized list of issues for immediate action.
+`monoai push` builds that map:
+- **AST extraction** (ts-morph) — functions, classes, interfaces, dependencies
+- **Knowledge graph** — relationships between code entities (calls, imports, inheritance)
+- **Change signals** — added, modified, or removed functions, classes, and files
 
-## Getting Started
+The LLM reasons on top of this map.
 
-### Requirements
-* Language: Official support for **TypeScript** (.ts, .tsx) codebases.
-* Environment: Node.js 18+ and Git-based projects.
 
-### Usage
-Execute immediately via `npx` without any installation.
+## Usage
 
 ```bash
-# Login (First time only)
-npx monoai login
-
-# Extract structure & Git history to build foundation for issue derivation
-npx monoai push
+npx monoai login   # first time only
+npx monoai push    # build and sync the structural map
 ```
 
-## .monoaiignore (optional)
+**Requirements:** TypeScript (.ts, .tsx) · Node.js 18+ · Git
 
-`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:
+## .monoaiignore
+
+Paths to exclude from AST scanning. Auto-generated on first push.
 
 ```gitignore
-# Example
 node_modules
 dist
 build
@@ -56,19 +48,13 @@ 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.
+## .monoaiwhitelist
 
-Use this when you run `monoai push` from a monorepo root but want to sync only one app (for example `step4.vite-web-migration`).
+Include-only filter — use this to scope a single app in a monorepo.
 
-```gitignore
-# Example: sync only step4 project
-step4.vite-web-migration/**
+```
+my-app/**
 ```
 
-Behavior summary:
-- `.monoaiwhitelist` limits scope first (include-only).
-- `.gitignore` and `.monoaiignore` still exclude paths inside that scope.
-
+Only matched paths are scanned. `.gitignore` and `.monoaiignore` still apply inside.

package/dist/commands/login.js

@@ -6,9 +6,9 @@ import open from 'open';
 import ora from 'ora';
 const config = new Conf({ projectName: 'monoai' });
 // 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 BACKEND_URL = process.env.MONOAI_API_URL ||
+    process.env.MONOAI_CONVEX_SITE_URL ||
+    'https://monoai-backend-653798811703.us-central1.run.app';
 const WEB_URL = 'https://monoai.space';
 export const loginCommand = new Command('login')
     .description('Sign in to MonoAI')
@@ -17,7 +17,7 @@ export const loginCommand = new Command('login')
     try {
         // 1. Init Session
         const initSpinner = ora('Preparing secure sign-in...').start();
-        const initRes = await axios.post(`${CONVEX_SITE_URL}/cli/auth/init`, {
+        const initRes = await axios.post(`${BACKEND_URL}/cli/auth/init`, {
             deviceDescription: process.platform
         });
         initSpinner.succeed();
@@ -34,13 +34,13 @@ export const loginCommand = new Command('login')
         const maxAttempts = 60; // 2 minutes (2s * 60)
         const pollInterval = setInterval(async () => {
             try {
-                const pollRes = await axios.post(`${CONVEX_SITE_URL}/cli/auth/poll`, { tempCode });
+                const pollRes = await axios.post(`${BACKEND_URL}/cli/auth/poll`, { tempCode });
                 const { status, token, userId } = pollRes.data;
                 if (status === 'approved' && token) {
                     clearInterval(pollInterval);
                     config.set('auth_token', token);
                     config.set('user_id', userId);
-                    config.set('convex_url', CONVEX_SITE_URL); // Store for future use
+                    config.set('api_url', BACKEND_URL); // Store for future use
                     pollSpinner.succeed(chalk.green('✅ Sign-in complete.'));
                     console.log(chalk.dim(`   Credentials saved to ${config.path}`));
                     process.exit(0);

package/dist/commands/push.js

@@ -6,7 +6,7 @@ import fs from 'fs';
 import path from 'path';
 import ignore from 'ignore';
 import Conf from 'conf';
-import { extractSkeleton } from '../utils/ast-extractor.js';
+import { extractSkeleton, buildEdgesFromSkeleton, buildReverseImportIndex, detectCircularDeps, detectArchitectureSmells } from '../utils/ast-extractor.js';
 const git = simpleGit();
 const config = new Conf({ projectName: 'monoai' });
 const MONOAIIGNORE_FILENAME = '.monoaiignore';
@@ -85,6 +85,98 @@ function buildChangedFileSignals(diffFiles) {
     })
         .filter(Boolean);
 }
+/**
+ * git diff --name-status로 삭제된 파일 목록 추출.
+ * simple-git diffSummary는 삭제 상태를 명시하지 않으므로 raw 명령 사용.
+ */
+async function detectDeletedFiles(fromRef, toRef = 'HEAD') {
+    try {
+        const raw = await git.raw(['diff', '--name-status', fromRef, toRef]);
+        const deleted = [];
+        for (const line of raw.split('\n')) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('D\t')) {
+                const fp = normalizeGitFilePath(trimmed.slice(2));
+                if (fp)
+                    deleted.push(fp);
+            }
+        }
+        return deleted.slice(0, 12);
+    }
+    catch {
+        return [];
+    }
+}
+function extractChangedSymbolsFromSkeleton(oldSkeleton, newSkeleton) {
+    const symbols = [];
+    const hasOld = Object.keys(oldSkeleton || {}).length > 0;
+    // 신규/수정 심볼 탐지 (새 스냅샷 기준)
+    for (const [filePath, newData] of Object.entries(newSkeleton || {})) {
+        if (!newData || typeof newData !== 'object')
+            continue;
+        const oldData = hasOld ? oldSkeleton?.[filePath] : undefined;
+        // 함수
+        const oldFuncMap = new Map((oldData?.functions || [])
+            .filter((f) => f?.name)
+            .map((f) => [f.name, f]));
+        for (const fn of (newData.functions || [])) {
+            const fname = fn?.name;
+            if (!fname)
+                continue;
+            if (!hasOld || !oldFuncMap.has(fname)) {
+                symbols.push(`+fn:${fname}`);
+            }
+            else {
+                // 시그니처 변경: 파라미터 수 변화
+                const oldFn = oldFuncMap.get(fname);
+                const oldParamCount = (oldFn?.parameters || []).length;
+                const newParamCount = (fn?.parameters || []).length;
+                if (oldParamCount !== newParamCount) {
+                    symbols.push(`~fn:${fname}`);
+                }
+            }
+        }
+        // 클래스
+        const oldClassMap = new Map((oldData?.classes || [])
+            .filter((c) => c?.name)
+            .map((c) => [c.name, c]));
+        for (const cls of (newData.classes || [])) {
+            const cname = cls?.name;
+            if (!cname)
+                continue;
+            if (!hasOld || !oldClassMap.has(cname)) {
+                symbols.push(`+class:${cname}`);
+            }
+            else {
+                // 메서드 수 변화 감지
+                const oldCls = oldClassMap.get(cname);
+                const oldMethodCount = (oldCls?.methods || []).length;
+                const newMethodCount = (cls?.methods || []).length;
+                if (oldMethodCount !== newMethodCount) {
+                    symbols.push(`~class:${cname}`);
+                }
+            }
+        }
+    }
+    // 삭제된 심볼 탐지 (이전 스냅샷에는 있었지만 새 스냅샷에는 없는 파일)
+    if (hasOld) {
+        for (const [filePath, oldData] of Object.entries(oldSkeleton)) {
+            if (newSkeleton[filePath])
+                continue; // 여전히 존재
+            if (!oldData || typeof oldData !== 'object')
+                continue;
+            for (const fn of (oldData.functions || [])) {
+                if (fn?.name)
+                    symbols.push(`-fn:${fn.name}`);
+            }
+            for (const cls of (oldData.classes || [])) {
+                if (cls?.name)
+                    symbols.push(`-class:${cls.name}`);
+            }
+        }
+    }
+    return symbols.slice(0, 16);
+}
 function buildGraphInsightsFromChanges(files) {
     if (!Array.isArray(files) || files.length === 0)
         return [];
@@ -124,6 +216,106 @@ 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.backendUrl}/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;
+    }
+}
+/**
+ * 백엔드에서 마지막 동기화 스냅샷의 skeleton(structure)을 fetch.
+ * oldSkeleton으로 삭제/수정 심볼 비교에 사용.
+ * 실패 시 {} 반환 (non-critical — 추가 심볼만 탐지).
+ */
+async function fetchLastSyncedSkeleton(params) {
+    try {
+        const res = await axios.post(`${params.backendUrl}/cli/git-last-skeleton`, { branch: params.branch }, {
+            headers: { Authorization: `Bearer ${params.token}` },
+            timeout: 8000,
+        });
+        const structure = res?.data?.structure;
+        if (typeof structure === 'string' && structure.trim()) {
+            return JSON.parse(structure);
+        }
+        if (typeof structure === 'object' && structure !== null) {
+            return structure;
+        }
+        return {};
+    }
+    catch {
+        return {};
+    }
+}
 export const pushCommand = new Command('push')
     .description('Sync your codebase structure to MonoAI')
     .option('-v, --verbose', 'Show internal pipeline logs')
@@ -147,54 +339,101 @@ export const pushCommand = new Command('push')
         });
     };
     try {
-        console.log(chalk.blue('🏎️  Starting codebase sync...'));
         // 0. Auth Check
         const token = config.get('auth_token');
         if (!token) {
-            console.error(chalk.red('❌ You are not signed in. Please run:'));
-            console.error(chalk.white('   npx monoai login'));
+            console.error(chalk.red('not signed in. run: npx monoai login'));
             return;
         }
         const isRepo = await git.checkIsRepo();
         if (!isRepo) {
-            console.error(chalk.red('❌ This folder is not a Git repository.'));
+            console.error(chalk.red('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' : ''})`));
+            logDetail(`  whitelist  ${whitelistRuleCount} rule${whitelistRuleCount > 1 ? 's' : ''}`);
         }
+        const BACKEND_URL = process.env.MONOAI_API_URL ||
+            process.env.MONOAI_BACKEND_URL ||
+            config.get('api_url') ||
+            config.get('convex_url') ||
+            'https://monoai-backend-653798811703.us-central1.run.app';
         // 1. Git Metadata (Zero-HITL Intent)
-        const { lastCommit, branch, changedScopes, graphInsights } = await track('git metadata', async () => {
+        const { lastCommit, branch, changedScopes, changedFiles, commitMessages, deletedFiles } = 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 = [];
+            let commitMessages = [];
+            let deletedFiles = [];
+            const maxDiffCommits = Math.max(1, Math.min(Number(process.env.MONOAI_DIFF_MAX_COMMITS || 30), 200));
+            const lastSyncedCommit = force
+                ? null
+                : await fetchLastSyncedCommit({
+                    backendUrl: BACKEND_URL,
+                    token: String(token),
+                    branch,
+                });
+            let fromRef = 'HEAD~1';
             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) {
+                            fromRef = `HEAD~${maxDiffCommits}`;
+                            diffSummary = await git.diffSummary([fromRef, 'HEAD']);
+                        }
+                        else {
+                            fromRef = lastSyncedCommit;
+                            diffSummary = await git.diffSummary([`${lastSyncedCommit}..HEAD`]);
+                        }
+                    }
+                    catch {
+                        fromRef = 'HEAD~1';
+                        diffSummary = await git.diffSummary(['HEAD~1', 'HEAD']);
+                    }
+                }
+                else {
+                    diffSummary = await git.diffSummary(['HEAD~1', 'HEAD']);
+                }
+                changedRows = buildChangedFileSignals(diffSummary?.files || []);
+                // 삭제된 파일 탐지 (git diff --name-status)
+                deletedFiles = await detectDeletedFiles(fromRef, 'HEAD');
+                // 다중 커밋 메시지 수집 (최대 10개)
+                try {
+                    const commitLog = await git.log({ maxCount: 10 });
+                    commitMessages = (commitLog.all || [])
+                        .map(c => `${c.hash.slice(0, 7)}: ${c.message.split('\n')[0].slice(0, 100)}`)
+                        .filter(Boolean);
+                }
+                catch {
+                    commitMessages = [lastCommit.message.split('\n')[0].slice(0, 100)];
+                }
             }
             catch {
-                changedFiles = [];
+                changedRows = [];
+                commitMessages = [];
+                deletedFiles = [];
             }
-            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, commitMessages, deletedFiles };
         });
         const shortCommitId = lastCommit.hash.substring(0, 7);
         const snapshotId = `${branch}@${shortCommitId}`;
-        logDetail(`   Branch: ${chalk.white(branch)}`);
-        logDetail(`   Commit: ${chalk.white(shortCommitId)}`);
-        // 2. Scan and extract source structure
-        console.log(chalk.blue('🔍 Scanning codebase structure...'));
+        const commitSummary = lastCommit.message.split('\n')[0].slice(0, 72);
+        console.log(`  → ${branch}  ${shortCommitId}  ${commitSummary}`);
+        console.log(`  building structure...`);
         const { skeleton } = await track('structure scan', async () => {
             const ig = ignore();
             const monoaiIgnorePath = path.join(process.cwd(), MONOAIIGNORE_FILENAME);
@@ -229,16 +468,82 @@ export const pushCommand = new Command('push')
                 }
             };
             scanDir(process.cwd());
-            const skeleton = extractSkeleton(filesToAnalyze);
-            console.log(chalk.dim(`   Files scanned: ${filesToAnalyze.length}`));
+            const skeleton = extractSkeleton(filesToAnalyze, isWhitelisted);
+            logDetail(`  scanned  ${filesToAnalyze.length} files`);
             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 data...'));
+        // 3. KG 엣지 + 역방향 인덱스 + 아키텍처 분석
+        const kgEdges = buildEdgesFromSkeleton(skeleton);
+        // oldSkeleton fetch (삭제/수정 심볼 탐지를 위해 이전 스냅샷 가져오기)
+        const oldSkeleton = await fetchLastSyncedSkeleton({
+            backendUrl: BACKEND_URL,
+            token: String(token),
+            branch,
+        });
+        // 변경 심볼 (oldSkeleton 있으면 삭제/수정 탐지, 없으면 추가만)
+        const changedSymbols = extractChangedSymbolsFromSkeleton(oldSkeleton, skeleton);
+        // 역방향 import 인덱스 계산 (영향 범위 분석용)
+        const reverseIndex = buildReverseImportIndex(skeleton);
+        // 아키텍처 스멜 감지 (god file, high fan-in/fan-out)
+        const archSmells = detectArchitectureSmells(skeleton, reverseIndex);
+        // 순환 의존성 감지
+        const circularDeps = detectCircularDeps(kgEdges);
+        const circularSignals = circularDeps.map(c => {
+            const fileA = c.cycleA.split('/').pop() || c.cycleA;
+            const fileB = c.cycleB.split('/').pop() || c.cycleB;
+            return `circular_dep:${fileA}↔${fileB}`;
+        });
+        // 영향 범위 신호 (변경 파일의 직접 importers)
+        const impactSignals = [];
+        for (const cf of changedFiles.slice(0, 8)) {
+            const importers = reverseIndex.get(cf.path) || [];
+            if (importers.length > 0) {
+                const affected = importers.slice(0, 3).map(f => f.split('/').pop() || f).join(',');
+                impactSignals.push(`impact_radius:${cf.path.split('/').pop()} importers=${importers.length} affected=[${affected}]`);
+            }
+        }
+        // 삭제 파일 신호
+        const deletedFileSignals = deletedFiles
+            .filter(f => isWhitelisted(f))
+            .map(f => `deleted_file:${f}`);
+        // graphInsights 조립 (56개로 확장)
+        const graphInsights = Array.from(new Set([
+            ...buildGraphInsightsFromChanges(changedFiles),
+            ...changedSymbols.map(s => `changed_symbol:${s}`),
+            ...archSmells,
+            ...circularSignals,
+            ...impactSignals,
+            ...deletedFileSignals,
+            ...buildTargetRawInsights(skeleton, changedFiles, 16),
+        ])).slice(0, 56);
+        // stats 출력
+        const statParts = [
+            `${Object.keys(skeleton).length} files`,
+            `${kgEdges.length} edges`,
+        ];
+        if (changedFiles.length > 0)
+            statParts.push(`${changedFiles.length} changed`);
+        if (changedSymbols.length > 0) {
+            const readable = changedSymbols.slice(0, 3).map(s => {
+                const [prefix, ...rest] = s.split(':');
+                const name = rest.join(':').split(':').pop() || rest.join(':');
+                if (prefix === '+fn' || prefix === '+class' || prefix === '+iface')
+                    return `added ${name}`;
+                if (prefix === '-fn' || prefix === '-class' || prefix === '-iface')
+                    return `removed ${name}`;
+                if (prefix === '~fn' || prefix === '~class' || prefix === '~iface')
+                    return `modified ${name}`;
+                return s;
+            });
+            statParts.push(readable.join(', '));
+        }
+        if (archSmells.length > 0)
+            statParts.push(`${archSmells.length} smell${archSmells.length > 1 ? 's' : ''}`);
+        if (circularDeps.length > 0)
+            statParts.push(`${circularDeps.length} circular`);
+        if (deletedFiles.length > 0)
+            statParts.push(`${deletedFiles.length} deleted`);
+        console.log(`  ${statParts.join('  ·  ')}`);
         // 4. Payload Construction
         const payload = {
             name: path.basename(process.cwd()),
@@ -246,17 +551,17 @@ export const pushCommand = new Command('push')
             branch: branch,
             commitId: shortCommitId,
             commitMessage: lastCommit.message,
-            structure: JSON.stringify(skeleton), // Structured AST
+            commitMessages: commitMessages.slice(0, 10),
+            structure: JSON.stringify(skeleton),
+            edges: kgEdges,
             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`, {
+        // 5. Send to Convex
+        const transmitResult = await track('upload', async () => {
+            const response = await axios.post(`${BACKEND_URL}/cli/git-commit`, {
                 codebaseData: payload,
-                force,
             }, {
                 headers: {
                     'Authorization': `Bearer ${token}`
@@ -264,85 +569,23 @@ 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('🧠 Building Knowledge Graph...'));
-            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 && 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: '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');
-                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(`❌ Could not build Knowledge Graph: ${finalJob.error}`));
-                }
-                if (finalJob.status === 'done') {
-                    console.log(chalk.green('✅ Knowledge Graph is ready.'));
-                }
-            }
-            else {
-                console.log(chalk.yellow('⚠ Knowledge Graph status is unavailable. It may still be processing in the background.'));
-            }
-        }
-        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 time: ${(totalMs / 1000).toFixed(2)}s`));
+        console.log(`  pushed.  (${(totalMs / 1000).toFixed(2)}s)`);
+        logDetail(`  graphJobId: ${transmitResult?.graphJobId || 'none'}`);
     }
     catch (error) {
         const totalMs = Date.now() - totalStart;
         if (error.response?.status === 401) {
-            console.error(chalk.red('❌ Your sign-in has expired. Please run:'));
-            console.error(chalk.white('   npx monoai login'));
+            console.error(chalk.red('auth expired. run: npx monoai login'));
         }
         else {
-            console.error(chalk.red('❌ Sync failed:'), error.message);
+            console.error(chalk.red(`sync failed: ${error.message}`));
         }
         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.dim(`  ${item.stage}: ${(item.ms / 1000).toFixed(2)}s`));
             }
         }
-        console.log(chalk.blue(`⏱ Total time: ${(totalMs / 1000).toFixed(2)}s`));
+        console.log(chalk.dim(`  (${(totalMs / 1000).toFixed(2)}s)`));
     }
 });

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,56 +166,237 @@ 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
+        // Extract Functions (function declarations + exported arrow/const functions)
+        const asyncFunctionNames = [];
         sourceFile.getFunctions().forEach(f => {
             if (f.isExported()) {
+                const deps = collectNodeDependencies(f, f.getText());
+                const isAsync = f.isAsync();
+                const fname = f.getName();
+                if (isAsync && fname)
+                    asyncFunctionNames.push(fname);
                 skeleton.functions.push({
-                    name: f.getName(),
+                    name: fname,
                     parameters: f.getParameters().map(p => ({
                         name: p.getName(),
                         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,
+                    isAsync,
+                    modifiers: f.getModifiers().map(m => m.getText()),
                 });
             }
         });
+        // Arrow functions / const fn (exported variable declarations)
+        sourceFile.getVariableStatements().forEach(stmt => {
+            if (!stmt.isExported())
+                return;
+            stmt.getDeclarations().forEach(decl => {
+                const init = decl.getInitializer();
+                if (!init)
+                    return;
+                const kind = init.getKind();
+                const isArrow = kind === SyntaxKind.ArrowFunction;
+                const isFuncExpr = kind === SyntaxKind.FunctionExpression;
+                if (!isArrow && !isFuncExpr)
+                    return;
+                const fname = decl.getName();
+                if (!fname)
+                    return;
+                const fn = init;
+                const isAsync = typeof fn.isAsync === 'function' ? fn.isAsync() : false;
+                if (isAsync)
+                    asyncFunctionNames.push(fname);
+                const params = typeof fn.getParameters === 'function'
+                    ? fn.getParameters().map((p) => ({ name: p.getName(), type: p.getType().getText() }))
+                    : [];
+                const returnType = typeof fn.getReturnType === 'function' ? fn.getReturnType().getText() : '';
+                const deps = collectNodeDependencies(init, init.getText());
+                skeleton.functions.push({
+                    name: fname,
+                    parameters: params,
+                    returnType,
+                    jsDoc: stmt.getJsDocs().map((d) => d.getCommentText()).join('\n'),
+                    dependencies: deps,
+                    isAsync,
+                    modifiers: stmt.getModifiers().map(m => m.getText()),
+                });
+            });
+        });
+        if (asyncFunctionNames.length > 0) {
+            skeleton.asyncFunctions = asyncFunctionNames.slice(0, 12);
+        }
         // Extract Classes
+        const classFieldSummaries = [];
         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' });
+                }
+                const cname = c.getName() || '';
+                // 클래스 프로퍼티(필드) 추출
+                const properties = c.getProperties().map(p => {
+                    const pname = p.getName();
+                    const ptype = p.getType().getText();
+                    const pmods = p.getModifiers().map(m => m.getText());
+                    if (cname && pname) {
+                        const modStr = pmods.filter(m => m !== 'public').join(' ');
+                        classFieldSummaries.push(`${cname}.${pname}${modStr ? `[${modStr}]` : ''}: ${ptype.slice(0, 60)}`);
+                    }
+                    return { name: pname, type: ptype, modifiers: pmods };
+                }).slice(0, 10);
                 skeleton.classes.push({
-                    name: c.getName(),
+                    name: cname,
+                    isAbstract: c.isAbstract(),
                     methods: c.getMethods().map(m => ({
                         name: m.getName(),
                         parameters: m.getParameters().map(p => ({
                             name: p.getName(),
                             type: p.getType().getText()
                         })),
-                        returnType: m.getReturnType().getText()
+                        returnType: m.getReturnType().getText(),
+                        isStatic: m.isStatic(),
+                        isAsync: m.isAsync(),
                     })),
-                    jsDoc: c.getJsDocs().map(d => d.getCommentText()).join('\n')
+                    properties,
+                    jsDoc: c.getJsDocs().map(d => d.getCommentText()).join('\n'),
+                    dependencies: uniqueDependencyEdges(deps, 20),
                 });
             }
         });
+        if (classFieldSummaries.length > 0) {
+            skeleton.classFields = classFieldSummaries.slice(0, 16);
+        }
         // Extract Interfaces
+        const interfaceShapeSummaries = [];
         sourceFile.getInterfaces().forEach(i => {
             if (i.isExported()) {
+                const deps = collectNodeDependencies(i, i.getText());
+                const iname = i.getName();
+                const properties = i.getProperties().map(p => {
+                    const pname = p.getName();
+                    const ptype = p.getType().getText();
+                    const optional = p.hasQuestionToken();
+                    if (iname && pname) {
+                        interfaceShapeSummaries.push(`${iname}.${pname}${optional ? '?' : ''}: ${ptype.slice(0, 60)}`);
+                    }
+                    return { name: pname, type: ptype, optional };
+                }).slice(0, 12);
                 skeleton.interfaces.push({
-                    name: i.getName(),
-                    jsDoc: i.getJsDocs().map(d => d.getCommentText()).join('\n')
+                    name: iname,
+                    jsDoc: i.getJsDocs().map(d => d.getCommentText()).join('\n'),
+                    dependencies: deps,
+                    properties,
                 });
             }
         });
+        if (interfaceShapeSummaries.length > 0) {
+            skeleton.interfaceShape = interfaceShapeSummaries.slice(0, 16);
+        }
         // 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)
@@ -133,3 +406,130 @@ export function extractSkeleton(filePaths) {
     }
     return result;
 }
+/**
+ * AST skeleton에서 KG 엣지를 직접 생성 (app.py _build_graph 로직 이식).
+ * Railway KG 워커 없이 사용자 컴퓨팅으로 결정론적 엣지를 추출한다.
+ */
+export function buildEdgesFromSkeleton(skeleton) {
+    const edges = [];
+    const edgeKeys = new Set();
+    function addEdge(sourceId, targetId, relationType, sourceType, targetType) {
+        const sid = sourceId.trim();
+        const tid = targetId.trim();
+        if (!sid || !tid)
+            return;
+        const key = `${sid}::${relationType}::${tid}`;
+        if (edgeKeys.has(key))
+            return;
+        edgeKeys.add(key);
+        edges.push({ sourceId: sid, targetId: tid, relationType, sourceType, targetType });
+    }
+    for (const [filePath, sk] of Object.entries(skeleton)) {
+        if (!filePath || typeof sk !== 'object')
+            continue;
+        // 파일 → import 파일 엣지
+        for (const importPath of sk.fileImports || []) {
+            if (!importPath)
+                continue;
+            addEdge(filePath, importPath, 'imports', 'code_file', 'code_file');
+        }
+        // 파일 → 심볼 (implemented_in)
+        const allSymbols = [
+            ...(sk.functions || []).map((f) => ({ name: f?.name, type: 'function' })),
+            ...(sk.classes || []).map((c) => ({ name: c?.name, type: 'class' })),
+            ...(sk.interfaces || []).map((i) => ({ name: i?.name, type: 'interface' })),
+            ...(sk.types || []).map((t) => ({ name: t?.name, type: 'type' })),
+        ];
+        for (const sym of allSymbols) {
+            if (!sym.name)
+                continue;
+            const symId = `${filePath}:${sym.name}`;
+            addEdge(filePath, symId, 'implemented_in', 'code_file', 'code_symbol');
+            // 심볼 의존성 엣지 (calls, type_ref, depends_on 등)
+            const symData = sk.functions?.find((f) => f?.name === sym.name) ||
+                sk.classes?.find((c) => c?.name === sym.name) ||
+                sk.interfaces?.find((i) => i?.name === sym.name) ||
+                sk.types?.find((t) => t?.name === sym.name);
+            const deps = Array.isArray(symData?.dependencies) ? symData.dependencies : [];
+            for (const dep of deps) {
+                const target = typeof dep === 'string' ? dep : dep?.target;
+                const rel = typeof dep === 'string' ? 'depends_on' : (dep?.relationType || 'depends_on');
+                if (!target)
+                    continue;
+                const targetType = target.includes(':') ? 'code_symbol' : 'code_file';
+                addEdge(symId, target, rel, 'code_symbol', targetType);
+            }
+        }
+    }
+    return edges;
+}
+/**
+ * skeleton에서 역방향 import 인덱스 계산.
+ * 반환: Map<targetFile, sourceFile[]>
+ * "이 파일을 import하는 파일들"을 O(1)로 조회 가능.
+ */
+export function buildReverseImportIndex(skeleton) {
+    const index = new Map();
+    for (const [filePath, sk] of Object.entries(skeleton)) {
+        if (!filePath || typeof sk !== 'object')
+            continue;
+        for (const importPath of sk.fileImports || []) {
+            if (!importPath)
+                continue;
+            const existing = index.get(importPath) || [];
+            existing.push(filePath);
+            index.set(importPath, existing);
+        }
+    }
+    return index;
+}
+/**
+ * KgEdge 목록에서 직접 순환 의존성(A→B + B→A) 탐지.
+ * import 엣지만 대상. 최대 8개 반환.
+ */
+export function detectCircularDeps(edges) {
+    const importEdges = edges.filter(e => e.relationType === 'imports');
+    const edgeSet = new Set(importEdges.map(e => `${e.sourceId}::${e.targetId}`));
+    const seen = new Set();
+    const cycles = [];
+    for (const e of importEdges) {
+        const reverseKey = `${e.targetId}::${e.sourceId}`;
+        const cycleKey = [e.sourceId, e.targetId].sort().join('::');
+        if (edgeSet.has(reverseKey) && !seen.has(cycleKey)) {
+            seen.add(cycleKey);
+            cycles.push({ cycleA: e.sourceId, cycleB: e.targetId });
+        }
+    }
+    return cycles.slice(0, 8);
+}
+/**
+ * skeleton + reverseIndex 활용한 아키텍처 스멜 감지.
+ * 반환: graphInsights에 추가할 신호 문자열 배열.
+ *   arch_smell:god_file:filename symbols=N   (심볼 과밀)
+ *   arch_smell:high_fan_in:filename importers=N  (많이 참조됨)
+ *   arch_smell:high_fan_out:filename imports=N   (너무 많이 의존)
+ */
+export function detectArchitectureSmells(skeleton, reverseIndex) {
+    const smells = [];
+    for (const [filePath, sk] of Object.entries(skeleton)) {
+        if (!filePath || typeof sk !== 'object')
+            continue;
+        const shortName = filePath.split('/').pop() || filePath;
+        // God file: 함수 + 클래스 수 > 15
+        const symbolCount = (sk.functions?.length || 0) + (sk.classes?.length || 0);
+        if (symbolCount > 15) {
+            smells.push(`arch_smell:god_file:${shortName} symbols=${symbolCount}`);
+        }
+        // High fan-in: 역방향 import 수 > 6 (많이 참조됨 = 변경 시 파급 큼)
+        const importers = reverseIndex.get(filePath) || [];
+        if (importers.length > 6) {
+            smells.push(`arch_smell:high_fan_in:${shortName} importers=${importers.length}`);
+        }
+        // High fan-out: 직접 import 수 > 10 (너무 많이 의존)
+        const fanOut = (sk.fileImports || []).length;
+        if (fanOut > 10) {
+            smells.push(`arch_smell:high_fan_out:${shortName} imports=${fanOut}`);
+        }
+    }
+    return smells.slice(0, 6);
+}

package/dist/utils/config.js

@@ -5,15 +5,16 @@ const config = new Conf({
 });
 export const saveCredentials = (token, url) => {
     config.set('authToken', token);
-    config.set('convexUrl', url);
+    config.set('apiUrl', url);
 };
 export const getCredentials = () => {
     return {
         authToken: config.get('authToken'),
-        convexUrl: config.get('convexUrl')
+        apiUrl: config.get('apiUrl') || config.get('convexUrl')
     };
 };
 export const clearCredentials = () => {
     config.delete('authToken');
+    config.delete('apiUrl');
     config.delete('convexUrl');
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "monoai",
   "type": "module",
-  "version": "0.2.9",
+  "version": "0.4.0",
   "description": "MonoAI CLI for syncing codebase history",
   "main": "dist/index.js",
   "bin": {
@@ -9,7 +9,6 @@
   },
   "files": [
     "dist",
-    "scripts",
     "README.md"
   ],
   "scripts": {

package/scripts/cognee_bridge.py

@@ -1,127 +0,0 @@
-import sys
-import json
-import asyncio
-import os
-from typing import List, Dict
-
-# Cognee 라이브러리 로드 시도
-try:
-    import cognee
-except ImportError:
-    # PoC 환경에서 패키지가 없을 경우 에러 메시지 반환
-    print(json.dumps({
-        "error": "cognee library not found. Please install it with 'pip install cognee' to enable graph-based analysis.",
-        "nodes": [],
-        "edges": []
-    }))
-    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 지식 그래프로 변환하고 분석합니다.
-    """
-    # 중앙 API 키 설정 (Cognee 엔진에 주입)
-    os.environ["OPENAI_API_KEY"] = api_key
-    
-    # 1. 온톨로지 정의 (MVP용 간략화)
-    # Cognee의 cognify 프로세스를 통해 코드 간의 실제 '의미론적 관계'를 추출합니다.
-    
-    nodes = []
-    edges = []
-    
-    # AST 데이터 파싱 (ts-morph 추출본 기준)
-    files = _normalize_files(ast_data)
-    
-    for file in files:
-        file_id = file.get("path")
-        nodes.append({
-            "id": file_id,
-           "type": "codebase",
-            "name": os.path.basename(file_id)
-        })
-        
-        # 클래스 및 함수 관계 추출
-        for item in file.get("items", []):
-            item_id = f"{file_id}:{item.get('name')}"
-            nodes.append({
-                "id": item_id,
-                "type": item.get("type", "unknown"),
-                "name": item.get("name")
-            })
-            
-            # 관계 생성 (File -> Item)
-            edges.append({
-                "sourceId": file_id,
-                "targetId": item_id,
-                "relationType": "implemented_in"
-            })
-            
-            # 의존성 관계 추출 (추후 Cognee 엔진이 텍스트 분석으로 보강할 영역)
-            for dep in item.get("dependencies", []):
-                edges.append({
-                    "sourceId": item_id,
-                    "targetId": dep,
-                    "relationType": "depends_on"
-                })
-
-    # 2. Cognee 엔진을 통한 그래프 고도화
-    # 실제 구현 시: 
-    # await cognee.add(ast_data).cognify()
-    # graph = await cognee.get_graph()
-    
-    return {
-        "nodes": nodes,
-        "edges": edges,
-        "status": "success",
-        "processor": "cognee-bridge-v1"
-    }
-
-async def main():
-    if len(sys.argv) < 3:
-        print(json.dumps({"error": "Missing arguments. Usage: python cognee_bridge.py <ast_path> <api_key>"}))
-        return
-
-    ast_path = sys.argv[1]
-    api_key = sys.argv[2]
-
-    try:
-        if not os.path.exists(ast_path):
-            raise FileNotFoundError(f"AST file not found: {ast_path}")
-
-        with open(ast_path, 'r') as f:
-            ast_data = json.load(f)
-        
-        result = await process_ast_to_graph(ast_data, api_key)
-        print(json.dumps(result))
-        
-    except Exception as e:
-        print(json.dumps({"error": str(e), "nodes": [], "edges": []}))
-
-if __name__ == "__main__":
-    asyncio.run(main())