@workit-dev/codex 0.0.0-stage → 1.0.0

package/dist/workit-hook-am9gge2k.js

@@ -0,0 +1,583 @@
+#!/usr/bin/env node
+import {
+  stateDir3
+} from "./workit-hook-6n3h8wh7.js";
+
+// packages/workit-core/src/core/heavy-words.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+
+// packages/workit-core/src/check-config.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import fs2 from "node:fs";
+import path2 from "node:path";
+
+// packages/workit-core/src/git/facts.ts
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+var cache = new Map;
+var revParse = (cwd, args) => {
+  const run = spawnSync("git", ["rev-parse", "--path-format=absolute", ...args], {
+    cwd,
+    encoding: "utf8",
+    timeout: 20000,
+    killSignal: "SIGKILL",
+    windowsHide: true
+  });
+  if (run.status !== 0)
+    return null;
+  const lines = (run.stdout ?? "").split(/\r?\n/u).filter(Boolean);
+  return lines.length === args.length ? lines : null;
+};
+var realOrNull = (file) => {
+  try {
+    return fs.realpathSync.native(file);
+  } catch {
+    return null;
+  }
+};
+var stillValid = (facts) => {
+  const gitDir = realOrNull(facts.gitDir);
+  if (!gitDir)
+    return false;
+  if (!facts.top)
+    return true;
+  const dotGit = path.join(facts.top, ".git");
+  let target = null;
+  try {
+    if (fs.statSync(dotGit).isDirectory())
+      target = dotGit;
+    else {
+      const match = /^gitdir:\s*(.+?)\s*$/mu.exec(fs.readFileSync(dotGit, "utf8"));
+      target = match ? path.resolve(facts.top, match[1]) : null;
+    }
+  } catch {
+    return false;
+  }
+  return target !== null && realOrNull(target) === gitDir;
+};
+function gitDirs(cwd) {
+  const key = path.resolve(cwd);
+  const hit = cache.get(key);
+  if (hit && stillValid(hit))
+    return hit;
+  cache.delete(key);
+  const full = revParse(key, ["--git-dir", "--git-common-dir", "--show-toplevel"]);
+  const dirs = full ?? revParse(key, ["--git-dir", "--git-common-dir"]);
+  if (!dirs)
+    return null;
+  const facts = { gitDir: dirs[0], commonDir: dirs[1], top: dirs[2] ?? null };
+  cache.set(key, facts);
+  return facts;
+}
+var callReads = null;
+function withinCall(fn) {
+  if (callReads)
+    return fn();
+  callReads = new Map;
+  try {
+    return fn();
+  } finally {
+    callReads = null;
+  }
+}
+function originUrl(cwd) {
+  const key = path.resolve(cwd);
+  if (callReads?.has(key))
+    return callReads.get(key) ?? null;
+  const run = spawnSync("git", ["remote", "get-url", "origin"], {
+    cwd,
+    encoding: "utf8",
+    timeout: 20000,
+    killSignal: "SIGKILL",
+    windowsHide: true
+  });
+  const url = run.status === 0 ? (run.stdout ?? "").trim() || null : null;
+  callReads?.set(key, url);
+  return url;
+}
+
+// packages/workit-core/src/check-config.ts
+var SCRIPT_CHECKS = ["test", "lint", "typecheck", "check"];
+var SCRIPT_CHECK_ALIASES = { packaging: "test:packaging" };
+var CHECKS_FILE = ".workit/checks.json";
+var LEGACY_CHECKS_FILE = "workit.checks.json";
+function checksConfigFile(root) {
+  const current = path2.join(root, CHECKS_FILE);
+  const legacy = path2.join(root, LEGACY_CHECKS_FILE);
+  return !fs2.existsSync(current) && fs2.existsSync(legacy) ? legacy : current;
+}
+var GENERATED_GITIGNORES = new Set([`*
+`, `*
+!risk-paths
+`]);
+function repoHeavyCommands(root) {
+  try {
+    const value = JSON.parse(fs2.readFileSync(checksConfigFile(root), "utf8"));
+    const resources = isRecord(value) ? value.resources : undefined;
+    const list = isRecord(resources) ? resources.heavyCommands : undefined;
+    return Array.isArray(list) ? list.filter((item) => typeof item === "string") : [];
+  } catch {
+    return [];
+  }
+}
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var SHELL_META = /[|&;<>()$`\\*?[\]{}~!#]/u;
+function splitCommand(command) {
+  const argv = [];
+  let current = "";
+  let quote = null;
+  let started = false;
+  for (const char of command) {
+    if (quote) {
+      if (char === quote)
+        quote = null;
+      else
+        current += char;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      started = true;
+      continue;
+    }
+    if (/\s/u.test(char)) {
+      if (started)
+        argv.push(current);
+      current = "";
+      started = false;
+      continue;
+    }
+    if (SHELL_META.test(char))
+      return new Error(`"${command}" uses shell syntax (${char}); configure an argv array instead`);
+    current += char;
+    started = true;
+  }
+  if (quote)
+    return new Error(`"${command}" has an unterminated quote`);
+  if (started)
+    argv.push(current);
+  return argv.length ? argv : new Error("empty command");
+}
+var git = (cwd, args) => {
+  const run = spawnSync2("git", args, {
+    cwd,
+    encoding: "utf8",
+    timeout: 20000,
+    killSignal: "SIGKILL",
+    windowsHide: true
+  });
+  const value = run.status === 0 ? (run.stdout ?? "").trim() : "";
+  return value || null;
+};
+function checkRoot(cwd) {
+  return path2.resolve(gitDirs(cwd)?.top ?? cwd);
+}
+var packageManager = (root) => {
+  const has = (file) => fs2.existsSync(path2.join(root, file));
+  if (has("bun.lock") || has("bun.lockb"))
+    return "bun";
+  if (has("pnpm-lock.yaml"))
+    return "pnpm";
+  if (has("yarn.lock"))
+    return "yarn";
+  return "npm";
+};
+var scriptCheck = (pm, name) => {
+  const argv = [pm, "run", name];
+  const accepts = [argv];
+  if (pm === "pnpm" || pm === "yarn" || pm === "npm" && name === "test")
+    accepts.push([pm, name]);
+  return { name, argv, accepts };
+};
+var CHECK_NAME = /^[a-z0-9][a-z0-9:._-]{0,63}$/u;
+function detectedChecks(root) {
+  const read = (file) => {
+    try {
+      return fs2.readFileSync(path2.join(root, file), "utf8");
+    } catch {
+      return null;
+    }
+  };
+  const checks = [];
+  const add = (check) => {
+    if (!checks.some((item) => item.name === check.name))
+      checks.push(check);
+  };
+  const manifestText = read("package.json");
+  if (manifestText !== null) {
+    let manifest = null;
+    try {
+      manifest = JSON.parse(manifestText);
+    } catch {}
+    const scripts = isRecord(manifest) && isRecord(manifest.scripts) ? manifest.scripts : {};
+    const pm = packageManager(root);
+    for (const name of SCRIPT_CHECKS) {
+      const script = scripts[name];
+      if (typeof script === "string" && script.trim() !== "")
+        add(scriptCheck(pm, name));
+    }
+    for (const [name, script] of Object.entries(SCRIPT_CHECK_ALIASES)) {
+      const body = scripts[script];
+      if (typeof body === "string" && body.trim() !== "")
+        add({ ...scriptCheck(pm, script), name });
+    }
+  }
+  const plain = (name, argv) => ({ name, argv, accepts: [argv] });
+  if (read("go.mod") !== null)
+    add(plain("test", ["go", "test", "./..."]));
+  if (read("Cargo.toml") !== null)
+    add(plain("test", ["cargo", "test"]));
+  if (read("pytest.ini") !== null || /\bpytest\b/u.test(read("pyproject.toml") ?? ""))
+    add(plain("test", ["pytest"]));
+  const makefile = read("Makefile") ?? read("makefile") ?? read("GNUmakefile");
+  if (makefile !== null && /^test\s*:(?!=)/mu.test(makefile))
+    add(plain("test", ["make", "test"]));
+  return checks;
+}
+var GATES = ["testing", "verification"];
+var UNSUPPORTED_GLOB = /[?[\]{}!\\]|[@+*]\(/u;
+var REGENERABLE_SHAPE = 'cleanup.regenerable must be a list of repo-relative globs (["packages/*/skills"])';
+function cleanupGlobs(value) {
+  if (value === undefined)
+    return [];
+  if (!isRecord(value))
+    return new Error('cleanup must be {"regenerable":["<glob>",…]}');
+  const unknown = Object.keys(value).find((key) => key !== "regenerable");
+  if (unknown)
+    return new Error(`cleanup.${unknown} is not a setting (use cleanup.regenerable)`);
+  const list = value.regenerable ?? [];
+  if (!Array.isArray(list))
+    return new Error(REGENERABLE_SHAPE);
+  const globs = [];
+  for (const item of list) {
+    if (typeof item !== "string")
+      return new Error(REGENERABLE_SHAPE);
+    const glob = item.trim().replace(/\/+$/u, "");
+    if (!glob || glob.startsWith("/") || glob.split("/").includes(".."))
+      return new Error(`${REGENERABLE_SHAPE}; "${item}" is not repo-relative`);
+    if (UNSUPPORTED_GLOB.test(glob))
+      return new Error(`${REGENERABLE_SHAPE}; "${item}" uses syntax beyond * and **`);
+    if (/^\*+$/u.test(glob.split("/").at(-1) ?? ""))
+      return new Error(`${REGENERABLE_SHAPE}; "${item}" ends in a bare wildcard, which would discard ignored files such as .env: name the generated dir`);
+    globs.push(glob);
+  }
+  return globs;
+}
+function configFileFor(root) {
+  const own = checksConfigFile(root);
+  if (fs2.existsSync(own))
+    return own;
+  const common = git(root, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+  if (!common || path2.basename(common) !== ".git")
+    return own;
+  const main = path2.dirname(common);
+  if (path2.resolve(main) === path2.resolve(root))
+    return own;
+  const shared = checksConfigFile(main);
+  return fs2.existsSync(shared) ? shared : own;
+}
+function loadCheckConfig(cwd) {
+  const root = checkRoot(cwd);
+  const file = configFileFor(root);
+  const legacy = path2.basename(file) === LEGACY_CHECKS_FILE;
+  const label = legacy ? LEGACY_CHECKS_FILE : CHECKS_FILE;
+  const note = legacy ? {
+    note: `${LEGACY_CHECKS_FILE} is deprecated; move it to ${CHECKS_FILE} (workit doctor --fix)`
+  } : {};
+  const none = (error = null) => ({
+    source: error ? label : "none",
+    root,
+    checks: [],
+    gates: {},
+    groups: {},
+    error,
+    ...note
+  });
+  let text = null;
+  try {
+    text = fs2.readFileSync(file, "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      return none(`cannot read ${label}: ${error.message}`);
+  }
+  if (text === null) {
+    const checks = detectedChecks(root);
+    return checks.length ? { source: "defaults", root, checks, gates: {}, groups: {}, error: null } : none();
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return none(`${label} is not valid JSON`);
+  }
+  if (!isRecord(parsed) || !isRecord(parsed.checks))
+    return none(`${label} must be {"checks":{"<name>":"<command>"|["argv",…]}}`);
+  const checks = [];
+  for (const [name, value] of Object.entries(parsed.checks)) {
+    if (!CHECK_NAME.test(name))
+      return none(`${label}: check name "${name}" must match ${CHECK_NAME.source}`);
+    const argv = typeof value === "string" ? splitCommand(value) : Array.isArray(value) && value.length > 0 && value.every((item) => typeof item === "string" && item.length > 0) ? value : new Error("expected a command string or a non-empty argv array");
+    if (argv instanceof Error)
+      return none(`${label}: check "${name}": ${argv.message}`);
+    checks.push({ name, argv, accepts: [argv] });
+  }
+  const gates = {};
+  if (parsed.gates !== undefined) {
+    if (!isRecord(parsed.gates))
+      return none(`${label}: gates must be {"testing":"<name>"|["<name>",…]}`);
+    for (const [gate, value] of Object.entries(parsed.gates)) {
+      if (!GATES.includes(gate))
+        return none(`${label}: unknown gate "${gate}" (use ${GATES.join(" or ")})`);
+      const names = typeof value === "string" ? [value] : value;
+      if (!Array.isArray(names) || names.length === 0 || !names.every((name) => typeof name === "string" && checks.some((c) => c.name === name)))
+        return none(`${label}: gates.${gate} must name configured checks`);
+      gates[gate] = names;
+    }
+  }
+  const groups = {};
+  if (parsed.groups !== undefined) {
+    if (!isRecord(parsed.groups))
+      return none(`${label}: groups must be {"ci":["<name>",…]}`);
+    for (const [group, value] of Object.entries(parsed.groups)) {
+      if (!CHECK_NAME.test(group))
+        return none(`${label}: group name "${group}" must match ${CHECK_NAME.source}`);
+      if (checks.some((c) => c.name === group))
+        return none(`${label}: group "${group}" has the name of a configured check`);
+      if (!Array.isArray(value) || value.length === 0 || !value.every((name) => typeof name === "string" && checks.some((c) => c.name === name)))
+        return none(`${label}: groups.${group} must be a non-empty list of configured checks`);
+      groups[group] = [...new Set(value)];
+    }
+  }
+  const regenerable = cleanupGlobs(parsed.cleanup);
+  if (regenerable instanceof Error)
+    return none(`${label}: ${regenerable.message}`);
+  return {
+    source: label,
+    root,
+    checks,
+    gates,
+    groups,
+    error: null,
+    ...note,
+    resources: parsed.resources,
+    regenerable
+  };
+}
+var sameArgv = (left, right) => left.length === right.length && left.every((item, index) => item === right[index]);
+function matchesNamedCheck(config, name, argv, cwd) {
+  if (config.error || name === null || cwd !== ".")
+    return false;
+  const check = config.checks.find((item) => item.name === name);
+  return Boolean(check?.accepts.some((accepted) => sameArgv(accepted, argv)));
+}
+function gateCheckNames(config, dimension) {
+  const explicit = config.gates[dimension];
+  if (explicit)
+    return explicit;
+  const names = config.checks.map((check) => check.name);
+  if (dimension === "testing")
+    return names.includes("test") ? ["test"] : [];
+  return names;
+}
+var workitOnPath;
+function workitAvailable(env = process.env) {
+  if (workitOnPath !== undefined)
+    return workitOnPath;
+  const windows = process.platform === "win32";
+  const exts = windows ? (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
+  const dirs = (env.PATH ?? env.Path ?? "").split(path2.delimiter).filter(Boolean);
+  workitOnPath = dirs.some((dir) => exts.some((ext) => {
+    try {
+      return fs2.statSync(path2.join(dir, `workit${ext}`)).isFile();
+    } catch {
+      return false;
+    }
+  }));
+  return workitOnPath;
+}
+function checkCommand(args, version, onPath = workitAvailable()) {
+  return onPath ? `workit check ${args}` : `npx -y @workit-dev/cli@${version} check ${args}`;
+}
+var only = (...names) => new Set(names);
+var FORMATTERS = {
+  oxfmt: "any",
+  prettier: "any",
+  dprint: only("fmt", "check"),
+  biome: only("format"),
+  black: "any",
+  isort: "any",
+  yapf: "any",
+  autopep8: "any",
+  ruff: only("format"),
+  gofmt: "any",
+  goimports: "any",
+  rustfmt: "any",
+  "clang-format": "any",
+  shfmt: "any",
+  stylua: "any",
+  taplo: only("fmt", "format"),
+  cargo: only("fmt"),
+  go: only("fmt"),
+  deno: only("fmt"),
+  mix: only("format"),
+  terraform: only("fmt"),
+  zig: only("fmt")
+};
+var FILE_LINTERS = {
+  eslint: "any",
+  oxlint: "any",
+  stylelint: "any",
+  tslint: "any",
+  biome: only("lint", "check"),
+  ruff: only("check"),
+  deno: only("lint"),
+  flake8: "any",
+  pylint: "any",
+  shellcheck: "any",
+  markdownlint: "any",
+  "markdownlint-cli2": "any",
+  hadolint: "any",
+  yamllint: "any",
+  actionlint: "any",
+  rubocop: "any"
+};
+var FORMAT_SCRIPT = /^(?:format|fmt|prettier)(?:$|[:_.-])/iu;
+var RUNNERS = new Set(["npx", "bunx", "pnpx"]);
+var PACKAGE_MANAGERS = new Set(["npm", "pnpm", "yarn", "bun"]);
+var PM_EXEC = new Set(["exec", "x", "dlx"]);
+var PM_RUN = new Set(["run", "run-script"]);
+var PYTHON_RUNNERS = new Set(["uv", "poetry", "pipenv", "pdm", "hatch", "rye"]);
+var toolName = (word) => (word?.split(/[\\/]/u).at(-1) ?? "").toLowerCase().replace(/\.(?:exe|cmd|bat|ps1)$/u, "");
+var firstPositional = (words, from) => {
+  let index = from;
+  while (index < words.length && words[index].startsWith("-")) {
+    if (words[index] === "--")
+      return index + 1;
+    index += 1;
+  }
+  return index;
+};
+function fileTarget(word, cwd) {
+  if (/[*?[\]{}]/u.test(word) || word.endsWith("/") || word.endsWith(path2.sep))
+    return false;
+  if (!/\.[A-Za-z0-9]+$/u.test(path2.basename(word)))
+    return false;
+  if (!cwd)
+    return true;
+  try {
+    return !fs2.statSync(path2.resolve(cwd, word)).isDirectory();
+  } catch {
+    return true;
+  }
+}
+var subcommandOf = (rule, words) => {
+  if (rule === "any")
+    return null;
+  const at = firstPositional(words, 1);
+  return rule.has(words[at] ?? "") ? words[at] : undefined;
+};
+function classify(words, cwd, depth) {
+  if (depth > 4 || !words.length)
+    return null;
+  const name = toolName(words[0]);
+  const inner = (from) => classify(words.slice(from), cwd, depth + 1);
+  if (RUNNERS.has(name))
+    return inner(firstPositional(words, 1));
+  if (PYTHON_RUNNERS.has(name) && words[firstPositional(words, 1)] === "run")
+    return inner(firstPositional(words, firstPositional(words, 1) + 1));
+  if (/^python[\d.]*$/u.test(name)) {
+    const at = words.indexOf("-m");
+    return at > 0 ? inner(at + 1) : null;
+  }
+  if (PACKAGE_MANAGERS.has(name)) {
+    const at = firstPositional(words, 1);
+    const command = words[at] ?? "";
+    if (PM_EXEC.has(command))
+      return inner(firstPositional(words, at + 1));
+    const script = PM_RUN.has(command) ? words[firstPositional(words, at + 1)] : command;
+    if (script && FORMAT_SCRIPT.test(script))
+      return {
+        kind: "formatter",
+        tool: `${name} ${script}`,
+        reason: `\`${name} ${PM_RUN.has(command) ? `${command} ` : ""}${script}\` only formats`
+      };
+    return name === "npm" || PM_RUN.has(command) ? null : inner(at);
+  }
+  const formatter = FORMATTERS[name];
+  if (formatter) {
+    const sub = subcommandOf(formatter, words);
+    if (sub !== undefined) {
+      const tool = sub ? `${name} ${sub}` : name;
+      return { kind: "formatter", tool, reason: `${tool} is a formatter` };
+    }
+  }
+  const linter = FILE_LINTERS[name];
+  if (!linter)
+    return null;
+  const sub = subcommandOf(linter, words);
+  if (sub === undefined)
+    return null;
+  const targets = words.slice(sub ? words.indexOf(sub) + 1 : 1).filter((word) => !word.startsWith("-") && !/^\d+$/u.test(word));
+  if (!targets.length || !targets.every((word) => fileTarget(word, cwd)))
+    return null;
+  const tool = sub ? `${name} ${sub}` : name;
+  return {
+    kind: "file-lint",
+    tool,
+    reason: `${tool} lints ${targets.length} named file${targets.length === 1 ? "" : "s"}`
+  };
+}
+function lightCommand(argv, cwd) {
+  return classify(argv, cwd, 0);
+}
+
+// packages/workit-core/src/core/heavy-words.ts
+var HEAVY_WORDS = new Set(("npm npx pnpm pnpx yarn bun bunx deno corepack make gmake docker podman nerdctl " + "python python3 py uv poetry pdm pipenv hatch rye bundle rake nx " + "jest vitest mocha ava tap karma jasmine nyc c8 tsc vue-tsc svelte-check eslint stylelint " + "tslint webpack webpack-cli rollup parcel tsup vite next nuxt nuxi astro ng react-scripts " + "playwright cypress wdio testcafe turbo lerna sonar-scanner sonarless sonarless-mcp go " + "golangci-lint gotestsum staticcheck cargo mvn mvnw gradle gradlew ant sbt bazel bazelisk " + "buck2 dotnet msbuild pytest py.test tox nox mypy pyright pylint coverage maturin pip pip3 " + "rspec rails phpunit pest phpstan psalm composer mix swift xcodebuild flutter dart pod cmake " + "ninja meson ctest scons docker-compose buildah earthly").split(" "));
+var wordsOf = (command) => command.split(/[\s;&|()<>`'"]+/u).map((word) => (word.split(/[\\/]/u).at(-1) ?? "").toLowerCase().replace(/\.(?:exe|cmd|bat)$/u, "")).filter(Boolean);
+var stateDir2 = (env) => stateDir3(env);
+var readJson = (file) => {
+  try {
+    return JSON.parse(fs3.readFileSync(file, "utf8"));
+  } catch {
+    return;
+  }
+};
+var patternWords = (cwd, env) => {
+  const patterns = [];
+  const machine = readJson(path3.join(stateDir2(env), "heavy-commands.json"));
+  if (Array.isArray(machine?.patterns))
+    patterns.push(...machine.patterns);
+  for (let dir = path3.resolve(cwd);; dir = path3.dirname(dir)) {
+    if (fs3.existsSync(path3.join(dir, ".git"))) {
+      patterns.push(...repoHeavyCommands(dir));
+      break;
+    }
+    if (path3.dirname(dir) === dir)
+      break;
+  }
+  const words = new Set;
+  for (const pattern of patterns) {
+    if (typeof pattern !== "string")
+      continue;
+    const first = wordsOf(pattern)[0];
+    if (!first || first.includes("*"))
+      return null;
+    words.add(first);
+  }
+  return words;
+};
+function maybeHeavy2(command, cwd, env = process.env) {
+  try {
+    const words = wordsOf(command);
+    if (words.some((word) => HEAVY_WORDS.has(word) || /^python[\d.]*$/u.test(word)))
+      return true;
+    const extra = patternWords(cwd, env);
+    return extra === null || words.some((word) => extra.has(word));
+  } catch {
+    return true;
+  }
+}
+
+export { gitDirs, withinCall, originUrl, CHECKS_FILE, repoHeavyCommands, loadCheckConfig, matchesNamedCheck, gateCheckNames, checkCommand, lightCommand, stateDir2, maybeHeavy2 };

package/dist/workit-hook-avy6vsn6.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import {
+  dataDir
+} from "./workit-hook-6n3h8wh7.js";
+
+// packages/workit-core/src/core/cli-locate.ts
+import { closeSync, existsSync, openSync, readSync } from "node:fs";
+import path from "node:path";
+var LAUNCHER_MARKER = "workit-owned-launcher";
+var CLI_PACKAGE_PATH = ["node_modules", "@workit-dev", "cli"];
+var installRoot = (env, platform = process.platform) => {
+  if (env.WORKIT_INSTALL_ROOT)
+    return env.WORKIT_INSTALL_ROOT;
+  const data = dataDir(env, platform);
+  return platform === "win32" ? path.join(data, "install") : data;
+};
+var ownedLauncherPath = (env, platform = process.platform) => path.join(installRoot(env, platform), "bin", platform === "win32" ? "workit.cmd" : "workit");
+var ownedCurrentEntry = (env, platform = process.platform) => path.join(installRoot(env, platform), "current", ...CLI_PACKAGE_PATH, "dist", "index.js");
+var head = (file) => {
+  let fd;
+  try {
+    fd = openSync(file, "r");
+    const buffer = Buffer.alloc(256);
+    const read = readSync(fd, buffer, 0, buffer.length, 0);
+    return buffer.subarray(0, read).toString("utf8");
+  } catch {
+    return "";
+  } finally {
+    if (fd !== undefined)
+      closeSync(fd);
+  }
+};
+var locateWorkitCli = (options = {}) => {
+  const env = options.env ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const exists = options.exists ?? existsSync;
+  const read = options.read ?? head;
+  const node = options.node ?? process.execPath;
+  const launcher = ownedLauncherPath(env, platform);
+  if (exists(launcher) && read(launcher).includes(LAUNCHER_MARKER))
+    return {
+      source: "owned-launcher",
+      command: launcher,
+      args: [],
+      binDir: path.dirname(launcher)
+    };
+  const current = ownedCurrentEntry(env, platform);
+  if (exists(current))
+    return {
+      source: "owned-current",
+      command: node,
+      args: [current],
+      binDir: null
+    };
+  if (options.bundled && exists(options.bundled))
+    return {
+      source: "bundled",
+      command: node,
+      args: [options.bundled],
+      binDir: null
+    };
+  return { source: "path", command: "workit", args: [], binDir: null };
+};
+var pathKey = (env) => Object.keys(env).find((key) => key.toUpperCase() === "PATH") ?? "PATH";
+var workitCliEnv = (located, env = process.env, platform = process.platform) => {
+  if (located.source === "path")
+    return {};
+  const patch = {
+    WORKIT_CLI: [located.command, ...located.args].join(" ")
+  };
+  if (located.binDir) {
+    const key = pathKey(env);
+    const delimiter = platform === "win32" ? ";" : ":";
+    const same = (dir) => platform === "win32" ? path.win32.normalize(dir).toLowerCase() === path.win32.normalize(located.binDir).toLowerCase() : path.posix.normalize(dir) === path.posix.normalize(located.binDir);
+    const rest = (env[key] ?? "").split(delimiter).filter((dir) => dir && !same(dir));
+    patch[key] = [located.binDir, ...rest].join(delimiter);
+  }
+  return patch;
+};
+var useOwnedWorkitCli = (options = {}) => {
+  const env = options.env ?? process.env;
+  const located = locateWorkitCli({ ...options, env });
+  Object.assign(env, workitCliEnv(located, env, options.platform));
+  return located;
+};
+export {
+  useOwnedWorkitCli
+};