@mnaoumov/typescript-dev-toolkit 3.1.0 → 3.3.0

package/dist/lib/esm/nano-staged-config.mjs

@@ -16,21 +16,19 @@ import {
   getEffectiveCommandLineLength,
   getMaxBatchCommandLength
 } from "./exec.mjs";
+import { readPackageJsonSync } from "./npm.mjs";
 import { getPackageManagerRunCommand } from "./package-manager.mjs";
 const PACKAGE_MANAGER_RUN_COMMAND = getPackageManagerRunCommand().join(" ");
-const SPELLCHECK_COMMAND = `${PACKAGE_MANAGER_RUN_COMMAND} spellcheck --`;
+const SPELLCHECK_SCRIPT_NAME = "spellcheck";
+const SPELLCHECK_COMMAND = toScriptCommand(SPELLCHECK_SCRIPT_NAME);
 const EXECUTABLE_PATH_RESERVE = 260;
 const TOKENIZER_UNSAFE_CHARACTERS_REG_EXP = /[\s"']/g;
-const WRITER_TASKS = {
-  "*.{ts,tsx,mts}": [
-    `${PACKAGE_MANAGER_RUN_COMMAND} lint:fix --`,
-    `${PACKAGE_MANAGER_RUN_COMMAND} format --`
-  ],
-  "*.md": [
-    `${PACKAGE_MANAGER_RUN_COMMAND} lint:md:fix --`
-  ]
+const WRITER_SCRIPT_NAMES = {
+  "*.{ts,tsx,mts}": ["lint:fix", "format"],
+  "*.md": ["lint:md:fix"]
 };
-const obsidianDevUtilsConfig = partitionSpellcheck(WRITER_TASKS);
+const WRITER_TASKS = toWriterTasks(() => true);
+const obsidianDevUtilsConfig = partitionSpellcheck(WRITER_TASKS, true);
 const NANO_STAGED_ENV_VARIABLE = "NANO_STAGED";
 function getNanoStagedConfig(options) {
   loadEnvFileIfExists();
@@ -39,15 +37,18 @@ function getNanoStagedConfig(options) {
 `);
     process.exit(0);
   }
+  const scriptNames = new Set(Object.keys(readPackageJsonSync().scripts ?? {}));
+  const hasAllSharedScripts = [SPELLCHECK_SCRIPT_NAME, ...Object.values(WRITER_SCRIPT_NAMES).flat()].every((scriptName) => scriptNames.has(scriptName));
   const additionalWriterTasks = options?.additionalWriterTasks ?? {};
-  if (Object.keys(additionalWriterTasks).length === 0) {
+  if (hasAllSharedScripts && Object.keys(additionalWriterTasks).length === 0) {
     return obsidianDevUtilsConfig;
   }
-  const duplicatePattern = Object.keys(additionalWriterTasks).find((pattern) => Object.hasOwn(WRITER_TASKS, pattern));
+  const writerTasks = toWriterTasks((scriptName) => scriptNames.has(scriptName));
+  const duplicatePattern = Object.keys(additionalWriterTasks).find((pattern) => Object.hasOwn(writerTasks, pattern));
   if (duplicatePattern !== void 0) {
     throw new Error(`nano-staged writer pattern '${duplicatePattern}' is already a shared writer pattern.`);
   }
-  return partitionSpellcheck({ ...WRITER_TASKS, ...additionalWriterTasks });
+  return partitionSpellcheck({ ...writerTasks, ...additionalWriterTasks }, scriptNames.has(SPELLCHECK_SCRIPT_NAME));
 }
 function batchCommandArguments(prefix, commandArguments) {
   const emptyLength = getEffectiveCommandLineLength("");
@@ -70,13 +71,16 @@ function batchCommandArguments(prefix, commandArguments) {
   }
   return batches;
 }
-function partitionSpellcheck(writerTasks) {
+function partitionSpellcheck(writerTasks, shouldSpellcheck) {
+  if (!shouldSpellcheck) {
+    return Object.fromEntries(Object.entries(writerTasks).map(([pattern, commands]) => [pattern, toBatchedTask(commands)]));
+  }
   const patterns = Object.keys(writerTasks);
   const patternWithSlash = patterns.find((pattern) => pattern.includes("/"));
   if (patternWithSlash !== void 0) {
     throw new Error(`nano-staged writer pattern '${patternWithSlash}' contains '/', which the spellcheck partition cannot express.`);
   }
-  const complementPattern = `!(${patterns.map((pattern) => `${pattern}!(?)`).join("|")})*`;
+  const complementPattern = patterns.length === 0 ? "*" : `!(${patterns.map((pattern) => `${pattern}!(?)`).join("|")})*`;
   const config = {
     [complementPattern]: toBatchedTask([SPELLCHECK_COMMAND])
   };
@@ -99,8 +103,21 @@ function toCommandArgument(filename) {
   }
   return commandArgument.replaceAll(TOKENIZER_UNSAFE_CHARACTERS_REG_EXP, "?");
 }
+function toScriptCommand(scriptName) {
+  return `${PACKAGE_MANAGER_RUN_COMMAND} ${scriptName} --`;
+}
+function toWriterTasks(shouldIncludeScript) {
+  const writerTasks = {};
+  for (const [pattern, scriptNames] of Object.entries(WRITER_SCRIPT_NAMES)) {
+    const commands = scriptNames.filter((scriptName) => shouldIncludeScript(scriptName)).map((scriptName) => toScriptCommand(scriptName));
+    if (commands.length > 0) {
+      writerTasks[pattern] = commands;
+    }
+  }
+  return writerTasks;
+}
 export {
   getNanoStagedConfig,
   obsidianDevUtilsConfig
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/nano-staged-config.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Shared nano-staged configuration for pre-commit hooks.\n */\n\nimport {\n  isAbsolute,\n  relative\n} from 'node:path';\nimport process from 'node:process';\n\nimport {\n  isEnvVariableOff,\n  loadEnvFileIfExists\n} from './env-toggle.ts';\nimport {\n  getEffectiveCommandLineLength,\n  getMaxBatchCommandLength\n} from './exec.ts';\nimport { getPackageManagerRunCommand } from './package-manager.ts';\n\n/**\n * Options for {@link getNanoStagedConfig}.\n */\nexport interface GetNanoStagedConfigOptions {\n  /**\n   * Repo-specific file-rewriting tasks, keyed by the nano-staged pattern that claims their files.\n   *\n   * Each gets spellcheck appended and its files removed from the spellcheck-only key, exactly like the shared\n   * writers. A pattern must not contain `/`, and must not repeat a shared writer pattern. Each command is a\n   * prefix the staged paths are appended to, in batches, like the shared ones (`npm run lint:fix --`).\n   */\n  readonly additionalWriterTasks?: Readonly<Record<string, readonly string[]>>;\n}\n\n/**\n * A nano-staged configuration whose every key is a {@link NanoStagedTask}.\n */\nexport type NanoStagedConfig = Record<string, NanoStagedTask>;\n\n/**\n * A function-valued nano-staged task: it receives the staged files its pattern claims and returns the\n * commands to run over them, in order.\n */\nexport type NanoStagedTask = (context: NanoStagedTaskContext) => string[];\n\n/**\n * What nano-staged passes to a function-valued task.\n */\nexport interface NanoStagedTaskContext {\n  /**\n   * The absolute paths of the staged files the task's pattern claims.\n   */\n  readonly filenames: readonly string[];\n}\n\n/**\n * The `<manager> run` prefix every task below is built on, resolved once for the process.\n *\n * Detection probes for a lockfile beside `package.json`, so it is a handful of `existsSync` calls and\n * nothing more \u2014 no `.env` read and no `process.exit`, which is what lets it sit at module scope.\n */\nconst PACKAGE_MANAGER_RUN_COMMAND = getPackageManagerRunCommand().join(' ');\n\nconst SPELLCHECK_COMMAND = `${PACKAGE_MANAGER_RUN_COMMAND} spellcheck --`;\n\n/**\n * Room left in every batch for the resolved path of the package manager's executable.\n *\n * nano-staged runs `npm` as the absolute path of `npm.cmd` (`<comspec> /D /S /C \"<path>\" \"<arg>\" \u2026`), which\n * the batch cannot see, so a full Windows `MAX_PATH` is set aside for it.\n */\nconst EXECUTABLE_PATH_RESERVE = 260;\n\n/**\n * The characters nano-staged's command tokenizer cannot carry inside an argument.\n *\n * A function-valued task returns its commands as STRINGS, and nano-staged splits each one with\n * `stringArgvToArray`, which emits a quoted token twice (once bare, once with its quotes) and has no escape.\n * So a path holding whitespace or a quote cannot be passed as itself.\n */\nconst TOKENIZER_UNSAFE_CHARACTERS_REG_EXP = /[\\s\"']/g;\n\n/**\n * The tasks that REWRITE a staged file, keyed by the nano-staged pattern that claims it.\n *\n * `lint:fix` and `format` both rewrite the file, so they have to share one key: nano-staged runs its\n * per-pattern groups under `Promise.all` (`run()` in `nano-staged/lib/cmd-runner.js`), and sequences only\n * the commands INSIDE a single key's array (`runTask()`, a `for ... of await`). Split across two keys they\n * race, whichever finishes last wins, and the commit stages bytes that neither tool would have produced on\n * its own.\n *\n * So do NOT express a directory exclusion by giving one of these two its own negated key -- that silently\n * takes the ordering away. An exclusion belongs in the excluded tool's own config, where ESLint's\n * `globalIgnores` already puts it: a path ESLint ignores is reported as a warning and exits 0 when it is\n * passed explicitly, so it costs a console line rather than a failed commit and needs no key here.\n */\nconst WRITER_TASKS: Readonly<Record<string, readonly string[]>> = {\n  '*.{ts,tsx,mts}': [\n    `${PACKAGE_MANAGER_RUN_COMMAND} lint:fix --`,\n    `${PACKAGE_MANAGER_RUN_COMMAND} format --`\n  ],\n  '*.md': [\n    `${PACKAGE_MANAGER_RUN_COMMAND} lint:md:fix --`\n  ]\n};\n\n/**\n * Nano-staged configuration that runs file-based lint, format, and spellcheck on staged files.\n *\n * Only includes tools that can operate on individual files. Whole-project checks\n * (TypeScript compilation, unit tests) are left to CI.\n *\n * Commands run through the package manager that owns the tree \u2014 `npm run ... --`, `bun run ... --`, and\n * so on \u2014 so nano-staged file paths are forwarded as CLI arguments, batched to fit the command line (see\n * `toBatchedTask`).\n *\n * Spellcheck is partitioned across the keys rather than given a catch-all `'*'` key (see\n * `partitionSpellcheck`). A repo adding a file-rewriting task of its own passes it to\n * {@link getNanoStagedConfig} as `additionalWriterTasks` rather than spreading this object and adding a key,\n * which would reintroduce the overlap for that key's files.\n */\nexport const obsidianDevUtilsConfig: NanoStagedConfig = partitionSpellcheck(WRITER_TASKS);\n\nconst NANO_STAGED_ENV_VARIABLE = 'NANO_STAGED';\n\n/**\n * Resolves the nano-staged configuration to use, honoring a per-developer opt-out.\n *\n * Loads a gitignored `.env` if present, then \u2014 when `NANO_STAGED` is set to an off value (`0`, `false`,\n * `off`, or `no`) \u2014 prints a notice and exits the process successfully so the pre-commit checks are\n * skipped. This mirrors husky's own `HUSKY=0` switch, but scoped to the nano-staged step (so the\n * commit-msg hook still runs). Otherwise it returns {@link obsidianDevUtilsConfig}, or \u2014 when\n * `additionalWriterTasks` are given \u2014 the same configuration re-partitioned with those writers added.\n *\n * `NANO_STAGED` is not an npm script, so it carries its own switch rather than the script-name-derived one\n * every npm script gets \u2014 but both share the same notion of an off value, via {@link isEnvVariableOff}.\n *\n * This is a function rather than module-level code so importing the package barrel never triggers the\n * `.env` read or the process exit; call it from the thin `scripts/nano-staged-config.ts` entry. Resolving the\n * package manager is the one thing that does run at module scope, and it does neither of those two\n * things \u2014 it only probes for a lockfile.\n *\n * @param options - The optional options.\n * @returns The nano-staged task configuration. Does not return when the opt-out is active.\n */\nexport function getNanoStagedConfig(options?: GetNanoStagedConfigOptions): NanoStagedConfig {\n  loadEnvFileIfExists();\n\n  if (isEnvVariableOff(NANO_STAGED_ENV_VARIABLE)) {\n    process.stdout.write(`nano-staged: skipped (${NANO_STAGED_ENV_VARIABLE} is off).\\n`);\n    process.exit(0);\n  }\n\n  const additionalWriterTasks = options?.additionalWriterTasks ?? {};\n  if (Object.keys(additionalWriterTasks).length === 0) {\n    return obsidianDevUtilsConfig;\n  }\n\n  const duplicatePattern = Object.keys(additionalWriterTasks).find((pattern) => Object.hasOwn(WRITER_TASKS, pattern));\n  if (duplicatePattern !== undefined) {\n    throw new Error(`nano-staged writer pattern '${duplicatePattern}' is already a shared writer pattern.`);\n  }\n\n  return partitionSpellcheck({ ...WRITER_TASKS, ...additionalWriterTasks });\n}\n\n/**\n * Splits command arguments into batches that each fit one command line after a given prefix.\n *\n * Each argument is costed as nano-staged passes it on Windows \u2014 quoted, then `^`-escaped by `cmd.exe`'s\n * rules \u2014 through {@link getEffectiveCommandLineLength}, and the budget is {@link getMaxBatchCommandLength},\n * which already holds back the reserve for the `npm` \u2192 `cmd.exe` \u2192 `.bin` shim chain re-expanding the\n * arguments. An argument too long for any batch still gets a batch of its own: it fails loudly there, which\n * dropping it would not.\n *\n * @param prefix - The command the arguments are appended to.\n * @param commandArguments - The arguments to split.\n * @returns The batches, in order, together holding every argument once.\n */\nfunction batchCommandArguments(prefix: string, commandArguments: readonly string[]): string[][] {\n  const emptyLength = getEffectiveCommandLineLength('');\n  const budget = getMaxBatchCommandLength() - EXECUTABLE_PATH_RESERVE - getEffectiveCommandLineLength(prefix);\n  const batches: string[][] = [];\n  let batch: string[] = [];\n  let batchLength = 0;\n\n  for (const commandArgument of commandArguments) {\n    const argumentLength = getEffectiveCommandLineLength(` \"${commandArgument}\"`) - emptyLength;\n    if (batch.length > 0 && batchLength + argumentLength > budget) {\n      batches.push(batch);\n      batch = [];\n      batchLength = 0;\n    }\n    batch.push(commandArgument);\n    batchLength += argumentLength;\n  }\n\n  if (batch.length > 0) {\n    batches.push(batch);\n  }\n\n  return batches;\n}\n\n/**\n * Builds a nano-staged configuration in which spellcheck never reads a file while another task rewrites it.\n *\n * The same `Promise.all` that forces two writers into one key makes a catch-all `'*'` spellcheck key run\n * CONCURRENTLY with every writer key, so cspell would read a file that ESLint or dprint is rewriting in\n * place -- a spurious finding on a half-written file, or a pass over content that is not what gets\n * committed. So the staged files are PARTITIONED instead:\n *\n * - every writer key gets spellcheck appended as its LAST command, so it reads that key's files after they\n *   have been rewritten;\n * - one complement key spellchecks exactly the files no writer key claims.\n *\n * The complement is written in nano-staged's own glob dialect, which compiles `!(...)` to a lookahead that\n * is NOT anchored at the end of the path: `!(*.md)*` would exclude `notes.md.bak` too. A nested `!(?)`\n * compiles to `(?!.)`, which IS an end anchor, so each alternative is suffixed with it. A writer pattern\n * containing `/` would switch nano-staged into globstar mode, where `*` stops crossing directories and the\n * construction no longer holds -- hence the throw. The unit test pins the partition against the installed\n * nano-staged compiler, so a release that changes its dialect fails there rather than in a commit.\n *\n * @param writerTasks - The file-rewriting tasks, keyed by the pattern that claims their files.\n * @returns The configuration, with the spellcheck step partitioned across the keys.\n */\nfunction partitionSpellcheck(writerTasks: Readonly<Record<string, readonly string[]>>): NanoStagedConfig {\n  const patterns = Object.keys(writerTasks);\n  const patternWithSlash = patterns.find((pattern) => pattern.includes('/'));\n  if (patternWithSlash !== undefined) {\n    throw new Error(`nano-staged writer pattern '${patternWithSlash}' contains '/', which the spellcheck partition cannot express.`);\n  }\n\n  const complementPattern = `!(${patterns.map((pattern) => `${pattern}!(?)`).join('|')})*`;\n  const config: NanoStagedConfig = {\n    [complementPattern]: toBatchedTask([SPELLCHECK_COMMAND])\n  };\n\n  for (const [pattern, commands] of Object.entries(writerTasks)) {\n    config[pattern] = toBatchedTask([...commands, SPELLCHECK_COMMAND]);\n  }\n\n  return config;\n}\n\n/**\n * Builds a task that runs each command over every staged file it receives, in as many batches as the command\n * line needs.\n *\n * nano-staged appends a string task's files to ONE command, so a commit staging a few hundred files ran\n * `npm run lint:fix -- <every path>` and failed on Windows with `The command line is too long.`, refusing\n * exactly the whole-repo commits that most need the hook. A function-valued task builds its own commands\n * instead, and these are batched against the same budget `exec()` uses (see `batchCommandArguments`).\n *\n * The commands keep their order: every batch of the first command runs before any batch of the second,\n * because nano-staged runs one key's commands one after another, so a writer still finishes before the next\n * writer, and spellcheck still reads the rewritten files.\n *\n * @param commands - The command prefixes, in the order they run.\n * @returns The task.\n */\nfunction toBatchedTask(commands: readonly string[]): NanoStagedTask {\n  return ({ filenames }) => {\n    const commandArguments = filenames.map((filename) => toCommandArgument(filename));\n    return commands.flatMap((command) => batchCommandArguments(command, commandArguments).map((batch) => `${command} ${batch.join(' ')}`));\n  };\n}\n\n/**\n * Turns a staged file's absolute path into the argument a batched task passes for it.\n *\n * The path is made relative to the working directory, where nano-staged and the task both run, which roughly\n * halves its length and so the number of batches; a path outside it stays absolute. A relative path starting\n * with `-` gets `./`, so no tool reads it as an option.\n *\n * Whitespace and quotes become `?`, because nano-staged's tokenizer cannot carry them (see\n * {@link TOKENIZER_UNSAFE_CHARACTERS_REG_EXP}). Every tool the tasks run (ESLint, dprint, cspell,\n * markdownlint-cli2) takes its paths as globs, and `?` matches exactly the one character it replaced, so the\n * file is still found; a sibling differing only in that character would match too, which costs a lint of an\n * extra file, not a missed one.\n *\n * @param filename - The absolute path of the staged file.\n * @returns The argument.\n */\nfunction toCommandArgument(filename: string): string {\n  const relativePath = relative(process.cwd(), filename);\n  let commandArgument = (relativePath.startsWith('..') || isAbsolute(relativePath) ? filename : relativePath).replaceAll('\\\\', '/');\n  if (commandArgument.startsWith('-')) {\n    commandArgument = `./${commandArgument}`;\n  }\n  return commandArgument.replaceAll(TOKENIZER_UNSAFE_CHARACTERS_REG_EXP, '?');\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/nano-staged-config.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Shared nano-staged configuration for pre-commit hooks.\n */\n\nimport {\n  isAbsolute,\n  relative\n} from 'node:path';\nimport process from 'node:process';\n\nimport {\n  isEnvVariableOff,\n  loadEnvFileIfExists\n} from './env-toggle.ts';\nimport {\n  getEffectiveCommandLineLength,\n  getMaxBatchCommandLength\n} from './exec.ts';\nimport { readPackageJsonSync } from './npm.ts';\nimport { getPackageManagerRunCommand } from './package-manager.ts';\n\n/**\n * Options for {@link getNanoStagedConfig}.\n */\nexport interface GetNanoStagedConfigOptions {\n  /**\n   * Repo-specific file-rewriting tasks, keyed by the nano-staged pattern that claims their files.\n   *\n   * Each gets spellcheck appended and its files removed from the spellcheck-only key, exactly like the shared\n   * writers. A pattern must not contain `/`, and must not repeat a shared writer pattern. Each command is a\n   * prefix the staged paths are appended to, in batches, like the shared ones (`npm run lint:fix --`).\n   */\n  readonly additionalWriterTasks?: Readonly<Record<string, readonly string[]>>;\n}\n\n/**\n * A nano-staged configuration whose every key is a {@link NanoStagedTask}.\n */\nexport type NanoStagedConfig = Record<string, NanoStagedTask>;\n\n/**\n * A function-valued nano-staged task: it receives the staged files its pattern claims and returns the\n * commands to run over them, in order.\n */\nexport type NanoStagedTask = (context: NanoStagedTaskContext) => string[];\n\n/**\n * What nano-staged passes to a function-valued task.\n */\nexport interface NanoStagedTaskContext {\n  /**\n   * The absolute paths of the staged files the task's pattern claims.\n   */\n  readonly filenames: readonly string[];\n}\n\n/**\n * The `<manager> run` prefix every task below is built on, resolved once for the process.\n *\n * Detection probes for a lockfile beside `package.json`, so it is a handful of `existsSync` calls and\n * nothing more \u2014 no `.env` read and no `process.exit`, which is what lets it sit at module scope.\n */\nconst PACKAGE_MANAGER_RUN_COMMAND = getPackageManagerRunCommand().join(' ');\n\nconst SPELLCHECK_SCRIPT_NAME = 'spellcheck';\n\nconst SPELLCHECK_COMMAND = toScriptCommand(SPELLCHECK_SCRIPT_NAME);\n\n/**\n * Room left in every batch for the resolved path of the package manager's executable.\n *\n * nano-staged runs `npm` as the absolute path of `npm.cmd` (`<comspec> /D /S /C \"<path>\" \"<arg>\" \u2026`), which\n * the batch cannot see, so a full Windows `MAX_PATH` is set aside for it.\n */\nconst EXECUTABLE_PATH_RESERVE = 260;\n\n/**\n * The characters nano-staged's command tokenizer cannot carry inside an argument.\n *\n * A function-valued task returns its commands as STRINGS, and nano-staged splits each one with\n * `stringArgvToArray`, which emits a quoted token twice (once bare, once with its quotes) and has no escape.\n * So a path holding whitespace or a quote cannot be passed as itself.\n */\nconst TOKENIZER_UNSAFE_CHARACTERS_REG_EXP = /[\\s\"']/g;\n\n/**\n * The npm scripts that REWRITE a staged file, in the order they run, keyed by the nano-staged pattern that\n * claims it.\n *\n * `lint:fix` and `format` both rewrite the file, so they have to share one key: nano-staged runs its\n * per-pattern groups under `Promise.all` (`run()` in `nano-staged/lib/cmd-runner.js`), and sequences only\n * the commands INSIDE a single key's array (`runTask()`, a `for ... of await`). Split across two keys they\n * race, whichever finishes last wins, and the commit stages bytes that neither tool would have produced on\n * its own.\n *\n * So do NOT express a directory exclusion by giving one of these two its own negated key -- that silently\n * takes the ordering away. An exclusion belongs in the excluded tool's own config, where ESLint's\n * `globalIgnores` already puts it: a path ESLint ignores is reported as a warning and exits 0 when it is\n * passed explicitly, so it costs a console line rather than a failed commit and needs no key here.\n */\nconst WRITER_SCRIPT_NAMES: Readonly<Record<string, readonly string[]>> = {\n  '*.{ts,tsx,mts}': ['lint:fix', 'format'],\n  '*.md': ['lint:md:fix']\n};\n\nconst WRITER_TASKS: Readonly<Record<string, readonly string[]>> = toWriterTasks(() => true);\n\n/**\n * Nano-staged configuration that runs file-based lint, format, and spellcheck on staged files.\n *\n * Only includes tools that can operate on individual files. Whole-project checks\n * (TypeScript compilation, unit tests) are left to CI.\n *\n * Commands run through the package manager that owns the tree \u2014 `npm run ... --`, `bun run ... --`, and\n * so on \u2014 so nano-staged file paths are forwarded as CLI arguments, batched to fit the command line (see\n * `toBatchedTask`).\n *\n * Spellcheck is partitioned across the keys rather than given a catch-all `'*'` key (see\n * `partitionSpellcheck`). A repo adding a file-rewriting task of its own passes it to\n * {@link getNanoStagedConfig} as `additionalWriterTasks` rather than spreading this object and adding a key,\n * which would reintroduce the overlap for that key's files.\n */\nexport const obsidianDevUtilsConfig: NanoStagedConfig = partitionSpellcheck(WRITER_TASKS, true);\n\nconst NANO_STAGED_ENV_VARIABLE = 'NANO_STAGED';\n\n/**\n * Resolves the nano-staged configuration to use, honoring a per-developer opt-out.\n *\n * Loads a gitignored `.env` if present, then \u2014 when `NANO_STAGED` is set to an off value (`0`, `false`,\n * `off`, or `no`) \u2014 prints a notice and exits the process successfully so the pre-commit checks are\n * skipped. This mirrors husky's own `HUSKY=0` switch, but scoped to the nano-staged step (so the\n * commit-msg hook still runs). Otherwise it returns {@link obsidianDevUtilsConfig}, or \u2014 when\n * `additionalWriterTasks` are given \u2014 the same configuration re-partitioned with those writers added.\n *\n * A shared task whose npm script the project's `package.json` does not declare is left out, so a project\n * without, say, markdownlint does not fail its first commit that stages a `.md` file on a missing script. A\n * writer pattern left with no writer is dropped, and spellcheck runs only when `spellcheck` is declared, in\n * which case its files fall to the spellcheck-only key. The `additionalWriterTasks` are the caller's own and\n * are kept as given.\n *\n * `NANO_STAGED` is not an npm script, so it carries its own switch rather than the script-name-derived one\n * every npm script gets \u2014 but both share the same notion of an off value, via {@link isEnvVariableOff}.\n *\n * This is a function rather than module-level code so importing the package barrel never triggers the\n * `.env` read or the process exit; call it from the thin `scripts/nano-staged-config.ts` entry. Resolving the\n * package manager is the one thing that does run at module scope, and it does neither of those two\n * things \u2014 it only probes for a lockfile.\n *\n * @param options - The optional options.\n * @returns The nano-staged task configuration. Does not return when the opt-out is active.\n */\nexport function getNanoStagedConfig(options?: GetNanoStagedConfigOptions): NanoStagedConfig {\n  loadEnvFileIfExists();\n\n  if (isEnvVariableOff(NANO_STAGED_ENV_VARIABLE)) {\n    process.stdout.write(`nano-staged: skipped (${NANO_STAGED_ENV_VARIABLE} is off).\\n`);\n    process.exit(0);\n  }\n\n  const scriptNames = new Set(Object.keys(readPackageJsonSync().scripts ?? {}));\n  const hasAllSharedScripts = [SPELLCHECK_SCRIPT_NAME, ...Object.values(WRITER_SCRIPT_NAMES).flat()]\n    .every((scriptName) => scriptNames.has(scriptName));\n  const additionalWriterTasks = options?.additionalWriterTasks ?? {};\n  if (hasAllSharedScripts && Object.keys(additionalWriterTasks).length === 0) {\n    return obsidianDevUtilsConfig;\n  }\n\n  const writerTasks = toWriterTasks((scriptName) => scriptNames.has(scriptName));\n  const duplicatePattern = Object.keys(additionalWriterTasks).find((pattern) => Object.hasOwn(writerTasks, pattern));\n  if (duplicatePattern !== undefined) {\n    throw new Error(`nano-staged writer pattern '${duplicatePattern}' is already a shared writer pattern.`);\n  }\n\n  return partitionSpellcheck({ ...writerTasks, ...additionalWriterTasks }, scriptNames.has(SPELLCHECK_SCRIPT_NAME));\n}\n\n/**\n * Splits command arguments into batches that each fit one command line after a given prefix.\n *\n * Each argument is costed as nano-staged passes it on Windows \u2014 quoted, then `^`-escaped by `cmd.exe`'s\n * rules \u2014 through {@link getEffectiveCommandLineLength}, and the budget is {@link getMaxBatchCommandLength},\n * which already holds back the reserve for the `npm` \u2192 `cmd.exe` \u2192 `.bin` shim chain re-expanding the\n * arguments. An argument too long for any batch still gets a batch of its own: it fails loudly there, which\n * dropping it would not.\n *\n * @param prefix - The command the arguments are appended to.\n * @param commandArguments - The arguments to split.\n * @returns The batches, in order, together holding every argument once.\n */\nfunction batchCommandArguments(prefix: string, commandArguments: readonly string[]): string[][] {\n  const emptyLength = getEffectiveCommandLineLength('');\n  const budget = getMaxBatchCommandLength() - EXECUTABLE_PATH_RESERVE - getEffectiveCommandLineLength(prefix);\n  const batches: string[][] = [];\n  let batch: string[] = [];\n  let batchLength = 0;\n\n  for (const commandArgument of commandArguments) {\n    const argumentLength = getEffectiveCommandLineLength(` \"${commandArgument}\"`) - emptyLength;\n    if (batch.length > 0 && batchLength + argumentLength > budget) {\n      batches.push(batch);\n      batch = [];\n      batchLength = 0;\n    }\n    batch.push(commandArgument);\n    batchLength += argumentLength;\n  }\n\n  if (batch.length > 0) {\n    batches.push(batch);\n  }\n\n  return batches;\n}\n\n/**\n * Builds a nano-staged configuration in which spellcheck never reads a file while another task rewrites it.\n *\n * The same `Promise.all` that forces two writers into one key makes a catch-all `'*'` spellcheck key run\n * CONCURRENTLY with every writer key, so cspell would read a file that ESLint or dprint is rewriting in\n * place -- a spurious finding on a half-written file, or a pass over content that is not what gets\n * committed. So the staged files are PARTITIONED instead:\n *\n * - every writer key gets spellcheck appended as its LAST command, so it reads that key's files after they\n *   have been rewritten;\n * - one complement key spellchecks exactly the files no writer key claims.\n *\n * The complement is written in nano-staged's own glob dialect, which compiles `!(...)` to a lookahead that\n * is NOT anchored at the end of the path: `!(*.md)*` would exclude `notes.md.bak` too. A nested `!(?)`\n * compiles to `(?!.)`, which IS an end anchor, so each alternative is suffixed with it. A writer pattern\n * containing `/` would switch nano-staged into globstar mode, where `*` stops crossing directories and the\n * construction no longer holds -- hence the throw. The unit test pins the partition against the installed\n * nano-staged compiler, so a release that changes its dialect fails there rather than in a commit.\n *\n * Without spellcheck there is nothing to partition: each writer key runs its own commands, and no complement\n * key is emitted.\n *\n * @param writerTasks - The file-rewriting tasks, keyed by the pattern that claims their files.\n * @param shouldSpellcheck - Whether the project has a `spellcheck` script to run.\n * @returns The configuration, with the spellcheck step partitioned across the keys.\n */\nfunction partitionSpellcheck(writerTasks: Readonly<Record<string, readonly string[]>>, shouldSpellcheck: boolean): NanoStagedConfig {\n  if (!shouldSpellcheck) {\n    return Object.fromEntries(Object.entries(writerTasks).map(([pattern, commands]) => [pattern, toBatchedTask(commands)]));\n  }\n\n  const patterns = Object.keys(writerTasks);\n  const patternWithSlash = patterns.find((pattern) => pattern.includes('/'));\n  if (patternWithSlash !== undefined) {\n    throw new Error(`nano-staged writer pattern '${patternWithSlash}' contains '/', which the spellcheck partition cannot express.`);\n  }\n\n  // `!()*` would compile to a lookahead that rejects every path, so with no writer the complement is everything.\n  const complementPattern = patterns.length === 0 ? '*' : `!(${patterns.map((pattern) => `${pattern}!(?)`).join('|')})*`;\n  const config: NanoStagedConfig = {\n    [complementPattern]: toBatchedTask([SPELLCHECK_COMMAND])\n  };\n\n  for (const [pattern, commands] of Object.entries(writerTasks)) {\n    config[pattern] = toBatchedTask([...commands, SPELLCHECK_COMMAND]);\n  }\n\n  return config;\n}\n\n/**\n * Builds a task that runs each command over every staged file it receives, in as many batches as the command\n * line needs.\n *\n * nano-staged appends a string task's files to ONE command, so a commit staging a few hundred files ran\n * `npm run lint:fix -- <every path>` and failed on Windows with `The command line is too long.`, refusing\n * exactly the whole-repo commits that most need the hook. A function-valued task builds its own commands\n * instead, and these are batched against the same budget `exec()` uses (see `batchCommandArguments`).\n *\n * The commands keep their order: every batch of the first command runs before any batch of the second,\n * because nano-staged runs one key's commands one after another, so a writer still finishes before the next\n * writer, and spellcheck still reads the rewritten files.\n *\n * @param commands - The command prefixes, in the order they run.\n * @returns The task.\n */\nfunction toBatchedTask(commands: readonly string[]): NanoStagedTask {\n  return ({ filenames }) => {\n    const commandArguments = filenames.map((filename) => toCommandArgument(filename));\n    return commands.flatMap((command) => batchCommandArguments(command, commandArguments).map((batch) => `${command} ${batch.join(' ')}`));\n  };\n}\n\n/**\n * Turns a staged file's absolute path into the argument a batched task passes for it.\n *\n * The path is made relative to the working directory, where nano-staged and the task both run, which roughly\n * halves its length and so the number of batches; a path outside it stays absolute. A relative path starting\n * with `-` gets `./`, so no tool reads it as an option.\n *\n * Whitespace and quotes become `?`, because nano-staged's tokenizer cannot carry them (see\n * {@link TOKENIZER_UNSAFE_CHARACTERS_REG_EXP}). Every tool the tasks run (ESLint, dprint, cspell,\n * markdownlint-cli2) takes its paths as globs, and `?` matches exactly the one character it replaced, so the\n * file is still found; a sibling differing only in that character would match too, which costs a lint of an\n * extra file, not a missed one.\n *\n * @param filename - The absolute path of the staged file.\n * @returns The argument.\n */\nfunction toCommandArgument(filename: string): string {\n  const relativePath = relative(process.cwd(), filename);\n  let commandArgument = (relativePath.startsWith('..') || isAbsolute(relativePath) ? filename : relativePath).replaceAll('\\\\', '/');\n  if (commandArgument.startsWith('-')) {\n    commandArgument = `./${commandArgument}`;\n  }\n  return commandArgument.replaceAll(TOKENIZER_UNSAFE_CHARACTERS_REG_EXP, '?');\n}\n\n/**\n * Builds the command prefix that runs an npm script over the paths appended to it.\n *\n * @param scriptName - The script name.\n * @returns The command prefix, such as `npm run lint:fix --`.\n */\nfunction toScriptCommand(scriptName: string): string {\n  return `${PACKAGE_MANAGER_RUN_COMMAND} ${scriptName} --`;\n}\n\n/**\n * Builds the shared writer tasks from {@link WRITER_SCRIPT_NAMES}, keeping only the scripts a filter accepts\n * and dropping a pattern left with none.\n *\n * @param shouldIncludeScript - Whether to run a given script.\n * @returns The writer tasks, keyed by the pattern that claims their files.\n */\nfunction toWriterTasks(shouldIncludeScript: (scriptName: string) => boolean): Record<string, readonly string[]> {\n  const writerTasks: Record<string, readonly string[]> = {};\n  for (const [pattern, scriptNames] of Object.entries(WRITER_SCRIPT_NAMES)) {\n    const commands = scriptNames.filter((scriptName) => shouldIncludeScript(scriptName)).map((scriptName) => toScriptCommand(scriptName));\n    if (commands.length > 0) {\n      writerTasks[pattern] = commands;\n    }\n  }\n  return writerTasks;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/upstream-sync-cli.d.mts

@@ -0,0 +1,34 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * The `sync-upstreams` command: reads its arguments, wires {@link syncUpstreams} to the real git, `gh`, GitHub API and
+ * npm registry, and turns the results into an exit code.
+ */
+import type { SyncDependencies, SyncUpstreamsOptions } from './upstream-sync.mjs';
+/**
+ * Creates the sync's outside world: commands run with `spawnSync`, JSON fetched with `fetch`, output to stdout.
+ * `GITHUB_TOKEN`, when set, is sent to the GitHub API and nowhere else.
+ *
+ * @returns The dependencies.
+ */
+export declare function createNodeSyncDependencies(): SyncDependencies;
+/**
+ * Builds the sync options from the command line.
+ *
+ * `--dry-run` prints each PR it would open and changes nothing. `--only=<name>[,<name>]` limits the sync to those
+ * entries, `--base=<branch>` names the branch the PRs target (`main` by default), and `--config=<path>` names the
+ * `upstreams.json` (the one in the working directory by default).
+ *
+ * @param cliArguments - The arguments after the command name.
+ * @returns The options.
+ */
+export declare function parseSyncUpstreamsArguments(cliArguments: readonly string[]): SyncUpstreamsOptions;
+/**
+ * Runs the `sync-upstreams` command.
+ *
+ * @param cliArguments - The arguments after the command name.
+ * @param dependencies - The outside world. The real one when omitted.
+ * @returns The exit code: `1` when the arguments or `upstreams.json` are wrong or any entry failed, `0` otherwise.
+ */
+export declare function runSyncUpstreamsCli(cliArguments: readonly string[], dependencies?: SyncDependencies): Promise<number>;

package/dist/lib/esm/upstream-sync-cli.mjs

@@ -0,0 +1,77 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { spawnSync } from "node:child_process";
+import process from "node:process";
+import { syncUpstreams } from "./upstream-sync.mjs";
+const DEFAULT_BASE_BRANCH = "main";
+const DEFAULT_CONFIG_PATH = "upstreams.json";
+function createNodeSyncDependencies() {
+  return {
+    exec(file, arguments_, env) {
+      return toResult(spawnSync(file, arguments_, { encoding: "utf-8", env: { ...process.env, ...env } }));
+    },
+    async fetchJson(url) {
+      const headers = { Accept: "application/vnd.github+json" };
+      const token = process.env["GITHUB_TOKEN"];
+      if (token && url.startsWith("https://api.github.com/")) {
+        headers["Authorization"] = `Bearer ${token}`;
+      }
+      const response = await fetch(url, { headers });
+      if (!response.ok) {
+        throw new Error(`GET ${url} failed: HTTP ${String(response.status)}.`);
+      }
+      return await response.json();
+    },
+    log(text) {
+      process.stdout.write(`${text}
+`);
+    },
+    shell(command, env) {
+      process.stdout.write(`> ${command}
+`);
+      const result = toResult(spawnSync(command, { encoding: "utf-8", env: { ...process.env, ...env }, shell: true }));
+      process.stdout.write(result.output);
+      return result;
+    }
+  };
+}
+function parseSyncUpstreamsArguments(cliArguments) {
+  const known = ["--dry-run", "--only=", "--base=", "--config="];
+  const unknown = cliArguments.filter((argument) => known.every((prefix) => !(prefix.endsWith("=") ? argument.startsWith(prefix) : argument === prefix)));
+  if (unknown.length > 0) {
+    throw new Error(`sync-upstreams: unknown argument ${unknown.map((argument) => `"${argument}"`).join(", ")}. Known: --dry-run, --only=, --base=, --config=.`);
+  }
+  return {
+    baseBranch: readOption(cliArguments, "base") ?? DEFAULT_BASE_BRANCH,
+    configPath: readOption(cliArguments, "config") ?? DEFAULT_CONFIG_PATH,
+    dryRun: cliArguments.includes("--dry-run"),
+    only: readOption(cliArguments, "only")?.split(",").filter((name) => name !== "") ?? []
+  };
+}
+async function runSyncUpstreamsCli(cliArguments, dependencies = createNodeSyncDependencies()) {
+  try {
+    const results = await syncUpstreams(parseSyncUpstreamsArguments(cliArguments), dependencies);
+    return results.some((result) => result.outcome === "error") ? 1 : 0;
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    return 1;
+  }
+}
+function readOption(cliArguments, name) {
+  const prefix = `--${name}=`;
+  const value = cliArguments.find((argument) => argument.startsWith(prefix))?.slice(prefix.length);
+  return value === "" ? void 0 : value;
+}
+function toResult(result) {
+  return result.error ? { exitCode: 1, output: result.error.message } : { exitCode: result.status ?? 1, output: `${result.stdout}${result.stderr}` };
+}
+export {
+  createNodeSyncDependencies,
+  parseSyncUpstreamsArguments,
+  runSyncUpstreamsCli
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/upstream-sync-cli.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The `sync-upstreams` command: reads its arguments, wires {@link syncUpstreams} to the real git, `gh`, GitHub API and\n * npm registry, and turns the results into an exit code.\n */\n\nimport type { SpawnSyncReturns } from 'node:child_process';\n\nimport { spawnSync } from 'node:child_process';\nimport process from 'node:process';\n\nimport type {\n  CommandResult,\n  SyncDependencies,\n  SyncUpstreamsOptions\n} from './upstream-sync.ts';\n\nimport { syncUpstreams } from './upstream-sync.ts';\n\nconst DEFAULT_BASE_BRANCH = 'main';\nconst DEFAULT_CONFIG_PATH = 'upstreams.json';\n\n/**\n * Creates the sync's outside world: commands run with `spawnSync`, JSON fetched with `fetch`, output to stdout.\n * `GITHUB_TOKEN`, when set, is sent to the GitHub API and nowhere else.\n *\n * @returns The dependencies.\n */\nexport function createNodeSyncDependencies(): SyncDependencies {\n  return {\n    exec(file, arguments_, env): CommandResult {\n      return toResult(spawnSync(file, arguments_, { encoding: 'utf-8', env: { ...process.env, ...env } }));\n    },\n    async fetchJson(url): Promise<unknown> {\n      const headers: Record<string, string> = { Accept: 'application/vnd.github+json' };\n      const token = process.env['GITHUB_TOKEN'];\n      if (token && url.startsWith('https://api.github.com/')) {\n        headers['Authorization'] = `Bearer ${token}`;\n      }\n      const response = await fetch(url, { headers });\n      if (!response.ok) {\n        throw new Error(`GET ${url} failed: HTTP ${String(response.status)}.`);\n      }\n      return await response.json();\n    },\n    log(text): void {\n      process.stdout.write(`${text}\\n`);\n    },\n    shell(command, env): CommandResult {\n      process.stdout.write(`> ${command}\\n`);\n      const result = toResult(spawnSync(command, { encoding: 'utf-8', env: { ...process.env, ...env }, shell: true }));\n      process.stdout.write(result.output);\n      return result;\n    }\n  };\n}\n\n/**\n * Builds the sync options from the command line.\n *\n * `--dry-run` prints each PR it would open and changes nothing. `--only=<name>[,<name>]` limits the sync to those\n * entries, `--base=<branch>` names the branch the PRs target (`main` by default), and `--config=<path>` names the\n * `upstreams.json` (the one in the working directory by default).\n *\n * @param cliArguments - The arguments after the command name.\n * @returns The options.\n */\nexport function parseSyncUpstreamsArguments(cliArguments: readonly string[]): SyncUpstreamsOptions {\n  const known = ['--dry-run', '--only=', '--base=', '--config='];\n  const unknown = cliArguments.filter((argument) => known.every((prefix) => !(prefix.endsWith('=') ? argument.startsWith(prefix) : argument === prefix)));\n  if (unknown.length > 0) {\n    throw new Error(`sync-upstreams: unknown argument ${unknown.map((argument) => `\"${argument}\"`).join(', ')}. Known: --dry-run, --only=, --base=, --config=.`);\n  }\n  return {\n    baseBranch: readOption(cliArguments, 'base') ?? DEFAULT_BASE_BRANCH,\n    configPath: readOption(cliArguments, 'config') ?? DEFAULT_CONFIG_PATH,\n    dryRun: cliArguments.includes('--dry-run'),\n    only: readOption(cliArguments, 'only')?.split(',').filter((name) => name !== '') ?? []\n  };\n}\n\n/**\n * Runs the `sync-upstreams` command.\n *\n * @param cliArguments - The arguments after the command name.\n * @param dependencies - The outside world. The real one when omitted.\n * @returns The exit code: `1` when the arguments or `upstreams.json` are wrong or any entry failed, `0` otherwise.\n */\nexport async function runSyncUpstreamsCli(cliArguments: readonly string[], dependencies: SyncDependencies = createNodeSyncDependencies()): Promise<number> {\n  try {\n    const results = await syncUpstreams(parseSyncUpstreamsArguments(cliArguments), dependencies);\n    return results.some((result) => result.outcome === 'error') ? 1 : 0;\n  } catch (error) {\n    // A wrong argument or config is the user's to fix, so it gets its message rather than a stack trace.\n    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\\n`);\n    return 1;\n  }\n}\n\n// An empty value counts as absent, because a workflow passes an unset input as one.\nfunction readOption(cliArguments: readonly string[], name: string): string | undefined {\n  const prefix = `--${name}=`;\n  const value = cliArguments.find((argument) => argument.startsWith(prefix))?.slice(prefix.length);\n  return value === '' ? undefined : value;\n}\n\nfunction toResult(result: SpawnSyncReturns<string>): CommandResult {\n  return result.error ? { exitCode: 1, output: result.error.message } : { exitCode: result.status ?? 1, output: `${result.stdout}${result.stderr}` };\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/upstream-sync.d.mts

@@ -0,0 +1,235 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Watches the upstreams a repository mirrors and opens one update PR per upstream that moved.
+ *
+ * Everything here is driven by `upstreams.json` and the handler commands it names, so any repository that vendors
+ * upstream code can use it: through the `sync-upstreams` bin, or the reusable `sync-upstreams.yml` workflow.
+ */
+/**
+ * What a command printed and how it exited.
+ */
+export interface CommandResult {
+    readonly exitCode: number;
+    readonly output: string;
+}
+/**
+ * An upstream followed on a GitHub branch or tag, pinned to a commit.
+ */
+export interface GitUpstreamEntry {
+    /**
+     * The pinned commit: the last upstream state the handler was run against.
+     */
+    commit: string;
+    /**
+     * The shell command that turns a newer upstream state into changes in this repository.
+     */
+    handler: string;
+    name: string;
+    /**
+     * The paths watched upstream, as globs relative to the repository root. A move that touches none of them opens no PR.
+     */
+    paths: readonly string[];
+    /**
+     * The branch or tag followed.
+     */
+    ref: string;
+    /**
+     * `<owner>/<repo>` on GitHub.
+     */
+    repo: string;
+    /**
+     * The shell command that checks the handler's result. Overrides the file's top-level `verify`.
+     */
+    verify?: string;
+}
+/**
+ * An upstream followed as an npm package's dist-tag, pinned to a version.
+ */
+export interface NpmUpstreamEntry {
+    handler: string;
+    name: string;
+    /**
+     * The package name.
+     */
+    npm: string;
+    /**
+     * The dist-tag followed. `latest` when absent.
+     */
+    tag?: string;
+    verify?: string;
+    /**
+     * The pinned version.
+     */
+    version: string;
+}
+/**
+ * Everything the sync does to the outside world, so a test can stand a fixture in for it.
+ */
+export interface SyncDependencies {
+    /**
+     * Runs an executable with arguments and no shell.
+     */
+    exec: (file: string, arguments_: readonly string[], env?: Readonly<Record<string, string>>) => CommandResult;
+    /**
+     * GETs a URL and parses the JSON it returns, throwing on an HTTP error.
+     */
+    fetchJson: (url: string) => Promise<unknown>;
+    log: (text: string) => void;
+    /**
+     * Runs a command line through the shell: a handler or a verify command.
+     */
+    shell: (command: string, env?: Readonly<Record<string, string>>) => CommandResult;
+}
+/**
+ * The PR an upstream move asks for.
+ */
+export interface SyncPlan {
+    branch: string;
+    status: UpstreamStatus;
+    title: string;
+}
+/**
+ * What happened to one entry.
+ */
+export interface SyncResult {
+    /**
+     * Set when checking or applying threw: the job reports it and moves on to the next entry.
+     */
+    readonly error?: string;
+    readonly name: string;
+    /**
+     * `planned` in a dry run, `opened`/`updated` when a PR was pushed, `unchanged` when the branch already held this result.
+     */
+    readonly outcome: 'current' | 'error' | 'opened' | 'planned' | 'unchanged' | 'unwatched' | 'updated';
+    readonly prNumber?: number;
+}
+/**
+ * What {@link syncUpstreams} syncs, and how.
+ */
+export interface SyncUpstreamsOptions {
+    /**
+     * The branch each PR targets and each update branch is cut from.
+     */
+    readonly baseBranch: string;
+    /**
+     * The path to `upstreams.json`, which the sync updates the pin in.
+     */
+    readonly configPath: string;
+    /**
+     * Plan and print every PR, and change nothing.
+     */
+    readonly dryRun: boolean;
+    /**
+     * Only the entries with these names, or every entry when empty.
+     */
+    readonly only: readonly string[];
+}
+/**
+ * One upstream that `upstreams.json` lists: a git one or an npm one.
+ */
+export type UpstreamEntry = GitUpstreamEntry | NpmUpstreamEntry;
+/**
+ * The content of `upstreams.json`.
+ */
+export interface UpstreamsConfig {
+    upstreams: readonly UpstreamEntry[];
+    /**
+     * The shell command that checks every handler's result, unless an entry names its own.
+     */
+    verify?: string;
+}
+/**
+ * What one comparison of an entry with its upstream found.
+ */
+export interface UpstreamStatus {
+    /**
+     * The upstream paths that changed and are watched, sorted. Always empty for an npm upstream.
+     */
+    changedPaths: readonly string[];
+    /**
+     * A link that shows what changed between the pin and the head.
+     */
+    compareUrl: string;
+    entry: UpstreamEntry;
+    /**
+     * The commit or version the upstream is at now.
+     */
+    head: string;
+    /**
+     * The commit or version `upstreams.json` records.
+     */
+    pin: string;
+    /**
+     * `current`: nothing to do. `moved`: a PR is due. `unwatched`: upstream moved, but no watched path changed.
+     */
+    state: 'current' | 'moved' | 'unwatched';
+    /**
+     * Whether GitHub truncated the compare's file list, so a watched path may be missing from `changedPaths`.
+     */
+    truncated: boolean;
+}
+interface StepResult {
+    readonly command: string;
+    readonly result: CommandResult;
+}
+/**
+ * The handler and verify runs a PR body reports.
+ */
+interface StepResults {
+    handler: StepResult;
+    verify: null | StepResult;
+}
+/**
+ * Writes the PR body.
+ *
+ * @param plan - The plan.
+ * @param steps - The handler and verify runs, or `null` in a dry run, where neither runs.
+ * @param diffStat - `git diff --stat` of the update commit, or `null` in a dry run.
+ * @returns The body, in Markdown.
+ */
+export declare function buildPrBody(plan: SyncPlan, steps: null | StepResults, diffStat: null | string): string;
+/**
+ * Compares one entry with its upstream.
+ *
+ * @param entry - The entry.
+ * @param dependencies - The outside world.
+ * @returns What the comparison found.
+ */
+export declare function compareWithUpstream(entry: UpstreamEntry, dependencies: Pick<SyncDependencies, 'fetchJson'>): Promise<UpstreamStatus>;
+/**
+ * Parses and validates an `upstreams.json`.
+ *
+ * @param text - The file's content.
+ * @returns The config.
+ */
+export declare function parseUpstreamsConfig(text: string): UpstreamsConfig;
+/**
+ * Plans the PR a moved upstream asks for.
+ *
+ * @param status - The comparison of a moved entry.
+ * @returns The branch and title.
+ */
+export declare function planSync(status: UpstreamStatus): SyncPlan;
+/**
+ * Checks every entry, and opens or updates one PR per moved upstream.
+ *
+ * A handler or verify failure still opens the PR, as a draft with the failure in its body, so a breaking upstream change
+ * is seen rather than skipped. An error in the sync itself, such as a failed API call, is reported in the entry's result
+ * and the next entry still runs.
+ *
+ * @param options - What to sync, and how.
+ * @param dependencies - The outside world.
+ * @returns One result per entry checked.
+ */
+export declare function syncUpstreams(options: SyncUpstreamsOptions, dependencies: SyncDependencies): Promise<SyncResult[]>;
+/**
+ * Records `head` as the entry's pin in `upstreams.json`, unless the handler already moved it, keeping the file's
+ * key order and formatting.
+ *
+ * @param configPath - The path to `upstreams.json`.
+ * @param status - The comparison.
+ */
+export declare function writePin(configPath: string, status: UpstreamStatus): void;
+export {};