@noyrax/documentation-system-plugin 1.0.4-beta.1

package/package.json

@@ -0,0 +1,306 @@
+{
+  "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.1",
+  "publisher": "noyrax",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/noyrax/noyrax.git",
+    "directory": "documentation-system-plugin"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://noyrax.dev",
+  "bugs": {
+    "url": "https://github.com/noyrax/noyrax/issues"
+  },
+  "engines": {
+    "vscode": "^1.75.0"
+  },
+  "categories": [
+    "Documentation",
+    "Linters",
+    "Other"
+  ],
+  "keywords": [
+    "noyrax",
+    "documentation",
+    "docs-as-code",
+    "drift-detection",
+    "validation",
+    "typescript",
+    "python",
+    "code-analysis",
+    "ai-agent",
+    "mcp"
+  ],
+  "main": "./out/extension.js",
+  "activationEvents": [
+    "onStartupFinished"
+  ],
+  "contributes": {
+    "commands": [
+      {
+        "command": "noyrax.generate",
+        "title": "Noyrax: Generate Documentation",
+        "category": "Noyrax",
+        "icon": "$(file-text)"
+      },
+      {
+        "command": "noyrax.scan",
+        "title": "Noyrax: Scan Project",
+        "category": "Noyrax",
+        "icon": "$(search)"
+      },
+      {
+        "command": "noyrax.search",
+        "title": "Noyrax: Search in Documentation",
+        "category": "Noyrax",
+        "icon": "$(search)"
+      },
+      {
+        "command": "noyrax.validate",
+        "title": "Noyrax: Validate Documentation",
+        "category": "Noyrax",
+        "icon": "$(check)"
+      },
+      {
+        "command": "noyrax.drift",
+        "title": "Noyrax: Check for Drift",
+        "category": "Noyrax",
+        "icon": "$(warning)"
+      },
+      {
+        "command": "noyrax.open",
+        "title": "Noyrax: Open Documentation File",
+        "category": "Noyrax",
+        "icon": "$(file)"
+      },
+      {
+        "command": "noyrax.overview",
+        "title": "Noyrax: Show System Overview",
+        "category": "Noyrax",
+        "icon": "$(graph)"
+      },
+      {
+        "command": "noyrax.sync",
+        "title": "Noyrax: Sync Documentation",
+        "category": "Noyrax",
+        "icon": "$(sync)"
+      },
+      {
+        "command": "noyrax.fullCycle",
+        "title": "Noyrax: Full Cycle (Scan → Generate → Validate)",
+        "category": "Noyrax",
+        "icon": "$(sync)"
+      }
+    ],
+    "views": {
+      "explorer": [
+        {
+          "id": "noyraxExplorer",
+          "name": "Noyrax",
+          "when": "workspaceFolderCount > 0",
+          "icon": "$(book)"
+        }
+      ],
+      "noyraxPanel": [
+        {
+          "id": "noyraxCommands",
+          "name": "Noyrax Commands",
+          "when": "workspaceFolderCount > 0"
+        }
+      ]
+    },
+    "viewsContainers": {
+      "activitybar": [
+        {
+          "id": "noyraxPanel",
+          "title": "Noyrax",
+          "icon": "$(book)"
+        }
+      ]
+    },
+    "configuration": {
+      "title": "Noyrax",
+      "properties": {
+        "noyrax.workspaceRoot": {
+          "type": "string",
+          "default": "${workspaceFolder}",
+          "description": "Root directory of the workspace"
+        },
+        "noyrax.outputPath": {
+          "type": "string",
+          "default": "docs",
+          "description": "Output directory for generated documentation"
+        },
+        "noyrax.coverageThresholds.classes": {
+          "type": "number",
+          "default": 0.9,
+          "description": "Coverage threshold for public classes (0..1)"
+        },
+        "noyrax.coverageThresholds.interfaces": {
+          "type": "number",
+          "default": 0.9,
+          "description": "Coverage threshold for public interfaces (0..1)"
+        },
+        "noyrax.coverageThresholds.methods": {
+          "type": "number",
+          "default": 0.9,
+          "description": "Coverage threshold for public methods (0..1)"
+        },
+        "noyrax.coverageThresholds.functions": {
+          "type": "number",
+          "default": 0.8,
+          "description": "Coverage threshold for public functions (0..1)"
+        },
+        "noyrax.concurrency": {
+          "type": "number",
+          "default": 4,
+          "description": "Maximum parallelism for parsing/generating"
+        },
+        "noyrax.useGitDiff": {
+          "type": "boolean",
+          "default": true,
+          "description": "Only parse changed files (git diff)"
+        },
+        "noyrax.includeBackups": {
+          "type": "boolean",
+          "default": false,
+          "description": "Include backup/archive directories in scan"
+        },
+        "noyrax.includePrivate": {
+          "type": "boolean",
+          "default": false,
+          "description": "Include private/protected symbols in documentation"
+        },
+        "noyrax.blockOnDrift": {
+          "type": "boolean",
+          "default": false,
+          "description": "Show error instead of warning when drift is detected"
+        },
+        "noyrax.apiDoc.depth": {
+          "type": "string",
+          "enum": [
+            "full",
+            "standard",
+            "minimal"
+          ],
+          "default": "full",
+          "description": "Depth of generated API documentation for symbols (full | standard | minimal)."
+        },
+        "noyrax.apiDoc.includeInternal": {
+          "type": "boolean",
+          "default": false,
+          "description": "Also generate deep API documentation for internal (non-public) symbols."
+        }
+      }
+    },
+    "menus": {
+      "commandPalette": [
+        {
+          "command": "noyrax.generate",
+          "when": "workspaceFolderCount > 0"
+        },
+        {
+          "command": "noyrax.scan",
+          "when": "workspaceFolderCount > 0"
+        },
+        {
+          "command": "noyrax.validate",
+          "when": "workspaceFolderCount > 0"
+        }
+      ],
+      "view/title": [
+        {
+          "command": "noyrax.refresh",
+          "when": "view == noyraxExplorer",
+          "group": "navigation"
+        },
+        {
+          "command": "noyrax.generate",
+          "when": "view == noyraxCommands",
+          "group": "navigation@1"
+        },
+        {
+          "command": "noyrax.scan",
+          "when": "view == noyraxCommands",
+          "group": "navigation@2"
+        },
+        {
+          "command": "noyrax.validate",
+          "when": "view == noyraxCommands",
+          "group": "navigation@3"
+        }
+      ]
+    },
+    "keybindings": [
+      {
+        "command": "noyrax.scan",
+        "key": "ctrl+shift+n s",
+        "mac": "cmd+shift+n s",
+        "when": "workspaceFolderCount > 0"
+      },
+      {
+        "command": "noyrax.generate",
+        "key": "ctrl+shift+n g",
+        "mac": "cmd+shift+n g",
+        "when": "workspaceFolderCount > 0"
+      },
+      {
+        "command": "noyrax.validate",
+        "key": "ctrl+shift+n v",
+        "mac": "cmd+shift+n v",
+        "when": "workspaceFolderCount > 0"
+      },
+      {
+        "command": "noyrax.fullCycle",
+        "key": "ctrl+shift+n f",
+        "mac": "cmd+shift+n f",
+        "when": "workspaceFolderCount > 0"
+      }
+    ]
+  },
+  "scripts": {
+    "vscode:prepublish": "npm run compile",
+    "prepublishOnly": "npm run compile",
+    "compile": "tsc -p ./",
+    "watch": "tsc -watch -p ./",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "sonar": "sonar-scanner",
+    "sonar:local": "sonar-scanner -Dsonar.host.url=http://localhost:9000",
+    "sonar:cloud": "sonar-scanner -Dsonar.host.url=https://sonarcloud.io -Dsonar.login=${SONAR_TOKEN}",
+    "quality": "npm run test && npm run sonar:cloud",
+    "package": "vsce package",
+    "publish": "vsce publish",
+    "publish:npm": "npm publish --access public",
+    "scan:cli": "node out/cli/scan-cli.js",
+    "validate:cli": "node out/cli/validate-cli.js",
+    "generate:cli": "node out/cli/generate-cli.js",
+    "verify:all": "node scripts/verify-architecture.js && node scripts/verify-adrs.js && node scripts/verify-imports.js",
+    "verify:architecture": "node scripts/verify-architecture.js",
+    "verify:adrs": "node scripts/verify-adrs.js",
+    "verify:imports": "node scripts/verify-imports.js"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "16.x",
+    "@types/vscode": "^1.74.0",
+    "@vscode/vsce": "^2.22.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^4.9.4"
+  },
+  "dependencies": {
+    "@noyrax/5d-database-plugin": "file:../database-plugin",
+    "@types/yaml": "^1.9.6",
+    "ignore": "^5.3.2",
+    "tree-sitter": "^0.21.1",
+    "tree-sitter-python": "^0.21.0",
+    "ts-morph": "^22.0.0",
+    "yaml": "^2.8.1"
+  }
+}

package/publish.ps1

@@ -0,0 +1,21 @@
+# Publish Script für noyrax
+# Führt npm login und publish direkt nacheinander aus
+
+Write-Host "Schritt 1: npm login..." -ForegroundColor Yellow
+npm login
+
+if ($LASTEXITCODE -ne 0) {
+    Write-Host "Login fehlgeschlagen!" -ForegroundColor Red
+    exit 1
+}
+
+Write-Host "`nSchritt 2: npm publish..." -ForegroundColor Yellow
+npm publish --access public
+
+if ($LASTEXITCODE -eq 0) {
+    Write-Host "`n✅ Erfolgreich veröffentlicht!" -ForegroundColor Green
+} else {
+    Write-Host "`n❌ Publish fehlgeschlagen!" -ForegroundColor Red
+    exit 1
+}
+

package/scripts/verify-adrs.js

@@ -0,0 +1,312 @@
+#!/usr/bin/env node
+
+/**
+ * Verification Script: ADR Claims
+ * 
+ * Prüft ADR-Claims gegen Code:
+ * - Dateien existieren (Pattern: `Erstelle \`src/path/file.ts\``)
+ * - Funktionen existieren (Pattern: `functionName()`)
+ * - Imports funktionieren
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const errors = [];
+const warnings = [];
+
+/**
+ * Rekursive Suche nach einem Pattern in einem Verzeichnis
+ */
+function searchInDirectory(dir, pattern) {
+  const regex = new RegExp(`\\b${pattern}\\b`);
+  const files = fs.readdirSync(dir);
+  
+  for (const file of files) {
+    const filePath = path.join(dir, file);
+    const stat = fs.statSync(filePath);
+    
+    if (stat.isDirectory()) {
+      if (searchInDirectory(filePath, pattern)) {
+        return true;
+      }
+    } else if (file.endsWith('.ts') || file.endsWith('.js')) {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      if (regex.test(content)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Extrahiert Claims aus einem ADR
+ */
+function extractClaimsFromAdr(adrPath) {
+  const content = fs.readFileSync(adrPath, 'utf-8');
+  const claims = [];
+  
+  // Pattern: "Erstelle `src/path/file.ts`"
+  // Pattern: "Erstelle: `src/path/file.ts`"
+  // Pattern: "- `src/path/file.ts`"
+  const createPattern = /(?:Erstelle|Erstellt|Erstellen|Create|Created|Creates)\s*:?\s*`([^`]+)`/gi;
+  let match;
+  while ((match = createPattern.exec(content)) !== null) {
+    const filePath = match[1].trim();
+    // Ignoriere Markdown-Links und andere nicht-Datei-Pfade
+    if (filePath.match(/\.(ts|js|json|md|yml|yaml)$/)) {
+      claims.push({
+        type: 'file-exists',
+        file: filePath,
+        adr: path.basename(adrPath),
+        line: content.substring(0, match.index).split('\n').length
+      });
+    }
+  }
+  
+  // Pattern: "function foo()" oder "function foo("
+  // Pattern: "export function foo()"
+  // Pattern: "class Foo"
+  // Pattern: "export class Foo"
+  const funcPattern = /(?:export\s+)?(?:function|class|const|let|var)\s+(\w+)/g;
+  const funcMatches = [];
+  while ((match = funcPattern.exec(content)) !== null) {
+    const funcName = match[1];
+    // Nur wenn es in einem Code-Block oder als Claim erwähnt wird
+    const context = content.substring(Math.max(0, match.index - 50), match.index + 50);
+    if (context.includes('```') || context.includes('`') || context.includes('implementiert')) {
+      funcMatches.push({
+        name: funcName,
+        adr: path.basename(adrPath),
+        line: content.substring(0, match.index).split('\n').length
+      });
+    }
+  }
+  
+  // Vereinfachte Funktion-Claims: Nur wenn explizit erwähnt
+  const explicitFuncPattern = /(?:implementiert|implemented|erstellt|created)\s+(?:die\s+)?(?:Funktion|function|Klasse|class)\s+`?(\w+)`?/gi;
+  while ((match = explicitFuncPattern.exec(content)) !== null) {
+    const funcName = match[1];
+    if (!funcMatches.find(f => f.name === funcName)) {
+      funcMatches.push({
+        name: funcName,
+        adr: path.basename(adrPath),
+        line: content.substring(0, match.index).split('\n').length,
+        explicit: true
+      });
+    }
+  }
+  
+  // Pattern für automatisch generierte ADRs: Funktionen/Klassen in Backticks unter "Hauptfunktionen" oder "Hauptklassen"
+  // Pattern: "- `FunctionName()`" oder "- `ClassName`" oder "`FunctionName.`"
+  const autoGenPattern = /(?:Hauptfunktionen|Hauptklassen|Functions|Classes)[\s\S]*?`([A-Za-z_][A-Za-z0-9_]*)(?:\(|\.|`)/g;
+  while ((match = autoGenPattern.exec(content)) !== null) {
+    const funcName = match[1];
+    // Ignoriere generische Namen und Methoden-Namen (nur Klassen/Funktionen auf oberster Ebene)
+    const ignoreList = ['other', 'unknown', 'getChildren', 'getTreeItem', 'refresh', 'getDocumentationFiles', 'Thenable', 'TreeItem', 'ExtensionContext'];
+    if (!ignoreList.includes(funcName) && funcName.length > 2) {
+      if (!funcMatches.find(f => f.name === funcName)) {
+        funcMatches.push({
+          name: funcName,
+          adr: path.basename(adrPath),
+          line: content.substring(0, match.index).split('\n').length,
+          explicit: false, // Nicht explizit, aber sollte existieren
+          autoGenerated: true
+        });
+      }
+    }
+  }
+  
+  // Zusätzliches Pattern: Funktionen/Klassen die direkt in Backticks erwähnt werden (z.B. "`activate()`")
+  const backtickPattern = /`([A-Za-z_][A-Za-z0-9_]*)\(\)`/g;
+  while ((match = backtickPattern.exec(content)) !== null) {
+    const funcName = match[1];
+    // Nur wenn es in einem relevanten Kontext ist (nicht in Code-Blöcken)
+    const contextBefore = content.substring(Math.max(0, match.index - 100), match.index);
+    const contextAfter = content.substring(match.index, Math.min(content.length, match.index + 100));
+    // Ignoriere Code-Blöcke (```)
+    if (!contextBefore.includes('```') && !contextAfter.includes('```')) {
+      // Nur wenn es in einem relevanten Abschnitt ist
+      if (contextBefore.includes('Hauptfunktionen') || contextBefore.includes('Functions') || 
+          contextBefore.includes('activate') || contextBefore.includes('deactivate')) {
+        if (!funcMatches.find(f => f.name === funcName)) {
+          funcMatches.push({
+            name: funcName,
+            adr: path.basename(adrPath),
+            line: content.substring(0, match.index).split('\n').length,
+            explicit: false,
+            autoGenerated: true
+          });
+        }
+      }
+    }
+  }
+  
+  claims.push(...funcMatches.map(f => ({
+    type: 'function-exists',
+    name: f.name,
+    adr: f.adr,
+    line: f.line,
+    explicit: f.explicit
+  })));
+  
+  return claims;
+}
+
+/**
+ * Verifiziert einen Claim
+ */
+function verifyClaim(claim, workspaceRoot) {
+  if (claim.type === 'file-exists') {
+    const fullPath = path.join(workspaceRoot, claim.file);
+    const exists = fs.existsSync(fullPath);
+    
+    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));
+      
+      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} 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)) {
+        warnings.push({
+          adr: claim.adr,
+          line: claim.line,
+          claim: `Could not verify function ${claim.name} (src/ directory not found)`,
+          type: 'function-exists'
+        });
+        return true;
+      }
+      
+      // Rekursive Suche in TypeScript-Dateien
+      const found = searchInDirectory(srcDir, claim.name);
+      
+      if (!found) {
+        if (claim.explicit || claim.autoGenerated) {
+          // Explizite Claims und auto-generierte Claims sollten existieren
+          errors.push({
+            adr: claim.adr,
+            line: claim.line,
+            claim: `Function/class ${claim.name} not found in codebase${claim.autoGenerated ? ' (auto-generated ADR)' : ''}`,
+            type: 'function-exists'
+          });
+          return false;
+        } else {
+          // Nicht-explizite Claims sind nur Warnungen
+          warnings.push({
+            adr: claim.adr,
+            line: claim.line,
+            claim: `Function/class ${claim.name} mentioned but not found (may be non-critical)`,
+            type: 'function-exists'
+          });
+          return true;
+        }
+      }
+      return true;
+    } catch (error) {
+      warnings.push({
+        adr: claim.adr,
+        line: claim.line,
+        claim: `Could not verify function ${claim.name}: ${error.message}`,
+        type: 'function-exists'
+      });
+      return true; // Nicht kritisch wenn Verification fehlschlägt
+    }
+  }
+  
+  return true;
+}
+
+/**
+ * Hauptfunktion
+ */
+function main() {
+  const workspaceRoot = path.join(__dirname, '..');
+  const adrDir = path.join(workspaceRoot, 'docs', 'adr');
+  
+  if (!fs.existsSync(adrDir)) {
+    console.log('⚠️  ADR directory not found, skipping verification');
+    process.exit(0);
+  }
+  
+  console.log('🚀 Starting ADR claims verification...\n');
+  
+  const adrFiles = fs.readdirSync(adrDir).filter(f => f.endsWith('.md') && f !== 'TEMPLATE.md');
+  
+  let totalClaims = 0;
+  let verifiedClaims = 0;
+  
+  for (const adrFile of adrFiles) {
+    const adrPath = path.join(adrDir, adrFile);
+    const claims = extractClaimsFromAdr(adrPath);
+    
+    totalClaims += claims.length;
+    
+    for (const claim of claims) {
+      const verified = verifyClaim(claim, workspaceRoot);
+      if (verified) {
+        verifiedClaims++;
+      }
+    }
+  }
+  
+  console.log(`📊 Verification Summary:`);
+  console.log(`   Total claims: ${totalClaims}`);
+  console.log(`   Verified: ${verifiedClaims}`);
+  console.log(`   Errors: ${errors.length}`);
+  console.log(`   Warnings: ${warnings.length}`);
+  
+  if (errors.length > 0) {
+    console.log('\n❌ ERRORS:');
+    errors.forEach((err, index) => {
+      console.log(`   ${index + 1}. ${err.adr}:${err.line}`);
+      console.log(`      ${err.claim}`);
+    });
+  }
+  
+  if (warnings.length > 0 && process.argv.includes('--verbose')) {
+    console.log('\n⚠️  WARNINGS:');
+    warnings.forEach((warn, index) => {
+      console.log(`   ${index + 1}. ${warn.adr}:${warn.line}`);
+      console.log(`      ${warn.claim}`);
+    });
+  }
+  
+  if (errors.length > 0) {
+    console.log('\n❌ ADR verification FAILED');
+    console.log('   Run with --verbose to see warnings');
+    process.exit(1);
+  } else {
+    console.log('\n✅ ADR verification PASSED');
+    if (warnings.length > 0) {
+      console.log(`   (${warnings.length} warnings, run with --verbose to see details)`);
+    }
+    process.exit(0);
+  }
+}
+
+main();