pkgviz 0.7.7 → 0.8.0

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

@@ -1,85 +1,81 @@
 '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.
- */
+import { readTextFileWithinRoot } from '@ankhorage/utility/node/fs';
+
+import type { ImportDefinition, MethodCall, MethodDefinition, ParsedFile } from '@/shared/types';
+import { toPosix } from '@/shared/utils/toPosix';
+
+/*** Extracts namespace from C++ code. */
 function extractNamespace(content: string): string {
-  const match = content.match(/namespace\s+([a-zA-Z0-9_:]+)\s*\{/);
+  const match = /namespace\s+([a-zA-Z0-9_:]+)\s*\{/.exec(content);
   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[] = [];
-
+/*** Retains include metadata canonical graph topology intentionally omits. */
+function extractPresentationOnlyIncludes(
+  content: string,
+  namespace: string,
+  canonicalImports: readonly ImportDefinition[]
+): ImportDefinition[] {
+  const canonicalNames = new Set(canonicalImports.map(({ name }) => name));
+  const includeRegex = /#include\s+(["<])([^">]+)[">]/g;
+  const imports: ImportDefinition[] = [];
   let match;
+
   while ((match = includeRegex.exec(content)) !== null) {
-    const includePath = match[1];
+    const delimiter = match[1];
+    const specifier = match[2];
+    if (canonicalNames.has(specifier)) continue;
 
-    // System includes use angle brackets, local includes use quotes
-    const isSystemInclude = content.includes(`<${includePath}>`);
-    const pkg = extractCppPackageFromImport(includePath);
+    const segments = specifier.replace(/\.(h|hpp|hxx)$/u, '').split('/');
+    const pkg = segments.length > 1 ? segments.slice(0, -1).join('.') : '';
+    if (pkg !== '' && pkg !== namespace) continue;
 
-    includes.push({
-      name: includePath,
+    imports.push({
+      name: specifier,
       pkg,
-      isIntrinsic: !isSystemInclude, // Local includes are intrinsic
+      isIntrinsic: delimiter === '"',
     });
   }
 
-  return includes;
+  return imports;
 }
 
-/**
- * Extracts the class name from the content and filename fallback.
- */
+/*** Restores complete include metadata in source declaration order. */
+function mergeImports(
+  content: string,
+  namespace: string,
+  canonicalImports: readonly ImportDefinition[]
+): readonly ImportDefinition[] {
+  return [
+    ...canonicalImports,
+    ...extractPresentationOnlyIncludes(content, namespace, canonicalImports),
+  ].sort((left, right) => content.indexOf(left.name) - content.indexOf(right.name));
+}
+
+/*** 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];
-  }
+  const classMatch = /class\s+([A-Za-z0-9_]+)/.exec(content);
+  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];
-  }
+  const structMatch = /struct\s+([A-Za-z0-9_]+)/.exec(content);
+  if (structMatch) return structMatch[1];
 
-  // Fallback to filename without extension
   return path.basename(fileName, path.extname(fileName));
 }
 
-/**
- * Extracts method definitions from C++ content.
- */
+/*** 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) {
+  for (const line of content.split('\n')) {
     const visMatch = visibilityRegex.exec(line);
-    if (visMatch) {
-      currentVisibility = visMatch[1] as 'public' | 'protected' | 'private';
-    }
+    if (visMatch) currentVisibility = visMatch[1] as 'public' | 'protected' | 'private';
   }
 
   methodRegex.lastIndex = 0;
@@ -92,59 +88,45 @@ function extractMethodDefinitions(content: string): MethodDefinition[] {
       .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,
-    });
+    if (['if', 'while', 'for', 'switch', 'catch'].includes(name)) continue;
+    methods.push({ name, returnType, parameters: params, visibility });
   }
 
   return methods;
 }
 
-/**
- * Extract method calls from C++ content.
- */
+/*** Extracts 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 });
+    calls.push({ callee: match[1], method: match[2] });
   }
-
   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);
+/*** Parses C++ metadata while consuming canonical dependency includes. */
+export async function parseCppFile(
+  fullPath: string,
+  projectRoot: string,
+  imports: readonly ImportDefinition[]
+): Promise<ParsedFile> {
+  const { content, path: resolvedPath } = readTextFileWithinRoot({
+    rootPath: projectRoot,
+    filePath: fullPath,
+  });
+  const fileName = path.basename(resolvedPath);
 
-  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,
+    className: extractClassName(content, fileName),
     package: namespace,
-    imports: includes,
-    methods,
-    calls,
-    path: relativePath,
+    imports: [...mergeImports(content, namespace, imports)],
+    methods: extractMethodDefinitions(content),
+    calls: extractMethodCalls(content),
+    path: toPosix(path.relative(projectRoot, resolvedPath)),
   };
 }

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

@@ -1,93 +1,32 @@
 'use server';
-import type { ParsedFile, MethodCall, MethodDefinition, ImportDefinition } from '@/shared/types';
-
-import fs from 'node:fs';
 import path from 'node:path';
-import { extractPackageFromImport } from '@/app/utils/parser/delphi/extractPackageFromImport';
-
-/**
- * Extracts package/unit path from Delphi file structure.
- */
-function extractUnitPath(filePath: string, projectRoot: string): string {
-  const relativePath = path.relative(projectRoot, filePath);
-  const dir = path.dirname(relativePath);
-
-  // Convert path separators to dots for Delphi unit notation
-  return dir === '.' ? '' : dir.replace(/[/\\]/g, '.');
-}
 
-/**
- * Extracts uses clause imports from Delphi code.
- */
-function extractImports(content: string): ImportDefinition[] {
-  const imports: ImportDefinition[] = [];
+import { readTextFileWithinRoot } from '@ankhorage/utility/node/fs';
 
-  // Match uses clause: uses Unit1, Unit2, Unit3;
-  // Can appear in interface and implementation sections
-  const usesRegex = /\buses\s+([\s\S]*?);/gi;
+import type { ImportDefinition, MethodCall, MethodDefinition, ParsedFile } from '@/shared/types';
+import { toPosix } from '@/shared/utils/toPosix';
 
-  let match;
-  while ((match = usesRegex.exec(content)) !== null) {
-    const usesClause = match[1];
-
-    // Split by comma and extract unit names
-    const units = usesClause.split(',').map(u => u.trim());
-
-    for (const unit of units) {
-      // Remove "in 'path'" suffix if present
-      const unitName = unit.replace(/\s+in\s+['"].*?['"]/gi, '').trim();
-
-      if (unitName) {
-        const pkg = extractPackageFromImport(unitName);
-
-        // Determine if it's a standard RTL/VCL/FMX unit
-        const isIntrinsic =
-          unitName.startsWith('System.') ||
-          unitName.startsWith('Vcl.') ||
-          unitName.startsWith('FMX.') ||
-          unitName.startsWith('Data.') ||
-          unitName.startsWith('Web.');
-
-        imports.push({
-          name: unitName,
-          pkg,
-          isIntrinsic,
-        });
-      }
-    }
-  }
-
-  return imports;
+/*** Extracts package/unit path from Delphi file structure. */
+function extractUnitPath(filePath: string, projectRoot: string): string {
+  const relativePath = toPosix(path.relative(projectRoot, filePath));
+  const dir = path.posix.dirname(relativePath);
+  return dir === '.' ? '' : dir.replace(/\//g, '.');
 }
 
-/**
- * Extracts the unit/class name from Delphi content.
- */
+/*** Extracts the unit/class name from Delphi content. */
 function extractClassName(content: string, fileName: string): string {
-  // Try to find unit name
-  const unitMatch = content.match(/\bunit\s+([A-Za-z_][A-Za-z0-9_]*)\s*;/i);
-  if (unitMatch) {
-    return unitMatch[1];
-  }
+  const unitMatch = /\bunit\s+([A-Za-z_][A-Za-z0-9_]*)\s*;/i.exec(content);
+  if (unitMatch) return unitMatch[1];
 
-  // Try to find primary class name in type section
-  const classMatch = content.match(/\bT([A-Za-z_][A-Za-z0-9_]*)\s*=\s*class/i);
-  if (classMatch) {
-    return 'T' + classMatch[1];
-  }
+  const classMatch = /\bT([A-Za-z_][A-Za-z0-9_]*)\s*=\s*class/i.exec(content);
+  if (classMatch) return 'T' + classMatch[1];
 
-  // Fallback to filename without extension
   return path.basename(fileName, path.extname(fileName));
 }
 
-/**
- * Extracts method/procedure/function definitions from Delphi content.
- */
+/*** Extracts method/procedure/function definitions from Delphi content. */
 function extractMethodDefinitions(content: string): MethodDefinition[] {
   const methods: MethodDefinition[] = [];
-
-  // Match procedure/function declarations in interface or class definition
-  // procedure MethodName(Params); or function MethodName: ReturnType;
   const methodRegex =
     /\b(procedure|function)\s+([A-Za-z_][A-Za-z0-9_]*)\s*(?:$$(.*?)$$)?\s*(?::\s*([A-Za-z_][A-Za-z0-9_.<>]+))?\s*;/gi;
 
@@ -97,25 +36,16 @@ function extractMethodDefinitions(content: string): MethodDefinition[] {
     const name = match[2];
     const paramsStr = match[3] || '';
     const returnType = match[4] || (kind === 'procedure' ? 'void' : 'Unknown');
-
-    // Parse parameters (format: Name: Type; Name2: Type2)
     const params = paramsStr
       .split(';')
       .map(p => p.trim())
       .filter(p => p)
       .map(p => {
-        // Extract parameter name (before colon)
         const colonIdx = p.indexOf(':');
-        if (colonIdx > 0) {
-          return p.substring(0, colonIdx).trim();
-        }
-        return p;
+        return colonIdx > 0 ? p.substring(0, colonIdx).trim() : p;
       });
 
-    // Determine visibility based on section or keywords
     let visibility: 'public' | 'protected' | 'private' | 'default' = 'public';
-
-    // Look backwards in content to find visibility section
     const beforeMethod = content.substring(0, match.index);
     if (/\bprivate\b(?!.*\bpublic\b)(?!.*\bprotected\b)/is.test(beforeMethod)) {
       visibility = 'private';
@@ -123,57 +53,43 @@ function extractMethodDefinitions(content: string): MethodDefinition[] {
       visibility = 'protected';
     }
 
-    methods.push({
-      name,
-      returnType,
-      parameters: params,
-      visibility,
-    });
+    methods.push({ name, returnType, parameters: params, visibility });
   }
 
   return methods;
 }
 
-/**
- * Extract method calls from Delphi content.
- */
+/*** Extracts method calls from Delphi content. */
 function extractMethodCalls(content: string): MethodCall[] {
   const calls: MethodCall[] = [];
-
-  // Match: Object.Method( or Object.Property
   const callRegex = /([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)\s*\(/g;
-
   let match;
-  while ((match = callRegex.exec(content)) !== null) {
-    const callee = match[1];
-    const method = match[2];
 
-    calls.push({ callee, method });
+  while ((match = callRegex.exec(content)) !== null) {
+    calls.push({ callee: match[1], method: match[2] });
   }
 
   return calls;
 }
 
-/**
- * Parses a Delphi file and returns metadata useful for diagram generation.
- */
-export async function parseDelphiFile(fullPath: string, projectRoot: string): Promise<ParsedFile> {
-  const content = fs.readFileSync(fullPath, 'utf-8');
-  const fileName = path.basename(fullPath);
-
-  const className = extractClassName(content, fileName);
-  const unitPath = extractUnitPath(fullPath, projectRoot);
-  const imports = extractImports(content);
-  const methods = extractMethodDefinitions(content);
-  const calls = extractMethodCalls(content);
-  const relativePath = path.relative(projectRoot, fullPath);
+/*** Parses Delphi metadata while consuming canonical dependency imports. */
+export async function parseDelphiFile(
+  fullPath: string,
+  projectRoot: string,
+  imports: readonly ImportDefinition[]
+): Promise<ParsedFile> {
+  const { content, path: resolvedPath } = readTextFileWithinRoot({
+    rootPath: projectRoot,
+    filePath: fullPath,
+  });
+  const fileName = path.basename(resolvedPath);
 
   return {
-    className,
-    package: unitPath,
-    imports,
-    methods,
-    calls,
-    path: relativePath,
+    className: extractClassName(content, fileName),
+    package: extractUnitPath(resolvedPath, projectRoot),
+    imports: [...imports],
+    methods: extractMethodDefinitions(content),
+    calls: extractMethodCalls(content),
+    path: toPosix(path.relative(projectRoot, resolvedPath)),
   };
 }

package/src/app/utils/parser/java/findEntryPoint.ts

@@ -1,8 +1,9 @@
 /**
  * @unused This file will be useful as soon as we add Sequence Diagrams
  */
-import { parseJavaFile } from '@/app/utils/parser/java/parseJavaFile';
+import type { parseJavaFile } from '@/app/utils/parser/java/parseJavaFile';
 
+/*** Finds the Java entry point in the parsed project. */
 export function findEntryPoint(files: JavaParsedFile[]): JavaParsedFile | null {
   for (const file of files) {
     const mainMethod = file.methods.find(

package/src/app/utils/parser/java/parseJavaFile.ts

@@ -1,39 +1,35 @@
 'use server';
-import type { ParsedFile, MethodCall, MethodDefinition } from '@/shared/types';
-
-import fs from 'node:fs';
 import path from 'node:path';
-import { getIntrinsicPackagesRecursive } from '@/app/utils/parser/java/getIntrinsicPackagesRecursive';
-import { extractJavaPackageFromImport } from '@/app/utils/parser/java/extractJavaPackageFromImport';
 
-/**
+import { readTextFileWithinRoot } from '@ankhorage/utility/node/fs';
+import { escapeRegExp } from '@ankhorage/utility/regex';
+
+import type { ImportDefinition, MethodCall, MethodDefinition, ParsedFile } from '@/shared/types';
+import { toPosix } from '@/shared/utils/toPosix';
+
+/***
  * Extracts the package declaration from Java code.
  */
 function extractPackageName(content: string): string {
-  const match = content.match(/^package\s+([a-zA-Z0-9_.]+);/m);
+  const match = /^package\s+([a-zA-Z0-9_.]+);/m.exec(content);
   return match?.[1] || '';
 }
 
-/**
- * Extracts import statements from Java code.
- */
-function extractImports(content: string): string[] {
-  return Array.from(content.matchAll(/^import\s+([a-zA-Z0-9_.*]+);/gm)).map(match => match[1]);
-}
-
-/**
+/***
  * Extracts the class name from the content and filename fallback.
  */
 function extractClassName(content: string, fileName: string): string {
-  const classPattern = new RegExp(`(?:public\\s+)?(class|interface|enum|record)\\s+${fileName}\\b`);
+  const classPattern = new RegExp(
+    `(?:public\\s+)?(class|interface|enum|record)\\s+${escapeRegExp(fileName)}\\b`
+  );
   const classNameMatch = content.match(classPattern);
   if (classNameMatch) return fileName;
 
-  const fallback = content.match(/(?:public\s+)?(class|interface|enum|record)\s+([A-Za-z0-9_]+)/);
+  const fallback = /(?:public\s+)?(class|interface|enum|record)\s+([A-Za-z0-9_]+)/.exec(content);
   return fallback?.[2] || '';
 }
 
-/**
+/***
  * Extracts the method definitions from file content
  */
 function extractMethodDefinitions(content: string): MethodDefinition[] {
@@ -62,8 +58,8 @@ function extractMethodDefinitions(content: string): MethodDefinition[] {
   return methods;
 }
 
-/**
- * Extract method calls from file content
+/***
+ * Extract method calls from Java content.
  */
 function extractMethodCalls(content: string): MethodCall[] {
   const callRegex = /(\b\w+)\.(\w+)\s*\(/g;
@@ -79,35 +75,27 @@ function extractMethodCalls(content: string): MethodCall[] {
   return calls;
 }
 
-/**
- * Parses a Java file and returns metadata useful for diagram generation.
+/***
+ * Parses Java class/method/call metadata while consuming canonical dependency imports.
  */
-export async function parseJavaFile(fullPath: string, projectRoot: string) {
-  const content = fs.readFileSync(fullPath, 'utf-8');
-  const fileName = path.basename(fullPath, '.java');
-  const intrinsicPackages = await getIntrinsicPackagesRecursive();
-
-  const className = extractClassName(content, fileName);
-  const pkg = extractPackageName(content);
-  const imports = extractImports(content).map(imp => {
-    const pkgFromImport = extractJavaPackageFromImport(imp);
-    return {
-      name: imp,
-      pkg: pkgFromImport,
-      isIntrinsic: intrinsicPackages.includes(pkgFromImport),
-    };
+export async function parseJavaFile(
+  fullPath: string,
+  projectRoot: string,
+  imports: readonly ImportDefinition[]
+): Promise<ParsedFile> {
+  const { content, path: resolvedPath } = readTextFileWithinRoot({
+    rootPath: projectRoot,
+    filePath: fullPath,
   });
-  const methods = extractMethodDefinitions(content);
-  const calls = extractMethodCalls(content);
-  const relativePath = path.relative(projectRoot, fullPath);
+  const fileName = path.basename(resolvedPath, '.java');
 
   const file: ParsedFile = {
-    className,
-    package: pkg,
-    imports,
-    methods,
-    calls,
-    path: relativePath,
+    className: extractClassName(content, fileName),
+    package: extractPackageName(content),
+    imports: [...imports],
+    methods: extractMethodDefinitions(content),
+    calls: extractMethodCalls(content),
+    path: toPosix(path.relative(projectRoot, resolvedPath)),
   };
 
   return file;