deel-local-cli 0.8.0 → 1.0.0

package/src/agent/compact.js

@@ -1,138 +1,131 @@
-// 컨텍스트가 차면 오래된 대화를 '요약해서' 이어 간다.
-//
-// 그냥 잘라내면 방금까지 뭘 하고 있었는지 모델이 잊는다. 파일을 다시 읽고,
-// 이미 고친 곳을 또 고치고, 정해 둔 방침을 어긴다. 그래서 자르는 대신 접는다.
-//
-// 접을 때 지켜야 하는 것 두 가지:
-//   1) 도구 호출과 그 결과는 한 몸이다. 사이를 끊으면 규격 위반이라 서버가 400 을 낸다.
-//   2) 요약도 모델이 만든다. 그 요청이 실패하면 프로그램이 멈추면 안 된다 —
-//      실패하면 옛 방식(그냥 자르기)으로 물러선다.
-import { chat } from '../backend/adapter.js';
-import { estimateTokens } from './session.js';
-
-// 몇 %에서 접기 시작할지. 접고 나서 다시 금방 차면 아무 소용이 없으니 넉넉히 비운다.
-export const COMPACT_AT = 0.8;
-export const KEEP_TAIL_RATIO = 0.3;   // 최근 대화 중 남길 비율
-export const KEEP_HEAD = 2;           // 맨 처음 요청은 언제나 남긴다 (목표가 거기 있다)
-
-const 요약지시 = `지금까지의 대화를 다음 형식으로 요약하세요. 이어서 일할 사람이 이것만 보고도 계속할 수 있어야 합니다.
-추측하지 말고 실제로 오간 내용만 쓰세요. 한국어로, 각 항목 3줄 이내로 쓰세요.
-
-## 목표
-사용자가 무엇을 시켰는가.
-
-## 한 일
-어떤 파일을 어떻게 고쳤는가. 파일 경로를 그대로 적으세요.
-
-## 알아낸 것
-코드·환경에 대해 확인된 사실. 다시 조사하지 않아도 되도록.
-
-## 정한 것
-어떤 방침·이름·구조로 하기로 했는가. 사용자가 거절한 것도 적으세요.
-
-## 남은 일
-아직 안 한 것.`;
-
-/**
- * 도구 호출과 결과가 갈라지지 않는 자리를 찾는다.
- * i 번째부터 남긴다고 할 때, 안전한 i 로 옮겨 준다.
- */
-export function safeCut(messages, i) {
-  let k = Math.max(0, Math.min(i, messages.length));
-  // tool 결과로 시작하면 그 앞의 assistant(tool_calls) 가 없어 규격이 깨진다. 앞으로 당긴다.
-  while (k > 0 && messages[k]?.role === 'tool') k--;
-  return k;
-}
-
-/**
- * 머리 쪽 자르는 자리.
- * 머리가 '결과를 기다리는 도구 호출' 로 끝나면 그 결과가 접혀 없어져 짝이 깨진다.
- * 그런 assistant 는 머리에서 뺀다 — 접히는 쪽에 같이 넘긴다.
- */
-export function safeHead(messages, k) {
-  let h = Math.max(0, Math.min(k, messages.length));
-  while (h > 0 && messages[h - 1]?.tool_calls?.length) h--;
-  return h;
-}
-
-/** 접을 구간과 남길 구간을 나눈다. */
-export function split(messages, { keepHead = KEEP_HEAD, tailRatio = KEEP_TAIL_RATIO } = {}) {
-  const n = messages.length;
-  const wantTail = Math.max(4, Math.floor(n * tailRatio));
-  const cut = safeCut(messages, n - wantTail);
-  const head = safeHead(messages, Math.min(keepHead, cut));
-  if (cut <= head) return null;                    // 접을 것이 없다
-  const fold = messages.slice(head, cut);
-  if (fold.length < 4) return null;
-  return { head: messages.slice(0, head), fold, tail: messages.slice(cut) };
-}
-
-// 요약에 넣을 글. 도구 결과는 길기만 하고 요약에 도움이 안 되니 앞부분만 준다.
-function transcript(msgs) {
-  const out = [];
-  for (const m of msgs) {
-    const who = m.role === 'user' ? '사용자' : m.role === 'assistant' ? '나' : '도구결과';
-    let body = typeof m.content === 'string' ? m.content : JSON.stringify(m.content ?? '');
-    if (m.role === 'tool') body = body.slice(0, 400);
-    const calls = (m.tool_calls ?? []).map((t) => {
-      const fn = t.function ?? t;
-      const args = typeof fn.arguments === 'string' ? fn.arguments : JSON.stringify(fn.arguments ?? {});
-      return `${fn.name}(${args.slice(0, 160)})`;
-    });
-    if (calls.length) out.push(`${who}: [도구] ${calls.join(', ')}`);
-    if (body.trim()) out.push(`${who}: ${body.trim()}`);
-  }
-  return out.join('\n');
-}
-
-/**
- * 실제로 접는다.
- * @returns {{ok:boolean, folded:number, before:number, after:number, summary?:string, why?:string}}
- */
-export async function compact(session, { auto = false } = {}) {
-  const before = session.breakdown().used;
-  const parts = split(session.messages);
-  if (!parts) return { ok: false, why: '접을 만큼 쌓이지 않았습니다', folded: 0, before, after: before };
-
-  const text = transcript(parts.fold);
-  let summary = null;
-  try {
-    const r = await chat(session.conn, {
-      messages: [
-        { role: 'system', content: '너는 대화를 요약한다. 요약 외에 다른 말을 하지 않는다.' },
-        { role: 'user', content: `${요약지시}\n\n----- 대화 -----\n${text}` },
-      ],
-      maxTokens: 1200,
-      think: session.conn.kind === 'ollama' ? false : 'low',   // 요약에 깊은 사고는 필요 없다
-    });
-    summary = (r.content ?? '').trim();
-  } catch (err) {
-    summary = null;
-  }
-
-  // 요약을 못 받았으면 옛 방식으로 물러선다. 멈추지는 않는다.
-  if (!summary) {
-    const folded = session.trim();
-    const after = session.breakdown().used;
-    return { ok: folded > 0, folded, before, after, why: '요약을 받지 못해 그냥 줄였습니다', fallback: true };
-  }
-
-  session.messages = [
-    ...parts.head,
-    {
-      role: 'user',
-      content: `[앞선 대화 ${parts.fold.length}개를 요약해 접었습니다. 아래가 그 요약입니다.]\n\n${summary}\n\n[요약 끝. 이어서 진행하세요. 파일 내용이 필요하면 다시 읽으세요.]`,
-    },
-    ...parts.tail,
-  ];
-  session.filesRead.clear();   // 접힌 뒤에는 읽어 둔 파일도 기억에서 지운다
-
-  const after = session.breakdown().used;
-  return { ok: true, folded: parts.fold.length, before, after, summary, auto };
-}
-
-/** 지금 접어야 하는가. */
-export function shouldCompact(session, at = COMPACT_AT) {
-  const b = session.breakdown();
-  return b.total > 0 && b.used / b.total >= at;
-}
+// 컨텍스트가 차면 오래된 대화를 '요약해서' 이어 간다.
+//
+// 그냥 잘라내면 방금까지 뭘 하고 있었는지 모델이 잊는다. 파일을 다시 읽고,
+// 이미 고친 곳을 또 고치고, 정해 둔 방침을 어긴다. 그래서 자르는 대신 접는다.
+//
+// 접을 때 지켜야 하는 것 두 가지:
+//   1) 도구 호출과 그 결과는 한 몸이다. 사이를 끊으면 규격 위반이라 서버가 400 을 낸다.
+//   2) 요약도 모델이 만든다. 그 요청이 실패하면 프로그램이 멈추면 안 된다 —
+//      실패하면 옛 방식(그냥 자르기)으로 물러선다.
+import { chat } from '../backend/adapter.js';
+import { estimateTokens, safeCut, safeHead } from './session.js';
+
+// 몇 %에서 접기 시작할지. 접고 나서 다시 금방 차면 아무 소용이 없으니 넉넉히 비운다.
+export const COMPACT_AT = 0.8;
+export const KEEP_TAIL_RATIO = 0.3;   // 최근 대화 중 남길 비율
+export const KEEP_HEAD = 2;           // 맨 처음 요청은 언제나 남긴다 (목표가 거기 있다)
+
+const 요약지시 = `지금까지의 대화를 다음 형식으로 요약하세요. 이어서 일할 사람이 이것만 보고도 계속할 수 있어야 합니다.
+추측하지 말고 실제로 오간 내용만 쓰세요. 한국어로, 각 항목 3줄 이내로 쓰세요.
+
+## 목표
+사용자가 무엇을 시켰는가.
+
+## 한 일
+어떤 파일을 어떻게 고쳤는가. 파일 경로를 그대로 적으세요.
+
+## 알아낸 것
+코드·환경에 대해 확인된 사실. 다시 조사하지 않아도 되도록.
+
+## 정한 것
+어떤 방침·이름·구조로 하기로 했는가. 사용자가 거절한 것도 적으세요.
+
+## 남은 일
+아직 안 한 것.`;
+
+// 자르는 자리를 찾는 두 함수는 session.js 에 있다. 접기와 그냥 줄이기(trim)가
+// **같은 잣대**를 써야 하기 때문이다 — 한쪽만 짝을 맞추면 물러서는 순간 대화가 망가진다.
+// 쓰던 자리가 있으니 이름은 그대로 내보낸다.
+export { safeCut, safeHead } from './session.js';
+
+/** 접을 구간과 남길 구간을 나눈다. */
+export function split(messages, { keepHead = KEEP_HEAD, tailRatio = KEEP_TAIL_RATIO } = {}) {
+  const n = messages.length;
+  const wantTail = Math.max(4, Math.floor(n * tailRatio));
+  const cut = safeCut(messages, n - wantTail);
+  const head = safeHead(messages, Math.min(keepHead, cut));
+  if (cut <= head) return null;                    // 접을 것이 없다
+  const fold = messages.slice(head, cut);
+  if (fold.length < 4) return null;
+  return { head: messages.slice(0, head), fold, tail: messages.slice(cut) };
+}
+
+// 요약에 넣을 글. 도구 결과는 길기만 하고 요약에 도움이 안 되니 앞부분만 준다.
+function transcript(msgs) {
+  const out = [];
+  for (const m of msgs) {
+    const who = m.role === 'user' ? '사용자' : m.role === 'assistant' ? '나' : '도구결과';
+    let body = typeof m.content === 'string' ? m.content : JSON.stringify(m.content ?? '');
+    if (m.role === 'tool') body = body.slice(0, 400);
+    const calls = (m.tool_calls ?? []).map((t) => {
+      const fn = t.function ?? t;
+      const args = typeof fn.arguments === 'string' ? fn.arguments : JSON.stringify(fn.arguments ?? {});
+      return `${fn.name}(${args.slice(0, 160)})`;
+    });
+    if (calls.length) out.push(`${who}: [도구] ${calls.join(', ')}`);
+    if (body.trim()) out.push(`${who}: ${body.trim()}`);
+  }
+  return out.join('\n');
+}
+
+/**
+ * 실제로 접는다.
+ * @returns {{ok:boolean, folded:number, before:number, after:number, summary?:string, why?:string}}
+ */
+export async function compact(session, { auto = false, signal = null } = {}) {
+  const before = session.breakdown().used;
+  const parts = split(session.messages);
+  if (!parts) return { ok: false, why: '접을 만큼 쌓이지 않았습니다', folded: 0, before, after: before };
+
+  const text = transcript(parts.fold);
+  let summary = null;
+  try {
+    const r = await chat(session.conn, {
+      messages: [
+        { role: 'system', content: '너는 대화를 요약한다. 요약 외에 다른 말을 하지 않는다.' },
+        { role: 'user', content: `${요약지시}\n\n----- 대화 -----\n${text}` },
+      ],
+      maxTokens: 1200,
+      think: session.conn.kind === 'ollama' ? false : 'low',   // 요약에 깊은 사고는 필요 없다
+      // 사용자가 Ctrl+C 를 누르면 이것도 멈춰야 한다. 안 받으면 답하는 도중
+      // 화면이 멈춰 있고 아무 키도 안 먹는 것처럼 보인다.
+      signal,
+      // 요약 하나에 5분을 기다릴 이유가 없다. 그만한 서버면 그냥 줄이는 편이 빠르다.
+      timeout: 60000,
+    });
+    summary = (r.content ?? '').trim();
+  } catch (err) {
+    // 사용자가 끊은 것은 실패가 아니다. 대화를 건드리지 않고 그대로 둔다 —
+    // 여기서 물러서기(trim)까지 해 버리면, 끊었는데 대화가 줄어 있게 된다.
+    if (err?.name === 'Aborted' || signal?.aborted) {
+      return { ok: false, aborted: true, why: '중단했습니다', folded: 0, before, after: before };
+    }
+    summary = null;
+  }
+
+  // 요약을 못 받았으면 옛 방식으로 물러선다. 멈추지는 않는다.
+  if (!summary) {
+    const folded = session.trim();
+    const after = session.breakdown().used;
+    return { ok: folded > 0, folded, before, after, why: '요약을 받지 못해 그냥 줄였습니다', fallback: true };
+  }
+
+  session.messages = [
+    ...parts.head,
+    {
+      role: 'user',
+      content: `[앞선 대화 ${parts.fold.length}개를 요약해 접었습니다. 아래가 그 요약입니다.]\n\n${summary}\n\n[요약 끝. 이어서 진행하세요. 파일 내용이 필요하면 다시 읽으세요.]`,
+    },
+    ...parts.tail,
+  ];
+  session.filesRead.clear();   // 접힌 뒤에는 읽어 둔 파일도 기억에서 지운다
+
+  const after = session.breakdown().used;
+  return { ok: true, folded: parts.fold.length, before, after, summary, auto };
+}
+
+/** 지금 접어야 하는가. */
+export function shouldCompact(session, at = COMPACT_AT) {
+  const b = session.breakdown();
+  return b.total > 0 && b.used / b.total >= at;
+}

package/src/agent/effort.js

@@ -21,34 +21,56 @@ export const STAGES = {
 // 출력 상한을 숫자로 못 박으면 안 된다. 컨텍스트 4k 짜리 모델에 4096 을 주면
 // 입력 자리가 하나도 안 남고, 200k 짜리 모델에는 턱없이 모자란다.
 // 그래서 '남은 자리의 몇 %' 로 정하고, 아래위로만 울타리를 친다.
+//
+// share 를 왜 넉넉히 잡나 — 여기서 한 번 잘못 알고 있었다:
+//   상한은 '쓸 예산' 이 아니라 '넘지 못하는 선' 이다. 상한을 작게 잡아도 모델이
+//   짧게 답하면 토큰은 그만큼만 나간다. 아끼는 효과가 없다. 반대로 답이 그 선에
+//   닿으면 **말이 중간에서 끊긴다.** 즉 share 를 조이면 아끼는 게 아니라 자르는 것이다.
+//
+//   실제로 그래서 파일이 안 만들어졌다. 이어가기(work) 가 0.15 였는데, 파일을 쓰는
+//   호출은 대개 이 단계에서 나온다. 32k 모델에서 4,600 토큰 — 1,000줄짜리 HTML 은
+//   그 세 배가 필요하다. 매번 같은 자리에서 잘렸다.
+//
+//   다음 턴이 들어갈 자리는 아래 tokensFor 의 room/2 가 이미 지킨다. 그러니 여기서
+//   또 조일 이유가 없다. 단계별 차이는 남겨 두되, 어느 단계든 한 번은 쓸 만큼 준다.
 export const PROFILES = {
   even: {
     name: '균일',
     desc: '모든 단계 같은 강도 — 예측 가능한 대신 느립니다',
     shift: { plan: 0, work: 0, fix: 0 },
-    share: { plan: 0.30, work: 0.30, fix: 0.30 },
+    share: { plan: 0.40, work: 0.40, fix: 0.40 },
   },
   save: {
     name: '절약',
     desc: '첫 판단만 세게, 이어가기는 얕게 — 대개 이게 낫습니다',
     shift: { plan: 0, work: -1, fix: +1 },
-    share: { plan: 0.30, work: 0.15, fix: 0.30 },
+    share: { plan: 0.40, work: 0.35, fix: 0.45 },
   },
   deep: {
     name: '깊게',
     desc: '전 단계 한 칸씩 위로 — 어려운 일에만',
     shift: { plan: +1, work: 0, fix: +1 },
-    share: { plan: 0.45, work: 0.30, fix: 0.45 },
+    share: { plan: 0.50, work: 0.45, fix: 0.50 },
   },
 };
 
 // 울타리.
 // 아래: 이보다 작으면 도구 호출 한 개도 못 뱉는다. 생각을 많이 하는 모델은 더 필요하다.
-// 위:   이 이상은 어떤 모델도 한 번에 잘 안 낸다. 실수로 큰 값을 보내 튕기는 것도 막는다.
 export const MIN_CAP = 512;
-// 컨텍스트가 128k 라도 '한 번에 낼 수 있는 출력' 은 대개 훨씬 작다.
-// 모델 한계보다 큰 max_tokens 를 보내면 그냥 거부하는 게이트웨이가 있어서
-// 안전한 선에서 멈춘다. 더 필요하면 프로필에 maxTokens 를 적어 올릴 수 있다.
+/**
+ * 출력 상한을 **모를 때** 쓰는 값.
+ *
+ * 컨텍스트가 128k 라도 '한 번에 낼 수 있는 출력' 은 대개 훨씬 작다. 모델 한계보다
+ * 큰 max_tokens 를 보내면 그냥 거부하는 게이트웨이가 있어서, 모르면 이 선에 선다.
+ *
+ * **아는 값이 있으면 이 값은 비켜선다.** 전에는 그게 안 됐다 —
+ *   Math.min(cap, max ?? MAX_CAP, MAX_CAP)
+ * 세 번째 인자가 무조건 다시 조여서, 사용자가 적어 둔 max 는 낮출 수만 있고
+ * 올릴 수는 없었다. /ctx out 200k 를 해도 16,384 였다. 그런데 주석도 README 도
+ * /ctx 안내도 셋 다 '올릴 수 있다' 고 말했다. 문서에 적힌 탈출구가 막혀 있었던 것이다.
+ *
+ * 아는 값은 두 곳에서 온다 — 사용자가 정한 것(/out)과 서버에서 알아낸 것(backend/ctxsize).
+ */
 export const MAX_CAP = 16384;
 
 const ALIAS = { 균일: 'even', 절약: 'save', 깊게: 'deep', uniform: 'even', thrifty: 'save' };
@@ -97,7 +119,8 @@ export function tokensFor(profileKey, stage, { ctx = 0, used = 0, max = null } =
   let cap = Math.floor(room * share);
   // 남은 자리의 절반을 넘겨 주지 않는다. 답이 길어져도 다음 턴이 들어갈 자리는 남겨야 한다.
   cap = Math.min(cap, Math.floor(room / 2));
-  cap = Math.min(cap, max ?? MAX_CAP, MAX_CAP);
+  // 아는 상한이 있으면 그것을 따른다. 모를 때만 MAX_CAP 에 선다.
+  cap = Math.min(cap, max ?? MAX_CAP);
   cap = Math.max(cap, MIN_CAP);
   // 남은 자리 자체가 바닥이면 울타리 아래라도 남은 만큼만 준다.
   return room > 0 ? Math.min(cap, Math.max(MIN_CAP, room)) : MIN_CAP;
@@ -106,13 +129,23 @@ export function tokensFor(profileKey, stage, { ctx = 0, used = 0, max = null } =
 /** 잘렸을 때 풀어 줄 최대 상한 — 남은 자리를 거의 다 내준다. */
 export function fullCap({ ctx = 0, used = 0, max = null } = {}) {
   const room = ctx > 0 ? Math.max(0, ctx - used) : 4096;
-  return Math.max(MIN_CAP, Math.min(Math.floor(room * 0.8), max ?? MAX_CAP, MAX_CAP));
+  return Math.max(MIN_CAP, Math.min(Math.floor(room * 0.8), max ?? MAX_CAP));
 }
 
-// 잘린 응답인가. 잘린 채로 넘어가면 도구 호출이 반토막 나서 조용히 실패한다.
+/**
+ * 잘린 응답인가. 잘린 채로 넘어가면 도구 호출이 반토막 나서 조용히 실패한다.
+ *
+ * finish_reason 만 보면 안 된다. 사내 게이트웨이나 중계 서버는 잘라 놓고도
+ * 'stop' 이라고 하는 경우가 실제로 있다. 그러면 상한을 올려 다시 부를 기회를
+ * 놓친 채 반토막 호출이 그냥 지나간다.
+ *
+ * 그런데 인자 JSON 이 깨진 것 자체가 잘렸다는 증거다 — 모델은 반쪽짜리 JSON 을
+ * 일부러 만들지 않는다. 그래서 말을 안 해 줘도 이걸 보고 안다.
+ */
 export function wasCut(msg) {
   const s = String(msg?.stopped ?? '');
-  return s === 'length' || s === 'max_tokens' || s === 'MAX_TOKENS';
+  if (s === 'length' || s === 'max_tokens' || s === 'MAX_TOKENS') return true;
+  return (msg?.toolCalls ?? []).some((t) => t?.argsBroken);
 }
 
 // 화면에 보여줄 표. 상한은 지금 붙어 있는 모델 기준으로 계산해서 보여준다 —