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

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

@@ -0,0 +1,118 @@
+import {
+  renderClaudeLessonsView,
+  renderCursorLessonsView
+} from "./compact-before-j9y4jgn4.mjs";
+import {
+  coreFacade
+} from "./compact-before-2hpbfxm5.mjs";
+import {
+  runProcess
+} from "./compact-before-49j320yp.mjs";
+
+// src/entrypoints/support.ts
+import { existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+var OBS_CONFIG = coreFacade.observability.DEFAULT_OBS;
+var OBS_CONFIG_AUDIT = { ...OBS_CONFIG, debugEnabled: true };
+function obsConfigFor(policy, base = OBS_CONFIG) {
+  return {
+    ...base,
+    globalSpool: policy.obs.globalSpool,
+    includePayloads: policy.obs.includePayloads,
+    maxAttrChars: policy.obs.maxAttrChars,
+    sessionCostAlertUsd: policy.obs.sessionCostAlertUsd,
+    retentionDays: policy.obs.retentionDays
+  };
+}
+function sizeOf(path) {
+  try {
+    return statSync(path).size;
+  } catch {
+    return 0;
+  }
+}
+function sessionIdFromKey(event) {
+  const prefix = `${event.provider}-`;
+  return event.sessionKey.startsWith(prefix) ? event.sessionKey.slice(prefix.length) : event.sessionKey;
+}
+async function currentGitBranch(root) {
+  if (!existsSync(join(root, ".git"))) {
+    return null;
+  }
+  const result = await runProcess({ command: ["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd: root });
+  if (result.exitCode !== 0) {
+    return null;
+  }
+  const branch = result.stdout.trim();
+  return branch.length > 0 ? branch : null;
+}
+async function currentGitSha(root) {
+  if (!existsSync(join(root, ".git"))) {
+    return null;
+  }
+  const result = await runProcess({ command: ["git", "rev-parse", "--short", "HEAD"], cwd: root });
+  if (result.exitCode !== 0) {
+    return null;
+  }
+  const sha = result.stdout.trim();
+  return sha.length > 0 ? sha : null;
+}
+function effectiveAllowedModels(configured, provider) {
+  return coreFacade.policy.forProvider(configured, provider.name) ?? [];
+}
+function effectiveBlockedPatterns(configured, provider) {
+  const fromConfig = coreFacade.policy.forProvider(configured, provider.name) ?? [];
+  return [...fromConfig, ...provider.policyDefaults().blockedPatterns];
+}
+function effectiveMinEffort(configured, provider) {
+  return configured ?? provider.policyDefaults().minEffort;
+}
+function subagentSpawnInput(event, policy, provider, model) {
+  return {
+    provider: provider.name,
+    sessionKey: event.sessionKey,
+    projectDir: event.projectDir,
+    model,
+    effort: event.effort,
+    allowedModels: effectiveAllowedModels(policy.subagents.allowedModels, provider),
+    blockedPatterns: effectiveBlockedPatterns(policy.subagents.blockedPatterns, provider),
+    minEffort: effectiveMinEffort(policy.subagents.minEffort, provider),
+    requireModel: policy.subagents.requireModel,
+    enforceAllowlist: policy.subagents.enforceAllowlist,
+    blockParentFast: policy.subagents.blockParentFast,
+    blockMode: policy.subagents.blockMode
+  };
+}
+function readModelFromToolInput(toolInput) {
+  if (!toolInput) {
+    return "";
+  }
+  const model = toolInput.model ?? toolInput.Model;
+  return typeof model === "string" ? model : "";
+}
+function renderLessonLine(lesson) {
+  return coreFacade.lesson.renderLessonBlock(lesson);
+}
+function renderProviderLessonsView(providerName, root) {
+  if (providerName === "cursor") {
+    return renderCursorLessonsView(root);
+  }
+  if (providerName === "claude") {
+    return renderClaudeLessonsView(root);
+  }
+  return null;
+}
+function formatLessonsBlock(lessons, title, omitted = 0) {
+  if (lessons.length === 0) {
+    return "";
+  }
+  const lines = [title, ...lessons.map(renderLessonLine)];
+  if (omitted > 0) {
+    const noun = omitted === 1 ? "lesson" : "lessons";
+    lines.push(`  (${omitted} more eligible ${noun} omitted under the char budget — raise maxCharsSession to see them)`);
+  }
+  return lines.join(`
+`);
+}
+
+export { OBS_CONFIG, OBS_CONFIG_AUDIT, obsConfigFor, sizeOf, sessionIdFromKey, currentGitBranch, currentGitSha, effectiveAllowedModels, effectiveBlockedPatterns, effectiveMinEffort, subagentSpawnInput, readModelFromToolInput, renderLessonLine, renderProviderLessonsView, formatLessonsBlock };

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

@@ -0,0 +1,137 @@
+import {
+  effectiveBlockedPatterns,
+  obsConfigFor,
+  sessionIdFromKey
+} from "./compact-before-pk86tqx2.mjs";
+import {
+  degrade,
+  providers,
+  resolveFromRegistry
+} from "./compact-before-j9y4jgn4.mjs";
+import {
+  coreFacade
+} from "./compact-before-2hpbfxm5.mjs";
+import {
+  appendRecord,
+  readStdinText
+} from "./compact-before-49j320yp.mjs";
+import {
+  projectStateDir
+} from "./compact-before-4jrq0sqs.mjs";
+
+// src/entrypoints/run.ts
+import { join } from "node:path";
+var CONTEXT_BUDGET_CHARS = 6000;
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function recordAdapterEvent(root, kind, attrs) {
+  try {
+    appendRecord(join(projectStateDir(root), "obs.jsonl"), {
+      schema: "harness.observability.v1",
+      provider: "unknown",
+      kind,
+      level: "signal",
+      ts: new Date().toISOString(),
+      attrs
+    });
+  } catch {}
+}
+function recordRefusal(event, policy, decision) {
+  if (decision.kind !== "deny" && decision.kind !== "ask") {
+    return;
+  }
+  if (event.event === "shell.before") {
+    return;
+  }
+  coreFacade.observability.recordObs(event.projectDir, obsConfigFor(policy), {
+    provider: event.provider,
+    kind: "policy.deny",
+    sessionKey: event.sessionKey,
+    attrs: {
+      event: event.event,
+      tool_name: event.toolName,
+      permission: decision.kind,
+      rule: decision.rule ?? "none"
+    }
+  });
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+async function runHandler(handler, io = {}) {
+  const readStdin = io.readStdin ?? readStdinText;
+  const now = io.now ? io.now() : new Date;
+  const abstainRendered = { stdout: null, exitCode: 0 };
+  const text = await readStdin();
+  const trimmed = text.trim();
+  if (!trimmed) {
+    recordAdapterEvent(process.cwd(), "adapter.unrecognized", { reason: "empty-stdin" });
+    return { event: null, decision: { kind: "abstain" }, rendered: abstainRendered };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    recordAdapterEvent(process.cwd(), "adapter.unrecognized", { reason: "invalid-json" });
+    return { event: null, decision: { kind: "abstain" }, rendered: abstainRendered };
+  }
+  const resolved = resolveFromRegistry(parsed, providers);
+  if (!resolved.provider) {
+    recordAdapterEvent(process.cwd(), "adapter.unrecognized", { reason: "no-provider-match" });
+    return { event: null, decision: { kind: "abstain" }, rendered: abstainRendered };
+  }
+  if (resolved.ambiguous) {
+    recordAdapterEvent(process.cwd(), "adapter.ambiguous", { matched: resolved.matchedNames });
+  }
+  const provider = resolved.provider;
+  const event = provider.toEvent(asRecord(parsed));
+  if (!event) {
+    recordAdapterEvent(process.cwd(), "adapter.unrecognized", {
+      reason: "unrecognized-event",
+      provider: provider.name
+    });
+    return { event: null, decision: { kind: "abstain" }, rendered: abstainRendered };
+  }
+  const capabilities = provider.capabilities();
+  try {
+    const policy = coreFacade.policy.loadPolicy(event.projectDir);
+    if (event.model) {
+      coreFacade.subagentPolicy.upsertParentModelState(event.projectDir, event.sessionKey, { model: event.model }, effectiveBlockedPatterns(policy.subagents.blockedPatterns, provider));
+    }
+    coreFacade.presence.heartbeat(event.projectDir, {
+      provider: event.provider,
+      session: sessionIdFromKey(event),
+      file: event.filePath,
+      now
+    });
+    const context = { policy, capabilities, provider, now };
+    const decision = await handler(event, context);
+    const degraded = degrade(decision, event, capabilities, {
+      contextBudgetChars: CONTEXT_BUDGET_CHARS
+    });
+    recordRefusal(event, policy, degraded);
+    const rendered = provider.render(degraded, event);
+    return { event, decision: degraded, rendered };
+  } catch (error) {
+    recordAdapterEvent(event.projectDir, "adapter.error", {
+      provider: event.provider,
+      event: event.event,
+      message: errorMessage(error)
+    });
+    const abstain = { kind: "abstain" };
+    return { event, decision: abstain, rendered: provider.render(abstain, event) };
+  }
+}
+async function main(handler) {
+  const outcome = await runHandler(handler);
+  if (outcome.rendered.stdout !== null) {
+    const text = outcome.rendered.stdout;
+    process.stdout.write(text.endsWith(`
+`) ? text : `${text}
+`);
+  }
+  process.exit(outcome.rendered.exitCode);
+}
+
+export { CONTEXT_BUDGET_CHARS, runHandler, main };

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

@@ -0,0 +1,315 @@
+import {
+  claudeConfigDir,
+  cursorConfigDir
+} from "./compact-before-4jrq0sqs.mjs";
+
+// src/providers/claude/claude.wiring.ts
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+var ENTRY_SPECS = [
+  { hookEvent: "SessionStart", handler: "session-start", timeoutSeconds: 10 },
+  { hookEvent: "SessionEnd", handler: "session-end", timeoutSeconds: 10 },
+  { hookEvent: "UserPromptSubmit", handler: "prompt-submit", timeoutSeconds: 5 },
+  { hookEvent: "PreToolUse", handler: "tool-before", timeoutSeconds: 10, failClosed: true },
+  { hookEvent: "PostToolUse", handler: "tool-after", timeoutSeconds: 10 },
+  { hookEvent: "PostToolUseFailure", handler: "tool-failure", timeoutSeconds: 5 },
+  { hookEvent: "SubagentStart", handler: "subagent-start", timeoutSeconds: 5, failClosed: true },
+  { hookEvent: "SubagentStop", handler: "subagent-stop", timeoutSeconds: 5 },
+  { hookEvent: "Stop", handler: "stop", timeoutSeconds: 120, loopLimit: 5 },
+  { hookEvent: "PreCompact", handler: "compact-before", timeoutSeconds: 5 },
+  { hookEvent: "MessageDisplay", handler: "response-after", timeoutSeconds: 5 }
+];
+function claudeSettingsPath() {
+  return join(claudeConfigDir(), "settings.json");
+}
+function claudeWiring(runtime) {
+  const entries = ENTRY_SPECS.map((spec) => ({
+    hookEvent: spec.hookEvent,
+    handler: spec.handler,
+    command: "node",
+    args: [runtime.launcherPath, spec.handler],
+    timeoutSeconds: spec.timeoutSeconds,
+    ...spec.failClosed !== undefined ? { failClosed: spec.failClosed } : {},
+    ...spec.loopLimit !== undefined ? { loopLimit: spec.loopLimit } : {}
+  }));
+  return {
+    target: claudeSettingsPath(),
+    strategy: "merge",
+    entries
+  };
+}
+function isPlainRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isHooksRecord(value) {
+  return isPlainRecord(value);
+}
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) {
+      return false;
+    }
+    return a.every((item, index) => deepEqual(item, b[index]));
+  }
+  if (isPlainRecord(a) && isPlainRecord(b)) {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) {
+      return false;
+    }
+    return aKeys.every((key) => bKeys.includes(key) && deepEqual(a[key], b[key]));
+  }
+  return false;
+}
+function desiredHooksFor(entries) {
+  const hooks = {};
+  for (const entry of entries) {
+    const group = {
+      hooks: [{ type: "command", command: entry.command, args: entry.args }]
+    };
+    hooks[entry.hookEvent] = [...hooks[entry.hookEvent] ?? [], group];
+  }
+  return hooks;
+}
+var LAUNCHER_MARKER = "tlc-exec.mjs";
+function isHarnessGroup(group) {
+  return JSON.stringify(group ?? null).includes(LAUNCHER_MARKER);
+}
+function canonicalLauncherPath(path, resolve = realpathSync) {
+  try {
+    return resolve(path);
+  } catch {
+    return path;
+  }
+}
+function canonicalizeGroups(groups, resolve) {
+  return JSON.parse(JSON.stringify(groups ?? null, (_key, value) => typeof value === "string" && value.includes(LAUNCHER_MARKER) ? canonicalLauncherPath(value, resolve) : value));
+}
+function mergeClaudeSettings(existingText, entries) {
+  const desired = desiredHooksFor(entries);
+  let settings = {};
+  if (existingText !== null && existingText.trim() !== "") {
+    let parsed;
+    try {
+      parsed = JSON.parse(existingText);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { ok: false, error: message, block: JSON.stringify({ hooks: desired }, null, 2) };
+    }
+    if (!isPlainRecord(parsed)) {
+      return {
+        ok: false,
+        error: "settings.json root is not a JSON object",
+        block: JSON.stringify({ hooks: desired }, null, 2)
+      };
+    }
+    settings = parsed;
+  }
+  const currentHooks = isHooksRecord(settings.hooks) ? settings.hooks : {};
+  const mergedHooks = { ...currentHooks };
+  let changed = false;
+  for (const [hookEvent, groups] of Object.entries(desired)) {
+    const existingGroups = mergedHooks[hookEvent] ?? [];
+    const foreign = existingGroups.filter((group) => !isHarnessGroup(group));
+    const nextGroups = [...foreign, ...groups];
+    if (!deepEqual(canonicalizeGroups(existingGroups), canonicalizeGroups(nextGroups))) {
+      changed = true;
+    }
+    mergedHooks[hookEvent] = nextGroups;
+  }
+  const mergedSettings = { ...settings, hooks: mergedHooks };
+  return { ok: true, settingsText: JSON.stringify(mergedSettings, null, 2), changed };
+}
+function unmergeClaudeSettings(existingText) {
+  if (existingText === null || existingText.trim() === "") {
+    return { ok: true, settingsText: "", changed: false };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(existingText);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { ok: false, error: message, block: "" };
+  }
+  if (!isPlainRecord(parsed)) {
+    return { ok: false, error: "settings.json root is not a JSON object", block: "" };
+  }
+  const currentHooks = isHooksRecord(parsed.hooks) ? parsed.hooks : {};
+  const remainingHooks = {};
+  let changed = false;
+  for (const [hookEvent, groups] of Object.entries(currentHooks)) {
+    const foreign = groups.filter((group) => !isHarnessGroup(group));
+    if (foreign.length !== groups.length) {
+      changed = true;
+    }
+    if (foreign.length > 0) {
+      remainingHooks[hookEvent] = foreign;
+    }
+  }
+  const next = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (key !== "hooks") {
+      next[key] = value;
+    } else if (Object.keys(remainingHooks).length > 0) {
+      next.hooks = remainingHooks;
+    }
+  }
+  return { ok: true, settingsText: JSON.stringify(next, null, 2), changed };
+}
+function removeClaudeWiring(settingsPath) {
+  if (!existsSync(settingsPath)) {
+    return { ok: true, settingsText: "", changed: false };
+  }
+  const result = unmergeClaudeSettings(readFileSync(settingsPath, "utf8"));
+  if (result.ok && result.changed) {
+    writeFileSync(settingsPath, result.settingsText, "utf8");
+  }
+  return result;
+}
+function applyClaudeWiring(settingsPath, entries) {
+  const existingText = existsSync(settingsPath) ? readFileSync(settingsPath, "utf8") : null;
+  const result = mergeClaudeSettings(existingText, entries);
+  if (result.ok && result.changed) {
+    mkdirSync(dirname(settingsPath), { recursive: true });
+    writeFileSync(settingsPath, result.settingsText, "utf8");
+  }
+  return result;
+}
+
+// src/providers/cursor/cursor.wiring.ts
+import { join as join2 } from "node:path";
+var ENTRY_SPECS2 = [
+  { hookEvent: "sessionStart", handler: "session-start", timeoutSeconds: 10 },
+  { hookEvent: "sessionEnd", handler: "session-end", timeoutSeconds: 10 },
+  { hookEvent: "beforeSubmitPrompt", handler: "prompt-submit", timeoutSeconds: 5 },
+  { hookEvent: "afterAgentThought", handler: "tool-after", timeoutSeconds: 5 },
+  { hookEvent: "preCompact", handler: "compact-before", timeoutSeconds: 5 },
+  { hookEvent: "subagentStart", handler: "subagent-start", timeoutSeconds: 5, failClosed: true },
+  { hookEvent: "subagentStop", handler: "subagent-stop", timeoutSeconds: 5 },
+  { hookEvent: "preToolUse", handler: "tool-before", timeoutSeconds: 5, failClosed: true },
+  { hookEvent: "postToolUse", handler: "tool-after", timeoutSeconds: 5 },
+  { hookEvent: "postToolUseFailure", handler: "tool-failure", timeoutSeconds: 5 },
+  { hookEvent: "beforeShellExecution", handler: "tool-before", timeoutSeconds: 10, failClosed: true },
+  { hookEvent: "afterShellExecution", handler: "tool-after", timeoutSeconds: 10 },
+  { hookEvent: "beforeMCPExecution", handler: "tool-before", timeoutSeconds: 10 },
+  { hookEvent: "afterMCPExecution", handler: "tool-after", timeoutSeconds: 5 },
+  { hookEvent: "beforeReadFile", handler: "tool-before", timeoutSeconds: 5 },
+  { hookEvent: "afterFileEdit", handler: "tool-after", timeoutSeconds: 30, matcher: "Write" },
+  { hookEvent: "stop", handler: "stop", timeoutSeconds: 120, loopLimit: 5 },
+  { hookEvent: "afterAgentResponse", handler: "response-after", timeoutSeconds: 5, matcher: "AgentResponse" }
+];
+function cursorWiring(runtime) {
+  const command = "node";
+  const argsPrefix = [runtime.launcherPath];
+  const entries = ENTRY_SPECS2.map((spec) => ({
+    hookEvent: spec.hookEvent,
+    handler: spec.handler,
+    command,
+    args: [...argsPrefix, spec.handler],
+    timeoutSeconds: spec.timeoutSeconds,
+    ...spec.failClosed !== undefined ? { failClosed: spec.failClosed } : {},
+    ...spec.matcher !== undefined ? { matcher: spec.matcher } : {},
+    ...spec.loopLimit !== undefined ? { loopLimit: spec.loopLimit } : {}
+  }));
+  return {
+    target: join2(cursorConfigDir(), "hooks.json"),
+    strategy: "replace",
+    entries
+  };
+}
+function commandTokens(command) {
+  return [...command.matchAll(/"([^"]*)"|(\S+)/g)].map((match) => match[1] ?? match[2] ?? "");
+}
+function cursorWiringProblems(text, runtime, fileExists) {
+  if (text === null) {
+    return [{ hookEvent: "(file)", reason: "no hooks file at the expected path" }];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return [{ hookEvent: "(file)", reason: "the hooks file is not valid JSON" }];
+  }
+  const hooks = parsed !== null && typeof parsed === "object" ? parsed.hooks ?? {} : {};
+  const problems = [];
+  for (const spec of ENTRY_SPECS2) {
+    const list = Array.isArray(hooks[spec.hookEvent]) ? hooks[spec.hookEvent] : [];
+    const commands = list.map((row) => row !== null && typeof row === "object" ? String(row.command ?? "") : "").filter((command) => command.includes(runtime.launcherPath));
+    if (commands.length === 0) {
+      problems.push({ hookEvent: spec.hookEvent, reason: "no harness entry — run: tlc harness update" });
+      continue;
+    }
+    for (const command of commands) {
+      const tokens = commandTokens(command);
+      const scriptAt = tokens.indexOf(runtime.launcherPath);
+      if (scriptAt < 1) {
+        problems.push({
+          hookEvent: spec.hookEvent,
+          reason: `no executable before the script: \`${command}\``
+        });
+        continue;
+      }
+      if (!fileExists(runtime.launcherPath)) {
+        problems.push({
+          hookEvent: spec.hookEvent,
+          reason: `the script does not exist: ${runtime.launcherPath}`
+        });
+        continue;
+      }
+      if (tokens[scriptAt + 1] === undefined || tokens[scriptAt + 1] === "") {
+        problems.push({
+          hookEvent: spec.hookEvent,
+          reason: `no handler after the script: \`${command}\``
+        });
+      }
+    }
+  }
+  return problems;
+}
+function formatWiringProblems(problems, max = 3) {
+  const shown = problems.slice(0, max).map((problem) => `${problem.hookEvent}: ${problem.reason}`).join("; ");
+  const rest = problems.length - Math.min(problems.length, max);
+  return rest > 0 ? `${shown}; and ${rest} more` : shown;
+}
+function unwireCursorHooks(text, marker = "tlc-exec.mjs") {
+  if (text === null || text.trim() === "") {
+    return { kind: "absent" };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return { kind: "unparsed" };
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { kind: "unparsed" };
+  }
+  const document = parsed;
+  const hooks = document.hooks !== null && typeof document.hooks === "object" && !Array.isArray(document.hooks) ? document.hooks : {};
+  const remaining = {};
+  let removed = 0;
+  let kept = 0;
+  for (const [hookEvent, value] of Object.entries(hooks)) {
+    const list = Array.isArray(value) ? value : [];
+    const foreign = list.filter((row) => !JSON.stringify(row ?? null).includes(marker));
+    removed += list.length - foreign.length;
+    if (foreign.length > 0) {
+      remaining[hookEvent] = foreign;
+      kept += foreign.length;
+    }
+  }
+  if (kept === 0) {
+    return { kind: "empty", removed };
+  }
+  return {
+    kind: "rewritten",
+    removed,
+    text: `${JSON.stringify({ ...document, hooks: remaining }, null, 2)}
+`
+  };
+}
+
+export { claudeWiring, mergeClaudeSettings, unmergeClaudeSettings, removeClaudeWiring, applyClaudeWiring, cursorWiring, cursorWiringProblems, formatWiringProblems, unwireCursorHooks };

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

@@ -0,0 +1,26 @@
+// src/platform/cli-output.ts
+var JSON_FLAG = "--json";
+function takeJsonFlag(args) {
+  const rest = [];
+  let json = false;
+  for (const arg of args) {
+    if (arg === JSON_FLAG) {
+      json = true;
+      continue;
+    }
+    rest.push(arg);
+  }
+  return { json, rest };
+}
+function emitJson(value, write = writeStdout) {
+  write(`${JSON.stringify(value)}
+`);
+}
+function writeStdout(text) {
+  process.stdout.write(text);
+}
+function unknownFlags(args) {
+  return args.filter((arg) => arg.startsWith("--"));
+}
+
+export { JSON_FLAG, takeJsonFlag, emitJson, unknownFlags };