cdsa-harness 0.14.2 → 0.19.0

package/src/completion.js

@@ -0,0 +1,56 @@
+// Tab 자동완성 — readline completer (의존성 0).
+// 지원: /슬래시명령(내장+스킬) · /provider 인자 · @파일명 멘션(작업 폴더 최상위)
+import fs from "node:fs";
+
+export const BUILTIN_COMMANDS = [
+  "/help", "/guide", "/tutorial", "/about",
+  "/setup", "/provider", "/model", "/models", "/update",
+  "/teach", "/stream", "/color", "/auto",
+  "/context", "/status", "/cost", "/config", "/sessions",
+  "/workspace", "/cd", "/init", "/memory",
+  "/skills", "/plugins", "/mcp",
+  "/new", "/clear", "/reset", "/compact", "/resume", "/undo",
+  "/quit", "/exit",
+];
+
+// ctx: { skills(): {name:...}, workspace(): string|null, providers: string[] }
+export function makeCompleter(ctx) {
+  return (line) => {
+    // 1) /provider <인자> 자동완성
+    if (line.startsWith("/provider ")) {
+      const frag = line.slice("/provider ".length);
+      const hits = (ctx.providers || [])
+        .filter((p) => p.startsWith(frag))
+        .map((p) => "/provider " + p);
+      return [hits, line];
+    }
+    // 2) 슬래시 명령(내장 + 스킬) — 첫 단어 입력 중일 때
+    if (line.startsWith("/") && !line.includes(" ")) {
+      let skills = {};
+      try {
+        skills = ctx.skills() || {};
+      } catch { /* 초기화 전 */ }
+      const names = [...new Set([...BUILTIN_COMMANDS, ...Object.keys(skills).map((s) => "/" + s)])].sort();
+      const hits = names.filter((n) => n.startsWith(line));
+      return [hits.length ? hits : names, line];
+    }
+    // 3) @파일명 멘션 — 작업 폴더 최상위 파일
+    const m = /@([\w가-힣./\\-]*)$/.exec(line);
+    if (m) {
+      let ws = null;
+      try {
+        ws = ctx.workspace();
+      } catch { /* 초기화 전 */ }
+      if (ws) {
+        let files = [];
+        try {
+          files = fs.readdirSync(ws).filter((f) => !f.startsWith("."));
+        } catch { /* ignore */ }
+        const head = line.slice(0, m.index);
+        const hits = files.filter((f) => f.startsWith(m[1])).map((f) => head + "@" + f);
+        return [hits, line];
+      }
+    }
+    return [[], line];
+  };
+}

package/src/config.js

@@ -4,7 +4,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
-export const PROVIDERS = ["openai", "anthropic", "openrouter", "mock"];
+export const PROVIDERS = ["openai", "anthropic", "openrouter", "ollama", "mock"];
 
 export const SUGGESTED_MODELS = {
   openai: ["gpt-4o-mini", "gpt-4.1-mini", "gpt-4.1"],
@@ -15,6 +15,8 @@ export const SUGGESTED_MODELS = {
     "anthropic/claude-3.7-sonnet",
     "google/gemini-2.0-flash-001",
   ],
+  // 로컬/폐쇄망(Ollama). 도구 호출(tools) 지원 모델 권장. exaone 은 한국어 특화(LG).
+  ollama: ["qwen2.5:7b", "llama3.1:8b", "exaone3.5:7.8b"],
   mock: ["mock-agent"],
 };
 
@@ -83,6 +85,7 @@ export class Config {
 
   isReady() {
     if (this.provider === "mock") return true;
+    if (this.provider === "ollama") return true; // 로컬 LLM — API 키 불필요
     return Boolean(this.resolvedKey());
   }
 

package/src/llm.js

@@ -11,6 +11,8 @@ const ENDPOINTS = {
   openai: "https://api.openai.com/v1/chat/completions",
   openrouter: "https://openrouter.ai/api/v1/chat/completions",
   anthropic: "https://api.anthropic.com/v1/messages",
+  // Ollama(로컬/폐쇄망)는 OpenAI 호환 API 를 제공한다. OLLAMA_HOST 로 호스트 변경 가능.
+  ollama: `${(process.env.OLLAMA_HOST || "http://localhost:11434").replace(/\/$/, "")}/v1/chat/completions`,
 };
 
 export class LLMClient {
@@ -55,7 +57,7 @@ export class LLMClient {
       res = await fetch(url, { method: "POST", headers, body: json, signal: ctrl.signal });
     } catch (e) {
       clearTimeout(timer);
-      throw new LLMError(`네트워크 오류: ${e.message}`);
+      throw new LLMError(this._netErrorMessage(e));
     }
     if (!res.ok) {
       clearTimeout(timer);
@@ -65,6 +67,14 @@ export class LLMClient {
     return { res, started, timer, bodyBytes: Buffer.byteLength(json, "utf8") };
   }
 
+  _netErrorMessage(e) {
+    let msg = `네트워크 오류: ${e.message}`;
+    if (this.provider === "ollama") {
+      msg += "\n  ↳ Ollama 가 실행 중인지 확인하세요: `ollama serve` (모델 설치: `ollama pull qwen2.5:7b`)";
+    }
+    return msg;
+  }
+
   async _post(url, headers, body) {
     const json = JSON.stringify(body);
     const ctrl = new AbortController();
@@ -74,7 +84,7 @@ export class LLMClient {
     try {
       res = await fetch(url, { method: "POST", headers, body: json, signal: ctrl.signal });
     } catch (e) {
-      throw new LLMError(`네트워크 오류: ${e.message}`);
+      throw new LLMError(this._netErrorMessage(e));
     } finally {
       clearTimeout(timer);
     }

package/src/loop.js

@@ -62,6 +62,24 @@ function summarizeMessages(messages) {
   return { rows, totalChars, estTokens: estimateTokens(messages.map((m) => (m.content || "") + JSON.stringify(m.tool_calls || "")).join("")) };
 }
 
+// 서브에이전트 위임 도구 — 최상위(depth 0)에서만 노출해 중첩 위임을 막는다.
+const SPAWN_AGENT_SCHEMA = {
+  type: "function",
+  function: {
+    name: "spawn_agent",
+    description:
+      "독립적인 하위 작업을 서브에이전트에게 위임한다. 서브에이전트는 같은 도구(읽기/검색/수정)로 작업하고 결과 텍스트를 돌려준다. 크고 스스로 완결되는 작업 덩어리에만 사용하고, 간단한 일은 직접 도구를 호출하라.",
+    parameters: {
+      type: "object",
+      properties: {
+        task: { type: "string", description: "위임할 작업 지시(구체적으로)" },
+        context: { type: "string", description: "작업에 필요한 배경 정보(선택)" },
+      },
+      required: ["task"],
+    },
+  },
+};
+
 const RULES_FILENAMES = ["AGENT.md", "AGENTS.md", "CLAUDE.md", "rules.md", "RULES.md"];
 
 function findRules(workspace) {
@@ -79,7 +97,7 @@ function findRules(workspace) {
 }
 
 export class AgentLoop {
-  constructor({ config, client, toolbox, onEvent, approvalCallback, session = null, onToken = null }) {
+  constructor({ config, client, toolbox, onEvent, approvalCallback, session = null, onToken = null, depth = 0 }) {
     this.config = config;
     this.client = client;
     this.toolbox = toolbox;
@@ -87,7 +105,9 @@ export class AgentLoop {
     this.approvalCallback = approvalCallback;
     this.session = session;
     this.onToken = onToken; // 스트리밍 토큰 콜백(있으면 실시간 출력)
+    this.depth = depth; // 0=최상위, 1=서브에이전트(중첩 위임 불가)
     this.messages = [];
+    this.usage = { input: 0, output: 0, total: 0, calls: 0 }; // 세션 누적 토큰(/status, /cost)
   }
 
   _emit(step, title = "", detail = "", data = {}) {
@@ -99,28 +119,45 @@ export class AgentLoop {
   _systemPrompt() {
     const ws = this.toolbox.workspace;
     const { name: rulesName, text: rulesText } = findRules(ws);
-    let listing;
+    // 폴더 '전체 목록'을 박아넣지 않는다(낡은 정보·토큰 낭비 방지) — 최상위 이름만 참고로 주고
+    // 최신 상태는 도구(list_dir/search_files)로 확인하게 한다. (OpenCode/Claude Code 방식)
+    let topLevel = "";
     try {
-      listing = this.toolbox.listDir(".").output;
+      const names = fs.readdirSync(ws).filter((n) => !n.startsWith(".")).sort();
+      topLevel = names.slice(0, 15).join(", ") + (names.length > 15 ? ` … (총 ${names.length}개)` : "");
     } catch {
-      listing = "(폴더를 읽을 수 없음)";
+      topLevel = "(읽을 수 없음)";
     }
-    const toolNames = ["list_dir", "read_file", "write_file"].concat(
-      this.config.allow_shell ? ["run_shell"] : []
-    );
-    const toolsDesc = toolNames.map((n) => `${n}(${TOOL_LABELS[n]})`).join(", ");
+    const pluginNames = (this.toolbox.plugins || []).map((p) => p.name).join(", ");
+    const now = new Date();
+    const day = ["일", "월", "화", "수", "목", "금", "토"][now.getDay()];
 
     const parts = [
-      "당신은 'CDSA Harness' 안에서 동작하는 소형 코딩 에이전트입니다.",
-      "당신은 직접 파일을 만질 수 없습니다. 반드시 제공된 도구로만 작업 폴더를 다룹니다.",
-      `사용 가능한 도구: ${toolsDesc}.`,
-      "파일을 수정할 때는 write_file 에 '파일 전체 내용'을 담아 호출하세요(부분 패치 아님).",
-      "추측하지 말고, 필요하면 먼저 read_file/list_dir 로 사실을 확인하세요.",
-      "작업이 끝나면 도구를 더 호출하지 말고 한국어로 결과를 요약하세요.",
-      `\n[작업 폴더 루트]\n${ws}`,
-      `\n[현재 폴더 내용]\n${listing}`,
-    ];
-    if (rulesText) parts.push(`\n[규칙 파일 ${rulesName}]\n${rulesText.trim()}`);
+      "# 정체성",
+      "당신은 CDSA Harness(made by CDSA) 안에서 동작하는 코딩·업무 에이전트입니다.",
+      "파일시스템에 직접 접근할 수 없으며, 제공된 도구 호출로만 작업 폴더를 다룹니다.",
+      "",
+      "# 환경",
+      `- 작업 폴더(루트): ${ws}`,
+      `- 최상위 항목(참고용 스냅샷): ${topLevel || "(빈 폴더)"}`,
+      `- 플랫폼: ${process.platform} · Node ${process.versions.node} · 오늘: ${now.toISOString().slice(0, 10)}(${day})`,
+      "- 모든 도구는 작업 폴더 밖으로 나갈 수 없습니다(sandbox). 파일 수정·셸 실행은 사용자 승인 후에만 적용됩니다.",
+      "",
+      "# 도구 사용 원칙",
+      "- 추측 금지: 파일 위치·내용이 불확실하면 먼저 search_files / list_dir / read_file 로 사실을 확인한다.",
+      "- 기존 파일의 일부 수정은 edit_file(old_text 는 파일에서 유일해야 함), 새 파일·전체 교체만 write_file 을 쓴다.",
+      "- 도구가 오류를 돌려주면 같은 호출을 반복하지 말고, 오류 메시지를 읽고 접근을 바꾼다.",
+      "- 사용자가 승인을 거부하면 그 의사를 존중하고 대안을 제시한다.",
+      this.depth === 0
+        ? "- 크고 독립적으로 나눌 수 있는 작업은 spawn_agent 로 서브에이전트에 위임할 수 있다(간단한 일엔 쓰지 말 것)."
+        : "- 당신은 상위 에이전트가 위임한 하위 작업을 수행하는 서브에이전트다. 주어진 작업만 완수하고, 결과를 명확한 텍스트로 보고하라.",
+      pluginNames ? `- 추가 도구: ${pluginNames}` : null,
+      "",
+      "# 응답 스타일",
+      "- 한국어로, 간결하게. 불필요한 서론·사과 없이 핵심부터.",
+      "- 작업이 끝나면 도구를 더 호출하지 말고 무엇을 했는지 요약한다.",
+    ].filter((p) => p !== null);
+    if (rulesText) parts.push("", `# 프로젝트 규칙 (${rulesName})`, rulesText.trim());
     return parts.join("\n");
   }
 
@@ -129,6 +166,16 @@ export class AgentLoop {
     this.messages = [{ role: "system", content: this.systemPromptText }];
   }
 
+  // 매 턴 시작 시 시스템 프롬프트를 신선하게 재구성한다(대화는 유지, 환경·스냅샷만 갱신).
+  refreshSystemPrompt() {
+    this.systemPromptText = this._systemPrompt();
+    if (this.messages.length && this.messages[0].role === "system") {
+      this.messages[0] = { role: "system", content: this.systemPromptText };
+    } else {
+      this.messages.unshift({ role: "system", content: this.systemPromptText });
+    }
+  }
+
   // /context 명령용: 현재 대화 컨텍스트 요약.
   contextSummary() {
     return { ...summarizeMessages(this.messages), systemPrompt: this.systemPromptText };
@@ -136,6 +183,7 @@ export class AgentLoop {
 
   async run(userInput) {
     if (this.messages.length === 0) this.reset();
+    else this.refreshSystemPrompt(); // 환경·규칙·스냅샷을 매 턴 최신으로 (대화 이력은 유지)
 
     this._emit(Step.USER_INPUT, "사용자 입력", userInput);
     this.messages.push({ role: "user", content: userInput });
@@ -143,10 +191,11 @@ export class AgentLoop {
     this._emit(
       Step.BUILD_CONTEXT,
       "컨텍스트 구성",
-      "규칙 파일 + 작업 폴더 내용을 시스템 프롬프트로 묶어 모델에 전달합니다."
+      "정체성·환경·도구원칙·프로젝트규칙(AGENT.md)을 시스템 프롬프트로 묶어 매 턴 신선하게 전달합니다."
     );
 
     const tools = toolSchemas(this.config.allow_shell, this.toolbox.plugins);
+    if (this.depth === 0) tools.push(SPAWN_AGENT_SCHEMA); // 서브에이전트는 재위임 불가
     const toolNames = tools.map((t) => t.function.name);
     let finalText = "";
 
@@ -183,6 +232,13 @@ export class AgentLoop {
 
       // ③ 모델의 원본 판단 + 실측 메타(응답시간/토큰/요청크기)를 드러낸다.
       // streamed=true 면 텍스트는 이미 실시간 출력됨 → UI 는 메타만 덧붙인다.
+      this.usage.calls += 1; // 모든 LLM 호출 횟수(usage 미제공 provider 포함)
+      if (reply.usage) {
+        this.usage.input += reply.usage.input || 0;
+        this.usage.output += reply.usage.output || 0;
+        this.usage.total += reply.usage.total || 0;
+      }
+
       this._emit(Step.MODEL_REPLY, "모델 응답", reply.content || "(텍스트 없음)", {
         toolCalls: reply.toolCalls.map((tc) => ({ name: tc.name, args: tc.args })),
         usage: reply.usage || null,
@@ -230,7 +286,46 @@ export class AgentLoop {
     return finalText;
   }
 
+  // 서브에이전트: 하위 AgentLoop 를 만들어 위임 작업을 수행시키고 결과 텍스트를 회수한다.
+  async _runSubAgent(tc) {
+    const task = (tc.args.task || "").trim();
+    if (!task) return "spawn_agent 오류: task 가 비어 있습니다.";
+    if (this.depth > 0) return "spawn_agent 오류: 서브에이전트는 다시 위임할 수 없습니다.";
+    this._emit(Step.TOOL_RUN, "도구 실행: 서브에이전트 위임", task.slice(0, 300));
+
+    const child = new AgentLoop({
+      config: this.config,
+      client: this.client,
+      toolbox: this.toolbox, // 같은 sandbox·같은 승인 정책 공유
+      session: this.session,
+      approvalCallback: this.approvalCallback,
+      onToken: null, // 하위 스트리밍은 화면 소음 — 패널로만 표시
+      onEvent: (ev) =>
+        this.onEvent({ ...ev, title: `┆ ${ev.title}`, data: { ...(ev.data || {}), sub: 1 } }),
+      depth: this.depth + 1,
+    });
+    child.reset();
+    const prompt = (tc.args.context ? `[배경]\n${tc.args.context}\n\n` : "") + `[위임된 작업]\n${task}`;
+
+    let result = "";
+    try {
+      result = await child.run(prompt);
+    } catch (e) {
+      result = `서브에이전트 실행 오류: ${e?.message || e}`;
+    }
+    // 하위 토큰 사용량을 상위(/status)에 합산
+    this.usage.input += child.usage.input;
+    this.usage.output += child.usage.output;
+    this.usage.total += child.usage.total;
+    this.usage.calls += child.usage.calls;
+
+    const out = (result || "").trim() || "(서브에이전트가 결과 텍스트를 반환하지 않았습니다)";
+    this._emit(Step.TOOL_RESULT, "결과 반영: 서브에이전트", out.slice(0, 4000));
+    return out;
+  }
+
   async _handleToolCall(tc) {
+    if (tc.name === "spawn_agent") return this._runSubAgent(tc);
     const label = this.toolbox.label ? this.toolbox.label(tc.name) : TOOL_LABELS[tc.name] || tc.name;
     const needsApproval = this.toolbox.isMutating(tc.name);
 
@@ -271,6 +366,10 @@ export class AgentLoop {
       const { path: p, diff } = this.toolbox.previewWrite(tc.args.path || "", tc.args.content || "");
       return { toolName: "write_file", toolLabel: TOOL_LABELS.write_file, args: tc.args, path: p, diff };
     }
+    if (tc.name === "edit_file") {
+      const { path: p, diff } = this.toolbox.previewEdit(tc.args.path || "", tc.args.old_text || "", tc.args.new_text ?? "");
+      return { toolName: "edit_file", toolLabel: TOOL_LABELS.edit_file, args: tc.args, path: p, diff };
+    }
     if (tc.name === "run_shell") {
       return {
         toolName: "run_shell",

package/src/tools.js

@@ -7,12 +7,15 @@ import path from "node:path";
 export const TOOL_LABELS = {
   list_dir: "폴더 보기",
   read_file: "파일 읽기",
-  write_file: "파일 수정",
+  write_file: "파일 쓰기",
+  edit_file: "부분 수정",
+  search_files: "파일 검색",
   run_shell: "셸 실행",
+  spawn_agent: "서브에이전트",
 };
 
 // 사용자 승인이 필요한(환경을 바꾸는) 도구
-export const MUTATING_TOOLS = new Set(["write_file", "run_shell"]);
+export const MUTATING_TOOLS = new Set(["write_file", "edit_file", "run_shell"]);
 
 export class ToolError extends Error {}
 
@@ -132,10 +135,32 @@ export class Toolbox {
     return { path: this.rel(target), diff };
   }
 
+  // /undo 용: 마지막 파일 변경 1건을 기억해 되돌릴 수 있게 한다(단순 프리미티브).
+  _backup(target) {
+    this.lastChange = {
+      target,
+      rel: this.rel(target),
+      old: fs.existsSync(target) ? fs.readFileSync(target, "utf8") : null, // null = 새 파일이었음
+    };
+  }
+
+  undoLast() {
+    if (!this.lastChange) throw new ToolError("되돌릴 파일 변경이 없습니다.");
+    const { target, rel, old } = this.lastChange;
+    this.lastChange = null;
+    if (old === null) {
+      fs.rmSync(target, { force: true });
+      return { ok: true, output: `${rel} 생성을 취소했습니다(파일 삭제).` };
+    }
+    fs.writeFileSync(target, old, "utf8");
+    return { ok: true, output: `${rel} 을 마지막 변경 이전 상태로 되돌렸습니다.` };
+  }
+
   writeFile(rel, content) {
     const target = this._resolve(rel);
     fs.mkdirSync(path.dirname(target), { recursive: true });
     const existed = fs.existsSync(target);
+    this._backup(target);
     fs.writeFileSync(target, content || "", "utf8");
     const verb = existed ? "수정" : "생성";
     return {
@@ -145,6 +170,91 @@ export class Toolbox {
     };
   }
 
+  // 부분 수정: old_text 를 딱 한 번 찾아 new_text 로 바꾼다(전체 덮어쓰기 불필요).
+  _computeEdit(rel, oldText, newText) {
+    const target = this._resolve(rel);
+    if (!fs.existsSync(target) || !fs.statSync(target).isFile()) {
+      throw new ToolError(`파일이 없습니다: ${rel}`);
+    }
+    if (!oldText) throw new ToolError("old_text 가 비어 있습니다.");
+    const cur = fs.readFileSync(target, "utf8");
+    const count = cur.split(oldText).length - 1;
+    if (count === 0) throw new ToolError("old_text 를 파일에서 찾지 못했습니다. 파일을 다시 read_file 로 확인하세요.");
+    if (count > 1) throw new ToolError(`old_text 가 ${count}번 일치합니다 — 주변 문맥을 포함해 더 길게 지정하세요.`);
+    return { target, cur, next: cur.replace(oldText, newText ?? "") };
+  }
+
+  previewEdit(rel, oldText, newText) {
+    try {
+      const { target, cur, next } = this._computeEdit(rel, oldText, newText);
+      return { path: this.rel(target), diff: diffLines(cur, next).filter((l) => !l.startsWith(" ")).join("\n") || "(변화 없음)" };
+    } catch (e) {
+      return { path: rel, diff: `(미리보기 불가: ${e.message})` };
+    }
+  }
+
+  editFile(rel, oldText, newText) {
+    const { target, next } = this._computeEdit(rel, oldText, newText);
+    this._backup(target);
+    fs.writeFileSync(target, next, "utf8");
+    return { ok: true, output: `${this.rel(target)} 부분 수정 완료 (old ${oldText.length}자 → new ${(newText ?? "").length}자).` };
+  }
+
+  // 파일명 + 내용 검색(재귀). node_modules/.git 등 노이즈 제외, 대소문자 무시.
+  searchFiles(query, sub = ".") {
+    if (!query || !query.trim()) throw new ToolError("검색어가 비어 있습니다.");
+    const q = query.toLowerCase();
+    const rootDir = this._resolve(sub);
+    const SKIP = new Set(["node_modules", ".git", "dist", "build", "__pycache__", ".venv"]);
+    const nameHits = [];
+    const contentHits = [];
+    let scanned = 0;
+    const walk = (dir) => {
+      let entries = [];
+      try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const e of entries) {
+        if (scanned > 2000 || contentHits.length >= 40) return;
+        const full = path.join(dir, e.name);
+        if (e.isDirectory()) {
+          if (!SKIP.has(e.name) && !e.name.startsWith(".")) walk(full);
+          continue;
+        }
+        scanned++;
+        const rel = this.rel(full);
+        if (e.name.toLowerCase().includes(q)) nameHits.push(rel);
+        let st;
+        try {
+          st = fs.statSync(full);
+        } catch {
+          continue;
+        }
+        if (st.size > 512 * 1024) continue; // 큰 파일 스킵
+        let text;
+        try {
+          text = fs.readFileSync(full, "utf8");
+        } catch {
+          continue;
+        }
+        if (text.includes("")) continue; // 바이너리 스킵
+        const lines = text.split("\n");
+        for (let i = 0; i < lines.length && contentHits.length < 40; i++) {
+          if (lines[i].toLowerCase().includes(q)) {
+            contentHits.push(`${rel}:${i + 1}  ${lines[i].trim().slice(0, 120)}`);
+          }
+        }
+      }
+    };
+    walk(rootDir);
+    const parts = [];
+    if (nameHits.length) parts.push(`[파일명 일치 ${nameHits.length}건]\n` + nameHits.slice(0, 20).join("\n"));
+    if (contentHits.length) parts.push(`[내용 일치]\n` + contentHits.join("\n"));
+    return { ok: true, output: parts.join("\n\n") || `'${query}' 검색 결과가 없습니다.` };
+  }
+
   runShell(command) {
     if (!this.allowShell) {
       throw new ToolError("셸 실행이 설정에서 비활성화되어 있습니다(allow_shell=false).");
@@ -172,6 +282,8 @@ export class Toolbox {
     if (name === "list_dir") return this.listDir(args.path || ".");
     if (name === "read_file") return this.readFile(args.path || "");
     if (name === "write_file") return this.writeFile(args.path || "", args.content || "");
+    if (name === "edit_file") return this.editFile(args.path || "", args.old_text || "", args.new_text ?? "");
+    if (name === "search_files") return this.searchFiles(args.query || "", args.path || ".");
     if (name === "run_shell") return this.runShell(args.command || "");
     const plugin = this._pluginMap.get(name);
     if (plugin) {
@@ -221,7 +333,7 @@ export function toolSchemas(allowShell = false, plugins = []) {
       function: {
         name: "write_file",
         description:
-          "작업 폴더 안의 파일을 새 내용으로 만들거나 덮어쓴다. 전체 파일 내용을 content 로 전달. 사용자 승인 후 적용된다.",
+          "새 파일을 만들거나 파일 전체를 덮어쓴다. 기존 파일의 일부만 고칠 땐 write_file 대신 edit_file 을 써라. 사용자 승인 후 적용된다.",
         parameters: {
           type: "object",
           properties: {
@@ -232,6 +344,38 @@ export function toolSchemas(allowShell = false, plugins = []) {
         },
       },
     },
+    {
+      type: "function",
+      function: {
+        name: "edit_file",
+        description:
+          "기존 파일의 일부만 수정한다(권장). old_text 는 파일 안에서 정확히 한 번만 일치해야 하며 new_text 로 치환된다. 사용자 승인 후 적용된다.",
+        parameters: {
+          type: "object",
+          properties: {
+            path: { type: "string", description: "수정할 파일의 상대 경로" },
+            old_text: { type: "string", description: "바꿀 기존 텍스트(문맥 포함, 파일에서 유일해야 함)" },
+            new_text: { type: "string", description: "새 텍스트" },
+          },
+          required: ["path", "old_text", "new_text"],
+        },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: "search_files",
+        description: "작업 폴더에서 파일명·파일내용을 재귀 검색한다(대소문자 무시). 어떤 파일에 뭐가 있는지 찾을 때 사용.",
+        parameters: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "검색어" },
+            path: { type: "string", description: "검색 시작 폴더(기본 '.')" },
+          },
+          required: ["query"],
+        },
+      },
+    },
   ];
   if (allowShell) {
     schemas.push({

package/src/ui.js

@@ -110,6 +110,57 @@ export function panel(lines, { title = "", color = "cyan" } = {}) {
   return [head, ...mid, bottom].join("\n");
 }
 
+// 모델 응답의 마크다운을 터미널 ANSI 로 렌더한다(OpenCode 류 체감 개선).
+// 지원: #제목 / **굵게** / *기울임* / `코드` / ```펜스``` / -·* 목록 / > 인용 / 표(|) / 구분선
+export function renderMarkdown(text) {
+  const out = [];
+  let inFence = false;
+  for (const raw of String(text ?? "").split("\n")) {
+    // 코드 펜스
+    const fence = /^\s*```(\w*)/.exec(raw);
+    if (fence) {
+      inFence = !inFence;
+      out.push(c.grey("  ┄┄┄" + (inFence && fence[1] ? " " + fence[1] + " " : "") + "┄┄┄"));
+      continue;
+    }
+    if (inFence) {
+      out.push("  " + c.yellow(raw));
+      continue;
+    }
+    let line = raw;
+    // 구분선
+    if (/^\s*(-{3,}|\*{3,}|_{3,})\s*$/.test(line)) {
+      out.push(c.grey("─".repeat(30)));
+      continue;
+    }
+    // 제목
+    const h = /^(#{1,4})\s+(.*)$/.exec(line);
+    if (h) {
+      out.push(c.bold(c.cyan(h[2])));
+      continue;
+    }
+    // 인용
+    line = line.replace(/^(\s*)>\s?/, (_, sp) => sp + c.grey("│ "));
+    // 목록 글머리
+    line = line.replace(/^(\s*)[-*]\s+/, (_, sp) => sp + c.cyan("• "));
+    // 표: | 를 은은한 세로선으로
+    if (/^\s*\|.*\|\s*$/.test(raw)) {
+      if (/^\s*\|[\s:|-]+\|\s*$/.test(raw)) {
+        out.push(c.grey(raw.replace(/[|:-]/g, (m) => (m === "|" ? "┼" : "─")).trim()));
+        continue;
+      }
+      line = line.replace(/\|/g, c.grey("│"));
+    }
+    // 인라인: `코드` → 노랑, **굵게**, *기울임*
+    line = line
+      .replace(/`([^`]+)`/g, (_, s) => c.yellow(s))
+      .replace(/\*\*([^*]+)\*\*/g, (_, s) => c.bold(s))
+      .replace(/(^|\s)\*([^*\s][^*]*)\*(?=\s|$|[.,!?)])/g, (_, pre, s) => pre + c.italic(s));
+    out.push(line);
+  }
+  return out;
+}
+
 // diff 문자열을 색으로 렌더 (+초록 / -빨강 / 그외 흐림)
 export function renderDiff(diff) {
   return diff.split("\n").map((line) => {