@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-7OQ56DVW.js

@@ -1,239 +0,0 @@
-import {
-  run_cut_decline
-} from "./chunk-VQVPAVQ3.js";
-import {
-  run_cut_ready
-} from "./chunk-RS764ZMU.js";
-import {
-  cost_cli,
-  cost_verdict
-} from "./chunk-FVVZIJUC.js";
-import {
-  shell_segments
-} from "./chunk-CVJHQOI3.js";
-import {
-  run_cut,
-  run_cut_handoff
-} from "./chunk-DYZOOWVW.js";
-import {
-  agent_session_role
-} from "./chunk-U3IVVR4W.js";
-import {
-  lane_child_marker
-} from "./chunk-QAHFPCFR.js";
-import {
-  lane_paths
-} from "./chunk-YIA6FC3K.js";
-import {
-  agent_provider
-} from "./chunk-JQXPLMCO.js";
-import {
-  agent_session_environment
-} from "./chunk-HHBC6QZE.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/rules/implementation-cut.ts
-import path from "node:path";
-
-// scripts/rules/edit-tool.ts
-var EDIT = "Edit";
-var WRITE = "Write";
-var EDIT_TOOLS = /* @__PURE__ */ new Set([EDIT, WRITE]);
-function is_edit_tool(name) {
-  return EDIT_TOOLS.has(name);
-}
-function string_field(input, key) {
-  const value = input[key];
-  return typeof value === "string" ? value : "";
-}
-var edit_tool = {
-  EDIT,
-  WRITE,
-  is_edit_tool,
-  string_field
-};
-
-// scripts/rules/implementation-cut-verdict.ts
-import { z } from "zod";
-var VERDICT_CACHE_PREFIX = "josh-impl-cut-verdict-";
-var VERDICT_REUSE_MS = 5e3;
-var VERDICT_VALUES = [
-  "over",
-  "under",
-  "unmeasurable"
-];
-var cache_schema = z.object({ read_at_ms: z.number(), verdict: z.enum(VERDICT_VALUES) });
-function cache_path(directory) {
-  return stamp_file.stamp_path(VERDICT_CACHE_PREFIX, directory);
-}
-function cached_verdict(target, now_ms) {
-  const raw = stamp_file.read_stamp_text(target);
-  if (raw === void 0) return void 0;
-  const cached = json_value.parse_with(raw, cache_schema);
-  if (cached === void 0) return void 0;
-  return now_ms - cached.read_at_ms < VERDICT_REUSE_MS ? cached.verdict : void 0;
-}
-function reused_verdict(read, directory, now_ms = Date.now()) {
-  const target = cache_path(directory);
-  const cached = cached_verdict(target, now_ms);
-  if (cached !== void 0) return cached;
-  const value = read();
-  stamp_file.replace_stamp(target, { read_at_ms: now_ms, verdict: value });
-  return value;
-}
-var implementation_cut_verdict = {
-  VERDICT_REUSE_MS,
-  cache_path,
-  reused_verdict
-};
-
-// scripts/rules/implementation-cut.ts
-var { is_edit_tool: is_edit_tool2 } = edit_tool;
-var CUT_COMMANDS = /* @__PURE__ */ new Set(["run:cut"]);
-var IMPL_FLAG = /(?:^|\s)--impl(?:[=\s]|$)/u;
-var RESUME_FLAG = /(?:^|\s)--resume(?:[=\s]|$)/u;
-function calls_cut_with(command, flag) {
-  return shell_segments.segments_of(command).some((segment) => shell_segments.is_josh_command(segment, CUT_COMMANDS) && flag.test(segment));
-}
-function takes_the_impl_cut(command) {
-  return calls_cut_with(command, IMPL_FLAG);
-}
-function resumes_a_cut(command) {
-  return calls_cut_with(command, RESUME_FLAG);
-}
-function can_cut_sync(issue, cwd) {
-  const directory = run_cut.worktree_git_directory_sync(cwd);
-  if (run_cut_decline.is_declined_sync(issue, directory)) return false;
-  return run_cut_ready.is_ready_sync(() => run_cut_ready.read_tree_sync(cwd));
-}
-function is_named(value) {
-  return value !== void 0 && value !== "";
-}
-function environment_for(transcript, source) {
-  if (agent_provider.resolve_provider(source).kind === "rejected" || is_named(source[agent_provider.CODEX_SESSION_KEY]) || is_named(source[agent_session_environment.SESSION_ID_KEY])) {
-    return source;
-  }
-  return {
-    ...source,
-    [agent_session_environment.SESSION_ID_KEY]: path.basename(transcript, ".jsonl")
-  };
-}
-function session_verdict(transcript, directory, source) {
-  return implementation_cut_verdict.reused_verdict(
-    () => cost_cli.session_verdict(directory, environment_for(transcript, source)),
-    transcript
-  );
-}
-function current_state(context, transcript) {
-  const { cwd, env } = context;
-  return {
-    directory: cwd,
-    source: env,
-    // The cut record and the run hold of the call's own work tree.
-    carried: (now) => run_cut.carried_cut_sync(now, run_cut.worktree_git_directory_sync(cwd)),
-    held_issue: () => run_cut.held_issue_sync(run_cut.worktree_git_directory_sync(cwd)),
-    // **Read through the short reuse window**. The row now fires per
-    // threshold crossing rather than once per run, so this predicate is a candidate on every edit;
-    // the window collapses one turn's burst of edits to a single whole-transcript price.
-    verdict: () => transcript === void 0 ? implementation_cut_verdict.reused_verdict(() => cost_cli.session_verdict(cwd, env), cwd) : session_verdict(transcript, cwd, env),
-    can_cut: (issue) => can_cut_sync(issue, cwd)
-  };
-}
-function lane_child_issue(state) {
-  if (!lane_child_marker.is_child_of(state.directory, state.source)) return void 0;
-  return lane_paths.lane_issue_of(state.directory, { ...state.source });
-}
-function held_run_issue(state) {
-  if (lane_paths.lane_issue_of(state.directory, { ...state.source }) !== void 0) return void 0;
-  return state.held_issue();
-}
-function implementing_run_issue(state) {
-  if (agent_session_role.is_reviewer(state.source)) return void 0;
-  return lane_child_issue(state) ?? held_run_issue(state);
-}
-function uncut_run_issue(state) {
-  const issue = implementing_run_issue(state);
-  if (issue === void 0) return void 0;
-  return state.carried()?.issue === issue ? void 0 : issue;
-}
-function file_path_of(call) {
-  if (!json_value.is_record(call.input)) return "";
-  const value = call.input["file_path"];
-  return typeof value === "string" ? value : "";
-}
-function is_handoff_write(call, directory, issue) {
-  const handoff = path.resolve(directory, run_cut_handoff.handoff_path_of(issue));
-  return path.resolve(directory, file_path_of(call)) === handoff;
-}
-function refusable_issue(call, state) {
-  const issue = uncut_run_issue(state);
-  if (issue === void 0) return void 0;
-  return is_handoff_write(call, state.directory, issue) ? void 0 : issue;
-}
-function warrants_the_cut(state) {
-  return state.verdict() === cost_verdict.OVER_VERDICT;
-}
-function is_over_threshold_edit(call, state) {
-  if (!is_edit_tool2(call.name)) return false;
-  const issue = refusable_issue(call, state);
-  if (issue === void 0) return false;
-  return warrants_the_cut(state) && state.can_cut(issue);
-}
-var THRESHOLD_TEXT = "`pnpm josh cost --cut`";
-var IMPLEMENTATION_CUT_REASON = `\u26D4 implementation-phase cut: refused on every edit over ${THRESHOLD_TEXT}. Write \`${run_cut_handoff.HANDOFF_PATH}\`: ${run_cut_handoff.HANDOFF_FORMAT}, run \`pnpm josh run:cut --impl <N> --handoff <path>\`; \`cut\`: end the turn immediately, no Telegram is owed; else reissue the edit (\`.claude/skills/workflow-commands/pre-gate-cut.md\`).`;
-var REISSUE_WINDOW_MS = 9e4;
-function is_reissued_refusal(now_ms, delivered_at_ms) {
-  return now_ms - delivered_at_ms < REISSUE_WINDOW_MS;
-}
-function decide(_call, run, _can_record, delivered_at_ms) {
-  return !is_reissued_refusal(run.now_ms, delivered_at_ms);
-}
-function decide_for_session(call, run, can_record, delivered_at_ms) {
-  return decide(call, run, can_record, delivered_at_ms) && is_over_threshold_edit(call, current_state(run.context, run.transcript));
-}
-function is_refusable_edit(call, state) {
-  return is_edit_tool2(call.name) && refusable_issue(call, state) !== void 0;
-}
-function is_refusable_edit_in(call, context) {
-  return is_refusable_edit(call, current_state(context));
-}
-var ROW = {
-  id: "implementation-cut",
-  is_trigger: is_refusable_edit_in,
-  reason: IMPLEMENTATION_CUT_REASON,
-  decide: decide_for_session,
-  // The opening the reason carried before it was cut to the action and the next command.
-  former_reasons: [
-    "\u26D4 implementation-phase cut: this checkout is a lane dispatched",
-    "\u26D4 implementation-phase cut: this run's context crossed the"
-  ],
-  about: {
-    title: "The implementation-phase cut",
-    topic: '`.claude/skills/workflow-commands/pre-gate-cut.md` \u2192 "It is a guard, fired at the edit that crosses the threshold"',
-    fires: "an `Edit` / `Write` by an uncut lane child whose recent context is over the `pnpm josh cost --cut` threshold; it hands over `pnpm josh run:cut --impl <N> --handoff <path>`. At each threshold crossing",
-    quiet: "not a lane child, a non-editing tool, the run's own handoff file, already cut, or under the threshold"
-  }
-};
-var implementation_cut = {
-  IMPLEMENTATION_CUT_REASON,
-  REISSUE_WINDOW_MS,
-  ROW,
-  decide,
-  is_over_threshold_edit,
-  is_reissued_refusal,
-  resumes_a_cut,
-  session_verdict,
-  takes_the_impl_cut,
-  uncut_run_issue
-};
-
-export {
-  edit_tool,
-  implementation_cut_verdict,
-  implementation_cut
-};

package/dist/commands/chunk-7VWPGTZO.js

@@ -1,260 +0,0 @@
-import {
-  lane_cache_run
-} from "./chunk-BRUBX64M.js";
-import {
-  lint_timing
-} from "./chunk-VGPIQNDB.js";
-import {
-  eslint_cache_dependencies
-} from "./chunk-4DVM57T7.js";
-import {
-  eslint_daemon
-} from "./chunk-KTV2HNWB.js";
-import {
-  verification_inputs
-} from "./chunk-34KZDKQJ.js";
-import {
-  lint_related_scope
-} from "./chunk-OOWGH2RG.js";
-import {
-  changed_file_scope
-} from "./chunk-7LJQMM2K.js";
-import {
-  lint_shard
-} from "./chunk-ZECFKW7D.js";
-import {
-  project_checks
-} from "./chunk-JM6EVOFN.js";
-import {
-  SKIP_MARKER
-} from "./chunk-IW6NWCSN.js";
-import {
-  gate_labels
-} from "./chunk-WQ6FS544.js";
-import {
-  ESLINT_CACHE_FILE,
-  ESLINT_CACHE_FLAGS,
-  PRETTIER_CACHE_FLAGS
-} from "./chunk-TBIX5FRN.js";
-import {
-  eslint_heap
-} from "./chunk-CGYDIYHD.js";
-import {
-  FAIL_EXIT_CODE,
-  buffered_process
-} from "./chunk-JZHY7D6D.js";
-
-// scripts/lint/lint-parallel.ts
-import { existsSync as existsSync2 } from "node:fs";
-
-// scripts/lint/lint-gate-scope.ts
-import { existsSync } from "node:fs";
-import path from "node:path";
-import { environment_flags } from "@joshuafolkken/kit/env";
-var GATE_CACHES = {
-  eslint_file: ESLINT_CACHE_FILE,
-  eslint_flags: ESLINT_CACHE_FLAGS,
-  prettier_flags: PRETTIER_CACHE_FLAGS
-};
-var CI_REASON = "CI lints the whole tree";
-var CONFIG_REASON = "a changed file configures the toolchain or the linters";
-var VOCABULARY = {
-  label: "josh lint --changed",
-  fallback_suffix: "checking the whole tree instead",
-  narrowed_suffix: "checking only them"
-};
-function all_scope(reason) {
-  return { mode: "all", files: [], reason };
-}
-function configures_lint(files, root) {
-  return verification_inputs.configures(
-    gate_labels.LINT_LABEL,
-    files.map((file) => path.relative(root, file).split(path.sep).join("/")),
-    root
-  );
-}
-function resolve_gate_scope(files, root, environment) {
-  if (environment_flags.is_ci_enabled(environment["CI"])) return all_scope(CI_REASON);
-  if (files !== void 0 && configures_lint(files, root)) return all_scope(CONFIG_REASON);
-  return changed_file_scope.resolve_scope(files, lint_related_scope.scope_inputs(existsSync));
-}
-function narrowed_run(files) {
-  return {
-    prettier: lint_related_scope.prettier_arguments(files, GATE_CACHES),
-    eslint: lint_related_scope.eslint_arguments(files, GATE_CACHES),
-    eslint_cache_file: GATE_CACHES.eslint_file
-  };
-}
-function describe_scope(scope, root) {
-  return changed_file_scope.describe_scope(scope, root, VOCABULARY);
-}
-var lint_gate_scope = {
-  CHANGED_FLAG: "--changed",
-  CI_REASON,
-  CONFIG_REASON,
-  describe_scope,
-  narrowed_run,
-  resolve_gate_scope
-};
-
-// scripts/lint/lint-parallel.ts
-function eslint_args_of(shard) {
-  return ["exec", "eslint", ...lint_shard.eslint_targets(shard), ...ESLINT_CACHE_FLAGS];
-}
-var ESLINT_ARGS = eslint_args_of(void 0);
-function prettier_check_args(targets) {
-  return ["exec", "prettier", "--check", ...targets, ...PRETTIER_CACHE_FLAGS];
-}
-var PRETTIER_ARGS = prettier_check_args([lint_shard.WHOLE_TREE]);
-function project_prettier_args() {
-  return prettier_check_args(
-    project_checks.prettier_targets(process.cwd(), [lint_shard.WHOLE_TREE])
-  );
-}
-var LEFT_TO_FORMATTING_SHARD = {
-  output: `josh prettier: ${lint_shard.FORMATTING_SHARD_REASON}.
-`,
-  exit_code: 0,
-  elapsed_ms: 0
-};
-function prettier_args_of(shard) {
-  return lint_shard.checks_formatting(shard) ? project_prettier_args() : void 0;
-}
-var GATE_TIMING_LABEL = "lint";
-var COLD_RUN = { warm_daemon: false };
-async function run_eslint_process(eslint) {
-  if (eslint.warm_daemon) return await eslint_daemon.run_or_cold(eslint.args, eslint.call);
-  return await eslint_heap.run_cold(eslint.args);
-}
-async function run_eslint(eslint) {
-  const { cache_file } = eslint;
-  return await lane_cache_run.run(cache_file, async () => {
-    const is_cached = existsSync2(cache_file);
-    const { result, drop } = await eslint_cache_dependencies.guard_counted(
-      cache_file,
-      async () => await run_eslint_process(eslint)
-    );
-    return { ...result, is_cached, drop };
-  });
-}
-function write_output(result) {
-  const { output } = result;
-  if (!output) return;
-  process.stdout.write(output.endsWith("\n") ? output : `${output}
-`);
-}
-function skipped(check, reason) {
-  return { output: `${project_checks.skip_notice(check, reason)}
-`, exit_code: 0, elapsed_ms: 0 };
-}
-async function run_prettier(directory, prettier_args) {
-  if (prettier_args === void 0) return LEFT_TO_FORMATTING_SHARD;
-  const reason = project_checks.prettier_skip_reason(directory);
-  if (reason !== void 0) return skipped("prettier", reason);
-  return await buffered_process.run_buffered_direct(prettier_args);
-}
-async function run_checked_eslint(directory, eslint) {
-  const reason = project_checks.eslint_skip_reason(directory);
-  if (reason !== void 0) return skipped("eslint", reason);
-  return await run_eslint(eslint);
-}
-function is_silent_pass(result) {
-  return result.output === "" && !buffered_process.is_process_failed(result);
-}
-function with_ran_notice(check, result, sibling) {
-  if (!sibling.output.includes(SKIP_MARKER) || !is_silent_pass(result)) return result;
-  return { ...result, output: `${project_checks.ran_notice(check)}
-` };
-}
-function lint_exit_code(prettier, eslint) {
-  return buffered_process.is_process_failed(prettier) || buffered_process.is_process_failed(eslint) ? FAIL_EXIT_CODE : 0;
-}
-async function run_lint_pair(prettier_args, eslint_args, cache_file, options) {
-  const directory = process.cwd();
-  const [prettier, eslint] = await Promise.all([
-    run_prettier(directory, prettier_args),
-    run_checked_eslint(directory, { args: eslint_args, cache_file, ...options })
-  ]);
-  return { prettier, eslint };
-}
-function write_lint_pair({ prettier, eslint }) {
-  write_output(with_ran_notice("prettier", prettier, eslint));
-  write_output(with_ran_notice("eslint", eslint, prettier));
-  return lint_exit_code(prettier, eslint);
-}
-function timing_line(pair, label, facts) {
-  const { prettier, eslint } = pair;
-  return lint_timing.line({
-    label,
-    prettier_ms: prettier.elapsed_ms,
-    eslint_ms: eslint.elapsed_ms,
-    facts
-  });
-}
-function daemon_fact(eslint) {
-  return eslint.daemon ?? "cold process";
-}
-function drop_fact({ dropped, total }) {
-  return `${String(dropped)} of ${String(total)} cache entries dropped`;
-}
-function cache_fact(eslint) {
-  if (eslint.is_cached !== true) return "cache absent";
-  return eslint.drop === void 0 ? "cache present" : `cache present \xB7 ${drop_fact(eslint.drop)}`;
-}
-async function run_lint_checks(prettier_args, eslint_args, cache_file, options = COLD_RUN) {
-  const { timing } = options;
-  if (timing === void 0) {
-    return write_lint_pair(await run_lint_pair(prettier_args, eslint_args, cache_file, options));
-  }
-  const pair = await run_lint_pair(prettier_args, eslint_args, cache_file, options);
-  const exit_code = write_lint_pair(pair);
-  const facts = [timing.targets, daemon_fact(pair.eslint), cache_fact(pair.eslint)];
-  process.stdout.write(timing_line(pair, timing.label, facts));
-  return exit_code;
-}
-async function run_timed_lint_checks(prettier_args, eslint_args, cache_file) {
-  const pair = await run_lint_pair(prettier_args, eslint_args, cache_file, COLD_RUN);
-  const exit_code = write_lint_pair(pair);
-  process.stdout.write(timing_line(pair, GATE_TIMING_LABEL, [cache_fact(pair.eslint)]));
-  return exit_code;
-}
-async function run_lint_parallel_checks(options = COLD_RUN) {
-  return await run_lint_checks(project_prettier_args(), ESLINT_ARGS, ESLINT_CACHE_FILE, options);
-}
-async function run_whole_lint_checks(scope_line, shard) {
-  process.stdout.write(`${scope_line}${lint_shard.describe(shard)}
-`);
-  return await run_timed_lint_checks(
-    prettier_args_of(shard),
-    eslint_args_of(shard),
-    ESLINT_CACHE_FILE
-  );
-}
-async function run_changed_lint_checks(shard) {
-  const root = await changed_file_scope.repository_root_or_cwd();
-  const files = await changed_file_scope.read_changed_files(root);
-  const scope = lint_gate_scope.resolve_gate_scope(files, root, process.env);
-  const scope_line = lint_gate_scope.describe_scope(scope, root);
-  if (scope.mode === "all") return await run_whole_lint_checks(scope_line, shard);
-  process.stdout.write(`${scope_line}
-`);
-  const narrowed = lint_gate_scope.narrowed_run(scope.files);
-  return await run_timed_lint_checks(narrowed.prettier, narrowed.eslint, narrowed.eslint_cache_file);
-}
-async function run_lint_command(command_arguments) {
-  const shard = lint_shard.shard_of(command_arguments);
-  if (command_arguments.includes(lint_gate_scope.CHANGED_FLAG)) {
-    return await run_changed_lint_checks(shard);
-  }
-  return await run_lint_checks(prettier_args_of(shard), eslint_args_of(shard), ESLINT_CACHE_FILE);
-}
-var lint_parallel = {
-  run_eslint,
-  run_lint_checks,
-  run_lint_command,
-  run_lint_parallel_checks
-};
-
-export {
-  lint_parallel
-};

package/dist/commands/chunk-7YZXS3AK.js

@@ -1,30 +0,0 @@
-import {
-  review_brief
-} from "./chunk-EKLU6QR7.js";
-import {
-  review_stamps
-} from "./chunk-MVHPRYHE.js";
-import {
-  gate_tree
-} from "./chunk-NFPD2P3V.js";
-
-// scripts/test/test-e2e-stamp.ts
-function record(tree, target) {
-  try {
-    review_stamps.e2e_stamp.write(tree.files, target, tree.base);
-  } catch {
-  }
-}
-function is_current(tree, source) {
-  if (tree.base === void 0) return false;
-  const stamp = review_brief.matching_stamp(review_stamps.e2e_stamp.read(source), tree.files);
-  return stamp?.base === tree.base;
-}
-async function is_current_tree() {
-  return is_current(await gate_tree.read_gate_tree());
-}
-var test_e2e_stamp = { is_current, is_current_tree, record };
-
-export {
-  test_e2e_stamp
-};

package/dist/commands/chunk-A4HOQKOG.js

@@ -1,85 +0,0 @@
-import {
-  git_grep_hits
-} from "./chunk-T25S4QHL.js";
-import {
-  git_spawn
-} from "./chunk-CJKPF5DJ.js";
-
-// scripts/run/run-prep-locate.ts
-var BACKTICKED = /`([^`\n]+)`/gu;
-var JOSH_PREFIX = /^(?:pnpm\s+)?josh\s+(\S+)/u;
-var LINE_SUFFIX = /(?::\d+)+$/u;
-var NAME_CHARACTERS = /^[\w@./:-]+$/u;
-var NAME_SEPARATOR = /[./:_-]/u;
-var MIN_TARGET_LENGTH = 3;
-var MAX_TARGETS = 10;
-var MAX_FILES_PER_TARGET = 3;
-var INDENT = "  ";
-var HIT_SEPARATOR = "  ";
-var NO_MATCH = " \u2014 no match in code";
-var SEARCH_FAILED = " \u2014 git grep failed; not searched";
-var FILE_PATHSPEC = ":(glob)**/";
-var FILE_HIT = { line: "1", excerpt: "(file named in the issue)" };
-var NO_TARGETS = "(no backticked path or identifier in the issue)";
-var CODE_PATHS = [
-  "*.ts",
-  "*.js",
-  "*.svelte",
-  ":(exclude)*.test.ts",
-  ":(exclude)*.e2e.ts",
-  ":(exclude)*.snap"
-];
-function to_target(span) {
-  const josh = JOSH_PREFIX.exec(span);
-  return josh?.[1] ?? span.trim().replace(LINE_SUFFIX, "");
-}
-function is_name(target) {
-  if (target.length < MIN_TARGET_LENGTH || target.includes("://")) return false;
-  return NAME_CHARACTERS.test(target) && NAME_SEPARATOR.test(target);
-}
-function names_of(text) {
-  const targets = [...text.matchAll(BACKTICKED)].map((match) => to_target(match[1] ?? ""));
-  return [...new Set(targets.filter((target) => is_name(target)))];
-}
-function extract_targets(text) {
-  return names_of(text).slice(0, MAX_TARGETS);
-}
-function format_target(located) {
-  if (located.has_failed) return `${located.target}${SEARCH_FAILED}`;
-  if (located.hits.length === 0) return `${located.target}${NO_MATCH}`;
-  const lines = located.hits.map(
-    (hit) => `${INDENT}${hit.path}:${hit.line}${HIT_SEPARATOR}${hit.excerpt}`
-  );
-  return [located.target, ...lines].join("\n");
-}
-function format_locations(located) {
-  if (located.length === 0) return NO_TARGETS;
-  return located.map((entry) => format_target(entry)).join("\n");
-}
-async function grep(target) {
-  const { hits, has_failed } = await git_grep_hits.search(target, ["-m", "1"], CODE_PATHS);
-  return { target, hits: hits.slice(0, MAX_FILES_PER_TARGET), has_failed };
-}
-async function find_files(target) {
-  try {
-    const stdout = await git_spawn.read(["ls-files", "--", `${FILE_PATHSPEC}${target}`]);
-    const paths = stdout.split("\n").filter((path) => path !== "");
-    return paths.slice(0, MAX_FILES_PER_TARGET).map((path) => ({ path, ...FILE_HIT }));
-  } catch {
-    return [];
-  }
-}
-async function find(target) {
-  const files = await find_files(target);
-  if (files.length > 0) return { target, hits: files, has_failed: false };
-  return await grep(target);
-}
-async function locate(text) {
-  const located = await Promise.all(extract_targets(text).map(async (target) => await find(target)));
-  return format_locations(located);
-}
-var run_prep_locate = { extract_targets, locate, names_of };
-
-export {
-  run_prep_locate
-};