@chappibunny/repolens 0.4.3 → 0.6.2

package/src/utils/branch.js

@@ -80,6 +80,38 @@ export function shouldPublishToNotion(config, currentBranch = getCurrentBranch()
   });
 }
 
+/**
+ * Check if current branch should publish to Confluence
+ * Based on config.confluence.branches setting
+ */
+export function shouldPublishToConfluence(config, currentBranch = getCurrentBranch()) {
+  // If no confluence config, allow all branches (backward compatible)
+  if (!config.confluence) {
+    return true;
+  }
+
+  // If branches not specified, allow all
+  if (!config.confluence.branches || config.confluence.branches.length === 0) {
+    return true;
+  }
+
+  // Check if current branch matches any allowed pattern
+  return config.confluence.branches.some(pattern => {
+    // Exact match
+    if (pattern === currentBranch) {
+      return true;
+    }
+
+    // Wildcard pattern (simple glob)
+    if (pattern.includes("*")) {
+      const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
+      return regex.test(currentBranch);
+    }
+
+    return false;
+  });
+}
+
 /**
  * Get branch-qualified page title
  */

package/src/utils/logger.js

@@ -1,26 +1,43 @@
+import { sanitizeSecrets } from "./secrets.js";
+
 const isVerbose = process.argv.includes("--verbose");
 const isTest = process.env.NODE_ENV === "test";
 
+/**
+ * Sanitize arguments for logging
+ */
+function sanitizeArgs(args) {
+  return args.map(arg => {
+    if (typeof arg === "string") {
+      return sanitizeSecrets(arg);
+    }
+    if (typeof arg === "object" && arg !== null) {
+      return JSON.parse(sanitizeSecrets(JSON.stringify(arg)));
+    }
+    return arg;
+  });
+}
+
 export function log(...args) {
   if (!isTest && isVerbose) {
-    console.log("[RepoLens]", ...args);
+    console.log("[RepoLens]", ...sanitizeArgs(args));
   }
 }
 
 export function info(...args) {
   if (!isTest) {
-    console.log("[RepoLens]", ...args);
+    console.log("[RepoLens]", ...sanitizeArgs(args));
   }
 }
 
 export function warn(...args) {
   if (!isTest) {
-    console.warn("[RepoLens]", ...args);
+    console.warn("[RepoLens]", ...sanitizeArgs(args));
   }
 }
 
 export function error(...args) {
   if (!isTest) {
-    console.error("[RepoLens]", ...args);
+    console.error("[RepoLens]", ...sanitizeArgs(args));
   }
 }

package/src/utils/metrics.js

@@ -0,0 +1,361 @@
+/**
+ * Metrics Collection for RepoLens Dashboard
+ * Calculates coverage, health scores, staleness, and quality issues
+ */
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { info, warn } from "./logger.js";
+
+/**
+ * Calculate documentation coverage
+ * @param {object} scanResult - Repository scan result
+ * @param {object} docs - Generated documentation
+ * @returns {object} - Coverage metrics
+ */
+export function calculateCoverage(scanResult, docs) {
+  const { modules = [], api = [], pages = [], filesCount = 0 } = scanResult;
+
+  // Module coverage: modules with descriptions vs total
+  const modulesWithDocs = modules.filter((m) => m.description || m.files?.length > 0).length;
+  const moduleCoverage = modules.length > 0 ? (modulesWithDocs / modules.length) * 100 : 0;
+
+  // API coverage: endpoints with descriptions vs total
+  const apisWithDocs = api.filter((a) => a.description || a.method).length;
+  const apiCoverage = api.length > 0 ? (apisWithDocs / api.length) * 100 : 100;
+
+  // Page coverage: pages with descriptions vs total
+  const pagesWithDocs = pages.filter((p) => p.description || p.component).length;
+  const pageCoverage = pages.length > 0 ? (pagesWithDocs / pages.length) * 100 : 100;
+
+  // Overall coverage (weighted average)
+  const weights = {
+    modules: 0.5,
+    api: 0.3,
+    pages: 0.2,
+  };
+
+  const overallCoverage =
+    moduleCoverage * weights.modules +
+    apiCoverage * weights.api +
+    pageCoverage * weights.pages;
+
+  return {
+    overall: overallCoverage,
+    modules: moduleCoverage,
+    api: apiCoverage,
+    pages: pageCoverage,
+    counts: {
+      modules: modules.length,
+      modulesDocumented: modulesWithDocs,
+      api: api.length,
+      apiDocumented: apisWithDocs,
+      pages: pages.length,
+      pagesDocumented: pagesWithDocs,
+      files: filesCount,
+    },
+  };
+}
+
+/**
+ * Calculate health score (0-100)
+ * @param {object} metrics - All metrics data
+ * @returns {number} - Health score
+ */
+export function calculateHealthScore(metrics) {
+  const { coverage, freshness, quality } = metrics;
+
+  // Coverage weight: 40%
+  const coverageScore = coverage.overall * 0.4;
+
+  // Freshness weight: 30%
+  const freshnessScore = freshness.score * 0.3;
+
+  // Quality weight: 30%
+  const qualityScore = quality.score * 0.3;
+
+  const healthScore = coverageScore + freshnessScore + qualityScore;
+
+  return Math.round(Math.min(100, Math.max(0, healthScore)));
+}
+
+/**
+ * Detect stale documentation
+ * @param {string} docsPath - Path to documentation directory
+ * @param {number} staleThreshold - Days before considering stale (default: 90)
+ * @returns {Promise<object>} - Freshness metrics
+ */
+export async function detectStaleness(docsPath, staleThreshold = 90) {
+  try {
+    const now = Date.now();
+    const staleMs = staleThreshold * 24 * 60 * 60 * 1000;
+
+    // Check if docs directory exists
+    try {
+      await fs.access(docsPath);
+    } catch {
+      // No docs yet
+      return {
+        lastUpdated: null,
+        daysSinceUpdate: null,
+        isStale: true,
+        score: 0,
+        files: [],
+      };
+    }
+
+    // Read all markdown files
+    const files = await fs.readdir(docsPath);
+    const mdFiles = files.filter((f) => f.endsWith(".md"));
+
+    if (mdFiles.length === 0) {
+      return {
+        lastUpdated: null,
+        daysSinceUpdate: null,
+        isStale: true,
+        score: 0,
+        files: [],
+      };
+    }
+
+    // Get modification times
+    const fileStats = await Promise.all(
+      mdFiles.map(async (file) => {
+        const filePath = path.join(docsPath, file);
+        const stats = await fs.stat(filePath);
+        return {
+          file,
+          mtime: stats.mtime.getTime(),
+          daysSince: Math.floor((now - stats.mtime.getTime()) / (24 * 60 * 60 * 1000)),
+        };
+      })
+    );
+
+    // Find most recently updated file
+    const newest = fileStats.reduce((a, b) => (a.mtime > b.mtime ? a : b));
+    const daysSinceUpdate = newest.daysSince;
+    const isStale = daysSinceUpdate > staleThreshold;
+
+    // Calculate freshness score (100 at 0 days, 0 at staleThreshold days)
+    const score = Math.max(0, 100 - (daysSinceUpdate / staleThreshold) * 100);
+
+    // Find stale files
+    const staleFiles = fileStats.filter((f) => f.daysSince > staleThreshold);
+
+    return {
+      lastUpdated: new Date(newest.mtime),
+      daysSinceUpdate,
+      isStale,
+      score: Math.round(score),
+      staleFiles: staleFiles.map((f) => ({
+        file: f.file,
+        daysSince: f.daysSince,
+      })),
+    };
+  } catch (err) {
+    warn(`Failed to detect staleness: ${err.message}`);
+    return {
+      lastUpdated: null,
+      daysSinceUpdate: null,
+      isStale: true,
+      score: 0,
+      staleFiles: [],
+    };
+  }
+}
+
+/**
+ * Find quality issues
+ * @param {object} scanResult - Repository scan result
+ * @param {object} docs - Generated documentation
+ * @returns {object} - Quality analysis
+ */
+export function analyzeQuality(scanResult, docs) {
+  const issues = [];
+  const { modules = [], api = [], pages = [] } = scanResult;
+
+  // Check for undocumented modules
+  const undocumentedModules = modules.filter((m) => !m.description && m.files?.length > 0);
+  if (undocumentedModules.length > 0) {
+    issues.push({
+      type: "undocumented_modules",
+      severity: "medium",
+      count: undocumentedModules.length,
+      message: `${undocumentedModules.length} modules lack descriptions`,
+      items: undocumentedModules.slice(0, 5).map((m) => m.name || m.path),
+    });
+  }
+
+  // Check for undocumented APIs
+  const undocumentedApis = api.filter((a) => !a.description && !a.handler);
+  if (undocumentedApis.length > 0) {
+    issues.push({
+      type: "undocumented_apis",
+      severity: "high",
+      count: undocumentedApis.length,
+      message: `${undocumentedApis.length} API endpoints lack documentation`,
+      items: undocumentedApis.slice(0, 5).map((a) => `${a.method || "GET"} ${a.path}`),
+    });
+  }
+
+  // Check for undocumented pages
+  const undocumentedPages = pages.filter((p) => !p.description && !p.component);
+  if (undocumentedPages.length > 0) {
+    issues.push({
+      type: "undocumented_pages",
+      severity: "low",
+      count: undocumentedPages.length,
+      message: `${undocumentedPages.length} pages lack descriptions`,
+      items: undocumentedPages.slice(0, 5).map((p) => p.path),
+    });
+  }
+
+  // Check for empty modules
+  const emptyModules = modules.filter((m) => !m.files || m.files.length === 0);
+  if (emptyModules.length > 0) {
+    issues.push({
+      type: "empty_modules",
+      severity: "low",
+      count: emptyModules.length,
+      message: `${emptyModules.length} modules contain no files`,
+      items: emptyModules.slice(0, 5).map((m) => m.name || m.path),
+    });
+  }
+
+  // Calculate quality score (100 - penalty for issues)
+  const penalties = {
+    high: 10,
+    medium: 5,
+    low: 2,
+  };
+
+  const totalPenalty = issues.reduce((sum, issue) => {
+    return sum + penalties[issue.severity] * Math.min(issue.count, 5);
+  }, 0);
+
+  const score = Math.max(0, 100 - totalPenalty);
+
+  return {
+    score: Math.round(score),
+    issues,
+    summary: {
+      total: issues.length,
+      high: issues.filter((i) => i.severity === "high").length,
+      medium: issues.filter((i) => i.severity === "medium").length,
+      low: issues.filter((i) => i.severity === "low").length,
+    },
+  };
+}
+
+/**
+ * Track metrics over time
+ * @param {object} metrics - Current metrics
+ * @param {string} historyPath - Path to metrics history file
+ * @returns {Promise<object>} - Updated history with trends
+ */
+export async function trackMetrics(metrics, historyPath) {
+  try {
+    // Load existing history
+    let history = [];
+    try {
+      const data = await fs.readFile(historyPath, "utf-8");
+      history = JSON.parse(data);
+    } catch {
+      // No history yet, start fresh
+      history = [];
+    }
+
+    // Add current metrics to history
+    const timestamp = new Date().toISOString();
+    history.push({
+      timestamp,
+      coverage: metrics.coverage.overall,
+      healthScore: metrics.healthScore,
+      filesCount: metrics.coverage.counts.files,
+      modulesCount: metrics.coverage.counts.modules,
+    });
+
+    // Keep last 90 days (assuming daily runs)
+    if (history.length > 90) {
+      history = history.slice(-90);
+    }
+
+    // Save updated history
+    await fs.mkdir(path.dirname(historyPath), { recursive: true });
+    await fs.writeFile(historyPath, JSON.stringify(history, null, 2));
+
+    // Calculate trends
+    const trends = calculateTrends(history);
+
+    return { history, trends };
+  } catch (err) {
+    warn(`Failed to track metrics: ${err.message}`);
+    return { history: [], trends: {} };
+  }
+}
+
+/**
+ * Calculate trends from history
+ * @param {array} history - Metrics history
+ * @returns {object} - Trend analysis
+ */
+function calculateTrends(history) {
+  if (history.length < 2) {
+    return {
+      coverage: { direction: "stable", change: 0 },
+      healthScore: { direction: "stable", change: 0 },
+    };
+  }
+
+  const latest = history[history.length - 1];
+  const previous = history[history.length - 2];
+
+  const coverageChange = latest.coverage - previous.coverage;
+  const healthChange = latest.healthScore - previous.healthScore;
+
+  return {
+    coverage: {
+      direction: coverageChange > 1 ? "up" : coverageChange < -1 ? "down" : "stable",
+      change: coverageChange.toFixed(1),
+    },
+    healthScore: {
+      direction: healthChange > 2 ? "up" : healthChange < -2 ? "down" : "stable",
+      change: healthChange.toFixed(0),
+    },
+  };
+}
+
+/**
+ * Collect all metrics
+ * @param {object} scanResult - Repository scan result
+ * @param {object} docs - Generated documentation
+ * @param {string} docsPath - Path to documentation directory
+ * @param {string} historyPath - Path to metrics history file
+ * @returns {Promise<object>} - Complete metrics data
+ */
+export async function collectMetrics(scanResult, docs, docsPath, historyPath) {
+  info("Collecting metrics...");
+
+  const coverage = calculateCoverage(scanResult, docs);
+  const freshness = await detectStaleness(docsPath);
+  const quality = analyzeQuality(scanResult, docs);
+
+  const metrics = {
+    coverage,
+    freshness,
+    quality,
+    timestamp: new Date().toISOString(),
+  };
+
+  metrics.healthScore = calculateHealthScore(metrics);
+
+  // Track over time
+  const { history, trends } = await trackMetrics(metrics, historyPath);
+  metrics.history = history;
+  metrics.trends = trends;
+
+  info(`✓ Health Score: ${metrics.healthScore}/100`);
+  info(`✓ Coverage: ${metrics.coverage.overall.toFixed(1)}%`);
+
+  return metrics;
+}