@joshuafolkken/kit 1.1240.0 → 1.1373.0

package/dist/hooks/chunk-RKUAD3I6.js

@@ -1,90 +0,0 @@
-// ports/index.js
-import { existsSync } from "node:fs";
-import path from "node:path";
-var PORT_SEED_KEY = "PORT_SEED";
-var LANE_SEAT_KEY = "JOSH_LANE_SEAT";
-var ENV_FILE_NAME = ".env";
-var PACKAGE_FILE_NAME = "package.json";
-var PROJECT_ENVIRONMENT_KEYS = /* @__PURE__ */ new Set([PORT_SEED_KEY, LANE_SEAT_KEY, "PLAYWRIGHT_REUSE_SERVER"]);
-var DEV_PORT_BASE = 5173;
-var PREVIEW_PORT_BASE = 4173;
-var MIN_SEED = 0;
-var SEED_LANE_MULTIPLIER = 10;
-var MAX_LANE = 9;
-var MAX_SEED = 99;
-var INTEGER_PATTERN = /^\d+$/u;
-function fail_invalid(key, raw, max) {
-  throw new Error(
-    `${key} must be an integer between ${MIN_SEED} and ${max}, got ${JSON.stringify(raw)}. Unset it to use the default ports (dev ${DEV_PORT_BASE}, preview ${PREVIEW_PORT_BASE}).`
-  );
-}
-function read_trimmed(environment, key) {
-  const raw = environment[key];
-  return raw === void 0 ? "" : raw.trim();
-}
-function resolve_bounded(environment, key, max) {
-  const trimmed = read_trimmed(environment, key);
-  if (trimmed.length === 0) return MIN_SEED;
-  if (!INTEGER_PATTERN.test(trimmed)) fail_invalid(key, trimmed, max);
-  const value = Number(trimmed);
-  if (value > max) fail_invalid(key, trimmed, max);
-  return value;
-}
-function resolve_seed(environment = process.env) {
-  return resolve_bounded(environment, PORT_SEED_KEY, MAX_SEED);
-}
-function resolve_lane(environment = process.env) {
-  return resolve_bounded(environment, LANE_SEAT_KEY, MAX_LANE);
-}
-function resolve_offset(environment = process.env) {
-  return resolve_seed(environment) * SEED_LANE_MULTIPLIER + resolve_lane(environment);
-}
-function offset_from(base, environment) {
-  return base + resolve_offset(environment);
-}
-function resolve_development_port(environment = process.env) {
-  return offset_from(DEV_PORT_BASE, environment);
-}
-function resolve_preview_port(environment = process.env) {
-  return offset_from(PREVIEW_PORT_BASE, environment);
-}
-function resolve_project_directory(directory) {
-  const start = path.resolve(directory);
-  let current = start;
-  while (!existsSync(path.join(current, PACKAGE_FILE_NAME))) {
-    const parent = path.dirname(current);
-    if (parent === current) return start;
-    current = parent;
-  }
-  return current;
-}
-function discard_loaded_keys(snapshot) {
-  for (const key of Object.keys(process.env)) {
-    if (!PROJECT_ENVIRONMENT_KEYS.has(key) && !Object.hasOwn(snapshot, key)) {
-      Reflect.deleteProperty(process.env, key);
-    }
-  }
-}
-function load_environment_file(directory = process.cwd()) {
-  const file = path.join(resolve_project_directory(directory), ENV_FILE_NAME);
-  if (!existsSync(file)) return false;
-  const snapshot = { ...process.env };
-  process.loadEnvFile(file);
-  discard_loaded_keys(snapshot);
-  return true;
-}
-var ports = {
-  load_environment_file,
-  resolve_project_directory,
-  resolve_seed,
-  resolve_lane,
-  resolve_development_port,
-  resolve_preview_port
-};
-
-export {
-  PORT_SEED_KEY,
-  LANE_SEAT_KEY,
-  ENV_FILE_NAME,
-  ports
-};

package/dist/hooks/chunk-WPALEIRX.js

@@ -1,18 +0,0 @@
-import {
-  ENV_FILE_NAME
-} from "./chunk-RKUAD3I6.js";
-
-// scripts/josh/josh-environment-file.ts
-function load_environment_file() {
-  try {
-    process.loadEnvFile(ENV_FILE_NAME);
-  } catch {
-  }
-}
-var josh_environment_file = {
-  load_environment_file
-};
-
-export {
-  josh_environment_file
-};

package/scripts/backlog/backlog-restructure.ts

@@ -1,152 +0,0 @@
-import type { BusyRead } from '#scripts/epic/epic-busy'
-import type { EpicChild } from '#scripts/epic/epic-graph'
-import type { SoloSelection } from '#scripts/epic/epic-solo'
-
-// Which candidates may not run side by side because both restructure the same file
-// (joshuafolkken/kit#3221). The condition is deliberately narrow: plain overlap is not serialized,
-// because every resume record of the 2026-10-05 backlog run was resolved mechanically by merging
-// main. What git cannot resolve on its own is a rename or modify/delete conflict — two lanes that
-// each move, split, rename or delete the same file — so only a path both bodies name on a line with
-// such a verb holds the second one back. `remove` is left out: issue bodies use it for lines and
-// options far more often than for files.
-const RESTRUCTURE_WORDS: ReadonlySet<string> = new Set([
-	'move',
-	'moved',
-	'moves',
-	'moving',
-	'rename',
-	'renamed',
-	'renames',
-	'renaming',
-	'split',
-	'splits',
-	'splitting',
-	'delete',
-	'deleted',
-	'deletes',
-	'deleting',
-])
-const RESTRUCTURE_PHRASES: ReadonlyArray<string> = ['移動', '分割', '削除', 'リネーム', '改名']
-const WORD = /[a-z]+/giu
-const CODE_SPAN = /`([^`\s]+)`/gu
-const LINE_SUFFIX = /:\d+(?::\d+)?$/u
-const FILE_EXTENSION = /\.[a-z]\w*$/iu
-
-// The restructured paths each issue declares, by issue number.
-type Declared = ReadonlyMap<number, ReadonlySet<string>>
-
-interface DeclaringIssue {
-	number: number
-	body?: string | undefined
-}
-
-function is_path(token: string): boolean {
-	return token.includes('/') || FILE_EXTENSION.test(token)
-}
-
-function paths_on(line: string): Array<string> {
-	return [...line.matchAll(CODE_SPAN)]
-		.map((match) => (match[1] ?? '').replace(LINE_SUFFIX, ''))
-		.filter((token) => is_path(token))
-}
-
-function is_restructuring(line: string): boolean {
-	const words = line.match(WORD) ?? []
-
-	if (words.some((word) => RESTRUCTURE_WORDS.has(word.toLowerCase()))) return true
-
-	return RESTRUCTURE_PHRASES.some((phrase) => line.includes(phrase))
-}
-
-// The backticked paths on the lines of `body` that carry a restructuring verb.
-function restructured_paths(body: string): ReadonlySet<string> {
-	const lines = body.split('\n').filter((line) => is_restructuring(line))
-
-	return new Set(lines.flatMap((line) => paths_on(line)))
-}
-
-function declared_of(issues: ReadonlyArray<DeclaringIssue>): Declared {
-	return new Map(issues.map((issue) => [issue.number, restructured_paths(issue.body ?? '')]))
-}
-
-interface SeparateContext {
-	read: BusyRead
-	repo: string
-}
-
-// The path each running lane restructures, mapped to the issue that holds it.
-function running_claims(declared: Declared, read: BusyRead): Map<string, number> {
-	const holders = read.kind === 'busy' ? read.issues.map((issue) => issue.number) : []
-	const pairs = holders.flatMap((number) =>
-		[...(declared.get(number) ?? [])].map((path): [string, number] => [path, number]),
-	)
-
-	return new Map(pairs)
-}
-
-function paths_of(child: EpicChild, declared: Declared, repo: string): ReadonlySet<string> {
-	if (child.repo !== repo) return new Set()
-
-	return declared.get(child.number) ?? new Set()
-}
-
-function clash_note(child: EpicChild, path: string, holder: number): string {
-	return `#${String(child.number)} waits: it and #${String(holder)} both restructure \`${path}\`.`
-}
-
-interface Walk {
-	claims: Map<string, number>
-	offered: Array<EpicChild>
-	withheld: Array<EpicChild>
-	notes: Array<string>
-}
-
-function visit(walk: Walk, child: EpicChild, paths: ReadonlySet<string>): void {
-	const clash = [...paths].find((path) => walk.claims.has(path))
-
-	if (clash === undefined) {
-		walk.offered.push(child)
-		for (const path of paths) walk.claims.set(path, child.number)
-
-		return
-	}
-
-	walk.withheld.push(child)
-	walk.notes.push(clash_note(child, clash, walk.claims.get(clash) ?? child.number))
-}
-
-function merged_notice(
-	notice: string | undefined,
-	notes: ReadonlyArray<string>,
-): string | undefined {
-	const parts = notice === undefined ? notes : [notice, ...notes]
-
-	return parts.length === 0 ? undefined : parts.join('\n')
-}
-
-// `selection` with every offered candidate that restructures a path a running lane or an earlier
-// candidate already restructures moved to `withheld`, in offer order.
-function separate(
-	selection: SoloSelection,
-	declared: Declared,
-	context: SeparateContext,
-): SoloSelection {
-	const walk: Walk = {
-		claims: running_claims(declared, context.read),
-		offered: [],
-		withheld: [],
-		notes: [],
-	}
-
-	for (const child of selection.offered) visit(walk, child, paths_of(child, declared, context.repo))
-
-	const notice = merged_notice(selection.notice, walk.notes)
-	const withheld = [...walk.withheld, ...selection.withheld]
-
-	return { offered: walk.offered, withheld, ...(notice !== undefined && { notice }) }
-}
-
-const backlog_restructure = { declared_of, restructured_paths, separate }
-
-export { backlog_restructure }
-export type { Declared }

package/scripts/rules/issue-fold-rule.ts

@@ -1,72 +0,0 @@
-import type { GuardedCall } from '#scripts/time-runtime/time-batch-guard'
-import { bash_triggers } from './bash-triggers'
-import { filing_cap } from './filing-cap'
-import { shell_segments } from './shell-segments'
-import { tail_commands } from './tail-commands'
-
-// The trigger and the delivered text behind the `issue-fold` row of `delivered-rules.ts`
-// (joshuafolkken/kit#2213).
-//
-// **A second filing in one run with no `pnpm josh issue:fold` in front of it, refused at that second
-// filing.** A run that files several findings from one session should first ask whether they fold
-// into one Issue — the filing-time counterpart to the split assessment. The **first** filing asks
-// nothing: there is nothing yet to fold it with, which is why the rule stands down when no earlier
-// filing is on the tail. From the second on the run holds two or more findings and the fold question
-// binds. The input is mechanical — has the run filed before, did it fold — so it is a delivered rule
-// rather than resident prose.
-//
-// **It is `issue-scout`'s shape, not `filing-cap`'s.** Refused until an `already_satisfied`
-// stand-down read off the tail answers: a filing with no prior filing is stood down (nothing to fold), and so
-// is one the run has already folded. The refusal hands over the command rather than asking the run to
-// "fold first". **No new predicate**: the filing trigger is `bash_triggers.is_issue_filing`, and the
-// prior-filing count is `filing_cap.prior_filing_count`, both reused verbatim.
-
-// `pnpm josh issue:fold`, the one act the rule asks for.
-const FOLD_NAMES: ReadonlySet<string> = new Set(['issue:fold'])
-
-// Keeping the rule: a call that runs the fold. Segment-wise, so a spelling quoted inside a filing's
-// own body is not read as the fold that filing skipped.
-function runs_the_fold(command: string): boolean {
-	return shell_segments
-		.segments_of(command)
-		.some((segment) => shell_segments.is_josh_command(segment, FOLD_NAMES))
-}
-
-// The `already_satisfied` stand-down. Two runs ask nothing new: one with no earlier filing — the first
-// filing has nothing to fold with — and one that has already folded. Only the second-or-later filing
-// of an unfolded run is left for the delivery. `prior_filing_count` counts real filings, excluding a
-// guard-refused one, exactly as `filing-cap` reads it (no clones).
-function already_folded(tail: string, _call: GuardedCall): boolean {
-	if (filing_cap.prior_filing_count(tail) === 0) return true
-
-	return tail_commands.prior_bash_commands(tail).some((command) => runs_the_fold(command))
-}
-
-// The instruction in the shape a refusal can carry: what the call skipped, the criterion it reuses,
-// and the command that fixes it. The default is named because it is the half that makes the rule
-// believable — fold is what a session's several findings do unless the size clearly forbids it.
-const ISSUE_FOLD_REASON =
-	'⛔ issue fold: this run has filed an Issue before and is filing another with no `pnpm josh ' +
-	'issue:fold` between them. Several findings from one session fold into one Issue by default — the ' +
-	'filing-time counterpart to the split assessment, whose two questions it reuses: are the findings ' +
-	'separable, and does the whole clearly exceed one verification gate (the size half is ' +
-	'`split:assess`, called not recomputed). Reissue after folding: `pnpm josh issue:fold "<title>" ' +
-	'"<title>" …` — `fold` means file one Issue covering them, `separate` means file them apart ' +
-	'(separable findings whose combined size clears the split guide), and the default is `fold`. Add ' +
-	'`--not-separable` when they are really one deliverable. The procedure is ' +
-	'`.claude/skills/workflow-commands/split-assessment.md` → "The question". Every later filing is ' +
-	'refused until the fold is on the transcript.'
-
-// The enumeration row itself, so `delivered-rules.ts` spreads one entry rather than restating the
-// trigger and reason it already single-sources here. Once per run with the stand-down above.
-const ROW = {
-	id: 'issue-fold',
-	is_trigger: bash_triggers.on_bash_command(bash_triggers.is_issue_filing),
-	reason: ISSUE_FOLD_REASON,
-	already_satisfied: already_folded,
-	keeps: bash_triggers.on_bash_command(runs_the_fold),
-}
-
-const issue_fold_rule = { ISSUE_FOLD_REASON, ROW, already_folded, runs_the_fold }
-
-export { issue_fold_rule }

package/scripts/rules/wip-cap.ts

@@ -1,63 +0,0 @@
-import { bash_triggers } from './bash-triggers'
-import { shell_segments } from './shell-segments'
-
-// The trigger and the delivered text behind the `wip-cap` row of `delivered-rules.ts`, moved out of
-// the enumeration so the list stays a list (joshuafolkken/kit#3264).
-
-// The whole of the WIP cap, in the shape a refusal can carry: the count, the refusal, the two
-// exemptions and the three tests that decide the second one. The three tests are spelled out rather
-// than named, because a delivery that said only "an interrupt is exempt" would hand the deciding back
-// to judgement at exactly the moment nothing else is open to read (joshuafolkken/kit#1518).
-// `WIP_CAP` is the number's single source; `wip-cap.md` states it once and a test pins the two equal.
-const WIP_CAP = 30
-const WIP_CAP_REASON =
-	`⛔ backlog WIP cap: \`pnpm josh issue:file\` counts the target repository's open Issues before filing. With more than ${String(WIP_CAP)} ` +
-	'open, close one first; nothing honestly closable means do not file — the command holds such a filing. ' +
-	'Two filings are exempt and proceed while stating the overage — one the run is blocked by (`--over-cap`, ' +
-	'or the `tier-a` / `split` route), and an interrupt (`--route interrupt`), decided by three tests rather ' +
-	'than judgement: a verification answers wrongly, a documented workflow cannot complete, or data is lost ' +
-	'or written outside the repository. Meeting none of the three, the finding is discretionary and waits. ' +
-	'Both procedures are in `prompts/collaboration-workflow/wip-cap.md`. Reissue this call and let the ' +
-	'command count — it fires once per run and cannot repeat on the call in hand.'
-
-// **Keeping the WIP cap is counting the open Issues**, which is the one act the rule asks for before
-// a filing.
-//
-// **It has to be Issues, open, and a listing — all three, in one segment.** A pattern that took any
-// of them alone scored `gh pr list --state open` and `epic:bundle`'s candidate search as the count,
-// and those inflate exactly the ratio the retirement decision reads. `gh issue list` alone is not
-// enough either: the cap is about *open* Issues, and a listing that does not say so is some other
-// question. Segment-wise like the comments predicate, so a spelling quoted inside a filing's body
-// is not read as the count that filing skipped.
-const ISSUE_LISTING = /^gh\s+(?:-{1,2}[\w-]+(?:[= ]\S+)?\s+)*issue\s+list\b/u
-const ISSUES_QUERY = /repos\/[^\s'"]*\/issues\?[^\s'"]*state=open/u
-const OPEN_STATE = /--state[= ]open|state=open/u
-// **A label filter makes it a different question.** `gh issue list --label epic --state open` and
-// `…/issues?labels=epic&state=open` ask which epics are open, which is what `epic:bundle` and the
-// Issue template do; counting either as the WIP count would credit the cap as kept by a run that
-// never counted the backlog. The residual the pattern cannot separate is named in
-// `docs/josh-commands.md`: the inventory command in the `diag` skill is byte-identical to a hand count
-// of the backlog, so no pattern can tell those two apart.
-const LABEL_FILTER = /--label\b|[?&]labels=/u
-
-function counts_open_issues(command: string): boolean {
-	return shell_segments.segments_of(command).some((segment) => {
-		if (LABEL_FILTER.test(segment)) return false
-
-		return (ISSUE_LISTING.test(segment) && OPEN_STATE.test(segment)) || ISSUES_QUERY.test(segment)
-	})
-}
-
-// The enumeration row itself, so `delivered-rules.ts` spreads one entry rather than restating the
-// trigger and reason it already single-sources here. Once per run: the refusal changes what the run
-// knows, so the reissue is let through.
-const ROW = {
-	id: 'wip-cap',
-	is_trigger: bash_triggers.on_bash_command(bash_triggers.is_issue_filing),
-	reason: WIP_CAP_REASON,
-	keeps: bash_triggers.on_bash_command(counts_open_issues),
-}
-
-const wip_cap = { ROW, WIP_CAP, WIP_CAP_REASON }
-
-export { wip_cap }

package/scripts/run/run-issue-number.ts

@@ -1,19 +0,0 @@
-// The shape an issue number may take where a `run:*` command interpolates it, and the refusal when
-// it does not (joshuafolkken/kit#1485).
-//
-// It sits in its own module because two commands need the same answer and a rule copied into two
-// files is a rule kept correct in one. `run:hold`'s preflight check interpolates the number into a
-// double-quoted shell command a caller is told to paste; `run:liveness` interpolates it into the same kind of
-// recovery advice, and reads GitHub with it. Both refuse before the interpolation rather than
-// leaving the check to whichever entry point remembered.
-
-const ISSUE_NUMBER_PATTERN = /^[1-9]\d*$/u
-const BAD_ISSUE_MESSAGE = 'Not an issue number: '
-
-function require_issue_number(issue: string): void {
-	if (!ISSUE_NUMBER_PATTERN.test(issue)) throw new Error(`${BAD_ISSUE_MESSAGE}${issue}`)
-}
-
-const run_issue_number = { ISSUE_NUMBER_PATTERN, require_issue_number }
-
-export { run_issue_number }