ruvnet-kb-first 6.2.0 → 6.4.0

package/src/commands/dashboard.js

@@ -0,0 +1,359 @@
+/**
+ * RuvNet-KB-First Dashboard
+ *
+ * Shows comprehensive status when running `ruvnet-kb-first` with no arguments.
+ * Displays KB metrics, application scores, and actionable recommendations.
+ */
+
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { globSync } from 'glob';
+
+export async function dashboardCommand() {
+  const cwd = process.cwd();
+  const projectName = cwd.split('/').pop();
+
+  // Banner
+  console.log('');
+  console.log(chalk.cyan('╔════════════════════════════════════════════════════════════════════════╗'));
+  console.log(chalk.cyan('║') + chalk.bold.white('                      RuvNet-KB-First Dashboard                        ') + chalk.cyan('║'));
+  console.log(chalk.cyan('║') + chalk.gray('                Build intelligent applications on expert knowledge        ') + chalk.cyan('║'));
+  console.log(chalk.cyan('╚════════════════════════════════════════════════════════════════════════╝'));
+  console.log('');
+
+  // Check if initialized
+  const configPath = join(cwd, '.ruvector', 'config.json');
+  if (!existsSync(configPath)) {
+    console.log(chalk.yellow('  ⚠ Not initialized in this directory'));
+    console.log('');
+    console.log(chalk.white('  Quick Start:'));
+    console.log(chalk.cyan('    ruvnet-kb-first init --kb ask_ruvnet'));
+    console.log('');
+    console.log(chalk.gray('  This will:'));
+    console.log(chalk.gray('    • Connect to the RuvNet Knowledge Base (230K+ entries)'));
+    console.log(chalk.gray('    • Set up hooks to enforce KB-first development'));
+    console.log(chalk.gray('    • Enable comprehensive scoring for your application'));
+    console.log('');
+    return;
+  }
+
+  const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // SECTION 1: KNOWLEDGE BASE STATUS
+  // ═══════════════════════════════════════════════════════════════════════════
+  console.log(chalk.white.bold('  📚 KNOWLEDGE BASE'));
+  console.log(chalk.gray('  ────────────────────────────────────────────────────────────────────'));
+
+  if (config.knowledgeBase?.connected) {
+    let kbStats = {
+      entries: config.knowledgeBase.entries,
+      isLive: false,
+      categories: 0,
+      avgEmbeddingSize: 0
+    };
+
+    // Try to get live stats
+    try {
+      const pg = await import('pg');
+      const client = new pg.default.Client({
+        host: config.knowledgeBase.host,
+        port: config.knowledgeBase.port,
+        database: 'postgres',
+        user: 'postgres',
+        password: 'guruKB2025'
+      });
+      await client.connect();
+
+      // Entry count
+      const countResult = await client.query(
+        `SELECT COUNT(*) as count FROM ${config.knowledgeBase.schema}.architecture_docs`
+      );
+      kbStats.entries = parseInt(countResult.rows[0].count);
+      kbStats.isLive = true;
+
+      // Get category count (if source column exists)
+      try {
+        const catResult = await client.query(
+          `SELECT COUNT(DISTINCT source) as cats FROM ${config.knowledgeBase.schema}.architecture_docs`
+        );
+        kbStats.categories = parseInt(catResult.rows[0].cats);
+      } catch (e) {
+        // Ignore if source column doesn't exist
+      }
+
+      await client.end();
+    } catch (e) {
+      // Use cached values
+    }
+
+    const statusIcon = kbStats.isLive ? chalk.green('●') : chalk.yellow('○');
+    const statusText = kbStats.isLive ? chalk.green('CONNECTED') : chalk.yellow('CACHED');
+
+    console.log(`  ${statusIcon} Status:    ${statusText}`);
+    console.log(`    Schema:    ${chalk.cyan(config.knowledgeBase.schema)}`);
+    console.log(`    Entries:   ${chalk.cyan(kbStats.entries.toLocaleString())}`);
+    if (kbStats.categories > 0) {
+      console.log(`    Sources:   ${chalk.cyan(kbStats.categories)}`);
+    }
+    console.log(`    Host:      ${chalk.gray(config.knowledgeBase.host + ':' + config.knowledgeBase.port)}`);
+
+    // KB Score (out of 100)
+    const kbScore = calculateKBScore(kbStats);
+    console.log('');
+    console.log(`    ${chalk.white('KB Health Score:')} ${renderScoreBar(kbScore)} ${colorScore(kbScore)}/100`);
+
+  } else {
+    console.log(chalk.red('  ○ Status:    NOT CONNECTED'));
+    console.log('');
+    console.log(chalk.yellow('    Run: ruvnet-kb-first init --kb ask_ruvnet'));
+  }
+
+  console.log('');
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // SECTION 2: APPLICATION SCORES
+  // ═══════════════════════════════════════════════════════════════════════════
+  console.log(chalk.white.bold('  📊 APPLICATION SCORES'));
+  console.log(chalk.gray('  ────────────────────────────────────────────────────────────────────'));
+
+  const scores = await calculateAllScores(cwd, config);
+
+  // Display each score category
+  for (const [category, data] of Object.entries(scores)) {
+    const label = formatLabel(category).padEnd(18);
+    const bar = renderScoreBar(data.percentage);
+    const scoreText = colorScore(data.percentage);
+    console.log(`    ${label} ${bar} ${scoreText.padStart(4)}/100  ${chalk.gray(data.summary)}`);
+  }
+
+  // Total Score
+  const totalScore = Math.round(
+    Object.values(scores).reduce((sum, s) => sum + s.percentage, 0) / Object.keys(scores).length
+  );
+
+  console.log('');
+  console.log(chalk.gray('  ────────────────────────────────────────────────────────────────────'));
+  const totalBar = renderScoreBar(totalScore);
+  console.log(`    ${chalk.bold('OVERALL SCORE')}     ${totalBar} ${colorScore(totalScore).padStart(4)}/100  ${getGrade(totalScore)}`);
+  console.log('');
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // SECTION 3: PROJECT INFO
+  // ═══════════════════════════════════════════════════════════════════════════
+  console.log(chalk.white.bold('  📁 PROJECT'));
+  console.log(chalk.gray('  ────────────────────────────────────────────────────────────────────'));
+  console.log(`    Name:      ${chalk.cyan(projectName)}`);
+  console.log(`    Namespace: ${chalk.cyan(config.kbFirst?.namespace || 'not set')}`);
+  console.log(`    Phase:     ${chalk.cyan(config.phases?.current || 0)}/11`);
+  console.log(`    Hooks:     ${config.hooks?.enabled ? chalk.green('Enabled') : chalk.red('Disabled')}`);
+  console.log('');
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // SECTION 4: RECOMMENDATIONS
+  // ═══════════════════════════════════════════════════════════════════════════
+  const recommendations = getRecommendations(scores, config);
+
+  if (recommendations.length > 0) {
+    console.log(chalk.white.bold('  💡 RECOMMENDATIONS'));
+    console.log(chalk.gray('  ────────────────────────────────────────────────────────────────────'));
+    for (const rec of recommendations.slice(0, 5)) {
+      console.log(chalk.yellow(`    → ${rec}`));
+    }
+    console.log('');
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // SECTION 5: COMMANDS
+  // ═══════════════════════════════════════════════════════════════════════════
+  console.log(chalk.white.bold('  ⌨️  COMMANDS'));
+  console.log(chalk.gray('  ────────────────────────────────────────────────────────────────────'));
+  console.log(chalk.cyan('    ruvnet-kb-first score --detailed') + chalk.gray('   Full score breakdown'));
+  console.log(chalk.cyan('    ruvnet-kb-first status --detailed') + chalk.gray('  Detailed project status'));
+  console.log(chalk.cyan('    ruvnet-kb-first verify') + chalk.gray('             Run verification checks'));
+  console.log(chalk.cyan('    ruvnet-kb-first phase <n>') + chalk.gray('          Execute build phase'));
+  console.log('');
+
+  // Final prompt
+  if (config.knowledgeBase?.connected) {
+    console.log(chalk.gray('  Ask Claude: "Review this app using RuvNet-KB-First and recommend improvements"'));
+  }
+  console.log('');
+}
+
+function calculateKBScore(stats) {
+  let score = 0;
+
+  // Connection (30 points)
+  if (stats.isLive) score += 30;
+  else score += 15;
+
+  // Entry count (50 points)
+  if (stats.entries >= 100000) score += 50;
+  else if (stats.entries >= 50000) score += 40;
+  else if (stats.entries >= 10000) score += 30;
+  else if (stats.entries >= 1000) score += 20;
+  else score += 10;
+
+  // Categories (20 points)
+  if (stats.categories >= 50) score += 20;
+  else if (stats.categories >= 20) score += 15;
+  else if (stats.categories >= 10) score += 10;
+  else score += 5;
+
+  return Math.min(score, 100);
+}
+
+async function calculateAllScores(cwd, config) {
+  const scores = {};
+
+  // 1. KB Coverage
+  const srcDir = join(cwd, 'src');
+  let kbCoverage = { percentage: 100, summary: 'No code yet' };
+  if (existsSync(srcDir)) {
+    const codeFiles = globSync('**/*.{ts,tsx,js,jsx,py}', { cwd: srcDir });
+    if (codeFiles.length > 0) {
+      let withCitation = 0;
+      for (const file of codeFiles) {
+        const content = readFileSync(join(srcDir, file), 'utf-8');
+        if (content.includes('KB-Generated:') || content.includes('Sources:')) {
+          withCitation++;
+        }
+      }
+      const pct = Math.round((withCitation / codeFiles.length) * 100);
+      kbCoverage = { percentage: pct, summary: `${withCitation}/${codeFiles.length} files` };
+    }
+  }
+  scores.kbCoverage = kbCoverage;
+
+  // 2. Phase Progress
+  const completed = config.phases?.completed?.length || 0;
+  const phasePct = Math.round((completed / 12) * 100);
+  scores.phaseProgress = { percentage: phasePct, summary: `${completed}/12 complete` };
+
+  // 3. Hook Compliance
+  let hookPct = 0;
+  if (config.hooks?.enabled) {
+    const hooksDir = join(cwd, '.ruvector', 'hooks');
+    let found = 0;
+    if (existsSync(join(hooksDir, 'pre-tool-use.py'))) found++;
+    if (existsSync(join(hooksDir, 'post-tool-use.py'))) found++;
+    hookPct = found === 2 ? 100 : (found === 1 ? 50 : 0);
+  }
+  scores.hooks = { percentage: hookPct, summary: hookPct === 100 ? 'All installed' : 'Incomplete' };
+
+  // 4. KB Gaps
+  const gapPath = join(cwd, '.ruvector', 'gaps.jsonl');
+  let gapPct = 100;
+  let gapSummary = 'No gaps';
+  if (existsSync(gapPath)) {
+    const content = readFileSync(gapPath, 'utf-8').trim();
+    if (content) {
+      const gaps = content.split('\n').length;
+      gapPct = Math.max(0, 100 - (gaps * 10));
+      gapSummary = `${gaps} unresolved`;
+    }
+  }
+  scores.kbGaps = { percentage: gapPct, summary: gapSummary };
+
+  // 5. Documentation
+  let docScore = 0;
+  if (existsSync(join(cwd, 'README.md'))) docScore += 40;
+  if (existsSync(join(cwd, 'docs', 'api.md'))) docScore += 30;
+  if (existsSync(join(cwd, 'docs', 'architecture.md'))) docScore += 30;
+  scores.documentation = { percentage: docScore, summary: docScore === 100 ? 'Complete' : 'Incomplete' };
+
+  // 6. Security
+  let secScore = 100;
+  const gitignore = join(cwd, '.gitignore');
+  if (!existsSync(gitignore)) {
+    secScore -= 30;
+  } else {
+    const content = readFileSync(gitignore, 'utf-8');
+    if (!content.includes('.env')) secScore -= 20;
+  }
+  if (!existsSync(join(cwd, 'package-lock.json')) && existsSync(join(cwd, 'package.json'))) {
+    secScore -= 20;
+  }
+  scores.security = { percentage: Math.max(0, secScore), summary: secScore === 100 ? 'Passed' : 'Issues found' };
+
+  return scores;
+}
+
+function renderScoreBar(percentage) {
+  const filled = Math.round(percentage / 5);
+  const empty = 20 - filled;
+  const color = percentage >= 80 ? chalk.green :
+               percentage >= 60 ? chalk.yellow :
+               percentage >= 40 ? chalk.hex('#FFA500') :
+               chalk.red;
+  return color('█'.repeat(filled)) + chalk.gray('░'.repeat(empty));
+}
+
+function colorScore(score) {
+  const color = score >= 80 ? chalk.green :
+               score >= 60 ? chalk.yellow :
+               score >= 40 ? chalk.hex('#FFA500') :
+               chalk.red;
+  return color(score.toString());
+}
+
+function formatLabel(key) {
+  const labels = {
+    kbCoverage: 'KB Coverage',
+    phaseProgress: 'Phase Progress',
+    hooks: 'Hooks',
+    kbGaps: 'KB Gaps',
+    documentation: 'Documentation',
+    security: 'Security'
+  };
+  return labels[key] || key;
+}
+
+function getGrade(score) {
+  if (score >= 95) return chalk.green.bold('A+');
+  if (score >= 90) return chalk.green.bold('A');
+  if (score >= 85) return chalk.green('A-');
+  if (score >= 80) return chalk.yellow.bold('B+');
+  if (score >= 75) return chalk.yellow('B');
+  if (score >= 70) return chalk.yellow('B-');
+  if (score >= 65) return chalk.hex('#FFA500')('C+');
+  if (score >= 60) return chalk.hex('#FFA500')('C');
+  if (score >= 55) return chalk.hex('#FFA500')('C-');
+  return chalk.red.bold('F');
+}
+
+function getRecommendations(scores, config) {
+  const recs = [];
+
+  if (!config.knowledgeBase?.connected) {
+    recs.push('Connect to KB: ruvnet-kb-first init --kb ask_ruvnet --force');
+  }
+
+  if (scores.kbCoverage.percentage < 80) {
+    recs.push('Add KB citations to code files (use kb_code_gen before writing)');
+  }
+
+  if (scores.phaseProgress.percentage < 50) {
+    recs.push(`Complete build phases: ruvnet-kb-first phase ${config.phases?.current || 0}`);
+  }
+
+  if (scores.hooks.percentage < 100) {
+    recs.push('Install enforcement hooks: ruvnet-kb-first hooks --install');
+  }
+
+  if (scores.kbGaps.percentage < 100) {
+    recs.push('Resolve KB gaps logged in .ruvector/gaps.jsonl');
+  }
+
+  if (scores.documentation.percentage < 100) {
+    recs.push('Add documentation: README.md, docs/api.md, docs/architecture.md');
+  }
+
+  if (scores.security.percentage < 100) {
+    recs.push('Fix security issues: ruvnet-kb-first verify --phase=9');
+  }
+
+  return recs;
+}

package/src/commands/init.js

@@ -14,6 +14,22 @@ import inquirer from 'inquirer';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+// Known KB schemas with descriptions
+const KNOWN_KB_SCHEMAS = {
+  'ask_ruvnet': {
+    description: 'RuvNet comprehensive knowledge base (230K+ entries)',
+    path: '/Users/stuartkerr/Code/Ask-Ruvnet'
+  },
+  'retirewell': {
+    description: 'Retirement planning knowledge base',
+    path: '/Users/stuartkerr/Code/RetireWell'
+  },
+  'presentermode': {
+    description: 'Presentation and public speaking knowledge',
+    path: null
+  }
+};
+
 // Project structure template
 const PROJECT_STRUCTURE = {
   directories: [
@@ -30,12 +46,21 @@ const PROJECT_STRUCTURE = {
   files: {
     '.ruvector/config.json': {
       kbFirst: {
-        version: '5.0.0',
+        version: '6.2.0',
         initialized: new Date().toISOString(),
         namespace: '',
         minConfidence: 0.5,
         gapLogging: true
       },
+      knowledgeBase: {
+        schema: null,
+        host: 'localhost',
+        port: 5435,
+        database: 'postgres',
+        table: 'architecture_docs',
+        entries: 0,
+        connected: false
+      },
       hooks: {
         enabled: true,
         preToolUse: true,
@@ -55,7 +80,7 @@ export async function initCommand(options) {
   const projectName = cwd.split('/').pop().toLowerCase().replace(/[^a-z0-9]/g, '_');
 
   console.log('');
-  console.log(chalk.cyan('Initializing KB-First project structure...'));
+  console.log(chalk.cyan('Initializing RuvNet-KB-First project structure...'));
   console.log('');
 
   // Check if already initialized
@@ -67,14 +92,42 @@ export async function initCommand(options) {
   }
 
   // Interactive prompts if not forcing
-  let config = { ...PROJECT_STRUCTURE.files['.ruvector/config.json'] };
+  let config = JSON.parse(JSON.stringify(PROJECT_STRUCTURE.files['.ruvector/config.json']));
+  config.kbFirst.initialized = new Date().toISOString();
+
+  // Handle --kb flag for connecting to existing KB
+  let kbSchema = options.kb;
+  const kbHost = options.kbHost || 'localhost';
+  const kbPort = options.kbPort || '5435';
+
+  if (!options.force && !kbSchema) {
+    // Show available KBs if not specified
+    const kbChoices = [
+      { name: 'None - Create new KB for this project', value: null },
+      ...Object.entries(KNOWN_KB_SCHEMAS).map(([schema, info]) => ({
+        name: `${schema} - ${info.description}`,
+        value: schema
+      })),
+      { name: 'Other - Enter custom schema name', value: '__custom__' }
+    ];
 
-  if (!options.force) {
     const answers = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'kbSchema',
+        message: 'Connect to existing Knowledge Base?',
+        choices: kbChoices
+      },
+      {
+        type: 'input',
+        name: 'customSchema',
+        message: 'Enter KB schema name:',
+        when: (answers) => answers.kbSchema === '__custom__'
+      },
       {
         type: 'input',
         name: 'namespace',
-        message: 'KB namespace (leave empty for project name):',
+        message: 'Project namespace (for new content):',
         default: projectName
       },
       {
@@ -96,12 +149,74 @@ export async function initCommand(options) {
       }
     ]);
 
+    kbSchema = answers.kbSchema === '__custom__' ? answers.customSchema : answers.kbSchema;
     config.kbFirst.namespace = answers.namespace || projectName;
     config.hooks.enabled = answers.installHooks;
   } else {
     config.kbFirst.namespace = projectName;
   }
 
+  // Connect to KB if specified
+  if (kbSchema) {
+    const spinner = ora(`Connecting to KB schema: ${kbSchema}...`).start();
+
+    try {
+      const pg = await import('pg');
+      const client = new pg.default.Client({
+        host: kbHost,
+        port: parseInt(kbPort),
+        database: 'postgres',
+        user: 'postgres',
+        password: 'guruKB2025'
+      });
+
+      await client.connect();
+
+      // Check if schema exists and count entries
+      const schemaCheck = await client.query(
+        `SELECT COUNT(*) as count FROM information_schema.schemata WHERE schema_name = $1`,
+        [kbSchema]
+      );
+
+      if (schemaCheck.rows[0].count === '0') {
+        spinner.fail(`KB schema '${kbSchema}' not found`);
+        await client.end();
+        console.log(chalk.yellow('\nAvailable schemas:'));
+        Object.entries(KNOWN_KB_SCHEMAS).forEach(([name, info]) => {
+          console.log(chalk.gray(`  ${name} - ${info.description}`));
+        });
+        return;
+      }
+
+      // Count entries
+      const countResult = await client.query(
+        `SELECT COUNT(*) as count FROM ${kbSchema}.architecture_docs`
+      );
+      const entryCount = parseInt(countResult.rows[0].count);
+
+      await client.end();
+
+      // Update config with KB connection
+      config.knowledgeBase = {
+        schema: kbSchema,
+        host: kbHost,
+        port: parseInt(kbPort),
+        database: 'postgres',
+        table: 'architecture_docs',
+        entries: entryCount,
+        connected: true,
+        connectedAt: new Date().toISOString()
+      };
+
+      spinner.succeed(`Connected to KB: ${kbSchema} (${entryCount.toLocaleString()} entries)`);
+
+    } catch (err) {
+      spinner.fail(`Failed to connect to KB: ${err.message}`);
+      console.log(chalk.yellow('\nMake sure the ruvector-kb container is running:'));
+      console.log(chalk.gray('  docker ps | grep ruvector-kb'));
+    }
+  }
+
   // Create directories
   const spinner = ora('Creating directory structure...').start();
 
@@ -192,8 +307,18 @@ export async function initCommand(options) {
 
   // Summary
   console.log('');
-  console.log(chalk.green('KB-First project initialized successfully!'));
+  console.log(chalk.green('RuvNet-KB-First project initialized successfully!'));
   console.log('');
+
+  // Show KB connection status
+  if (config.knowledgeBase.connected) {
+    console.log(chalk.white('Knowledge Base:'));
+    console.log(chalk.green(`  ✓ Connected to: ${config.knowledgeBase.schema}`));
+    console.log(chalk.gray(`    ${config.knowledgeBase.entries.toLocaleString()} entries available`));
+    console.log(chalk.gray(`    Host: ${config.knowledgeBase.host}:${config.knowledgeBase.port}`));
+    console.log('');
+  }
+
   console.log(chalk.white('Project structure:'));
   console.log(chalk.gray('  .ruvector/         - KB configuration and hooks'));
   console.log(chalk.gray('  src/kb/            - Knowledge base modules'));
@@ -201,9 +326,13 @@ export async function initCommand(options) {
   console.log(chalk.gray('  scripts/           - Verification scripts'));
   console.log('');
   console.log(chalk.white('Next steps:'));
-  console.log(chalk.cyan('  1. Run: kb-first status'));
-  console.log(chalk.cyan('  2. Start Phase 0: kb-first phase 0'));
-  console.log(chalk.cyan('  3. Build your KB in src/kb/'));
+  console.log(chalk.cyan('  1. Run: npx ruvnet-kb-first status'));
+  console.log(chalk.cyan('  2. Start Phase 0: npx ruvnet-kb-first phase 0'));
+  if (config.knowledgeBase.connected) {
+    console.log(chalk.cyan('  3. Ask Claude: "Review this app using RuvNet-KB-First and recommend improvements"'));
+  } else {
+    console.log(chalk.cyan('  3. Build your KB in src/kb/'));
+  }
   console.log('');
 }
 

package/src/commands/status.js

@@ -31,22 +31,70 @@ export async function statusCommand(options) {
 
   console.log('');
   console.log(chalk.cyan('╔═══════════════════════════════════════════════════════════════╗'));
-  console.log(chalk.cyan('║') + chalk.bold.white('                    KB-First Project Status                   ') + chalk.cyan('║'));
+  console.log(chalk.cyan('║') + chalk.bold.white('                 RuvNet-KB-First Project Status                ') + chalk.cyan('║'));
   console.log(chalk.cyan('╚═══════════════════════════════════════════════════════════════╝'));
   console.log('');
 
   // Check if initialized
   const configPath = join(cwd, '.ruvector', 'config.json');
   if (!existsSync(configPath)) {
-    console.log(chalk.red('  Not a KB-First project.'));
+    console.log(chalk.red('  Not a RuvNet-KB-First project.'));
     console.log('');
-    console.log(chalk.gray('  Initialize with: kb-first init'));
+    console.log(chalk.gray('  Initialize with: npx ruvnet-kb-first init'));
+    console.log(chalk.gray('  With KB:         npx ruvnet-kb-first init --kb ask_ruvnet'));
     console.log('');
     return;
   }
 
   const config = JSON.parse(readFileSync(configPath, 'utf-8'));
 
+  // Knowledge Base Connection (PROMINENT - this is the "Bible")
+  if (config.knowledgeBase?.connected) {
+    console.log(chalk.white('  Knowledge Base (Authority Source)'));
+    console.log(chalk.gray('  ─────────────────────────────────────────────────────────────'));
+
+    // Try to get live count
+    let liveCount = config.knowledgeBase.entries;
+    let isLive = false;
+    try {
+      const pg = await import('pg');
+      const client = new pg.default.Client({
+        host: config.knowledgeBase.host,
+        port: config.knowledgeBase.port,
+        database: 'postgres',
+        user: 'postgres',
+        password: 'guruKB2025'
+      });
+      await client.connect();
+      const result = await client.query(
+        `SELECT COUNT(*) as count FROM ${config.knowledgeBase.schema}.architecture_docs`
+      );
+      liveCount = parseInt(result.rows[0].count);
+      await client.end();
+      isLive = true;
+    } catch (e) {
+      // Use cached count
+    }
+
+    const statusIcon = isLive ? chalk.green('●') : chalk.yellow('○');
+    console.log(`  ${statusIcon} Schema:     ${chalk.green(config.knowledgeBase.schema)}`);
+    console.log(`    Entries:    ${chalk.cyan(liveCount.toLocaleString())} ${isLive ? chalk.green('(live)') : chalk.yellow('(cached)')}`);
+    console.log(`    Host:       ${chalk.gray(config.knowledgeBase.host + ':' + config.knowledgeBase.port)}`);
+    console.log('');
+    console.log(chalk.gray('  Claude will use this KB to:'));
+    console.log(chalk.gray('    • Verify architecture patterns are correct'));
+    console.log(chalk.gray('    • Ensure optimal configurations are applied'));
+    console.log(chalk.gray('    • Identify missing best practices'));
+    console.log(chalk.gray('    • Generate code with proper KB citations'));
+    console.log('');
+  } else {
+    console.log(chalk.white('  Knowledge Base'));
+    console.log(chalk.gray('  ─────────────────────────────────────────────────────────────'));
+    console.log(chalk.yellow('  ○ Not connected'));
+    console.log(chalk.gray('    Reinitialize with: npx ruvnet-kb-first init --kb ask_ruvnet'));
+    console.log('');
+  }
+
   // Project Info
   console.log(chalk.white('  Project Information'));
   console.log(chalk.gray('  ─────────────────────────────────────────────────────────────'));
@@ -132,12 +180,18 @@ export async function statusCommand(options) {
   console.log(chalk.white('  Next Steps'));
   console.log(chalk.gray('  ─────────────────────────────────────────────────────────────'));
 
+  if (config.knowledgeBase?.connected) {
+    console.log(chalk.cyan('  → Ask Claude: "Review this app using RuvNet-KB-First"'));
+    console.log(chalk.gray('    Claude will query the KB and analyze your code'));
+    console.log('');
+  }
+
   if (currentPhase < 11) {
-    console.log(chalk.cyan(`  → Run: kb-first phase ${currentPhase}`));
+    console.log(chalk.cyan(`  → Run: npx ruvnet-kb-first phase ${currentPhase}`));
     console.log(chalk.gray(`    Complete Phase ${currentPhase}: ${PHASES.find(p => p.num === currentPhase)?.name}`));
   } else {
     console.log(chalk.green('  → All phases complete!'));
-    console.log(chalk.gray('    Run: kb-first score --detailed'));
+    console.log(chalk.gray('    Run: npx ruvnet-kb-first score --detailed'));
   }
 
   console.log('');