pkgviz 0.7.6 → 0.8.0

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

@@ -1,93 +1,47 @@
 '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/kotlin/extractPackageFromImport';
-
-/**
- * Extracts package declaration from Kotlin content.
- */
-function extractPackage(content: string): string {
-  const packageMatch = content.match(/^\s*package\s+([\w.]+)/m);
-  return packageMatch ? packageMatch[1] : '';
-}
 
-/**
- * Extracts import statements from Kotlin code.
- */
-function extractImports(content: string): ImportDefinition[] {
-  const imports: ImportDefinition[] = [];
-  const importRegex = /^\s*import\s+([\w.]+(?:\.\*)?)/gm;
+import { readTextFileWithinRoot } from '@ankhorage/utility/node/fs';
 
-  let match;
-  while ((match = importRegex.exec(content)) !== null) {
-    const importPath = match[1];
-    const pkg = extractPackageFromImport(importPath);
-
-    // Check if it's an intrinsic/standard library import
-    const isIntrinsic =
-      importPath.startsWith('kotlin.') ||
-      importPath.startsWith('java.') ||
-      importPath.startsWith('javax.');
-
-    imports.push({
-      name: importPath,
-      pkg,
-      isIntrinsic,
-    });
-  }
+import type { ImportDefinition, MethodCall, MethodDefinition, ParsedFile } from '@/shared/types';
+import { toPosix } from '@/shared/utils/toPosix';
 
-  return imports;
+/*** Extracts package declaration from Kotlin content. */
+function extractPackage(content: string): string {
+  const packageMatch = /^\s*package\s+([\w.]+)/m.exec(content);
+  return packageMatch ? packageMatch[1] : '';
 }
 
-/**
- * Extracts class, object, data class, or sealed class name from Kotlin content.
- */
+/*** Extracts class, object, data class, or sealed class name from Kotlin content. */
 function extractClassName(content: string, fileName: string): string {
-  // Try to find class/object/interface declaration
-  const classMatch = content.match(
-    /(?:^|\n)\s*(?:data\s+|sealed\s+|abstract\s+|open\s+)?(?:class|object|interface)\s+([A-Za-z0-9_]+)/m
-  );
+  const classMatch =
+    /(?:^|\n)\s*(?:data\s+|sealed\s+|abstract\s+|open\s+)?(?:class|object|interface)\s+([A-Za-z0-9_]+)/m.exec(
+      content
+    );
 
-  if (classMatch) {
-    return classMatch[1];
-  }
-
-  // Fallback to filename without extension
+  if (classMatch) return classMatch[1];
   return path.basename(fileName, path.extname(fileName));
 }
 
-/**
- * Extracts method/function definitions from Kotlin content.
- */
+/*** Extracts method/function definitions from Kotlin content. */
 function extractMethodDefinitions(content: string): MethodDefinition[] {
   const methods: MethodDefinition[] = [];
-
-  // Match function definitions: fun methodName(params): ReturnType or suspend fun methodName
   const methodRegex =
     /(?:^|\n)\s*(?:(private|protected|public|internal)\s+)?(?:suspend\s+)?fun\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*$$([^)]*)$$(?:\s*:\s*([^{=\n]+))?/gm;
 
   let match;
   while ((match = methodRegex.exec(content)) !== null) {
     const visibility = (match[1] || 'public') as
-      | 'public'
-      | 'protected'
-      | 'private'
-      | 'internal'
-      | 'default';
+      'public' | 'protected' | 'private' | 'internal' | 'default';
     const name = match[2];
     const paramsStr = match[3];
     const returnType = match[4]?.trim() || 'Unit';
-
-    // Parse parameters
     const params = paramsStr
       .split(',')
       .map(p => p.trim())
       .filter(p => p)
       .map(p => {
-        // Extract parameter name (before colon)
-        const paramMatch = p.match(/([a-zA-Z_][a-zA-Z0-9_]*)\s*:/);
+        const paramMatch = /([a-zA-Z_][a-zA-Z0-9_]*)\s*:/.exec(p);
         return paramMatch ? paramMatch[1] : p;
       });
 
@@ -102,46 +56,39 @@ function extractMethodDefinitions(content: string): MethodDefinition[] {
   return methods;
 }
 
-/**
- * Extract method calls from Kotlin content.
- */
+/*** Extracts method calls from Kotlin content. */
 function extractMethodCalls(content: string): MethodCall[] {
   const calls: MethodCall[] = [];
-
-  // Match: object.method( or variable.method(
   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 });
   }
 
   return calls;
 }
 
-/**
- * Parses a Kotlin file and returns metadata useful for diagram generation.
- */
-export async function parseKotlinFile(fullPath: string, projectRoot: string): Promise<ParsedFile> {
-  const content = fs.readFileSync(fullPath, 'utf-8');
-  const fileName = path.basename(fullPath);
-
-  const packageName = extractPackage(content);
-  const className = extractClassName(content, fileName);
-  const imports = extractImports(content);
-  const methods = extractMethodDefinitions(content);
-  const calls = extractMethodCalls(content);
-  const relativePath = path.relative(projectRoot, fullPath);
+/*** Parses Kotlin class/method/call metadata while consuming canonical dependency imports. */
+export async function parseKotlinFile(
+  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: packageName,
-    imports,
-    methods,
-    calls,
-    path: relativePath,
+    className: extractClassName(content, fileName),
+    package: extractPackage(content),
+    imports: [...imports],
+    methods: extractMethodDefinitions(content),
+    calls: extractMethodCalls(content),
+    path: toPosix(path.relative(projectRoot, resolvedPath)),
   };
 }

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

@@ -1,89 +1,29 @@
 'use server';
-import type { ParsedFile, MethodCall, MethodDefinition, ImportDefinition } from '@/shared/types';
-
-import fs from 'node:fs';
 import path from 'node:path';
-import { extractPythonPackageFromImport } from '@/app/utils/parser/python/extractPythonPackageFromImport';
 
-/**
- * Extracts module path from Python __init__.py structure.
- */
-function extractModulePath(filePath: string, projectRoot: string): string {
-  const relativePath = path.relative(projectRoot, filePath);
-  const parts = relativePath.split(path.sep);
+import { readTextFileWithinRoot } from '@ankhorage/utility/node/fs';
 
-  // Remove the filename
-  parts.pop();
+import type { ImportDefinition, MethodCall, MethodDefinition, ParsedFile } from '@/shared/types';
+import { toPosix } from '@/shared/utils/toPosix';
 
-  // Join with dots for Python module notation
+/*** Extracts module path from Python source structure. */
+function extractModulePath(filePath: string, projectRoot: string): string {
+  const relativePath = toPosix(path.relative(projectRoot, filePath));
+  const parts = relativePath.split('/');
+  parts.pop();
   return parts.join('.');
 }
 
-/**
- * Extracts import statements from Python code.
- */
-function extractImports(content: string): ImportDefinition[] {
-  const imports: ImportDefinition[] = [];
-
-  // Match: import module
-  // Match: import module as alias
-  // Match: from module import something
-  const importRegex =
-    /(?:^|\n)\s*(?:from\s+([\w.]+)\s+)?import\s+([\w\s,*]+?)(?:\s+as\s+\w+)?(?:\s|$|#)/gm;
-
-  let match;
-  while ((match = importRegex.exec(content)) !== null) {
-    const fromModule = match[1];
-    const importedItems = match[2];
-
-    if (fromModule) {
-      // from X import Y
-      const pkg = extractPythonPackageFromImport(fromModule);
-      const isIntrinsic = fromModule.startsWith('.');
-
-      imports.push({
-        name: fromModule,
-        pkg,
-        isIntrinsic,
-      });
-    } else {
-      // import X, Y, Z
-      const mods = importedItems.split(',').map(m => m.trim());
-      for (const mod of mods) {
-        const pkg = extractPythonPackageFromImport(mod);
-        imports.push({
-          name: mod,
-          pkg,
-          isIntrinsic: false,
-        });
-      }
-    }
-  }
-
-  return imports;
-}
-
-/**
- * Extracts the class name from Python content.
- */
+/*** Extracts the class name from Python content. */
 function extractClassName(content: string, fileName: string): string {
-  // Try to find class declaration
-  const classMatch = content.match(/^class\s+([A-Za-z0-9_]+)/m);
-  if (classMatch) {
-    return classMatch[1];
-  }
-
-  // Fallback to filename without extension
+  const classMatch = /^class\s+([A-Za-z0-9_]+)/m.exec(content);
+  if (classMatch) return classMatch[1];
   return path.basename(fileName, path.extname(fileName));
 }
 
-/**
- * Extracts method/function definitions from Python content.
- */
+/*** Extracts method/function definitions from Python content. */
 function extractMethodDefinitions(content: string): MethodDefinition[] {
   const methods: MethodDefinition[] = [];
-
-  // Match function definitions: def method_name(params): or async def method_name(params):
   const methodRegex =
     /(?:^|\n)\s*(async\s+)?def\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*$$([^)]*)$$\s*(?:->([^:]+))?:/gm;
 
@@ -92,14 +32,11 @@ function extractMethodDefinitions(content: string): MethodDefinition[] {
     const name = match[2];
     const paramsStr = match[3];
     const returnType = match[4]?.trim() || 'None';
-
-    // Parse parameters
     const params = paramsStr
       .split(',')
       .map(p => p.trim())
       .filter(p => p && p !== 'self' && p !== 'cls');
 
-    // Determine visibility (Python convention: _ prefix = protected, __ prefix = private)
     let visibility: 'public' | 'protected' | 'private' | 'default' = 'public';
     if (name.startsWith('__') && !name.endsWith('__')) {
       visibility = 'private';
@@ -118,13 +55,9 @@ function extractMethodDefinitions(content: string): MethodDefinition[] {
   return methods;
 }
 
-/**
- * Extract method calls from Python content.
- */
+/*** Extracts method calls from Python content. */
 function extractMethodCalls(content: string): MethodCall[] {
   const calls: MethodCall[] = [];
-
-  // Match: object.method( or self.method(
   const callRegex = /([a-zA-Z_][a-zA-Z0-9_]*)\.([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/g;
 
   let match;
@@ -132,7 +65,6 @@ function extractMethodCalls(content: string): MethodCall[] {
     const callee = match[1];
     const method = match[2];
 
-    // Skip common built-in methods to reduce noise
     if (
       ['append', 'extend', 'pop', 'remove', 'join', 'split', 'strip'].includes(method) &&
       ['str', 'list', 'dict', 'set'].includes(callee)
@@ -146,26 +78,24 @@ function extractMethodCalls(content: string): MethodCall[] {
   return calls;
 }
 
-/**
- * Parses a Python file and returns metadata useful for diagram generation.
- */
-export async function parsePythonFile(fullPath: string, projectRoot: string): Promise<ParsedFile> {
-  const content = fs.readFileSync(fullPath, 'utf-8');
-  const fileName = path.basename(fullPath);
-
-  const className = extractClassName(content, fileName);
-  const modulePath = extractModulePath(fullPath, projectRoot);
-  const imports = extractImports(content);
-  const methods = extractMethodDefinitions(content);
-  const calls = extractMethodCalls(content);
-  const relativePath = path.relative(projectRoot, fullPath);
+/*** Parses Python metadata while consuming canonical dependency imports. */
+export async function parsePythonFile(
+  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: modulePath,
-    imports,
-    methods,
-    calls,
-    path: relativePath,
+    className: extractClassName(content, fileName),
+    package: extractModulePath(resolvedPath, projectRoot),
+    imports: [...imports],
+    methods: extractMethodDefinitions(content),
+    calls: extractMethodCalls(content),
+    path: toPosix(path.relative(projectRoot, resolvedPath)),
   };
 }

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

@@ -1,57 +1,16 @@
-import type { ParsedFile, MethodCall, MethodDefinition, ImportDefinition } from '@/shared/types';
-
 import fs from 'node:fs/promises';
-import { basename, relative, resolve } from 'node:path';
-import ts from 'typescript';
-import { extractTypeScriptPackageFromImport } from '@/app/utils/parser/typescript/extractTypeScriptPackageFromImport';
-import { toPosix } from '@/shared/utils/toPosix';
-import { parseProjectPath } from '@/shared/utils/parseProjectPath';
-
-/**
- * Extracts import statements from TypeScript code.
- */
-function extractImports(content: string, filename: string): ImportDefinition[] {
-  const sourceFile = ts.createSourceFile('temp.ts', content, ts.ScriptTarget.Latest, true);
-  const imports: ImportDefinition[] = [];
-
-  sourceFile.forEachChild(node => {
-    if (!ts.isImportDeclaration(node)) return;
-
-    const fullPath = toPosix(filename).split('/').slice(0, -1).join('/');
-    const moduleSpecifier = (node.moduleSpecifier as ts.StringLiteral).text;
-
-    function resolveImportPath(curDir: string, specifier: string) {
-      const root = parseProjectPath();
+import { basename, relative } from 'node:path';
 
-      if (specifier.startsWith('./') || specifier.startsWith('../'))
-        return {
-          isIntrinsic: true,
-          resolvedPath: resolve(curDir, specifier).slice(root.length + 1),
-        };
-
-      if (specifier.startsWith('@/'))
-        return {
-          isIntrinsic: true,
-          resolvedPath: specifier.replace(/^@/, 'src'),
-        };
-
-      return { isIntrinsic: false, resolvedPath: specifier };
-    }
-
-    const { resolvedPath, isIntrinsic } = resolveImportPath(fullPath, moduleSpecifier);
-
-    const pkg = extractTypeScriptPackageFromImport(resolvedPath);
-    imports.push({ name: pkg, pkg, isIntrinsic });
-  });
+import ts from 'typescript';
 
-  return imports;
-}
+import type { ImportDefinition, MethodCall, MethodDefinition, ParsedFile } from '@/shared/types';
+import { toPosix } from '@/shared/utils/toPosix';
 
-/**
+/***
  * Extracts the class name from the content and filename fallback.
  */
 function extractClassName(content: string, fileName: string): string {
-  const classMatch = content.match(/class\s+(\w+)/);
+  const classMatch = /class\s+(\w+)/.exec(content);
   if (classMatch) {
     return classMatch[1];
   }
@@ -59,13 +18,14 @@ function extractClassName(content: string, fileName: string): string {
   return basename(fileName, '.ts');
 }
 
-/**
+/***
  * Extracts method definitions from TypeScript content.
  */
 function extractMethodDefinitions(content: string): MethodDefinition[] {
   const sourceFile = ts.createSourceFile('temp.ts', content, ts.ScriptTarget.Latest, true);
   const methods: MethodDefinition[] = [];
 
+  /*** Visits syntax nodes while collecting parser metadata. */
   function visit(node: ts.Node) {
     if (ts.isMethodDeclaration(node) && node.name) {
       const name = node.name.getText();
@@ -88,13 +48,14 @@ function extractMethodDefinitions(content: string): MethodDefinition[] {
   return methods;
 }
 
-/**
+/***
  * Extracts method calls from TypeScript content.
  */
 function extractMethodCalls(content: string): MethodCall[] {
   const sourceFile = ts.createSourceFile('temp.ts', content, ts.ScriptTarget.Latest, true);
   const calls: MethodCall[] = [];
 
+  /*** Visits syntax nodes while collecting parser metadata. */
   function visit(node: ts.Node) {
     if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
       const callee = node.expression.expression.getText();
@@ -109,10 +70,14 @@ function extractMethodCalls(content: string): MethodCall[] {
   return calls;
 }
 
-/**
+/***
  * Parses a TypeScript file and returns metadata useful for diagram generation.
  */
-export async function parseFile(fullPath: string, projectRoot: string): Promise<ParsedFile> {
+export async function parseFile(
+  fullPath: string,
+  projectRoot: string,
+  imports: readonly ImportDefinition[]
+): Promise<ParsedFile> {
   const posixFullPath = toPosix(fullPath);
   const content = await fs.readFile(posixFullPath, 'utf-8');
   const relativePath = toPosix(relative(projectRoot, posixFullPath));
@@ -121,7 +86,7 @@ export async function parseFile(fullPath: string, projectRoot: string): Promise<
 
   return {
     className: extractClassName(content, fullPath),
-    imports: extractImports(content, fullPath),
+    imports: [...imports],
     methods: extractMethodDefinitions(content),
     calls: extractMethodCalls(content),
     package: segmentedPath.join('.'),

package/src/app/utils/selectParserLanguage.ts

@@ -0,0 +1,39 @@
+import type { ProjectDetection } from '@ankhorage/project-detector/types';
+
+import { Language } from '../../shared/types';
+import type { ParserSelection } from '../../types/parserSelection';
+
+/*** Select a supported parser by evidence strength, evidence count, then stable parser order. */
+export function selectParserLanguage(detection: ProjectDetection): ParserSelection {
+  const supported = [
+    Language.TypeScript,
+    Language.Java,
+    Language.Cpp,
+    Language.Python,
+    Language.Delphi,
+    Language.Kotlin,
+  ];
+  const candidates = supported
+    .flatMap(language => {
+      const detected = detection.languages.find(candidate => candidate.id === language);
+      return detected ? [{ language, detected }] : [];
+    })
+    .sort(
+      (left, right) =>
+        right.detected.score - left.detected.score ||
+        right.detected.evidence.length - left.detected.evidence.length ||
+        supported.indexOf(left.language) - supported.indexOf(right.language)
+    );
+  const selected = candidates[0];
+  if (!selected) {
+    throw new Error(
+      `No supported parser detected. Found: ${detection.languages.map(language => language.id).join(', ') || 'unknown'}. Supported: ${supported.join(', ')}.`
+    );
+  }
+  return {
+    language: selected.language,
+    score: selected.detected.score,
+    indicators: selected.detected.evidence,
+    candidates: detection.languages,
+  };
+}

package/src/cli/formatAuditRuleFailures.ts

@@ -0,0 +1,21 @@
+import type { AuditRuleResult } from '@/types/audit';
+
+/*** Formats blocking audit-rule failures for terminal and CI output. */
+export function formatAuditRuleFailures(
+  results: readonly AuditRuleResult[],
+  artifactPath: string
+): string {
+  const failures = results.filter(
+    result => result.policy === 'blocking' && result.status === 'failed'
+  );
+  const ruleLines = failures.flatMap(result => {
+    const details =
+      result.details.length > 0
+        ? result.details.map(detail => `  ${detail}`)
+        : [`  ${result.message}`];
+
+    return [`✗ ${result.id}`, ...details, ''];
+  });
+
+  return ['PKGViz audit failed', '', ...ruleLines, `Audit: ${artifactPath}`].join('\n');
+}

package/src/cli/runAuditAsync.ts

@@ -0,0 +1,41 @@
+import { resolveFileSystemPathWithinRoot, writeFileWithinRoot } from '@ankhorage/utility/node/fs';
+
+import { createAuditAsync } from '@/features/audit/composition/createAuditAsync';
+import { hasBlockingAuditRuleFailure } from '@/features/audit/domain/hasBlockingAuditRuleFailure';
+import type { Audit, ResolveAuditConfigurationInput } from '@/types/audit';
+
+/*** Creates, writes, and evaluates an audit while retaining the artifact on rule failure. */
+export async function runAuditAsync(input: RunAuditInput): Promise<RunAuditResult> {
+  const audit = await createAuditAsync(input.projectPath, input.configuration);
+  const body = input.pretty ? JSON.stringify(audit, null, 2) : JSON.stringify(audit);
+
+  await writeFileWithinRoot({
+    rootPath: input.projectPath,
+    filePath: input.outputPath,
+    body: new TextEncoder().encode(body),
+    exclusive: false,
+  });
+
+  const artifactPath = resolveFileSystemPathWithinRoot(input.projectPath, input.outputPath);
+  const shouldFail =
+    audit.configuration.failOnRuleViolation && hasBlockingAuditRuleFailure(audit.evaluation.rules);
+
+  return {
+    audit,
+    artifactPath,
+    exitCode: shouldFail ? 2 : 0,
+  };
+}
+
+interface RunAuditInput {
+  readonly projectPath: string;
+  readonly outputPath: string;
+  readonly pretty: boolean;
+  readonly configuration?: ResolveAuditConfigurationInput;
+}
+
+interface RunAuditResult {
+  readonly audit: Audit;
+  readonly artifactPath: string;
+  readonly exitCode: 0 | 2;
+}

package/src/components/Breadcrumb.tsx

@@ -1,10 +1,11 @@
 'use client';
-import React from 'react';
 import { ChevronRight, Home } from 'lucide-react';
 import Link from 'next/link';
+import React from 'react';
 
+/*** Renders package navigation breadcrumbs without empty path segments. */
 export default function Breadcrumb({ path, onNavigate }: BreadcrumbProps) {
-  const parts = path.split('/') || [''];
+  const parts = path.split('/').filter(Boolean);
 
   return (
     <nav className="flex items-center space-x-1 text-sm">
@@ -13,10 +14,10 @@ export default function Breadcrumb({ path, onNavigate }: BreadcrumbProps) {
       </Link>
 
       {parts.map((part, index) => {
-        const currentPath = parts.length ? parts.slice(0, index + 1).join('.') : '';
+        const currentPath = parts.slice(0, index + 1).join('/');
 
         return (
-          <div key={index} className="flex items-center">
+          <div key={currentPath} className="flex items-center">
             <ChevronRight className="h-4 w-4 text-foreground opacity-20" />
             <Link href="#" onClick={() => onNavigate(currentPath)} className="ml-1 text-foreground">
               {part}

package/src/components/ExportPanel.tsx

@@ -0,0 +1,53 @@
+'use client';
+import { DownloadIcon } from 'lucide-react';
+import React from 'react';
+
+import { downloadAuditJsonAction, downloadAuditXmlAction } from '@/app/actions/audit.actions';
+import { SidebarRow } from '@/components/sidebar/SidebarRow';
+
+/*** Renders secondary audit-export actions inside the Export sidebar tab. */
+export function ExportPanel() {
+  return (
+    <div className="pt-3">
+      <SidebarRow>
+        <ExportButton
+          format="JSON"
+          mimeType="application/json"
+          onExport={downloadAuditJsonAction}
+        />
+      </SidebarRow>
+      <SidebarRow>
+        <ExportButton format="XML" mimeType="application/xml" onExport={downloadAuditXmlAction} />
+      </SidebarRow>
+    </div>
+  );
+}
+
+/*** Downloads one serialized audit format. */
+function ExportButton({ format, mimeType, onExport }: ExportButtonProps) {
+  return (
+    <button
+      type="button"
+      onClick={async () => {
+        const { data, filename } = await onExport();
+        const blob = new Blob([data], { type: mimeType });
+        const url = URL.createObjectURL(blob);
+        const anchor = document.createElement('a');
+        anchor.href = url;
+        anchor.download = filename;
+        anchor.click();
+        URL.revokeObjectURL(url);
+      }}
+      className="flex cursor-pointer items-center text-xs hover:text-blue-600 dark:hover:text-blue-400"
+    >
+      <DownloadIcon size={10} className="mr-1.5" />
+      <span>{format}</span>
+    </button>
+  );
+}
+
+interface ExportButtonProps {
+  readonly format: string;
+  readonly mimeType: string;
+  readonly onExport: () => Promise<{ data: string; filename: string }>;
+}

package/src/components/Header.tsx

@@ -4,6 +4,7 @@ import ThemeToggle from '@/components/ThemeToggle';
 import { t } from '@/i18n/i18n';
 import { getProjectName } from '@/shared/utils/getProjectName';
 
+/*** Renders the application header. */
 export default function Header({ children, title }: HeaderProps) {
   const projectName = getProjectName();