thuban 0.3.1 → 0.3.2

package/cli.js

@@ -20,6 +20,7 @@
 
 const path = require('path');
 const fs = require('fs');
+const os = require('os');
 
 // Import engine components
 const CodeScanner = require('./packages/scanner/code-scanner.js');
@@ -93,7 +94,8 @@ function printHelp() {
   // ─── SCAN & DETECT ───────────────────────────────────────
   console.log(c('bold', '  SCAN & DETECT'));
   console.log('');
-  console.log(`    ${c('cyan', 'scan')} [path]              Full health scan — score, grade, all issues`);
+  console.log(`    ${c('cyan', 'scan')} [path|url]           Full health scan — score, grade, all issues`);
+  console.log(`    ${c('cyan', 'compare')} [a] [b]          Compare two codebases side by side`);
   console.log(`    ${c('cyan', 'hallucinate')} [path]       Find phantom APIs and invented imports`);
   console.log(`    ${c('cyan', 'ghosts')} [path]            Dead functions nobody calls`);
   console.log(`    ${c('cyan', 'ai-score')} [path]          Probability each function is AI-generated`);
@@ -166,6 +168,9 @@ function printHelp() {
   console.log(c('gray', '  # Scan a specific folder, ignore tests'));
   console.log(`    ${c('white', 'npx thuban scan ./src --ignore "**/*.test.js"')}`);
   console.log('');
+  console.log(c('gray', '  Report a bug or request a feature:'));
+  console.log(`    ${c('cyan', 'https://github.com/SilverwingsBenefitsGit/thuban/issues')}`);
+  console.log('');
 }
 
 function parseArgs(args) {
@@ -204,7 +209,14 @@ function parseArgs(args) {
     else if (arg === '--version' || arg === '-v') { opts.command = 'version'; }
     else if (!opts.command) { opts.command = arg; }
     else if (opts.command === 'activate' && !opts.licenseKey) { opts.licenseKey = arg; }
-    else if (!noPathCommands.includes(opts.command)) { opts.targetPath = path.resolve(arg); }
+    else if (!noPathCommands.includes(opts.command)) {
+      // Don't resolve git URLs as local paths
+      if (arg.match(/^(https?:\/\/|git@)/)) {
+        opts.targetPath = arg;
+      } else {
+        opts.targetPath = path.resolve(arg);
+      }
+    }
     i++;
   }
 
@@ -256,7 +268,34 @@ function collectFiles(dir, ignorePatterns = []) {
 
 async function cmdScan(opts) {
   const startTime = Date.now();
-  const targetPath = path.resolve(opts.targetPath);
+  const gitUrlPattern = /^(https?:\/\/|git@)/;
+  const isGitUrl = gitUrlPattern.test(opts.targetPath);
+  let targetPath = isGitUrl ? opts.targetPath : path.resolve(opts.targetPath);
+  let clonedRepo = null;
+
+  // ─── Git URL detection — clone and scan ─────────────────
+  if (isGitUrl) {
+    if (!opts.json) {
+      console.log('');
+      console.log(c('cyan', '  Cloning repository...'));
+      console.log(c('gray', `  ${opts.targetPath}`));
+    }
+    const tmpDir = path.join(os.tmpdir(), 'thuban-scan-' + Date.now());
+    const { execSync } = require('child_process');
+    try {
+      execSync(`git clone --depth 1 "${opts.targetPath}" "${tmpDir}"`, { stdio: 'pipe', timeout: 60000 });
+      targetPath = tmpDir;
+      clonedRepo = tmpDir;
+      if (!opts.json) {
+        console.log(c('cyan', '  Cloned successfully'));
+        console.log('');
+      }
+    } catch (e) {
+      console.error(c('red', `  Failed to clone repository: ${e.message}`));
+      console.error(c('gray', '  Check the URL is correct and the repo is accessible'));
+      process.exit(1);
+    }
+  }
 
   // ─── License check ───────────────────────────────────────
   const lm = new LicenseManager();
@@ -966,6 +1005,11 @@ async function cmdReport(opts) {
     if (orphans.length > 5) console.log(`  ${c('gray', '→')} Consider removing ${orphans.length} orphan files`);
     console.log('');
   }
+
+  // Clean up cloned repo
+  if (clonedRepo) {
+    try { fs.rmSync(clonedRepo, { recursive: true, force: true }); } catch {}
+  }
 }
 
 // ─── Tech Debt & Fix Commands ────────────────────────────
@@ -1948,6 +1992,292 @@ async function cmdBaseline(opts) {
   }
 }
 
+// ─── Telemetry (opt-in anonymous usage stats) ───────────────
+
+function getTelemetryConfigPath() {
+  const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+  return path.join(home, '.thuban-telemetry.json');
+}
+
+function isTelemetryEnabled() {
+  try {
+    const config = JSON.parse(fs.readFileSync(getTelemetryConfigPath(), 'utf-8'));
+    return config.enabled === true;
+  } catch { return false; }
+}
+
+function sendAnonymousTelemetry(data) {
+  if (!isTelemetryEnabled()) return;
+  try {
+    const payload = JSON.stringify({
+      v: data.version || '0.3.1',
+      cmd: data.command,
+      files: data.fileCount,
+      score: data.score,
+      grade: data.grade,
+      langs: data.languages,
+      issues: data.issueCount,
+      duration: data.duration,
+      os: process.platform,
+      node: process.version,
+      ts: new Date().toISOString()
+    });
+    // Fire and forget — never blocks the CLI
+    const https = require('https');
+    const req = https.request({
+      hostname: 'thuban-telemetry.silverwingsbenefits.workers.dev',
+      path: '/report',
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) },
+      timeout: 3000
+    });
+    req.on('error', () => {}); // silently ignore
+    req.write(payload);
+    req.end();
+  } catch { /* never fail the CLI for telemetry */ }
+}
+
+async function cmdTelemetry(opts) {
+  const configPath = getTelemetryConfigPath();
+  const args = process.argv.slice(2);
+
+  if (args.includes('--on')) {
+    fs.writeFileSync(configPath, JSON.stringify({ enabled: true, updated: new Date().toISOString() }));
+    console.log('');
+    console.log(c('cyan', '  Telemetry enabled'));
+    console.log(c('gray', '  Anonymous usage stats will be sent (no code, no paths, no PII)'));
+    console.log(c('gray', '  Turn off anytime: npx thuban telemetry --off'));
+    console.log('');
+  } else if (args.includes('--off')) {
+    fs.writeFileSync(configPath, JSON.stringify({ enabled: false, updated: new Date().toISOString() }));
+    console.log('');
+    console.log(c('cyan', '  Telemetry disabled'));
+    console.log(c('gray', '  No data will be collected'));
+    console.log('');
+  } else {
+    const enabled = isTelemetryEnabled();
+    console.log('');
+    console.log(c('bold', '  TELEMETRY STATUS'));
+    console.log('');
+    console.log(`  Status:   ${enabled ? c('cyan', 'Enabled') : c('gray', 'Disabled (default)')}`);
+    console.log('');
+    console.log(c('gray', '  Thuban telemetry is 100% opt-in and anonymous.'));
+    console.log(c('gray', '  We collect: file count, score, grade, languages, OS, scan duration.'));
+    console.log(c('gray', '  We never collect: code, file names, paths, project names, or PII.'));
+    console.log('');
+    console.log(`  Enable:   ${c('cyan', 'npx thuban telemetry --on')}`);
+    console.log(`  Disable:  ${c('cyan', 'npx thuban telemetry --off')}`);
+    console.log('');
+  }
+}
+
+// ─── Internal scan (returns data without printing) ──────────
+
+async function runScanSilent(targetInput) {
+  const gitUrlPattern = /^(https?:\/\/|git@)/;
+  const isGitUrl = gitUrlPattern.test(targetInput);
+  let targetPath = isGitUrl ? targetInput : path.resolve(targetInput);
+  let clonedRepo = null;
+  let label = targetInput;
+
+  if (isGitUrl) {
+    const tmpDir = path.join(os.tmpdir(), 'thuban-compare-' + Date.now() + '-' + Math.random().toString(36).slice(2,6));
+    const { execSync } = require('child_process');
+    execSync(`git clone --depth 1 "${targetInput}" "${tmpDir}"`, { stdio: 'pipe', timeout: 60000 });
+    targetPath = tmpDir;
+    clonedRepo = tmpDir;
+    // Extract repo name for label
+    const parts = targetInput.replace(/\.git$/, '').split('/');
+    label = parts[parts.length - 1] || targetInput;
+  } else {
+    label = path.basename(path.resolve(targetInput)) || targetInput;
+  }
+
+  const startTime = Date.now();
+  const scanner = new CodeScanner();
+  const graph = new DependencyGraph();
+  const hallDetector = new HallucinationDetector({ rootPath: targetPath });
+
+  const files = collectFiles(targetPath, []);
+  const scanResults = {};
+  let annotated = 0;
+  let driftCount = 0;
+
+  for (const file of files) {
+    try {
+      const result = scanner.scanFile(file);
+      const relPath = path.relative(targetPath, file);
+      scanResults[file] = result;
+      graph.addFile(file, targetPath);
+      if (result.motherCode && result.motherCode.hasDNA) annotated++;
+      if (result.drifts && result.drifts.length > 0) driftCount++;
+    } catch (e) { /* skip */ }
+  }
+
+  // Run hallucination detection (same as main scan)
+  const hallResults = hallDetector.scan(files, targetPath);
+
+  const elapsed = Date.now() - startTime;
+  let totalIssues = 0, criticalCount = 0, highCount = 0;
+  const issueByCat = {};
+
+  // Count code scanner issues
+  for (const [, r] of Object.entries(scanResults)) {
+    if (r.issues) {
+      totalIssues += r.issues.length;
+      for (const iss of r.issues) {
+        if (iss.severity === 'critical') criticalCount++;
+        if (iss.severity === 'high') highCount++;
+        const cat = iss.category || iss.type || 'other';
+        issueByCat[cat] = (issueByCat[cat] || 0) + 1;
+      }
+    }
+  }
+
+  // Count hallucination issues
+  const hallIssueCount = (hallResults.phantomAPIs || []).length
+    + (hallResults.phantomImports || []).length
+    + (hallResults.deprecatedAPIs || []).length;
+  totalIssues += hallIssueCount;
+  criticalCount += (hallResults.phantomAPIs || []).length + (hallResults.phantomImports || []).length;
+  highCount += (hallResults.deprecatedAPIs || []).length;
+  if (hallIssueCount > 0) issueByCat['hallucination'] = hallIssueCount;
+
+  const orphans = graph.getOrphanFiles();
+  const circular = graph.circularDeps || [];
+  const coverage = files.length > 0 ? Math.round((annotated / files.length) * 100) : 0;
+
+  const score = Math.max(0, Math.round(
+    100 - (criticalCount * 15) - (highCount * 5) - (circular.length * 10)
+    - (orphans.length * 1) - ((100 - coverage) * 0.1) - (driftCount * 3)
+  ));
+
+  const grade = score >= 90 ? 'A' : score >= 80 ? 'B' : score >= 70 ? 'C' : score >= 60 ? 'D' : 'F';
+
+  if (clonedRepo) {
+    try { fs.rmSync(clonedRepo, { recursive: true, force: true }); } catch {}
+  }
+
+  return {
+    label,
+    files: files.length,
+    score,
+    grade,
+    elapsed,
+    issues: { total: totalIssues, critical: criticalCount, high: highCount },
+    categories: issueByCat,
+    dependencies: { circular: circular.length, orphans: orphans.length },
+    motherCode: { annotated, coverage, drifted: driftCount }
+  };
+}
+
+// ─── Compare Command ────────────────────────────────────────
+
+async function cmdCompare(opts) {
+  const args = process.argv.slice(2);
+  // Find the two paths after 'compare'
+  const paths = args.filter(a => a !== 'compare' && !a.startsWith('--'));
+
+  if (paths.length < 2) {
+    console.log('');
+    console.log(c('red', '  Compare requires two paths or URLs'));
+    console.log('');
+    console.log(c('gray', '  Usage:'));
+    console.log(`    ${c('cyan', 'npx thuban compare ./project-a ./project-b')}`);
+    console.log(`    ${c('cyan', 'npx thuban compare . https://github.com/user/repo')}`);
+    console.log(`    ${c('cyan', 'npx thuban compare https://github.com/a/repo https://github.com/b/repo')}`);
+    console.log('');
+    process.exit(1);
+  }
+
+  console.log('');
+  console.log(c('bold', '  ╔══════════════════════════════════════╗'));
+  console.log(c('bold', '  ║     THUBAN — Codebase Comparison     ║'));
+  console.log(c('bold', '  ╚══════════════════════════════════════╝'));
+  console.log('');
+
+  console.log(c('cyan', `  Scanning: ${paths[0]}`));
+  const resultA = await runScanSilent(paths[0]);
+  console.log(c('cyan', `  Scanning: ${paths[1]}`));
+  const resultB = await runScanSilent(paths[1]);
+
+  console.log('');
+
+  // ─── Side by side comparison ────────────────────────────
+  const pad = (str, len) => String(str).padEnd(len);
+  const padL = (str, len) => String(str).padStart(len);
+  const colW = 20;
+  const labelA = resultA.label.length > colW ? resultA.label.slice(0, colW - 2) + '..' : resultA.label;
+  const labelB = resultB.label.length > colW ? resultB.label.slice(0, colW - 2) + '..' : resultB.label;
+
+  const scoreColorA = resultA.score >= 80 ? 'green' : resultA.score >= 60 ? 'yellow' : 'red';
+  const scoreColorB = resultB.score >= 80 ? 'green' : resultB.score >= 60 ? 'yellow' : 'red';
+
+  const arrow = (a, b) => {
+    if (a === b) return c('gray', '  =');
+    return a > b ? c('green', '  ↑') : c('red', '  ↓');
+  };
+
+  const better = (a, b, lowerIsBetter) => {
+    if (a === b) return c('gray', ' draw');
+    if (lowerIsBetter) return a < b ? c('green', ' ← winner') : c('red', '');
+    return a > b ? c('green', ' ← winner') : c('red', '');
+  };
+
+  console.log(c('bold', '  ┌──────────────────────┬──────────────────────┬──────────────────────┐'));
+  console.log(c('bold', `  │ ${pad('METRIC', colW)} │ ${pad(labelA, colW)} │ ${pad(labelB, colW)} │`));
+  console.log(c('bold', '  ├──────────────────────┼──────────────────────┼──────────────────────┤'));
+
+  const row = (label, valA, valB) => {
+    console.log(`  │ ${c('gray', pad(label, colW))} │ ${pad(valA, colW)} │ ${pad(valB, colW)} │`);
+  };
+
+  row('Health Score', `${c(scoreColorA, resultA.score + '/100')}`, `${c(scoreColorB, resultB.score + '/100')}`);
+  row('Grade', `${c(scoreColorA, resultA.grade)}`, `${c(scoreColorB, resultB.grade)}`);
+  row('Files Scanned', String(resultA.files), String(resultB.files));
+  row('Total Issues', String(resultA.issues.total), String(resultB.issues.total));
+  row('Critical Issues', String(resultA.issues.critical), String(resultB.issues.critical));
+  row('High Issues', String(resultA.issues.high), String(resultB.issues.high));
+  row('Circular Deps', String(resultA.dependencies.circular), String(resultB.dependencies.circular));
+  row('Orphan Files', String(resultA.dependencies.orphans), String(resultB.dependencies.orphans));
+  row('Mother Code DNA', `${resultA.motherCode.coverage}%`, `${resultB.motherCode.coverage}%`);
+  row('Drift Issues', String(resultA.motherCode.drifted), String(resultB.motherCode.drifted));
+  row('Scan Time', `${resultA.elapsed}ms`, `${resultB.elapsed}ms`);
+
+  console.log(c('bold', '  └──────────────────────┴──────────────────────┴──────────────────────┘'));
+  console.log('');
+
+  // ─── Verdict ────────────────────────────────────────────
+  const diff = resultA.score - resultB.score;
+  if (diff === 0) {
+    console.log(c('cyan', `  VERDICT: Both codebases score identically (${resultA.score}/100)`));
+  } else {
+    const winner = diff > 0 ? resultA : resultB;
+    const loser = diff > 0 ? resultB : resultA;
+    console.log(c('cyan', `  VERDICT: ${winner.label} is healthier`));
+    console.log(c('gray', `  ${winner.label} scores ${winner.score}/100 (${winner.grade}) vs ${loser.label} at ${loser.score}/100 (${loser.grade})`));
+    console.log(c('gray', `  ${Math.abs(diff)} point difference — ${Math.abs(diff) > 20 ? 'significant gap' : Math.abs(diff) > 10 ? 'moderate gap' : 'close race'}`));
+  }
+
+  // ─── Issue breakdown comparison ─────────────────────────
+  const allCats = new Set([...Object.keys(resultA.categories), ...Object.keys(resultB.categories)]);
+  if (allCats.size > 0) {
+    console.log('');
+    console.log(c('bold', '  ISSUE BREAKDOWN'));
+    for (const cat of allCats) {
+      const countA = resultA.categories[cat] || 0;
+      const countB = resultB.categories[cat] || 0;
+      const catLabel = cat.charAt(0).toUpperCase() + cat.slice(1);
+      console.log(c('gray', `    ${pad(catLabel, 22)} ${padL(countA, 5)} vs ${padL(countB, 5)}  ${countA < countB ? c('green', `← ${labelA}`) : countA > countB ? c('green', `→ ${labelB}`) : c('gray', 'tied')}`));
+    }
+  }
+
+  console.log('');
+  console.log(c('gray', `  Full scan: npx thuban scan ${paths[0]}`));
+  console.log(c('gray', `  Full scan: npx thuban scan ${paths[1]}`));
+  console.log('');
+}
+
 async function main() {
   const args = process.argv.slice(2);
   const opts = parseArgs(args);
@@ -1964,9 +2294,9 @@ async function main() {
   }
 
   // Verify target path exists
-  const noPathCommands2 = ['activate', 'status', 'upgrade'];
+  const noPathCommands2 = ['activate', 'status', 'upgrade', 'telemetry', 'compare'];
 
-  if (!noPathCommands2.includes(opts.command) && !fs.existsSync(opts.targetPath)) {
+  if (!noPathCommands2.includes(opts.command) && !opts.targetPath.match(/^(https?:\/\/|git@)/) && !fs.existsSync(opts.targetPath)) {
     console.error(c('red', `  Error: Path not found: ${opts.targetPath}`));
     process.exit(1);
   }
@@ -2049,12 +2379,18 @@ async function main() {
       case 'baseline':
         await cmdBaseline(opts);
         break;
+      case 'telemetry':
+        await cmdTelemetry(opts);
+        break;
+      case 'compare':
+        await cmdCompare(opts);
+        break;
       default:
         console.error('');
         console.error(c('red', `  Unknown command: ${opts.command}`));
         console.error('');
         // Suggest closest match
-        const allCmds = ['scan','deps','drift','inject','health','report','debt','fix','hallucinate','watch','dashboard','diff','gate','cost','ghosts','ai-score','clones','passport','executive','baseline','activate','status','upgrade'];
+        const allCmds = ['scan','compare','deps','drift','inject','health','report','debt','fix','hallucinate','watch','dashboard','diff','gate','cost','ghosts','ai-score','clones','passport','executive','baseline','activate','status','upgrade','telemetry'];
         const suggestions = allCmds.filter(cmd => cmd.startsWith(opts.command.slice(0,2)) || cmd.includes(opts.command));
         if (suggestions.length > 0) {
           console.error(c('gray', `  Did you mean: `) + c('cyan', suggestions.join(', ')) + c('gray', '?'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thuban",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "The safety layer for AI-coded software. Detect hallucinated APIs, ghost code, tech debt, and architecture drift. One command. Zero dependencies.",
   "bin": {
     "thuban": "./cli.js"