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

package/dist/chunks/compact-before-4jrq0sqs.mjs

@@ -0,0 +1,61 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/platform/paths.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+function harnessDir(root) {
+  return join(root, ".tlc", "harness");
+}
+function conventionalRuntimeHome() {
+  return join(homedir(), ".tlc", "harness");
+}
+function runtimeHome(env = process.env) {
+  return env.TLC_HOME ?? conventionalRuntimeHome();
+}
+function runtimeHomeWasChosen(env = process.env) {
+  return env.TLC_HOME_FROM_ENV === "1";
+}
+function runtimeStateDir() {
+  return join(runtimeHome(), "state");
+}
+function runtimeSpoolPath() {
+  return join(runtimeStateDir(), "obs-spool.jsonl");
+}
+function projectConfigPath(root) {
+  return join(harnessDir(root), "config.json");
+}
+function projectStateDir(root) {
+  return join(harnessDir(root), "state");
+}
+function flagsDir(root) {
+  return join(projectStateDir(root), "flags");
+}
+function presenceDir(root) {
+  return join(projectStateDir(root), "presence");
+}
+function loopsDir(root) {
+  return join(projectStateDir(root), "loops");
+}
+function bootDir(root) {
+  return join(projectStateDir(root), "boot");
+}
+function policyBaselineDir(root) {
+  return join(projectStateDir(root), "policy-baseline");
+}
+function claudeConfigDir() {
+  const custom = process.env.CLAUDE_CONFIG_DIR?.trim();
+  return custom && custom.length > 0 ? custom : join(homedir(), ".claude");
+}
+function cursorConfigDir() {
+  const custom = process.env.CURSOR_CONFIG_DIR?.trim();
+  return custom && custom.length > 0 ? custom : join(homedir(), ".cursor");
+}
+function userSettingsPaths() {
+  return [join(claudeConfigDir(), "settings.json"), join(cursorConfigDir(), "hooks.json")];
+}
+function providerConfigDirs() {
+  return [cursorConfigDir(), claudeConfigDir()];
+}
+
+export { __require, conventionalRuntimeHome, runtimeHome, runtimeHomeWasChosen, runtimeStateDir, runtimeSpoolPath, projectConfigPath, projectStateDir, flagsDir, presenceDir, loopsDir, bootDir, policyBaselineDir, claudeConfigDir, cursorConfigDir, userSettingsPaths, providerConfigDirs };

package/dist/chunks/compact-before-6w8n1vh1.mjs

@@ -0,0 +1,186 @@
+import {
+  NPM_MARKER,
+  NPM_PACKAGE,
+  linkDir,
+  wireRuntime
+} from "./compact-before-1e4qg1qt.mjs";
+import {
+  PLAIN,
+  createStyle,
+  render
+} from "./compact-before-49j320yp.mjs";
+import {
+  __require,
+  conventionalRuntimeHome,
+  runtimeHome,
+  runtimeHomeWasChosen
+} from "./compact-before-4jrq0sqs.mjs";
+
+// tools/install-runtime.ts
+import { spawnSync } from "node:child_process";
+import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join, relative, resolve, sep } from "node:path";
+var RUNTIME_PAYLOAD = [
+  "bin",
+  "capabilities",
+  "dist",
+  "docs",
+  "skills",
+  "src",
+  "tools",
+  "config.example.json",
+  "package.json"
+];
+var OPERATOR_OWNED = ["config.json", "state", "flags"];
+var NOT_SHIPPED = [join("tools", "dev"), join("tools", "__test__")];
+function isShipped(relativePath) {
+  const normalised = relativePath.split(sep).join("/");
+  return !NOT_SHIPPED.some((excluded) => {
+    const prefix = excluded.split(sep).join("/");
+    return normalised === prefix || normalised.startsWith(`${prefix}/`);
+  });
+}
+function originRoot(env = process.env) {
+  const declared = env.TLC_ORIGIN?.trim();
+  if (declared && declared.length > 0) {
+    return resolve(declared);
+  }
+  const home = env.TLC_HOME?.trim();
+  return home && home.length > 0 ? resolve(home) : conventionalRuntimeHome();
+}
+function installRuntime(source, dest) {
+  if (resolve(source) === resolve(dest)) {
+    return { kind: "in-place", source, dest, entries: [], missing: [] };
+  }
+  mkdirSync(dest, { recursive: true });
+  const entries = [];
+  const missing = [];
+  for (const entry of RUNTIME_PAYLOAD) {
+    const from = join(source, entry);
+    if (!existsSync(from)) {
+      missing.push(entry);
+      continue;
+    }
+    const to = join(dest, entry);
+    rmSync(to, { recursive: true, force: true });
+    cpSync(from, to, {
+      recursive: true,
+      filter: (src) => isShipped(relative(source, src))
+    });
+    entries.push(entry);
+  }
+  writeFileSync(join(dest, NPM_MARKER), `Installed by \`tlc harness install\` from ${source}.
+Update with: npm i -g ${NPM_PACKAGE}@latest && tlc harness install
+`, "utf8");
+  const config = join(dest, "config.json");
+  const example = join(dest, "config.example.json");
+  if (!existsSync(config) && existsSync(example)) {
+    writeFileSync(config, readFileSync(example, "utf8"), "utf8");
+  }
+  return { kind: "copied", source, dest, entries, missing };
+}
+function linkRuntime(source, dest) {
+  if (resolve(source) === resolve(dest)) {
+    return { kind: "in-place", source, dest, entries: [], missing: [] };
+  }
+  const outcome = linkDir(resolve(source), dest);
+  if (outcome.kind === "refused") {
+    return { kind: "refused", source, dest, entries: [], missing: [], reason: outcome.reason };
+  }
+  const missing = RUNTIME_PAYLOAD.filter((entry) => !existsSync(join(dest, entry)));
+  return { kind: outcome.kind === "relinked" ? "relinked" : "linked", source, dest, entries: [], missing };
+}
+function installScreen(report) {
+  if (report.kind === "refused") {
+    return {
+      title: "harness install",
+      sections: [{ rows: [{ label: "refused", value: report.reason ?? "", level: "fail" }] }]
+    };
+  }
+  if (report.kind === "linked" || report.kind === "relinked") {
+    return {
+      title: "harness install",
+      sections: [
+        {
+          rows: [
+            {
+              label: report.kind === "linked" ? "linked" : "relinked",
+              value: `${report.dest} → ${report.source}`,
+              level: "ok"
+            },
+            ...report.missing.length > 0 ? [
+              {
+                label: "incomplete",
+                value: `the checkout has no ${report.missing.join(", ")} — run the build`,
+                level: "fail"
+              }
+            ] : []
+          ]
+        }
+      ],
+      footer: "an edit in the checkout is live in the next hook  ·  `npm link` puts `tlc` on PATH"
+    };
+  }
+  if (report.kind === "in-place") {
+    return {
+      title: "harness install",
+      sections: [
+        { rows: [{ label: "runtime", value: `already at ${report.dest} — nothing to copy`, level: "ok" }] }
+      ]
+    };
+  }
+  const rows = [
+    { label: "installed", value: `${report.entries.length} path(s) → ${report.dest}`, level: "ok" },
+    { label: "from", value: report.source }
+  ];
+  if (report.missing.length > 0) {
+    rows.push({
+      label: "packaging",
+      value: `MISSING from the source: ${report.missing.join(", ")}`,
+      level: "fail"
+    });
+  }
+  return { title: "harness install", sections: [{ rows }] };
+}
+function installReportText(report, style = PLAIN) {
+  return render(installScreen(report), style);
+}
+function installDest(env = process.env) {
+  const explicit = env.TLC_INSTALL_DEST?.trim();
+  if (explicit && explicit.length > 0) {
+    return resolve(explicit);
+  }
+  return runtimeHomeWasChosen(env) ? runtimeHome(env) : conventionalRuntimeHome();
+}
+function fetchPrices(dest, spawn = spawnSync) {
+  const result = spawn(process.execPath, [join(dest, "bin", "tlc-exec.mjs"), "refresh-model-prices"], {
+    stdio: "inherit",
+    env: { ...process.env, TLC_HOME: dest }
+  });
+  if ((result.status ?? 1) !== 0) {
+    console.log("install: prices not fetched — cost estimates stay empty until `tlc harness prices refresh`");
+  }
+}
+if (__require.main == __require.module) {
+  const link = process.argv.includes("--link");
+  const source = link ? process.cwd() : originRoot();
+  const dest = installDest();
+  const report = link ? linkRuntime(source, dest) : installRuntime(source, dest);
+  console.log(installReportText(report, createStyle()));
+  if (report.kind === "refused") {
+    process.exit(1);
+  }
+  const wired = wireRuntime(dest, dest);
+  for (const line of wired.lines) {
+    console.log(`install: ${line}`);
+  }
+  if (wired.missingSkill) {
+    console.error(`install: missing skill at ${join(dest, "skills", "harness-init")}`);
+    process.exit(1);
+  }
+  fetchPrices(dest);
+  console.log("install: ok — restart Cursor or Claude Code, then run `tlc harness doctor`");
+  process.exit(report.missing.length > 0 ? 1 : 0);
+}
+
+export { RUNTIME_PAYLOAD, OPERATOR_OWNED, NOT_SHIPPED, isShipped, originRoot, installRuntime, linkRuntime, installScreen, installReportText, installDest, fetchPrices };

package/dist/chunks/compact-before-7sdmwswh.mjs

@@ -0,0 +1,52 @@
+// bin/write-user-hooks.mjs
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+var CURSOR_MARKER = "tlc-exec.mjs";
+function quoteIfNeeded(token) {
+  return token.includes(" ") ? `"${token}"` : token;
+}
+function commandStringFor(entry) {
+  return [entry.command, ...entry.args].map(quoteIfNeeded).join(" ");
+}
+function renderCursorHooksDocument(entries) {
+  const hooks = {};
+  for (const entry of entries) {
+    const rendered = { command: commandStringFor(entry), timeout: entry.timeoutSeconds };
+    if (entry.failClosed) {
+      rendered.failClosed = true;
+    }
+    if (entry.matcher !== undefined) {
+      rendered.matcher = entry.matcher;
+    }
+    if (entry.loopLimit !== undefined) {
+      rendered.loop_limit = entry.loopLimit;
+    }
+    hooks[entry.hookEvent] = [...hooks[entry.hookEvent] ?? [], rendered];
+  }
+  return { version: 1, hooks };
+}
+function isCursorWired(targetPath) {
+  return existsSync(targetPath) && readFileSync(targetPath, "utf8").includes(CURSOR_MARKER);
+}
+function applyCursorWiring(wiring, { force = false } = {}) {
+  const targetPath = wiring.target;
+  const document = renderCursorHooksDocument(wiring.entries);
+  const rendered = `${JSON.stringify(document, null, 2)}
+`;
+  if (existsSync(targetPath) && !force) {
+    if (isCursorWired(targetPath)) {
+      return { status: "unchanged", target: targetPath };
+    }
+    return {
+      status: "refused",
+      target: targetPath,
+      reason: `${targetPath} exists without harness entries — rerun with --force to overwrite, or merge manually.`
+    };
+  }
+  mkdirSync(dirname(targetPath), { recursive: true });
+  writeFileSync(targetPath, rendered);
+  return { status: "written", target: targetPath };
+}
+if (false) {}
+
+export { renderCursorHooksDocument, isCursorWired, applyCursorWiring };

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

@@ -0,0 +1,187 @@
+import {
+  runtimeHome
+} from "./compact-before-4jrq0sqs.mjs";
+
+// src/platform/pricing.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var FALLBACK_PLANE = "litellm";
+var MODEL_ALIASES = {
+  "cursor-grok-4.5": "grok-4.5",
+  auto: "auto-cost"
+};
+var VENDOR_TO_NEUTRAL_POOL = {
+  cursor_models: "provider_native",
+  anthropic_models: "provider_native",
+  other_models: "other",
+  auto: "auto",
+  unknown: "unknown"
+};
+function mapPoolToNeutral(pool) {
+  return VENDOR_TO_NEUTRAL_POOL[pool];
+}
+function stripMeta(table) {
+  if (!table) {
+    return {};
+  }
+  const { _meta: _ignored, ...rest } = table;
+  return rest;
+}
+function slugifyModelName(name) {
+  return name.trim().toLowerCase().replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/[[\]]/g, "").replace(/[^a-z0-9.+]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function candidatesFor(model, aliases) {
+  const trimmed = model.trim();
+  const out = [];
+  const push = (v) => {
+    if (v && !out.includes(v)) {
+      out.push(v);
+    }
+  };
+  push(trimmed);
+  push(aliases[trimmed]);
+  push(slugifyModelName(trimmed));
+  push(aliases[slugifyModelName(trimmed)]);
+  if (trimmed.includes("/")) {
+    push(trimmed.slice(trimmed.lastIndexOf("/") + 1));
+  }
+  const noEffort = trimmed.replace(/-(high|medium|low|max|fast|thinking)$/i, "");
+  if (noEffort !== trimmed) {
+    push(noEffort);
+    push(aliases[noEffort]);
+    push(slugifyModelName(noEffort));
+  }
+  return out;
+}
+function fuzzyFind(table, needle) {
+  const direct = table[needle];
+  if (direct) {
+    return { key: needle, entry: direct };
+  }
+  for (const [key, entry] of Object.entries(table)) {
+    if (needle.startsWith(key) || key.startsWith(needle)) {
+      return { key, entry };
+    }
+  }
+  return;
+}
+function cataloguePath() {
+  return join(runtimeHome(), "model-prices.json");
+}
+function overridesPath() {
+  return join(runtimeHome(), "model-prices.local.json");
+}
+var cache = new Map;
+function readCatalogue(path) {
+  if (!existsSync(path)) {
+    cache.delete(path);
+    return null;
+  }
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch {
+    cache.delete(path);
+    return null;
+  }
+  const hit = cache.get(path);
+  if (hit && hit.text === text) {
+    return hit.value;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    cache.delete(path);
+    return null;
+  }
+  cache.set(path, { text, value: parsed });
+  return parsed;
+}
+function loadCatalogue() {
+  return readCatalogue(cataloguePath()) ?? {};
+}
+function planeMeta() {
+  return loadCatalogue()._meta?.planes ?? {};
+}
+function catalogueMeta() {
+  const parsed = readCatalogue(cataloguePath());
+  return parsed === null ? null : parsed._meta ?? {};
+}
+function planeFor(catalogue, plane) {
+  return stripMeta(catalogue.planes?.[plane] ?? null);
+}
+function resolveModelPrice(provider, model) {
+  const trimmed = model.trim();
+  if (!trimmed) {
+    return;
+  }
+  const catalogue = loadCatalogue();
+  const overrides = stripMeta(readCatalogue(overridesPath()));
+  const native = provider ? planeFor(catalogue, provider) : {};
+  const litellm = planeFor(catalogue, FALLBACK_PLANE);
+  const candidates = candidatesFor(trimmed, MODEL_ALIASES);
+  for (const id of candidates) {
+    const entry = overrides[id];
+    if (entry) {
+      return { entry, key: id, source: "override" };
+    }
+  }
+  for (const id of candidates) {
+    const entry = native[id];
+    if (entry) {
+      return { entry, key: id, source: "provider" };
+    }
+  }
+  for (const id of candidates) {
+    const entry = litellm[id];
+    if (entry) {
+      return { entry, key: id, source: "litellm" };
+    }
+  }
+  const slug = slugifyModelName(trimmed);
+  const fuzzyOverride = fuzzyFind(overrides, slug);
+  if (fuzzyOverride) {
+    return { ...fuzzyOverride, source: "override" };
+  }
+  const fuzzyNative = fuzzyFind(native, slug);
+  if (fuzzyNative) {
+    return { ...fuzzyNative, source: "provider" };
+  }
+  const fuzzyLitellm = fuzzyFind(litellm, slug);
+  if (fuzzyLitellm) {
+    return { ...fuzzyLitellm, source: "litellm" };
+  }
+  return;
+}
+function estimateCostUsd(provider, model, usage) {
+  const inputTokens = usage.inputTokens ?? 0;
+  const outputTokens = usage.outputTokens ?? 0;
+  const cacheReadTokens = usage.cacheReadTokens ?? 0;
+  const cacheWriteTokens = usage.cacheWriteTokens ?? 0;
+  if (!model || inputTokens <= 0 && outputTokens <= 0 && cacheReadTokens <= 0 && cacheWriteTokens <= 0) {
+    return { costUsd: null, billing: "unknown", pool: "unknown", source: "missing" };
+  }
+  const resolved = resolveModelPrice(provider, model);
+  if (!resolved) {
+    return { costUsd: null, billing: "unknown", pool: "unknown", source: "missing" };
+  }
+  const { entry, key, source } = resolved;
+  const pool = entry.pool ?? "unknown";
+  if (entry.billing === "included") {
+    return { costUsd: null, billing: "included", pool, source, catalogKey: key };
+  }
+  if (typeof entry.promptPer1M !== "number" || typeof entry.completionPer1M !== "number") {
+    return { costUsd: null, billing: entry.billing ?? "unknown", pool, source, catalogKey: key };
+  }
+  let costUsd = inputTokens / 1e6 * entry.promptPer1M + outputTokens / 1e6 * entry.completionPer1M;
+  if (typeof entry.cacheReadPer1M === "number" && cacheReadTokens > 0) {
+    costUsd += cacheReadTokens / 1e6 * entry.cacheReadPer1M;
+  }
+  if (typeof entry.cacheWritePer1M === "number" && cacheWriteTokens > 0) {
+    costUsd += cacheWriteTokens / 1e6 * entry.cacheWritePer1M;
+  }
+  return { costUsd, billing: "metered", pool, source, catalogKey: key };
+}
+
+export { FALLBACK_PLANE, mapPoolToNeutral, slugifyModelName, cataloguePath, overridesPath, loadCatalogue, planeMeta, catalogueMeta, resolveModelPrice, estimateCostUsd };