@tech-leads-club/harness-toolkit 0.3.2 → 0.3.3

package/dist/chunks/compact-before-wt2c3nh4.mjs

@@ -1,551 +0,0 @@
-import {
-  isCursorWired
-} from "./compact-before-7sdmwswh.mjs";
-import {
-  NPM_PACKAGE,
-  runtimePathKind
-} from "./compact-before-1e4qg1qt.mjs";
-import {
-  emitJson,
-  takeJsonFlag
-} from "./compact-before-wnnds45y.mjs";
-import {
-  catalogueMeta,
-  planeMeta
-} from "./compact-before-beqpmqrm.mjs";
-import {
-  providers
-} from "./compact-before-j9y4jgn4.mjs";
-import {
-  cursorWiringProblems,
-  formatWiringProblems,
-  mergeClaudeSettings
-} from "./compact-before-w1293m4n.mjs";
-import {
-  coreFacade
-} from "./compact-before-2hpbfxm5.mjs";
-import {
-  PLAIN,
-  SYMBOLS,
-  createStyle
-} from "./compact-before-49j320yp.mjs";
-import {
-  __require,
-  projectConfigPath,
-  projectStateDir,
-  providerConfigDirs,
-  runtimeHome
-} from "./compact-before-4jrq0sqs.mjs";
-
-// tools/doctor.ts
-import { spawnSync } from "node:child_process";
-import { existsSync as existsSync2, lstatSync, readFileSync as readFileSync2, readlinkSync, realpathSync as realpathSync2 } from "node:fs";
-import { homedir, platform as osPlatform } from "node:os";
-import { basename, delimiter as delimiter2, dirname as dirname2, join as join2 } from "node:path";
-
-// bin/tlc-exec.mjs
-import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
-import { delimiter, dirname, join } from "node:path";
-function isPackagedCopy(candidate) {
-  return candidate.split(/[/\\]/).includes("node_modules");
-}
-var BUN_EXECUTABLE_NAMES = ["bun", "bun.exe"];
-function findBunOnPath(env = process.env) {
-  for (const dir of (env.PATH ?? "").split(delimiter)) {
-    if (!dir) {
-      continue;
-    }
-    for (const name of BUN_EXECUTABLE_NAMES) {
-      const candidate = join(dir, name);
-      if (existsSync(candidate)) {
-        return candidate;
-      }
-    }
-  }
-  return null;
-}
-function runtimeCachePath(harnessHome) {
-  return join(harnessHome, "state", "runtime-cache.json");
-}
-function writeRuntimeCache(harnessHome, bunPath) {
-  const record = { bunPath, checkedAt: new Date().toISOString() };
-  if (isPackagedCopy(harnessHome)) {
-    return record;
-  }
-  try {
-    const cachePath = runtimeCachePath(harnessHome);
-    mkdirSync(dirname(cachePath), { recursive: true });
-    writeFileSync(cachePath, `${JSON.stringify(record)}
-`);
-  } catch {}
-  return record;
-}
-if (false) {}
-
-// tools/doctor.ts
-function plural(count, word) {
-  return `${count} ${word}${count === 1 ? "" : "s"}`;
-}
-var MIN_NODE = 24;
-function medianMs(samples) {
-  if (samples.length === 0) {
-    return null;
-  }
-  const sorted = [...samples].sort((a, b) => a - b);
-  const middle = Math.floor(sorted.length / 2);
-  return sorted.length % 2 === 1 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
-}
-function measureRuntimeStart(args) {
-  const spawn = args.spawn ?? ((command, argv) => ({
-    ok: (spawnSync(command, argv, { stdio: "ignore" }).status ?? 1) === 0
-  }));
-  const now = args.now ?? (() => Date.now());
-  const durations = [];
-  for (let i = 0;i < (args.samples ?? 3); i += 1) {
-    const started = now();
-    if (!spawn(args.command, args.args).ok) {
-      return null;
-    }
-    durations.push(now() - started);
-  }
-  return medianMs(durations);
-}
-function checkNodeVersion(nodeVersion, bunPath = null) {
-  const nodeMajor = Number.parseInt(nodeVersion.replace(/^v/, "").split(".")[0] ?? "0", 10);
-  const checks = [
-    {
-      level: nodeMajor >= MIN_NODE || bunPath !== null ? "ok" : "fail",
-      name: "Node.js runtime",
-      detail: nodeMajor >= MIN_NODE ? `${nodeVersion} (>= ${MIN_NODE})` : bunPath !== null ? `${nodeVersion} — below ${MIN_NODE}, covered by Bun at ${bunPath}` : `${nodeVersion} — no runtime for hooks. Install Bun (curl -fsSL https://bun.sh/install | bash) or Node ${MIN_NODE}+ (nodejs.org), then reload the editor.`
-    }
-  ];
-  if (nodeMajor === 25) {
-    checks.push({
-      level: "warn",
-      name: "Node.js line",
-      detail: "Node 25 is EOL — prefer 24 LTS or 26 Current"
-    });
-  }
-  return checks;
-}
-function runtimeOwnershipCheck(home) {
-  const kind = runtimePathKind(home);
-  const detail = {
-    managed: "managed checkout — `tlc harness update` moves it to upstream and owns its contents",
-    linked: "link to a working clone — update never writes here; pull that clone yourself",
-    npm: "installed from npm — `tlc harness update` bumps the package and re-materialises this directory",
-    unmanaged: "not a git checkout — update cannot pull; install the package and run `tlc harness install`",
-    absent: "missing — install the package, then run `tlc harness install`"
-  };
-  return {
-    level: kind === "managed" || kind === "linked" || kind === "npm" ? "ok" : "fail",
-    name: "runtime ownership",
-    detail: detail[kind]
-  };
-}
-function checkSkillLinks(home, providerDirs = providerConfigDirs(), probe = {
-  linkTarget: (path) => {
-    try {
-      return realpathSync2(path);
-    } catch {
-      try {
-        return readlinkSync(path);
-      } catch {
-        return null;
-      }
-    }
-  },
-  exists: existsSync2,
-  realpath: (path) => {
-    try {
-      return realpathSync2(path);
-    } catch {
-      return path;
-    }
-  }
-}) {
-  return providerDirs.filter((dir) => existsSync2(dir)).map((dir) => {
-    const health = coreFacade.skill.linkHealth(join2(dir, "skills", "harness-init"), home, probe);
-    return {
-      level: health.state === "ok" ? "ok" : "fail",
-      name: `init skill (${basename(dir)})`,
-      detail: coreFacade.skill.linkHealthMessage(health)
-    };
-  });
-}
-function checkPrices(now = new Date, read = { meta: catalogueMeta, planes: planeMeta }) {
-  const state = coreFacade.pricing.freshness(read.meta(), now);
-  const planes = read.planes();
-  const named = Object.entries(planes).map(([plane, meta]) => `${plane} ${meta.count ?? 0}`).join(", ");
-  return [
-    {
-      level: state.state === "fresh" ? "ok" : "warn",
-      name: "prices",
-      detail: state.state === "fresh" ? `${coreFacade.pricing.freshnessMessage(state, "catalogue")}${named ? ` (${named})` : ""}` : coreFacade.pricing.freshnessMessage(state, "catalogue")
-    }
-  ];
-}
-function resolveOnPath(command, env = process.env, exists = existsSync2) {
-  for (const dir of (env.PATH ?? "").split(delimiter2)) {
-    if (!dir) {
-      continue;
-    }
-    for (const name of [command, `${command}.cmd`, `${command}.exe`, `${command}.ps1`]) {
-      const candidate = join2(dir, name);
-      if (exists(candidate)) {
-        return candidate;
-      }
-    }
-  }
-  return null;
-}
-function checkRuntimePaths(home, platform) {
-  const launcher = join2(home, "bin", "tlc-exec.mjs");
-  const distSample = join2(home, "dist", "stop.mjs");
-  const onPath = resolveOnPath("tlc");
-  return [
-    { level: "ok", name: "platform", detail: platform },
-    { level: existsSync2(launcher) ? "ok" : "fail", name: "global runtime", detail: home },
-    runtimeOwnershipCheck(home),
-    {
-      level: existsSync2(distSample) ? "ok" : "fail",
-      name: "dist bundles",
-      detail: existsSync2(distSample) ? join2(home, "dist") : "missing — run: tlc harness build"
-    },
-    { level: existsSync2(launcher) ? "ok" : "fail", name: "portable launcher", detail: launcher },
-    {
-      level: onPath === null ? "fail" : "ok",
-      name: "CLI on PATH",
-      detail: onPath ?? `no \`tlc\` on PATH — npm i -g ${NPM_PACKAGE}, or \`npm link\` from a clone`
-    }
-  ];
-}
-function checkHookRuntime(_home, bunPath, measure = measureRuntimeStart) {
-  const runtime = bunPath ?? process.execPath;
-  const label = bunPath ? `Bun (${bunPath})` : `Node + dist/ (${process.version})`;
-  const ms = measure({ command: runtime, args: ["-e", ""] });
-  const timing = ms === null ? " — interpreter start could not be measured on this machine" : ` — interpreter start measured at ${ms} ms here, paid once per hook`;
-  return bunPath ? { level: "ok", name: "hook runtime", detail: `${label}${timing}` } : {
-    level: "warn",
-    name: "hook runtime",
-    detail: `${label}${timing}. Bun runs the source directly and starts faster — install: https://bun.sh`
-  };
-}
-function wiringProblems(wiring) {
-  if (wiring.strategy !== "replace") {
-    return [];
-  }
-  const text = existsSync2(wiring.target) ? readFileSync2(wiring.target, "utf8") : null;
-  return cursorWiringProblems(text, { launcherPath: launcherPathOf(wiring) }, existsSync2);
-}
-function launcherPathOf(wiring) {
-  const first = wiring.entries[0];
-  return first?.args.find((arg) => arg.endsWith(".mjs")) ?? "";
-}
-function providerWiringStatus(wiring) {
-  if (!existsSync2(dirname2(wiring.target))) {
-    return "not-installed";
-  }
-  if (wiring.strategy === "replace") {
-    if (!isCursorWired(wiring.target)) {
-      return "detected-but-unwired";
-    }
-    return wiringProblems(wiring).length === 0 ? "wired" : "detected-but-unwired";
-  }
-  const existingText = existsSync2(wiring.target) ? readFileSync2(wiring.target, "utf8") : null;
-  const result = mergeClaudeSettings(existingText, wiring.entries);
-  return result.ok && !result.changed ? "wired" : "detected-but-unwired";
-}
-function checkProviders(registry, home) {
-  const launcherPath = join2(home, "bin", "tlc-exec.mjs");
-  return registry.map((provider) => {
-    const wiring = provider.wiring({ launcherPath });
-    const status = providerWiringStatus(wiring);
-    if (status === "not-installed") {
-      return { level: "ok", name: `${provider.name} wiring`, detail: "not installed" };
-    }
-    if (status === "wired") {
-      return { level: "ok", name: `${provider.name} wiring`, detail: `wired (${wiring.target})` };
-    }
-    const problems = wiringProblems(wiring);
-    const why = problems.length > 0 ? ` — ${formatWiringProblems(problems)}` : "";
-    return {
-      level: "warn",
-      name: `${provider.name} wiring`,
-      detail: `detected but not wired${why} — run: tlc harness update (${wiring.target})`
-    };
-  });
-}
-function checkCapabilities(root, runtimeRoot) {
-  const catalog = coreFacade.capability.loadCatalog(runtimeRoot);
-  const policy = coreFacade.capability.readProjectPolicyRaw(root);
-  if (!catalog || !policy) {
-    return [];
-  }
-  const available = coreFacade.capability.listAvailableNotEnabled(policy, catalog);
-  if (available.length === 0) {
-    return [];
-  }
-  return [
-    {
-      level: "ok",
-      name: "capabilities",
-      detail: coreFacade.capability.formatAvailableInventory(available)
-    }
-  ];
-}
-function checkPosture(root) {
-  const posture = coreFacade.policy.resolveProjectPosture(root);
-  if (posture.origin !== "fallback") {
-    return { level: "ok", name: "operator posture", detail: `${posture.mode} (from ${posture.origin})` };
-  }
-  return {
-    level: "warn",
-    name: "operator posture",
-    detail: `\`${posture.invalid}\` is not a posture — running as ${posture.mode}. Accepted: ${coreFacade.policy.OPERATOR_MODES.join(" | ")}. Fix \`mode\` in ${projectConfigPath(root)}, or run: tlc harness mode <${coreFacade.policy.OPERATOR_MODES.join("|")}>`
-  };
-}
-function checkObservedRails(root) {
-  const policy = coreFacade.policy.loadPolicy(root);
-  if (!policy.observe.enabled) {
-    return [];
-  }
-  const unusable = coreFacade.observe.unobservableRails(policy.observe.rails);
-  const observable = coreFacade.observe.OBSERVABLE_RAILS.join(" | ");
-  if (policy.observe.rails.length === 0) {
-    return [
-      {
-        level: "warn",
-        name: "observed rails",
-        detail: `observation is on with no rails listed, so nothing is measured. Set \`observe.rails\` to one or more of: ${observable}`
-      }
-    ];
-  }
-  if (unusable.length === 0) {
-    return [{ level: "ok", name: "observed rails", detail: policy.observe.rails.join(", ") }];
-  }
-  return [
-    {
-      level: "warn",
-      name: "observed rails",
-      detail: `no checker exists for ${unusable.map((rail) => `\`${rail}\``).join(", ")}, so nothing is recorded for them. Observable today: ${observable}`
-    }
-  ];
-}
-function checkSubagentAllowlist(root) {
-  const { subagents } = coreFacade.policy.loadPolicy(root);
-  if (!subagents.enforceAllowlist) {
-    return [];
-  }
-  const configured = subagents.allowedModels;
-  const entries = Array.isArray(configured) ? configured.length : Object.values(configured ?? {}).reduce((total, list) => total + list.length, 0);
-  if (entries > 0) {
-    return [];
-  }
-  return [
-    {
-      level: "fail",
-      name: "subagent allowlist",
-      detail: "enforceAllowlist is on and subagents.allowedModels is empty, so it permits every model. The harness ships no list — add the model slugs you allow, or set enforceAllowlist to false."
-    }
-  ];
-}
-function checkLessonHealth(root) {
-  const policy = coreFacade.policy.loadPolicy(root);
-  if (!policy.intelligence.lessons.enabled) {
-    return [];
-  }
-  const now = new Date;
-  const writable = [...coreFacade.lesson.readProjectLessons(root), ...coreFacade.lesson.readGlobalLessons()];
-  if (writable.length === 0) {
-    return [];
-  }
-  const stale = writable.filter((lesson) => coreFacade.lesson.isStaleLesson(lesson));
-  const outOfWindow = writable.filter((lesson) => coreFacade.lesson.validityReason(lesson, now) !== "active");
-  const unproven = writable.filter((lesson) => coreFacade.lesson.lessonEffectiveness(lesson) === "unproven");
-  const checks = [];
-  if (stale.length > 0) {
-    checks.push({
-      level: "warn",
-      name: "stale lessons",
-      detail: `${plural(stale.length, "lesson")} name a path or symbol that no longer resolves, so ${stale.length === 1 ? "it is" : "they are"} withheld: ${stale.map((lesson) => lesson.id).join(", ")}. Run: tlc harness lessons list`
-    });
-  }
-  if (outOfWindow.length > 0) {
-    checks.push({
-      level: "warn",
-      name: "lessons out of window",
-      detail: `${plural(outOfWindow.length, "lesson")} fall outside their validity window: ${outOfWindow.map((lesson) => lesson.id).join(", ")}. Run: tlc harness lessons garden`
-    });
-  }
-  if (unproven.length > 0) {
-    checks.push({
-      level: "warn",
-      name: "unproven lessons",
-      detail: unproven.length === 1 ? "1 lesson has been injected for a gate and never graded, so nothing shows it helped" : `${unproven.length} lessons have been injected for a gate and never graded, so nothing shows they helped`
-    });
-  }
-  if (checks.length === 0) {
-    return [
-      {
-        level: "ok",
-        name: "lesson health",
-        detail: `${plural(writable.length, "lesson")} across the writable tiers, none stale, none out of window`
-      }
-    ];
-  }
-  return checks;
-}
-function checkPolicyDivergence(root) {
-  const diverged = coreFacade.policy.allDivergedPaths(root);
-  if (diverged.length === 0) {
-    return [];
-  }
-  return [
-    {
-      level: "warn",
-      name: "policy baseline",
-      detail: `changed out of band during a live session: ${diverged.join(", ")}. If that was you: tlc harness policy accept ${diverged.join(" ")}`
-    }
-  ];
-}
-function checkGateScope(root) {
-  const policy = coreFacade.policy.loadPolicy(root);
-  if (!policy.grind.enabled) {
-    return [];
-  }
-  const checks = [];
-  for (const [label, command] of [
-    ["lintCommand", policy.grind.lintCommand],
-    ["testCommand", policy.grind.testCommand]
-  ]) {
-    if (!command || command.length === 0) {
-      continue;
-    }
-    const verdict = coreFacade.gate.appendFilesVerdict(command, policy.grind.appendFiles);
-    if (verdict.appends || policy.grind.appendFiles === "never") {
-      continue;
-    }
-    checks.push({
-      level: "warn",
-      name: `gate scope (${label})`,
-      detail: `runs in full on every attempt, up to maxLoops ${policy.grind.maxLoops}, because ${verdict.reason}. Scope the command itself, or accept the cost knowingly.`
-    });
-  }
-  return checks;
-}
-function checkProjectPolicy(root) {
-  const configPath = projectConfigPath(root);
-  const stateDir = projectStateDir(root);
-  return [
-    {
-      level: "ok",
-      name: "project policy",
-      detail: existsSync2(configPath) ? configPath : "missing — run: tlc harness init"
-    },
-    {
-      level: "ok",
-      name: "state dir",
-      detail: existsSync2(stateDir) ? stateDir : `${stateDir} (created on first session)`
-    },
-    checkPosture(root),
-    ...checkObservedRails(root),
-    ...checkLessonHealth(root),
-    ...checkSubagentAllowlist(root),
-    ...checkPolicyDivergence(root),
-    ...checkGateScope(root)
-  ];
-}
-function checkGlobalCommands(home) {
-  const globalCommands = join2(home, ".cursor", "commands");
-  if (!existsSync2(globalCommands)) {
-    return {
-      level: "ok",
-      name: "global commands dir",
-      detail: "optional — ~/.cursor/commands for slash commands"
-    };
-  }
-  try {
-    const st = lstatSync(globalCommands);
-    const detail = st.isSymbolicLink() ? `${globalCommands} → ${readlinkSync(globalCommands)}` : globalCommands;
-    return { level: "ok", name: "global commands dir", detail };
-  } catch {
-    return { level: "ok", name: "global commands dir", detail: globalCommands };
-  }
-}
-function runChecks(ctx) {
-  return [
-    ...checkNodeVersion(ctx.nodeVersion, ctx.bunPath),
-    ...checkRuntimePaths(ctx.runtimeHome, ctx.platform),
-    ...checkSkillLinks(ctx.runtimeHome),
-    checkHookRuntime(ctx.runtimeHome, ctx.bunPath),
-    ...checkProviders(ctx.registry, ctx.runtimeHome),
-    ...checkProjectPolicy(ctx.root),
-    ...checkCapabilities(ctx.root, ctx.runtimeHome),
-    ...checkPrices(),
-    checkGlobalCommands(ctx.home)
-  ];
-}
-function exitCodeFor(checks) {
-  return checks.some((c) => c.level === "fail") ? 1 : 0;
-}
-function checkId(name) {
-  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-}
-function toReport(checks) {
-  const statuses = { ok: "OK", warn: "WARN", fail: "FAIL" };
-  return {
-    ok: exitCodeFor(checks) === 0,
-    failed: checks.filter((check) => check.level === "fail").length,
-    warned: checks.filter((check) => check.level === "warn").length,
-    checks: checks.map((check) => ({
-      id: checkId(check.name),
-      name: check.name,
-      status: statuses[check.level],
-      detail: check.detail
-    }))
-  };
-}
-function formatReport(checks, style = PLAIN) {
-  const marks = { ok: "OK  ", warn: "WARN", fail: "FAIL" };
-  const paint = { ok: "success", warn: "warning", fail: "error" };
-  const lines = checks.map((c) => `${style.paint(paint[c.level], marks[c.level])}  ${style.paint("textMuted", c.name)} ${style.dim("—")} ${c.detail}`);
-  const failed = checks.filter((c) => c.level === "fail").length;
-  const warned = checks.filter((c) => c.level === "warn").length;
-  lines.push("");
-  if (failed > 0) {
-    lines.push(style.paint("error", `${SYMBOLS.cross} doctor: ${plural(failed, "failure")}${warned > 0 ? `, ${plural(warned, "warning")}` : ""}`));
-  } else if (warned > 0) {
-    lines.push(style.paint("warning", `${SYMBOLS.warning} doctor: no failures, ${plural(warned, "warning")} to read above`));
-  } else {
-    lines.push(style.paint("success", `${SYMBOLS.check} doctor: all checks passed`));
-  }
-  return lines.join(`
-`);
-}
-function realContext() {
-  const home = runtimeHome();
-  const bunPath = findBunOnPath();
-  writeRuntimeCache(home, bunPath);
-  return {
-    root: process.env.TLC_PROJECT_DIR ?? process.cwd(),
-    home: homedir(),
-    runtimeHome: home,
-    platform: osPlatform(),
-    nodeVersion: process.version,
-    bunPath,
-    registry: providers
-  };
-}
-if (__require.main == __require.module) {
-  const { json } = takeJsonFlag(process.argv.slice(2));
-  const checks = runChecks(realContext());
-  if (json) {
-    emitJson(toReport(checks));
-  } else {
-    console.log(formatReport(checks, createStyle()));
-  }
-  process.exit(exitCodeFor(checks));
-}
-
-export { plural, medianMs, measureRuntimeStart, checkNodeVersion, runtimeOwnershipCheck, checkSkillLinks, checkPrices, resolveOnPath, checkRuntimePaths, checkHookRuntime, wiringProblems, providerWiringStatus, checkProviders, checkCapabilities, checkSubagentAllowlist, checkLessonHealth, checkProjectPolicy, checkGlobalCommands, runChecks, exitCodeFor, checkId, toReport, formatReport };