deel-local-cli 0.5.0 → 0.9.0

package/src/agent/route.js

@@ -0,0 +1,156 @@
+// 사용자가 무엇을 시켰는지 보고 알맞은 작업 모드를 고른다.
+//
+// 왜 규칙으로 하나:
+//   모델에게 "이건 무슨 일이냐" 고 한 번 더 물을 수도 있다. 그런데 그러면
+//   한마디 할 때마다 왕복이 하나 늘고, 작은 로컬 모델은 이런 분류를 잘 못한다.
+//   느려지고 틀리기까지 하면 자동으로 하는 의미가 없다.
+//
+//   그래서 낱말로 고른다. 대신 두 가지를 지킨다.
+//     1) 애매하면 안 바꾼다. 종합 모드에 그대로 둔다.
+//        잘못 바꾸는 것보다 안 바꾸는 편이 낫다 — 특히 읽기 전용 모드로
+//        잘못 보내면 사용자는 "왜 파일을 안 고쳐?" 하고 막힌다.
+//     2) 왜 그렇게 봤는지 남긴다. 화면에 그 이유가 같이 뜬다.
+//
+// 사용자가 직접 모드를 고르면 이건 아예 안 돈다. 사람이 고른 것을 뒤집지 않는다.
+
+// 낱말과 점수. 큰 점수일수록 그 모드라는 증거가 강하다는 뜻이다.
+//
+// 한국어를 먼저 두되 영어도 같이 본다 — 오류 메시지를 그대로 붙여넣는 일이 흔하다.
+const 표 = {
+  debug: [
+    // 고장은 신호가 뚜렷하다. 그리고 디버그는 파일을 고칠 수 있으므로
+    // 잘못 골라도 막히지 않는다. 그래서 세게 준다.
+    [/왜\s*안\s*(되|돼|됨)/, 5], [/안\s*(되는|돼는|됩니다|되네|돼네|돼요|되요)/, 4],
+    [/작동\s*안/, 4], [/동작\s*안/, 4],
+    [/에러|오류|예외|익셉션/, 4], [/버그/, 4],
+    [/실패/, 3], [/터(져|졌|진다)/, 3], [/죽(어|었|는다|네)/, 3],
+    [/멈(춰|췄|춘다|추)/, 3], [/먹통/, 3], [/이상(해|하다|한데)/, 3],
+    [/재현/, 3], [/스택\s*트레이스|stack\s*trace|traceback/i, 4],
+    // 'TypeError' 처럼 앞에 글자가 붙어 오는 일이 훨씬 흔하다.
+    // \berror\b 로 잡으면 정작 붙여넣은 진짜 오류 메시지를 놓친다.
+    [/error/i, 3], [/\bexception\b|\bcrash|\bfail(s|ed|ing)?\b|\bbroken\b/i, 3],
+    [/고장/, 3], [/왜\s*이(래|러|렇게\s*나)/, 2],
+    [/왜\s*(못|안)/, 3], [/뭐\s*때문(이|에)/, 3],
+  ],
+
+  plan: [
+    // '먼저' 와 붙어야 계획이다. 그냥 '어떻게' 는 설명일 수도 있다.
+    [/계획/, 5], [/플랜|\bplan\b/i, 5],
+    [/먼저\s*(정리|생각|살펴|파악|검토|짜|세)/, 4],
+    [/어떤\s*순서/, 4], [/순서(를|대로)?\s*(정|짜|잡)/, 3],
+    [/단계(를|로)?\s*(나눠|쪼개|정리)/, 3],
+    [/로드맵|\broadmap\b/i, 5],
+    [/방향(을|만)?\s*(잡|정)/, 3],
+    [/하기\s*전에\s*(정리|살펴|검토)/, 3],
+    [/무엇부터|뭐부터/, 3],
+  ],
+
+  architect: [
+    [/설계/, 5], [/아키텍(처|쳐)|architecture/i, 5],
+    [/구조(를|가|는)?\s*(어떻게|바꾸|잡|짜|개선)/, 5],
+    [/어떻게\s*(나누|쪼개|짜)/, 5],
+    [/모듈(로|을)?\s*(나누|분리)/, 3],
+    [/의존(성|\s*방향)/, 3], [/레이어|계층/, 3],
+    [/어느\s*(쪽|것)이\s*(나을|좋을)/, 3], [/선택지|대안/, 3],
+    [/패턴(을|이)?\s*(쓰|적용|고르)/, 2],
+    [/\bdesign\b|\bstructure\b|\brefactor(ing)?\s*(방향|plan)/i, 3],
+  ],
+
+  ask: [
+    // 설명은 아무것도 안 바꾸는 모드라 잘못 고르면 답답해진다. 신호를 엄격히 본다.
+    [/뭐(야|예요|입니까|지)\s*\??$/m, 5], [/무엇(인가|입니까|이야)/, 5],
+    [/설명(해|좀|을)/, 5], [/알려\s*(줘|주세요|줄래)/, 3],
+    [/어떻게\s*(동작|작동|돌아가)/, 5],
+    [/무슨\s*(뜻|의미)|의미(가|는)\s*뭐/, 5],
+    [/차이(가|는|점)/, 3],
+    [/궁금/, 3], [/왜\s*이렇게\s*(만들|짰|되어)/, 3],
+    [/\bwhat\s+is\b|\bexplain\b|\bhow\s+does\b/i, 4],
+    [/읽어(만)?\s*보고\s*(설명|알려)/, 4],
+  ],
+
+  orchestrator: [
+    // 총괄의 신호는 낱말 하나가 아니라 '넓이' 다. 그래서 하나하나는 약하게 두고
+    // 여럿이 겹칠 때 문턱을 넘게 한다 — 실제로 큰 일에는 이런 말이 같이 나온다.
+    // "전체 로그 형식을 다 통일해줘" 는 '전체' 와 '통일' 이 겹쳐야 총괄이 된다.
+    [/전부|모두|싹\s*다|통째로/, 3],
+    [/전체/, 3],
+    [/하나씩/, 3],
+    [/끝까지/, 3], [/마무리까지/, 3],
+    [/여러\s*(개|군데|파일|단계|곳)/, 3],
+    [/순서대로/, 3],
+    [/통일(해|시켜|좀)|일괄/, 2],
+    [/흩어진|여기저기/, 2],
+    [/\bend[- ]?to[- ]?end\b/i, 3],
+  ],
+
+  code: [
+    [/고쳐|고쳐줘|수정(해|좀)/, 4],
+    [/만들어|추가(해|좀)|넣어(줘|주세요)/, 4],
+    [/구현(해|좀)/, 5],
+    [/바꿔(줘|주세요)?|변경(해|좀)/, 3],
+    [/지워(줘)?|삭제(해|좀)/, 3],
+    [/이름\s*바꿔|리네임|rename/i, 3],
+    [/옮겨(줘)?/, 2],
+    [/리팩터(링)?(해|좀)/, 3],
+    [/\bimplement\b|\badd\b|\bfix\b|\bwrite\b/i, 2],
+    [/써(줘|주세요)/, 3],
+  ],
+};
+
+// 이만큼은 되어야 바꾼다. 못 미치면 종합 모드 그대로 둔다.
+//
+// 읽기 전용 모드는 문턱을 높인다. 잘못 보내면 파일을 못 고쳐서 사용자가 막힌다.
+// 파일을 고칠 수 있는 모드는 잘못 골라도 일이 막히지는 않으므로 낮게 둔다.
+const 문턱 = {
+  debug: 3,
+  code: 3,
+  orchestrator: 4,
+  plan: 5,
+  architect: 5,
+  ask: 5,
+};
+
+/**
+ * 이 한마디가 무슨 일인지 고른다.
+ *
+ * @param {string} text 사용자가 친 말
+ * @returns {{ mode: string|null, score: number, why: string, 점수들: object }}
+ *          mode 가 null 이면 '모르겠다' 는 뜻이다 — 종합 모드에 그대로 둔다.
+ */
+export function route(text) {
+  const s = String(text ?? '');
+  const 점수들 = {};
+  const 근거 = {};
+
+  for (const [mode, 규칙들] of Object.entries(표)) {
+    let 합 = 0;
+    const 걸린것 = [];
+    for (const [re, 점] of 규칙들) {
+      const m = s.match(re);
+      if (!m) continue;
+      합 += 점;
+      걸린것.push(m[0].trim());
+    }
+    점수들[mode] = 합;
+    근거[mode] = 걸린것;
+  }
+
+  const 순위 = Object.entries(점수들).sort((a, b) => b[1] - a[1]);
+  const [으뜸, 점수] = 순위[0] ?? [null, 0];
+  if (!으뜸 || 점수 < (문턱[으뜸] ?? 4)) {
+    return { mode: null, score: 점수, why: '무슨 일인지 뚜렷하지 않음', 점수들 };
+  }
+
+  // 1·2등이 붙으면 고르지 않는다. 반반인 것을 억지로 정하면 절반은 틀린다.
+  const 둘째 = 순위[1]?.[1] ?? 0;
+  if (점수 - 둘째 < 2 && 둘째 >= (문턱[순위[1][0]] ?? 4)) {
+    return { mode: null, score: 점수, why: `${으뜸} 과 ${순위[1][0]} 가 비슷함`, 점수들 };
+  }
+
+  return {
+    mode: 으뜸,
+    score: 점수,
+    why: 근거[으뜸].slice(0, 2).map((x) => `'${x}'`).join(', '),
+    점수들,
+  };
+}

package/src/agent/session.js

@@ -1,6 +1,8 @@
 // 대화 상태와 컨텍스트 셈. /context 가 보여주는 숫자가 여기서 나온다.
 import { readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
+import { get as workMode, DEFAULT as WORK_DEFAULT } from './modes.js';
+import { normalize as normLevel, DEFAULT as LEVEL_DEFAULT } from '../ui/level.js';
 
 // 토큰 추정 — 정확한 토크나이저 없이 대략만 센다.
 // 한글은 글자당 약 1토큰, 영문·코드는 약 4글자당 1토큰으로 본다.
@@ -25,11 +27,19 @@ const BASE_RULES = `너는 deel 다. 사용자의 작업 폴더 안에서 코드
 - 사용자에게 답할 때는 한국어로, 짧게. 코드를 통째로 붙여넣지 말고 무엇이 달라졌는지 말한다.`;
 
 export class Session {
-  constructor(conn, { root, mode = 'auto', think = 'medium', maxSteps = 24 } = {}) {
+  constructor(conn, { root, mode = 'auto', work = null, level = null, think = 'medium', effort = 'save', web = true, maxSteps = 24 } = {}) {
     this.conn = conn;
     this.root = root;
-    this.mode = mode;
-    this.think = think;
+    this.mode = mode;        // 승인 정책 — 얼마나 물어보나 (auto/confirm/strict)
+    this.work = work ?? WORK_DEFAULT;   // 작업 모드 — 무슨 일을 하는 중인가 (modes.js)
+    // 이번 한마디에만 쓸 모드. 종합 모드일 때 요청을 보고 골라 넣는다 (agent/route.js).
+    // 기본 모드(this.work)는 안 건드린다 — 다음 한마디는 다시 처음부터 고른다.
+    this.routed = null;
+    // 사용자 수준 — 화면에 무엇을 내놓을지만 정한다. 안전 장치는 안 바꾼다 (ui/level.js)
+    this.level = normLevel(level) ?? LEVEL_DEFAULT;
+    this.think = think;      // 기준 강도
+    this.effort = effort;    // 그 강도를 단계별로 어떻게 나눌지 (effort.js)
+    this.web = web;          // 웹 읽기 도구를 줄지 (오프라인이면 무조건 안 준다)
     this.maxSteps = maxSteps;
     this.messages = [];
     this.filesRead = new Map();   // 경로 → 추정 토큰
@@ -53,9 +63,24 @@ export class Session {
     return null;
   }
 
+  /**
+   * 지금 이 순간 실제로 쓰는 작업 모드.
+   *
+   * 종합 모드에서는 한마디마다 골라 넣은 것(routed)이 있고, 그때는 그것이 답이다.
+   * 직접 고른 모드가 있으면 routed 는 비어 있으므로 기본 모드가 그대로 답이 된다.
+   * 도구·추론·프롬프트가 전부 이 값을 봐야 한다. 하나라도 빠뜨리면 어긋난다.
+   */
+  effectiveWork() {
+    return this.routed ?? this.work;
+  }
+
   systemPrompt() {
     const parts = [BASE_RULES];
     parts.push(`\n작업 폴더: ${this.root}\n이 폴더 밖의 파일은 읽지도 쓰지도 못한다.`);
+
+    // 지금 무슨 일을 하는 중인지. 도구 목록도 이 모드에 맞춰 이미 걸러져 있다.
+    const w = workMode(this.effectiveWork());
+    parts.push(`\n--- 지금 모드: ${w.name} (${w.en}) ---\n${w.say}`);
     if (this.rules) parts.push(`\n--- ${this.rules.name} (사용자 규칙, 위 원칙보다 우선) ---\n${this.rules.text}`);
     const listed = this.listedSkills();
     if (listed.length) {

package/src/agent/sessionui.js

@@ -0,0 +1,59 @@
+// deel sessions — 이 폴더에 남아 있는 대화 목록.
+import { c, say, rule, pad, mark, clip, width } from '../ui/ansi.js';
+import { list, remove, sessionsDir } from './store.js';
+import { existsSync } from 'node:fs';
+
+// "3분 전", "어제" 처럼. 목록에서는 절대 시각보다 이쪽이 눈에 잘 들어온다.
+function 언제(d) {
+  const s = Math.floor((Date.now() - d.getTime()) / 1000);
+  if (s < 60) return '방금';
+  if (s < 3600) return `${Math.floor(s / 60)}분 전`;
+  if (s < 86400) return `${Math.floor(s / 3600)}시간 전`;
+  if (s < 172800) return '어제';
+  if (s < 604800) return `${Math.floor(s / 86400)}일 전`;
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+}
+
+export function runSessions(flags = {}) {
+  const root = flags.root ? String(flags.root) : process.cwd();
+
+  if (flags.rm || flags.delete) {
+    const id = String(flags.rm ?? flags.delete);
+    const r = remove(root, id);
+    say('');
+    say(r.error ? `  ${mark.no} ${r.error}` : `  ${mark.ok} 지웠습니다: ${c.bold(r.removed)}`);
+    say('');
+    return r.error ? 1 : 0;
+  }
+
+  const rows = list(root, { limit: flags.all ? 1000 : 20 });
+  say('');
+  rule('이 폴더의 대화', 78);
+  say(`  ${c.gray(root)}`);
+  say('');
+
+  if (!rows.length) {
+    say(`  ${c.gray('남아 있는 대화가 없습니다.')}`);
+    if (!existsSync(sessionsDir(root))) {
+      say(`  ${c.gray('이 폴더에서 deel 을 한 번 쓰면 여기에 쌓입니다.')}`);
+    }
+    say('');
+    return 0;
+  }
+
+  const wId = Math.max(...rows.map((r) => width(r.id)));
+  for (const [i, r] of rows.entries()) {
+    const 최근 = i === 0 ? c.hgreen('●') : c.gray('·');
+    say(`  ${최근} ${c.bold(pad(r.id, wId))}  ${c.gray(pad(언제(r.at), 9))}`
+      + `${c.gray(pad(`${r.turns}턴`, 6, 'right'))}  ${c.gray(pad(clip(r.model, 22), 24))}`);
+    say(`    ${c.gray('  ')}${clip(r.first, 68)}`);
+  }
+  say('');
+  say(`  ${c.gray('가장 최근 것 이어하기')}   ${c.cyan('deel --continue')}`);
+  say(`  ${c.gray('골라서 이어하기')}         ${c.cyan(`deel --resume ${rows[0].id}`)}`);
+  say(`  ${c.gray('하나 지우기')}             ${c.cyan(`deel sessions --rm ${rows.at(-1).id}`)}`);
+  say('');
+  say(`  ${c.gray(`저장 위치: ${sessionsDir(root)}  (.gitignore 에 들어 있어 깃에 안 올라갑니다)`)}`);
+  say('');
+  return 0;
+}

package/src/agent/store.js

@@ -0,0 +1,193 @@
+// 대화를 파일에 남겨 두고, 껐다 켜도 이어서 하게 한다.
+//
+// 왜 필요한가:
+//   터미널을 실수로 닫거나, 컴퓨터가 재부팅되거나, 긴 작업 중 자리를 뜨는 일은 늘 있다.
+//   그때 대화가 통째로 날아가면 모델이 알아낸 것·정한 것이 전부 사라진다.
+//   다시 설명하는 비용이 실제 작업보다 큰 경우도 많다.
+//
+// 어디에 두나:
+//   작업 폴더의 .deel/sessions/<id>.jsonl — 그 폴더의 일은 그 폴더에 남긴다.
+//   .gitignore 에 .deel/ 이 들어 있어 깃에 올라가지 않는다.
+//
+// 왜 jsonl 인가:
+//   한 줄에 한 메시지씩 이어 붙이기만 하면 된다. 도중에 프로그램이 죽어도
+//   마지막 줄까지는 성하다. 통째로 다시 쓰는 방식이면 그 순간 파일이 깨진다.
+import {
+  existsSync, mkdirSync, readdirSync, readFileSync,
+  appendFileSync, writeFileSync, statSync, rmSync,
+} from 'node:fs';
+import { join } from 'node:path';
+
+export const sessionsDir = (root) => join(root, '.deel', 'sessions');
+
+// 사람이 읽을 수 있고 정렬하면 시간순인 id.
+export function newId(at = new Date()) {
+  const p = (n, w = 2) => String(n).padStart(w, '0');
+  return `${at.getFullYear()}${p(at.getMonth() + 1)}${p(at.getDate())}`
+    + `-${p(at.getHours())}${p(at.getMinutes())}${p(at.getSeconds())}`;
+}
+
+/**
+ * 아직 안 쓰인 id 를 고른다.
+ *
+ * id 가 초 단위라서, 창을 두 개 거의 동시에 열면 같은 id 가 나온다.
+ * 그러면 서로 다른 두 대화가 한 파일에 섞여 들어가고 되살릴 때 뒤엉킨다.
+ * 이미 있는 이름이면 뒤에 번호를 붙여 피한다.
+ */
+export function freeId(dir, at = new Date()) {
+  const base = newId(at);
+  if (!existsSync(join(dir, `${base}.jsonl`))) return base;
+  for (let n = 2; n < 1000; n++) {
+    const id = `${base}-${n}`;
+    if (!existsSync(join(dir, `${id}.jsonl`))) return id;
+  }
+  return `${base}-${process.pid}`;
+}
+
+export class Store {
+  constructor(root, id = null) {
+    this.root = root;
+    this.dir = sessionsDir(root);
+    this.auto = id == null;      // 우리가 지은 이름인가 (그러면 겹칠 때 바꿔도 된다)
+    this.#use(id ?? freeId(this.dir));
+    this.opened = false;
+  }
+
+  #use(id) {
+    this.id = id;
+    this.file = join(this.dir, `${id}.jsonl`);
+  }
+
+  #open() {
+    if (this.opened) return;
+    mkdirSync(this.dir, { recursive: true });
+    this.opened = true;
+  }
+
+  /**
+   * 첫 줄은 머리글 — 어떤 모델·어떤 폴더에서 한 대화인지.
+   *
+   * 'wx' 로 만든다: 이미 있으면 실패한다. 이름을 확인하고 만드는 사이에
+   * 다른 창이 같은 이름을 채 갔을 수 있어서, 그때는 다른 이름으로 옮겨 간다.
+   * 사용자가 --resume 으로 이름을 준 경우에는 옮기지 않고 그 파일에 이어 쓴다.
+   */
+  begin(meta) {
+    this.#open();
+    const head = JSON.stringify({ t: 'meta', at: new Date().toISOString(), ...meta }) + '\n';
+    for (let tries = 0; tries < 50; tries++) {
+      try {
+        writeFileSync(this.file, head, { encoding: 'utf8', flag: 'wx' });
+        return this;
+      } catch (err) {
+        if (err?.code !== 'EEXIST') return this;   // 못 적어도 대화는 계속돼야 한다
+        if (!this.auto) return this;               // 이어쓰기 — 이미 있는 게 맞다
+        this.#use(freeId(this.dir));               // 누가 채 갔다. 옆자리로.
+      }
+    }
+    return this;
+  }
+
+  #write(obj) {
+    try { appendFileSync(this.file, JSON.stringify(obj) + '\n', 'utf8'); }
+    catch { /* 기록에 실패해도 대화는 계속돼야 한다 */ }
+  }
+
+  // 메시지 하나를 덧붙인다. 대화가 진행되는 대로 즉시 남긴다.
+  append(msg) {
+    this.#open();
+    this.#write({ t: 'msg', m: msg });
+  }
+
+  // 압축이 일어나면 이력이 통째로 바뀐다. 그때는 새로 적는다.
+  replace(messages, note = '압축') {
+    this.#open();
+    const meta = this.readMeta() ?? {};
+    const lines = [JSON.stringify({ t: 'meta', at: new Date().toISOString(), ...meta })];
+    lines.push(JSON.stringify({ t: 'note', at: new Date().toISOString(), note }));
+    for (const m of messages) lines.push(JSON.stringify({ t: 'msg', m }));
+    try { writeFileSync(this.file, lines.join('\n') + '\n', 'utf8'); } catch {}
+  }
+
+  readMeta() {
+    if (!existsSync(this.file)) return null;
+    try {
+      const first = readFileSync(this.file, 'utf8').split('\n', 1)[0];
+      const j = JSON.parse(first);
+      return j.t === 'meta' ? j : null;
+    } catch { return null; }
+  }
+
+  // 저장된 대화를 읽어 온다. 깨진 줄은 건너뛴다 — 도중에 죽었을 수 있다.
+  load() {
+    if (!existsSync(this.file)) return { meta: null, messages: [] };
+    let meta = null;
+    const messages = [];
+    for (const line of readFileSync(this.file, 'utf8').split('\n')) {
+      if (!line.trim()) continue;
+      let j;
+      try { j = JSON.parse(line); } catch { continue; }
+      if (j.t === 'meta') meta = j;
+      else if (j.t === 'msg' && j.m) messages.push(j.m);
+    }
+    return { meta, messages };
+  }
+}
+
+// 사람에게 보여줄 첫 마디. 이게 목록에서 대화를 알아보는 유일한 단서다.
+function firstAsk(messages) {
+  const m = messages.find((x) => x.role === 'user' && typeof x.content === 'string'
+    && x.content.trim() && !x.content.startsWith('['));
+  return m ? m.content.replace(/\s+/g, ' ').trim() : '(빈 대화)';
+}
+
+/**
+ * 이 폴더에 남아 있는 대화 목록. 최근 것이 위로.
+ */
+export function list(root, { limit = 20 } = {}) {
+  const dir = sessionsDir(root);
+  if (!existsSync(dir)) return [];
+  const out = [];
+  for (const name of readdirSync(dir)) {
+    if (!name.endsWith('.jsonl')) continue;
+    const id = name.slice(0, -6);
+    const file = join(dir, name);
+    let st;
+    try { st = statSync(file); } catch { continue; }
+    const { meta, messages } = new Store(root, id).load();
+    if (!messages.length) continue;
+    out.push({
+      id,
+      file,
+      at: st.mtime,
+      bytes: st.size,
+      model: meta?.model ?? '?',
+      turns: messages.filter((m) => m.role === 'user').length,
+      messages: messages.length,
+      first: firstAsk(messages),
+    });
+  }
+  return out.sort((a, b) => b.at - a.at).slice(0, limit);
+}
+
+export function remove(root, id) {
+  const f = join(sessionsDir(root), `${id}.jsonl`);
+  if (!existsSync(f)) return { error: `그런 대화가 없습니다: ${id}` };
+  rmSync(f, { force: true });
+  return { removed: id };
+}
+
+/** 가장 최근 대화. --continue 가 집어 오는 것. */
+export function latest(root) {
+  return list(root, { limit: 1 })[0] ?? null;
+}
+
+/**
+ * 오래된 것은 정리한다. 안 그러면 폴더가 끝없이 자란다.
+ * 최근 keep 개는 무조건 남기고, 그보다 오래되고 days 를 넘긴 것만 지운다.
+ */
+export function prune(root, { keep = 30, days = 30 } = {}) {
+  const all = list(root, { limit: 1000 });
+  const 자를것 = all.slice(keep).filter((s) => (Date.now() - s.at.getTime()) > days * 86400000);
+  for (const s of 자를것) { try { rmSync(s.file, { force: true }); } catch {} }
+  return 자를것.length;
+}

package/src/backend/adapter.js

@@ -1,6 +1,6 @@
 // 규격 차이(OpenAI 호환 / Ollama)를 여기 한 곳에서만 흡수한다.
 // 진단(probe)과 에이전트 루프가 같은 함수를 쓴다.
-import { req, headersFor, serverMessage } from './http.js';
+import { req, headersFor, serverMessage, Aborted } from './http.js';
 
 export function endpoint(shape) {
   return shape === 'ollama' ? '/api/chat' : '/chat/completions';
@@ -88,6 +88,7 @@ export async function chat(conn, opts) {
     headers: headersFor(conn.auth, conn.key ?? ''),
     body,
     timeout: opts.timeout ?? 300000,
+    signal: opts.signal ?? null,
   });
   if (!r.ok) throw new Error(serverMessage(r));
   return extractMessage(conn.kind, r.json);
@@ -102,6 +103,7 @@ export async function* chatStream(conn, opts) {
     body,
     timeout: opts.timeout ?? 300000,
     stream: true,
+    signal: opts.signal ?? null,
   });
   if (!r.ok || !r.res?.body) throw new Error(r.error ?? `HTTP ${r.status}`);
 
@@ -111,7 +113,15 @@ export async function* chatStream(conn, opts) {
   let buf = '';
 
   while (true) {
-    const { done, value } = await reader.read();
+    // 사용자가 끊었으면 흘러오는 것을 더 받지 않는다. 읽던 연결도 닫는다.
+    if (opts.signal?.aborted) {
+      try { await reader.cancel(); } catch {}
+      throw new Aborted();
+    }
+    let done;
+    let value;
+    try { ({ done, value } = await reader.read()); }
+    catch (err) { if (opts.signal?.aborted) throw new Aborted(); throw err; }
     if (done) break;
     buf += dec.decode(value, { stream: true });
 

package/src/backend/ctxsize.js

@@ -0,0 +1,174 @@
+// 모델이 한 번에 받아 줄 수 있는 길이(컨텍스트)를 서버에서 알아낸다.
+//
+// 왜 파일을 따로 뒀는가:
+//
+// 이 숫자 하나가 프로그램 전체를 좌우한다. 이게 작으면 파일을 몇 개 못 읽히고,
+// 대화가 금방 접히고, 한 번에 쓸 수 있는 답 길이도 같이 줄어든다(effort.js 가
+// 이 값에서 상한을 계산한다). 예전에는 못 알아내면 32768 로 뒀는데, 요즘
+// 로컬 모델은 262,144 · 655,360 처럼 훨씬 크다. 32k 로 깔고 앉으면 모델이
+// 가진 것의 5% 만 쓰는 셈이다.
+//
+// 문제는 서버마다 이 숫자를 다른 이름, 다른 자리에 둔다는 것이다. 그래서
+// 한 군데만 보지 않고 아는 자리를 전부 훑는다. 한 번에 다 못 찾아도
+// 부분만 찾으면 그걸 쓴다.
+//
+//   OpenAI 호환    /v1/models/{id}  또는 /v1/models 목록 안의 그 항목
+//   LM Studio      /api/v0/models   (max_context_length · loaded_context_length)
+//   llama.cpp      /props           (n_ctx)
+//   vLLM           /v1/models       (max_model_len)
+//   Ollama         /api/show        (…​.context_length)
+//
+// '올린 길이' 와 '모델 최대' 를 구분한다. LM Studio 는 모델이 655,360 까지
+// 되더라도 8,192 로 올려 둘 수 있다. 그 상태에서 655,360 을 믿고 보내면
+// 서버가 거절한다. 그래서 실제로 쓸 값은 '올린 길이' 로 잡고, '모델 최대' 는
+// 따로 알려 준다 — 사용자가 서버에서 더 올린 다음 /ctx 로 맞출 수 있게.
+import { req, headersFor } from './http.js';
+
+// 이 이름들 중 하나면 컨텍스트 길이다. 순서가 곧 우선순위다.
+const 최대이름 = [
+  'max_context_length',      // LM Studio
+  'context_window',          // 일부 게이트웨이
+  'context_length',          // llama.cpp·HF 계열
+  'max_model_len',           // vLLM
+  'max_input_tokens',        // LiteLLM·OpenRouter 계열
+  'n_ctx',                   // llama.cpp
+  'max_position_embeddings', // 모델 config 원본
+  'max_sequence_length',
+  'max_seq_len',
+];
+const 올린이름 = ['loaded_context_length', 'n_ctx', 'context_length'];
+
+// 사람이 알아볼 수 없는 값은 안 받는다. 512 미만은 오독, 1000만 초과는 단위 착각.
+const 최소 = 512;
+const 최대허용 = 10_000_000;
+
+function 성한수(v) {
+  const n = Number(v);
+  if (!Number.isFinite(n)) return null;
+  const i = Math.floor(n);
+  return i >= 최소 && i <= 최대허용 ? i : null;
+}
+
+/**
+ * 객체 어디에 박혀 있어도 찾는다.
+ *
+ * 서버가 { data: { meta: { config: { max_position_embeddings: 655360 } } } } 처럼
+ * 깊이 넣어 두는 일이 흔하다. 그래서 이름으로 훑는다. 다만 아무 데나 파고들면
+ * 엉뚱한 숫자를 집으므로 깊이를 5 로 막는다.
+ */
+function 파보기(obj, 이름들, depth = 0) {
+  if (!obj || typeof obj !== 'object' || depth > 5) return null;
+  for (const key of 이름들) {
+    const v = 성한수(obj[key]);
+    if (v) return v;
+  }
+  // 이름이 정확히 안 맞으면 '…context_length' 처럼 끝나는 것도 본다 (Ollama).
+  for (const [k, v] of Object.entries(obj)) {
+    if (/(^|[._])(context_length|context_window|n_ctx)$/i.test(k)) {
+      const n = 성한수(v);
+      if (n) return n;
+    }
+  }
+  for (const v of Object.values(obj)) {
+    if (v && typeof v === 'object') {
+      const found = 파보기(v, 이름들, depth + 1);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+// 목록 응답에서 이 모델 항목만 골라낸다.
+function 목록에서찾기(json, model) {
+  const list = json?.data ?? json?.models ?? (Array.isArray(json) ? json : []);
+  if (!Array.isArray(list)) return null;
+  return list.find((m) => (m?.id ?? m?.name ?? m?.model) === model) ?? null;
+}
+
+/**
+ * 서버에 물어 컨텍스트 길이를 알아낸다.
+ *
+ * @param {{kind:string, base:string, auth:string, key:string, model:string}} conn
+ * @returns {Promise<{value:number|null, max:number|null, loaded:number|null, source:string|null, tried:Array}>}
+ */
+export async function probeCtx(conn, { timeout = 12000 } = {}) {
+  const H = () => headersFor(conn.auth, conn.key);
+  const base = String(conn.base ?? '').replace(/\/+$/, '');
+  const origin = base.replace(/\/v\d+$/, '').replace(/\/api$/, '');
+  const model = conn.model;
+  const tried = [];
+  let max = null;
+  let loaded = null;
+  let source = null;
+
+  const 본다 = async (label, url, opts = {}) => {
+    if (max && loaded) return null;
+    try {
+      const r = await req(url, { headers: H(), timeout, ...opts });
+      tried.push({ label, url, status: r.status ?? 0, ok: !!r.ok });
+      return r.ok ? r.json : null;
+    } catch (err) {
+      tried.push({ label, url, status: 0, ok: false, why: String(err?.message ?? err) });
+      return null;
+    }
+  };
+
+  const 담기 = (json, label, { 목록 = false } = {}) => {
+    if (!json) return;
+    const 대상 = 목록 ? 목록에서찾기(json, model) : json;
+    if (!대상) return;
+    const m = 파보기(대상, 최대이름);
+    const l = 파보기(대상, 올린이름);
+    if (m && !max) { max = m; source = label; }
+    if (l && !loaded) loaded = l;
+  };
+
+  if (conn.kind === 'ollama') {
+    담기(await 본다('Ollama /api/show', `${origin}/api/show`, { method: 'POST', body: { model } }), 'Ollama 모델 정보');
+  } else {
+    // 1) 이 모델만 콕 집어 묻는다. 있으면 가장 정확하다.
+    담기(await 본다('모델 상세', `${base}/models/${encodeURIComponent(model)}`), '모델 상세');
+
+    // 2) LM Studio 는 자기 규격에만 '올린 길이' 를 준다. 이게 실제로 쓸 값이다.
+    담기(await 본다('LM Studio 상세', `${origin}/api/v0/models/${encodeURIComponent(model)}`), 'LM Studio');
+    담기(await 본다('LM Studio 목록', `${origin}/api/v0/models`), 'LM Studio', { 목록: true });
+
+    // 3) 목록 응답 안에 들어 있는 경우 (vLLM 의 max_model_len 이 여기 있다)
+    담기(await 본다('모델 목록', `${base}/models`), '모델 목록', { 목록: true });
+
+    // 4) llama.cpp 서버는 /props 로만 알려 준다.
+    const props = await 본다('llama.cpp /props', `${origin}/props`);
+    if (props) {
+      const n = 파보기(props, ['n_ctx', 'context_length']);
+      if (n) { if (!max) { max = n; source = 'llama.cpp'; } if (!loaded) loaded = n; }
+    }
+  }
+
+  // 실제로 쓸 값: 올려 둔 길이가 있으면 그것. 없으면 모델 최대.
+  const value = loaded ?? max ?? null;
+  return { value, max, loaded, source, tried };
+}
+
+/**
+ * "655360" · "655k" · "128K" · "1m" 을 숫자로. 못 읽으면 null.
+ *
+ * k/m 을 받는 이유는 단순하다 — 655360 을 손으로 치면 자릿수를 틀린다.
+ */
+export function parseSize(text) {
+  const s = String(text ?? '').trim().replace(/[,_\s]/g, '').toLowerCase();
+  const m = /^(\d+(?:\.\d+)?)([km])?$/.exec(s);
+  if (!m) return null;
+  const mult = m[2] === 'm' ? 1024 * 1024 : m[2] === 'k' ? 1024 : 1;
+  return 성한수(Number(m[1]) * mult);
+}
+
+/** 33k · 655k · 1.0M — 화면에 넣을 짧은 표기 */
+export function fmtSize(n) {
+  const v = Number(n) || 0;
+  if (v < 1000) return String(v);
+  if (v < 1024 * 1024) return Math.round(v / 1024) + 'k';
+  return (v / (1024 * 1024)).toFixed(1) + 'M';
+}
+
+/** 서버가 끝내 안 알려 줄 때 쓰는 값. 옛날 32768 보다는 요즘 기본에 가깝다. */
+export const 기본값 = 32768;