@triflux/core 10.0.0-alpha.1

package/hud/utils.mjs

@@ -0,0 +1,287 @@
+// ============================================================================
+// 유틸리티 함수
+// ============================================================================
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { createHash } from "node:crypto";
+import {
+  PERCENT_CELL_WIDTH, TIME_CELL_INNER_WIDTH, SV_CELL_WIDTH,
+} from "./constants.mjs";
+
+export async function readStdinJson() {
+  if (process.stdin.isTTY) return {};
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      process.stdin.destroy();
+      resolve({});
+    }, 200);
+    const chunks = [];
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => {
+      clearTimeout(timeout);
+      const raw = chunks.join("").trim();
+      if (!raw) { resolve({}); return; }
+      try { resolve(JSON.parse(raw)); } catch { resolve({}); }
+    });
+    process.stdin.on("error", () => {
+      clearTimeout(timeout);
+      resolve({});
+    });
+    process.stdin.resume();
+  });
+}
+
+export function readJson(filePath, fallback) {
+  if (!existsSync(filePath)) return fallback;
+  try { return JSON.parse(readFileSync(filePath, "utf-8")); } catch { return fallback; }
+}
+
+export function writeJsonSafe(filePath, data) {
+  try {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, JSON.stringify(data), { mode: 0o600 });
+  } catch { /* 쓰기 실패 무시 */ }
+}
+
+// .omc/ → .claude/cache/ 마이그레이션: 새 경로 우선, 없으면 레거시 읽고 복사
+export function readJsonMigrate(newPath, legacyPath, fallback) {
+  const data = readJson(newPath, null);
+  if (data != null) return data;
+  const legacy = readJson(legacyPath, null);
+  if (legacy != null) { writeJsonSafe(newPath, legacy); return legacy; }
+  return fallback;
+}
+
+export function stripAnsi(text) {
+  return String(text).replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+function getVisibleLength(text) {
+  return stripAnsi(text).length;
+}
+
+function padAnsi(text, width, align = "right") {
+  const len = getVisibleLength(text);
+  if (len >= width) return text;
+  const padding = " ".repeat(width - len);
+  return align === "left" ? padding + text : text + padding;
+}
+
+export function padAnsiRight(text, width) {
+  return padAnsi(text, width, "right");
+}
+
+export function padAnsiLeft(text, width) {
+  return padAnsi(text, width, "left");
+}
+
+export function fitText(text, width) {
+  const t = String(text || "");
+  if (t.length <= width) return t;
+  if (width <= 1) return "…";
+  return `${t.slice(0, width - 1)}…`;
+}
+
+export function makeHash(text) {
+  return createHash("sha256").update(String(text || ""), "utf8").digest("hex").slice(0, 16);
+}
+
+export function clampPercent(value) {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return 0;
+  return Math.max(0, Math.min(100, Math.round(numeric)));
+}
+
+export function formatPercentCell(value) {
+  return `${clampPercent(value)}%`.padStart(PERCENT_CELL_WIDTH, " ");
+}
+
+export function formatPlaceholderPercentCell() {
+  return "--%".padStart(PERCENT_CELL_WIDTH, " ");
+}
+
+export function normalizeTimeToken(value) {
+  const text = String(value || "n/a");
+  const hourMinute = text.match(/^(\d+)h(\d+)m$/);
+  if (hourMinute) {
+    return `${Number(hourMinute[1])}h${String(Number(hourMinute[2])).padStart(2, "0")}m`;
+  }
+  const dayHour = text.match(/^(\d+)d(\d+)h$/);
+  if (dayHour) {
+    return `${String(Number(dayHour[1])).padStart(2, "0")}d${String(Number(dayHour[2])).padStart(2, "0")}h`;
+  }
+  return text;
+}
+
+export function formatTimeCell(value) {
+  const text = normalizeTimeToken(value);
+  // 시간값(숫자 포함)은 0패딩, 비시간값(n/a 등)은 공백패딩
+  const padChar = /\d/.test(text) ? "0" : " ";
+  return `(${text.padStart(TIME_CELL_INNER_WIDTH, padChar)})`;
+}
+
+// 주간(d/h) 전용 — 최대 7d00h(5자)이므로 공백 불필요
+export function formatTimeCellDH(value) {
+  const text = normalizeTimeToken(value);
+  return `(${text})`;
+}
+
+export function getCliArgValue(flag) {
+  const idx = process.argv.indexOf(flag);
+  if (idx < 0) return null;
+  return process.argv[idx + 1] || null;
+}
+
+export function formatDuration(ms) {
+  if (!Number.isFinite(ms) || ms <= 0) return "n/a";
+  const totalMinutes = Math.floor(ms / 60000);
+  const days = Math.floor(totalMinutes / (60 * 24));
+  const hours = Math.floor((totalMinutes % (60 * 24)) / 60);
+  const minutes = totalMinutes % 60;
+  if (days > 0) return hours > 0 ? `${days}d${hours}h` : `${days}d`;
+  if (hours > 0) return minutes > 0 ? `${hours}h${minutes}m` : `${hours}h`;
+  return `${minutes}m`;
+}
+
+export function formatTokenCount(n) {
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+  if (n >= 1_000) return `${Math.round(n / 1_000)}K`;
+  return String(n);
+}
+
+export function getContextPercent(stdin) {
+  const nativePercent = stdin?.context_window?.used_percentage;
+  if (typeof nativePercent === "number" && Number.isFinite(nativePercent)) return clampPercent(nativePercent);
+  const usage = stdin?.context_window?.current_usage || {};
+  const totalTokens = Number(usage.input_tokens || 0)
+    + Number(usage.cache_creation_input_tokens || 0)
+    + Number(usage.cache_read_input_tokens || 0);
+  const capacity = Number(stdin?.context_window?.context_window_size || 0);
+  if (!capacity || capacity <= 0) return 0;
+  return clampPercent((totalTokens / capacity) * 100);
+}
+
+// 과거 리셋 시간 → 다음 주기로 순환하여 미래 시점 반환
+export function advanceToNextCycle(epochMs, cycleMs) {
+  const now = Date.now();
+  if (epochMs >= now || !cycleMs) return epochMs;
+  const elapsed = now - epochMs;
+  return epochMs + Math.ceil(elapsed / cycleMs) * cycleMs;
+}
+
+function parseResetDate(isoOrUnix) {
+  if (!isoOrUnix) return null;
+  const date = typeof isoOrUnix === "string"
+    ? new Date(isoOrUnix)
+    : new Date(isoOrUnix * 1000);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+
+function getResetTargetMs(isoOrUnix, cycleMs = 0) {
+  const date = parseResetDate(isoOrUnix);
+  if (!date) return null;
+  return advanceToNextCycle(date.getTime(), cycleMs);
+}
+
+function getRemainingResetMs(isoOrUnix, cycleMs = 0) {
+  const targetMs = getResetTargetMs(isoOrUnix, cycleMs);
+  if (targetMs == null) return null;
+  return targetMs - Date.now();
+}
+
+export function formatResetRemaining(isoOrUnix, cycleMs = 0) {
+  const diffMs = getRemainingResetMs(isoOrUnix, cycleMs);
+  if (diffMs == null || diffMs <= 0) return "";
+  const totalMinutes = Math.floor(diffMs / 60000);
+  const totalHours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  return `${totalHours}h${String(minutes).padStart(2, "0")}m`;
+}
+
+export function isResetPast(isoOrUnix) {
+  const date = parseResetDate(isoOrUnix);
+  return date != null && date.getTime() <= Date.now();
+}
+
+export function formatResetRemainingDayHour(isoOrUnix, cycleMs = 0) {
+  const diffMs = getRemainingResetMs(isoOrUnix, cycleMs);
+  if (diffMs == null || diffMs <= 0) return "";
+  const totalMinutes = Math.floor(diffMs / 60000);
+  const days = Math.floor(totalMinutes / (60 * 24));
+  const hours = Math.floor((totalMinutes % (60 * 24)) / 60);
+  return `${String(days).padStart(2, "0")}d${String(hours).padStart(2, "0")}h`;
+}
+
+export function calcCooldownLeftSeconds(isoDatetime) {
+  if (!isoDatetime) return 0;
+  const cooldownMs = new Date(isoDatetime).getTime() - Date.now();
+  if (!Number.isFinite(cooldownMs) || cooldownMs <= 0) return 0;
+  return Math.ceil(cooldownMs / 1000);
+}
+
+export function getProviderAccountId(provider, accountsConfig, accountsState) {
+  const providerState = accountsState?.providers?.[provider] || {};
+  const selectedId = providerState.last_selected_id;
+  if (selectedId) return selectedId;
+  const providerConfig = accountsConfig?.providers?.[provider] || [];
+  return providerConfig[0]?.id || `${provider}-main`;
+}
+
+// JWT base64 디코딩 공통 헬퍼
+export function decodeJwtEmail(idToken) {
+  if (!idToken) return null;
+  const parts = idToken.split(".");
+  if (parts.length < 2) return null;
+  let payload = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+  while (payload.length % 4) payload += "=";
+  try {
+    const decoded = JSON.parse(Buffer.from(payload, "base64").toString("utf-8"));
+    return decoded.email || null;
+  } catch { return null; }
+}
+
+// HTTPS POST (타임아웃 포함) — https 모듈은 호출자가 주입
+export function createHttpsPost(https, timeoutMs) {
+  return function httpsPost(url, body, accessToken) {
+    return new Promise((resolve) => {
+      const urlObj = new URL(url);
+      const data = JSON.stringify(body);
+      const req = https.request({
+        hostname: urlObj.hostname,
+        path: urlObj.pathname + urlObj.search,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${accessToken}`,
+          "Content-Length": Buffer.byteLength(data),
+        },
+        timeout: timeoutMs,
+      }, (res) => {
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => {
+          try { resolve(JSON.parse(Buffer.concat(chunks).toString())); }
+          catch { resolve(null); }
+        });
+      });
+      req.on("error", () => resolve(null));
+      req.on("timeout", () => { req.destroy(); resolve(null); });
+      req.write(data);
+      req.end();
+    });
+  };
+}
+
+// sv 퍼센트 포맷 (1000+ → k 표기, 5자 고정폭)
+export function formatSvPct(value) {
+  if (value == null) return "--%".padStart(SV_CELL_WIDTH);
+  if (value >= 10000) return `${Math.round(value / 1000)}k%`.padStart(SV_CELL_WIDTH);
+  if (value >= 1000) return `${(value / 1000).toFixed(1)}k%`.padStart(SV_CELL_WIDTH);
+  return `${value}%`.padStart(SV_CELL_WIDTH);
+}
+
+export function formatSavings(dollars) {
+  if (dollars >= 100) return `$${Math.round(dollars)}`;
+  if (dollars >= 10) return `$${dollars.toFixed(1)}`;
+  return `$${dollars.toFixed(2)}`;
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@triflux/core",
+  "version": "10.0.0-alpha.1",
+  "description": "triflux core — CLI routing, pipeline, adapters. Zero native dependencies.",
+  "type": "module",
+  "main": "hub/index.mjs",
+  "exports": {
+    ".": "./hub/index.mjs",
+    "./hub/*": "./hub/*"
+  },
+  "engines": { "node": ">=18.0.0" },
+  "dependencies": {
+    "pino": "^10.3.1",
+    "pino-pretty": "^13.1.3",
+    "zod": "^4.0.0"
+  },
+  "files": [
+    "hub",
+    "scripts/lib",
+    "hooks",
+    "hud"
+  ],
+  "keywords": ["claude-code", "cli-routing", "codex", "gemini", "triflux"],
+  "author": "tellang",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tellang/triflux.git",
+    "directory": "packages/core"
+  }
+}

package/scripts/lib/claudemd-manager.mjs

@@ -0,0 +1,325 @@
+/**
+ * claudemd-manager.mjs — TFX CLAUDE.md 섹션 관리
+ *
+ * OMC 패턴 차용: <!-- TFX:START --> / <!-- TFX:END --> 마커 기반.
+ * setup/update 시 마커 사이 내용을 템플릿으로 교체.
+ * doctor 시 stale 감지 + 직접 호출 충돌 경고.
+ */
+
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
+const TEMPLATE_PATH = join(SCRIPT_DIR, "..", "templates", "claudemd-tfx-section.md");
+
+const TFX_START = "<!-- TFX:START -->";
+const TFX_END = "<!-- TFX:END -->";
+const TFX_VERSION_RE = /<!-- TFX:VERSION:([\d.]+) -->/;
+
+// 직접 호출 패턴 (TFX 블록 외부에서 발견되면 충돌)
+const DIRECT_CALL_PATTERNS = [
+  /codex\s+exec\s+--dangerously/,
+  /codex\s+--profile\s+\w+\s+exec/,
+  /gemini\s+-[yp]\s/,
+  /codex\s+exec\s+review/,
+];
+
+/**
+ * 현재 triflux 버전을 package.json에서 읽기
+ */
+export function getPackageVersion() {
+  try {
+    const pkgPath = join(SCRIPT_DIR, "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    return pkg.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+/**
+ * 템플릿 파일 읽기
+ */
+export function loadTemplate() {
+  try {
+    return readFileSync(TEMPLATE_PATH, "utf8").trim();
+  } catch (error) {
+    throw new Error(`TFX 템플릿 로드 실패: ${TEMPLATE_PATH}: ${error.message}`);
+  }
+}
+
+/**
+ * CLAUDE.md에서 TFX 섹션 추출
+ * @returns {{ found: boolean, version: string|null, content: string|null, startIdx: number, endIdx: number }}
+ */
+export function readSection(filePath) {
+  if (!existsSync(filePath)) {
+    return { found: false, version: null, content: null, startIdx: -1, endIdx: -1 };
+  }
+
+  const raw = readFileSync(filePath, "utf8");
+  const startIdx = raw.indexOf(TFX_START);
+  const endIdx = raw.indexOf(TFX_END);
+
+  if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) {
+    return { found: false, version: null, content: null, startIdx: -1, endIdx: -1 };
+  }
+
+  const section = raw.slice(startIdx, endIdx + TFX_END.length);
+  const versionMatch = section.match(TFX_VERSION_RE);
+  const version = versionMatch ? versionMatch[1] : null;
+
+  return { found: true, version, content: section, startIdx, endIdx: endIdx + TFX_END.length };
+}
+
+/**
+ * TFX 섹션 쓰기/교체
+ * - 기존 마커가 있으면 교체
+ * - 없으면 OMC:END 뒤에 삽입 (없으면 파일 끝)
+ */
+export function writeSection(filePath, options = {}) {
+  const version = options.version || getPackageVersion();
+  const template = options.template || loadTemplate();
+
+  const block = [
+    TFX_START,
+    `<!-- TFX:VERSION:${version} -->`,
+    template,
+    TFX_END,
+  ].join("\n");
+
+  if (!existsSync(filePath)) {
+    writeFileSync(filePath, block + "\n", "utf8");
+    return { action: "created", version };
+  }
+
+  const raw = readFileSync(filePath, "utf8");
+  const existing = readSection(filePath);
+
+  if (existing.found) {
+    // 기존 TFX 블록 교체
+    const before = raw.slice(0, existing.startIdx);
+    const after = raw.slice(existing.endIdx);
+    writeFileSync(filePath, before + block + after, "utf8");
+    return { action: "updated", oldVersion: existing.version, version };
+  }
+
+  // OMC:END 뒤에 삽입
+  const omcEndIdx = raw.indexOf("<!-- OMC:END -->");
+  if (omcEndIdx !== -1) {
+    const insertAt = omcEndIdx + "<!-- OMC:END -->".length;
+    const before = raw.slice(0, insertAt);
+    const after = raw.slice(insertAt);
+    writeFileSync(filePath, before + "\n" + block + after, "utf8");
+    return { action: "inserted_after_omc", version };
+  }
+
+  // 파일 끝에 추가
+  const separator = raw.endsWith("\n") ? "" : "\n";
+  writeFileSync(filePath, raw + separator + block + "\n", "utf8");
+  return { action: "appended", version };
+}
+
+/**
+ * TFX 섹션 제거
+ */
+export function removeSection(filePath) {
+  if (!existsSync(filePath)) return { action: "no_file" };
+
+  const raw = readFileSync(filePath, "utf8");
+  const existing = readSection(filePath);
+
+  if (!existing.found) return { action: "not_found" };
+
+  const before = raw.slice(0, existing.startIdx);
+  const after = raw.slice(existing.endIdx);
+  // 연속 빈줄 정리
+  const cleaned = (before + after).replace(/\n{3,}/g, "\n\n");
+  writeFileSync(filePath, cleaned, "utf8");
+  return { action: "removed", oldVersion: existing.version };
+}
+
+/**
+ * TFX 블록 외부에서 직접 CLI 호출 감지
+ * @returns {{ conflicts: Array<{line: number, text: string, pattern: string}> }}
+ */
+export function detectConflicts(filePath) {
+  if (!existsSync(filePath)) return { conflicts: [] };
+
+  const raw = readFileSync(filePath, "utf8");
+  const existing = readSection(filePath);
+
+  // TFX 블록 내부 제거 후 검사
+  let textOutside = raw;
+  if (existing.found) {
+    textOutside = raw.slice(0, existing.startIdx) + raw.slice(existing.endIdx);
+  }
+
+  const lines = textOutside.split("\n");
+  const conflicts = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    // 코드블록 안은 무시
+    if (line.trim().startsWith("```")) continue;
+    // 주석/금지 문맥 무시
+    if (/금지|차단|NEVER|prohibit|block/i.test(line)) continue;
+
+    for (const pattern of DIRECT_CALL_PATTERNS) {
+      if (pattern.test(line)) {
+        conflicts.push({
+          line: i + 1,
+          text: line.trim(),
+          pattern: pattern.source,
+        });
+      }
+    }
+  }
+
+  return { conflicts };
+}
+
+/**
+ * Doctor 진단 — 종합 검사
+ * @returns {{ status: "ok"|"warn"|"error", issues: string[] }}
+ */
+export function diagnose(filePath) {
+  const issues = [];
+
+  if (!existsSync(filePath)) {
+    return { status: "error", issues: ["CLAUDE.md 파일 없음: " + filePath] };
+  }
+
+  const section = readSection(filePath);
+  if (!section.found) {
+    issues.push("TFX 섹션 없음 — `tfx setup` 또는 `/tfx-setup`으로 추가 필요");
+  } else {
+    const currentVersion = getPackageVersion();
+    if (section.version !== currentVersion) {
+      issues.push(`TFX 섹션 stale: ${section.version} → ${currentVersion} (업데이트 필요)`);
+    }
+  }
+
+  const { conflicts } = detectConflicts(filePath);
+  for (const c of conflicts) {
+    issues.push(`L${c.line}: 직접 CLI 호출 감지 — "${c.text.slice(0, 60)}..."`);
+  }
+
+  if (issues.length === 0) return { status: "ok", issues: [] };
+  if (issues.some((i) => i.includes("stale") || i.includes("없음"))) return { status: "error", issues };
+  return { status: "warn", issues };
+}
+
+// ── 기존 유저 마이그레이션 ──
+
+// 레거시 <user_cli_routing> 마커 없는 섹션 감지
+const LEGACY_PATTERNS = [
+  /<user_cli_routing>/,
+  /Codex Pro 무료 기간/,
+  /codex exec --dangerously-bypass.*skip-git-repo-check/,
+  /OMC 에이전트 → CLI 매핑/,
+  /Spark 가드레일/,
+];
+
+/**
+ * 레거시 CLI 라우팅 섹션 감지
+ * @returns {{ found: boolean, startIdx: number, endIdx: number, markers: string[] }}
+ */
+export function detectLegacy(filePath) {
+  if (!existsSync(filePath)) return { found: false, startIdx: -1, endIdx: -1, markers: [] };
+
+  const raw = readFileSync(filePath, "utf8");
+  const markers = [];
+
+  for (const p of LEGACY_PATTERNS) {
+    if (p.test(raw)) markers.push(p.source);
+  }
+
+  if (markers.length === 0) return { found: false, startIdx: -1, endIdx: -1, markers: [] };
+
+  // <user_cli_routing> ... </user_cli_routing> 블록 범위 찾기
+  const startTag = raw.indexOf("<user_cli_routing>");
+  const endTag = raw.indexOf("</user_cli_routing>");
+
+  if (startTag !== -1 && endTag !== -1) {
+    return { found: true, startIdx: startTag, endIdx: endTag + "</user_cli_routing>".length, markers };
+  }
+
+  return { found: true, startIdx: -1, endIdx: -1, markers };
+}
+
+/**
+ * 레거시 섹션을 TFX 관리 블록으로 마이그레이션
+ * 1. 레거시 <user_cli_routing> 제거
+ * 2. TFX 마커 블록 삽입
+ * @returns {{ action: string, removed: string[], version: string }}
+ */
+export function migrate(filePath, options = {}) {
+  const legacy = detectLegacy(filePath);
+  const existing = readSection(filePath);
+
+  // 이미 TFX 마커가 있고 레거시가 없으면 스킵
+  if (existing.found && !legacy.found) {
+    return { action: "already_managed", removed: [], version: existing.version };
+  }
+
+  const raw = readFileSync(filePath, "utf8");
+  let cleaned = raw;
+
+  const removed = [];
+
+  // 1. 레거시 <user_cli_routing> 블록 제거
+  if (legacy.found && legacy.startIdx !== -1) {
+    // <!-- USER OVERRIDES --> 코멘트도 같이 제거
+    let removeStart = legacy.startIdx;
+    const userOverrideComment = "<!-- USER OVERRIDES";
+    const commentIdx = cleaned.lastIndexOf(userOverrideComment, removeStart);
+    if (commentIdx !== -1 && removeStart - commentIdx < 200) {
+      removeStart = commentIdx;
+    }
+
+    const before = cleaned.slice(0, removeStart);
+    const after = cleaned.slice(legacy.endIdx);
+    cleaned = (before + after).replace(/\n{3,}/g, "\n\n");
+    removed.push("<user_cli_routing> block");
+  }
+
+  // 2. TFX 블록이 있으면 제거 (교체 위해)
+  if (existing.found) {
+    const s = readSection(filePath);
+    if (s.found) {
+      cleaned = cleaned.slice(0, cleaned.indexOf(TFX_START)) +
+        cleaned.slice(cleaned.indexOf(TFX_END) + TFX_END.length);
+      cleaned = cleaned.replace(/\n{3,}/g, "\n\n");
+      removed.push("old TFX block");
+    }
+  }
+
+  // 3. 정리된 파일 저장
+  writeFileSync(filePath, cleaned, "utf8");
+
+  // 4. 새 TFX 블록 삽입
+  const result = writeSection(filePath, options);
+
+  return { action: "migrated", removed, version: result.version };
+}
+
+/**
+ * 모든 CLAUDE.md 파일 스캔 (전역 + 프로젝트)
+ * @returns {string[]} 경로 목록
+ */
+export function findAllClaudeMdPaths() {
+  const paths = [];
+
+  // 전역
+  const globalPath = join(homedir(), ".claude", "CLAUDE.md");
+  if (existsSync(globalPath)) paths.push(globalPath);
+
+  // 현재 프로젝트
+  const cwdPath = join(process.cwd(), "CLAUDE.md");
+  if (existsSync(cwdPath)) paths.push(cwdPath);
+
+  return paths;
+}