@joshuafolkken/kit 1.1514.0 → 1.2114.0

package/dist/hooks/duplicate-read-guard.js

@@ -1,30 +0,0 @@
-#!/usr/bin/env tsx
-import {
-  DISABLED_VALUES,
-  SWITCH_ENV_KEY,
-  deny_envelope,
-  duplicate_read_outcome,
-  duplicate_read_refusal,
-  duplicate_reads,
-  is_enabled,
-  notice_refusal_path,
-  refusal_path
-} from "./chunk-PF2NZL2A.js";
-import "./chunk-PTICX4OL.js";
-import "./chunk-JP45SOCJ.js";
-import "./chunk-6TS2JD6D.js";
-import "./chunk-TNUMY6NL.js";
-import "./chunk-LAOV7NLM.js";
-import "./chunk-APUO6U4J.js";
-import "./chunk-DGT54IH5.js";
-export {
-  DISABLED_VALUES,
-  SWITCH_ENV_KEY,
-  deny_envelope,
-  duplicate_read_outcome,
-  duplicate_read_refusal,
-  duplicate_reads,
-  is_enabled,
-  notice_refusal_path,
-  refusal_path
-};

package/dist/hooks/investigation-guard.js

@@ -1,29 +0,0 @@
-#!/usr/bin/env tsx
-import {
-  DISABLED_VALUES,
-  SWITCH_ENV_KEY,
-  deny_envelope,
-  investigation_outcome,
-  investigation_refusal,
-  is_enabled,
-  load_environment_file,
-  refusal_path
-} from "./chunk-7DSBJVFH.js";
-import "./chunk-PTICX4OL.js";
-import "./chunk-UPUZF3AN.js";
-import "./chunk-JP45SOCJ.js";
-import "./chunk-6TS2JD6D.js";
-import "./chunk-TNUMY6NL.js";
-import "./chunk-LAOV7NLM.js";
-import "./chunk-APUO6U4J.js";
-import "./chunk-DGT54IH5.js";
-export {
-  DISABLED_VALUES,
-  SWITCH_ENV_KEY,
-  deny_envelope,
-  investigation_outcome,
-  investigation_refusal,
-  is_enabled,
-  load_environment_file,
-  refusal_path
-};

package/scripts/backlog/backlog-stalled-cli.ts

@@ -1,30 +0,0 @@
-#!/usr/bin/env tsx
-import { fileURLToPath } from 'node:url'
-import { backlog_stalled } from './backlog-stalled'
-import { backlog_stalled_detect } from './backlog-stalled-detect'
-
-// `josh backlog:stalled` — read the three conditions once and print the verdict.
-// This is the manual and testable face of the detector `stop-guard.ts` runs
-// on every stop; both call the one `detect_and_report`, so the command and the hook can never drift.
-//
-// **It reports, it never stops.** The exit code is always success — a stall is a state to surface, not
-// an error to fail on — so a caller (a person, a test, a wired hook) reads the verdict off stdout and is
-// never halted by it. An unreadable record prints `unreadable` for the same reason: the run carries on.
-
-const SUCCESS_EXIT_CODE = 0
-
-async function main(): Promise<void> {
-	try {
-		console.info(await backlog_stalled_detect.detect_and_report())
-	} catch {
-		console.info(backlog_stalled.UNREADABLE)
-	}
-
-	process.exitCode = SUCCESS_EXIT_CODE
-}
-
-const backlog_stalled_cli = { main }
-
-if (process.argv[1] === fileURLToPath(import.meta.url)) await main()
-
-export { backlog_stalled_cli }

package/scripts/cost-runtime/context-cut-threshold.ts

@@ -1,11 +0,0 @@
-import { context_cut_payback } from './context-cut-payback'
-
-// The scheduler entry/hand-off and lane worker implementation cut use one threshold. Keeping the
-// value here prevents either side from drifting when the context budget changes.
-// The threshold is a break-even, not a chosen number: the current per-request context at which a
-// cut pays back over the expected remaining requests (`context-cut-payback.ts`). At
-// `POST_CUT_CONTEXT` 60_000 and a 10-request horizon that is 135_000, derived from the cache-price
-// multipliers and the horizon rather than restated, so it moves with the model.
-const CONTEXT_CUT_THRESHOLD = context_cut_payback.break_even_context()
-
-export { CONTEXT_CUT_THRESHOLD }

package/scripts/cost-runtime/cost-format.ts

@@ -1,29 +0,0 @@
-// The three figures a cost report prints — a dollar amount, a token count, a percentage share — and
-// the precision each uses. Shared by the run-tree report modules and by `josh time`'s reports, which
-// render the same figures.
-
-const USD_DECIMALS = 4
-const PERCENT_SCALE = 100
-const PERCENT_DECIMALS = 1
-
-function format_usd(usd: number): string {
-	return `$${usd.toFixed(USD_DECIMALS)}`
-}
-
-function format_tokens(count: number): string {
-	return count.toLocaleString('en-US')
-}
-
-function format_share(part: number, whole: number): string {
-	if (whole === 0) return 'n/a'
-
-	return `${((part / whole) * PERCENT_SCALE).toFixed(PERCENT_DECIMALS)}%`
-}
-
-const cost_format = {
-	format_usd,
-	format_tokens,
-	format_share,
-}
-
-export { cost_format }

package/scripts/init/basic-path-migration.ts

@@ -1,24 +0,0 @@
-// The two references `josh init` writes into a basic project, under the paths they had while the
-// basic profile was named static. kit still ships both old paths so an earlier
-// project keeps working; re-running `josh init` moves the project onto the new ones, which is what
-// lets the old paths be retired once projects have moved.
-const RENAMED_REFERENCES: ReadonlyArray<readonly [RegExp, string]> = [
-	[
-		/@node_modules\/@joshuafolkken\/kit\/dist\/CLAUDE\.static\.md(?![\w.])/gu,
-		'@node_modules/@joshuafolkken/kit/dist/CLAUDE.basic.md',
-	],
-	[/@joshuafolkken\/kit\/prettier\/static(?=['"])/gu, '@joshuafolkken/kit/prettier/basic'],
-]
-
-function migrate_basic_paths(content: string): string {
-	let migrated = content
-
-	for (const [pattern, replacement] of RENAMED_REFERENCES) {
-		migrated = migrated.replaceAll(pattern, () => replacement)
-	}
-
-	return migrated
-}
-
-const basic_path_migration = { migrate_basic_paths }
-export { basic_path_migration }

package/scripts/issue/issue-backlinks-cli.ts

@@ -1,93 +0,0 @@
-#!/usr/bin/env tsx
-import { fileURLToPath } from 'node:url'
-import { git_gh_command } from '#scripts/gh/git-gh-command'
-import { parse_json_object_or_undefined } from '#scripts/git/parse-json-array'
-import { issue_number_shape } from '#scripts/issue/issue-number-shape'
-import { z } from 'zod'
-import { issue_backlinks, type UpstreamEntry } from './issue-backlinks'
-
-// `josh issue:backlinks <N>` — read origin issue N, then the upstream issues it lists, and print one
-// of `ok` / `missing-origin` / `missing-upstream` / `wrong-heading`, exiting non-zero on anything but
-// `ok` so it works as a gate.
-
-const SUCCESS_EXIT_CODE = 0
-const FAILURE_EXIT_CODE = 1
-const ARGV_OFFSET = 2
-const REF_PATTERN = /^([\w.-]+\/[\w.-]+)#(\d+)$/u
-const BODY_FIELD = 'body'
-const USAGE = 'Usage: josh issue:backlinks <issue-number>'
-const READ_FAILURE = '✖ could not read an issue body — a rate limit, expired auth, or a bad number'
-const body_schema = z.object({ body: z.string().nullish() })
-
-function parse_body(raw_json: string | undefined): string | undefined {
-	if (raw_json === undefined) return undefined
-	const parsed = parse_json_object_or_undefined(raw_json, body_schema)
-
-	return parsed === undefined ? undefined : (parsed.body ?? '')
-}
-
-async function read_body(issue_number: string, repo?: string): Promise<string | undefined> {
-	return parse_body(await git_gh_command.issue_view_json(issue_number, BODY_FIELD, repo))
-}
-
-async function read_upstream(reference: string): Promise<UpstreamEntry | undefined> {
-	const match = REF_PATTERN.exec(reference)
-	if (match === null) return undefined
-
-	const [, repo, number = ''] = match
-	const body = await read_body(number, repo)
-
-	return body === undefined ? undefined : { ref: reference, body }
-}
-
-async function read_upstreams(
-	references: ReadonlyArray<string>,
-): Promise<ReadonlyArray<UpstreamEntry> | undefined> {
-	const entries = await Promise.all(
-		references.map(async (reference) => await read_upstream(reference)),
-	)
-
-	return entries.every((entry) => entry !== undefined) ? entries : undefined
-}
-
-async function classify(issue_number: string): Promise<string | undefined> {
-	const origin_body = await read_body(issue_number)
-	if (origin_body === undefined) return undefined
-
-	if (!issue_backlinks.needs_upstreams(origin_body)) {
-		return issue_backlinks.classify_backlinks(origin_body, [])
-	}
-
-	const upstreams = await read_upstreams(issue_backlinks.upstream_refs(origin_body))
-	if (upstreams === undefined) return undefined
-
-	return issue_backlinks.classify_backlinks(origin_body, upstreams)
-}
-
-async function run(argv: ReadonlyArray<string>): Promise<number> {
-	const [issue_number] = argv
-
-	if (issue_number === undefined || !issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue_number)) {
-		console.error(USAGE)
-
-		return FAILURE_EXIT_CODE
-	}
-
-	const verdict = await classify(issue_number)
-
-	if (verdict === undefined) {
-		console.error(READ_FAILURE)
-
-		return FAILURE_EXIT_CODE
-	}
-
-	console.info(verdict)
-
-	return verdict === 'ok' ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE
-}
-
-async function main(argv: ReadonlyArray<string>): Promise<void> {
-	process.exitCode = await run(argv)
-}
-
-if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))

package/scripts/josh/josh-commands-guard.ts

@@ -1,38 +0,0 @@
-import type { CommandEntry } from './josh-command-types'
-
-// The `PreToolUse` guard registry, split out of `josh-commands-ai.ts` so that file stays under its
-// 300-code-line limit, exactly as `LANE_COMMANDS` and `SPLIT_COMMANDS` were for the same reason.
-// It is spread into
-// `AI_COMMANDS` so the guards stay grouped with the other AI tools.
-//
-// **None declare `tsx_arguments`, for the reason `batch:guard` declares none**:
-// declaring any disqualifies a command from in-process dispatch, and these run in front of every read
-// or shell call. Each script calls `process.loadEnvFile` itself instead, through `hook-decision.ts`.
-
-/* eslint-disable @typescript-eslint/naming-convention */
-const GUARD_COMMANDS: Record<string, CommandEntry> = {
-	'investigation:guard': {
-		script: 'scripts/delegation/investigation-guard.ts',
-		description:
-			'Claude Code hook: refuse a read once the unedited-read threshold is reached again (reads the tool call on stdin)',
-		category: 'AI tools',
-		reference: ['', 'automation', ['none']],
-	},
-	'duplicate-read:guard': {
-		script: 'scripts/delegation/duplicate-read-guard.ts',
-		description:
-			'Claude Code hook: refuse a second whole-file read of a path whose content has not changed since the run last read it (reads the tool call on stdin)',
-		category: 'AI tools',
-		reference: ['', 'automation', ['none']],
-	},
-	'rule:guard': {
-		script: 'scripts/rules/rule-guard.ts',
-		description:
-			'Claude Code hook: deliver a trigger-delivered rule at the call that binds it (reads the tool call on stdin)',
-		category: 'AI tools',
-		reference: ['', 'automation', ['none']],
-	},
-}
-/* eslint-enable @typescript-eslint/naming-convention */
-
-export { GUARD_COMMANDS }

package/scripts/josh/josh-usage-automation.ts

@@ -1,121 +0,0 @@
-import type { CommandUsage } from './josh-command-types'
-
-// The usage of the commands `docs/josh-commands-automation.md` documents under "Development",
-// "Project" and "AI tools", keyed by command name. The page's usage blocks are generated from this
-// table and `josh help <command>` prints it, so an example or a flag is written once, here (#3939).
-const STAGED = '--staged'
-const JSON_FLAG = '--json'
-const BRANCH_DIFF = 'the branch diff'
-const STAGED_DIFF = 'the staged diff instead'
-const PR_NUMBER = '42'
-const DRY_RUN = '--dry-run'
-const SKIP_PUBLISH_WAIT = '--skip-publish-wait'
-
-/* eslint-disable @typescript-eslint/naming-convention */
-const AUTOMATION_USAGE: Readonly<Record<string, CommandUsage>> = {
-	'refactor:scan': { examples: [{ arguments: '' }] },
-	'time:density': {
-		examples: [{ arguments: '' }, { arguments: '--lanes 5', note: 'the five most recent lanes' }],
-		flags: [
-			{
-				names: ['--lanes <n>'],
-				description: 'average over a different count of recent qualifying lanes (default 10).',
-			},
-			{
-				names: ['--path <dir>'],
-				description:
-					"read another project's lane transcripts, as `josh time` does. Run it from the main checkout — a lane reads only its own transcript.",
-			},
-		],
-	},
-	'e2e:retry-check': { examples: [{ arguments: '' }] },
-	'sync:scope': {
-		examples: [
-			{ arguments: '', note: BRANCH_DIFF },
-			{ arguments: STAGED, note: STAGED_DIFF },
-			{ arguments: JSON_FLAG, note: '{"scope":"managed","reason":"..."}' },
-		],
-		flags: [
-			{ names: [STAGED], description: 'inspect the staged diff instead of the branch diff.' },
-			{ names: [JSON_FLAG], description: 'emit `{"scope","reason"}` as JSON.' },
-		],
-	},
-	'dogfood:commit': { examples: [{ arguments: '~/Development/kit-test-html-start' }] },
-	'fresh:run': {
-		examples: [
-			{ arguments: '--list', note: "kit's six patterns" },
-			{ arguments: 'kit-test-html-init', note: 'one pattern, the packed checkout' },
-			{
-				arguments: 'kit-test-html-start',
-				note: 'a GitHub pattern, the latest published version',
-			},
-			{ arguments: '--spec fresh/html-init.json', note: 'a scenario another toolkit wrote' },
-		],
-		flags: [
-			{ names: ['--list'], description: 'print the pattern names and run nothing.' },
-			{
-				names: ['--spec <file.json>'],
-				description:
-					'run the scenario in this file instead of a named pattern; the path is relative to the project root.',
-			},
-			{
-				names: ['--package-version <version>'],
-				description:
-					"the published version a `package_source: published` scenario installs. Default: the registry's latest version of the package the command is run from.",
-			},
-			{
-				names: ['--log-dir <dir>'],
-				description: 'where the log is written. Default: `.claude/tmp/fresh-machine`.',
-			},
-			{ names: ['--rebuild'], description: 'build the machine image without the layer cache.' },
-		],
-	},
-	'auth:setup': {
-		examples: [
-			{ arguments: '', note: 'sign in and save the token' },
-			{ arguments: '--check', note: 'ok: … saved on <date>, or missing: … and exit 1' },
-		],
-	},
-	'sonar:hotspots': { examples: [{ arguments: PR_NUMBER }] },
-	'sonar:new-code': { examples: [{ arguments: PR_NUMBER }] },
-	'ui:routes': {
-		examples: [
-			{ arguments: '', note: BRANCH_DIFF },
-			{ arguments: STAGED, note: STAGED_DIFF },
-		],
-	},
-	propagate: {
-		examples: [
-			{ arguments: '' },
-			{ arguments: DRY_RUN, note: 'report targets and steps, write nothing' },
-			{ arguments: SKIP_PUBLISH_WAIT, note: 'release already known to be published' },
-			{ arguments: '--target app-kit', note: 'carry the release into one consumer only' },
-		],
-		flags: [
-			{
-				names: [DRY_RUN],
-				description:
-					'report targets and steps without writing; skips the publish wait, opens no issues.',
-			},
-			{
-				names: [SKIP_PUBLISH_WAIT],
-				description: 'skip the registry poll for an already-published release.',
-			},
-			{
-				names: ['--target <repo>'],
-				description:
-					'process only that consumer (`app-kit` or `joshuafolkken/app-kit`); the rest are reported `skipped` and left untouched. An unknown, ambiguous or non-dependent name fails before the publish wait, writing nothing.',
-			},
-		],
-	},
-	'repo:party': {
-		examples: [
-			{ arguments: 'joshuafolkken/kit', note: '→ first-party (in the kit session)' },
-			{ arguments: 'sveltejs/kit', note: '→ third-party' },
-			{ arguments: '', note: "no argument: the session's own repository" },
-		],
-	},
-}
-/* eslint-enable @typescript-eslint/naming-convention */
-
-export { AUTOMATION_USAGE }

package/scripts/josh/josh-usage-backlog.ts

@@ -1,180 +0,0 @@
-import type { CommandUsage } from './josh-command-types'
-
-// The usage of the epic and backlog commands `docs/josh-commands-backlog.md` documents under "Epics
-// and backlog", keyed by command name. The page's usage blocks are generated from this table and
-// `josh help <command>` prints it, so an example or a flag is written once, here (#3938).
-const EXCLUDE = '--exclude <N>'
-const BUDGET = '--answer candidates --started "$started" --active "$active"'
-const REPO = '--repo <owner/repo>'
-const JUST_MERGED = 'skip the issue just merged'
-const EXCLUDE_1630 = '--exclude 1630'
-
-/* eslint-disable @typescript-eslint/naming-convention */
-const BACKLOG_USAGE: Readonly<Record<string, CommandUsage>> = {
-	epic: {
-		examples: [
-			{ arguments: '"Epic: split the parser work" 101 102 103' },
-			{ arguments: '"Epic: staged rollout" 101 102 --ordered' },
-			{ arguments: '"Epic: ..." 101 102 --rationale-file rationale.md' },
-			{ arguments: '--promote 858 101 102 103', note: 'turn an existing issue into an epic' },
-			{ arguments: '--add 893 894', note: 'track #894, declaring no order for it' },
-			{ arguments: '--add 893 894 --before 891', note: '#894 must finish before #891' },
-			{ arguments: '--add 893 894 --after 890', note: '#894 starts once #890 is done' },
-			{ arguments: '--add 893 894 --decision-file why.md', note: '…and record why, in one call' },
-			{
-				arguments: '--reconcile 2184',
-				note: 'rewrite the body to match the recorded blocked-by, and record any order the body declared',
-			},
-		],
-		flags: [
-			{
-				names: ['--ordered'],
-				description:
-					'argument order is the dependency order; writes the arrow chain, records the matching `blocked-by` relations, and adds a `### Declared order` entry under `## Decisions`.',
-			},
-			{
-				names: ['--rationale-file <path|->'],
-				description: 'split rationale prose (`-` reads stdin).',
-			},
-			{
-				names: ['--origin <owner/repo#N>'],
-				description: 'backlink when the split originated in another repository.',
-			},
-			{
-				names: ['--before <M>'],
-				description:
-					'with `--add`: insert before `#M`, re-pointing what `#M` was waiting on so the chain is never broken.',
-			},
-			{
-				names: ['--after <M>'],
-				description:
-					'with `--add`: start after `#M`; branches when `#M` already has a successor, extends when it is a tail.',
-			},
-			{
-				names: ['--order-before <M>', '--order-after <M>'],
-				description: 'with `--add`: move the task-list row only; write no `blocked-by` relation.',
-			},
-			{
-				names: ['--decision-file <path|->'],
-				description: 'with `--add`: record why the child was placed.',
-			},
-			{
-				names: ['--remove <E> <M> <N> [<N2> …]'],
-				description:
-					'delete a declared order from the body and the relations; each consecutive pair is one link.',
-			},
-		],
-	},
-	'epic:next': {
-		examples: [
-			{ arguments: '858' },
-			{ arguments: '858 --repo joshuafolkken/kit', note: 'just the next child for one repository' },
-			{ arguments: '858 --repo joshuafolkken/kit --lanes', note: 'one child per free lane there' },
-		],
-		flags: [
-			{
-				names: [REPO],
-				description:
-					'answer for one repository; stdout carries one token (an issue number, or `wait`/`stop`/`complete`), everything else on stderr.',
-			},
-			{
-				names: ['--lanes'],
-				description:
-					'print one issue number per free lane (requires `--repo`); `JOSH_LANE_LIMIT` sets the ceiling, default 4. Prints `triage` instead while any candidate carries neither `run:solo` nor `run:lane` (the triage gate in `josh backlog:next`).',
-			},
-		],
-	},
-	'epic:bundle': { examples: [{ arguments: '874' }] },
-	'epic:audit': { examples: [{ arguments: '858' }] },
-	'epic:check': { examples: [{ arguments: '700' }] },
-	'auto-ok:next': {
-		examples: [{ arguments: '' }, { arguments: '--exclude 906', note: JUST_MERGED }],
-		flags: [
-			{
-				names: [EXCLUDE],
-				description: 'drop issues from the answer; comma-separated, repeatable.',
-			},
-		],
-	},
-	'auto-ok:judge': {
-		examples: [
-			{ arguments: '', note: 'the issues that still owe a judgement' },
-			{ arguments: '--apply 912 --lane', note: 'opt it in, with its run label' },
-			{ arguments: '--decline 913 --reason "<why>"', note: 'record why it stays out' },
-		],
-		flags: [
-			{
-				names: ['--apply <N> --lane|--solo'],
-				description:
-					'checks the exclusions again against the labels as they stand, applies the run label and then `auto-ok`, and notes it on the progress board.',
-			},
-			{ names: ['--decline <N> --reason <text>'], description: 'applies nothing.' },
-		],
-	},
-	'backlog:next': {
-		examples: [{ arguments: '' }, { arguments: EXCLUDE_1630, note: JUST_MERGED }],
-		flags: [
-			{
-				names: [EXCLUDE],
-				description: 'drop issues from every bucket; comma-separated, repeatable.',
-			},
-		],
-	},
-	'backlog:plan': {
-		examples: [
-			{ arguments: '' },
-			{ arguments: EXCLUDE_1630, note: 'after #1630 merged' },
-			{ arguments: '--waves', note: 'the run order, wave by wave' },
-		],
-		flags: [
-			{ names: [EXCLUDE], description: 'same exclusion as `backlog:next`.' },
-			{
-				names: ['--waves'],
-				description:
-					'print the order the run takes, wave by wave, assuming each wave merges before the next. Read-only.',
-			},
-		],
-	},
-	'backlog:stalled': { examples: [{ arguments: '' }] },
-	'backlog:budget': {
-		examples: [
-			{ arguments: BUDGET },
-			{ arguments: '--answer exhausted --started "$started" --active "$active" --idle 60' },
-			{ arguments: `${BUDGET} --merged 3 --running 2 --max 5` },
-		],
-		flags: [
-			{
-				names: ['--answer <candidates|exhausted|blocked|parked|unreadable|untriaged>'],
-				description: "`backlog:next`'s answer, mapped.",
-			},
-			{
-				names: ['--started', '--active'],
-				description:
-					'when the invocation began / when it last had work (required unless the watch is off).',
-			},
-			{
-				names: ['--idle <minutes>'],
-				description:
-					'once nothing can proceed, keep polling this long, counted from `--active` (default 480, 8 hours; `--idle 0` turns the watch off).',
-			},
-			{
-				names: ['--max <count>'],
-				description:
-					'issues one invocation may take (default unlimited); `--merged` and `--running` count against it.',
-			},
-			{
-				names: ['--json'],
-				description: 'collapse verdict and reason into `{"budget": "<verdict>", "reason": "…"}`.',
-			},
-		],
-	},
-	'backlog:offer': {
-		examples: [{ arguments: '--started "$started" --active "$active" --running 2 --retries 1' }],
-	},
-	'backlog:drive': {
-		examples: [{ arguments: '--owner "$PPID" [--max <n>] [--idle <minutes>] [--only]' }],
-	},
-}
-/* eslint-enable @typescript-eslint/naming-convention */
-
-export { BACKLOG_USAGE }