@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-XRQMVAB4.js

@@ -1,85 +0,0 @@
-import {
-  git_grep_hits
-} from "./chunk-LU5EOGFQ.js";
-import {
-  git_spawn
-} from "./chunk-B5HP6T4L.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
-};

package/dist/commands/chunk-XUXCFPDK.js

@@ -1,218 +0,0 @@
-import {
-  lane_residents
-} from "./chunk-43H725LG.js";
-import {
-  lane_spent
-} from "./chunk-KR6WUAJM.js";
-import {
-  lane_plan
-} from "./chunk-MDGPJOLK.js";
-import {
-  lane_registry
-} from "./chunk-NEOCCN6D.js";
-import {
-  git_worktree
-} from "./chunk-WNBJK6QE.js";
-import {
-  lane_state
-} from "./chunk-7EAYFMDN.js";
-import {
-  lane_reap
-} from "./chunk-ON4IKRGS.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  lane_paths
-} from "./chunk-G75GWNNY.js";
-import {
-  git_command
-} from "./chunk-IXZZSST7.js";
-
-// scripts/lane/lane-close.ts
-import { existsSync, rmSync } from "node:fs";
-
-// scripts/lane/lane-reap-settle.ts
-import { userInfo } from "node:os";
-var GRACE_MS = 3e3;
-var KILL_WAIT_MS = 1e3;
-var KILL_SIGNAL = "SIGKILL";
-var STATE_FORMAT = ["-o", "user=,stat=", "-p"];
-var FIELD_SEPARATOR = /\s+/u;
-var UNREADABLE_TEXT = "the lane's processes (lsof or ps failed)";
-function kill(pid) {
-  try {
-    process.kill(pid, KILL_SIGNAL);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function wait(milliseconds) {
-  await new Promise((resolve) => setTimeout(resolve, milliseconds));
-}
-function reason_from(user, state) {
-  if (user !== userInfo().username) return `owned by ${user}`;
-  return `state ${state}`;
-}
-function reason_of(pid) {
-  const printed = lane_reap.run_probe(lane_reap.PS_COMMAND, [...STATE_FORMAT, String(pid)]);
-  const [user = "", state = ""] = printed.trim().split(FIELD_SEPARATOR);
-  return user.length === 0 ? "unreadable" : reason_from(user, state);
-}
-var SYSTEM_PROBES = {
-  residents: (lane) => lane_residents.residents(lane),
-  kill,
-  wait,
-  reason_of
-};
-function is_empty(reading) {
-  return reading?.length === 0;
-}
-async function kill_all(lingering, probes) {
-  const targets = lingering ?? [];
-  for (const pid of targets) probes.kill(pid);
-  await probes.wait(KILL_WAIT_MS);
-}
-function survivors(lane, probes) {
-  return probes.residents(lane)?.map((pid) => ({ pid, reason: probes.reason_of(pid) }));
-}
-async function settle(lane, probes = SYSTEM_PROBES) {
-  if (is_empty(probes.residents(lane))) return [];
-  await probes.wait(GRACE_MS);
-  const lingering = probes.residents(lane);
-  if (is_empty(lingering)) return [];
-  await kill_all(lingering, probes);
-  return survivors(lane, probes);
-}
-function survivor_texts(settled) {
-  if (settled === void 0) return [UNREADABLE_TEXT];
-  return settled.map((survivor) => `process ${String(survivor.pid)} (${survivor.reason})`);
-}
-var lane_reap_settle = { GRACE_MS, KILL_WAIT_MS, reason_from, settle, survivor_texts };
-
-// scripts/lane/lane-close.ts
-async function ignore_failure(action) {
-  try {
-    await action();
-  } catch {
-  }
-}
-function lane_targets(root, issue, lane) {
-  return {
-    directory: lane?.directory ?? lane_paths.lane_directory(root, issue),
-    branch: lane?.branch ?? lane_paths.lane_branch(issue)
-  };
-}
-function remove_directory(directory) {
-  try {
-    rmSync(directory, { force: true, recursive: true });
-  } catch {
-  }
-}
-async function remove_lane(targets) {
-  await ignore_failure(async () => await git_worktree.worktree_remove(targets.directory));
-  remove_directory(targets.directory);
-  await ignore_failure(async () => await git_worktree.worktree_prune());
-  await ignore_failure(async () => await git_worktree.branch_delete(targets.branch));
-}
-async function residue(targets) {
-  const left = [];
-  if (existsSync(targets.directory)) left.push(targets.directory);
-  if (await git_command.branch_exists(targets.branch)) left.push(targets.branch);
-  return left;
-}
-function close_kind(did_exist, left_behind) {
-  if (left_behind.length > 0) return "incomplete";
-  return did_exist ? "closed" : "none";
-}
-async function resolve_lane(issue) {
-  const root = await lane_registry.lane_root_directory();
-  const existing = lane_registry.find_lane(await lane_registry.list_lanes(), issue);
-  return { existing, targets: lane_targets(root, issue, existing) };
-}
-async function is_ending(issue, kind) {
-  if (kind !== "none") return kind === "closed";
-  const record = await lane_state.read_state(issue);
-  return record !== void 0 && record.state !== "ended";
-}
-async function survivors_of(issue, directory) {
-  const survivors2 = await lane_reap_settle.settle({ issue, directory });
-  if (survivors2 !== void 0) await lane_state.record_stuck(issue, survivors2);
-  return lane_reap_settle.survivor_texts(survivors2);
-}
-async function left_behind_of(issue, targets) {
-  const survivors2 = await survivors_of(issue, targets.directory);
-  return [...await residue(targets), ...survivors2];
-}
-async function record_end(issue) {
-  await lane_state.record_change({ issue, state: "ended", command: "lane:close" });
-  lane_plan.release(Number(issue), process.cwd());
-}
-async function close_lane(issue) {
-  const { existing, targets } = await resolve_lane(issue);
-  const did_exist = existing !== void 0 || existsSync(targets.directory);
-  const reaped = lane_reap.reap_child({ issue, directory: targets.directory });
-  const residents = lane_residents.end_residents({ issue, directory: targets.directory }, reaped);
-  await remove_lane(targets);
-  const left_behind = await left_behind_of(issue, targets);
-  const kind = close_kind(did_exist, left_behind);
-  if (await is_ending(issue, kind)) await record_end(issue);
-  return { issue, kind, left_behind, reaped, residents };
-}
-async function always_due() {
-  return true;
-}
-async function try_close(issue) {
-  try {
-    const outcome = await close_lane(issue);
-    return outcome.kind !== "incomplete";
-  } catch (error) {
-    error_text.trace_swallowed("lane_close.try_close", error);
-    return false;
-  }
-}
-async function close_into(sweep, issue, is_due) {
-  if (!await is_due(issue)) return;
-  const bucket = await try_close(issue) ? sweep.closed : sweep.failed;
-  bucket.push(issue);
-}
-async function close_each(issues, is_due = always_due) {
-  const sweep = { closed: [], failed: [] };
-  for (const issue of issues) {
-    await close_into(sweep, issue, is_due);
-  }
-  return sweep;
-}
-async function prune_lanes() {
-  const lanes = await lane_registry.list_lanes();
-  const { spent, kept } = await lane_spent.sort_lanes(lanes);
-  const doomed = lanes.filter((lane) => lane.is_stranded || spent.includes(lane));
-  const sweep = await close_each(doomed.map((lane) => lane.issue));
-  return { ...sweep, kept };
-}
-async function close_all_lanes() {
-  const lanes = await lane_registry.list_lanes();
-  return await close_each(lanes.map((lane) => lane.issue));
-}
-async function is_unfinished(issue) {
-  const { targets } = await resolve_lane(issue);
-  return !existsSync(targets.directory);
-}
-async function retry_closes() {
-  const records = await lane_state.read_records();
-  const issues = records.filter((record) => record.state !== "ended").map(({ issue }) => issue);
-  return await close_each(issues, is_unfinished);
-}
-var lane_close = {
-  close_all_lanes,
-  close_lane,
-  prune_lanes,
-  resolve_lane,
-  retry_closes
-};
-
-export {
-  lane_reap_settle,
-  lane_close
-};

package/dist/commands/chunk-XZQWEVR3.js

@@ -1,84 +0,0 @@
-import {
-  markdown_section
-} from "./chunk-JZK33TA5.js";
-import {
-  issue_body_keys
-} from "./chunk-KXK2A2HB.js";
-
-// scripts/issue/expected-effect-lint.ts
-var DECLARATION_LINE = issue_body_keys.line("purpose", "time_saving");
-var BACKGROUND_HEADING = issue_body_keys.heading("background");
-var HEADING = issue_body_keys.heading("expected_effect");
-var RATE_LABEL = "\u52B9\u304F\u7387";
-var GAIN_LABEL = "1 \u56DE\u3042\u305F\u308A\u306E\u5F97";
-var ITEM_LABELS = [RATE_LABEL, GAIN_LABEL, "\u5916\u308C\u305F\u3068\u304D\u306E\u640D", "\u51FA\u5178"];
-var WEEK = "\u9031";
-var COUNT = /(?<![\d.])(?<count>\d+) ?回/gu;
-var SPAN = /(?<![\d.])(?<weeks>\d+) ?週/u;
-var ONE_WEEK = 1;
-var DURATION = /(?<![\d.])(?<amount>\d+(?:\.\d+)?) ?(?<unit>[分秒])/u;
-var SECONDS_UNIT = "\u79D2";
-var SECONDS_PER_MINUTE = 60;
-var NONE = 0;
-var PLACEHOLDER = /^<.*>$/u;
-function is_target(body) {
-  const background = markdown_section.section_lines(body, BACKGROUND_HEADING).join("\n");
-  return markdown_section.has_unfenced_line(background, DECLARATION_LINE);
-}
-function item_value(line, label) {
-  const prefix = `- ${label}:`;
-  if (!line.startsWith(prefix)) return void 0;
-  return line.slice(prefix.length).trim();
-}
-function is_stated(value) {
-  return value !== void 0 && value.length > 0 && !PLACEHOLDER.test(value);
-}
-function stated_value(lines, label) {
-  return lines.map((line) => item_value(line.trim(), label)).find((value) => is_stated(value));
-}
-function effect_lines(body) {
-  const section = markdown_section.section_lines(body, HEADING).join("\n");
-  return markdown_section.unfenced_lines(section);
-}
-function value_of(body, label) {
-  return stated_value(effect_lines(body), label);
-}
-function weeks_of(rate) {
-  const weeks = SPAN.exec(rate)?.groups?.["weeks"];
-  return Math.max(Number(weeks ?? ONE_WEEK), ONE_WEEK);
-}
-function weekly_hits(rate) {
-  if (!rate?.includes(WEEK)) return NONE;
-  const counts = [...rate.matchAll(COUNT)].map((match) => Number(match.groups?.["count"]));
-  return (counts.at(-1) ?? NONE) / weeks_of(rate);
-}
-function minutes_per_hit(gain = "") {
-  const groups = DURATION.exec(gain)?.groups;
-  if (groups === void 0) return NONE;
-  const amount = Number(groups["amount"]);
-  return groups["unit"] === SECONDS_UNIT ? amount / SECONDS_PER_MINUTE : amount;
-}
-function weekly_minutes(body = "") {
-  return weekly_hits(value_of(body, RATE_LABEL)) * minutes_per_hit(value_of(body, GAIN_LABEL));
-}
-function problems(body) {
-  if (!is_target(body)) return [];
-  if (!markdown_section.has_line(body, HEADING)) return [`missing heading: ${HEADING}`];
-  const lines = effect_lines(body);
-  return ITEM_LABELS.filter((label) => stated_value(lines, label) === void 0).map(
-    (label) => `missing expected-effect item: - ${label}: <value>`
-  );
-}
-var expected_effect_lint = {
-  DECLARATION_LINE,
-  HEADING,
-  ITEM_LABELS,
-  is_target,
-  problems,
-  value_of,
-  weekly_minutes
-};
-
-export {
-  expected_effect_lint
-};

package/dist/commands/chunk-Y6OGDG5I.js

@@ -1,49 +0,0 @@
-import {
-  split_assess
-} from "./chunk-ZGEUWHFF.js";
-
-// scripts/lane/lane-plan-estimate.ts
-import { readFile } from "node:fs/promises";
-import { z } from "zod";
-var FLAG = "--estimate";
-var FLAG_WIDTH = 2;
-var change_schema = z.object({
-  path: z.string().trim().min(1),
-  changed_lines: z.number().int().nonnegative()
-});
-var schema = z.object({
-  changes: z.array(change_schema),
-  added: z.array(z.string()).default([])
-});
-function split(tokens) {
-  const at = tokens.indexOf(FLAG);
-  if (at === -1) return { tokens: [...tokens] };
-  if (tokens.lastIndexOf(FLAG) !== at) throw new Error("duplicate --estimate");
-  const file = tokens[at + 1];
-  if (file === void 0 || file.startsWith("--")) throw new Error("--estimate needs a JSON file");
-  return { tokens: [...tokens.slice(0, at), ...tokens.slice(at + FLAG_WIDTH)], file };
-}
-async function read(file) {
-  const scope = schema.parse(JSON.parse(await readFile(file, "utf8")));
-  const paths = scope.changes.map((change) => change.path);
-  if (new Set(paths).size !== paths.length) throw new Error("duplicate estimate path");
-  if (scope.added.some((path) => !paths.includes(path))) {
-    throw new Error("added path needs an estimate");
-  }
-  return scope;
-}
-async function attach(plan, file) {
-  if (file === void 0) return plan;
-  const scope = await read(file);
-  const paths = scope.changes.map((change) => change.path);
-  if (plan.paths.some((path) => !paths.includes(path))) {
-    throw new Error("planned path needs an estimate");
-  }
-  const size = split_assess.measure(scope.changes, void 0, new Set(scope.added));
-  return { ...plan, paths, estimated_size: { files: size.files, lines: size.lines } };
-}
-var lane_plan_estimate = { attach, read, split };
-
-export {
-  lane_plan_estimate
-};