#Step 12 — 종합 프로젝트 : 해설

/**
 * 보고서의 인용을 기계적으로 검증합니다.
 * 이 파일에는 LLM 호출이 없습니다 — 전부 결정적이라 유닛 테스트가 가능합니다.
 */

export interface CitationIssue {
  kind:
    | "ghost_citation"
    | "unused_source"
    | "hallucinated_url"
    | "no_sources_section"
    | "gap_in_numbering";
  detail: string;
}

/** '### 출처' 제목. m 플래그로 줄 단위 매칭. */
const SOURCES_HEADING = /^###\s*출처\s*$/m;

/**
 * 보고서를 본문과 출처 섹션으로 자릅니다.
 *
 * 이 분리가 이 과제의 핵심입니다. 자르지 않고 전체에서 [n] 을 뽑으면
 * 출처 목록 자체의 "[1] 제목: URL" 이 본문 인용으로 잡혀서,
 * 유령 인용이 **영원히 검출되지 않습니다**.
 */
export function splitReport(report: string): { body: string; sources: string } {
  const m = SOURCES_HEADING.exec(report);
  if (!m) return { body: report, sources: "" };
  return {
    body: report.slice(0, m.index),
    sources: report.slice(m.index + m[0].length),
  };
}

/** "[1] 제목: https://..." 줄들을 파싱합니다. */
export function parseSources(sources: string): Map<number, { title: string; url: string }> {
  const out = new Map<number, { title: string; url: string }>();
  const re = /^\s*\[(\d+)\]\s*(.+?):\s*(https?:\/\/\S+)\s*$/gm;
  let m: RegExpExecArray | null;
  while ((m = re.exec(sources)) !== null) {
    out.set(Number(m[1]), { title: m[2]!.trim(), url: m[3]!.trim() });
  }
  return out;
}

/** 본문에서 [n] 인용 번호를 뽑습니다. */
export function parseBodyCitations(body: string): Set<number> {
  const out = new Set<number>();
  const re = /\[(\d+)\]/g;
  let m: RegExpExecArray | null;
  while ((m = re.exec(body)) !== null) out.add(Number(m[1]));
  return out;
}

export function verifyCitations(report: string, allowedUrls: Set<string>): CitationIssue[] {
  const issues: CitationIssue[] = [];
  const { body, sources } = splitReport(report);

  // 출처 섹션이 아예 없으면 나머지 검사는 의미가 없습니다. 조기 반환.
  if (!SOURCES_HEADING.test(report)) {
    issues.push({ kind: "no_sources_section", detail: "'### 출처' 섹션이 없습니다." });
    return issues;
  }

  const sourceMap = parseSources(sources);
  const cited = parseBodyCitations(body);

  // 1) 유령 인용: 본문엔 있는데 출처 목록에 없음
  for (const n of [...cited].sort((a, b) => a - b)) {
    if (!sourceMap.has(n)) {
      issues.push({
        kind: "ghost_citation",
        detail: `본문이 [${n}] 을 인용하지만 출처 목록에 ${n}번이 없습니다.`,
      });
    }
  }

  // 2) 미사용 출처: 목록엔 있는데 본문에서 안 씀
  for (const n of [...sourceMap.keys()].sort((a, b) => a - b)) {
    if (!cited.has(n)) {
      issues.push({
        kind: "unused_source",
        detail: `출처 ${n}번(${sourceMap.get(n)!.url})이 본문에서 인용되지 않았습니다.`,
      });
    }
  }

  // 3) URL 환각: findings 에 없는 URL — 가장 위험한 위반
  for (const [n, { url }] of [...sourceMap].sort((a, b) => a[0] - b[0])) {
    if (!allowedUrls.has(url)) {
      issues.push({
        kind: "hallucinated_url",
        detail: `출처 ${n}번의 URL 이 findings 에 없습니다(지어냈을 가능성): ${url}`,
      });
    }
  }

  // 4) 번호 갭: 1,2,3... 으로 이어져야 함
  const nums = [...sourceMap.keys()].sort((a, b) => a - b);
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] !== i + 1) {
      issues.push({
        kind: "gap_in_numbering",
        detail: `출처 번호가 1부터 연속이어야 하는데 ${JSON.stringify(nums)} 입니다.`,
      });
      break; // 갭은 하나만 보고하면 충분합니다
    }
  }

  return issues;
}

/**
 * findings 파일들에서 실제로 등장한 URL 을 모읍니다.
 *
 * ⚠️ `/findings/` 로 시작하는 파일만 봅니다. `/report.md` 를 포함시키면
 * 보고서가 지어낸 URL 이 "허용 목록"에 들어가 버려서, 환각 검사가
 * 자기 자신을 근거로 통과하는 순환이 생깁니다.
 */
export function collectUrlsFromFindings(files: Record<string, unknown>): Set<string> {
  const urls = new Set<string>();
  for (const [path, entry] of Object.entries(files ?? {})) {
    if (!path.startsWith("/findings/")) continue;

    const content = (entry as { content?: unknown })?.content;
    // 파일 형식 v1/v2 를 모두 받아냅니다 (12-4 참고)
    const text =
      typeof content === "string"
        ? content
        : Array.isArray(content)
          ? content.join("\n")
          : content instanceof Uint8Array
            ? new TextDecoder().decode(content)
            : "";

    for (const m of text.matchAll(/https?:\/\/[^\s)\]<>"']+/g)) {
      // 문장 끝 구두점이 URL 에 붙어 들어오는 것을 떼어냅니다.
      urls.add(m[0].replace(/[.,;:]+$/, ""));
    }
  }
  return urls;
}

const findings = {
  "/findings/a.md": {
    content:
      "본문 [1]\n\n### 출처\n" +
      "[1] RAG 개요: https://example.com/docs/rag-overview\n" +
      "[2] 비용: https://example.com/research/rag-cost-analysis",
  },
  // /findings/ 가 아니므로 무시되어야 함
  "/report.md": { content: "https://evil.example.com/should-not-count" },
};
const allowed = collectUrlsFromFindings(findings);
console.log([...allowed]);

import { buildResearchAgent, readStateFile } from "../agent.js";
import { verifyCitations, collectUrlsFromFindings } from "./citations.js";

const MAX_FIX_ROUNDS = 2; // ← 상한 필수

export async function researchWithCitationCheck(question: string) {
  const agent = buildResearchAgent();
  const config = { configurable: { thread_id: crypto.randomUUID() } };

  let result = await agent.invoke(
    { messages: [{ role: "user", content: question }] },
    { ...config, recursionLimit: 100 },
  );

  for (let round = 0; round < MAX_FIX_ROUNDS; round++) {
    const files = (result as { files?: Record<string, unknown> }).files ?? {};
    const report = readStateFile(files, "/report.md");
    if (!report) break;

    const allowed = collectUrlsFromFindings(files);
    const issues = verifyCitations(report, allowed);
    if (issues.length === 0) {
      console.log("인용 검증 통과");
      break;
    }

    console.log(`인용 위반 ${issues.length}건 — 재작성 요청 (라운드 ${round + 1})`);
    for (const i of issues) console.log(`  - [${i.kind}] ${i.detail}`);

    // 문제를 자연어로 알려주고 다시 쓰게 합니다.
    // 같은 thread_id 라서 에이전트는 findings 를 그대로 갖고 있습니다 — 재조사가 필요 없습니다.
    result = await agent.invoke(
      {
        messages: [
          {
            role: "user",
            content:
              "/report.md 의 인용에 다음 문제가 있습니다. /findings/ 를 다시 읽고 " +
              "출처를 바로잡아 /report.md 를 다시 쓰세요. " +
              "findings 에 없는 URL 은 절대 쓰지 마세요.\n\n" +
              issues.map((i) => `- ${i.detail}`).join("\n"),
          },
        ],
      },
      { ...config, recursionLimit: 100 },
    );
  }

  return result;
}

import * as z from "zod";
import { createDeepAgent } from "deepagents";
import type { SubAgent } from "deepagents";
import { createSearchTool } from "../tools.js";
import { ORCHESTRATOR_PROMPT, RESEARCHER_PROMPT, CRITIQUE_PROMPT } from "../prompts.js";
import { ORCHESTRATOR_MODEL, RESEARCH_MODEL, CRITIQUE_MODEL } from "../subagents.js";
import { readStateFile } from "../agent.js";

/* ===== 1) 구조화된 판정 스키마 ===== */

export const CritiqueVerdict = z.object({
  verdict: z.enum(["PASS", "REVISE"]),
  issues: z
    .array(
      z.object({
        problem: z.string().describe("무엇이 잘못되었는가"),
        location: z.string().describe("어느 파일의 어느 부분인가"),
        researchTopic: z
          .string()
          .describe("부모가 그대로 task() 에 넣을 수 있는 조사 주제 한 문장"),
      }),
    )
    .describe("PASS 인 경우 빈 배열"),
});

export type CritiqueVerdictT = z.infer<typeof CritiqueVerdict>;

/* ===== 2) responseFormat 을 붙인 비평 서브에이전트 ===== */

const critiqueSubagent: SubAgent = {
  name: "critique-subagent",
  description:
    "/findings/ 의 조사 결과를 심사해 PASS 또는 REVISE 를 구조화된 JSON 으로 판정합니다. 검색은 하지 않습니다.",
  systemPrompt: CRITIQUE_PROMPT,
  model: CRITIQUE_MODEL,
  // 이것 하나로 부모가 문자열을 파싱할 필요가 사라집니다.
  responseFormat: CritiqueVerdict,
};

const researchSubagent: SubAgent = {
  name: "research-subagent",
  description:
    "웹 검색으로 하나의 구체적인 주제를 깊이 조사하고, 결과를 /findings/ 에 저장한 뒤 요약을 돌려줍니다.",
  systemPrompt: RESEARCHER_PROMPT,
  tools: [createSearchTool()],
  model: RESEARCH_MODEL,
};

/* ===== 3) 바깥 코드가 루프를 돈다 ===== */

const MAX_REVISE_ROUNDS = 2;

export async function researchWithCritiqueLoop(question: string) {
  const agent = createDeepAgent({
    model: ORCHESTRATOR_MODEL,
    systemPrompt: ORCHESTRATOR_PROMPT,
    tools: [],
    subagents: [researchSubagent, critiqueSubagent],
  });

  const config = { configurable: { thread_id: crypto.randomUUID() } };

  // 1단계: 조사만 시킵니다. 보고서는 아직 쓰지 말라고 명시합니다.
  let result = await agent.invoke(
    {
      messages: [
        {
          role: "user",
          content:
            `다음 질문을 조사하세요: ${question}\n\n` +
            "지금은 **조사만** 하세요. /question.txt 를 저장하고, 계획을 세우고, " +
            "research-subagent 로 조사해 /findings/ 를 채우세요. " +
            "아직 /report.md 는 쓰지 마세요.",
        },
      ],
    },
    { ...config, recursionLimit: 100 },
  );

  // 2단계: 비평 → 재조사 루프
  for (let round = 0; round <= MAX_REVISE_ROUNDS; round++) {
    const isLastRound = round === MAX_REVISE_ROUNDS;

    result = await agent.invoke(
      {
        messages: [
          {
            role: "user",
            content:
              "critique-subagent 를 호출해 /findings/ 를 심사시키세요. " +
              "판정 JSON 을 그대로 보여주세요.",
          },
        ],
      },
      { ...config, recursionLimit: 100 },
    );

    const verdict = extractVerdict(result);
    console.log(`[라운드 ${round}] 판정:`, verdict?.verdict ?? "(파싱 실패)");

    if (!verdict || verdict.verdict === "PASS") break;

    if (isLastRound) {
      // ⚠️ 마지막 라운드에서 반드시 탈출구를 줘야 무한 루프가 안 납니다.
      console.log("재조사 한도 도달 — 현재 findings 로 보고서를 씁니다.");
      break;
    }

    // REVISE → 지적된 주제를 그대로 재조사시킵니다.
    const topics = verdict.issues.map((i) => i.researchTopic);
    console.log(`  재조사 주제 ${topics.length}건:`, topics);

    result = await agent.invoke(
      {
        messages: [
          {
            role: "user",
            content:
              "비평가가 아래 구멍을 지적했습니다. 각 주제를 research-subagent 로 " +
              "재조사해 /findings/ 를 보강하세요. 아직 /report.md 는 쓰지 마세요.\n\n" +
              topics.map((t, i) => `${i + 1}. ${t}`).join("\n"),
          },
        ],
      },
      { ...config, recursionLimit: 100 },
    );
  }

  // 3단계: 이제 보고서를 씁니다.
  result = await agent.invoke(
    {
      messages: [
        {
          role: "user",
          content:
            "이제 /findings/ 를 모두 읽고 종합해 /report.md 를 작성하세요. " +
            "마지막에 /question.txt 를 다시 읽고 질문의 모든 측면에 답했는지 확인하세요.",
        },
      ],
    },
    { ...config, recursionLimit: 100 },
  );

  return result;
}

/**
 * 부모 메시지에서 비평 판정 JSON 을 찾아냅니다.
 *
 * responseFormat 을 준 서브에이전트의 결과는 JSON 문자열로 직렬화되어
 * ToolMessage 내용으로 들어옵니다. 뒤에서부터 훑어 가장 최근 판정을 찾습니다.
 */
function extractVerdict(result: unknown): CritiqueVerdictT | undefined {
  const messages = (result as { messages?: Array<{ content?: unknown }> }).messages ?? [];
  for (let i = messages.length - 1; i >= 0; i--) {
    const content = messages[i]?.content;
    if (typeof content !== "string") continue;
    // 문자열 안에 JSON 이 섞여 있을 수 있으므로 중괄호 범위를 뽑아 시도합니다.
    const start = content.indexOf("{");
    const end = content.lastIndexOf("}");
    if (start < 0 || end <= start) continue;
    try {
      const parsed = CritiqueVerdict.safeParse(JSON.parse(content.slice(start, end + 1)));
      if (parsed.success) return parsed.data;
    } catch {
      // 이 메시지는 JSON 이 아니었습니다. 계속 훑습니다.
    }
  }
  return undefined;
}

import { createDeepAgent } from "deepagents";
import { createSearchTool } from "../tools.js";
import { RESEARCHER_PROMPT } from "../prompts.js";
import { RESEARCH_MODEL } from "../subagents.js";

export interface ResearchOutcome {
  topic: string;
  ok: boolean;
  findings: string;
  files: Record<string, unknown>;
  error?: string;
}

/** 조사 전용 독립 에이전트. 서브에이전트가 아니라 그냥 에이전트로 씁니다. */
function createResearcher() {
  return createDeepAgent({
    model: RESEARCH_MODEL,
    systemPrompt: RESEARCHER_PROMPT,
    tools: [createSearchTool()],
    // 서브에이전트가 필요 없습니다 — 이 에이전트가 곧 말단입니다.
    subagents: [],
  });
}

async function researchOne(topic: string): Promise<ResearchOutcome> {
  try {
    const agent = createResearcher();
    const result = await agent.invoke(
      { messages: [{ role: "user", content: topic }] },
      {
        configurable: { thread_id: crypto.randomUUID() }, // 조사마다 독립 스레드
        recursionLimit: 50,
      },
    );
    const messages = (result as { messages?: Array<{ content?: unknown }> }).messages ?? [];
    const last = messages[messages.length - 1]?.content;
    return {
      topic,
      ok: true,
      findings: typeof last === "string" ? last : JSON.stringify(last),
      files: (result as { files?: Record<string, unknown> }).files ?? {},
    };
  } catch (e) {
    // 하나가 죽어도 나머지는 살아야 합니다.
    return { topic, ok: false, findings: "", files: {}, error: String(e) };
  }
}

/** 배열을 size 크기 청크로 자릅니다. */
function chunk<T>(arr: T[], size: number): T[][] {
  const out: T[][] = [];
  for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size));
  return out;
}

export async function researchInParallel(
  topics: string[],
  concurrency = 3,
): Promise<ResearchOutcome[]> {
  const results: ResearchOutcome[] = [];
  // 청크 단위로 병렬 → 동시 실행 수가 concurrency 를 넘지 않습니다.
  for (const group of chunk(topics, concurrency)) {
    const settled = await Promise.all(group.map(researchOne));
    results.push(...settled);
  }
  return results;
}

/**
 * 여러 조사 결과의 files 를 병합합니다.
 *
 * ⚠️ 키 충돌 주의: 두 조사가 같은 슬러그(/findings/cost.md)를 쓰면 하나가 덮입니다.
 * 그래서 충돌 시 접미사를 붙여 살립니다.
 */
export function mergeFiles(outcomes: ResearchOutcome[]): Record<string, unknown> {
  const merged: Record<string, unknown> = {};
  for (const o of outcomes) {
    for (const [path, data] of Object.entries(o.files)) {
      if (!(path in merged)) {
        merged[path] = data;
        continue;
      }
      // 충돌 → -2, -3 ... 을 붙여 새 이름을 찾습니다.
      const dot = path.lastIndexOf(".");
      const stem = dot > 0 ? path.slice(0, dot) : path;
      const ext = dot > 0 ? path.slice(dot) : "";
      let n = 2;
      while (`${stem}-${n}${ext}` in merged) n++;
      merged[`${stem}-${n}${ext}`] = data;
    }
  }
  return merged;
}

const topics = [
  "RAG(검색 증강 생성)의 개념과 장단점을 조사하라.",
  "파인튜닝의 개념과 장단점을 조사하라.",
  "RAG와 파인튜닝의 비용 구조를 비교 조사하라.",
];

console.time("순차");
for (const t of topics) await researchOne(t);
console.timeEnd("순차");

console.time("병렬");
await researchInParallel(topics, 3);
console.timeEnd("병렬");

import { createMiddleware, ToolMessage } from "langchain";

export interface BudgetOptions {
  maxSearches: number;
  maxTokens?: number;
}

/**
 * 검색 예산 미들웨어.
 *
 * ⚠️ 이 함수는 **팩토리**입니다. 호출할 때마다 새 카운터가 생깁니다.
 * 모듈 최상단에서 한 번 만들어 여러 실행이 공유하면, 카운터가 누적되어
 * 두 번째 실행이 시작하자마자 예산 소진 상태가 됩니다. 실행마다 새로 부르세요.
 */
export function createSearchBudgetMiddleware(options: BudgetOptions) {
  const { maxSearches, maxTokens } = options;

  let searchCount = 0;
  let totalTokens = 0;

  // createMiddleware 를 쓰면 훅의 타입이 전부 추론됩니다.
  // 객체 리터럴에 `as AgentMiddleware` 를 붙이는 것보다 안전합니다 —
  // 단언은 훅 시그니처가 틀려도 통과시켜 버립니다.
  return createMiddleware({
    name: "SearchBudgetMiddleware",

    // 모델 응답마다 토큰을 누적합니다.
    afterModel: (state) => {
      const last = state.messages[state.messages.length - 1];
      // usage_metadata 는 AIMessage 에만 있으므로 unknown 을 거쳐 좁힙니다.
      const usage = (last as unknown as { usage_metadata?: unknown })?.usage_metadata as
        | { input_tokens?: number; output_tokens?: number }
        | undefined;
      if (usage) {
        totalTokens += (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0);
      }
      return undefined; // 상태를 바꾸지 않습니다
    },

    // 도구 실행을 가로챕니다.
    wrapToolCall: (request, handler) => {
      if (request.toolCall.name !== "web_search") {
        return handler(request); // 다른 도구는 통과
      }

      // ⚠️ wrapToolCall 은 ToolMessage | Command 를 돌려줘야 합니다.
      //    { content, tool_call_id } 같은 평범한 객체를 돌려주면 타입이 맞지 않습니다.
      const deny = (reason: string) =>
        new ToolMessage({ content: reason, tool_call_id: request.toolCall.id ?? "" });

      if (searchCount >= maxSearches) {
        // throw 하지 않습니다. 문자열로 알려줘야 모델이 대처합니다.
        return deny(
          `검색 예산(${maxSearches}회)을 모두 사용했습니다. 더 이상 검색할 수 없습니다. ` +
            "지금까지 찾은 정보로 결론을 정리하세요.",
        );
      }

      if (maxTokens !== undefined && totalTokens >= maxTokens) {
        return deny(
          `토큰 예산(${maxTokens.toLocaleString()})을 초과했습니다(현재 ${totalTokens.toLocaleString()}). ` +
            "검색을 중단하고 지금까지 찾은 정보로 결론을 정리하세요.",
        );
      }

      searchCount++;
      return handler(request);
    },
  });
}

import { createDeepAgent } from "deepagents";
import { createSearchBudgetMiddleware } from "./budget.js";

function createBudgetedResearcher() {
  return createDeepAgent({
    model: RESEARCH_MODEL,
    systemPrompt: RESEARCHER_PROMPT,
    tools: [createSearchTool()],
    // 실행마다 새 팩토리 호출 → 카운터 격리
    middleware: [createSearchBudgetMiddleware({ maxSearches: 5, maxTokens: 100_000 })],
  });
}

import "dotenv/config";
import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";
import { Command } from "@langchain/langgraph";
import { createDeepAgent } from "deepagents";
import { ORCHESTRATOR_PROMPT } from "../prompts.js";
import { allSubagents, ORCHESTRATOR_MODEL } from "../subagents.js";
import { readStateFile } from "../agent.js";

const argv = process.argv.slice(2);
const threadIdx = argv.indexOf("--thread");
// ⚠️ crypto.randomUUID() 를 기본값으로 두면 재개가 원천적으로 불가능합니다.
const threadId = threadIdx >= 0 ? argv[threadIdx + 1] : undefined;
if (!threadId) {
  console.error("--thread <id> 는 필수입니다. 재개하려면 같은 id 를 쓰세요.");
  process.exit(1);
}

// 디스크에 저장되는 체크포인터. 프로세스가 죽어도 남습니다.
const checkpointer = SqliteSaver.fromConnString("./research-checkpoints.sqlite");

const agent = createDeepAgent({
  model: ORCHESTRATOR_MODEL,
  systemPrompt: ORCHESTRATOR_PROMPT,
  tools: [],
  subagents: allSubagents,
  checkpointer,
  interruptOn: {
    write_file: {
      allowedDecisions: ["approve", "reject"],
      when: (request) => String(request.toolCall.args.file_path ?? "") === "/report.md",
    },
  },
});

const config = { configurable: { thread_id: threadId }, recursionLimit: 100 };

// 지금 이 스레드가 어떤 상태인지 먼저 확인합니다.
const snapshot = await agent.getState(config);
const hasHistory = snapshot.values && Object.keys(snapshot.values).length > 0;
const isPending = (snapshot.next?.length ?? 0) > 0;

console.log(`thread: ${threadId}`);
console.log(`  이전 기록: ${hasHistory ? "있음" : "없음"}`);
console.log(`  대기 중인 노드: ${snapshot.next?.join(", ") || "(없음)"}`);

let result;

if (!hasHistory) {
  // 신규 실행
  const question = argv.filter((a, i) => i !== threadIdx && i !== threadIdx + 1).join(" ").trim();
  console.log(`\n새 리서치 시작: ${question}\n`);
  result = await agent.invoke({ messages: [{ role: "user", content: question }] }, config);
} else if (isPending && argv.includes("--approve-pending")) {
  // 승인 대기 중이었던 것을 승인하며 재개
  console.log("\n승인 대기 지점부터 재개합니다.\n");
  result = await agent.invoke(new Command({ resume: { decisions: [{ type: "approve" }] } }), config);
} else {
  // 중간에 죽었던 것을 그냥 이어서 진행
  // 입력에 null 을 주면 "새 메시지 없이 마지막 지점부터 계속"이라는 뜻입니다.
  console.log("\n마지막 지점부터 이어서 진행합니다.\n");
  result = await agent.invoke(null, config);
}

const files = (result as { files?: Record<string, unknown> }).files;
console.log(readStateFile(files, "/report.md") ?? "(아직 보고서 없음 — 승인 대기 중일 수 있습니다)");

import { createDeepAgent, FilesystemBackend } from "deepagents";
import type { SubAgent } from "deepagents";
import { ORCHESTRATOR_MODEL, RESEARCH_MODEL, CRITIQUE_MODEL } from "../subagents.js";

const TODAY = new Date().toISOString().split("T")[0];

/* ===== 프롬프트 3개를 도메인에 맞게 다시 씀 ===== */

const REVIEW_ORCHESTRATOR_PROMPT = `당신은 코드 리뷰 오케스트레이터입니다. 오늘 날짜는 ${TODAY} 입니다.

직접 리뷰하지 마세요. 리뷰는 reviewer-subagent 에게 위임하고, 당신은 종합만 합니다.

# 절차
1. write_file 로 리뷰 대상 범위와 기준을 \`/scope.md\` 에 저장합니다. (← /question.txt 에 해당하는 기준점)
2. write_todos 로 리뷰 단계를 3~6개로 쪼갭니다. 파일이나 관심사 단위로 나누세요.
3. task() 로 reviewer-subagent 에게 위임합니다. 한 번에 하나의 파일 또는 하나의 관심사만 주세요.
   지적 결과는 \`/issues/<파일-슬러그>.md\` 에 저장하라고 지시하세요.
4. task() 로 judge-subagent 를 호출해 지적이 타당한지 심사시킵니다.
5. \`/issues/\` 를 모두 읽고 종합해 \`/review.md\` 에 씁니다.
6. \`/scope.md\` 를 다시 읽고 범위를 다 덮었는지 확인합니다.

# 리뷰 보고서 규칙
- 심각도(critical / major / minor)로 분류합니다.
- 각 지적에는 반드시 \`파일:줄번호\` 를 답니다. ← 리서치의 '인용'에 해당합니다.
- 근거 없는 취향 지적은 쓰지 마세요. "이렇게 하는 게 더 예쁘다"는 리뷰가 아닙니다.
- 코드를 **고치지 마세요.** 지적만 합니다.`;

const REVIEWER_PROMPT = `당신은 코드 리뷰어입니다. 오늘 날짜는 ${TODAY} 입니다.

read_file, grep, glob 으로 코드를 읽고 문제를 찾습니다. 코드를 수정할 권한은 없습니다.

# 예산
- 파일 하나당 read_file/grep 을 합쳐 최대 8회.
- 같은 파일을 두 번 읽지 마세요.

# 무엇을 찾나 (우선순위 순)
1. 버그 — 잘못된 로직, 처리 안 된 에러, 경계 조건
2. 보안 — 인젝션, 시크릿 하드코딩, 검증 누락
3. 성능 — N+1, 불필요한 반복, 누수
4. 가독성 — 이름, 죽은 코드

취향 문제(따옴표 스타일 등)는 **적지 마세요.** 포매터가 할 일입니다.

# 저장
write_file 로 \`/issues/<파일-슬러그>.md\` 에 저장하세요.

\`\`\`markdown
# <파일 경로>

## 지적
- **[critical] 제목** (\`파일:줄번호\`)
  무엇이 문제이고 왜 문제인가.

## 확인하지 못한 것
(읽지 못한 부분. 없으면 "없음")
\`\`\`

부모에게는 요약만 돌려주세요. 코드 원문을 붙여넣지 마세요.`;

const JUDGE_PROMPT = `당신은 코드 리뷰 지적을 심사합니다. 오늘 날짜는 ${TODAY} 입니다.

당신에게는 코드 수정 권한이 없습니다. read_file 로 읽고 판정만 합니다.

# 절차
1. ls 로 \`/issues/\` 를 봅니다.
2. 각 파일을 읽습니다.
3. 지적된 \`파일:줄번호\` 를 read_file 로 **직접 확인**합니다.

# 심사 기준
- **위치 오류**: 지적한 줄번호에 그 코드가 실제로 없는가? (← 리서치의 '출처 유령')
- **오해**: 리뷰어가 코드를 잘못 읽었는가?
- **취향**: 버그가 아니라 취향 문제를 지적했는가?
- **범위 밖**: /scope.md 의 범위를 벗어난 지적인가?
- **누락**: 명백한 문제를 놓쳤는가?

# 출력
판정: PASS 또는 REVISE
REVISE 면 각 항목마다 - 문제 / 위치 / 조치(재리뷰 주제 한 문장).
칭찬하지 마세요.`;

/* ===== 서브에이전트 ===== */

const reviewerSubagent: SubAgent = {
  name: "reviewer-subagent",
  description:
    "코드 파일 하나 또는 하나의 관심사를 리뷰하고, 지적을 /issues/ 에 저장한 뒤 요약을 돌려줍니다. " +
    "한 번에 하나의 파일만 주세요. 파일 경로와 리뷰 관점을 함께 지시해야 합니다.",
  systemPrompt: REVIEWER_PROMPT,
  model: RESEARCH_MODEL,
  // ⚠️ 리뷰어는 코드를 고치면 안 됩니다. 권한으로 강제합니다.
  permissions: [
    { operations: ["read"], paths: ["/**"] },
    // 지적은 저장해야 하므로 /issues/ 만 쓰기 허용 — 전역 deny 보다 **앞**에 와야 합니다.
    { operations: ["write"], paths: ["/issues/**"] },
    { operations: ["write"], paths: ["/**"], mode: "deny" },
  ],
};

const judgeSubagent: SubAgent = {
  name: "judge-subagent",
  description:
    "/issues/ 의 지적이 타당한지 심사해 PASS 또는 REVISE 를 판정합니다. 코드를 수정하지 않습니다.",
  systemPrompt: JUDGE_PROMPT,
  model: CRITIQUE_MODEL,
  permissions: [
    { operations: ["read"], paths: ["/**"] },
    { operations: ["write"], paths: ["/**"], mode: "deny" },
  ],
};

export function createCodeReviewAgent(rootDir: string) {
  return createDeepAgent({
    model: ORCHESTRATOR_MODEL,
    systemPrompt: REVIEW_ORCHESTRATOR_PROMPT,
    tools: [], // 검색 없음 — 도구는 파일시스템뿐
    subagents: [reviewerSubagent, judgeSubagent],
    // 진짜 코드를 읽어야 하므로 FilesystemBackend
    backend: new FilesystemBackend({ rootDir }),
  });
}

import { buildResearchAgent, readStateFile } from "../agent.js";
import { verifyCitations, collectUrlsFromFindings } from "./citations.js";

export interface EvalResult {
  question: string;
  passed: boolean;
  checks: Record<string, boolean>;
  metrics: {
    reportLength: number;
    sourceCount: number;
    citationCount: number;
    findingsCount: number;
    durationMs: number;
  };
}

const SELF_REFERENCE = /제가\s*조사|찾아보니|검색해\s*보니|제가\s*알아본|저는\s*.{0,10}했습니다/;

async function evalOne(question: string): Promise<EvalResult> {
  const started = Date.now();
  const agent = buildResearchAgent();
  const result = await agent.invoke(
    { messages: [{ role: "user", content: question }] },
    { configurable: { thread_id: crypto.randomUUID() }, recursionLimit: 100 },
  );
  const durationMs = Date.now() - started;

  const files = (result as { files?: Record<string, unknown> }).files ?? {};
  const report = readStateFile(files, "/report.md") ?? "";
  const allowed = collectUrlsFromFindings(files);
  const issues = verifyCitations(report, allowed);
  const findingsPaths = Object.keys(files).filter((p) => p.startsWith("/findings/"));

  const checks: Record<string, boolean> = {
    report_exists: report.length > 0,
    has_sources: /^###\s*출처\s*$/m.test(report),
    no_ghost_citations: !issues.some((i) => i.kind === "ghost_citation"),
    no_hallucinated_urls: !issues.some((i) => i.kind === "hallucinated_url"),
    question_saved: readStateFile(files, "/question.txt") !== undefined,
    findings_exist: findingsPaths.length > 0,
    no_self_reference: !SELF_REFERENCE.test(report),
  };

  return {
    question,
    passed: Object.values(checks).every(Boolean),
    checks,
    metrics: {
      reportLength: report.length,
      sourceCount: (report.match(/^\s*\[\d+\]\s*.+?:\s*https?:\/\//gm) ?? []).length,
      citationCount: new Set(report.match(/\[\d+\]/g) ?? []).size,
      findingsCount: findingsPaths.length,
      durationMs,
    },
  };
}

/**
 * 각 질문을 repeats 회 반복합니다.
 *
 * 모델은 비결정적이라 1회 결과로 "좋아졌다"고 하면 그냥 운입니다.
 * 3회 이상 돌려 통과율을 봐야 프롬프트 변경의 효과를 말할 수 있습니다.
 */
export async function runEval(questions: string[], repeats = 3): Promise<EvalResult[]> {
  const out: EvalResult[] = [];
  for (const q of questions) {
    for (let i = 0; i < repeats; i++) {
      out.push(await evalOne(q));
    }
  }
  return out;
}

export function printReport(results: EvalResult[]): void {
  const checkNames = Object.keys(results[0]?.checks ?? {});

  console.log("\n검사별 통과율");
  console.log("-".repeat(52));
  for (const name of checkNames) {
    const passed = results.filter((r) => r.checks[name]).length;
    const rate = (passed / results.length) * 100;
    const bar = "█".repeat(Math.round(rate / 5)).padEnd(20, "░");
    console.log(`  ${name.padEnd(22)} ${bar} ${rate.toFixed(0).padStart(3)}%`);
  }

  const overall = results.filter((r) => r.passed).length;
  console.log("-".repeat(52));
  console.log(`  전체 통과: ${overall}/${results.length} (${((overall / results.length) * 100).toFixed(0)}%)`);

  const avg = (f: (r: EvalResult) => number) =>
    (results.reduce((s, r) => s + f(r), 0) / results.length).toFixed(0);
  console.log(`  평균 보고서 길이: ${avg((r) => r.metrics.reportLength)}자`);
  console.log(`  평균 출처 수    : ${avg((r) => r.metrics.sourceCount)}`);
  console.log(`  평균 소요       : ${avg((r) => r.metrics.durationMs)}ms`);
}

// 질문 유형을 섞습니다: 단순 사실 / 비교 / 목록
const QUESTIONS = [
  "RAG(검색 증강 생성)란 무엇인가?",
  "RAG와 파인튜닝의 주요 차이점은 무엇인가?",
  "RAG 시스템의 비용을 줄이는 기법들을 나열하라.",
];

if (import.meta.url === `file://${process.argv[1]}`) {
  // ⚠️ 목 검색으로 돌리세요. TAVILY_API_KEY 가 있으면 지워야 재현이 됩니다.
  delete process.env.TAVILY_API_KEY;
  printReport(await runEval(QUESTIONS, 3));
}

import "dotenv/config";
import { createServer } from "node:http";
import { buildResearchAgent, readStateFile } from "../agent.js";

const PORT = 3000;

const PAGE = `<!doctype html>
<html lang="ko"><meta charset="utf-8">
<title>딥 리서치</title>
<style>
  body { font-family: system-ui, sans-serif; max-width: 820px; margin: 2rem auto; padding: 0 1rem; }
  #log { background: #111; color: #0f0; padding: 1rem; height: 320px; overflow-y: auto;
         font-family: ui-monospace, monospace; font-size: 12px; white-space: pre-wrap; }
  #report { border: 1px solid #ddd; padding: 1rem; margin-top: 1rem; white-space: pre-wrap; }
  input { width: 70%; padding: .5rem; }
  button { padding: .5rem 1rem; }
</style>
<h1>딥 리서치 에이전트</h1>
<input id="q" value="RAG와 파인튜닝의 차이는?">
<button onclick="run()">조사</button>
<h3>진행 상황</h3>
<div id="log"></div>
<h3>보고서</h3>
<div id="report"></div>
<script>
function run() {
  const log = document.getElementById('log');
  const report = document.getElementById('report');
  log.textContent = ''; report.textContent = '';
  const es = new EventSource('/run?q=' + encodeURIComponent(document.getElementById('q').value));
  es.addEventListener('progress', (e) => {
    log.textContent += JSON.parse(e.data).line + '\\n';
    log.scrollTop = log.scrollHeight;   // 항상 최신 줄이 보이게
  });
  es.addEventListener('report', (e) => { report.textContent = JSON.parse(e.data).report; });
  es.addEventListener('done', () => es.close());
}
</script>`;

createServer(async (req, res) => {
  const url = new URL(req.url ?? "/", \`http://\${req.headers.host}\`);

  if (url.pathname === "/") {
    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
    res.end(PAGE);
    return;
  }

  if (url.pathname !== "/run") {
    res.writeHead(404).end();
    return;
  }

  // SSE 헤더
  res.writeHead(200, {
    "Content-Type": "text/event-stream; charset=utf-8",
    "Cache-Control": "no-cache",
    Connection: "keep-alive",
  });
  const send = (event: string, data: unknown) =>
    res.write(\`event: \${event}\\ndata: \${JSON.stringify(data)}\\n\\n\`);

  const question = url.searchParams.get("q") ?? "";
  const agent = buildResearchAgent();

  try {
    const stream = await agent.streamEvents(
      { messages: [{ role: "user", content: question }] },
      { version: "v3", configurable: { thread_id: crypto.randomUUID() }, recursionLimit: 100 },
    );

    // run.subagents 로 서브에이전트 활동을 따로 잡습니다 — UI 의 핵심.
    void (async () => {
      for await (const sub of stream.subagents) {
        send("progress", { line: \`  ↳ [\${sub.name}] 작업 중\` });
      }
    })();

    for await (const message of stream.messages) {
      for await (const chunk of message.toolCalls) {
        // ⚠️ 도구 호출 인자는 조각나서 옵니다. 여기서 JSON.parse 하면 터집니다.
        //    이름만 씁니다.
        send("progress", { line: \`도구 호출: \${chunk.name ?? "(...)"}\` });
      }
    }

    const result = await stream.result;
    const files = (result as { files?: Record<string, unknown> }).files;
    send("report", { report: readStateFile(files, "/report.md") ?? "(보고서 없음)" });
  } catch (e) {
    send("progress", { line: \`에러: \${String(e)}\` });
  } finally {
    send("done", {});
    res.end();
  }
}).listen(PORT, () => console.log(\`http://localhost:\${PORT}\`));