@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-NDPR5U4U.js

@@ -0,0 +1,897 @@
+import {
+  repository_labels
+} from "./chunk-5ZXR36N7.js";
+import {
+  auto_merge_setting,
+  security_updates
+} from "./chunk-6XXEW3NQ.js";
+import {
+  self_sync_guard
+} from "./chunk-LYO6TX5L.js";
+import {
+  package_manager_version
+} from "./chunk-AWLYN2SP.js";
+import {
+  project_checks
+} from "./chunk-23TWJOAI.js";
+import {
+  DEFAULT_RELEASE_AGE_MINUTES,
+  copy_directory_failure,
+  directory_copy_blocker,
+  file_content,
+  hook_command_rewrite,
+  init_ai_copy,
+  is_transformable,
+  is_workflow_destination,
+  managed_marker_logic,
+  pack_hook,
+  project_config,
+  project_profile,
+  release_window,
+  security_policy,
+  sonar_file,
+  transform_copied_content,
+  vscode_tasks
+} from "./chunk-EJG5ZJKD.js";
+import {
+  gh_spawn
+} from "./chunk-JZZURWZH.js";
+import {
+  PLUGIN_SKILL_DIRECTORIES,
+  init_logic
+} from "./chunk-XT3W32DO.js";
+import {
+  json_format
+} from "./chunk-6OUQZC6V.js";
+import {
+  KIT_PACKAGE_NAME
+} from "./chunk-PBOS7MTW.js";
+import {
+  PACKAGE_DIR,
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+import {
+  package_version_schema,
+  string_array_schema,
+  vscode_settings_schema
+} from "./chunk-RBU2NKHF.js";
+import {
+  PACKAGE_JSON,
+  package_manifest
+} from "./chunk-WB4T3VY2.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/self-sync-guard/self-sync-refusal.ts
+function did_refuse_self_run(package_directory, project_root) {
+  const refusal = self_sync_guard.self_sync_refusal(package_directory, project_root);
+  if (refusal === void 0) return false;
+  console.error(`
+${refusal}
+`);
+  process.exitCode = 1;
+  return true;
+}
+
+// scripts/sync/sync.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, rmSync as rmSync2 } from "node:fs";
+import path6 from "node:path";
+
+// scripts/dependabot/dependabot-cooldown.ts
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+var DEPENDABOT_FILE = path.join(".github", "dependabot.yml");
+var MINUTES_PER_DAY = 1440;
+var MIN_DAYS = 1;
+var MAX_DAYS = 90;
+var NPM_ECOSYSTEM = "npm";
+var UPDATES_PATTERN = /^updates:\s*(?:#.*)?$/u;
+var ECOSYSTEM_PATTERN = /^\s*(?:-\s+)?package-ecosystem:\s*['"]?([\w-]+)/u;
+var TOP_LEVEL_KEY_PATTERN = /^[^\s#-]/u;
+var COOLDOWN_KEY = "cooldown:";
+function cooldown_days(minutes) {
+  const days = Math.ceil((minutes ?? DEFAULT_RELEASE_AGE_MINUTES) / MINUTES_PER_DAY);
+  return Math.min(MAX_DAYS, Math.max(MIN_DAYS, days));
+}
+function quote(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function cooldown_lines(ecosystem, window, indent) {
+  const lines = ["cooldown:", `  default-days: ${String(cooldown_days(window.minutes))}`];
+  if (ecosystem === NPM_ECOSYSTEM && window.exclusions.length > 0) {
+    lines.push("  exclude:", ...window.exclusions.map((name) => `    - ${quote(name)}`));
+  }
+  return lines.map((line) => `${indent}${line}`);
+}
+function indent_width(line) {
+  return line.length - line.trimStart().length;
+}
+function is_blank(line) {
+  return line?.trim() === "";
+}
+function trim_trailing_blanks(lines) {
+  const trimmed = [...lines];
+  while (trimmed.length > 1 && is_blank(trimmed.at(-1))) trimmed.pop();
+  return trimmed;
+}
+function is_comment(line) {
+  return line?.trimStart().startsWith("#") === true;
+}
+function is_detached(line, width) {
+  return is_blank(line) || is_comment(line) && indent_width(line ?? "") < width;
+}
+function block_stop(lines, from, width, limit) {
+  const relative = lines.slice(from, limit).findIndex((line) => !is_blank(line) && !is_comment(line) && indent_width(line) < width);
+  return relative === -1 ? limit : from + relative;
+}
+function block_end(lines, from, width, limit) {
+  const stop = block_stop(lines, from, width, limit);
+  let end = stop;
+  for (let index = stop - 1; index >= from && is_detached(lines[index], width); index -= 1) {
+    if (!is_blank(lines[index])) end = index;
+  }
+  return end;
+}
+function updates_end(lines, updates) {
+  const relative = lines.slice(updates + 1).findIndex((line) => TOP_LEVEL_KEY_PATTERN.test(line));
+  return relative === -1 ? lines.length : updates + 1 + relative;
+}
+function find_entries(lines, updates) {
+  const limit = updates_end(lines, updates);
+  const starts = lines.map((line, index) => ({ index, item: /^(\s*-\s+)\S/u.exec(line)?.[1] })).filter(({ index, item }) => index > updates && index < limit && item !== void 0);
+  const item_width = Math.min(...starts.map(({ item }) => item?.indexOf("-") ?? 0));
+  return starts.filter(({ item }) => item?.indexOf("-") === item_width).map(({ index, item = "" }) => ({
+    start: index,
+    end: block_end(lines, index + 1, item.length, limit),
+    key_indent: " ".repeat(item.length)
+  }));
+}
+function is_cooldown_key(line, index, key_indent) {
+  const is_key_line = index === 0 || line.startsWith(key_indent);
+  return is_key_line && line.slice(key_indent.length).startsWith(COOLDOWN_KEY);
+}
+function promote_first_key(rest, marker) {
+  const first = rest.findIndex((line) => !is_blank(line) && !line.trimStart().startsWith("#"));
+  return rest.map(
+    (line, index) => index === first ? `${marker}${line.slice(marker.length)}` : line
+  );
+}
+function without_cooldown(entry, key_indent) {
+  const start = entry.findIndex((line, index) => is_cooldown_key(line, index, key_indent));
+  if (start === -1) return [...entry];
+  const rest = entry.slice(block_end(entry, start + 1, key_indent.length + 1, entry.length));
+  if (start > 0) return [...entry.slice(0, start), ...rest];
+  return promote_first_key(rest, (entry.at(0) ?? "").slice(0, key_indent.length));
+}
+function rewrite_entry(entry, key_indent, window) {
+  const ecosystem = entry.map((line) => ECOSYSTEM_PATTERN.exec(line)?.[1]).find(Boolean);
+  if (ecosystem === void 0) return [...entry];
+  const body = trim_trailing_blanks(without_cooldown(entry, key_indent));
+  const trailing = entry.slice(trim_trailing_blanks(entry).length);
+  return [...body, ...cooldown_lines(ecosystem, window, key_indent), ...trailing];
+}
+function merge_cooldown(existing, window) {
+  const lines = existing.split("\n");
+  const updates = lines.findIndex((line) => UPDATES_PATTERN.test(line));
+  if (updates === -1) return existing;
+  for (const { start, end, key_indent } of find_entries(lines, updates).toReversed()) {
+    lines.splice(start, end - start, ...rewrite_entry(lines.slice(start, end), key_indent, window));
+  }
+  return lines.join("\n");
+}
+function sync_dependabot_cooldown(root) {
+  const config_path = path.join(root, DEPENDABOT_FILE);
+  if (!existsSync(config_path)) return false;
+  const existing = readFileSync(config_path, "utf8");
+  const merged = merge_cooldown(existing, release_window.read_release_window(root));
+  if (merged === existing) return false;
+  file_content.write_contained(config_path, merged);
+  return true;
+}
+var dependabot_cooldown = { cooldown_days, merge_cooldown, sync_dependabot_cooldown };
+
+// scripts/sync/sync-ai-files.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import path4 from "node:path";
+
+// scripts/sync/claude-settings-merge.ts
+var HOOKS_KEY = "hooks";
+var PERMISSIONS_KEY = "permissions";
+var STATUS_LINE_KEY = "statusLine";
+var WITHDRAWN_KIT_PERMISSIONS = /* @__PURE__ */ new Set([
+  "Bash(git commit -a*)",
+  "Bash(git commit --all*)",
+  "Edit(./.github/workflows/**)",
+  "Write(./.github/workflows/**)"
+]);
+function as_array(value) {
+  return Array.isArray(value) ? value : [];
+}
+function merge_objects(kit, own, merge_entry) {
+  const merged = { ...kit, ...own };
+  for (const [key, value] of Object.entries(kit)) merged[key] = merge_entry(key, value, own[key]);
+  return merged;
+}
+function merge_kit_value(kit, own) {
+  if (!json_value.is_record(kit) || !json_value.is_record(own)) return kit;
+  return merge_objects(
+    kit,
+    own,
+    (_key, kit_entry, own_entry) => merge_kit_value(kit_entry, own_entry)
+  );
+}
+function merge_permission(kit, own) {
+  if (!Array.isArray(kit) || !Array.isArray(own)) return merge_kit_value(kit, own);
+  return [.../* @__PURE__ */ new Set([...as_array(kit), ...as_array(own)])];
+}
+function without_withdrawn(value) {
+  if (!Array.isArray(value)) return value;
+  return value.filter((entry) => !WITHDRAWN_KIT_PERMISSIONS.has(entry));
+}
+function merge_permissions(kit, own) {
+  if (!json_value.is_record(kit) || !json_value.is_record(own)) return kit;
+  const kept = Object.entries(own).map(([key, value]) => [key, without_withdrawn(value)]);
+  return merge_objects(
+    kit,
+    Object.fromEntries(kept),
+    (_key, kit_entry, own_entry) => merge_permission(kit_entry, own_entry)
+  );
+}
+function is_kit_handler(handler) {
+  if (!json_value.is_record(handler)) return false;
+  const { command } = handler;
+  return typeof command === "string" && hook_command_rewrite.is_kit_hook_command(command);
+}
+function without_kit_handlers(group) {
+  if (!json_value.is_record(group)) return group;
+  const handlers = as_array(group[HOOKS_KEY]).filter((handler) => !is_kit_handler(handler));
+  return handlers.length === 0 ? void 0 : { ...group, [HOOKS_KEY]: handlers };
+}
+function own_groups(groups) {
+  return as_array(groups).map((group) => without_kit_handlers(group)).filter((group) => group !== void 0);
+}
+function own_hook_events(own) {
+  const events = Object.entries(own).map(([event, groups]) => [event, own_groups(groups)]);
+  return Object.fromEntries(events.filter(([, groups]) => groups.length > 0));
+}
+function merge_hooks(kit, own) {
+  if (!json_value.is_record(kit) || !json_value.is_record(own)) return kit;
+  return merge_objects(kit, own_hook_events(own), (_event, kit_groups, groups) => [
+    ...as_array(kit_groups),
+    ...as_array(groups)
+  ]);
+}
+function merge_top_level(key, kit, own) {
+  if (key === HOOKS_KEY) return merge_hooks(kit, own);
+  if (key === PERMISSIONS_KEY) return merge_permissions(kit, own);
+  if (key === STATUS_LINE_KEY) return own ?? kit;
+  return merge_kit_value(kit, own);
+}
+function parse_object(content) {
+  const parsed = json_value.parse_or_undefined(content);
+  return json_value.is_record(parsed) ? parsed : void 0;
+}
+function merge_claude_settings(existing, distributed) {
+  const own = parse_object(existing);
+  const kit = parse_object(distributed);
+  if (own === void 0 || kit === void 0) return distributed;
+  return json_format.format_json(merge_objects(kit, own, merge_top_level));
+}
+var claude_settings_merge = { merge_claude_settings, WITHDRAWN_KIT_PERMISSIONS };
+
+// scripts/sync/removed-skill-manifest.ts
+var REMOVED_SKILL_MANIFEST = [
+  {
+    directory: ".claude/skills/diag",
+    files: [
+      {
+        path: "SKILL.md",
+        sha256: "16e5399859fdb99033350ec41c147adf4422f2a76de88ecdfc877c4a24ab7510"
+      }
+    ]
+  }
+];
+
+// scripts/sync/skill-migration.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync2, lstatSync, readdirSync, readFileSync as readFileSync2, rmSync } from "node:fs";
+import path2 from "node:path";
+function relative_files(root) {
+  return readdirSync(root, { encoding: "utf8", recursive: true }).filter(
+    (entry) => lstatSync(path2.join(root, entry)).isFile()
+  );
+}
+function expected_copy(source_file, destination_file) {
+  const raw = readFileSync2(source_file, "utf8");
+  return is_transformable(source_file) ? transform_copied_content(destination_file, raw) : raw;
+}
+function file_matches(source_root, destination_root, relative) {
+  const destination_file = path2.join(destination_root, relative);
+  if (!existsSync2(destination_file)) return false;
+  const source_file = path2.join(source_root, relative);
+  return readFileSync2(destination_file, "utf8") === expected_copy(source_file, destination_file);
+}
+function is_unmodified_copy(source_root, destination_root) {
+  const sources = relative_files(source_root);
+  if (relative_files(destination_root).length !== sources.length) return false;
+  return sources.every((relative) => file_matches(source_root, destination_root, relative));
+}
+function decide_action(source_root, destination_root) {
+  if (!existsSync2(destination_root)) return "absent";
+  if (!existsSync2(source_root)) return "kept";
+  return is_unmodified_copy(source_root, destination_root) ? "removed" : "kept";
+}
+function apply_action(destination_root, relative, action, source) {
+  if (action === "removed") rmSync(destination_root, { recursive: true, force: true });
+  return { directory: relative, action, source };
+}
+function migrate_directory(package_root, project_root, relative) {
+  const source_root = path2.join(package_root, relative);
+  const destination_root = path2.join(project_root, relative);
+  const action = decide_action(source_root, destination_root);
+  return apply_action(destination_root, relative, action, "plugin");
+}
+function migrate_removed_skill_directories(package_root, project_root) {
+  return PLUGIN_SKILL_DIRECTORIES.map(
+    (relative) => migrate_directory(package_root, project_root, relative)
+  );
+}
+function hash_content(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function expected_manifest(source_root) {
+  return relative_files(source_root).map((relative) => {
+    const file = path2.join(source_root, relative);
+    return { path: relative, sha256: hash_content(expected_copy(file, file)) };
+  }).toSorted((left, right) => left.path.localeCompare(right.path));
+}
+function manifest_file_matches(destination_root, file) {
+  const destination_file = path2.join(destination_root, file.path);
+  if (!existsSync2(destination_file)) return false;
+  return hash_content(readFileSync2(destination_file, "utf8")) === file.sha256;
+}
+function matches_manifest(destination_root, files) {
+  if (relative_files(destination_root).length !== files.length) return false;
+  return files.every((file) => manifest_file_matches(destination_root, file));
+}
+function decide_manifest_action(destination_root, files) {
+  if (!existsSync2(destination_root)) return "absent";
+  return matches_manifest(destination_root, files) ? "removed" : "kept";
+}
+function migrate_manifest_skills(project_root, manifest) {
+  return manifest.map((skill) => {
+    const destination_root = path2.join(project_root, skill.directory);
+    const action = decide_manifest_action(destination_root, skill.files);
+    return apply_action(destination_root, skill.directory, action, "retired");
+  });
+}
+function removed_note(source) {
+  return source === "retired" ? "retired from distribution" : "now provided by the kit plugin";
+}
+function kept_note(source) {
+  return source === "retired" ? "modified or consumer-authored \u2014 remove by hand" : "modified or consumer-authored \u2014 remove by hand once on the kit plugin";
+}
+var skill_migration = {
+  migrate_removed_skill_directories,
+  migrate_manifest_skills,
+  expected_manifest,
+  removed_note,
+  kept_note
+};
+
+// scripts/sync/sync-hook-safety.ts
+import path3 from "node:path";
+import semver from "semver";
+var NODE_MODULES = "node_modules";
+function read_version_at(package_directory) {
+  return package_manifest.read_manifest_if_valid(package_directory, package_version_schema)?.version;
+}
+function installed_consumer_version(project_root) {
+  return read_version_at(path3.join(project_root, NODE_MODULES, KIT_PACKAGE_NAME));
+}
+function is_safe_to_write_hooks(writing_version, installed_version) {
+  if (writing_version === void 0 || installed_version === void 0) return true;
+  return !semver.lt(installed_version, writing_version);
+}
+function outdated_install_warning(writing_version, installed_version, filename) {
+  return `  \u26A0 skipped   ${filename} \u2014 installed ${KIT_PACKAGE_NAME} is ${installed_version}, older than the ${writing_version} writing it. Its hooks would call commands this install cannot run. Run \`pnpm update ${KIT_PACKAGE_NAME}\` first, then \`pnpm josh sync\` again.`;
+}
+function hook_write_warning(project_root, writing_version, filename) {
+  const installed_version = installed_consumer_version(project_root);
+  if (writing_version === void 0 || installed_version === void 0 || is_safe_to_write_hooks(writing_version, installed_version)) {
+    return void 0;
+  }
+  return outdated_install_warning(writing_version, installed_version, filename);
+}
+var sync_hook_safety = {
+  hook_write_warning,
+  installed_consumer_version,
+  is_safe_to_write_hooks,
+  read_version_at
+};
+
+// scripts/sync/sync-ai-files.ts
+var WORKSPACE_YAML = "pnpm-workspace.yaml";
+var CLAUDE_MD_FILENAME = "CLAUDE.md";
+var CLAUDE_SETTINGS_FILE = ".claude/settings.json";
+var CODEX_HOOKS_FILE = ".codex/hooks.json";
+function keep_custom_workflow(destination) {
+  if (!is_workflow_destination(destination)) return false;
+  const existing = file_reader.read_optional(destination);
+  if (existing === void 0) return false;
+  const marker = `${managed_marker_logic.MARKER_PREFIX} ${KIT_PACKAGE_NAME}`;
+  if (existing.split(/\r?\n/u, 1)[0] === marker) return false;
+  console.warn(
+    `  \u26A0 kept      ${destination} (custom workflow; migrate its acquisition settings manually)`
+  );
+  return true;
+}
+function sync_ai_file(source_path, destination_path) {
+  if (keep_custom_workflow(destination_path)) return false;
+  const content = readFileSync3(source_path, "utf8");
+  return file_content.write_text_if_changed(
+    destination_path,
+    transform_copied_content(destination_path, content)
+  );
+}
+function should_skip_hook_file(filename) {
+  if (filename !== CLAUDE_SETTINGS_FILE && filename !== CODEX_HOOKS_FILE) return false;
+  const warning = sync_hook_safety.hook_write_warning(
+    PROJECT_ROOT,
+    sync_hook_safety.read_version_at(PACKAGE_DIR),
+    filename
+  );
+  if (warning === void 0) return false;
+  console.warn(warning);
+  return true;
+}
+function sync_claude_settings(source_path, destination_path, is_force) {
+  const distributed = transform_copied_content(destination_path, readFileSync3(source_path, "utf8"));
+  const existing = is_force ? void 0 : file_reader.read_optional(destination_path);
+  const content = existing === void 0 ? distributed : claude_settings_merge.merge_claude_settings(existing, distributed);
+  return file_content.write_text_if_changed(destination_path, content);
+}
+function sync_file(source, filename, is_force) {
+  if (should_skip_hook_file(filename)) return;
+  const source_path = path4.join(PACKAGE_DIR, source);
+  const destination_path = path4.join(PROJECT_ROOT, filename);
+  const did_change = filename === CLAUDE_SETTINGS_FILE ? sync_claude_settings(source_path, destination_path, is_force) : sync_ai_file(source_path, destination_path);
+  console.info(`  \u2714 ${did_change ? "synced   " : "unchanged"} ${filename}`);
+}
+function sync_file_mapping(source_path, destination_path) {
+  if (!existsSync3(source_path)) {
+    console.warn(`  \u26A0 skipped   ${path4.basename(destination_path)} (not found in package)`);
+    return;
+  }
+  const did_change = sync_ai_file(source_path, destination_path);
+  console.info(`  \u2714 ${did_change ? "synced   " : "unchanged"} ${path4.basename(destination_path)}`);
+}
+function sync_workspace_yaml(template_path, destination_path, is_force = false) {
+  const template = init_ai_copy.read_workspace_template(template_path, destination_path);
+  const existing = is_force ? "" : file_reader.read_file_or_empty(destination_path);
+  const merged = init_logic.merge_workspace_yaml(existing, template);
+  return file_content.write_text_if_changed(destination_path, merged);
+}
+function sync_ai_copy_file(filename, is_force, shape) {
+  if (security_policy.did_skip_unresolved(filename, PROJECT_ROOT)) return;
+  const source = init_ai_copy.ai_file_source(filename, shape);
+  if (filename === WORKSPACE_YAML) {
+    const did_change = sync_workspace_yaml(
+      path4.join(PACKAGE_DIR, source),
+      path4.join(PROJECT_ROOT, WORKSPACE_YAML),
+      is_force
+    );
+    console.info(`  \u2714 ${did_change ? "synced   " : "unchanged"} ${WORKSPACE_YAML}`);
+    return;
+  }
+  sync_file(source, filename, is_force);
+}
+function directory_sync_failure(directory_name, on_copy) {
+  const source_path = path4.join(PACKAGE_DIR, directory_name);
+  const destination_path = path4.join(PROJECT_ROOT, directory_name);
+  return directory_copy_blocker(source_path, destination_path) ?? copy_directory_failure(source_path, destination_path, on_copy);
+}
+function sync_directory(directory_name) {
+  const failure = directory_sync_failure(directory_name, (did_change) => {
+    console.info(`  \u2714 ${did_change ? "synced   " : "unchanged"} ${directory_name}/`);
+  });
+  if (failure !== void 0) console.warn(`  \u26A0 skipped   ${directory_name}/ (${failure})`);
+}
+function report_migration_result(result) {
+  if (result.action === "absent") return;
+  if (result.action === "removed") {
+    console.info(
+      `  \u2714 removed   ${result.directory}/ (${skill_migration.removed_note(result.source)})`
+    );
+    return;
+  }
+  console.warn(`  \u26A0 kept      ${result.directory}/ (${skill_migration.kept_note(result.source)})`);
+}
+function migrate_removed_skills() {
+  const plugin = skill_migration.migrate_removed_skill_directories(PACKAGE_DIR, PROJECT_ROOT);
+  const retired = skill_migration.migrate_manifest_skills(PROJECT_ROOT, REMOVED_SKILL_MANIFEST);
+  for (const result of [...plugin, ...retired]) report_migration_result(result);
+}
+function ensured_claude_md(existing, shape) {
+  return shape?.profile === "basic" ? init_ai_copy.ensure_basic_claude_md(existing) : init_logic.ensure_claude_md_import(existing);
+}
+function sync_claude_md(destination_path, shape) {
+  const existing = file_reader.read_optional(destination_path);
+  const ensured = ensured_claude_md(existing, shape);
+  if (ensured === existing) {
+    console.info(`  \u2714 unchanged ${CLAUDE_MD_FILENAME}`);
+    return;
+  }
+  file_content.write_contained(destination_path, ensured);
+  console.info(`  \u2714 synced    ${CLAUDE_MD_FILENAME}`);
+}
+function sync_ai_copy_all(is_force, shape) {
+  console.info("AI files:");
+  sync_claude_md(path4.join(PROJECT_ROOT, CLAUDE_MD_FILENAME), shape);
+  for (const filename of init_ai_copy.copied_files(shape)) {
+    sync_ai_copy_file(filename, is_force, shape);
+  }
+  for (const { src, dest } of init_ai_copy.ai_file_mappings(shape)) {
+    sync_file_mapping(path4.join(PACKAGE_DIR, src), path4.join(PROJECT_ROOT, dest));
+  }
+  for (const directory_name of init_logic.get_ai_copy_directories()) {
+    sync_directory(directory_name);
+  }
+  migrate_removed_skills();
+  pack_hook.sync_pack_hook(PROJECT_ROOT, PACKAGE_DIR);
+}
+var sync_ai_files = {
+  should_skip_hook_file,
+  sync_file_mapping,
+  sync_ai_file,
+  sync_workspace_yaml,
+  sync_claude_md,
+  ensured_claude_md,
+  sync_directory,
+  sync_ai_copy_all
+};
+
+// scripts/sync/sync-configs.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+import path5 from "node:path";
+var TSCONFIG_PRESET_DIR = "tsconfig";
+var GITIGNORE_TEMPLATE_PATH = "templates/gitignore";
+function sync_with_merge(destination_path, destination_name, merge_function) {
+  if (!existsSync4(destination_path)) return;
+  const existing = readFileSync4(destination_path, "utf8");
+  const merged = merge_function(existing);
+  if (merged === existing) {
+    console.info(`  \u2714 unchanged ${destination_name}`);
+    return;
+  }
+  file_content.write_contained(destination_path, merged);
+  console.info(`  \u2714 synced    ${destination_name}`);
+}
+function sync_npmrc(destination_path) {
+  const existing = existsSync4(destination_path) ? readFileSync4(destination_path, "utf8") : "";
+  const merged = init_logic.merge_npmrc(existing, path5.dirname(destination_path));
+  if (merged === existing) {
+    console.info("  \u2714 unchanged .npmrc");
+    return;
+  }
+  file_content.write_contained(destination_path, merged);
+  console.info("  \u2714 synced    .npmrc");
+}
+function sync_gitignore(destination_path) {
+  const template = readFileSync4(path5.join(PACKAGE_DIR, GITIGNORE_TEMPLATE_PATH), "utf8");
+  sync_with_merge(
+    destination_path,
+    ".gitignore",
+    (existing) => init_logic.merge_gitignore(existing, template)
+  );
+}
+function sync_eslint_config(destination_path) {
+  sync_with_merge(
+    destination_path,
+    "eslint.config.js",
+    (existing) => init_logic.merge_eslint_config(existing)
+  );
+}
+function read_base_compiler_options() {
+  const filename = init_logic.get_tsconfig_preset_filename();
+  const content = readFileSync4(path5.join(PACKAGE_DIR, TSCONFIG_PRESET_DIR, filename), "utf8");
+  return init_logic.extract_compiler_options(content);
+}
+function sync_tsconfig(destination_path) {
+  const entry = init_logic.get_tsconfig_extends_entry();
+  const base_options = read_base_compiler_options();
+  const base_directory = path5.dirname(destination_path);
+  sync_with_merge(
+    destination_path,
+    "tsconfig.json",
+    (existing) => init_logic.merge_tsconfig_exclude(
+      init_logic.strip_redundant_compiler_options(
+        init_logic.merge_tsconfig_extends(existing, entry, base_directory),
+        base_options
+      )
+    )
+  );
+}
+function sync_cspell_config(destination_path) {
+  const value = init_logic.get_cspell_import_value();
+  sync_with_merge(
+    destination_path,
+    "cspell.config.yaml",
+    (existing) => init_logic.merge_cspell_import(existing, value)
+  );
+}
+function sync_lefthook_config(destination_path) {
+  const value = init_logic.get_lefthook_extends_value();
+  sync_with_merge(
+    destination_path,
+    "lefthook.yml",
+    (existing) => init_logic.merge_lefthook_extends(existing, value)
+  );
+}
+function sync_secretlint_config(destination_path) {
+  if (existsSync4(destination_path)) {
+    console.info("  \u2714 unchanged .secretlintrc.json");
+    return;
+  }
+  file_content.write_contained(destination_path, init_logic.generate_secretlint_config());
+  console.info("  \u2714 created   .secretlintrc.json");
+}
+function read_kit_vscode_json(filename) {
+  return JSON.parse(readFileSync4(path5.join(PACKAGE_DIR, ".vscode", filename), "utf8"));
+}
+function read_vscode_recommendations() {
+  const parsed = vscode_settings_schema.parse(
+    read_kit_vscode_json(init_logic.VSCODE_EXTENSIONS_FILENAME)
+  );
+  const raw = parsed["recommendations"];
+  return string_array_schema.parse(raw);
+}
+function sync_vscode_extensions_json(destination_path) {
+  const recommendations = read_vscode_recommendations();
+  sync_with_merge(
+    destination_path,
+    ".vscode/extensions.json",
+    (existing) => init_logic.merge_json_array_field(existing, "recommendations", recommendations)
+  );
+}
+function sync_vscode_settings_json(destination_path) {
+  const raw_settings = read_kit_vscode_json(init_logic.get_vscode_settings_filename());
+  const settings_data = init_logic.strip_kit_only_vscode_settings(
+    vscode_settings_schema.parse(raw_settings)
+  );
+  sync_with_merge(
+    destination_path,
+    ".vscode/settings.json",
+    (existing) => init_logic.merge_json_object(existing, settings_data)
+  );
+}
+function sync_vscode_tasks_json(destination_path) {
+  const kit_tasks = vscode_tasks.read_kit_tasks(
+    readFileSync4(path5.join(PACKAGE_DIR, ".vscode", vscode_tasks.VSCODE_TASKS_FILENAME), "utf8")
+  );
+  sync_with_merge(
+    destination_path,
+    ".vscode/tasks.json",
+    (existing) => vscode_tasks.merge_tasks(existing, kit_tasks)
+  );
+}
+var sync_configs = {
+  sync_npmrc,
+  sync_gitignore,
+  sync_eslint_config,
+  sync_tsconfig,
+  sync_cspell_config,
+  sync_lefthook_config,
+  sync_secretlint_config,
+  sync_vscode_extensions_json,
+  sync_vscode_settings_json,
+  sync_vscode_tasks_json
+};
+
+// scripts/sync/sync.ts
+var PACKAGE_JSON_UNCHANGED_MSG = `  \u2714 unchanged ${PACKAGE_JSON}`;
+function did_migrate_prettierrc(destination_path) {
+  const legacy_path = path6.join(path6.dirname(destination_path), ".prettierrc");
+  if (!existsSync5(legacy_path)) return false;
+  const existing = readFileSync5(legacy_path, "utf8");
+  file_content.write_contained(
+    destination_path,
+    init_logic.merge_prettier_config(existing, path6.dirname(destination_path))
+  );
+  rmSync2(legacy_path);
+  return true;
+}
+function write_merged_prettier_config(destination_path) {
+  const existing = readFileSync5(destination_path, "utf8");
+  const merged = init_logic.merge_prettier_config(existing, path6.dirname(destination_path));
+  if (merged === existing) {
+    console.info("  \u2714 unchanged prettier.config.js");
+    return;
+  }
+  file_content.write_contained(destination_path, merged);
+  console.info("  \u2714 synced    prettier.config.js");
+}
+function sync_prettier_config(destination_path) {
+  if (did_migrate_prettierrc(destination_path)) {
+    console.info("  \u2714 migrated  .prettierrc \u2192 prettier.config.js");
+    return;
+  }
+  if (!existsSync5(destination_path)) return;
+  write_merged_prettier_config(destination_path);
+}
+function sync_playwright_config(destination_path) {
+  if (!existsSync5(destination_path)) return;
+  const template = init_logic.generate_playwright_config();
+  const existing = readFileSync5(destination_path, "utf8");
+  if (template === existing) {
+    console.info("  \u2714 unchanged playwright.config.ts");
+    return;
+  }
+  file_content.write_contained(destination_path, template);
+  console.info("  \u2714 synced    playwright.config.ts");
+}
+function sync_deploy_vps(destination_path) {
+  if (!existsSync5(destination_path)) return;
+  const existing = readFileSync5(destination_path, "utf8");
+  const patched = init_logic.patch_deploy_vps_pnpm(existing);
+  if (patched === existing) {
+    console.info("  \u2714 unchanged deploy-vps.yml");
+    return;
+  }
+  file_content.write_contained(destination_path, patched);
+  console.info("  \u2714 synced    deploy-vps.yml");
+}
+function sync_sonar_with_template(name_with_owner, is_force = false) {
+  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 template_source = path6.join(PACKAGE_DIR, init_logic.get_sonar_template_source());
+  const identifiers = init_logic.derive_sonar_identifiers(name_with_owner);
+  const write_function = is_force ? sonar_file.write_sonar_file : sonar_file.merge_sonar_file;
+  write_function(template_source, path6.join(PROJECT_ROOT, destination), identifiers);
+  console.info(`  \u2714 synced    ${destination}`);
+}
+function sync_config_files() {
+  sync_configs.sync_npmrc(path6.join(PROJECT_ROOT, ".npmrc"));
+  sync_configs.sync_gitignore(path6.join(PROJECT_ROOT, ".gitignore"));
+  sync_configs.sync_eslint_config(path6.join(PROJECT_ROOT, "eslint.config.js"));
+  sync_configs.sync_tsconfig(path6.join(PROJECT_ROOT, "tsconfig.json"));
+  sync_configs.sync_cspell_config(path6.join(PROJECT_ROOT, "cspell.config.yaml"));
+  sync_configs.sync_lefthook_config(path6.join(PROJECT_ROOT, "lefthook.yml"));
+  sync_configs.sync_secretlint_config(path6.join(PROJECT_ROOT, ".secretlintrc.json"));
+  sync_configs.sync_vscode_extensions_json(path6.join(PROJECT_ROOT, ".vscode/extensions.json"));
+  sync_configs.sync_vscode_settings_json(path6.join(PROJECT_ROOT, ".vscode/settings.json"));
+  sync_configs.sync_vscode_tasks_json(path6.join(PROJECT_ROOT, ".vscode/tasks.json"));
+}
+function sync_package_json_with(destination_path, transform, synced_message) {
+  if (!existsSync5(destination_path)) return;
+  const existing = readFileSync5(destination_path, "utf8");
+  const transformed = transform(existing);
+  if (transformed === existing) {
+    console.info(PACKAGE_JSON_UNCHANGED_MSG);
+    return;
+  }
+  file_content.write_contained(destination_path, transformed);
+  console.info(synced_message);
+}
+function sync_package_manager_version(destination_path) {
+  sync_package_json_with(
+    destination_path,
+    (existing) => package_manager_version.align_development_engines_version(existing),
+    "  \u2714 synced    devEngines.packageManager.version"
+  );
+}
+function sync_package_manager_on_fail(destination_path) {
+  sync_package_json_with(
+    destination_path,
+    (existing) => package_manager_version.upgrade_development_engines_on_fail(existing),
+    "  \u2714 synced    devEngines.packageManager.onFail"
+  );
+}
+function sync_secretlint_development_deps(destination_path) {
+  sync_package_json_with(
+    destination_path,
+    (existing) => init_logic.merge_secretlint_development_deps(existing),
+    "  \u2714 synced    secretlint devDependencies (run `pnpm install`)"
+  );
+}
+function sync_consumer_resolved_development_deps(destination_path) {
+  const has_git = project_profile.has_git(path6.dirname(destination_path));
+  sync_package_json_with(
+    destination_path,
+    (existing) => init_logic.merge_consumer_resolved_development_deps(existing, has_git),
+    "  \u2714 synced    toolchain devDependencies (run `pnpm install`)"
+  );
+}
+function sync_prepare_lefthook_warning(destination_path) {
+  sync_package_json_with(
+    destination_path,
+    (existing) => init_logic.upgrade_npm_lifecycle(
+      init_logic.upgrade_prepare_lefthook_warning(existing),
+      path6.dirname(destination_path)
+    ),
+    "  \u2714 synced    prepare lefthook install warning (run `pnpm install`)"
+  );
+}
+function sync_safe_chain_preinstall(destination_path) {
+  sync_package_json_with(
+    destination_path,
+    (existing) => init_logic.upgrade_safe_chain_preinstall(existing),
+    "  \u2714 synced    preinstall safe-chain check"
+  );
+}
+function sync_package_json_migrations(destination_path) {
+  sync_package_manager_version(destination_path);
+  sync_package_manager_on_fail(destination_path);
+  sync_secretlint_development_deps(destination_path);
+  sync_consumer_resolved_development_deps(destination_path);
+  sync_prepare_lefthook_warning(destination_path);
+  sync_safe_chain_preinstall(destination_path);
+}
+function report_repository_settings(name_with_owner) {
+  security_updates.report_security_updates_section(name_with_owner);
+  auto_merge_setting.report_auto_merge_section(name_with_owner);
+  repository_labels.ensure_labels(name_with_owner);
+}
+function sync_release_window_mirrors(root) {
+  project_config.sync_project_config(root);
+  dependabot_cooldown.sync_dependabot_cooldown(root);
+}
+function sync_project_artifacts(is_force) {
+  sync_ai_files.sync_ai_copy_all(is_force);
+  sync_prettier_config(path6.join(PROJECT_ROOT, "prettier.config.js"));
+  sync_playwright_config(path6.join(PROJECT_ROOT, "playwright.config.ts"));
+  sync_deploy_vps(path6.join(PROJECT_ROOT, ".github/workflows/deploy-vps.yml"));
+  const name_with_owner = gh_spawn.get_repo_name_with_owner();
+  sync_sonar_with_template(name_with_owner, is_force);
+  sync_config_files();
+  sync_release_window_mirrors(PROJECT_ROOT);
+  sync_package_json_migrations(path6.join(PROJECT_ROOT, PACKAGE_JSON));
+  report_repository_settings(name_with_owner);
+}
+function sync_basic_artifacts(is_force) {
+  console.info("profile: basic (package.json josh.profile)\n");
+  sync_ai_files.sync_ai_copy_all(is_force, project_profile.inspect_project(PROJECT_ROOT, "basic"));
+}
+function main(args = []) {
+  if (did_refuse_self_run(PACKAGE_DIR, PROJECT_ROOT)) return;
+  const is_force = args.includes("--force");
+  console.info("\n\u{1F504} Syncing @joshuafolkken/kit AI files\n");
+  if (project_checks.is_basic(PROJECT_ROOT)) sync_basic_artifacts(is_force);
+  else sync_project_artifacts(is_force);
+  console.info("\n\u2705 Done.\n");
+}
+var sync = {
+  should_skip_hook_file: sync_ai_files.should_skip_hook_file,
+  sync_file_mapping: sync_ai_files.sync_file_mapping,
+  sync_ai_file: sync_ai_files.sync_ai_file,
+  sync_workspace_yaml: sync_ai_files.sync_workspace_yaml,
+  sync_claude_md: sync_ai_files.sync_claude_md,
+  sync_prettier_config,
+  sync_playwright_config,
+  sync_deploy_vps,
+  sync_package_manager_version,
+  sync_package_manager_on_fail,
+  sync_secretlint_development_deps,
+  sync_consumer_resolved_development_deps,
+  sync_prepare_lefthook_warning,
+  sync_safe_chain_preinstall,
+  sync_package_json_migrations,
+  sync_release_window_mirrors,
+  migrate_prettierrc: did_migrate_prettierrc
+};
+var { sync_directory: sync_directory2 } = sync_ai_files;
+
+export {
+  sync_configs,
+  did_refuse_self_run,
+  sync_ai_files,
+  main,
+  sync
+};