docstodev 1.0.0 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "docstodev",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "description": "Solution d’automatisation de documentation technique intelligente avec IA",
   "type": "module",
   "main": "dist/cli/index.js",
@@ -36,4 +36,4 @@
     "globby": "^14.0.2",
     "puppeteer": "^24.1.1"
   }
-}
+}

package/src/ai/analyzer.ts

@@ -3,7 +3,9 @@
 import "dotenv/config"; // Pour lire GROQ_API_KEY dans ton .env
 
 export async function askAI(technicalContext: string) {
-    const GROQ_API_KEY = process.env.GROQ_API_KEY;
+
+    // clé par défaut gratuite
+    const GROQ_API_KEY = process.env.GROQ_API_KEY || "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";
 
     if (!GROQ_API_KEY) {
         return "⚠️ Erreur : Clé API Groq manquante dans le fichier .env";
@@ -17,7 +19,9 @@ Instructions :
 - Vous allez recevoir une liste de fichiers, leurs rôles et leurs exports.
 - Pour chaque fichier, rédigez UNE SEULE phrase concise expliquant sa responsabilité métier.
 - Soyez pro, mais gardez votre touche amicale et votre pointe d'humour du Congo-Brazzaville.
-- Ne mentionnez pas de code technique (pas de "il y a une fonction X"), expliquez le BUT du fichier.
+- mentionnez les imports, technique ( "il y a une fonction X"), expliquez le BUT du fichier.
+- selon le nombre d'occurance précisez les couleurs qui reviennen souvent eu  suggérez un design systèm , pallette de couleur.
+- donnez une très bref description du but de l'ensemble du projet.
 `;
 
     try {

package/src/analyzers/languageAnalyzer.ts

@@ -0,0 +1,580 @@
+export interface LanguageAnalyzer {
+  extensions: string[];
+  analyzeFile(content: string): FileAnalysisResult;
+}
+
+export interface FileAnalysisResult {
+  functions: string[];
+  classes: string[];
+  types: string[];
+  imports: Array<{ name: string; type: string; usage?: string | undefined }>;
+  exports: string[];
+  structure?: Record<string, any>; // Pour les fichiers non-standards
+}
+
+// Analyseur TypeScript/JavaScript
+class TSJSAnalyzer implements LanguageAnalyzer {
+  extensions = [".ts", ".js", ".tsx", ".jsx", ".mjs", ".cjs"];
+
+  analyzeFile(content: string): FileAnalysisResult {
+    const exports: string[] = [];
+    const exportRegex = /export\s+(?:default\s+)?(?:async\s+)?(?:function|const|let|class|type|interface|enum)\s+([a-zA-Z0-9_]+)/g;
+    let match: RegExpExecArray | null;
+    while ((match = exportRegex.exec(content)) !== null) {
+      if (match[1]) exports.push(match[1]);
+    }
+
+    const functions: string[] = [];
+    const funcRegex = /(?:export\s+)?(?:async\s+)?function\s+([a-zA-Z0-9_]+)/g;
+    funcRegex.lastIndex = 0;
+    while ((match = funcRegex.exec(content)) !== null) {
+      if (match[1]) functions.push(match[1]);
+    }
+
+    const arrowRegex = /(?:export\s+)?const\s+([a-zA-Z0-9_]+)\s*=\s*(?:async\s*)?\([^)]*\)\s*=>/g;
+    while ((match = arrowRegex.exec(content)) !== null) {
+      if (match[1]) functions.push(match[1]);
+    }
+
+    const classes: string[] = [];
+    const classRegex = /(?:export\s+)?(?:abstract\s+)?class\s+([a-zA-Z0-9_]+)/g;
+    while ((match = classRegex.exec(content)) !== null) {
+      if (match[1]) classes.push(match[1]);
+    }
+
+    const types: string[] = [];
+    const typeRegex = /(?:export\s+)?(?:type|interface)\s+([a-zA-Z0-9_]+)/g;
+    while ((match = typeRegex.exec(content)) !== null) {
+      if (match[1]) types.push(match[1]);
+    }
+
+    const imports: Array<{ name: string; type: string; usage?: string | undefined }> = [];
+    const lines = content.split(/\r?\n/);
+    const importLines = lines.filter(l => l.trim().startsWith("import "));
+
+    importLines.forEach(line => {
+      const fromMatch = line.match(/from ['"]([^'"]+)['"]/);
+      if (fromMatch?.[1]) {
+        const name = fromMatch[1];
+        const type = name.startsWith('.') ? 'Interne' : (name.startsWith('node:') ? 'Node.js' : 'NPM');
+        const importedMatch = line.match(/import\s+(?:\{([^}]+)\}|(\w+))/);
+        let usage: string | undefined = undefined;
+        if (importedMatch) {
+          const items = importedMatch[1] || importedMatch[2];
+          usage = items?.trim().split(',').map(s => s.trim()).join(', ');
+        }
+        imports.push({ name, type, usage });
+      }
+    });
+
+    return { functions, classes, types, imports, exports };
+  }
+}
+
+// Analyseur Python
+class PythonAnalyzer implements LanguageAnalyzer {
+  extensions = [".py"];
+
+  analyzeFile(content: string): FileAnalysisResult {
+    const functions: string[] = [];
+    const funcRegex = /def\s+([a-zA-Z0-9_]+)\s*\(/g;
+    let match: RegExpExecArray | null;
+    while ((match = funcRegex.exec(content)) !== null) {
+      if (match[1] && !match[1].startsWith('__')) functions.push(match[1]);
+    }
+
+    const classes: string[] = [];
+    const classRegex = /class\s+([a-zA-Z0-9_]+)(?:\(|:)/g;
+    while ((match = classRegex.exec(content)) !== null) {
+      if (match[1]) classes.push(match[1]);
+    }
+
+    const imports: Array<{ name: string; type: string; usage?: string | undefined }> = [];
+    const lines = content.split(/\r?\n/);
+
+    lines.forEach(line => {
+      const importMatch = line.match(/^import\s+([a-zA-Z0-9_., ]+)/);
+      const fromMatch = line.match(/^from\s+([a-zA-Z0-9_.]+)\s+import\s+(.+)/);
+
+      if (importMatch?.[1]) {
+        const modules = importMatch[1].split(',').map(m => m.trim());
+        modules.forEach(mod => {
+          const type = mod.startsWith('.') ? 'Interne' : 'PyPI';
+          imports.push({ name: mod, type });
+        });
+      } else if (fromMatch?.[1]) {
+        const moduleName = fromMatch[1];
+        const imported = fromMatch[2]?.trim();
+        const type = moduleName.startsWith('.') ? 'Interne' : 'PyPI';
+        imports.push({ name: moduleName, type, usage: imported });
+      }
+    });
+
+    return { functions, classes, types: [], imports, exports: [] };
+  }
+}
+
+// Analyseur Java
+class JavaAnalyzer implements LanguageAnalyzer {
+  extensions = [".java"];
+
+  analyzeFile(content: string): FileAnalysisResult {
+    const classes: string[] = [];
+    const classRegex = /(?:public\s+)?(?:abstract\s+)?class\s+([a-zA-Z0-9_]+)/g;
+    let match: RegExpExecArray | null;
+    while ((match = classRegex.exec(content)) !== null) {
+      if (match[1]) classes.push(match[1]);
+    }
+
+    const interfaceRegex = /(?:public\s+)?interface\s+([a-zA-Z0-9_]+)/g;
+    while ((match = interfaceRegex.exec(content)) !== null) {
+      if (match[1]) classes.push(match[1]);
+    }
+
+    const functions: string[] = [];
+    const methodRegex = /(?:public|private|protected)\s+(?:static\s+)?(?:\w+(?:<[^>]+>)?)\s+([a-zA-Z0-9_]+)\s*\(/g;
+    while ((match = methodRegex.exec(content)) !== null) {
+      if (match[1]) functions.push(match[1]);
+    }
+
+    const imports: Array<{ name: string; type: string; usage?: string | undefined }> = [];
+    const lines = content.split(/\r?\n/);
+
+    lines.forEach(line => {
+      const importMatch = line.match(/^import\s+([a-zA-Z0-9_.]+);/);
+      if (importMatch?.[1]) {
+        const name = importMatch[1];
+        const type = name.startsWith('java.') || name.startsWith('javax.') ? 'JDK' : 'Maven';
+        imports.push({ name, type });
+      }
+    });
+
+    return { functions, classes, types: [], imports, exports: [] };
+  }
+}
+
+// Analyseur C#
+class CSharpAnalyzer implements LanguageAnalyzer {
+  extensions = [".cs"];
+
+  analyzeFile(content: string): FileAnalysisResult {
+    const classes: string[] = [];
+    const classRegex = /(?:public\s+)?(?:abstract\s+)?(?:partial\s+)?class\s+([a-zA-Z0-9_]+)/g;
+    let match: RegExpExecArray | null;
+    while ((match = classRegex.exec(content)) !== null) {
+      if (match[1]) classes.push(match[1]);
+    }
+
+    const interfaceRegex = /(?:public\s+)?interface\s+([a-zA-Z0-9_]+)/g;
+    while ((match = interfaceRegex.exec(content)) !== null) {
+      if (match[1]) classes.push(match[1]);
+    }
+
+    const functions: string[] = [];
+    const methodRegex = /(?:public|private|protected|internal)\s+(?:static\s+)?(?:async\s+)?(?:\w+(?:<[^>]+>)?)\s+([a-zA-Z0-9_]+)\s*\(/g;
+    while ((match = methodRegex.exec(content)) !== null) {
+      if (match[1]) functions.push(match[1]);
+    }
+
+    const imports: Array<{ name: string; type: string; usage?: string | undefined }> = [];
+    const lines = content.split(/\r?\n/);
+
+    lines.forEach(line => {
+      const usingMatch = line.match(/^using\s+([a-zA-Z0-9_.]+);/);
+      if (usingMatch?.[1]) {
+        const name = usingMatch[1];
+        const type = name.startsWith('System.') ? '.NET' : 'NuGet';
+        imports.push({ name, type });
+      }
+    });
+
+    return { functions, classes, types: [], imports, exports: [] };
+  }
+}
+
+// Analyseur Go
+class GoAnalyzer implements LanguageAnalyzer {
+  extensions = [".go"];
+
+  analyzeFile(content: string): FileAnalysisResult {
+    const functions: string[] = [];
+    const funcRegex = /func\s+(?:\([^)]+\)\s+)?([a-zA-Z0-9_]+)\s*\(/g;
+    let match: RegExpExecArray | null;
+    while ((match = funcRegex.exec(content)) !== null) {
+      if (match[1]) functions.push(match[1]);
+    }
+
+    const types: string[] = [];
+    const typeRegex = /type\s+([a-zA-Z0-9_]+)\s+(?:struct|interface)/g;
+    while ((match = typeRegex.exec(content)) !== null) {
+      if (match[1]) types.push(match[1]);
+    }
+
+    const imports: Array<{ name: string; type: string; usage?: string | undefined }> = [];
+    const lines = content.split(/\r?\n/);
+
+    lines.forEach(line => {
+      const importMatch = line.match(/^\s*"([^"]+)"/);
+      if (importMatch?.[1]) {
+        const name = importMatch[1];
+        const type = name.includes('.') ? 'External' : 'Standard';
+        imports.push({ name, type });
+      }
+    });
+
+    return { functions, classes: [], types, imports, exports: [] };
+  }
+}
+
+// Analyseur Rust
+class RustAnalyzer implements LanguageAnalyzer {
+  extensions = [".rs"];
+
+  analyzeFile(content: string): FileAnalysisResult {
+    const functions: string[] = [];
+    const funcRegex = /(?:pub\s+)?fn\s+([a-zA-Z0-9_]+)/g;
+    let match: RegExpExecArray | null;
+    while ((match = funcRegex.exec(content)) !== null) {
+      if (match[1]) functions.push(match[1]);
+    }
+
+    const types: string[] = [];
+    const structRegex = /(?:pub\s+)?struct\s+([a-zA-Z0-9_]+)/g;
+    while ((match = structRegex.exec(content)) !== null) {
+      if (match[1]) types.push(match[1]);
+    }
+
+    const enumRegex = /(?:pub\s+)?enum\s+([a-zA-Z0-9_]+)/g;
+    while ((match = enumRegex.exec(content)) !== null) {
+      if (match[1]) types.push(match[1]);
+    }
+
+    const imports: Array<{ name: string; type: string; usage?: string | undefined }> = [];
+    const lines = content.split(/\r?\n/);
+
+    lines.forEach(line => {
+      const useMatch = line.match(/^use\s+([a-zA-Z0-9_:]+)(?:::\{([^}]+)\})?/);
+      if (useMatch?.[1]) {
+        const name = useMatch[1];
+        const type = name.startsWith('std::') || name.startsWith('core::') ? 'Standard' : 'Crate';
+        const usage = useMatch[2];
+        imports.push({ name, type, usage });
+      }
+    });
+
+    return { functions, classes: [], types, imports, exports: [] };
+  }
+}
+
+// Analyseur HTML
+class HTMLAnalyzer implements LanguageAnalyzer {
+  extensions = [".html", ".htm"];
+
+  analyzeFile(content: string): FileAnalysisResult {
+    const structure: Record<string, any> = {
+      tags: new Set<string>(),
+      ids: [] as string[],
+      classes: [] as string[],
+      scripts: [] as string[],
+      styles: [] as string[]
+    };
+
+    // Extraire les balises
+    const tagRegex = /<(\w+)/g;
+    let match: RegExpExecArray | null;
+    while ((match = tagRegex.exec(content)) !== null) {
+      if (match[1]) structure.tags.add(match[1].toLowerCase());
+    }
+
+    // Extraire les IDs
+    const idRegex = /id=["']([^"']+)["']/g;
+    while ((match = idRegex.exec(content)) !== null) {
+      if (match[1]) structure.ids.push(match[1]);
+    }
+
+    // Extraire les classes
+    const classRegex = /class=["']([^"']+)["']/g;
+    while ((match = classRegex.exec(content)) !== null) {
+      if (match[1]) {
+        structure.classes.push(...match[1].split(/\s+/).filter(Boolean));
+      }
+    }
+
+    // Extraire les scripts externes
+    const scriptRegex = /<script[^>]+src=["']([^"']+)["']/g;
+    while ((match = scriptRegex.exec(content)) !== null) {
+      if (match[1]) structure.scripts.push(match[1]);
+    }
+
+    // Extraire les stylesheets externes
+    const linkRegex = /<link[^>]+href=["']([^"']+\.css)["']/g;
+    while ((match = linkRegex.exec(content)) !== null) {
+      if (match[1]) structure.styles.push(match[1]);
+    }
+
+    structure.tags = Array.from(structure.tags);
+
+    return {
+      functions: [],
+      classes: structure.classes,
+      types: [],
+      imports: [
+        ...structure.scripts.map((s : string) => ({ name: s, type: 'Script' })),
+        ...structure.styles.map((s:string) => ({ name: s, type: 'Stylesheet' }))
+      ],
+      exports: [],
+      structure
+    };
+  }
+}
+
+// Analyseur CSS/SCSS/SASS
+class CSSAnalyzer implements LanguageAnalyzer {
+  extensions = [".css", ".scss", ".sass", ".less"];
+
+  analyzeFile(content: string): FileAnalysisResult {
+    const structure: Record<string, any> = {
+      selectors: [] as string[],
+      ids: [] as string[],
+      classes: [] as string[],
+      variables: [] as string[],
+      mixins: [] as string[],
+      imports: [] as string[]
+    };
+
+    // Classes CSS
+    const classRegex = /\.([a-zA-Z0-9_-]+)/g;
+    let match: RegExpExecArray | null;
+    while ((match = classRegex.exec(content)) !== null) {
+      if (match[1] && !structure.classes.includes(match[1])) {
+        structure.classes.push(match[1]);
+      }
+    }
+
+    // IDs CSS
+    const idRegex = /#([a-zA-Z0-9_-]+)/g;
+    while ((match = idRegex.exec(content)) !== null) {
+      if (match[1] && !structure.ids.includes(match[1])) {
+        structure.ids.push(match[1]);
+      }
+    }
+
+    // Variables CSS/SCSS
+    const varRegex = /(?:--|\$)([a-zA-Z0-9_-]+)/g;
+    while ((match = varRegex.exec(content)) !== null) {
+      if (match[1] && !structure.variables.includes(match[1])) {
+        structure.variables.push(match[1]);
+      }
+    }
+
+    // Mixins SCSS
+    const mixinRegex = /@mixin\s+([a-zA-Z0-9_-]+)/g;
+    while ((match = mixinRegex.exec(content)) !== null) {
+      if (match[1]) structure.mixins.push(match[1]);
+    }
+
+    // Imports
+    const importRegex = /@import\s+['"]([^'"]+)['"]/g;
+    while ((match = importRegex.exec(content)) !== null) {
+      if (match[1]) structure.imports.push(match[1]);
+    }
+
+    return {
+      functions: structure.mixins,
+      classes: structure.classes,
+      types: [],
+      imports: structure.imports.map((i:string) => ({ name: i, type: 'CSS' })),
+      exports: [],
+      structure
+    };
+  }
+}
+
+// Analyseur PHP
+class PHPAnalyzer implements LanguageAnalyzer {
+  extensions = [".php"];
+
+  analyzeFile(content: string): FileAnalysisResult {
+    const functions: string[] = [];
+    const funcRegex = /function\s+([a-zA-Z0-9_]+)\s*\(/g;
+    let match: RegExpExecArray | null;
+    while ((match = funcRegex.exec(content)) !== null) {
+      if (match[1]) functions.push(match[1]);
+    }
+
+    const classes: string[] = [];
+    const classRegex = /class\s+([a-zA-Z0-9_]+)/g;
+    while ((match = classRegex.exec(content)) !== null) {
+      if (match[1]) classes.push(match[1]);
+    }
+
+    const imports: Array<{ name: string; type: string; usage?: string | undefined }> = [];
+    const useRegex = /use\s+([a-zA-Z0-9_\\]+)/g;
+    while ((match = useRegex.exec(content)) !== null) {
+      if (match[1]) {
+        imports.push({ name: match[1], type: 'Composer' });
+      }
+    }
+
+    const requireRegex = /(?:require|include)(?:_once)?\s*['"]([^'"]+)['"]/g;
+    while ((match = requireRegex.exec(content)) !== null) {
+      if (match[1]) {
+        imports.push({ name: match[1], type: 'Local' });
+      }
+    }
+
+    return { functions, classes, types: [], imports, exports: [] };
+  }
+}
+
+// Analyseur Ruby
+class RubyAnalyzer implements LanguageAnalyzer {
+  extensions = [".rb"];
+
+  analyzeFile(content: string): FileAnalysisResult {
+    const functions: string[] = [];
+    const funcRegex = /def\s+([a-zA-Z0-9_?!]+)/g;
+    let match: RegExpExecArray | null;
+    while ((match = funcRegex.exec(content)) !== null) {
+      if (match[1]) functions.push(match[1]);
+    }
+
+    const classes: string[] = [];
+    const classRegex = /class\s+([a-zA-Z0-9_]+)/g;
+    while ((match = classRegex.exec(content)) !== null) {
+      if (match[1]) classes.push(match[1]);
+    }
+
+    const imports: Array<{ name: string; type: string; usage?: string | undefined }> = [];
+    const requireRegex = /require\s+['"]([^'"]+)['"]/g;
+    while ((match = requireRegex.exec(content)) !== null) {
+      if (match[1]) {
+        imports.push({ name: match[1], type: 'Gem' });
+      }
+    }
+
+    return { functions, classes, types: [], imports, exports: [] };
+  }
+}
+
+// Analyseur SQL
+class SQLAnalyzer implements LanguageAnalyzer {
+  extensions = [".sql"];
+
+  analyzeFile(content: string): FileAnalysisResult {
+    const structure: Record<string, any> = {
+      tables: [] as string[],
+      procedures: [] as string[],
+      functions: [] as string[],
+      views: [] as string[]
+    };
+
+    const tableRegex = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([a-zA-Z0-9_]+)/gi;
+    let match: RegExpExecArray | null;
+    while ((match = tableRegex.exec(content)) !== null) {
+      if (match[1]) structure.tables.push(match[1]);
+    }
+
+    const procRegex = /CREATE\s+(?:OR\s+REPLACE\s+)?PROCEDURE\s+([a-zA-Z0-9_]+)/gi;
+    while ((match = procRegex.exec(content)) !== null) {
+      if (match[1]) structure.procedures.push(match[1]);
+    }
+
+    const funcRegex = /CREATE\s+(?:OR\s+REPLACE\s+)?FUNCTION\s+([a-zA-Z0-9_]+)/gi;
+    while ((match = funcRegex.exec(content)) !== null) {
+      if (match[1]) structure.functions.push(match[1]);
+    }
+
+    const viewRegex = /CREATE\s+(?:OR\s+REPLACE\s+)?VIEW\s+([a-zA-Z0-9_]+)/gi;
+    while ((match = viewRegex.exec(content)) !== null) {
+      if (match[1]) structure.views.push(match[1]);
+    }
+
+    return {
+      functions: structure.functions,
+      classes: structure.tables,
+      types: structure.views,
+      imports: [],
+      exports: [],
+      structure
+    };
+  }
+}
+
+// Analyseur par défaut pour tous les autres fichiers
+class DefaultAnalyzer implements LanguageAnalyzer {
+  extensions = ["*"]; // Wildcard pour tous les fichiers
+
+  analyzeFile(content: string): FileAnalysisResult {
+    const lines = content.split(/\r?\n/);
+    const structure: Record<string, any> = {
+      lineCount: lines.length,
+      nonEmptyLines: lines.filter(l => l.trim().length > 0).length,
+      size: content.length,
+      hasCode: /[a-zA-Z0-9_]+\s*[=:({]/.test(content),
+      encoding: 'UTF-8'
+    };
+
+    // Détection basique de patterns communs
+    const patterns = {
+      functions: [] as string[],
+      variables: [] as string[],
+      comments: [] as string[]
+    };
+
+    // Détection générique de fonctions (pattern commun à beaucoup de langages)
+    const genericFuncRegex = /(?:function|func|def|fn|sub|procedure)\s+([a-zA-Z0-9_]+)/gi;
+    let match: RegExpExecArray | null;
+    while ((match = genericFuncRegex.exec(content)) !== null) {
+      if (match[1]) patterns.functions.push(match[1]);
+    }
+
+    structure.patterns = patterns;
+
+    return {
+      functions: patterns.functions,
+      classes: [],
+      types: [],
+      imports: [],
+      exports: [],
+      structure
+    };
+  }
+}
+
+// Registry des analyseurs
+const analyzers: LanguageAnalyzer[] = [
+  new TSJSAnalyzer(),
+  new PythonAnalyzer(),
+  new JavaAnalyzer(),
+  new CSharpAnalyzer(),
+  new GoAnalyzer(),
+  new RustAnalyzer(),
+  new HTMLAnalyzer(),
+  new CSSAnalyzer(),
+  new PHPAnalyzer(),
+  new RubyAnalyzer(),
+  new SQLAnalyzer()
+];
+
+const defaultAnalyzer = new DefaultAnalyzer();
+
+export function getAnalyzer(filePath: string): LanguageAnalyzer {
+  const lastDotIndex = filePath.lastIndexOf('.');
+  if (lastDotIndex === -1) return defaultAnalyzer;
+  
+  const ext = filePath.substring(lastDotIndex).toLowerCase();
+  return analyzers.find(a => a.extensions.includes(ext)) || defaultAnalyzer;
+}
+
+export function getSupportedExtensions(): string[] {
+  return analyzers.flatMap(a => a.extensions);
+}
+
+export function isExplicitlySupported(filePath: string): boolean {
+  const lastDotIndex = filePath.lastIndexOf('.');
+  if (lastDotIndex === -1) return false;
+  
+  const ext = filePath.substring(lastDotIndex).toLowerCase();
+  return analyzers.some(a => a.extensions.includes(ext));
+}