@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-AFGEGGIF.js

@@ -0,0 +1,17 @@
+import {
+  issue_state_cli
+} from "./chunk-6TOWGIY2.js";
+import {
+  has_parked_label
+} from "./chunk-QQBMVC5W.js";
+
+// scripts/lane/lane-parked.ts
+async function is_parked(issue) {
+  const read = await issue_state_cli.read_issue(issue);
+  return read.kind === "state" && has_parked_label(read.state.labels);
+}
+var lane_parked = { is_parked };
+
+export {
+  lane_parked
+};

package/dist/commands/chunk-AJTXSSRD.js

@@ -0,0 +1,29 @@
+import {
+  run_event_scope,
+  run_event_stream_emit
+} from "./chunk-XO7S2BTY.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+
+// scripts/run/event/run-event-plan.ts
+var KIND = run_event_stream.EVENT_KIND.PLAN;
+var PLAN_VERB = "planned";
+function plan_text(issue) {
+  return `${PLAN_VERB} ${issue_cite.plain_for("program", issue)}`;
+}
+function has_plan(events, issue) {
+  return run_event_scope.since_own_launch(events, issue).some((event) => event.kind === KIND && run_event_scope.issue_named(event) === issue);
+}
+async function emit_plan(issue) {
+  if (has_plan(await run_event_stream_emit.invocation_or_all_events(), issue)) return;
+  await run_event_stream_emit.emit(KIND, plan_text(issue));
+}
+var run_event_plan = { emit_plan, plan_text };
+
+export {
+  run_event_plan
+};

package/dist/commands/chunk-AKM3BHVJ.js

@@ -0,0 +1,48 @@
+import {
+  run_carry_reclaim
+} from "./chunk-Z2GZIWAU.js";
+import {
+  run_carry,
+  run_carry_conversation
+} from "./chunk-JSJS3OT7.js";
+import {
+  agent_provider,
+  cost_transcript
+} from "./chunk-DDZVMXZD.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/run/wake/run-wake-handoff.ts
+import { existsSync } from "node:fs";
+function session_owner(session) {
+  if (session.provider === agent_provider.OPENAI_PROVIDER) {
+    return { session: session.session_id, is_headless: true };
+  }
+  const directory = cost_transcript.transcript_directory(session.worktree);
+  const transcript = run_carry_conversation.transcript_of(session.session_id, directory);
+  return { transcript, is_headless: true };
+}
+function hand_off(target) {
+  const read = run_carry.read_carry(target);
+  if (read.kind !== "carried" || read.carry.is_handed_off === true) return;
+  stamp_file.replace_stamp(target, { ...read.carry, is_handed_off: true });
+}
+function hand_to(target, owner) {
+  const read = run_carry.read_carry(target);
+  if (read.kind !== "carried") return;
+  run_carry.adopt_carry(target, read.carry, { ...owner, provider: read.carry.scheduler_provider });
+}
+function hand_on(target, owner, pid) {
+  if (owner.transcript === void 0 && owner.session === void 0) return;
+  const process_owner = run_carry.owner_of(pid, void 0, owner.transcript);
+  run_carry_reclaim.reclaim_at(target, { ...process_owner, session: owner.session });
+}
+function has_session_begun(carry) {
+  return carry.owner_transcript === void 0 || existsSync(carry.owner_transcript);
+}
+var run_wake_handoff = { hand_off, session_owner, hand_to, hand_on, has_session_begun };
+
+export {
+  run_wake_handoff
+};

package/dist/commands/chunk-AL2H63BP.js

@@ -0,0 +1,48 @@
+import {
+  change_base
+} from "./chunk-FVPRBMHE.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+
+// scripts/git/changed-paths.ts
+function to_paths(raw) {
+  return raw.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+}
+async function tracked_names() {
+  const base = await change_base.resolved_through_merge();
+  if (base === void 0) {
+    return { tracked: to_paths(await git_command.diff_main_names()), base: "fallback" };
+  }
+  return { tracked: to_paths(await git_command.diff_names_since(base)), base: "merge_base" };
+}
+async function read_changed_parts() {
+  const { tracked, base } = await tracked_names();
+  const untracked = to_paths(await git_command.untracked_names());
+  return { tracked, untracked, base };
+}
+async function read_changed_paths(is_staged) {
+  if (is_staged) return to_paths(await git_command.diff_cached_names());
+  const { tracked, untracked } = await read_changed_parts();
+  return [...tracked, ...untracked];
+}
+async function read_changed_since(commit) {
+  const tracked = to_paths(await git_command.diff_names_since(commit));
+  const untracked = to_paths(await git_command.untracked_names());
+  return [.../* @__PURE__ */ new Set([...tracked, ...untracked])];
+}
+async function read_held_at(commit, paths) {
+  if (paths.length === 0) return [];
+  return to_paths(await git_command.tree_names_at(commit, paths));
+}
+var changed_paths = {
+  read_changed_parts,
+  read_changed_paths,
+  read_changed_since,
+  read_held_at,
+  to_paths
+};
+
+export {
+  changed_paths
+};

package/dist/commands/chunk-AMQNHTDN.js

@@ -0,0 +1,60 @@
+import {
+  stash_args
+} from "./chunk-R7IT5VOL.js";
+import {
+  main_merge_guard
+} from "./chunk-LDYDRXOY.js";
+import {
+  git_stash
+} from "./chunk-5KEESWMC.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/git/stash/stash-push-cli.ts
+var COMMAND = "stash:push";
+var STASH_RERUN = "the command that stashed (`run:pause`, `stash:push`, `latest:if-required`)";
+var STASHED_VERDICT = "stashed";
+var CLEAN_VERDICT = "clean";
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+function report(verdict, detail) {
+  console.info(verdict);
+  console.error(detail);
+  return SUCCESS_EXIT_CODE;
+}
+function refuse() {
+  console.error(stash_args.usage(COMMAND));
+  return FAILURE_EXIT_CODE;
+}
+async function set_aside(request) {
+  const unmerged = await git_stash.unmerged_paths(request.dir);
+  if (unmerged.length > 0) {
+    throw new Error(main_merge_guard.unresolved_message(COMMAND, unmerged, STASH_RERUN));
+  }
+  if (!await git_stash.has_stashable_changes(request.dir)) return CLEAN_VERDICT;
+  await git_stash.push(request.message, request.dir, git_stash.STASHABLE_PATHSPEC);
+  return STASHED_VERDICT;
+}
+async function answer(request) {
+  if (await set_aside(request) === CLEAN_VERDICT) {
+    return report(CLEAN_VERDICT, "Nothing to stash.");
+  }
+  return report(STASHED_VERDICT, `Stashed as "${request.message}".`);
+}
+async function run(argv) {
+  const parsed = stash_args.read_arguments(argv);
+  const request = parsed === void 0 ? void 0 : stash_args.to_request(parsed);
+  if (request === void 0) return refuse();
+  try {
+    return await answer(request);
+  } catch (error) {
+    console.error(error_text.message_of(error));
+    return FAILURE_EXIT_CODE;
+  }
+}
+var stash_push_cli = { CLEAN_VERDICT, STASHED_VERDICT, run, set_aside };
+
+export {
+  stash_push_cli
+};

package/dist/commands/chunk-AQGVQMWF.js

@@ -0,0 +1,168 @@
+import {
+  propagate_publish
+} from "./chunk-YPCMBQYP.js";
+import {
+  derive_versions_endpoint
+} from "./chunk-SADJPNDB.js";
+import {
+  repo_map_logic
+} from "./chunk-MDKDJF2K.js";
+import {
+  repo_origin
+} from "./chunk-4ZHWTTQW.js";
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  git_gh_exec
+} from "./chunk-NAZ753DE.js";
+import {
+  GH_API_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/epic/epic-cross-repo.ts
+import { load } from "js-yaml";
+function package_name_for(repo) {
+  const identity = repo_origin.parse_origin_url(`https://${repo_origin.GITHUB_HOST}/${repo}`);
+  if (identity === void 0) return void 0;
+  return `@${identity.owner}/${identity.repo}`;
+}
+var published_cache = /* @__PURE__ */ new Map();
+function fetch_versions_for(repo) {
+  const package_name = package_name_for(repo);
+  if (package_name === void 0) return void 0;
+  return propagate_publish.fetch_published_versions(derive_versions_endpoint(package_name));
+}
+function published_versions(repo) {
+  if (published_cache.has(repo)) return published_cache.get(repo);
+  const versions = fetch_versions_for(repo);
+  published_cache.set(repo, versions);
+  return versions;
+}
+var version_cache = /* @__PURE__ */ new Map();
+function reset_publish_cache() {
+  published_cache.clear();
+  version_cache.clear();
+}
+function is_published(repo, version) {
+  const versions = published_versions(repo);
+  if (versions === void 0) return false;
+  return propagate_publish.is_version_published(versions, version);
+}
+var VERSION_JQ = ".content | @base64d | fromjson | {version, private, workspaces} | tojson";
+var PNPM_WORKSPACE_FILE = "pnpm-workspace.yaml";
+var WORKSPACE_JQ = ".content | @base64d";
+var NOT_FOUND_STATUS = 404;
+function manifest_path(repo) {
+  return `${git_gh_api_path.repo_api_path(repo)}/contents/package.json`;
+}
+function declares_packages(yaml) {
+  try {
+    const parsed = load(yaml);
+    if (typeof parsed !== "object" || parsed === null) return false;
+    const { packages } = parsed;
+    return Array.isArray(packages) && packages.length > 0;
+  } catch {
+    return false;
+  }
+}
+function pnpm_workspace_path(repo) {
+  return `${git_gh_api_path.repo_api_path(repo)}/contents/${PNPM_WORKSPACE_FILE}`;
+}
+function classify_workspace_failure(repo) {
+  const status = git_gh_exec.exec_gh_api_status_sync(pnpm_workspace_path(repo), GH_API_TIMEOUT_MS);
+  return status === NOT_FOUND_STATUS ? "single" : "unreadable";
+}
+function read_pnpm_workspace(repo) {
+  const stdout = git_gh_exec.read_gh_api_sync({
+    path: pnpm_workspace_path(repo),
+    jq_filter: WORKSPACE_JQ,
+    timeout_ms: GH_API_TIMEOUT_MS
+  });
+  if (stdout === void 0) return classify_workspace_failure(repo);
+  return declares_packages(stdout) ? "workspace" : "single";
+}
+function declared_workspaces(declared) {
+  if (declared === void 0 || declared === null) return void 0;
+  if (Array.isArray(declared)) return declared.length > 0 ? "workspace" : "single";
+  return "workspace";
+}
+function workspace_check(repo, fields) {
+  return declared_workspaces(fields.workspaces) ?? read_pnpm_workspace(repo);
+}
+function to_answer(repo, fields) {
+  const version = typeof fields.version === "string" ? fields.version : void 0;
+  if (fields.private !== true) {
+    return { kind: "manifest", version, is_private: false, is_workspace: false };
+  }
+  const check = workspace_check(repo, fields);
+  if (check === "unreadable") return { kind: "unreadable" };
+  return { kind: "manifest", version, is_private: true, is_workspace: check === "workspace" };
+}
+function to_manifest(repo, stdout) {
+  const parsed = json_value.parse_or_undefined(stdout.trim());
+  if (typeof parsed !== "object" || parsed === null) return { kind: "unreadable" };
+  return to_answer(repo, parsed);
+}
+function classify_manifest_failure(repo) {
+  const status = git_gh_exec.exec_gh_api_status_sync(manifest_path(repo), GH_API_TIMEOUT_MS);
+  return { kind: status === NOT_FOUND_STATUS ? "absent" : "unreadable" };
+}
+function fetch_manifest(repo) {
+  const stdout = git_gh_exec.read_gh_api_sync({
+    path: manifest_path(repo),
+    jq_filter: VERSION_JQ,
+    timeout_ms: GH_API_TIMEOUT_MS
+  });
+  return stdout === void 0 ? classify_manifest_failure(repo) : to_manifest(repo, stdout);
+}
+function read_manifest(repo) {
+  const cached = version_cache.get(repo);
+  if (cached !== void 0) return cached;
+  const answer = fetch_manifest(repo);
+  version_cache.set(repo, answer);
+  return answer;
+}
+function read_default_branch_version(repo) {
+  const answer = read_manifest(repo);
+  return answer.kind === "manifest" ? answer.version : void 0;
+}
+function publishes_nothing(repo) {
+  const answer = read_manifest(repo);
+  if (answer.kind === "absent") return true;
+  return answer.kind === "manifest" && answer.is_private && !answer.is_workspace;
+}
+function publish_verdict(repo, version) {
+  if (publishes_nothing(repo)) return "resolved";
+  if (version === void 0) return "time";
+  return is_published(repo, version) ? "resolved" : "time";
+}
+function resolve_cross_repo(blocker, blocked, read_target_version = read_default_branch_version) {
+  if (blocker.state !== "CLOSED") return "inherit";
+  if (blocker.repo === blocked.repo) return "resolved";
+  return publish_verdict(blocker.repo, read_target_version(blocker.repo));
+}
+function owner_of(repo) {
+  return repo.split("/", 1)[0] ?? "";
+}
+function is_same_owner_repo(repo, current_owner) {
+  const identity = repo_origin.parse_origin_url(`https://${repo_origin.GITHUB_HOST}/${repo}`);
+  if (identity === void 0) return false;
+  return repo_map_logic.is_same_owner(identity, current_owner);
+}
+var epic_cross_repo = {
+  publishes_nothing,
+  read_default_branch_version,
+  reset_publish_cache,
+  package_name_for,
+  resolve_cross_repo,
+  owner_of,
+  is_same_owner_repo
+};
+
+export {
+  epic_cross_repo
+};

package/dist/commands/chunk-B4OZF4XL.js

@@ -0,0 +1,89 @@
+import {
+  run_park
+} from "./chunk-TLCFZAL4.js";
+import {
+  bash_triggers
+} from "./chunk-25LVQDOF.js";
+import {
+  shell_segments
+} from "./chunk-CVJHQOI3.js";
+import {
+  lane_handoff
+} from "./chunk-5QICRFVL.js";
+import {
+  NEEDS_DECISION_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+
+// scripts/rules/lane-park.ts
+var NOTIFY_COMMANDS = /* @__PURE__ */ new Set(["notify"]);
+var CONFIRMATION_TASK_TYPE = /(?:^|\s)--task-type[=\s]+["']?confirmation\b/u;
+function is_confirmation_notify(command) {
+  return shell_segments.segments_of(command).some(
+    (segment) => shell_segments.is_josh_command(segment, NOTIFY_COMMANDS) && CONFIRMATION_TASK_TYPE.test(segment)
+  );
+}
+var NOTIFY_INVOCATION = /josh\s+(?:notify|nf)\b/u;
+var COMMAND_NOTIFY_MARKER = "stop notified: a confirmation Telegram was sent by this command";
+function mentions_confirmation_notify(text) {
+  if (text.includes(COMMAND_NOTIFY_MARKER)) return true;
+  return NOTIFY_INVOCATION.test(text) && CONFIRMATION_TASK_TYPE.test(text);
+}
+function is_parking_child(directory = process.cwd(), source = process.env) {
+  return lane_child_marker.is_child_of(directory, source) && !lane_handoff.is_handed_off(directory, source);
+}
+function is_unparked_child(directory = process.cwd(), source = process.env) {
+  if (!is_parking_child(directory, source)) return false;
+  const issue = lane_child_marker.marked_issue(source);
+  return issue === void 0 || !run_park.is_parked_sync(issue, directory);
+}
+function is_unparked_stop(command, is_child = is_unparked_child) {
+  if (!is_confirmation_notify(command)) return false;
+  return is_child();
+}
+function is_unparked_stop_in(command, context) {
+  return is_unparked_stop(command, () => is_unparked_child(context.cwd, context.env));
+}
+var APPLIES_NEEDS_DECISION = new RegExp(
+  String.raw`(?:labels\[\]=|--add-label[= ]'?)${NEEDS_DECISION_LABEL}\b`,
+  "u"
+);
+var PARK_COMMANDS = /* @__PURE__ */ new Set(["run:park"]);
+var CLEAR_FLAG = /(?:^|\s)--clear\b/u;
+function is_park_command(segment) {
+  return shell_segments.is_josh_command(segment, PARK_COMMANDS) && !CLEAR_FLAG.test(segment);
+}
+function records_the_park(command) {
+  if (APPLIES_NEEDS_DECISION.test(command)) return true;
+  return shell_segments.segments_of(command).some((segment) => is_park_command(segment));
+}
+var LANE_PARK_REASON = "\u26D4 lane child park: this session is a dispatched lane child, so a stop for a person parks first: `pnpm josh run:park <N> --body-file <path>` (options, tiers, recommendation, stash \u2014 it applies `needs-decision`); a `needs-human-review` / `already-done` stop already is. The park is the stop: no notify after it. Refused once per run (`.claude/skills/workflow-commands/pre-gate-cut.md`).";
+var ROW = {
+  id: "lane-park",
+  is_trigger: bash_triggers.on_bash_command(is_unparked_stop_in),
+  reason: LANE_PARK_REASON,
+  keeps: bash_triggers.on_bash_command(records_the_park),
+  about: {
+    title: "Lane child park",
+    topic: "`.claude/skills/workflow-commands/pre-gate-cut.md`",
+    fires: "a dispatched lane child issuing `pnpm josh notify --task-type confirmation`",
+    quiet: "not a lane child, or not a stop notification"
+  }
+};
+var lane_park = {
+  COMMAND_NOTIFY_MARKER,
+  LANE_PARK_REASON,
+  ROW,
+  is_confirmation_notify,
+  is_parking_child,
+  is_unparked_child,
+  is_unparked_stop,
+  mentions_confirmation_notify,
+  records_the_park
+};
+
+export {
+  lane_park
+};