@anirudw/repolens 0.1.0 → 0.1.3

package/dist/index.js

@@ -0,0 +1,934 @@
+#!/usr/bin/env node
+
+// src/cli/commands.ts
+import { Command } from "commander";
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve3 } from "path";
+
+// src/scanner/walker.ts
+import { readdirSync, statSync } from "fs";
+import { join, relative, isAbsolute, resolve } from "path";
+
+// src/scanner/ignore.ts
+import { readFileSync } from "fs";
+import ignore from "ignore";
+var DEFAULT_IGNORES = [
+  "node_modules",
+  "bower_components",
+  "dist",
+  "build",
+  "out",
+  "target",
+  ".git",
+  ".svn",
+  ".hg",
+  ".DS_Store",
+  "Thumbs.db",
+  "*.pyc",
+  "__pycache__",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".next",
+  ".nuxt",
+  ".cache",
+  ".parcel-cache",
+  "coverage",
+  ".nyc_output",
+  ".turbo"
+];
+function createIgnoreRules(rootDir) {
+  const ig = ignore();
+  for (const pattern of DEFAULT_IGNORES) {
+    ig.add(pattern);
+  }
+  const gitignorePath = `${rootDir}/.gitignore`;
+  try {
+    const content = readFileSync(gitignorePath, "utf-8");
+    const rules = content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+    ig.add(rules);
+  } catch {
+  }
+  return ig;
+}
+function shouldIgnore(ig, relativePath, isDirectory) {
+  const pathWithTrailingSlash = isDirectory ? `${relativePath}/` : relativePath;
+  return ig.test(pathWithTrailingSlash).ignored;
+}
+
+// src/scanner/file-types.ts
+var LANGUAGE_EXTENSIONS = {
+  ["javascript" /* JavaScript */]: [".js", ".jsx", ".mjs", ".cjs"],
+  ["typescript" /* TypeScript */]: [".ts", ".tsx", ".mts", ".cts"],
+  ["python" /* Python */]: [".py"],
+  ["java" /* Java */]: [".java"],
+  ["markdown" /* Markdown */]: [".md", ".markdown"],
+  ["unknown" /* Unknown */]: []
+};
+var EXTENSION_TO_LANGUAGE = /* @__PURE__ */ new Map();
+for (const [lang, extensions] of Object.entries(LANGUAGE_EXTENSIONS)) {
+  if (lang !== "unknown" /* Unknown */) {
+    for (const ext of extensions) {
+      EXTENSION_TO_LANGUAGE.set(ext, lang);
+    }
+  }
+}
+function getLanguageFromPath(filePath) {
+  const ext = getExtension(filePath);
+  return EXTENSION_TO_LANGUAGE.get(ext) ?? "unknown" /* Unknown */;
+}
+function getExtension(filePath) {
+  const lastDot = filePath.lastIndexOf(".");
+  if (lastDot === -1) return "";
+  return filePath.slice(lastDot);
+}
+function isTargetLanguage(filePath) {
+  return getLanguageFromPath(filePath) !== "unknown" /* Unknown */;
+}
+
+// src/scanner/walker.ts
+function scanDirectory(options) {
+  const { rootDir, verbose = false } = options;
+  const absoluteRoot = isAbsolute(rootDir) ? rootDir : resolve(rootDir);
+  if (verbose) {
+    console.log(`Scanning directory: ${absoluteRoot}`);
+  }
+  const ig = createIgnoreRules(absoluteRoot);
+  const files = [];
+  let ignoredCount = 0;
+  function walk(dir, baseDir = dir) {
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch (err) {
+      if (verbose) {
+        console.warn(`Warning: Cannot read directory ${dir}: ${err}`);
+      }
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join(dir, entry);
+      const relativePath = relative(baseDir, fullPath);
+      let isDir;
+      try {
+        isDir = statSync(fullPath).isDirectory();
+      } catch (err) {
+        if (verbose) {
+          console.warn(`Warning: Cannot stat ${fullPath}: ${err}`);
+        }
+        continue;
+      }
+      if (shouldIgnore(ig, relativePath, isDir)) {
+        if (!isDir) {
+          ignoredCount++;
+        }
+        continue;
+      }
+      if (isDir) {
+        walk(fullPath, baseDir);
+      } else {
+        if (isTargetLanguage(entry)) {
+          files.push({
+            path: entry,
+            absolutePath: fullPath,
+            relativePath: normalizePath(relativePath),
+            language: getLanguageFromFile(entry)
+          });
+        }
+      }
+    }
+  }
+  walk(absoluteRoot);
+  const filesByLanguage = countByLanguage(files);
+  if (verbose) {
+    console.log(`Found ${files.length} target files`);
+    for (const [lang, count] of Object.entries(filesByLanguage)) {
+      if (count > 0) {
+        console.log(`  ${lang}: ${count}`);
+      }
+    }
+  }
+  return {
+    files,
+    totalFiles: files.length,
+    filesByLanguage,
+    ignoredCount
+  };
+}
+function normalizePath(p) {
+  return p.replace(/\\/g, "/");
+}
+function getLanguageFromFile(filePath) {
+  return getLanguageFromPath(filePath);
+}
+function countByLanguage(files) {
+  const counts = {};
+  for (const file of files) {
+    counts[file.language] = (counts[file.language] ?? 0) + 1;
+  }
+  return counts;
+}
+
+// src/parser/strategies/markdown.ts
+import { remark } from "remark";
+import { visit } from "unist-util-visit";
+var MarkdownParser = class {
+  processor = remark();
+  async parse(filePath, content) {
+    const tree = this.processor.parse(content);
+    const dependencies = [];
+    visit(tree, "link", (node) => {
+      if (node.url) {
+        dependencies.push({
+          rawSpecifier: node.url,
+          type: "markdown-link",
+          location: {
+            line: node.position?.start.line ?? 1,
+            column: node.position?.start.column ?? 1
+          },
+          resolvedPath: this.resolvePath(node.url)
+        });
+      }
+    });
+    const wikilinkRegex = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
+    let match;
+    while ((match = wikilinkRegex.exec(content)) !== null) {
+      const lineInfo = this.getLineNumber(content, match.index);
+      dependencies.push({
+        rawSpecifier: match[1],
+        type: "wikilink",
+        location: {
+          line: lineInfo.line,
+          column: lineInfo.column
+        },
+        resolvedPath: this.resolvePath(match[1])
+      });
+    }
+    return {
+      id: filePath,
+      relativePath: filePath.split("/").pop() ?? filePath,
+      language: "markdown",
+      dependencies,
+      metadata: {
+        sizeBytes: Buffer.byteLength(content, "utf-8"),
+        heuristics: {
+          hasWikilinks: dependencies.some((d) => d.type === "wikilink"),
+          hasExternalLinks: dependencies.some(
+            (d) => d.rawSpecifier.startsWith("http")
+          )
+        }
+      }
+    };
+  }
+  getLineNumber(content, index) {
+    const lines = content.substring(0, index).split("\n");
+    return {
+      line: lines.length,
+      column: (lines[lines.length - 1]?.length ?? 0) + 1
+    };
+  }
+  resolvePath(specifier) {
+    if (specifier.startsWith("http") || specifier.startsWith("//")) {
+      return null;
+    }
+    return specifier;
+  }
+};
+
+// src/parser/strategies/javascript.ts
+var TreeSitterParser;
+var JavaScript;
+async function ensureLoaded() {
+  if (!TreeSitterParser) {
+    const [ts, js] = await Promise.all([
+      import("tree-sitter"),
+      import("tree-sitter-javascript")
+    ]);
+    TreeSitterParser = ts.default;
+    JavaScript = js.default;
+  }
+}
+var JavaScriptParser = class {
+  parser = null;
+  async ensureParser() {
+    if (!this.parser) {
+      await ensureLoaded();
+      this.parser = new TreeSitterParser();
+      this.parser.setLanguage(JavaScript);
+    }
+    return this.parser;
+  }
+  async parse(filePath, content) {
+    const parser = await this.ensureParser();
+    const tree = parser.parse(content);
+    const rootNode = tree.rootNode;
+    const dependencies = [];
+    const imports = /* @__PURE__ */ new Set();
+    const sourceModules = [];
+    this.extractImports(rootNode, dependencies, imports, sourceModules);
+    const heuristics = {};
+    const allImports = [...imports, ...sourceModules].map((s) => s.toLowerCase());
+    heuristics.isReact = allImports.some((i) => i === "react" || i === "@types/react");
+    heuristics.isReactNative = allImports.some((i) => i === "react-native");
+    heuristics.isNodejs = allImports.some((i) => i.startsWith("node:"));
+    heuristics.hasDefaultExport = this.hasDefaultExport(rootNode);
+    heuristics.hasNamedExports = this.hasNamedExports(rootNode);
+    return {
+      id: filePath,
+      relativePath: filePath.split("/").pop() ?? filePath,
+      language: "javascript",
+      dependencies,
+      metadata: {
+        sizeBytes: Buffer.byteLength(content, "utf-8"),
+        heuristics
+      }
+    };
+  }
+  extractImports(node, dependencies, imports, sourceModules) {
+    if (node.type === "import_statement") {
+      this.extractImportStatement(node, dependencies, imports, sourceModules);
+    } else if (node.type === "call_expression" && this.isRequireCall(node)) {
+      this.extractRequireCall(node, dependencies, sourceModules);
+    }
+    for (const child of node.children) {
+      this.extractImports(child, dependencies, imports, sourceModules);
+    }
+  }
+  extractImportStatement(node, dependencies, imports, sourceModules) {
+    const sourceNode = node.childForFieldName("source");
+    if (sourceNode && sourceNode.type === "string") {
+      const rawSpecifier = sourceNode.text.slice(1, -1);
+      sourceModules.push(rawSpecifier);
+      dependencies.push({
+        rawSpecifier,
+        type: "import",
+        location: {
+          line: node.startPosition.row + 1,
+          column: node.startPosition.column + 1
+        },
+        resolvedPath: rawSpecifier
+      });
+    }
+    for (const child of node.children) {
+      if (child.type === "import_specifier") {
+        const nameNode = child.childForFieldName("name");
+        if (nameNode) {
+          imports.add(nameNode.text);
+        }
+      } else if (child.type === "import_default_specifier") {
+        const nameNode = child.childForFieldName("name");
+        if (nameNode) {
+          imports.add(nameNode.text);
+        }
+      } else if (child.type === "import_namespace_specifier") {
+        const nameNode = child.childForFieldName("name");
+        if (nameNode) {
+          imports.add(nameNode.text);
+        }
+      }
+    }
+  }
+  extractRequireCall(node, dependencies, sourceModules) {
+    const args = node.childForFieldName("arguments");
+    if (args) {
+      for (const arg of args.children) {
+        if (arg.type === "string") {
+          const rawSpecifier = arg.text.slice(1, -1);
+          sourceModules.push(rawSpecifier);
+          dependencies.push({
+            rawSpecifier,
+            type: "require",
+            location: {
+              line: node.startPosition.row + 1,
+              column: node.startPosition.column + 1
+            },
+            resolvedPath: rawSpecifier
+          });
+        }
+      }
+    }
+  }
+  isRequireCall(node) {
+    const functionExpr = node.childForFieldName("function");
+    if (!functionExpr) return false;
+    if (functionExpr.type === "identifier" && functionExpr.text === "require") {
+      return true;
+    }
+    if (functionExpr.type === "member_expression") {
+      const object = functionExpr.childForFieldName("object");
+      const property = functionExpr.childForFieldName("property");
+      if (object?.text === "require" && property?.text === "resolve") {
+        return true;
+      }
+    }
+    return false;
+  }
+  hasDefaultExport(node) {
+    if (node.type === "export_statement") {
+      return node.children.some((c) => c.type === "default");
+    }
+    for (const child of node.children) {
+      if (this.hasDefaultExport(child)) return true;
+    }
+    return false;
+  }
+  hasNamedExports(node) {
+    if (node.type === "export_clause") return true;
+    if (node.type === "export_statement") {
+      const hasDefault = node.children.some((c) => c.type === "default");
+      if (hasDefault) return false;
+      return node.children.some(
+        (c) => c.type === "variable_declaration" || c.type === "function_declaration" || c.type === "class_declaration"
+      );
+    }
+    for (const child of node.children) {
+      if (this.hasNamedExports(child)) return true;
+    }
+    return false;
+  }
+};
+
+// src/parser/strategies/python.ts
+var TreeSitterParser2;
+var Python;
+async function ensureLoaded2() {
+  if (!TreeSitterParser2) {
+    const [ts, py] = await Promise.all([
+      import("tree-sitter"),
+      import("tree-sitter-python")
+    ]);
+    TreeSitterParser2 = ts.default;
+    Python = py.default;
+  }
+}
+var PythonParser = class {
+  parser = null;
+  async ensureParser() {
+    if (!this.parser) {
+      await ensureLoaded2();
+      this.parser = new TreeSitterParser2();
+      this.parser.setLanguage(Python);
+    }
+    return this.parser;
+  }
+  async parse(filePath, content) {
+    const parser = await this.ensureParser();
+    const tree = parser.parse(content);
+    const rootNode = tree.rootNode;
+    const dependencies = [];
+    const heuristics = {};
+    this.extractImports(rootNode, dependencies);
+    heuristics.hasEntrypoint = this.detectMainEntrypoint(rootNode);
+    return {
+      id: filePath,
+      relativePath: filePath.split("/").pop() ?? filePath,
+      language: "python",
+      dependencies,
+      metadata: {
+        sizeBytes: Buffer.byteLength(content, "utf-8"),
+        heuristics
+      }
+    };
+  }
+  extractImports(node, dependencies) {
+    if (node.type === "import_statement") {
+      for (const child of node.children) {
+        if (child.type === "dotted_name") {
+          dependencies.push({
+            rawSpecifier: child.text,
+            type: "import",
+            location: {
+              line: node.startPosition.row + 1,
+              column: node.startPosition.column + 1
+            },
+            resolvedPath: child.text
+          });
+        } else if (child.type === "aliased_name") {
+          const dottedName = child.childForFieldName("name");
+          if (dottedName) {
+            dependencies.push({
+              rawSpecifier: dottedName.text,
+              type: "import",
+              location: {
+                line: node.startPosition.row + 1,
+                column: node.startPosition.column + 1
+              },
+              resolvedPath: dottedName.text
+            });
+          }
+        }
+      }
+    } else if (node.type === "import_from_statement") {
+      let moduleName = "";
+      const importedNames = [];
+      let foundImportKeyword = false;
+      for (const child of node.children) {
+        if (child.type === "dotted_name") {
+          if (!foundImportKeyword) {
+            moduleName = child.text;
+          } else {
+            importedNames.push(child.text);
+          }
+        } else if (child.type === "identifier") {
+          if (foundImportKeyword) {
+            importedNames.push(child.text);
+          }
+        } else if (child.type === "import") {
+          foundImportKeyword = true;
+        } else if (child.type === "wildcard_import") {
+          importedNames.push("*");
+        }
+      }
+      if (importedNames.length === 0 && moduleName) {
+        dependencies.push({
+          rawSpecifier: moduleName,
+          type: "import",
+          location: {
+            line: node.startPosition.row + 1,
+            column: node.startPosition.column + 1
+          },
+          resolvedPath: moduleName
+        });
+      } else {
+        for (const name of importedNames) {
+          dependencies.push({
+            rawSpecifier: `${moduleName}.${name}`,
+            type: "import",
+            location: {
+              line: node.startPosition.row + 1,
+              column: node.startPosition.column + 1
+            },
+            resolvedPath: `${moduleName}.${name}`
+          });
+        }
+      }
+    }
+    for (const child of node.children) {
+      this.extractImports(child, dependencies);
+    }
+  }
+  detectMainEntrypoint(node) {
+    if (node.type === "if_statement") {
+      const condition = node.childForFieldName("condition");
+      if (condition && this.isNameEqualsMainCheck(condition)) {
+        return true;
+      }
+    }
+    for (const child of node.children) {
+      if (this.detectMainEntrypoint(child)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  isNameEqualsMainCheck(node) {
+    if (node.type === "comparison_operator") {
+      let hasName = false;
+      let hasMainString = false;
+      for (const child of node.children) {
+        if (child.type === "identifier" && child.text === "__name__") {
+          hasName = true;
+        } else if (child.type === "string") {
+          const innerText = child.text.replace(/['"]/g, "");
+          if (innerText === "__main__") {
+            hasMainString = true;
+          }
+        }
+      }
+      return hasName && hasMainString;
+    }
+    return false;
+  }
+};
+
+// src/parser/strategies/java.ts
+var TreeSitterParser3;
+var Java;
+async function ensureLoaded3() {
+  if (!TreeSitterParser3) {
+    const [ts, j] = await Promise.all([
+      import("tree-sitter"),
+      import("tree-sitter-java")
+    ]);
+    TreeSitterParser3 = ts.default;
+    Java = j.default;
+  }
+}
+var JavaParser = class {
+  parser = null;
+  async ensureParser() {
+    if (!this.parser) {
+      await ensureLoaded3();
+      this.parser = new TreeSitterParser3();
+      this.parser.setLanguage(Java);
+    }
+    return this.parser;
+  }
+  async parse(filePath, content) {
+    const parser = await this.ensureParser();
+    const tree = parser.parse(content);
+    const rootNode = tree.rootNode;
+    const dependencies = [];
+    const heuristics = {};
+    this.extractImports(rootNode, dependencies);
+    heuristics.hasMainMethod = this.detectMainMethod(rootNode);
+    return {
+      id: filePath,
+      relativePath: filePath.split("/").pop() ?? filePath,
+      language: "java",
+      dependencies,
+      metadata: {
+        sizeBytes: Buffer.byteLength(content, "utf-8"),
+        heuristics
+      }
+    };
+  }
+  extractImports(node, dependencies) {
+    if (node.type === "import_declaration") {
+      const importText = this.getScopedIdentifierText(node);
+      if (importText) {
+        dependencies.push({
+          rawSpecifier: importText,
+          type: "import",
+          location: {
+            line: node.startPosition.row + 1,
+            column: node.startPosition.column + 1
+          },
+          resolvedPath: importText
+        });
+      }
+    }
+    for (const child of node.children) {
+      this.extractImports(child, dependencies);
+    }
+  }
+  detectMainMethod(node) {
+    if (node.type === "method_declaration") {
+      const nameNode = this.getChildByType(node, "identifier");
+      const modifiersNode = this.getChildByType(node, "modifiers");
+      if (nameNode?.text === "main") {
+        if (modifiersNode) {
+          const modifierTexts = this.getModifierTexts(modifiersNode);
+          if (modifierTexts.includes("public") && modifierTexts.includes("static")) {
+            return true;
+          }
+        }
+      }
+    }
+    for (const child of node.children) {
+      if (this.detectMainMethod(child)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getChildByType(node, type) {
+    for (const child of node.children) {
+      if (child.type === type) return child;
+    }
+    return null;
+  }
+  getModifierTexts(node) {
+    const modifiers = [];
+    for (const child of node.children) {
+      if (child.type === "public" || child.type === "private" || child.type === "protected" || child.type === "static" || child.type === "final" || child.type === "abstract" || child.type === "synchronized" || child.type === "volatile" || child.type === "transient" || child.type === "native" || child.type === "strictfp") {
+        modifiers.push(child.text);
+      } else if (child.type === "annotation" || child.type === "identifier") {
+        modifiers.push(child.text);
+      }
+    }
+    return modifiers;
+  }
+  getScopedIdentifierText(node) {
+    for (const child of node.children) {
+      if (child.type === "scoped_identifier") {
+        const parts = [];
+        this.collectIdentifiers(child, parts);
+        return parts.join(".");
+      } else if (child.type === "identifier") {
+        return child.text;
+      }
+    }
+    return "";
+  }
+  collectIdentifiers(node, parts) {
+    for (const child of node.children) {
+      if (child.type === "identifier") {
+        parts.push(child.text);
+      } else if (child.type === "scoped_identifier") {
+        this.collectIdentifiers(child, parts);
+      }
+    }
+  }
+};
+
+// src/parser/index.ts
+var JAVASCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".mts", ".cts"]);
+var MARKDOWN_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".markdown"]);
+var PYTHON_EXTENSIONS = /* @__PURE__ */ new Set([".py"]);
+var JAVA_EXTENSIONS = /* @__PURE__ */ new Set([".java"]);
+function createParser(filePath) {
+  const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+  if (JAVASCRIPT_EXTENSIONS.has(ext)) {
+    return new JavaScriptParser();
+  }
+  if (MARKDOWN_EXTENSIONS.has(ext)) {
+    return new MarkdownParser();
+  }
+  if (PYTHON_EXTENSIONS.has(ext)) {
+    return new PythonParser();
+  }
+  if (JAVA_EXTENSIONS.has(ext)) {
+    return new JavaParser();
+  }
+  return null;
+}
+
+// src/graph/network.ts
+import { resolve as resolve2, dirname } from "path";
+var Graph = class {
+  nodes = /* @__PURE__ */ new Map();
+  edges = [];
+  constructor(files) {
+    for (const file of files) {
+      this.nodes.set(file.id, {
+        id: file.id,
+        relativePath: file.relativePath,
+        language: file.language,
+        metadata: file.metadata,
+        inboundEdges: 0,
+        outboundEdges: 0
+      });
+    }
+    this.resolveEdges(files);
+  }
+  resolveEdges(files) {
+    for (const file of files) {
+      const dir = dirname(file.id);
+      for (const dep of file.dependencies) {
+        if (!dep.rawSpecifier) continue;
+        if (dep.rawSpecifier.startsWith("http") || dep.rawSpecifier.startsWith("//") || dep.rawSpecifier.startsWith("#") || !this.isLocalImport(dep.rawSpecifier)) {
+          continue;
+        }
+        const resolvedPath = this.resolveImportPath(
+          dir,
+          dep.rawSpecifier
+        );
+        if (resolvedPath && this.nodes.has(resolvedPath)) {
+          dep.resolvedPath = resolvedPath;
+          this.edges.push({
+            source: file.id,
+            target: resolvedPath,
+            type: dep.type
+          });
+          const targetNode = this.nodes.get(resolvedPath);
+          if (targetNode) {
+            targetNode.inboundEdges++;
+          }
+          const sourceNode = this.nodes.get(file.id);
+          if (sourceNode) {
+            sourceNode.outboundEdges++;
+          }
+        }
+      }
+    }
+  }
+  resolveImportPath(fromDir, specifier) {
+    const candidatePaths = [
+      specifier,
+      `${specifier}.js`,
+      `${specifier}.ts`,
+      `${specifier}.jsx`,
+      `${specifier}.tsx`,
+      `${specifier}/index.js`,
+      `${specifier}/index.ts`,
+      `${specifier}/index.jsx`,
+      `${specifier}/index.tsx`
+    ];
+    for (const candidate of candidatePaths) {
+      try {
+        const fullPath = resolve2(fromDir, candidate);
+        if (this.nodes.has(fullPath)) {
+          return fullPath;
+        }
+      } catch {
+        continue;
+      }
+    }
+    return null;
+  }
+  isLocalImport(specifier) {
+    return specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/");
+  }
+  getNodes() {
+    return this.nodes;
+  }
+  getEdges() {
+    return this.edges;
+  }
+  getNode(id) {
+    return this.nodes.get(id);
+  }
+  getNeighbors(id) {
+    const inbound = [];
+    const outbound = [];
+    for (const edge of this.edges) {
+      if (edge.target === id) {
+        const node = this.nodes.get(edge.source);
+        if (node) inbound.push(node);
+      }
+      if (edge.source === id) {
+        const node = this.nodes.get(edge.target);
+        if (node) outbound.push(node);
+      }
+    }
+    return { inbound, outbound };
+  }
+};
+
+// src/graph/analyzer/pagerank.ts
+function analyzeGraph(graph) {
+  const nodes = graph.getNodes();
+  const ranked = [];
+  for (const [, node] of nodes) {
+    let centrality = node.inboundEdges;
+    if (node.metadata?.heuristics?.isReact) {
+      centrality += 5;
+    }
+    if (node.metadata?.heuristics?.hasMainMethod) {
+      centrality += 5;
+    }
+    ranked.push({
+      ...node,
+      centrality
+    });
+  }
+  ranked.sort((a, b) => b.centrality - a.centrality);
+  return ranked;
+}
+
+// src/renderers/json/exporter.ts
+import { writeFile } from "fs/promises";
+async function exportGraphToJson(graph, parsedFiles, outputPath) {
+  const fileMap = /* @__PURE__ */ new Map();
+  for (const file of parsedFiles) {
+    fileMap.set(file.id, file);
+  }
+  const nodes = [];
+  for (const [nodeId] of graph.getNodes()) {
+    const parsedFile = fileMap.get(nodeId);
+    if (parsedFile) {
+      nodes.push({
+        id: parsedFile.id,
+        relativePath: parsedFile.relativePath,
+        language: parsedFile.language,
+        sizeBytes: parsedFile.metadata.sizeBytes,
+        heuristics: parsedFile.metadata.heuristics
+      });
+    }
+  }
+  const edges = graph.getEdges().map((edge) => ({
+    source: edge.source,
+    target: edge.target,
+    type: edge.type
+  }));
+  const output = { nodes, edges };
+  await writeFile(outputPath, JSON.stringify(output, null, 2));
+}
+
+// src/utils/colors.ts
+import picocolors from "picocolors";
+var pc = {
+  bold: picocolors.bold,
+  dim: picocolors.dim,
+  cyan: picocolors.cyan,
+  yellow: picocolors.yellow,
+  green: picocolors.green,
+  red: picocolors.red,
+  blue: picocolors.blue,
+  magenta: picocolors.magenta,
+  white: picocolors.white
+};
+
+// src/cli/commands.ts
+function createCommand() {
+  const program2 = new Command();
+  program2.name("repolens").description("Visualize repository dependency graphs").version("0.1.0").argument("[path]", "Directory to scan", process.cwd()).option("-v, --verbose", "Enable verbose output", false).option(
+    "-f, --format <format>",
+    "Output format (text, json)",
+    "text"
+  ).option("-o, --output <file>", "Output file path").action(async (path, options) => {
+    const scanResult = scanDirectory({ rootDir: path, verbose: options.verbose });
+    if (options.verbose) {
+      console.log(pc.dim("\nParsing files..."));
+    }
+    const parsedFiles = [];
+    for (const file of scanResult.files) {
+      const parser = createParser(file.absolutePath);
+      if (parser) {
+        try {
+          const content = readFileSync2(file.absolutePath, "utf-8");
+          const parsed = await parser.parse(file.absolutePath, content);
+          parsedFiles.push(parsed);
+        } catch (err) {
+          if (options.verbose) {
+            console.warn(`Warning: Failed to parse ${file.relativePath}: ${err}`);
+          }
+        }
+      }
+    }
+    const graph = new Graph(parsedFiles);
+    const rankedNodes = analyzeGraph(graph);
+    if (options.format === "json") {
+      const outputPath = options.output ?? resolve3(process.cwd(), "repolens-graph.json");
+      await exportGraphToJson(graph, parsedFiles, outputPath);
+      console.log(`Graph exported to ${outputPath}`);
+    } else {
+      printSummary(scanResult, rankedNodes, options.verbose);
+    }
+  });
+  return program2;
+}
+function printSummary(result, rankedNodes, verbose) {
+  console.log(pc.bold("\nRepository Scan Summary\n"));
+  console.log(`Total files found: ${pc.cyan(result.totalFiles.toString())}`);
+  console.log(`Files ignored: ${result.ignoredCount}
+`);
+  console.log(pc.bold("Files by language:"));
+  const langColors = {
+    javascript: pc.yellow,
+    typescript: pc.blue,
+    python: pc.green,
+    java: pc.red,
+    markdown: pc.magenta
+  };
+  for (const [lang, count] of Object.entries(result.filesByLanguage)) {
+    if (count > 0) {
+      const color = langColors[lang] ?? pc.white;
+      console.log(`  ${color(`\u2022 ${lang}`)}: ${pc.bold(count.toString())}`);
+    }
+  }
+  const topHubs = rankedNodes.filter((n) => n.inboundEdges > 0).slice(0, 3);
+  if (topHubs.length > 0) {
+    console.log(pc.bold("\nTop Hubs (Most Connected):"));
+    for (const hub of topHubs) {
+      const badge = hub.metadata?.heuristics?.isReact ? " [React]" : "";
+      console.log(
+        `  ${pc.cyan(hub.relativePath)}${badge}: ${pc.bold(hub.inboundEdges.toString())} inbound`
+      );
+    }
+  }
+  if (verbose && result.files.length > 0) {
+    console.log(pc.bold("\nScanned files:"));
+    for (const file of result.files.slice(0, 50)) {
+      console.log(`  ${pc.dim(file.relativePath)}`);
+    }
+    if (result.files.length > 50) {
+      console.log(`  ${pc.dim(`... and ${result.files.length - 50} more`)}`);
+    }
+  }
+  console.log();
+}
+
+// src/cli/index.ts
+var program = createCommand();
+program.parse(process.argv);