@girardelli/architect-agents 8.1.0

package/src/core/agent-generator/framework-detector.ts

@@ -0,0 +1,66 @@
+import { AnalysisReport } from '@girardelli/architect-core/src/core/types/core.js';
+import { FrameworkInfo, DetectedToolchain } from './types/stack.js';
+import { PythonDetector } from './detectors/python-detector.js';
+import { NodeDetector } from './detectors/node-detector.js';
+import { JavaDetector } from './detectors/java-detector.js';
+import { PhpDetector } from './detectors/php-detector.js';
+import { GoDetector } from './detectors/go-detector.js';
+import { RubyDetector } from './detectors/ruby-detector.js';
+import { DartDetector } from './detectors/dart-detector.js';
+import { RustDetector } from './detectors/rust-detector.js';
+import { ToolchainDetector } from './detectors/toolchain-detector.js';
+import { StructureDetector } from './detectors/structure-detector.js';
+
+/**
+ * FrameworkDetector — Detects actual frameworks and toolchain from dependency files.
+ * Re-architected as a Strategy/Registry Facade.
+ */
+export class FrameworkDetector {
+  private detectors = [
+    new PythonDetector(),
+    new NodeDetector(),
+    new JavaDetector(),
+    new PhpDetector(),
+    new GoDetector(),
+    new RubyDetector(),
+    new DartDetector(),
+    new RustDetector()
+  ];
+  private toolchainDetector = new ToolchainDetector();
+  private structureDetector = new StructureDetector();
+
+  detect(projectPath: string, report: AnalysisReport): {
+    frameworks: FrameworkInfo[];
+    primaryFramework: FrameworkInfo | null;
+    toolchain: DetectedToolchain;
+    projectStructure: 'clean-architecture' | 'mvc' | 'modular' | 'flat' | 'monorepo' | 'unknown';
+  } {
+    const frameworks: FrameworkInfo[] = [];
+
+    // Run all detectors
+    for (const detector of this.detectors) {
+      detector.detect(projectPath, frameworks);
+    }
+
+    // Deduplicate by name
+    const seen = new Set<string>();
+    const unique = frameworks.filter(f => {
+      if (seen.has(f.name)) return false;
+      seen.add(f.name);
+      return true;
+    });
+
+    // Sort: web frameworks first, then by confidence
+    unique.sort((a, b) => {
+      if (a.category === 'web' && b.category !== 'web') return -1;
+      if (a.category !== 'web' && b.category === 'web') return 1;
+      return b.confidence - a.confidence;
+    });
+
+    const primaryFramework = unique.find(f => f.category === 'web') || null;
+    const toolchain = this.toolchainDetector.detectToolchain(projectPath, report, primaryFramework, unique);
+    const projectStructure = this.structureDetector.detectProjectStructure(report);
+
+    return { frameworks: unique, primaryFramework, toolchain, projectStructure };
+  }
+}

package/src/core/agent-generator/index.ts

@@ -0,0 +1,55 @@
+import { join } from "path";
+import { existsSync } from "fs";
+import { AnalysisReport } from '@girardelli/architect-core/src/core/types/core.js';
+import { RefactoringPlan } from '@girardelli/architect-core/src/core/types/rules.js';
+import { StackInfo, FrameworkInfo, DetectedToolchain } from './types/stack.js';
+import { AgentAuditFinding, AgentItem, AgentItemStatus, AgentSuggestion} from './types/agent.js';
+import {  EnrichedTemplateContext } from './types/template.js';
+import { DomainInsights, ModuleDetail, DetectedEndpoint } from './types/domain.js';
+
+import { ContextBuilder } from "./engines/context-builder.js";
+import { AuditEngine } from "./engines/audit-engine.js";
+import { SuggestionEngine } from "./engines/suggestion-engine.js";
+import { GenerationEngine } from "./engines/generation-engine.js";
+import { StackDetector } from "./stack-detector.js";
+
+export type { StackInfo, AgentAuditFinding, AgentItem, AgentItemStatus, AgentSuggestion, EnrichedTemplateContext, DomainInsights, ModuleDetail, DetectedEndpoint, FrameworkInfo, DetectedToolchain };
+
+/**
+ * Agent Generator v3.2 — Enterprise-Grade
+ *
+ * Generates or audits .agent/ directories with enterprise-grade
+ * agent frameworks. Delegated to specialized engines.
+ */
+export class AgentGenerator {
+  private stackDetector = new StackDetector();
+  private contextBuilder = new ContextBuilder();
+  private auditEngine = new AuditEngine();
+  private suggestionEngine = new SuggestionEngine();
+  private generationEngine = new GenerationEngine();
+
+  suggest(report: AnalysisReport, plan: RefactoringPlan, projectPath: string): AgentSuggestion {
+    return this.suggestionEngine.suggest(report, plan, projectPath);
+  }
+
+  generate(
+    report: AnalysisReport,
+    plan: RefactoringPlan,
+    projectPath: string,
+    outputDir?: string
+  ): { generated: string[]; audit: AgentAuditFinding[] } {
+    const cleanReport = this.contextBuilder.sanitizeReport(report);
+    const stack = this.stackDetector.detect(cleanReport);
+    const agentDir = outputDir || join(projectPath, '.agent');
+    const isExisting = existsSync(agentDir);
+
+    if (isExisting) {
+      const audit = this.auditEngine.auditExisting(agentDir, stack, cleanReport, plan);
+      const generated = this.generationEngine.generateMissing(agentDir, audit, cleanReport, plan, stack, projectPath);
+      return { generated, audit };
+    }
+
+    const generated = this.generationEngine.generateFull(agentDir, cleanReport, plan, stack, projectPath);
+    return { generated, audit: [] };
+  }
+}

package/src/core/agent-generator/stack-detector.ts

@@ -0,0 +1,115 @@
+import { AnalysisReport } from '@girardelli/architect-core/src/core/types/core.js';
+import { StackInfo } from './types/stack.js';
+
+/**
+ * Detects the technology stack from an AnalysisReport.
+ *
+ * v5.1: Uses report.projectInfo.frameworks (precise, from scanner v5.0)
+ * instead of naive string-matching on file paths.
+ */
+export class StackDetector {
+  detect(report: AnalysisReport): StackInfo {
+    const files = report.dependencyGraph.nodes;
+    const extensions = new Set<string>();
+    const languages = new Set<string>();
+    const frameworks = new Set<string>();
+
+    for (const file of files) {
+      const ext = file.split('.').pop()?.toLowerCase() || '';
+      extensions.add(ext);
+    }
+
+    // ── Language Detection ──
+    if (extensions.has('py')) languages.add('Python');
+    if (extensions.has('ts') || extensions.has('tsx')) languages.add('TypeScript');
+    if (extensions.has('js') || extensions.has('jsx')) languages.add('JavaScript');
+    if (extensions.has('dart')) languages.add('Dart');
+    if (extensions.has('go')) languages.add('Go');
+    if (extensions.has('rs')) languages.add('Rust');
+    if (extensions.has('java') || extensions.has('kt')) languages.add('Java/Kotlin');
+    if (extensions.has('rb')) languages.add('Ruby');
+    if (extensions.has('php')) languages.add('PHP');
+    if (extensions.has('cs')) languages.add('C#');
+
+    // ── Framework Detection: Trust report.projectInfo.frameworks ──
+    // These come from scanner v5.0 which reads actual package.json dependencies
+    const reportFrameworks = report.projectInfo?.frameworks || [];
+    for (const fw of reportFrameworks) {
+      frameworks.add(fw);
+    }
+
+    // ── Derived Properties ──
+    const primary = languages.size > 0 ? [...languages][0] : 'Unknown';
+
+    // Frontend frameworks that indicate hasFrontend
+    const FRONTEND_FRAMEWORKS = new Set([
+      'Angular', 'Vue', 'Vue.js', 'Next.js', 'React', 'Nuxt', 'Nuxt.js',
+      'Svelte', 'SvelteKit', 'Remix', 'Gatsby', 'Vite',
+    ]);
+
+    // Backend frameworks that indicate hasBackend (language-based is fallback)
+    const BACKEND_FRAMEWORKS = new Set([
+      'Express', 'Express.js', 'NestJS', 'Fastify', 'Koa', 'Hapi',
+      'Django', 'Flask', 'FastAPI', 'Spring Boot', 'Laravel', 'Rails',
+      'Ruby on Rails', 'Gin', 'Echo', 'Fiber', 'Actix Web', 'Rocket',
+      'Probot', 'MCP SDK',
+    ]);
+
+    const MOBILE_FRAMEWORKS = new Set(['Flutter', 'React Native', 'Expo']);
+
+    const hasBackend = [...frameworks].some(f => BACKEND_FRAMEWORKS.has(f)) ||
+      languages.has('Python') || languages.has('TypeScript') ||
+      languages.has('Go') || languages.has('Java/Kotlin') || languages.has('Ruby') ||
+      languages.has('PHP') || languages.has('C#') || languages.has('Rust');
+
+    const hasFrontend = [...frameworks].some(f => FRONTEND_FRAMEWORKS.has(f)) ||
+      extensions.has('tsx') || extensions.has('jsx');
+
+    const hasMobile = [...frameworks].some(f => MOBILE_FRAMEWORKS.has(f)) ||
+      languages.has('Dart');
+
+    const allFiles = files.join(' ').toLowerCase();
+    const hasDatabase = allFiles.includes('migration') || allFiles.includes('entity') ||
+      allFiles.includes('model') || allFiles.includes('schema') ||
+      allFiles.includes('prisma') || allFiles.includes('typeorm');
+
+    const testFramework = this.detectTestFramework(languages, frameworks);
+    const packageManager = this.detectPackageManager(languages);
+
+    return {
+      primary,
+      languages: [...languages],
+      frameworks: [...frameworks],
+      hasBackend,
+      hasFrontend,
+      hasMobile,
+      hasDatabase,
+      testFramework,
+      packageManager,
+    };
+  }
+
+  private detectTestFramework(languages: Set<string>, frameworks: Set<string>): string {
+    if (languages.has('Dart')) return 'flutter_test';
+    if (languages.has('Python')) return 'pytest';
+    if (languages.has('Go')) return 'go test';
+    if (languages.has('Java/Kotlin')) return 'JUnit';
+    if (languages.has('Ruby')) return 'RSpec';
+    if (languages.has('C#')) return 'xUnit';
+    if (languages.has('Rust')) return 'cargo test';
+    if (frameworks.has('Angular')) return 'Jest + Jasmine';
+    return 'Jest';
+  }
+
+  private detectPackageManager(languages: Set<string>): string {
+    if (languages.has('Python')) return 'pip';
+    if (languages.has('Go')) return 'go mod';
+    if (languages.has('Dart')) return 'pub';
+    if (languages.has('Ruby')) return 'bundler';
+    if (languages.has('Java/Kotlin')) return 'gradle/maven';
+    if (languages.has('Rust')) return 'cargo';
+    if (languages.has('PHP')) return 'composer';
+    if (languages.has('C#')) return 'nuget';
+    return 'npm';
+  }
+}