@fuzdev/fuz_gitops 0.78.1 → 0.79.0

package/dist/gitops_config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gitops_config.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gitops_config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,yBAAyB,CAAC;AAGnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAIzD,MAAM,WAAW,YAAY;IAC5B,KAAK,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,kBAAkB,GAAG,CAChC,WAAW,EAAE,YAAY,KACrB,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AAEhD,MAAM,WAAW,eAAe;IAC/B,KAAK,CAAC,EAAE,KAAK,CAAC,GAAG,GAAG,mBAAmB,CAAC,CAAC;IACzC,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG,QAAQ,GAAG,SAAS,CAAC;AAExD,MAAM,WAAW,gBAAgB;IAChC;;;;;;OAMG;IACH,QAAQ,EAAE,GAAG,CAAC;IAEd;;;;;;;;;;;OAWG;IACH,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAExB;;OAEG;IACH,MAAM,EAAE,SAAS,CAAC;IAElB;;OAEG;IACH,UAAU,EAAE,oBAAoB,CAAC;IAEjC;;;OAGG;IACH,EAAE,EAAE,OAAO,CAAC;IAEZ;;OAEG;IACH,QAAQ,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,mBAAmB;IACnC,QAAQ,EAAE,GAAG,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,kEAAkE;IAClE,UAAU,CAAC,EAAE,oBAAoB,CAAC;IAClC,oFAAoF;IACpF,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,iFAAiF;IACjF,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,eAAO,MAAM,0BAA0B,QAAO,YAG5C,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,uBAAuB,GAAI,YAAY,eAAe,KAAG,YAUrE,CAAC;AAwBF,MAAM,WAAW,kBAAkB;IAClC,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,kBAAkB,CAAC;CACvD;AAED,eAAO,MAAM,kBAAkB,GAAU,aAAa,MAAM,KAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAazF,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,CAC3C,aAAa,EAAE,GAAG,EAClB,WAAW,EAAE,MAAM,KACf,OAAO,CAAC,aAAa,IAAI,kBAS7B,CAAC"}
+{"version":3,"file":"gitops_config.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gitops_config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D,iCAAiC;AACjC,eAAO,MAAM,YAAY;;kBAIvB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD,yDAAyD;AACzD,MAAM,MAAM,kBAAkB,GAAG,MAAM,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AAE5E,MAAM,WAAW,kBAAkB;IAClC,QAAQ,CAAC,OAAO,EAAE,YAAY,GAAG,kBAAkB,CAAC;CACpD;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kCAAkC,GAC9C,SAAS,aAAa,CAAC,gBAAgB,CAAC,EACxC,iBAAiB,OAAO,KACtB,KAAK,CAAC,gBAAgB,CACgD,CAAC;AAE1E;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAU,aAAa,MAAM,KAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAwBzF,CAAC;AAKF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAI,KAAK,OAAO,EAAE,aAAa,MAAM,KAAG,YAwBvE,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,CAC3C,aAAa,EAAE,GAAG,EAClB,WAAW,EAAE,MAAM,KACf,OAAO,CAAC,aAAa,IAAI,kBAS7B,CAAC"}

package/dist/gitops_config.js

@@ -1,76 +1,99 @@
 /**
- * Configuration types and normalization for gitops multi-repo management.
+ * The gitops config: which repos a project's gitops tasks work over, as a flat
+ * list of `repos.toml` registry keys.
  *
- * Two-phase configuration system:
- * - `RawGitopsConfig` - User-friendly format with optional fields and flexible types
- * - `GitopsConfig` - Internal format with required fields and strict types
- *
- * This allows users to provide minimal configs (e.g., just URLs as strings) while
- * the system works with normalized configs internally for type safety.
+ * Every other fact about a repo — its dir, URL, branch, visibility, `ci`, and
+ * `archived` — comes from the registry, through `repos status --json`, so the
+ * config declares nothing that could drift from it.
  *
  * @module
  */
 import { existsSync } from 'node:fs';
-import { strip_end } from '@fuzdev/fuz_util/string.ts';
-import { DEFAULT_REPOS_DIR } from './paths.js';
-export const create_empty_gitops_config = () => ({
-    repos: [],
-    repos_dir: DEFAULT_REPOS_DIR
+import { z } from 'zod';
+/** A project's gitops config. */
+export const GitopsConfig = z.strictObject({
+    repos: z
+        .array(z.string().min(1))
+        .meta({ description: 'repos.toml registry keys of owned repos, in the order tasks list them' })
 });
 /**
- * Transforms a `RawGitopsConfig` to the more strict `GitopsConfig`.
- * This allows users to provide a more relaxed config.
+ * The private repos a public host package must not publish. `gitops_sync` writes
+ * every configured repo's GitHub metadata into the host project's generated
+ * `repos.json` — a public site's data when the host package is public — so a
+ * private repo in that config would leak. Empty when the host is private.
+ *
+ * @param entries - the configured repos' registry entries
+ * @param host_is_private - whether the host `package.json` sets `private: true`
+ */
+export const gitops_config_leaked_private_repos = (entries, host_is_private) => host_is_private ? [] : entries.filter((e) => e.visibility === 'private');
+/**
+ * Loads a gitops config module and validates it.
+ *
+ * @returns the config, or `null` when no file exists at `config_path`
+ * @throws {Error} if the module's default export isn't a valid config
  */
-export const normalize_gitops_config = (raw_config) => {
-    const empty_config = create_empty_gitops_config();
-    // All of the raw config properties are optional,
-    // so fall back to the empty values when `undefined`.
-    const { repos, repos_dir } = raw_config;
-    return {
-        repos: repos ? repos.map((r) => parse_fuz_repo_config(r)) : empty_config.repos,
-        // Default to two dirs up from config if not specified
-        repos_dir: repos_dir ?? DEFAULT_REPOS_DIR
-    };
-};
-const parse_fuz_repo_config = (r) => {
-    if (typeof r === 'string') {
-        return {
-            repo_url: r,
-            repo_dir: null,
-            branch: 'main', // TODO @zts use flavored for GitBranch
-            visibility: 'public',
-            ci: true,
-            archived: false
-        };
-    }
-    const visibility = r.visibility ?? 'public';
-    return {
-        repo_url: strip_end(r.repo_url, '.git'),
-        repo_dir: r.repo_dir ?? null,
-        branch: r.branch ?? 'main', // TODO @zts use flavored for GitBranch
-        visibility,
-        ci: r.ci ?? visibility === 'public',
-        archived: r.archived ?? false
-    };
-};
 export const load_gitops_config = async (config_path) => {
     if (!existsSync(config_path)) {
         // No user config file found.
         return null;
     }
-    // Import the user's `gitops.config.ts`.
-    const config_module = await import(config_path);
+    // Import the user's `gitops.config.ts`. An import or call failure keeps its
+    // stack, which carries the config's file and line; validation errors don't need one.
+    let config_module;
+    try {
+        config_module = await import(config_path);
+    }
+    catch (err) {
+        throw Error(`Failed to import the gitops config at ${config_path}:\n${error_with_stack(err)}`);
+    }
     validate_gitops_config_module(config_module, config_path);
-    return normalize_gitops_config(typeof config_module.default === 'function'
-        ? await config_module.default(create_empty_gitops_config())
-        : config_module.default);
+    let raw;
+    try {
+        raw =
+            typeof config_module.default === 'function'
+                ? await config_module.default()
+                : config_module.default;
+    }
+    catch (err) {
+        throw Error(`The gitops config at ${config_path} threw:\n${error_with_stack(err)}`);
+    }
+    return parse_gitops_config(raw, config_path);
+};
+const error_with_stack = (err) => err instanceof Error ? (err.stack ?? err.message) : String(err);
+/**
+ * Validates a loaded config value: registry keys, each listed once.
+ *
+ * @throws {Error} naming the config and what's wrong with it
+ */
+export const parse_gitops_config = (raw, config_path) => {
+    const parsed = GitopsConfig.safeParse(raw);
+    if (!parsed.success) {
+        const hint = "\n  `repos` lists repos.toml registry keys; a repo's url, dir, branch, visibility, ci, and archived come from the registry";
+        throw Error(`Invalid gitops config at ${config_path}:\n${z.prettifyError(parsed.error)}${hint}`);
+    }
+    const config = parsed.data;
+    const problems = [];
+    const seen = new Set();
+    for (const key of config.repos) {
+        if (key.includes('/')) {
+            problems.push(`\`${key}\` isn't a registry key — list repos by their repos.toml key`);
+        }
+        else if (seen.has(key)) {
+            problems.push(`\`${key}\` is listed more than once`);
+        }
+        seen.add(key);
+    }
+    if (problems.length) {
+        throw Error(`Invalid gitops config at ${config_path}:\n  ${problems.join('\n  ')}`);
+    }
+    return config;
 };
 export const validate_gitops_config_module = (config_module, config_path) => {
     const config = config_module.default;
     if (!config) {
-        throw Error(`Invalid Fuz config module at ${config_path}: expected a default export`);
+        throw Error(`Invalid gitops config module at ${config_path}: expected a default export`);
     }
     else if (!(typeof config === 'function' || typeof config === 'object')) {
-        throw Error(`Invalid Fuz config module at ${config_path}: the default export must be a function or object`);
+        throw Error(`Invalid gitops config module at ${config_path}: the default export must be a function or object`);
     }
 };

package/dist/gitops_constants.d.ts

@@ -6,11 +6,13 @@
  * @module
  */
 /**
- * Maximum number of iterations for fixed-point iteration during publishing.
- * Used in both plan generation and actual publishing to resolve transitive dependency cascades.
+ * Maximum number of fixed-point iterations plan generation runs to resolve
+ * transitive dependency cascades. Publishing executes the frozen plan in a
+ * single pass and doesn't iterate.
  *
- * In practice, most repos converge in 2-3 iterations.
- * Deep dependency chains may require more iterations.
+ * Each iteration reaches at least one more level of dependents, so a deep dependency
+ * chain needs more; a plan that hits the limit still changing warns, naming
+ * the packages left.
  */
 export declare const GITOPS_MAX_ITERATIONS_DEFAULT = 10;
 /**

package/dist/gitops_constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gitops_constants.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gitops_constants.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,KAAK,CAAC;AAEhD;;GAEG;AACH,eAAO,MAAM,0BAA0B,qBAAqB,CAAC;AAE7D;;GAEG;AACH,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C;;;GAGG;AACH,eAAO,MAAM,+BAA+B,SAAU,CAAC"}
+{"version":3,"file":"gitops_constants.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gitops_constants.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,6BAA6B,KAAK,CAAC;AAEhD;;GAEG;AACH,eAAO,MAAM,0BAA0B,qBAAqB,CAAC;AAE7D;;GAEG;AACH,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C;;;GAGG;AACH,eAAO,MAAM,+BAA+B,SAAU,CAAC"}

package/dist/gitops_constants.js

@@ -6,11 +6,13 @@
  * @module
  */
 /**
- * Maximum number of iterations for fixed-point iteration during publishing.
- * Used in both plan generation and actual publishing to resolve transitive dependency cascades.
+ * Maximum number of fixed-point iterations plan generation runs to resolve
+ * transitive dependency cascades. Publishing executes the frozen plan in a
+ * single pass and doesn't iterate.
  *
- * In practice, most repos converge in 2-3 iterations.
- * Deep dependency chains may require more iterations.
+ * Each iteration reaches at least one more level of dependents, so a deep dependency
+ * chain needs more; a plan that hits the limit still changing warns, naming
+ * the packages left.
  */
 export const GITOPS_MAX_ITERATIONS_DEFAULT = 10;
 /**

package/dist/gitops_plan.task.d.ts

@@ -1,9 +1,13 @@
 import type { Task } from '@fuzdev/gro';
+import type { Logger } from '@fuzdev/fuz_util/log.ts';
 import { z } from 'zod';
+import { type ResolveGitopsReposOptions } from './gitops_task_helpers.js';
+import type { LocalRepo } from './local_repo.js';
+import type { ChangesetOperations } from './operations.js';
 /** @nodocs */
 export declare const Args: z.ZodObject<{
     config: z.ZodDefault<z.ZodString>;
-    dir: z.ZodOptional<z.ZodString>;
+    registry: z.ZodOptional<z.ZodString>;
     format: z.ZodDefault<z.ZodEnum<{
         stdout: "stdout";
         json: "json";
@@ -11,7 +15,6 @@ export declare const Args: z.ZodObject<{
     }>>;
     outfile: z.ZodOptional<z.ZodString>;
     verbose: z.ZodDefault<z.ZodBoolean>;
-    sync: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strict>;
 export type Args = z.infer<typeof Args>;
 /**
@@ -20,10 +23,33 @@ export type Args = z.infer<typeof Args>;
  *
  * Usage:
  *   `gro gitops_plan`
- *   `gro gitops_plan --dir ../repos`
+ *   `gro gitops_plan --registry ../repos.toml`
  *   `gro gitops_plan --config ./custom.config.ts`
  *
  * @nodocs
  */
 export declare const task: Task<Args>;
+/**
+ * The side effects `run_gitops_plan` reaches through, injectable for tests.
+ *
+ * @nodocs
+ */
+export interface GitopsPlanDeps {
+    /** Loads the configured repos as they sit (`get_gitops_ready`). */
+    load_repos: (options: ResolveGitopsReposOptions) => Promise<{
+        local_repos: Array<LocalRepo>;
+    }>;
+    /** Reads each repo's changesets for the plan. */
+    changeset_ops: ChangesetOperations;
+}
+/**
+ * Runs `gro gitops_plan`: loads the repos as they sit, logs the readiness
+ * block, generates the plan, and outputs it. Under `--format json` or
+ * `markdown` without `--outfile`, the log goes to stderr and stdout carries
+ * the document alone (`route_human_output`).
+ *
+ * @throws {Error} when the plan has errors that would block publishing, after outputting it
+ * @nodocs
+ */
+export declare const run_gitops_plan: (args: Args, log: Logger, deps?: Partial<GitopsPlanDeps>) => Promise<void>;
 //# sourceMappingURL=gitops_plan.task.d.ts.map

package/dist/gitops_plan.task.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gitops_plan.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gitops_plan.task.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,cAAc;AACd,eAAO,MAAM,IAAI;;;;;;;;;;;kBAsBf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CAmC3B,CAAC"}
+{"version":3,"file":"gitops_plan.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gitops_plan.task.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAGN,KAAK,yBAAyB,EAC9B,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAgB3D,cAAc;AACd,eAAO,MAAM,IAAI;;;;;;;;;;kBAkBf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CAM3B,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC9B,mEAAmE;IACnE,UAAU,EAAE,CAAC,OAAO,EAAE,yBAAyB,KAAK,OAAO,CAAC;QAAE,WAAW,EAAE,KAAK,CAAC,SAAS,CAAC,CAAA;KAAE,CAAC,CAAC;IAC/F,iDAAiD;IACjD,aAAa,EAAE,mBAAmB,CAAC;CACnC;AAOD;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,GAC3B,MAAM,IAAI,EACV,KAAK,MAAM,EACX,OAAM,OAAO,CAAC,cAAc,CAAM,KAChC,OAAO,CAAC,IAAI,CA4Bd,CAAC"}

package/dist/gitops_plan.task.js

@@ -1,8 +1,10 @@
 import { z } from 'zod';
 import { styleText as st } from 'node:util';
-import { get_gitops_ready } from './gitops_task_helpers.js';
-import { generate_publishing_plan, log_publishing_plan } from './publishing_plan.js';
-import { format_and_output } from './output_helpers.js';
+import { get_gitops_ready, log_readiness_block } from './gitops_task_helpers.js';
+import { default_changeset_operations } from './operations_defaults.js';
+import { generate_publishing_plan, version_change_kind } from './publishing_plan.js';
+import { log_publishing_plan } from './publishing_plan_logging.js';
+import { format_and_output, output_is_machine, route_human_output } from './output_helpers.js';
 import { GITOPS_CONFIG_PATH_DEFAULT } from './gitops_constants.js';
 /** @nodocs */
 export const Args = z.strictObject({
@@ -10,22 +12,18 @@ export const Args = z.strictObject({
         .string()
         .meta({ description: 'path to the gitops config file, absolute or relative to the cwd' })
         .default(GITOPS_CONFIG_PATH_DEFAULT),
-    dir: z
+    registry: z
         .string()
-        .meta({ description: 'path containing the repos, defaults to the parent of the config dir' })
+        .meta({
+        description: 'path to the repos.toml registry, when `repos` would not find it walking up from the cwd'
+    })
         .optional(),
     format: z
         .enum(['stdout', 'json', 'markdown'])
         .meta({ description: 'output format' })
         .default('stdout'),
     outfile: z.string().meta({ description: 'write output to file instead of logging' }).optional(),
-    verbose: z.boolean().meta({ description: 'show additional details' }).default(false),
-    sync: z
-        .boolean()
-        .meta({
-        description: 'sync repos (switch branch, pull, install) before planning instead of reading the working tree as-is'
-    })
-        .default(false)
+    verbose: z.boolean().meta({ description: 'show additional details' }).default(false)
 });
 /**
  * Generate a publishing plan showing what would happen during multi-repo publishing.
@@ -33,7 +31,7 @@ export const Args = z.strictObject({
  *
  * Usage:
  *   `gro gitops_plan`
- *   `gro gitops_plan --dir ../repos`
+ *   `gro gitops_plan --registry ../repos.toml`
  *   `gro gitops_plan --config ./custom.config.ts`
  *
  * @nodocs
@@ -42,29 +40,43 @@ export const task = {
     summary: 'generate a publishing plan based on changesets',
     Args,
     run: async ({ args, log }) => {
-        const { dir, config, format, outfile, verbose, sync } = args;
-        log.info(st('cyan', 'Generating multi-repo publishing plan...'));
-        // Load local repos; read the working tree as-is unless `--sync`
-        const { local_repos } = await get_gitops_ready({
-            config,
-            dir,
-            download: false, // Don't download if missing
-            sync,
-            log
-        });
-        if (local_repos.length === 0) {
-            log.error('No local repos found');
-            return;
-        }
-        log.info(`  Found ${local_repos.length} local repos`);
-        // Generate publishing plan
-        const plan = await generate_publishing_plan(local_repos, { log, verbose });
-        // Format and output using output_helpers
-        await format_and_output(plan, create_plan_formatters({ verbose }), { format, outfile, log });
-        // Exit with error if there are blocking issues
-        if (plan.errors.length > 0) {
-            throw new Error('Publishing plan found errors that would block publishing');
-        }
+        await run_gitops_plan(args, log);
+    }
+};
+const default_gitops_plan_deps = {
+    load_repos: get_gitops_ready,
+    changeset_ops: default_changeset_operations
+};
+/**
+ * Runs `gro gitops_plan`: loads the repos as they sit, logs the readiness
+ * block, generates the plan, and outputs it. Under `--format json` or
+ * `markdown` without `--outfile`, the log goes to stderr and stdout carries
+ * the document alone (`route_human_output`).
+ *
+ * @throws {Error} when the plan has errors that would block publishing, after outputting it
+ * @nodocs
+ */
+export const run_gitops_plan = async (args, log, deps = {}) => {
+    const { load_repos, changeset_ops } = { ...default_gitops_plan_deps, ...deps };
+    const { config, registry, format, outfile, verbose } = args;
+    const write_stdout = route_human_output(log, output_is_machine(format, outfile));
+    log.info(st('cyan', 'Generating multi-repo publishing plan...'));
+    // Load local repos as they sit, and say which aren't at rest
+    const { local_repos } = await load_repos({ config, registry, log });
+    log_readiness_block(local_repos, log);
+    log.info(`  Found ${local_repos.length} local repos`);
+    // Generate publishing plan
+    const plan = await generate_publishing_plan(local_repos, { log, verbose, ops: changeset_ops });
+    // Format and output using output_helpers
+    await format_and_output(plan, create_plan_formatters({ verbose }), {
+        format,
+        outfile,
+        log,
+        write_stdout
+    });
+    // Exit with error if there are blocking issues
+    if (plan.errors.length > 0) {
+        throw new Error('Publishing plan found errors that would block publishing');
     }
 };
 const create_plan_formatters = (options = {}) => ({
@@ -76,6 +88,7 @@ const create_plan_formatters = (options = {}) => ({
             breaking_cascades: Object.fromEntries(plan.breaking_cascades),
             warnings: plan.warnings,
             info: plan.info,
+            no_changes: plan.no_changes,
             errors: plan.errors
         };
         return JSON.stringify(output, null, 2);
@@ -85,7 +98,7 @@ const create_plan_formatters = (options = {}) => ({
 });
 const format_plan_as_markdown = (plan) => {
     const lines = [];
-    const { publishing_order, version_changes, dependency_updates, breaking_cascades, warnings, info, errors } = plan;
+    const { publishing_order, version_changes, dependency_updates, breaking_cascades, warnings, info, no_changes, errors } = plan;
     lines.push('# Publishing Plan');
     lines.push('');
     // Errors
@@ -106,28 +119,28 @@ const format_plan_as_markdown = (plan) => {
     }
     // Version changes
     if (version_changes.length > 0) {
-        const with_changesets = version_changes.filter((vc) => vc.has_changesets && !vc.needs_bump_escalation);
-        const with_escalation = version_changes.filter((vc) => vc.needs_bump_escalation);
-        const with_auto_changesets = version_changes.filter((vc) => vc.will_generate_changeset);
+        const with_changesets = version_changes.filter((vc) => version_change_kind(vc) === 'explicit');
+        const with_escalation = version_changes.filter((vc) => version_change_kind(vc) === 'escalation');
+        const with_auto_changesets = version_changes.filter((vc) => version_change_kind(vc) === 'auto');
         if (with_changesets.length > 0) {
             lines.push('## Version Changes (from changesets)');
             lines.push('');
-            lines.push('| Package | From | To | Bump | Major |');
-            lines.push('|---------|------|----|------|-------|');
+            lines.push('| Package | From | To | Bump | Breaking |');
+            lines.push('|---------|------|----|------|----------|');
             for (const change of with_changesets) {
-                const is_major = change.bump_type === 'major' ? '💥 Yes' : 'No';
-                lines.push(`| \`${change.package_name}\` | ${change.from} | ${change.to} | ${change.bump_type} | ${is_major} |`);
+                const breaking = change.breaking ? '💥 Yes' : 'No';
+                lines.push(`| \`${change.package_name}\` | ${change.from} | ${change.to} | ${change.bump_type} | ${breaking} |`);
             }
             lines.push('');
         }
         if (with_escalation.length > 0) {
             lines.push('## Version Changes (bump escalation required)');
             lines.push('');
-            lines.push('| Package | From | To | Changesets Bump | Required Bump | Major |');
-            lines.push('|---------|------|-----|-----------------|---------------|-------|');
+            lines.push('| Package | From | To | Changesets Bump | Required Bump | Breaking |');
+            lines.push('|---------|------|-----|-----------------|---------------|----------|');
             for (const change of with_escalation) {
-                const is_major = change.bump_type === 'major' ? '💥 Yes' : 'No';
-                lines.push(`| \`${change.package_name}\` | ${change.from} | ${change.to} | ${change.existing_bump} | ${change.required_bump} | ${is_major} |`);
+                const breaking = change.breaking ? '💥 Yes' : 'No';
+                lines.push(`| \`${change.package_name}\` | ${change.from} | ${change.to} | ${change.existing_bump} | ${change.required_bump} | ${breaking} |`);
             }
             lines.push('');
             lines.push('> ⬆️ These packages have changesets, but dependencies require a larger version bump.');
@@ -136,11 +149,11 @@ const format_plan_as_markdown = (plan) => {
         if (with_auto_changesets.length > 0) {
             lines.push('## Version Changes (auto-generated for dependency updates)');
             lines.push('');
-            lines.push('| Package | From | To | Bump | Major |');
-            lines.push('|---------|------|-----|------|-------|');
+            lines.push('| Package | From | To | Bump | Breaking |');
+            lines.push('|---------|------|-----|------|----------|');
             for (const change of with_auto_changesets) {
-                const is_major = change.bump_type === 'major' ? '💥 Yes' : 'No';
-                lines.push(`| \`${change.package_name}\` | ${change.from} | ${change.to} | ${change.bump_type} | ${is_major} |`);
+                const breaking = change.breaking ? '💥 Yes' : 'No';
+                lines.push(`| \`${change.package_name}\` | ${change.from} | ${change.to} | ${change.bump_type} | ${breaking} |`);
             }
             lines.push('');
         }
@@ -201,24 +214,33 @@ const format_plan_as_markdown = (plan) => {
         }
         lines.push('');
     }
-    // Info (packages with no changes - normal status)
+    // Info (normal status, not warnings)
     if (info.length > 0) {
-        lines.push('## ℹ️ No Changes to Publish');
+        lines.push('## ℹ️ Info');
+        lines.push('');
+        for (const line of info) {
+            lines.push(`- ${line}`);
+        }
+        lines.push('');
+    }
+    // Packages with nothing to publish (normal status)
+    if (no_changes.length > 0) {
+        lines.push('## No Changes to Publish');
         lines.push('');
-        lines.push('*These packages have no changesets and no dependency updates:*');
+        lines.push('*These packages have no changesets and nothing to publish:*');
         lines.push('');
-        for (const pkg of info) {
+        for (const pkg of no_changes) {
             lines.push(`- \`${pkg}\``);
         }
         lines.push('');
     }
     // Summary
-    const major_bump_count = version_changes.filter((vc) => vc.bump_type === 'major').length;
+    const breaking_count = version_changes.filter((vc) => vc.breaking).length;
     lines.push('## Summary');
     lines.push('');
     lines.push(`- **Packages to publish**: ${version_changes.length}`);
     lines.push(`- **Dependency updates**: ${dependency_updates.length}`);
-    lines.push(`- **Major version bumps**: ${major_bump_count}`);
+    lines.push(`- **Breaking changes**: ${breaking_count}`);
     lines.push(`- **Warnings**: ${warnings.length}`);
     lines.push(`- **Errors**: ${errors.length}`);
     return lines;

package/dist/gitops_publish.task.d.ts

@@ -1,13 +1,18 @@
 import type { Task } from '@fuzdev/gro';
+import type { Logger } from '@fuzdev/fuz_util/log.ts';
 import { z } from 'zod';
+import { type ResolveGitopsReposOptions } from './gitops_task_helpers.js';
+import type { LocalRepo } from './local_repo.js';
+import type { GitopsOperations, ReposOperations } from './operations.js';
 /** @nodocs */
 export declare const Args: z.ZodObject<{
     config: z.ZodDefault<z.ZodString>;
-    dir: z.ZodOptional<z.ZodString>;
+    registry: z.ZodOptional<z.ZodString>;
     peer_strategy: z.ZodDefault<z.ZodEnum<{
         exact: "exact";
         caret: "caret";
         tilde: "tilde";
+        gte: "gte";
     }>>;
     wetrun: z.ZodDefault<z.ZodBoolean>;
     format: z.ZodDefault<z.ZodEnum<{
@@ -21,10 +26,65 @@ export declare const Args: z.ZodObject<{
     emit_json: z.ZodDefault<z.ZodBoolean>;
     outfile: z.ZodOptional<z.ZodString>;
     verbose: z.ZodDefault<z.ZodBoolean>;
-    sync: z.ZodDefault<z.ZodBoolean>;
     preview: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strict>;
 export type Args = z.infer<typeof Args>;
 /** @nodocs */
 export declare const task: Task<Args>;
+/**
+ * The side effects `run_gitops_publish` reaches through, injectable so the
+ * order of its steps is testable.
+ *
+ * @nodocs
+ */
+export interface GitopsPublishDeps {
+    /** Loads the configured repos as they sit (`get_gitops_ready`). */
+    load_repos: (options: ResolveGitopsReposOptions) => Promise<{
+        local_repos: Array<LocalRepo>;
+    }>;
+    /** Runs `repos status` for the readiness gate. */
+    repos_ops: ReposOperations;
+    /** The executor's operations. */
+    ops: GitopsOperations;
+    /**
+     * Asks the operator to confirm the plan, on stderr, so a machine-readable
+     * stdout carries nothing but its document or events.
+     */
+    confirm: () => Promise<boolean>;
+}
+/**
+ * Runs `gro gitops_publish`, in order: load the repos as they sit,
+ * generate the plan, and — for `--wetrun` — run the readiness gate
+ * (`gate_publish_readiness`, read-only: `repos status --fetch`) before
+ * printing the plan and asking to confirm, so a refusal or a "no" changes
+ * nothing. Then preflight and the executor. A dry run skips the gate and
+ * prints the diagnostics' readiness block instead. Under `--emit_json`, or
+ * `--format json` or `markdown` without `--outfile`, the log goes to stderr
+ * and stdout carries the events or the report alone (`route_human_output`).
+ *
+ * @returns `cancelled` when the operator declines, `failed` when the run failed (its output already written), else `done`
+ * @throws {TaskError} when the readiness gate refuses or loading fails
+ * @nodocs
+ */
+export declare const run_gitops_publish: (args: Args, log: Logger, deps?: Partial<GitopsPublishDeps>) => Promise<"done" | "cancelled" | "failed">;
+/**
+ * Where `gro publish` and `gro deploy`, streaming live, show their stdout: on
+ * our stderr when our stdout carries a machine-readable stream — the
+ * `--emit_json` events, or a JSON or markdown report not sent to `--outfile` —
+ * so their output can't corrupt it, else on our stdout. The same test sends
+ * the task's own log and prompt to stderr.
+ *
+ * @nodocs
+ */
+export declare const to_child_stdout: (args: Pick<Args, "emit_json" | "format" | "outfile">) => "stdout" | "stderr";
+/**
+ * A failed package's markdown: the message's first line on the bullet, and the
+ * rest — the end of a command's stderr — in an indented fenced block, its fence
+ * longer than any backtick run inside so stderr can't close it.
+ *
+ * @param name - the package name
+ * @param message - the failure message
+ * @nodocs
+ */
+export declare const format_failure_markdown: (name: string, message: string) => Array<string>;
 //# sourceMappingURL=gitops_publish.task.d.ts.map

package/dist/gitops_publish.task.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gitops_publish.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gitops_publish.task.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiBxB,cAAc;AACd,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;kBA+Cf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,cAAc;AACd,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CAiH3B,CAAC"}
+{"version":3,"file":"gitops_publish.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gitops_publish.task.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAIN,KAAK,yBAAyB,EAC9B,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAyBzE,cAAc;AACd,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;kBAoDf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,cAAc;AACd,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CAY3B,CAAC;AAEF;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IACjC,mEAAmE;IACnE,UAAU,EAAE,CAAC,OAAO,EAAE,yBAAyB,KAAK,OAAO,CAAC;QAAE,WAAW,EAAE,KAAK,CAAC,SAAS,CAAC,CAAA;KAAE,CAAC,CAAC;IAC/F,kDAAkD;IAClD,SAAS,EAAE,eAAe,CAAC;IAC3B,iCAAiC;IACjC,GAAG,EAAE,gBAAgB,CAAC;IACtB;;;OAGG;IACH,OAAO,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;CAChC;AAYD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB,GAC9B,MAAM,IAAI,EACV,KAAK,MAAM,EACX,OAAM,OAAO,CAAC,iBAAiB,CAAM,KACnC,OAAO,CAAC,MAAM,GAAG,WAAW,GAAG,QAAQ,CA4HzC,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,GAC3B,MAAM,IAAI,CAAC,IAAI,EAAE,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAC,KAClD,QAAQ,GAAG,QACuE,CAAC;AAEtF;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,GAAI,MAAM,MAAM,EAAE,SAAS,MAAM,KAAG,KAAK,CAAC,MAAM,CAQnF,CAAC"}