byuckchon-frontend-cli 1.9.0 → 1.9.2

package/README.md

@@ -193,6 +193,10 @@ FE 전반의 규칙(폴더 구조, 네이밍, 스웨거 → 코드 변환 규칙
 
 - **OpenAPI**: chat 시작 시 자동 fetch + 1시간 디스크 캐시 → 엔드포인트 요약을 시스템 프롬프트에 박음.
   - 헤더에 `openapi` 줄로 표시. 캐시 hit 면 `(cached)`, fresh fetch 면 `(live)`.
+  - **세션 중 서버가 스펙을 바꿔도 자동 대응 (v1.10+)**: `search_openapi` / `get_openapi_endpoint` 가
+    캐시에서 엔드포인트를 못 찾으면 **딱 한 번 최신본을 다시 받아 재검색**합니다 (`🔄 OpenAPI 스펙 새로고침`).
+    남용 방지를 위해 세션당 횟수·간격이 제한됩니다. "방금 스웨거 업데이트했어, 다시 읽어줘" 라고 하면
+    즉시 강제 새로고침(`refresh_openapi`)합니다.
 - **코드 인덱스**: chat 시작 시 인덱스 파일이 없으면 **백그라운드에서 자동 빌드**.
   - 빌드 중에는 화면에 `📚 인덱싱 중 ...` 진행 표시. 끝나면 `✓` 메시지 한 줄.
   - OpenAI 키가 없으면 빌드를 건너뛰고 도움 메시지를 띄움 (Anthropic 은 임베딩 API 미제공).
@@ -284,6 +288,8 @@ TTY 안에서 자동으로 ink 모드로 뜨고, 파이프/CI 같은 비-TTY 환
 | ------------------- | ------------------------------------------ |
 | `/help`             | 도움말                                     |
 | `/clear`            | 대화 컨텍스트 초기화                        |
+| `/history`          | 이전 대화 선택 후 해당 컨텍스트 이어가기     |
+| `/retry`            | 마지막 사용자 요청 다시 실행                |
 | `/model [id]`       | 세션 모델 변경 (인자 없으면 목록)           |
 | `/cost`             | 누적 토큰/비용                              |
 | `/image <path>`     | 다음 메시지에 이미지 첨부 (Vision 모델 권장) |
@@ -294,6 +300,10 @@ TTY 안에서 자동으로 ink 모드로 뜨고, 파이프/CI 같은 비-TTY 환
 | `/rag on\|off`      | RAG 컨텍스트 주입 즉석 토글                 |
 | `/exit`             | 종료 (`Ctrl+C` 도 가능)                     |
 
+Ink 모드에서 `/history`를 실행하면 `↑↓`로 세션을 선택하고 `Enter`로 불러올 수 있습니다.
+선택한 세션에서 `d`를 누른 뒤 `y`로 확인하면 해당 기록을 삭제합니다. 메시지를 한 번도
+보내지 않고 종료한 빈 세션은 저장되거나 목록에 표시되지 않습니다.
+
 이미지 첨부는 png / jpg / jpeg / gif / webp 만 지원하며,
 Claude / GPT 비전 모델에 멀티파트 메시지로 전달됩니다.
 

package/bin/index.js

@@ -28,7 +28,7 @@ const program = new Command();
 program
   .name('bc')
   .description('Byuckchon Frontend Workbench — 프로젝트 스타터 + AI 어시스턴트')
-  .version('1.9.0');
+  .version('1.10.0');
 
 program
   .command('init')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "byuckchon-frontend-cli",
-  "version": "1.9.0",
+  "version": "1.9.2",
   "description": "Byuckchon Frontend Workbench — project starter + AI chat + codebase RAG + OpenAPI codegen",
   "type": "module",
   "engines": {

package/src/ai/tools.js

@@ -44,6 +44,39 @@ export function buildTools({ projectRoot, effective, onEvent = () => {}, openapi
     return _openapiDocPromise;
   }
 
+  // ── live refetch (서버가 세션 도중 스펙을 바꾼 경우 대비) ──
+  // 남용 방지: 세션당 최대 횟수 + 최소 간격 throttle.
+  const REFRESH_MAX = 6;
+  const REFRESH_MIN_INTERVAL_MS = 10_000;
+  let _refreshCount = 0;
+  let _lastRefreshAt = 0;
+
+  /**
+   * 캐시를 무시하고 OpenAPI 스펙을 다시 fetch 한다.
+   * @returns {Promise<{ doc: object|null, refreshed: boolean, reason?: string }>}
+   */
+  async function refreshOpenApiDoc() {
+    if (!openapiSource) return { doc: null, refreshed: false, reason: 'no-source' };
+
+    const now = Date.now();
+    if (_refreshCount >= REFRESH_MAX) {
+      return { doc: await loadOpenApiDoc(), refreshed: false, reason: 'limit' };
+    }
+    if (now - _lastRefreshAt < REFRESH_MIN_INTERVAL_MS) {
+      return { doc: await loadOpenApiDoc(), refreshed: false, reason: 'throttled' };
+    }
+
+    _refreshCount += 1;
+    _lastRefreshAt = now;
+    _openapiDocPromise = getCachedOpenApi(openapiSource, { force: true })
+      .then((res) => res.doc ?? null)
+      .catch(() => null);
+
+    const doc = await _openapiDocPromise;
+    onEvent({ kind: 'openapi_refreshed', ok: !!doc });
+    return { doc, refreshed: true };
+  }
+
   function safePath(p) {
     if (!p || typeof p !== 'string') {
       throw new Error('path 가 비어있습니다');
@@ -188,7 +221,11 @@ export function buildTools({ projectRoot, effective, onEvent = () => {}, openapi
   // ─────────── OpenAPI 툴 ───────────
 
   async function searchOpenApi({ query, limit = 40 }) {
-    const doc = await loadOpenApiDoc();
+    let doc = await loadOpenApiDoc();
+    if (!doc) {
+      // 첫 로드 실패면 한 번 live refetch 시도.
+      ({ doc } = await refreshOpenApiDoc());
+    }
     if (!doc) {
       return {
         ok: false,
@@ -197,11 +234,25 @@ export function buildTools({ projectRoot, effective, onEvent = () => {}, openapi
           '(NestJS 는 보통 /api/docs 가 아니라 /api/docs-json).',
       };
     }
-    const hits = searchEndpoints(doc, query, { limit });
+
+    let hits = searchEndpoints(doc, query, { limit });
+    let refreshed = false;
+
+    // 캐시된 스펙에서 못 찾으면 → 서버에서 방금 추가됐을 수 있으니 딱 한 번 live refetch 후 재검색.
+    if (hits.length === 0) {
+      const r = await refreshOpenApiDoc();
+      if (r.refreshed && r.doc) {
+        refreshed = true;
+        doc = r.doc;
+        hits = searchEndpoints(doc, query, { limit });
+      }
+    }
+
     return {
       ok: true,
       query,
       count: hits.length,
+      refreshed,
       endpoints: hits.map((e) => ({
         method: e.method,
         path: e.path,
@@ -210,17 +261,63 @@ export function buildTools({ projectRoot, effective, onEvent = () => {}, openapi
       })),
       hint:
         hits.length === 0
-          ? '매치 없음. 다른 키워드로 재시도하거나, query 를 비워 전체 목록을 받아 path 를 직접 고르세요.'
-          : '상세 스키마가 필요하면 get_openapi_endpoint(path, method) 를 호출하세요.',
+          ? (refreshed
+              ? '최신 스펙을 다시 받아왔는데도 매치가 없습니다. 다른 키워드로 재시도하거나 query 를 비워 전체 목록을 확인하세요.'
+              : '매치 없음. 다른 키워드로 재시도하거나, query 를 비워 전체 목록을 받아 path 를 직접 고르세요.')
+          : (refreshed
+              ? '캐시엔 없던 항목을 최신 스펙에서 찾았습니다. 상세는 get_openapi_endpoint(path, method).'
+              : '상세 스키마가 필요하면 get_openapi_endpoint(path, method) 를 호출하세요.'),
     };
   }
 
   async function getOpenApiEndpoint({ path: epPath, method }) {
-    const doc = await loadOpenApiDoc();
+    let doc = await loadOpenApiDoc();
+    if (!doc) {
+      ({ doc } = await refreshOpenApiDoc());
+    }
     if (!doc) {
       return { ok: false, error: 'OpenAPI 스펙을 불러올 수 없습니다.' };
     }
-    return getEndpoint(doc, epPath, method);
+
+    let result = getEndpoint(doc, epPath, method);
+
+    // 못 찾으면 → 최신 스펙으로 한 번 더.
+    if (!result.ok) {
+      const r = await refreshOpenApiDoc();
+      if (r.refreshed && r.doc) {
+        const retry = getEndpoint(r.doc, epPath, method);
+        if (retry.ok) result = { ...retry, refreshed: true };
+        else result = { ...retry, refreshed: true };
+      }
+    }
+    return result;
+  }
+
+  async function refreshOpenApi() {
+    if (!openapiSource) {
+      return { ok: false, error: 'bc.config.json 에 api.openapi 가 설정되어 있지 않습니다.' };
+    }
+    const r = await refreshOpenApiDoc();
+    if (!r.doc) {
+      return {
+        ok: false,
+        refreshed: r.refreshed,
+        error:
+          r.reason === 'throttled'
+            ? '방금 새로고침했습니다. 잠시 후 다시 시도하세요.'
+            : '스펙을 다시 받아오지 못했습니다 (네트워크/URL 확인).',
+      };
+    }
+    const count = (r.doc.paths ? Object.keys(r.doc.paths).length : 0);
+    return {
+      ok: true,
+      refreshed: r.refreshed,
+      reason: r.refreshed ? undefined : r.reason,
+      paths: count,
+      message: r.refreshed
+        ? `최신 OpenAPI 스펙을 다시 받아왔습니다 (path ${count}개).`
+        : '최근에 이미 새로고침되어 캐시를 재사용했습니다.',
+    };
   }
 
   // ─────────── Figma 툴 ───────────
@@ -381,6 +478,20 @@ export function buildTools({ projectRoot, effective, onEvent = () => {}, openapi
       }),
       execute: getOpenApiEndpoint,
     }),
+    refresh_openapi: tool({
+      description:
+        '연결된 OpenAPI(Swagger) 스펙을 캐시 무시하고 서버에서 다시 받아온다. ' +
+        '사용자가 "방금 스웨거(백엔드 API) 를 업데이트했다 / 다시 읽어라" 라고 하거나, ' +
+        'search_openapi 가 분명히 있어야 할 엔드포인트를 못 찾을 때 호출. ' +
+        '(search_openapi / get_openapi_endpoint 는 못 찾으면 자동으로 한 번 새로고침하므로, ' +
+        '명시적 요청이 있을 때만 직접 부르면 된다.)',
+      inputSchema: jsonSchema({
+        type: 'object',
+        properties: {},
+        additionalProperties: false,
+      }),
+      execute: refreshOpenApi,
+    }),
     write_file: tool({
       description:
         '새 파일을 만들거나 기존 파일을 통째로 덮어쓴다. 새 파일을 만들기 전에 반드시 1) 비슷한 기존 파일을 read_file 로 보고 2) 같은 폴더 컨벤션(barrel 파일, 네이밍, import 순서) 을 따른다.',

package/src/commands/chat.js

@@ -17,10 +17,12 @@ import { printInlineThumbnail } from '../ai/imagePreview.js';
 import {
   createSession,
   saveSession,
+  deleteSession,
   listSessions,
   loadSession,
   loadLatestSession,
 } from '../history/store.js';
+import { findLastRetryableUser, formatSessionList } from '../history/management.js';
 import { getCachedOpenApi } from '../openapi/cache.js';
 import { summarizeOpenApi } from '../openapi/summary.js';
 
@@ -119,6 +121,9 @@ export async function chatCommand(opts = {}) {
           '가져와서 zod/타입/요청 함수를 만든다. ' +
           '예: 사용자가 "inquiries" 라고 하면 search_openapi("inquiries") 로 ' +
           '`/api/admin/inquiries` 같은 실제 경로를 찾아낸다. ' +
+          '스펙은 캐시(최대 1시간)라 서버가 방금 바꿨으면 오래됐을 수 있다 — ' +
+          'search_openapi/get_openapi_endpoint 는 못 찾으면 자동으로 한 번 최신본을 다시 받아온다. ' +
+          '사용자가 "방금 스웨거 업데이트했어/다시 읽어" 라고 하면 `refresh_openapi()` 를 먼저 호출한다. ' +
           '이미 `*.gen.ts` 가 있으면 그걸 import 해서 쓰는 것도 좋다.';
       }
     } catch {
@@ -162,8 +167,6 @@ export async function chatCommand(opts = {}) {
     // 모델은 사용자가 명시했거나 글로벌 설정으로 갱신 가능 — 세션의 model 은 표시용.
     session.model = resolved.meta.id;
   }
-  await saveSession(session); // 빈 파일이라도 디스크에 만들어둠
-
   // ink 는 stdin/stdout 둘 다 TTY 이어야 정상 동작.
   // - --plain 플래그가 명시되거나 비-TTY 면 readline 폴백.
   // - 글로벌 ui.mode 가 "plain" 이면 한글 IME 가 깨지는 케이스를 자동 회피.
@@ -206,9 +209,36 @@ async function runInkApp({ cfg, resolved, system, session, openapiInfo, conventi
 
   const initialConfig = { ...cfg, system, openapiInfo, conventionFiles };
 
+  let activeSession = session;
+
   const onSessionUpdate = async (messages) => {
-    session.messages = messages;
-    await saveSession(session);
+    const target = activeSession;
+    const hasConversation = messages.some(
+      (message) =>
+        (message.role === 'user' || message.role === 'assistant') &&
+        typeof message.text === 'string' &&
+        message.text.trim(),
+    );
+    if (!hasConversation && !target._persisted) return;
+    target.messages = messages;
+    await saveSession(target);
+  };
+
+  const onSessionSwitch = async (id) => {
+    const loaded = await loadSession(id);
+    loaded.model = resolved.meta.id;
+    activeSession = loaded;
+    return loaded;
+  };
+
+  const onSessionDelete = async (id) => {
+    const deletingActive = activeSession.id === id;
+    const result = await deleteSession(id);
+    if (!deletingActive) return { ...result, replacementSession: null };
+
+    const replacementSession = await createSession({ model: resolved.meta.id });
+    activeSession = replacementSession;
+    return { ...result, replacementSession };
   };
 
   const { waitUntilExit } = render(
@@ -217,6 +247,8 @@ async function runInkApp({ cfg, resolved, system, session, openapiInfo, conventi
       initialResolved: resolved,
       session,
       onSessionUpdate,
+      onSessionSwitch,
+      onSessionDelete,
     }),
     { exitOnCtrlC: false },
   );
@@ -235,6 +267,12 @@ async function runOnce({ cfg, resolved, system, prompt }) {
     effective: cfg.effective,
     openapiSource: cfg.effective.api?.openapi ?? null,
     onEvent: (ev) => {
+      if (ev.kind === 'openapi_refreshed') {
+        console.log(
+          chalk.dim(ev.ok ? '  🔄 OpenAPI 스펙 새로고침' : '  ⚠️  OpenAPI 새로고침 실패'),
+        );
+        return;
+      }
       const label =
         ev.kind === 'write_created'
           ? '🆕'
@@ -291,7 +329,9 @@ async function runReadlineFallback({ cfg, resolved, system, session, openapiInfo
     console.log(chalk.dim(`  세션: ${session.id} (${session.messages.length} turns 이어가기)`));
   }
   console.log(
-    chalk.dim('  /image <경로> · /paste(클립보드 이미지) · /clear-attach · /exit\n'),
+    chalk.dim(
+      '  /history · /retry · /image <경로> · /paste · /clear-attach · /exit\n',
+    ),
   );
 
   // 다음 메시지에 함께 보낼 이미지 첨부 목록.
@@ -341,6 +381,21 @@ async function runReadlineFallback({ cfg, resolved, system, session, openapiInfo
   const history = (session?.messages ?? [])
     .filter((m) => m.role === 'user' || m.role === 'assistant')
     .map((m) => ({ role: m.role, content: m.text ?? '' }));
+  const persistHistory = async () => {
+    if (!session) return;
+    session.messages = history.map((message) => {
+      // 이미지 바이트는 세션 파일에 저장하지 않고 사용자 텍스트만 보존한다.
+      if (Array.isArray(message.content)) {
+        const textPart = message.content.find((part) => part.type === 'text');
+        return {
+          role: message.role,
+          text: textPart?.text ?? '[이미지 첨부]',
+        };
+      }
+      return { role: message.role, text: message.content };
+    });
+    await saveSession(session);
+  };
   const ask = () => rl.prompt();
 
   rl.on('close', () => {
@@ -359,6 +414,29 @@ async function runReadlineFallback({ cfg, resolved, system, session, openapiInfo
       rl.close();
       return;
     }
+    if (line === '/history') {
+      try {
+        const sessions = await listSessions();
+        console.log(chalk.dim('\n' + formatSessionList(sessions)));
+        console.log(chalk.dim('\n  이어가기: bc chat --resume <id>'));
+      } catch (err) {
+        console.log(chalk.red('  대화 목록을 불러올 수 없습니다: ' + err.message));
+      }
+      ask();
+      continue;
+    }
+    let retryContent = null;
+    if (line === '/retry') {
+      const retry = findLastRetryableUser(history);
+      if (!retry) {
+        console.log(chalk.red('  다시 실행할 사용자 요청이 없습니다.'));
+        ask();
+        continue;
+      }
+      retryContent = retry.message.content;
+      history.splice(retry.index);
+      console.log(chalk.dim('  마지막 요청을 다시 실행합니다.'));
+    }
     // 이미지 첨부 관련 슬래시 명령 — plain 모드에서도 지원.
     if (line.startsWith('/image')) {
       await addImage(line.slice('/image'.length).trim());
@@ -388,7 +466,9 @@ async function runReadlineFallback({ cfg, resolved, system, session, openapiInfo
     }
 
     // 일반 메시지 — 첨부가 있으면 멀티모달 content 로 구성.
-    if (pendingAttachments.length) {
+    if (retryContent != null) {
+      history.push({ role: 'user', content: retryContent });
+    } else if (pendingAttachments.length) {
       const parts = [{ type: 'text', text: line }];
       try {
         for (const att of pendingAttachments) {
@@ -403,6 +483,11 @@ async function runReadlineFallback({ cfg, resolved, system, session, openapiInfo
     } else {
       history.push({ role: 'user', content: line });
     }
+    try {
+      await persistHistory();
+    } catch {
+      /* 저장 실패가 AI 요청을 막지는 않게 한다. */
+    }
     rl.pause();
 
     const projectRoot = cfg.paths.projectFile
@@ -413,6 +498,12 @@ async function runReadlineFallback({ cfg, resolved, system, session, openapiInfo
       effective: cfg.effective,
       openapiSource: cfg.effective.api?.openapi ?? null,
       onEvent: (ev) => {
+        if (ev.kind === 'openapi_refreshed') {
+          console.log(
+            chalk.dim(ev.ok ? '\n  🔄 OpenAPI 스펙 새로고침' : '\n  ⚠️  OpenAPI 새로고침 실패'),
+          );
+          return;
+        }
         const label =
           ev.kind === 'write_created'
             ? '🆕 생성'
@@ -457,21 +548,11 @@ async function runReadlineFallback({ cfg, resolved, system, session, openapiInfo
     }
     if (acc) history.push({ role: 'assistant', content: acc });
 
-    // 세션 자동 저장 — readline 모드에서도 끊김 대비.
-    if (session) {
-      session.messages = history.map((h) => {
-        // 멀티모달(content 가 배열) 인 경우 text 파트만 추출해 저장 (이미지 바이트는 세션에 안 남김).
-        if (Array.isArray(h.content)) {
-          const textPart = h.content.find((p) => p.type === 'text');
-          return { role: h.role, text: textPart?.text ?? '[이미지 첨부]' };
-        }
-        return { role: h.role, text: h.content };
-      });
-      try {
-        await saveSession(session);
-      } catch {
-        /* noop */
-      }
+    // 응답까지 포함한 최신 상태로 다시 저장한다.
+    try {
+      await persistHistory();
+    } catch {
+      /* noop */
     }
 
     rl.resume();

package/src/history/management.js

@@ -0,0 +1,30 @@
+function messageText(message) {
+  if (typeof message?.text === 'string') return message.text;
+  if (typeof message?.content === 'string') return message.content;
+  if (Array.isArray(message?.content)) {
+    return message.content.find((part) => part.type === 'text')?.text ?? '[이미지 첨부]';
+  }
+  return '';
+}
+
+export function findLastRetryableUser(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message.role === 'user' && messageText(message).trim()) {
+      return { index, message, text: messageText(message) };
+    }
+  }
+  return null;
+}
+
+export function formatSessionList(sessions, { limit = 10 } = {}) {
+  if (!sessions.length) return '저장된 이전 세션이 없습니다.';
+  return sessions
+    .slice(0, limit)
+    .map((session) => {
+      const when = session.updatedAt?.replace('T', ' ').slice(0, 19) ?? '';
+      const preview = session.preview || '(빈 세션)';
+      return `${session.id}  ${when}  ${session.turns} turns\n  ${preview}`;
+    })
+    .join('\n');
+}

package/src/history/store.js

@@ -49,7 +49,7 @@ export async function createSession({ model, cwd = process.cwd() } = {}) {
     cwd,
     messages: [],
   };
-  return { ...session, _file: path.join(dir, `${id}.json`) };
+  return { ...session, _file: path.join(dir, `${id}.json`), _persisted: false };
 }
 
 export async function saveSession(session) {
@@ -64,6 +64,7 @@ export async function saveSession(session) {
     messages: session.messages,
   };
   await fs.writeFile(file, JSON.stringify(data, null, 2) + '\n', 'utf8');
+  session._persisted = true;
 }
 
 export async function listSessions(cwd = process.cwd(), { limit = 20 } = {}) {
@@ -77,19 +78,27 @@ export async function listSessions(cwd = process.cwd(), { limit = 20 } = {}) {
   }
   const files = entries.filter((f) => f.endsWith('.json')).sort().reverse();
   const out = [];
-  for (const name of files.slice(0, limit)) {
+  for (const name of files) {
+    if (out.length >= limit) break;
     const file = path.join(dir, name);
     try {
       const raw = await fs.readFile(file, 'utf8');
       const data = JSON.parse(raw);
-      const firstUser = data.messages?.find((m) => m.role === 'user');
+      const conversation = (data.messages ?? []).filter(
+        (message) =>
+          (message.role === 'user' || message.role === 'assistant') &&
+          typeof message.text === 'string' &&
+          message.text.trim(),
+      );
+      if (conversation.length === 0) continue;
+      const firstUser = conversation.find((message) => message.role === 'user');
       out.push({
         id: data.id,
         file,
         startedAt: data.startedAt,
         updatedAt: data.updatedAt,
         model: data.model,
-        turns: data.messages?.length ?? 0,
+        turns: conversation.length,
         preview: firstUser?.text?.slice(0, 60) ?? '(빈 세션)',
       });
     } catch {
@@ -107,7 +116,7 @@ export async function loadSession(idOrFile, cwd = process.cwd()) {
   }
   const raw = await fs.readFile(file, 'utf8');
   const data = JSON.parse(raw);
-  return { ...data, _file: file };
+  return { ...data, _file: file, _persisted: true };
 }
 
 export async function loadLatestSession(cwd = process.cwd()) {
@@ -115,3 +124,22 @@ export async function loadLatestSession(cwd = process.cwd()) {
   if (list.length === 0) return null;
   return loadSession(list[0].id, cwd);
 }
+
+export async function deleteSession(id, cwd = process.cwd()) {
+  const normalized = String(id ?? '').replace(/\.json$/, '');
+  if (!/^[a-zA-Z0-9_-]+$/.test(normalized)) {
+    const error = new Error(`잘못된 세션 ID: ${id}`);
+    error.code = 'BC_INVALID_SESSION_ID';
+    throw error;
+  }
+
+  const dir = await getHistoryDir(cwd);
+  const file = path.join(dir, `${normalized}.json`);
+  try {
+    await fs.unlink(file);
+    return { id: normalized, file, deleted: true };
+  } catch (error) {
+    if (error.code === 'ENOENT') return { id: normalized, file, deleted: false };
+    throw error;
+  }
+}

package/src/openapi/cache.js

@@ -23,8 +23,13 @@ function keyFor(input) {
  *
  * - 네트워크 실패 시: 만료된 캐시라도 있으면 그걸로 폴백 (offline-friendly).
  * - 캐시는 .bc/cache/openapi-<hash>.json 에 저장.
+ *
+ * @param {string} input  OpenAPI URL 또는 파일 경로
+ * @param {object} [opts]
+ * @param {boolean} [opts.force]  true 면 TTL 무시하고 무조건 live refetch (캐시 갱신).
+ *                                서버가 세션 도중 스펙을 바꿨을 때 사용.
  */
-export async function getCachedOpenApi(input) {
+export async function getCachedOpenApi(input, { force = false } = {}) {
   const dir = await getCacheDir();
   const file = path.join(dir, `openapi-${keyFor(input)}.json`);
 
@@ -39,7 +44,7 @@ export async function getCachedOpenApi(input) {
     /* miss */
   }
 
-  if (cachedFresh && cached) {
+  if (!force && cachedFresh && cached) {
     return { doc: cached, cached: true, source: input };
   }
 

package/src/ui/ChatApp.js

@@ -14,6 +14,8 @@ import { toSdkMessages, isImagePath } from '../ai/messageContent.js';
 import { buildTools } from '../ai/tools.js';
 import { searchIndex } from '../indexer/search.js';
 import { loadIndex, buildIndex } from '../indexer/store.js';
+import { listSessions } from '../history/store.js';
+import { findLastRetryableUser } from '../history/management.js';
 
 const h = React.createElement;
 
@@ -287,6 +289,8 @@ function AttachBar({ pending }) {
 const SLASH_COMMANDS = [
   { cmd: '/help', hint: '', desc: '명령 도움말' },
   { cmd: '/clear', hint: '', desc: '대화 컨텍스트 비우기' },
+  { cmd: '/history', hint: '', desc: '프로젝트의 이전 대화 목록' },
+  { cmd: '/retry', hint: '', desc: '마지막 사용자 요청 다시 실행' },
   { cmd: '/model', hint: '<id>', desc: '세션 모델 변경 (인자 없으면 목록)' },
   { cmd: '/cost', hint: '', desc: '누적 토큰/비용' },
   { cmd: '/image', hint: '<path>', desc: '이미지 첨부 (Finder 에서 끌어다 놔도 됨)' },
@@ -350,7 +354,45 @@ function SlashMenu({ items, activeIndex }) {
   );
 }
 
-export function ChatApp({ initialConfig, initialResolved, session, onSessionUpdate }) {
+function HistoryMenu({ items, activeIndex, activeSessionId, deleteId }) {
+  if (items.length === 0) return null;
+  return h(
+    Box,
+    {
+      flexDirection: 'column',
+      borderStyle: 'single',
+      borderColor: 'gray',
+      paddingX: 1,
+    },
+    h(Text, { bold: true }, '이전 대화'),
+    ...items.map((item, index) => {
+      const active = index === activeIndex;
+      const current = item.id === activeSessionId;
+      const when = item.updatedAt?.replace('T', ' ').slice(0, 16) ?? '';
+      return h(
+        Text,
+        {
+          key: item.id,
+          color: item.id === deleteId ? 'red' : active ? 'cyan' : undefined,
+          bold: active,
+        },
+        `${active ? '›' : ' '} ${item.id}${current ? ' (현재)' : ''}  ${when}  ${item.turns} turns\n  ${item.preview}`,
+      );
+    }),
+    deleteId
+      ? h(Text, { color: 'red' }, `${deleteId} 세션을 삭제할까요? y/n`)
+      : h(Text, { dimColor: true }, '↑↓ 선택 · Enter 불러오기 · d 삭제 · Esc 취소'),
+  );
+}
+
+export function ChatApp({
+  initialConfig,
+  initialResolved,
+  session,
+  onSessionUpdate,
+  onSessionSwitch,
+  onSessionDelete,
+}) {
   const app = useApp();
   const { stdout } = useStdout();
   const [cfg, setCfg] = useState(initialConfig);
@@ -380,12 +422,17 @@ export function ChatApp({ initialConfig, initialResolved, session, onSessionUpda
   const [indexProgress, setIndexProgress] = useState('');
   const [ragEnabled, setRagEnabled] = useState(true);
   const [menuIndex, setMenuIndex] = useState(0);
+  const [historyItems, setHistoryItems] = useState([]);
+  const [historyIndex, setHistoryIndex] = useState(0);
+  const [historyDeleteId, setHistoryDeleteId] = useState(null);
+  const [activeSessionId, setActiveSessionId] = useState(session?.id ?? null);
   const [, force] = useState(0);
   const rerender = useCallback(() => force((n) => n + 1), []);
 
   // 슬래시 메뉴: input 상태에 따라 동적으로 계산.
   const slashItems = state === 'idle' ? filterSlashCommands(input) : [];
   const slashOpen = slashItems.length > 0;
+  const historyOpen = state === 'idle' && historyItems.length > 0;
   // input 이 바뀌면 선택 인덱스를 0 으로 리셋 (필터 변경 시 자연스럽게).
   useEffect(() => {
     setMenuIndex(0);
@@ -507,6 +554,29 @@ export function ChatApp({ initialConfig, initialResolved, session, onSessionUpda
       app.exit();
       return;
     }
+    if (historyOpen) {
+      if (historyDeleteId) {
+        if (char.toLowerCase() === 'y') {
+          void deleteHistorySession();
+        } else if (char.toLowerCase() === 'n' || key.escape) {
+          setHistoryDeleteId(null);
+        }
+        return;
+      }
+      if (key.upArrow) {
+        setHistoryIndex((index) => Math.max(0, index - 1));
+      } else if (key.downArrow) {
+        setHistoryIndex((index) => Math.min(historyItems.length - 1, index + 1));
+      } else if (key.escape) {
+        setHistoryItems([]);
+      } else if (char.toLowerCase() === 'd') {
+        const selected = historyItems[historyIndex];
+        if (selected) setHistoryDeleteId(selected.id);
+      } else if (key.return) {
+        void selectHistorySession();
+      }
+      return;
+    }
     if (!slashOpen) return;
     if (key.upArrow) {
       setMenuIndex((i) => Math.max(0, i - 1));
@@ -552,6 +622,33 @@ export function ChatApp({ initialConfig, initialResolved, session, onSessionUpda
       pushSystemInfo('대화 컨텍스트를 비웠습니다.');
       return true;
     }
+    if (cmd === 'history') {
+      try {
+        const sessions = await listSessions();
+        if (!sessions.length) {
+          pushSystemInfo('저장된 이전 세션이 없습니다.');
+          return true;
+        }
+        setHistoryItems(sessions.slice(0, 10));
+        setHistoryIndex(0);
+        setHistoryDeleteId(null);
+      } catch (err) {
+        pushSystemError('대화 목록을 불러올 수 없습니다: ' + err.message);
+      }
+      return true;
+    }
+    if (cmd === 'retry') {
+      const retry = findLastRetryableUser(messages);
+      if (!retry) {
+        pushSystemError('다시 실행할 사용자 요청이 없습니다.');
+        return true;
+      }
+      await sendMessage(retry.text, {
+        baseMessages: messages.slice(0, retry.index),
+        attachments: retry.message.attachments ?? [],
+      });
+      return true;
+    }
     if (cmd === 'cost') {
       pushSystemInfo(meterRef.current.format());
       return true;
@@ -656,13 +753,70 @@ export function ChatApp({ initialConfig, initialResolved, session, onSessionUpda
     return true;
   };
 
-  const sendMessage = async (text) => {
+  const selectHistorySession = async () => {
+    const selected = historyItems[historyIndex];
+    if (!selected || !onSessionSwitch) return;
+
+    setHistoryItems([]);
+    setState('thinking');
+    try {
+      const loaded = await onSessionSwitch(selected.id);
+      setActiveSessionId(loaded.id);
+      setPendingAttachments([]);
+      setMessages([
+        ...(loaded.messages ?? []),
+        {
+          role: 'system-info',
+          text: `세션 ${loaded.id} 컨텍스트를 불러왔습니다.`,
+        },
+      ]);
+    } catch (err) {
+      pushSystemError('세션을 불러올 수 없습니다: ' + (err?.message ?? String(err)));
+    } finally {
+      setState('idle');
+    }
+  };
+
+  const deleteHistorySession = async () => {
+    const id = historyDeleteId;
+    if (!id || !onSessionDelete) return;
+
+    setHistoryDeleteId(null);
+    try {
+      const result = await onSessionDelete(id);
+      const remaining = historyItems.filter((item) => item.id !== id);
+      setHistoryItems(remaining);
+      setHistoryIndex((index) => Math.min(index, Math.max(0, remaining.length - 1)));
+
+      if (result.replacementSession) {
+        setActiveSessionId(result.replacementSession.id);
+        setPendingAttachments([]);
+        setMessages([
+          {
+            role: 'system-info',
+            text: `세션 ${id}을 삭제하고 새 세션을 시작했습니다.`,
+          },
+        ]);
+      } else {
+        pushSystemInfo(
+          result.deleted ? `세션 ${id}을 삭제했습니다.` : `세션 ${id}을 찾을 수 없습니다.`,
+        );
+      }
+    } catch (err) {
+      pushSystemError('세션을 삭제할 수 없습니다: ' + (err?.message ?? String(err)));
+    }
+  };
+
+  const sendMessage = async (
+    text,
+    { baseMessages = messages, attachments = pendingAttachments } = {},
+  ) => {
     const userMsg = {
       role: 'user',
       text,
-      attachments: pendingAttachments,
+      attachments,
     };
-    const newMessages = [...messages, userMsg];
+    const newMessages = [...baseMessages, userMsg];
     setMessages(newMessages);
     setPendingAttachments([]);
     setState('thinking');
@@ -717,6 +871,18 @@ export function ChatApp({ initialConfig, initialResolved, session, onSessionUpda
 
       // 툴 실행 이벤트는 채팅에 시스템 메시지로 표시 (사용자가 무엇이 일어났는지 보게).
       const onToolEvent = (ev) => {
+        if (ev.kind === 'openapi_refreshed') {
+          setMessages((m) => [
+            ...m,
+            {
+              role: 'system-info',
+              text: ev.ok
+                ? '🔄 OpenAPI 스펙 새로고침 (서버에서 최신본 다시 받음)'
+                : '⚠️  OpenAPI 새로고침 실패 (네트워크/URL 확인)',
+            },
+          ]);
+          return;
+        }
         const labels = {
           write_created: '🆕 생성',
           write_overwritten: '✏️  덮어씀',
@@ -896,12 +1062,20 @@ export function ChatApp({ initialConfig, initialResolved, session, onSessionUpda
       }),
     ),
     h(AttachBar, { pending: pendingAttachments }),
+    historyOpen
+      ? h(HistoryMenu, {
+          items: historyItems,
+          activeIndex: historyIndex,
+          activeSessionId,
+          deleteId: historyDeleteId,
+        })
+      : null,
     slashOpen ? h(SlashMenu, { items: slashItems, activeIndex: menuIndex }) : null,
     h(
       Box,
       { marginTop: 0 },
       h(Text, { color: 'magenta', bold: true }, 'you › '),
-      state === 'idle'
+      state === 'idle' && !historyOpen
         ? h(TextInput, {
             value: input,
             onChange: setInput,
@@ -912,7 +1086,15 @@ export function ChatApp({ initialConfig, initialResolved, session, onSessionUpda
             // 가짜 커서가 있으면 한글 IME 미리보기가 한 칸 어긋나 보일 수 있다.
             showCursor: false,
           })
-        : h(Text, { dimColor: true }, '(응답 받는 중 — 잠시만)'),
+        : h(
+            Text,
+            { dimColor: true },
+            historyOpen
+              ? historyDeleteId
+                ? '(y 또는 n을 입력하세요)'
+                : '(이전 대화를 선택하세요)'
+              : '(응답 받는 중 — 잠시만)',
+          ),
     ),
   );
 }