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

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.10",
+  "version": "1.0.4-beta.12",
   "publisher": "noyrax",
   "repository": {
     "type": "git",

package/scripts/verify-adrs.js

@@ -241,15 +241,87 @@ function verifyClaim(claim, workspaceRoot) {
   return true;
 }
 
+/**
+ * Findet das docs/ Verzeichnis durch intelligente Suche.
+ * Sucht im gegebenen Verzeichnis und in Parent-Verzeichnissen (max. 5 Ebenen).
+ * 
+ * @param startDir Das Verzeichnis, von dem aus gesucht werden soll
+ * @param maxDepth Maximale Anzahl von Parent-Ebenen, die durchsucht werden sollen (default: 5)
+ * @returns Der Pfad zum docs/ Verzeichnis oder null, wenn nicht gefunden
+ */
+function findDocsDirectory(startDir, maxDepth = 5) {
+  let currentDir = path.resolve(startDir);
+  let depth = 0;
+
+  while (depth < maxDepth) {
+    const docsPath = path.join(currentDir, 'docs');
+    if (fs.existsSync(docsPath)) {
+      const stats = fs.statSync(docsPath);
+      if (stats.isDirectory()) {
+        return docsPath;
+      }
+    }
+
+    const parentDir = path.dirname(currentDir);
+    
+    // Stop if we've reached the root (parent equals current)
+    if (parentDir === currentDir) {
+      break;
+    }
+
+    currentDir = parentDir;
+    depth++;
+  }
+
+  return null;
+}
+
 /**
  * Hauptfunktion
  */
 function main() {
-  const workspaceRoot = path.join(__dirname, '..');
-  const adrDir = path.join(workspaceRoot, 'docs', 'adr');
+  // Workspace-Root bestimmen:
+  // 1. Falls als erstes Argument übergeben, verwenden
+  // 2. Sonst process.cwd() verwenden (wird vom MCP-Tool als cwd gesetzt)
+  // 3. Fallback: __dirname + '/..' (für Kompatibilität mit direktem Aufruf)
+  let workspaceRoot;
+  
+  if (process.argv.length >= 3 && process.argv[2] !== '--' && process.argv[2] !== '--verbose') {
+    // Erstes Argument ist Workspace-Root (vor -- oder --verbose)
+    workspaceRoot = path.resolve(process.argv[2]);
+    // Argument aus process.argv entfernen, damit --verbose weiterhin funktioniert
+    process.argv.splice(2, 1);
+  } else {
+    // Standard: process.cwd() (wird vom MCP-Tool als cwd gesetzt)
+    workspaceRoot = process.cwd();
+    
+    // Fallback: __dirname + '/..' (nur wenn process.cwd() nicht das richtige Verzeichnis ist)
+    // Prüfe, ob docs/ in process.cwd() gefunden werden kann
+    const docsFromCwd = findDocsDirectory(workspaceRoot);
+    if (!docsFromCwd) {
+      // Fallback: Versuche __dirname + '/..'
+      const fallbackRoot = path.join(__dirname, '..');
+      const docsFromFallback = findDocsDirectory(fallbackRoot);
+      if (docsFromFallback) {
+        workspaceRoot = fallbackRoot;
+      }
+    }
+  }
+
+  // docs/ Verzeichnis finden (intelligente Suche)
+  const docsPath = findDocsDirectory(workspaceRoot);
+  if (!docsPath) {
+    console.log('⚠️  ADR directory not found, skipping verification');
+    console.log(`   Searched from: ${workspaceRoot}`);
+    process.exit(0);
+  }
+
+  const adrDir = path.join(docsPath, 'adr');
   
   if (!fs.existsSync(adrDir)) {
     console.log('⚠️  ADR directory not found, skipping verification');
+    console.log(`   Docs directory found: ${docsPath}`);
+    console.log(`   ADR directory expected: ${adrDir}`);
     process.exit(0);
   }
   

package/scripts/verify-architecture.js

@@ -16,14 +16,54 @@ const { execSync } = require('child_process');
 const errors = [];
 const warnings = [];
 
+/**
+ * Findet ein Verzeichnis durch intelligente Suche.
+ * Sucht im gegebenen Verzeichnis und in Parent-Verzeichnissen (max. 5 Ebenen).
+ * 
+ * @param startDir Das Verzeichnis, von dem aus gesucht werden soll
+ * @param targetPath Relativer Pfad zum gesuchten Verzeichnis (z.B. 'mcp/src' oder 'package.json')
+ * @param maxDepth Maximale Anzahl von Parent-Ebenen, die durchsucht werden sollen (default: 5)
+ * @returns Der Pfad zum Verzeichnis/File oder null, wenn nicht gefunden
+ */
+function findDirectoryOrFile(startDir, targetPath, maxDepth = 5) {
+  let currentDir = path.resolve(startDir);
+  let depth = 0;
+
+  while (depth < maxDepth) {
+    const targetFullPath = path.join(currentDir, targetPath);
+    if (fs.existsSync(targetFullPath)) {
+      return targetFullPath;
+    }
+
+    const parentDir = path.dirname(currentDir);
+    
+    // Stop if we've reached the root (parent equals current)
+    if (parentDir === currentDir) {
+      break;
+    }
+
+    currentDir = parentDir;
+    depth++;
+  }
+
+  return null;
+}
+
 /**
  * Prüft ob mcp/ direkt nach src/ importiert
  */
-function checkMcpToSrcImports() {
+function checkMcpToSrcImports(workspaceRoot) {
   console.log('🔍 Checking for invalid imports from mcp/ to src/...');
   
-  const mcpSrcDir = path.join(__dirname, '..', 'mcp', 'src');
-  if (!fs.existsSync(mcpSrcDir)) {
+  // Suche mcp/src relativ zu workspaceRoot
+  let mcpSrcDir = findDirectoryOrFile(workspaceRoot, 'mcp/src');
+  if (!mcpSrcDir) {
+    // Fallback: Versuche __dirname + '/..' (Plugin-interne Suche)
+    const fallbackRoot = path.join(__dirname, '..');
+    mcpSrcDir = findDirectoryOrFile(fallbackRoot, 'mcp/src');
+  }
+  
+  if (!mcpSrcDir) {
     console.log('⚠️  mcp/src directory not found, skipping check');
     return;
   }
@@ -82,13 +122,30 @@ function checkImportDirections() {
 /**
  * Prüft package.json type Feld
  */
-function checkPackageJsonType() {
+function checkPackageJsonType(workspaceRoot) {
   console.log('🔍 Checking package.json type fields...');
   
-  const rootPackageJson = path.join(__dirname, '..', 'package.json');
-  const mcpPackageJson = path.join(__dirname, '..', 'mcp', 'package.json');
+  // Suche package.json relativ zu workspaceRoot
+  let rootPackageJson = findDirectoryOrFile(workspaceRoot, 'package.json');
+  if (!rootPackageJson) {
+    // Fallback: Versuche __dirname + '/..' (Plugin-interne Suche)
+    const fallbackRoot = path.join(__dirname, '..');
+    rootPackageJson = findDirectoryOrFile(fallbackRoot, 'package.json');
+  }
   
-  if (fs.existsSync(rootPackageJson)) {
+  let mcpPackageJson = findDirectoryOrFile(workspaceRoot, 'mcp/package.json');
+  if (!mcpPackageJson && rootPackageJson) {
+    // Wenn rootPackageJson gefunden wurde, versuche mcp/package.json relativ dazu
+    const rootDir = path.dirname(rootPackageJson);
+    mcpPackageJson = findDirectoryOrFile(rootDir, 'mcp/package.json');
+  }
+  if (!mcpPackageJson) {
+    // Fallback: Versuche __dirname + '/..' (Plugin-interne Suche)
+    const fallbackRoot = path.join(__dirname, '..');
+    mcpPackageJson = findDirectoryOrFile(fallbackRoot, 'mcp/package.json');
+  }
+  
+  if (rootPackageJson && fs.existsSync(rootPackageJson)) {
     const rootPkg = JSON.parse(fs.readFileSync(rootPackageJson, 'utf8'));
     if (!rootPkg.type) {
       console.log('✅ Root package.json has no type field (defaults to CommonJS)');
@@ -141,11 +198,39 @@ function getAllTsFiles(dir) {
  * Hauptfunktion
  */
 function main() {
+  // Workspace-Root bestimmen:
+  // 1. Falls als erstes Argument übergeben, verwenden
+  // 2. Sonst process.cwd() verwenden (wird vom MCP-Tool als cwd gesetzt)
+  // 3. Fallback: __dirname + '/..' (für Kompatibilität mit direktem Aufruf)
+  let workspaceRoot;
+  
+  if (process.argv.length >= 3 && process.argv[2] !== '--' && process.argv[2] !== '--verbose') {
+    // Erstes Argument ist Workspace-Root (vor -- oder --verbose)
+    workspaceRoot = path.resolve(process.argv[2]);
+    // Argument aus process.argv entfernen, damit --verbose weiterhin funktioniert
+    process.argv.splice(2, 1);
+  } else {
+    // Standard: process.cwd() (wird vom MCP-Tool als cwd gesetzt)
+    workspaceRoot = process.cwd();
+    
+    // Fallback: __dirname + '/..' (nur wenn process.cwd() nicht das richtige Verzeichnis ist)
+    // Prüfe, ob package.json in process.cwd() gefunden werden kann
+    const packageJsonFromCwd = findDirectoryOrFile(workspaceRoot, 'package.json');
+    if (!packageJsonFromCwd) {
+      // Fallback: Versuche __dirname + '/..'
+      const fallbackRoot = path.join(__dirname, '..');
+      const packageJsonFromFallback = findDirectoryOrFile(fallbackRoot, 'package.json');
+      if (packageJsonFromFallback) {
+        workspaceRoot = fallbackRoot;
+      }
+    }
+  }
+
   console.log('🚀 Starting architecture verification...\n');
   
-  checkMcpToSrcImports();
+  checkMcpToSrcImports(workspaceRoot);
   checkImportDirections();
-  checkPackageJsonType();
+  checkPackageJsonType(workspaceRoot);
   
   console.log('\n📊 Verification Summary:');
   console.log(`   Errors: ${errors.length}`);

package/scripts/verify-imports.js

@@ -88,11 +88,45 @@ function extractExports(filePath) {
   return exports;
 }
 
+/**
+ * Findet das src/ Verzeichnis durch intelligente Suche.
+ * Sucht im gegebenen Verzeichnis und in Parent-Verzeichnissen (max. 5 Ebenen).
+ * 
+ * @param startDir Das Verzeichnis, von dem aus gesucht werden soll
+ * @param maxDepth Maximale Anzahl von Parent-Ebenen, die durchsucht werden sollen (default: 5)
+ * @returns Der Pfad zum src/ Verzeichnis oder null, wenn nicht gefunden
+ */
+function findSrcDirectory(startDir, maxDepth = 5) {
+  let currentDir = path.resolve(startDir);
+  let depth = 0;
+
+  while (depth < maxDepth) {
+    const srcPath = path.join(currentDir, 'src');
+    if (fs.existsSync(srcPath)) {
+      const stats = fs.statSync(srcPath);
+      if (stats.isDirectory()) {
+        return srcPath;
+      }
+    }
+
+    const parentDir = path.dirname(currentDir);
+    
+    // Stop if we've reached the root (parent equals current)
+    if (parentDir === currentDir) {
+      break;
+    }
+
+    currentDir = parentDir;
+    depth++;
+  }
+
+  return null;
+}
+
 /**
  * Prüft ob ein Import verfügbar ist
  */
-function checkImport(importPath, importedName, fromFile) {
-  const workspaceRoot = path.join(__dirname, '..');
+function checkImport(importPath, importedName, fromFile, workspaceRoot) {
   
   // Resolve import path
   let targetFile;
@@ -196,7 +230,7 @@ function checkFileImports(filePath, workspaceRoot) {
     
     // Check each imported name
     importedNames.forEach(name => {
-      checkImport(importPath, name, filePath);
+      checkImport(importPath, name, filePath, workspaceRoot);
     });
   }
 }
@@ -205,16 +239,46 @@ function checkFileImports(filePath, workspaceRoot) {
  * Hauptfunktion
  */
 function main() {
-  const workspaceRoot = path.join(__dirname, '..');
-  
-  console.log('🚀 Starting import verification...\n');
+  // Workspace-Root bestimmen:
+  // 1. Falls als erstes Argument übergeben, verwenden
+  // 2. Sonst process.cwd() verwenden (wird vom MCP-Tool als cwd gesetzt)
+  // 3. Fallback: __dirname + '/..' (für Kompatibilität mit direktem Aufruf)
+  let workspaceRoot;
   
-  // Check src/ directory
-  const srcDir = path.join(workspaceRoot, 'src');
-  if (!fs.existsSync(srcDir)) {
+  if (process.argv.length >= 3 && process.argv[2] !== '--' && process.argv[2] !== '--verbose') {
+    // Erstes Argument ist Workspace-Root (vor -- oder --verbose)
+    workspaceRoot = path.resolve(process.argv[2]);
+    // Argument aus process.argv entfernen, damit --verbose weiterhin funktioniert
+    process.argv.splice(2, 1);
+  } else {
+    // Standard: process.cwd() (wird vom MCP-Tool als cwd gesetzt)
+    workspaceRoot = process.cwd();
+    
+    // Fallback: __dirname + '/..' (nur wenn process.cwd() nicht das richtige Verzeichnis ist)
+    // Prüfe, ob src/ in process.cwd() gefunden werden kann
+    const srcFromCwd = findSrcDirectory(workspaceRoot);
+    if (!srcFromCwd) {
+      // Fallback: Versuche __dirname + '/..'
+      const fallbackRoot = path.join(__dirname, '..');
+      const srcFromFallback = findSrcDirectory(fallbackRoot);
+      if (srcFromFallback) {
+        workspaceRoot = fallbackRoot;
+      }
+    }
+  }
+
+  // src/ Verzeichnis finden (intelligente Suche)
+  const srcDir = findSrcDirectory(workspaceRoot);
+  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);
+  
+  console.log('🚀 Starting import verification...\n');
   
   const files = getAllTsFiles(srcDir);
   console.log(`📁 Found ${files.length} TypeScript files\n`);