@joshuafolkken/kit 1.1471.0 → 1.1784.0

package/dist/hooks/chunk-YYPI7SJZ.js

@@ -1,131 +0,0 @@
-import {
-  investigation_reads
-} from "./chunk-H5HVWYXK.js";
-import {
-  lane_guard_policy
-} from "./chunk-SHGPANFB.js";
-import {
-  hook_decision
-} from "./chunk-J47HU5H5.js";
-import {
-  time_spans
-} from "./chunk-AS74OU3D.js";
-import {
-  json_value
-} from "./chunk-E7OIKX5Z.js";
-
-// scripts/delegation/duplicate-read-guard.ts
-import { statSync } from "node:fs";
-import { text } from "node:stream/consumers";
-import { fileURLToPath } from "node:url";
-var SWITCH_ENV_KEY = "JOSH_DUPLICATE_READ_GUARD";
-var LANE_GUARD_ID = "duplicate-read";
-var STAMP_PREFIX = "josh-duplicate-read-guard-";
-var NOTICE_STAMP_PREFIX = "josh-duplicate-read-notice-";
-var READ_TOOL = "Read";
-var GLOB_CHARACTERS = /[*?]/u;
-var REASON = `\u26D4 duplicate read: this file was already read in this session and has not changed since (its mtime predates that read), so reading it again returns nothing new. Scroll up to the earlier result instead of re-reading it. A read with a new offset/limit, or of a file that has since changed, is allowed; set \`JOSH_DUPLICATE_READ_GUARD=off\` to disable this guard.`;
-var NOTICE = `\u26A0 duplicate read: this file was already read in this session and has not changed since, so re-reading it returns nothing new \u2014 scroll up to the earlier result instead of re-reading it. Set \`JOSH_DUPLICATE_READ_GUARD=off\` to silence this.`;
-function is_paginated(input) {
-  return input["offset"] !== void 0 || input["limit"] !== void 0;
-}
-function names_one_file(file_path) {
-  return typeof file_path === "string" && file_path !== "" && !GLOB_CHARACTERS.test(file_path);
-}
-function read_target(call) {
-  if (call.name !== READ_TOOL || !json_value.is_record(call.input)) return void 0;
-  const { input } = call;
-  if (is_paginated(input) || !names_one_file(input["file_path"])) return void 0;
-  return investigation_reads.resolved(input["file_path"]);
-}
-function is_refusable_call(call) {
-  return read_target(call) !== void 0;
-}
-function is_successful_read(span) {
-  const is_read = investigation_reads.READ_TOOLS.has(span.label);
-  return is_read && span.outcome !== time_spans.FAILED_OUTCOME;
-}
-function reads_target(span, target) {
-  return span.targets.some((one) => investigation_reads.resolved(one) === target);
-}
-function last_read_ms(spans, target) {
-  const times = spans.filter((span) => is_successful_read(span) && reads_target(span, target)).map((span) => span.ended_ms);
-  return times.length === 0 ? hook_decision.NEVER_MS : Math.max(...times);
-}
-function file_mtime_ms(target) {
-  try {
-    return statSync(target).mtimeMs;
-  } catch {
-    return void 0;
-  }
-}
-function read_window(tail, target) {
-  const { spans, started_ms } = time_spans.parse_timeline(tail);
-  return { last_ms: last_read_ms(spans, target), window_start_ms: started_ms };
-}
-function is_unchanged_reread(last_ms, mtime) {
-  if (mtime === void 0 || last_ms === hook_decision.NEVER_MS) return false;
-  return mtime < last_ms;
-}
-function is_rearmed(window, fired_at_ms) {
-  if (fired_at_ms === hook_decision.NEVER_MS || fired_at_ms < window.window_start_ms) return true;
-  return window.last_ms > fired_at_ms;
-}
-function is_redundant_reread(tail, call, fired_at_ms) {
-  const target = read_target(call);
-  if (target === void 0) return false;
-  const window = read_window(tail, target);
-  if (!is_unchanged_reread(window.last_ms, file_mtime_ms(target))) return false;
-  return is_rearmed(window, fired_at_ms);
-}
-function duplicate_mode() {
-  return lane_guard_policy.mode_here(LANE_GUARD_ID);
-}
-function is_candidate(call) {
-  return is_refusable_call(call) && duplicate_mode() !== "off";
-}
-function should_block_here(tail, call, refused_at_ms) {
-  if (duplicate_mode() !== "refuse") return false;
-  return is_redundant_reread(tail, call, refused_at_ms);
-}
-function should_notify_here(tail, call, notified_at_ms) {
-  if (duplicate_mode() !== "notice") return false;
-  return is_redundant_reread(tail, call, notified_at_ms);
-}
-var GUARD = hook_decision.create_transcript_guard({
-  prefix: STAMP_PREFIX,
-  switch_key: SWITCH_ENV_KEY,
-  is_candidate,
-  should_block: should_block_here,
-  reason: REASON,
-  notify: {
-    prefix: NOTICE_STAMP_PREFIX,
-    should_notify: should_notify_here,
-    text: () => NOTICE
-  }
-});
-var duplicate_read_refusal = GUARD.refusal;
-var duplicate_read_outcome = GUARD.outcome;
-var { is_enabled, refusal_path } = GUARD;
-var notice_refusal_path = hook_decision.create_refusal_stamp(NOTICE_STAMP_PREFIX).path;
-var { deny_envelope, DISABLED_VALUES } = hook_decision;
-var duplicate_reads = {
-  REASON,
-  NOTICE
-};
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
-  if (process.stdin.isTTY) hook_decision.report_no_payload("duplicate-read:guard");
-  else hook_decision.write_outcome(await text(process.stdin), duplicate_read_outcome);
-}
-
-export {
-  SWITCH_ENV_KEY,
-  duplicate_read_refusal,
-  duplicate_read_outcome,
-  is_enabled,
-  refusal_path,
-  notice_refusal_path,
-  deny_envelope,
-  DISABLED_VALUES,
-  duplicate_reads
-};

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-YYPI7SJZ.js";
-import "./chunk-H5HVWYXK.js";
-import "./chunk-SHGPANFB.js";
-import "./chunk-J47HU5H5.js";
-import "./chunk-AS74OU3D.js";
-import "./chunk-K4EOONYM.js";
-import "./chunk-E7OIKX5Z.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,32 +0,0 @@
-#!/usr/bin/env tsx
-import {
-  DISABLED_VALUES,
-  NOTICE,
-  SWITCH_ENV_KEY,
-  deny_envelope,
-  investigation_notice_path,
-  investigation_outcome,
-  investigation_refusal,
-  is_enabled,
-  load_environment_file,
-  refusal_path
-} from "./chunk-K4LMBQC2.js";
-import "./chunk-H5HVWYXK.js";
-import "./chunk-SHGPANFB.js";
-import "./chunk-J47HU5H5.js";
-import "./chunk-AS74OU3D.js";
-import "./chunk-K4EOONYM.js";
-import "./chunk-E7OIKX5Z.js";
-import "./chunk-DGT54IH5.js";
-export {
-  DISABLED_VALUES,
-  NOTICE,
-  SWITCH_ENV_KEY,
-  deny_envelope,
-  investigation_notice_path,
-  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/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/lint/cross-file-recheck.ts

@@ -1,155 +0,0 @@
-import { FAIL_EXIT_CODE, type BufferedProcessResult } from '#scripts/lib/buffered-process'
-import type { ESLint } from 'eslint'
-
-// Some rules read other files, and the lint cache keys a verdict on the linted file's own content.
-// So once the other file is fixed, the untouched one keeps its cached error until its own content
-// changes. `import/no-cycle` did it first (joshuafolkken/kit#3641): a cycle closed by editing one
-// side stayed reported on the other. The type-aware rules do it too (joshuafolkken/kit#3667): a call
-// to a function its module did not export yet stays `no-unsafe-call` after the export is added.
-//
-// A red lint run therefore re-reads its cached report: the files reported for a rule that reads
-// other files are linted once more without the cache, and their fresh results replace the cached
-// ones. A green run never reaches this, so the green path costs what it did.
-//
-// Which rules those are is the rule's own statement, never a list kept here: a type-aware rule
-// declares `requiresTypeChecking`, and the `import` plugin's rules resolve the modules they name.
-// That plugin answers to two names: the base config registers it as `import`, and its own preset —
-// whose rules a hand-authored `.js` file keeps — as `import-x`.
-//
-// Only a stale red is re-read. A stale green — the other file broke, the untouched one still
-// answers clean — is not something a report can point at; the type check is what catches it.
-//
-// That holds for a run narrowed to one change's files as much as for the whole tree: the change can
-// hold both files, and the one a later edit leaves alone keeps its cached report.
-//
-// The cached run is asked again through the Node API rather than read off the first run's report:
-// that report is the stylish text, and taking a file out of it means re-deriving its problem
-// counts. The second asking is answered from the cache the first one just wrote.
-const IMPORT_RULE_PATTERN = /^import(?:-x)?\//u
-const FORMATTER = 'stylish'
-const UNCACHED_SUFFIX = '.uncached'
-
-type RulesMeta = ESLint.LintResultData['rulesMeta']
-
-interface Linters {
-	cached: ESLint
-	fresh: ESLint
-}
-
-interface CrossFileRecheckOptions {
-	cache_file: string
-	// What the run linted — the whole tree, or one change's files — so the cached run is asked the
-	// question it was asked the first time.
-	patterns: ReadonlyArray<string>
-	// What the fixture test varies: the directory linted and the configuration it is linted with.
-	eslint_options?: ESLint.Options
-}
-
-// The exit code is eslint's "finished and reported problems", not any failure: a run that could not
-// finish — a configuration that does not load, a rule that threw — exits 2, and asking it again
-// throws the same error here, ahead of both buffered reports.
-function is_red(result: BufferedProcessResult): boolean {
-	return result.exit_code === FAIL_EXIT_CODE
-}
-
-// `requiresTypeChecking` is typescript-eslint's convention, which other type-aware plugins follow;
-// eslint's own type for a rule's docs does not name it.
-function is_type_aware(documentation: object | undefined): boolean {
-	if (documentation === undefined) return false
-
-	return 'requiresTypeChecking' in documentation && documentation.requiresTypeChecking === true
-}
-
-// A problem with no rule is the parser's, about the file itself.
-function reads_other_files(rule_id: string | null, rules_meta: RulesMeta): boolean {
-	if (rule_id === null) return false
-
-	return IMPORT_RULE_PATTERN.test(rule_id) || is_type_aware(rules_meta[rule_id]?.docs)
-}
-
-function suspects_of(linter: ESLint, cached: Array<ESLint.LintResult>): Array<string> {
-	const rules_meta = linter.getRulesMetaForResults(cached)
-
-	return cached
-		.filter((result) =>
-			result.messages.some((message) => reads_other_files(message.ruleId, rules_meta)),
-		)
-		.map((result) => result.filePath)
-}
-
-function cached_options(options: CrossFileRecheckOptions): ESLint.Options {
-	return {
-		...options.eslint_options,
-		cache: true,
-		cacheStrategy: 'content',
-		cacheLocation: options.cache_file,
-	}
-}
-
-// A linter that runs without a cache deletes the cache file it would have used, and that defaults to
-// the very file the lint run keeps. So the uncached linter is pointed at a sibling path nothing
-// ever writes: the re-reading must not cost the next run its whole cache.
-function fresh_options(options: CrossFileRecheckOptions): ESLint.Options {
-	return {
-		...options.eslint_options,
-		cache: false,
-		cacheLocation: `${options.cache_file}${UNCACHED_SUFFIX}`,
-	}
-}
-
-// `eslint` is loaded here, only past a red report: it is an optional peer a basic-profile
-// consumer may not have, and this module is imported by the entry of every `josh lint`, which has to
-// reach its skip notice there.
-async function create_linters(options: CrossFileRecheckOptions): Promise<Linters> {
-	const eslint = await import('eslint')
-
-	return {
-		cached: new eslint.ESLint(cached_options(options)),
-		fresh: new eslint.ESLint(fresh_options(options)),
-	}
-}
-
-async function lint_fresh(
-	linter: ESLint,
-	suspects: Array<string>,
-): Promise<Map<string, ESLint.LintResult>> {
-	const fresh = await linter.lintFiles(suspects)
-
-	return new Map(fresh.map((result) => [result.filePath, result]))
-}
-
-async function report(
-	linter: ESLint,
-	results: Array<ESLint.LintResult>,
-): Promise<Pick<BufferedProcessResult, 'output' | 'exit_code'>> {
-	const formatter = await linter.loadFormatter(FORMATTER)
-	const is_failed = results.some((result) => result.errorCount > 0)
-
-	return { output: await formatter.format(results), exit_code: is_failed ? FAIL_EXIT_CODE : 0 }
-}
-
-// A red about rules that read nothing else is handed back as the run reported it: its cached
-// verdicts are about the files they are keyed on.
-async function verify(
-	result: BufferedProcessResult,
-	options: CrossFileRecheckOptions,
-): Promise<BufferedProcessResult> {
-	if (!is_red(result)) return result
-	const started_at = performance.now()
-	const linters = await create_linters(options)
-	const cached = await linters.cached.lintFiles([...options.patterns])
-	const suspects = suspects_of(linters.cached, cached)
-	if (suspects.length === 0) return result
-	const fresh = await lint_fresh(linters.fresh, suspects)
-	const verified = await report(
-		linters.fresh,
-		cached.map((entry) => fresh.get(entry.filePath) ?? entry),
-	)
-
-	return { ...verified, elapsed_ms: result.elapsed_ms + performance.now() - started_at }
-}
-
-const cross_file_recheck = { verify }
-
-export type { CrossFileRecheckOptions }
-export { cross_file_recheck }