@joshuafolkken/kit 1.2116.0 → 1.3000.0

package/dist/commands/chunk-XH6BGVVP.js

@@ -0,0 +1,1639 @@
+import {
+  composite_actions
+} from "./chunk-RXAZJMSZ.js";
+import {
+  gh_spawn
+} from "./chunk-3PEXBHRN.js";
+import {
+  init_logic,
+  init_logic_json_merge,
+  json_format,
+  managed_config_scope,
+  npm_publish_files,
+  parse_jsonc,
+  patch_json_key
+} from "./chunk-RZ4OKKPM.js";
+import {
+  KIT_PACKAGE_NAME
+} from "./chunk-PBOS7MTW.js";
+import {
+  release_age
+} from "./chunk-2MJ4OCDL.js";
+import {
+  yaml_document
+} from "./chunk-UCI4AL3Q.js";
+import {
+  distributed_paths
+} from "./chunk-66TGK5XL.js";
+import {
+  repo_origin
+} from "./chunk-4ZHWTTQW.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  session_language
+} from "./chunk-OKYFQJW3.js";
+import {
+  PACKAGE_DIR,
+  PROJECT_ROOT,
+  package_path
+} from "./chunk-3CCGKX7Y.js";
+import {
+  json_object_schema,
+  string_array_schema,
+  vscode_settings_schema
+} from "./chunk-RBU2NKHF.js";
+import {
+  PACKAGE_JSON,
+  package_manifest
+} from "./chunk-NKKH3PBE.js";
+import {
+  git_spawn_sync
+} from "./chunk-B77ZMVHS.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/safe-chain/project-config.ts
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import path3 from "node:path";
+
+// scripts/sync/file-content.ts
+import { lstatSync, mkdirSync, readFileSync, readlinkSync, writeFileSync } from "node:fs";
+import path from "node:path";
+var PATH_SEPARATORS = path.sep === "\\" ? /[/\\]/u : /\//u;
+var MAX_RESOLVE_STEPS = 4096;
+function is_read_denied(error) {
+  return error instanceof Error && "code" in error && ["EACCES", "EPERM"].includes(String(error.code));
+}
+function is_regular_existing_file(destination_path) {
+  try {
+    return lstatSync(destination_path).isFile();
+  } catch (error) {
+    if (file_reader.is_absent(error)) return false;
+    throw error;
+  }
+}
+function does_read_match(destination_path, expected) {
+  try {
+    return readFileSync(destination_path).equals(expected);
+  } catch (error) {
+    if (is_read_denied(error)) return false;
+    throw error;
+  }
+}
+function is_same_file_content(destination_path, content) {
+  if (!is_regular_existing_file(destination_path)) return false;
+  const expected = Buffer.isBuffer(content) ? content : Buffer.from(content);
+  return does_read_match(destination_path, expected);
+}
+function read_symlink(target) {
+  if (!lstatSync(target, { throwIfNoEntry: false })?.isSymbolicLink()) return void 0;
+  return readlinkSync(target);
+}
+function split_components(target) {
+  return target.split(PATH_SEPARATORS).filter((part) => part !== "" && part !== ".");
+}
+function enter_component(current, name, pending) {
+  if (name === "..") return path.dirname(current);
+  const next = path.join(current, name);
+  const link = read_symlink(next);
+  if (link === void 0) return next;
+  const root = path.isAbsolute(link) ? path.parse(link).root : "";
+  pending.unshift(...split_components(link.slice(root.length)));
+  return root === "" ? current : root;
+}
+function resolve_write_path(target) {
+  const absolute = path.isAbsolute(target) ? target : `${process.cwd()}${path.sep}${target}`;
+  let current = path.parse(absolute).root;
+  const pending = split_components(absolute.slice(current.length));
+  for (let steps = 0; steps <= MAX_RESOLVE_STEPS; steps += 1) {
+    const name = pending.shift();
+    if (name === void 0) return current;
+    current = enter_component(current, name, pending);
+  }
+  throw new Error(`Refusing to write ${target}: too many links`);
+}
+function is_within(root, target) {
+  const relative = path.relative(root, target);
+  return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+function does_escape_project(destination_path) {
+  if (!is_within(path.resolve(PROJECT_ROOT), path.resolve(destination_path))) return false;
+  return !is_within(resolve_write_path(PROJECT_ROOT), resolve_write_path(destination_path));
+}
+function write_contained(destination_path, content) {
+  if (does_escape_project(destination_path)) {
+    throw new Error(`Refusing to write ${destination_path}: it resolves outside the project`);
+  }
+  mkdirSync(path.dirname(destination_path), { recursive: true });
+  writeFileSync(destination_path, content);
+}
+function write_text_if_changed(destination_path, content) {
+  if (is_same_file_content(destination_path, content)) return false;
+  write_contained(destination_path, content);
+  return true;
+}
+var file_content = { is_same_file_content, write_contained, write_text_if_changed };
+
+// scripts/version/release-window.ts
+import path2 from "node:path";
+import { z } from "zod";
+var WORKSPACE_FILE = "pnpm-workspace.yaml";
+var exclusions_schema = z.object({ minimumReleaseAgeExclude: z.array(z.string()).optional() });
+var DEFAULT_RELEASE_AGE_MINUTES = 4320;
+function parse_release_window(workspace) {
+  const exclusions = exclusions_schema.parse(yaml_document.parse_yaml(workspace));
+  return {
+    minutes: release_age.parse_declared_minimum_release_age(workspace),
+    exclusions: exclusions.minimumReleaseAgeExclude ?? []
+  };
+}
+function read_release_window(root) {
+  return parse_release_window(file_reader.read_file_or_empty(path2.join(root, WORKSPACE_FILE)));
+}
+var release_window = { parse_release_window, read_release_window };
+
+// scripts/safe-chain/project-config.ts
+import { dump } from "js-yaml";
+var WORKSPACE_FILE2 = "pnpm-workspace.yaml";
+var PROJECT_CONFIG_FILE = ".aikido";
+var EXCLUSIONS_FIELD = "minimumPackageAgeExclusions";
+var AGE_FIELD = "minimumPackageAgeHours";
+var MINUTES_PER_HOUR = 60;
+function read_mapping(value, label) {
+  if (value === void 0) return {};
+  if (yaml_document.is_mapping_document(value)) return value;
+  throw new Error(`${label} must be a YAML mapping`);
+}
+function is_block_line(line) {
+  return line.trim() === "" || line.startsWith(" ") || line.startsWith("	");
+}
+function trim_block_end(lines, start, end) {
+  let trimmed = end;
+  while (trimmed > start + 1 && lines[trimmed - 1]?.trim() === "") trimmed -= 1;
+  return trimmed;
+}
+function find_block_end(lines, start) {
+  const remaining = lines.slice(start + 1);
+  const relative = remaining.findIndex((line, index) => {
+    if (is_block_line(line)) return false;
+    if (!line.startsWith("#")) return true;
+    const next = remaining.slice(index + 1).find((candidate) => candidate.trim() !== "" && !candidate.startsWith("#"));
+    return next === void 0 || !is_block_line(next);
+  });
+  const end = relative === -1 ? lines.length : start + 1 + relative;
+  return trim_block_end(lines, start, end);
+}
+function append_block(existing, block) {
+  if (existing.length === 0) return block;
+  const prefix = existing.endsWith("\n") ? existing : `${existing}
+`;
+  return `${prefix}
+${block}`;
+}
+function preserve_anchor(block, key_line) {
+  const anchor = /(?:^|\s)(&[^\s#]+)/u.exec(key_line)?.[1];
+  if (!anchor) return block;
+  const header = "safe-chain:";
+  return `${header} ${anchor}${block.slice(header.length)}`;
+}
+function replace_safe_chain_block(existing, safe_chain) {
+  const block = dump({ "safe-chain": safe_chain }, { lineWidth: -1 });
+  const lines = existing.split("\n");
+  const start = lines.findIndex(
+    (line) => /^(?:safe-chain|'safe-chain'|"safe-chain")\s*:/u.test(line)
+  );
+  if (start === -1) return append_block(existing, block);
+  const replacement = preserve_anchor(block, lines[start] ?? "");
+  const end = find_block_end(lines, start);
+  const prefix = lines.slice(0, start).join("\n");
+  const suffix = lines.slice(end).join("\n");
+  return `${prefix}${prefix ? "\n" : ""}${replacement}${suffix}`;
+}
+function package_age_hours(workspace) {
+  const { minutes } = release_window.parse_release_window(workspace);
+  if (minutes === void 0) return void 0;
+  return Math.floor(minutes / MINUTES_PER_HOUR);
+}
+function merge_age(safe_chain, workspace) {
+  const hours = package_age_hours(workspace);
+  if (hours === void 0) return safe_chain;
+  return { ...safe_chain, [AGE_FIELD]: hours };
+}
+function merge_exclusions(safe_chain, exclusions) {
+  const npm = read_mapping(safe_chain["npm"], "safe-chain.npm");
+  return { ...safe_chain, npm: { ...npm, [EXCLUSIONS_FIELD]: exclusions } };
+}
+function has_nothing_to_write(existing, exclusions, workspace) {
+  return existing.length === 0 && exclusions.length === 0 && package_age_hours(workspace) === void 0;
+}
+function merge_project_config(existing, workspace) {
+  const { exclusions } = release_window.parse_release_window(workspace);
+  const aikido = yaml_document.parse_yaml(existing);
+  const safe_chain = read_mapping(aikido["safe-chain"], "safe-chain");
+  const merged = merge_age(merge_exclusions(safe_chain, exclusions), workspace);
+  if (JSON.stringify(merged) === JSON.stringify(safe_chain) || has_nothing_to_write(existing, exclusions, workspace)) {
+    return existing;
+  }
+  return replace_safe_chain_block(existing, merged);
+}
+function sync_project_config(root) {
+  const workspace_path = path3.join(root, WORKSPACE_FILE2);
+  if (!existsSync(workspace_path)) return false;
+  const config_path = path3.join(root, PROJECT_CONFIG_FILE);
+  const existing = file_reader.read_file_or_empty(config_path);
+  const workspace = readFileSync2(workspace_path, "utf8");
+  const merged = merge_project_config(existing, workspace);
+  if (merged === existing) return false;
+  file_content.write_contained(config_path, merged);
+  return true;
+}
+var project_config = { merge_project_config, sync_project_config };
+
+// scripts/init/init-actions.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+import path5 from "node:path";
+
+// scripts/init/session-language-environment.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
+import path4 from "node:path";
+var ENV_FILE = ".env";
+var CLAUDE_SETTINGS_PATH = path4.join(".claude", "settings.json");
+var SESSION_LANG_HOOK = "session:lang";
+var LOCALE_KEYS = ["LC_ALL", "LC_MESSAGES", "LANG"];
+var JAPANESE_PREFIX = "ja";
+var NON_JAPANESE_LANG = "en";
+var KEY_LINE_PATTERN = new RegExp(
+  String.raw`^\s*(?:export\s+)?${session_language.ENV_KEY}\s*=`,
+  "mu"
+);
+function lang_from_locale(environment) {
+  const locale = LOCALE_KEYS.map((key) => environment[key]?.trim()).find(Boolean) ?? "";
+  return locale.toLowerCase().startsWith(JAPANESE_PREFIX) ? JAPANESE_PREFIX : NON_JAPANESE_LANG;
+}
+function resolve_lang(environment) {
+  const exported = environment[session_language.ENV_KEY]?.trim();
+  if (exported) return exported;
+  return lang_from_locale(environment);
+}
+function session_lang_line(lang) {
+  return `${session_language.ENV_KEY}=${lang}
+`;
+}
+function merge_session_lang(existing, lang) {
+  if (KEY_LINE_PATTERN.test(existing)) return existing;
+  const separator = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
+  return `${existing}${separator}${session_lang_line(lang)}`;
+}
+function is_session_lang_hooked(project_root) {
+  const settings_path = path4.join(project_root, CLAUDE_SETTINGS_PATH);
+  return existsSync2(settings_path) && readFileSync3(settings_path, "utf8").includes(SESSION_LANG_HOOK);
+}
+function build_session_lang_actions(environment = process.env, project_root = PROJECT_ROOT) {
+  if (is_session_lang_hooked(project_root)) return [];
+  const lang = resolve_lang(environment);
+  return [
+    {
+      dest: ENV_FILE,
+      create: () => session_lang_line(lang),
+      merge: (existing) => merge_session_lang(existing, lang)
+    }
+  ];
+}
+var session_language_environment = {
+  build_session_lang_actions,
+  lang_from_locale,
+  merge_session_lang
+};
+
+// scripts/config-merge/patch-json-array.ts
+import { findNodeAtLocation, getNodeValue, parseTree } from "jsonc-parser";
+var PROBE_HEAD_LINES = 2;
+var PROBE_TAIL_LINES = 3;
+function element_nodes(array) {
+  if (array?.type !== "array") return [];
+  return array.children ?? [];
+}
+function find_array(content, key) {
+  const root = parseTree(content);
+  const array = root === void 0 ? void 0 : findNodeAtLocation(root, [key]);
+  const elements = element_nodes(array);
+  if (array?.parent === void 0 || elements.length === 0) return void 0;
+  return { property: array.parent, elements };
+}
+function render_element(content, site, upsert) {
+  const lines = json_format.format_json({ [upsert.key]: [upsert.value] }).split("\n");
+  const text = lines.slice(PROBE_HEAD_LINES, -PROBE_TAIL_LINES).join("\n");
+  const unit = patch_json_key.line_indent(content, site.property.offset);
+  return patch_json_key.fit_value(content, text, unit).trimStart();
+}
+function splice(content, node, length, text) {
+  return content.slice(0, node.offset) + text + content.slice(node.offset + length);
+}
+function append_element(content, last, element_text) {
+  const indent = patch_json_key.line_indent(content, last.offset);
+  const text = `,${patch_json_key.eol_of(content)}${indent}${element_text}`;
+  const end = { ...last, offset: last.offset + last.length };
+  return splice(content, end, 0, text);
+}
+function is_equal(node, value) {
+  return JSON.stringify(getNodeValue(node)) === JSON.stringify(value);
+}
+function upsert_in(content, site, upsert) {
+  const target = site.elements.find((element) => upsert.is_target(getNodeValue(element)));
+  if (target !== void 0 && is_equal(target, upsert.value)) return content;
+  const element_text = render_element(content, site, upsert);
+  if (target !== void 0) return splice(content, target, target.length, element_text);
+  const last = site.elements.at(-1);
+  return last === void 0 ? content : append_element(content, last, element_text);
+}
+function upsert_element(content, upsert) {
+  const site = find_array(content, upsert.key);
+  if (site === void 0) return patch_json_key.set_json_key(content, upsert.key, [upsert.value]);
+  return upsert_in(content, site, upsert);
+}
+var patch_json_array = { upsert_element };
+
+// scripts/init/vscode-tasks.ts
+import { z as z2 } from "zod";
+var TASKS_KEY = "tasks";
+var LABEL_KEY = "label";
+var TASKS_VERSION = "2.0.0";
+var VSCODE_TASKS_FILENAME = "tasks.json";
+var RETIRED_LABELS = /* @__PURE__ */ new Map([
+  ["josh: run event watch", "josh: run board"]
+]);
+var task_array_schema = z2.array(json_object_schema);
+function read_tasks(parsed) {
+  const result = task_array_schema.safeParse(parsed[TASKS_KEY]);
+  return result.success ? result.data : [];
+}
+function has_label(element, label) {
+  const result = json_object_schema.safeParse(element);
+  if (!result.success) return false;
+  const own = result.data[LABEL_KEY];
+  return (RETIRED_LABELS.get(own) ?? own) === label;
+}
+function merge_tasks(content, kit_tasks) {
+  let merged = init_logic_json_merge.merge_json_object(content, { version: TASKS_VERSION });
+  for (const task of kit_tasks) {
+    merged = patch_json_array.upsert_element(merged, {
+      key: TASKS_KEY,
+      value: task,
+      is_target: (element) => has_label(element, task[LABEL_KEY])
+    });
+  }
+  return merged;
+}
+function read_kit_tasks(content) {
+  return read_tasks(parse_jsonc(content));
+}
+var vscode_tasks = { VSCODE_TASKS_FILENAME, merge_tasks, read_kit_tasks };
+
+// scripts/init/init-actions.ts
+var PRETTIER_CONFIG_JS = "prettier.config.js";
+var BASIC_PRETTIER_CONFIG = "prettier.config.mjs";
+var VSCODE_EXTENSIONS_PATH = ".vscode/extensions.json";
+var VSCODE_SETTINGS_PATH = ".vscode/settings.json";
+var TSCONFIG_PATH = "tsconfig.json";
+var LEFTHOOK_PATH = "lefthook.yml";
+function read_package_file(relative_path) {
+  return readFileSync4(package_path(relative_path), "utf8");
+}
+function read_package_json(relative_path) {
+  return JSON.parse(read_package_file(relative_path));
+}
+function build_action(destination, create, merge) {
+  return { dest: destination, create, merge };
+}
+function build_vscode_tasks_action() {
+  const tasks_path = path5.join(".vscode", vscode_tasks.VSCODE_TASKS_FILENAME);
+  const kit_tasks = vscode_tasks.read_kit_tasks(read_package_file(tasks_path));
+  return build_action(
+    tasks_path,
+    () => read_package_file(tasks_path),
+    (existing) => vscode_tasks.merge_tasks(existing, kit_tasks)
+  );
+}
+function build_vscode_actions() {
+  const extensions_path = path5.join(".vscode", init_logic.VSCODE_EXTENSIONS_FILENAME);
+  const settings_path = path5.join(".vscode", init_logic.get_vscode_settings_filename());
+  const extensions_raw = vscode_settings_schema.parse(read_package_json(extensions_path));
+  const raw_recommendations = extensions_raw["recommendations"];
+  const recommendations = string_array_schema.parse(raw_recommendations);
+  const settings_data = init_logic.strip_kit_only_vscode_settings(
+    vscode_settings_schema.parse(read_package_json(settings_path))
+  );
+  return [
+    {
+      dest: VSCODE_EXTENSIONS_PATH,
+      create: () => read_package_file(extensions_path),
+      merge: (existing) => init_logic.merge_json_array_field(existing, "recommendations", recommendations)
+    },
+    {
+      dest: VSCODE_SETTINGS_PATH,
+      create: () => init_logic.strip_kit_only_vscode_settings_content(read_package_file(settings_path)),
+      merge: (existing) => init_logic.merge_json_object(existing, settings_data)
+    },
+    build_vscode_tasks_action()
+  ];
+}
+var BASIC_EXTENSIONS = [
+  "streetsidesoftware.code-spell-checker",
+  "pkief.material-icon-theme",
+  "usernamehw.errorlens",
+  "anthropic.claude-code",
+  "github.github-vscode-theme"
+];
+var PRETTIER_EXTENSION = "esbenp.prettier-vscode";
+var DEFAULT_FORMATTER = "editor.defaultFormatter";
+var FORMAT_ON_SAVE = "editor.formatOnSave";
+var BASIC_LANGUAGES = ["[html]", "[css]", "[javascript]"];
+function basic_settings() {
+  const formatter = { [DEFAULT_FORMATTER]: PRETTIER_EXTENSION, [FORMAT_ON_SAVE]: true };
+  return Object.fromEntries(BASIC_LANGUAGES.map((language) => [language, formatter]));
+}
+function build_basic_settings_action() {
+  const settings = basic_settings();
+  return build_action(
+    VSCODE_SETTINGS_PATH,
+    () => json_format.format_json(settings),
+    (existing) => init_logic.merge_json_object(existing, settings)
+  );
+}
+function build_basic_vscode_actions(shape) {
+  const recommendations = shape.should_use_prettier ? [...BASIC_EXTENSIONS, PRETTIER_EXTENSION] : BASIC_EXTENSIONS;
+  const actions = [
+    build_action(
+      VSCODE_EXTENSIONS_PATH,
+      () => json_format.format_json({ recommendations }),
+      (existing) => init_logic.merge_json_array_field(existing, "recommendations", recommendations)
+    )
+  ];
+  if (shape.should_use_prettier) actions.push(build_basic_settings_action());
+  return actions;
+}
+function build_basic_tsconfig_action() {
+  return build_action(
+    TSCONFIG_PATH,
+    () => json_format.format_json({ extends: init_logic.get_tsconfig_extends_entry() }),
+    (existing) => init_logic.merge_tsconfig_extends(
+      existing,
+      init_logic.get_tsconfig_extends_entry(),
+      PROJECT_ROOT
+    )
+  );
+}
+function build_secretlint_action() {
+  return {
+    dest: init_logic.get_secretlint_config_filename(),
+    create: () => init_logic.generate_secretlint_config()
+  };
+}
+function build_tsconfig_action() {
+  return build_action(
+    TSCONFIG_PATH,
+    () => init_logic.generate_tsconfig(),
+    (existing) => init_logic.merge_tsconfig_exclude(
+      init_logic.merge_tsconfig_extends(
+        existing,
+        init_logic.get_tsconfig_extends_entry(),
+        PROJECT_ROOT
+      )
+    )
+  );
+}
+function build_config_file_actions() {
+  const lefthook_extends = init_logic.get_lefthook_extends_value();
+  return [
+    build_tsconfig_action(),
+    build_action(
+      "cspell.config.yaml",
+      () => init_logic.generate_cspell_config(),
+      (existing) => init_logic.merge_cspell_import(existing, init_logic.get_cspell_import_value())
+    ),
+    build_action(
+      LEFTHOOK_PATH,
+      () => init_logic.generate_lefthook_config(),
+      (existing) => init_logic.merge_lefthook_extends(existing, lefthook_extends)
+    ),
+    build_secretlint_action(),
+    ...build_vscode_actions()
+  ];
+}
+function build_playwright_action() {
+  return { dest: "playwright.config.ts", create: () => init_logic.generate_playwright_config() };
+}
+function build_eslint_action() {
+  return build_action(
+    "eslint.config.js",
+    () => init_logic.generate_eslint_config(),
+    (existing) => init_logic.merge_eslint_config(existing)
+  );
+}
+function build_gitignore_action() {
+  const template = read_package_file("templates/gitignore");
+  return build_action(
+    ".gitignore",
+    () => template,
+    (existing) => init_logic.merge_gitignore(existing, template)
+  );
+}
+function build_basic_actions(shape) {
+  const actions = [];
+  if (shape.has_git) actions.push(build_gitignore_action());
+  if (shape.has_typescript) actions.push(build_basic_tsconfig_action());
+  if (shape.should_use_prettier) {
+    actions.push({
+      dest: BASIC_PRETTIER_CONFIG,
+      create: () => "import { config } from '@joshuafolkken/kit/prettier/basic'\n\nexport default config\n"
+    });
+  }
+  actions.push(...build_basic_vscode_actions(shape));
+  if (shape.has_workflow) actions.push(...session_language_environment.build_session_lang_actions());
+  return actions;
+}
+function build_file_actions(shape) {
+  if (shape?.profile === "basic") return build_basic_actions(shape);
+  return [
+    ...shape?.has_git === false ? [] : [build_gitignore_action()],
+    build_eslint_action(),
+    build_action(
+      PRETTIER_CONFIG_JS,
+      () => init_logic.generate_prettier_config(init_logic.detect_tailwind_stylesheet(PROJECT_ROOT)),
+      (existing) => init_logic.merge_prettier_config(existing, PROJECT_ROOT)
+    ),
+    build_playwright_action(),
+    ...build_config_file_actions().filter(
+      (action) => shape?.has_git !== false || action.dest !== LEFTHOOK_PATH
+    ),
+    ...session_language_environment.build_session_lang_actions()
+  ];
+}
+var init_actions = { build_file_actions, read_package_json };
+
+// scripts/init/project-profile.ts
+import { existsSync as existsSync8, readdirSync as readdirSync3 } from "node:fs";
+import path14 from "node:path";
+import { z as z4 } from "zod";
+
+// scripts/safe-chain/pack-hook.ts
+import { existsSync as existsSync3, readFileSync as readFileSync5, rmSync } from "node:fs";
+import path6 from "node:path";
+import { z as z3 } from "zod";
+var PACK_HOOK_FILE = ".pnpmfile.mjs";
+var MANAGED_LINE = "// josh-managed-pnpmfile: @joshuafolkken/kit";
+var LEGACY_HOOK_FILE = ".pnpmfile.cjs";
+var CONFIG_FILES = ["pnpm-workspace.yaml", ".npmrc"];
+var PNPMFILE_SETTINGS = /* @__PURE__ */ new Set(["pnpmfile", "pnpmfiles"]);
+var SETTING_KEY_END = /[\s:=]/u;
+var manifest_schema = z3.looseObject({ private: z3.boolean().optional() });
+function is_published(manifest_text) {
+  return manifest_schema.parse(JSON.parse(manifest_text)).private !== true;
+}
+function sets_pnpmfile(config_text) {
+  return config_text.split("\n").some((line) => PNPMFILE_SETTINGS.has(line.trimStart().split(SETTING_KEY_END, 1)[0] ?? ""));
+}
+function has_own_hook_source(project_root) {
+  if (existsSync3(path6.join(project_root, LEGACY_HOOK_FILE))) return true;
+  return CONFIG_FILES.some(
+    (name) => sets_pnpmfile(file_reader.read_file_or_empty(path6.join(project_root, name)))
+  );
+}
+function write_hook(destination, package_directory) {
+  const source = readFileSync5(path6.join(package_directory, PACK_HOOK_FILE), "utf8");
+  return file_content.write_text_if_changed(destination, source) ? "written" : "unchanged";
+}
+function withdraw(destination, existing) {
+  if (existing === void 0) return "owned";
+  rmSync(destination);
+  return "withdrawn";
+}
+function apply(project_root, package_directory) {
+  const destination = path6.join(project_root, PACK_HOOK_FILE);
+  const existing = file_reader.read_optional(destination);
+  if (existing !== void 0 && !existing.startsWith(MANAGED_LINE)) return "owned";
+  if (has_own_hook_source(project_root)) return withdraw(destination, existing);
+  return write_hook(destination, package_directory);
+}
+var MESSAGES = {
+  written: `  \u2714 synced    ${PACK_HOOK_FILE} (run \`pnpm install\` to refresh pnpmfileChecksum)`,
+  unchanged: `  \u2714 unchanged ${PACK_HOOK_FILE}`,
+  private: void 0,
+  owned: `  \u26A0 skipped   ${PACK_HOOK_FILE} \u2014 the project has its own pnpmfile; strip the safe-chain preinstall at pack time there`,
+  withdrawn: `  \u26A0 removed   ${PACK_HOOK_FILE} \u2014 it shadowed the project's own pnpmfile; strip the safe-chain preinstall at pack time there`
+};
+function sync_pack_hook(project_root, package_directory) {
+  const manifest_text = file_reader.read_optional(package_manifest.manifest_path(project_root));
+  const is_private = manifest_text === void 0 || !is_published(manifest_text);
+  const result = is_private ? "private" : apply(project_root, package_directory);
+  const message = MESSAGES[result];
+  if (message !== void 0) console.info(message);
+  return result;
+}
+var pack_hook = { MANAGED_LINE, sync_pack_hook };
+
+// scripts/init/init-ai-copy.ts
+import { existsSync as existsSync6, readFileSync as readFileSync9 } from "node:fs";
+import path12 from "node:path";
+
+// scripts/claude/workflow-destination.ts
+var WORKFLOW_DESTINATION_PATTERN = /(?:^|[/\\])\.github[/\\]workflows[/\\][^/\\]+\.ya?ml$/u;
+var COMPOSITE_ACTION_DESTINATION_PATTERN = /(?:^|[/\\])\.github[/\\]actions[/\\][^/\\]+[/\\]action\.ya?ml$/u;
+function is_workflow_destination(destination) {
+  return WORKFLOW_DESTINATION_PATTERN.test(destination) || COMPOSITE_ACTION_DESTINATION_PATTERN.test(destination);
+}
+
+// scripts/managed-marker/managed-marker-logic.ts
+var MARKER_TOKEN = "josh-managed-workflow:";
+var MARKER_PREFIX = `# ${MARKER_TOKEN}`;
+var MARKER_NOTE = "Overwritten on every sync of that package. Edit it there, not here.";
+function marker_block(package_name) {
+  return `${MARKER_PREFIX} ${package_name}
+# ${MARKER_NOTE}
+`;
+}
+function is_marked(text) {
+  return text.startsWith(MARKER_PREFIX);
+}
+function apply_marker_for_destination(destination, text, package_name) {
+  if (!is_workflow_destination(destination) || is_marked(text)) return text;
+  return `${marker_block(package_name)}${text}`;
+}
+var managed_marker_logic = {
+  MARKER_TOKEN,
+  MARKER_PREFIX,
+  is_marked,
+  apply_marker_for_destination
+};
+
+// scripts/sync/directory-copy-guard.ts
+import { cpSync, lstatSync as lstatSync2, readdirSync as readdirSync2, readFileSync as readFileSync7 } from "node:fs";
+import path10 from "node:path";
+
+// scripts/sync/workflow-pin-logic.ts
+import { readdirSync, readFileSync as readFileSync6 } from "node:fs";
+import path7 from "node:path";
+var RUNTIME_WORKFLOWS_DIR = ".github/workflows";
+var TEMPLATE_WORKFLOWS_DIR = "templates/workflows";
+var USES_KEY = "uses:";
+var YAML_PATTERN = /\.ya?ml$/u;
+var SYNC_HINT = "  Run `pnpm josh sync-workflow-pins` to sync template workflow pins.";
+function parse_uses_line(line) {
+  const key_index = line.indexOf(USES_KEY);
+  if (key_index === -1 || line.slice(0, key_index).trim() !== "") return void 0;
+  const value = line.slice(key_index + USES_KEY.length).trim();
+  const at_index = value.indexOf("@");
+  if (at_index === -1) return void 0;
+  return { name: value.slice(0, at_index), ref: value.slice(at_index + 1) };
+}
+function conflict_message(name, existing, found, file) {
+  return `Action ${name} pinned to conflicting refs in .github/workflows: "${existing}" vs "${found}" (${file})`;
+}
+function add_pin(pins, pin, file) {
+  const existing = pins.get(pin.name);
+  if (existing !== void 0 && existing !== pin.ref) {
+    throw new Error(conflict_message(pin.name, existing, pin.ref, file));
+  }
+  pins.set(pin.name, pin.ref);
+}
+function collect_into(pins, source) {
+  for (const line of source.text.split("\n")) {
+    const pin = parse_uses_line(line);
+    if (pin) add_pin(pins, pin, source.file);
+  }
+}
+function collect_canonical(sources) {
+  const pins = /* @__PURE__ */ new Map();
+  for (const source of sources) collect_into(pins, source);
+  return pins;
+}
+function drift_for_line(template, line, index, canonical) {
+  const pin = parse_uses_line(line);
+  if (!pin) return void 0;
+  const want = canonical.get(pin.name);
+  if (want === void 0 || want === pin.ref) return void 0;
+  return { template, line: index + 1, action: pin.name, from: pin.ref, to: want };
+}
+function find_drift_in_text(template, text, canonical) {
+  const drifts = [];
+  for (const [index, line] of text.split("\n").entries()) {
+    const drift = drift_for_line(template, line, index, canonical);
+    if (drift) drifts.push(drift);
+  }
+  return drifts;
+}
+function rewrite_line(line, canonical) {
+  const pin = parse_uses_line(line);
+  if (!pin) return line;
+  const want = canonical.get(pin.name);
+  if (want === void 0 || want === pin.ref) return line;
+  const key_index = line.indexOf(USES_KEY);
+  return `${line.slice(0, key_index)}${USES_KEY} ${pin.name}@${want}`;
+}
+function apply_to_text(text, canonical) {
+  return text.split("\n").map((line) => rewrite_line(line, canonical)).join("\n");
+}
+function read_source(relative_directory, name) {
+  const file = path7.join(relative_directory, name);
+  return { file, text: readFileSync6(package_path(file), "utf8") };
+}
+function list_workflow_sources(relative_directory) {
+  return readdirSync(package_path(relative_directory)).filter((name) => YAML_PATTERN.test(name)).toSorted((left, right) => left.localeCompare(right)).map((name) => read_source(relative_directory, name));
+}
+function list_composite_action_sources() {
+  return composite_actions.list(package_path).map((file) => ({ file, text: readFileSync6(package_path(file), "utf8") }));
+}
+function build_canonical_pins() {
+  return collect_canonical([
+    ...list_workflow_sources(RUNTIME_WORKFLOWS_DIR),
+    ...list_composite_action_sources()
+  ]);
+}
+function unknown_actions_in_source(source, canonical) {
+  const unknown = [];
+  for (const [index, line] of source.text.split("\n").entries()) {
+    const pin = parse_uses_line(line);
+    if (pin && !canonical.has(pin.name)) {
+      unknown.push({ template: source.file, line: index + 1, action: pin.name });
+    }
+  }
+  return unknown;
+}
+function apply_pins_for_destination(destination, text) {
+  if (!is_workflow_destination(destination)) return text;
+  return apply_to_text(text, build_canonical_pins());
+}
+function scan_templates(scan) {
+  const canonical = build_canonical_pins();
+  return list_workflow_sources(TEMPLATE_WORKFLOWS_DIR).flatMap((source) => scan(source, canonical));
+}
+function find_unknown_template_actions() {
+  return scan_templates(unknown_actions_in_source);
+}
+function format_drift_message(drifts) {
+  const lines = drifts.map(
+    (drift) => `  - ${drift.template}:${String(drift.line)} ${drift.action}: ${drift.from} \u2192 ${drift.to}`
+  );
+  return [
+    "\u2716 Template workflow action pins drifted from .github/workflows:",
+    ...lines,
+    SYNC_HINT
+  ].join("\n");
+}
+var workflow_pin_logic = {
+  RUNTIME_WORKFLOWS_DIR,
+  parse_uses_line,
+  collect_canonical,
+  find_drift_in_text,
+  apply_to_text,
+  is_workflow_destination,
+  apply_pins_for_destination,
+  build_canonical_pins,
+  find_unknown_template_actions,
+  format_drift_message
+};
+
+// scripts/init/claude-plugin-config.ts
+import path8 from "node:path";
+var MARKETPLACE_NAME = "kit";
+var PLUGIN_ID = "kit@kit";
+var MARKETPLACE_PATH = "./node_modules/@joshuafolkken/kit";
+var CLAUDE_SETTINGS_DESTINATION = path8.join(".claude", "settings.json");
+var PLUGIN_SETTINGS = {
+  extraKnownMarketplaces: {
+    [MARKETPLACE_NAME]: { source: { source: "directory", path: MARKETPLACE_PATH } }
+  },
+  enabledPlugins: { [PLUGIN_ID]: true }
+};
+function inject_plugin_config(content) {
+  return init_logic_json_merge.merge_json_object(content, PLUGIN_SETTINGS);
+}
+function apply_plugin_config_for_destination(destination_path, content) {
+  return destination_path.endsWith(CLAUDE_SETTINGS_DESTINATION) ? inject_plugin_config(content) : content;
+}
+var claude_plugin_config = {
+  PLUGIN_ID,
+  MARKETPLACE_PATH,
+  CLAUDE_SETTINGS_DESTINATION,
+  inject_plugin_config,
+  apply_plugin_config_for_destination
+};
+
+// scripts/init/claude-kit-only-settings.ts
+var KIT_ONLY_SETTING_KEYS = ["enableArtifact"];
+function strip_kit_only_settings(content) {
+  let stripped = content;
+  for (const key of KIT_ONLY_SETTING_KEYS) stripped = patch_json_key.remove_json_key(stripped, key);
+  return stripped;
+}
+function apply_kit_only_strip_for_destination(destination_path, content) {
+  return destination_path.endsWith(claude_plugin_config.CLAUDE_SETTINGS_DESTINATION) ? strip_kit_only_settings(content) : content;
+}
+var claude_kit_only_settings = {
+  KIT_ONLY_SETTING_KEYS,
+  strip_kit_only_settings,
+  apply_kit_only_strip_for_destination
+};
+
+// scripts/init/hook-launch.ts
+var HOOK_DIST_DIR = "dist/hooks";
+var RUN_HOOK_SCRIPT = "scripts/hooks/run-hook.sh";
+var ROOT_LOOKUP = "git rev-parse --show-toplevel";
+var CLAUDE_ROOT = "$CLAUDE_PROJECT_DIR";
+var CODEX_ROOT = `$( (unset GIT_DIR GIT_WORK_TREE; ${ROOT_LOOKUP} 2>/dev/null) || ${ROOT_LOOKUP})`;
+function rooted_path(root, relative_path) {
+  return `"${root}/${relative_path}"`;
+}
+function hook_launch_command(name, root = CLAUDE_ROOT) {
+  return `sh ${rooted_path(root, RUN_HOOK_SCRIPT)} ${name}`;
+}
+function codex_command(command) {
+  return command.split(`"${CLAUDE_ROOT}/`).join(`"${CODEX_ROOT}/`);
+}
+function fallback_command(name) {
+  return name.replace("-", ":");
+}
+var hook_launch = {
+  CLAUDE_ROOT,
+  codex_command,
+  CODEX_ROOT,
+  fallback_command,
+  HOOK_DIST_DIR,
+  hook_launch_command,
+  rooted_path,
+  RUN_HOOK_SCRIPT
+};
+
+// scripts/init/hook-command-rewrite.ts
+var PNPM_JOSH_PREFIX = "pnpm josh ";
+var { MARKETPLACE_PATH: MARKETPLACE_PATH2 } = claude_plugin_config;
+var PACKAGE_PATH = MARKETPLACE_PATH2.replace(/^\.\//u, "");
+var INSTALLED_LAUNCHER = `${PACKAGE_PATH}/${hook_launch.RUN_HOOK_SCRIPT}`;
+var INSTALLED_DISPATCHER = `${PACKAGE_PATH}/dist/josh.js`;
+var INSTALLED_MANIFEST = `${PACKAGE_PATH}/package.json`;
+var MISSING_INSTALL_NOTICE = "kit hooks inactive: run pnpm install, then reread CLAUDE.md";
+var CODEX_HOOKS_DESTINATION = ".codex/hooks.json";
+var RELATIVE_RUN_HOOK_INVOCATION = `sh ${hook_launch.RUN_HOOK_SCRIPT} `;
+var RELATIVE_CONSUMER_RUN_HOOK_INVOCATION = `sh ${MARKETPLACE_PATH2}/${hook_launch.RUN_HOOK_SCRIPT} `;
+var RELATIVE_BUNDLE_INVOCATION = `node ${MARKETPLACE_PATH2}/dist/josh.js `;
+var RELATIVE_INSTALL_GUARD = `if [ ! -f ${MARKETPLACE_PATH2}/package.json ]; then echo '${MISSING_INSTALL_NOTICE}' >&2; exit 0; fi; `;
+var LOCATION_VARIABLES = "GIT_ALTERNATE_OBJECT_DIRECTORIES GIT_COMMON_DIR GIT_DIR GIT_INDEX_FILE GIT_NAMESPACE GIT_OBJECT_DIRECTORY GIT_WORK_TREE";
+var ROOT_LOOKUP2 = "git rev-parse --show-toplevel";
+var LOCATION_FREE_ROOT = `$( (unset ${LOCATION_VARIABLES}; ${ROOT_LOOKUP2} 2>/dev/null) || ${ROOT_LOOKUP2})`;
+var ROOT_PREFIXES = [
+  `export JOSH_HOOK_CWD="$PWD" && project_root="\${CLAUDE_PROJECT_DIR:-${LOCATION_FREE_ROOT}}" && cd "$project_root" && `,
+  `project_root="\${CLAUDE_PROJECT_DIR:-${LOCATION_FREE_ROOT}}" && cd "$project_root" && `,
+  `if project_root="$(unset ${LOCATION_VARIABLES}; ${ROOT_LOOKUP2} 2>/dev/null)"; then unset ${LOCATION_VARIABLES}; else project_root="$(${ROOT_LOOKUP2})"; fi && cd "$project_root" && `
+];
+var PLAIN_KIT_COMMANDS = new Set(
+  [
+    "audit:provision",
+    "batch:guard",
+    "format:edited",
+    "investigation:guard",
+    "rule:guard",
+    "session:lang"
+  ].map((command) => `${PNPM_JOSH_PREFIX}${command}`)
+);
+var KIT_COMMAND_MARKERS = [
+  `/${hook_launch.RUN_HOOK_SCRIPT}" `,
+  `/${INSTALLED_DISPATCHER}" `,
+  RELATIVE_RUN_HOOK_INVOCATION,
+  RELATIVE_CONSUMER_RUN_HOOK_INVOCATION,
+  RELATIVE_BUNDLE_INVOCATION
+];
+var COMMAND_FIELD = /("command":\s*")((?:[^"\\]|\\.)*)(")/gu;
+function install_guard(root) {
+  const manifest = hook_launch.rooted_path(root, INSTALLED_MANIFEST);
+  return `if [ ! -f ${manifest} ]; then echo '${MISSING_INSTALL_NOTICE}' >&2; exit 0; fi; `;
+}
+function launch_part(command, root) {
+  const prefix = ROOT_PREFIXES.find((candidate) => command.startsWith(candidate)) ?? "";
+  const launch = command.slice(prefix.length);
+  const guard = [RELATIVE_INSTALL_GUARD, install_guard(root)].find(
+    (candidate) => launch.startsWith(candidate)
+  );
+  return launch.slice(guard?.length ?? 0);
+}
+function rebased(launch, root) {
+  const consumer_launch = `sh ${hook_launch.rooted_path(root, INSTALLED_LAUNCHER)} `;
+  const bundle_launch = `node ${hook_launch.rooted_path(root, INSTALLED_DISPATCHER)} `;
+  const replacements = [
+    [`sh ${hook_launch.rooted_path(root, hook_launch.RUN_HOOK_SCRIPT)} `, consumer_launch],
+    [RELATIVE_CONSUMER_RUN_HOOK_INVOCATION, consumer_launch],
+    [RELATIVE_RUN_HOOK_INVOCATION, consumer_launch],
+    [RELATIVE_BUNDLE_INVOCATION, bundle_launch],
+    [PNPM_JOSH_PREFIX, bundle_launch]
+  ];
+  let text = launch;
+  for (const [from, to] of replacements) text = text.split(from).join(to);
+  return text;
+}
+function rewrite_command(command, root) {
+  const rewritten = rebased(launch_part(command, root), root);
+  return rewritten.includes(PACKAGE_PATH) ? `${install_guard(root)}${rewritten}` : rewritten;
+}
+function rewrite_command_value(value, root) {
+  const command = JSON.parse(`"${value}"`);
+  const rewritten = rewrite_command(command, root);
+  return rewritten === command ? value : JSON.stringify(rewritten).slice(1, -1);
+}
+function rewrite_hook_commands(content, is_codex = false) {
+  const root = is_codex ? hook_launch.CODEX_ROOT : hook_launch.CLAUDE_ROOT;
+  return content.replaceAll(
+    COMMAND_FIELD,
+    (_match, open, value, close) => `${open}${rewrite_command_value(value, root)}${close}`
+  );
+}
+function apply_hook_command_rewrite_for_destination(destination_path, content) {
+  if (destination_path.endsWith(CODEX_HOOKS_DESTINATION)) {
+    return rewrite_hook_commands(content, true);
+  }
+  if (destination_path.endsWith(claude_plugin_config.CLAUDE_SETTINGS_DESTINATION)) {
+    return rewrite_hook_commands(content);
+  }
+  return content;
+}
+function is_kit_hook_command(command) {
+  if (PLAIN_KIT_COMMANDS.has(command)) return true;
+  return KIT_COMMAND_MARKERS.some((marker) => command.includes(marker));
+}
+var hook_command_rewrite = {
+  apply_hook_command_rewrite_for_destination,
+  is_kit_hook_command,
+  rewrite_hook_commands
+};
+
+// scripts/init/security-policy.ts
+import path9 from "node:path";
+var SECURITY_MD = "SECURITY.md";
+var SECURITY_TEMPLATE = "templates/SECURITY.md";
+var REPOSITORY_PLACEHOLDER = "{{REPOSITORY}}";
+var KIT_ADVISORY_URL = "https://github.com/joshuafolkken/kit/security/advisories/new";
+var UNRESOLVED_REASON = "`origin` is not a GitHub repository `owner/repo` can be read from";
+var LINK_DELIMITER = /[\s()<>[\]]+/u;
+function repository_at(root) {
+  const url = git_spawn_sync.origin_url(root);
+  const identity = url === void 0 ? void 0 : repo_origin.parse_origin_url(url);
+  return identity === void 0 ? void 0 : `${identity.owner}/${identity.repo}`;
+}
+function apply_repository(content, repository) {
+  return content.replaceAll(REPOSITORY_PLACEHOLDER, () => repository);
+}
+function apply_repository_for_destination(destination_path, content) {
+  if (path9.basename(destination_path) !== SECURITY_MD) return content;
+  const repository = repository_at(path9.dirname(destination_path));
+  if (repository === void 0) {
+    throw new Error(`${SECURITY_MD} needs a GitHub origin to name the repository it reports to`);
+  }
+  return apply_repository(content, repository);
+}
+function does_report_to_kit(root) {
+  const existing = file_reader.read_if_readable(path9.join(root, SECURITY_MD)) ?? "";
+  return new Set(existing.split(LINK_DELIMITER)).has(KIT_ADVISORY_URL);
+}
+function unresolved_warning(root) {
+  if (!does_report_to_kit(root)) return `  \u26A0 skipped   ${SECURITY_MD} (${UNRESOLVED_REASON})`;
+  return `  \u26A0 stale     ${SECURITY_MD} still reports vulnerabilities to joshuafolkken/kit \u2014 replace it with your own policy or delete it (${UNRESOLVED_REASON})`;
+}
+function did_skip_unresolved(filename, root) {
+  if (filename !== SECURITY_MD || repository_at(root) !== void 0) return false;
+  console.warn(unresolved_warning(root));
+  return true;
+}
+var security_policy = {
+  SECURITY_MD,
+  SECURITY_TEMPLATE,
+  REPOSITORY_PLACEHOLDER,
+  KIT_ADVISORY_URL,
+  repository_at,
+  apply_repository_for_destination,
+  did_skip_unresolved
+};
+
+// scripts/init/init-copy-content.ts
+function transform_copied_content(destination_path, content) {
+  const with_paths = init_logic.transform_distributed_paths(content);
+  const with_pins = workflow_pin_logic.apply_pins_for_destination(destination_path, with_paths);
+  const with_marker = managed_marker_logic.apply_marker_for_destination(
+    destination_path,
+    with_pins,
+    KIT_PACKAGE_NAME
+  );
+  const with_kit_only_stripped = claude_kit_only_settings.apply_kit_only_strip_for_destination(
+    destination_path,
+    with_marker
+  );
+  const with_plugin = claude_plugin_config.apply_plugin_config_for_destination(
+    destination_path,
+    with_kit_only_stripped
+  );
+  const with_hooks = hook_command_rewrite.apply_hook_command_rewrite_for_destination(
+    destination_path,
+    with_plugin
+  );
+  return security_policy.apply_repository_for_destination(destination_path, with_hooks);
+}
+
+// scripts/sync/directory-copy-guard.ts
+function classify_path(candidate_path) {
+  try {
+    return lstatSync2(candidate_path).isDirectory() ? "directory" : "other";
+  } catch (error) {
+    return file_reader.is_absent(error) ? "absent" : "other";
+  }
+}
+function directory_copy_blocker(source_path, destination_path) {
+  if (classify_path(source_path) !== "directory") return "missing from the installed package";
+  if (path10.resolve(source_path) === path10.resolve(destination_path)) {
+    return "already the package's own copy";
+  }
+  return classify_path(destination_path) === "other" ? "destination is not a directory" : void 0;
+}
+var TRANSFORMED_EXTENSION = ".md";
+function is_regular_file(candidate_path) {
+  try {
+    return lstatSync2(candidate_path).isFile();
+  } catch {
+    return false;
+  }
+}
+function is_transformable(candidate_path) {
+  return candidate_path.endsWith(TRANSFORMED_EXTENSION) && is_regular_file(candidate_path);
+}
+function transform_copied_file(file_path) {
+  const content = readFileSync7(file_path, "utf8");
+  const transformed = transform_copied_content(file_path, content);
+  if (transformed !== content) file_content.write_contained(file_path, transformed);
+}
+function transform_copied_tree(source_path, destination_path) {
+  const entries = readdirSync2(source_path, { encoding: "utf8", recursive: true });
+  for (const entry of entries) {
+    if (!is_transformable(path10.join(source_path, entry))) continue;
+    transform_copied_file(path10.join(destination_path, entry));
+  }
+}
+function should_copy_entry(source_path, destination_path) {
+  if (!is_regular_file(source_path)) return true;
+  if (classify_path(destination_path) === "directory") {
+    throw new Error("destination is a directory where the package has a file");
+  }
+  const source_content = readFileSync7(source_path);
+  const content = source_path.endsWith(TRANSFORMED_EXTENSION) ? transform_copied_content(destination_path, source_content.toString("utf8")) : source_content;
+  return !file_content.is_same_file_content(destination_path, content);
+}
+function is_changed_entry(source_entry, destination_entry, root) {
+  if (source_entry === root) return false;
+  if (is_regular_file(source_entry)) return true;
+  return classify_path(destination_entry) === "absent";
+}
+function copy_directory(source_path, destination_path) {
+  let did_change = false;
+  cpSync(source_path, destination_path, {
+    recursive: true,
+    filter: (source_entry, destination_entry) => {
+      const should_copy = should_copy_entry(source_entry, destination_entry);
+      if (should_copy && is_changed_entry(source_entry, destination_entry, source_path)) {
+        did_change = true;
+      }
+      return should_copy;
+    }
+  });
+  return did_change;
+}
+function failure_message(prefix, error) {
+  return `${prefix} (${error_text.message_of(error)})`;
+}
+function copy_directory_failure(source_path, destination_path, on_copy) {
+  let did_change = false;
+  try {
+    did_change ||= copy_directory(source_path, destination_path);
+  } catch (error) {
+    return failure_message("copy failed", error);
+  }
+  try {
+    transform_copied_tree(source_path, destination_path);
+  } catch (error) {
+    return failure_message("copied but left partly un-rewritten \u2014 re-run the sync", error);
+  }
+  on_copy?.(did_change);
+  return void 0;
+}
+
+// scripts/init/init-sonar.ts
+import { existsSync as existsSync5 } from "node:fs";
+import path11 from "node:path";
+
+// scripts/security/sonar-file.ts
+import { existsSync as existsSync4, readFileSync as readFileSync8 } from "node:fs";
+function write_sonar_file(template_source, destination_path, identifiers) {
+  const content = init_logic.apply_sonar_template(
+    readFileSync8(template_source, "utf8"),
+    identifiers.project_key,
+    identifiers.organization
+  );
+  file_content.write_contained(destination_path, content);
+}
+function merge_sonar_file(template_source, destination_path, identifiers) {
+  if (!existsSync4(destination_path)) {
+    write_sonar_file(template_source, destination_path, identifiers);
+    return;
+  }
+  const template_content = init_logic.apply_sonar_template(
+    readFileSync8(template_source, "utf8"),
+    identifiers.project_key,
+    identifiers.organization
+  );
+  const existing = readFileSync8(destination_path, "utf8");
+  file_content.write_contained(
+    destination_path,
+    init_logic.merge_sonar_properties(existing, template_content)
+  );
+}
+var sonar_file = { write_sonar_file, merge_sonar_file };
+
+// scripts/init/init-sonar.ts
+function copy_sonar_with_template(name_with_owner) {
+  const destination = init_logic.get_sonar_template_destination();
+  if (name_with_owner === void 0) {
+    console.warn(`  \u26A0 skipped   ${destination} (gh repo view failed)`);
+    return;
+  }
+  const destination_path = path11.join(PROJECT_ROOT, destination);
+  const is_existing = existsSync5(destination_path);
+  const identifiers = init_logic.derive_sonar_identifiers(name_with_owner);
+  sonar_file.merge_sonar_file(
+    path11.join(PACKAGE_DIR, init_logic.get_sonar_template_source()),
+    destination_path,
+    identifiers
+  );
+  console.info(`  \u2714 ${is_existing ? "updated" : "created"}   ${destination}`);
+}
+var init_sonar = {
+  copy_sonar_with_template
+};
+
+// scripts/init/init-ai-copy.ts
+var WORKSPACE_YAML = "pnpm-workspace.yaml";
+var CLAUDE_MD_FILENAME = "CLAUDE.md";
+var BASIC_CLAUDE_IMPORT = "@node_modules/@joshuafolkken/kit/dist/CLAUDE.basic.md";
+var PRETTIER_IGNORE = ".prettierignore";
+var GIT_ATTRIBUTES = ".gitattributes";
+var CODE_OF_CONDUCT = "CODE_OF_CONDUCT.md";
+var { SECURITY_MD: SECURITY_MD2 } = security_policy;
+var AGENTS_MD = "AGENTS.md";
+var GEMINI_MD = "GEMINI.md";
+var BASIC_AI_FILES = [
+  AGENTS_MD,
+  GEMINI_MD,
+  PRETTIER_IGNORE,
+  GIT_ATTRIBUTES,
+  CODE_OF_CONDUCT,
+  SECURITY_MD2,
+  WORKSPACE_YAML
+];
+var BASIC_SOURCES = {
+  [AGENTS_MD]: "templates/AGENTS.basic.md",
+  [GEMINI_MD]: "templates/GEMINI.basic.md",
+  [PRETTIER_IGNORE]: "templates/prettierignore.basic",
+  [WORKSPACE_YAML]: "templates/pnpm-workspace.basic.yaml"
+};
+var CONSUMER_SOURCES = {
+  [SECURITY_MD2]: security_policy.SECURITY_TEMPLATE
+};
+var BASIC_WORKFLOW_AI_FILES = [...BASIC_AI_FILES, ".claude/settings.json"];
+var GITHUB_FILES = /* @__PURE__ */ new Set([CODE_OF_CONDUCT, SECURITY_MD2]);
+var BASIC_POINTER_MAPPING = { src: "templates/cursorrules.basic", dest: ".cursorrules" };
+var PULL_REQUEST_TEMPLATE = ".github/pull_request_template.md";
+var RELEASE_CONFIG = ".github/release.yml";
+var BASIC_GITHUB_MAPPINGS = [
+  { src: PULL_REQUEST_TEMPLATE, dest: PULL_REQUEST_TEMPLATE },
+  { src: RELEASE_CONFIG, dest: RELEASE_CONFIG }
+];
+function did_read_unstamped(destination_path) {
+  try {
+    return !managed_marker_logic.is_marked(readFileSync9(destination_path, "utf8"));
+  } catch {
+    return false;
+  }
+}
+function copied_content(source_path, destination_path) {
+  return transform_copied_content(destination_path, readFileSync9(source_path, "utf8"));
+}
+function copy_ai_file(source_path, destination_path) {
+  file_content.write_contained(destination_path, copied_content(source_path, destination_path));
+}
+function did_warn_unstamped_workflow(destination_path, label) {
+  if (!is_workflow_destination(destination_path) || !did_read_unstamped(destination_path)) {
+    return false;
+  }
+  console.warn(`  \u26A0 ${label} has no managed-workflow header \u2014 run josh sync before merging bumps`);
+  return true;
+}
+function did_skip_copy_if_absent(source_path, destination_path, label) {
+  if (existsSync6(destination_path)) {
+    console.info(`  \u23ED skipped   ${label} (already exists)`);
+    did_warn_unstamped_workflow(destination_path, label);
+    return true;
+  }
+  copy_ai_file(source_path, destination_path);
+  console.info(`  \u2714 created   ${label}`);
+  return false;
+}
+function read_workspace_template(source_path, destination_path) {
+  const npmrc = file_reader.read_file_or_empty(path12.join(path12.dirname(destination_path), ".npmrc"));
+  const distributed = init_logic.drop_kit_only_regions(readFileSync9(source_path, "utf8"));
+  return init_logic.carry_npmrc_settings(distributed, npmrc);
+}
+function merge_existing_workspace_yaml(source_path, destination_path) {
+  const template = read_workspace_template(source_path, destination_path);
+  const existing = readFileSync9(destination_path, "utf8");
+  const merged = init_logic.merge_workspace_yaml(existing, template);
+  if (merged === existing) {
+    console.info(`  \u2714 unchanged ${WORKSPACE_YAML}`);
+    return;
+  }
+  file_content.write_contained(destination_path, merged);
+  console.info(`  \u2714 updated   ${WORKSPACE_YAML}`);
+}
+function workspace_content(source_path, destination_path) {
+  return transform_copied_content(
+    destination_path,
+    read_workspace_template(source_path, destination_path)
+  );
+}
+function did_skip_workspace_yaml_copy(source_path, destination_path) {
+  if (existsSync6(destination_path)) {
+    merge_existing_workspace_yaml(source_path, destination_path);
+    return false;
+  }
+  file_content.write_contained(destination_path, workspace_content(source_path, destination_path));
+  console.info(`  \u2714 created   ${WORKSPACE_YAML}`);
+  return false;
+}
+function ai_file_source(filename, shape) {
+  const basic_source = shape?.profile === "basic" ? BASIC_SOURCES[filename] : void 0;
+  return basic_source ?? CONSUMER_SOURCES[filename] ?? filename;
+}
+function did_skip_ai_file_copy(filename, shape) {
+  if (security_policy.did_skip_unresolved(filename, PROJECT_ROOT)) return false;
+  const source_path = package_path(ai_file_source(filename, shape));
+  const destination_path = path12.join(PROJECT_ROOT, filename);
+  if (filename === WORKSPACE_YAML) {
+    return did_skip_workspace_yaml_copy(source_path, destination_path);
+  }
+  return did_skip_copy_if_absent(source_path, destination_path, filename);
+}
+function did_skip_ai_file_mapping(source, destination) {
+  return did_skip_copy_if_absent(
+    package_path(source),
+    path12.join(PROJECT_ROOT, destination),
+    destination
+  );
+}
+function directory_copy_skip(source_path, destination_path) {
+  const blocker = directory_copy_blocker(source_path, destination_path);
+  if (blocker !== void 0) return { reason: blocker, is_blocked: true };
+  if (classify_path(destination_path) !== "absent") {
+    return { reason: "already exists \u2014 run josh sync to update", is_blocked: false };
+  }
+  return void 0;
+}
+function report_directory_skip(directory_name, skip) {
+  const line = `${directory_name}/ (${skip.reason})`;
+  if (skip.is_blocked) console.warn(`  \u26A0 skipped   ${line}`);
+  else console.info(`  \u23ED skipped   ${line}`);
+}
+function did_copy_directory(directory_name) {
+  const failure = copy_directory_failure(
+    package_path(directory_name),
+    path12.join(PROJECT_ROOT, directory_name)
+  );
+  if (failure !== void 0) {
+    console.warn(`  \u26A0 skipped   ${directory_name}/ (${failure})`);
+    return false;
+  }
+  console.info(`  \u2714 created   ${directory_name}/`);
+  return true;
+}
+function did_skip_ai_directory_copy(directory_name) {
+  const skip = directory_copy_skip(
+    package_path(directory_name),
+    path12.join(PROJECT_ROOT, directory_name)
+  );
+  if (skip === void 0) {
+    did_copy_directory(directory_name);
+    return false;
+  }
+  report_directory_skip(directory_name, skip);
+  return !skip.is_blocked;
+}
+function basic_claude_md() {
+  return `> If kit is not installed, run \`pnpm install\` first.
+
+${BASIC_CLAUDE_IMPORT}
+`;
+}
+function ensure_basic_claude_md(existing) {
+  if (existing === void 0) return basic_claude_md();
+  const kept = distributed_paths.remove_claude_md_import(existing);
+  if (kept.includes(BASIC_CLAUDE_IMPORT)) return kept;
+  return kept === "" ? basic_claude_md() : `${basic_claude_md()}
+${kept}`;
+}
+function did_skip_claude_md_import(shape) {
+  const destination_path = path12.join(PROJECT_ROOT, CLAUDE_MD_FILENAME);
+  if (existsSync6(destination_path)) {
+    console.info(`  \u23ED skipped   ${CLAUDE_MD_FILENAME} (already exists)`);
+    return true;
+  }
+  const content = shape?.profile === "basic" ? basic_claude_md() : init_logic.ensure_claude_md_import(void 0);
+  file_content.write_contained(destination_path, content);
+  console.info(`  \u2714 created   ${CLAUDE_MD_FILENAME}`);
+  return false;
+}
+function should_copy_git_file(filename, shape) {
+  if (shape?.has_git !== false) return true;
+  return filename !== GIT_ATTRIBUTES && !filename.startsWith(".claude/") && !filename.startsWith(".codex/");
+}
+function should_copy_github_file(filename, shape) {
+  if (shape?.has_github !== false) return true;
+  return !GITHUB_FILES.has(filename) && !filename.startsWith(".github/");
+}
+function should_copy_basic_file(filename, shape) {
+  if (filename !== PRETTIER_IGNORE || shape?.profile !== "basic") return true;
+  return shape.should_use_prettier;
+}
+function should_copy_ai_file(filename, shape) {
+  return should_copy_git_file(filename, shape) && should_copy_github_file(filename, shape) && should_copy_basic_file(filename, shape);
+}
+function basic_ai_files(shape) {
+  return shape.has_workflow ? BASIC_WORKFLOW_AI_FILES : BASIC_AI_FILES;
+}
+function ai_files(shape) {
+  const files = shape?.profile === "basic" ? basic_ai_files(shape) : init_logic.get_ai_copy_files();
+  return files.filter((filename) => should_copy_ai_file(filename, shape));
+}
+function copied_files(shape) {
+  return [...ai_files(shape), ...npm_publish_files.files(shape)];
+}
+function ai_file_mappings(shape) {
+  const mappings = shape?.profile === "basic" ? [BASIC_POINTER_MAPPING, ...shape.has_github ? BASIC_GITHUB_MAPPINGS : []] : init_logic.get_ai_copy_file_mappings();
+  return mappings.filter(({ dest }) => shape?.has_github !== false || !dest.startsWith(".github/"));
+}
+function ai_mapping_skips(shape) {
+  return ai_file_mappings(shape).map(({ src, dest }) => did_skip_ai_file_mapping(src, dest));
+}
+function repository_name(shape) {
+  if (shape?.has_github === false || shape?.profile === "basic") return void 0;
+  return gh_spawn.get_repo_name_with_owner();
+}
+function report_sync_hint(has_skips, shape) {
+  if (!has_skips || shape?.profile === "basic") return;
+  console.info("\n  \u{1F4A1} Run `josh sync` to overwrite skipped AI files with the latest version.");
+}
+function run_ai_copies(shape) {
+  const did_skip_claude_md = did_skip_claude_md_import(shape);
+  const file_skips = copied_files(shape).map((filename) => did_skip_ai_file_copy(filename, shape));
+  const mapping_skips = ai_mapping_skips(shape);
+  const directory_skips = init_logic.get_ai_copy_directories().map((directory_name) => did_skip_ai_directory_copy(directory_name));
+  const has_skips = [did_skip_claude_md, ...file_skips, ...mapping_skips, ...directory_skips].some(
+    Boolean
+  );
+  const name_with_owner = repository_name(shape);
+  if (shape?.profile !== "basic") init_sonar.copy_sonar_with_template(name_with_owner);
+  report_sync_hint(has_skips, shape);
+  return name_with_owner;
+}
+var init_ai_copy = {
+  copy_ai_file,
+  copied_content,
+  workspace_content,
+  run_ai_copies,
+  ai_files,
+  copied_files,
+  ai_file_source,
+  ai_file_mappings,
+  ensure_basic_claude_md,
+  read_workspace_template
+};
+
+// scripts/init/kit-written-paths.ts
+var LOCKFILE = "pnpm-lock.yaml";
+var SETUP_ONLY_PATHS = /* @__PURE__ */ new Set([
+  CLAUDE_MD_FILENAME,
+  BASIC_PRETTIER_CONFIG,
+  PROJECT_CONFIG_FILE,
+  PACK_HOOK_FILE,
+  PACKAGE_JSON,
+  LOCKFILE
+]);
+function is_kit_written(file_path) {
+  return SETUP_ONLY_PATHS.has(file_path) || managed_config_scope.has_managed_path([file_path]);
+}
+function select(paths) {
+  return paths.filter((file_path) => is_kit_written(file_path));
+}
+var kit_written_paths = { is_kit_written, select };
+
+// scripts/init/own-formatter.ts
+import { existsSync as existsSync7 } from "node:fs";
+import path13 from "node:path";
+var OWN_FORMATTER_CONFIGS = [
+  "biome.json",
+  "biome.jsonc",
+  "dprint.json",
+  "dprint.jsonc",
+  ".dprint.json",
+  ".dprint.jsonc"
+];
+function find_config(root) {
+  return OWN_FORMATTER_CONFIGS.find((name) => existsSync7(path13.join(root, name)));
+}
+var own_formatter = { find_config };
+
+// scripts/init/workflow-mark.ts
+var WORKFLOW_ENV = "JOSH_WORKFLOW";
+var GITHUB_WORKFLOW = "github";
+function is_requested(environment = process.env) {
+  return environment[WORKFLOW_ENV] === GITHUB_WORKFLOW;
+}
+function is_recorded(manifest) {
+  const josh = manifest?.["josh"];
+  return json_value.is_record(josh) && josh["workflow"] === GITHUB_WORKFLOW;
+}
+function request(environment = process.env) {
+  environment[WORKFLOW_ENV] = GITHUB_WORKFLOW;
+}
+function recorded_fields(has_workflow2) {
+  return has_workflow2 ? { workflow: GITHUB_WORKFLOW } : {};
+}
+var workflow_mark = { is_requested, is_recorded, request, recorded_fields };
+
+// scripts/init/project-profile.ts
+var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".svelte-kit"]);
+var WEB_EXTENSIONS = /* @__PURE__ */ new Set([".html", ".css", ".js", ".jsx", ".mjs", ".cjs"]);
+var TYPESCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx"]);
+var PROFILE_ARG_LENGTH = 2;
+var PROFILE_NAMES = {
+  basic: "basic",
+  full: "full",
+  static: "basic",
+  node: "full"
+};
+function parse_profile(value) {
+  return typeof value === "string" && Object.hasOwn(PROFILE_NAMES, value) ? PROFILE_NAMES[value] : void 0;
+}
+var LEGACY_NAMES = { basic: "static", full: "node" };
+function with_legacy_profile_names(args) {
+  return args.map((argument, index) => {
+    const profile = args[index - 1] === "--profile" ? parse_profile(argument) : void 0;
+    return profile === void 0 ? argument : LEGACY_NAMES[profile];
+  });
+}
+function is_profile_pair(args) {
+  return args.length === PROFILE_ARG_LENGTH && args[0] === "--profile";
+}
+function requested_profile(args, usage = "josh init [--profile basic|full]") {
+  if (args.length === 0) return void 0;
+  if (!is_profile_pair(args)) throw new Error(`Usage: ${usage}`);
+  const profile = parse_profile(args[1]);
+  if (profile !== void 0) return profile;
+  throw new Error("Profile must be basic or full");
+}
+function read_manifest(root) {
+  if (!existsSync8(package_manifest.manifest_path(root))) return void 0;
+  const parsed = package_manifest.read_manifest(root, z4.unknown());
+  if (!json_value.is_record(parsed)) throw new Error("package.json must contain an object");
+  return parsed;
+}
+function recorded_profile(manifest) {
+  const { josh } = manifest;
+  return json_value.is_record(josh) ? parse_profile(josh["profile"]) : void 0;
+}
+function has_build_script(value) {
+  return json_value.is_record(value) && ("build" in value || "dev" in value);
+}
+function has_project_dependencies(value) {
+  if (!json_value.is_record(value)) return false;
+  return Object.keys(value).some((name) => name !== KIT_PACKAGE_NAME);
+}
+function inferred_profile(manifest) {
+  if (has_project_dependencies(manifest["dependencies"]) || has_project_dependencies(manifest["devDependencies"])) {
+    return { profile: "full", reason: "package dependencies" };
+  }
+  if (has_build_script(manifest["scripts"])) {
+    return { profile: "full", reason: "build or dev script" };
+  }
+  return { profile: "basic", reason: "metadata-only package.json" };
+}
+function resolve_profile(root, requested) {
+  if (requested !== void 0) return { profile: requested, reason: "explicit --profile" };
+  const manifest = read_manifest(root);
+  if (manifest === void 0) return { profile: "basic", reason: "no package.json" };
+  const profile = recorded_profile(manifest);
+  if (profile !== void 0) return { profile, reason: "package.json josh.profile" };
+  return inferred_profile(manifest);
+}
+function is_ignored_directory(name) {
+  return IGNORED_DIRECTORIES.has(name);
+}
+function should_visit(entry) {
+  return entry.isDirectory() && !is_ignored_directory(entry.name);
+}
+function scan_directory(directory, pending) {
+  const entries = readdirSync3(directory, { withFileTypes: true });
+  pending.push(
+    ...entries.filter((entry) => should_visit(entry)).map((entry) => path14.join(directory, entry.name))
+  );
+  return entries.filter((entry) => entry.isFile()).map((entry) => path14.join(directory, entry.name));
+}
+function is_project_file(root, file) {
+  const relative_path = path14.relative(root, file).split(path14.sep).join(path14.posix.sep);
+  return !kit_written_paths.is_kit_written(relative_path);
+}
+function list_files(root) {
+  const pending = [root];
+  const files = [];
+  for (const directory of pending) {
+    files.push(...scan_directory(directory, pending));
+  }
+  return files;
+}
+function file_extensions(root) {
+  return list_files(root).filter((file) => is_project_file(root, file)).map((file) => path14.extname(file));
+}
+function scan_files(root) {
+  const extensions = file_extensions(root);
+  const has_web = extensions.some((extension) => WEB_EXTENSIONS.has(extension));
+  const should_use_prettier = has_web && own_formatter.find_config(root) === void 0;
+  const has_typescript = extensions.some((extension) => TYPESCRIPT_EXTENSIONS.has(extension));
+  return { should_use_prettier, has_typescript };
+}
+function has_github_remote(root) {
+  const url = git_spawn_sync.origin_url(root);
+  return url !== void 0 && repo_origin.parse_origin_url(url) !== void 0;
+}
+function has_git(root) {
+  return existsSync8(path14.join(root, ".git"));
+}
+function has_workflow(root) {
+  return workflow_mark.is_requested() || workflow_mark.is_recorded(read_manifest(root));
+}
+function inspect_project(root, requested) {
+  const profile = resolve_profile(root, requested);
+  const files = scan_files(root);
+  const is_git = has_git(root);
+  return {
+    ...profile,
+    ...files,
+    has_git: is_git,
+    has_github: is_git && has_github_remote(root),
+    has_workflow: has_workflow(root)
+  };
+}
+var project_profile = {
+  parse_profile,
+  resolve_profile,
+  has_git,
+  inspect_project,
+  is_ignored_directory,
+  list_files,
+  requested_profile,
+  with_legacy_profile_names
+};
+
+export {
+  own_formatter,
+  file_content,
+  PACK_HOOK_FILE,
+  pack_hook,
+  DEFAULT_RELEASE_AGE_MINUTES,
+  release_window,
+  PROJECT_CONFIG_FILE,
+  project_config,
+  vscode_tasks,
+  PRETTIER_CONFIG_JS,
+  LEFTHOOK_PATH,
+  init_actions,
+  hook_launch,
+  hook_command_rewrite,
+  security_policy,
+  transform_copied_content,
+  directory_copy_blocker,
+  is_transformable,
+  copy_directory_failure,
+  sonar_file,
+  WORKSPACE_YAML,
+  CLAUDE_MD_FILENAME,
+  init_ai_copy,
+  kit_written_paths,
+  workflow_mark,
+  project_profile
+};