@chappibunny/repolens 0.4.1

package/src/delivery/comment.js

@@ -0,0 +1,139 @@
+import { execSync } from "node:child_process";
+import { log } from "../utils/logger.js";
+import { fetchWithRetry } from "../utils/retry.js";
+
+function safe(text) {
+  return String(text || "").trim();
+}
+
+function buildBody(diff) {
+  const lines = [
+    "## RepoLens — Architecture Summary",
+    "",
+    `**Added files:** ${diff.added.length}`,
+    `**Removed files:** ${diff.removed.length}`,
+    `**Modified files:** ${diff.modified.length}`,
+    `**Added routes:** ${diff.addedRoutes.length}`,
+    `**Removed routes:** ${diff.removedRoutes.length}`,
+    `**Impacted modules:** ${diff.impactedModules.length}`,
+    ""
+  ];
+
+  if (diff.addedRoutes.length) {
+    lines.push("### Added routes", "");
+    for (const route of diff.addedRoutes.slice(0, 10)) {
+      lines.push(`- \`${route}\``);
+    }
+    lines.push("");
+  }
+
+  if (diff.removedRoutes.length) {
+    lines.push("### Removed routes", "");
+    for (const route of diff.removedRoutes.slice(0, 10)) {
+      lines.push(`- \`${route}\``);
+    }
+    lines.push("");
+  }
+
+  if (diff.impactedModules.length) {
+    lines.push("### Impacted modules", "");
+    for (const module of diff.impactedModules.slice(0, 12)) {
+      lines.push(`- \`${module}\``);
+    }
+    lines.push("");
+  }
+
+  lines.push("_Generated by RepoLens_");
+  return lines.join("\n");
+}
+
+async function githubRequest(method, url, body) {
+  const token = process.env.GITHUB_TOKEN;
+  const repo = process.env.GITHUB_REPOSITORY;
+
+  if (!token) throw new Error("Missing GITHUB_TOKEN");
+  if (!repo) throw new Error("Missing GITHUB_REPOSITORY");
+
+  const res = await fetchWithRetry(`https://api.github.com${url}`, {
+    method,
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Accept": "application/vnd.github+json",
+      "Content-Type": "application/json",
+      "User-Agent": "RepoLens"
+    },
+    body: body ? JSON.stringify(body) : undefined
+  }, {
+    retries: 3,
+    baseDelayMs: 500,
+    maxDelayMs: 4000,
+    label: `GitHub ${method} ${url}`
+  });
+
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`GitHub API error ${res.status}: ${text}`);
+  }
+
+  return await res.json();
+}
+
+async function findExistingRepoLensComment(owner, repo, issueNumber) {
+  const comments = await githubRequest(
+    "GET",
+    `/repos/${owner}/${repo}/issues/${issueNumber}/comments`
+  );
+
+  return comments.find((c) =>
+    typeof c.body === "string" && c.body.includes("## RepoLens — Architecture Summary")
+  );
+}
+
+export async function upsertPrComment(diff) {
+  const eventName = process.env.GITHUB_EVENT_NAME;
+  if (eventName !== "pull_request") {
+    log("GITHUB_EVENT_NAME is not 'pull_request', skipping PR comment.");
+    return;
+  }
+
+  const repoFull = process.env.GITHUB_REPOSITORY;
+  const prNumber = process.env.GITHUB_REF_NAME
+    ? undefined
+    : undefined;
+
+  const eventPath = process.env.GITHUB_EVENT_PATH;
+  if (!eventPath) throw new Error("Missing GITHUB_EVENT_PATH");
+
+  const fs = await import("node:fs/promises");
+  const raw = await fs.readFile(eventPath, "utf8");
+  const event = JSON.parse(raw);
+
+  const issueNumber = event?.pull_request?.number;
+  if (!issueNumber) {
+    log("No PR number found, skipping PR comment.");
+    return;
+  }
+
+  const [owner, repo] = repoFull.split("/");
+  const body = buildBody(diff);
+
+  const existing = await findExistingRepoLensComment(owner, repo, issueNumber);
+
+  if (existing) {
+    await githubRequest(
+      "PATCH",
+      `/repos/${owner}/${repo}/issues/comments/${existing.id}`,
+      { body }
+    );
+    log(`Updated existing PR comment ${existing.id}`);
+    return;
+  }
+
+  const created = await githubRequest(
+    "POST",
+    `/repos/${owner}/${repo}/issues/${issueNumber}/comments`,
+    { body }
+  );
+
+  log(`Created PR comment ${created.id}`);
+}// update existing PR comment test

package/src/docs/generate-doc-set.js

@@ -0,0 +1,123 @@
+// Orchestrate generation of complete documentation set
+
+import { buildAIContext, buildModuleContext } from "../analyzers/context-builder.js";
+import { inferDataFlows } from "../analyzers/flow-inference.js";
+import { getActiveDocuments } from "../ai/document-plan.js";
+import {
+  generateExecutiveSummary,
+  generateSystemOverview,
+  generateBusinessDomains,
+  generateArchitectureOverview,
+  generateDataFlows,
+  generateDeveloperOnboarding
+} from "../ai/generate-sections.js";
+import { renderModuleCatalog as renderModuleCatalogOriginal } from "../renderers/render.js";
+import { renderRouteMap as renderRouteMapOriginal } from "../renderers/render.js";
+import { renderApiSurface as renderApiSurfaceOriginal } from "../renderers/render.js";
+import { renderSystemMap } from "../renderers/renderMap.js";
+import { renderArchitectureDiff } from "../renderers/renderDiff.js";
+import { info } from "../utils/logger.js";
+
+export async function generateDocumentSet(scanResult, config, diffData = null) {
+  info("Building structured context for AI...");
+  
+  // Build AI context from scan results
+  const aiContext = buildAIContext(scanResult, config);
+  const moduleContext = buildModuleContext(scanResult.modules, config);
+  const flows = inferDataFlows(scanResult, config);
+  
+  // Get active documents based on config
+  const activeDocuments = getActiveDocuments(config);
+  
+  info(`Generating ${activeDocuments.length} documentation files...`);
+  
+  const documents = [];
+  const artifacts = {
+    context: aiContext,
+    modules: moduleContext,
+    flows
+  };
+  
+  // Generate each document
+  for (const docPlan of activeDocuments) {
+    let content = null;
+    
+    try {
+      content = await generateDocument(docPlan, {
+        scanResult,
+        config,
+        aiContext,
+        moduleContext,
+        flows,
+        diffData
+      });
+      
+      documents.push({
+        ...docPlan,
+        content,
+        generated: new Date().toISOString()
+      });
+      
+      info(`✓ Generated ${docPlan.filename}`);
+      
+    } catch (error) {
+      info(`✗ Failed to generate ${docPlan.filename}: ${error.message}`);
+    }
+  }
+  
+  return {
+    documents,
+    artifacts,
+    config
+  };
+}
+
+async function generateDocument(docPlan, context) {
+  const { key } = docPlan;
+  const { scanResult, config, aiContext, moduleContext, flows, diffData } = context;
+  
+  switch (key) {
+    case "executive_summary":
+      return await generateExecutiveSummary(aiContext);
+      
+    case "system_overview":
+      return await generateSystemOverview(aiContext);
+      
+    case "business_domains":
+      return await generateBusinessDomains(aiContext);
+      
+    case "architecture_overview":
+      return await generateArchitectureOverview(aiContext);
+      
+    case "module_catalog":
+      // Hybrid: deterministic skeleton + AI enhancement (for now, just deterministic)
+      return renderModuleCatalogOriginal(config, scanResult);
+      
+    case "route_map":
+      // Hybrid: deterministic skeleton + AI enhancement (for now, just deterministic)
+      return renderRouteMapOriginal(config, scanResult);
+      
+    case "api_surface":
+      // Hybrid: deterministic skeleton + AI enhancement (for now, just deterministic)
+      return renderApiSurfaceOriginal(config, scanResult);
+      
+    case "data_flows":
+      return await generateDataFlows(flows, aiContext);
+      
+    case "arch_diff":
+      if (!diffData) {
+        return "# Architecture Diff\n\nNo changes detected.";
+      }
+      return renderArchitectureDiff(diffData);
+      
+    case "system_map":
+      // Hybrid: deterministic diagram + AI explanation (for now, just diagram)
+      return renderSystemMap(scanResult, config);
+      
+    case "developer_onboarding":
+      return await generateDeveloperOnboarding(aiContext);
+      
+    default:
+      throw new Error(`Unknown document type: ${key}`);
+  }
+}

package/src/docs/write-doc-set.js

@@ -0,0 +1,85 @@
+// Write generated documentation set to disk
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { info } from "../utils/logger.js";
+
+export async function writeDocumentSet(docSet, targetDir = process.cwd()) {
+  const { documents, artifacts, config } = docSet;
+  
+  // Determine output directory
+  const outputDir = path.join(
+    targetDir, 
+    config.documentation?.output_dir || ".repolens"
+  );
+  
+  // Create output directory
+  await fs.mkdir(outputDir, { recursive: true });
+  
+  info(`Writing documentation to ${outputDir}`);
+  
+  // Write each document
+  for (const doc of documents) {
+    const filePath = path.join(outputDir, doc.filename);
+    await fs.writeFile(filePath, doc.content, "utf8");
+    info(`✓ Wrote ${doc.filename}`);
+  }
+  
+  // Write artifacts if enabled
+  if (config.documentation?.include_artifacts !== false) {
+    const artifactsDir = path.join(outputDir, "artifacts");
+    await fs.mkdir(artifactsDir, { recursive: true });
+    
+    // Write AI context
+    await fs.writeFile(
+      path.join(artifactsDir, "ai-context.json"),
+      JSON.stringify(artifacts.context, null, 2),
+      "utf8"
+    );
+    
+    // Write module context
+    await fs.writeFile(
+      path.join(artifactsDir, "modules.json"),
+      JSON.stringify(artifacts.modules, null, 2),
+      "utf8"
+    );
+    
+    // Write flows
+    await fs.writeFile(
+      path.join(artifactsDir, "flows.json"),
+      JSON.stringify(artifacts.flows, null, 2),
+      "utf8"
+    );
+    
+    info(`✓ Wrote artifacts to artifacts/`);
+  }
+  
+  info(`Documentation written successfully to ${outputDir}`);
+  
+  return {
+    outputDir,
+    documentCount: documents.length,
+    files: documents.map(d => d.filename)
+  };
+}
+
+export async function readPreviousDocumentSet(targetDir = process.cwd(), config) {
+  const outputDir = path.join(
+    targetDir,
+    config.documentation?.output_dir || ".repolens"
+  );
+  
+  try {
+    const artifactsDir = path.join(outputDir, "artifacts");
+    
+    const contextData = await fs.readFile(
+      path.join(artifactsDir, "ai-context.json"),
+      "utf8"
+    );
+    
+    return JSON.parse(contextData);
+    
+  } catch (error) {
+    return null;
+  }
+}

package/src/doctor.js

@@ -0,0 +1,174 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { loadConfig } from "./core/config.js";
+import { info } from "./utils/logger.js";
+import { forceCheckForUpdates } from "./utils/update-check.js";
+
+const DETECTABLE_ROOTS = [
+  "app",
+  "src/app",
+  "components",
+  "src/components",
+  "lib",
+  "src/lib",
+  "hooks",
+  "src/hooks",
+  "store",
+  "src/store",
+  "pages",
+  "src/pages"
+];
+
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function dirExists(dirPath) {
+  try {
+    const stat = await fs.stat(dirPath);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+async function detectRepoRoots(repoRoot) {
+  const found = [];
+
+  for (const relativePath of DETECTABLE_ROOTS) {
+    const absolutePath = path.join(repoRoot, relativePath);
+    if (await dirExists(absolutePath)) {
+      found.push(relativePath);
+    }
+  }
+
+  return found;
+}
+
+function ok(message) {
+  info(`✅ ${message}`);
+}
+
+function fail(message) {
+  info(`❌ ${message}`);
+}
+
+function warn(message) {
+  info(`⚠️  ${message}`);
+}
+
+export async function runDoctor(targetDir = process.cwd()) {
+  const repoRoot = path.resolve(targetDir);
+
+  const repolensConfigPath = path.join(repoRoot, ".repolens.yml");
+  const workflowPath = path.join(repoRoot, ".github", "workflows", "repolens.yml");
+  const envExamplePath = path.join(repoRoot, ".env.example");
+  const readmePath = path.join(repoRoot, "README.repolens.md");
+
+  let hasFailures = false;
+
+  info(`Running doctor for ${repoRoot}`);
+  info("");
+  
+  // Check for RepoLens version updates
+  info("Version Check:");
+  info("");
+  await forceCheckForUpdates();
+  info("");
+
+  if (await fileExists(repolensConfigPath)) {
+    ok("Found .repolens.yml");
+  } else {
+    fail("Missing .repolens.yml");
+    hasFailures = true;
+  }
+
+  if (await fileExists(workflowPath)) {
+    ok("Found .github/workflows/repolens.yml");
+  } else {
+    fail("Missing .github/workflows/repolens.yml");
+    hasFailures = true;
+  }
+
+  if (await fileExists(envExamplePath)) {
+    ok("Found .env.example");
+  } else {
+    warn("Missing .env.example");
+  }
+
+  if (await fileExists(readmePath)) {
+    ok("Found README.repolens.md");
+  } else {
+    warn("Missing README.repolens.md");
+  }
+
+  info("");
+
+  let cfg = null;
+
+  if (await fileExists(repolensConfigPath)) {
+    try {
+      cfg = await loadConfig(repolensConfigPath);
+      ok("RepoLens config parsed successfully");
+    } catch (error) {
+      fail(`RepoLens config is invalid: ${error.message}`);
+      hasFailures = true;
+    }
+  }
+
+  if (cfg) {
+    if (Array.isArray(cfg.publishers) && cfg.publishers.length > 0) {
+      ok(`Configured publishers: ${cfg.publishers.join(", ")}`);
+    } else {
+      fail("No publishers configured");
+      hasFailures = true;
+    }
+
+    if (Array.isArray(cfg.scan?.include) && cfg.scan.include.length > 0) {
+      ok(`scan.include has ${cfg.scan.include.length} pattern(s)`);
+    } else {
+      fail("scan.include is missing or empty");
+      hasFailures = true;
+    }
+
+    if (Array.isArray(cfg.module_roots) && cfg.module_roots.length > 0) {
+      ok(`module_roots has ${cfg.module_roots.length} item(s)`);
+    } else {
+      fail("module_roots is missing or empty");
+      hasFailures = true;
+    }
+
+    if (Array.isArray(cfg.outputs?.pages) && cfg.outputs.pages.length > 0) {
+      ok(`outputs.pages has ${cfg.outputs.pages.length} page definition(s)`);
+    } else {
+      fail("outputs.pages is missing or empty");
+      hasFailures = true;
+    }
+  }
+
+  info("");
+
+  const detectedRoots = await detectRepoRoots(repoRoot);
+
+  if (detectedRoots.length > 0) {
+    ok(`Detected repo roots: ${detectedRoots.join(", ")}`);
+  } else {
+    warn("No known repo roots detected (app/src/components/lib/hooks/store/pages)");
+  }
+
+  info("");
+
+  if (hasFailures) {
+    fail("RepoLens doctor found blocking issues.");
+    process.exitCode = 1;
+    return { ok: false };
+  }
+
+  ok("RepoLens doctor passed.");
+  return { ok: true };
+}