hillclimb 0.8.4 → 0.8.6

package/dist/chunk-543ASWNO.js

@@ -0,0 +1,309 @@
+#!/usr/bin/env node
+
+// src/platform/log.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/config.ts
+import { execFile } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var MAX_SNAPSHOT_LIMIT_OVERRIDE_BYTES = 100 * 1024 * 1024;
+var DEFAULT_CONFIG_DIR = path.join(os.homedir(), ".hillclimb");
+function normalizeProjectConfig(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const config = raw;
+  const projectId = config.projectId ?? config.workspaceId;
+  const projectSlug = config.projectSlug ?? config.workspaceSlug;
+  const projectName = config.projectName ?? config.workspaceName;
+  if (!config.apiBaseUrl || !projectId || !projectSlug || !projectName || !config.contributionTypeSlug || !config.contributionTypeName || typeof config.autoSubmit !== "boolean") {
+    return null;
+  }
+  const normalized = {
+    ...config,
+    apiBaseUrl: config.apiBaseUrl,
+    projectId,
+    projectSlug,
+    projectName,
+    workspaceId: config.workspaceId ?? projectId,
+    workspaceSlug: config.workspaceSlug ?? projectSlug,
+    workspaceName: config.workspaceName ?? projectName,
+    contributionTypeSlug: config.contributionTypeSlug,
+    contributionTypeName: config.contributionTypeName,
+    autoSubmit: config.autoSubmit,
+    snapshotLimits: normalizeSnapshotLimits(config.snapshotLimits)
+  };
+  if (typeof normalized.rootCommit !== "string") delete normalized.rootCommit;
+  if (typeof normalized.remoteUrl !== "string") delete normalized.remoteUrl;
+  return normalized;
+}
+function normalizeSnapshotLimits(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const limits = { ...raw };
+  if (!isValidSnapshotLimit(limits.maxTrackedFileBytes))
+    delete limits.maxTrackedFileBytes;
+  if (!isValidSnapshotLimit(limits.maxUntrackedFileBytes))
+    delete limits.maxUntrackedFileBytes;
+  if (!isValidSnapshotLimit(limits.maxBinaryFileBytes))
+    delete limits.maxBinaryFileBytes;
+  return Object.keys(limits).length > 0 ? limits : void 0;
+}
+function isValidSnapshotLimit(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 && value <= MAX_SNAPSHOT_LIMIT_OVERRIDE_BYTES;
+}
+function configDir() {
+  return process.env.HILLCLIMB_CONFIG_DIR ?? DEFAULT_CONFIG_DIR;
+}
+function configPath() {
+  return path.join(configDir(), "projects.json");
+}
+async function loadProjects() {
+  try {
+    const raw = await fs.promises.readFile(configPath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.projects || typeof parsed.projects !== "object") {
+      return { projects: {} };
+    }
+    const projects = {};
+    for (const [repoRoot, config] of Object.entries(parsed.projects)) {
+      const normalized = normalizeProjectConfig(config);
+      if (normalized) projects[repoRoot] = normalized;
+    }
+    return { projects };
+  } catch {
+    return { projects: {} };
+  }
+}
+async function saveProjects(file) {
+  await fs.promises.mkdir(configDir(), { recursive: true, mode: 448 });
+  const tmp = `${configPath()}.tmp`;
+  await fs.promises.writeFile(tmp, JSON.stringify(file, null, 2), {
+    mode: 384
+  });
+  await fs.promises.rename(tmp, configPath());
+}
+async function upsertProject(repoRoot, config) {
+  const file = await loadProjects();
+  const normalized = normalizeProjectConfig(config);
+  if (!normalized) throw new Error("Invalid project config.");
+  const resolvedRepoRoot = path.resolve(repoRoot);
+  const existing = file.projects[resolvedRepoRoot];
+  if (!normalized.snapshotLimits && existing?.snapshotLimits) {
+    normalized.snapshotLimits = existing.snapshotLimits;
+  }
+  const identity = await repoIdentity(resolvedRepoRoot);
+  if (identity.rootCommit) normalized.rootCommit = identity.rootCommit;
+  if (identity.remoteUrl) normalized.remoteUrl = identity.remoteUrl;
+  file.projects[resolvedRepoRoot] = normalized;
+  await saveProjects(file);
+}
+async function gitOut(args, cwd) {
+  try {
+    const { stdout } = await execFileAsync("git", args, {
+      cwd,
+      timeout: 5e3,
+      maxBuffer: 1024 * 1024
+    });
+    const out = stdout.trim();
+    return out.length > 0 ? out : null;
+  } catch {
+    return null;
+  }
+}
+async function repoIdentity(repoRoot) {
+  const [roots, remote] = await Promise.all([
+    gitOut(["rev-list", "--max-parents=0", "HEAD"], repoRoot),
+    gitOut(["config", "--get", "remote.origin.url"], repoRoot)
+  ]);
+  const rootCommit = roots?.split("\n").map((line) => line.trim()).filter(Boolean).sort()[0];
+  return {
+    rootCommit: rootCommit || void 0,
+    remoteUrl: remote || void 0
+  };
+}
+async function logHeal(level, message) {
+  try {
+    const { appendLog: appendLog2 } = await import("./log-W7QJJF46.js");
+    appendLog2(level, message);
+  } catch {
+  }
+}
+function matchByPath(projects, resolved) {
+  let best = null;
+  let bestLen = -1;
+  for (const [key, config] of Object.entries(projects)) {
+    const canonical = path.resolve(key);
+    if (resolved === canonical || resolved.startsWith(canonical + path.sep)) {
+      if (canonical.length > bestLen) {
+        bestLen = canonical.length;
+        best = { key, repoRoot: canonical, config };
+      }
+    }
+  }
+  return best;
+}
+var healMisses = /* @__PURE__ */ new Set();
+async function healRenamedProject(file, resolved) {
+  const dead = Object.entries(file.projects).filter(
+    ([key]) => !fs.existsSync(path.resolve(key))
+  );
+  if (dead.length === 0) return null;
+  const missKey = `${configPath()}|${resolved}`;
+  if (healMisses.has(missKey)) return null;
+  const toplevel = await gitOut(["rev-parse", "--show-toplevel"], resolved);
+  if (!toplevel) {
+    healMisses.add(missKey);
+    return null;
+  }
+  const repoRoot = path.resolve(toplevel);
+  const identity = await repoIdentity(repoRoot);
+  const strong = dead.filter(([, config2]) => {
+    if (config2.rootCommit && identity.rootCommit) {
+      return config2.rootCommit === identity.rootCommit;
+    }
+    return Boolean(
+      config2.remoteUrl && identity.remoteUrl && config2.remoteUrl === identity.remoteUrl
+    );
+  });
+  const legacy = dead.filter(
+    ([key, config2]) => !config2.rootCommit && !config2.remoteUrl && path.basename(path.resolve(key)) === path.basename(repoRoot)
+  );
+  const candidates = strong.length > 0 ? strong : legacy;
+  if (candidates.length !== 1) {
+    if (candidates.length > 1) {
+      await logHeal(
+        "warn",
+        `config heal: ${candidates.length} dead entries match the repo at ${repoRoot}; not migrating`
+      );
+    }
+    healMisses.add(missKey);
+    return null;
+  }
+  const [oldKey, config] = candidates[0];
+  const updated = {
+    ...config,
+    rootCommit: identity.rootCommit ?? config.rootCommit,
+    remoteUrl: identity.remoteUrl ?? config.remoteUrl
+  };
+  if (updated.rootCommit === void 0) delete updated.rootCommit;
+  if (updated.remoteUrl === void 0) delete updated.remoteUrl;
+  delete file.projects[oldKey];
+  file.projects[repoRoot] = updated;
+  await saveProjects(file);
+  await logHeal(
+    "info",
+    `config heal: migrated project ${config.projectSlug} from ${oldKey} to ${repoRoot} (directory renamed)`
+  );
+  return { repoRoot, config: updated };
+}
+async function backfillIdentity(file, match) {
+  if (match.config.rootCommit || match.config.remoteUrl) return;
+  const missKey = `${configPath()}|backfill|${match.repoRoot}`;
+  if (healMisses.has(missKey)) return;
+  healMisses.add(missKey);
+  const identity = await repoIdentity(match.repoRoot);
+  if (!identity.rootCommit && !identity.remoteUrl) return;
+  const stored = file.projects[match.key];
+  if (!stored) return;
+  if (identity.rootCommit) stored.rootCommit = identity.rootCommit;
+  if (identity.remoteUrl) stored.remoteUrl = identity.remoteUrl;
+  await saveProjects(file);
+}
+async function findProjectForCwd(cwd) {
+  const file = await loadProjects();
+  const resolved = path.resolve(cwd);
+  const match = matchByPath(file.projects, resolved);
+  if (match) {
+    await backfillIdentity(file, match);
+    return { repoRoot: match.repoRoot, config: match.config };
+  }
+  return healRenamedProject(file, resolved);
+}
+
+// src/platform/log.ts
+var PT_TIME_ZONE = "America/Los_Angeles";
+function pacificParts(date) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: PT_TIME_ZONE,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hourCycle: "h23"
+  }).formatToParts(date);
+  const lookup = {};
+  for (const p of parts) if (p.type !== "literal") lookup[p.type] = p.value;
+  return {
+    year: lookup.year ?? "0000",
+    month: lookup.month ?? "00",
+    day: lookup.day ?? "00",
+    hour: lookup.hour ?? "00",
+    minute: lookup.minute ?? "00",
+    second: lookup.second ?? "00"
+  };
+}
+function pacificOffsetMinutes(date) {
+  const p = pacificParts(date);
+  const asIfUtc = Date.UTC(
+    Number(p.year),
+    Number(p.month) - 1,
+    Number(p.day),
+    Number(p.hour),
+    Number(p.minute),
+    Number(p.second)
+  );
+  return Math.round((asIfUtc - date.getTime()) / 6e4);
+}
+function pacificTimestamp(date) {
+  const p = pacificParts(date);
+  const ms = String(date.getMilliseconds()).padStart(3, "0");
+  const off = pacificOffsetMinutes(date);
+  const sign = off >= 0 ? "+" : "-";
+  const abs = Math.abs(off);
+  const oh = String(Math.floor(abs / 60)).padStart(2, "0");
+  const om = String(abs % 60).padStart(2, "0");
+  return `${p.year}-${p.month}-${p.day}T${p.hour}:${p.minute}:${p.second}.${ms}${sign}${oh}:${om}`;
+}
+function pacificDateString(date) {
+  const p = pacificParts(date);
+  return `${p.year}-${p.month}-${p.day}`;
+}
+function logsDir() {
+  return path2.join(configDir(), "logs");
+}
+function todayLogPath() {
+  return path2.join(logsDir(), `${pacificDateString(/* @__PURE__ */ new Date())}.log`);
+}
+var logPrefix = "";
+function setLogPrefix(prefix) {
+  logPrefix = prefix;
+}
+function appendLog(level, message) {
+  const tag = logPrefix ? ` ${logPrefix}` : "";
+  const line = `[${pacificTimestamp(/* @__PURE__ */ new Date())}] [${level}]${tag} ${message}
+`;
+  try {
+    fs2.mkdirSync(logsDir(), { recursive: true, mode: 448 });
+    fs2.appendFileSync(todayLogPath(), line);
+  } catch {
+    process.stderr.write(`hillclimb:${tag} ${level}: ${message}
+`);
+  }
+}
+
+export {
+  todayLogPath,
+  setLogPrefix,
+  appendLog,
+  MAX_SNAPSHOT_LIMIT_OVERRIDE_BYTES,
+  configDir,
+  configPath,
+  loadProjects,
+  upsertProject,
+  findProjectForCwd
+};

package/dist/log-W7QJJF46.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import {
+  appendLog,
+  setLogPrefix,
+  todayLogPath
+} from "./chunk-543ASWNO.js";
+export {
+  appendLog,
+  setLogPrefix,
+  todayLogPath
+};