@joshuafolkken/kit 1.2114.0 → 1.3000.0

package/dist/commands/chunk-UJOZ2MGX.js

@@ -0,0 +1,705 @@
+import {
+  working_tree
+} from "./chunk-V4Z7G4UH.js";
+import {
+  doctor_io
+} from "./chunk-MMTVQOCP.js";
+import {
+  did_refuse_self_run,
+  sync
+} from "./chunk-MS6Q3Z7V.js";
+import {
+  auto_merge_setting,
+  security_updates
+} from "./chunk-A6T2N7VC.js";
+import {
+  start_exec
+} from "./chunk-RH6ZWJOA.js";
+import {
+  package_manager_version
+} from "./chunk-AWLYN2SP.js";
+import {
+  PRETTIER_CONFIG_JS,
+  file_content,
+  init_actions,
+  init_ai_copy,
+  pack_hook,
+  project_profile,
+  workflow_mark
+} from "./chunk-XH6BGVVP.js";
+import {
+  init_logic,
+  init_logic_workspace,
+  json_format
+} from "./chunk-RZ4OKKPM.js";
+import {
+  KIT_PACKAGE_NAME
+} from "./chunk-PBOS7MTW.js";
+import {
+  resolve_tsx_runner
+} from "./chunk-LMS6N6GE.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  PACKAGE_DIR,
+  PROJECT_ROOT,
+  package_path
+} from "./chunk-3CCGKX7Y.js";
+import {
+  resolve_local_bin
+} from "./chunk-F7XLEK55.js";
+import {
+  package_version_schema,
+  with_package_manager_schema
+} from "./chunk-RBU2NKHF.js";
+import {
+  PACKAGE_JSON,
+  package_manifest
+} from "./chunk-NKKH3PBE.js";
+import {
+  git_spawn_sync
+} from "./chunk-B77ZMVHS.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/init/init-dry-run.ts
+import { createHash } from "node:crypto";
+import {
+  constants,
+  cpSync,
+  existsSync as existsSync2,
+  lstatSync,
+  mkdtempSync,
+  readFileSync as readFileSync2,
+  rmSync,
+  statSync
+} from "node:fs";
+import os from "node:os";
+import path2 from "node:path";
+import { execaSync as execaSync2 } from "execa";
+
+// scripts/init/init-bootstrap.ts
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import path from "node:path";
+import { z as z2 } from "zod";
+
+// scripts/init/init-basic.ts
+import { z } from "zod";
+var KIT_PACKAGE_NAME2 = "@joshuafolkken/kit";
+var record_schema = z.record(z.string(), z.unknown());
+function initial_manifest() {
+  return json_format.format_json({ private: true });
+}
+function with_recorded_profile(content, profile, has_workflow = false) {
+  const parsed = JSON.parse(content);
+  const manifest = record_schema.parse(parsed);
+  const existing = manifest["josh"];
+  const josh = json_value.is_record(existing) ? existing : {};
+  manifest["josh"] = { ...josh, profile, ...workflow_mark.recorded_fields(has_workflow) };
+  return json_format.format_json(manifest);
+}
+function merge_basic_manifest(content, shape, versions) {
+  const with_profile = with_recorded_profile(content, shape.profile, shape.has_workflow);
+  const with_script = init_logic.merge_package_scripts(with_profile, {
+    preinstall: init_logic.SAFE_CHAIN_CMD,
+    josh: "josh"
+  });
+  const with_kit = init_logic.merge_development_dependencies(with_script, {
+    [KIT_PACKAGE_NAME2]: versions.kit
+  });
+  const with_prettier = shape.should_use_prettier ? init_logic.merge_development_dependencies(with_kit, { prettier: versions.prettier }) : with_kit;
+  return init_logic.sort_package_json_keys(with_prettier);
+}
+var init_basic = { initial_manifest, with_recorded_profile, merge_basic_manifest };
+
+// scripts/init/init-install.ts
+import { execaSync } from "execa";
+var NO_INSTALL_FLAG = "--no-install";
+var INSTALL_STEP = { label: "pnpm install", command: "pnpm", args: ["install"] };
+var FORMAT_STEP = {
+  label: "pnpm josh format",
+  command: "pnpm",
+  args: ["exec", "josh", "format"]
+};
+var TOO_NEW_DEPENDENCY_HINT = [
+  "If pnpm refused a dependency published inside minimumReleaseAge, the lockfile pins a version",
+  "newer than the wait allows: delete pnpm-lock.yaml and run pnpm install to resolve again."
+].join(" ");
+var INSTALL_FAILURE = [
+  `${INSTALL_STEP.label} failed \u2014 fix the cause above,`,
+  `then run it manually: ${INSTALL_STEP.label} && ${FORMAT_STEP.label}.`,
+  TOO_NEW_DEPENDENCY_HINT
+].join(" ");
+var FORMAT_WARNING = [
+  `  \u26A0 ${FORMAT_STEP.label} left problems it could not fix in the project's own files \u2014`,
+  `the setup itself succeeded; fix them, then run: ${FORMAT_STEP.label}`
+].join(" ");
+function split_install_flag(args) {
+  return {
+    is_install: !args.includes(NO_INSTALL_FLAG),
+    rest: args.filter((argument) => argument !== NO_INSTALL_FLAG)
+  };
+}
+function did_step_succeed(step, project_root) {
+  console.info(`
+$ ${step.label}`);
+  const result = execaSync(step.command, step.args, {
+    cwd: project_root,
+    env: step.env ?? {},
+    stdio: "inherit",
+    reject: false
+  });
+  return result.exitCode === 0;
+}
+function run_post_init_steps(project_root) {
+  console.info("\nDependencies:");
+  if (!did_step_succeed(INSTALL_STEP, project_root)) return INSTALL_FAILURE;
+  if (!did_step_succeed(FORMAT_STEP, project_root)) console.warn(FORMAT_WARNING);
+  return void 0;
+}
+var init_install = {
+  NO_INSTALL_FLAG,
+  INSTALL_STEP,
+  TOO_NEW_DEPENDENCY_HINT,
+  FORMAT_STEP,
+  split_install_flag,
+  did_step_succeed,
+  run_post_init_steps
+};
+
+// scripts/init/init-bootstrap.ts
+var KIT_PACKAGE_NAME3 = "@joshuafolkken/kit";
+var NODE_MODULES = "node_modules";
+var KIT_BUILDS_TEMPLATE = "templates/pnpm-workspace.basic.yaml";
+var WORKSPACE_FILE = "pnpm-workspace.yaml";
+var NPMRC_FILE = ".npmrc";
+var RELEASE_AGE_KEY = "minimumReleaseAge";
+var HANDOFF_FAILURE = "josh init from the project-installed kit failed \u2014 see the output above";
+var HANDOFF_ENV = "JOSH_INIT_HANDED_OFF";
+var REPEATED_HANDOFF = `the kit this project installed is not at ${NODE_MODULES}/${KIT_PACKAGE_NAME3} \u2014 run \`pnpm exec josh init\` where it is`;
+var dependency_fields_schema = z2.looseObject({
+  dependencies: z2.record(z2.string(), z2.string()).optional(),
+  devDependencies: z2.record(z2.string(), z2.string()).optional()
+});
+function real_directory(directory) {
+  return existsSync(directory) ? realpathSync(directory) : void 0;
+}
+function is_project_kit(package_directory, project_root) {
+  const installed = real_directory(path.join(project_root, NODE_MODULES, KIT_PACKAGE_NAME3));
+  return installed !== void 0 && installed === real_directory(package_directory);
+}
+function kit_build_flags(template) {
+  return [...init_logic_workspace.template_build_values(template)].filter(([, value]) => value === "true").map(([name]) => `--allow-build=${name}`);
+}
+function has_kit_dependency(project_root) {
+  if (!existsSync(package_manifest.manifest_path(project_root))) return false;
+  const manifest = package_manifest.read_manifest(project_root, dependency_fields_schema);
+  const names = Object.keys({ ...manifest.dependencies, ...manifest.devDependencies });
+  return names.includes(KIT_PACKAGE_NAME3);
+}
+function kit_install_step(has_kit, template) {
+  if (has_kit) return { label: "pnpm install", command: "pnpm", args: ["install"] };
+  const args = ["add", "-D", ...kit_build_flags(template), KIT_PACKAGE_NAME3];
+  return { label: `pnpm ${args.join(" ")}`, command: "pnpm", args };
+}
+function install_failure(install) {
+  return `${install.label} failed \u2014 ${init_install.TOO_NEW_DEPENDENCY_HINT}`;
+}
+function handoff_step(args) {
+  const handoff_args = ["exec", "josh", "init", ...project_profile.with_legacy_profile_names(args)];
+  return {
+    label: `pnpm ${handoff_args.join(" ")}`,
+    command: "pnpm",
+    args: handoff_args,
+    env: { [HANDOFF_ENV]: "1" }
+  };
+}
+function ensure_project_manifest(project_root) {
+  const manifest_path = package_manifest.manifest_path(project_root);
+  if (existsSync(manifest_path)) return;
+  file_content.write_contained(manifest_path, init_basic.initial_manifest());
+}
+function read_optional(file) {
+  return existsSync(file) ? readFileSync(file, "utf8") : "";
+}
+function release_age_block(project_root, template) {
+  const block = `${init_logic_workspace.extract_yaml_block(template, RELEASE_AGE_KEY)}
+`;
+  const npmrc = read_optional(path.join(project_root, NPMRC_FILE));
+  return init_logic_workspace.carry_npmrc_settings(block, npmrc);
+}
+function ensure_release_age(project_root, template) {
+  const workspace_path = path.join(project_root, WORKSPACE_FILE);
+  const existing = read_optional(workspace_path);
+  const block = release_age_block(project_root, template);
+  const merged = init_logic_workspace.merge_workspace_yaml(existing, block);
+  if (merged === existing) return;
+  file_content.write_contained(workspace_path, merged);
+}
+function is_handed_off() {
+  return process.env[HANDOFF_ENV] !== void 0;
+}
+function hand_off(package_directory, project_root, args) {
+  if (is_handed_off()) return REPEATED_HANDOFF;
+  console.info("\n\u{1F680} Installing @joshuafolkken/kit into the project, then running its josh init");
+  const template = readFileSync(path.join(package_directory, KIT_BUILDS_TEMPLATE), "utf8");
+  const install = kit_install_step(has_kit_dependency(project_root), template);
+  ensure_project_manifest(project_root);
+  ensure_release_age(project_root, template);
+  if (!init_install.did_step_succeed(install, project_root)) return install_failure(install);
+  if (!init_install.did_step_succeed(handoff_step(args), project_root)) return HANDOFF_FAILURE;
+  return void 0;
+}
+var init_bootstrap = { HANDOFF_ENV, is_project_kit, kit_build_flags, hand_off, is_handed_off };
+
+// scripts/init/init-dry-run-report.ts
+var JSON_EXTENSION = ".json";
+var KIND_WIDTH = "overwrite".length;
+var NO_CHANGES = "  (no file changes)";
+function changed_files(before, after) {
+  const paths = [.../* @__PURE__ */ new Set([...before.keys(), ...after.keys()])].toSorted(
+    (left, right) => left.localeCompare(right)
+  );
+  return paths.filter((file) => before.get(file) !== after.get(file)).map((file) => ({ path: file, before: before.get(file), after: after.get(file) }));
+}
+function keeps_every_line(before, after) {
+  const remaining = new Set(after.split("\n"));
+  return before.split("\n").every((line) => remaining.has(line));
+}
+function is_kept_array(before, after) {
+  if (!Array.isArray(after)) return false;
+  const remaining = new Set(after.map((value) => JSON.stringify(value)));
+  return before.every((value) => remaining.has(JSON.stringify(value)));
+}
+function is_kept(before, after) {
+  if (Array.isArray(before)) return is_kept_array(before, after);
+  if (!json_value.is_record(before) || !json_value.is_record(after)) return before === after;
+  return Object.keys(before).every((key) => is_kept(before[key], after[key]));
+}
+function keeps_every_value(before, after) {
+  const old_value = json_value.parse_or_undefined(before);
+  const new_value = json_value.parse_or_undefined(after);
+  if (old_value === void 0 || new_value === void 0) return void 0;
+  return is_kept(old_value, new_value);
+}
+function keeps_content(file, before, after) {
+  const is_kept_by_value = file.endsWith(JSON_EXTENSION) ? keeps_every_value(before, after) : void 0;
+  return is_kept_by_value ?? keeps_every_line(before, after);
+}
+function change_kind(change) {
+  if (change.before === void 0) return "create";
+  if (change.after === void 0) return "delete";
+  return keeps_content(change.path, change.before, change.after) ? "merge" : "overwrite";
+}
+function parse_record(content) {
+  const parsed = content === void 0 ? void 0 : json_value.parse_or_undefined(content);
+  return json_value.is_record(parsed) ? parsed : {};
+}
+function changed_keys(before, after) {
+  const keys = [.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])];
+  return keys.filter((key) => JSON.stringify(before[key]) !== JSON.stringify(after[key]));
+}
+function entry_line(name, before, after) {
+  if (before === void 0) return `+ ${name} ${JSON.stringify(after)}`;
+  if (after === void 0) return `- ${name}`;
+  return `~ ${name} ${JSON.stringify(before)} \u2192 ${JSON.stringify(after)}`;
+}
+function as_entries(value) {
+  if (value === void 0) return {};
+  return json_value.is_record(value) ? value : void 0;
+}
+function field_lines(key, before, after) {
+  const old_entries = as_entries(before);
+  const new_entries = as_entries(after);
+  if (old_entries === void 0 || new_entries === void 0) {
+    return [entry_line(key, before, after)];
+  }
+  return changed_keys(old_entries, new_entries).map(
+    (name) => entry_line(`${key}.${name}`, old_entries[name], new_entries[name])
+  );
+}
+function package_json_lines(change) {
+  const before = parse_record(change.before);
+  const after = parse_record(change.after);
+  return changed_keys(before, after).flatMap((key) => field_lines(key, before[key], after[key]));
+}
+function change_lines(change) {
+  const head = `  ${change_kind(change).padEnd(KIND_WIDTH)} ${change.path}`;
+  if (change.path !== PACKAGE_JSON || change.after === void 0) return [head];
+  return [head, ...package_json_lines(change).map((line) => `      ${line}`)];
+}
+function format_report(title, changes, dependency_lines2) {
+  const files = changes.length === 0 ? [NO_CHANGES] : changes.flatMap((change) => change_lines(change));
+  const dependencies = dependency_lines2.map((line) => `  ${line}`);
+  return [title, "", "Files:", ...files, "", "Dependencies:", ...dependencies].join("\n");
+}
+var init_dry_run_report = { changed_files, change_kind, package_json_lines, format_report };
+
+// scripts/init/init-dry-run.ts
+var DRY_RUN_FLAG = "--dry-run";
+var INIT_SCRIPT = "scripts/init/init-main.ts";
+var SCRATCH_PREFIX = "josh-init-dry-run-";
+var DEFAULT_BRANCH = "main";
+var TITLE = "josh init --dry-run \u2014 nothing was written. The setup would:";
+function split_dry_run_flag(args) {
+  return {
+    is_dry_run: args.includes(DRY_RUN_FLAG),
+    rest: args.filter((argument) => argument !== DRY_RUN_FLAG)
+  };
+}
+function is_copied_directory(source) {
+  return !lstatSync(source).isSymbolicLink() && !project_profile.is_ignored_directory(path2.basename(source));
+}
+function is_copied(root, source) {
+  if (source === root) return true;
+  if (!existsSync2(source)) return false;
+  return !statSync(source).isDirectory() || is_copied_directory(source);
+}
+function mirror_git(root, scratch) {
+  start_exec.git_succeeds(["init", "--quiet", `--initial-branch=${DEFAULT_BRANCH}`], scratch);
+  const origin = git_spawn_sync.origin_url(root);
+  if (origin !== void 0) start_exec.git_succeeds(["remote", "add", "origin", origin], scratch);
+}
+function prepare_scratch(root, has_git) {
+  const scratch = mkdtempSync(path2.join(os.tmpdir(), SCRATCH_PREFIX));
+  cpSync(root, scratch, {
+    recursive: true,
+    dereference: true,
+    mode: constants.COPYFILE_FICLONE,
+    filter: (source) => is_copied(root, source)
+  });
+  if (has_git) mirror_git(root, scratch);
+  return scratch;
+}
+function digest_of(file) {
+  return createHash("sha256").update(readFileSync2(file)).digest("hex");
+}
+function snapshot(root) {
+  const files = project_profile.list_files(root);
+  return new Map(files.map((file) => [path2.relative(root, file), digest_of(file)]));
+}
+function content_of(root, file, digests) {
+  return digests.has(file) ? readFileSync2(path2.join(root, file), "utf8") : void 0;
+}
+function changes_since(request, scratch, before) {
+  const after = snapshot(scratch);
+  return init_dry_run_report.changed_files(before, after).map((change) => ({
+    path: change.path,
+    before: content_of(request.root, change.path, before),
+    after: content_of(scratch, change.path, after)
+  }));
+}
+function run_init(scratch, profile) {
+  const runner = resolve_tsx_runner();
+  const profile_args = profile === void 0 ? [] : ["--profile", profile];
+  const args = [package_path(INIT_SCRIPT), init_install.NO_INSTALL_FLAG, ...profile_args];
+  const result = execaSync2(runner.executable, [...runner.leading_arguments, ...args], {
+    cwd: scratch,
+    env: { [init_bootstrap.HANDOFF_ENV]: "1" },
+    all: true,
+    reject: false
+  });
+  if (result.exitCode !== 0) throw new Error(`the simulated josh init failed:
+${result.all}`);
+}
+function simulate(request) {
+  const scratch = prepare_scratch(request.root, request.has_git);
+  try {
+    const before = snapshot(scratch);
+    run_init(scratch, request.profile);
+    return changes_since(request, scratch, before);
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+}
+function dependency_lines(root, is_install) {
+  if (!is_install) return [`skip the install and the format (${init_install.NO_INSTALL_FLAG})`];
+  const steps = `run ${init_install.INSTALL_STEP.label}, then ${init_install.FORMAT_STEP.label}`;
+  if (init_bootstrap.is_project_kit(PACKAGE_DIR, root)) return [steps];
+  return [`install ${KIT_PACKAGE_NAME} into the project and hand the setup to its josh init`, steps];
+}
+function plan_report(request, title = TITLE) {
+  const changes = simulate(request);
+  return init_dry_run_report.format_report(
+    title,
+    changes,
+    dependency_lines(request.root, request.is_install)
+  );
+}
+var init_dry_run = { DRY_RUN_FLAG, split_dry_run_flag, plan_report };
+
+// scripts/init/init.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+import path4 from "node:path";
+import { execaSync as execaSync3 } from "execa";
+import { z as z3 } from "zod";
+
+// scripts/init/init-file-action.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import path3 from "node:path";
+var SAMPLE_INDENT_WIDTH = 4;
+var SAMPLE_INDENT = " ".repeat(SAMPLE_INDENT_WIDTH);
+function write_new_file(action, destination_path) {
+  file_content.write_contained(destination_path, action.create());
+  console.info(`  \u2714 created   ${action.dest}`);
+}
+function show_sample(action) {
+  console.info(`  \u26A0 exists    ${action.dest} \u2014 add manually:`);
+  console.info("");
+  console.info(action.create().replaceAll(/^/gmu, () => SAMPLE_INDENT));
+}
+function report_unchanged(action, existing) {
+  const is_sample_missing = existing !== action.create();
+  if (is_sample_missing && action.merge === void 0) show_sample(action);
+  else console.info(`  \u2714 unchanged ${action.dest}`);
+}
+function merge_existing_file(action, destination_path) {
+  const existing = readFileSync3(destination_path, "utf8");
+  const merged = action.merge === void 0 ? existing : action.merge(existing);
+  if (merged === existing) {
+    report_unchanged(action, existing);
+    return;
+  }
+  file_content.write_contained(destination_path, merged);
+  console.info(`  \u2714 updated   ${action.dest}`);
+}
+function execute_file_action(action, project_root) {
+  const destination_path = path3.join(project_root, action.dest);
+  if (existsSync3(destination_path)) merge_existing_file(action, destination_path);
+  else write_new_file(action, destination_path);
+}
+var init_file_action = { execute_file_action };
+
+// scripts/init/package-manager-pin.ts
+import semver from "semver";
+var PNPM_USER_AGENT_REGEX = /^pnpm\/(\S+)/u;
+function running_pnpm_version(user_agent = "") {
+  const version = PNPM_USER_AGENT_REGEX.exec(user_agent)?.[1];
+  return version === void 0 ? void 0 : semver.valid(version) ?? void 0;
+}
+function is_older_than(kit_pin, version) {
+  const kit_version = semver.valid(package_manager_version.extract_pnpm_pin(kit_pin) ?? "");
+  return kit_version !== null && semver.lt(kit_version, version);
+}
+function choose(kit_pin, user_agent) {
+  const running = running_pnpm_version(user_agent);
+  if (kit_pin === void 0 || running === void 0) return kit_pin;
+  return is_older_than(kit_pin, running) ? `pnpm@${running}` : kit_pin;
+}
+var package_manager_pin = {
+  running_pnpm_version,
+  choose
+};
+
+// scripts/init/init.ts
+var KIT_PACKAGE_NAME4 = "@joshuafolkken/kit";
+var LEFTHOOK_BIN = "lefthook";
+var INSTALL_HINT = "\u2192 run `pnpm install` to install what package.json lists";
+var INIT_USAGE = "josh init [--profile basic|full] [--no-install] [--dry-run]";
+var engine_pin_schema = z3.looseObject({ name: z3.string(), version: z3.string() });
+var published_development_engines_schema = z3.looseObject({
+  devEngines: z3.looseObject({ packageManager: engine_pin_schema.optional() }).optional()
+});
+function resolve_kit_package_manager(manifest) {
+  const { packageManager: package_manager } = with_package_manager_schema.parse(manifest);
+  if (package_manager !== void 0 && package_manager.length > 0) return package_manager;
+  const pin = published_development_engines_schema.parse(manifest).devEngines?.packageManager;
+  return pin === void 0 ? void 0 : `${pin.name}@${pin.version}`;
+}
+function get_kit_package_manager() {
+  return package_manager_pin.choose(
+    resolve_kit_package_manager(init_actions.read_package_json(PACKAGE_JSON)),
+    process.env["npm_config_user_agent"]
+  );
+}
+function get_kit_development_engines() {
+  return init_logic.get_development_engines_value();
+}
+function get_kit_self_dependency() {
+  const { version } = package_version_schema.parse(init_actions.read_package_json(PACKAGE_JSON));
+  return { [KIT_PACKAGE_NAME4]: version };
+}
+function apply_dependency_merges(content, has_git = true) {
+  const migrated = init_logic.strip_managed_postinstall(content);
+  const suggested = init_logic.get_suggested_scripts_for_content(migrated);
+  const merged = init_logic.merge_package_scripts(
+    migrated,
+    has_git ? suggested : Object.fromEntries(Object.entries(suggested).filter(([key]) => key !== "prepare"))
+  );
+  const with_toolchain = init_logic.merge_development_dependencies(
+    merged,
+    init_logic.get_toolchain_development_dependencies(has_git)
+  );
+  const with_secretlint = init_logic.merge_secretlint_development_deps(with_toolchain);
+  return init_logic.merge_development_dependencies(with_secretlint, get_kit_self_dependency());
+}
+function apply_package_json_merges(content, has_git = true) {
+  const with_kit = apply_dependency_merges(content, has_git);
+  const upgraded = has_git ? init_logic.upgrade_prepare_lefthook_warning(with_kit) : with_kit;
+  const with_lifecycle = has_git ? init_logic.merge_prepare_lifecycle_cmd(upgraded) : upgraded;
+  const kit_pm = get_kit_package_manager();
+  const with_pm = kit_pm === void 0 ? with_lifecycle : init_logic.merge_package_manager(with_lifecycle, kit_pm);
+  const with_de = init_logic.merge_development_engines(with_pm, get_kit_development_engines());
+  const sorted = init_logic.sort_package_json_keys(with_de);
+  return package_manager_version.align_development_engines_version(sorted);
+}
+function get_basic_versions() {
+  const manifest = z3.object({
+    version: z3.string(),
+    devDependencies: z3.record(z3.string(), z3.string())
+  }).parse(init_actions.read_package_json(PACKAGE_JSON));
+  const { prettier } = manifest.devDependencies;
+  if (prettier === void 0) throw new Error("Missing prettier development version");
+  return { kit: manifest.version, prettier };
+}
+function merged_manifest(existing, shape) {
+  if (shape.profile === "basic") {
+    return init_basic.merge_basic_manifest(existing, shape, get_basic_versions());
+  }
+  return init_basic.with_recorded_profile(
+    apply_package_json_merges(existing, shape.has_git),
+    shape.profile,
+    shape.has_workflow
+  );
+}
+function merge_project_package_json(shape) {
+  const package_json_path = path4.join(PROJECT_ROOT, PACKAGE_JSON);
+  const is_existing = existsSync4(package_json_path);
+  const existing = is_existing ? readFileSync4(package_json_path, "utf8") : init_basic.initial_manifest();
+  const merged = merged_manifest(existing, shape);
+  if (is_existing && merged === existing) {
+    console.info("  \u2714 unchanged package.json");
+    return;
+  }
+  file_content.write_contained(package_json_path, merged);
+  console.info(`  \u2714 ${is_existing ? "updated" : "created"}   package.json`);
+}
+function install_lefthook(project_root = PROJECT_ROOT) {
+  console.info("\nLefthook:");
+  const bin = resolve_local_bin(project_root, LEFTHOOK_BIN);
+  if (!existsSync4(bin)) {
+    console.info("  \u2139 lefthook is not installed yet \u2014 `pnpm install` installs the git hooks");
+    return;
+  }
+  const result = execaSync3(bin, ["install"], { cwd: project_root, stdio: "inherit", reject: false });
+  if (result.exitCode === void 0) {
+    console.warn("  \u26A0 lefthook install failed \u2014 run it manually: lefthook install");
+  }
+}
+function run_config_file_actions(shape) {
+  console.info("Config files:");
+  if (shape.profile === "full" && sync.migrate_prettierrc(path4.join(PROJECT_ROOT, PRETTIER_CONFIG_JS))) {
+    console.info("  \u2714 migrated  .prettierrc \u2192 prettier.config.js");
+  }
+  for (const action of init_actions.build_file_actions(shape)) {
+    init_file_action.execute_file_action(action, PROJECT_ROOT);
+  }
+}
+function report_repository_settings(name_with_owner) {
+  if (doctor_io.has_distributed_dependabot_config(PROJECT_ROOT, PROJECT_ROOT)) {
+    security_updates.report_security_updates_section(name_with_owner);
+  }
+  if (doctor_io.has_auto_merge_workflow(PROJECT_ROOT, PROJECT_ROOT)) {
+    auto_merge_setting.report_auto_merge_section(name_with_owner);
+  }
+}
+function run_ai_file_actions(shape) {
+  console.info("\nAI files:");
+  const name_with_owner = init_ai_copy.run_ai_copies(shape);
+  if (shape.has_github) report_repository_settings(name_with_owner);
+}
+function initialize_project(shape) {
+  console.info("\n\u{1F680} Initializing @joshuafolkken/kit\n");
+  console.info(`profile: ${shape.profile} (${shape.reason})`);
+  run_config_file_actions(shape);
+  console.info("\nPackage scripts:");
+  merge_project_package_json(shape);
+  run_ai_file_actions(shape);
+  pack_hook.sync_pack_hook(PROJECT_ROOT, PACKAGE_DIR);
+  if (shape.profile === "full") sync.sync_release_window_mirrors(PROJECT_ROOT);
+}
+function report_manual_install(shape) {
+  console.info(`
+Dependencies:
+  ${INSTALL_HINT}`);
+  if (shape.has_git && shape.profile === "full") install_lefthook();
+}
+function finish_dependencies(shape, is_install) {
+  if (!is_install) {
+    report_manual_install(shape);
+    return;
+  }
+  const failure = init_install.run_post_init_steps(PROJECT_ROOT);
+  if (failure !== void 0) throw new Error(failure);
+}
+function did_hand_off(args) {
+  if (init_bootstrap.is_project_kit(PACKAGE_DIR, PROJECT_ROOT)) return false;
+  const failure = init_bootstrap.hand_off(PACKAGE_DIR, PROJECT_ROOT, args);
+  if (failure !== void 0) throw new Error(failure);
+  return true;
+}
+function set_up_project(requested, is_install) {
+  const shape = project_profile.inspect_project(PROJECT_ROOT, requested);
+  initialize_project(shape);
+  finish_dependencies(shape, is_install);
+  console.info("\n\u2705 Done.\n");
+}
+function print_dry_run({ requested, is_install }) {
+  const has_git = project_profile.has_git(PROJECT_ROOT);
+  console.info(
+    init_dry_run.plan_report({ root: PROJECT_ROOT, profile: requested, has_git, is_install })
+  );
+  return false;
+}
+function did_set_up_here({ requested, is_install }, args) {
+  const is_set_up_here = !is_install || !did_hand_off(args);
+  if (is_set_up_here) set_up_project(requested, is_install);
+  return is_set_up_here;
+}
+function parse_init_args(args) {
+  const { is_dry_run, rest: run_args } = init_dry_run.split_dry_run_flag(args);
+  const { is_install, rest } = init_install.split_install_flag(run_args);
+  return { is_dry_run, is_install, requested: project_profile.requested_profile(rest, INIT_USAGE) };
+}
+function main(args = []) {
+  if (did_refuse_self_run(PACKAGE_DIR, PROJECT_ROOT)) return false;
+  const request = parse_init_args(args);
+  return request.is_dry_run ? print_dry_run(request) : did_set_up_here(request, args);
+}
+function did_refuse_dirty_tree() {
+  const refusal = init_bootstrap.is_handed_off() ? void 0 : working_tree.dirty_tree_refusal(PROJECT_ROOT, "josh init");
+  if (refusal === void 0) return false;
+  console.error(`
+${refusal}
+`);
+  process.exitCode = 1;
+  return true;
+}
+function run_cli(args) {
+  try {
+    if (did_refuse_dirty_tree()) return;
+    main(args);
+  } catch (error) {
+    console.error(`
+\u2716 ${error_text.message_of(error)}
+`);
+    process.exitCode = 1;
+  }
+}
+var init = {
+  copy_ai_file: init_ai_copy.copy_ai_file,
+  apply_package_json_merges,
+  merged_manifest,
+  install_lefthook,
+  resolve_kit_package_manager
+};
+
+export {
+  init_basic,
+  init_dry_run,
+  main,
+  run_cli,
+  init
+};