@conscience-technology/ctds 0.0.0-stage → 0.1.0

package/src/commands/update.js

@@ -0,0 +1,275 @@
+/**
+ * `ctds update` — 설치된 CTDS 자산을 최신으로 교체.
+ *
+ * 하는 일:
+ *   1) components/ctds/.ctds-meta.json 로드. 없으면 "init으로 재설치" 안내 + exit.
+ *   2) components/ctds — 해시 비교로 3단 큐 분류:
+ *      - 신규 (사용자 쪽에 없음) → 추가
+ *      - 안전 (해시 매치 또는 번들과 동일) → 조용히 덮어쓰기
+ *      - 충돌 (사용자 수정) → prompt (y/n/d/A/N/q) 또는 --force 전부 덮어쓰기
+ *   3) prompts/, .claude/skills/ctds/, public/onboarding/ — 조용히 전부 덮어쓰기
+ *   4) components/ctds/.ctds-meta.json 재생성
+ *
+ * 플래그:
+ *   --dry     쓰기 없이 변경·충돌 보고만
+ *   --force   수정 감지 무시, 전부 덮어쓰기 (git 커밋 후에만)
+ */
+
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { detectProject } from "../utils/detect.js";
+import { getAssetSources } from "../utils/assets.js";
+import { hashFile } from "../utils/hash.js";
+import { loadMeta, writeMeta, computeFilesMap, rebuildMeta } from "../utils/meta.js";
+import { askConflict } from "../utils/prompt.js";
+import { renderDiff } from "../utils/diff.js";
+import { c, step, success, warn, info, kv } from "../utils/log.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CLI_PKG_PATH = join(__dirname, "..", "..", "package.json");
+function readCliVersion() {
+  try {
+    return JSON.parse(readFileSync(CLI_PKG_PATH, "utf8")).version;
+  } catch {
+    return "unknown";
+  }
+}
+
+const META_NAME = ".ctds-meta.json";
+
+export async function run(args) {
+  const dry = args.includes("--dry");
+  const force = args.includes("--force");
+
+  console.log("");
+  console.log(c.bold("CTDS 업데이트"));
+  console.log(c.dim("—").repeat(40));
+
+  const cwd = process.cwd();
+  const project = detectProject(cwd);
+  if (!project.ok) {
+    console.error(c.red("✗"), project.reason);
+    process.exit(1);
+  }
+
+  const componentsDir = resolve(
+    cwd,
+    project.useSrcDir ? "src/components/ctds" : "components/ctds",
+  );
+  const promptsDir = resolve(cwd, "prompts");
+  const skillDir = resolve(cwd, ".claude/skills/ctds");
+  const publicDir = resolve(cwd, "public/onboarding");
+
+  // 1) 메타 로드
+  const meta = loadMeta(componentsDir);
+  if (!meta) {
+    console.error(c.red("✗"), `${META_NAME}이 없습니다.`);
+    console.error("");
+    console.error("   이 프로젝트는 ctds init으로 설치되지 않았거나 구버전입니다.");
+    console.error("   `npx ctds init --force`로 재설치하거나 수동으로 생성 후 다시 시도하세요.");
+    process.exit(1);
+  }
+  kv("프로젝트", project.name);
+  kv("설치 버전", meta.version);
+  kv("CLI 버전", readCliVersion());
+  if (dry) kv("모드", c.yellow("dry run (쓰기 없음)"));
+  if (force) kv("모드", c.yellow("force (충돌 무시, 전부 덮어쓰기)"));
+  console.log("");
+
+  // 2) 자산 소스 로드
+  const assets = getAssetSources();
+  info(`자산 소스: ${assets.mode === "bundled" ? "번들" : "로컬 레포"}`);
+  console.log("");
+
+  // 3) components 비교 — 3단 큐 분류
+  const sourceComponents = assets.components;
+  if (!existsSync(sourceComponents)) {
+    console.error(c.red("✗"), `번들 components 소스를 찾을 수 없습니다: ${sourceComponents}`);
+    process.exit(1);
+  }
+
+  const bundleFiles = computeFilesMap(sourceComponents); // { relPath: "sha256:hex" }
+  const addQueue = [];      // 사용자 쪽에 없음
+  const safeQueue = [];     // 사용자가 안 건드림 (meta 해시 일치)
+  const conflictQueue = []; // 사용자 수정
+
+  for (const [relPath, bundleHash] of Object.entries(bundleFiles)) {
+    const userPath = join(componentsDir, relPath);
+    if (!existsSync(userPath)) {
+      addQueue.push(relPath);
+      continue;
+    }
+    const metaHash = meta.files?.[relPath];
+    const userHash = `sha256:${hashFile(userPath)}`;
+    if (!metaHash) {
+      // meta엔 없는데 파일은 있음 → 사용자가 수동 추가. 신규 번들 파일이 아니면 보존하는 게 안전.
+      // 이번 번들에도 있으면 사용자 커스텀 추가분으로 간주 — 충돌 처리.
+      conflictQueue.push({ relPath, userHash, bundleHash, reason: "untracked" });
+      continue;
+    }
+    if (userHash === metaHash) {
+      // 사용자가 안 건드림
+      if (userHash !== bundleHash) safeQueue.push(relPath);
+      // 번들과 동일하면 아무것도 안 함
+    } else {
+      // 사용자가 수정함
+      if (userHash !== bundleHash) {
+        conflictQueue.push({ relPath, userHash, bundleHash, reason: "modified" });
+      }
+      // 수정했는데 번들과 동일한 경우(이론상 거의 없음) → 조용히 통과
+    }
+  }
+
+  // 번들에서 삭제된 파일(사용자 쪽에만 있음)은 보존 — 안전 측
+  const removedInBundle = Object.keys(meta.files ?? {}).filter((p) => !(p in bundleFiles));
+
+  // 요약
+  console.log(c.bold("요약"));
+  kv("추가", String(addQueue.length));
+  kv("안전 덮어쓰기", String(safeQueue.length));
+  kv("충돌", String(conflictQueue.length));
+  if (removedInBundle.length > 0) {
+    kv("번들에서 삭제됨 (보존)", String(removedInBundle.length));
+  }
+  console.log("");
+
+  if (dry) {
+    if (addQueue.length > 0) {
+      console.log(c.bold("추가 예정:"));
+      for (const p of addQueue) console.log(`  + ${p}`);
+      console.log("");
+    }
+    if (safeQueue.length > 0) {
+      console.log(c.bold("안전 덮어쓰기 예정:"));
+      for (const p of safeQueue) console.log(`  ~ ${p}`);
+      console.log("");
+    }
+    if (conflictQueue.length > 0) {
+      console.log(c.bold("충돌 (실제 실행 시 prompt):"));
+      for (const { relPath, reason } of conflictQueue) {
+        console.log(`  ! ${relPath} ${c.dim(`(${reason})`)}`);
+      }
+      console.log("");
+    }
+    info("dry run — 실제 변경 없음.");
+    return;
+  }
+
+  // 4) 안전·추가 처리
+  for (const relPath of safeQueue) {
+    copyFile(sourceComponents, componentsDir, relPath);
+    step("업데이트", relPath);
+  }
+  for (const relPath of addQueue) {
+    copyFile(sourceComponents, componentsDir, relPath);
+    step("추가", relPath);
+  }
+
+  // 5) 충돌 처리
+  let overwriteAll = force;
+  let keepAll = false;
+  const kept = [];
+  const overwritten = [];
+  for (const item of conflictQueue) {
+    const { relPath, userHash, bundleHash } = item;
+    if (overwriteAll) {
+      copyFile(sourceComponents, componentsDir, relPath);
+      overwritten.push(relPath);
+      step("덮어쓰기 (force)", relPath);
+      continue;
+    }
+    if (keepAll) {
+      kept.push(relPath);
+      continue;
+    }
+
+    let decided = false;
+    while (!decided) {
+      const choice = await askConflict(relPath);
+      if (choice === "y") {
+        copyFile(sourceComponents, componentsDir, relPath);
+        overwritten.push(relPath);
+        decided = true;
+      } else if (choice === "n") {
+        kept.push(relPath);
+        decided = true;
+      } else if (choice === "d") {
+        const userContent = readFileSync(join(componentsDir, relPath), "utf8");
+        const bundleContent = readFileSync(join(sourceComponents, relPath), "utf8");
+        console.log("");
+        console.log(renderDiff(userContent, bundleContent, { label: relPath }));
+      } else if (choice === "A") {
+        copyFile(sourceComponents, componentsDir, relPath);
+        overwritten.push(relPath);
+        overwriteAll = true;
+        decided = true;
+      } else if (choice === "N") {
+        kept.push(relPath);
+        keepAll = true;
+        decided = true;
+      } else if (choice === "q") {
+        console.log("");
+        warn("중단됨. 이미 처리된 파일은 유지됩니다.");
+        _finalReport(overwritten, kept, addQueue, safeQueue);
+        return;
+      }
+    }
+  }
+
+  // 6) 보조 자산 — 조용히 덮어쓰기
+  for (const [src, destAbs, label] of [
+    [assets.prompts, promptsDir, "prompts"],
+    [assets.skill, skillDir, "skill"],
+    [assets.publicAssets, publicDir, "onboarding"],
+  ]) {
+    if (!existsSync(src)) {
+      warn(`자산 누락 (스킵): ${label}`);
+      continue;
+    }
+    rmSyncIfExists(destAbs);
+    mkdirSync(destAbs, { recursive: true });
+    cpSync(src, destAbs, { recursive: true });
+    step("덮어쓰기", label);
+  }
+
+  // 7) meta 재생성
+  writeMeta(componentsDir, rebuildMeta(componentsDir, meta, readCliVersion()));
+  step("메타 갱신", `${componentsDir.replace(cwd + sep, "")}${sep}${META_NAME}`);
+
+  console.log("");
+  _finalReport(overwritten, kept, addQueue, safeQueue);
+}
+
+/** 번들 소스에서 사용자 플젝으로 파일 하나 복사. 디렉토리 자동 생성. */
+function copyFile(sourceRoot, destRoot, relPath) {
+  const src = join(sourceRoot, relPath);
+  const dst = join(destRoot, relPath);
+  mkdirSync(dirname(dst), { recursive: true });
+  cpSync(src, dst);
+}
+
+function rmSyncIfExists(path) {
+  if (existsSync(path)) rmSync(path, { recursive: true, force: true });
+}
+
+function _finalReport(overwritten, kept, addQueue, safeQueue) {
+  console.log(c.bold("완료"));
+  success(`${safeQueue.length + overwritten.length}개 업데이트`);
+  if (addQueue.length > 0) success(`${addQueue.length}개 추가`);
+  if (kept.length > 0) {
+    warn(`${kept.length}개 유지 (사용자 수정 보존):`);
+    for (const p of kept) console.log(`    · ${p}`);
+    console.log("");
+    info("나중에 수동으로 머지하려면: git diff --no-index <현재> <원본>");
+  }
+}

package/src/utils/assets.js

@@ -0,0 +1,78 @@
+/**
+ * CLI가 복사해줄 자산(components/, prompts/, .claude/skills/ctds/)의 루트 경로.
+ *
+ * 두 가지 상황을 지원:
+ *  1) 로컬 개발 — `npm link`로 심링크된 상태. 이 파일 → ../../assets가 비어있을 수 있어
+ *     repo root로 올라가 ../../web/components, ../../prompts 를 참조.
+ *  2) publish 후 — publish 전 `bundle-assets` 스크립트가 자산을 packages/ctds-cli/assets/
+ *     로 복사해놓음. 이때는 assets/components, assets/prompts 가 존재.
+ *
+ * 우선순위: bundled assets → repo fallback.
+ */
+
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export function getAssetRoot() {
+  const cliRoot = join(__dirname, "..", "..");
+
+  // 1) bundled
+  const bundledAssets = join(cliRoot, "assets");
+  if (existsSync(join(bundledAssets, "components"))) {
+    return bundledAssets;
+  }
+
+  // 2) local repo fallback: packages/ctds-cli → repo root
+  const repoRoot = join(cliRoot, "..", "..");
+  return makeRepoView(repoRoot);
+}
+
+/**
+ * repo 소스를 "bundled 구조"처럼 보이게 하는 뷰 경로 매핑.
+ * cp 할 때 join(assetRoot, "components") 같은 식으로 조립하니까
+ * 실제 소스 경로가 뭐든 그 구조를 흉내내야 함.
+ *
+ * 간단한 해결: repoRoot를 그대로 돌려주되, caller가 "components" 대신
+ * "web/components"로 요청하도록 하면 안 돼. 그래서 symlink·실제 복사 대신
+ * **tagged root 객체**를 리턴하지 않고, assetRoot를 바탕으로 상대 경로 리스트를
+ * caller 쪽에서 적절히 재지정하는 게 깔끔.
+ *
+ * 지금은 간단히: repo fallback 모드에선 repoRoot를 돌려주고 caller는
+ * "web/components" 식 경로를 쓰도록 — getAssetMap()으로 분리.
+ */
+function makeRepoView(repoRoot) {
+  return repoRoot;
+}
+
+/**
+ * 자산 복사 매핑. 번들/레포 모드에 따라 소스 경로가 다름.
+ *   returns: Array<[absoluteSrcDir, label]>
+ * label은 로그 표시용.
+ */
+export function getAssetSources() {
+  const cliRoot = join(__dirname, "..", "..");
+  const bundledAssets = join(cliRoot, "assets");
+
+  if (existsSync(join(bundledAssets, "components"))) {
+    return {
+      mode: "bundled",
+      components: join(bundledAssets, "components"),
+      prompts: join(bundledAssets, "prompts"),
+      skill: join(bundledAssets, "skill"),
+      publicAssets: join(bundledAssets, "public"),
+    };
+  }
+
+  // repo fallback
+  const repoRoot = join(cliRoot, "..", "..");
+  return {
+    mode: "repo",
+    components: join(repoRoot, "web", "components"),
+    prompts: join(repoRoot, "prompts"),
+    skill: join(repoRoot, ".claude", "skills", "ctds"),
+    publicAssets: join(repoRoot, "web", "public", "onboarding"),
+  };
+}

package/src/utils/deps.js

@@ -0,0 +1,51 @@
+/**
+ * CTDS 런타임 의존성 체크 + 설치 명령 생성.
+ * 사용자 플젝 package.json을 읽어 빠진 패키지만 안내.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+/** CTDS 컴포넌트가 실제로 import하는 외부 패키지. */
+export const CTDS_RUNTIME_DEPS = {
+  "@phosphor-icons/react": "^2.1.10",
+  "solar-icon-set": "^2.0.1",
+  "lucide-react": "^1.47.0",
+  "@radix-ui/react-popover": "^1.1.23",
+  "@radix-ui/react-select": "^2.3.7",
+  "@radix-ui/react-tooltip": "^1.2.16",
+  "@radix-ui/react-context-menu": "^2.3.7",
+  "@radix-ui/react-slot": "^1.3.3",
+  "@dnd-kit/core": "^6.3.1",
+  "@dnd-kit/sortable": "^10.0.0",
+  "@dnd-kit/utilities": "^3.2.2",
+};
+
+/**
+ * 사용자 플젝의 package.json을 읽어 CTDS가 필요로 하는 deps 중 빠진 것 리스트.
+ * @returns { missing: string[], installed: string[] }
+ */
+export function checkMissingDeps(projectRoot) {
+  const pkgPath = join(projectRoot, "package.json");
+  if (!existsSync(pkgPath)) {
+    return { missing: Object.keys(CTDS_RUNTIME_DEPS), installed: [] };
+  }
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+  const allDeps = {
+    ...(pkg.dependencies ?? {}),
+    ...(pkg.devDependencies ?? {}),
+  };
+  const missing = [];
+  const installed = [];
+  for (const name of Object.keys(CTDS_RUNTIME_DEPS)) {
+    if (allDeps[name]) installed.push(name);
+    else missing.push(name);
+  }
+  return { missing, installed };
+}
+
+/** `npm install` 명령어 문자열 생성. */
+export function renderInstallCmd(missing) {
+  if (missing.length === 0) return null;
+  return `npm install ${missing.join(" ")}`;
+}

package/src/utils/detect.js

@@ -0,0 +1,47 @@
+/**
+ * Next.js app router 플젝 감지.
+ * - package.json에 next 의존성이 있어야 함
+ * - app/ 또는 src/app/ 디렉토리가 있어야 함
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+export function detectProject(cwd) {
+  const pkgPath = join(cwd, "package.json");
+  if (!existsSync(pkgPath)) {
+    return { ok: false, reason: "package.json을 찾을 수 없습니다." };
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+  } catch (e) {
+    return { ok: false, reason: `package.json 파싱 실패: ${e.message}` };
+  }
+
+  const hasNext =
+    (pkg.dependencies && pkg.dependencies.next) ||
+    (pkg.devDependencies && pkg.devDependencies.next);
+  if (!hasNext) {
+    return {
+      ok: false,
+      reason: "package.json에 next 의존성이 없습니다. Next.js 플젝이 아닙니다.",
+    };
+  }
+
+  const useSrcDir = existsSync(join(cwd, "src", "app"));
+  const useRootDir = existsSync(join(cwd, "app"));
+  if (!useSrcDir && !useRootDir) {
+    return {
+      ok: false,
+      reason: "app/ 또는 src/app/ 디렉토리를 찾을 수 없습니다. App Router 플젝이 아닙니다.",
+    };
+  }
+
+  return {
+    ok: true,
+    name: pkg.name ?? "(unnamed)",
+    useSrcDir,
+    appDir: useSrcDir ? "src/app" : "app",
+  };
+}

package/src/utils/diff.js

@@ -0,0 +1,52 @@
+/**
+ * 간단 line-by-line diff 포매터. 외부 의존성 없음.
+ *
+ * 전략: 두 파일을 라인 단위로 비교해 공통 접두어·접미어는 생략하고,
+ * 차이 블록만 `--- / +++` 형태로 출력. maxLines로 cap, 넘으면 "... (N more lines)".
+ *
+ * 실제 LCS diff가 아니라 "변경된 라인 범위"만 보여주는 축약판.
+ * 완벽한 diff는 git diff --no-index를 유도 (가이드 문서에 명시).
+ */
+
+import { c } from "./log.js";
+
+export function renderDiff(before, after, { label, maxLines = 50 } = {}) {
+  const b = before.split("\n");
+  const a = after.split("\n");
+
+  // 공통 접두어·접미어 길이 계산
+  let prefix = 0;
+  while (prefix < b.length && prefix < a.length && b[prefix] === a[prefix]) prefix++;
+
+  let suffix = 0;
+  while (
+    suffix < b.length - prefix &&
+    suffix < a.length - prefix &&
+    b[b.length - 1 - suffix] === a[a.length - 1 - suffix]
+  ) {
+    suffix++;
+  }
+
+  const bChanged = b.slice(prefix, b.length - suffix);
+  const aChanged = a.slice(prefix, a.length - suffix);
+
+  const lines = [];
+  if (label) {
+    lines.push(c.dim(`--- ${label} (현재)`));
+    lines.push(c.dim(`+++ ${label} (ctds 최신)`));
+  }
+  lines.push(c.dim(`@@ line ${prefix + 1} @@`));
+
+  const changed = [];
+  for (const l of bChanged) changed.push(c.red(`- ${l}`));
+  for (const l of aChanged) changed.push(c.green(`+ ${l}`));
+
+  if (changed.length <= maxLines) {
+    lines.push(...changed);
+  } else {
+    lines.push(...changed.slice(0, maxLines));
+    lines.push(c.dim(`... (${changed.length - maxLines} more lines, 전체는 git diff로 확인)`));
+  }
+
+  return lines.join("\n");
+}

package/src/utils/hash.js

@@ -0,0 +1,16 @@
+/**
+ * SHA-256 해시 유틸. 외부 의존성 없이 Node 내장 crypto만 사용.
+ */
+
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+
+/** 파일 경로 → sha256 hex. */
+export function hashFile(path) {
+  return createHash("sha256").update(readFileSync(path)).digest("hex");
+}
+
+/** 문자열 → sha256 hex. */
+export function hashString(s) {
+  return createHash("sha256").update(s, "utf8").digest("hex");
+}

package/src/utils/log.js

@@ -0,0 +1,41 @@
+/**
+ * 미니멀 로그 헬퍼. ANSI 색 지원 (TTY에서만).
+ * 외부 의존성 없이 cross-platform.
+ */
+
+const isTTY = process.stdout.isTTY && !process.env.NO_COLOR;
+
+function wrap(code) {
+  return (s) => (isTTY ? `\x1b[${code}m${s}\x1b[0m` : s);
+}
+
+export const c = {
+  bold: wrap(1),
+  dim: wrap(2),
+  red: wrap(31),
+  green: wrap(32),
+  yellow: wrap(33),
+  blue: wrap(34),
+  cyan: wrap(36),
+};
+
+export function step(verb, msg) {
+  console.log(`  ${c.cyan("•")} ${c.dim(verb)} ${msg}`);
+}
+
+export function success(msg) {
+  console.log(`  ${c.green("✓")} ${msg}`);
+}
+
+export function warn(msg) {
+  console.log(`  ${c.yellow("!")} ${msg}`);
+}
+
+export function info(msg) {
+  console.log(`  ${c.blue("i")} ${msg}`);
+}
+
+/** 키-값 라인 (들여쓰기 2칸, 키는 dim) */
+export function kv(key, val) {
+  console.log(`  ${c.dim(key.padEnd(14))} ${val}`);
+}

package/src/utils/meta.js

@@ -0,0 +1,73 @@
+/**
+ * .ctds-meta.json 읽기/쓰기 + 파일 트리 해시 맵 계산.
+ *
+ * 메타 포맷:
+ * {
+ *   "version": "0.1.0",
+ *   "installedAt": "ISO-8601",
+ *   "updatedAt": "ISO-8601",
+ *   "files": { "<상대경로>": "sha256:<hex>", ... }
+ * }
+ *
+ * 파일 경로는 메타 파일이 담긴 디렉토리 기준 상대 경로 (POSIX 슬래시).
+ * .ctds-meta.json 자신은 files 맵에서 제외.
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+import { hashFile } from "./hash.js";
+
+const META_NAME = ".ctds-meta.json";
+
+export function metaPath(dir) {
+  return join(dir, META_NAME);
+}
+
+/** 메타 로드. 없으면 null. */
+export function loadMeta(dir) {
+  const p = metaPath(dir);
+  if (!existsSync(p)) return null;
+  try {
+    return JSON.parse(readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+/** 메타 쓰기. updatedAt 자동 갱신. */
+export function writeMeta(dir, meta) {
+  const next = { ...meta, updatedAt: new Date().toISOString() };
+  writeFileSync(metaPath(dir), JSON.stringify(next, null, 2) + "\n", "utf8");
+}
+
+/** 디렉토리 재귀 walk → { 상대경로(posix): "sha256:hex" } 맵. 메타 파일 자체는 제외. */
+export function computeFilesMap(dir) {
+  const out = {};
+  walk(dir, dir, out);
+  return out;
+}
+
+function walk(rootDir, currentDir, out) {
+  for (const name of readdirSync(currentDir)) {
+    if (name === META_NAME) continue;
+    const full = join(currentDir, name);
+    const st = statSync(full);
+    if (st.isDirectory()) {
+      walk(rootDir, full, out);
+    } else if (st.isFile()) {
+      const rel = relative(rootDir, full).split(sep).join("/");
+      out[rel] = `sha256:${hashFile(full)}`;
+    }
+  }
+}
+
+/** version·installedAt 유지, files·updatedAt만 재계산한 새 메타 생성. */
+export function rebuildMeta(dir, prevMeta, version) {
+  const now = new Date().toISOString();
+  return {
+    version,
+    installedAt: prevMeta?.installedAt ?? now,
+    updatedAt: now,
+    files: computeFilesMap(dir),
+  };
+}

package/src/utils/prompt.js

@@ -0,0 +1,28 @@
+/**
+ * 대화형 prompt — readline 기반. 외부 의존성 없음.
+ */
+
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+
+const VALID = new Set(["y", "n", "d", "A", "N", "q"]);
+
+/**
+ * 충돌 파일에 대해 사용자 선택을 받음.
+ * 반환: 'y' | 'n' | 'd' | 'A' | 'N' | 'q'
+ */
+export async function askConflict(relPath) {
+  const rl = createInterface({ input, output });
+  try {
+    while (true) {
+      console.log("");
+      console.log(`  ${relPath} 가 수정됐어요.`);
+      console.log(`  (y) 덮어쓰기  (n) 유지  (d) diff 보기  (A) 남은 전부 y  (N) 남은 전부 n  (q) 중단`);
+      const answer = (await rl.question("  > ")).trim();
+      if (VALID.has(answer)) return answer;
+      console.log("  (올바른 선택지: y / n / d / A / N / q)");
+    }
+  } finally {
+    rl.close();
+  }
+}