docstodev 1.0.0 → 1.0.2

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";

package/src/analyzers/languageAnalyzer.ts

@@ -0,0 +1,288 @@
+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[];
+}
+
+// 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;
+    // Resetting regex because of global flag
+    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: [] };
+  }
+}
+
+// Registry des analyseurs
+const analyzers: LanguageAnalyzer[] = [
+  new TSJSAnalyzer(),
+  new PythonAnalyzer(),
+  new JavaAnalyzer(),
+  new CSharpAnalyzer(),
+  new GoAnalyzer(),
+  new RustAnalyzer()
+];
+
+export function getAnalyzer(filePath: string): LanguageAnalyzer | null {
+  const lastDotIndex = filePath.lastIndexOf('.');
+  if (lastDotIndex === -1) return null;
+  const ext = filePath.substring(lastDotIndex).toLowerCase();
+  return analyzers.find(a => a.extensions.includes(ext)) || null;
+}
+
+export function getSupportedExtensions(): string[] {
+  return analyzers.flatMap(a => a.extensions);
+}

package/src/cache/cacheManager.ts

@@ -0,0 +1,179 @@
+// Emplacement : M:\workspace\extensions\docstodev\src\cache\cacheManager.ts
+
+import { createHash } from "node:crypto";
+import { readFileSync, writeFileSync, existsSync, statSync, mkdirSync } from "node:fs";
+import path from "node:path";
+
+export interface CacheEntry {
+  hash: string;
+  timestamp: number;
+  analysis: any;
+  metadata: {
+    lines: number;
+    size: number;
+  };
+}
+
+export interface CacheManifest {
+  version: string;
+  files: Map<string, CacheEntry>;
+  lastUpdate: number;
+}
+
+export class CacheManager {
+  private cacheDir: string;
+  private manifestPath: string;
+  private manifest: CacheManifest;
+  private readonly CACHE_VERSION = "1.0.0";
+
+  constructor(projectRoot: string) {
+    this.cacheDir = path.join(projectRoot, ".docstodev", "cache");
+    this.manifestPath = path.join(this.cacheDir, "manifest.json");
+    
+    if (!existsSync(this.cacheDir)) {
+      mkdirSync(this.cacheDir, { recursive: true });
+    }
+
+    this.manifest = this.loadManifest();
+  }
+
+  private loadManifest(): CacheManifest {
+    if (existsSync(this.manifestPath)) {
+      try {
+        const data = JSON.parse(readFileSync(this.manifestPath, "utf-8"));
+        
+        // Vérifier la version du cache
+        if (data.version !== this.CACHE_VERSION) {
+          console.log("⚠️  Cache version mismatch, clearing cache...");
+          return this.createNewManifest();
+        }
+
+        // Reconstituer la Map depuis l'objet
+        return {
+          version: data.version,
+          files: new Map(Object.entries(data.files || {})),
+          lastUpdate: data.lastUpdate
+        };
+      } catch (e) {
+        console.error("⚠️  Failed to load cache manifest:", e);
+        return this.createNewManifest();
+      }
+    }
+    return this.createNewManifest();
+  }
+
+  private createNewManifest(): CacheManifest {
+    return {
+      version: this.CACHE_VERSION,
+      files: new Map(),
+      lastUpdate: Date.now()
+    };
+  }
+
+  private saveManifest(): void {
+    try {
+      const data = {
+        version: this.manifest.version,
+        files: Object.fromEntries(this.manifest.files),
+        lastUpdate: this.manifest.lastUpdate
+      };
+      writeFileSync(this.manifestPath, JSON.stringify(data, null, 2));
+    } catch (e) {
+      console.error("⚠️  Failed to save cache manifest:", e);
+    }
+  }
+
+  private computeHash(filePath: string, content: string): string {
+    const stats = statSync(filePath);
+    const hashContent = `${content}|${stats.mtime.getTime()}|${stats.size}`;
+    return createHash("sha256").update(hashContent).digest("hex");
+  }
+
+  public isCached(filePath: string, content: string): boolean {
+    const entry = this.manifest.files.get(filePath);
+    if (!entry) return false;
+
+    const currentHash = this.computeHash(filePath, content);
+    return entry.hash === currentHash;
+  }
+
+  public get(filePath: string): CacheEntry | null {
+    return this.manifest.files.get(filePath) || null;
+  }
+
+  public set(filePath: string, content: string, analysis: any): void {
+    const stats = statSync(filePath);
+    const hash = this.computeHash(filePath, content);
+
+    const entry: CacheEntry = {
+      hash,
+      timestamp: Date.now(),
+      analysis,
+      metadata: {
+        lines: content.split(/\r?\n/).length,
+        size: stats.size
+      }
+    };
+
+    this.manifest.files.set(filePath, entry);
+    this.manifest.lastUpdate = Date.now();
+    this.saveManifest();
+  }
+
+  public invalidate(filePath: string): void {
+    this.manifest.files.delete(filePath);
+    this.saveManifest();
+  }
+
+  public invalidateAll(): void {
+    this.manifest = this.createNewManifest();
+    this.saveManifest();
+  }
+
+  public getStats(): { total: number; size: number; oldestEntry: number } {
+    const entries = Array.from(this.manifest.files.values());
+    return {
+      total: entries.length,
+      size: entries.reduce((sum, e) => sum + e.metadata.size, 0),
+      oldestEntry: Math.min(...entries.map(e => e.timestamp), Date.now())
+    };
+  }
+
+  public pruneOldEntries(maxAgeMs: number = 7 * 24 * 60 * 60 * 1000): number {
+    const now = Date.now();
+    let pruned = 0;
+
+    for (const [filePath, entry] of this.manifest.files.entries()) {
+      if (now - entry.timestamp > maxAgeMs) {
+        this.manifest.files.delete(filePath);
+        pruned++;
+      }
+    }
+
+    if (pruned > 0) {
+      this.saveManifest();
+    }
+
+    return pruned;
+  }
+
+  public getModifiedFiles(files: string[]): string[] {
+    const modified: string[] = [];
+
+    for (const file of files) {
+      if (!existsSync(file)) continue;
+
+      try {
+        const content = readFileSync(file, "utf-8");
+        if (!this.isCached(file, content)) {
+          modified.push(file);
+        }
+      } catch (e) {
+        // Si erreur de lecture, considérer comme modifié
+        modified.push(file);
+      }
+    }
+
+    return modified;
+  }
+}