@cheongfish/bouncer 0.0.0-stage → 0.1.13

package/dist/retro-read.js

@@ -0,0 +1,259 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+// Cursor가 대화를 담아 두는 ItemTable key. 이 밖의 key는 대화가 아니므로 읽지 않는다.
+const CURSOR_KEYS = [
+    'workbench.panel.aichat.view.aichat.chatdata',
+    'aiService.prompts',
+    'composer.composerData',
+];
+const UNSUPPORTED = { ok: false, reason: 'unsupported-schema' };
+/**
+ * 값이 null이 아닌 일반 객체인지 판정한다. JSON 줄의 모양이 제각각이라
+ * 접근 전에 항상 이 가드를 거친다.
+ *
+ * @param {unknown} v - 검사할 값
+ * @returns {boolean} 객체(배열 제외)이면 true
+ */
+function isObj(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+/**
+ * Claude `tool_result`의 content에서 텍스트를 뽑는다. 문자열은 그대로, 배열은
+ * 그 안의 `text` 문자열을 개행으로 잇는다. 그 밖의 모양은 텍스트가 없는 것이다.
+ *
+ * @param {unknown} content - `tool_result.content`
+ * @returns {string} 추출한 텍스트(없으면 빈 문자열)
+ */
+function toolResultText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .filter((c) => isObj(c) && typeof c.text === 'string')
+        .map((c) => c.text)
+        .join('\n');
+}
+/**
+ * Claude Code 메시지 줄(`type`이 user·assistant)에서 메시지를 뽑는다.
+ * 토큰 사용량·첨부 같은 텍스트 외 필드는 의도적으로 버린다.
+ *
+ * @param {Json} obj - 파싱된 JSONL 줄
+ * @returns {Message[]} text 메시지 다음 tool_error 메시지 순서의 목록(없으면 빈 배열)
+ */
+function claudeMessages(obj) {
+    const role = obj.type;
+    const content = obj.message.content;
+    if (typeof content === 'string')
+        return [{ role, text: content }];
+    if (!Array.isArray(content))
+        return [];
+    const out = [];
+    const texts = content
+        .filter((c) => isObj(c) && c.type === 'text' && typeof c.text === 'string')
+        .map((c) => c.text);
+    if (texts.length > 0)
+        out.push({ role, text: texts.join('\n') });
+    for (const c of content) {
+        if (isObj(c) && c.type === 'tool_result' && c.is_error === true) {
+            out.push({ role: 'tool_error', text: toolResultText(c.content) });
+        }
+    }
+    return out;
+}
+/**
+ * Codex `response_item`/`message` 줄에서 메시지 하나를 만든다. developer·system
+ * 같은 역할은 사용자·모델 발화가 아니므로 `unknown`으로 내려 구분한다.
+ *
+ * @param {Json} payload - 줄의 `payload`
+ * @returns {Message[]} 텍스트가 있으면 메시지 하나, 없으면 빈 배열
+ */
+function codexMessages(payload) {
+    const content = Array.isArray(payload.content) ? payload.content : [];
+    const texts = content
+        .filter((c) => isObj(c) && (c.type === 'input_text' || c.type === 'output_text') && typeof c.text === 'string')
+        .map((c) => c.text);
+    if (texts.length === 0)
+        return [];
+    const role = payload.role === 'user' || payload.role === 'assistant' ? payload.role : 'unknown';
+    return [{ role, text: texts.join('\n') }];
+}
+/**
+ * JSONL 한 줄을 분류하고 정규화한다. `invalid`는 JSON 파싱 실패만, `ignored`는
+ * 메시지 줄이 아닌 JSON(session_meta, summary 등)만 뜻한다. 메시지 줄이지만
+ * 텍스트가 없으면 빈 messages로 돌려 host 판정에는 쓰이되 목록에는 기여하지 않는다.
+ *
+ * @param {string} line - 원시 JSONL 한 줄
+ * @returns {JsonlLine} invalid / ignored / messages(host 포함)
+ */
+function normalizeJsonlLine(line) {
+    let obj;
+    try {
+        obj = JSON.parse(line);
+    }
+    catch (err) {
+        // JSON.parse는 SyntaxError만 던진다. 깨진 줄은 세어 보고하되 전체 읽기는 계속한다.
+        if (err instanceof SyntaxError)
+            return { kind: 'invalid' };
+        throw err;
+    }
+    if (!isObj(obj))
+        return { kind: 'ignored' };
+    if ((obj.type === 'user' || obj.type === 'assistant') && isObj(obj.message)) {
+        return { kind: 'messages', host: 'claude-code', messages: claudeMessages(obj) };
+    }
+    if (obj.type === 'response_item' && isObj(obj.payload) && obj.payload.type === 'message') {
+        return { kind: 'messages', host: 'codex', messages: codexMessages(obj.payload) };
+    }
+    return { kind: 'ignored' };
+}
+/**
+ * 값을 문서 순서로 훑어 `text` 문자열 필드를 모은다. Cursor 저장소는 스키마가
+ * 버전마다 달라 고정 경로 대신 모든 깊이의 `text`를 대상으로 한다.
+ *
+ * @param {unknown} v - 파싱된 JSON 값
+ * @param {Message[]} out - 메시지를 누적할 목록
+ * @returns {void}
+ */
+function collectTexts(v, out) {
+    if (Array.isArray(v)) {
+        for (const x of v)
+            collectTexts(x, out);
+    }
+    else if (isObj(v)) {
+        for (const [k, x] of Object.entries(v)) {
+            if (k === 'text' && typeof x === 'string')
+                out.push({ role: 'unknown', text: x });
+            else
+                collectTexts(x, out);
+        }
+    }
+}
+/**
+ * Cursor `state.vscdb`를 읽기 전용으로 열어 메시지를 뽑는다. `node:sqlite`는
+ * 이 경로에서만 필요하므로 lazy require해 다른 형식의 시작 비용을 늘리지 않는다.
+ *
+ * @param {string} filePath - `.vscdb` 경로
+ * @returns {Message[] | null} 메시지 목록. 대상 key가 없거나 SQLite가 아니면 null
+ */
+function readCursor(filePath) {
+    const { DatabaseSync } = require('node:sqlite');
+    const messages = [];
+    let found = false;
+    let db;
+    try {
+        db = new DatabaseSync(filePath, { readOnly: true });
+        const stmt = db.prepare('SELECT value FROM ItemTable WHERE key = ?');
+        for (const key of CURSOR_KEYS) {
+            const row = stmt.get(key);
+            if (!row)
+                continue;
+            found = true;
+            try {
+                collectTexts(JSON.parse(String(row.value)), messages);
+            }
+            catch (err) {
+                // 값이 JSON이 아닌 행은 건너뛴다. SyntaxError만 흡수하고 나머지는 던진다.
+                if (!(err instanceof SyntaxError))
+                    throw err;
+            }
+        }
+    }
+    catch (err) {
+        // SQLite 파일이 아니거나 ItemTable이 없는 경우(ERR_SQLITE_ERROR)만 스키마 불일치로 본다.
+        // 다른 오류(권한 등)를 이 사유로 뭉개지 않도록 코드를 확인한다.
+        if (err.code === 'ERR_SQLITE_ERROR')
+            return null;
+        throw err;
+    }
+    finally {
+        if (db)
+            db.close();
+    }
+    return found ? messages : null;
+}
+/**
+ * 합계가 상한을 넘으면 가장 최근 메시지부터 남긴다. retro는 대화 끝쪽(최근 실패)이
+ * 더 중요하므로 앞을 버린다. 최근 메시지 하나가 혼자 상한을 넘으면 그 꼬리만 남긴다.
+ *
+ * @param {Message[]} messages - 시간순 메시지
+ * @param {number} maxChars - 텍스트 글자 수 상한
+ * @returns {{ messages: Message[], truncated: boolean }} 상한 적용 결과
+ */
+function applyCap(messages, maxChars) {
+    const total = messages.reduce((n, m) => n + m.text.length, 0);
+    if (total <= maxChars)
+        return { messages, truncated: false };
+    const kept = [];
+    let used = 0;
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const m = messages[i];
+        if (used + m.text.length > maxChars) {
+            // 가장 최근 메시지가 혼자 상한을 넘는 경우에만 꼬리를 잘라 남긴다.
+            if (kept.length === 0)
+                kept.push({ role: m.role, text: m.text.slice(-maxChars) });
+            break;
+        }
+        kept.unshift(m);
+        used += m.text.length;
+    }
+    return { messages: kept, truncated: true };
+}
+/**
+ * transcript 하나를 `{ role, text }` 목록으로 정규화한다. 파일을 쓰지 않는다.
+ * 확장자 `.vscdb`는 Cursor SQLite, `.jsonl`은 첫 메시지 줄의 모양으로 host를 정한다.
+ *
+ * @param {string} filePath - transcript 경로
+ * @param {{ maxChars: number }} opts - maxChars: 텍스트 합계 상한
+ * @returns {ReadResult} 성공 시 메시지·truncated·skipped_lines, 실패 시 reason
+ *   (`unreadable`: 파일 접근 불가, `unsupported-schema`: 알 수 없는 형식이거나 메시지 없음)
+ */
+function readTranscript(filePath, opts) {
+    const ext = path.extname(filePath).toLowerCase();
+    let raw = null;
+    try {
+        if (ext === '.jsonl')
+            raw = fs.readFileSync(filePath, 'utf8');
+        else
+            fs.accessSync(filePath, fs.constants.R_OK);
+    }
+    catch (err) {
+        // 없음·권한·디렉터리는 모두 "읽을 수 없음"이다. 그 외 오류는 원인을 숨기지 않도록 던진다.
+        const code = err.code;
+        if (['ENOENT', 'ENOTDIR', 'EACCES', 'EPERM', 'EISDIR'].includes(code)) {
+            return { ok: false, reason: 'unreadable' };
+        }
+        throw err;
+    }
+    if (ext === '.vscdb') {
+        const found = readCursor(filePath);
+        if (!found)
+            return UNSUPPORTED;
+        const capped = applyCap(found, opts.maxChars);
+        return { ok: true, host: 'cursor', format: 'sqlite', ...capped, skipped_lines: 0 };
+    }
+    if (raw === null)
+        return UNSUPPORTED;
+    let host = null;
+    let skipped = 0;
+    const messages = [];
+    for (const line of raw.split('\n')) {
+        if (line.trim() === '')
+            continue;
+        const r = normalizeJsonlLine(line);
+        if (r.kind === 'invalid')
+            skipped += 1;
+        else if (r.kind === 'messages') {
+            // host는 첫 메시지 줄이 정한다. 다른 host 모양의 줄이 섞여도 목록을 오염시키지 않는다.
+            host = host ?? r.host;
+            if (r.host === host)
+                messages.push(...r.messages);
+        }
+    }
+    if (host === null || messages.length === 0)
+        return UNSUPPORTED;
+    const capped = applyCap(messages, opts.maxChars);
+    return { ok: true, host, format: 'jsonl', ...capped, skipped_lines: skipped };
+}
+module.exports = { readTranscript, normalizeJsonlLine };

package/dist/retro-sources.js

@@ -0,0 +1,318 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const url = require('node:url');
+// Codex 첫 줄(session_meta)만 읽는다. 본문 전체를 읽지 않으려는 상한이며,
+// 이보다 긴 첫 줄은 해석 불가로 skipped에 남는다.
+const CODEX_META_MAX_BYTES = 64 * 1024;
+/**
+ * 파일시스템 오류를 host별 skipped 사유로 바꾼다. 예상한 코드(없음·권한)만
+ * 흡수하고 나머지는 그대로 던져 원인이 다른 실패가 한 사유로 뭉개지지 않게 한다.
+ *
+ * @param {unknown} err - fs 호출이 던진 값
+ * @param {Host} host - 실패가 난 host
+ * @param {string} target - 실패한 경로(루트 또는 파일)
+ * @param {Skipped[]} skipped - 사유를 누적할 목록
+ * @returns {void} 흡수하면 skipped에 한 건을 더하고 돌아오며, 모르는 오류는 다시 던진다
+ */
+function absorbFsError(err, host, target, skipped) {
+    const code = err?.code;
+    // ENOENT/ENOTDIR: 설치되지 않았거나 경로가 디렉터리가 아님 — 루트가 없는 것과 같다.
+    if (code === 'ENOENT' || code === 'ENOTDIR') {
+        skipped.push({ host, path: target, reason: 'root-missing' });
+        return;
+    }
+    // EACCES/EPERM: 존재는 하나 읽을 수 없음. 없음과 구분해 사용자가 권한을 고치게 한다.
+    if (code === 'EACCES' || code === 'EPERM') {
+        skipped.push({ host, path: target, reason: 'permission-denied' });
+        return;
+    }
+    throw err;
+}
+/**
+ * 정규화한 경로 p가 root와 같거나 root 아래인지 판정한다. `/r2`가 `/r` 아래로
+ * 오인되지 않도록 구분자를 붙여 비교한다.
+ *
+ * @param {string} p - 검사할 경로
+ * @param {string} root - project root
+ * @returns {boolean} 같거나 아래이면 true
+ */
+function isUnderRoot(p, root) {
+    const np = path.resolve(p);
+    const nr = path.resolve(root);
+    return np === nr || np.startsWith(nr + path.sep);
+}
+/**
+ * 파일 하나의 stat을 Source로 만든다.
+ *
+ * @param {Host} host - 출처 host
+ * @param {string} file - 절대 경로
+ * @param {'jsonl' | 'sqlite'} format - 파일 형식
+ * @returns {Source} mtime은 ISO 8601, size는 bytes
+ */
+function toSource(host, file, format) {
+    const st = fs.statSync(file);
+    return { host, path: file, format, mtime: st.mtime.toISOString(), size: st.size };
+}
+/**
+ * Claude Code 프로젝트 디렉터리 이름(slug)을 만든다. Claude Code가 cwd를
+ * 디렉터리 이름으로 바꾸는 규칙과 같게 영숫자가 아닌 글자를 모두 `-`로 바꾼다.
+ *
+ * @param {string} projectRoot - project root 절대 경로
+ * @returns {string} 예: `/home/a/repo.x` → `-home-a-repo-x`
+ */
+function claudeProjectSlug(projectRoot) {
+    return projectRoot.replace(/[^A-Za-z0-9]/g, '-');
+}
+/**
+ * Claude Code 후보를 모은다. slug와 같은 이름, 또는 `<slug>--`로 시작하는
+ * 이름(`.worktrees` 아래 worktree의 slug)의 디렉터리 바로 아래 `*.jsonl`만 본다.
+ *
+ * @param {string} root - claude projects 루트
+ * @param {string} projectRoot - project root
+ * @param {Skipped[]} skipped - 건너뛴 사유 누적 목록
+ * @returns {Source[]} 후보 목록(정렬 전)
+ */
+function collectClaude(root, projectRoot, skipped) {
+    let names;
+    try {
+        names = fs.readdirSync(root);
+    }
+    catch (err) {
+        absorbFsError(err, 'claude-code', root, skipped);
+        return [];
+    }
+    const slug = claudeProjectSlug(projectRoot);
+    const out = [];
+    for (const name of names) {
+        if (name !== slug && !name.startsWith(`${slug}--`))
+            continue;
+        const dir = path.join(root, name);
+        let files;
+        try {
+            files = fs.readdirSync(dir);
+        }
+        catch (err) {
+            absorbFsError(err, 'claude-code', dir, skipped);
+            continue;
+        }
+        for (const f of files) {
+            if (f.endsWith('.jsonl'))
+                out.push(toSource('claude-code', path.join(dir, f), 'jsonl'));
+        }
+    }
+    return out;
+}
+/**
+ * Codex rollout 파일의 첫 줄만 읽어 JSON으로 해석한다. 본문은 읽지 않는다.
+ *
+ * @param {string} file - rollout jsonl 절대 경로
+ * @returns {unknown} 해석한 첫 줄. 줄이 없거나 JSON이 아니면 undefined
+ */
+function readFirstLineJson(file) {
+    const fd = fs.openSync(file, 'r');
+    let text;
+    try {
+        const buf = Buffer.alloc(CODEX_META_MAX_BYTES);
+        const n = fs.readSync(fd, buf, 0, CODEX_META_MAX_BYTES, 0);
+        text = buf.subarray(0, n).toString('utf8');
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    const line = text.split('\n', 1)[0];
+    try {
+        return JSON.parse(line);
+    }
+    catch (err) {
+        // JSON.parse는 SyntaxError만 던진다. 첫 줄이 깨진 파일은 해석 불가로
+        // 보고하는 것이 목적이라 흡수하고, 다른 오류가 끼어들 자리는 없다.
+        if (err instanceof SyntaxError)
+            return undefined;
+        throw err;
+    }
+}
+/**
+ * Codex sessions 루트 아래 모든 `*.jsonl`을 재귀로 훑어 cwd가 project root
+ * 아래인 파일을 후보로 모은다.
+ *
+ * @param {string} root - codex sessions 루트
+ * @param {string} projectRoot - project root
+ * @param {Skipped[]} skipped - 건너뛴 사유 누적 목록
+ * @returns {Source[]} 후보 목록(정렬 전)
+ */
+function collectCodex(root, projectRoot, skipped) {
+    const out = [];
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch (err) {
+            absorbFsError(err, 'codex', dir, skipped);
+            return;
+        }
+        for (const e of entries) {
+            const full = path.join(dir, e.name);
+            if (e.isDirectory()) {
+                walk(full);
+                continue;
+            }
+            if (!e.isFile() || !e.name.endsWith('.jsonl'))
+                continue;
+            let meta;
+            try {
+                meta = readFirstLineJson(full);
+            }
+            catch (err) {
+                absorbFsError(err, 'codex', full, skipped);
+                continue;
+            }
+            const cwd = meta?.payload?.cwd;
+            if (typeof cwd !== 'string') {
+                skipped.push({ host: 'codex', path: full, reason: 'unparseable-session-meta' });
+                continue;
+            }
+            if (isUnderRoot(cwd, projectRoot))
+                out.push(toSource('codex', full, 'jsonl'));
+        }
+    };
+    walk(root);
+    return out;
+}
+/**
+ * Cursor workspaceStorage를 훑어 `workspace.json`의 folder가 project root 아래인
+ * 작업공간의 `state.vscdb`를 후보로 모은다.
+ *
+ * @param {string} root - cursor workspaceStorage 루트
+ * @param {string} projectRoot - project root
+ * @param {Skipped[]} skipped - 건너뛴 사유 누적 목록
+ * @returns {Source[]} 후보 목록(정렬 전)
+ */
+function collectCursor(root, projectRoot, skipped) {
+    let names;
+    try {
+        names = fs.readdirSync(root);
+    }
+    catch (err) {
+        absorbFsError(err, 'cursor', root, skipped);
+        return [];
+    }
+    const out = [];
+    for (const name of names) {
+        const dir = path.join(root, name);
+        let parsed;
+        try {
+            parsed = JSON.parse(fs.readFileSync(path.join(dir, 'workspace.json'), 'utf8'));
+        }
+        catch (err) {
+            // workspace.json이 없거나(ENOENT/ENOTDIR) 깨진 작업공간은 이 프로젝트와
+            // 무관한 항목이다. skipped 사유 enum에 Cursor용 해석 불가가 없어 조용히 건너뛰고,
+            // 권한 오류 등 그 밖의 코드는 숨기지 않고 던진다.
+            const code = err.code;
+            if (code === 'ENOENT' || code === 'ENOTDIR' || err instanceof SyntaxError)
+                continue;
+            absorbFsError(err, 'cursor', dir, skipped);
+            continue;
+        }
+        // JSON `null`이나 배열·원시값처럼 객체가 아닌 workspace.json은 `.folder` 접근이
+        // TypeError를 던지므로, try 밖에서 형태를 확인해 folder 없음과 같게 건너뛴다.
+        const folder = parsed !== null && typeof parsed === 'object'
+            ? parsed.folder
+            : undefined;
+        if (typeof folder !== 'string' || !folder.startsWith('file://'))
+            continue;
+        let folderPath;
+        try {
+            folderPath = url.fileURLToPath(folder);
+        }
+        catch (err) {
+            // 이 플랫폼에서 해석할 수 없는 file URI(예: 다른 OS의 드라이브 경로)는
+            // 현재 project root와 일치할 수 없으므로 건너뛴다. POSIX에서 호스트가 든
+            // `file://host/...`(ERR_INVALID_FILE_URL_HOST)도 로컬 project root일 수 없어 같다.
+            // 그 밖의 오류는 던진다.
+            const code = err.code;
+            if (code === 'ERR_INVALID_FILE_URL_PATH' || code === 'ERR_INVALID_FILE_URL_HOST'
+                || code === 'ERR_INVALID_URL')
+                continue;
+            throw err;
+        }
+        if (!isUnderRoot(folderPath, projectRoot))
+            continue;
+        const db = path.join(dir, 'state.vscdb');
+        try {
+            out.push(toSource('cursor', db, 'sqlite'));
+        }
+        catch (err) {
+            // state.vscdb가 아직 없는 작업공간은 읽을 transcript가 없는 것이다.
+            if (err.code === 'ENOENT')
+                continue;
+            absorbFsError(err, 'cursor', db, skipped);
+        }
+    }
+    return out;
+}
+/**
+ * 현재 프로젝트에 속한 Claude Code·Codex·Cursor transcript 후보를 나열한다.
+ * transcript 본문은 읽지 않으며(Codex 첫 줄 메타만), host별 실패는 전체 실패가
+ * 아니라 skipped에 남긴다. 루트는 있으나 일치 항목이 없는 host는 `no-project-match`다.
+ *
+ * @param {object} opts - 탐색 입력
+ * @param {string} opts.projectRoot - project root 절대 경로
+ * @param {Roots} opts.roots - host별 transcript 루트(테스트는 임시 디렉터리를 주입)
+ * @param {number} opts.limit - 최대 후보 수(호출자가 1..200으로 검증)
+ * @returns {{project_root: string, sources: Source[], skipped: Skipped[]}}
+ *   sources는 mtime 내림차순으로 limit개까지
+ */
+function listRetroSources(opts) {
+    const { projectRoot, roots, limit } = opts;
+    const skipped = [];
+    const hosts = [
+        ['claude-code', roots.claude, collectClaude],
+        ['codex', roots.codex, collectCodex],
+        ['cursor', roots.cursor, collectCursor],
+    ];
+    const all = [];
+    for (const [host, root, collect] of hosts) {
+        const before = skipped.length;
+        const found = collect(root, projectRoot, skipped);
+        all.push(...found);
+        // 루트 접근 실패(root-missing/permission-denied)와 겹치지 않도록, 그 사유가
+        // 이 host에 이미 기록된 경우에는 no-project-match를 더하지 않는다.
+        const rootFailed = skipped.slice(before).some((s) => s.host === host && s.path === root);
+        if (found.length === 0 && !rootFailed) {
+            skipped.push({ host, path: root, reason: 'no-project-match' });
+        }
+    }
+    // mtime 동률은 경로로 고정해 같은 입력이 같은 순서를 내게 한다.
+    all.sort((a, b) => (a.mtime < b.mtime ? 1 : a.mtime > b.mtime ? -1 : a.path.localeCompare(b.path)));
+    return { project_root: projectRoot, sources: all.slice(0, limit), skipped };
+}
+/**
+ * host별 기본 transcript 루트를 정한다. 호출자가 home·platform·env를 주입해
+ * 테스트가 실제 home을 읽지 않는다.
+ *
+ * @param {object} opts - 입력
+ * @param {string} opts.homeDir - 사용자 home
+ * @param {NodeJS.Platform} opts.platform - Cursor 기본 경로를 가르는 플랫폼
+ * @param {Record<string, string | undefined>} opts.env - CLAUDE_CONFIG_DIR·CODEX_HOME·APPDATA를 읽는 환경
+ * @returns {Roots} claude/codex/cursor 루트
+ */
+function defaultRetroRoots(opts) {
+    const { homeDir, platform, env } = opts;
+    const claude = path.join(env.CLAUDE_CONFIG_DIR || path.join(homeDir, '.claude'), 'projects');
+    const codex = path.join(env.CODEX_HOME || path.join(homeDir, '.codex'), 'sessions');
+    let cursorBase;
+    if (platform === 'darwin') {
+        cursorBase = path.join(homeDir, 'Library', 'Application Support');
+    }
+    else if (platform === 'win32') {
+        // APPDATA가 없으면 Windows 기본 위치(home 아래 AppData/Roaming)로 추정한다.
+        cursorBase = env.APPDATA || path.join(homeDir, 'AppData', 'Roaming');
+    }
+    else {
+        cursorBase = path.join(homeDir, '.config');
+    }
+    return { claude, codex, cursor: path.join(cursorBase, 'Cursor', 'User', 'workspaceStorage') };
+}
+module.exports = { listRetroSources, defaultRetroRoots, claudeProjectSlug };