ci/src/agents/ideation-agent.ts

import * as fs from "node:fs";
import * as path from "node:path";
import { BaseAgent, AgentContext, AgentResult } from "./base.js";

interface Idea {
  source: "uncovered_requirement" | "repeated_lesson" | "gap_in_coverage" | "improvement_pattern";
  title: string;
  rationale: string;
  confidence: number;
  relatedReq?: string;
}

export class IdeationAgent extends BaseAgent {
  readonly name = "ideation-agent";
  readonly description = "Generates improvement ideas. Output feeds directly into planning pipeline.";
  readonly workflow = "research";

  async execute(context: AgentContext): Promise<AgentResult> {
    const start = Date.now();
    this.log("Generating improvement ideas...");

    if (context.backend) {
      const result = await this.executeViaBackend(
        context,
        `Generate improvement ideas for: ${context.specification}`
      );
      return { ...result, duration_ms: Date.now() - start };
    }

    const ideas = this.mechanicalIdeate(context.project_path);
    const output = this.formatIdeas(ideas);

    return {
      success: true,
      output,
      artifacts_created: [],
      decisions: 0,
      escalations: 0,
      duration_ms: Date.now() - start,
    };
  }

  mechanicalIdeate(projectPath: string): Idea[] {
    const ideas: Idea[] = [];
    const uncoveredReqs = this.readUncoveredRequirements(projectPath);
    const lessons = this.readRecentLessons(projectPath);
    const repeated = this.findRepeatedPatterns(lessons);
    const coverageGaps = this.identifyCoverageGaps(projectPath);

    for (const req of uncoveredReqs) {
      ideas.push({
        source: "uncovered_requirement",
        title: `Address uncovered requirement: ${req}`,
        rationale: `Requirement ${req} has no corresponding implementation task.`,
        confidence: 0.8,
        relatedReq: req,
      });
    }

    for (const topic of repeated) {
      ideas.push({
        source: "repeated_lesson",
        title: `Investigate repeated lesson: ${topic}`,
        rationale: `Topic "${topic}" appears in multiple commit lessons, indicating a systemic issue.`,
        confidence: 0.7,
      });
    }

    for (const gap of coverageGaps) {
      ideas.push({
        source: "gap_in_coverage",
        title: `Fill coverage gap: ${gap}`,
        rationale: `Agent "${gap}" is claimed in PROJECT.md but not found in the agent registry.`,
        confidence: 0.75,
      });
    }

    this.generateIdeas(uncoveredReqs, repeated, ideas);

    return ideas;
  }

  readUncoveredRequirements(projectPath: string): string[] {
    const reqPath = path.join(projectPath, ".ciagent", "REQUIREMENTS.md");
    if (!fs.existsSync(reqPath)) return [];

    const content = fs.readFileSync(reqPath, "utf-8");
    const reqIds: string[] = [];
    const reqIdRegex = /REQ-(\d+)/g;
    let match;
    while ((match = reqIdRegex.exec(content)) !== null) {
      reqIds.push(`REQ-${match[1]}`);
    }

    const planPath = path.join(projectPath, ".ciagent", "PLAN.md");
    if (!fs.existsSync(planPath)) return reqIds;

    const planContent = fs.readFileSync(planPath, "utf-8");
    const coveredReqIds = new Set<string>();
    const planRegex = /REQ-(\d+)/g;
    let planMatch;
    while ((planMatch = planRegex.exec(planContent)) !== null) {
      coveredReqIds.add(`REQ-${planMatch[1]}`);
    }

    return reqIds.filter((id) => !coveredReqIds.has(id));
  }

  readRecentLessons(projectPath: string): Array<{ topic: string; detail: string }> {
    const lessons: Array<{ topic: string; detail: string }> = [];
    try {
      const { execSync } = require("node:child_process");
      const log = execSync('git log --grep="lessons:" --format="%B" -50', {
        cwd: projectPath,
        encoding: "utf-8",
        timeout: 5000,
      });
      const lessonsRegex = /lessons:\s*\n((?:\s+-\s+.+\n?)+)/g;
      let match;
      while ((match = lessonsRegex.exec(log)) !== null) {
        const items = match[1].split("\n").filter((l: string) => l.trim().startsWith("-"));
        for (const item of items) {
          const detail = item.replace(/^\s*-\s*/, "").trim();
          const topic = detail.split(":")[0].trim().toLowerCase();
          lessons.push({ topic, detail });
        }
      }
    } catch {}

    return lessons;
  }

  findRepeatedPatterns(lessons: Array<{ topic: string; detail: string }>): string[] {
    const counts: Record<string, number> = {};
    for (const lesson of lessons) {
      counts[lesson.topic] = (counts[lesson.topic] || 0) + 1;
    }
    return Object.entries(counts)
      .filter(([, count]) => count > 1)
      .map(([topic]) => topic);
  }

  generateIdeas(uncoveredReqs: string[], repeated: string[], ideas: Idea[]): void {
    const repeatedSet = new Set(repeated.map((r) => r.toLowerCase()));
    for (const req of uncoveredReqs) {
      for (const topic of repeated) {
        if (req.toLowerCase().includes(topic) || topic.includes(req.toLowerCase())) {
          ideas.push({
            source: "improvement_pattern",
            title: `Cross-reference: ${req} ↔ ${topic}`,
            rationale: `Repeated lesson "${topic}" directly relates to uncovered requirement ${req}.`,
            confidence: 0.85,
            relatedReq: req,
          });
        }
      }
    }
  }

  identifyCoverageGaps(projectPath: string): string[] {
    const projectMdPath = path.join(projectPath, ".ciagent", "PROJECT.md");
    if (!fs.existsSync(projectMdPath)) return [];

    const content = fs.readFileSync(projectMdPath, "utf-8");
    const agentMentionRegex = /(?:agent|Agent):\s*(\S+)/g;
    const mentionedAgents: string[] = [];
    let match;
    while ((match = agentMentionRegex.exec(content)) !== null) {
      mentionedAgents.push(match[1]);
    }

    const agentsDir = path.join(projectPath, "src", "agents");
    if (!fs.existsSync(agentsDir)) return mentionedAgents;

    const existingAgents = new Set(
      fs.readdirSync(agentsDir)
        .filter((f) => f.endsWith(".ts") && !f.endsWith(".test.ts") && !f.endsWith(".d.ts") && f !== "index.ts" && f !== "base.ts")
        .map((f) => f.replace(".ts", ""))
    );

    return mentionedAgents.filter((a) => !existingAgents.has(a) && !existingAgents.has(a.replace(/-agent$/, "")));
  }

  private formatIdeas(ideas: Idea[]): string {
    if (ideas.length === 0) return "No improvement ideas generated.";
    const lines: string[] = ["Improvement Ideas:", ""];
    for (const idea of ideas) {
      lines.push(`[${idea.source}|${idea.confidence.toFixed(2)}] ${idea.title} — ${idea.rationale}${idea.relatedReq ? ` (req: ${idea.relatedReq})` : ""}`);
    }
    return lines.join("\n");
  }
}