npm - @girardelli/architect - Versions diffs - 5.0.0 → 6.0.0 - Mend

@girardelli/architect 5.0.0 → 6.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (803) hide show

package/src/adapters/html-reporter.ts ADDED Viewed

@@ -0,0 +1,89 @@
+import { groupAntiPatterns, groupSuggestions, escapeHtml, renderHeader, renderFooter, renderProjectOverview, renderScoreHero, renderRadarChart, renderStats, renderLayers, renderDependencyGraph, renderAntiPatternBubbles, renderAntiPatterns, renderSuggestions, renderRefactoringPlan, renderAgentSuggestions, getScripts, getStyles, AnalysisReport, AntiPattern, RefactoringPlan, RefactorStep, AgentSuggestion } from './html-reporter_deps.js';
+/**
+ * Generates premium visual HTML reports from AnalysisReport.
+ * Features: D3.js force graph, bubble charts, radar chart, animated counters.
+ */
+export class HtmlReportGenerator {
+  generateHtml(report: AnalysisReport, plan?: RefactoringPlan, agentSuggestion?: AgentSuggestion): string {
+    const grouped = groupAntiPatterns(report.antiPatterns);
+    const sugGrouped = groupSuggestions(report.suggestions);
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Architect Report — ${escapeHtml(report.projectInfo.name)}</title>
+${getStyles()}
+<script src="https://cdn.jsdelivr.net/npm/d3@7"><\/script>
+</head>
+<body>
+${renderHeader(report)}
+<div class="report-layout">
+  <nav class="sidebar" id="reportSidebar">
+    <div class="sidebar-title">Navigation</div>
+    <a href="#score" class="sidebar-link active" data-section="score">📊 Score</a>
+    ${report.projectSummary ? `<a href="#overview" class="sidebar-link" data-section="overview">📋 Overview</a>` : ''}
+    <a href="#layers" class="sidebar-link" data-section="layers">📐 Layers & Graph</a>
+    <a href="#anti-patterns" class="sidebar-link" data-section="anti-patterns">⚠️ Anti-Patterns (${report.antiPatterns.length})</a>
+    <a href="#suggestions" class="sidebar-link" data-section="suggestions">💡 Suggestions (${report.suggestions.length})</a>
+    ${plan ? `<a href="#refactoring" class="sidebar-link" data-section="refactoring">🔧 Refactoring (${plan.steps.length})</a>` : ''}
+    ${agentSuggestion ? `<a href="#agents" class="sidebar-link" data-section="agents">🤖 Agents</a>` : ''}
+  </nav>
+  <button class="sidebar-toggle" onclick="document.getElementById('reportSidebar').classList.toggle('sidebar-open')">☰</button>
+  <div class="container">
+    <div id="score">
+      ${renderScoreHero(report)}
+      ${renderRadarChart(report)}
+      ${renderStats(report)}
+    </div>
+    ${renderProjectOverview(report)}
+    <details class="section-accordion" id="layers" open>
+      <summary class="section-accordion-header">📐 Layer Analysis & Dependencies</summary>
+      <div class="section-accordion-body">
+        ${renderLayers(report)}
+        ${renderDependencyGraph(report)}
+      </div>
+    </details>
+    <details class="section-accordion" id="anti-patterns" open>
+      <summary class="section-accordion-header">⚠️ Anti-Patterns (${report.antiPatterns.length})</summary>
+      <div class="section-accordion-body">
+        ${renderAntiPatternBubbles(report, grouped)}
+        ${renderAntiPatterns(report, grouped)}
+      </div>
+    </details>
+    <details class="section-accordion" id="suggestions">
+      <summary class="section-accordion-header">💡 Suggestions (${report.suggestions.length})</summary>
+      <div class="section-accordion-body">
+        ${renderSuggestions(sugGrouped)}
+      </div>
+    </details>
+    ${plan ? `<details class="section-accordion" id="refactoring" open>
+      <summary class="section-accordion-header">🔧 Refactoring Plan (${plan.steps.length} steps, ${plan.totalOperations} operations)</summary>
+      <div class="section-accordion-body">
+        ${renderRefactoringPlan(plan)}
+      </div>
+    </details>` : ''}
+    ${agentSuggestion ? `<details class="section-accordion" id="agents" open>
+      <summary class="section-accordion-header">🤖 Agent System</summary>
+      <div class="section-accordion-body">
+        ${renderAgentSuggestions(agentSuggestion)}
+      </div>
+    </details>` : ''}
+  </div>
+</div>
+${renderFooter()}
+${getScripts(report)}
+</body>
+</html>`;
+  }
+}

package/src/adapters/html-reporter_deps.ts ADDED Viewed

@@ -0,0 +1,14 @@
+export { groupAntiPatterns, groupSuggestions, escapeHtml } from './html-reporter/utils_adapters.js';
+export { renderHeader, renderFooter } from './html-reporter/sections/header.js';
+export { renderProjectOverview } from './html-reporter/sections/overview.js';
+export { renderScoreHero, renderRadarChart, renderStats } from './html-reporter/sections/score.js';
+export { renderLayers, renderDependencyGraph } from './html-reporter/sections/layers.js';
+export { renderAntiPatternBubbles, renderAntiPatterns } from './html-reporter/sections/anti-patterns.js';
+export { renderSuggestions } from './html-reporter/sections/suggestions.js';
+export { renderRefactoringPlan } from './html-reporter/sections/refactoring-plan.js';
+export { renderAgentSuggestions } from './html-reporter/sections/agents.js';
+export { getScripts } from './html-reporter/scripts.js';
+export { getStyles } from './html-reporter/styles.js';
+export { AnalysisReport, AntiPattern } from '../core/types/core.js';
+export { RefactoringPlan, RefactorStep } from '../core/types/rules.js';
+export { AgentSuggestion } from '../core/agent-generator/index.js';

package/src/{refactor-reporter.ts → adapters/refactor-reporter.ts} RENAMED Viewed

@@ -1,4 +1,4 @@
-import { RefactoringPlan, RefactorStep, FileOperation } from './types.js';
+import { RefactoringPlan, RefactorStep, FileOperation } from '../core/types/rules.js';
 /**
  * Generates interactive HTML report for refactoring plans.

package/src/{reporter.ts → adapters/reporter.ts} RENAMED Viewed

@@ -1,4 +1,4 @@
-import { AnalysisReport } from './types.js';
+import { AnalysisReport } from '../core/types/core.js';
 export class ReportGenerator {
   generateMarkdownReport(report: AnalysisReport): string {

package/src/core/agent-generator/context-enricher.ts ADDED Viewed

@@ -0,0 +1,67 @@
+import { AnalysisReport } from '../types/core.js';
+import { RefactoringPlan } from '../types/rules.js';
+import { StackInfo } from './types/stack.js';
+import { EnrichedTemplateContext } from './types/template.js';
+import { AgentGeneratorConfig, DEFAULT_AGENT_CONFIG } from './types/agent.js';
+import { DomainInferrer } from './domain-inferrer.js';
+import { FrameworkDetector } from './framework-detector.js';
+// Engines
+import { ModuleExtractor } from './enrichers/module-extractor.js';
+import { EndpointExtractor } from './enrichers/endpoint-extractor.js';
+import { AnalysisHelpers } from './enrichers/analysis-helpers.js';
+/**
+ * ContextEnricher — Builds an EnrichedTemplateContext from AnalysisReport.
+ * Refactored via Strategy/Facade into separate Extractor engines.
+ */
+export class ContextEnricher {
+  private domainInferrer = new DomainInferrer();
+  private frameworkDetector = new FrameworkDetector();
+  private moduleExtractor = new ModuleExtractor();
+  private endpointExtractor = new EndpointExtractor();
+  private analysisHelpers = new AnalysisHelpers();
+  enrich(
+    report: AnalysisReport,
+    plan: RefactoringPlan,
+    stack: StackInfo,
+    projectPath: string,
+    config: AgentGeneratorConfig = DEFAULT_AGENT_CONFIG,
+  ): EnrichedTemplateContext {
+    const modules = this.moduleExtractor.extractModules(report, projectPath);
+    const endpoints = this.endpointExtractor.extractEndpoints(report, modules);
+    const untestedModules = this.analysisHelpers.findUntestedModules(modules);
+    const criticalPaths = this.analysisHelpers.findCriticalPaths(report);
+    const projectDepth = this.analysisHelpers.classifyProjectDepth(report);
+    const domain = this.domainInferrer.infer(report, projectPath);
+    const fwResult = this.frameworkDetector.detect(projectPath, report);
+    const webFrameworks = (report.projectInfo?.frameworks || [])
+      .filter(f => !['Jest', 'Vitest', 'Mocha', 'ESLint', 'Prettier', 'Biome',
+        'pytest', 'Ruff', 'mypy', 'Black', 'Flake8', 'RSpec',
+        '@jest/globals', '@types/jest', 'ts-jest'].includes(f));
+    const stackLabel = [...new Set([...stack.languages, ...webFrameworks])].join(' + ');
+    return {
+      report,
+      plan,
+      stack,
+      projectName: report.projectInfo.name || 'Project',
+      stackLabel,
+      config,
+      domain,
+      modules,
+      endpoints,
+      untestedModules,
+      criticalPaths,
+      projectDepth,
+      detectedFrameworks: fwResult.frameworks,
+      primaryFramework: fwResult.primaryFramework,
+      toolchain: fwResult.toolchain,
+      projectStructure: fwResult.projectStructure,
+    };
+  }
+}

package/src/core/agent-generator/detectors/base-detector.ts ADDED Viewed

@@ -0,0 +1,18 @@
+import { FrameworkInfo } from '../types/stack.js';
+import { readFileSync } from 'fs';
+export interface FrameworkDetectorStrategy {
+  detect(projectPath: string, out: FrameworkInfo[]): void;
+}
+export abstract class BaseDetector implements FrameworkDetectorStrategy {
+  abstract detect(projectPath: string, out: FrameworkInfo[]): void;
+  protected safeReadFile(path: string): string {
+    try {
+      return readFileSync(path, 'utf-8');
+    } catch {
+      return '';
+    }
+  }
+}

package/src/core/agent-generator/detectors/dart-detector.ts ADDED Viewed

@@ -0,0 +1,17 @@
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { FrameworkInfo } from '../types/stack.js';
+import { BaseDetector } from './base-detector.js';
+import { FRAMEWORK_MAP } from './framework-registry.js';
+export class DartDetector extends BaseDetector {
+public detect(projectPath: string, out: FrameworkInfo[]): void {
+    const pubspecPath = join(projectPath, 'pubspec.yaml');
+    if (!existsSync(pubspecPath)) return;
+    const content = this.safeReadFile(pubspecPath);
+    if (content.includes('flutter:')) {
+      out.push({ name: 'Flutter', version: null, category: 'web', confidence: 0.95 });
+    }
+  }
+}

package/src/core/agent-generator/detectors/framework-registry.ts ADDED Viewed

@@ -0,0 +1,82 @@
+import { FrameworkInfo } from '../types/stack.js';
+export const FRAMEWORK_MAP: Record<string, { name: string; category: FrameworkInfo['category'] }> = {
+    // Python Web
+    'fastapi': { name: 'FastAPI', category: 'web' },
+    'django': { name: 'Django', category: 'web' },
+    'flask': { name: 'Flask', category: 'web' },
+    'starlette': { name: 'Starlette', category: 'web' },
+    'tornado': { name: 'Tornado', category: 'web' },
+    'sanic': { name: 'Sanic', category: 'web' },
+    'aiohttp': { name: 'aiohttp', category: 'web' },
+    'litestar': { name: 'Litestar', category: 'web' },
+    // Python ORM
+    'sqlalchemy': { name: 'SQLAlchemy', category: 'orm' },
+    'tortoise-orm': { name: 'Tortoise ORM', category: 'orm' },
+    'peewee': { name: 'Peewee', category: 'orm' },
+    'sqlmodel': { name: 'SQLModel', category: 'orm' },
+    'prisma': { name: 'Prisma', category: 'orm' },
+    'django-rest-framework': { name: 'DRF', category: 'web' },
+    'djangorestframework': { name: 'DRF', category: 'web' },
+    // Python Test
+    'pytest': { name: 'pytest', category: 'test' },
+    'unittest': { name: 'unittest', category: 'test' },
+    'hypothesis': { name: 'Hypothesis', category: 'test' },
+    // Python Lint
+    'ruff': { name: 'Ruff', category: 'lint' },
+    'flake8': { name: 'Flake8', category: 'lint' },
+    'pylint': { name: 'Pylint', category: 'lint' },
+    'black': { name: 'Black', category: 'lint' },
+    'mypy': { name: 'mypy', category: 'lint' },
+    // Node.js Web
+    '@nestjs/core': { name: 'NestJS', category: 'web' },
+    'express': { name: 'Express', category: 'web' },
+    'fastify': { name: 'Fastify', category: 'web' },
+    'koa': { name: 'Koa', category: 'web' },
+    'hapi': { name: 'Hapi', category: 'web' },
+    '@hapi/hapi': { name: 'Hapi', category: 'web' },
+    'next': { name: 'Next.js', category: 'web' },
+    'nuxt': { name: 'Nuxt', category: 'web' },
+    // Node.js ORM
+    'typeorm': { name: 'TypeORM', category: 'orm' },
+    '@prisma/client': { name: 'Prisma', category: 'orm' },
+    'sequelize': { name: 'Sequelize', category: 'orm' },
+    'mongoose': { name: 'Mongoose', category: 'orm' },
+    'knex': { name: 'Knex', category: 'orm' },
+    'drizzle-orm': { name: 'Drizzle', category: 'orm' },
+    // Node.js Test
+    'jest': { name: 'Jest', category: 'test' },
+    'vitest': { name: 'Vitest', category: 'test' },
+    'mocha': { name: 'Mocha', category: 'test' },
+    // Node.js Lint
+    'eslint': { name: 'ESLint', category: 'lint' },
+    'biome': { name: 'Biome', category: 'lint' },
+    '@biomejs/biome': { name: 'Biome', category: 'lint' },
+    'prettier': { name: 'Prettier', category: 'lint' },
+    // Java/Kotlin
+    'spring-boot-starter-web': { name: 'Spring Boot', category: 'web' },
+    'spring-boot-starter': { name: 'Spring Boot', category: 'web' },
+    'quarkus': { name: 'Quarkus', category: 'web' },
+    'micronaut': { name: 'Micronaut', category: 'web' },
+    'ktor': { name: 'Ktor', category: 'web' },
+    // PHP
+    'laravel/framework': { name: 'Laravel', category: 'web' },
+    'symfony/framework-bundle': { name: 'Symfony', category: 'web' },
+    'slim/slim': { name: 'Slim', category: 'web' },
+    // Ruby
+    'rails': { name: 'Ruby on Rails', category: 'web' },
+    // Go — detected from imports
+    'gin-gonic/gin': { name: 'Gin', category: 'web' },
+    'labstack/echo': { name: 'Echo', category: 'web' },
+    'gofiber/fiber': { name: 'Fiber', category: 'web' },
+    'gorilla/mux': { name: 'Gorilla Mux', category: 'web' },
+    'go-chi/chi': { name: 'Chi', category: 'web' },
+    // Dart/Flutter
+    'flutter': { name: 'Flutter', category: 'web' },
+    'shelf': { name: 'Shelf', category: 'web' },
+    'dart_frog': { name: 'Dart Frog', category: 'web' },
+    // Rust
+    'actix-web': { name: 'Actix Web', category: 'web' },
+    'rocket': { name: 'Rocket', category: 'web' },
+    'axum': { name: 'Axum', category: 'web' },
+  };

package/src/core/agent-generator/detectors/go-detector.ts ADDED Viewed

@@ -0,0 +1,26 @@
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { FrameworkInfo } from '../types/stack.js';
+import { BaseDetector } from './base-detector.js';
+import { FRAMEWORK_MAP } from './framework-registry.js';
+export class GoDetector extends BaseDetector {
+public detect(projectPath: string, out: FrameworkInfo[]): void {
+    const goModPath = join(projectPath, 'go.mod');
+    if (!existsSync(goModPath)) return;
+    const content = this.safeReadFile(goModPath);
+    const lines = content.split('\n');
+    for (const line of lines) {
+      const match = line.match(/^\s*(github\.com\/[^\s]+)/);
+      if (match) {
+        const modPath = match[1].toLowerCase();
+        for (const [key, fwInfo] of Object.entries(FRAMEWORK_MAP)) {
+          if (modPath.includes(key.toLowerCase())) {
+            out.push({ name: fwInfo.name, version: null, category: fwInfo.category, confidence: 0.9 });
+          }
+        }
+      }
+    }
+  }
+}

package/src/core/agent-generator/detectors/java-detector.ts ADDED Viewed

@@ -0,0 +1,46 @@
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { FrameworkInfo } from '../types/stack.js';
+import { BaseDetector } from './base-detector.js';
+import { FRAMEWORK_MAP } from './framework-registry.js';
+export class JavaDetector extends BaseDetector {
+public detect(projectPath: string, out: FrameworkInfo[]): void {
+    // pom.xml
+    const pomPath = join(projectPath, 'pom.xml');
+    if (existsSync(pomPath)) {
+      const content = this.safeReadFile(pomPath);
+      const deps = content.match(/<artifactId>([^<]+)<\/artifactId>/gi) || [];
+      for (const dep of deps) {
+        const match = dep.match(/<artifactId>([^<]+)<\/artifactId>/i);
+        if (match) {
+          const artifact = match[1].toLowerCase();
+          const fwInfo = FRAMEWORK_MAP[artifact];
+          if (fwInfo) {
+            out.push({ name: fwInfo.name, version: null, category: fwInfo.category, confidence: 0.85 });
+          }
+        }
+      }
+    }
+    // build.gradle / build.gradle.kts
+    for (const gradleFile of ['build.gradle', 'build.gradle.kts']) {
+      const gradlePath = join(projectPath, gradleFile);
+      if (existsSync(gradlePath)) {
+        const content = this.safeReadFile(gradlePath);
+        if (content.includes('spring-boot')) {
+          out.push({ name: 'Spring Boot', version: null, category: 'web', confidence: 0.9 });
+        }
+        if (content.includes('quarkus')) {
+          out.push({ name: 'Quarkus', version: null, category: 'web', confidence: 0.9 });
+        }
+        if (content.includes('micronaut')) {
+          out.push({ name: 'Micronaut', version: null, category: 'web', confidence: 0.9 });
+        }
+        if (content.includes('ktor')) {
+          out.push({ name: 'Ktor', version: null, category: 'web', confidence: 0.9 });
+        }
+      }
+    }
+  }
+}

package/src/core/agent-generator/detectors/node-detector.ts ADDED Viewed

@@ -0,0 +1,28 @@
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { FrameworkInfo } from '../types/stack.js';
+import { BaseDetector } from './base-detector.js';
+import { FRAMEWORK_MAP } from './framework-registry.js';
+export class NodeDetector extends BaseDetector {
+public detect(projectPath: string, out: FrameworkInfo[]): void {
+    const pkgPath = join(projectPath, 'package.json');
+    if (!existsSync(pkgPath)) return;
+    const content = this.safeReadFile(pkgPath);
+    try {
+      const pkg = JSON.parse(content);
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+      for (const [name, version] of Object.entries(allDeps)) {
+        const fwInfo = FRAMEWORK_MAP[name];
+        if (fwInfo) {
+          const vStr = typeof version === 'string' ? version : '';
+          const vMatch = vStr.match(/([0-9][0-9.]*)/);
+          out.push({ name: fwInfo.name, version: vMatch?.[1] || null, category: fwInfo.category, confidence: 0.95 });
+        }
+      }
+    } catch {
+      // Invalid JSON
+    }
+  }
+}

package/src/core/agent-generator/detectors/php-detector.ts ADDED Viewed

@@ -0,0 +1,28 @@
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { FrameworkInfo } from '../types/stack.js';
+import { BaseDetector } from './base-detector.js';
+import { FRAMEWORK_MAP } from './framework-registry.js';
+export class PhpDetector extends BaseDetector {
+public detect(projectPath: string, out: FrameworkInfo[]): void {
+    const composerPath = join(projectPath, 'composer.json');
+    if (!existsSync(composerPath)) return;
+    const content = this.safeReadFile(composerPath);
+    try {
+      const pkg = JSON.parse(content);
+      const allDeps = { ...pkg.require, ...pkg['require-dev'] };
+      for (const [name, version] of Object.entries(allDeps)) {
+        const fwInfo = FRAMEWORK_MAP[name];
+        if (fwInfo) {
+          const vStr = typeof version === 'string' ? version : '';
+          const vMatch = vStr.match(/([0-9][0-9.]*)/);
+          out.push({ name: fwInfo.name, version: vMatch?.[1] || null, category: fwInfo.category, confidence: 0.9 });
+        }
+      }
+    } catch {
+      // Invalid JSON
+    }
+  }
+}

package/src/core/agent-generator/detectors/python-detector.ts ADDED Viewed

@@ -0,0 +1,125 @@
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { FrameworkInfo } from '../types/stack.js';
+import { BaseDetector } from './base-detector.js';
+import { FRAMEWORK_MAP } from './framework-registry.js';
+export class PythonDetector extends BaseDetector {
+public detect(projectPath: string, out: FrameworkInfo[]): void {
+    // requirements.txt
+    const reqFiles = ['requirements.txt', 'requirements/base.txt', 'requirements/prod.txt'];
+    for (const reqFile of reqFiles) {
+      const path = join(projectPath, reqFile);
+      if (existsSync(path)) {
+        const content = this.safeReadFile(path);
+        this.parsePythonRequirements(content, out);
+      }
+    }
+    // pyproject.toml
+    const pyproject = join(projectPath, 'pyproject.toml');
+    if (existsSync(pyproject)) {
+      const content = this.safeReadFile(pyproject);
+      this.parsePyprojectToml(content, out);
+    }
+    // setup.py / setup.cfg
+    const setupPy = join(projectPath, 'setup.py');
+    if (existsSync(setupPy)) {
+      const content = this.safeReadFile(setupPy);
+      this.parsePythonRequirements(content, out);
+    }
+    // Pipfile
+    const pipfile = join(projectPath, 'Pipfile');
+    if (existsSync(pipfile)) {
+      const content = this.safeReadFile(pipfile);
+      this.parsePythonRequirements(content, out);
+    }
+  }
+private parsePythonRequirements(content: string, out: FrameworkInfo[]): void {
+    const lines = content.toLowerCase().split('\n');
+    for (const line of lines) {
+      const cleaned = line.replace(/#.*$/, '').trim();
+      if (!cleaned) continue;
+      // Match: package==1.0.0, package>=1.0, package~=1.0, package[extras]
+      const match = cleaned.match(/^([a-z0-9_-]+)(?:\[.*?\])?\s*(?:[=<>~!]+\s*([0-9][0-9.]*\S*))?/);
+      if (match) {
+        const pkg = match[1].replace(/-/g, '-');
+        const version = match[2] || null;
+        const fwInfo = FRAMEWORK_MAP[pkg];
+        if (fwInfo) {
+          out.push({ name: fwInfo.name, version, category: fwInfo.category, confidence: 0.95 });
+        }
+      }
+    }
+  }
+private parsePyprojectToml(content: string, out: FrameworkInfo[]): void {
+    // Strategy 1: [project.dependencies] section (legacy format)
+    const depSection = content.match(/\[(?:project\.)?dependencies\]([\s\S]*?)(?:\n\[|$)/);
+    if (depSection) {
+      this.parsePythonRequirements(depSection[1], out);
+    }
+    // Strategy 2: [project] section with inline `dependencies = [...]` (PEP 621 format)
+    // This is the standard pyproject.toml format used by most modern Python projects
+    const projectSection = content.match(/\[project\]\s*\n([\s\S]*?)(?:\n\[(?!project\.)|$)/);
+    if (projectSection) {
+      // Extract the dependencies array: dependencies = [ "pkg>=1.0", ... ]
+      const depsArrayMatch = projectSection[1].match(/dependencies\s*=\s*\[([\s\S]*?)\]/);
+      if (depsArrayMatch) {
+        // Extract quoted strings from the array
+        const deps = depsArrayMatch[1].match(/"([^"]+)"/g);
+        if (deps) {
+          const depsAsLines = deps.map(d => d.replace(/"/g, '')).join('\n');
+          this.parsePythonRequirements(depsAsLines, out);
+        }
+      }
+    }
+    // Strategy 3: [project.optional-dependencies] sections (dev, test, etc.)
+    const optionalDeps = content.match(/\[project\.optional-dependencies\]\s*\n([\s\S]*?)(?:\n\[(?!project\.)|$)/);
+    if (optionalDeps) {
+      // Parse each group: dev = ["pkg>=1.0", ...], test = [...]
+      const groupMatches = optionalDeps[1].matchAll(/\w+\s*=\s*\[([\s\S]*?)\]/g);
+      for (const groupMatch of groupMatches) {
+        const deps = groupMatch[1].match(/"([^"]+)"/g);
+        if (deps) {
+          const depsAsLines = deps.map(d => d.replace(/"/g, '')).join('\n');
+          this.parsePythonRequirements(depsAsLines, out);
+        }
+      }
+    }
+    // Strategy 4: tool.poetry.dependencies
+    const poetrySection = content.match(/\[tool\.poetry\.dependencies\]([\s\S]*?)(?:\n\[|$)/);
+    if (poetrySection) {
+      const lines = poetrySection[1].split('\n');
+      for (const line of lines) {
+        const match = line.match(/^([a-z0-9_-]+)\s*=\s*"?([^"]*)"?/i);
+        if (match) {
+          const pkg = match[1].toLowerCase();
+          const fwInfo = FRAMEWORK_MAP[pkg];
+          if (fwInfo) {
+            const versionMatch = match[2].match(/([0-9][0-9.]*)/);
+            out.push({ name: fwInfo.name, version: versionMatch?.[1] || null, category: fwInfo.category, confidence: 0.95 });
+          }
+        }
+      }
+    }
+    // Deduplicate by framework name (keep highest confidence)
+    const seen = new Map<string, number>();
+    for (let i = out.length - 1; i >= 0; i--) {
+      const key = out[i].name;
+      if (seen.has(key)) {
+        out.splice(i, 1);
+      } else {
+        seen.set(key, i);
+      }
+    }
+  }
+}

package/src/core/agent-generator/detectors/ruby-detector.ts ADDED Viewed

@@ -0,0 +1,24 @@
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { FrameworkInfo } from '../types/stack.js';
+import { BaseDetector } from './base-detector.js';
+import { FRAMEWORK_MAP } from './framework-registry.js';
+export class RubyDetector extends BaseDetector {
+public detect(projectPath: string, out: FrameworkInfo[]): void {
+    const gemfilePath = join(projectPath, 'Gemfile');
+    if (!existsSync(gemfilePath)) return;
+    const content = this.safeReadFile(gemfilePath);
+    if (content.includes("'rails'") || content.includes('"rails"')) {
+      const vMatch = content.match(/['"]rails['"],\s*['"]~?>\s*([0-9.]+)['"]/);
+      out.push({ name: 'Ruby on Rails', version: vMatch?.[1] || null, category: 'web', confidence: 0.95 });
+    }
+    if (content.includes("'sinatra'") || content.includes('"sinatra"')) {
+      out.push({ name: 'Sinatra', category: 'web', version: null, confidence: 0.9 });
+    }
+    if (content.includes("'rspec'") || content.includes('"rspec"')) {
+      out.push({ name: 'RSpec', category: 'test', version: null, confidence: 0.9 });
+    }
+  }
+}

package/src/core/agent-generator/detectors/rust-detector.ts ADDED Viewed

@@ -0,0 +1,19 @@
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { FrameworkInfo } from '../types/stack.js';
+import { BaseDetector } from './base-detector.js';
+import { FRAMEWORK_MAP } from './framework-registry.js';
+export class RustDetector extends BaseDetector {
+public detect(projectPath: string, out: FrameworkInfo[]): void {
+    const cargoPath = join(projectPath, 'Cargo.toml');
+    if (!existsSync(cargoPath)) return;
+    const content = this.safeReadFile(cargoPath);
+    for (const [key, fwInfo] of Object.entries(FRAMEWORK_MAP)) {
+      if (content.includes(`"${key}"`) || content.includes(`'${key}'`) || content.includes(`${key} =`)) {
+        out.push({ name: fwInfo.name, version: null, category: fwInfo.category, confidence: 0.85 });
+      }
+    }
+  }
+}

package/src/core/agent-generator/detectors/structure-detector.ts ADDED Viewed

@@ -0,0 +1,38 @@
+import { AnalysisReport } from '../../types/core.js';
+export class StructureDetector {
+  public detectProjectStructure(report: AnalysisReport): 'clean-architecture' | 'mvc' | 'modular' | 'flat' | 'monorepo' | 'unknown' {
+    const paths = report.dependencyGraph.nodes.map(n => n.toLowerCase());
+    // Clean Architecture / DDD
+    const hasDomain = paths.some(p => p.includes('/domain/'));
+    const hasApplication = paths.some(p => p.includes('/application/'));
+    const hasInfrastructure = paths.some(p => p.includes('/infrastructure/'));
+    const hasPresentation = paths.some(p => p.includes('/presentation/'));
+    if ((hasDomain && hasInfrastructure) || (hasDomain && hasApplication && hasPresentation)) {
+      return 'clean-architecture';
+    }
+    // MVC
+    const hasModels = paths.some(p => p.includes('/models/'));
+    const hasViews = paths.some(p => p.includes('/views/'));
+    const hasControllers = paths.some(p => p.includes('/controllers/'));
+    if (hasModels && hasViews && hasControllers) return 'mvc';
+    // Modular (NestJS, feature-based)
+    const hasModules = paths.some(p => p.includes('/modules/'));
+    const hasFeatures = paths.some(p => p.includes('/features/'));
+    if (hasModules || hasFeatures) return 'modular';
+    // Monorepo
+    const hasPackages = paths.some(p => p.includes('/packages/'));
+    const hasApps = paths.some(p => p.includes('/apps/'));
+    if (hasPackages || hasApps) return 'monorepo';
+    // Flat
+    const maxDepth = Math.max(...paths.map(p => p.split('/').length));
+    if (maxDepth <= 3) return 'flat';
+    return 'unknown';
+  }
+}