fivocell 1.0.0

package/dist/cli.js

@@ -0,0 +1,1131 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const index_1 = require("./index");
+const program = new commander_1.Command();
+program
+    .name('cell')
+    .description('FIVO Cell — Anticipatory Intelligence. Learns your coding taste.')
+    .version('1.0.0');
+program
+    .command('init')
+    .description('Initialize FIVO Cell in the current project')
+    .action(() => {
+    const cellDir = path.join(process.cwd(), index_1.DEFAULT_CONFIG.cellDir);
+    if (!fs.existsSync(cellDir)) {
+        fs.mkdirSync(cellDir, { recursive: true });
+    }
+    const store = new index_1.PatternStore(cellDir);
+    store.save();
+    console.log('✅ FIVO Cell initialized.');
+    console.log(`   Directory: ${cellDir}`);
+    console.log('');
+    console.log('🌐 Cloud Sync: ON (Anonymous pattern stats only)');
+    console.log('   → Better suggestions from 10K+ developers');
+    console.log('   → Your code NEVER leaves your machine');
+    console.log('   → What we share (just stats, no code):');
+    console.log('     "prefers const over let (92%)"');
+    console.log('     "uses named exports, not default (88%)"');
+    console.log('     "vitest over jest (95%)"');
+    console.log('     "pnpm over npm (90%)"');
+    console.log('   → No file paths. No project names. No source code.');
+    console.log('   → Turn off anytime: cell cloud off');
+    console.log('');
+    console.log('   Run `cell status` to see your taste profile.');
+});
+program
+    .command('status')
+    .description('Show current taste profile summary')
+    .action(() => {
+    const cellDir = path.join(process.cwd(), index_1.DEFAULT_CONFIG.cellDir);
+    if (!fs.existsSync(cellDir)) {
+        console.log('❌ Cell not initialized. Run `cell init` first.');
+        return;
+    }
+    const store = new index_1.PatternStore(cellDir);
+    console.log('\n📊 FIVO Cell — Taste Profile');
+    console.log('──────────────────────────────');
+    const patterns = store.getAllPatterns();
+    if (patterns.length === 0) {
+        console.log('No patterns learned yet. Start coding to teach Cell your style.');
+        return;
+    }
+    console.log(`Total patterns: ${patterns.length}`);
+    console.log(`Total signals: ${store.getTotalSignals()}`);
+    const strong = store.getPatternsByTier('strong');
+    const moderate = store.getPatternsByTier('moderate');
+    const weak = store.getPatternsByTier('weak');
+    console.log(`\nTiers:`);
+    console.log(`  Strong (>0.80):   ${strong.length} patterns`);
+    console.log(`  Moderate (0.50-0.80): ${moderate.length} patterns`);
+    console.log(`  Weak (0.30-0.50):    ${weak.length} patterns`);
+    if (strong.length > 0) {
+        console.log('\nTop patterns:');
+        const top = patterns
+            .sort((a, b) => b.confidence.mean - a.confidence.mean)
+            .slice(0, 5);
+        for (const p of top) {
+            console.log(`  ✅ ${p.description} (${p.confidence.mean}, ${p.signals?.positive || 0}/${p.signals?.total || 0} signals)`);
+        }
+    }
+    console.log('');
+});
+program
+    .command('taste show')
+    .description('Display your cell.md profile')
+    .action(() => {
+    const cellDir = path.join(process.cwd(), index_1.DEFAULT_CONFIG.cellDir);
+    const mdPath = path.join(cellDir, 'cell.md');
+    if (!fs.existsSync(mdPath)) {
+        console.log('❌ No taste profile found. Run `cell init` first, then start coding.');
+        return;
+    }
+    console.log(fs.readFileSync(mdPath, 'utf-8'));
+});
+program
+    .command('taste reset')
+    .description('Reset all learned patterns')
+    .action(() => {
+    const cellDir = path.join(process.cwd(), index_1.DEFAULT_CONFIG.cellDir);
+    if (!fs.existsSync(cellDir)) {
+        console.log('❌ Cell not initialized.');
+        return;
+    }
+    const store = new index_1.PatternStore(cellDir);
+    store.clear();
+    console.log('✅ All patterns reset. Cell will relearn from scratch.');
+});
+program
+    .command('learn')
+    .description('Feed a code edit to Cell for learning')
+    .option('-o, --original <code>', 'Original AI-generated code')
+    .option('-e, --edited <code>', 'Your edited version')
+    .option('-a, --accept', 'Mark as accepted (no edits)')
+    .option('-r, --reject', 'Mark as rejected')
+    .action((options) => {
+    const cellDir = path.join(process.cwd(), index_1.DEFAULT_CONFIG.cellDir);
+    if (!fs.existsSync(cellDir)) {
+        console.log('❌ Cell not initialized. Run `cell init` first.');
+        return;
+    }
+    const capture = new index_1.SignalCapture();
+    const cascade = new index_1.ExtractionCascade();
+    const store = new index_1.PatternStore(cellDir);
+    const context = {
+        language: 'typescript',
+        framework: 'unknown',
+        fileType: 'unknown',
+        strictness: 'moderate',
+        projectId: path.basename(process.cwd()),
+    };
+    if (options.accept && options.original) {
+        const signal = capture.captureAccept(options.original, context);
+        console.log(`✅ Accept signal captured (session: ${signal.sessionId})`);
+    }
+    else if (options.reject && options.original) {
+        const signal = capture.captureReject(options.original, context);
+        console.log(`❌ Reject signal captured (session: ${signal.sessionId})`);
+    }
+    else if (options.original && options.edited) {
+        const signal = capture.captureEditDiff(options.original, options.edited, context);
+        const result = cascade.extract(options.original, options.edited);
+        console.log(`📝 Edit diff captured (session: ${signal.sessionId})`);
+        console.log(`   Step used: ${result.stepUsed}`);
+        console.log(`   Latency: ${result.latencyMs}ms`);
+        console.log(`   Patterns found: ${result.patterns.length}`);
+        for (const p of result.patterns) {
+            const pattern = store.addOrUpdatePattern(p.category, p.description, p.from, p.to, true, p.conditions);
+            console.log(`   → ${p.description} (confidence: ${pattern.confidence.mean})`);
+        }
+        store.save();
+        console.log(`\n✅ Taste profile updated. ${store.getPatternCount()} patterns total.`);
+    }
+    else {
+        console.log('❌ Provide --original and --edited, or --accept, or --reject');
+    }
+});
+program
+    .command('push')
+    .description('Push your taste to team directory')
+    .option('-u, --username <name>', 'Your username')
+    .action((options) => {
+    const cellDir = path.join(process.cwd(), index_1.DEFAULT_CONFIG.cellDir);
+    if (!fs.existsSync(cellDir)) {
+        console.log('❌ Cell not initialized. Run `cell init` first.');
+        return;
+    }
+    const username = options.username || process.env.USER || process.env.USERNAME || 'anonymous';
+    const store = new index_1.PatternStore(cellDir);
+    const composer = new index_1.TeamComposer(store, cellDir);
+    composer.pushTaste(username);
+    console.log(`✅ Taste pushed for ${username}.`);
+    console.log(`   Team members: ${composer.getTeamMembers().join(', ') || 'none yet'}`);
+});
+program
+    .command('pull')
+    .description('Pull team or member taste')
+    .option('-u, --username <name>', 'Pull specific member taste')
+    .option('--team', 'Pull full team composite')
+    .action((options) => {
+    const cellDir = path.join(process.cwd(), index_1.DEFAULT_CONFIG.cellDir);
+    if (!fs.existsSync(cellDir)) {
+        console.log('❌ Cell not initialized.');
+        return;
+    }
+    const store = new index_1.PatternStore(cellDir);
+    const composer = new index_1.TeamComposer(store, cellDir);
+    if (options.username) {
+        const taste = composer.pullTaste(options.username);
+        if (!taste) {
+            console.log(`❌ No taste found for ${options.username}.`);
+            return;
+        }
+        console.log(`📥 Pulled taste from ${options.username}:`);
+        console.log(`   Patterns: ${taste.patterns.length}`);
+        console.log(`   Signals: ${taste.totalSignals}`);
+    }
+    else {
+        const taste = composer.pullTeamTaste();
+        if (!taste) {
+            console.log('❌ No team taste available. Have teammates pushed yet?');
+            return;
+        }
+        console.log(`📥 Pulled team taste (${composer.getTeamMembers().length} members):`);
+        console.log(`   Patterns: ${taste.patterns.length}`);
+        console.log(`   Total signals: ${taste.totalSignals}`);
+    }
+});
+program
+    .command('vote')
+    .description('Vote on a pattern conflict')
+    .option('-p, --pattern <id>', 'Pattern conflict ID (e.g., p_abc_vs_p_def)')
+    .option('-v, --vote <choice>', 'Your vote: A, B, or none')
+    .option('--status', 'Show vote status')
+    .action((options) => {
+    const cellDir = path.join(process.cwd(), index_1.DEFAULT_CONFIG.cellDir);
+    if (!fs.existsSync(cellDir)) {
+        console.log('❌ Cell not initialized.');
+        return;
+    }
+    const detector = new index_1.ConflictDetector(cellDir);
+    if (options.status && options.pattern) {
+        const sessions = fs.existsSync(detector['voteStorePath'])
+            ? JSON.parse(fs.readFileSync(detector['voteStorePath'], 'utf-8'))
+            : [];
+        const session = sessions.find((s) => s.patternId === options.pattern);
+        if (!session) {
+            console.log('❌ Vote session not found.');
+            return;
+        }
+        console.log(detector.getVoteStatus(session));
+        return;
+    }
+    if (options.pattern && options.vote) {
+        const username = process.env.USER || process.env.USERNAME || 'anonymous';
+        const session = detector.castVote(options.pattern, username, options.vote);
+        if (!session) {
+            console.log('❌ Vote failed. Check pattern ID and deadline.');
+            return;
+        }
+        console.log(`✅ Vote cast: ${options.vote}`);
+        console.log(detector.getVoteStatus(session));
+        return;
+    }
+    console.log('Usage: cell taste vote --pattern "X_vs_Y" --vote A');
+    console.log('       cell taste vote --pattern "X_vs_Y" --status');
+});
+program
+    .command('community')
+    .description('Show community prior patterns')
+    .action(() => {
+    const cellDir = path.join(process.cwd(), index_1.DEFAULT_CONFIG.cellDir);
+    if (!fs.existsSync(cellDir)) {
+        console.log('❌ Cell not initialized.');
+        return;
+    }
+    const prior = new index_1.CommunityPrior(cellDir);
+    if (prior.getPatternCount() === 0) {
+        console.log('🌱 Generating synthetic community seed...');
+        prior.generateSyntheticSeed();
+    }
+    console.log(`\n🌍 ${prior.getDisplayLabel()}`);
+    console.log(`   Total patterns: ${prior.getPatternCount()}`);
+    console.log(`   Synthetic: ${prior.getSyntheticPatterns().length}`);
+    console.log(`   Live-learned: ${prior.getLivePatterns().length}`);
+    const patterns = prior.getPatterns(0.5);
+    if (patterns.length > 0) {
+        console.log('\nTop community patterns:');
+        for (const p of patterns.slice(0, 5)) {
+            const marker = prior.getSyntheticPatterns().some(sp => sp.patternId === p.patternId) ? '🧪' : '👥';
+            console.log(`   ${marker} ${p.description} (${p.confidence.mean})`);
+        }
+    }
+    console.log('');
+});
+program
+    .command('next')
+    .description('Predict next coding action')
+    .option('-a, --action <name>', 'Record an action for sequence learning')
+    .option('-f, --feedback <action>', 'Give feedback on a prediction (was it useful?)')
+    .action((options) => {
+    const predictor = new index_1.NextActionPredictor();
+    if (options.action) {
+        predictor.recordAction(options.action);
+        console.log(`✅ Recorded action: ${options.action}`);
+        const predictions = predictor.predictNext([]);
+        if (predictions.length > 0) {
+            console.log('\nPredicted next actions:');
+            for (const p of predictions) {
+                console.log(`   → ${p.description} (confidence: ${p.confidence})`);
+            }
+            const bulk = predictor.getBulkSuggestion(predictions);
+            if (bulk)
+                console.log(`   ⚡ ${bulk.description}`);
+        }
+        return;
+    }
+    if (options.feedback) {
+        predictor.recordFeedback(options.feedback, true);
+        console.log(`✅ Feedback recorded for: ${options.feedback}`);
+        return;
+    }
+    const predictions = predictor.predictNext([]);
+    console.log('Predicted next actions:');
+    for (const p of predictions) {
+        console.log(`   → ${p.description} (confidence: ${p.confidence})`);
+    }
+});
+program
+    .command('branch')
+    .description('Pre-generate files from git branch name')
+    .option('-b, --branch <name>', 'Branch name (e.g., feature/payment-gateway)')
+    .action((options) => {
+    if (!options.branch) {
+        console.log('❌ Provide --branch name');
+        return;
+    }
+    const generator = new index_1.GitBranchPreGenerator();
+    const summary = generator.getIntentSummary(options.branch);
+    console.log(`📋 ${summary}`);
+    const files = generator.generateFiles(options.branch, []);
+    for (const f of files) {
+        console.log(`\n--- ${f.path} ---`);
+        console.log(f.content);
+    }
+});
+program
+    .command('gentests')
+    .description('Generate test cases for a function')
+    .option('-c, --code <code>', 'Function code to analyze')
+    .action((options) => {
+    if (!options.code) {
+        console.log('❌ Provide --code with function signature');
+        return;
+    }
+    const anticipator = new index_1.TestAnticipator();
+    const tests = anticipator.generateTests(options.code);
+    console.log(`Generated ${tests.length} test cases:\n`);
+    for (const t of tests) {
+        console.log(`[${t.type}] ${t.name}`);
+        console.log(t.code);
+        console.log('');
+    }
+});
+program
+    .command('errors')
+    .description('Predict potential errors in code')
+    .option('-c, --code <code>', 'Code to analyze')
+    .action((options) => {
+    if (!options.code) {
+        console.log('❌ Provide --code to analyze');
+        return;
+    }
+    const predictor = new index_1.ErrorPredictor();
+    const predictions = predictor.predict(options.code);
+    if (predictions.length === 0) {
+        console.log('✅ No potential errors detected.');
+        return;
+    }
+    console.log(`Found ${predictions.length} potential errors:\n`);
+    for (const p of predictions) {
+        console.log(`[${p.severity}] Line ${p.line}: ${p.message}`);
+        console.log(`   Fix: ${predictor.getQuickFix(p)}`);
+        console.log('');
+    }
+});
+program
+    .command('buildcheck')
+    .description('Predict build failures (TS, ESLint, tests)')
+    .option('-c, --code <code>', 'Code to analyze')
+    .action((options) => {
+    if (!options.code) {
+        console.log('❌ Provide --code to analyze');
+        return;
+    }
+    const predictor = new index_1.BuildFailurePredictor();
+    const result = predictor.predictAll(options.code);
+    const all = [...result.tsErrors, ...result.eslintViolations, ...result.testFailures];
+    if (all.length === 0) {
+        console.log('✅ No build failures predicted.');
+        return;
+    }
+    console.log(`Predicted ${all.length} build failures:\n`);
+    for (const p of all) {
+        const auto = p.autoFixable ? ' [AUTO-FIXABLE]' : '';
+        console.log(`[${p.type}] Line ${p.line}: ${p.message}${auto}`);
+        if (p.fix)
+            console.log(`   Fix: ${p.fix}`);
+        console.log('');
+    }
+    const stats = predictor.getStats(all);
+    console.log(`Summary: ${stats.total} total, ${stats.autoFixable} auto-fixable`);
+});
+program
+    .command('mergecheck')
+    .description('Predict merge conflicts between branches')
+    .option('-a, --diff-a <diff>', 'Diff from branch A')
+    .option('-b, --diff-b <diff>', 'Diff from branch B')
+    .action((options) => {
+    if (!options.diffA || !options.diffB) {
+        console.log('❌ Provide --diff-a and --diff-b');
+        return;
+    }
+    const predictor = new index_1.MergeConflictPredictor();
+    const conflicts = predictor.predictConflicts(options.diffA, options.diffB);
+    if (conflicts.length === 0) {
+        console.log('✅ No merge conflicts predicted.');
+        return;
+    }
+    console.log(`Predicted ${conflicts.length} merge conflicts:\n`);
+    for (const c of conflicts) {
+        console.log(`[${c.type}] ${c.file}:${c.line} (confidence: ${c.confidence})`);
+        console.log(`   ${c.suggestion}`);
+        console.log('');
+    }
+});
+program
+    .command('scan')
+    .description('Scan code for security vulnerabilities')
+    .option('-c, --code <code>', 'Code to scan')
+    .action((options) => {
+    if (!options.code) {
+        console.log('❌ Provide --code to scan');
+        return;
+    }
+    const predictor = new index_1.SecurityPredictor();
+    const predictions = predictor.predict(options.code);
+    if (predictions.length === 0) {
+        console.log('✅ No security vulnerabilities detected.');
+        return;
+    }
+    console.log(`Found ${predictions.length} security issues:\n`);
+    for (const p of predictions) {
+        console.log(`[${p.severity}] ${p.type}: Line ${p.line}`);
+        console.log(`   ${p.message}`);
+        console.log(`   Fix: ${p.sanitizedVersion}`);
+        console.log('');
+    }
+});
+program
+    .command('perf')
+    .description('Analyze code for performance issues')
+    .option('-c, --code <code>', 'Code to analyze')
+    .action((options) => {
+    if (!options.code) {
+        console.log('❌ Provide --code to analyze');
+        return;
+    }
+    const predictor = new index_1.PerformancePredictor();
+    const predictions = predictor.predict(options.code);
+    if (predictions.length === 0) {
+        console.log('✅ No performance issues detected.');
+        return;
+    }
+    console.log(`Found ${predictions.length} performance issues:\n`);
+    for (const p of predictions) {
+        console.log(`[${p.severity}] ${p.type}: Line ${p.line}`);
+        console.log(`   ${p.message}`);
+        console.log(`   Fix: ${p.suggestion}`);
+        console.log('');
+    }
+});
+program
+    .command('snapshot')
+    .description('Capture or restore project context')
+    .option('-p, --project <id>', 'Project ID')
+    .option('-r, --restore', 'Restore last snapshot')
+    .action((options) => {
+    const cellDir = path.join(process.cwd(), index_1.DEFAULT_CONFIG.cellDir);
+    const restore = new index_1.ContextRestore(cellDir);
+    if (options.restore && options.project) {
+        const snapshot = restore.restore(options.project);
+        if (!snapshot) {
+            console.log('❌ No snapshot found.');
+            return;
+        }
+        console.log(restore.getResumePrompt(snapshot));
+        return;
+    }
+    if (options.project) {
+        restore.capture(options.project, [], '', 0, [], '', 'main');
+        console.log(`✅ Snapshot captured for ${options.project}`);
+        return;
+    }
+    const snapshots = restore.getAllSnapshots();
+    console.log(`${snapshots.length} snapshots available:`);
+    for (const s of snapshots) {
+        console.log(`   ${s.projectId} (${s.timestamp})`);
+    }
+});
+program
+    .command('sync')
+    .description('Sync patterns across projects')
+    .option('-s, --source <id>', 'Source project ID')
+    .option('-t, --target <id>', 'Target project ID')
+    .action((options) => {
+    const cellDir = path.join(process.cwd(), index_1.DEFAULT_CONFIG.cellDir);
+    const store = new index_1.PatternStore(cellDir);
+    const sync = new index_1.CrossProjectSync(store, cellDir);
+    if (options.source && options.target) {
+        const adapted = sync.generateAdaptedPatterns(options.source, options.target);
+        console.log(`${adapted.length} patterns compatible with ${options.target}:`);
+        for (const a of adapted) {
+            console.log(`   ${a.original.description} (compatibility: ${a.compatibilityScore})`);
+        }
+        return;
+    }
+    const stats = sync.getSyncStats();
+    console.log(`Cross-project sync: ${stats.projects} projects, ${stats.totalPatterns} patterns`);
+});
+program
+    .command('solutions')
+    .description('Search solution index')
+    .option('-q, --query <text>', 'Search query')
+    .option('-a, --add <title>', 'Add a solution')
+    .option('-d, --desc <text>', 'Solution description')
+    .option('-p, --project <id>', 'Project ID')
+    .option('--stats', 'Show solution index stats')
+    .action((options) => {
+    const cellDir = path.join(process.cwd(), index_1.DEFAULT_CONFIG.cellDir);
+    const index = new index_1.SolutionIndex(cellDir);
+    if (options.stats) {
+        const stats = index.getStats();
+        console.log(`Solution index: ${stats.projects} projects, ${stats.totalSolutions} solutions`);
+        console.log(`Top tags: ${stats.topTags.join(', ')}`);
+        if (index.isColdStart())
+            console.log(index.getColdStartMessage());
+        return;
+    }
+    if (options.add && options.desc && options.project) {
+        const sol = index.addSolution(options.add, options.desc, [], options.project, [], '');
+        console.log(`✅ Solution added: ${sol.id}`);
+        return;
+    }
+    if (options.query) {
+        const results = index.search(options.query);
+        console.log(`Found ${results.length} solutions for "${options.query}":`);
+        for (const s of results) {
+            console.log(`   📋 ${s.title} (${s.projectId})`);
+            console.log(`      ${s.description}`);
+        }
+        return;
+    }
+    console.log('Usage: cell solutions --query "auth middleware"');
+    console.log('       cell solutions --add "Title" --desc "Description" --project "my-project"');
+    console.log('       cell solutions --stats');
+});
+program
+    .command('langswitch')
+    .description('Get language switch guide')
+    .option('-f, --from <lang>', 'Source language')
+    .option('-t, --to <lang>', 'Target language')
+    .action((options) => {
+    const assistant = new index_1.LanguageSwitchAssistant();
+    if (options.from && options.to) {
+        const guide = assistant.getGuide(options.from, options.to);
+        if (!guide) {
+            console.log(`❌ No guide for ${options.from}→${options.to}`);
+            console.log(`Available: ${assistant.getAvailableTransitions().join(', ')}`);
+            return;
+        }
+        console.log(`\n📖 ${guide.from} → ${guide.to} Guide\n`);
+        console.log('⚠️  Gotchas:');
+        for (const g of guide.gotchas)
+            console.log(`   • ${g}`);
+        console.log('\n💡 Style Tips:');
+        for (const t of guide.styleTips)
+            console.log(`   • ${t}`);
+        return;
+    }
+    console.log('Available transitions:');
+    for (const t of assistant.getAvailableTransitions()) {
+        console.log(`   ${t}`);
+    }
+});
+program
+    .command('resume')
+    .description('Check for interruption and resume')
+    .action(() => {
+    const cellDir = path.join(process.cwd(), index_1.DEFAULT_CONFIG.cellDir);
+    const recovery = new index_1.InterruptionRecovery(cellDir);
+    const interruption = recovery.detectInterruption();
+    if (interruption) {
+        console.log(recovery.getContinuePrompt(interruption));
+        console.log(recovery.getSummaryPrompt(interruption));
+        console.log(recovery.getRestartPrompt());
+    }
+    else {
+        console.log('✅ No interruption detected. Ready to work.');
+    }
+});
+program
+    .command('handoff')
+    .description('Generate teammate handoff summary')
+    .option('-t, --teammate <name>', 'Teammate name')
+    .option('-b, --branch <name>', 'Branch name')
+    .action((options) => {
+    const cellDir = path.join(process.cwd(), index_1.DEFAULT_CONFIG.cellDir);
+    const detector = new index_1.HandoffDetector(cellDir);
+    if (options.teammate && options.branch) {
+        const isAbsent = detector.detectAbsence(options.teammate, options.branch);
+        if (isAbsent) {
+            const summary = detector.generateReturnSummary(options.teammate, options.branch, [], [], [], new Date().toISOString());
+            console.log(detector.getReturnPrompt(summary));
+        }
+        else {
+            console.log(`✅ ${options.teammate} is active on ${options.branch}.`);
+        }
+        return;
+    }
+    console.log('Usage: cell handoff --teammate "alice" --branch "feature/auth"');
+});
+program
+    .command('silos')
+    .description('Detect knowledge silos')
+    .option('-m, --modules <json>', 'Module→contributors mapping as JSON')
+    .action((options) => {
+    const cellDir = path.join(process.cwd(), index_1.DEFAULT_CONFIG.cellDir);
+    const detector = new index_1.KnowledgeSiloDetector(cellDir);
+    if (options.modules) {
+        const mapping = JSON.parse(options.modules);
+        const reports = detector.analyzeProject(mapping);
+        const risks = detector.getTopRisks(reports);
+        console.log(`${reports.length} modules analyzed. ${risks.length} at risk:\n`);
+        for (const r of risks) {
+            console.log(`🔴 ${r.module} (risk: ${r.riskScore}, bus factor: ${r.busFactor})`);
+            console.log(`   ${r.recommendation}`);
+        }
+        return;
+    }
+    const saved = detector.loadReport();
+    if (saved.length === 0) {
+        console.log('No silo reports. Run: cell silos --modules \'{"auth":["alice"],"api":["bob","carol"]}\'');
+        return;
+    }
+    console.log(`${saved.length} modules in saved report.`);
+});
+program
+    .command('review')
+    .description('Generate PR review summary')
+    .option('-t, --title <text>', 'PR title')
+    .option('-d, --diff <text>', 'PR diff content')
+    .action((options) => {
+    const cellDir = path.join(process.cwd(), index_1.DEFAULT_CONFIG.cellDir);
+    const store = new index_1.PatternStore(cellDir);
+    const assistant = new index_1.PRReviewAssistant();
+    if (options.title && options.diff) {
+        const patterns = store.getAllPatterns();
+        const summary = assistant.generateSummary(options.title, options.diff, patterns);
+        console.log(`\n📋 PR Review: ${summary.title}`);
+        console.log(`   Files: ${summary.filesChanged} | +${summary.linesAdded} -${summary.linesRemoved}`);
+        if (summary.potentialBugs.length > 0) {
+            console.log(`\n🐛 Potential Bugs (${summary.potentialBugs.length}):`);
+            for (const b of summary.potentialBugs)
+                console.log(`   • ${b}`);
+        }
+        if (summary.patternDeviations.length > 0) {
+            console.log(`\n⚠️  Pattern Deviations (${summary.patternDeviations.length}):`);
+            for (const d of summary.patternDeviations)
+                console.log(`   • ${d}`);
+        }
+        if (summary.potentialBugs.length === 0 && summary.patternDeviations.length === 0) {
+            console.log('\n✅ No issues detected.');
+        }
+        return;
+    }
+    console.log('Usage: cell review --title "Add auth" --diff "<git diff>"');
+});
+program
+    .command('standup')
+    .description('Generate daily standup')
+    .option('-c, --completed <items>', 'Completed items (comma-separated)')
+    .option('-p, --progress <items>', 'In-progress items (comma-separated)')
+    .option('-b, --blocked <items>', 'Blocked items (comma-separated)')
+    .option('-n, --plan <items>', 'Planned items (comma-separated)')
+    .action((options) => {
+    const generator = new index_1.StandupGenerator();
+    if (options.completed || options.progress || options.plan) {
+        const completed = options.completed ? options.completed.split(',') : [];
+        const inProgress = options.progress ? options.progress.split(',') : [];
+        const blocked = options.blocked ? options.blocked.split(',') : [];
+        const plan = options.plan ? options.plan.split(',') : [];
+        const entry = generator.generateDaily(completed, inProgress, blocked, plan);
+        console.log(generator.formatStandup(entry));
+        return;
+    }
+    const summary = generator.getWeeklySummary();
+    console.log(summary);
+});
+program
+    .command('offline')
+    .description('Check offline queue status')
+    .option('--heartbeat', 'Send engine heartbeat')
+    .action((options) => {
+    const cellDir = path.join(process.cwd(), index_1.DEFAULT_CONFIG.cellDir);
+    const queue = new index_1.OfflineQueue(cellDir);
+    if (options.heartbeat) {
+        queue.heartbeat();
+        console.log('✅ Heartbeat sent. Engine is ONLINE.');
+        return;
+    }
+    const status = queue.checkEngineHealth();
+    console.log(`Engine: ${status.state}`);
+    console.log(`Queue size: ${queue.getQueueSize()}`);
+    console.log(queue.getDegradedMessage(status));
+});
+program
+    .command('deadcode')
+    .description('Detect dead code in a file')
+    .option('-c, --code <code>', 'Code to analyze')
+    .option('-f, --file <name>', 'File name')
+    .action((options) => {
+    if (!options.code || !options.file) {
+        console.log('❌ Provide --code and --file');
+        return;
+    }
+    const detector = new index_1.DeadCodeDetector();
+    const reports = detector.detectAll(options.code, options.file);
+    if (reports.length === 0) {
+        console.log('✅ No dead code detected.');
+        return;
+    }
+    console.log(`Found ${reports.length} dead code items:\n`);
+    for (const r of reports) {
+        console.log(`[${r.type}] ${r.file}:${r.line} — ${r.name}`);
+        console.log(`   ${r.suggestion}`);
+    }
+});
+program
+    .command('cycles')
+    .description('Detect circular dependencies')
+    .option('-i, --imports <json>', 'Import edges as JSON array of {from,to}')
+    .action((options) => {
+    if (!options.imports) {
+        console.log('❌ Provide --imports as JSON');
+        return;
+    }
+    const detector = new index_1.CircularDependencyDetector();
+    const edges = JSON.parse(options.imports);
+    const graph = detector.buildGraph(edges);
+    const cycles = detector.detectCycles(graph);
+    if (cycles.length === 0) {
+        console.log('✅ No circular dependencies detected.');
+        return;
+    }
+    console.log(`Found ${cycles.length} circular dependencies:\n`);
+    for (const c of cycles) {
+        console.log(`🔴 Cycle (${c.length} nodes): ${c.cycle.join(' → ')}`);
+        console.log(`   Break at: ${c.breakPoint}`);
+    }
+    const stats = detector.getStats(cycles);
+    console.log(`\nStats: ${stats.totalCycles} cycles, max length ${stats.maxLength}, avg ${stats.avgLength}`);
+});
+program
+    .command('dupes')
+    .description('Detect code duplication')
+    .option('-f, --files <json>', 'Files as JSON {filepath: code}')
+    .action((options) => {
+    if (!options.files) {
+        console.log('❌ Provide --files as JSON');
+        return;
+    }
+    const detector = new index_1.DuplicationDetector();
+    const files = JSON.parse(options.files);
+    const groups = detector.detectClones(files);
+    if (groups.length === 0) {
+        console.log('✅ No code duplication detected.');
+        return;
+    }
+    console.log(`Found ${groups.length} duplication groups:\n`);
+    for (const g of groups.slice(0, 5)) {
+        console.log(`📋 Group ${g.id} (${(g.similarity * 100).toFixed(0)}% similar)`);
+        console.log(`   Files: ${g.files.join(', ')}`);
+        console.log(`   ${detector.getExtractHelperAction(g)}`);
+    }
+    const stats = detector.getStats(groups);
+    console.log(`\nStats: ${stats.totalGroups} groups across ${stats.totalFiles} files, avg similarity ${stats.avgSimilarity}`);
+});
+program
+    .command('complexity')
+    .description('Analyze code complexity')
+    .option('-c, --code <code>', 'Code to analyze')
+    .option('-f, --file <name>', 'File name')
+    .action((options) => {
+    if (!options.code || !options.file) {
+        console.log('❌ Provide --code and --file');
+        return;
+    }
+    const analyzer = new index_1.ComplexityAnalyzer();
+    const reports = analyzer.analyze(options.code, options.file);
+    if (reports.length === 0) {
+        console.log('✅ No functions found.');
+        return;
+    }
+    const hotspots = analyzer.getHotspots(reports);
+    console.log(`${reports.length} functions analyzed. ${hotspots.length} hotspots:\n`);
+    for (const r of hotspots) {
+        const icon = r.level === 'high' ? '🔴' : '🟡';
+        console.log(`${icon} ${r.function} (complexity: ${r.complexity}, ${r.level})`);
+        console.log(`   ${r.file}:${r.line}`);
+        console.log(`   ${r.suggestion}`);
+        console.log('');
+    }
+    const stats = analyzer.getStats(reports);
+    console.log(`Stats: ${stats.total} functions, ${stats.high} high, ${stats.medium} medium, ${stats.low} low, avg ${stats.avgComplexity}`);
+});
+program
+    .command('deps')
+    .description('Check dependency health')
+    .option('-d, --deps <json>', 'Dependencies as JSON {name: version}')
+    .option('-l, --latest <json>', 'Latest versions as JSON {name: version}')
+    .action((options) => {
+    if (!options.deps || !options.latest) {
+        console.log('❌ Provide --deps and --latest as JSON');
+        return;
+    }
+    const checker = new index_1.DependencyHealthChecker();
+    const deps = JSON.parse(options.deps);
+    const latest = JSON.parse(options.latest);
+    const reports = checker.check(deps, latest);
+    console.log(`${reports.length} dependencies checked:\n`);
+    for (const r of reports) {
+        const icons = { up_to_date: '✅', minor_behind: '🟡', major_behind: '🟠', deprecated: '🔴' };
+        console.log(`${icons[r.status]} ${r.name}: ${r.current} → ${r.latest} ${r.breakingChanges ? '(BREAKING)' : ''}`);
+    }
+    console.log(`\n${checker.getFullUpdatePlan(reports)}`);
+    const stats = checker.getStats(reports);
+    console.log(`Stats: ${stats.total} total, ${stats.outdated} outdated, ${stats.deprecated} deprecated, ${stats.upToDate} up-to-date`);
+});
+program
+    .command('abtest')
+    .description('Run A/B test')
+    .option('-n, --name <name>', 'Test name')
+    .option('-c, --control <n>', 'Control group size', '10')
+    .option('-e, --experiment <n>', 'Experiment group size', '10')
+    .option('-t, --test-id <id>', 'Test ID for recording predictions')
+    .option('-p, --prediction <id>', 'Prediction ID')
+    .option('-g, --group <group>', 'Group: control or experiment')
+    .option('-w, --was-correct', 'Was the prediction correct?')
+    .option('--significance', 'Check statistical significance')
+    .action((options) => {
+    const framework = new index_1.ABTestFramework();
+    if (options.name) {
+        const test = framework.createTest(options.name, parseInt(options.control), parseInt(options.experiment));
+        console.log(`✅ A/B test created: ${test.id}`);
+        console.log(`   Control: ${test.controlGroup.length}, Experiment: ${test.experimentGroup.length}`);
+        return;
+    }
+    if (options.testId && options.prediction && options.group) {
+        framework.recordPrediction(options.testId, options.prediction, options.wasCorrect || false, options.group);
+        const stats = framework.getStats(options.testId);
+        console.log(`📊 Test ${options.testId}:`);
+        console.log(`   Control accuracy: ${stats.controlAccuracy}`);
+        console.log(`   Experiment accuracy: ${stats.experimentAccuracy}`);
+        console.log(`   Total predictions: ${stats.totalPredictions}`);
+        return;
+    }
+    if (options.significance && options.testId) {
+        const result = framework.computeSignificance(options.testId);
+        console.log(`📊 Significance test for ${options.testId}:`);
+        console.log(`   p-value: ${result.pValue}`);
+        console.log(`   Significant: ${result.isSignificant ? 'YES' : 'NO'}`);
+        console.log(`   Winner: ${result.winner}`);
+        return;
+    }
+    const tests = framework.getAllTests();
+    console.log(`${tests.length} A/B tests:`);
+    for (const t of tests) {
+        console.log(`   ${t.id}: ${t.name} (${t.predictions.length} predictions)`);
+    }
+});
+program
+    .command('community-live')
+    .description('Show live community prior stats')
+    .option('--ingest <json>', 'Ingest signals JSON')
+    .option('--decay', 'Apply faster decay to synthetic patterns')
+    .option('--opt-out <user>', 'Opt out of community contribution')
+    .option('--opt-in <user>', 'Opt back into community contribution')
+    .action((options) => {
+    const cellDir = path.join(process.cwd(), index_1.DEFAULT_CONFIG.cellDir);
+    const live = new index_1.CommunityLive(cellDir);
+    if (options.ingest) {
+        const signals = JSON.parse(options.ingest);
+        const stats = live.ingestSignals(signals);
+        console.log(`📥 Ingested: ${stats.totalIngested} total, ${stats.syntheticReplaced} synthetic→live`);
+        console.log(`   Remaining synthetic: ${stats.remainingSynthetic}`);
+        console.log(`   Weekly rate: ${stats.weeklyRate}`);
+        return;
+    }
+    if (options.decay) {
+        live.applyFasterDecay();
+        console.log('✅ Faster decay applied to synthetic patterns.');
+        return;
+    }
+    if (options.optOut) {
+        live.optOut(options.optOut);
+        console.log(`✅ ${options.optOut} opted out of community contribution.`);
+        return;
+    }
+    if (options.optIn) {
+        live.optIn(options.optIn);
+        console.log(`✅ ${options.optIn} opted back into community contribution.`);
+        return;
+    }
+    const stats = live.getStats();
+    console.log(`\n🌍 ${live.getDisplayLabel()}`);
+    console.log(`   Total ingested: ${stats.totalIngested}`);
+    console.log(`   Synthetic replaced: ${stats.syntheticReplaced}`);
+    console.log(`   Remaining synthetic: ${stats.remainingSynthetic}`);
+    console.log(`   Weekly rate: ${stats.weeklyRate}`);
+});
+program
+    .command('community-full')
+    .description('Show full community prior dashboard')
+    .option('--translate <json>', 'Translate pattern across languages {pattern, from, to}')
+    .action((options) => {
+    const cellDir = path.join(process.cwd(), index_1.DEFAULT_CONFIG.cellDir);
+    const full = new index_1.CommunityFull(cellDir);
+    if (options.translate) {
+        const { pattern, from, to } = JSON.parse(options.translate);
+        const translated = full.translatePattern(pattern, from, to);
+        if (translated) {
+            console.log(`✅ Translated: ${translated.description} (confidence: ${translated.confidence.mean})`);
+        }
+        else {
+            console.log('❌ No cross-language mapping available.');
+        }
+        return;
+    }
+    const dashboard = full.getPowerDashboard();
+    console.log(`\n📊 Community Prior Power Dashboard`);
+    console.log(`──────────────────────────────────`);
+    console.log(`   Total patterns: ${dashboard.totalPatterns}`);
+    console.log(`   Live patterns: ${dashboard.livePatterns}`);
+    console.log(`   Synthetic patterns: ${dashboard.syntheticPatterns}`);
+    console.log(`   Avg confidence: ${dashboard.avgConfidence}`);
+    console.log(`   Calibration: ${dashboard.calibrationPhase}`);
+    console.log(`   Cross-language maps: ${dashboard.crossLanguageMappings}`);
+    console.log(`\n${full.getDisplayLabel()}`);
+    const stats = full.getStats();
+    console.log(`\n   All-real guarantee: ${stats.isAllReal ? '✅ YES' : '❌ NO'}`);
+});
+program
+    .command('enterprise')
+    .description('Enterprise features')
+    .option('--obfuscate <name>', 'Obfuscate project name')
+    .option('--paginate <json>', 'Paginate items {items, page, pageSize}')
+    .option('--s3-config <json>', 'Get S3 config {bucket, region}')
+    .option('--self-hosted <url>', 'Get self-hosted config')
+    .action((options) => {
+    const enterprise = new index_1.EnterpriseFeatures();
+    if (options.obfuscate) {
+        console.log(`Hash: ${enterprise.obfuscateProjectName(options.obfuscate)}`);
+        return;
+    }
+    if (options.paginate) {
+        const { items, page, pageSize } = JSON.parse(options.paginate);
+        const result = enterprise.paginate(items, page, pageSize);
+        console.log(`Page ${result.page}/${result.totalPages} (${result.total} total items):`);
+        for (const item of result.items) {
+            console.log(`   ${JSON.stringify(item)}`);
+        }
+        return;
+    }
+    if (options.s3Config) {
+        const { bucket, region } = JSON.parse(options.s3Config);
+        console.log(JSON.stringify(enterprise.getS3Config(bucket, region), null, 2));
+        return;
+    }
+    if (options.selfHosted) {
+        console.log(JSON.stringify(enterprise.getSelfHostedConfig(options.selfHosted), null, 2));
+        return;
+    }
+    console.log('Enterprise features: obfuscate, paginate, s3-config, self-hosted');
+});
+program
+    .command('xdomain')
+    .description('Cross-domain projections (RESEARCH)')
+    .option('-f, --from <domain>', 'Source domain')
+    .option('-t, --to <domain>', 'Target domain')
+    .option('--gate', 'Check research gate status')
+    .action((options) => {
+    const { CrossDomainProjections } = require('./core/cross-domain-projections');
+    const projections = new CrossDomainProjections();
+    if (options.gate) {
+        console.log(projections.getResearchGateStatus());
+        return;
+    }
+    if (options.from && options.to) {
+        const proj = projections.getProjection(options.from, options.to);
+        if (!proj) {
+            console.log('❌ No projection available.');
+            return;
+        }
+        console.log(`\n🔬 ${proj.sourceDomain} → ${proj.targetDomain}`);
+        console.log(`   Transfer accuracy: ${proj.transferAccuracy}`);
+        console.log(`   Confidence: ${proj.confidence}`);
+        console.log(`   Passes 70% gate: ${projections.validateTransferAccuracy(proj) ? '✅' : '❌'}`);
+        console.log('\n   Concept mappings:');
+        for (const [from, to] of Object.entries(proj.mappedConcepts)) {
+            console.log(`   ${from} → ${to}`);
+        }
+        return;
+    }
+    console.log('Cross-domain projections:');
+    for (const p of projections.getAllProjections()) {
+        console.log(`   ${p.sourceDomain} → ${p.targetDomain} (${p.transferAccuracy})`);
+    }
+    console.log(`\n${projections.getResearchGateStatus()}`);
+});
+// ─── DAEMON COMMANDS ──────────────────────────────────
+const daemonCmd = program.command('daemon').description('Manage Cell Daemon (background service)');
+daemonCmd
+    .command('start')
+    .description('Start the Cell Daemon in background')
+    .action(async () => {
+    console.log('Starting Cell Daemon...');
+    try {
+        const { startDaemon } = await Promise.resolve().then(() => __importStar(require('./daemon/lifecycle')));
+        const result = await startDaemon();
+        console.log(`✅ Daemon started (PID: ${result.pid}, Port: ${result.port})`);
+        console.log(`   Health: http://localhost:${result.port}/health`);
+    }
+    catch (err) {
+        console.error(`❌ Failed to start daemon: ${err.message}`);
+    }
+});
+daemonCmd
+    .command('stop')
+    .description('Stop the Cell Daemon')
+    .action(async () => {
+    const { stopDaemon } = await Promise.resolve().then(() => __importStar(require('./daemon/lifecycle')));
+    const result = stopDaemon();
+    console.log(result.success ? `✅ ${result.message}` : `⚠️ ${result.message}`);
+});
+daemonCmd
+    .command('restart')
+    .description('Restart the Cell Daemon')
+    .action(async () => {
+    console.log('Restarting Cell Daemon...');
+    try {
+        const { restartDaemon } = await Promise.resolve().then(() => __importStar(require('./daemon/lifecycle')));
+        const result = await restartDaemon();
+        console.log(`✅ Daemon restarted (PID: ${result.pid}, Port: ${result.port})`);
+    }
+    catch (err) {
+        console.error(`❌ Failed to restart daemon: ${err.message}`);
+    }
+});
+daemonCmd
+    .command('status')
+    .description('Show daemon status')
+    .action(async () => {
+    const { statusDaemon } = await Promise.resolve().then(() => __importStar(require('./daemon/lifecycle')));
+    const status = await statusDaemon();
+    if (status.running && status.health) {
+        const h = status.health;
+        console.log('✅ Daemon is running');
+        console.log(`   PID: ${status.pid} | Port: ${status.port}`);
+        console.log(`   Uptime: ${Math.round(h.uptime)}s | Patterns: ${h.patterns} | Signals: ${h.signals}`);
+        console.log(`   Modules: ${h.modulesLoaded || 'N/A'} | Memory: ${Math.round(h.memory / 1024 / 1024)}MB`);
+    }
+    else {
+        console.log('❌ Daemon is not running');
+        if (status.pid)
+            console.log(`   Stale PID found: ${status.pid}`);
+    }
+});
+program
+    .command('cloud')
+    .description('Manage cloud sync')
+    .addCommand(new commander_1.Command('on')
+    .description('Enable cloud sync (anonymous pattern stats only)')
+    .action(() => {
+    const cellDir = path.join(os.homedir(), '.fivo', 'cell');
+    if (!fs.existsSync(cellDir))
+        fs.mkdirSync(cellDir, { recursive: true });
+    const configPath = path.join(cellDir, 'cell-meta.json');
+    let meta = {};
+    if (fs.existsSync(configPath))
+        meta = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    meta.cloudSyncEnabled = true;
+    fs.writeFileSync(configPath, JSON.stringify(meta, null, 2), 'utf-8');
+    console.log('🌐 Cloud sync: ON');
+    console.log('   Anonymous pattern stats shared. Code NEVER leaves your machine.');
+    console.log('   Turn off: cell cloud off');
+}))
+    .addCommand(new commander_1.Command('off')
+    .description('Disable cloud sync (fully offline)')
+    .action(() => {
+    const cellDir = path.join(os.homedir(), '.fivo', 'cell');
+    if (!fs.existsSync(cellDir))
+        fs.mkdirSync(cellDir, { recursive: true });
+    const configPath = path.join(cellDir, 'cell-meta.json');
+    let meta = {};
+    if (fs.existsSync(configPath))
+        meta = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    meta.cloudSyncEnabled = false;
+    fs.writeFileSync(configPath, JSON.stringify(meta, null, 2), 'utf-8');
+    console.log('🔒 Cloud sync: OFF');
+    console.log('   Fully offline. Nothing leaves your machine.');
+    console.log('   Turn on: cell cloud on');
+}));
+program.parse(process.argv);
+//# sourceMappingURL=cli.js.map