@noyrax/documentation-system-plugin 1.0.4-beta.12 → 1.0.4-beta.14

package/package.json

@@ -2,7 +2,7 @@
   "name": "@noyrax/documentation-system-plugin",
   "displayName": "Noyrax",
   "description": "Documentation that never drifts. Automatic documentation generation with validation and drift detection. Generates 5-dimensional documentation structure (modules, symbols, dependencies, ADRs, changes) for codebases.",
-  "version": "1.0.4-beta.12",
+  "version": "1.0.4-beta.14",
   "publisher": "noyrax",
   "repository": {
     "type": "git",

package/scripts/verify-adrs.js

@@ -154,56 +154,162 @@ function extractClaimsFromAdr(adrPath) {
   return claims;
 }
 
+/**
+ * Lädt die Path-Alias-Map aus .database-plugin/path-aliases.json
+ */
+function loadAliasMap(workspaceRoot) {
+  const aliasMapPath = path.join(workspaceRoot, '.database-plugin', 'path-aliases.json');
+  if (fs.existsSync(aliasMapPath)) {
+    try {
+      const content = fs.readFileSync(aliasMapPath, 'utf-8');
+      return JSON.parse(content);
+    } catch (error) {
+      // Ignore errors loading alias map
+      return {};
+    }
+  }
+  return {};
+}
+
+/**
+ * Resolved einen Pfad mit Hilfe der Alias-Map
+ */
+function resolvePathWithAlias(filePath, workspaceRoot, aliasMap) {
+  // Normalisiere den Pfad (forward slashes)
+  const normalized = filePath.replace(/\\/g, '/');
+  
+  // Prüfe ob es einen Alias gibt
+  if (aliasMap[normalized]) {
+    return path.join(workspaceRoot, aliasMap[normalized]);
+  }
+  
+  // Fallback: Original-Pfad
+  return path.join(workspaceRoot, filePath);
+}
+
+/**
+ * Findet alle src/ Verzeichnisse (und app/ für Next.js) mit Hilfe der Alias-Map
+ */
+function findAllSourceDirectories(workspaceRoot, aliasMap) {
+  const sourceDirs = [];
+  
+  // Standard: src/ im Workspace-Root
+  const standardSrc = path.join(workspaceRoot, 'src');
+  if (fs.existsSync(standardSrc)) {
+    sourceDirs.push(standardSrc);
+  }
+  
+  // Suche in Alias-Map nach src/ Pfaden
+  for (const [alias, target] of Object.entries(aliasMap)) {
+    if (alias.startsWith('src/') || alias.includes('/src/')) {
+      // Extrahiere das Plugin-Root aus dem Target
+      const targetParts = target.split('/');
+      const srcIndex = targetParts.indexOf('src');
+      if (srcIndex > 0) {
+        const pluginRoot = targetParts.slice(0, srcIndex).join('/');
+        const srcDir = path.join(workspaceRoot, pluginRoot, 'src');
+        if (fs.existsSync(srcDir) && !sourceDirs.includes(srcDir)) {
+          sourceDirs.push(srcDir);
+        }
+      }
+    }
+  }
+  
+  // Suche rekursiv nach src/ Verzeichnissen (max. 2 Ebenen tief)
+  try {
+    const searchDirs = [
+      workspaceRoot,
+      ...fs.readdirSync(workspaceRoot, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory() && !dirent.name.startsWith('.') && dirent.name !== 'node_modules')
+        .map(dirent => path.join(workspaceRoot, dirent.name))
+    ];
+    
+    for (const searchDir of searchDirs) {
+      // src/ Verzeichnisse
+      const srcDir = path.join(searchDir, 'src');
+      if (fs.existsSync(srcDir) && !sourceDirs.includes(srcDir)) {
+        sourceDirs.push(srcDir);
+      }
+      
+      // app/ Verzeichnisse (Next.js)
+      const appDir = path.join(searchDir, 'app');
+      if (fs.existsSync(appDir) && !sourceDirs.includes(appDir)) {
+        sourceDirs.push(appDir);
+      }
+    }
+  } catch (error) {
+    // Ignore errors
+  }
+  
+  return sourceDirs.length > 0 ? sourceDirs : null;
+}
+
 /**
  * Verifiziert einen Claim
  */
 function verifyClaim(claim, workspaceRoot) {
+  // Lade Alias-Map
+  const aliasMap = loadAliasMap(workspaceRoot);
+  
   if (claim.type === 'file-exists') {
-    const fullPath = path.join(workspaceRoot, claim.file);
-    const exists = fs.existsSync(fullPath);
+    // Versuche zuerst mit Alias-Map
+    const resolvedPath = resolvePathWithAlias(claim.file, workspaceRoot, aliasMap);
+    const exists = fs.existsSync(resolvedPath);
     
     if (!exists) {
-      // Prüfe ob es als .js in out/ existiert (kompilierte Version)
-      const jsPath = fullPath.replace(/^src\//, 'out/').replace(/\.ts$/, '.js');
-      const jsExists = fs.existsSync(path.join(workspaceRoot, jsPath));
+      // Fallback: Original-Pfad
+      const fullPath = path.join(workspaceRoot, claim.file);
+      const existsOriginal = fs.existsSync(fullPath);
       
-      if (jsExists) {
-        warnings.push({
+      if (!existsOriginal) {
+        // Prüfe ob es als .js in out/ existiert (kompilierte Version)
+        const jsPath = fullPath.replace(/^src\//, 'out/').replace(/\.ts$/, '.js');
+        const jsExists = fs.existsSync(path.join(workspaceRoot, jsPath));
+        
+        if (jsExists) {
+          warnings.push({
+            adr: claim.adr,
+            line: claim.line,
+            claim: `File ${claim.file} exists as compiled ${jsPath}, but source not found`,
+            type: 'file-exists'
+          });
+          return true; // Akzeptabel
+        }
+        
+        errors.push({
           adr: claim.adr,
           line: claim.line,
-          claim: `File ${claim.file} exists as compiled ${jsPath}, but source not found`,
+          claim: `File ${claim.file} does not exist`,
           type: 'file-exists'
         });
-        return true; // Akzeptabel
+        return false;
       }
-      
-      errors.push({
-        adr: claim.adr,
-        line: claim.line,
-        claim: `File ${claim.file} does not exist`,
-        type: 'file-exists'
-      });
-      return false;
     }
     return true;
   }
   
   if (claim.type === 'function-exists') {
     try {
-      // Windows-optimierte Suche mit PowerShell
-      const srcDir = path.join(workspaceRoot, 'src');
-      if (!fs.existsSync(srcDir)) {
+      // Finde alle src/ und app/ Verzeichnisse mit Hilfe der Alias-Map
+      const sourceDirs = findAllSourceDirectories(workspaceRoot, aliasMap);
+      if (!sourceDirs || sourceDirs.length === 0) {
         warnings.push({
           adr: claim.adr,
           line: claim.line,
-          claim: `Could not verify function ${claim.name} (src/ directory not found)`,
+          claim: `Could not verify function ${claim.name} (src/ or app/ directory not found)`,
           type: 'function-exists'
         });
         return true;
       }
       
-      // Rekursive Suche in TypeScript-Dateien
-      const found = searchInDirectory(srcDir, claim.name);
+      // Rekursive Suche in allen TypeScript-Dateien (src/ und app/)
+      let found = false;
+      for (const srcDir of sourceDirs) {
+        if (searchInDirectory(srcDir, claim.name)) {
+          found = true;
+          break;
+        }
+      }
       
       if (!found) {
         if (claim.explicit || claim.autoGenerated) {

package/scripts/verify-architecture.js

@@ -16,6 +16,39 @@ const { execSync } = require('child_process');
 const errors = [];
 const warnings = [];
 
+/**
+ * Lädt die Path-Alias-Map aus .database-plugin/path-aliases.json
+ */
+function loadAliasMap(workspaceRoot) {
+  const aliasMapPath = path.join(workspaceRoot, '.database-plugin', 'path-aliases.json');
+  if (fs.existsSync(aliasMapPath)) {
+    try {
+      const content = fs.readFileSync(aliasMapPath, 'utf-8');
+      return JSON.parse(content);
+    } catch (error) {
+      // Ignore errors loading alias map
+      return {};
+    }
+  }
+  return {};
+}
+
+/**
+ * Resolved einen Pfad mit Hilfe der Alias-Map
+ */
+function resolvePathWithAlias(filePath, workspaceRoot, aliasMap) {
+  // Normalisiere den Pfad (forward slashes)
+  const normalized = filePath.replace(/\\/g, '/');
+  
+  // Prüfe ob es einen Alias gibt
+  if (aliasMap[normalized]) {
+    return path.join(workspaceRoot, aliasMap[normalized]);
+  }
+  
+  // Fallback: Original-Pfad
+  return path.join(workspaceRoot, filePath);
+}
+
 /**
  * Findet ein Verzeichnis durch intelligente Suche.
  * Sucht im gegebenen Verzeichnis und in Parent-Verzeichnissen (max. 5 Ebenen).
@@ -55,8 +88,25 @@ function findDirectoryOrFile(startDir, targetPath, maxDepth = 5) {
 function checkMcpToSrcImports(workspaceRoot) {
   console.log('🔍 Checking for invalid imports from mcp/ to src/...');
   
+  // Lade Alias-Map
+  const aliasMap = loadAliasMap(workspaceRoot);
+  
   // Suche mcp/src relativ zu workspaceRoot
   let mcpSrcDir = findDirectoryOrFile(workspaceRoot, 'mcp/src');
+  if (!mcpSrcDir) {
+    // Versuche mit Alias-Map
+    const aliasKeys = Object.keys(aliasMap);
+    for (const alias of aliasKeys) {
+      if (alias.includes('mcp/src') || alias.includes('/mcp/src')) {
+        const resolved = resolvePathWithAlias(alias, workspaceRoot, aliasMap);
+        if (fs.existsSync(resolved)) {
+          mcpSrcDir = resolved;
+          break;
+        }
+      }
+    }
+  }
+  
   if (!mcpSrcDir) {
     // Fallback: Versuche __dirname + '/..' (Plugin-interne Suche)
     const fallbackRoot = path.join(__dirname, '..');

package/scripts/verify-imports.js

@@ -15,6 +15,69 @@ const { execSync } = require('child_process');
 const errors = [];
 const warnings = [];
 
+/**
+ * Lädt die Path-Alias-Map aus .database-plugin/path-aliases.json
+ */
+function loadAliasMap(workspaceRoot) {
+  const aliasMapPath = path.join(workspaceRoot, '.database-plugin', 'path-aliases.json');
+  if (fs.existsSync(aliasMapPath)) {
+    try {
+      const content = fs.readFileSync(aliasMapPath, 'utf-8');
+      return JSON.parse(content);
+    } catch (error) {
+      // Ignore errors loading alias map
+      return {};
+    }
+  }
+  return {};
+}
+
+/**
+ * Resolved einen Pfad mit Hilfe der Alias-Map
+ */
+function resolvePathWithAlias(filePath, workspaceRoot, aliasMap) {
+  // Normalisiere den Pfad (forward slashes)
+  const normalized = filePath.replace(/\\/g, '/');
+  
+  // Prüfe ob es einen Alias gibt
+  if (aliasMap[normalized]) {
+    return path.join(workspaceRoot, aliasMap[normalized]);
+  }
+  
+  // Fallback: Original-Pfad
+  return path.join(workspaceRoot, filePath);
+}
+
+/**
+ * Findet src/ Verzeichnis mit Hilfe der Alias-Map
+ */
+function findSrcDirectoryWithAlias(startDir, workspaceRoot, aliasMap, maxDepth = 5) {
+  // Standard: src/ im Workspace-Root
+  const standardSrc = path.join(workspaceRoot, 'src');
+  if (fs.existsSync(standardSrc)) {
+    return standardSrc;
+  }
+  
+  // Suche in Alias-Map nach src/ Pfaden
+  for (const [alias, target] of Object.entries(aliasMap)) {
+    if (alias.startsWith('src/') || alias.includes('/src/')) {
+      // Extrahiere das Plugin-Root aus dem Target
+      const targetParts = target.split('/');
+      const srcIndex = targetParts.indexOf('src');
+      if (srcIndex > 0) {
+        const pluginRoot = targetParts.slice(0, srcIndex).join('/');
+        const srcDir = path.join(workspaceRoot, pluginRoot, 'src');
+        if (fs.existsSync(srcDir)) {
+          return srcDir;
+        }
+      }
+    }
+  }
+  
+  // Fallback: Original findSrcDirectory
+  return findSrcDirectory(startDir, maxDepth);
+}
+
 /**
  * Sammelt alle TypeScript-Dateien rekursiv
  */
@@ -126,7 +189,7 @@ function findSrcDirectory(startDir, maxDepth = 5) {
 /**
  * Prüft ob ein Import verfügbar ist
  */
-function checkImport(importPath, importedName, fromFile, workspaceRoot) {
+function checkImport(importPath, importedName, fromFile, workspaceRoot, aliasMap) {
   
   // Resolve import path
   let targetFile;
@@ -148,6 +211,14 @@ function checkImport(importPath, importedName, fromFile, workspaceRoot) {
         targetFile = path.join(targetFile, 'index.js');
       }
     }
+    
+    // Versuche mit Alias-Map, wenn Datei nicht gefunden wurde
+    if (!fs.existsSync(targetFile) && aliasMap) {
+      const relativePath = path.relative(workspaceRoot, targetFile).replace(/\\/g, '/');
+      if (aliasMap[relativePath]) {
+        targetFile = path.join(workspaceRoot, aliasMap[relativePath]);
+      }
+    }
   } else {
     // Node module import - skip for now
     return true;
@@ -187,7 +258,7 @@ function checkImport(importPath, importedName, fromFile, workspaceRoot) {
 /**
  * Prüft alle Imports in einer Datei
  */
-function checkFileImports(filePath, workspaceRoot) {
+function checkFileImports(filePath, workspaceRoot, aliasMap) {
   const content = fs.readFileSync(filePath, 'utf8');
   const lines = content.split('\n');
   
@@ -230,7 +301,7 @@ function checkFileImports(filePath, workspaceRoot) {
     
     // Check each imported name
     importedNames.forEach(name => {
-      checkImport(importPath, name, filePath, workspaceRoot);
+      checkImport(importPath, name, filePath, workspaceRoot, aliasMap);
     });
   }
 }
@@ -267,14 +338,17 @@ function main() {
     }
   }
 
-  // src/ Verzeichnis finden (intelligente Suche)
-  const srcDir = findSrcDirectory(workspaceRoot);
+  // Lade Alias-Map
+  const aliasMap = loadAliasMap(workspaceRoot);
+  
+  // src/ Verzeichnis finden (intelligente Suche mit Alias-Map)
+  const srcDir = findSrcDirectoryWithAlias(workspaceRoot, workspaceRoot, aliasMap);
   if (!srcDir) {
     console.log('⚠️  src/ directory not found, skipping verification');
     console.log(`   Searched from: ${workspaceRoot}`);
     process.exit(0);
   }
-
+  
   // workspaceRoot auf Basis des gefundenen src/ korrigieren
   workspaceRoot = path.dirname(srcDir);
   
@@ -285,7 +359,7 @@ function main() {
   
   let checkedFiles = 0;
   for (const file of files) {
-    checkFileImports(file, workspaceRoot);
+    checkFileImports(file, workspaceRoot, aliasMap);
     checkedFiles++;
     
     if (checkedFiles % 10 === 0) {