@primitive.ai/prim 0.1.0-alpha.8 → 0.1.0-alpha.81

package/dist/chunk-PMRDE2DA.js

@@ -0,0 +1,310 @@
+import {
+  stripControlChars
+} from "./chunk-Z7YPFWAZ.js";
+
+// src/lib/bin-path.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, isAbsolute, join } from "path";
+import { fileURLToPath } from "url";
+
+// src/lib/semver.ts
+function parseSemver(value) {
+  if (typeof value !== "string" || value.length > 256) return;
+  const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u.exec(
+    value
+  );
+  if (!match) return;
+  const prerelease = match[4]?.split(".") ?? [];
+  if (prerelease.some((part) => /^\d+$/u.test(part) && part.length > 1 && part.startsWith("0"))) {
+    return;
+  }
+  return { core: [BigInt(match[1]), BigInt(match[2]), BigInt(match[3])], prerelease };
+}
+function compareSemver(left, right) {
+  const a = parseSemver(left);
+  const b = parseSemver(right);
+  if (!a || !b) return;
+  for (let i = 0; i < a.core.length; i += 1) {
+    if (a.core[i] !== b.core[i]) return a.core[i] < b.core[i] ? -1 : 1;
+  }
+  if (a.prerelease.length === 0 || b.prerelease.length === 0) {
+    return a.prerelease.length === b.prerelease.length ? 0 : a.prerelease.length === 0 ? 1 : -1;
+  }
+  for (let i = 0; i < Math.max(a.prerelease.length, b.prerelease.length); i += 1) {
+    const x = a.prerelease[i];
+    const y = b.prerelease[i];
+    if (x === void 0 || y === void 0) return x === void 0 ? -1 : 1;
+    if (x === y) continue;
+    const xNumeric = /^\d+$/u.test(x);
+    const yNumeric = /^\d+$/u.test(y);
+    if (xNumeric && yNumeric) return BigInt(x) < BigInt(y) ? -1 : 1;
+    if (xNumeric !== yNumeric) return xNumeric ? -1 : 1;
+    return x < y ? -1 : 1;
+  }
+  return 0;
+}
+
+// src/lib/bin-path.ts
+var PKG_NAME = "@primitive.ai/prim";
+var ROOT_WALK_LIMIT = 6;
+var STABLE_HOOK_LAUNCHER_NAME = "prim-hook-launcher-v1";
+var resolvedRoot;
+function locateRoot() {
+  if (resolvedRoot !== void 0) {
+    return resolvedRoot;
+  }
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < ROOT_WALK_LIMIT; depth++) {
+    const manifestPath = join(dir, "package.json");
+    if (existsSync(manifestPath)) {
+      try {
+        const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+        if (manifest.name === PKG_NAME && manifest.bin) {
+          resolvedRoot = { dir, version: manifest.version, bin: manifest.bin };
+          return resolvedRoot;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  resolvedRoot = null;
+  return resolvedRoot;
+}
+function binFile(bin) {
+  const root = locateRoot();
+  const rel = root?.bin[bin];
+  if (!root || !rel) {
+    return null;
+  }
+  return isAbsolute(rel) ? rel : join(root.dir, rel);
+}
+function packageVersion() {
+  return locateRoot()?.version ?? null;
+}
+function packageRoot() {
+  return locateRoot()?.dir ?? null;
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function shellWord(value) {
+  return /^[A-Za-z0-9_@%+=:,./-]+$/u.test(value) ? value : shellQuote(value);
+}
+function pinnedNpxArgs(bin, args = [], options = {}) {
+  const version = packageVersion();
+  if (!version) throw new Error("cannot determine Primitive package version");
+  return [
+    "--yes",
+    "--ignore-scripts",
+    ...options.preferOnline ? ["--prefer-online"] : [],
+    "-p",
+    `${PKG_NAME}@${version}`,
+    bin,
+    ...args
+  ];
+}
+function pinnedNpxCommand(bin, args = [], options = {}) {
+  return ["npx", ...pinnedNpxArgs(bin, args, options)].map(shellWord).join(" ");
+}
+function pinnedHookCommand(bin, args = "") {
+  const suffix = args ? ` ${args}` : "";
+  const fallback = `${pinnedNpxCommand(bin)}${suffix}`;
+  const file = binFile(bin);
+  if (!file) return fallback;
+  return `if [ -x ${shellQuote(process.execPath)} ] && [ -f ${shellQuote(file)} ]; then ${shellQuote(process.execPath)} ${shellQuote(file)}${suffix}; else ${fallback}; fi`;
+}
+var STABLE_HOOK_ARGUMENTS_RE = /^[-A-Za-z0-9_ ]*$/u;
+var STABLE_HOOK_BIN_RE = /^[A-Za-z0-9][A-Za-z0-9-]*$/u;
+function stableHookCommand(bin, args = "") {
+  if (!STABLE_HOOK_BIN_RE.test(bin) || !STABLE_HOOK_ARGUMENTS_RE.test(args)) {
+    throw new Error("invalid stable hook command");
+  }
+  const resolver = [
+    // #242 and earlier identify managed commands by this package marker. Keep
+    // it as inert data during the rolling window so an older uninstall or
+    // reinstall can remove the stable entry without invoking npm or PATH.
+    `prim_legacy_reader='-p ${PKG_NAME}@stable prim-shim.sh ${bin} '; `,
+    'prim_absolute() { case "$1" in /*) ;; *) return 1 ;; esac; case "$1" in [[:space:]]*|*[[:space:]]|*//*|*/./*|*/../*|*/.|*/..|?*/) return 1 ;; esac; }; ',
+    'prim_config=${PRIM_CONFIG_DIR:-}; if ! prim_absolute "$prim_config"; then prim_config=${XDG_CONFIG_HOME:-}; if prim_absolute "$prim_config"; then ',
+    'case "$prim_config" in /) prim_config=/prim ;; *) prim_config="$prim_config/prim" ;; esac; ',
+    'else prim_home=${HOME:-}; prim_absolute "$prim_home" || exit 78; case "$prim_home" in /) prim_config=/.config/prim ;; *) prim_config="$prim_home/.config/prim" ;; esac; ',
+    "fi; fi; ",
+    `case "$prim_config" in /) prim_launcher=/${STABLE_HOOK_LAUNCHER_NAME} ;; *) prim_launcher="$prim_config/${STABLE_HOOK_LAUNCHER_NAME}" ;; esac; `,
+    'exec "$prim_launcher" "$@"'
+  ].join("");
+  const suffix = args ? ` ${args}` : "";
+  return `/bin/sh -c ${shellQuote(resolver)} ${STABLE_HOOK_LAUNCHER_NAME} ${bin}${suffix}`;
+}
+function detachedHookShimCommand(bin, args = "") {
+  return `payload=$(cat); { trap '' HUP; printf '%s' "$payload" | { ${stableHookCommand(bin, args)}; }; } </dev/null >/dev/null 2>&1 &`;
+}
+function commandMatchesBin(command, bin) {
+  if (!command) {
+    return false;
+  }
+  const c = command.trim();
+  if (c === bin || c.startsWith(`${bin} `)) {
+    return true;
+  }
+  const exactBin = new RegExp(`(?:^|\\s)${bin.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?:\\s|;|$)`);
+  return c.includes(`command -v ${bin} `) || c.includes(`-p ${PKG_NAME}@`) && exactBin.test(c) || c.includes(STABLE_HOOK_LAUNCHER_NAME) && exactBin.test(c);
+}
+function exactPinnedNpxVersion(command, bin) {
+  const escapedBin = bin.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const shellQuoted = `'(?:[^']|'"'"')*'`;
+  const safeArgs = "(?: [A-Za-z0-9_@%+=:,./-]+)*";
+  const direct = new RegExp(
+    `^npx --yes --ignore-scripts -p @primitive\\.ai/prim@(?<version>[0-9A-Za-z.+-]+) ${escapedBin}${safeArgs}$`,
+    "u"
+  ).exec(command);
+  const wrapped = new RegExp(
+    `^if \\[ -x (?<node>${shellQuoted}) \\] && \\[ -f (?<entry>${shellQuoted}) \\]; then \\k<node> \\k<entry>(?<args>${safeArgs}); else npx --yes --ignore-scripts -p @primitive\\.ai/prim@(?<version>[0-9A-Za-z.+-]+) ${escapedBin}\\k<args>; fi$`,
+    "u"
+  ).exec(command);
+  const version = direct?.groups?.version ?? wrapped?.groups?.version;
+  return version && compareSemver(version, version) !== void 0 ? version : void 0;
+}
+function hookCommandResolution(command, bin) {
+  const trimmed = command?.trim();
+  if (!trimmed || !commandMatchesBin(trimmed, bin)) return void 0;
+  if (trimmed.includes(STABLE_HOOK_LAUNCHER_NAME)) return { kind: "stable_launcher" };
+  const version = exactPinnedNpxVersion(trimmed, bin);
+  return version ? { kind: "exact_npx_fallback", version } : { kind: "legacy_path" };
+}
+function hookCommandResolutions(commands, bins) {
+  const resolutions = [];
+  for (const command of commands) {
+    for (const bin of bins) {
+      const resolution = hookCommandResolution(command, bin);
+      if (resolution) resolutions.push(resolution);
+    }
+  }
+  return resolutions;
+}
+
+// src/lib/presence.ts
+var DECISION_ORIGIN = "https://app.getprimitive.ai";
+function validDecisionUrl(value) {
+  if (typeof value !== "string" || stripControlChars(value) !== value) {
+    return void 0;
+  }
+  try {
+    const url = new URL(value);
+    if (url.origin !== DECISION_ORIGIN || url.username !== "" || url.password !== "" || url.search !== "" || url.hash !== "" || !/^\/decisions\/[^/]+$/u.test(url.pathname)) {
+      return void 0;
+    }
+    return url.href;
+  } catch {
+    return void 0;
+  }
+}
+function decisionLink(label, decisionUrl, plain) {
+  const url = validDecisionUrl(decisionUrl);
+  if (plain || !url) {
+    return label;
+  }
+  return `\x1B]8;;${url}\x07\x1B[34;4m${label}\x1B[0m\x1B]8;;\x07`;
+}
+function formatLabeled(labels, cap) {
+  if (labels === void 0) {
+    return "\u2014";
+  }
+  if (labels.length === 0) {
+    return "just you";
+  }
+  if (labels.length <= cap) {
+    return labels.join(", ");
+  }
+  return `${labels.slice(0, cap).join(", ")} +${String(labels.length - cap)}`;
+}
+function formatTeammates(names, cap) {
+  return formatLabeled(names?.map(stripControlChars), cap);
+}
+function formatTeammatesWithArea(teammates, cap, plainLinks = false) {
+  return formatLabeled(
+    teammates?.map((t) => {
+      const name = stripControlChars(t.name);
+      const area = stripControlChars(t.area ?? "").trim();
+      const label = area ? `${name} - ${area}` : name;
+      return decisionLink(label, t.decisionUrl, plainLinks);
+    }),
+    cap
+  );
+}
+
+// src/lib/statusline-render.ts
+function repositoryBindingDiagnosticLabel(state) {
+  if (state === "unbound") return "GitHub repo connection: required (run `prim github connect`)";
+  if (state === "invalid") return "GitHub repo connection: invalid (run `prim doctor`)";
+  return void 0;
+}
+var STATUSLINE_NAME_CAP = 3;
+function formatStatusline(version, snapshot, resolveIngestionStatus, options = {}) {
+  const ingestionSuffix = (status) => status === void 0 ? "" : ` \xB7 Decision ingestion ${status}`;
+  const ingestionStatus = snapshot === null || snapshot.healthy === false ? options.includeIngestionWhenUnavailable ? resolveIngestionStatus() : void 0 : resolveIngestionStatus();
+  if (snapshot?.healthy === false && snapshot.needsReauth) {
+    return `primitive ${version} (daemon: paused \xB7 run \`prim auth login\`${ingestionSuffix(ingestionStatus)})`;
+  }
+  const repositoryLabel = repositoryBindingDiagnosticLabel(
+    snapshot !== null && snapshot.healthy !== false || options.includeIngestionWhenUnavailable === true ? options.resolveRepositoryBindingState?.() : void 0
+  );
+  const repositorySuffix = repositoryLabel ? ` \xB7 ${repositoryLabel}` : "";
+  if (!snapshot) {
+    return `primitive ${version} (daemon: down${repositorySuffix}${ingestionSuffix(ingestionStatus)})`;
+  }
+  if (snapshot.healthy === false) {
+    if (snapshot.ingestion?.healthy === false) {
+      const pending = snapshot.ingestion.pendingCount;
+      const qualifier = snapshot.ingestion.pendingSampled ? "at least " : "";
+      return `primitive ${version} (daemon: degraded \xB7 delivery: stalled${typeof pending === "number" ? ` \xB7 ${qualifier}${String(pending)} pending` : ""}${repositorySuffix}${ingestionSuffix(ingestionStatus)})`;
+    }
+    if (snapshot.heartbeat?.healthy === false) {
+      return `primitive ${version} (daemon: degraded \xB7 presence: unavailable${repositorySuffix}${ingestionSuffix(ingestionStatus)})`;
+    }
+    return `primitive ${version} (daemon: starting${repositorySuffix}${ingestionSuffix(ingestionStatus)})`;
+  }
+  if (snapshot.envMismatch) {
+    return `primitive ${version} (daemon: live, Decision ingestion ${ingestionStatus}${repositorySuffix} \xB7 presence: other env)`;
+  }
+  if (snapshot.principalMismatch) {
+    return `primitive ${version} (daemon: live, Decision ingestion ${ingestionStatus}${repositorySuffix} \xB7 presence: other account)`;
+  }
+  if (snapshot.presenceStale) {
+    return `primitive ${version} (daemon: live, Decision ingestion ${ingestionStatus}${repositorySuffix} \xB7 presence: stale)`;
+  }
+  let team;
+  if (snapshot.onlineTeammates !== void 0) {
+    team = `team: ${formatTeammatesWithArea(snapshot.onlineTeammates, STATUSLINE_NAME_CAP, options.plainLinks === true)}`;
+  } else if (snapshot.onlineNames !== void 0) {
+    team = `team: ${formatTeammates(snapshot.onlineNames, STATUSLINE_NAME_CAP)}`;
+  } else if (typeof snapshot.onlineCount === "number") {
+    team = `team: ${String(snapshot.onlineCount)} online`;
+  } else {
+    team = "team: \u2014";
+  }
+  return `primitive ${version} (daemon: live, Decision ingestion ${ingestionStatus}${repositorySuffix} \xB7 ${team})`;
+}
+
+export {
+  compareSemver,
+  STABLE_HOOK_LAUNCHER_NAME,
+  binFile,
+  packageVersion,
+  packageRoot,
+  pinnedNpxArgs,
+  pinnedNpxCommand,
+  pinnedHookCommand,
+  stableHookCommand,
+  detachedHookShimCommand,
+  commandMatchesBin,
+  hookCommandResolution,
+  hookCommandResolutions,
+  formatTeammates,
+  repositoryBindingDiagnosticLabel,
+  formatStatusline
+};

package/dist/chunk-RO3F6JYV.js

@@ -0,0 +1,126 @@
+import {
+  getClient,
+  getSiteUrl,
+  terminalSafeLine
+} from "./chunk-Z7YPFWAZ.js";
+import {
+  daemonRequest
+} from "./chunk-CUE2LKLR.js";
+
+// src/daemon/proxy.ts
+var DAEMON_HTTP_TIMEOUT_MS = 1e4;
+var DAEMON_PROBE_TIMEOUT_MS = 250;
+async function daemonOrDirect(method, params, direct) {
+  const fromDaemon = await daemonRequest(
+    method,
+    { ...params, callerEnv: getSiteUrl() },
+    { timeoutMs: DAEMON_PROBE_TIMEOUT_MS }
+  );
+  if (fromDaemon !== null) {
+    return fromDaemon;
+  }
+  return await direct();
+}
+async function daemonOrDirectGet(method, path, client, timeoutMs = DAEMON_HTTP_TIMEOUT_MS) {
+  return await daemonOrDirect(
+    method,
+    { path },
+    async () => await client.get(path, {
+      signal: AbortSignal.timeout(timeoutMs)
+    })
+  );
+}
+
+// src/hooks/decisions-check.ts
+var DECISIONS_CHECK_TIMEOUT_MS = 1e4;
+var MAX_FILES_PER_REQUEST = 25;
+var defaultDeps = { getClient };
+function chunk(items, size) {
+  const out = [];
+  for (let i = 0; i < items.length; i += size) {
+    out.push(items.slice(i, i + size));
+  }
+  return out;
+}
+async function fetchAffecting(client, batch) {
+  const params = new URLSearchParams();
+  for (const file of batch) {
+    params.append("files", file);
+  }
+  try {
+    return await daemonOrDirectGet(
+      "decisions_affecting",
+      `/api/cli/decisions/affecting?${params.toString()}`,
+      client,
+      DECISIONS_CHECK_TIMEOUT_MS
+    );
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return { decisions: [], truncated: false, unavailable: `decision check failed: ${detail}` };
+  }
+}
+async function checkAffectedDecisions(filePaths, deps = defaultDeps) {
+  if (filePaths.length === 0) {
+    return { decisions: [], truncated: false };
+  }
+  const client = deps.getClient();
+  const responses = await Promise.all(
+    chunk(filePaths, MAX_FILES_PER_REQUEST).map((batch) => fetchAffecting(client, batch))
+  );
+  const byId = /* @__PURE__ */ new Map();
+  let truncated = false;
+  let unavailable;
+  for (const res of responses) {
+    if (res.unavailable !== void 0 && unavailable === void 0) {
+      unavailable = res.unavailable;
+    }
+    truncated ||= res.truncated === true;
+    for (const d of res.decisions) {
+      const existing = byId.get(d.id);
+      if (existing) {
+        existing.matchedFiles = [.../* @__PURE__ */ new Set([...existing.matchedFiles, ...d.matchedFiles])];
+      } else {
+        byId.set(d.id, { ...d, matchedFiles: [...d.matchedFiles] });
+      }
+    }
+  }
+  const result = { decisions: [...byId.values()], truncated };
+  if (unavailable !== void 0) {
+    result.unavailable = unavailable;
+  }
+  return result;
+}
+var FILES_PREVIEW_LIMIT = 3;
+function formatDecisionsWarning(result) {
+  const lines = [];
+  if (result.unavailable !== void 0) {
+    lines.push(`[prim] decision check not verified \u2014 ${terminalSafeLine(result.unavailable)}`);
+  }
+  if (result.decisions.length > 0) {
+    lines.push(
+      `[prim] ${String(result.decisions.length)} active decision(s) reference staged files:`
+    );
+    for (const d of result.decisions) {
+      const statusMark = d.status === "under_review" ? " (under review)" : "";
+      const preview = d.matchedFiles.slice(0, FILES_PREVIEW_LIMIT).map(terminalSafeLine).join(", ");
+      const overflow = d.matchedFiles.length > FILES_PREVIEW_LIMIT ? ` (+${String(d.matchedFiles.length - FILES_PREVIEW_LIMIT)} more)` : "";
+      lines.push(`  \xB7 ${terminalSafeLine(d.intent)}${statusMark}`);
+      lines.push(`    files: ${preview}${overflow}`);
+      if (d.rationale) {
+        lines.push(`    rationale: ${terminalSafeLine(d.rationale)}`);
+      }
+    }
+  }
+  if (result.truncated) {
+    lines.push(
+      "[prim] result truncated \u2014 more files than the server checks per request; not all decisions shown"
+    );
+  }
+  return lines.join("\n");
+}
+
+export {
+  daemonOrDirectGet,
+  checkAffectedDecisions,
+  formatDecisionsWarning
+};