depfresh 0.9.2

package/dist/chunks/index2.mjs

@@ -0,0 +1,624 @@
+import * as readline from 'node:readline';
+import * as semver from 'semver';
+import { g as getVersionPrefix, f as applyVersionPrefix, h as getDiff, t as timeDifference, s as stripAnsi, i as truncate, j as padEnd, b as colorizeVersionDiff, a as arrow, e as colorDiff } from '../shared/depfresh.ClIHCCxD.mjs';
+import c from 'ansis';
+import '../shared/depfresh.B1o7OHO_.mjs';
+import 'node:fs';
+import 'node:os';
+import 'find-up-simple';
+import 'ini';
+import 'pathe';
+import 'node:child_process';
+import 'detect-indent';
+import 'pnpm-workspace-yaml';
+import 'yaml';
+import 'p-limit';
+import 'better-sqlite3';
+import 'tinyglobby';
+
+const MAX_VERSIONS = 20;
+function prepareDetailVersions(dep, explain) {
+  const { pkgData, currentVersion } = dep;
+  const current = semver.coerce(currentVersion);
+  if (!current) return [];
+  const newer = pkgData.versions.filter((v) => {
+    const parsed = semver.valid(v);
+    return parsed && semver.gt(v, current);
+  }).sort((a, b) => semver.gt(a, b) ? -1 : 1).slice(0, MAX_VERSIONS);
+  const tagsByVersion = /* @__PURE__ */ new Map();
+  for (const [tag, ver] of Object.entries(pkgData.distTags)) {
+    tagsByVersion.set(ver, tag);
+  }
+  return newer.map((version) => {
+    const diff = getDiff(currentVersion, version);
+    const publishedAt = pkgData.time?.[version];
+    const age = timeDifference(publishedAt);
+    const distTag = tagsByVersion.get(version);
+    const deprecated = pkgData.deprecated?.[version];
+    const nodeEngines = pkgData.engines?.[version];
+    const provenance = pkgData.provenance?.[version];
+    const result = { version, diff };
+    if (age) result.age = age;
+    if (distTag) result.distTag = distTag;
+    if (deprecated) result.deprecated = deprecated;
+    if (nodeEngines) result.nodeEngines = nodeEngines;
+    if (provenance) result.provenance = provenance;
+    if (explain) {
+      result.explain = getExplanation(diff, deprecated, provenance === "none");
+    }
+    return result;
+  });
+}
+function getExplanation(diff, deprecated, provenanceDowngrade, nodeIncompat) {
+  const parts = [];
+  switch (diff) {
+    case "major":
+      parts.push("Breaking change. Check migration guide.");
+      break;
+    case "minor":
+      parts.push("New features. Backwards compatible.");
+      break;
+    case "patch":
+      parts.push("Bug fixes only. Safe to update.");
+      break;
+  }
+  if (deprecated) parts.push("Deprecated.");
+  if (provenanceDowngrade) parts.push("Provenance downgrade.");
+  return parts.join(" ");
+}
+function applyVersionSelection(dep, selectedVersion) {
+  const prefix = getVersionPrefix(dep.currentVersion);
+  dep.targetVersion = applyVersionPrefix(selectedVersion, prefix);
+  dep.diff = getDiff(dep.currentVersion, selectedVersion);
+}
+
+function safeTermSize(value, fallback) {
+  return typeof value === "number" && value > 0 ? value : fallback;
+}
+
+const CHROME_LINES = 6;
+function getViewportHeight(termRows, chrome) {
+  return Math.max(1, termRows - (chrome ?? CHROME_LINES));
+}
+function calculateScrollOffset(cursor, viewportHeight, totalItems, currentOffset) {
+  const maxOffset = Math.max(0, totalItems - viewportHeight);
+  let offset = currentOffset;
+  if (cursor < offset) {
+    offset = cursor;
+  }
+  if (cursor >= offset + viewportHeight) {
+    offset = cursor - viewportHeight + 1;
+  }
+  return Math.min(offset, maxOffset);
+}
+function getVisibleRange(scrollOffset, viewportHeight, totalItems) {
+  const start = scrollOffset;
+  const end = Math.min(scrollOffset + viewportHeight, totalItems);
+  return { start, end };
+}
+function hasOverflowAbove(scrollOffset) {
+  return scrollOffset > 0;
+}
+function hasOverflowBelow(scrollOffset, viewportHeight, totalItems) {
+  return scrollOffset + viewportHeight < totalItems;
+}
+
+function updateListScroll(state, cursor, termRows) {
+  const viewport = getViewportHeight(termRows);
+  return calculateScrollOffset(cursor, viewport, state.items.length, state.scrollOffset);
+}
+function updateDetailScroll(state, detailCursor, termRows, currentOffset) {
+  const viewport = getViewportHeight(termRows);
+  return calculateScrollOffset(detailCursor, viewport, state.detailVersions.length, currentOffset);
+}
+function resize(state, rows, cols) {
+  const termRows = safeTermSize(rows, state.termRows);
+  const termCols = safeTermSize(cols, state.termCols);
+  const resized = {
+    ...state,
+    termRows,
+    termCols
+  };
+  if (resized.view === "detail") {
+    return {
+      ...resized,
+      detailScrollOffset: updateDetailScroll(
+        resized,
+        resized.detailCursor,
+        termRows,
+        resized.detailScrollOffset
+      )
+    };
+  }
+  return {
+    ...resized,
+    scrollOffset: updateListScroll(resized, resized.cursor, termRows)
+  };
+}
+
+function enterDetail(state) {
+  if (state.view !== "list") return state;
+  const item = state.items[state.cursor];
+  if (item?.type !== "dep" || !item.dep) return state;
+  const detailVersions = prepareDetailVersions(item.dep, state.explain);
+  if (detailVersions.length === 0) return state;
+  return {
+    ...state,
+    view: "detail",
+    detailDep: item.dep,
+    detailVersions,
+    detailCursor: 0,
+    detailScrollOffset: calculateScrollOffset(
+      0,
+      getViewportHeight(state.termRows),
+      detailVersions.length,
+      0
+    )
+  };
+}
+function exitDetail(state) {
+  if (state.view !== "detail") return state;
+  return {
+    ...state,
+    view: "list",
+    detailDep: null,
+    detailVersions: [],
+    detailCursor: 0,
+    detailScrollOffset: 0
+  };
+}
+function selectDetailVersion(state) {
+  if (state.view !== "detail" || !state.detailDep || state.detailVersions.length === 0) return state;
+  const selected = state.detailVersions[state.detailCursor];
+  if (!selected) return state;
+  applyVersionSelection(state.detailDep, selected.version);
+  const selectedNames = new Set(state.selectedNames);
+  selectedNames.add(state.detailDep.name);
+  return {
+    ...state,
+    view: "list",
+    detailDep: null,
+    detailVersions: [],
+    detailCursor: 0,
+    detailScrollOffset: 0,
+    selectedNames
+  };
+}
+function moveDetailCursor(state, delta) {
+  if (state.view !== "detail" || state.detailVersions.length === 0 || delta === 0) return state;
+  const max = state.detailVersions.length - 1;
+  const next = Math.min(max, Math.max(0, state.detailCursor + delta));
+  if (next === state.detailCursor) return state;
+  return {
+    ...state,
+    detailCursor: next,
+    detailScrollOffset: updateDetailScroll(state, next, state.termRows, state.detailScrollOffset)
+  };
+}
+
+function findDepIndex(items, start, direction) {
+  let i = start;
+  while (i >= 0 && i < items.length) {
+    const item = items[i];
+    if (item?.type === "dep") return i;
+    i += direction;
+  }
+  return -1;
+}
+function createInitialState(updates, options = {}) {
+  const termRows = safeTermSize(options.termRows, 24);
+  const termCols = safeTermSize(options.termCols, 80);
+  const grouped = /* @__PURE__ */ new Map();
+  for (const [depIndex, dep] of updates.entries()) {
+    const existing = grouped.get(dep.source);
+    if (existing) {
+      existing.push({ dep, depIndex });
+    } else {
+      grouped.set(dep.source, [{ dep, depIndex }]);
+    }
+  }
+  const items = [];
+  let index = 0;
+  for (const [groupLabel, deps] of grouped.entries()) {
+    items.push({
+      type: "group-header",
+      groupLabel,
+      index
+    });
+    index++;
+    for (const entry of deps) {
+      items.push({
+        type: "dep",
+        dep: entry.dep,
+        depIndex: entry.depIndex,
+        index
+      });
+      index++;
+    }
+  }
+  const firstDepCursor = findDepIndex(items, 0, 1);
+  const cursor = firstDepCursor >= 0 ? firstDepCursor : 0;
+  const initial = {
+    view: "list",
+    items,
+    cursor,
+    scrollOffset: 0,
+    detailDep: null,
+    detailVersions: [],
+    detailCursor: 0,
+    detailScrollOffset: 0,
+    selectedNames: /* @__PURE__ */ new Set(),
+    termRows,
+    termCols,
+    explain: options.explain ?? false,
+    confirmed: false,
+    cancelled: false
+  };
+  return {
+    ...initial,
+    scrollOffset: updateListScroll(initial, cursor, termRows)
+  };
+}
+function moveCursor(state, delta) {
+  if (state.view !== "list" || delta === 0 || state.items.length === 0) return state;
+  const direction = delta > 0 ? 1 : -1;
+  let cursor = state.cursor;
+  const steps = Math.max(1, Math.abs(delta));
+  for (let i = 0; i < steps; i++) {
+    const next = findDepIndex(state.items, cursor + direction, direction);
+    if (next === -1) break;
+    cursor = next;
+  }
+  if (cursor === state.cursor) return state;
+  return {
+    ...state,
+    cursor,
+    scrollOffset: updateListScroll(state, cursor, state.termRows)
+  };
+}
+function jumpToFirst(state) {
+  if (state.view !== "list") return state;
+  const cursor = findDepIndex(state.items, 0, 1);
+  if (cursor === -1 || cursor === state.cursor) return state;
+  return {
+    ...state,
+    cursor,
+    scrollOffset: updateListScroll(state, cursor, state.termRows)
+  };
+}
+function jumpToLast(state) {
+  if (state.view !== "list") return state;
+  const cursor = findDepIndex(state.items, state.items.length - 1, -1);
+  if (cursor === -1 || cursor === state.cursor) return state;
+  return {
+    ...state,
+    cursor,
+    scrollOffset: updateListScroll(state, cursor, state.termRows)
+  };
+}
+function pageMove(state, direction) {
+  if (state.view !== "list") return state;
+  const distance = getViewportHeight(state.termRows);
+  return moveCursor(state, direction * distance);
+}
+function toggleSelection(state) {
+  if (state.view !== "list") return state;
+  const item = state.items[state.cursor];
+  if (item?.type !== "dep" || !item.dep) return state;
+  const selectedNames = new Set(state.selectedNames);
+  if (selectedNames.has(item.dep.name)) {
+    selectedNames.delete(item.dep.name);
+  } else {
+    selectedNames.add(item.dep.name);
+  }
+  return { ...state, selectedNames };
+}
+function toggleAll(state) {
+  const depNames = Array.from(
+    new Set(
+      state.items.filter(
+        (item) => item.type === "dep" && !!item.dep
+      ).map((item) => item.dep.name)
+    )
+  );
+  if (depNames.length === 0) return state;
+  const allSelected = depNames.every((name) => state.selectedNames.has(name));
+  return {
+    ...state,
+    selectedNames: allSelected ? /* @__PURE__ */ new Set() : new Set(depNames)
+  };
+}
+
+function confirm(state) {
+  return { ...state, confirmed: true };
+}
+function cancel(state) {
+  return { ...state, cancelled: true };
+}
+
+function isShiftG(key) {
+  return key.name === "G" || key.name === "g" && key.shift || key.sequence === "G";
+}
+function handleListViewKeypress(state, key) {
+  switch (key.name) {
+    case "down":
+    case "j":
+      return moveCursor(state, 1);
+    case "up":
+    case "k":
+      return moveCursor(state, -1);
+    case "space":
+      return toggleSelection(state);
+    case "a":
+      return toggleAll(state);
+    case "right":
+    case "l":
+      return enterDetail(state);
+    case "return":
+      return confirm(state);
+    case "escape":
+    case "q":
+      return cancel(state);
+    case "pagedown":
+      return pageMove(state, 1);
+    case "pageup":
+      return pageMove(state, -1);
+    case "g":
+      return isShiftG(key) ? jumpToLast(state) : jumpToFirst(state);
+    default:
+      return isShiftG(key) ? jumpToLast(state) : state;
+  }
+}
+function handleDetailViewKeypress(state, key) {
+  switch (key.name) {
+    case "down":
+    case "j":
+      return moveDetailCursor(state, 1);
+    case "up":
+    case "k":
+      return moveDetailCursor(state, -1);
+    case "space":
+    case "return":
+      return selectDetailVersion(state);
+    case "left":
+    case "h":
+    case "escape":
+    case "q":
+      return exitDetail(state);
+    default:
+      return state;
+  }
+}
+function handleKeypress(state, key) {
+  if (key.ctrl && key.name === "c") {
+    return cancel(state);
+  }
+  if (state.view === "detail") {
+    return handleDetailViewKeypress(state, key);
+  }
+  return handleListViewKeypress(state, key);
+}
+
+const LIST_HELP = "  up/down navigate  Space toggle  -> versions  a all  Enter confirm  Esc cancel";
+const DETAIL_HELP = "  up/down navigate  Space/Enter select  left/Esc back";
+const DETAIL_CHROME_LINES = 8;
+function colorAge(age) {
+  if (!age) return "";
+  if (age.color === "green") return c.green(age.text);
+  if (age.color === "yellow") return c.yellow(age.text);
+  return c.red(age.text);
+}
+function fitLine(line, termCols) {
+  if (termCols <= 0) return line;
+  const visible = stripAnsi(line);
+  if (visible.length <= termCols) return line;
+  return truncate(visible, termCols);
+}
+function getDepItems(state) {
+  return state.items.filter(
+    (item) => item.type === "dep" && !!item.dep
+  );
+}
+
+function renderListView(state) {
+  const lines = [];
+  const depItems = getDepItems(state);
+  const nameWidth = Math.min(
+    depItems.reduce((max, item) => Math.max(max, item.dep.name.length), 4),
+    24
+  );
+  const viewportHeight = getViewportHeight(state.termRows);
+  const { start, end } = getVisibleRange(state.scrollOffset, viewportHeight, state.items.length);
+  const visibleItems = state.items.slice(start, end);
+  lines.push(fitLine("  Select dependencies to update", state.termCols));
+  lines.push("");
+  if (hasOverflowAbove(state.scrollOffset)) {
+    lines.push(fitLine(`  ${c.gray("^ more")}`, state.termCols));
+  }
+  for (const item of visibleItems) {
+    lines.push(renderListLine(state, item, nameWidth));
+  }
+  if (hasOverflowBelow(state.scrollOffset, viewportHeight, state.items.length)) {
+    lines.push(fitLine(`  ${c.gray("v more")}`, state.termCols));
+  }
+  const totalDeps = depItems.length;
+  const selectedCount = depItems.reduce(
+    (count, item) => state.selectedNames.has(item.dep.name) ? count + 1 : count,
+    0
+  );
+  lines.push(fitLine(`  ${selectedCount}/${totalDeps} selected`, state.termCols));
+  lines.push("");
+  lines.push(fitLine(LIST_HELP, state.termCols));
+  return lines;
+}
+function renderListLine(state, item, nameWidth) {
+  if (item.type === "group-header") {
+    return fitLine(`  ${c.gray(item.groupLabel ?? "")}`, state.termCols);
+  }
+  if (!item.dep) return "";
+  return renderListDepLine(
+    item.dep,
+    item.index === state.cursor,
+    state.selectedNames.has(item.dep.name),
+    nameWidth,
+    state.termCols
+  );
+}
+function renderListDepLine(dep, focused, selected, nameWidth, termCols) {
+  const pointer = focused ? c.cyan(">") : " ";
+  const selectedMark = selected ? c.green("*") : c.gray("o");
+  const name = padEnd(truncate(dep.name, nameWidth), nameWidth);
+  const target = colorizeVersionDiff(dep.currentVersion, dep.targetVersion, dep.diff);
+  const age = timeDifference(dep.publishedAt);
+  let line = `  ${pointer} ${selectedMark} ${name}  ${dep.currentVersion}${arrow()}${target}  ${colorDiff(dep.diff)}`;
+  if (age) line += `  ${colorAge(age)}`;
+  return fitLine(line, termCols);
+}
+
+function renderDetailView(state) {
+  const lines = [];
+  const dep = state.detailDep;
+  if (!dep) return renderListView(state);
+  const header = `  ${dep.name}  ${dep.currentVersion}${arrow()}?`;
+  lines.push(fitLine(header, state.termCols));
+  lines.push("");
+  const versionWidth = Math.min(
+    state.detailVersions.reduce((max, item) => Math.max(max, item.version.length), 6),
+    18
+  );
+  const viewportHeight = getViewportHeight(state.termRows, DETAIL_CHROME_LINES);
+  const { start, end } = getVisibleRange(
+    state.detailScrollOffset,
+    viewportHeight,
+    state.detailVersions.length
+  );
+  const visible = state.detailVersions.slice(start, end);
+  if (hasOverflowAbove(state.detailScrollOffset)) {
+    lines.push(fitLine(`  ${c.gray("^ more")}`, state.termCols));
+  }
+  for (const [index, version] of visible.entries()) {
+    lines.push(renderDetailVersionLine(state, version, start + index, versionWidth));
+  }
+  if (hasOverflowBelow(state.detailScrollOffset, viewportHeight, state.detailVersions.length)) {
+    lines.push(fitLine(`  ${c.gray("v more")}`, state.termCols));
+  }
+  const distTags = Object.entries(dep.pkgData.distTags).map(([tag, version]) => `${tag}${arrow()}${version}`).join(" | ");
+  lines.push("");
+  if (distTags) {
+    lines.push(fitLine(`  dist-tags: ${distTags}`, state.termCols));
+  }
+  if (dep.pkgData.homepage) {
+    lines.push(fitLine(`  Homepage: ${dep.pkgData.homepage}`, state.termCols));
+  }
+  lines.push("");
+  lines.push(fitLine(DETAIL_HELP, state.termCols));
+  return lines;
+}
+function renderDetailVersionLine(state, version, idx, versionWidth) {
+  const pointer = idx === state.detailCursor ? c.cyan(">") : " ";
+  const versionText = padEnd(version.version, versionWidth);
+  let line = `  ${pointer} ${versionText}  ${colorDiff(version.diff)}`;
+  if (version.age) line += `  ${colorAge(version.age)}`;
+  if (version.distTag) line += `  ${c.cyan(version.distTag)}`;
+  if (version.explain) line += `  ${c.gray(version.explain)}`;
+  if (version.deprecated) line += `  ${c.red("deprecated")}`;
+  if (version.provenance === "none") line += `  ${c.yellow("no-provenance")}`;
+  if (version.nodeEngines) line += `  ${c.gray(`node ${version.nodeEngines}`)}`;
+  return fitLine(line, state.termCols);
+}
+
+function renderFrame(state) {
+  const lines = state.view === "detail" ? renderDetailView(state) : renderListView(state);
+  return `${lines.join("\n")}
+`;
+}
+function eraseLines(count) {
+  if (count <= 0) return "";
+  return `\x1B[${count}A\x1B[0J`;
+}
+
+const HIDE_CURSOR = "\x1B[?25l";
+const SHOW_CURSOR = "\x1B[?25h";
+function getRows() {
+  return process.stdout.rows ?? 24;
+}
+function getCols() {
+  return process.stdout.columns ?? 80;
+}
+function countFrameLines(frame) {
+  const parts = frame.split("\n");
+  return frame.endsWith("\n") ? parts.length - 1 : parts.length;
+}
+function getSelectedUpdates(state, updates) {
+  return updates.filter((dep) => state.selectedNames.has(dep.name));
+}
+async function createInteractiveTUI(updates, options) {
+  if (updates.length === 0) return [];
+  const input = process.stdin;
+  const output = process.stdout;
+  if (typeof input.setRawMode !== "function") {
+    return [];
+  }
+  return new Promise((resolve, reject) => {
+    let state = createInitialState(updates, {
+      termRows: getRows(),
+      termCols: getCols(),
+      explain: options.explain
+    });
+    let lastFrameLineCount = 0;
+    let finished = false;
+    const render = () => {
+      const frame = renderFrame(state);
+      if (lastFrameLineCount > 0) {
+        output.write(eraseLines(lastFrameLineCount));
+      }
+      output.write(frame);
+      lastFrameLineCount = countFrameLines(frame);
+    };
+    const cleanup = () => {
+      input.off("keypress", onKeypress);
+      output.off("resize", onResize);
+      if (lastFrameLineCount > 0) {
+        output.write(eraseLines(lastFrameLineCount));
+      }
+      output.write(SHOW_CURSOR);
+      input.setRawMode(false);
+      input.pause();
+    };
+    const finish = (result) => {
+      if (finished) return;
+      finished = true;
+      cleanup();
+      resolve(result);
+    };
+    const onResize = () => {
+      state = resize(state, getRows(), getCols());
+      render();
+    };
+    const onKeypress = (_sequence, key) => {
+      state = handleKeypress(state, key);
+      render();
+      if (state.cancelled) {
+        finish([]);
+        return;
+      }
+      if (state.confirmed) {
+        finish(getSelectedUpdates(state, updates));
+      }
+    };
+    try {
+      readline.emitKeypressEvents(input);
+      input.setRawMode(true);
+      input.resume();
+      output.write(HIDE_CURSOR);
+      render();
+      input.on("keypress", onKeypress);
+      output.on("resize", onResize);
+    } catch (error) {
+      cleanup();
+      reject(error);
+    }
+  });
+}
+
+export { createInteractiveTUI };