@yoavsh/treekeeper 0.0.0-stage → 0.1.0

package/src/util/paths.ts

@@ -0,0 +1,84 @@
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve, sep } from "node:path";
+import { realpath } from "node:fs/promises";
+
+/** Expand a leading `~` and resolve to an absolute path. */
+export function expandPath(input: string, base = process.cwd()): string {
+  let p = input.trim();
+  if (p === "~") p = homedir();
+  else if (p.startsWith("~/") || p.startsWith(`~${sep}`)) p = join(homedir(), p.slice(2));
+  return isAbsolute(p) ? resolve(p) : resolve(base, p);
+}
+
+/** Collapse `$HOME` back to `~` for display. */
+export function shortenPath(p: string): string {
+  const home = homedir();
+  return p === home || p.startsWith(home + sep) ? "~" + p.slice(home.length) : p;
+}
+
+/** True when `child` is `parent` or lives underneath it. Pure string compare. */
+export function isInside(parent: string, child: string): boolean {
+  if (parent === child) return true;
+  const base = parent.endsWith(sep) ? parent : parent + sep;
+  return child.startsWith(base);
+}
+
+/** realpath that falls back to the input when the path does not exist. */
+export async function realpathSafe(p: string): Promise<string> {
+  try {
+    return await realpath(p);
+  } catch {
+    return p;
+  }
+}
+
+/** Where treekeeper keeps config, logs, cache and archives. */
+export function treekeeperHome(): string {
+  const override = process.env.TREEKEEPER_HOME;
+  if (override && override.trim() !== "") return expandPath(override);
+  return join(homedir(), ".treekeeper");
+}
+
+/**
+ * Very small glob matcher: supports `*` (not crossing `/`), `**` (crossing it)
+ * and `?`. Enough for branch names and path patterns, and it keeps the
+ * dependency count at zero.
+ */
+export function matchGlob(pattern: string, value: string): boolean {
+  const re = globToRegExp(pattern);
+  return re.test(value);
+}
+
+export function matchAnyGlob(patterns: readonly string[], value: string): boolean {
+  return patterns.some((p) => matchGlob(p, value));
+}
+
+const cache = new Map<string, RegExp>();
+
+function globToRegExp(pattern: string): RegExp {
+  const hit = cache.get(pattern);
+  if (hit) return hit;
+  let out = "^";
+  for (let i = 0; i < pattern.length; i += 1) {
+    const c = pattern[i]!;
+    if (c === "*") {
+      if (pattern[i + 1] === "*") {
+        i += 1;
+        if (pattern[i + 1] === "/") i += 1;
+        out += "(?:.*\\/)?";
+      } else {
+        out += "[^/]*";
+      }
+    } else if (c === "?") {
+      out += "[^/]";
+    } else if ("\\^$.|+()[]{}".includes(c)) {
+      out += "\\" + c;
+    } else {
+      out += c;
+    }
+  }
+  out += "$";
+  const re = new RegExp(out);
+  cache.set(pattern, re);
+  return re;
+}

package/src/util/prompt.ts

@@ -0,0 +1,13 @@
+import { createInterface } from "node:readline/promises";
+
+/** Ask a yes/no question. Returns `fallback` when stdin is not a TTY. */
+export async function confirm(question: string, fallback = false): Promise<boolean> {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return fallback;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await rl.question(`${question} [y/N] `)).trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}

package/src/util/redact.ts

@@ -0,0 +1,43 @@
+/**
+ * Credential scrubbing for anything that might reach a log file or stdout.
+ *
+ * Remotes routinely carry secrets — `https://user:ghp_xxx@github.com/o/r.git`
+ * is a perfectly ordinary origin URL — and git and gh echo them back in error
+ * messages. treekeeper writes a persistent log, so a token must never make it
+ * that far.
+ */
+
+/** `https://user:token@host/path` -> `https://host/path`. */
+export function redactRemote(url: string): string {
+  return url.replace(/^([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)[^@/]*@/, "$1");
+}
+
+const PATTERNS: Array<[RegExp, string]> = [
+  // userinfo in any URL
+  [/([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)[^@/\s]*@/g, "$1"],
+  // well-known token shapes, even when they appear bare
+  [/\bgh[pousr]_[A-Za-z0-9]{16,}/g, "[redacted]"],
+  [/\bgithub_pat_[A-Za-z0-9_]{20,}/g, "[redacted]"],
+  [/\bglpat-[A-Za-z0-9_-]{16,}/g, "[redacted]"],
+  [/\b(?:xox[baprs]-)[A-Za-z0-9-]{10,}/g, "[redacted]"],
+  [/\bAKIA[0-9A-Z]{16}\b/g, "[redacted]"],
+];
+
+/** Remove credentials from free text. */
+export function redactSecrets(text: string): string {
+  let out = text;
+  for (const [re, replacement] of PATTERNS) out = out.replace(re, replacement);
+  return out;
+}
+
+/** Recursively redact strings in a value destined for a log record. */
+export function redactValue<T>(value: T): T {
+  if (typeof value === "string") return redactSecrets(value) as unknown as T;
+  if (Array.isArray(value)) return value.map((v) => redactValue(v)) as unknown as T;
+  if (value !== null && typeof value === "object") {
+    const out: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(value)) out[k] = redactValue(v);
+    return out as unknown as T;
+  }
+  return value;
+}

package/src/util/time.ts

@@ -0,0 +1,75 @@
+const UNITS: Record<string, number> = {
+  ms: 1,
+  s: 1_000,
+  m: 60_000,
+  h: 3_600_000,
+  d: 86_400_000,
+  w: 604_800_000,
+};
+
+/**
+ * Parse a duration like "30m", "2h", "7d", "1h30m", "0" or a bare number of
+ * milliseconds. Throws on anything else so a typo in a config file is loud
+ * rather than silently becoming 0 (which would disable a safety gate).
+ */
+export function parseDuration(input: string | number): number {
+  if (typeof input === "number") {
+    if (!Number.isFinite(input) || input < 0) throw new Error(`invalid duration: ${input}`);
+    return Math.round(input);
+  }
+  const text = input.trim().toLowerCase();
+  if (text === "" ) throw new Error("invalid duration: empty string");
+  if (/^\d+$/.test(text)) return Number(text);
+
+  const re = /(\d+(?:\.\d+)?)\s*(ms|s|m|h|d|w)/g;
+  let total = 0;
+  let matched = 0;
+  let consumed = 0;
+  for (const m of text.matchAll(re)) {
+    const [whole, value, unit] = m;
+    total += Number(value) * UNITS[unit as string]!;
+    matched += 1;
+    consumed += whole.length;
+  }
+  const stripped = text.replace(/[\s,]/g, "");
+  if (matched === 0 || consumed < stripped.length) {
+    throw new Error(`invalid duration: ${input} (use e.g. 30m, 2h, 7d)`);
+  }
+  return Math.round(total);
+}
+
+/** "3m", "2h 10m", "4d" — compact, at most two units. */
+export function formatDuration(ms: number): string {
+  if (!Number.isFinite(ms) || ms < 0) return "?";
+  if (ms < 1_000) return `${Math.round(ms)}ms`;
+  const d = Math.floor(ms / UNITS.d!);
+  const h = Math.floor((ms % UNITS.d!) / UNITS.h!);
+  const m = Math.floor((ms % UNITS.h!) / UNITS.m!);
+  const s = Math.floor((ms % UNITS.m!) / UNITS.s!);
+  if (d > 0) return h > 0 ? `${d}d ${h}h` : `${d}d`;
+  if (h > 0) return m > 0 ? `${h}h ${m}m` : `${h}h`;
+  if (m > 0) return `${m}m`;
+  return `${s}s`;
+}
+
+/** "12m ago" / "just now" */
+export function formatAgo(timestamp: number, now = Date.now()): string {
+  const delta = now - timestamp;
+  if (delta < 45_000) return "just now";
+  return `${formatDuration(delta)} ago`;
+}
+
+export function formatClock(timestamp: number): string {
+  const d = new Date(timestamp);
+  const pad = (n: number) => String(n).padStart(2, "0");
+  return `${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+
+export function formatStamp(timestamp: number): string {
+  const d = new Date(timestamp);
+  const pad = (n: number) => String(n).padStart(2, "0");
+  return (
+    `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}` +
+    `-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`
+  );
+}