@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-B636LL4X.js

@@ -0,0 +1,239 @@
+import {
+  run_cut_decline
+} from "./chunk-EHVFQQO6.js";
+import {
+  run_cut_ready
+} from "./chunk-5ZMVRU3U.js";
+import {
+  cost_cli,
+  cost_verdict
+} from "./chunk-JEYITIWB.js";
+import {
+  shell_segments
+} from "./chunk-CVJHQOI3.js";
+import {
+  run_cut,
+  run_cut_handoff
+} from "./chunk-OTCWA4QE.js";
+import {
+  agent_session_role
+} from "./chunk-DURHGVRC.js";
+import {
+  agent_provider
+} from "./chunk-DDZVMXZD.js";
+import {
+  agent_session_environment
+} from "./chunk-HHBC6QZE.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.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-B762PNT6.js

@@ -0,0 +1,66 @@
+import {
+  git_gh_blocked_by_graphql
+} from "./chunk-B7UY7EOD.js";
+import {
+  git_gh_issue_graphql
+} from "./chunk-U6SMBYTN.js";
+import {
+  git_gh_transport
+} from "./chunk-W4R6ZBLO.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/gh/git-gh-issue-alias-graphql.ts
+import { z } from "zod";
+var ALIAS_PREFIX = "issue";
+var rate_limit_schema = z.object({ cost: z.number(), remaining: z.number() });
+function alias_of(issue_number) {
+  return `${ALIAS_PREFIX}${String(issue_number)}`;
+}
+function query_of(issue_numbers, fields) {
+  const aliases = issue_numbers.map(
+    (issue_number) => `${alias_of(issue_number)}: issue(number: ${String(issue_number)}) { ${fields} }`
+  );
+  return `query($owner: String!, $name: String!) {
+	rateLimit { cost remaining }
+	repository(owner: $owner, name: $name) { ${aliases.join("\n")} }
+}`;
+}
+function response_schema_of(issue_schema) {
+  const repository_schema = z.record(z.string(), issue_schema.nullable());
+  const data_schema = z.looseObject({ rateLimit: rate_limit_schema, repository: repository_schema });
+  return z.looseObject({ data: data_schema });
+}
+async function query_chunk(issue_numbers, fields, issue_schema, variables) {
+  const json = await git_gh_transport.query({ query: query_of(issue_numbers, fields), variables });
+  if (json === void 0) return void 0;
+  return json_value.parse_with(json, response_schema_of(issue_schema))?.data;
+}
+function with_chunk(read, issue_numbers, data) {
+  if (data === void 0) return read;
+  const answered = issue_numbers.flatMap((issue_number) => {
+    const issue = data.repository[alias_of(issue_number)];
+    return issue === void 0 || issue === null ? [] : [[issue_number, issue]];
+  });
+  return {
+    answers: new Map([...read.answers, ...answered]),
+    cost: read.cost + data.rateLimit.cost,
+    remaining: data.rateLimit.remaining
+  };
+}
+async function read_aliased(issue_numbers, fields, issue_schema, repo) {
+  const variables = issue_numbers.length === 0 ? void 0 : git_gh_issue_graphql.repository_variables_of(repo);
+  let read = { answers: /* @__PURE__ */ new Map(), cost: 0, remaining: void 0 };
+  if (variables === void 0) return read;
+  const chunks = git_gh_blocked_by_graphql.chunks_of([...new Set(issue_numbers)]);
+  for (const chunk of chunks) {
+    read = with_chunk(read, chunk, await query_chunk(chunk, fields, issue_schema, variables));
+  }
+  return read;
+}
+var git_gh_issue_alias_graphql = { read_aliased };
+
+export {
+  git_gh_issue_alias_graphql
+};

package/dist/commands/chunk-B7UY7EOD.js

@@ -0,0 +1,72 @@
+import {
+  BLOCKER,
+  PAGE,
+  blocker_node_schema,
+  git_gh_issue_graphql,
+  git_gh_issue_rest
+} from "./chunk-U6SMBYTN.js";
+import {
+  git_gh_transport
+} from "./chunk-W4R6ZBLO.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/gh/git-gh-blocked-by-graphql.ts
+import { z } from "zod";
+var IDS_PER_QUERY = 100;
+var BLOCKED_BY_QUERY = `query($ids: [ID!]!) {
+	nodes(ids: $ids) { ... on Issue { id blockedBy(${PAGE}) { nodes { ${BLOCKER} } } } }
+}`;
+var issue_node_schema = z.object({
+  id: z.string(),
+  blockedBy: z.object({ nodes: z.array(blocker_node_schema) })
+});
+var nodes_schema = z.array(issue_node_schema.nullable());
+var response_schema = z.looseObject({ data: z.looseObject({ nodes: nodes_schema }) });
+function needs_read(row) {
+  if (row.node_id === void 0 || git_gh_issue_rest.is_pull_request(row)) return false;
+  return git_gh_issue_rest.total_blocked_by(row) !== 0;
+}
+function chunks_of(items) {
+  const chunks = [];
+  for (let start = 0; start < items.length; start += IDS_PER_QUERY) {
+    chunks.push(items.slice(start, start + IDS_PER_QUERY));
+  }
+  return chunks;
+}
+function to_blocked_by(row, node) {
+  const nodes = node.blockedBy.nodes.map(
+    (blocker) => git_gh_issue_graphql.to_blocking_issue(blocker)
+  );
+  return { nodes, totalCount: git_gh_issue_rest.total_blocked_by(row) ?? nodes.length };
+}
+async function query_nodes(ids) {
+  const json = await git_gh_transport.query({ query: BLOCKED_BY_QUERY, variables: { ids } });
+  if (json === void 0) return [];
+  return json_value.parse_with(json, response_schema)?.data.nodes ?? [];
+}
+function index_by_id(nodes) {
+  const resolved = nodes.filter((node) => node !== null);
+  return new Map(resolved.map((node) => [node.id, node]));
+}
+async function read_chunk(rows, answered) {
+  const by_id = index_by_id(await query_nodes(rows.map((row) => row.node_id)));
+  for (const row of rows) {
+    const node = by_id.get(row.node_id);
+    if (node !== void 0) answered.set(row, to_blocked_by(row, node));
+  }
+}
+async function read_answered(rows) {
+  const answered = /* @__PURE__ */ new Map();
+  const chunks = chunks_of(rows.filter((row) => needs_read(row)));
+  for (const chunk of chunks) {
+    await read_chunk(chunk, answered);
+  }
+  return answered;
+}
+var git_gh_blocked_by_graphql = { chunks_of, read_answered };
+
+export {
+  git_gh_blocked_by_graphql
+};

package/dist/commands/chunk-BAJABWKW.js

@@ -0,0 +1,43 @@
+import {
+  format_dependency_links
+} from "./chunk-2ADQ5XRD.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+
+// scripts/epic/epic-relations.ts
+async function apply_one(link, action) {
+  const blocked = String(link.blocked);
+  const blocker = String(link.blocker);
+  return action === "record" ? await git_gh_command.issue_add_blocked_by(blocked, blocker) : await git_gh_command.issue_remove_blocked_by(blocked, blocker);
+}
+async function apply_relations(links, action) {
+  if (links.length === 0) return 0;
+  const applied = await Promise.all(links.map(async (link) => await apply_one(link, action)));
+  return applied.filter((is_applied) => !is_applied).length;
+}
+function describe_action(action) {
+  return action === "record" ? "recorded" : "removed";
+}
+function format_relation_report(input) {
+  const verb = describe_action(input.action);
+  const total = String(input.links.length);
+  if (input.links.length === 0) return `\u{1F517} No blocked-by relation was ${verb}.`;
+  if (input.failures === 0) {
+    return session_cite.text(
+      `\u{1F517} ${total} blocked-by relation(s) ${verb}: ${format_dependency_links(input.links)}.`
+    );
+  }
+  return `\u26A0\uFE0F  ${String(input.failures)} of ${total} blocked-by relation(s) could not be ${verb}; the epic body is intact.`;
+}
+var epic_relations = {
+  apply_relations,
+  format_relation_report
+};
+
+export {
+  epic_relations
+};

package/dist/commands/chunk-BAQRD3TC.js

@@ -0,0 +1,105 @@
+import {
+  lane_session_broker
+} from "./chunk-XDWCF4XH.js";
+import {
+  run_ship_review
+} from "./chunk-ILQU26IF.js";
+import {
+  review_attest
+} from "./chunk-37RULO76.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/review/review-record-slot.ts
+var FAILURE_EXIT_CODE = 1;
+var FROM_SLOT = "--from-slot";
+var DEFAULT_DISPOSITION = "fixed";
+var OVERRIDE_PATTERN = /^(?<line>[1-9]\d*)=(?<disposition>\S.*)$/u;
+var USAGE = `Usage: josh review:record ${FROM_SLOT} --issue <N> [--interaction | --comment] [<n>=<disposition> ...]`;
+var OPTIONS = {
+  issue: { type: "string" },
+  interaction: { type: "boolean" },
+  comment: { type: "boolean" },
+  "from-slot": { type: "boolean" }
+};
+function refused(refusal) {
+  return { argv: [], refusal };
+}
+function override_of(positional) {
+  const { line, disposition } = OVERRIDE_PATTERN.exec(positional)?.groups ?? {};
+  if (line === void 0 || disposition === void 0) return void 0;
+  return [Number(line), disposition];
+}
+function overrides_of(positionals, overrides) {
+  for (const positional of positionals) {
+    const override = override_of(positional);
+    if (override === void 0) return positional;
+    overrides.set(...override);
+  }
+  return void 0;
+}
+function slot_text(is_interaction) {
+  const { CODE, INTERACTION } = review_attest.REVIEW_SLOT;
+  const paths = lane_session_broker.review_paths(PROJECT_ROOT, is_interaction ? INTERACTION : CODE);
+  return stamp_file.read_stamp_text(paths.findings);
+}
+function unmarked(line) {
+  const { FIXED_PREFIX } = run_ship_review;
+  return line.startsWith(FIXED_PREFIX) ? line.slice(FIXED_PREFIX.length) : line;
+}
+function slot_findings(text, overrides) {
+  const verdict = run_ship_review.read_verdict(text);
+  if (verdict.kind === run_ship_review.VERDICT.INVALID) return refused(verdict.note);
+  const last = Math.max(0, ...overrides.keys());
+  if (last > verdict.report.length) return refused(`no finding ${String(last)} in the slot`);
+  return {
+    argv: verdict.report.map(
+      (line, index) => `${overrides.get(index + 1) ?? DEFAULT_DISPOSITION} ${unmarked(line)}`
+    )
+  };
+}
+function flags_of(values) {
+  return [
+    ...values.issue === void 0 ? [] : ["--issue", values.issue],
+    ...values.interaction === true ? ["--interaction"] : [],
+    ...values.comment === true ? ["--comment"] : []
+  ];
+}
+function expand_parsed(values, positionals, read) {
+  const overrides = /* @__PURE__ */ new Map();
+  const unreadable = overrides_of(positionals, overrides);
+  if (unreadable !== void 0) return refused(`unreadable override: ${unreadable}
+${USAGE}`);
+  const findings = slot_findings(read(values.interaction === true), overrides);
+  if (findings.refusal !== void 0) return findings;
+  return { argv: [...flags_of(values), ...findings.argv] };
+}
+function expand(argv, read = slot_text) {
+  if (!argv.includes(FROM_SLOT)) return { argv };
+  const parsed = cli_flags.arguments_of(argv, OPTIONS);
+  if (parsed === void 0) return refused(USAGE);
+  return expand_parsed(parsed.values, parsed.positionals, read);
+}
+async function run(argv, record) {
+  const expansion = expand(argv);
+  if (expansion.refusal === void 0) return await record(expansion.argv, /* @__PURE__ */ new Date());
+  console.error(expansion.refusal);
+  return FAILURE_EXIT_CODE;
+}
+var review_record_slot = {
+  expand,
+  run,
+  slot_text,
+  unmarked
+};
+
+export {
+  review_record_slot
+};

package/dist/commands/chunk-BBPESBU3.js

@@ -0,0 +1,85 @@
+import {
+  changed_file_scope
+} from "./chunk-MEJ2CQK2.js";
+import {
+  project_checks
+} from "./chunk-23TWJOAI.js";
+import {
+  ESLINT_RELATED_CACHE_FILE,
+  ESLINT_RELATED_CACHE_FLAGS,
+  PRETTIER_RELATED_CACHE_FLAGS
+} from "./chunk-TBIX5FRN.js";
+
+// scripts/lint/lint-related-scope.ts
+import path from "node:path";
+var LINTABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".svelte",
+  ".vue",
+  ".md",
+  ".mdx",
+  ".json",
+  ".jsonc",
+  ".json5",
+  ".yaml",
+  ".yml",
+  ".css",
+  ".scss",
+  ".less",
+  ".html",
+  ".graphql",
+  ".gql"
+]);
+var NOTHING_LINTABLE_REASON = "no changed file is one prettier or eslint reads";
+var COMMAND_NAME = "lint:related";
+var COMMAND_LABEL = `josh ${COMMAND_NAME}`;
+var VOCABULARY = {
+  label: COMMAND_LABEL,
+  fallback_suffix: "checking the whole tree instead",
+  narrowed_suffix: "checking only them"
+};
+var PRETTIER_ARGS = ["exec", "prettier", "--check", "--ignore-unknown"];
+var ESLINT_ARGS = ["exec", "eslint"];
+var ESLINT_SCOPED_FLAGS = ["--no-warn-ignored"];
+function is_lintable(file_path) {
+  return LINTABLE_EXTENSIONS.has(path.extname(file_path));
+}
+function scope_inputs(is_present) {
+  return { is_present, is_selectable: is_lintable, nothing_reason: NOTHING_LINTABLE_REASON };
+}
+function describe_scope(scope, root) {
+  return changed_file_scope.describe_scope(scope, root, VOCABULARY);
+}
+var RELATED_CACHES = {
+  eslint_file: ESLINT_RELATED_CACHE_FILE,
+  eslint_flags: ESLINT_RELATED_CACHE_FLAGS,
+  prettier_flags: PRETTIER_RELATED_CACHE_FLAGS
+};
+function prettier_arguments(files, caches = RELATED_CACHES, directory = process.cwd()) {
+  const targets = project_checks.prettier_targets(directory, files);
+  return [...PRETTIER_ARGS, ...targets, ...caches.prettier_flags];
+}
+function eslint_arguments(files, caches = RELATED_CACHES) {
+  return [...ESLINT_ARGS, ...files, ...caches.eslint_flags, ...ESLINT_SCOPED_FLAGS];
+}
+var lint_related_scope = {
+  COMMAND_LABEL,
+  NOTHING_LINTABLE_REASON,
+  RELATED_CACHES,
+  describe_scope,
+  eslint_arguments,
+  is_lintable,
+  prettier_arguments,
+  scope_inputs
+};
+
+export {
+  lint_related_scope
+};

package/dist/commands/chunk-BGKUZJT7.js

@@ -0,0 +1,25 @@
+import {
+  run_hold
+} from "./chunk-NQ4D2XZY.js";
+
+// scripts/run/hold/run-hold-block.ts
+function held_block(hold, issue) {
+  return run_hold.is_reentry(hold, issue) ? void 0 : run_hold.held_message(hold);
+}
+function is_own_unstopped(hold, issue) {
+  return run_hold.is_reentry(hold, issue) && !run_hold.is_stop_marked(hold);
+}
+async function stale_block(hold, issue) {
+  if (is_own_unstopped(hold, issue)) return void 0;
+  return await run_hold.is_tree_dirty() ? run_hold.uncommitted_message(hold) : void 0;
+}
+async function blocking_message(read, issue) {
+  if (read.kind === "held") return held_block(read.hold, issue);
+  if (read.kind === "unreadable") return run_hold.unreadable_message();
+  return read.kind === "stale" ? await stale_block(read.hold, issue) : void 0;
+}
+var run_hold_block = { blocking_message };
+
+export {
+  run_hold_block
+};

package/dist/commands/chunk-BIVM6OTE.js

@@ -0,0 +1,19 @@
+import {
+  start_exec
+} from "./chunk-5VUHAXPI.js";
+
+// scripts/init/initial-commit.ts
+var DEFAULT_BRANCH = "main";
+function create_repository(root) {
+  start_exec.git_run(["init", `--initial-branch=${DEFAULT_BRANCH}`], root);
+}
+function commit_all(root) {
+  start_exec.git_run(["add", "--all"], root);
+  start_exec.git_run(["commit", "--no-verify", "--message", "Initial commit"], root);
+  start_exec.git_run(["branch", "--move", "--force", DEFAULT_BRANCH], root);
+}
+var initial_commit = { create_repository, commit_all };
+
+export {
+  initial_commit
+};