@mandujs/core 0.8.2 → 0.9.0

package/src/brain/doctor/patcher.ts

@@ -0,0 +1,349 @@
+/**
+ * Brain v0.1 - Doctor Patcher
+ *
+ * Generates and applies minimal patches to fix violations.
+ * Auto-apply is disabled by default - patches are suggestions only.
+ */
+
+import type { PatchSuggestion } from "../types";
+import type { DoctorAnalysis } from "../types";
+import {
+  validatePatchSuggestion,
+  filterSafePatchSuggestions,
+} from "../permissions";
+import path from "path";
+import fs from "fs/promises";
+
+/**
+ * Patch application result
+ */
+export interface PatchResult {
+  /** Whether the patch was applied */
+  applied: boolean;
+  /** The patch that was applied */
+  patch: PatchSuggestion;
+  /** Error message if failed */
+  error?: string;
+  /** Output from command (for command type) */
+  output?: string;
+}
+
+/**
+ * Batch patch result
+ */
+export interface BatchPatchResult {
+  /** Total patches attempted */
+  total: number;
+  /** Successfully applied */
+  applied: number;
+  /** Failed patches */
+  failed: number;
+  /** Skipped (unsafe) patches */
+  skipped: number;
+  /** Individual results */
+  results: PatchResult[];
+}
+
+/**
+ * Prioritize patches by confidence and type
+ */
+export function prioritizePatches(patches: PatchSuggestion[]): PatchSuggestion[] {
+  return [...patches].sort((a, b) => {
+    // Commands before modifications
+    if (a.type === "command" && b.type !== "command") return -1;
+    if (b.type === "command" && a.type !== "command") return 1;
+
+    // Higher confidence first
+    return b.confidence - a.confidence;
+  });
+}
+
+/**
+ * Deduplicate patches by file and type
+ */
+export function deduplicatePatches(patches: PatchSuggestion[]): PatchSuggestion[] {
+  const seen = new Set<string>();
+  const result: PatchSuggestion[] = [];
+
+  for (const patch of patches) {
+    const key = `${patch.file}:${patch.type}:${patch.command || ""}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(patch);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Generate a minimal patch for a violation
+ *
+ * Returns a human-readable patch description.
+ */
+export function generatePatchDescription(patch: PatchSuggestion): string {
+  const confidenceLabel =
+    patch.confidence >= 0.8
+      ? "높음"
+      : patch.confidence >= 0.5
+        ? "보통"
+        : "낮음";
+
+  switch (patch.type) {
+    case "command":
+      return `[명령어 실행] ${patch.command}\n  대상: ${patch.file}\n  설명: ${patch.description}\n  신뢰도: ${confidenceLabel}`;
+
+    case "add":
+      return `[파일 생성] ${patch.file}\n  설명: ${patch.description}\n  신뢰도: ${confidenceLabel}`;
+
+    case "modify":
+      const lineInfo = patch.line ? ` (라인 ${patch.line})` : "";
+      return `[파일 수정] ${patch.file}${lineInfo}\n  설명: ${patch.description}\n  신뢰도: ${confidenceLabel}`;
+
+    case "delete":
+      return `[파일 삭제] ${patch.file}\n  설명: ${patch.description}\n  신뢰도: ${confidenceLabel}`;
+
+    default:
+      return `[${patch.type}] ${patch.file}\n  설명: ${patch.description}`;
+  }
+}
+
+/**
+ * Apply a single patch
+ *
+ * NOTE: This is experimental and disabled by default.
+ * Only applies safe patches (commands like mandu generate).
+ */
+export async function applyPatch(
+  patch: PatchSuggestion,
+  rootDir: string
+): Promise<PatchResult> {
+  // Validate patch first
+  const validation = validatePatchSuggestion(patch);
+
+  if (!validation.valid) {
+    return {
+      applied: false,
+      patch,
+      error: validation.reason || "Patch validation failed",
+    };
+  }
+
+  if (validation.requiresConfirmation) {
+    return {
+      applied: false,
+      patch,
+      error: `Manual confirmation required: ${validation.reason}`,
+    };
+  }
+
+  try {
+    switch (patch.type) {
+      case "command": {
+        if (!patch.command) {
+          return {
+            applied: false,
+            patch,
+            error: "No command specified",
+          };
+        }
+
+        // Only allow mandu commands for safety
+        if (!patch.command.startsWith("bunx mandu")) {
+          return {
+            applied: false,
+            patch,
+            error: "Only mandu commands are allowed for auto-apply",
+          };
+        }
+
+        // Execute the command
+        const proc = Bun.spawn(patch.command.split(" "), {
+          cwd: rootDir,
+          stdout: "pipe",
+          stderr: "pipe",
+        });
+
+        const stdout = await new Response(proc.stdout).text();
+        const stderr = await new Response(proc.stderr).text();
+        const exitCode = await proc.exited;
+
+        if (exitCode !== 0) {
+          return {
+            applied: false,
+            patch,
+            error: stderr || `Command exited with code ${exitCode}`,
+            output: stdout,
+          };
+        }
+
+        return {
+          applied: true,
+          patch,
+          output: stdout,
+        };
+      }
+
+      case "add":
+      case "modify": {
+        if (!patch.content) {
+          return {
+            applied: false,
+            patch,
+            error: "No content specified for file operation",
+          };
+        }
+
+        const filePath = path.join(rootDir, patch.file);
+
+        // Ensure directory exists
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+
+        // Write content
+        await fs.writeFile(filePath, patch.content, "utf-8");
+
+        return {
+          applied: true,
+          patch,
+        };
+      }
+
+      case "delete": {
+        const filePath = path.join(rootDir, patch.file);
+
+        try {
+          await fs.unlink(filePath);
+          return {
+            applied: true,
+            patch,
+          };
+        } catch (error) {
+          return {
+            applied: false,
+            patch,
+            error:
+              error instanceof Error
+                ? error.message
+                : "Failed to delete file",
+          };
+        }
+      }
+
+      default:
+        return {
+          applied: false,
+          patch,
+          error: `Unknown patch type: ${patch.type}`,
+        };
+    }
+  } catch (error) {
+    return {
+      applied: false,
+      patch,
+      error: error instanceof Error ? error.message : "Unknown error",
+    };
+  }
+}
+
+/**
+ * Apply multiple patches
+ *
+ * NOTE: Auto-apply is experimental and disabled by default.
+ */
+export async function applyPatches(
+  patches: PatchSuggestion[],
+  rootDir: string,
+  options: { dryRun?: boolean; minConfidence?: number } = {}
+): Promise<BatchPatchResult> {
+  const { dryRun = true, minConfidence = 0.5 } = options;
+
+  // Filter safe patches
+  const safePatches = filterSafePatchSuggestions(patches);
+
+  // Filter by confidence
+  const confidentPatches = safePatches.filter(
+    (p) => p.confidence >= minConfidence
+  );
+
+  // Deduplicate and prioritize
+  const orderedPatches = prioritizePatches(deduplicatePatches(confidentPatches));
+
+  const results: PatchResult[] = [];
+  let applied = 0;
+  let failed = 0;
+  const skipped = patches.length - orderedPatches.length;
+
+  for (const patch of orderedPatches) {
+    if (dryRun) {
+      // In dry run mode, just report what would be done
+      results.push({
+        applied: false,
+        patch,
+        error: "Dry run mode - patch not applied",
+      });
+      continue;
+    }
+
+    const result = await applyPatch(patch, rootDir);
+    results.push(result);
+
+    if (result.applied) {
+      applied++;
+    } else {
+      failed++;
+    }
+  }
+
+  return {
+    total: patches.length,
+    applied,
+    failed,
+    skipped,
+    results,
+  };
+}
+
+/**
+ * Generate a patch report from analysis
+ */
+export function generatePatchReport(analysis: DoctorAnalysis): string {
+  const lines: string[] = [];
+
+  lines.push("# Mandu Doctor Report");
+  lines.push("");
+  lines.push(`## 요약`);
+  lines.push(analysis.summary);
+  lines.push("");
+
+  if (analysis.explanation) {
+    lines.push(`## 상세 분석`);
+    lines.push(analysis.explanation);
+    lines.push("");
+  }
+
+  if (analysis.patches.length > 0) {
+    lines.push(`## 제안된 패치 (${analysis.patches.length}개)`);
+    lines.push("");
+
+    const prioritized = prioritizePatches(analysis.patches);
+
+    for (let i = 0; i < prioritized.length; i++) {
+      lines.push(`### ${i + 1}. ${prioritized[i].description}`);
+      lines.push(generatePatchDescription(prioritized[i]));
+      lines.push("");
+    }
+  }
+
+  if (analysis.nextCommand) {
+    lines.push(`## 권장 다음 명령어`);
+    lines.push("```bash");
+    lines.push(analysis.nextCommand);
+    lines.push("```");
+    lines.push("");
+  }
+
+  lines.push(`---`);
+  lines.push(`LLM 지원: ${analysis.llmAssisted ? "예" : "아니오"}`);
+
+  return lines.join("\n");
+}

package/src/brain/doctor/reporter.ts

@@ -0,0 +1,336 @@
+/**
+ * Brain v0.1 - Doctor Reporter
+ *
+ * Formats and outputs Doctor analysis results.
+ * Works with or without LLM - always provides actionable output.
+ */
+
+import type { DoctorAnalysis, PatchSuggestion } from "../types";
+import type { GuardViolation } from "../../guard/rules";
+import { prioritizePatches } from "./patcher";
+
+/**
+ * ANSI color codes for terminal output
+ */
+const colors = {
+  reset: "\x1b[0m",
+  bright: "\x1b[1m",
+  dim: "\x1b[2m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  magenta: "\x1b[35m",
+  cyan: "\x1b[36m",
+};
+
+/**
+ * Check if colors should be used
+ */
+function useColors(): boolean {
+  // Check for NO_COLOR environment variable
+  if (process.env.NO_COLOR) return false;
+
+  // Check if stdout is a TTY
+  if (typeof process?.stdout?.isTTY === "boolean") {
+    return process.stdout.isTTY;
+  }
+
+  return true;
+}
+
+/**
+ * Apply color if enabled
+ */
+function color(text: string, colorCode: string): string {
+  if (!useColors()) return text;
+  return `${colorCode}${text}${colors.reset}`;
+}
+
+/**
+ * Format a violation for terminal output
+ */
+export function formatViolation(violation: GuardViolation): string {
+  const lines: string[] = [];
+
+  const severity = violation.severity || "error";
+  const icon = severity === "error" ? "❌" : "⚠️";
+  const colorCode = severity === "error" ? colors.red : colors.yellow;
+
+  lines.push(
+    `${icon} ${color(`[${violation.ruleId}]`, colorCode)} ${violation.file}`
+  );
+  lines.push(`   ${violation.message}`);
+
+  if (violation.suggestion) {
+    lines.push(`   ${color("💡", colors.cyan)} ${violation.suggestion}`);
+  }
+
+  if (violation.line) {
+    lines.push(`   ${color("📍", colors.dim)} Line ${violation.line}`);
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Format a patch suggestion for terminal output
+ */
+export function formatPatch(patch: PatchSuggestion, index: number): string {
+  const lines: string[] = [];
+
+  const confidenceIcon =
+    patch.confidence >= 0.8 ? "🟢" : patch.confidence >= 0.5 ? "🟡" : "🔴";
+
+  lines.push(
+    `${color(`${index}.`, colors.bright)} ${patch.description} ${confidenceIcon}`
+  );
+
+  switch (patch.type) {
+    case "command":
+      lines.push(
+        `   ${color("$ ", colors.dim)}${color(patch.command || "", colors.cyan)}`
+      );
+      break;
+
+    case "add":
+      lines.push(`   ${color("+ 파일 생성:", colors.green)} ${patch.file}`);
+      break;
+
+    case "modify":
+      lines.push(`   ${color("~ 파일 수정:", colors.yellow)} ${patch.file}`);
+      if (patch.line) {
+        lines.push(`   ${color("📍", colors.dim)} Line ${patch.line}`);
+      }
+      break;
+
+    case "delete":
+      lines.push(`   ${color("- 파일 삭제:", colors.red)} ${patch.file}`);
+      break;
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Print Doctor analysis to console
+ */
+export function printDoctorReport(analysis: DoctorAnalysis): void {
+  const { violations, summary, explanation, patches, llmAssisted, nextCommand } =
+    analysis;
+
+  console.log();
+  console.log(color("🩺 Mandu Doctor Report", colors.bright + colors.blue));
+  console.log(color("─".repeat(50), colors.dim));
+  console.log();
+
+  // Summary
+  console.log(color("📋 요약", colors.bright));
+  console.log(`   ${summary}`);
+  console.log();
+
+  // Violations
+  if (violations.length > 0) {
+    console.log(
+      color(`🔍 발견된 위반 (${violations.length}개)`, colors.bright)
+    );
+    console.log();
+
+    for (const violation of violations) {
+      console.log(formatViolation(violation));
+      console.log();
+    }
+  }
+
+  // Detailed explanation
+  if (explanation) {
+    console.log(color("📖 상세 분석", colors.bright));
+    console.log();
+
+    // Format explanation with proper indentation
+    const explLines = explanation.split("\n");
+    for (const line of explLines) {
+      if (line.startsWith("##")) {
+        console.log(color(line.replace("## ", "▸ "), colors.cyan));
+      } else if (line.trim()) {
+        console.log(`   ${line}`);
+      } else {
+        console.log();
+      }
+    }
+    console.log();
+  }
+
+  // Patch suggestions
+  if (patches.length > 0) {
+    console.log(color(`💊 제안된 수정 (${patches.length}개)`, colors.bright));
+    console.log();
+
+    const prioritized = prioritizePatches(patches);
+
+    for (let i = 0; i < prioritized.length; i++) {
+      console.log(formatPatch(prioritized[i], i + 1));
+      console.log();
+    }
+  }
+
+  // Next command
+  if (nextCommand) {
+    console.log(color("▶ 권장 다음 명령어", colors.bright));
+    console.log();
+    console.log(`   ${color("$ ", colors.dim)}${color(nextCommand, colors.green)}`);
+    console.log();
+  }
+
+  // Footer
+  console.log(color("─".repeat(50), colors.dim));
+  console.log(
+    `${color("ℹ️", colors.cyan)} LLM 지원: ${llmAssisted ? color("예", colors.green) : color("아니오", colors.yellow)}`
+  );
+  console.log();
+}
+
+/**
+ * Generate a JSON report for MCP/API consumption
+ */
+export function generateJsonReport(analysis: DoctorAnalysis): string {
+  return JSON.stringify(
+    {
+      summary: analysis.summary,
+      violationCount: analysis.violations.length,
+      violations: analysis.violations.map((v) => ({
+        ruleId: v.ruleId,
+        file: v.file,
+        message: v.message,
+        suggestion: v.suggestion,
+        line: v.line,
+        severity: v.severity || "error",
+      })),
+      patches: analysis.patches.map((p) => ({
+        file: p.file,
+        type: p.type,
+        description: p.description,
+        command: p.command,
+        confidence: p.confidence,
+      })),
+      nextCommand: analysis.nextCommand,
+      llmAssisted: analysis.llmAssisted,
+    },
+    null,
+    2
+  );
+}
+
+/**
+ * Generate a Markdown report
+ */
+export function generateMarkdownReport(analysis: DoctorAnalysis): string {
+  const lines: string[] = [];
+
+  lines.push("# 🩺 Mandu Doctor Report");
+  lines.push("");
+
+  lines.push("## 📋 요약");
+  lines.push("");
+  lines.push(analysis.summary);
+  lines.push("");
+
+  if (analysis.violations.length > 0) {
+    lines.push(`## 🔍 발견된 위반 (${analysis.violations.length}개)`);
+    lines.push("");
+
+    for (const v of analysis.violations) {
+      const severity = v.severity || "error";
+      const icon = severity === "error" ? "❌" : "⚠️";
+
+      lines.push(`### ${icon} ${v.ruleId}`);
+      lines.push("");
+      lines.push(`- **파일**: \`${v.file}\``);
+      lines.push(`- **메시지**: ${v.message}`);
+      if (v.suggestion) {
+        lines.push(`- **제안**: ${v.suggestion}`);
+      }
+      if (v.line) {
+        lines.push(`- **라인**: ${v.line}`);
+      }
+      lines.push("");
+    }
+  }
+
+  if (analysis.explanation) {
+    lines.push("## 📖 상세 분석");
+    lines.push("");
+    lines.push(analysis.explanation);
+    lines.push("");
+  }
+
+  if (analysis.patches.length > 0) {
+    lines.push(`## 💊 제안된 수정 (${analysis.patches.length}개)`);
+    lines.push("");
+
+    const prioritized = prioritizePatches(analysis.patches);
+
+    for (let i = 0; i < prioritized.length; i++) {
+      const p = prioritized[i];
+      const confidenceLabel =
+        p.confidence >= 0.8 ? "🟢 높음" : p.confidence >= 0.5 ? "🟡 보통" : "🔴 낮음";
+
+      lines.push(`### ${i + 1}. ${p.description}`);
+      lines.push("");
+      lines.push(`- **타입**: ${p.type}`);
+      lines.push(`- **대상**: \`${p.file}\``);
+      lines.push(`- **신뢰도**: ${confidenceLabel}`);
+
+      if (p.command) {
+        lines.push("");
+        lines.push("```bash");
+        lines.push(p.command);
+        lines.push("```");
+      }
+
+      lines.push("");
+    }
+  }
+
+  if (analysis.nextCommand) {
+    lines.push("## ▶ 권장 다음 명령어");
+    lines.push("");
+    lines.push("```bash");
+    lines.push(analysis.nextCommand);
+    lines.push("```");
+    lines.push("");
+  }
+
+  lines.push("---");
+  lines.push("");
+  lines.push(
+    `*LLM 지원: ${analysis.llmAssisted ? "예" : "아니오"}*`
+  );
+
+  return lines.join("\n");
+}
+
+/**
+ * Format output based on requested format
+ */
+export type ReportFormat = "console" | "json" | "markdown";
+
+export function formatDoctorReport(
+  analysis: DoctorAnalysis,
+  format: ReportFormat = "console"
+): string | void {
+  switch (format) {
+    case "console":
+      printDoctorReport(analysis);
+      return;
+
+    case "json":
+      return generateJsonReport(analysis);
+
+    case "markdown":
+      return generateMarkdownReport(analysis);
+
+    default:
+      printDoctorReport(analysis);
+  }
+}