@chappibunny/repolens 0.4.1

package/src/analyzers/flow-inference.js

@@ -0,0 +1,198 @@
+// Infer data flows through the application using heuristics
+
+export function inferDataFlows(scanResult, config) {
+  const flows = [];
+  
+  // Stock/Market Data Flow (if applicable)
+  const marketFlow = inferMarketDataFlow(scanResult);
+  if (marketFlow) flows.push(marketFlow);
+  
+  // Authentication Flow
+  const authFlow = inferAuthFlow(scanResult);
+  if (authFlow) flows.push(authFlow);
+  
+  // Content/Article Flow
+  const contentFlow = inferContentFlow(scanResult);
+  if (contentFlow) flows.push(contentFlow);
+  
+  // API Integration Flow
+  const apiFlow = inferApiIntegrationFlow(scanResult);
+  if (apiFlow) flows.push(apiFlow);
+  
+  return flows;
+}
+
+function inferMarketDataFlow(scanResult) {
+  const { modules, pages, api } = scanResult;
+  
+  const hasStockModules = modules.some(m => 
+    m.key.toLowerCase().includes("stock") || 
+    m.key.toLowerCase().includes("market") ||
+    m.key.toLowerCase().includes("chart")
+  );
+  
+  const hasStockPages = pages?.some(p => 
+    p.path.includes("stock") || 
+    p.path.includes("market")
+  );
+  
+  const hasStockApis = api?.some(a => 
+    a.path.includes("price") || 
+    a.path.includes("stock") ||
+    a.path.includes("market")
+  );
+  
+  if (!hasStockModules && !hasStockPages && !hasStockApis) return null;
+  
+  return {
+    name: "Market Data Flow",
+    description: "User requests stock data, which flows through UI components to market data services",
+    steps: [
+      "User visits stock analysis page",
+      "Page component loads stock-specific UI",
+      "Components request data from stock libraries",
+      "Libraries fetch from market data APIs",
+      "Data is transformed and displayed to user"
+    ],
+    modules: modules.filter(m => 
+      m.key.toLowerCase().includes("stock") || 
+      m.key.toLowerCase().includes("market") ||
+      m.key.toLowerCase().includes("chart")
+    ).map(m => m.key),
+    critical: true
+  };
+}
+
+function inferAuthFlow(scanResult) {
+  const { modules, pages, api } = scanResult;
+  
+  const hasAuthModules = modules.some(m => 
+    m.key.toLowerCase().includes("auth") || 
+    m.key.toLowerCase().includes("login") ||
+    m.key.toLowerCase().includes("session")
+  );
+  
+  const hasAuthPages = pages?.some(p => 
+    p.path.includes("login") || 
+    p.path.includes("signup") ||
+    p.path.includes("auth")
+  );
+  
+  const hasAuthApis = api?.some(a => 
+    a.path.includes("auth") || 
+    a.path.includes("login") ||
+    a.path.includes("session")
+  );
+  
+  if (!hasAuthModules && !hasAuthPages && !hasAuthApis) return null;
+  
+  return {
+    name: "Authentication Flow",
+    description: "User authentication and session management",
+    steps: [
+      "User submits login credentials",
+      "Auth API validates credentials",
+      "Session is created and stored",
+      "User is redirected to authenticated area",
+      "Subsequent requests include auth token"
+    ],
+    modules: modules.filter(m => 
+      m.key.toLowerCase().includes("auth") || 
+      m.key.toLowerCase().includes("login") ||
+      m.key.toLowerCase().includes("session")
+    ).map(m => m.key),
+    critical: true
+  };
+}
+
+function inferContentFlow(scanResult) {
+  const { modules, pages, api } = scanResult;
+  
+  const hasContentModules = modules.some(m => 
+    m.key.toLowerCase().includes("article") || 
+    m.key.toLowerCase().includes("content") ||
+    m.key.toLowerCase().includes("newsletter") ||
+    m.key.toLowerCase().includes("blog")
+  );
+  
+  const hasContentPages = pages?.some(p => 
+    p.path.includes("article") || 
+    p.path.includes("news") ||
+    p.path.includes("blog")
+  );
+  
+  if (!hasContentModules && !hasContentPages) return null;
+  
+  return {
+    name: "Content Delivery Flow",
+    description: "Research articles and content are fetched and displayed to users",
+    steps: [
+      "User browses content sections",
+      "Content components load articles",
+      "Articles may be fetched from CMS or database",
+      "Content is rendered with formatting",
+      "User can interact with content features"
+    ],
+    modules: modules.filter(m => 
+      m.key.toLowerCase().includes("article") || 
+      m.key.toLowerCase().includes("content") ||
+      m.key.toLowerCase().includes("newsletter")
+    ).map(m => m.key),
+    critical: false
+  };
+}
+
+function inferApiIntegrationFlow(scanResult) {
+  const { api } = scanResult;
+  
+  if (!api || api.length === 0) return null;
+  
+  return {
+    name: "API Integration Flow",
+    description: "External service integrations and backend processing",
+    steps: [
+      "Frontend makes API request",
+      "API route receives and validates request",
+      "Business logic is executed",
+      "External services may be called",
+      "Response is formatted and returned"
+    ],
+    modules: [`${api.length} API endpoints detected`],
+    critical: false
+  };
+}
+
+export function identifyFlowDependencies(flow, scanResult) {
+  // Simple heuristic: modules in flow likely depend on each other
+  // and on shared libraries
+  const { modules } = scanResult;
+  
+  const libModules = modules.filter(m => 
+    m.key.toLowerCase().includes("lib") || 
+    m.key.toLowerCase().includes("util")
+  );
+  
+  return {
+    internalDependencies: flow.modules,
+    sharedLibraries: libModules.slice(0, 5).map(m => m.key),
+    externalDependencies: inferExternalDependencies(flow)
+  };
+}
+
+function inferExternalDependencies(flow) {
+  const external = [];
+  
+  if (flow.name.includes("Market") || flow.name.includes("Stock")) {
+    external.push("Market data provider API");
+  }
+  
+  if (flow.name.includes("Auth")) {
+    external.push("Authentication service");
+  }
+  
+  if (flow.name.includes("Content")) {
+    external.push("Content management system");
+  }
+  
+  return external;
+}

package/src/cli.js

@@ -0,0 +1,271 @@
+import "dotenv/config";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadConfig } from "./core/config.js";
+import { scanRepo } from "./core/scan.js";
+import { getGitDiff } from "./core/diff.js";
+import { runDoctor } from "./doctor.js";
+
+import {
+  renderSystemOverview,
+  renderModuleCatalog,
+  renderApiSurface,
+  renderRouteMap
+} from "./renderers/render.js";
+import { renderSystemMap } from "./renderers/renderMap.js";
+import { renderArchitectureDiff, buildArchitectureDiffData } from "./renderers/renderDiff.js";
+
+import { publishDocs } from "./publishers/index.js";
+import { upsertPrComment } from "./delivery/comment.js";
+import { runInit } from "./init.js";
+import { runMigrate } from "./migrate.js";
+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";
+
+async function getPackageVersion() {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  const packageJsonPath = path.resolve(__dirname, "../package.json");
+
+  const raw = await fs.readFile(packageJsonPath, "utf8");
+  const pkg = JSON.parse(raw);
+
+  return pkg.version || "0.0.0";
+}
+
+async function printBanner() {
+  const version = await getPackageVersion();
+  console.log(`\nRepoLens v${version}`);
+  console.log("─".repeat(40));
+}
+
+function getArg(name) {
+  const index = process.argv.indexOf(name);
+  return index >= 0 ? process.argv[index + 1] : undefined;
+}
+
+/**
+ * Auto-discover .repolens.yml starting from current directory
+ * Searches upward through parent directories until found or root reached
+ */
+async function findConfig(startDir = process.cwd()) {
+  let currentDir = path.resolve(startDir);
+  const root = path.parse(currentDir).root;
+
+  while (currentDir !== root) {
+    const configPath = path.join(currentDir, ".repolens.yml");
+    try {
+      await fs.access(configPath);
+      return configPath;
+    } catch {
+      // Config not found, try parent directory
+      currentDir = path.dirname(currentDir);
+    }
+  }
+
+  // Check root directory as final attempt
+  const rootConfigPath = path.join(root, ".repolens.yml");
+  try {
+    await fs.access(rootConfigPath);
+    return rootConfigPath;
+  } catch {
+    throw new Error(
+      "RepoLens config not found (.repolens.yml)\n" +
+      "Run 'repolens init' to create one, or use --config to specify a path."
+    );
+  }
+}
+
+function printHelp() {
+  console.log(`
+RepoLens — Repo intelligence CLI
+
+Usage:
+  repolens <command> [options]
+
+Commands:
+  init        Scaffold RepoLens files in a target repository
+  doctor      Validate a repository's RepoLens setup
+  migrate     Upgrade workflow files to v0.4.0 format
+  publish     Scan, render, and publish RepoLens outputs
+  version     Print the current RepoLens version
+
+Options:
+  --config     Path to .repolens.yml (auto-discovered if not provided)
+  --target     Target repository path for init/doctor/migrate
+  --dry-run    Preview migration changes without applying them
+  --force      Skip interactive confirmation for migration
+  --verbose    Enable verbose logging
+  --version    Print version
+  --help       Show this help message
+
+Examples:
+  repolens init --target /tmp/my-repo
+  repolens doctor --target /tmp/my-repo
+  repolens migrate                              # Migrate workflows in current directory
+  repolens migrate --dry-run                    # Preview changes without applying
+  repolens publish                              # Auto-discovers .repolens.yml
+  repolens publish --config /path/.repolens.yml # Explicit config path
+  repolens --version
+`);
+}
+
+async function main() {
+  const command = process.argv[2];
+
+  // Check for updates (non-blocking, runs in background)
+  checkForUpdates().catch(() => {/* Silently fail */});
+
+  if (command === "--help" || command === "-h" || command === "help") {
+    printHelp();
+    return;
+  }
+
+  if (command === "--version" || command === "-v" || command === "version") {
+    const version = await getPackageVersion();
+    console.log(version);
+    return;
+  }
+
+  if (command === "init") {
+    await printBanner();
+    const targetDir = getArg("--target") || process.cwd();
+    info(`Initializing RepoLens in: ${targetDir}`);
+    try {
+      await runInit(targetDir);
+      info("✓ RepoLens initialized successfully");
+    } catch (err) {
+      error("Failed to initialize RepoLens:");
+      error(err.message);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (command === "doctor") {
+    await printBanner();
+    const targetDir = getArg("--target") || process.cwd();
+    info(`Validating RepoLens setup in: ${targetDir}`);
+    try {
+      await runDoctor(targetDir);
+      info("✓ RepoLens validation passed");
+    } catch (err) {
+      error("Validation failed:");
+      error(err.message);
+      process.exit(2);
+    }
+    return;
+  }
+
+  if (command === "migrate") {
+    const targetDir = getArg("--target") || process.cwd();
+    const dryRun = process.argv.includes("--dry-run");
+    const force = process.argv.includes("--force");
+    
+    try {
+      await runMigrate(targetDir, { dryRun, force });
+    } catch (err) {
+      error("Migration failed:");
+      error(err.message);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (command === "publish" || !command || command.startsWith("--")) {
+    await printBanner();
+    
+    // Auto-discover config if not provided
+    let configPath;
+    try {
+      configPath = getArg("--config") || await findConfig();
+      info(`Using config: ${configPath}`);
+    } catch (err) {
+      error(err.message);
+      process.exit(2);
+    }
+
+    let cfg, scan;
+    try {
+      info("Loading configuration...");
+      cfg = await loadConfig(configPath);
+    } catch (err) {
+      error("Failed to load configuration:");
+      error(err.message);
+      process.exit(2);
+    }
+
+    try {
+      info("Scanning repository...");
+      scan = await scanRepo(cfg);
+      info(`Detected ${scan.modules?.length || 0} modules`);
+    } catch (err) {
+      error("Failed to scan repository:");
+      error(err.message);
+      process.exit(1);
+    }
+
+    const rawDiff = getGitDiff("origin/main");
+    const diffData = buildArchitectureDiffData(rawDiff);
+
+    try {
+      info("Generating documentation set...");
+      const docSet = await generateDocumentSet(scan, cfg, rawDiff);
+      
+      info("Writing documentation to disk...");
+      const writeResult = await writeDocumentSet(docSet, process.cwd());
+      info(`✓ Generated ${writeResult.documentCount} documents in ${writeResult.outputDir}`);
+      
+      // Build legacy renderedPages format for Notion publishing
+      const renderedPages = {};
+      for (const doc of docSet.documents) {
+        // Map new document keys to legacy keys for backwards compatibility
+        const legacyKey = doc.key;
+        renderedPages[legacyKey] = doc.content;
+      }
+      
+      info("Publishing documentation...");
+      await publishDocs(cfg, renderedPages);
+      await upsertPrComment(diffData);
+      info("✓ Documentation published successfully");
+    } catch (err) {
+      error("Failed to publish documentation:");
+      error(err.message);
+      process.exit(1);
+    }
+
+    return;
+  }
+
+  error(`Unknown command: ${command}`);
+  error("Available commands: init, doctor, migrate, publish, version, help");
+  process.exit(1);
+}
+
+main().catch((err) => {
+  console.error("\n❌ RepoLens encountered an unexpected error:\n");
+  
+  if (err.code === "ENOENT") {
+    error(`File not found: ${err.path}`);
+    error("Check that all required files exist and paths are correct.");
+  } else if (err.code === "EACCES") {
+    error(`Permission denied: ${err.path}`);
+    error("Check file permissions and try again.");
+  } else if (err.message) {
+    error(err.message);
+  } else {
+    error(err);
+  }
+  
+  if (process.env.VERBOSE || process.argv.includes("--verbose")) {
+    console.error("\nStack trace:");
+    console.error(err.stack);
+  } else {
+    console.error("\nRun with --verbose for full error details.");
+  }
+  
+  process.exit(1);
+});