agentforge-multi 0.1.5 → 0.1.6

package/agentforge

@@ -27,6 +27,7 @@ from collections import deque
 from pathlib import Path
 
 import requests as _requests
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
 from rich.console import Console
 from rich.layout import Layout
@@ -56,6 +57,7 @@ NOISE_RE = re.compile(r'^\s*([\-─═\s]+)?$')
 console = Console()
 _last_session: dict | None = None        # {goal, history, eval_history, workdir}
 _interrupt_event = threading.Event()     # ESC 감지 플래그
+_current_response = None                 # 현재 스트리밍 HTTP 응답 (즉시 끊기용)
 
 # ── ChatGPT backend API ────────────────────────────────────────────────────────
 
@@ -134,30 +136,57 @@ WORKER_TOOLS = [
 ]
 
 
+RESEARCH_TOOLS = WORKER_TOOLS + [
+    {
+        "type": "function", "name": "web_search",
+        "description": "Search the web using DuckDuckGo (or Brave if BRAVE_API_KEY set). Returns summaries and links.",
+        "parameters": {"type": "object",
+                       "properties": {"query": {"type": "string"}},
+                       "required": ["query"]},
+        "strict": False,
+    },
+    {
+        "type": "function", "name": "fetch_url",
+        "description": "Fetch and extract text content from a URL.",
+        "parameters": {"type": "object",
+                       "properties": {"url": {"type": "string"}},
+                       "required": ["url"]},
+        "strict": False,
+    },
+]
+
+
 def _iter_events(payload: dict):
     """
     ChatGPT backend-api/codex/responses 스트리밍 호출.
-    SSE 이벤트를 실시간으로 yield.  _interrupt_event가 set되면 조기 종료.
+    SSE 이벤트를 실시간으로 yield.  _interrupt_event가 set되면 즉시 연결 끊기.
     """
+    global _current_response
     headers = _get_auth_headers()
     try:
         r = _requests.post(
             CHATGPT_RESPONSES_URL, headers=headers,
             json=payload, stream=True, timeout=300,
         )
+        _current_response = r
         r.raise_for_status()
-        for line in r.iter_lines():
-            if _interrupt_event.is_set():
-                break
-            if not line:
-                continue
-            decoded = line.decode("utf-8", errors="replace")
-            if decoded.startswith("data: "):
-                try:
-                    yield json.loads(decoded[6:])
-                except Exception:
-                    pass
+        try:
+            for line in r.iter_lines():
+                if _interrupt_event.is_set():
+                    r.close()
+                    break
+                if not line:
+                    continue
+                decoded = line.decode("utf-8", errors="replace")
+                if decoded.startswith("data: "):
+                    try:
+                        yield json.loads(decoded[6:])
+                    except Exception:
+                        pass
+        finally:
+            _current_response = None
     except Exception as e:
+        _current_response = None
         yield {"type": "_error", "message": str(e)}
 
 
@@ -195,6 +224,48 @@ def _execute_tool(name: str, args: dict, workdir: str) -> str:
             return "\n".join(
                 ("dir  " if p.is_dir() else "file ") + p.name for p in items
             )
+        elif name == "web_search":
+            query = args["query"]
+            brave_key = os.environ.get("BRAVE_API_KEY")
+            if brave_key:
+                r = _requests.get(
+                    "https://api.search.brave.com/res/v1/web/search",
+                    params={"q": query, "count": 10},
+                    headers={"Accept": "application/json",
+                             "Accept-Encoding": "gzip",
+                             "X-Subscription-Token": brave_key},
+                    timeout=15,
+                )
+                items = r.json().get("web", {}).get("results", [])
+                return "\n".join(
+                    f"[{i+1}] {it['title']}\n    {it['url']}\n    {it.get('description','')}"
+                    for i, it in enumerate(items[:8])
+                ) or "(결과 없음)"
+            else:
+                r = _requests.get(
+                    "https://html.duckduckgo.com/html/",
+                    params={"q": query},
+                    headers={"User-Agent": "Mozilla/5.0"},
+                    timeout=15,
+                )
+                snippets = re.findall(r'class="result__snippet">(.*?)</a>', r.text, re.S)
+                titles   = re.findall(r'class="result__a"[^>]*>(.*?)</a>', r.text, re.S)
+                urls     = re.findall(r'uddg=(https?[^&"]+)', r.text)
+                from urllib.parse import unquote
+                lines = []
+                for i, (t, u, s) in enumerate(zip(titles, urls, snippets)):
+                    t = re.sub(r'<[^>]+>', '', t).strip()
+                    s = re.sub(r'<[^>]+>', '', s).strip()
+                    lines.append(f"[{i+1}] {t}\n    {unquote(u)}\n    {s}")
+                    if i >= 7:
+                        break
+                return "\n".join(lines) or "(결과 없음)"
+        elif name == "fetch_url":
+            url = args["url"]
+            r = _requests.get(url, timeout=15, headers={"User-Agent": "Mozilla/5.0"})
+            text = re.sub(r'<[^>]+>', ' ', r.text)
+            text = re.sub(r'\s+', ' ', text).strip()
+            return text[:8000]
         else:
             return f"Unknown tool: {name}"
     except Exception as e:
@@ -203,23 +274,30 @@ def _execute_tool(name: str, args: dict, workdir: str) -> str:
 # ── Slash command autocomplete ────────────────────────────────────────────────
 
 SLASH_COMMANDS = [
-    ("/resume", "마지막 세션을 이어서 실행"),
-    ("/exit",   "agentforge 종료"),
+    ("/resume",          "마지막 세션 재개"),
+    ("/exit",            "종료"),
+    ("/mode code",       "코딩 모드로 전환"),
+    ("/mode research",   "연구 모드로 전환"),
+    ("/eval-every <N>",  "N번마다 Evaluator 실행"),
+    ("/status",          "현재 설정 확인"),
+    ("/help",            "커맨드 목록 표시"),
 ]
 
 class SlashCompleter(Completer):
     def get_completions(self, document, complete_event):
         text = document.text_before_cursor
         if text.startswith('/'):
-            typed = text.lstrip('/')
+            typed = text[1:]  # strip leading /
             for cmd, desc in SLASH_COMMANDS:
-                name = cmd.lstrip('/')
-                if name.startswith(typed):
+                name = cmd[1:].split()[0]  # first word without /
+                full = cmd[1:]             # full command without /
+                if full.startswith(typed) or name.startswith(typed.split()[0] if typed else ''):
+                    import html as _html
                     yield Completion(
                         cmd,
                         start_position=-len(text),
-                        display=HTML(f'<ansicyan>{cmd}</ansicyan>'),
-                        display_meta=HTML(f'<ansiwhite>{desc}</ansiwhite>'),
+                        display=HTML(f'<ansicyan>{_html.escape(cmd)}</ansicyan>'),
+                        display_meta=HTML(f'<ansiwhite>{_html.escape(desc)}</ansiwhite>'),
                     )
 
 PROMPT_STYLE = PtStyle.from_dict({
@@ -298,6 +376,30 @@ EVALUATOR_SYSTEM = textwrap.dedent("""\
     Do NOT write anything before the decision keyword.
 """).strip()
 
+RESEARCH_WORKER_SYSTEM = textwrap.dedent("""\
+    You are an expert researcher. Your goal is to investigate a topic thoroughly.
+    - Use web_search to find relevant papers, articles, and data
+    - Use fetch_url to read full content of important pages
+    - Use read_file/write_file to organize findings into structured notes
+    - Synthesize information across multiple sources
+    - Stay on topic; do not drift from the research goal
+""").strip()
+
+RESEARCH_EVALUATOR_SYSTEM = textwrap.dedent("""\
+    You are a rigorous academic reviewer. Evaluate whether the research goal is achieved.
+    Respond with EXACTLY ONE first line: DONE, IMPROVE: <feedback>, or REDIRECT: <feedback>
+
+    DONE only if: sufficient sources found, content analyzed, findings written to file(s).
+    IMPROVE if: more sources needed, analysis incomplete, or notes missing.
+    REDIRECT if: wrong direction entirely.
+
+    When DONE, add Korean summary:
+    판단 이유: ...
+    결과물 위치: ...
+    결과 요약: ...
+""").strip()
+
+
 def build_worker_prompt(goal: str, history: list) -> str:
     lines = [f"GOAL: {goal}", ""]
     if not history:
@@ -422,6 +524,11 @@ def _esc_listener(stop: threading.Event):
                 ch = os.read(tty_fd, 1)
                 if ch == b'\x1b':
                     _interrupt_event.set()
+                    if _current_response:
+                        try:
+                            _current_response.close()
+                        except Exception:
+                            pass
                     break
     except Exception:
         pass
@@ -436,9 +543,13 @@ def _esc_listener(stop: threading.Event):
 # ── Agent Runners ─────────────────────────────────────────────────────────────
 
 def run_worker(prompt: str, workdir: str, model: str | None,
-               buf: deque, status_ref: list) -> tuple[str, int]:
-    """Worker: ChatGPT backend Responses API 직접 호출 + 도구 실행 루프."""
+               buf: deque, status_ref: list,
+               system_prompt: str | None = None,
+               tools: list | None = None) -> tuple[str, int]:
+    """Worker: ChatGPT backend Responses API 직접 호출 + 병렬 도구 실행 루프."""
     model = model or DEFAULT_WORKER_MODEL
+    system_prompt = system_prompt or WORKER_SYSTEM
+    tools = tools if tools is not None else WORKER_TOOLS
     status_ref[0] = "running"
 
     # 입력 히스토리 (user msg + function_call + function_call_output 누적)
@@ -460,9 +571,9 @@ def run_worker(prompt: str, workdir: str, model: str | None,
 
         payload = {
             "model": model,
-            "instructions": WORKER_SYSTEM,
+            "instructions": system_prompt,
             "input": input_history,
-            "tools": WORKER_TOOLS,
+            "tools": tools,
             "store": False,
             "stream": True,
         }
@@ -504,26 +615,33 @@ def run_worker(prompt: str, workdir: str, model: str | None,
         if not fc_items:
             break
 
-        # 도구 실행 및 히스토리에 추가
+        # 도구 병렬 실행
+        with ThreadPoolExecutor(max_workers=min(len(fc_items), 8)) as pool:
+            futures = {
+                pool.submit(
+                    _execute_tool,
+                    fc["name"],
+                    json.loads(fc["arguments"]) if fc["arguments"] else {},
+                    workdir,
+                ): fc
+                for fc in fc_items
+            }
+            results: dict[str, str] = {}
+            for fut in as_completed(futures):
+                fc = futures[fut]
+                try:
+                    results[fc["call_id"]] = fut.result()
+                except Exception as e:
+                    results[fc["call_id"]] = f"Error: {e}"
+
+        # call_id 순서 보장하며 히스토리 추가
         for fc in fc_items:
-            call_id = fc["call_id"]
-            name    = fc["name"]
-            raw_args = fc["arguments"]
-            try:
-                args = json.loads(raw_args)
-            except Exception:
-                args = {}
-
-            arg_preview = raw_args[:80]
-            buf.append(f"[cyan]▶ {name}({arg_preview})[/cyan]")
-            result = _execute_tool(name, args, workdir)
-            short = result[:300].replace('\n', ' ')
-            buf.append(f"[dim]{short}[/dim]")
-
-            # Responses API 형식 히스토리
-            input_history.append({"type": "function_call", "call_id": call_id,
-                                   "name": name, "arguments": raw_args})
-            input_history.append({"type": "function_call_output", "call_id": call_id,
+            result = results[fc["call_id"]]
+            buf.append(f"[cyan]▶ {fc['name']}({fc['arguments'][:80]})[/cyan]")
+            buf.append(f"[dim]{result[:300].replace(chr(10), ' ')}[/dim]")
+            input_history.append({"type": "function_call", "call_id": fc["call_id"],
+                                   "name": fc["name"], "arguments": fc["arguments"]})
+            input_history.append({"type": "function_call_output", "call_id": fc["call_id"],
                                    "output": result})
 
     # 잔여 line_buf flush
@@ -534,12 +652,14 @@ def run_worker(prompt: str, workdir: str, model: str | None,
     return "\n".join(all_text_parts), 0
 
 
-def run_evaluator(prompt: str, workdir: str, model: str | None) -> tuple[str, int]:
+def run_evaluator(prompt: str, workdir: str, model: str | None,
+                  system_prompt: str | None = None) -> tuple[str, int]:
     """Evaluator: ChatGPT backend Responses API, 도구 없이 텍스트만."""
     model = model or DEFAULT_EVAL_MODEL
+    system_prompt = system_prompt or EVALUATOR_SYSTEM
     payload = {
         "model": model,
-        "instructions": EVALUATOR_SYSTEM,
+        "instructions": system_prompt,
         "input": [{"role": "user", "content": prompt}],
         "store": False,
         "stream": True,
@@ -745,10 +865,12 @@ def run_agent_loop(goal: str, workdir: str, worker_model: str | None,
                    eval_model: str | None, max_iter: int,
                    layout: Layout, live: Live,
                    initial_history: list | None = None,
-                   initial_eval_history: list | None = None) -> str:
+                   initial_eval_history: list | None = None,
+                   mode: str = "code",
+                   eval_every: int = 1) -> str:
     """
     Worker + Evaluator 반복 루프.
-    반환: 'done' | 'max'
+    반환: 'done' | 'max' | 'interrupted'
     """
     global _last_session
     history = list(initial_history or [])
@@ -757,6 +879,11 @@ def run_agent_loop(goal: str, workdir: str, worker_model: str | None,
     worker_status = ["idle"]
     done = False
 
+    # 모드별 시스템 프롬프트 및 도구 선택
+    worker_sys   = RESEARCH_WORKER_SYSTEM if mode == "research" else WORKER_SYSTEM
+    eval_sys     = RESEARCH_EVALUATOR_SYSTEM if mode == "research" else EVALUATOR_SYSTEM
+    active_tools = RESEARCH_TOOLS if mode == "research" else WORKER_TOOLS
+
     # ESC 리스너 시작
     _interrupt_event.clear()
     _esc_stop = threading.Event()
@@ -787,7 +914,8 @@ def run_agent_loop(goal: str, workdir: str, worker_model: str | None,
 
         def _worker():
             worker_result[0], worker_result[1] = run_worker(
-                worker_prompt, workdir, worker_model, worker_buf, worker_status)
+                worker_prompt, workdir, worker_model, worker_buf, worker_status,
+                system_prompt=worker_sys, tools=active_tools)
 
         t = threading.Thread(target=_worker, daemon=True)
         t.start()
@@ -823,9 +951,13 @@ def run_agent_loop(goal: str, workdir: str, worker_model: str | None,
                              "eval_history": eval_history, "workdir": workdir}
             return _finish('interrupted')
 
-        refresh("evaluator", iteration)
-        eval_prompt = build_evaluator_prompt(goal, last_msg or "", iteration)
-        eval_msg, _ = run_evaluator(eval_prompt, workdir, eval_model)
+        if iteration % eval_every == 0 or iteration == max_iter:
+            refresh("evaluator", iteration)
+            eval_prompt = build_evaluator_prompt(goal, last_msg or "", iteration)
+            eval_msg, _ = run_evaluator(eval_prompt, workdir, eval_model,
+                                        system_prompt=eval_sys)
+        else:
+            eval_msg = "IMPROVE: (evaluation skipped)"
 
         decision, feedback = parse_decision(eval_msg)
         history[-1]['decision'] = decision
@@ -954,6 +1086,10 @@ def main():
                         help="Evaluator 모델")
     parser.add_argument("-n", "--max-iterations", type=int, default=DEFAULT_MAX_ITER,
                         metavar="N", help=f"최대 반복 횟수 (기본: {DEFAULT_MAX_ITER})")
+    parser.add_argument("--mode", choices=["code", "research"], default="code",
+                        help="실행 모드: code(기본) / research(웹 검색·분석)")
+    parser.add_argument("--eval-every", type=int, default=1, metavar="N",
+                        help="N번 반복마다 Evaluator 실행 (기본: 1, 즉 매번)")
     args = parser.parse_args()
 
     # ── auth 서브커맨드 ────────────────────────────────────────────────
@@ -1004,7 +1140,10 @@ def main():
                 "agentforge auth login 으로 나중에 로그인할 수 있습니다.[/dim]"
             )
 
-    console.print("[dim]명령을 입력하세요. /resume | /exit[/dim]")
+    current_mode = args.mode
+    eval_every   = args.eval_every
+
+    console.print(f"[dim]명령을 입력하세요. /help 로 커맨드 목록 확인. 모드: {current_mode}[/dim]")
 
     _completer = SlashCompleter()
 
@@ -1054,18 +1193,39 @@ def main():
                     max_iter, layout2, live2,
                     initial_history=s["history"],
                     initial_eval_history=s["eval_history"],
+                    mode=current_mode, eval_every=eval_every,
                 )
-                goal = s["goal"]
                 if outcome == 'interrupted':
-                    goal = _handle_interrupt(goal, workdir, args, max_iter)
+                    console.print("\n[yellow]⚠  중단됨. REPL로 돌아갑니다.[/yellow]")
                 elif outcome == 'max':
                     console.print(f"[red]{max_iter}번 반복 후에도 완료되지 않았습니다.[/red]")
                 if outcome != 'interrupted':
                     console.print("[dim]다음 명령을 입력하세요. /exit 로 종료.[/dim]")
 
+            elif cmd_name == 'mode':
+                if cmd_arg in ('code', 'research'):
+                    current_mode = cmd_arg
+                    console.print(f"[cyan]모드 변경: {current_mode}[/cyan]")
+                else:
+                    console.print("[red]사용법: /mode code  또는  /mode research[/red]")
+
+            elif cmd_name == 'eval-every':
+                try:
+                    eval_every = int(cmd_arg)
+                    console.print(f"[cyan]Evaluator: {eval_every}번마다 실행[/cyan]")
+                except ValueError:
+                    console.print("[red]숫자를 입력하세요. 예: /eval-every 3[/red]")
+
+            elif cmd_name == 'status':
+                console.print(f"모드: [cyan]{current_mode}[/cyan]  |  eval-every: [cyan]{eval_every}[/cyan]  |  dir: [cyan]{workdir}[/cyan]")
+
+            elif cmd_name == 'help':
+                for cmd, desc in SLASH_COMMANDS:
+                    console.print(f"  [cyan]{cmd:<25}[/cyan] {desc}")
+
             else:
                 console.print(f"[red]알 수 없는 커맨드: /{cmd_name}[/red]")
-                console.print("[dim]사용 가능: /resume  /exit[/dim]")
+                console.print("[dim]/help 로 커맨드 목록을 확인하세요.[/dim]")
 
         else:
             # 일반 텍스트 → 바로 Worker에게 목표로 전달
@@ -1078,9 +1238,10 @@ def main():
             outcome = run_agent_loop(
                 goal, workdir, args.worker_model, args.eval_model,
                 max_iter, layout2, live2,
+                mode=current_mode, eval_every=eval_every,
             )
             if outcome == 'interrupted':
-                goal = _handle_interrupt(goal, workdir, args, max_iter)
+                console.print("\n[yellow]⚠  중단됨. REPL로 돌아갑니다.[/yellow]")
             elif outcome == 'max':
                 console.print(f"[red]{max_iter}번 반복 후에도 완료되지 않았습니다.[/red]")
             if outcome != 'interrupted':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentforge-multi",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Multi-agent CLI: Worker + Evaluator agents collaborate in a loop to achieve your goal",
   "keywords": [
     "ai",