#!/usr/bin/env python3
"""eye - eyefeetai LLM을 터미널에서 쓰는 작은 CLI (표준 라이브러리만 사용).

  eye                    대화 모드 (전체 화면: 마우스로 누르는 버튼, 대화 스크롤, 고정 입력창. 쓸 수 없는 터미널이면 자동으로 기존 방식)
  eye "질문"             한 번만 묻고 답을 출력
  cat a.log | eye "요약"  표준입력을 함께 전달
  eye -m nemotron-3.5 "질문"    모델 지정
  eye --no-commands      모델이 명령(git 등)을 실행하는 도구를 끔 (EYE_NO_COMMANDS=1 도 가능)
  eye --cli              전체 화면 대신 기존 줄 단위 대화 방식으로 (EYE_TUI=0 으로 항상 끔, --no-tui 도 같은 뜻)
  eye --raw ...          마크다운을 변환하지 않고 모델이 보낸 원문 그대로 출력 (파이프/파일로 보낼 때는 자동으로 원문)
  (실행한 폴더가 작업 폴더가 되어 그 안의 파일을 읽고, 승인 후 수정할 수 있음.
   --no-files 로 끔, 홈/루트 폴더에서는 --files 를 붙여야 켜짐)
  eye models             채팅에 쓸 수 있는 모델 목록 (--all: 임베딩/별칭까지 전부)
  eye -c / --continue    이 폴더에서 한 마지막 대화를 이어서 시작 (--resume 은 목록에서 선택, --no-save 는 저장 안 함)
  eye login              브라우저로 통합 계정 로그인 (구독형: 계정 사용량 한도 적용)
  eye usage              현재 사용량과 한도
  eye --version          설치된 eye 버전
  eye config             API 키/모델/주소를 직접 입력 (API형: 키별 한도 적용)

설정 우선순위: 환경변수(EYE_API_KEY, EYE_MODEL, EYE_BASE_URL) > 설정 파일 > 기본값
"""
import fnmatch
import getpass
import codecs
import _thread
import builtins
import json
import locale
import os
import queue as _queue
import re
import shlex
import shutil
import signal
import subprocess
import sys
import threading
import time
import unicodedata
import urllib.error
import urllib.request
import uuid
import zipfile

try:
    import readline  # noqa: F401  (입력 편집/히스토리)
    HAVE_READLINE = True
except ImportError:
    HAVE_READLINE = False

for _stream in (sys.stdout, sys.stderr, sys.stdin):  # Windows 콘솔의 기본 인코딩에서도 한글이 깨지지 않게
    try:
        _stream.reconfigure(encoding="utf-8")
    except (AttributeError, OSError):
        pass

VERSION = "1.11.0"
DEFAULT_BASE = "https://www.eyefeetai.com/v1"
DEFAULT_LOGIN_BASE = "https://www.eyefeetai.com/api/cli"
DEFAULT_MODEL = "qwen3.8-27b"
DEFAULT_CONTEXT = 32768  # 서버가 모델별 값을 알려 주지 않을 때 쓰는 슬롯 하나의 컨텍스트 토큰 수 (EYE_CONTEXT 로 직접 정할 수도 있다)
CONFIG = os.path.join(os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config")), "eye", "config")


def load_config():
    cfg = {}
    try:
        with open(CONFIG, encoding="utf-8") as f:
            for line in f:
                line = line.strip()
                if line and not line.startswith("#") and "=" in line:
                    k, v = line.split("=", 1)
                    cfg[k.strip()] = v.strip()
    except FileNotFoundError:
        pass
    env_key = os.environ.get("EYE_API_KEY")
    env_base = os.environ.get("EYE_BASE_URL")
    if env_key:  # API 방식: 환경변수의 키가 항상 우선
        key, mode, base = env_key, "api", env_base or DEFAULT_BASE
    elif cfg.get("EYE_TOKEN"):  # 구독형: eye login 으로 받은 로그인 토큰
        key, mode, base = cfg["EYE_TOKEN"], "login", env_base or cfg.get("EYE_BASE_URL") or DEFAULT_LOGIN_BASE
    else:
        key, mode, base = cfg.get("EYE_API_KEY", ""), "api", env_base or cfg.get("EYE_BASE_URL") or DEFAULT_BASE
    try:
        context = int(os.environ.get("EYE_CONTEXT") or cfg.get("EYE_CONTEXT") or DEFAULT_CONTEXT)
    except ValueError:
        context = DEFAULT_CONTEXT
    try:
        max_steps = int(os.environ.get("EYE_MAX_STEPS") or cfg.get("EYE_MAX_STEPS") or DEFAULT_MAX_STEPS)
    except ValueError:
        max_steps = DEFAULT_MAX_STEPS
    return {
        "key": key,
        "mode": mode,
        "context": max(2048, context),
        "context_fixed": bool(os.environ.get("EYE_CONTEXT") or cfg.get("EYE_CONTEXT")),  # 직접 정했으면 서버가 알려 주는 모델별 값보다 우선
        "max_steps": min(max(0, max_steps), 1000),
        "model": os.environ.get("EYE_MODEL") or cfg.get("EYE_MODEL", DEFAULT_MODEL),
        "base": base.rstrip("/"),
    }


def die(msg):
    print("eye: " + msg, file=sys.stderr)
    sys.exit(1)


class ApiError(Exception):
    def __init__(self, code, detail):
        super().__init__(f"HTTP {code}: {detail}")
        self.code, self.detail = code, detail


def request(cfg, path, body=None, soft=False, headers=None):
    """soft=True 이면 HTTP 오류를 ApiError 로 던진다 (호출한 쪽이 처리). 아니면 메시지를 출력하고 종료."""
    if not cfg["key"]:
        die("API 키가 없습니다. `eye login` 으로 로그인하거나 EYE_API_KEY 를 설정하세요.")
    req = urllib.request.Request(
        cfg["base"] + path,
        data=None if body is None else json.dumps(body).encode(),
        headers={"Authorization": "Bearer " + cfg["key"], "Content-Type": "application/json", "User-Agent": "eye-cli/1",
                 **(headers or {})},
    )
    try:
        return urllib.request.urlopen(req, timeout=600)
    except urllib.error.HTTPError as e:
        detail = e.read().decode(errors="replace")
        try:
            data = json.loads(detail)
            err = data.get("error") or data.get("detail") or detail
            detail = err.get("message", err) if isinstance(err, dict) else err
        except ValueError:
            pass
        if soft:
            raise ApiError(e.code, str(detail)[:500])
        die(f"HTTP {e.code}: {str(detail)[:500]}")
    except urllib.error.URLError as e:
        die(f"접속 실패: {e.reason}")


def show_usage(cfg):
    if cfg["mode"] != "login":
        print("사용량 표시는 `eye login` 으로 로그인한 경우에만 지원합니다. (API 키는 웹의 키 화면에서 확인)")
        return
    with request(cfg, "/usage") as r:
        u = json.load(r)
    left = f" · 가장 오래된 사용분이 약 {max(1, int((u['resets_at'] - time.time()) // 60))}분 뒤 풀립니다" if u.get("resets_at") else ""
    print(f"최근 {u['window_hours']:g}시간 사용량: {u['used']:,} / {u['limit']:,} 토큰{left}")


NOT_FOR_CHAT = re.compile(r"embed|bge", re.I)
LEGACY_ALIASES = {"qwen3-30b-a3b", "gemma"}  # 옛 이름 별칭 (같은 모델이 다른 이름으로 이미 목록에 있음)


def list_models(cfg, show_all=False):
    """채팅에 쓸 수 있는 모델만 (임베딩 모델과 옛 별칭은 제외). show_all 이면 서버 목록 전체."""
    with request(cfg, "/models") as r:
        ids = [m["id"] for m in json.load(r)["data"]]
    if show_all:
        return ids
    return [i for i in ids if not NOT_FOR_CHAT.search(i) and i not in LEGACY_ALIASES]


DEFAULT_MAX_STEPS = 0  # 한 질문에서 모델이 도구를 부를 수 있는 횟수. 0 은 제한 없음 (EYE_MAX_STEPS=숫자 로 제한할 수 있음)
RESULT_LIMIT = 8000  # 도구 결과 길이 상한 (모델 컨텍스트가 슬롯당 약 16k 토큰이라 아껴 쓴다)
SKIP_DIRS = {".git", "node_modules", "__pycache__", ".venv", "venv", ".mypy_cache", ".pytest_cache"}
# 목록에는 보이지만 내용은 보지 않는 폴더. 모델이 "그런 폴더가 없다"고 오해하지 않도록 이유를 함께 보여 준다.
SKIP_NOTES = {
    ".git": "git 저장소 — 있지만 내용은 접근하지 않음",
    "node_modules": "의존성 폴더 — 내용은 생략",
    ".venv": "파이썬 가상환경 — 내용은 생략",
    "venv": "파이썬 가상환경 — 내용은 생략",
    "__pycache__": "캐시 — 내용은 생략",
    ".mypy_cache": "캐시 — 내용은 생략",
    ".pytest_cache": "캐시 — 내용은 생략",
}
SECRET_NAMES = re.compile(r"^(\.env(\..*)?|id_rsa.*|id_ed25519.*|.*\.pem|.*\.key|.*\.p12|\.netrc|\.npmrc)$", re.I)


def _tool(name, description, properties, required):
    return {"type": "function", "function": {
        "name": name, "description": description,
        "parameters": {"type": "object", "properties": properties, "required": required}}}


TOOLS = [
    _tool("list_files", "작업 폴더 안의 파일/폴더 목록을 본다.",
          {"path": {"type": "string", "description": "작업 폴더 기준 상대 경로 (기본 '.')"},
           "recursive": {"type": "boolean", "description": "하위 폴더까지 (최대 3단계)"}}, []),
    _tool("read_file", "텍스트 파일을 줄 번호와 함께 읽는다. 큰 파일은 start_line/max_lines 로 나눠 읽는다.",
          {"path": {"type": "string"},
           "start_line": {"type": "integer", "description": "시작 줄 (1부터, 기본 1)"},
           "max_lines": {"type": "integer", "description": "읽을 줄 수 (기본 200, 최대 400)"}}, ["path"]),
    _tool("read_binary", "바이너리 파일(이미지, pdf, 압축, 실행 파일, docx/xlsx 등)의 형식과 크기를 알려 주고, "
                         "mode 에 따라 16진수 덤프(hex) 또는 안에 들어 있는 읽을 수 있는 문자열(strings)을 보여 준다. 텍스트 파일은 read_file 을 쓴다.",
          {"path": {"type": "string"},
           "mode": {"type": "string", "description": "hex(기본) 또는 strings"},
           "offset": {"type": "integer", "description": "시작 위치(바이트, 기본 0)"},
           "length": {"type": "integer", "description": "hex 에서 볼 길이(바이트, 기본 256, 최대 1024)"}}, ["path"]),
    _tool("run_command", "작업 폴더에서 터미널 명령을 실행하고 종료 코드와 출력을 돌려준다. git status/diff/log 같은 읽기 명령은 바로 실행되고, "
                         "파일을 바꾸거나 그 밖의 명령(git add/commit/push, 설치, 스크립트 실행 등)은 사용자가 승인해야 실행된다. "
                         "입력을 기다리는 대화형 프로그램은 쓸 수 없다. 파일 내용은 read_file, 목록은 list_files 가 더 안전하다.",
          {"command": {"type": "string", "description": "실행할 명령 한 줄 (예: git status)"},
           "timeout": {"type": "integer", "description": "제한 시간(초, 기본 60, 최대 300)"}}, ["command"]),
    _tool("search_text", "파일 내용에서 정규식으로 검색한다 (grep).",
          {"pattern": {"type": "string", "description": "파이썬 정규식"},
           "path": {"type": "string", "description": "검색할 폴더/파일 (기본 '.')"},
           "file_glob": {"type": "string", "description": "예: *.py"}}, ["pattern"]),
    _tool("write_file", "파일을 새로 만들거나 통째로 덮어쓴다. 사용자가 승인해야 실행된다.",
          {"path": {"type": "string"}, "content": {"type": "string"}}, ["path", "content"]),
    _tool("edit_file", "파일 안의 old_text 한 곳을 new_text 로 바꾼다 (old_text 는 파일에서 한 번만 나와야 함). 사용자가 승인해야 실행된다.",
          {"path": {"type": "string"}, "old_text": {"type": "string"}, "new_text": {"type": "string"}},
          ["path", "old_text", "new_text"]),
]


class ToolError(Exception):
    pass


def clip(text):
    if len(text) <= RESULT_LIMIT:
        return text
    return text[:RESULT_LIMIT] + f"\n...(길어서 {RESULT_LIMIT}자까지만 표시했습니다. 범위를 좁혀 다시 요청하세요)"


# ---- 명령 실행 도구 (run_command) ---------------------------------------------------------------------------------
# 읽기 전용이 확실한 명령만 바로 실행하고, 그 밖의 명령은 사용자가 승인해야 실행한다. 승인으로도 막는 명령은 DENY_PATTERNS.
SHELL_META = re.compile(r"[;&|<>`$\\\n\r(){}]")  # 명령을 잇거나, 리다이렉트/치환/서브셸을 만드는 문자
DENY_PATTERNS = [
    (re.compile(r"(^|[;&|]\s*)(sudo|su|doas|runas)(\s|$)", re.I), "권한 상승 명령"),
    (re.compile(r"\brm\s+(-\S+\s+)*-\S*[rR]\S*\s+(-\S+\s+)*(/|~|\*|\.\.?|\$HOME|%USERPROFILE%)(/?\*?)?(\s|$)"), "광범위한 재귀 삭제"),
    (re.compile(r"\b(rd|rmdir)\s+(/\S+\s+)*/[sS]\b|\bdel\s+(/\S+\s+)*/[sS]\b"), "광범위한 재귀 삭제"),
    (re.compile(r"\bmkfs(\.\w+)?\b|\bformat\s+[a-zA-Z]:|\bdiskpart\b"), "디스크 포맷"),
    (re.compile(r"\bdd\b.*\bof=/dev/"), "디스크 직접 쓰기"),
    (re.compile(r"(^|[;&|]\s*)(shutdown|reboot|halt|poweroff)(\s|$)"), "시스템 종료/재부팅"),
    (re.compile(r":\(\)\s*\{"), "포크 폭탄"),
    (re.compile(r"\b(curl|wget|iwr|Invoke-WebRequest)\b[^|]*\|\s*(sudo\s+)?(ba|z|da)?sh\b|\|\s*iex\b", re.I), "내려받은 스크립트를 바로 실행"),
]
VERSION_TOOLS = {"python", "python3", "py", "node", "npm", "npx", "pip", "pip3", "git", "go", "java", "javac", "rustc", "cargo",
                 "docker", "uv", "pnpm", "yarn", "dotnet", "ruby", "php", "gcc", "g++", "make", "cmake"}
# 읽기만 하는 git 하위 명령. 옵션이 파일을 쓰거나, 저장소 밖을 읽거나, 외부 프로그램을 실행하는 경우는 아래 GIT_BLOCKED 로 승인 대상이 된다.
GIT_FREE = {"status", "log", "diff", "show", "ls-files", "rev-parse", "describe", "blame", "shortlog", "ls-tree", "grep",
            "cat-file", "rev-list", "name-rev", "diff-tree", "merge-base", "show-ref", "for-each-ref", "show-branch"}
GIT_BLOCKED = ("--output", "--no-index", "--git-dir", "--work-tree", "--upload-pack", "--receive-pack", "--exec",
               "--contents", "--open-files-in-pager", "--ext-diff", "--textconv", "-O")


def _git_level(args):
    if not args:
        return "approve", "git 하위 명령이 없음"
    sub, rest = args[0], args[1:]
    if sub.startswith("-"):
        return "approve", "git 전역 옵션(-C, -c 등)이 있음"
    bad = next((a for a in rest if any(a == o or a.startswith(o + "=") or (o == "-O" and a.startswith("-O")) for o in GIT_BLOCKED)), None)
    if bad:
        return "approve", f"옵션 {bad} 은(는) 파일을 쓰거나 저장소 밖을 읽을 수 있음"
    if sub in GIT_FREE:
        return "auto", "읽기 전용 git 명령"
    if sub == "branch":
        listing = any(a in ("--list", "-l") for a in rest)
        if all(a.startswith("-") and a in ("-a", "--all", "-r", "--remotes", "-v", "-vv", "--verbose", "--list", "-l", "--show-current") or (listing and not a.startswith("-")) for a in rest):
            return "auto", "브랜치 목록 보기"
        return "approve", "브랜치를 만들거나 바꿈"
    if sub == "remote":
        if not rest or rest in (["-v"], ["--verbose"]) or rest[0] in ("show", "get-url"):
            return "auto", "원격 저장소 보기"
        return "approve", "원격 저장소 설정을 바꿈"
    if sub == "tag":
        if (not rest or rest[0] in ("-l", "--list", "-n")) and not any(a in ("-d", "-f", "-a", "-m", "-s", "-u") for a in rest):
            return "auto", "태그 목록 보기"
        return "approve", "태그를 만들거나 지움"
    if sub == "stash":
        return ("auto", "스태시 보기") if rest and rest[0] in ("list", "show") else ("approve", "작업 내용을 스태시에 넣거나 꺼냄")
    if sub == "reflog":
        return ("auto", "reflog 보기") if (not rest or rest[0] == "show") else ("approve", "reflog 를 바꿈")
    return "approve", f"git {sub} 은(는) 저장소나 원격을 바꿀 수 있음"


def classify_command(command):
    """('auto'|'approve'|'deny', 이유). auto: 읽기 전용이 확실해 바로 실행, approve: 사용자 승인 필요, deny: 실행하지 않음."""
    text = (command or "").strip()
    if not text:
        return "deny", "명령이 비어 있음"
    for rx, why in DENY_PATTERNS:
        if rx.search(text):
            return "deny", why
    if SHELL_META.search(text):
        return "approve", "여러 명령을 잇거나 리다이렉트/치환이 있음"
    try:
        tokens = shlex.split(text)
    except ValueError:
        return "approve", "따옴표가 맞지 않음"
    if not tokens:
        return "deny", "명령이 비어 있음"
    head, args = tokens[0], tokens[1:]
    if head == "git":
        return _git_level(args)
    if head in VERSION_TOOLS and args in (["--version"], ["-V"]):
        return "auto", "버전 확인"
    if head in ("pwd", "whoami", "hostname", "date") and not args:
        return "auto", "시스템 정보 보기"
    if head == "uname" and all(a in ("-a", "-s", "-r", "-m") for a in args):
        return "auto", "시스템 정보 보기"
    return "approve", "읽기 전용으로 확인되지 않은 명령"


def shell_argv(command):
    """플랫폼에 맞게 명령을 셸로 실행할 인자와 shell 여부, 출력 인코딩을 돌려준다."""
    git_bash = os.name == "nt" and os.environ.get("MSYSTEM") and shutil.which("bash")
    if git_bash:
        argv, use_shell = ["bash", "-c", command], False
    elif os.name == "nt":
        argv, use_shell = command, True
    else:
        argv, use_shell = [os.environ.get("SHELL") or "/bin/sh", "-c", command], False
    encoding = "utf-8" if (os.name != "nt" or git_bash) else (locale.getpreferredencoding(False) or "utf-8")
    return argv, use_shell, encoding


ACTIVE_PROCS = set()  # 지금 실행 중인 명령들. 터미널을 닫거나 로그아웃/종료할 때 함께 끝내기 위해 기억해 둔다


def install_shutdown_handlers():
    """터미널을 닫거나(SIGHUP) 종료/로그아웃/시스템 종료(SIGTERM, 윈도우 콘솔 이벤트)가 오면
    실행 중인 명령을 모두 끝내고 eye 도 바로 종료한다. 사용자가 멈춘 적 없는 작업이 뒤에 남지 않게 한다."""

    def shutdown(*_):
        for proc in list(ACTIVE_PROCS):
            kill_tree(proc)
        os._exit(1)

    if os.name == "nt":
        try:
            import ctypes
            handler_type = ctypes.WINFUNCTYPE(ctypes.c_int, ctypes.c_uint)

            def on_console_event(event):
                if event in (2, 5, 6):  # CTRL_CLOSE_EVENT, CTRL_LOGOFF_EVENT, CTRL_SHUTDOWN_EVENT
                    shutdown()
                return 0  # Ctrl-C(0), Ctrl-Break(1)는 기존대로 처리

            global _CONSOLE_HANDLER
            _CONSOLE_HANDLER = handler_type(on_console_event)  # 참조를 잡아 두지 않으면 사라진다
            ctypes.windll.kernel32.SetConsoleCtrlHandler(_CONSOLE_HANDLER, True)
        except Exception:
            pass
    else:
        for name in ("SIGHUP", "SIGTERM"):
            try:
                signal.signal(getattr(signal, name), shutdown)
            except (AttributeError, ValueError, OSError):
                pass


def kill_tree(proc):
    try:
        if os.name == "nt":
            subprocess.run(["taskkill", "/F", "/T", "/PID", str(proc.pid)], capture_output=True)
        else:
            os.killpg(proc.pid, 9)
    except (OSError, ProcessLookupError):
        pass
    try:
        proc.kill()
    except OSError:
        pass


def execute_command(command, cwd, timeout):
    """작업 폴더에서 명령을 실행해 (종료 코드, 출력, 시간초과 여부) 를 돌려준다. 입력은 막고, EYE_* 환경변수는 넘기지 않는다."""
    argv, use_shell, encoding = shell_argv(command)
    env = {k: v for k, v in os.environ.items() if not k.startswith("EYE_")}
    env.update({"GIT_PAGER": "cat", "PAGER": "cat", "GIT_TERMINAL_PROMPT": "0", "GIT_EDITOR": "true"})
    try:
        proc = subprocess.Popen(argv, shell=use_shell, cwd=cwd, env=env, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE,
                                stderr=subprocess.STDOUT, start_new_session=(os.name != "nt"))
    except OSError as e:
        return None, f"실행하지 못했습니다: {e.strerror or e}", False
    ACTIVE_PROCS.add(proc)
    buf = bytearray()
    fd = proc.stdout.fileno()

    def reader():
        while True:
            try:
                chunk = os.read(fd, 65536)
            except OSError:
                break
            if not chunk:
                break
            if len(buf) < 1_000_000:  # 출력이 아무리 많아도 메모리에는 1MB 까지만 둔다
                buf.extend(chunk[:1_000_000 - len(buf)])

    thread = threading.Thread(target=reader, daemon=True)
    thread.start()
    timed_out = False
    deadline = time.time() + timeout
    code = None
    try:
        while True:
            try:
                code = proc.wait(timeout=0.25)  # 짧게 끊어 기다린다: 윈도우에서는 긴 wait 중에는 Ctrl-C 가 늦게 처리되기 때문
                break
            except subprocess.TimeoutExpired:
                if time.time() >= deadline:
                    timed_out = True
                    kill_tree(proc)
                    try:
                        code = proc.wait(timeout=5)
                    except subprocess.TimeoutExpired:
                        code = None
                    break
    except KeyboardInterrupt:  # Ctrl-C: 실행 중인 명령(과 그 하위 프로세스)도 함께 종료하고 위로 알린다
        kill_tree(proc)
        raise
    finally:
        ACTIVE_PROCS.discard(proc)
    thread.join(2)
    return code, codecs.getincrementaldecoder(encoding)(errors="replace").decode(bytes(buf)), timed_out


AUTO = {"on": False}  # 자동 승인 모드: 승인 질문에서 a 를 고르면 켜지고, 이번 실행이 끝날 때까지 파일 수정·명령·Eyefeet Cloud 변경 작업을 묻지 않는다
AUTO_NOTICE = ("  자동 승인 모드를 켰습니다: 이제 파일 수정, 명령 실행, Eyefeet Cloud 변경 작업을 묻지 않고 진행합니다 "
               "(sudo 등 거부 목록은 계속 막히고, Eyefeet Cloud 의 삭제·초기화·중지 같은 작업은 계속 확인합니다). 끄려면 /commands ask")


def auto_on():
    AUTO["on"] = True
    sys.stderr.write("\033[2m" + AUTO_NOTICE + "\033[0m\n")


class Workspace:
    """eye 를 실행한 폴더를 작업 폴더로 삼아, 그 안에서만 파일을 읽고 (승인 후) 쓸 수 있게 한다."""

    def __init__(self, root, commands=True):
        self.root = os.path.realpath(root)
        self.always = False  # 파일 수정 자동 승인 (a)
        self.commands = commands
        self.auto_commands = False  # 명령 자동 승인 (명령 확인에서 a). 저장하지 않고 이번 실행에서만 유효

    def resolve(self, path):
        full = os.path.realpath(os.path.join(self.root, path or "."))
        base, cand = os.path.normcase(self.root), os.path.normcase(full)
        if cand != base and not cand.startswith(base.rstrip(os.sep) + os.sep):
            raise ToolError(f"작업 폴더 밖은 접근할 수 없습니다: {path}")
        rel = os.path.relpath(full, self.root)
        if ".git" in rel.split(os.sep):
            raise ToolError(".git 폴더는 접근할 수 없습니다")
        if cand == os.path.normcase(os.path.realpath(CONFIG)):
            raise ToolError("eye 설정 파일은 접근할 수 없습니다")
        return full

    def resolve_file(self, path):
        full = self.resolve(path)
        if SECRET_NAMES.match(os.path.basename(full)):
            raise ToolError(f"민감한 파일({os.path.basename(full)})은 읽거나 쓸 수 없습니다")
        return full

    def rel(self, full):
        return os.path.relpath(full, self.root).replace(os.sep, "/")

    @staticmethod
    def read_text(full):
        with open(full, "rb") as f:
            raw = f.read(2_000_001)
        if len(raw) > 2_000_000:
            raise ToolError("파일이 너무 큽니다 (2MB 초과). search_text 로 필요한 부분을 찾아보세요")
        if b"\0" in raw[:4096]:
            raise ToolError("바이너리 파일입니다. read_binary 도구로 형식 확인, 16진수 덤프, 문자열 추출을 할 수 있습니다")
        return raw.decode("utf-8", errors="replace")

    # ---- 읽기 도구 ----
    def list_files(self, path=".", recursive=False):
        full = self.resolve(path)
        if not os.path.isdir(full):
            raise ToolError(f"폴더가 아닙니다: {path}")
        lines = []
        for dirpath, dirs, files in os.walk(full):
            depth = 0 if dirpath == full else os.path.relpath(dirpath, full).count(os.sep) + 1
            kept = []
            for d in sorted(dirs):
                entry = self.rel(os.path.join(dirpath, d)) + "/"
                if d in SKIP_DIRS:
                    lines.append(f"{entry}  ({SKIP_NOTES.get(d, '내용은 생략')})")
                else:
                    lines.append(entry)
                    kept.append(d)
            dirs[:] = kept
            for f in sorted(files):
                lines.append(self.rel(os.path.join(dirpath, f)))
            if not recursive or depth >= 2:
                dirs[:] = []
            if len(lines) >= 300:
                break
        shown = lines[:300]
        out = "\n".join(shown) or "(비어 있음)"
        return clip(out + ("\n...(300개까지만 표시)" if len(lines) > 300 else ""))

    def read_file(self, path, start_line=1, max_lines=200):
        full = self.resolve_file(path)
        if not os.path.isfile(full):
            raise ToolError(f"파일이 없습니다: {path}")
        text = self.read_text(full).splitlines()
        start = max(1, int(start_line or 1))
        count = min(max(1, int(max_lines or 200)), 400)
        chunk = text[start - 1:start - 1 + count]
        if not chunk:
            return f"(파일은 총 {len(text)}줄입니다. {start}번째 줄부터는 내용이 없습니다)"
        body = "\n".join(f"{start + i:>5}\t{line}" for i, line in enumerate(chunk))
        end = start + len(chunk) - 1
        return clip(f"[{self.rel(full)} · 전체 {len(text)}줄 중 {start}-{end}]\n{body}")

    MAGIC = [
        (b"%PDF", "PDF 문서"), (b"\x89PNG", "PNG 이미지"), (b"\xff\xd8\xff", "JPEG 이미지"), (b"GIF8", "GIF 이미지"),
        (b"\x7fELF", "ELF 실행 파일"), (b"MZ", "Windows 실행 파일(exe/dll)"), (b"SQLite format 3\0", "SQLite 데이터베이스"),
        (b"\x1f\x8b", "gzip 압축"), (b"BZh", "bzip2 압축"), (b"7z\xbc\xaf\x27\x1c", "7-Zip 압축"), (b"Rar!", "RAR 압축"),
        (b"\xd0\xcf\x11\xe0\xa1\xb1\x1a\xe1", "MS Office 97-2003 또는 한글(hwp) 같은 OLE 문서"),
        (b"RIFF", "RIFF 컨테이너(wav/avi/webp)"), (b"ID3", "MP3 오디오"),
    ]

    @classmethod
    def describe_binary(cls, full, head):
        """파일 앞부분으로 형식을 추정한다. ZIP 계열(docx/xlsx/jar 등)은 안의 파일 목록도 돌려준다."""
        if head.startswith(b"PK\x03\x04"):
            try:
                with zipfile.ZipFile(full) as z:
                    names = z.namelist()
                    kind = ("Word 문서(docx)" if any(n.startswith("word/") for n in names) else
                            "Excel 통합 문서(xlsx)" if any(n.startswith("xl/") for n in names) else
                            "PowerPoint(pptx)" if any(n.startswith("ppt/") for n in names) else
                            "Java 압축(jar)" if "META-INF/MANIFEST.MF" in names else "ZIP 압축")
                    listing = [f"  {i.file_size:>10,}  {i.filename}" for i in z.infolist()[:40]]
                    more = [f"  ...외 {len(names) - 40}개"] if len(names) > 40 else []
                    return kind, "안에 든 파일:\n" + "\n".join(listing + more)
            except (zipfile.BadZipFile, OSError):
                return "ZIP 계열(열 수 없음, 손상됐을 수 있음)", ""
        for sig, name in cls.MAGIC:
            if head.startswith(sig):
                return name, ""
        return "알 수 없음 (텍스트가 아닌 데이터)", ""

    UTF8_RUN = re.compile(rb"(?:[\x20-\x7e\t]|[\xc2-\xdf][\x80-\xbf]|[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf4][\x80-\xbf]{3}){4,}")
    UTF16_RUN = re.compile(rb"(?:(?:[\x20-\x7e]\x00)|(?:[\x00-\xff][\xac-\xd7])){4,}")

    def read_binary(self, path, mode="hex", offset=0, length=256):
        full = self.resolve_file(path)
        if not os.path.isfile(full):
            raise ToolError(f"파일이 없습니다: {path}")
        mode = (mode or "hex").lower()
        if mode not in ("hex", "strings"):
            raise ToolError("mode 는 hex 또는 strings 여야 합니다")
        size = os.path.getsize(full)
        offset = max(0, int(offset or 0))
        with open(full, "rb") as f:
            head = f.read(4096)
            kind, extra = self.describe_binary(full, head)
            f.seek(offset)
            if mode == "hex":
                length = min(max(1, int(length or 256)), 1024)
                data = f.read(length)
            else:
                data = f.read(2_000_000)
        header = f"[{self.rel(full)} · {size:,}바이트 · 형식: {kind}]"
        if extra:
            header += "\n" + extra
        if offset >= size and size:
            return header + f"\n(시작 위치 {offset} 가 파일 끝({size})을 넘었습니다)"
        if mode == "hex":
            lines = []
            for i in range(0, len(data), 16):
                chunk = data[i:i + 16]
                hexpart = " ".join(f"{b:02x}" for b in chunk)
                text = "".join(chr(b) if 32 <= b < 127 else "." for b in chunk)
                lines.append(f"{offset + i:08x}  {hexpart:<47}  |{text}|")
            return clip(header + f"\n[{offset}-{offset + len(data) - 1} 바이트]\n" + "\n".join(lines))
        found = []
        for m in self.UTF8_RUN.finditer(data):
            found.append((m.start(), m.group().decode("utf-8", errors="replace")))
        for m in self.UTF16_RUN.finditer(data):
            found.append((m.start(), m.group().decode("utf-16-le", errors="replace")))
        seen, rows = set(), []
        for pos, text in sorted(found):
            if text not in seen:
                seen.add(text)
                rows.append(f"{offset + pos:>10}  {text[:200]}")
            if len(rows) >= 200:
                break
        body = "\n".join(rows) if rows else "(읽을 수 있는 문자열이 없습니다)"
        return clip(header + f"\n[읽을 수 있는 문자열 {len(rows)}개 · 앞쪽 2MB까지 검사]\n" + body)

    def search_text(self, pattern, path=".", file_glob=None):
        try:
            rx = re.compile(pattern)
        except re.error as e:
            raise ToolError(f"정규식이 올바르지 않습니다: {e}")
        start = self.resolve(path)
        targets = []
        if os.path.isfile(start):
            self.resolve_file(path)
            targets.append(start)
        else:
            for dirpath, dirs, files in os.walk(start):
                dirs[:] = sorted(d for d in dirs if d not in SKIP_DIRS)
                for f in sorted(files):
                    if file_glob and not fnmatch.fnmatch(f, file_glob):
                        continue
                    if not SECRET_NAMES.match(f):
                        targets.append(os.path.join(dirpath, f))
        hits = []
        for full in targets:
            try:
                if os.path.getsize(full) > 1_000_000:
                    continue
                text = self.read_text(full)
            except (OSError, ToolError):
                continue
            for n, line in enumerate(text.splitlines(), 1):
                if rx.search(line):
                    hits.append(f"{self.rel(full)}:{n}: {line.strip()[:200]}")
                    if len(hits) >= 50:
                        return clip("\n".join(hits) + "\n...(50건까지만 표시)")
        return clip("\n".join(hits)) if hits else "(일치하는 내용이 없습니다)"

    # ---- 쓰기 도구 (사용자 승인 필요) ----
    def approve(self, summary):
        if self.always or AUTO["on"]:
            return True
        if not sys.stdin.isatty():
            return False
        try:
            answer = ask_line(f"{summary}\n  적용할까요? [y/N/a=이번 실행 동안 모두 자동 승인] ").strip().lower()
        except (EOFError, KeyboardInterrupt):
            print()
            return False
        if answer == "a":
            auto_on()
        return answer in ("y", "yes", "a")

    def write_file(self, path, content):
        full = self.resolve_file(path)
        if os.path.isdir(full):
            raise ToolError(f"폴더입니다: {path}")
        lines = content.count("\n") + (0 if content.endswith("\n") or not content else 1)
        kind = "덮어쓰기" if os.path.exists(full) else "새 파일"
        preview = "\n".join("    + " + l for l in content.splitlines()[:8])
        if not self.approve(f"\n  ✎ {kind}: {self.rel(full)} ({lines}줄)\n{preview}"):
            return "사용자가 거절했습니다. 파일은 바뀌지 않았습니다."
        os.makedirs(os.path.dirname(full), exist_ok=True)
        with open(full, "w", encoding="utf-8", newline="") as f:
            f.write(content)
        return f"{self.rel(full)} 에 {lines}줄을 썼습니다."

    def edit_file(self, path, old_text, new_text):
        full = self.resolve_file(path)
        if not os.path.isfile(full):
            raise ToolError(f"파일이 없습니다: {path}")
        text = self.read_text(full)
        if "\r\n" in text:  # CRLF 파일: 모델이 보낸 줄바꿈(\n)을 파일 형식에 맞춘다
            old_text = old_text.replace("\r\n", "\n").replace("\n", "\r\n")
            new_text = new_text.replace("\r\n", "\n").replace("\n", "\r\n")
        n = text.count(old_text)
        if not old_text:
            raise ToolError("old_text 가 비어 있습니다")
        if n == 0:
            raise ToolError("old_text 를 파일에서 찾지 못했습니다. read_file 로 현재 내용을 다시 확인하세요")
        if n > 1:
            raise ToolError(f"old_text 가 {n}곳에 있습니다. 앞뒤 내용을 더 포함해 한 곳만 가리키게 하세요")
        diff = "\n".join(["    - " + l for l in old_text.splitlines()[:8]] + ["    + " + l for l in new_text.splitlines()[:8]])
        if not self.approve(f"\n  ✎ 수정: {self.rel(full)}\n{diff}"):
            return "사용자가 거절했습니다. 파일은 바뀌지 않았습니다."
        with open(full, "w", encoding="utf-8", newline="") as f:
            f.write(text.replace(old_text, new_text, 1))
        return f"{self.rel(full)} 을 수정했습니다."

    # ---- 명령 실행 (읽기 명령은 바로, 나머지는 사용자 승인 후) ----
    def tools(self):
        return [t for t in TOOLS if self.commands or t["function"]["name"] != "run_command"]

    def confirm(self, summary):
        """명령 실행 승인. y: 이번 한 번, a: 이번 실행 동안 거부 목록 외의 모든 명령을 자동 승인.
        a 는 파일 수정·명령·Eyefeet Cloud 변경 작업을 모두 포함하는 하나의 자동 승인 모드(AUTO)를 켠다."""
        if not sys.stdin.isatty():
            return False
        try:
            answer = ask_line(f"{summary}\n  실행할까요? [y/N/a=이번 실행 동안 모두 자동 승인] ").strip().lower()
        except (EOFError, KeyboardInterrupt):
            print()
            return False
        if answer in ("a", "all"):
            auto_on()
            return True
        return answer in ("y", "yes")

    def run_command(self, command, timeout=60):
        if not self.commands:
            return "오류: 명령 실행이 꺼져 있습니다 (--no-commands 또는 EYE_NO_COMMANDS)"
        level, why = classify_command(command)
        if level == "deny":
            return (f"이 명령은 안전을 위해 실행하지 않습니다 ({why}). "
                    "정말 필요하면 사용자가 대화창에서 `!명령`으로 직접 실행해야 합니다.")
        timeout = min(max(1, int(timeout or 60)), 300)
        if level == "approve":
            if self.auto_commands or AUTO["on"]:  # 사용자가 a 로 자동 승인을 켠 경우: 묻지 않지만 무엇을 실행하는지는 매번 보여 준다
                sys.stderr.write(f"\033[2m  ⚙ 자동 승인: $ {command[:300]}\033[0m\n")
            elif not self.confirm(f"\n  ⚙ 명령 실행 요청 (작업 폴더: {self.root})\n      $ {command}\n      ({why})"):
                return "사용자가 거절했거나 승인할 수 없는 환경(터미널이 아님)이라 실행하지 않았습니다. 명령은 실행되지 않았고 아무것도 바뀌지 않았습니다."
        code, output, timed_out = execute_command(command, self.root, timeout)
        output = output.rstrip()
        head = (f"(시간 초과: {timeout}초 안에 끝나지 않아 중단했습니다)" if timed_out
                else "(실행하지 못함)" if code is None else f"(종료 코드 {code})")
        all_lines = output.splitlines()
        preview = ["    " + l[:160] for l in all_lines[:15]] + (["    ..."] if len(all_lines) > 15 else []) + [f"    {head}"]
        sys.stderr.write("\033[2m" + "\n".join(preview) + "\033[0m\n")
        sys.stderr.flush()
        if len(output) > RESULT_LIMIT:
            output = output[:RESULT_LIMIT // 3] + "\n...(중간 생략)...\n" + output[-(RESULT_LIMIT * 2 // 3):]
        return f"{head}\n{output}" if output else head

    def run(self, name, raw_args):
        try:
            args = json.loads(raw_args) if raw_args and raw_args.strip() else {}
            if not isinstance(args, dict):
                raise ValueError
        except ValueError:
            return "오류: 도구 인자가 올바른 JSON 객체가 아닙니다"
        shown = ", ".join(f"{k}={str(v)[:40]!r}" for k, v in args.items() if k not in ("content", "old_text", "new_text", "command"))
        if name == "run_command":  # 무엇이 실행되는지 사용자가 정확히 볼 수 있도록 명령은 길게 보여 준다
            shown = str(args.get("command", ""))[:200]
        sys.stderr.write(f"\033[2m  ⏺ {name}({shown})\033[0m\n")
        sys.stderr.flush()
        fn = getattr(self, name, None) if name in {t["function"]["name"] for t in TOOLS} else None
        if fn is None:
            return f"오류: 알 수 없는 도구입니다: {name}"
        try:
            return fn(**args)
        except ToolError as e:
            return f"오류: {e}"
        except (TypeError, ValueError) as e:
            return f"오류: 인자가 맞지 않습니다 ({e})"
        except OSError as e:
            return f"오류: {e.strerror or e}"


def system_prompt(ws):
    return (
        "당신은 터미널에서 쓰는 도우미입니다. 작업 폴더는 `" + ws.root + "` 이고, 도구(list_files, read_file, read_binary, search_text, "
        "write_file, edit_file)로 그 안의 파일만 읽고 수정할 수 있습니다. 경로는 작업 폴더 기준 상대 경로로 쓰세요. "
        "파일 내용을 추측하지 말고 필요한 부분만 도구로 확인한 뒤 그 내용을 근거로 답하세요. 큰 파일은 start_line/max_lines 로 "
        "나눠 읽으세요. 파일을 고치기 전에는 먼저 읽어서 현재 내용을 확인하고, 작은 수정은 write_file 대신 edit_file 을 쓰세요. "
        "목록에서 이름 뒤에 괄호 설명이 붙은 폴더(예: .git/ (git 저장소…))는 내용을 보지 않을 뿐 실제로 있는 폴더입니다. "
        + (RUN_COMMAND_PROMPT if ws.commands else "") +
        "도구가 필요 없는 질문에는 바로 답하세요. 사용자가 쓰는 언어로 답하세요."
    )


# ---- 대화 저장 (--continue / --resume) -----------------------------------------------------------------------
DATA_HOME = os.environ.get("XDG_DATA_HOME") or os.path.expanduser("~/.local/share")
SESSIONS_DIR = os.path.join(DATA_HOME, "eye", "sessions")
MAX_SESSIONS = 50


class Session:
    """한 번의 대화. 질문과 최종 답(실행한 작업 목록 포함)만 저장한다 (도구 호출/결과는 저장하지 않음)."""

    def __init__(self, cwd, model, data=None):
        data = data or {}
        self.id = data.get("id") or time.strftime("%Y%m%d-%H%M%S") + "-" + os.urandom(2).hex()
        self.cwd = data.get("cwd", cwd)
        self.model = data.get("model", model)
        self.created = data.get("created", time.time())
        self.updated = data.get("updated", self.created)
        self.title = data.get("title", "")
        self.messages = data.get("messages", [])

    @property
    def path(self):
        return os.path.join(SESSIONS_DIR, self.id + ".json")

    def save(self):
        if not self.messages:
            return
        self.updated = time.time()
        if not self.title:
            first = next((m["content"] for m in self.messages if m["role"] == "user"), "")
            self.title = " ".join(first.split())[:60]
        data = {k: getattr(self, k) for k in ("id", "cwd", "model", "created", "updated", "title", "messages")}
        try:
            os.makedirs(SESSIONS_DIR, exist_ok=True)
            tmp = self.path + ".tmp"
            fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
            with os.fdopen(fd, "w", encoding="utf-8") as f:
                json.dump(data, f, ensure_ascii=False)
            os.replace(tmp, self.path)
            prune_sessions()
        except OSError as e:
            sys.stderr.write(f"eye: 대화를 저장하지 못했습니다 ({e.strerror or e})\n")


def list_sessions():
    found = []
    try:
        names = os.listdir(SESSIONS_DIR)
    except OSError:
        return found
    for name in names:
        if not name.endswith(".json"):
            continue
        try:
            with open(os.path.join(SESSIONS_DIR, name), encoding="utf-8") as f:
                data = json.load(f)
            if isinstance(data, dict) and isinstance(data.get("messages"), list):
                found.append(Session(data.get("cwd", ""), data.get("model", ""), data))
        except (OSError, ValueError):
            continue
    return sorted(found, key=lambda s: s.updated, reverse=True)


def prune_sessions():
    for old in list_sessions()[MAX_SESSIONS:]:
        try:
            os.remove(old.path)
        except OSError:
            pass


def same_dir(a, b):
    return os.path.normcase(os.path.realpath(a or "")) == os.path.normcase(os.path.realpath(b or ""))


def latest_session_for(cwd):
    return next((s for s in list_sessions() if same_dir(s.cwd, cwd)), None)


def choose_session(cwd):
    """--resume: 저장된 대화 목록에서 번호로 고른다. 현재 폴더의 대화를 먼저 보여 준다."""
    sessions = list_sessions()
    if not sessions:
        print("저장된 대화가 없습니다.")
        return None
    if not sys.stdin.isatty():
        die("--resume 은 터미널에서만 쓸 수 있습니다. 가장 최근 대화는 --continue 로 이어갈 수 있습니다.")
    sessions = sorted(sessions, key=lambda s: (not same_dir(s.cwd, cwd), -s.updated))[:20]
    for n, s in enumerate(sessions, 1):
        here = "" if same_dir(s.cwd, cwd) else f"  [{s.cwd}]"
        print(f"{n:>3}. {time.strftime('%Y-%m-%d %H:%M', time.localtime(s.updated))}  {s.title or '(제목 없음)'}{here}")
    try:
        pick = input("이어갈 번호 (엔터=취소): ").strip()
    except (EOFError, KeyboardInterrupt):
        print()
        return None
    if not pick.isdigit() or not 1 <= int(pick) <= len(sessions):
        return None
    return sessions[int(pick) - 1]


def describe_resume(session):
    last = next((m["content"] for m in reversed(session.messages) if m["role"] == "assistant"), "")
    when = time.strftime("%Y-%m-%d %H:%M", time.localtime(session.updated))
    lines = [f"이어가는 대화: {session.title or '(제목 없음)'} · 메시지 {len(session.messages)}개 · {when}"]
    if last:
        lines.append("  마지막 답: " + " ".join(last.split())[:160])
    return "\n".join(lines)


# ---- 자동 압축 -----------------------------------------------------------------------------------------------------
COMPACT_RATIO = 0.7  # 컨텍스트의 이 비율을 넘기 전에 줄인다 (나머지는 답변 공간)
OVERFLOW = re.compile(r"exceed|context (size|length|window)|too (long|large)|n_ctx|maximum context", re.I)


def est_tokens(text):
    """글자 수로 토큰 수를 어림한다 (영문 ≈ 3.5자/토큰, 한글 등 ≈ 1.3자/토큰으로 넉넉하게)."""
    ascii_chars = len(text.encode("ascii", "ignore"))
    return ascii_chars / 3.5 + (len(text) - ascii_chars) / 1.3


def messages_tokens(messages):
    total = 0
    for m in messages:
        total += 8 + est_tokens(m.get("content") or "")
        for c in m.get("tool_calls") or []:
            total += est_tokens((c.get("function") or {}).get("arguments") or "")
    return total


HONESTY_PROMPT = (
    "도구로 직접 확인하지 못한 사실(파일이나 폴더가 있는지, 저장소 주소, 명령을 실행한 결과 등)은 지어내지 마세요. "
    "모르면 모른다고 하고 확인 방법을 알려 주세요."
)
NO_COMMAND_PROMPT = (
    "당신은 터미널 명령을 직접 실행할 수 없습니다. "
    "명령 실행이 필요하면 사용자가 대화창에서 `!명령`(예: `!git status`)으로 직접 실행하면 그 결과가 다음 질문과 함께 전달된다고 안내하세요."
)
RUN_COMMAND_PROMPT = (
    "run_command 로 작업 폴더에서 터미널 명령을 실행해 결과를 확인할 수 있습니다. git status, git diff, git log 같은 읽기 명령은 바로 "
    "실행되고, 파일을 바꾸거나 그 밖의 명령(git add/commit/push, 설치, 스크립트 실행 등)은 실행 전에 사용자가 승인해야 합니다. "
    "저장소 상태나 명령 결과는 추측하지 말고 실제로 실행해서 확인하세요. 입력을 기다리는 대화형 프로그램은 쓸 수 없고 명령은 제한 시간 안에 끝나야 합니다. "
    "사용자가 승인하지 않아 실행되지 않았다면 실행된 것처럼 말하지 말고, 사용자가 직접 `!명령`으로 실행할 수 있다고 안내하세요. "
    "지난 답변 뒤에 붙은 `[eye 가 자동으로 남긴 기록…]` 은 eye 프로그램이 실제로 실행한 작업을 적어 둔 것이니 사실로 믿고 참고하되, 답변에 그 형식을 직접 쓰지는 마세요. "
)


SERVER_PROMPT_TOKENS = 600  # 서버가 요청마다 붙이는 Eyefeet 서비스 안내의 어림값 (컨텍스트 계산에 반영)


# ---- Eyefeet Cloud 도구 (eyefeetai 서버가 사용자의 Eyefeet Cloud MCP 를 대신 호출한다) --------------------------------
# 도구 정의가 길어 컨텍스트를 많이 쓰므로, 질문에 관련 말이 나왔을 때만 붙인다 (한 번 붙으면 이번 실행 동안 유지).
CLOUD_WORDS = re.compile(r"eyefeet|이파이|gitsalt|깃솔트|테넌트|배포|호스팅|서브도메인|paas", re.I)
CLOUD_BUILD = re.compile(r"(프로그램|앱|어플|웹\s*앱|웹\s*사이트|사이트|홈페이지|서비스|api|서버|봇|대시보드|게임|크롤러|스크립트|페이지|웹).{0,30}(만들|개발|작성|구현|제작|짜\s*줘)|(만들|개발|작성|구현|제작).{0,10}(프로그램|앱|사이트|홈페이지)|(build|create|make|write|develop).{0,25}(app|site|website|api|bot|program|service)", re.I)  # 제작 요청: 서버가 '배포할까요?' 하고 물으므로 대답을 바로 처리하도록 도구를 미리 붙인다
CLOUD_READ_ONLY = re.compile(r"^(list|get|check)_")  # 조회 도구는 바로 실행하고, 나머지는 매번 사용자가 승인한다
CLOUD = {"on": False, "tools": [], "prompt": "", "loaded": False, "direct": False}
CLOUD_KEY_ENV = "EYE_CLOUD_KEY"  # 로그인하지 않고 Eyefeet Cloud MCP 키를 직접 쓰는 방법 (환경변수로만 받는다)
CLOUD_MCP_DEFAULT = "https://admin.eyefeet.com/mcp"
LOCAL_CLOUD_PROMPT = (
    "Eyefeet Cloud 도구가 연결되어 있습니다. 사용자가 Eyefeet Cloud 에 배포하거나 테넌트를 만들려고 하면, "
    "도구를 호출하기 전에 필요한 값(서브도메인 이름, 표시 이름, 런타임, 저장소 URL, 브랜치, 빌드/시작 명령, 포트 등)을 "
    "사용자에게 먼저 물어보고, 모르는 값은 추측하지 말고 되물으세요. "
    "조회(list/get)는 바로 해도 되지만, 생성·수정·삭제·배포·중지 같은 변경 작업은 실행할 내용을 요약한 뒤 호출하세요 "
    "(터미널에서 사용자가 승인해야 실제로 실행됩니다). 토큰, 비밀번호 같은 값은 대화에 남기지 않도록 주의시키세요.\n"
    "저장소가 아직 없으면 create_gitsalt_repo 로 사용자의 GitSalt 계정에 저장소를 먼저 만드세요 (이름, 공개/비공개를 물어본 뒤). "
    "순서는 반드시 ① 저장소 생성 → ② 테넌트 생성(create_tenant, repo_url 은 ① 결과의 recommended_repo_url) → "
    "③ 웹훅 연결(register_gitsalt_webhook) → ④ 코드 올리기(git push) 입니다. 웹훅을 먼저 연결해 두어야 ④ 의 push 가 바로 자동 배포되므로, "
    "코드를 올리기 전에 deploy_tenant 로 수동 배포하지 마세요(새 저장소는 비어 있어 배포가 실패합니다). "
    "사용자가 프로그램을 만들어서 배포해 달라고 하면 코드부터 작성하지 마세요. 먼저 필요한 값(만들 앱의 종류, 런타임, 저장소·서브도메인 이름 등)을 물어보면서, "
    "진행 방식을 번호로 고르게 하세요: \"1. 테넌트·저장소만 만들고 기다리기 / 2. 테넌트·저장소를 만들고 코드 계획만 세워 보여 준 뒤, 시작하라고 하면 시작 / 3. 그냥 처음부터 끝까지 진행\". "
    "사용자가 고르기 전에는 저장소·테넌트도 만들지 마세요. 고른 뒤에는 ① ② ③ 을 진행하고(변경 작업이라 승인을 받습니다), 선택에 따라 이어 갑니다. "
    "1번: ③ 까지 끝내고 멈춰서 다음 지시를 기다립니다(코드는 쓰지 않습니다). "
    "2번: ③ 까지 끝낸 뒤 만들 코드의 계획(파일 구성, 핵심 기능, 사용할 런타임)만 정리해 보여 주고, 사용자가 시작하라고 말할 때까지 코드를 쓰지 않습니다. "
    "3번: ③ 까지 끝낸 뒤 바로 ④ 를 합니다. "
    "④ 는 저장소를 작업 폴더에 clone 하고(① 결과의 주소 사용) 그 안에 코드를 작성한 뒤 commit·push 해서 자동 배포되게 하는 것입니다. "
    "명령 실행 도구가 있으면 git clone / commit / push 로 실행할 내용을 요약해 승인을 받은 뒤 실행하고, 도구가 없으면 사용자가 실행할 명령을 알려 주세요. "
    "저장소가 이미 있으면 list_gitsalt_repos 로 보여 주고 고르게 하세요."
)


class CloudError(Exception):
    pass


def cloud_api(cfg, path, body=None, timeout=30):
    req = urllib.request.Request(
        cfg["base"] + path,
        data=None if body is None else json.dumps(body).encode(),
        headers={"Authorization": "Bearer " + cfg["key"], "Content-Type": "application/json", "User-Agent": "eye-cli/1"},
    )
    try:
        with urllib.request.urlopen(req, timeout=timeout) as r:
            return json.load(r)
    except urllib.error.HTTPError as e:
        detail = e.read().decode(errors="replace")
        try:
            data = json.loads(detail)
            detail = str(data.get("detail") or data.get("error") or detail)
        except (ValueError, AttributeError):
            pass
        raise CloudError(f"HTTP {e.code}: {detail[:300]}")
    except (urllib.error.URLError, OSError, ValueError) as e:
        raise CloudError(f"접속 실패: {getattr(e, 'reason', e)}")


def cloud_direct(cfg):
    """로그인 없이 환경변수의 MCP 키로 Eyefeet Cloud 를 직접 호출하는 방식인가."""
    return cfg.get("mode") != "login" and bool(os.environ.get(CLOUD_KEY_ENV, "").strip())


def mcp_direct(method, params=None, timeout=60):
    """Eyefeet Cloud MCP (stateless Streamable HTTP, Bearer 키) 로 JSON-RPC 요청을 보낸다. 키는 환경변수에서만 읽고 어디에도 남기지 않는다."""
    url = os.environ.get("EYE_CLOUD_MCP_URL", "").strip() or CLOUD_MCP_DEFAULT
    req = urllib.request.Request(
        url,
        data=json.dumps({"jsonrpc": "2.0", "id": 1, "method": method, "params": params or {}}).encode(),
        headers={
            "Authorization": "Bearer " + os.environ.get(CLOUD_KEY_ENV, "").strip(),
            "Content-Type": "application/json",
            "Accept": "application/json, text/event-stream",
            "User-Agent": "eye-cli/1",
        },
    )
    try:
        with urllib.request.urlopen(req, timeout=timeout) as r:
            ctype = r.headers.get("Content-Type", "")
            text = r.read().decode(errors="replace")
    except urllib.error.HTTPError as e:
        if e.code in (401, 403):
            raise CloudError(f"Eyefeet Cloud 가 키를 받아들이지 않았습니다. {CLOUD_KEY_ENV} 를 확인해 주세요")
        raise CloudError(f"Eyefeet Cloud 오류 (HTTP {e.code})")
    except (urllib.error.URLError, OSError) as e:
        raise CloudError(f"접속 실패: {getattr(e, 'reason', e)}")
    if "text/event-stream" in ctype:
        datas = [ln[5:].strip() for ln in text.splitlines() if ln.startswith("data:")]
        text = datas[-1] if datas else ""
    try:
        msg = json.loads(text)
    except ValueError:
        raise CloudError("Eyefeet Cloud 응답을 해석하지 못했습니다")
    if msg.get("error"):
        raise CloudError(str(msg["error"].get("message") or msg["error"])[:300])
    return msg.get("result") or {}


def direct_tools():
    result = mcp_direct("tools/list")
    return {"tools": [
        {"type": "function", "function": {
            "name": t["name"],
            "description": (t.get("description") or "")[:1000],
            "parameters": t.get("inputSchema") or {"type": "object", "properties": {}},
        }}
        for t in result.get("tools", []) if isinstance(t, dict) and t.get("name")
    ], "prompt": LOCAL_CLOUD_PROMPT}


def direct_call(name, args):
    result = mcp_direct("tools/call", {"name": name, "arguments": args}, timeout=130)
    parts = [c.get("text", "") for c in result.get("content", []) if isinstance(c, dict) and c.get("type") == "text"]
    text = "\n".join(parts) or json.dumps(result.get("structuredContent", result), ensure_ascii=False)
    return {"is_error": bool(result.get("isError")), "text": text[:20000]}


def load_cloud(cfg):
    CLOUD["direct"] = cloud_direct(cfg)
    try:
        data = direct_tools() if CLOUD["direct"] else cloud_api(cfg, "/cloud/tools")
    except CloudError as e:
        sys.stderr.write(dim(f"  Eyefeet Cloud 도구를 가져오지 못했습니다 ({e})") + "\n")
        return False
    own = {t["function"]["name"] for t in TOOLS}
    CLOUD["tools"] = [t for t in data.get("tools", []) if t["function"]["name"] not in own]
    CLOUD["prompt"] = str(data.get("prompt") or "")
    CLOUD["loaded"] = True
    return True


def cloud_prepare(cfg, text, history=()):
    """질문(또는 최근 사용자 메시지)에 Eyefeet 관련 말이 나오면 Eyefeet Cloud 도구를 붙인다. 로그인 방식일 때만 (EYE_NO_CLOUD 로 끌 수 있다)."""
    if os.environ.get("EYE_NO_CLOUD"):
        return
    if cfg.get("mode") != "login" and not cloud_direct(cfg):
        # API 키 방식은 사용자를 특정할 수 없어 서버 연결을 쓸 수 없다 — 관련 말이 나오면 한 번만 방법을 알려 준다
        if not CLOUD.get("hinted") and CLOUD_WORDS.search(text or ""):
            CLOUD["hinted"] = True
            sys.stderr.write(dim(f"  Eyefeet Cloud 도구는 `eye login` 으로 로그인하거나, 환경변수 {CLOUD_KEY_ENV} 에 Eyefeet Cloud MCP 키를 넣어야 쓸 수 있습니다.") + "\n")
        return
    if not CLOUD["on"]:
        recent = [text or ""] + [m.get("content") or "" for m in list(history)[-6:] if m.get("role") == "user"]
        if not any(CLOUD_WORDS.search(t) or CLOUD_BUILD.search(t) for t in recent):
            return
        CLOUD["on"] = True
    if not CLOUD["loaded"] and load_cloud(cfg):
        n = len(CLOUD["tools"])
        sys.stderr.write(dim(f"  Eyefeet Cloud 도구 {n}개를 연결했습니다." if n else "  Eyefeet Cloud 연결 안내를 준비했습니다.") + "\n")


def cloud_active():
    return CLOUD["on"] and CLOUD["loaded"]


def cloud_tool_names():
    return {t["function"]["name"] for t in CLOUD["tools"]} | ({"cloud_issue_key"} if cloud_active() and not CLOUD["direct"] else set())


def turn_tools(ws):
    tools = (ws.tools() if ws else []) + (CLOUD["tools"] if cloud_active() else [])
    return tools or None


CLOUD_ALWAYS_ASK = re.compile(r"^(delete|rotate|reset|cancel|stop)_|^cloud_issue_key$")  # 자동 승인 모드에서도 매번 확인하는 작업


def confirm_cloud(summary, name=""):
    """Eyefeet Cloud 의 변경 작업은 사용자가 승인해야 한다. 자동 승인 모드에서는 묻지 않고 진행하되, 삭제·초기화·중지 같은 작업은 계속 묻는다."""
    if AUTO["on"] and not CLOUD_ALWAYS_ASK.match(name):
        sys.stderr.write("\033[2m  ☁ 자동 승인: " + " ".join(summary.split())[:300] + "\033[0m\n")
        return True
    if not sys.stdin.isatty():
        return False
    always = bool(CLOUD_ALWAYS_ASK.match(name))  # 삭제·초기화·중지 같은 작업에는 자동 승인(a)을 권하지 않는다
    try:
        answer = ask_line(f"{summary}\n  실행할까요? " + ("[y/N] " if always else "[y 실행 / a 모두 자동 승인 / N 거절] ")).strip().lower()
    except (EOFError, KeyboardInterrupt):
        print()
        return False
    if answer == "a" and not always:
        auto_on()
        return True
    return answer in ("y", "yes")


def run_cloud(cfg, name, raw_args):
    try:
        args = json.loads(raw_args) if raw_args and raw_args.strip() else {}
        if not isinstance(args, dict):
            raise ValueError
    except ValueError:
        return "오류: 도구 인자가 올바른 JSON 객체가 아닙니다"
    if name == "cloud_issue_key" and CLOUD["direct"]:
        return "오류: 환경변수의 키를 쓰는 중이라 키 발급 도구는 없습니다"
    if name == "cloud_issue_key":
        ok = confirm_cloud("\n  ☁ Eyefeet Cloud 연결 키를 발급합니다 (이미 있으면 가져옵니다).", name)
    elif CLOUD_READ_ONLY.match(name):
        shown = ", ".join(f"{k}={str(v)[:40]!r}" for k, v in args.items())
        sys.stderr.write(dim(f"  ⏺ {name}({shown})") + "\n")
        sys.stderr.flush()
        ok = True
    else:
        ok = confirm_cloud(f"\n  ☁ Eyefeet Cloud 작업: {name}\n      " + json.dumps(args, ensure_ascii=False)[:300], name)
    if not ok:
        return "사용자가 거절했거나 승인할 수 없는 환경(터미널이 아님)이라 실행하지 않았습니다. Eyefeet Cloud 에는 아무것도 바뀌지 않았습니다."
    try:
        res = direct_call(name, args) if CLOUD["direct"] else cloud_api(cfg, "/cloud/call", {"name": name, "arguments": args}, timeout=130)
    except CloudError as e:
        return f"오류: {e}"
    text = str(res.get("text", ""))
    if res.get("is_error"):
        return clip("오류: " + text)
    if name == "cloud_issue_key":  # 연결됐다: 키 발급 도구 대신 실제 Eyefeet Cloud 도구를 가져온다
        CLOUD["loaded"] = False
        load_cloud(cfg)
    return clip(text)


def full_system_prompt(ws):
    can_run = bool(ws and ws.commands)
    return "\n\n".join(([system_prompt(ws)] if ws else []) + ([CLOUD["prompt"].strip()] if cloud_active() and CLOUD["prompt"] else []) + [HONESTY_PROMPT] + ([] if can_run else [NO_COMMAND_PROMPT]) + [STYLE_PROMPT])


def fixed_tokens(ws):
    return (SERVER_PROMPT_TOKENS + est_tokens(full_system_prompt(ws)) + (est_tokens(json.dumps(ws.tools(), ensure_ascii=False)) if ws else 0)
            + (est_tokens(json.dumps(CLOUD["tools"], ensure_ascii=False)) if cloud_active() else 0))


def model_context(cfg):
    """지금 모델의 슬롯 하나가 처리하는 컨텍스트 토큰 수. 서버가 모델 목록에 알려 주는 값을 쓰고(처음 한 번만 가져온다),
    모르면 기본값 또는 사용자가 정한 EYE_CONTEXT 를 쓴다."""
    if cfg.get("context_fixed"):
        return cfg["context"]
    known = cfg.get("_model_ctx")
    if known is None:
        known = {}
        try:
            with request(cfg, "/models", soft=True) as r:
                for m in json.load(r).get("data", []):
                    if isinstance(m, dict) and isinstance(m.get("context"), int) and m["context"] > 0:
                        known[m["id"]] = m["context"]
        except (ApiError, SystemExit, OSError, ValueError, AttributeError):
            pass  # 못 가져와도 기본값으로 동작한다
        cfg["_model_ctx"] = known
    return max(2048, known.get(cfg["model"], cfg["context"]))


def threshold(cfg):
    return model_context(cfg) * COMPACT_RATIO


def shrink_tool_results(work, keep_last):
    """오래된 도구 결과(파일 내용 등)를 한 줄 요약으로 바꾼다. 최근 keep_last 개는 그대로 둔다."""
    idx = [i for i, m in enumerate(work) if m["role"] == "tool"]
    changed = False
    for i in idx[:max(0, len(idx) - keep_last)]:
        content = work[i]["content"]
        if not content.startswith("[생략됨]"):
            work[i] = dict(work[i], content="[생략됨] " + (content.splitlines() or [""])[0][:100])
            changed = True
    return changed


def clip_history(history, limit=3000):
    out = []
    for m in history:
        c = m.get("content") or ""
        if len(c) > limit:
            c = c[:limit // 2] + "\n...(길어서 중간 생략)...\n" + c[-limit // 2:]
        out.append(dict(m, content=c))
    return out


def compact_history(cfg, history, keep_pairs=2):
    """오래된 대화를 모델에게 요약시켜 한 덩어리로 바꾸고, 최근 keep_pairs 번의 주고받음은 그대로 둔다."""
    user_idx = [i for i, m in enumerate(history) if m["role"] == "user"]
    if len(user_idx) <= keep_pairs:
        return clip_history(history)  # 요약할 만큼 오래된 대화가 없으면 긴 메시지만 줄인다
    cut = user_idx[-keep_pairs]
    old, recent = history[:cut], history[cut:]

    budget, lines = model_context(cfg) * 0.5, []
    for m in reversed(old):  # 최근 쪽부터 채우고, 모자라면 오래된 앞부분을 버린다
        who = "사용자" if m["role"] == "user" else "도우미"
        text = f"{who}: {(m.get('content') or '')[:3000]}"
        budget -= est_tokens(text)
        if budget < 0:
            lines.append("(더 오래된 대화는 생략)")
            break
        lines.append(text)
    transcript = "\n\n".join(reversed(lines))

    sys.stderr.write("\033[2m  대화가 길어져 이전 내용을 요약합니다.\033[0m\n")
    sys.stderr.flush()
    ask = [
        {"role": "system", "content": "당신은 대화 요약기입니다. 요약만 출력하세요."},
        {"role": "user", "content": (
            "아래는 사용자와 도우미의 지난 대화입니다. 이어서 대화하는 데 필요한 내용만 간결하게 요약하세요. "
            "결정된 사항, 다룬 파일 경로, 사용자의 요청과 아직 남은 할 일, 중요한 코드/수치를 꼭 포함하고, "
            "사용자가 쓴 언어로 쓰세요.\n\n" + transcript)},
    ]
    try:
        summary, _, interrupted = chat(cfg, ask, quiet=True, label="대화를 요약하는 중")
    except ApiError as e:
        sys.stderr.write(f"eye: 요약하지 못했습니다 ({e.detail[:100]}). 긴 메시지만 줄입니다.\n")
        return clip_history(history)
    summary = summary.strip()
    if interrupted or not summary:
        return clip_history(history)
    before = messages_tokens(history)
    new = [{"role": "user", "content": "[이전 대화 요약]\n" + summary},
           {"role": "assistant", "content": "요약을 확인했습니다. 이어서 도와드리겠습니다."}] + recent
    sys.stderr.write(f"\033[2m  ✓ 요약 완료 (약 {int(before):,} → {int(messages_tokens(new)):,} 토큰)\033[0m\n")
    return new


def maybe_compact(cfg, history, next_text, ws):
    cloud_prepare(cfg, next_text, history)
    need = messages_tokens(history) + est_tokens(next_text) + fixed_tokens(ws)
    return compact_history(cfg, history) if need > threshold(cfg) else history


# ---- 터미널용 마크다운 출력 ------------------------------------------------------------------------------------
STYLE_PROMPT = (
    "출력은 터미널에서 읽습니다. 짧은 문단과 간단한 글머리표('-')를 쓰고, 이모지·장식 문구·긴 머리말은 피하세요. "
    "코드나 명령어는 ``` 코드 블록에 넣고, 표는 꼭 필요할 때만 열이 적은 간단한 표로 쓰세요. "
    "굵은 글씨는 꼭 필요한 곳에만 쓰세요."
)


def enable_ansi():
    """Windows 콘솔에서 ANSI 색상/서식 코드가 보이도록 켠다 (다른 OS에서는 아무 일도 하지 않음)."""
    if os.name != "nt":
        return
    try:
        import ctypes
        kernel = ctypes.windll.kernel32
        handle = kernel.GetStdHandle(-11)
        mode = ctypes.c_ulong()
        if kernel.GetConsoleMode(handle, ctypes.byref(mode)):
            kernel.SetConsoleMode(handle, mode.value | 0x0004)
    except Exception:
        pass


class Style:
    def __init__(self, color=True):
        def c(code):
            return f"\033[{code}m" if color else ""
        self.reset, self.dim = c(0), c(2)
        self.bold, self.unbold = c(1), c(22)
        self.code, self.uncode = c(36), c(39)
        self.head = c("1;4")


def display_width(text):
    return sum(2 if unicodedata.east_asian_width(ch) in "WF" else 1 for ch in text)


def strip_inline(text):
    return re.sub(r"`([^`]*)`", r"\1", re.sub(r"\*\*(.+?)\*\*", r"\1", text)).strip()


class MdStream:
    """모델이 보내는 마크다운을 글자가 나오는 대로 터미널 서식으로 바꿔 출력한다.
    제목/굵게/인라인 코드/코드 블록/목록/인용/구분선/링크/표를 처리하고, 그 밖의 글자는 그대로 둔다."""

    LINK = re.compile(r"\[([^\]\n]+)\]\(([^)\s]+)\)")

    def __init__(self, write, style):
        self.w, self.s = write, style
        self.at_start, self.lead = True, ""
        self.bold = self.code_span = self.star = False
        self.link = None
        self.in_fence = self.fence_header = False
        self.fence_line = ""
        self.table, self.table_line = [], None
        self.skip_space = False

    # -- 입력 --
    def feed(self, text):
        for ch in text:
            self._ch(ch)

    def finish(self):
        if self.in_fence and self.fence_line and not self.fence_header:
            self.w(self.s.dim + "    " + self.fence_line + self.s.reset)
        self.in_fence = self.fence_header = False
        if self.table_line is not None:
            self.table.append(self.table_line)
            self.table_line = None
        self._flush_table()
        if self.lead:
            lead, self.lead, self.at_start = self.lead, "", False
            for ch in lead:
                self._inline(ch)
        self._end_inline()
        self.w(self.s.reset)

    # -- 한 글자 --
    def _ch(self, ch):
        if self.in_fence:
            return self._fence_ch(ch)
        if self.table_line is not None:
            if ch == "\n":
                self.table.append(self.table_line)
                self.table_line, self.at_start, self.lead = None, True, ""
            else:
                self.table_line += ch
            return
        if self.at_start:
            return self._start_ch(ch)
        if ch == "\n":
            return self._newline()
        self._inline(ch)

    def _newline(self):
        self._end_inline()
        self.w(self.s.reset + "\n")
        self.bold = self.code_span = False
        self.at_start, self.lead = True, ""

    def _end_inline(self):
        if self.link is not None:
            link, self.link = self.link, None
            self.w(link)
        if self.star:
            self.star = False
            self.w("*")

    # -- 줄 맨 앞: 어떤 종류의 줄인지 판단 --
    def _start_ch(self, ch):
        if ch == "\n":
            pending, self.lead = self.lead, ""
            rest = pending.lstrip(" ")
            self._flush_table()
            if len(rest) >= 3 and set(rest) == {"-"}:
                self.w(self.s.dim + "─" * 40 + self.s.reset + "\n")
                self.at_start = True
                return
            if rest:
                self._plain(pending)
            return self._newline()
        lead = self.lead + ch
        ind = len(lead) - len(lead.lstrip(" "))
        rest = lead[ind:]
        if rest == "":
            self.lead = lead
            return
        first = rest[0]
        if first == "|":
            self.table_line, self.lead = lead, ""
            return
        self._flush_table()
        if first == "`":
            if rest == "```":
                self.in_fence = self.fence_header = True
                self.lead = ""
                return
            if set(rest) == {"`"} and len(rest) < 3:
                self.lead = lead
                return
            return self._plain(lead)
        if first == "#":
            hashes = len(rest) - len(rest.lstrip("#"))
            if hashes == len(rest):
                if hashes <= 6:
                    self.lead = lead
                    return
                return self._plain(lead)
            if rest[hashes] == " " and 1 <= hashes <= 6:
                self.lead, self.at_start = "", False
                self.w(self.s.head)
                return
            return self._plain(lead)
        if first in "-+*":
            if len(rest) == 1:
                self.lead = lead
                return
            if rest[1] == " ":
                self.lead, self.at_start = "", False
                self.w(" " * ind + "• ")
                return
            if first == "-" and set(rest) <= {"-"}:
                self.lead = lead  # 구분선일 수 있으니 줄 끝까지 본다
                return
            return self._plain(lead)
        if first == ">":
            self.lead, self.at_start, self.skip_space = "", False, True
            self.w(" " * ind + self.s.dim + "│ ")
            return
        self._plain(lead)

    def _plain(self, text):
        self.lead, self.at_start = "", False
        for ch in text:
            self._inline(ch)

    # -- 줄 안: **굵게**, `코드`, [링크](주소) --
    def _inline(self, ch):
        if self.skip_space:
            self.skip_space = False
            if ch == " ":
                return
        if self.link is not None:
            self.link += ch
            if self.LINK.fullmatch(self.link):
                text, url = self.LINK.fullmatch(self.link).groups()
                self.w(url if text == url else f"{text} ({url})")
                self.link = None
            elif len(self.link) > 300 or ("]" in self.link and "](" not in self.link and not self.link.endswith("]")):
                link, self.link = self.link, None
                self.w(link)
            return
        if self.code_span:
            if ch == "`":
                self.code_span = False
                self.w(self.s.uncode)
            else:
                self.w(ch)
            return
        if self.star:
            self.star = False
            if ch == "*":
                self.bold = not self.bold
                self.w(self.s.bold if self.bold else self.s.unbold)
                return
            self.w("*")
        if ch == "*":
            self.star = True
        elif ch == "`":
            self.code_span = True
            self.w(self.s.code)
        elif ch == "[":
            self.link = "["
        else:
            self.w(ch)

    # -- 코드 블록: 줄 단위로 모았다가 들여써서 출력 (복사하기 쉽게 왼쪽 테두리 없음) --
    def _fence_ch(self, ch):
        if self.fence_header:
            if ch == "\n":
                self.fence_header, self.fence_line = False, ""
            return
        if ch != "\n":
            self.fence_line += ch
            return
        line, self.fence_line = self.fence_line, ""
        if line.strip().startswith("```"):
            self.in_fence, self.at_start, self.lead = False, True, ""
            return
        self.w(self.s.dim + "    " + line + self.s.reset + "\n")

    # -- 표: 끝날 때까지 모았다가 열을 맞춰 출력 --
    def _flush_table(self):
        lines, self.table = self.table, []
        if not lines:
            return
        rows, header_end = [], None
        for line in lines:
            cells = [strip_inline(c) for c in line.strip().strip("|").split("|")]
            if all(re.fullmatch(r":?-{2,}:?", c.replace(" ", "")) for c in cells if c) and any(cells):
                header_end = len(rows) if header_end is None else header_end
                continue
            rows.append(cells)
        width_cols = max(len(r) for r in rows) if rows else 0
        widths = [max((display_width(r[i]) for r in rows if i < len(r)), default=0) for i in range(width_cols)]
        total = sum(widths) + 2 * max(0, width_cols - 1)
        if not rows or total > term_columns():
            self.w("\n".join(lines) + "\n")  # 너무 넓으면 원문 그대로
            return
        for n, r in enumerate(rows):
            cells = [r[i] + " " * (widths[i] - display_width(r[i])) if i < len(r) else " " * widths[i] for i in range(width_cols)]
            text = "  ".join(cells).rstrip()
            if header_end is not None and n < header_end:
                self.w(self.s.bold + text + self.s.reset + "\n")
                if n == header_end - 1:
                    self.w(self.s.dim + "─" * total + self.s.reset + "\n")
            else:
                self.w(text + "\n")


def make_renderer(cfg):
    """터미널로 직접 출력할 때만 마크다운을 변환한다. 파이프/파일로 나갈 때와 --raw 에서는 원문 그대로."""
    if cfg.get("raw") or not sys.stdout.isatty():
        return None
    color = not os.environ.get("NO_COLOR")
    if color:
        enable_ansi()
    return MdStream(sys.stdout.write, Style(color))


class Spinner:
    """응답을 기다리는 동안 움직이는 표시를 stderr 에 그린다. 답이 나오기 시작하면 지운다."""

    FRAMES = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
    current = None  # 지금 화면에 그려지고 있는 스피너 (알림이 진행 표시와 섞이지 않게 쓴다)

    def __init__(self, label, fixed=False):
        Spinner.current = self
        self.out = sys.stderr
        self.label, self.fixed = label, fixed
        self.t0 = time.time()
        self.lock = threading.Lock()
        self.done = threading.Event()
        self.width = 0
        try:
            self.FRAMES.encode(getattr(self.out, "encoding", None) or "utf-8")
            self.frames = self.FRAMES
        except (UnicodeEncodeError, LookupError):
            self.frames = "|/-\\"
        self.dim, self.reset = ("", "") if os.environ.get("NO_COLOR") else ("\033[2m", "\033[0m")
        self.thread = threading.Thread(target=self._run, daemon=True)
        self.thread.start()

    def set(self, label):
        if not self.fixed:
            self.label = label

    def _run(self):
        n = 0
        if self.done.wait(0.3):  # 바로 답이 오면 아무것도 그리지 않는다
            return
        while True:
            with self.lock:
                if self.done.is_set():
                    return
                elapsed = int(time.time() - self.t0)
                text = f"{self.frames[n % len(self.frames)]} {self.label}" + (f" ({elapsed}초)" if elapsed >= 2 else "")
                width = display_width(text)
                self.out.write("\r" + self.dim + text + self.reset + " " * max(0, self.width - width))
                self.out.flush()
                self.width = width
            n += 1
            if self.done.wait(0.1):
                return

    def stop(self):
        self.done.set()
        self.thread.join(1)
        with self.lock:
            if self.width:
                self.out.write("\r" + " " * self.width + "\r")
                self.out.flush()
                self.width = 0
        if Spinner.current is self:
            Spinner.current = None


def make_spinner(label, fixed=False):
    if TUI is not None:  # 전체 화면 모드: 상태줄에 지금 하는 일을 보여 준다
        return TuiSpinner(TUI, label, fixed)
    if not sys.stderr.isatty() or os.environ.get("EYE_NO_SPINNER"):
        return None
    if not os.environ.get("NO_COLOR"):
        enable_ansi()
    return Spinner(label, fixed)


class Heartbeat:
    """응답을 받는 동안 서버에 주기적으로 '살아 있다'는 신호를 보낸다.
    PC 전원이 갑자기 꺼지면 연결이 정상적으로 닫히지 않아 서버가 모르고 계속 생성하므로,
    이 신호가 끊기면 서버가 스스로 모델 생성을 멈춘다. 로그인(eye login)으로 쓸 때만 동작한다."""

    INTERVAL = 10

    def __init__(self, cfg):
        self.cfg = cfg
        self.rid = uuid.uuid4().hex if cfg.get("mode") == "login" else ""
        self.done = threading.Event()
        if self.rid:
            threading.Thread(target=self._run, daemon=True).start()

    def headers(self):
        return {"X-Eye-Request": self.rid} if self.rid else {}

    def _run(self):
        while not self.done.wait(self.INTERVAL):
            try:
                req = urllib.request.Request(
                    self.cfg["base"] + "/ping?rid=" + self.rid, data=b"", method="POST",
                    headers={"Authorization": "Bearer " + self.cfg["key"], "User-Agent": "eye-cli/1"})
                urllib.request.urlopen(req, timeout=5).close()
            except Exception:
                pass  # 일시적인 네트워크 문제는 다음 주기에 다시 시도한다

    def stop(self):
        self.done.set()


def chat(cfg, messages, show_think=False, tools=None, quiet=False, label=None):
    """모델에 요청해 답을 받는다. 답이 나오기 전까지는 움직이는 '기다리는 중' 표시를 보여 준다."""
    spin = make_spinner(label or "응답을 기다리는 중", fixed=bool(label))
    try:
        return _chat(cfg, messages, show_think, tools, quiet, spin)
    finally:
        if spin:
            spin.stop()


LAST_FINISH = {"reason": ""}  # 가장 최근 응답의 finish_reason (length 면 출력 길이/컨텍스트 한도에 닿아 잘린 것)


def _chat(cfg, messages, show_think, tools, quiet, spin):
    """스트리밍으로 답을 출력한다 (quiet 이면 출력하지 않음).
    (답변 텍스트, 도구 호출 목록, 중단 여부) 를 반환한다. Ctrl-C 로 중단하면 지금까지의 답을 반환.
    HTTP 오류는 ApiError 로 던진다."""
    out, think_open, calls, interrupted = [], False, {}, False
    LAST_FINISH["reason"] = ""
    render = None if quiet else make_renderer(cfg)
    body = {"model": cfg["model"], "messages": messages, "stream": True}
    if tools:
        body["tools"] = tools
    beat = Heartbeat(cfg)
    try:
        r = request(cfg, "/chat/completions", body, soft=True, headers=beat.headers())
    except BaseException:
        beat.stop()
        raise
    try:
        for raw in r:
            line = raw.decode("utf-8", errors="replace").strip()
            if not line.startswith("data:"):
                continue
            data = line[5:].strip()
            if data == "[DONE]":
                break
            try:
                choice = json.loads(data)["choices"][0]
                delta = choice["delta"]
            except (ValueError, KeyError, IndexError, TypeError):
                continue
            if choice.get("finish_reason"):
                LAST_FINISH["reason"] = choice["finish_reason"]
            if delta.get("reasoning_content") and spin:
                if show_think and not quiet:
                    spin.stop()  # 생각 과정을 화면에 직접 보여 줄 때는 표시를 끈다
                else:
                    spin.set("생각 중")
            if show_think and not quiet and delta.get("reasoning_content"):
                if not think_open:
                    sys.stderr.write("\033[2m")
                    think_open = True
                sys.stderr.write(delta["reasoning_content"])
                sys.stderr.flush()
            for part in delta.get("tool_calls") or []:
                if spin:
                    spin.set("도구 호출 준비 중")
                slot = calls.setdefault(part.get("index", len(calls)), {"id": "", "name": "", "arguments": ""})
                slot["id"] = part.get("id") or slot["id"]
                fn = part.get("function") or {}
                slot["name"] += fn.get("name") or ""
                slot["arguments"] += fn.get("arguments") or ""
            text = delta.get("content")
            if text:
                if spin:
                    spin.stop()  # 본문이 나오기 시작하면 표시를 지운다
                if think_open:
                    sys.stderr.write("\033[0m\n")
                    think_open = False
                out.append(text)
                if render:
                    render.feed(text)
                    sys.stdout.flush()
                elif not quiet:
                    sys.stdout.write(text)
                    sys.stdout.flush()
    except KeyboardInterrupt:
        note_interrupt()  # 읽기 스레드가 보낸 신호인지 장부에 기록 (요약 같은 조용한 호출 중에 온 신호도 여기서 정리된다)
        if render:
            render.finish()
            render = None
        if not quiet:
            sys.stdout.write("\n[중단됨]")
        interrupted = True
    finally:
        beat.stop()
        r.close()
        if think_open:
            sys.stderr.write("\033[0m")
    if render:
        render.finish()
    if (out or interrupted) and not quiet:
        sys.stdout.write("\n")
    ordered = [calls[k] for k in sorted(calls)]
    for n, c in enumerate(ordered):
        c["id"] = c["id"] or f"call_{n}"
    return "".join(out), [c for c in ordered if c["name"]], interrupted


WRAP_UP = ("도구 호출 횟수 한도에 도달했습니다. 더 이상 도구를 쓰지 말고, 지금까지 확인한 내용만으로 질문에 답하세요. "
           "확인하지 못한 부분이 있으면 그것이 무엇이고 무엇이 더 필요한지 알려 주세요.")


def ask_continue(steps):
    """도구 호출 한도에 닿았을 때 터미널이면 이어갈지 묻는다. 터미널이 아니면 묻지 않고 False."""
    if not (sys.stdin.isatty() and sys.stderr.isatty()):
        return False
    try:
        answer = ask_line(f"\n도구를 {steps}번 썼습니다. 계속할까요? [y/N] ").strip().lower()
    except (EOFError, KeyboardInterrupt):
        print()
        return False
    return answer in ("y", "yes")


# ---- 작업 중 입력: 대기열과 '지금 보내기' ------------------------------------------------------------------------------
# 모델이 일하는 동안에도 입력을 받는다. 그냥 입력하면 대기열에 쌓였다가 지금 작업이 끝나면 한꺼번에 전달되고,
# `/now 메시지` 는 하던 작업을 멈추고 먼저 답한 뒤 원래 작업을 이어서 한다.
URGENT_PREFIX = ("[긴급 메시지: 작업 도중 사용자가 '지금 바로 처리해 달라'며 보냈습니다. 이 메시지에 먼저 답하세요. "
                 "답한 뒤에는 중단했던 원래 작업을 이어서 하게 됩니다.]\n")
RESUME_NOTE = ("(긴급 요청 처리가 끝났습니다. 중단했던 원래 작업을 이어서 계속하세요. 이미 끝낸 부분은 반복하지 마세요. "
               "긴급 메시지가 원래 작업의 방향을 바꾸는 내용이었다면 그에 맞춰 이어가세요.)")
BUSY_HINT = ("작업 중에도 입력할 수 있습니다. 그냥 입력하면 대기열에 쌓여 작업이 끝난 뒤 한꺼번에 전달되고, "
             "/now 메시지 는 하던 작업을 멈추고 먼저 답한 뒤 이어서 계속합니다. (/queue 로 대기열 보기)")
ACTIVE_INBOX = None  # 작업 중 입력을 받고 있는 동안에만 설정된다
ACTIVE_BUSY = None   # 그때의 BusyInput (대기열 버튼이 작업을 깨울 때 쓴다)


class Inbox:
    """작업 중에 사용자가 보낸 메시지들. 스레드 사이에서 안전하게 쓴다."""

    def __init__(self):
        self.lock = threading.Lock()
        self.queued = []   # 지금 작업이 끝나면 한꺼번에 보낼 메시지
        self.urgent = []   # 지금 바로 처리해 달라고 한 메시지
        self.answers = _queue.Queue()  # 승인 질문(y/N)에 대한 답
        self.awaiting = False
        self.active = False
        self.signals_sent = self.signals_seen = 0

    def add_queued(self, text):
        with self.lock:
            self.queued.append(text)
            return len(self.queued)

    def add_urgent(self, text):
        with self.lock:
            self.urgent.append(text)

    def has_urgent(self):
        return bool(self.urgent)

    def pop_urgent(self):
        with self.lock:
            text, self.urgent = "\n\n".join(self.urgent), []
            return text

    def pop_queued(self):
        with self.lock:
            items, self.queued = self.queued, []
            return items

    def promote(self):
        with self.lock:
            moved = len(self.queued)
            self.urgent.extend(self.queued)
            self.queued = []
            return moved

    def clear(self):
        with self.lock:
            n = len(self.queued)
            self.queued = []
            return n

    def snapshot(self):
        with self.lock:
            return list(self.queued)

    def remove_at(self, n):
        """대기열의 n 번째(1부터) 메시지를 빼서 돌려준다."""
        with self.lock:
            return self.queued.pop(n - 1) if 1 <= n <= len(self.queued) else None

    def promote_one(self, n):
        """대기열의 n 번째 메시지만 지금 바로 보낼 긴급 메시지로 옮긴다."""
        with self.lock:
            if 1 <= n <= len(self.queued):
                self.urgent.append(self.queued.pop(n - 1))
                return True
            return False

    # 읽기 스레드가 메인 스레드를 깨우려고 보낸 신호(KeyboardInterrupt)를 사용자의 Ctrl-C 와 구별하기 위한 장부
    def note_signal(self):
        with self.lock:
            self.signals_sent += 1

    def consume_signal(self):
        with self.lock:
            if self.signals_sent > self.signals_seen:
                self.signals_seen += 1
                return True
            return False

    def pending_signals(self):
        return self.signals_sent - self.signals_seen


LAST_INTERRUPT_SELF = False  # 가장 최근의 KeyboardInterrupt 가 읽기 스레드가 보낸 신호였는가


def note_interrupt(inbox=None):
    """방금 받은 KeyboardInterrupt 가 입력 읽기 스레드가 보낸 신호인지 장부에서 확인하고(소비), 사용자의 Ctrl-C 면 False 를 돌려준다."""
    global LAST_INTERRUPT_SELF
    box = inbox or ACTIVE_INBOX
    LAST_INTERRUPT_SELF = bool(box) and box.consume_signal()
    return LAST_INTERRUPT_SELF


def combine_messages(items):
    """작업 중에 쌓인 메시지들을 모델에게 한 번에 보낼 하나의 메시지로 합친다."""
    if len(items) == 1:
        return items[0]
    body = "\n".join(f"{n}. {t}" for n, t in enumerate(items, 1))
    return f"작업 중에 보낸 메시지 {len(items)}개입니다. 모두 확인해서 한 번에 답해 주세요.\n\n{body}"


def parse_busy_line(line):
    """작업 중에 입력한 한 줄의 뜻. (종류, 내용): queue / now / promote / show / clear / hint"""
    text = line.strip()
    if text == "/now":
        return "promote", ""
    if text.startswith("/now "):
        return ("now", text[5:].strip()) if text[5:].strip() else ("promote", "")
    if text == "/queue":
        return "show", ""
    if text == "/queue clear":
        return "clear", ""
    if text.startswith("/") or text.startswith("!"):
        return "hint", ""
    return "queue", text


def notify(text):
    """진행 표시(스피너)와 섞이지 않게 한 줄 알림을 stderr 에 출력한다."""
    spin = Spinner.current
    if spin is not None:
        with spin.lock:
            if spin.width:
                spin.out.write("\r" + " " * spin.width + "\r")
                spin.width = 0
            spin.out.write(text + "\n")
            spin.out.flush()
    else:
        sys.stderr.write(text + "\n")
        sys.stderr.flush()


def dim(text):
    return text if os.environ.get("NO_COLOR") else f"\033[2m{text}\033[0m"


def ask_line(prompt):
    """한 줄을 묻는다. 작업 중 입력을 받는 중이면 같은 입력 채널에서 답을 받는다 (그 줄은 대기열 메시지로 처리되지 않는다)."""
    if TUI is not None:  # 전체 화면 모드: 버튼이 있는 승인 창 (그 밖의 질문은 입력창)
        return TUI.ask(prompt)
    inbox = ACTIVE_INBOX
    if inbox is None or not inbox.active:
        return input(prompt)
    while not inbox.answers.empty():
        inbox.answers.get_nowait()
    sys.stdout.write(prompt)
    sys.stdout.flush()
    inbox.awaiting = True
    try:
        while True:
            try:
                return inbox.answers.get(timeout=0.2)
            except _queue.Empty:
                continue
            except KeyboardInterrupt:
                if inbox.consume_signal():  # 읽기 스레드가 보낸 신호가 늦게 도착한 것: 무시하고 계속 기다린다
                    continue
                raise
    finally:
        inbox.awaiting = False


class LineEditor:
    """글자를 하나씩 받아 한 줄을 만든다 (윈도우 콘솔용: 이 모드에서는 줄 편집을 터미널이 해 주지 않는다). 줄이 끝나면 그 줄을 돌려준다."""

    def __init__(self, echo):
        self.echo = echo
        self.chars = []
        self.skip = False

    def text(self):
        return "".join(self.chars)

    def _erase_all(self):
        while self.chars:
            w = display_width(self.chars.pop())
            self.echo("\b" * w + " " * w + "\b" * w)

    def feed(self, ch):
        if self.skip:  # 방향키 같은 특수키는 두 글자로 들어온다: 두 번째 글자도 버린다
            self.skip = False
            return None
        if ch in ("\x00", "\xe0"):
            self.skip = True
            return None
        if ch in ("\r", "\n"):
            line = self.text()
            self.chars = []
            self.echo("\r\n")
            return line
        if ch in ("\x08", "\x7f"):
            if self.chars:
                w = display_width(self.chars.pop())
                self.echo("\b" * w + " " * w + "\b" * w)
            return None
        if ch == "\x15":  # Ctrl-U: 입력 중인 줄 지우기
            self._erase_all()
            return None
        if ch < " ":
            return None
        self.chars.append(ch)
        self.echo(ch)
        return None


class WindowsLineSource:
    """윈도우 콘솔에서 글자 단위로 입력을 읽는다 (msvcrt)."""

    def __init__(self, msvcrt):
        self.m = msvcrt
        self.editor = LineEditor(lambda s: [self.m.putwch(c) for c in s])

    def poll(self, timeout):
        lines, end = [], time.time() + timeout
        while True:
            while self.m.kbhit():
                line = self.editor.feed(self.m.getwch())
                if line is not None:
                    lines.append(line)
            if lines or time.time() >= end:
                return lines
            time.sleep(0.02)

    def leftover(self):
        return self.editor.text()

    def close(self):
        pass


class PosixLineSource:
    """리눅스/맥 터미널에서 줄 단위로 입력을 읽는다. 터미널이 줄 편집과 echo 를 해 주고, 엔터를 쳐야 데이터가 들어온다."""

    def __init__(self, fd, select_fn, read_fn):
        self.fd, self.select, self.read, self.buf = fd, select_fn, read_fn, b""

    def poll(self, timeout):
        ready, _, _ = self.select([self.fd], [], [], timeout)
        if not ready:
            return []
        data = self.read(self.fd, 4096)
        if not data:
            raise EOFError
        self.buf += data
        lines = []
        while b"\n" in self.buf:
            raw, self.buf = self.buf.split(b"\n", 1)
            lines.append(raw.decode("utf-8", errors="replace").rstrip("\r"))
        return lines

    def leftover(self):
        return ""  # 엔터를 치지 않고 입력 중이던 글자는 터미널이 가지고 있어서 다음 입력에 이어진다

    def close(self):
        pass


def make_line_source():
    """이 터미널에서 쓸 수 있는 '작업 중 입력' 읽기 방식. 터미널이 아니거나 쓸 수 없으면 None."""
    try:
        if not sys.stdin.isatty():
            return None
        if os.name == "nt":
            import msvcrt
            return WindowsLineSource(msvcrt)
        import select
        return PosixLineSource(sys.stdin.fileno(), select.select, os.read)
    except (ImportError, AttributeError, OSError, ValueError):
        return None


LINE_SOURCE_FACTORY = make_line_source


def interrupt_main_thread():
    """작업 중인 메인 스레드를 깨운다. 리눅스/맥은 진짜 신호라 네트워크 대기도 바로 풀리고, 윈도우는 다음 글자/확인 지점에서 풀린다."""
    if hasattr(signal, "pthread_kill"):
        signal.pthread_kill(threading.main_thread().ident, signal.SIGINT)
    else:
        _thread.interrupt_main()


class BusyInput:
    """작업(모델 응답, 도구 실행)이 진행되는 동안 입력을 받아 Inbox 에 넣는다."""

    def __init__(self, inbox, source=None, wake=None):
        self.inbox = inbox
        self.source = source if source is not None else LINE_SOURCE_FACTORY()
        self.wake = wake or interrupt_main_thread
        self.stop_event = threading.Event()
        self.thread = None
        self.started = False

    def start(self):
        global ACTIVE_INBOX, ACTIVE_BUSY
        if self.source is None:
            return False
        self.inbox.active, ACTIVE_INBOX, ACTIVE_BUSY = True, self.inbox, self
        self.thread = threading.Thread(target=self._run, daemon=True)
        self.thread.start()
        self.started = True
        return True

    def stop(self):
        """입력 받기를 끝낸다. 엔터를 치지 않은 채 입력 중이던 글자가 있으면 돌려준다."""
        global ACTIVE_INBOX, ACTIVE_BUSY
        if not self.started:
            return ""
        self.stop_event.set()
        self.thread.join(1.5)
        left = ""
        try:
            left = self.source.leftover()
            self.source.close()
            # 읽기 스레드가 보낸 신호가 아직 도착하지 않았다면 여기서 받아 버린다 (작업이 끝난 뒤에 엉뚱한 곳에서 터지지 않게)
            deadline = time.time() + 0.5
            while self.inbox.pending_signals() > 0 and time.time() < deadline:
                time.sleep(0.01)
        except KeyboardInterrupt:
            self.inbox.consume_signal()
        finally:
            self.inbox.active, ACTIVE_INBOX, ACTIVE_BUSY = False, None, None
        return left

    def _run(self):
        try:
            while not self.stop_event.is_set():
                try:
                    lines = self.source.poll(0.1)
                except EOFError:
                    break
                for line in lines:
                    self._handle(line)
        except Exception:
            pass

    def _wake_main(self):
        if self.stop_event.is_set():
            return
        self.inbox.note_signal()
        try:
            self.wake()
        except Exception:
            self.inbox.consume_signal()

    def notify_promoted(self):
        """대기열 메시지를 지금 보내기로 바꿨을 때(마우스 버튼): 알리고 하던 작업을 깨운다."""
        notify(dim("  ⚡ 지금 보냅니다: 하던 작업을 멈추고 먼저 답한 뒤 이어서 계속합니다."))
        self._wake_main()

    def _handle(self, line):
        inbox, line = self.inbox, line.strip()
        if not line:
            return
        if inbox.awaiting:  # 승인 질문(y/N)에 대한 답
            inbox.answers.put(line)
            return
        kind, text = parse_busy_line(line)
        if kind == "queue":
            n = inbox.add_queued(text)
            notify(dim(f"  📥 대기열에 추가했습니다 ({n}개). 지금 작업이 끝나면 한꺼번에 보냅니다. 바로 보내려면 /now"))
        elif kind == "now":
            inbox.add_urgent(text)
            notify(dim("  ⚡ 지금 보냅니다: 하던 작업을 멈추고 먼저 답한 뒤 이어서 계속합니다."))
            self._wake_main()
        elif kind == "promote":
            if inbox.promote():
                notify(dim("  ⚡ 대기 중인 메시지를 지금 보냅니다: 하던 작업을 멈추고 먼저 답한 뒤 이어서 계속합니다."))
                self._wake_main()
            else:
                notify(dim("  대기 중인 메시지가 없습니다. 보낼 내용은 /now 메시지 로 입력하세요."))
        elif kind == "show":
            with inbox.lock:
                items = list(inbox.queued)
            notify(dim("  대기열 비어 있음" if not items else "  대기열:\n" + "\n".join(f"    {n}. {t[:100]}" for n, t in enumerate(items, 1))))
        elif kind == "clear":
            notify(dim(f"  대기열 {inbox.clear()}개를 지웠습니다."))
        else:
            notify(dim("  작업 중에는 일반 메시지(대기열), /now, /queue 만 쓸 수 있습니다. 나머지 명령은 작업이 끝난 뒤에 입력하세요."))


# ---- TUI (전체 화면 모드, eye --tui) -------------------------------------------------------------------------------------
# 기존 대화 루프(repl)는 그대로 두고 입력과 출력만 이 화면으로 바꿔 끼운다: 위쪽은 대화 내용(스크롤), 아래쪽은 대기열, 상태줄, 입력창.
# 마우스: 대기열의 [지금 보내기]/[삭제], 승인 창의 버튼, 휠 스크롤. 마우스 모드를 켜면 글자 드래그 복사가 막히므로 F2 로 끌 수 있다.
CSI_RE = re.compile(r"\x1b\[[0-?]*[ -/]*[@-~]")
SGR_RE = re.compile(r"\x1b\[([0-9;]*)m")


def strip_ansi(text):
    return CSI_RE.sub("", text)


def char_width(ch):
    if unicodedata.combining(ch):
        return 0
    return 2 if unicodedata.east_asian_width(ch) in "WF" else 1


def ansi_width(text):
    """색 코드를 뺀 화면 폭 (한글 같은 전각 문자는 2칸)."""
    return sum(char_width(c) for c in strip_ansi(text) if c >= " " and c != "\x7f")


def wrap_ansi(text, width):
    """줄바꿈이 없는 한 줄을 화면 폭에 맞춰 여러 줄로 나눈다. 색(SGR)은 줄이 바뀌어도 이어지게 새 줄 앞에 다시 붙인다."""
    width = max(1, width)
    text = text.replace("\t", "    ")
    rows, cur, col, active, i, n = [], [], 0, [], 0, len(text)
    while i < n:
        m = CSI_RE.match(text, i)
        if m:
            seq = m.group(0)
            cur.append(seq)
            sgr = SGR_RE.fullmatch(seq)
            if sgr:
                if sgr.group(1) in ("", "0"):
                    active = []
                else:
                    active.append(seq)
            i = m.end()
            continue
        ch = text[i]
        i += 1
        if ch < " " or ch == "\x7f":
            continue
        w = char_width(ch)
        if col + w > width and col > 0:
            rows.append("".join(cur) + ("\033[0m" if active else ""))
            cur, col = list(active), 0
        cur.append(ch)
        col += w
    rows.append("".join(cur))
    return rows


def clip_ansi(text, width):
    """한 줄을 폭에 맞게 자른다 (넘치는 부분은 버린다)."""
    first = wrap_ansi(text, width)[0]
    return first if SGR_RE.search(first) is None or first.endswith("\033[0m") else first + "\033[0m"


class KeyParser:
    """터미널이 보내는 바이트(키 입력, 마우스, 붙여넣기)를 이벤트로 바꾼다.
    이벤트: ("text", 글자) ("key", 이름) ("mouse", 종류, 값, x, y) ("paste", 글자)"""

    NEED_MORE = object()
    CSI_KEYS = {"A": "up", "B": "down", "C": "right", "D": "left", "H": "home", "F": "end", "Z": "shift-tab"}
    TILDE_KEYS = {"1": "home", "2": "insert", "3": "delete", "4": "end", "5": "pageup", "6": "pagedown", "7": "home", "8": "end",
                  "11": "f1", "12": "f2", "13": "f3", "14": "f4", "15": "f5"}
    SS3_KEYS = {"A": "up", "B": "down", "C": "right", "D": "left", "H": "home", "F": "end", "P": "f1", "Q": "f2", "R": "f3", "S": "f4"}
    CONTROL_KEYS = {0x0D: "enter", 0x0A: "ctrl-j", 0x09: "tab", 0x7F: "backspace", 0x08: "backspace"}
    PASTE_END = b"\x1b[201~"

    def __init__(self):
        self.buf = b""
        self.decoder = codecs.getincrementaldecoder("utf-8")(errors="replace")
        self.paste = None  # 붙여넣기 중이면 지금까지 모은 글자 조각들

    def feed(self, data):
        self.buf += data
        events = []
        while self.buf:
            ev = self._next()
            if ev is KeyParser.NEED_MORE:
                break
            if ev is not None:
                events.append(ev)
        return events

    def flush(self):
        """ESC 한 글자만 들어오고 뒤가 안 오면 (ESC 키를 누른 것이므로) 그 키로 처리한다."""
        if self.buf == b"\x1b" and self.paste is None:
            self.buf = b""
            return [("key", "esc")]
        return []

    def _next(self):
        b = self.buf
        if self.paste is not None:
            idx = b.find(self.PASTE_END)
            if idx < 0:
                keep = max((k for k in range(1, min(len(b), len(self.PASTE_END)) + 1) if b.endswith(self.PASTE_END[:k])), default=0)
                self.paste.append(self.decoder.decode(b[:len(b) - keep]))
                self.buf = b[len(b) - keep:]
                return KeyParser.NEED_MORE
            self.paste.append(self.decoder.decode(b[:idx]))
            text, self.paste, self.buf = "".join(self.paste), None, b[idx + len(self.PASTE_END):]
            return ("paste", text)
        c = b[0]
        if c == 0x1B:
            if len(b) == 1:
                return KeyParser.NEED_MORE
            nxt = b[1]
            if nxt == 0x5B:  # ESC [ : CSI
                j = 2
                while j < len(b) and not (0x40 <= b[j] <= 0x7E):
                    j += 1
                if j >= len(b):
                    return KeyParser.NEED_MORE
                params, final = b[2:j].decode("ascii", "ignore"), chr(b[j])
                if final == "M" and params == "":  # 예전 방식 마우스(ESC [ M 뒤에 3바이트): 쓰지 않으니 버린다
                    if len(b) < j + 4:
                        return KeyParser.NEED_MORE
                    self.buf = b[j + 4:]
                    return None
                self.buf = b[j + 1:]
                return self._csi(params, final)
            if nxt == 0x4F:  # ESC O : SS3
                if len(b) < 3:
                    return KeyParser.NEED_MORE
                key = self.SS3_KEYS.get(chr(b[2]))
                self.buf = b[3:]
                return ("key", key) if key else None
            self.buf = b[2:]  # Alt + 키
            if nxt == 0x0D:
                return ("key", "alt-enter")
            if nxt == 0x7F:
                return ("key", "alt-backspace")
            if 0x20 <= nxt < 0x7F:
                return ("key", "alt-" + chr(nxt))
            return ("key", "esc")
        if c < 0x20 or c == 0x7F:
            self.buf = b[1:]
            return ("key", self.CONTROL_KEYS.get(c) or "ctrl-" + chr(c + 96))
        j = 0
        while j < len(b) and b[j] >= 0x20 and b[j] != 0x7F:
            j += 1
        chunk, self.buf = b[:j], b[j:]
        text = self.decoder.decode(chunk)  # 글자가 중간에 끊겨 들어오면 디코더가 다음 바이트를 기다린다
        return ("text", text) if text else None

    def _csi(self, params, final):
        if params.startswith("<") and final in "Mm":  # SGR 마우스: ESC [ < 버튼 ; x ; y M(누름) / m(뗌)
            try:
                btn, x, y = (int(p) for p in params[1:].split(";"))
            except ValueError:
                return None
            if btn & 64:  # 휠: 64 위로, 65 아래로
                return ("mouse", "wheel", "up" if (btn & 1) == 0 else "down", x, y)
            if btn & 32:  # 마우스를 움직이는 중: 쓰지 않는다
                return None
            return ("mouse", "press" if final == "M" else "release", btn & 3, x, y)
        mod = params.split(";")[1] if ";" in params else ""
        prefix = "ctrl-" if mod in ("5", "6") else "alt-" if mod in ("3", "4") else ""
        if final == "~":
            if params == "200":
                self.paste = []
                return None
            key = self.TILDE_KEYS.get(params.split(";")[0])
            return ("key", prefix + key) if key else None
        key = self.CSI_KEYS.get(final)
        return ("key", prefix + key) if key else None


SLASH_COMMANDS = ["/help", "/model", "/models", "/usage", "/reset", "/compact", "/files", "/commands", "/queue", "/now", "/mouse", "/exit"]


class InputEditor:
    """입력창의 편집 상태 (여러 줄, 커서 이동, 기록, 슬래시 명령 탭 완성)."""

    def __init__(self):
        self.text, self.pos = "", 0
        self.history, self.hist, self.draft = [], None, ""
        self.completion = None

    def clear(self):
        self.text, self.pos, self.hist, self.completion = "", 0, None, None

    def insert(self, s):
        s = s.replace("\r\n", "\n").replace("\r", "\n")
        s = "".join(c for c in s if c == "\n" or c == "\t" or c >= " ")
        self.text = self.text[:self.pos] + s + self.text[self.pos:]
        self.pos += len(s)
        self.hist = self.completion = None

    def _line_bounds(self):
        start = self.text.rfind("\n", 0, self.pos) + 1
        end = self.text.find("\n", self.pos)
        return start, (len(self.text) if end < 0 else end)

    def _word_start(self):
        i = self.pos
        while i > 0 and self.text[i - 1].isspace():
            i -= 1
        while i > 0 and not self.text[i - 1].isspace():
            i -= 1
        return i

    def key(self, name):
        """키 하나를 처리한다. 엔터로 입력이 끝나면 ("submit", 글자) 를 돌려준다."""
        if name != "tab":
            self.completion = None
        if name == "enter":
            if self.text.endswith("\\") and not self.text.endswith("\\\\"):  # 줄 끝의 \ 는 다음 줄로 이어 쓰기 (기존 방식과 같다)
                self.text, self.pos = self.text[:-1], len(self.text) - 1
                self.insert("\n")
                return None
            text = self.text
            if text.strip() and (not self.history or self.history[-1] != text):
                self.history.append(text)
                del self.history[:-200]
            self.clear()
            return ("submit", text)
        if name in ("alt-enter", "ctrl-j"):
            self.insert("\n")
        elif name == "backspace":
            if self.pos > 0:
                self.text, self.pos = self.text[:self.pos - 1] + self.text[self.pos:], self.pos - 1
        elif name == "delete":
            self.text = self.text[:self.pos] + self.text[self.pos + 1:]
        elif name == "left":
            self.pos = max(0, self.pos - 1)
        elif name == "right":
            self.pos = min(len(self.text), self.pos + 1)
        elif name in ("ctrl-left", "alt-b"):
            self.pos = self._word_start()
        elif name in ("ctrl-right", "alt-f"):
            i = self.pos
            while i < len(self.text) and self.text[i].isspace():
                i += 1
            while i < len(self.text) and not self.text[i].isspace():
                i += 1
            self.pos = i
        elif name in ("home", "ctrl-a"):
            self.pos = self._line_bounds()[0]
        elif name in ("end", "ctrl-e"):
            self.pos = self._line_bounds()[1]
        elif name == "ctrl-u":
            start = self._line_bounds()[0]
            self.text, self.pos = self.text[:start] + self.text[self.pos:], start
        elif name == "ctrl-k":
            self.text = self.text[:self.pos] + self.text[self._line_bounds()[1]:]
        elif name in ("ctrl-w", "alt-backspace"):
            start = self._word_start()
            self.text, self.pos = self.text[:start] + self.text[self.pos:], start
        elif name == "up":
            self._vertical(-1)
        elif name == "down":
            self._vertical(1)
        elif name == "tab":
            self._complete()
        return None

    def _vertical(self, step):
        start, end = self._line_bounds()
        col = self.pos - start
        if step < 0 and start > 0:  # 윗줄로
            pstart = self.text.rfind("\n", 0, start - 1) + 1
            self.pos = min(pstart + col, start - 1)
        elif step > 0 and end < len(self.text):  # 아랫줄로
            nend = self.text.find("\n", end + 1)
            nend = len(self.text) if nend < 0 else nend
            self.pos = min(end + 1 + col, nend)
        else:  # 맨 위/아래 줄이면 입력 기록을 넘긴다
            self._history(step)

    def _history(self, step):
        if not self.history:
            return
        if self.hist is None:
            if step > 0:
                return
            self.draft, self.hist = self.text, len(self.history)
        idx = self.hist + step
        if idx < 0:
            return
        if idx >= len(self.history):
            self.text, self.hist = self.draft, None
        else:
            self.text, self.hist = self.history[idx], idx
        self.pos = len(self.text)

    def _complete(self):
        if self.completion is None:
            if not self.text.startswith("/") or " " in self.text or "\n" in self.text:
                return
            matches = [c for c in SLASH_COMMANDS if c.startswith(self.text)]
            if not matches:
                return
            self.completion = [matches, 0]
        else:
            self.completion[1] = (self.completion[1] + 1) % len(self.completion[0])
        self.text = self.completion[0][self.completion[1]]
        self.pos = len(self.text)

    def layout(self, width, prompt, max_rows=6, placeholder=""):
        """(입력창에 그릴 줄들, 커서 (줄, 칸), 전체 줄 수). 첫 줄 앞에는 프롬프트, 이어지는 줄은 같은 폭만큼 들여쓴다."""
        pw = ansi_width(prompt)
        avail = max(1, width - pw)
        rows, row, col, cursor = [], [], 0, None
        for i in range(len(self.text) + 1):
            ch = self.text[i] if i < len(self.text) else ""
            w = char_width(ch) if ch and ch != "\n" else 0
            wraps = bool(ch) and ch != "\n" and col + w > avail and col > 0
            if wraps:
                rows.append("".join(row)); row, col = [], 0
            if i == self.pos:
                cursor = (len(rows), col)
            if not ch:
                break
            if ch == "\n":
                rows.append("".join(row)); row, col = [], 0
                continue
            row.append(ch if ch != "\t" else "    ")
            col += w
        if col >= avail and cursor == (len(rows), col):  # 줄이 꽉 찬 끝에 커서가 있으면 다음 줄로 넘긴다
            rows.append("".join(row)); row, col = [], 0
            cursor = (len(rows), 0)
        rows.append("".join(row))
        total = len(rows)
        out = [(prompt if n == 0 else " " * pw) + r for n, r in enumerate(rows)]
        if not self.text and placeholder:
            out[0] += "\033[2m" + clip_ansi(placeholder, max(1, avail)) + "\033[0m"
        crow, ccol = cursor
        if total > max_rows:  # 너무 길면 커서가 보이는 부분만
            top = max(0, min(crow - max_rows + 1, total - max_rows))
            out, crow = out[top:top + max_rows], crow - top
        return out, (crow, pw + ccol), total


TUI = None  # 켜져 있는 Tui 객체 (전체 화면 모드가 아니면 None)
SPIN_FRAMES = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
MOUSE_ON = "\033[?1000h\033[?1006h"
MOUSE_OFF = "\033[?1006l\033[?1000l"


def tui_debug(msg):
    path = os.environ.get("EYE_TUI_DEBUG")
    if path:
        try:
            with open(path, "a", encoding="utf-8") as f:
                f.write(f"{time.strftime('%H:%M:%S')} {msg}\n")
        except OSError:
            pass


class RowBuilder:
    """화면의 한 줄을 조립한다. 클릭할 수 있는 조각(버튼)은 칸 범위와 동작을 기록해 둔다."""

    def __init__(self, width):
        self.width, self.parts, self.col, self.zones = width, [], 0, []

    def add(self, text, action=None):
        room = self.width - self.col
        if room <= 0 or not text:
            return self
        if ansi_width(text) > room:
            text = clip_ansi(text, room)
        w = ansi_width(text)
        if action is not None and w:
            self.zones.append((self.col, self.col + w, action))
        self.parts.append(text)
        self.col += w
        return self

    def fill_to(self, col, ch=" ", style=""):
        if col > self.col:
            self.add(style + ch * (col - self.col) + ("\033[0m" if style else ""))
        return self

    def result(self):
        return "".join(self.parts) + "\033[0m"


class TuiStream:
    """sys.stdout / sys.stderr 대신 쓰는 출력: 글자를 화면의 대화 영역에 쌓는다."""
    encoding = "utf-8"
    errors = "replace"

    def __init__(self, tui):
        self.tui = tui

    def write(self, s):
        self.tui.append_text(s)
        return len(s)

    def flush(self):
        pass

    def isatty(self):
        return True

    def fileno(self):
        raise OSError("TUI stream has no file descriptor")

    def reconfigure(self, **kw):
        pass


class TuiLineSource:
    """작업 중 입력(BusyInput)이 TUI 입력창에서 엔터로 보낸 줄들을 받아 가는 통로."""

    def __init__(self, tui):
        self.tui = tui

    def poll(self, timeout):
        lines = []
        try:
            first = self.tui.submitted.get(timeout=timeout)
            lines.append(first)
            while True:
                lines.append(self.tui.submitted.get_nowait())
        except _queue.Empty:
            pass
        return [l for l in lines if l is not None]

    def leftover(self):
        return ""  # 입력창이 글자를 그대로 가지고 있어서 따로 넘길 것이 없다

    def close(self):
        pass


class TuiSpinner:
    """TUI 에서는 스피너를 따로 그리지 않고 상태줄에 지금 하는 일을 보여 준다."""

    def __init__(self, tui, label, fixed=False):
        self.tui, self.fixed = tui, fixed
        tui.set_working(label)

    def set(self, label):
        if not self.fixed:
            self.tui.set_working(label, keep_time=True)

    def stop(self):
        self.tui.clear_working()


class PosixTerminal:
    def __init__(self):
        import termios
        import tty
        self.termios, self.tty = termios, tty
        self.fd = sys.stdin.fileno()
        self.saved = None

    def setup(self):
        self.saved = self.termios.tcgetattr(self.fd)
        self.tty.setraw(self.fd)  # Ctrl-C 도 글자(0x03)로 들어온다: 우리가 직접 처리한다

    def teardown(self):
        if self.saved is not None:
            self.termios.tcsetattr(self.fd, self.termios.TCSADRAIN, self.saved)

    def read(self):
        return os.read(self.fd, 4096)

    def write(self, s):
        sys.__stdout__.write(s)
        sys.__stdout__.flush()

    def size(self):
        sz = shutil.get_terminal_size((80, 24))
        return sz.columns, sz.lines


class WindowsTerminal:
    """윈도우 콘솔(Windows Terminal, conhost): 가상 터미널 입력/출력 모드를 켜서 방향키와 마우스를 VT 코드로 받는다."""

    def __init__(self):
        import ctypes
        import msvcrt
        self.ctypes, self.msvcrt = ctypes, msvcrt
        self.k = ctypes.windll.kernel32
        self.k.GetStdHandle.restype = ctypes.c_void_p
        for fn in (self.k.GetConsoleMode, self.k.SetConsoleMode):
            fn.argtypes = [ctypes.c_void_p, ctypes.c_void_p] if fn is self.k.GetConsoleMode else [ctypes.c_void_p, ctypes.c_ulong]
        self.saved = None

    def _mode(self, handle):
        mode = self.ctypes.c_ulong()
        if not self.k.GetConsoleMode(handle, self.ctypes.byref(mode)):
            raise OSError("not a console")
        return mode.value

    def setup(self):
        self.hin, self.hout = self.k.GetStdHandle(-10), self.k.GetStdHandle(-11)
        self.saved = (self._mode(self.hin), self._mode(self.hout), self.k.GetConsoleCP(), self.k.GetConsoleOutputCP())
        # 입력: 가상 터미널 입력(0x200) + 확장 플래그(0x80). 줄 입력(0x2), 에코(0x4), 처리된 입력(0x1, Ctrl-C), 빠른 편집(0x40) 은 끈다
        self.k.SetConsoleMode(self.hin, (self.saved[0] | 0x0200 | 0x0080) & ~(0x0001 | 0x0002 | 0x0004 | 0x0040))
        self.k.SetConsoleMode(self.hout, self.saved[1] | 0x0001 | 0x0004)
        self.k.SetConsoleCP(65001)
        self.k.SetConsoleOutputCP(65001)
        self.msvcrt.setmode(0, os.O_BINARY)

    def teardown(self):
        if self.saved is not None:
            self.k.SetConsoleMode(self.hin, self.saved[0])
            self.k.SetConsoleMode(self.hout, self.saved[1])
            self.k.SetConsoleCP(self.saved[2])
            self.k.SetConsoleOutputCP(self.saved[3])

    def read(self):
        return os.read(0, 4096)

    def write(self, s):
        sys.__stdout__.write(s)
        sys.__stdout__.flush()

    def size(self):
        sz = shutil.get_terminal_size((80, 24))
        return sz.columns, sz.lines


def make_terminal():
    """전체 화면 모드를 쓸 수 있는 터미널이면 그 제어 객체, 아니면 None."""
    try:
        if not (sys.stdin.isatty() and sys.__stdout__.isatty()):
            return None
        return WindowsTerminal() if os.name == "nt" else PosixTerminal()
    except Exception:
        return None


class Tui:
    MAX_LINES = 6000
    MIN_TRANSCRIPT = 3

    def __init__(self, terminal, cfg=None):
        self.term = terminal
        self.cfg = cfg or {}
        self.lock = threading.RLock()
        self.width, self.height = terminal.size()
        self.lines, self.wrapped, self.partial = [], [], ""
        self.total = 0                  # 화면 폭으로 줄바꿈한 전체 줄 수 (진행 중인 줄 포함)
        self.scroll = 0                 # 맨 아래에서 몇 줄 위를 보고 있는가 (0 = 최신)
        self.view_height = max(1, self.height - 4)
        self.editor, self.parser = InputEditor(), KeyParser()
        self.submitted = _queue.Queue()  # 입력창에서 엔터로 보낸 줄들 (None = 입력 끝)
        self.prompt, self.idle = "", False
        self.working = None             # (설명, 시작 시각)
        self.modal = None               # 승인 창 {"text", "choices", "answers"}
        self.mouse = True
        self.inbox = None
        self.zones, self.prev_rows, self.force_full, self.dirty = [], [], True, True
        self.stop_event = threading.Event()
        self.threads = []
        self.saved_streams = None

    # ---------- 대화 내용 ----------
    def _rewrap(self):
        self.wrapped = [wrap_ansi(l, self.width) for l in self.lines]
        self.total = sum(len(w) for w in self.wrapped) + self._partial_rows()
        self.scroll = min(self.scroll, max(0, self.total - self.view_height))

    def _partial_rows(self):
        return len(wrap_ansi(self.partial, self.width)) if self.partial else 0

    def append_text(self, text):
        if not text:
            return
        with self.lock:
            before = self.total
            parts = text.replace("\r\n", "\n").split("\n")
            for k, seg in enumerate(parts):
                if "\r" in seg:  # 같은 줄에 덮어쓰는 출력: 지금까지의 미완성 줄을 버린다
                    self.partial, seg = "", seg.rsplit("\r", 1)[1]
                self.partial += seg
                if k < len(parts) - 1:
                    rows = wrap_ansi(self.partial, self.width)
                    self.lines.append(self.partial)
                    self.wrapped.append(rows)
                    self.partial = ""
            if len(self.lines) > self.MAX_LINES:
                drop = len(self.lines) - self.MAX_LINES + 1000
                del self.lines[:drop], self.wrapped[:drop]
            self.total = sum(len(w) for w in self.wrapped) + self._partial_rows()
            if self.scroll > 0:  # 위를 보는 중이면 화면이 밀리지 않게 새로 늘어난 만큼 같이 올린다
                self.scroll += max(0, self.total - before)
            self.dirty = True

    def view_rows(self, count):
        """대화 영역에 보일 count 줄 (scroll 만큼 위에서부터)."""
        need = self.scroll + count
        got = list(reversed(wrap_ansi(self.partial, self.width))) if self.partial else []
        i = len(self.wrapped) - 1
        while len(got) < need and i >= 0:
            got.extend(reversed(self.wrapped[i]))
            i -= 1
        got.reverse()
        end = len(got) - self.scroll
        rows = got[max(0, end - count):end]
        return rows + [""] * (count - len(rows))

    def _scroll(self, delta):
        with self.lock:
            self.scroll = max(0, min(self.scroll + delta, max(0, self.total - self.view_height)))
            self.dirty = True

    # ---------- 상태 ----------
    def set_working(self, label, keep_time=False):
        with self.lock:
            t0 = self.working[1] if (keep_time and self.working) else time.time()
            self.working, self.dirty = (label, t0), True

    def clear_working(self):
        with self.lock:
            self.working, self.dirty = None, True

    def set_mouse(self, on):
        with self.lock:
            self.mouse = bool(on)
            self.term.write(MOUSE_ON if self.mouse else MOUSE_OFF)
            self.dirty = True

    # ---------- 화면 만들기 ----------
    def _header(self, W):
        left = f" eye {VERSION} · {self.cfg.get('model', '')} · {short_cwd()}"
        right = f"F2 마우스 {'켬' if self.mouse else '끔'} · /help "
        left = clip_ansi(left, max(1, W - ansi_width(right) - 1))  # 폴더 경로가 길어도 오른쪽 안내가 밀려나지 않게
        rb = RowBuilder(W)
        rb.add("\033[7m" + left)
        rb.fill_to(W - ansi_width(right), " ", "\033[7m")
        rb.add("\033[7m" + right)
        return rb.fill_to(W, " ", "\033[7m").result()

    def _modal_rows(self, W):
        m, rows = self.modal, []
        rb = RowBuilder(W)
        rb.add("\033[7m ⚠ 확인이 필요합니다").fill_to(W, " ", "\033[7m")
        rows.append((rb.result(), []))
        body = []
        for para in m["text"].split("\n"):
            body.extend(wrap_ansi(para, max(1, W - 2)))
        for line in body[:8]:
            rows.append((" " + line + "\033[0m", []))
        rb = RowBuilder(W)
        rb.add(" ")
        for key, label in m["choices"]:
            rb.add(f"\033[7m [{key}] {label} \033[0m", ("answer", key)).add("  ")
        rb.add("\033[2m(키보드로 y / a / n 을 눌러도 됩니다)\033[0m")
        rows.append((rb.result(), rb.zones))
        return rows

    def _queue_rows(self, W):
        items = self.inbox.snapshot() if self.inbox else []
        if not items:
            return []
        rows = []
        rb = RowBuilder(W)
        rb.add(f"\033[1m 📥 대기열 {len(items)}개\033[0m\033[2m · 작업이 끝나면 한꺼번에 전달\033[0m  ")
        rb.add("\033[7m 전체 지금 보내기 \033[0m", ("send_all",)).add(" ").add("\033[7m 전체 삭제 \033[0m", ("clear",))
        rows.append((rb.result(), rb.zones))
        for n, text in enumerate(items[:4], 1):
            send, delete = "\033[7m 지금 보내기 \033[0m", "\033[7m 삭제 \033[0m"
            btn_w = ansi_width(send) + 1 + ansi_width(delete) + 1
            rb = RowBuilder(W)
            label = f" {n}. " + " ".join(text.split())
            rb.add(clip_ansi(label, max(1, W - btn_w - 1)))
            rb.fill_to(W - btn_w)
            rb.add(send, ("send_now", n, text)).add(" ").add(delete, ("delete", n, text))
            rows.append((rb.result(), rb.zones))
        if len(items) > 4:
            rows.append((f"\033[2m    …외 {len(items) - 4}개 (/queue)\033[0m", []))
        return rows

    def _status_row(self, W):
        rb = RowBuilder(W)
        if self.working:
            label, t0 = self.working
            elapsed = int(time.time() - t0)
            frame = SPIN_FRAMES[int(time.time() * 10) % len(SPIN_FRAMES)]
            rb.add(f"\033[36m {frame} {label}" + (f" ({elapsed}초)" if elapsed >= 2 else "") + "\033[0m")
        elif self.idle:
            rb.add("\033[2m 입력 대기 중\033[0m")
        else:
            rb.add("\033[2m 처리 중…\033[0m")
        if self.scroll > 0:
            rb.add("  ").add("\033[7m ↓ 맨 아래로 \033[0m", ("scroll_bottom",))
        right = "PgUp/PgDn 스크롤 · Ctrl-C 중단 · Ctrl-D 종료 "
        rb.fill_to(max(rb.col, W - ansi_width(right)), "─", "\033[2m")
        rb.add("\033[2m" + right + "\033[0m")
        return rb.result(), rb.zones

    def build_frame(self):
        """(줄 목록, 커서 위치, 클릭 영역들). 화면에 그리는 일과 분리해 두어 시험할 수 있다."""
        with self.lock:
            W, H = self.width, self.height
            modal = self._modal_rows(W) if self.modal else []
            queue = [] if self.modal else self._queue_rows(W)
            placeholder = "" if self.idle else "작업 중에도 입력할 수 있습니다 — 엔터: 대기열에 추가, /now 메시지: 지금 바로 보내기"
            prompt = self.prompt if self.idle else "\033[2m… \033[0m"
            input_rows, (crow, ccol), _ = self.editor.layout(W, prompt, max_rows=6, placeholder=placeholder)
            input_rows = [clip_ansi(r, W) for r in input_rows]
            footer = modal + queue + [self._status_row(W)]
            avail = H - 1 - self.MIN_TRANSCRIPT  # 대화 영역에 최소한 남겨야 하는 줄을 뺀, 아래 영역이 쓸 수 있는 줄 수
            while len(footer) + len(input_rows) > avail and len(footer) > 1:  # 좁은 화면: 대기열/승인 창의 윗줄부터 줄인다
                footer.pop(0)
            if len(footer) + len(input_rows) > avail:  # 그래도 넘치면 입력창을 커서 근처만 보여 준다
                keep = max(1, avail - len(footer))
                top = max(0, min(crow - keep + 1, len(input_rows) - keep))
                input_rows, crow = input_rows[top:top + keep], crow - top
            th = max(1, H - 1 - len(footer) - len(input_rows))
            self.view_height = th
            self.scroll = max(0, min(self.scroll, max(0, self.total - th)))
            rows = [self._header(W)] + [r + "\033[0m" for r in self.view_rows(th)]
            zones = []
            for text, zs in footer:
                for c0, c1, action in zs:
                    zones.append((len(rows), c0, c1, action))
                rows.append(text)
            input_top = len(rows)
            rows.extend(r + "\033[0m" for r in input_rows)
            rows = (rows + [""] * H)[:H]
            cursor = None if self.modal else (min(H - 1, input_top + crow), min(W - 1, ccol))
            self.zones = zones
            return rows, cursor, zones

    def snapshot_text(self):
        rows, cursor, _ = self.build_frame()
        return "\n".join(strip_ansi(r).rstrip() for r in rows)

    # ---------- 그리기 ----------
    def draw(self):
        rows, cursor, _ = self.build_frame()
        out = ["\033[?25l"]
        if self.force_full or len(self.prev_rows) != len(rows):
            out.append("\033[2J")
            self.prev_rows = [None] * len(rows)
            self.force_full = False
        for r, row in enumerate(rows):
            if self.prev_rows[r] != row:
                out.append(f"\033[{r + 1};1H{row}\033[K")
        self.prev_rows = rows
        if cursor:
            out.append(f"\033[{cursor[0] + 1};{cursor[1] + 1}H\033[?25h")
        self.term.write("".join(out))

    def tick(self):
        """한 번치 화면 갱신: 터미널 크기가 바뀌었으면 다시 줄바꿈하고, 바뀐 것이 있으면(또는 진행 표시가 움직이는 중이면) 다시 그린다."""
        size = self.term.size()
        with self.lock:
            if size != (self.width, self.height):
                self.width, self.height = size
                self._rewrap()
                self.force_full = True
                self.dirty = True
            need = self.dirty or self.working is not None
            self.dirty = False
        if need:
            self.draw()

    def _render_loop(self):
        while not self.stop_event.is_set():
            try:
                self.tick()
            except Exception as e:
                tui_debug(f"render: {e!r}")
            self.stop_event.wait(0.05)

    # ---------- 입력 ----------
    def _read_loop(self):
        while not self.stop_event.is_set():
            try:
                data = self.term.read()
            except Exception as e:
                tui_debug(f"read: {e!r}")
                break
            if not data:
                self.submitted.put(None)
                break
            self.feed(data)

    def feed(self, data):
        if isinstance(data, str):
            data = data.encode("utf-8")
        for ev in self.parser.feed(data):
            self._handle(ev)
        if self.parser.buf == b"\x1b":  # ESC 한 글자: 뒤따르는 글자가 없는지 잠깐 기다렸다가 ESC 키로 처리
            threading.Timer(0.06, self._flush_esc).start()

    def _flush_esc(self):
        for ev in self.parser.flush():
            self._handle(ev)

    def _handle(self, ev):
        try:
            kind = ev[0]
            if kind == "text":
                self._on_text(ev[1])
            elif kind == "paste":
                with self.lock:
                    if not self.modal:
                        self.editor.insert(ev[1])
                    self.dirty = True
            elif kind == "key":
                self._on_key(ev[1])
            elif kind == "mouse":
                self._on_mouse(ev)
        except Exception as e:
            tui_debug(f"event {ev!r}: {e!r}")

    def _answer(self, key):
        with self.lock:
            m = self.modal
        if m:
            m["answers"].put(key)

    def _on_text(self, s):
        with self.lock:
            if self.modal:
                for ch in s.lower():
                    if ch in [k for k, _ in self.modal["choices"]]:
                        self.modal["answers"].put(ch)
                        break
                return
            self.editor.insert(s)
            self.dirty = True

    def _on_key(self, name):
        if name == "ctrl-c":
            with self.lock:
                if self.idle and self.editor.text:  # 입력하던 글자가 있으면 그것만 지운다 (셸과 같다)
                    self.editor.clear()
                    self.dirty = True
                    return
            interrupt_main_thread()
            return
        with self.lock:
            if self.modal:
                if name in ("enter", "esc"):
                    self.modal["answers"].put("n")
                return
            if name == "ctrl-d":
                if not self.editor.text:
                    self.submitted.put(None)
                else:
                    self.editor.key("delete")
            elif name == "f2":
                self.set_mouse(not self.mouse)
            elif name == "ctrl-l":
                self.force_full = True
            elif name == "pageup":
                self._scroll(max(1, self.view_height - 2))
            elif name == "pagedown":
                self._scroll(-max(1, self.view_height - 2))
            else:
                res = self.editor.key(name)
                if res:
                    self.submitted.put(res[1])
            self.dirty = True

    def _on_mouse(self, ev):
        _, kind, val, x, y = ev
        if kind == "wheel":
            self._scroll(3 if val == "up" else -3)
        elif kind == "press" and val == 0:
            with self.lock:
                hit = next((z[3] for z in self.zones if z[0] == y - 1 and z[1] <= x - 1 < z[2]), None)
            if hit:
                self.run_action(hit)

    def run_action(self, action):
        kind = action[0]
        inbox = self.inbox
        if kind == "answer":
            self._answer(action[1])
        elif kind == "scroll_bottom":
            with self.lock:
                self.scroll, self.dirty = 0, True
        elif kind == "delete" and inbox:
            if inbox.snapshot()[action[1] - 1:action[1]] == [action[2]]:
                inbox.remove_at(action[1])
        elif kind == "clear" and inbox:
            inbox.clear()
        elif kind in ("send_now", "send_all") and inbox:
            busy = ACTIVE_BUSY
            if kind == "send_now":
                if inbox.snapshot()[action[1] - 1:action[1]] != [action[2]]:
                    return  # 그 사이에 대기열이 바뀌었다
                if busy is not None:
                    inbox.promote_one(action[1])
                    busy.notify_promoted()
                else:  # 작업이 끝나 대기열이 멈춰 있을 때: 그 메시지를 지금 보낸다
                    self.submitted.put(inbox.remove_at(action[1]))
            else:
                if busy is not None:
                    if inbox.promote():
                        busy.notify_promoted()
                else:
                    items = inbox.pop_queued()
                    if items:
                        self.submitted.put(combine_messages(items))
        with self.lock:
            self.dirty = True

    # ---------- eye 와 연결 ----------
    def input(self, prompt=""):
        """input() 대신 쓴다: 입력창에 프롬프트를 띄우고 엔터가 올 때까지 기다린다."""
        plain = prompt.replace("\001", "").replace("\002", "").lstrip("\n")
        with self.lock:
            self.prompt, self.idle, self.dirty = plain, True, True
        try:
            while True:
                try:
                    line = self.submitted.get(timeout=0.2)
                except _queue.Empty:
                    continue
                if line is None:
                    raise EOFError
                self.append_text(plain + line.replace("\n", "\n" + " " * ansi_width(plain)) + "\n")
                return line
        except KeyboardInterrupt:
            with self.lock:
                self.editor.clear()
            raise
        finally:
            with self.lock:
                self.idle, self.prompt, self.dirty = False, "", True

    def ask(self, prompt):
        """y/N/a 확인 질문을 버튼이 있는 승인 창으로 보여 주고 y / a / n 중 하나를 돌려준다. 그 밖의 질문은 입력창으로 받는다."""
        text = prompt.strip("\n")
        m = re.search(r"\[(y/N[^\]]*)\]\s*$", text)
        if not m:
            return self.input(prompt)
        body, opts = text[:m.start()].rstrip(), m.group(1)
        if "적용할까요" in body:
            choices = [("y", "적용"), ("a", "이번 실행 동안 모두 자동 승인"), ("n", "거절")]
        elif "실행할까요" in body:
            choices = [("y", "실행"), ("a", "이번 실행 동안 모두 자동 승인"), ("n", "거절")]
        elif "계속할까요" in body:
            choices = [("y", "계속"), ("n", "멈추고 정리")]
        else:
            choices = [("y", "예"), ("n", "아니오")]
        if "a=" not in opts:
            choices = [c for c in choices if c[0] != "a"]
        answers = _queue.Queue()
        with self.lock:
            self.modal, self.dirty = {"text": body, "choices": choices, "answers": answers}, True
        try:
            while True:
                try:
                    key = answers.get(timeout=0.2)
                    break
                except _queue.Empty:
                    continue
        finally:
            with self.lock:
                self.modal, self.dirty = None, True
        label = dict(choices).get(key, key)
        self.append_text(f"\033[2m  {'✔' if key != 'n' else '✖'} {label}\033[0m\n")
        return key

    def start(self):
        self.term.setup()
        self.term.write("\033[?1049h\033[?2004h" + (MOUSE_ON if self.mouse else ""))
        self.force_full = True
        for fn in (self._read_loop, self._render_loop):
            t = threading.Thread(target=fn, daemon=True)
            t.start()
            self.threads.append(t)

    def stop(self):
        self.stop_event.set()
        try:
            self.term.write(MOUSE_OFF + "\033[?2004l\033[?25h\033[0m\033[?1049l")
        finally:
            self.term.teardown()

    def running(self):
        tui = self

        class Ctx:
            def __enter__(self_):
                global TUI, LINE_SOURCE_FACTORY
                tui.saved_streams = (sys.stdout, sys.stderr, builtins.input, LINE_SOURCE_FACTORY)
                tui.start()
                TUI = tui
                sys.stdout, sys.stderr = TuiStream(tui), TuiStream(tui)
                builtins.input = tui.input
                LINE_SOURCE_FACTORY = lambda: TuiLineSource(tui)
                return tui

            def __exit__(self_, *exc):
                global TUI, LINE_SOURCE_FACTORY
                sys.stdout, sys.stderr, builtins.input, LINE_SOURCE_FACTORY = tui.saved_streams
                TUI = None
                tui.stop()
                return False
        return Ctx()


def run_tui(cfg, show_think, ws, session, explicit=False):
    """전체 화면(TUI)으로 대화를 연다. 쓸 수 없는 터미널이면 기존 방식으로 연다 (기본값으로 켜진 경우에는 조용히, --tui 로 직접 켰으면 안내와 함께)."""
    term = make_terminal()
    if term is None or min(term.size()) < 10 or term.size()[0] < 40:
        if explicit:
            print("eye: 이 터미널에서는 전체 화면 모드(--tui)를 쓸 수 없어 기존 방식으로 엽니다. (터미널 크기 40x10 이상, 진짜 터미널이 필요)")
        return repl(cfg, show_think, ws, session)
    tui = Tui(term, cfg)
    try:
        with tui.running():
            repl(cfg, show_think, ws, session)
    finally:
        print("eye 를 종료했습니다. 이 폴더의 대화는 `eye -c` 로 이어갈 수 있습니다.")


def term_columns():
    return TUI.width if TUI is not None else shutil.get_terminal_size((80, 24)).columns


STUCK_REPEATS = 3  # 같은 도구 호출을 이만큼 연속으로 실행한 뒤에는 같은 호출을 더 실행하지 않는다 (결과가 같을 뿐이라 반복만 낭비)
STUCK_LIMIT = 3    # 막힌 호출이 이만큼 연속으로 이어지면 도구를 끄고 지금까지의 내용으로 답하게 한다
TRUNC_LIMIT = 3    # 도구 인자가 잘린 응답이 이만큼 연속으로 이어지면 포기하고 지금까지의 내용으로 답하게 한다


TEXT_CALL_NAME_KEYS = ("tool_name", "name", "tool", "function")
TEXT_CALL_ARG_KEYS = ("params", "arguments", "parameters", "args", "input")
TEXT_CALL_MAX_REST = 120  # JSON 과 코드블록 표시를 빼고 남은 글이 이보다 길면 '설명하는 글'로 보고 건드리지 않는다


def text_tool_calls(text, known):
    """모델이 도구 호출을 tool_calls 로 보내지 않고 본문에 {"tool_name": ..., "params": {...}} 같은 JSON 글자로 출력한 경우,
    그 호출을 되살린다. 아는 도구 이름일 때만, 그리고 글 대부분이 그 JSON 일 때만 바꾼다 (JSON 을 설명하는 답변은 그대로 둔다)."""
    if not text or "{" not in text:
        return []
    dec, i, found, rest = json.JSONDecoder(), 0, [], []
    while True:
        j = text.find("{", i)
        if j < 0:
            rest.append(text[i:])
            break
        try:
            obj, end = dec.raw_decode(text, j)
        except ValueError:
            rest.append(text[i:j + 1])
            i = j + 1
            continue
        name = next((obj[k] for k in TEXT_CALL_NAME_KEYS if isinstance(obj, dict) and isinstance(obj.get(k), str)), None)
        if name not in known:
            rest.append(text[i:end])
            i = end
            continue
        args = next((obj[k] for k in TEXT_CALL_ARG_KEYS if k in obj), {})
        if isinstance(args, str):
            try:
                args = json.loads(args)
            except ValueError:
                return []
        if not isinstance(args, dict):
            return []
        found.append({"id": f"text_{len(found)}", "name": name, "arguments": json.dumps(args, ensure_ascii=False)})
        rest.append(text[i:j])
        i = end
    left = re.sub(r"```[a-zA-Z]*|`", "", "".join(rest)).strip()
    return found[:5] if found and len(left) <= TEXT_CALL_MAX_REST else []


def broken_call(calls):
    """도구 호출 인자가 끝까지 생성되지 않아 올바른 JSON 이 아닌 첫 호출 (없으면 None). 파일을 한 번에 너무 길게 쓰려다 잘리는 경우가 흔하다."""
    for c in calls:
        raw = (c.get("arguments") or "").strip()
        if not raw:
            continue
        try:
            json.loads(raw)
        except ValueError:
            return c
    return None


def truncated_note(call):
    why = ("출력 길이 한도에 닿아 생성이 중간에 멈췄습니다" if LAST_FINISH["reason"] == "length"
           else "인자가 끝까지 생성되지 않았습니다")
    return (f"방금 {call['name']} 호출은 {why} (인자가 완전한 JSON 이 아님). 실행하지 않았고 아무것도 바뀌지 않았습니다. "
            "내용이 너무 길었을 수 있습니다. 한 번에 쓰는 양을 줄여서 다시 호출하세요: 파일을 여러 개로 나누거나, "
            "먼저 짧은 뼈대를 write_file 로 만든 뒤 edit_file 로 부분씩 채우세요. 같은 내용을 그대로 다시 시도하지 마세요.")


ACTION_TOOLS = ("run_command", "write_file", "edit_file")  # 실제로 무언가를 바꾸거나 실행하는 도구 (읽기 도구는 남기지 않는다)
ACTION_LIMIT = 20


def action_line(name, raw_args, result):
    """실행한 명령/파일 수정을 대화 기록에 남길 한 줄로 만든다. 남길 필요가 없는 도구면 None."""
    if name in cloud_tool_names() and not CLOUD_READ_ONLY.match(name):  # Eyefeet Cloud 변경 작업 (값은 남기지 않는다)
        try:
            cargs = json.loads(raw_args) if raw_args and raw_args.strip() else {}
        except ValueError:
            cargs = {}
        target = next((str(cargs[k])[:40] for k in ("subdomain", "name", "tenant", "repo") if isinstance(cargs, dict) and cargs.get(k)), "")
        first = (result or "").strip()
        outcome = ("실행되지 않음" if first.startswith("사용자가 거절") else "실패" if first.startswith("오류") else "완료")
        return f"Eyefeet Cloud {name}{f' ({target})' if target else ''} → {outcome}"
    if name not in ACTION_TOOLS:
        return None
    try:
        args = json.loads(raw_args) if raw_args and raw_args.strip() else {}
    except ValueError:
        args = {}
    if not isinstance(args, dict):
        args = {}
    lines = (result or "").strip().splitlines()
    first = lines[0].strip() if lines else ""
    if name == "run_command":
        what = "$ " + " ".join(str(args.get("command", "")).split())[:150]
        if first.startswith(("(종료 코드", "(시간 초과", "(실행하지 못함")):
            outcome = first.strip("()")[:40]
        else:  # 거부 목록, 사용자 거절, 오류 등: 실행되지 않았다
            outcome = "실행되지 않음"
    else:
        what = f"{name} {args.get('path', '')}"
        outcome = ("거절됨 (바뀌지 않음)" if first.startswith("사용자가 거절") else
                   "실패" if first.startswith("오류") else "완료")
    return f"{what} → {outcome}"


def with_actions(answer, report):
    """대화 기록에 저장할 답 뒤에, 이번 질문에서 실제로 실행한 작업 목록을 붙인다 (다음 질문에서 모델이 기억하도록)."""
    acts = (report or {}).get("actions") or []
    if not acts:
        return answer
    shown = acts[-ACTION_LIMIT:]
    skipped = f", 앞의 {len(acts) - len(shown)}개 생략" if len(shown) < len(acts) else ""
    return answer + f"\n\n[eye 가 자동으로 남긴 기록: 이번 질문에서 실제로 실행한 작업{skipped}]\n" + "\n".join("- " + a for a in shown)


def run_turn(cfg, history, user_text, show_think=False, ws=None, inbox=None, report=None):
    """사용자 질문 하나를 처리한다. 모델이 도구를 부르면 실행해서 결과를 돌려주며 답이 나올 때까지 반복한다.
    도구 호출/결과는 이번 질문 안에서만 쓰고, 대화 기록에는 최종 답과 실행한 작업 목록(report["actions"], with_actions 로 붙임)만 남긴다 (컨텍스트 절약).
    컨텍스트가 차면 오래된 도구 결과를 비우고, 그래도 서버가 거절하면 대화를 요약해 다시 시도한다.
    도구 호출 횟수는 기본적으로 제한이 없다 (cfg["max_steps"] > 0 이면 그 횟수마다 이어갈지 묻고, 멈추면 지금까지 확인한 내용으로 답하게 한다).
    다만 같은 호출만 계속 반복하면 더 실행하지 않고 다른 방법을 쓰거나 답하도록 안내하며, 끝내 반복하면 도구를 끄고 답하게 한다.
    Ctrl-C 는 답변을 받는 중에도, 도구를 실행하는 중에도 바로 멈춘다.

    inbox 가 있으면 작업 중에 사용자가 `/now` 로 보낸 긴급 메시지를 처리한다: 하던 응답/도구 실행을 멈추고, 그 메시지에 먼저 답한 뒤,
    중단했던 원래 작업을 이어서 계속한다 (그 사이의 대화는 모델에게 그대로 전달된다).
    report 에는 긴급 메시지와 그 답의 쌍(urgent_pairs)과, 사용자가 Ctrl-C 로 멈췄는지(aborted)를 기록한다.
    (최종 답, 작업 폴더, 압축됐을 수 있는 대화 기록) 을 반환한다."""
    if report is None:
        report = {}
    report.setdefault("urgent_pairs", [])
    report.setdefault("aborted", False)
    report.setdefault("actions", [])
    cloud_prepare(cfg, user_text, history)
    turn = []  # 이번 질문에서 오간 도구 호출/결과
    overflows = steps = blocked = truncs = 0
    batch = max(0, int(cfg.get("max_steps", DEFAULT_MAX_STEPS) or 0))  # 0: 제한 없음
    limit = batch
    recent = []  # 실제로 실행한 (도구, 인자) 기록
    final = ""
    resume_pending = False  # 긴급 메시지에 답한 뒤 원래 작업으로 돌아가야 함
    urgent_asked = []

    def build():
        head = [{"role": "system", "content": full_system_prompt(ws)}]
        return head + history + [{"role": "user", "content": user_text}] + turn

    def wrap_up(why):
        sys.stderr.write(f"\033[2m  {why} 지금까지 확인한 내용으로 답합니다.\033[0m\n")
        try:
            wrapped, _, _ = chat(cfg, build() + [{"role": "user", "content": WRAP_UP}], show_think, None)
        except ApiError as e:
            sys.stderr.write(f"eye: 정리 답변을 받지 못했습니다 ({e.detail[:100]})\n")
            return final
        return wrapped or final

    def self_interrupt():
        """방금 받은 KeyboardInterrupt 가 사용자의 Ctrl-C 가 아니라 입력 읽기 스레드가 보낸 신호인가."""
        return note_interrupt(inbox)

    def take_urgent():
        nonlocal resume_pending
        if not (inbox and inbox.has_urgent()):
            return False
        text = inbox.pop_urgent()
        if build()[-1]["role"] == "user":  # 사용자 메시지가 연달아 오지 않게 모델이 한 말을 하나 끼운다
            turn.append({"role": "assistant", "content": "(알겠습니다)"})
        turn.append({"role": "user", "content": URGENT_PREFIX + text})
        urgent_asked.append(text)
        resume_pending = True
        notify(dim("  ⚡ 긴급 메시지를 먼저 처리합니다."))
        return True

    while True:
        take_urgent()
        work = build()
        for keep in (3, 2, 1):  # 컨텍스트가 차면 오래된 도구 결과부터 비운다 (방금 받은 결과는 남긴다)
            if messages_tokens(work) + fixed_tokens(ws) <= threshold(cfg):
                break
            if shrink_tool_results(turn, keep):
                work = build()
        try:
            text, calls, interrupted = chat(cfg, work, show_think, turn_tools(ws))
        except KeyboardInterrupt:  # 응답을 기다리는 동안(연결/대기 중) 들어온 중단
            text, calls, interrupted = "", [], True
            note_interrupt(inbox)
        except ApiError as e:
            if OVERFLOW.search(e.detail) and overflows < 2:
                overflows += 1
                sys.stderr.write("eye: 컨텍스트가 가득 차서 대화를 줄인 뒤 다시 시도합니다.\n")
                history = compact_history(cfg, history, keep_pairs=1)
                shrink_tool_results(turn, 1)
                continue
            if (ws or cloud_active()) and e.code in (400, 422):
                CLOUD["on"] = CLOUD["loaded"] = False
                sys.stderr.write(f"eye: 서버가 도구 호출을 받아들이지 않아 파일 접근 없이 다시 시도합니다. ({e.detail[:120]})\n")
                ws, turn = None, []
                continue
            die(str(e))
        if interrupted:
            if LAST_INTERRUPT_SELF:  # chat() 가 이미 장부에서 확인했다 (다시 확인하면 한 번 더 소비된다)
                continue  # 긴급 메시지 때문에 끊긴 것: 위에서 긴급 메시지를 처리한다 (늦게 온 헛 신호였다면 같은 요청을 다시 보낸다)
            report["aborted"] = True
            return (text if not resume_pending else final), ws, history
        if not calls and not interrupted:
            as_calls = text_tool_calls(text, {t["function"]["name"] for t in (turn_tools(ws) or [])})
            if as_calls:  # 모델이 도구 호출을 글자로 써 버렸다: 그 호출을 실제 도구 호출로 바꿔 실행한다 (변경 작업은 평소처럼 승인을 받는다)
                sys.stderr.write(dim("  모델이 도구 호출을 글자로 출력해서, 그 내용을 도구 호출로 바꿔 실행합니다.") + "\n")
                calls, text = as_calls, ""
        if not resume_pending:
            final = text  # 긴급 메시지에 대한 답은 원래 작업의 최종 답으로 쓰지 않는다
        if not calls:
            if resume_pending:  # 긴급 메시지에 대한 답이 끝났다: 기록해 두고 중단했던 원래 작업으로 돌아간다
                report["urgent_pairs"].append((urgent_asked[-1], text))
                turn.append({"role": "assistant", "content": text})
                turn.append({"role": "user", "content": RESUME_NOTE})
                resume_pending = False
                continue
            return final, ws, history
        bad = broken_call(calls)
        if bad:  # 잘린 호출은 실행하지도, 기록에 넣지도 않는다 (깨진 JSON 을 서버로 되돌려 보내면 다시 파싱 오류가 난다)
            truncs += 1
            sys.stderr.write(f"\033[2m  {bad['name']} 호출이 중간에 잘렸습니다. 나눠서 다시 쓰도록 안내합니다. ({truncs}/{TRUNC_LIMIT})\033[0m\n")
            if truncs >= TRUNC_LIMIT:
                return wrap_up("도구 호출이 계속 잘려"), ws, history
            turn.append({"role": "assistant", "content": text or "(도구 호출을 작성하다가 잘렸습니다)"})
            turn.append({"role": "user", "content": truncated_note(bad)})
            continue
        truncs = 0
        if batch and steps >= limit:
            if ask_continue(steps):
                limit += batch  # 한도를 한 묶음 더 늘려 방금 요청한 도구부터 이어서 실행한다
            else:
                return wrap_up(f"도구 호출 {steps}번에 도달해."), ws, history
        turn.append({"role": "assistant", "content": text, "tool_calls": [
            {"id": c["id"], "type": "function", "function": {"name": c["name"], "arguments": c["arguments"] or "{}"}} for c in calls]})
        preempted = False
        for c in calls:
            if preempted:
                turn.append({"role": "tool", "tool_call_id": c["id"],
                             "content": "(건너뜀: 긴급 메시지를 먼저 처리하느라 실행하지 않았습니다. 필요하면 다시 요청하세요.)"})
                continue
            key = (c["name"], (c["arguments"] or "").strip())
            if len(recent) >= STUCK_REPEATS and all(r == key for r in recent[-STUCK_REPEATS:]):
                blocked += 1
                result = (f"같은 호출({c['name']})을 이미 {STUCK_REPEATS}번 연속으로 실행했고 결과도 같았습니다. "
                          "같은 호출을 반복하지 말고 다른 방법을 쓰거나, 지금까지 확인한 내용으로 답하세요.")
            else:
                blocked = 0
                try:
                    if c["name"] in cloud_tool_names():
                        result = run_cloud(cfg, c["name"], c["arguments"])
                    else:
                        result = ws.run(c["name"], c["arguments"]) if ws else "오류: 지금은 파일 도구를 쓸 수 없습니다"
                except KeyboardInterrupt:  # 도구(파일 검색, 명령 등)를 실행하는 중의 중단
                    if self_interrupt():
                        result = "(긴급 메시지를 먼저 처리하느라 중단됨)" if inbox.has_urgent() else "(중단됨)"
                        preempted = True
                    else:
                        report["aborted"] = True
                        sys.stdout.write("\n[중단됨]\n")
                        return final, ws, history
                else:
                    recent.append(key)
                    line = action_line(c["name"], c["arguments"], result)
                    if line:
                        report["actions"].append(line)
                    if inbox and inbox.has_urgent():
                        preempted = True  # 이 도구는 끝났다: 남은 도구는 건너뛰고 긴급 메시지를 먼저 처리
            turn.append({"role": "tool", "tool_call_id": c["id"], "content": result})
        steps += 1
        if blocked >= STUCK_LIMIT:
            return wrap_up("같은 호출이 계속 반복돼 도구를 더 쓰지 않고,"), ws, history


_BUSY_HINT_SHOWN = False


def process_turns(cfg, messages, text, show_think, ws, inbox, session):
    """질문 하나를 처리한다. 작업 중 대기열에 쌓인 메시지가 있으면 끝난 뒤 한꺼번에 이어서 처리한다.
    (대화 기록, 작업 폴더, 엔터 없이 입력 중이던 글자) 를 돌려준다."""
    global _BUSY_HINT_SHOWN
    leftover = ""
    while text is not None:
        report = {"urgent_pairs": [], "aborted": False}
        busy = BusyInput(inbox)
        started = busy.start()
        if started and TUI is None and not _BUSY_HINT_SHOWN and not os.environ.get("EYE_NO_HINT"):
            _BUSY_HINT_SHOWN = True
            notify(dim("  " + BUSY_HINT))
        answer = ""
        try:
            try:
                history = maybe_compact(cfg, messages, text, ws)
                answer, ws, history = run_turn(cfg, history, text, show_think, ws, inbox=inbox if started else None, report=report)
                messages = history
            except KeyboardInterrupt:
                report["aborted"] = True
                sys.stdout.write("\n[중단됨]\n")
        finally:
            leftover = busy.stop()
        if answer:
            for asked, replied in [(text, with_actions(answer, report))] + report["urgent_pairs"]:
                messages = messages + [{"role": "user", "content": asked}, {"role": "assistant", "content": replied}]
            session.messages, session.model = messages, cfg["model"]
            session.save()
        urgent_left = inbox.pop_urgent()
        items = ([urgent_left] if urgent_left else []) + inbox.pop_queued()
        if items and report["aborted"]:  # 사용자가 Ctrl-C 로 멈췄으면 대기열은 보내지 않고 남겨 둔다
            with inbox.lock:
                inbox.queued[:0] = items
            notify(dim(f"  대기 중인 메시지 {len(items)}개가 남아 있습니다. 엔터(빈 입력)로 보내거나 /queue clear 로 지우세요."))
            text = None
        elif items:
            notify(dim(f"  대기 중이던 메시지 {len(items)}개를 한꺼번에 보냅니다."))
            text = combine_messages(items)
        else:
            text = None
    return messages, ws, leftover


def default_workspace(force=False, commands=True):
    root = os.path.realpath(os.getcwd())
    home = os.path.realpath(os.path.expanduser("~"))
    if not force and (root == home or root == os.path.dirname(root)):
        sys.stderr.write(f"eye: 홈 폴더나 루트({root})에서는 파일 접근을 켜지 않습니다. 프로젝트 폴더에서 실행하거나 --files 를 붙이세요.\n")
        return None
    return Workspace(root, commands)


SHELL_OUTPUT_LIMIT = 6000


def run_shell(command):
    """`!명령`: 사용자가 직접 친 터미널 명령을 이 폴더에서 실행하고 출력을 화면에 바로 보여 준다.
    다음 질문에 참고용으로 붙일 요약 문자열을 돌려준다. 모델이 부르는 도구가 아니라 사용자가 입력한 명령만 실행한다."""
    argv, use_shell, encoding = shell_argv(command)
    decoder = codecs.getincrementaldecoder(encoding)(errors="replace")
    parts, code, interrupted = [], None, False
    try:
        # 전체 화면 모드에서는 터미널을 TUI 가 쓰고 있으므로, 명령이 터미널에서 직접 입력을 받으려 하지 못하게 분리한다
        isolate = {"stdin": subprocess.DEVNULL, "start_new_session": os.name != "nt"} if TUI is not None else {}
        proc = subprocess.Popen(argv, shell=use_shell, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=os.getcwd(),
                                env={**os.environ, "GIT_PAGER": "cat", "PAGER": "cat"}, **isolate)
    except OSError as e:
        print(f"eye: 명령을 실행하지 못했습니다 ({e.strerror or e})")
        return f"[방금 실행하려던 명령]\n$ {command}\n(실행하지 못함: {e.strerror or e})"
    ACTIVE_PROCS.add(proc)
    try:
        while True:
            data = os.read(proc.stdout.fileno(), 4096)
            if not data:
                break
            text = decoder.decode(data)
            parts.append(text)
            sys.stdout.write(text)
            sys.stdout.flush()
    except KeyboardInterrupt:
        interrupted = True
    finally:
        try:
            code = proc.wait(timeout=5 if interrupted else None)
        except subprocess.TimeoutExpired:
            proc.kill()
            code = proc.wait()
        ACTIVE_PROCS.discard(proc)
    output = "".join(parts)
    if not output:
        sys.stdout.write("\033[2m(출력 없음)\033[0m\n" if sys.stdout.isatty() else "(출력 없음)\n")
    elif not output.endswith("\n"):
        sys.stdout.write("\n")
    status = "중단됨" if interrupted else (f"종료 코드 {code}" if code else "")
    if status:
        sys.stdout.write(f"\033[2m({status})\033[0m\n" if sys.stdout.isatty() else f"({status})\n")
    if len(output) > SHELL_OUTPUT_LIMIT:
        output = output[:2000] + "\n...(중간 생략)...\n" + output[-(SHELL_OUTPUT_LIMIT - 2000):]
    return f"[방금 사용자가 직접 실행한 명령]\n$ {command}\n{output.rstrip()}\n(종료 코드 {code})"


def short_cwd(cwd=None, home=None, msys=None, limit=40):
    """프롬프트에 보여 줄 현재 경로: 홈은 ~ 로 줄이고, Git Bash 에서는 /c/Users/... 형태로, 너무 길면 …/끝 두 폴더로 줄인다."""
    path = os.path.abspath(cwd or os.getcwd())
    home = os.path.abspath(home or os.path.expanduser("~"))
    msys = bool(os.environ.get("MSYSTEM")) if msys is None else msys
    norm = os.path.normcase
    if norm(path) == norm(home):
        shown = "~"
    elif norm(path).startswith(norm(home).rstrip(os.sep) + os.sep):
        shown = "~" + path[len(home):]
    else:
        shown = path
    shown = shown.replace("\\", "/")
    if msys and re.match(r"^[A-Za-z]:/", shown):
        shown = "/" + shown[0].lower() + shown[2:]
    parts = shown.split("/")
    if len(shown) > limit and len(parts) > 3:
        shown = "…/" + "/".join(parts[-2:])
    return shown


def make_prompt(color=None, cwd=None, home=None):
    """bash 처럼 `계정명@경로 $ ` 모양의 입력 프롬프트. 관리자(root)면 $ 대신 #."""
    try:
        user = getpass.getuser()
    except Exception:
        user = os.environ.get("USER") or os.environ.get("USERNAME") or "eye"
    sign = "#" if hasattr(os, "geteuid") and os.geteuid() == 0 else "$"
    where = short_cwd(cwd, home)
    if color is None:
        color = sys.stdout.isatty() and not os.environ.get("NO_COLOR")
    if not color:
        return f"{user}@{where} {sign} "

    def paint(code, text):  # readline 이 커서 위치를 잘못 계산하지 않도록 색 코드를 \001 \002 로 감싼다 (readline 이 있을 때만)
        start, end = ("\001", "\002") if HAVE_READLINE else ("", "")
        return f"{start}\033[{code}m{end}{text}{start}\033[0m{end}"
    return f"{paint('1;32', user + '@')}{paint('1;34', where)} {sign} "


def repl(cfg, show_think, ws=None, session=None):
    resumed = session is not None
    session = session or Session(os.getcwd(), cfg["model"])
    where = f" · 작업 폴더: {ws.root}" if ws else ""
    print(f"eye · {cfg['model']}{where}  (/help 도움말 · 줄 끝에 \\ 를 쓰면 여러 줄 입력 · Ctrl-D 종료)")
    if resumed:
        print(describe_resume(session))
    root_dir = ws.root if ws else None
    commands_on = ws.commands if ws else True
    messages = session.messages
    shell_notes = []  # `!명령` 으로 실행한 결과. 다음 질문에 함께 전달한다
    inbox = Inbox()  # 작업 중에 입력한 메시지들
    if TUI is not None:
        TUI.inbox, TUI.cfg = inbox, cfg  # 화면이 대기열을 보여 주고 버튼으로 다루게 한다
    carry = ""       # 작업 중에 엔터 없이 입력하다 만 글자 (다음 입력에 이어 붙인다)
    while True:
        try:
            if sys.stdout.isatty() and not os.environ.get("NO_COLOR"):
                enable_ansi()
            q = (carry + input("\n" + make_prompt() + carry)).strip()
            carry = ""
        except EOFError:
            print()
            return
        except KeyboardInterrupt:
            print()
            continue
        while q.endswith("\\"):
            try:
                q = q[:-1] + "\n" + input("… ").strip()
            except (EOFError, KeyboardInterrupt):
                break
        if not q:
            if not inbox.queued:
                continue
            q = combine_messages(inbox.pop_queued())  # 작업 중 쌓아 두었던 메시지를 지금 보낸다
            print(dim("  대기 중이던 메시지를 보냅니다."))
        if q in ("/queue", "/queue clear"):
            if q.endswith("clear"):
                print(f"대기열 {inbox.clear()}개를 지웠습니다.")
            else:
                print("대기열 비어 있음" if not inbox.queued else "대기열:\n" + "\n".join(f"  {n}. {t[:100]}" for n, t in enumerate(inbox.queued, 1)))
            continue
        if q == "/now" or q.startswith("/now "):  # 작업 중이 아닐 때의 /now 는 그냥 보내기와 같다
            q = q[4:].strip() or (combine_messages(inbox.pop_queued()) if inbox.queued else "")
            if not q:
                print("보낼 내용이 없습니다. /now 메시지 처럼 입력하세요.")
                continue
        if q.startswith("!"):
            command = q[1:].strip()
            if not command:
                print("사용법: !명령  (예: !git status) — 이 폴더에서 터미널 명령을 바로 실행합니다. 결과는 다음 질문에 함께 전달됩니다.")
                continue
            shell_notes.append(run_shell(command))
            del shell_notes[:-3]  # 최근 3개만 보관
            continue
        if q == "/help":
            print("작업 중에도 입력할 수 있습니다: 그냥 입력=대기열(작업이 끝나면 한꺼번에 전달), /now 메시지=하던 작업을 멈추고 먼저 답한 뒤 이어서 계속\n"
                  "/queue [clear]  대기열 보기/지우기 (대기 중일 때 엔터만 치면 보냅니다)\n"
                  "!명령        이 폴더에서 터미널 명령을 직접 실행 (예: !git status). 결과는 다음 질문에 함께 전달\n"
                  "/model 이름  모델 변경\n/models      모델 목록\n/usage       사용량\n/reset       새 대화 시작\n"
                  "/compact     지금까지의 대화를 요약해서 줄이기\n"
                  "/files [on|off]  작업 폴더 파일 접근 켜기/끄기\n"
                  "/commands [ask|off|on]  모델의 명령 실행: 매번 확인으로 되돌리기 / 끄기 / 켜기\n"
                  "/exit        종료 (Ctrl-D 도 가능)\n답변 중 Ctrl-C  생성 중단\n"
                  "다음에 이어가려면: eye --continue (이 폴더의 최근 대화) / eye --resume (목록에서 선택)")
            if TUI is not None:
                print("\n전체 화면 모드: 마우스로 대기열의 [지금 보내기]/[삭제]와 승인 창의 버튼을 누를 수 있습니다. 휠/PgUp/PgDn 으로 스크롤, "
                      "F2 (또는 /mouse on|off) 로 마우스 모드를 끄면 글자를 드래그해서 복사할 수 있습니다. 엔터=보내기, Alt-엔터 또는 Ctrl-J=줄바꿈, "
                      "↑/↓=입력 기록, Tab=/명령 완성, Ctrl-C=중단(입력 중이면 입력 지우기), Ctrl-D=종료")
            continue
        if q in ("/exit", "/quit", "exit", "quit"):
            return
        if q == "/reset":
            session = Session(os.getcwd(), cfg["model"])
            messages = session.messages
            print("새 대화를 시작합니다.")
            continue
        if q == "/compact":
            if len(messages) < 4:
                print("요약할 만큼 대화가 길지 않습니다.")
                continue
            messages = compact_history(cfg, messages, keep_pairs=1)
            session.messages = messages
            session.save()
            continue
        if q in ("/models", "/models all"):
            print("\n".join(list_models(cfg, show_all=q.endswith("all"))))
            continue
        if q == "/usage":
            show_usage(cfg)
            continue
        if q.startswith("/mouse"):
            arg = q[6:].strip()
            if TUI is None:
                print("/mouse 는 전체 화면 모드(eye --tui)에서만 쓸 수 있습니다.")
            elif arg in ("on", "off"):
                TUI.set_mouse(arg == "on")
                print("마우스 모드: " + ("켬 (클릭/휠 가능, 글자 드래그는 Shift 를 누른 채로)" if TUI.mouse else "끔 (글자를 드래그해서 복사할 수 있음)"))
            else:
                print(f"마우스 모드: {'켬' if TUI.mouse else '끔'}   (사용법: /mouse on | off, 또는 F2)")
            continue
        if q.startswith("/commands"):
            arg = q[9:].strip()
            if not ws:
                print("파일 접근이 꺼져 있어 명령 도구도 쓸 수 없습니다. /files on 으로 켜세요.")
            elif arg == "ask":
                ws.auto_commands = ws.always = AUTO["on"] = False
                print("자동 승인 모드를 껐습니다. 이제 파일 수정과 명령, Eyefeet Cloud 변경 작업을 매번 확인합니다.")
            elif arg == "off":
                ws.commands = commands_on = False
                print("모델의 명령 실행을 껐습니다.")
            elif arg == "on":
                ws.commands = commands_on = True
                print("모델의 명령 실행을 켰습니다 (읽기 명령은 바로, 그 밖의 명령은 확인 후 실행).")
            else:
                state = "꺼짐" if not ws.commands else ("자동 승인 중 (/commands ask 로 되돌림)" if ws.auto_commands or AUTO["on"] else "명령마다 확인")
                print(f"모델의 명령 실행: {state}   (사용법: /commands ask | off | on)")
            continue
        if q.startswith("/files"):
            arg = q[6:].strip()
            if arg == "off":
                ws = None
            elif arg == "on" and root_dir:
                ws = Workspace(root_dir, commands_on)
            elif arg == "on":
                ws = default_workspace(force=True, commands=commands_on)
                root_dir = ws.root if ws else None
            print(f"파일 접근: {'켜짐 — ' + ws.root if ws else '꺼짐'}")
            continue
        if q.startswith("/model"):
            name = q[6:].strip()
            if name:
                cfg["model"] = name
            print("모델:", cfg["model"])
            continue
        text = q
        if shell_notes:
            text = "\n\n".join(shell_notes) + "\n\n" + q
            shell_notes = []
        messages, ws, carry = process_turns(cfg, messages, text, show_think, ws, inbox, session)


def save_config(key, model, base, token=""):
    os.makedirs(os.path.dirname(CONFIG), exist_ok=True)
    keep = []
    try:  # 사용자가 직접 적어 둔 EYE_CONTEXT / EYE_MAX_STEPS 는 다시 저장해도 유지한다
        with open(CONFIG, encoding="utf-8") as f:
            keep = [l.strip() for l in f if l.startswith(("EYE_CONTEXT=", "EYE_MAX_STEPS="))]
    except OSError:
        pass
    fd = os.open(CONFIG, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
    with os.fdopen(fd, "w", encoding="utf-8") as f:
        f.write(f"EYE_MODEL={model}\nEYE_BASE_URL={base}\n")
        f.write(f"EYE_TOKEN={token}\n" if token else f"EYE_API_KEY={key}\n")
        for line in keep:
            f.write(line + "\n")
    try:
        os.chmod(CONFIG, 0o600)
    except OSError:
        pass
    print("저장했습니다:", CONFIG)


def setup():
    cur = load_config()
    key = getpass.getpass("API 키 (입력은 화면에 보이지 않음, 비우면 유지): ").strip() or cur["key"]
    model = input(f"기본 모델 [{cur['model']}]: ").strip() or cur["model"]
    base = input(f"API 주소 [{cur['base']}]: ").strip() or cur["base"]
    save_config(key, model, base)


def device_post(origin, path, body):
    req = urllib.request.Request(
        origin + path, data=json.dumps(body).encode(),
        headers={"Content-Type": "application/json", "User-Agent": "eye-cli/1"},
    )
    try:
        with urllib.request.urlopen(req, timeout=30) as r:
            return json.load(r)
    except urllib.error.HTTPError as e:
        try:
            detail = json.loads(e.read().decode(errors="replace")).get("detail", "")
        except ValueError:
            detail = ""
        die(f"로그인 실패 (HTTP {e.code}) {detail}")
    except urllib.error.URLError as e:
        die(f"접속 실패: {e.reason}")


def login():
    cur = load_config()
    origin = cur["base"]
    for suffix in ("/api/cli", "/v1"):
        if origin.endswith(suffix):
            origin = origin[: -len(suffix)]
    start = device_post(origin, "/api/device/start", {})
    print(f"브라우저에서 아래 주소를 열고 통합 계정으로 로그인한 뒤 승인하세요.\n\n  {start['verification_url']}\n\n  확인 코드: {start['user_code']}\n", flush=True)
    try:
        import webbrowser
        webbrowser.open(start["verification_url"])
    except Exception:
        pass
    deadline = time.time() + start["expires_in"]
    print("승인을 기다리는 중... (Ctrl-C 로 취소)")
    try:
        while time.time() < deadline:
            time.sleep(start["interval"])
            res = device_post(origin, "/api/device/token", {"device_code": start["device_code"]})
            if res.get("status") == "approved":
                save_config("", cur["model"], res["api_base"], token=res["token"])
                print("로그인 완료. 이제 `eye` 를 바로 쓸 수 있습니다.")
                return
    except KeyboardInterrupt:
        print("\n취소했습니다.")
        return
    die("시간이 지났습니다. eye login 을 다시 실행해 주세요.")


def main():
    install_shutdown_handlers()
    args = sys.argv[1:]
    cfg = load_config()
    show_think = False
    files_mode = "auto"  # auto: 현재 폴더(홈/루트 제외) / on: 강제 / off: 끔
    commands = os.environ.get("EYE_NO_COMMANDS", "").strip().lower() not in ("1", "true", "yes", "on")  # 모델의 명령 실행 도구
    resume_mode = None  # "continue": 이 폴더의 최근 대화 / "resume": 목록에서 선택
    save = True
    model_arg = None
    tui_env = os.environ.get("EYE_TUI", "").strip().lower()
    tui_mode = tui_env not in ("0", "false", "no", "off")  # 전체 화면 모드가 기본이다 (--cli 또는 EYE_TUI=0 으로 끈다)
    tui_explicit = tui_env in ("1", "true", "yes", "on")   # 직접 켜 달라고 한 경우에만 못 쓰는 터미널에서 안내를 보인다
    words = []
    i = 0
    while i < len(args):
        a = args[i]
        if a in ("-h", "--help"):
            print(__doc__)
            return
        if a in ("-V", "--version"):
            print(f"eye {VERSION}")
            return
        if a in ("-m", "--model") and i + 1 < len(args):
            model_arg = args[i + 1]
            cfg["model"] = model_arg
            i += 2
            continue
        if a == "--think":
            show_think = True
        elif a == "--no-files":
            files_mode = "off"
        elif a == "--files":
            files_mode = "on"
        elif a == "--no-commands":
            commands = False
        elif a in ("-c", "--continue"):
            resume_mode = "continue"
        elif a in ("-r", "--resume"):
            resume_mode = "resume"
        elif a == "--no-save":
            save = False
        elif a == "--tui":
            tui_mode, tui_explicit = True, True
        elif a in ("--cli", "--no-tui"):
            tui_mode = False
        elif a == "--raw":
            cfg["raw"] = True
        else:
            words.append(a)
        i += 1

    if words[:1] == ["login"]:
        return login()
    if words[:1] == ["config"]:
        return setup()
    if words[:1] == ["usage"]:
        return show_usage(cfg)
    if words[:1] == ["models"]:
        print("\n".join(list_models(cfg, show_all="--all" in args)))
        return

    prompt = " ".join(words).strip()
    piped = "" if sys.stdin.isatty() else sys.stdin.read().strip()
    one_shot = bool(prompt or piped)
    if not cfg["key"] and not one_shot:
        if input("저장된 API 키가 없습니다. 지금 브라우저로 로그인할까요? [Y/n] ").strip().lower() in ("", "y", "yes"):
            login()
            cfg = load_config()
            if model_arg:
                cfg["model"] = model_arg
            if not cfg["key"]:
                return
        else:
            return

    cwd = os.path.realpath(os.getcwd())
    session = None
    if resume_mode == "continue":
        session = latest_session_for(cwd)
        if session is None:
            print("이 폴더에서 이어갈 대화가 없어 새로 시작합니다.", file=sys.stderr)
    elif resume_mode == "resume":
        session = choose_session(cwd)
        if session is None and not one_shot:
            return
    if session is not None and not model_arg and session.model:
        cfg["model"] = session.model

    ws = None if files_mode == "off" else default_workspace(force=files_mode == "on", commands=commands)

    if one_shot:
        text = f"{prompt}\n\n{piped}" if prompt and piped else (prompt or piped)
        # 터미널에서 직접 쓸 때(또는 --continue/--resume 일 때)만 대화를 저장한다. 스크립트/파이프 호출은 저장하지 않는다.
        persist = save and (resume_mode is not None or sys.stdin.isatty())
        if session is None and persist:
            session = Session(cwd, cfg["model"])
        history = maybe_compact(cfg, session.messages, text, ws) if session else []
        report = {}
        answer, ws, history = run_turn(cfg, history, text, show_think, ws, report=report)
        if persist and answer:
            session.messages = history + [{"role": "user", "content": text}, {"role": "assistant", "content": with_actions(answer, report)}]
            session.model = cfg["model"]
            session.save()
        return

    if not save:
        Session.save = lambda self: None
    if tui_mode:
        return run_tui(cfg, show_think, ws, session, explicit=tui_explicit)
    repl(cfg, show_think, ws, session)


if __name__ == "__main__":
    main()
