ripp-cli 1.0.0 → 1.2.1

package/lib/doctor.js

@@ -0,0 +1,370 @@
+/**
+ * RIPP Doctor - Health Check and Diagnostics
+ *
+ * Checks repository health and provides actionable fix-it commands
+ * for common RIPP setup issues.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+/**
+ * Run all health checks
+ * @param {string} cwd - Current working directory
+ * @returns {Object} Health check results
+ */
+function runHealthChecks(cwd = process.cwd()) {
+  const checks = {
+    nodeVersion: checkNodeVersion(),
+    gitRepository: checkGitRepository(cwd),
+    rippDirectory: checkRippDirectory(cwd),
+    configFile: checkConfigFile(cwd),
+    evidencePack: checkEvidencePack(cwd),
+    candidates: checkCandidates(cwd),
+    confirmedIntent: checkConfirmedIntent(cwd),
+    schema: checkSchema(),
+    cliVersion: checkCliVersion()
+  };
+
+  // Calculate overall health
+  const total = Object.keys(checks).length;
+  const passed = Object.values(checks).filter(c => c.status === 'pass').length;
+  const warnings = Object.values(checks).filter(c => c.status === 'warning').length;
+
+  return {
+    checks,
+    summary: {
+      total,
+      passed,
+      warnings,
+      failed: total - passed - warnings,
+      healthy: passed === total
+    }
+  };
+}
+
+/**
+ * Check Node.js version (>= 20.0.0)
+ */
+function checkNodeVersion() {
+  const version = process.version;
+  const major = parseInt(version.slice(1).split('.')[0]);
+
+  if (major >= 20) {
+    return {
+      status: 'pass',
+      message: `Node.js ${version}`,
+      fix: null
+    };
+  } else {
+    return {
+      status: 'fail',
+      message: `Node.js ${version} is too old`,
+      fix: 'Install Node.js 20 or later: https://nodejs.org/',
+      docs: 'https://dylan-natter.github.io/ripp-protocol/getting-started.html#prerequisites'
+    };
+  }
+}
+
+/**
+ * Check if current directory is a Git repository
+ */
+function checkGitRepository(cwd) {
+  try {
+    const gitDir = path.join(cwd, '.git');
+    if (fs.existsSync(gitDir)) {
+      return {
+        status: 'pass',
+        message: 'Git repository detected',
+        fix: null
+      };
+    } else {
+      return {
+        status: 'fail',
+        message: 'Not a Git repository',
+        fix: 'Initialize Git: git init',
+        docs: 'https://git-scm.com/docs/git-init'
+      };
+    }
+  } catch (error) {
+    return {
+      status: 'fail',
+      message: 'Unable to check Git repository',
+      fix: 'Ensure you are in a valid directory',
+      docs: null
+    };
+  }
+}
+
+/**
+ * Check if .ripp directory exists
+ */
+function checkRippDirectory(cwd) {
+  const rippDir = path.join(cwd, '.ripp');
+  if (fs.existsSync(rippDir) && fs.statSync(rippDir).isDirectory()) {
+    return {
+      status: 'pass',
+      message: '.ripp directory exists',
+      fix: null
+    };
+  } else {
+    return {
+      status: 'fail',
+      message: '.ripp directory not found',
+      fix: 'Initialize RIPP: ripp init',
+      docs: 'https://dylan-natter.github.io/ripp-protocol/getting-started.html'
+    };
+  }
+}
+
+/**
+ * Check if config.yaml exists
+ */
+function checkConfigFile(cwd) {
+  const configPath = path.join(cwd, '.ripp', 'config.yaml');
+  if (fs.existsSync(configPath)) {
+    return {
+      status: 'pass',
+      message: 'config.yaml present',
+      fix: null
+    };
+  } else {
+    return {
+      status: 'warning',
+      message: 'config.yaml not found (using defaults)',
+      fix: 'Initialize RIPP: ripp init',
+      docs: 'https://dylan-natter.github.io/ripp-protocol/getting-started.html'
+    };
+  }
+}
+
+/**
+ * Check if evidence pack exists
+ */
+function checkEvidencePack(cwd) {
+  const evidenceIndex = path.join(cwd, '.ripp', 'evidence', 'index.yaml');
+  if (fs.existsSync(evidenceIndex)) {
+    return {
+      status: 'pass',
+      message: 'Evidence pack built',
+      fix: null
+    };
+  } else {
+    return {
+      status: 'warning',
+      message: 'Evidence pack not built',
+      fix: 'Build evidence: ripp evidence build',
+      docs: 'https://dylan-natter.github.io/ripp-protocol/getting-started.html#step-2-build-evidence'
+    };
+  }
+}
+
+/**
+ * Check if candidates exist (discovery has run)
+ */
+function checkCandidates(cwd) {
+  const candidatesDir = path.join(cwd, '.ripp', 'candidates');
+  if (fs.existsSync(candidatesDir)) {
+    const files = fs.readdirSync(candidatesDir);
+    const yamlFiles = files.filter(f => f.endsWith('.yaml') || f.endsWith('.yml'));
+
+    if (yamlFiles.length > 0) {
+      return {
+        status: 'pass',
+        message: `${yamlFiles.length} candidate(s) found`,
+        fix: null
+      };
+    } else {
+      return {
+        status: 'warning',
+        message: 'No candidate files in candidates directory',
+        fix: 'Run discovery: ripp discover (requires AI enabled)',
+        docs: 'https://dylan-natter.github.io/ripp-protocol/getting-started.html#step-3-discover-intent'
+      };
+    }
+  } else {
+    return {
+      status: 'warning',
+      message: 'Discovery not run',
+      fix: 'Run discovery: ripp discover (requires AI enabled)',
+      docs: 'https://dylan-natter.github.io/ripp-protocol/getting-started.html#step-3-discover-intent'
+    };
+  }
+}
+
+/**
+ * Check if confirmed intent exists
+ */
+function checkConfirmedIntent(cwd) {
+  const intentPath = path.join(cwd, '.ripp', 'intent.confirmed.yaml');
+  if (fs.existsSync(intentPath)) {
+    return {
+      status: 'pass',
+      message: 'Intent confirmed',
+      fix: null
+    };
+  } else {
+    return {
+      status: 'warning',
+      message: 'Intent not confirmed',
+      fix: 'Confirm intent: ripp confirm --checklist (then ripp build --from-checklist)',
+      docs: 'https://dylan-natter.github.io/ripp-protocol/getting-started.html#step-4-confirm-intent'
+    };
+  }
+}
+
+/**
+ * Check if RIPP schema is accessible
+ */
+function checkSchema() {
+  try {
+    // First check bundled schema (always available when CLI is installed)
+    const bundledSchemaPath = path.join(__dirname, '../schema', 'ripp-1.0.schema.json');
+    if (fs.existsSync(bundledSchemaPath)) {
+      return {
+        status: 'pass',
+        message: 'RIPP schema accessible',
+        fix: null
+      };
+    }
+
+    // Fallback: check if we're in project root (for development)
+    const projectRoot = path.resolve(__dirname, '../../..');
+    const schemaPath = path.join(projectRoot, 'schema', 'ripp-1.0.schema.json');
+    if (fs.existsSync(schemaPath)) {
+      return {
+        status: 'pass',
+        message: 'RIPP schema accessible',
+        fix: null
+      };
+    } else {
+      return {
+        status: 'warning',
+        message: 'RIPP schema not found locally',
+        fix: 'Schema will be loaded from repository when needed',
+        docs: 'https://dylan-natter.github.io/ripp-protocol/schema/ripp-1.0.schema.json'
+      };
+    }
+  } catch (error) {
+    return {
+      status: 'warning',
+      message: 'Unable to check schema',
+      fix: null,
+      docs: null
+    };
+  }
+}
+
+/**
+ * Check CLI version
+ */
+function checkCliVersion() {
+  try {
+    const pkg = require('../package.json');
+    return {
+      status: 'pass',
+      message: `ripp-cli v${pkg.version}`,
+      fix: null
+    };
+  } catch (error) {
+    return {
+      status: 'warning',
+      message: 'Unable to determine CLI version',
+      fix: null,
+      docs: null
+    };
+  }
+}
+
+/**
+ * Format health check results as text
+ */
+function formatHealthCheckText(results) {
+  const { checks, summary } = results;
+
+  let output = '\n';
+  output += '🔍 RIPP Health Check\n';
+  output += '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n';
+
+  // Overall summary
+  if (summary.healthy) {
+    output += '✅ All checks passed!\n\n';
+  } else {
+    output += `📊 Summary: ${summary.passed}/${summary.total} checks passed`;
+    if (summary.warnings > 0) {
+      output += `, ${summary.warnings} warnings`;
+    }
+    if (summary.failed > 0) {
+      output += `, ${summary.failed} failed`;
+    }
+    output += '\n\n';
+  }
+
+  // Individual checks
+  for (const [name, check] of Object.entries(checks)) {
+    const icon = check.status === 'pass' ? '✓' : check.status === 'warning' ? '⚠' : '✗';
+    const statusColor = check.status === 'pass' ? '' : check.status === 'warning' ? '⚠ ' : '✗ ';
+
+    output += `${icon} ${formatCheckName(name)}: ${check.message}\n`;
+
+    if (check.fix) {
+      output += `  → Fix: ${check.fix}\n`;
+    }
+
+    if (check.docs) {
+      output += `  → Docs: ${check.docs}\n`;
+    }
+
+    output += '\n';
+  }
+
+  // Next steps
+  if (!summary.healthy) {
+    output += '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n';
+    output += '💡 Next Steps:\n\n';
+
+    const failedChecks = Object.entries(checks)
+      .filter(([_, check]) => check.status === 'fail')
+      .map(([_, check]) => check.fix)
+      .filter(fix => fix !== null);
+
+    if (failedChecks.length > 0) {
+      failedChecks.forEach((fix, idx) => {
+        output += `  ${idx + 1}. ${fix}\n`;
+      });
+    } else {
+      output += '  All critical checks passed. Address warnings to improve workflow.\n';
+    }
+
+    output += '\n';
+  }
+
+  output += '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n';
+  output += 'For more help: https://dylan-natter.github.io/ripp-protocol/getting-started.html\n';
+
+  return output;
+}
+
+/**
+ * Format check name for display
+ */
+function formatCheckName(name) {
+  const names = {
+    nodeVersion: 'Node.js Version',
+    gitRepository: 'Git Repository',
+    rippDirectory: 'RIPP Directory',
+    configFile: 'Configuration',
+    evidencePack: 'Evidence Pack',
+    candidates: 'Intent Candidates',
+    confirmedIntent: 'Confirmed Intent',
+    schema: 'RIPP Schema',
+    cliVersion: 'CLI Version'
+  };
+  return names[name] || name;
+}
+
+module.exports = {
+  runHealthChecks,
+  formatHealthCheckText
+};

package/lib/evidence.js

@@ -74,14 +74,15 @@ async function buildEvidencePack(cwd, config) {
  */
 async function scanFiles(cwd, evidenceConfig) {
   const files = [];
+  let excludedCount = 0;
   const { includeGlobs, excludeGlobs, maxFileSize } = evidenceConfig;
 
-  // Build combined pattern
-  const patterns = includeGlobs.map(pattern => path.join(cwd, pattern));
-
-  for (const pattern of patterns) {
+  // Use glob with cwd option instead of joining paths
+  // This ensures patterns work correctly on all platforms
+  for (const pattern of includeGlobs) {
     const matches = await glob(pattern, {
-      ignore: excludeGlobs.map(ex => path.join(cwd, ex)),
+      cwd: cwd,
+      ignore: excludeGlobs,
       nodir: true,
       absolute: true
     });
@@ -92,6 +93,7 @@ async function scanFiles(cwd, evidenceConfig) {
 
         // Skip files that are too large
         if (stats.size > maxFileSize) {
+          excludedCount++;
           continue;
         }
 
@@ -109,12 +111,13 @@ async function scanFiles(cwd, evidenceConfig) {
         });
       } catch (error) {
         // Skip files we can't read
+        excludedCount++;
         continue;
       }
     }
   }
 
-  return files;
+  return { files, excludedCount };
 }
 
 /**
@@ -151,7 +154,10 @@ async function extractEvidence(files, cwd) {
     routes: [],
     schemas: [],
     auth: [],
-    workflows: []
+    workflows: [],
+    projectType: detectProjectType(files),
+    keyInsights: extractKeyInsights(files, cwd),
+    codeSnippets: extractKeyCodeSnippets(files)
   };
 
   for (const file of files) {
@@ -362,6 +368,203 @@ function redactSecrets(text) {
   return redacted;
 }
 
+/**
+ * Detect project type from evidence
+ */
+function detectProjectType(files) {
+  const indicators = {
+    cli: 0,
+    webApp: 0,
+    api: 0,
+    library: 0,
+    protocol: 0
+  };
+
+  for (const file of files) {
+    const content = file.content ? file.content.toLowerCase() : '';
+    const path = file.path.toLowerCase();
+
+    // CLI tool indicators
+    if (path.includes('/bin/') || path.includes('cli') || path.includes('command'))
+      indicators.cli += 3;
+    if (
+      content.includes('commander') ||
+      content.includes('yargs') ||
+      content.includes('process.argv')
+    )
+      indicators.cli += 2;
+    if (path === 'package.json' && content.includes('"bin"')) indicators.cli += 4;
+
+    // Web app indicators
+    if (path.includes('app/') || path.includes('pages/') || path.includes('components/'))
+      indicators.webApp += 3;
+    if (content.includes('react') || content.includes('vue') || content.includes('angular'))
+      indicators.webApp += 2;
+    if (path.includes('index.html') || path.includes('app.tsx')) indicators.webApp += 3;
+
+    // API indicators
+    if (path.includes('api/') || path.includes('routes/') || path.includes('controllers/'))
+      indicators.api += 3;
+    if (content.includes('express') || content.includes('fastify') || content.includes('koa'))
+      indicators.api += 2;
+    if (content.includes('@app.route') || content.includes('@route') || content.includes('router.'))
+      indicators.api += 2;
+
+    // Library indicators
+    if (path === 'package.json' && !content.includes('"bin"') && !content.includes('"scripts"'))
+      indicators.library += 2;
+    if (path.includes('lib/') || path.includes('src/index')) indicators.library += 1;
+
+    // Protocol/spec indicators
+    if (path.includes('spec.md') || path.includes('protocol') || path.includes('rfc'))
+      indicators.protocol += 4;
+    if (path.includes('schema/') && path.includes('.json')) indicators.protocol += 2;
+  }
+
+  // Return type with highest score
+  const sorted = Object.entries(indicators).sort((a, b) => b[1] - a[1]);
+  return {
+    primary: sorted[0][0],
+    secondary: sorted[1][1] > 0 ? sorted[1][0] : null,
+    confidence: sorted[0][1] > 5 ? 'high' : sorted[0][1] > 2 ? 'medium' : 'low',
+    scores: indicators
+  };
+}
+
+/**
+ * Extract key insights from README, package.json, and main files
+ */
+function extractKeyInsights(files, cwd) {
+  const insights = {
+    purpose: null,
+    description: null,
+    mainFeatures: [],
+    architecture: null
+  };
+
+  for (const file of files) {
+    const path = file.path.toLowerCase();
+    const content = file.content || '';
+
+    // Extract from README
+    if (path.includes('readme.md') || path.includes('readme.txt')) {
+      // Extract first paragraph as description
+      const lines = content.split('\n');
+      let desc = '';
+      for (const line of lines) {
+        if (line.trim() && !line.startsWith('#') && !line.startsWith('[')) {
+          desc += line.trim() + ' ';
+          if (desc.length > 200) break;
+        }
+      }
+      if (desc) insights.description = desc.slice(0, 300);
+
+      // Extract features (look for bullet points or numbered lists)
+      const featureMatch = content.match(
+        /(?:features|capabilities|includes)[\s\S]{0,50}?\n((?:[-*]\s.+\n)+)/i
+      );
+      if (featureMatch) {
+        insights.mainFeatures = featureMatch[1]
+          .split('\n')
+          .map(f => f.replace(/^[-*]\s+/, '').trim())
+          .filter(f => f.length > 0)
+          .slice(0, 5);
+      }
+    }
+
+    // Extract from package.json
+    if (path === 'package.json') {
+      try {
+        const pkg = JSON.parse(content);
+        if (pkg.description && !insights.description) {
+          insights.description = pkg.description;
+        }
+        if (pkg.name && !insights.purpose) {
+          insights.purpose = `${pkg.name}: ${pkg.description || 'No description'}`;
+        }
+      } catch (e) {
+        // Ignore JSON parse errors
+      }
+    }
+
+    // Extract from SPEC files
+    if (path.includes('spec.md') || path.includes('architecture.md')) {
+      const purposeMatch = content.match(/(?:purpose|goal|objective)[\s:]+([^\n]{50,300})/i);
+      if (purposeMatch && !insights.purpose) {
+        insights.purpose = purposeMatch[1].trim();
+      }
+    }
+  }
+
+  return insights;
+}
+
+/**
+ * Extract key code snippets (functions, classes, exports)
+ */
+function extractKeyCodeSnippets(files) {
+  const snippets = [];
+  let count = 0;
+  const maxSnippets = 15;
+
+  for (const file of files) {
+    if (count >= maxSnippets) break;
+    if (!file.content || file.type !== 'source') continue;
+
+    const content = file.content;
+    const path = file.path;
+
+    // Extract function definitions (JavaScript/TypeScript)
+    const funcMatches = content.matchAll(
+      /(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\([^)]*\)\s*{([^}]{0,200})/g
+    );
+    for (const match of funcMatches) {
+      if (count >= maxSnippets) break;
+      snippets.push({
+        file: path,
+        type: 'function',
+        name: match[1],
+        snippet: match[0].substring(0, 150)
+      });
+      count++;
+    }
+
+    // Extract class definitions
+    const classMatches = content.matchAll(
+      /(?:export\s+)?class\s+(\w+)(?:\s+extends\s+\w+)?\s*{([^}]{0,150})/g
+    );
+    for (const match of classMatches) {
+      if (count >= maxSnippets) break;
+      snippets.push({
+        file: path,
+        type: 'class',
+        name: match[1],
+        snippet: match[0].substring(0, 150)
+      });
+      count++;
+    }
+
+    // Extract key comments (JSDoc, purpose statements)
+    const commentMatches = content.matchAll(/\/\*\*\s*\n\s*\*\s*([^\n]{30,200})/g);
+    for (const match of commentMatches) {
+      if (count >= maxSnippets) break;
+      if (
+        match[1].toLowerCase().includes('purpose') ||
+        match[1].toLowerCase().includes('description')
+      ) {
+        snippets.push({
+          file: path,
+          type: 'comment',
+          snippet: match[1].trim()
+        });
+        count++;
+      }
+    }
+  }
+
+  return snippets.slice(0, maxSnippets);
+}
+
 module.exports = {
   buildEvidencePack,
   redactSecrets