@vpxa/kb 0.1.1

package/packages/analyzers/dist/regex-call-graph.js

@@ -0,0 +1,428 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { extname, join, relative } from "node:path";
+const SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "coverage",
+  ".turbo",
+  ".cache",
+  "cdk.out",
+  ".venv",
+  "venv",
+  "__pycache__",
+  "target",
+  "vendor",
+  "bin",
+  "obj"
+]);
+const CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".java",
+  ".py",
+  ".go",
+  ".cs",
+  ".kt",
+  ".scala",
+  ".rs",
+  ".rb",
+  ".php",
+  ".swift"
+]);
+async function extractRegexCallGraph(rootPath) {
+  const startTime = Date.now();
+  const files = collectFiles(rootPath);
+  if (files.length === 0) return null;
+  const cappedFiles = files.slice(0, 800);
+  const fileImports = /* @__PURE__ */ new Map();
+  const moduleExports = /* @__PURE__ */ new Map();
+  for (const fullPath of cappedFiles) {
+    const relPath = relative(rootPath, fullPath).replace(/\\/g, "/");
+    const content = readFileSync(fullPath, "utf-8");
+    const ext = extname(fullPath).toLowerCase();
+    const imports = parseImports(content, ext);
+    fileImports.set(relPath, imports);
+    const exports = parseExports(content, ext);
+    moduleExports.set(relPath, exports);
+  }
+  const stemToFiles = buildStemLookup(cappedFiles, rootPath);
+  const edgeMap = /* @__PURE__ */ new Map();
+  for (const [callerRel, imports] of fileImports) {
+    if (isTestPath(callerRel)) continue;
+    const callerContent = readFileSync(join(rootPath, callerRel), "utf-8");
+    const bodyContent = stripImportLines(callerContent, extname(callerRel));
+    for (const imp of imports) {
+      if (!imp.isRelative) continue;
+      const targetPaths = resolveImportPath(callerRel, imp.source, stemToFiles, extname(callerRel));
+      if (targetPaths.length === 0) continue;
+      const targetRel = targetPaths[0];
+      if (isTestPath(targetRel)) continue;
+      if (callerRel === targetRel) continue;
+      let usedSymbols;
+      if (imp.symbols.length > 0) {
+        usedSymbols = imp.symbols.filter((sym) => {
+          const regex = new RegExp(`\\b${escapeRegex(sym)}\\b`);
+          return regex.test(bodyContent);
+        });
+      } else {
+        usedSymbols = ["*"];
+      }
+      if (usedSymbols.length === 0) continue;
+      const edgeKey = `${callerRel}|${targetRel}`;
+      const existing = edgeMap.get(edgeKey);
+      if (existing) {
+        for (const s of usedSymbols) existing.add(s);
+      } else {
+        edgeMap.set(edgeKey, new Set(usedSymbols));
+      }
+    }
+  }
+  const edges = [];
+  for (const [key, syms] of edgeMap) {
+    const [from, to] = key.split("|");
+    edges.push({ from, to, symbols: [...syms].sort().slice(0, 10) });
+  }
+  edges.sort((a, b) => b.symbols.length - a.symbols.length);
+  return {
+    edges,
+    fileCount: cappedFiles.length,
+    edgeCount: edges.length,
+    durationMs: Date.now() - startTime
+  };
+}
+function parseImports(content, ext) {
+  const imports = [];
+  switch (ext) {
+    case ".ts":
+    case ".tsx":
+    case ".js":
+    case ".jsx": {
+      const esNamed = /import\s+(?:type\s+)?\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/g;
+      let m;
+      while ((m = esNamed.exec(content)) !== null) {
+        const symbols = m[1].split(",").map((s) => {
+          const parts = s.trim().split(/\s+as\s+/);
+          return (parts[parts.length - 1] || "").trim();
+        }).filter(Boolean);
+        imports.push({ source: m[2], symbols, isRelative: m[2].startsWith(".") });
+      }
+      const esDefault = /import\s+(\w+)\s+from\s+['"]([^'"]+)['"]/g;
+      while ((m = esDefault.exec(content)) !== null) {
+        if (m[1] === "type") continue;
+        imports.push({ source: m[2], symbols: [m[1]], isRelative: m[2].startsWith(".") });
+      }
+      const cjsNamed = /(?:const|let|var)\s+\{([^}]+)\}\s*=\s*require\(\s*['"]([^'"]+)['"]\s*\)/g;
+      while ((m = cjsNamed.exec(content)) !== null) {
+        const symbols = m[1].split(",").map((s) => s.trim().split(":")[0].trim()).filter(Boolean);
+        imports.push({ source: m[2], symbols, isRelative: m[2].startsWith(".") });
+      }
+      break;
+    }
+    case ".java":
+    case ".kt":
+    case ".scala": {
+      const javaImport = /^import\s+(?:static\s+)?([\w.]+)\s*;/gm;
+      let m;
+      while ((m = javaImport.exec(content)) !== null) {
+        const parts = m[1].split(".");
+        const lastPart = parts[parts.length - 1];
+        if (lastPart === "*") {
+          imports.push({
+            source: m[1],
+            symbols: [],
+            isRelative: isInternalJavaImport(m[1], content)
+          });
+        } else {
+          imports.push({
+            source: m[1],
+            symbols: [lastPart],
+            isRelative: isInternalJavaImport(m[1], content)
+          });
+        }
+      }
+      break;
+    }
+    case ".py": {
+      const fromImport = /^from\s+([\w.]+)\s+import\s+(.+)$/gm;
+      let m;
+      while ((m = fromImport.exec(content)) !== null) {
+        const symbols = m[2].split(",").map((s) => {
+          const parts = s.trim().split(/\s+as\s+/);
+          return (parts[parts.length - 1] || "").trim();
+        }).filter((s) => s && s !== "(");
+        imports.push({ source: m[1], symbols, isRelative: m[1].startsWith(".") });
+      }
+      const plainImport = /^import\s+([\w.]+)(?:\s+as\s+(\w+))?\s*$/gm;
+      while ((m = plainImport.exec(content)) !== null) {
+        const pyParts = m[1].split(".");
+        const alias = m[2] || pyParts[pyParts.length - 1];
+        imports.push({ source: m[1], symbols: [alias], isRelative: m[1].startsWith(".") });
+      }
+      break;
+    }
+    case ".go": {
+      const goSingle = /import\s+(?:(\w+)\s+)?[""]([^""]+)[""]/g;
+      let m;
+      while ((m = goSingle.exec(content)) !== null) {
+        const goParts = m[2].split("/");
+        const alias = m[1] || goParts[goParts.length - 1];
+        imports.push({
+          source: m[2],
+          symbols: [alias],
+          isRelative: !m[2].includes(".") && !m[2].startsWith("github.com")
+        });
+      }
+      const goBlock = /import\s*\(([\s\S]*?)\)/g;
+      while ((m = goBlock.exec(content)) !== null) {
+        const blockContent = m[1];
+        const lineRe = /(?:(\w+)\s+)?[""]([^""]+)[""]/g;
+        let lm;
+        while ((lm = lineRe.exec(blockContent)) !== null) {
+          const blockParts = lm[2].split("/");
+          const alias = lm[1] || blockParts[blockParts.length - 1];
+          imports.push({
+            source: lm[2],
+            symbols: [alias],
+            isRelative: !lm[2].includes(".") && !lm[2].startsWith("github.com")
+          });
+        }
+      }
+      break;
+    }
+    case ".cs": {
+      const csUsing = /^using\s+(?:static\s+)?([\w.]+)\s*;/gm;
+      let m;
+      while ((m = csUsing.exec(content)) !== null) {
+        const parts = m[1].split(".");
+        imports.push({ source: m[1], symbols: [parts[parts.length - 1]], isRelative: true });
+      }
+      break;
+    }
+    case ".rs": {
+      const rsUse = /^use\s+([\w:]+(?:::\w+)*)/gm;
+      let m;
+      while ((m = rsUse.exec(content)) !== null) {
+        const parts = m[1].split("::");
+        const lastPart = parts[parts.length - 1];
+        imports.push({
+          source: m[1],
+          symbols: lastPart === "*" ? [] : [lastPart],
+          isRelative: m[1].startsWith("crate") || m[1].startsWith("super")
+        });
+      }
+      break;
+    }
+  }
+  return imports;
+}
+function parseExports(content, ext) {
+  const exports = /* @__PURE__ */ new Set();
+  switch (ext) {
+    case ".ts":
+    case ".tsx":
+    case ".js":
+    case ".jsx": {
+      const exportPattern = /export\s+(?:default\s+)?(?:abstract\s+)?(?:async\s+)?(?:function|class|const|let|var|type|interface|enum)\s+(\w+)/g;
+      let m;
+      while ((m = exportPattern.exec(content)) !== null) exports.add(m[1]);
+      break;
+    }
+    case ".java":
+    case ".kt":
+    case ".scala": {
+      const javaPattern = /(?:public|protected)\s+(?:static\s+)?(?:abstract\s+)?(?:final\s+)?(?:class|interface|enum|record|@interface)\s+(\w+)/g;
+      let m;
+      while ((m = javaPattern.exec(content)) !== null) exports.add(m[1]);
+      const methodPattern = /(?:public|protected)\s+(?:static\s+)?(?:abstract\s+)?(?:final\s+)?\w+(?:<[^>]+>)?\s+(\w+)\s*\(/g;
+      while ((m = methodPattern.exec(content)) !== null) {
+        if (![
+          "if",
+          "for",
+          "while",
+          "switch",
+          "catch",
+          "return",
+          "class",
+          "interface",
+          "enum",
+          "new"
+        ].includes(m[1])) {
+          exports.add(m[1]);
+        }
+      }
+      break;
+    }
+    case ".py": {
+      const pyPattern = /^(?:def|class)\s+([A-Z_]\w*)/gm;
+      let m;
+      while ((m = pyPattern.exec(content)) !== null) {
+        if (!m[1].startsWith("_")) exports.add(m[1]);
+      }
+      break;
+    }
+    case ".go": {
+      const goPattern = /^(?:func|type|var|const)\s+(\(?[A-Z]\w*)/gm;
+      let m;
+      while ((m = goPattern.exec(content)) !== null) exports.add(m[1].replace("(", ""));
+      break;
+    }
+  }
+  return exports;
+}
+function isInternalJavaImport(importPath, fileContent) {
+  const pkgMatch = fileContent.match(/^package\s+([\w.]+)\s*;/m);
+  if (!pkgMatch) return false;
+  const filePkg = pkgMatch[1];
+  const fileParts = filePkg.split(".");
+  const importParts = importPath.split(".");
+  return fileParts.length >= 2 && importParts.length >= 2 && fileParts[0] === importParts[0] && fileParts[1] === importParts[1];
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function stripImportLines(content, ext) {
+  switch (ext) {
+    case ".ts":
+    case ".tsx":
+    case ".js":
+    case ".jsx":
+      return content.replace(/^import\s+.+$/gm, "").replace(/^const\s+.+=\s*require\(.+$/gm, "");
+    case ".java":
+    case ".kt":
+    case ".scala":
+      return content.replace(/^import\s+.+;$/gm, "");
+    case ".py":
+      return content.replace(/^(?:from\s+.+import\s+.+|import\s+.+)$/gm, "");
+    case ".go":
+      return content.replace(/^import\s+.+$/gm, "").replace(/import\s*\([\s\S]*?\)/g, "");
+    case ".cs":
+      return content.replace(/^using\s+.+;$/gm, "");
+    case ".rs":
+      return content.replace(/^use\s+.+;$/gm, "");
+    default:
+      return content;
+  }
+}
+function buildStemLookup(files, rootPath) {
+  const lookup = /* @__PURE__ */ new Map();
+  for (const fullPath of files) {
+    const relPath = relative(rootPath, fullPath).replace(/\\/g, "/");
+    const withoutExt = relPath.replace(/\.[^.]+$/, "");
+    addToLookup(lookup, withoutExt, relPath);
+    const stemParts = withoutExt.split("/");
+    const baseName = stemParts[stemParts.length - 1];
+    addToLookup(lookup, baseName, relPath);
+  }
+  return lookup;
+}
+function addToLookup(lookup, key, value) {
+  const existing = lookup.get(key);
+  if (existing) existing.push(value);
+  else lookup.set(key, [value]);
+}
+function resolveImportPath(callerRel, source, stemLookup, callerExt) {
+  switch (callerExt) {
+    case ".ts":
+    case ".tsx":
+    case ".js":
+    case ".jsx": {
+      if (!source.startsWith(".")) return [];
+      const callerDir = callerRel.split("/").slice(0, -1).join("/");
+      const resolved = normalizePath(callerDir ? `${callerDir}/${source}` : source);
+      for (const ext of ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.js"]) {
+        const candidates = stemLookup.get(resolved + ext) || stemLookup.get((resolved + ext).replace(/\.[^.]+$/, ""));
+        if (candidates && candidates.length > 0) return [candidates[0]];
+      }
+      const direct = stemLookup.get(resolved.replace(/\.[^.]+$/, ""));
+      if (direct) return [direct[0]];
+      return [];
+    }
+    case ".java":
+    case ".kt":
+    case ".scala": {
+      const parts = source.split(".");
+      const className = parts[parts.length - 1];
+      if (className === "*") return [];
+      const candidates = stemLookup.get(className);
+      if (candidates) return [candidates[0]];
+      return [];
+    }
+    case ".py": {
+      if (source.startsWith(".")) {
+        const callerDir = callerRel.split("/").slice(0, -1).join("/");
+        const modulePath2 = source.replace(/^\.+/, "").replace(/\./g, "/");
+        const resolved = callerDir ? `${callerDir}/${modulePath2}` : modulePath2;
+        const pyResParts = resolved.split("/");
+        const candidates2 = stemLookup.get(resolved) || stemLookup.get(pyResParts[pyResParts.length - 1]);
+        if (candidates2) return [candidates2[0]];
+      }
+      const modulePath = source.replace(/\./g, "/");
+      const candidates = stemLookup.get(modulePath);
+      if (candidates) return [candidates[0]];
+      return [];
+    }
+    case ".go": {
+      const goSegments = source.split("/");
+      const lastSeg = goSegments[goSegments.length - 1];
+      const candidates = stemLookup.get(lastSeg);
+      if (candidates) return [candidates[0]];
+      return [];
+    }
+    default:
+      return [];
+  }
+}
+function normalizePath(p) {
+  const parts = p.split("/");
+  const result = [];
+  for (const part of parts) {
+    if (part === "." || part === "") continue;
+    if (part === "..") {
+      result.pop();
+      continue;
+    }
+    result.push(part);
+  }
+  return result.join("/");
+}
+function isTestPath(fp) {
+  const segments = fp.split("/");
+  return segments.some(
+    (s) => s === "test" || s === "tests" || s === "__tests__" || s === "spec" || s === "test_" || s === "__test__"
+  ) || /\.(test|spec)\.[^.]+$/.test(fp);
+}
+function collectFiles(rootPath) {
+  const files = [];
+  const walk = (dir, depth) => {
+    if (depth > 10) return;
+    try {
+      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          walk(fullPath, depth + 1);
+        } else {
+          const ext = extname(entry.name).toLowerCase();
+          if (!CODE_EXTENSIONS.has(ext)) continue;
+          if (entry.name.endsWith(".d.ts")) continue;
+          if (/\.(test|spec)\.[^.]+$/.test(entry.name)) continue;
+          const relDir = relative(rootPath, dir).replace(/\\/g, "/");
+          if (relDir.split("/").some((s) => s === "test" || s === "tests" || s === "__tests__" || s === "spec"))
+            continue;
+          files.push(fullPath);
+        }
+      }
+    } catch {
+    }
+  };
+  walk(rootPath, 0);
+  return files;
+}
+export {
+  extractRegexCallGraph
+};
+//# sourceMappingURL=regex-call-graph.js.map

package/packages/analyzers/dist/structure-analyzer.d.ts

@@ -0,0 +1,11 @@
+import type { AnalysisResult, IAnalyzer, StructureAnalyzerOptions } from './types.js';
+export declare class StructureAnalyzer implements IAnalyzer<StructureAnalyzerOptions> {
+    readonly name = "structure";
+    analyze(rootPath: string, options?: StructureAnalyzerOptions): Promise<AnalysisResult>;
+    private buildTree;
+    private computeStats;
+    private formatMarkdown;
+    private renderTree;
+    private countFiles;
+}
+//# sourceMappingURL=structure-analyzer.d.ts.map

package/packages/analyzers/dist/structure-analyzer.js

@@ -0,0 +1,258 @@
+import { readdir, stat } from "node:fs/promises";
+import { extname, join } from "node:path";
+const DIRECTORY_PURPOSES = {
+  src: "Application source",
+  lib: "Library code",
+  dist: "Build output",
+  build: "Build output",
+  test: "Tests",
+  tests: "Tests",
+  spec: "Tests",
+  __tests__: "Tests",
+  docs: "Documentation",
+  scripts: "Build/utility scripts",
+  config: "Configuration",
+  handlers: "Entry point handlers",
+  controllers: "HTTP controllers",
+  routes: "API routes",
+  middleware: "Middleware",
+  services: "Business logic services",
+  domain: "Domain/business logic",
+  infrastructure: "External integrations",
+  adapters: "Adapter implementations",
+  ports: "Port interfaces",
+  models: "Data models",
+  entities: "Domain entities",
+  repositories: "Data access",
+  utils: "Utilities",
+  helpers: "Helper functions",
+  types: "Type definitions",
+  interfaces: "Interface definitions",
+  constants: "Constants",
+  cdk: "CDK infrastructure",
+  stacks: "CDK stacks",
+  constructs: "CDK constructs",
+  lambdas: "Lambda functions",
+  components: "UI components",
+  hooks: "React hooks",
+  pages: "Page components",
+  layouts: "Layout components",
+  store: "State management",
+  assets: "Static assets",
+  styles: "Stylesheets",
+  fixtures: "Test fixtures",
+  mocks: "Test mocks",
+  migrations: "Database migrations"
+};
+const LANGUAGE_MAP = {
+  ".ts": "TypeScript",
+  ".tsx": "React TSX",
+  ".js": "JavaScript",
+  ".jsx": "React JSX",
+  ".mjs": "ES Module",
+  ".cjs": "CommonJS",
+  ".json": "JSON",
+  ".yaml": "YAML",
+  ".yml": "YAML",
+  ".md": "Markdown",
+  ".mdx": "MDX",
+  ".py": "Python",
+  ".go": "Go",
+  ".rs": "Rust",
+  ".java": "Java",
+  ".sh": "Shell",
+  ".ps1": "PowerShell",
+  ".css": "CSS",
+  ".scss": "SCSS",
+  ".html": "HTML",
+  ".sql": "SQL",
+  ".graphql": "GraphQL",
+  ".proto": "Protocol Buffers",
+  ".toml": "TOML",
+  ".env": "Environment"
+};
+const DEFAULT_EXCLUDES = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  "coverage",
+  ".turbo",
+  ".cache",
+  "__pycache__",
+  ".venv",
+  ".terraform",
+  "cdk.out"
+]);
+const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  // Code
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".java",
+  ".kt",
+  ".kts",
+  ".scala",
+  ".py",
+  ".go",
+  ".rs",
+  ".rb",
+  ".php",
+  ".swift",
+  ".cs",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".sh",
+  ".bash",
+  ".ps1",
+  ".sql",
+  ".graphql",
+  ".gql",
+  ".proto",
+  // Config
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".env",
+  ".ini",
+  ".cfg",
+  ".xml",
+  ".pom",
+  ".gradle",
+  ".tf",
+  ".hcl",
+  // Build/project
+  ".lock",
+  ".mjs"
+]);
+const COLLAPSED_DIRS = /* @__PURE__ */ new Set([
+  "__tests__",
+  "test",
+  "tests",
+  "spec",
+  "__mocks__",
+  "__fixtures__",
+  "fixtures",
+  "mocks"
+]);
+class StructureAnalyzer {
+  name = "structure";
+  async analyze(rootPath, options = {}) {
+    const { format = "markdown", maxDepth = 6, sourceOnly = false } = options;
+    const startTime = Date.now();
+    const tree = await this.buildTree(rootPath, 0, maxDepth, sourceOnly);
+    const stats = this.computeStats(tree);
+    const output = format === "json" ? JSON.stringify({ tree, stats }, null, 2) : this.formatMarkdown(tree, stats, rootPath);
+    return {
+      output,
+      data: { tree, stats },
+      meta: {
+        analyzedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        scope: rootPath,
+        fileCount: stats.totalFiles,
+        durationMs: Date.now() - startTime
+      }
+    };
+  }
+  async buildTree(dirPath, depth, maxDepth, sourceOnly) {
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    const children = [];
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      if (DEFAULT_EXCLUDES.has(entry.name)) continue;
+      if (entry.name.startsWith(".") && entry.name !== ".env.example") continue;
+      const fullPath = join(dirPath, entry.name);
+      if (entry.isDirectory() && depth < maxDepth) {
+        const subtree = await this.buildTree(fullPath, depth + 1, maxDepth, sourceOnly);
+        if (sourceOnly && (!subtree.children || subtree.children.length === 0)) continue;
+        children.push(subtree);
+      } else if (entry.isFile()) {
+        const ext = extname(entry.name).toLowerCase();
+        if (sourceOnly && ext && !SOURCE_EXTENSIONS.has(ext)) continue;
+        if (sourceOnly && !ext) continue;
+        const fileStat = await stat(fullPath);
+        children.push({
+          name: entry.name,
+          type: "file",
+          language: LANGUAGE_MAP[ext] ?? (ext || "unknown"),
+          size: fileStat.size
+        });
+      }
+    }
+    const dirName = dirPath.split(/[/\\]/).pop() ?? dirPath;
+    return {
+      name: dirName,
+      type: "directory",
+      purpose: DIRECTORY_PURPOSES[dirName.toLowerCase()],
+      children
+    };
+  }
+  computeStats(tree) {
+    const languages = {};
+    let totalFiles = 0;
+    let totalSize = 0;
+    const walk = (node) => {
+      if (node.type === "file") {
+        totalFiles++;
+        totalSize += node.size ?? 0;
+        const lang = node.language ?? "unknown";
+        languages[lang] = (languages[lang] ?? 0) + 1;
+      }
+      node.children?.forEach(walk);
+    };
+    walk(tree);
+    return { totalFiles, totalSize, languages };
+  }
+  formatMarkdown(tree, stats, rootPath) {
+    const lines = [];
+    lines.push(`## Project Structure: ${rootPath}
+`);
+    lines.push(
+      `**${stats.totalFiles} files** | Languages: ${Object.entries(stats.languages).map(([l, c]) => `${l} (${c})`).join(", ")}
+`
+    );
+    lines.push("```");
+    this.renderTree(tree, "", lines);
+    lines.push("```");
+    return lines.join("\n");
+  }
+  renderTree(node, prefix, lines) {
+    const annotation = node.purpose ? ` \u2500\u2500 ${node.purpose}` : "";
+    if (node.type === "directory") {
+      const lowerName = node.name.toLowerCase();
+      if (COLLAPSED_DIRS.has(lowerName) && node.children) {
+        const count = this.countFiles(node);
+        lines.push(`${prefix}${node.name}/${annotation} (${count} files)`);
+        return;
+      }
+      lines.push(`${prefix}${node.name}/${annotation}`);
+      node.children?.forEach((child, i) => {
+        const isLast = i === (node.children?.length ?? 0) - 1;
+        const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+        const nextPrefix = prefix + (isLast ? "    " : "\u2502   ");
+        if (child.type === "directory") {
+          this.renderTree(child, nextPrefix, lines);
+        } else {
+          lines.push(`${prefix}${connector}${child.name}`);
+        }
+      });
+    } else {
+      lines.push(`${prefix}${node.name}`);
+    }
+  }
+  countFiles(node) {
+    if (node.type === "file") return 1;
+    return (node.children ?? []).reduce((sum, child) => sum + this.countFiles(child), 0);
+  }
+}
+export {
+  StructureAnalyzer
+};
+//# sourceMappingURL=structure-analyzer.js.map