pkgviz 0.7.2 → 0.7.4

package/src/app/utils/getParsedFileStructure.ts

@@ -0,0 +1,225 @@
+'use server';
+import { Language, type ParsedDirectory } from '@/shared/types';
+
+import { existsSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+import { toPosix } from '@/shared/utils/toPosix';
+import { detectLanguage } from '@/shared/utils/detectLanguage';
+import { parseJavaFile } from '@/app/utils/parser/java/parseJavaFile';
+import { parseFile as parseTypeScriptFile } from '@/app/utils/parser/typescript/parseFile';
+import { parseCppFile } from '@/app/utils/parser/cpp/parseCppFile';
+import { parsePythonFile } from '@/app/utils/parser/python/parseFile';
+import { parseDelphiFile } from '@/app/utils/parser/delphi/parseFile';
+import { parseKotlinFile } from '@/app/utils/parser/kotlin/parseFile';
+import { parseProjectPath } from '@/shared/utils/parseProjectPath';
+import { JAVA_ROOT } from '@/shared/constants';
+
+/**
+ * Returns resolved root
+ */
+export async function resolveRoot(dir: string, detectedLanguage: Language) {
+  switch (detectedLanguage) {
+    case Language.Java: {
+      const javaRoot = toPosix(path.resolve(dir, JAVA_ROOT));
+      if (!existsSync(javaRoot)) {
+        console.error('Failed to find:', JAVA_ROOT);
+        throw new Error(`Invalid Java project structure. Missing ${JAVA_ROOT}`);
+      }
+      return javaRoot;
+    }
+
+    case Language.TypeScript:
+      // Normalize to an absolute project root
+      return toPosix(path.resolve(dir));
+
+    case Language.Cpp:
+      // For C++, look for src directory or use project root
+      const cppSrcRoot = toPosix(path.resolve(dir, 'src'));
+      if (existsSync(cppSrcRoot)) {
+        return cppSrcRoot;
+      }
+      return toPosix(path.resolve(dir));
+
+    case Language.Python:
+      // For Python, look for src directory or use project root
+      const pythonSrcRoot = toPosix(path.resolve(dir, 'src'));
+      if (existsSync(pythonSrcRoot)) {
+        return pythonSrcRoot;
+      }
+      // Also check for common Python app structure
+      const appRoot = toPosix(path.resolve(dir, 'app'));
+      if (existsSync(appRoot)) {
+        return appRoot;
+      }
+      return toPosix(path.resolve(dir));
+
+    case Language.Delphi:
+      // For Delphi, look for common source directories
+      const delphiSrcRoot = toPosix(path.resolve(dir, 'src'));
+      if (existsSync(delphiSrcRoot)) {
+        return delphiSrcRoot;
+      }
+      // Also check for Source directory (common in Delphi projects)
+      const sourceRoot = toPosix(path.resolve(dir, 'Source'));
+      if (existsSync(sourceRoot)) {
+        return sourceRoot;
+      }
+      return toPosix(path.resolve(dir));
+
+    case Language.Kotlin:
+      // For Kotlin, look for src/main/kotlin directory (Gradle/Maven structure)
+      const kotlinSrcRoot = toPosix(path.resolve(dir, 'src/main/kotlin'));
+      if (existsSync(kotlinSrcRoot)) {
+        return kotlinSrcRoot;
+      }
+      // Fallback to src directory
+      const kotlinAltSrcRoot = toPosix(path.resolve(dir, 'src'));
+      if (existsSync(kotlinAltSrcRoot)) {
+        return kotlinAltSrcRoot;
+      }
+      return toPosix(path.resolve(dir));
+
+    default:
+      throw new Error(`Invalid file structure for ${detectedLanguage}`);
+  }
+}
+
+/**
+ * Read directory recursively
+ */
+export async function readDirRecursively(
+  dir: string,
+  result: ParsedDirectory = {},
+  projectRoot: string,
+  language: Language
+): Promise<ParsedDirectory> {
+  const resolvedRoot = path.resolve(projectRoot);
+  const resolvedDir = path.resolve(dir);
+
+  // Validate dir is inside projectRoot (avoid path traversal / accidental escapes)
+  const relative = path.relative(resolvedRoot, resolvedDir);
+  if (relative.startsWith('..') || path.isAbsolute(relative)) {
+    throw new Error(`Path traversal detected: ${dir} is outside of project root ${projectRoot}`);
+  }
+
+  // 1. Read current directory
+  const entries = readdirSync(resolvedDir, { withFileTypes: true });
+
+  const ignores = [
+    '@types',
+    '.cache',
+    '.git',
+    '.github',
+    '.meta',
+    '.next',
+    '.vscode',
+    'coverage',
+    'examples',
+    'node_modules',
+    'packages',
+    'test',
+  ];
+
+  for (const entry of entries) {
+    if (ignores.includes(entry.name)) continue;
+
+    const fullPath = path.resolve(resolvedDir, entry.name);
+
+    // Directory: Recursively continue to read
+    if (entry.isDirectory()) {
+      result[entry.name] = await readDirRecursively(fullPath, {}, projectRoot, language);
+      continue;
+    }
+
+    // File: Parse file according to detected project language
+    switch (language) {
+      // Java
+      case Language.Java:
+        if (entry.name.endsWith('.java')) {
+          result[entry.name] = await parseJavaFile(fullPath, projectRoot);
+        }
+        break;
+
+      // TypeScript
+      case Language.TypeScript:
+        if (entry.name.endsWith('.ts') || entry.name.endsWith('.tsx')) {
+          result[entry.name] = await parseTypeScriptFile(fullPath, projectRoot);
+        }
+        break;
+
+      // C++
+      case Language.Cpp:
+        if (
+          entry.name.endsWith('.cpp') ||
+          entry.name.endsWith('.cc') ||
+          entry.name.endsWith('.cxx') ||
+          entry.name.endsWith('.h') ||
+          entry.name.endsWith('.hpp') ||
+          entry.name.endsWith('.hxx')
+        ) {
+          result[entry.name] = await parseCppFile(fullPath, projectRoot);
+        }
+        break;
+
+      // Python
+      case Language.Python:
+        if (entry.name.endsWith('.py')) {
+          result[entry.name] = await parsePythonFile(fullPath, projectRoot);
+        }
+        break;
+
+      // Delphi
+      case Language.Delphi:
+        if (
+          entry.name.endsWith('.pas') ||
+          entry.name.endsWith('.pp') ||
+          entry.name.endsWith('.dpr')
+        ) {
+          result[entry.name] = await parseDelphiFile(fullPath, projectRoot);
+        }
+        break;
+
+      // Kotlin
+      case Language.Kotlin:
+        if (entry.name.endsWith('.kt') || entry.name.endsWith('.kts')) {
+          result[entry.name] = await parseKotlinFile(fullPath, projectRoot);
+        }
+        break;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Entrypoint
+ */
+export async function getParsedFileStructure() {
+  const projectPath = parseProjectPath();
+
+  // 1. Detect language & filter non-supported
+  const detectedLanguage = (await detectLanguage(projectPath)).language;
+  console.log('1. Detected language:', detectedLanguage);
+
+  if (
+    ![
+      Language.Java,
+      Language.TypeScript,
+      Language.Cpp,
+      Language.Python,
+      Language.Delphi,
+      Language.Kotlin,
+    ].includes(detectedLanguage)
+  ) {
+    throw new Error(
+      "Supported language is 'Java', 'TypeScript', 'C++', 'Python', 'Delphi' & 'Kotlin'. More to follow."
+    );
+  }
+
+  // 2. Get validated root directory by detectedLanguage
+  const rootDir = await resolveRoot(projectPath, detectedLanguage);
+  console.log('2. rootDir:', rootDir);
+
+  // 3. Read directory recursively (pass resolved root as both dir and projectRoot)
+  return await readDirRecursively(rootDir, {}, rootDir, detectedLanguage);
+}

package/src/app/utils/markCyclicPackages.ts

@@ -0,0 +1,275 @@
+import type { ElementsDefinition } from 'cytoscape';
+import type { ParsedDirectory, ParsedFile } from '@/shared/types';
+
+/** Collect all files from your ParsedDirectory tree. */
+function collectFiles(root: ParsedDirectory): ParsedFile[] {
+  const files: ParsedFile[] = [];
+  const walk = (dir: ParsedDirectory) => {
+    for (const key in dir) {
+      const entry = (dir as Record<string, unknown>)[key];
+      if (entry && typeof entry === 'object' && 'path' in entry && 'package' in entry) {
+        files.push(entry as ParsedFile);
+      } else if (entry && typeof entry === 'object') {
+        walk(entry as ParsedDirectory);
+      }
+    }
+  };
+  walk(root);
+  return files;
+}
+
+/** Build per-edge evidence: key "from->to" → list of ImportEvidence. */
+function buildEdgeEvidence(dir: ParsedDirectory): Map<string, ImportEvidence[]> {
+  const files = collectFiles(dir);
+  const map = new Map<string, ImportEvidence[]>();
+
+  for (const f of files) {
+    const from = f.package as TUniquePackageName;
+    for (const imp of f.imports ?? []) {
+      const to = imp.pkg as TUniquePackageName;
+      if (!to || to === from) continue;
+      const key = `${from}->${to}`;
+      if (!map.has(key)) map.set(key, []);
+      map.get(key)!.push({
+        filePath: f.path,
+        fileClass: f.className,
+        importName: imp.name,
+        isIntrinsic: imp.isIntrinsic,
+      });
+    }
+  }
+  return map;
+}
+
+/** Convert ElementsDefinition (from buildGraph) to adjacency map. */
+function elementsToAdj(elements: ElementsDefinition) {
+  const adj = new Map<TUniquePackageName, Set<TUniquePackageName>>();
+  for (const n of elements.nodes) {
+    const id = String(n.data.id) as TUniquePackageName;
+    if (!adj.has(id)) adj.set(id, new Set());
+  }
+  for (const e of elements.edges) {
+    const s = String(e.data.source) as TUniquePackageName;
+    const t = String(e.data.target) as TUniquePackageName;
+    if (!adj.has(s)) adj.set(s, new Set());
+    if (!adj.has(t)) adj.set(t, new Set());
+    adj.get(s)!.add(t);
+  }
+  return adj;
+}
+
+/** Tarjan SCC on adjacency. */
+function tarjanSCC(
+  graph: Map<TUniquePackageName, Set<TUniquePackageName>>
+): TUniquePackageName[][] {
+  let index = 0;
+  const idx = new Map<TUniquePackageName, number>();
+  const low = new Map<TUniquePackageName, number>();
+  const stack: TUniquePackageName[] = [];
+  const onStack = new Set<TUniquePackageName>();
+  const out: TUniquePackageName[][] = [];
+
+  function strong(v: TUniquePackageName) {
+    idx.set(v, index);
+    low.set(v, index);
+    index++;
+    stack.push(v);
+    onStack.add(v);
+
+    for (const w of graph.get(v) ?? []) {
+      if (!idx.has(w)) {
+        strong(w);
+        low.set(v, Math.min(low.get(v)!, low.get(w)!));
+      } else if (onStack.has(w)) {
+        low.set(v, Math.min(low.get(v)!, idx.get(w)!));
+      }
+    }
+
+    if (low.get(v) === idx.get(v)) {
+      const comp: TUniquePackageName[] = [];
+      let w: TUniquePackageName;
+      do {
+        w = stack.pop()!;
+        onStack.delete(w);
+        comp.push(w);
+      } while (w !== v);
+      out.push(comp);
+    }
+  }
+
+  for (const v of graph.keys()) if (!idx.has(v)) strong(v);
+  return out;
+}
+
+/** Find one simple cycle ordering inside a given SCC. */
+function findOneCycleInScc(
+  graph: Map<TUniquePackageName, Set<TUniquePackageName>>,
+  sccSet: Set<TUniquePackageName>
+): TUniquePackageName[] | null {
+  const nodes = Array.from(sccSet);
+  for (const start of nodes) {
+    const path: TUniquePackageName[] = [];
+    const seen = new Set<TUniquePackageName>();
+    function dfs(v: TUniquePackageName): TUniquePackageName[] | null {
+      path.push(v);
+      seen.add(v);
+      for (const w of graph.get(v) ?? []) {
+        if (!sccSet.has(w)) continue;
+        if (w === start && path.length > 1) return [...path, start];
+        if (!seen.has(w)) {
+          const r = dfs(w);
+          if (r) return r;
+        }
+      }
+      path.pop();
+      return null;
+    }
+    const cyc = dfs(start);
+    if (cyc) return cyc;
+  }
+  return null;
+}
+
+/**
+ * High-level API: build graph via `buildGraph`, detect package cycles,
+ * and attach **member evidence** (files/imports) per cycle edge.
+ */
+export function getPackageCyclesWithMembers(
+  dir: ParsedDirectory,
+  graph: ElementsDefinition
+): {
+  cycles: PackageCycleDetail[];
+  packageSet: Set<TUniquePackageName>;
+  graph: ElementsDefinition; // for convenience (already built)
+} {
+  const adj = elementsToAdj(graph);
+  const sccs = tarjanSCC(adj);
+  const evidence = buildEdgeEvidence(dir);
+
+  const cycles: PackageCycleDetail[] = [];
+  const packageSet = new Set<TUniquePackageName>();
+
+  for (const scc of sccs) {
+    const selfLoop = scc.length === 1 && (adj.get(scc[0])?.has(scc[0]) ?? false);
+    if (scc.length > 1 || selfLoop) {
+      scc.forEach(p => packageSet.add(p));
+      const sccSet = new Set(scc);
+      const cycle = findOneCycleInScc(adj, sccSet) ?? [...scc, scc[0]];
+
+      const edges: CycleEdgeEvidence[] = [];
+      for (let i = 0; i < cycle.length - 1; i++) {
+        const from = cycle[i];
+        const to = cycle[i + 1];
+        const key = `${from}->${to}`;
+        edges.push({
+          from,
+          to,
+          via: evidence.get(key) ?? [],
+        });
+      }
+
+      cycles.push({ packages: cycle, edges });
+    }
+  }
+
+  return { cycles, packageSet, graph };
+}
+
+/**
+ * Annotate Cytoscape nodes:
+ *  - adds class "packageCycle" for cyclic packages
+ *  - sets data.packageCycle (boolean)
+ *  - sets data.cycleEvidence (edges where this pkg is the "from" side)
+ */
+export function markCyclicPackagesWithEvidence(
+  elements: ElementsDefinition,
+  dir: ParsedDirectory
+): ElementsDefinition {
+  const { cycles, packageSet } = getPackageCyclesWithMembers(dir, elements);
+
+  // pkg → list of outgoing cycle edges (evidence)
+  const pkgToEdges = new Map<TUniquePackageName, CycleEdgeEvidence[]>();
+
+  // Track cycle edges by (from → to) for quick lookup when mapping Cytoscape edges
+  const cycleEdgeKeys = new Set<string>();
+
+  for (const c of cycles) {
+    for (const e of c.edges) {
+      if (!pkgToEdges.has(e.from)) pkgToEdges.set(e.from, []);
+      pkgToEdges.get(e.from)!.push(e);
+      cycleEdgeKeys.add(`${e.from}→${e.to}`);
+    }
+  }
+
+  const nodes = (elements.nodes ?? []).map(n => {
+    const id = String(n.data.id) as TUniquePackageName;
+    const isCyclic = packageSet.has(id);
+    const existing = n.classes ? String(n.classes) : '';
+    const classes = isCyclic ? (existing ? `${existing} packageCycle` : 'packageCycle') : existing;
+
+    return {
+      ...n,
+      classes,
+      data: {
+        ...n.data,
+        packageCycle: isCyclic,
+        cycleEvidence: isCyclic ? (pkgToEdges.get(id) ?? []) : undefined,
+      },
+    };
+  });
+
+  const edges = (elements.edges ?? []).map(e => {
+    const source = String(e.data.source) as TUniquePackageName;
+    const target = String(e.data.target) as TUniquePackageName;
+    const isCycleEdge = cycleEdgeKeys.has(`${source}→${target}`);
+
+    const existing = e.classes ? String(e.classes) : '';
+    const classes = isCycleEdge
+      ? existing
+        ? `${existing} packageCycle`
+        : 'packageCycle'
+      : existing;
+
+    return {
+      ...e,
+      classes,
+      data: {
+        ...e.data,
+        packageCycle: isCycleEdge,
+      },
+    };
+  });
+
+  return { ...elements, nodes, edges };
+}
+
+/**
+ * Convenience that only returns the set of cyclic packages (no evidence)
+ */
+export function getCyclicPackageSet(
+  dir: ParsedDirectory,
+  graph: ElementsDefinition
+): Set<TUniquePackageName> {
+  const { packageSet } = getPackageCyclesWithMembers(dir, graph);
+  return packageSet;
+}
+
+type TUniquePackageName = string;
+
+interface ImportEvidence {
+  readonly filePath: string; // ParsedFile.path (relative to project)
+  readonly fileClass: string; // ParsedFile.className
+  readonly importName: string; // IJavaImport.name
+  readonly isIntrinsic?: boolean; // IJavaImport.isIntrinsic
+}
+
+interface CycleEdgeEvidence {
+  readonly from: TUniquePackageName;
+  readonly to: TUniquePackageName;
+  readonly via: ImportEvidence[]; // files in `from` that import `to`
+}
+
+export interface PackageCycleDetail {
+  readonly packages: TUniquePackageName[]; // ordered cycle incl. closing node, e.g. ["A","B","A"]
+  readonly edges: CycleEdgeEvidence[]; // evidence aligned with packages[i] -> packages[i+1]
+}

package/src/app/utils/parser/cpp/extractCppPackageFromImport.ts

@@ -0,0 +1,18 @@
+/**
+ * Extracts the package/namespace from a C++ include statement
+ * For example: "myapp/utils/Helper.h" -> "myapp.utils"
+ */
+export function extractCppPackageFromImport(importPath: string): string {
+  // Remove file extension
+  const withoutExt = importPath.replace(/\.(h|hpp|hxx)$/, '');
+
+  // Split by path separator and take all but the last segment
+  const segments = withoutExt.split('/');
+
+  if (segments.length <= 1) {
+    return '';
+  }
+
+  // Join with dots to create package-like structure
+  return segments.slice(0, -1).join('.');
+}

package/src/app/utils/parser/cpp/parseCppFile.ts

@@ -0,0 +1,150 @@
+'use server';
+import type { ParsedFile, MethodCall, MethodDefinition, ImportDefinition } from '@/shared/types';
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { extractCppPackageFromImport } from '@/app/utils/parser/cpp/extractCppPackageFromImport';
+
+/**
+ * Extracts namespace from C++ code.
+ */
+function extractNamespace(content: string): string {
+  const match = content.match(/namespace\s+([a-zA-Z0-9_:]+)\s*\{/);
+  return match?.[1]?.replace(/::/g, '.') || '';
+}
+
+/**
+ * Extracts include statements from C++ code.
+ */
+function extractIncludes(content: string, projectRoot: string): ImportDefinition[] {
+  console.log('[CPP] projectRoot:', projectRoot);
+  const includeRegex = /#include\s+["<]([^">]+)[">]/g;
+  const includes: ImportDefinition[] = [];
+
+  let match;
+  while ((match = includeRegex.exec(content)) !== null) {
+    const includePath = match[1];
+
+    // System includes use angle brackets, local includes use quotes
+    const isSystemInclude = content.includes(`<${includePath}>`);
+    const pkg = extractCppPackageFromImport(includePath);
+
+    includes.push({
+      name: includePath,
+      pkg,
+      isIntrinsic: !isSystemInclude, // Local includes are intrinsic
+    });
+  }
+
+  return includes;
+}
+
+/**
+ * Extracts the class name from the content and filename fallback.
+ */
+function extractClassName(content: string, fileName: string): string {
+  // Try to find class declaration
+  const classMatch = content.match(/class\s+([A-Za-z0-9_]+)/);
+  if (classMatch) {
+    return classMatch[1];
+  }
+
+  // Try to find struct declaration
+  const structMatch = content.match(/struct\s+([A-Za-z0-9_]+)/);
+  if (structMatch) {
+    return structMatch[1];
+  }
+
+  // Fallback to filename without extension
+  return path.basename(fileName, path.extname(fileName));
+}
+
+/**
+ * Extracts method definitions from C++ content.
+ */
+function extractMethodDefinitions(content: string): MethodDefinition[] {
+  const methods: MethodDefinition[] = [];
+
+  // Match method definitions (simplified regex, may need refinement)
+  const methodRegex = /(?:(public|protected|private):\s*)?([\w<>:&*\s]+)\s+(\w+)\s*$$([^)]*)$$/g;
+
+  let match;
+  let currentVisibility: 'public' | 'protected' | 'private' | 'default' = 'default';
+
+  // Also track visibility changes
+  const visibilityRegex = /(public|protected|private):/g;
+  const lines = content.split('\n');
+
+  for (const line of lines) {
+    const visMatch = visibilityRegex.exec(line);
+    if (visMatch) {
+      currentVisibility = visMatch[1] as 'public' | 'protected' | 'private';
+    }
+  }
+
+  methodRegex.lastIndex = 0;
+  while ((match = methodRegex.exec(content)) !== null) {
+    const visibility = (match[1] as 'public' | 'protected' | 'private') || currentVisibility;
+    const returnType = match[2]?.trim() || 'void';
+    const name = match[3];
+    const params = match[4]
+      .split(',')
+      .map(p => p.trim())
+      .filter(Boolean);
+
+    // Skip obvious non-methods (keywords, control structures)
+    if (['if', 'while', 'for', 'switch', 'catch'].includes(name)) {
+      continue;
+    }
+
+    methods.push({
+      name,
+      returnType,
+      parameters: params,
+      visibility,
+    });
+  }
+
+  return methods;
+}
+
+/**
+ * Extract method calls from C++ content.
+ */
+function extractMethodCalls(content: string): MethodCall[] {
+  const callRegex = /(\b\w+)(?:\.|->)(\w+)\s*\(/g;
+  const calls: MethodCall[] = [];
+
+  let match;
+  while ((match = callRegex.exec(content)) !== null) {
+    const callee = match[1];
+    const method = match[2];
+    calls.push({ callee, method });
+  }
+
+  return calls;
+}
+
+/**
+ * Parses a C++ file and returns metadata useful for diagram generation.
+ */
+export async function parseCppFile(fullPath: string, projectRoot: string): Promise<ParsedFile> {
+  const content = fs.readFileSync(fullPath, 'utf-8');
+  const fileName = path.basename(fullPath);
+
+  const className = extractClassName(content, fileName);
+  const namespace = extractNamespace(content);
+  const includes = extractIncludes(content, projectRoot);
+  const methods = extractMethodDefinitions(content);
+  const calls = extractMethodCalls(content);
+  const relativePath = path.relative(projectRoot, fullPath);
+
+  return {
+    className,
+    package: namespace,
+    imports: includes,
+    methods,
+    calls,
+    path: relativePath,
+  };
+}

package/src/app/utils/parser/delphi/extractPackageFromImport.ts

@@ -0,0 +1,21 @@
+/**
+ * Extracts the package/unit name from a Delphi uses clause import.
+ *
+ * Delphi imports are in the format:
+ * - uses UnitName;
+ * - uses UnitName in 'path/to/UnitName.pas';
+ * - uses Vcl.Forms, System.SysUtils;
+ *
+ * @param importStatement - The full import statement (e.g., "System.SysUtils")
+ * @returns The package/namespace name
+ */
+export function extractPackageFromImport(importStatement: string): string {
+  const trimmed = importStatement.trim();
+
+  // Handle dotted notation (e.g., "System.SysUtils" -> "System")
+  const parts = trimmed.split('.');
+  if (parts.length > 1) return parts[0];
+
+  // For single unit names without namespace, return as-is
+  return trimmed;
+}