@chappibunny/repolens 0.4.3 → 0.6.2

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@chappibunny/repolens",
-  "version": "0.4.3",
+  "version": "0.6.2",
   "description": "AI-assisted documentation intelligence system for technical and non-technical audiences",
   "license": "MIT",
   "type": "module",
   "main": "src/cli.js",
   "bin": {
-    "repolens": "./bin/repolens.js"
+    "repolens": "bin/repolens.js"
   },
   "files": [
     "bin",
@@ -18,12 +18,19 @@
   ],
   "keywords": [
     "cli",
-    "docs",
+    "documentation",
     "architecture",
     "github",
     "notion",
+    "confluence",
     "markdown",
-    "developer-tools"
+    "developer-tools",
+    "repolens",
+    "observability",
+    "metrics",
+    "team-collaboration",
+    "discord",
+    "ai-documentation"
   ],
   "repository": {
     "type": "git",
@@ -34,6 +41,10 @@
     "url": "https://github.com/CHAPIBUNNY/repolens/issues"
   },
   "author": "Charl van Zyl",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
   "scripts": {
     "test:notion": "node notion-test.js",
     "docs:publish": "node src/cli.js publish --config ../../.repolens.yml",
@@ -47,6 +58,7 @@
     "release:major": "npm version major"
   },
   "dependencies": {
+    "@sentry/node": "^10.42.0",
     "dotenv": "^17.3.1",
     "fast-glob": "^3.3.3",
     "js-yaml": "^4.1.0",

package/src/ai/provider.js

@@ -1,6 +1,7 @@
 // Provider-agnostic AI text generation
 
 import { warn, info } from "../utils/logger.js";
+import { executeAIRequest } from "../utils/rate-limit.js";
 
 const DEFAULT_TIMEOUT_MS = 60000;
 const DEFAULT_TEMPERATURE = 0.2;
@@ -68,54 +69,56 @@ export async function generateText({ system, user, temperature, maxTokens }) {
 }
 
 async function callOpenAICompatibleAPI({ baseUrl, apiKey, model, system, user, temperature, maxTokens, timeoutMs }) {
-  const url = `${baseUrl}/chat/completions`;
-  
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-  
-  try {
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${apiKey}`
-      },
-      body: JSON.stringify({
-        model,
-        messages: [
-          { role: "system", content: system },
-          { role: "user", content: user }
-        ],
-        temperature,
-        max_tokens: maxTokens
-      }),
-      signal: controller.signal
-    });
-    
-    clearTimeout(timeoutId);
-    
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`API error (${response.status}): ${errorText}`);
-    }
+  return await executeAIRequest(async () => {
+    const url = `${baseUrl}/chat/completions`;
     
-    const data = await response.json();
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
     
-    if (!data.choices || data.choices.length === 0) {
-      throw new Error("No completion returned from API");
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          model,
+          messages: [
+            { role: "system", content: system },
+            { role: "user", content: user }
+          ],
+          temperature,
+          max_tokens: maxTokens
+        }),
+        signal: controller.signal
+      });
+      
+      clearTimeout(timeoutId);
+      
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`API error (${response.status}): ${errorText}`);
+      }
+      
+      const data = await response.json();
+      
+      if (!data.choices || data.choices.length === 0) {
+        throw new Error("No completion returned from API");
+      }
+      
+      return data.choices[0].message.content;
+      
+    } catch (error) {
+      clearTimeout(timeoutId);
+      
+      if (error.name === "AbortError") {
+        throw new Error(`Request timeout after ${timeoutMs}ms`);
+      }
+      
+      throw error;
     }
-    
-    return data.choices[0].message.content;
-    
-  } catch (error) {
-    clearTimeout(timeoutId);
-    
-    if (error.name === "AbortError") {
-      throw new Error(`Request timeout after ${timeoutMs}ms`);
-    }
-    
-    throw error;
-  }
+  });
 }
 
 export function isAIEnabled() {

package/src/cli.js

@@ -24,6 +24,15 @@ import { info, error } from "./utils/logger.js";
 import { checkForUpdates } from "./utils/update-check.js";
 import { generateDocumentSet } from "./docs/generate-doc-set.js";
 import { writeDocumentSet } from "./docs/write-doc-set.js";
+import { 
+  initTelemetry, 
+  captureError, 
+  setContext, 
+  closeTelemetry,
+  trackUsage,
+  startTimer,
+  stopTimer
+} from "./utils/telemetry.js";
 
 async function getPackageVersion() {
   const __filename = fileURLToPath(import.meta.url);
@@ -38,8 +47,17 @@ async function getPackageVersion() {
 
 async function printBanner() {
   const version = await getPackageVersion();
-  console.log(`\nRepoLens v${version}`);
-  console.log("─".repeat(40));
+  console.log(`
+██████╗ ███████╗██████╗  ██████╗ ██╗     ███████╗███╗   ██╗███████╗
+██╔══██╗██╔════╝██╔══██╗██╔═══██╗██║     ██╔════╝████╗  ██║██╔════╝
+██████╔╝█████╗  ██████╔╝██║   ██║██║     █████╗  ██╔██╗ ██║███████╗
+██╔══██╗██╔══╝  ██╔═══╝ ██║   ██║██║     ██╔══╝  ██║╚██╗██║╚════██║
+██║  ██║███████╗██║     ╚██████╔╝███████╗███████╗██║ ╚████║███████║
+╚═╝  ╚═╝╚══════╝╚═╝      ╚═════╝ ╚══════╝╚══════╝╚═╝  ╚═══╝╚══════╝
+          🔍 Repository Intelligence by RABITAI 🐰
+          v${version}
+`);
+  console.log("─".repeat(70));
 }
 
 function getArg(name) {
@@ -81,16 +99,16 @@ async function findConfig(startDir = process.cwd()) {
 
 function printHelp() {
   console.log(`
-RepoLens — Repo intelligence CLI
+RepoLens — Repository Intelligence CLI by RABITAI 🐰
 
 Usage:
   repolens <command> [options]
 
 Commands:
-  init        Scaffold RepoLens files in a target repository
-  doctor      Validate a repository's RepoLens setup
+  init        Scaffold RepoLens files in your repository
+  doctor      Validate your RepoLens setup
   migrate     Upgrade workflow files to v0.4.0 format
-  publish     Scan, render, and publish RepoLens outputs
+  publish     Scan, render, and publish documentation
   version     Print the current RepoLens version
 
 Options:
@@ -116,6 +134,15 @@ Examples:
 async function main() {
   const command = process.argv[2];
 
+  // Initialize telemetry (opt-in via REPOLENS_TELEMETRY_ENABLED=true)
+  initTelemetry();
+  setContext("cli", {
+    command: command || "publish",
+    args: process.argv.slice(2),
+    nodeVersion: process.version,
+    platform: process.platform,
+  });
+
   // Check for updates (non-blocking, runs in background)
   checkForUpdates().catch(() => {/* Silently fail */});
 
@@ -134,12 +161,22 @@ async function main() {
     await printBanner();
     const targetDir = getArg("--target") || process.cwd();
     info(`Initializing RepoLens in: ${targetDir}`);
+    
+    const timer = startTimer("init");
     try {
       await runInit(targetDir);
+      const duration = stopTimer(timer);
       info("✓ RepoLens initialized successfully");
+      
+      trackUsage("init", "success", { duration });
+      await closeTelemetry();
     } catch (err) {
+      stopTimer(timer);
+      captureError(err, { command: "init", targetDir });
+      trackUsage("init", "failure");
       error("Failed to initialize RepoLens:");
       error(err.message);
+      await closeTelemetry();
       process.exit(1);
     }
     return;
@@ -149,12 +186,22 @@ async function main() {
     await printBanner();
     const targetDir = getArg("--target") || process.cwd();
     info(`Validating RepoLens setup in: ${targetDir}`);
+    
+    const timer = startTimer("doctor");
     try {
       await runDoctor(targetDir);
+      const duration = stopTimer(timer);
       info("✓ RepoLens validation passed");
+      
+      trackUsage("doctor", "success", { duration });
+      await closeTelemetry();
     } catch (err) {
+      stopTimer(timer);
+      captureError(err, { command: "doctor", targetDir });
+      trackUsage("doctor", "failure");
       error("Validation failed:");
       error(err.message);
+      await closeTelemetry();
       process.exit(2);
     }
     return;
@@ -165,11 +212,25 @@ async function main() {
     const dryRun = process.argv.includes("--dry-run");
     const force = process.argv.includes("--force");
     
+    const timer = startTimer("migrate");
     try {
-      await runMigrate(targetDir, { dryRun, force });
+      const result = await runMigrate(targetDir, { dryRun, force });
+      const duration = stopTimer(timer);
+      
+      trackUsage("migrate", "success", {
+        duration,
+        migratedCount: result?.migratedCount || 0,
+        skippedCount: result?.skippedCount || 0,
+        dryRun,
+      });
+      await closeTelemetry();
     } catch (err) {
+      stopTimer(timer);
+      captureError(err, { command: "migrate", targetDir, dryRun, force });
+      trackUsage("migrate", "failure", { dryRun });
       error("Migration failed:");
       error(err.message);
+      await closeTelemetry();
       process.exit(1);
     }
     return;
@@ -178,12 +239,15 @@ async function main() {
   if (command === "publish" || !command || command.startsWith("--")) {
     await printBanner();
     
+    const commandTimer = startTimer("publish");
+    
     // Auto-discover config if not provided
     let configPath;
     try {
       configPath = getArg("--config") || await findConfig();
       info(`Using config: ${configPath}`);
     } catch (err) {
+      stopTimer(commandTimer);
       error(err.message);
       process.exit(2);
     }
@@ -193,18 +257,28 @@ async function main() {
       info("Loading configuration...");
       cfg = await loadConfig(configPath);
     } catch (err) {
+      stopTimer(commandTimer);
+      captureError(err, { command: "publish", step: "load-config", configPath });
+      trackUsage("publish", "failure", { step: "config-load" });
       error("Failed to load configuration:");
       error(err.message);
+      await closeTelemetry();
       process.exit(2);
     }
 
     try {
       info("Scanning repository...");
+      const scanTimer = startTimer("scan");
       scan = await scanRepo(cfg);
+      stopTimer(scanTimer);
       info(`Detected ${scan.modules?.length || 0} modules`);
     } catch (err) {
+      stopTimer(commandTimer);
+      captureError(err, { command: "publish", step: "scan", patterns: cfg.scan?.patterns });
+      trackUsage("publish", "failure", { step: "scan" });
       error("Failed to scan repository:");
       error(err.message);
+      await closeTelemetry();
       process.exit(1);
     }
 
@@ -213,7 +287,9 @@ async function main() {
 
     try {
       info("Generating documentation set...");
+      const renderTimer = startTimer("render");
       const docSet = await generateDocumentSet(scan, cfg, rawDiff);
+      stopTimer(renderTimer);
       
       info("Writing documentation to disk...");
       const writeResult = await writeDocumentSet(docSet, process.cwd());
@@ -228,15 +304,40 @@ async function main() {
       }
       
       info("Publishing documentation...");
-      await publishDocs(cfg, renderedPages);
+      const publishTimer = startTimer("publish_docs");
+      await publishDocs(cfg, renderedPages, scan);
+      stopTimer(publishTimer);
+      
       await upsertPrComment(diffData);
       info("✓ Documentation published successfully");
+      
+      const totalDuration = stopTimer(commandTimer);
+      
+      // Track successful publish with comprehensive metrics
+      const publishers = [];
+      if (cfg.publishers?.notion?.enabled !== false) publishers.push("notion");
+      if (cfg.publishers?.markdown?.enabled !== false) publishers.push("markdown");
+      
+      trackUsage("publish", "success", {
+        duration: totalDuration,
+        fileCount: scan.filesCount || 0,
+        moduleCount: scan.modules?.length || 0,
+        aiEnabled: Boolean(process.env.REPOLENS_AI_API_KEY || process.env.OPENAI_API_KEY),
+        aiProvider: process.env.AI_PROVIDER || "openai",
+        publishers,
+        documentCount: writeResult.documentCount,
+      });
     } catch (err) {
+      stopTimer(commandTimer);
+      captureError(err, { command: "publish", step: "generate-or-publish", publishers: cfg.publishers });
+      trackUsage("publish", "failure", { step: "generate-or-publish" });
       error("Failed to publish documentation:");
       error(err.message);
+      await closeTelemetry();
       process.exit(1);
     }
 
+    await closeTelemetry();
     return;
   }
 
@@ -245,7 +346,13 @@ async function main() {
   process.exit(1);
 }
 
-main().catch((err) => {
+main().catch(async (err) => {
+  // Capture unexpected errors
+  captureError(err, { 
+    type: "uncaught",
+    command: process.argv[2] || "unknown"
+  });
+  
   console.error("\n❌ RepoLens encountered an unexpected error:\n");
   
   if (err.code === "ENOENT") {
@@ -267,5 +374,6 @@ main().catch((err) => {
     console.error("\nRun with --verbose for full error details.");
   }
   
+  await closeTelemetry();
   process.exit(1);
 });

package/src/core/config-schema.js

@@ -8,7 +8,7 @@
  */
 
 const CURRENT_SCHEMA_VERSION = 1;
-const SUPPORTED_PUBLISHERS = ["notion", "markdown"];
+const SUPPORTED_PUBLISHERS = ["notion", "markdown", "confluence"];
 const SUPPORTED_PAGE_KEYS = [
   "system_overview",
   "module_catalog",
@@ -161,6 +161,48 @@ export function validateConfig(config) {
     }
   }
 
+  // Validate Discord configuration (optional)
+  if (config.discord !== undefined) {
+    if (typeof config.discord !== "object" || Array.isArray(config.discord)) {
+      errors.push("discord must be an object");
+    } else {
+      // Validate notifyOn
+      if (config.discord.notifyOn !== undefined) {
+        const validOptions = ["always", "significant", "never"];
+        if (!validOptions.includes(config.discord.notifyOn)) {
+          errors.push(`discord.notifyOn must be one of: ${validOptions.join(", ")}`);
+        }
+      }
+
+      // Validate significantThreshold
+      if (config.discord.significantThreshold !== undefined) {
+        if (typeof config.discord.significantThreshold !== "number") {
+          errors.push("discord.significantThreshold must be a number");
+        } else if (config.discord.significantThreshold < 0 || config.discord.significantThreshold > 100) {
+          errors.push("discord.significantThreshold must be between 0 and 100");
+        }
+      }
+
+      // Validate branches filter
+      if (config.discord.branches !== undefined) {
+        if (!Array.isArray(config.discord.branches)) {
+          errors.push("discord.branches must be an array");
+        } else {
+          config.discord.branches.forEach((branch, idx) => {
+            if (typeof branch !== "string") {
+              errors.push(`discord.branches[${idx}] must be a string`);
+            }
+          });
+        }
+      }
+
+      // Validate enabled flag
+      if (config.discord.enabled !== undefined && typeof config.discord.enabled !== "boolean") {
+        errors.push("discord.enabled must be a boolean");
+      }
+    }
+  }
+
   // Validate feature flags (optional)
   if (config.features !== undefined) {
     if (typeof config.features !== "object" || Array.isArray(config.features)) {

package/src/core/config.js

@@ -1,15 +1,32 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import yaml from "js-yaml";
-import { validateConfig } from "./config-schema.js";
+import { validateConfig as validateSchema } from "./config-schema.js";
+import { validateConfig } from "../utils/validate.js";
+import { warn, error } from "../utils/logger.js";
 
 export async function loadConfig(configPath) {
   const absoluteConfigPath = path.resolve(configPath);
   const raw = await fs.readFile(absoluteConfigPath, "utf8");
   const cfg = yaml.load(raw);
 
-  // Validate config against schema
-  validateConfig(cfg);
+  // Validate config against schema (structure)
+  validateSchema(cfg);
+  
+  // Validate config for security (injection, secrets, etc.)
+  const securityResult = validateConfig(cfg);
+  
+  // Log warnings
+  if (securityResult.warnings.length > 0) {
+    securityResult.warnings.forEach(w => warn(`Config warning: ${w}`));
+  }
+  
+  // Throw error if invalid
+  if (!securityResult.valid) {
+    error("Configuration validation failed:");
+    securityResult.errors.forEach(e => error(`  - ${e}`));
+    throw new Error(`Invalid configuration: ${securityResult.errors.join(", ")}`);
+  }
 
   cfg.__configPath = absoluteConfigPath;
   cfg.__repoRoot = path.dirname(absoluteConfigPath);