@fuzdev/fuz_gitops 0.78.0 → 0.79.0

package/dist/gitops_task_helpers.js

@@ -1,103 +1,144 @@
 /**
  * Shared initialization logic for all gitops tasks.
  *
- * Provides `get_gitops_ready()` which orchestrates:
- * - Config loading and normalization
- * - Repo resolution (local path discovery)
- * - Branch switching and syncing
- * - Dependency installation
+ * `resolve_gitops_repos()` loads the config's registry keys, runs
+ * `repos status <keys…> --json`, and resolves each key to its checkout.
+ * `get_gitops_ready()` then loads each repo's library as its working tree
+ * sits. `gate_publish_readiness()` is the read-only gate a real publish runs
+ * before its prompt, and `log_readiness_block()` the diagnostics' report of
+ * repos not at rest (both over `repo_readiness.ts`).
  *
  * Used by: `gitops_sync.task.ts`, `gitops_analyze.task.ts`, `gitops_plan.task.ts`,
- * `gitops_publish.task.ts`, and `gitops_validate.task.ts`.
+ * `gitops_publish.task.ts`, `gitops_validate.task.ts`, and `gitops_run.task.ts`.
  *
- * Accepts `git_ops` and `npm_ops` parameters to support testing via operations pattern
- * (see `operations.ts` for dependency injection details).
+ * Accepts `repos_ops` to support testing via the operations pattern (see
+ * `operations.ts` for dependency injection details).
  *
  * @module
  */
 import { TaskError } from '@fuzdev/gro';
 import { styleText as st } from 'node:util';
-import { resolve, dirname } from 'node:path';
-import { print_path } from '@fuzdev/gro/paths.ts';
+import { resolve } from 'node:path';
+import { to_error_message } from '@fuzdev/fuz_util/error.ts';
 import { load_gitops_config } from './gitops_config.js';
-import { local_repos_load, local_repos_ensure } from './local_repo.js';
-import { resolve_gitops_config } from './resolved_gitops_config.js';
-import { DEFAULT_REPOS_DIR } from './paths.js';
+import { local_repos_load, local_repos_resolve, repo_is_npm } from './local_repo.js';
+import { load_repos_status, to_repos_command } from './repos_status_load.js';
+import { check_publish_readiness, format_readiness_ahead, format_readiness_block, repos_not_at_rest } from './repo_readiness.js';
+import { default_repos_operations } from './operations_defaults.js';
 /**
- * Central initialization function for all gitops tasks.
+ * Resolves the gitops config's repos through `repos status`: loads the
+ * config's registry keys, reports on them, and resolves each to its checkout,
+ * in config order. Reads nothing but git state and writes nothing.
  *
- * Initialization sequence:
- * 1. Loads and normalizes config from `gitops.config.ts`
- * 2. Resolves local repo paths (creates missing with `--download`)
- * 3. If `sync`, switches branches and pulls latest changes (in parallel by default)
- * 4. If `sync`, auto-installs deps if `package.json` changed during pull
+ * @returns the config, the `repos status` report, and each repo's path and entry
+ * @throws {TaskError} if the config is missing, invalid, or lists no repos, `repos status` fails, or any configured repo is unknown, a reference, missing, not a repo, unprobed, or private under a public `host`
+ */
+export const resolve_gitops_repos = async (options) => {
+    const { config, registry, host, log, repos_ops = default_repos_operations } = options;
+    const config_path = resolve(config);
+    const gitops_config = await import_gitops_config(config_path);
+    const keys = gitops_config.repos;
+    if (keys.length === 0) {
+        throw new TaskError(`No repos are configured in ${config_path}`);
+    }
+    log?.info(`reading the state of ${keys.length} repos from \`repos status\``);
+    log?.debug('repos status targets', keys);
+    const loaded = await load_repos_status({ keys, registry, repos_ops });
+    if (!loaded.ok) {
+        // an unknown key is the config's to fix, so name the config
+        throw new TaskError(loaded.error?.kind === 'unknown_entry' ? `${config_path}: ${loaded.message}` : loaded.message);
+    }
+    const { report } = loaded;
+    const resolved = local_repos_resolve({ keys, report, host, registry });
+    if (!resolved.ok) {
+        throw new TaskError(`${config_path}: ${resolved.message}`);
+    }
+    return { config_path, gitops_config, report, local_repo_paths: resolved.value };
+};
+/**
+ * Central initialization function for the gitops tasks that load libraries:
+ * resolves the config's repos through `repos status` (`resolve_gitops_repos`),
+ * then loads each repo's library as its working tree sits (`local_repos_load`).
+ * Moves no ref; gro caches each library at `.gro/library.json` in its repo, at
+ * a clean commit.
  *
- * With `sync: false` (the default for read-only diagnostics), steps 3-4 are
- * skipped and repos are loaded exactly as checked out — no branch switch, pull,
- * install, or clean-workspace check.
+ * @returns the loaded repos, in config order
+ * @throws {TaskError} if resolving the repos or loading them fails
+ */
+export const get_gitops_ready = async (options) => {
+    const { local_repo_paths } = await resolve_gitops_repos(options);
+    const local_repos = await local_repos_load({ local_repo_paths, log: options.log });
+    return { local_repos };
+};
+/**
+ * The readiness gate `gitops_publish --wetrun` runs before its confirmation
+ * prompt: fetches every npm repo from origin (`repos status <keys…> --fetch
+ * --json`, which writes remote-tracking refs and nothing else) and refuses
+ * unless each is ready (`check_publish_readiness`) — on its registry branch,
+ * clean, idle, in sync with origin or ahead of it, fetched without error, no
+ * other live session in its checkout, and nothing left to a person. Each
+ * ready repo ahead of origin is logged, saying whether its release push
+ * carries those commits or they stay unpushed.
  *
- * Priority for path resolution:
- * - `dir` argument (explicit override)
- * - Config `repos_dir` setting
- * - `DEFAULT_REPOS_DIR` constant
+ * Every npm repo, not just those the plan publishes or rewrites: the plan
+ * reads each one's working tree (changesets, versions, dependency ranges), so
+ * a repo off its branch or behind origin can hide a changeset and leave the
+ * plan wrong about what to publish. Changes nothing.
  *
- * @param options.git_ops - for testing (defaults to real git operations)
- * @param options.npm_ops - for testing (defaults to real npm operations)
- * @param options.parallel - whether to load repos in parallel (default: true)
- * @param options.concurrency - max concurrent repo loads (default: 5)
- * @param options.sync - sync working trees before loading (default: true)
- * @param options.allow_dirty - when syncing, tolerate uncommitted changes (default: false)
- * @returns initialized config and fully loaded repos ready for operations
- * @throws {TaskError} if config loading or repo resolution fails
+ * @param options - the loaded repos, the `--registry` if any, the package names the plan publishes, a logger, and the `repos` runner
+ * @throws {TaskError} if `repos status` fails or any npm repo isn't ready, naming each problem and its fix
  */
-export const get_gitops_ready = async (options) => {
-    const { config, dir, download, log, git_ops, npm_ops, parallel, concurrency, sync, allow_dirty } = options;
-    const config_path = resolve(config);
-    const gitops_config = await import_gitops_config(config_path);
-    // Priority: explicit dir arg → config repos_dir → default (two dirs up from config)
-    const repos_dir = resolve_gitops_paths({
-        config,
-        dir,
-        config_repos_dir: gitops_config.repos_dir,
-    }).repos_dir;
-    log?.info(`resolving gitops configs on the filesystem in ${repos_dir}`, gitops_config.repos.map((r) => r.repo_url));
-    const resolved_config = resolve_gitops_config(gitops_config, repos_dir);
-    const local_repo_paths = await local_repos_ensure({
-        resolved_config,
-        repos_dir,
-        gitops_config,
-        download,
-        log,
-        npm_ops,
-    });
-    const local_repos = await local_repos_load({
-        local_repo_paths,
-        log,
-        git_ops,
-        npm_ops,
-        parallel,
-        concurrency,
-        sync,
-        allow_dirty,
-    });
-    return { config_path, repos_dir, gitops_config, local_repos };
+export const gate_publish_readiness = async (options) => {
+    const { local_repos, registry, publishing, log, repos_ops = default_repos_operations } = options;
+    const npm_repos = local_repos.filter(repo_is_npm);
+    const keys = npm_repos.map((r) => r.entry.key);
+    if (keys.length === 0)
+        return;
+    log?.info(`fetching ${keys.length} npm repos to check they're ready to publish`);
+    const loaded = await load_repos_status({ keys, registry, fetch: true, repos_ops });
+    if (!loaded.ok) {
+        throw new TaskError(`the readiness check failed: ${loaded.message}`);
+    }
+    const repos_command = to_repos_command(registry);
+    const checked = check_publish_readiness({ report: loaded.report, keys, repos_command });
+    if (!checked.ok) {
+        throw new TaskError(checked.message);
+    }
+    log?.info(st('green', `all ${keys.length} npm repos are ready to publish`));
+    const name_by_key = new Map(npm_repos.map((r) => [r.entry.key, r.library.name]));
+    for (const ahead of checked.ahead) {
+        const name = name_by_key.get(ahead.key);
+        const publishes = name !== undefined && publishing?.has(name) === true;
+        log?.info(st('yellow', format_readiness_ahead(ahead, publishes, { repos_command })));
+    }
 };
-export const resolve_gitops_paths = (options) => {
-    const { config, dir, config_repos_dir } = options;
-    const config_path = resolve(config);
-    const config_dir = dirname(config_path);
-    // Priority: explicit dir arg → config repos_dir → default (parent of config dir)
-    const repos_dir = dir !== undefined
-        ? resolve(dir)
-        : config_repos_dir !== undefined
-            ? resolve(config_dir, config_repos_dir)
-            : resolve(config_dir, DEFAULT_REPOS_DIR);
-    return { config_path, repos_dir };
+/**
+ * Logs the diagnostics' readiness block as warnings (stderr, so a `--format
+ * json` or `markdown` document on stdout stays clean): each npm repo not at
+ * rest, and how. Logs nothing when every one is at rest. Reads the entries
+ * `repos status` already reported, from local refs.
+ *
+ * @param local_repos - the loaded repos; the npm ones are reported
+ * @param log - where the warnings go
+ * @param now - the current time in unix seconds (defaults to the clock)
+ */
+export const log_readiness_block = (local_repos, log, now = Math.floor(Date.now() / 1000)) => {
+    const not_ready = repos_not_at_rest(local_repos.filter(repo_is_npm).map((r) => r.entry));
+    for (const line of format_readiness_block(not_ready, now)) {
+        log.warn(st('yellow', line));
+    }
 };
-export const import_gitops_config = async (config_path) => {
-    const gitops_config = await load_gitops_config(config_path);
+const import_gitops_config = async (config_path) => {
+    let gitops_config;
+    try {
+        gitops_config = await load_gitops_config(config_path);
+    }
+    catch (err) {
+        // an invalid config is the user's to fix, not an unexpected task failure
+        throw new TaskError(to_error_message(err));
+    }
     if (!gitops_config) {
-        throw new TaskError(st('red', `No gitops config found at ${print_path(config_path)}`));
+        throw new TaskError(st('red', `No gitops config found at ${config_path}`));
     }
     return gitops_config;
 };

package/dist/gitops_validate.task.d.ts

@@ -3,9 +3,8 @@ import { z } from 'zod';
 /** @nodocs */
 export declare const Args: z.ZodObject<{
     config: z.ZodDefault<z.ZodString>;
-    dir: z.ZodOptional<z.ZodString>;
+    registry: z.ZodOptional<z.ZodString>;
     verbose: z.ZodDefault<z.ZodBoolean>;
-    sync: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strict>;
 export type Args = z.infer<typeof Args>;
 /** @nodocs */

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

@@ -1 +1 @@
-{"version":3,"file":"gitops_validate.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gitops_validate.task.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,aAAa,CAAC;AACtC,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAetB,cAAc;AACd,eAAO,MAAM,IAAI;;;;;kBAiBf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,cAAc;AACd,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CA8Q3B,CAAC"}
+{"version":3,"file":"gitops_validate.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gitops_validate.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;;;;kBAaf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,cAAc;AACd,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CA0Q3B,CAAC"}

package/dist/gitops_validate.task.js

@@ -1,8 +1,9 @@
 import { z } from 'zod';
 import { styleText as st } from 'node:util';
-import { get_gitops_ready } from './gitops_task_helpers.js';
+import { get_gitops_ready, log_readiness_block } from './gitops_task_helpers.js';
 import { analyze_repos } from './graph_validation.js';
-import { generate_publishing_plan, log_publishing_plan, } from './publishing_plan.js';
+import { generate_publishing_plan } from './publishing_plan.js';
+import { log_publishing_plan } from './publishing_plan_logging.js';
 import { execute_publishing_plan } from './multi_repo_publisher.js';
 import { log_dependency_analysis } from './log_helpers.js';
 import { GITOPS_CONFIG_PATH_DEFAULT } from './gitops_constants.js';
@@ -13,32 +14,29 @@ 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' })
-        .optional(),
-    verbose: z.boolean().meta({ description: 'show additional details' }).default(false),
-    sync: z
-        .boolean()
         .meta({
-        description: 'sync repos (switch branch, pull, install) before validating instead of reading the working tree as-is',
+        description: 'path to the repos.toml registry, when `repos` would not find it walking up from the cwd'
     })
-        .default(false),
+        .optional(),
+    verbose: z.boolean().meta({ description: 'show additional details' }).default(false)
 });
 /** @nodocs */
 export const task = {
     Args,
     summary: 'validate gitops configuration by running all read-only commands and checking for issues',
     run: async ({ args, log }) => {
-        const { config, dir, verbose, sync } = args;
+        const { config, registry, verbose } = args;
         log.info(st('cyan', 'Running Gitops Validation Suite'));
         log.info(st('dim', 'This runs all read-only commands and checks for consistency.'));
         const results = [];
         const start_time = Date.now();
-        // Load repos once (shared by all commands); read the working tree as-is unless `--sync`
+        // Load repos once (shared by all commands), as they sit, and say which aren't at rest
         log.info(st('dim', 'Loading repositories...'));
-        const { local_repos } = await get_gitops_ready({ config, dir, download: false, sync, log });
+        const { local_repos } = await get_gitops_ready({ config, registry, log });
         log.info(st('dim', `   Found ${local_repos.length} local repos`));
+        log_readiness_block(local_repos, log);
         // 1. Run gitops_analyze
         log.info(st('yellow', 'Running gitops_analyze...'));
         const analyze_start = Date.now();
@@ -65,7 +63,7 @@ export const task = {
                 duration: analyze_duration,
                 warning_details,
                 info_details,
-                analysis,
+                analysis
             });
             log.info(st('green', `  ✓ gitops_analyze completed in ${analyze_duration}ms`));
             // Print detailed analysis
@@ -81,7 +79,7 @@ export const task = {
                 success: false,
                 warnings: 0,
                 errors: 1,
-                duration: analyze_duration,
+                duration: analyze_duration
             });
             log.error(st('red', `  ✗ gitops_analyze failed: ${error}`));
         }
@@ -100,7 +98,7 @@ export const task = {
                 success: errors === 0,
                 warnings,
                 errors,
-                duration: plan_duration,
+                duration: plan_duration
             });
             log.info(st('green', `  ✓ gitops_plan completed in ${plan_duration}ms`));
             if (verbose) {
@@ -120,7 +118,7 @@ export const task = {
                 success: false,
                 warnings: 0,
                 errors: 1,
-                duration: plan_duration,
+                duration: plan_duration
             });
             log.error(st('red', `  ✗ gitops_plan failed: ${error}`));
         }
@@ -130,7 +128,7 @@ export const task = {
         try {
             const options = {
                 wetrun: false,
-                log: undefined, // Silent for validation
+                log: undefined // Silent for validation
             };
             // Reuse the plan from step 2 (regenerate only if that step failed to produce one).
             const result = await execute_publishing_plan(local_repos, publishing_plan ?? (await generate_publishing_plan(local_repos, { verbose })), options);
@@ -143,7 +141,7 @@ export const task = {
                 success: result.ok,
                 warnings: 0,
                 errors,
-                duration: dry_duration,
+                duration: dry_duration
             });
             log.info(st('green', `  ✓ gitops_publish (dry run) completed in ${dry_duration}ms`));
             if (errors > 0) {
@@ -157,24 +155,19 @@ export const task = {
                 success: false,
                 warnings: 0,
                 errors: 1,
-                duration: dry_duration,
+                duration: dry_duration
             });
             log.error(st('red', `  ✗ gitops_publish (dry run) failed: ${error}`));
         }
-        // 4. Reconcile each repo's declared `ci` against actual workflow files on disk.
+        // 4. Reconcile each repo's registry-declared `ci` against actual workflow files on disk.
         log.info(st('yellow', 'Running ci_reconcile...'));
         const ci_start = Date.now();
         try {
             const ci_drift = reconcile_ci(local_repos.map((r) => ({
-                repo_url: r.repo_config.repo_url,
-                ci: r.repo_config.ci,
+                repo_url: r.entry.url,
+                ci: r.entry.ci,
                 has_workflows: repo_has_workflows(r.repo_dir),
-                // TODO: `local_repos` only ever holds checked-out repos — a missing repo
-                // throws in `local_repos_ensure` before we reach here — so `checkable` is
-                // always `true` today. The gate exists for a future caller that loads a
-                // partial set; until then the skip path is inert and untested.
-                checkable: true,
-                archived: r.repo_config.archived,
+                archived: r.entry.archived
             })));
             const ci_duration = Date.now() - ci_start;
             const drift_details = ci_drift.map((d) => d.kind === 'missing_ci'
@@ -185,7 +178,7 @@ export const task = {
                 success: ci_drift.length === 0,
                 warnings: 0,
                 errors: ci_drift.length,
-                duration: ci_duration,
+                duration: ci_duration
             });
             if (ci_drift.length === 0) {
                 log.info(st('green', `  ✓ ci_reconcile completed in ${ci_duration}ms`));
@@ -204,7 +197,7 @@ export const task = {
                 success: false,
                 warnings: 0,
                 errors: 1,
-                duration: ci_duration,
+                duration: ci_duration
             });
             log.error(st('red', `  ✗ ci_reconcile failed: ${error}`));
         }
@@ -255,5 +248,5 @@ export const task = {
             log.error(st('red', '❌ Validation failed - review the errors above.'));
             throw new Error('Validation failed');
         }
-    },
+    }
 };

package/dist/graph_validation.d.ts

@@ -1,45 +1,35 @@
 /**
- * Shared dependency graph validation logic used across multiple workflows.
+ * Dependency graph validation shared by the publishing plan and the analysis tasks.
  *
- * Consolidates graph building, cycle detection, and publishing order computation
- * that was duplicated in three places: `multi_repo_publisher.ts`, `publishing_plan.ts`,
- * and `gitops_analyze.task.ts`.
+ * Builds the graph, detects cycles by type, and computes the publishing order,
+ * reporting cycles and sort failures in the result rather than throwing, so
+ * each caller decides how to surface them: the plan turns them into errors,
+ * `gitops_analyze` and `gitops_validate` format them.
  *
- * Options pattern supports different behaviors: analyze can tolerate cycles for
- * reporting, while publish must throw on production cycles.
- *
- * See also: `dependency_graph.ts` for core graph data structure and algorithms.
+ * See also: `dependency_graph.ts` for the core graph data structure and algorithms.
  *
  * @module
  */
-import type { Logger } from '@fuzdev/fuz_util/log.ts';
-import { DependencyGraph, DependencyGraphBuilder } from './dependency_graph.js';
+import { DependencyGraph, type DependencyAnalysis } from './dependency_graph.js';
 import { type LocalRepo } from './local_repo.js';
 export interface GraphValidationResult {
     graph: DependencyGraph;
     publishing_order: Array<string>;
     production_cycles: Array<Array<string>>;
     dev_cycles: Array<Array<string>>;
+    /** Why the topological sort failed, when it did; `publishing_order` is then empty. */
     sort_error?: string;
 }
 /**
- * Shared utility for building dependency graph, detecting cycles, and computing publishing order.
- * This centralizes logic that was duplicated across `multi_repo_publisher`, `publishing_plan`, and `gitops_analyze`.
+ * Builds the dependency graph, detects cycles, and computes the publishing order
+ * (prod/peer dependencies only, so dev cycles don't block it).
+ *
+ * Never throws on cycles: a production/peer cycle leaves `publishing_order` empty
+ * and sets `sort_error`, and the caller reports it.
  *
- * @param options.throw_on_prod_cycles - whether to throw an error if production cycles are detected (default: true)
- * @param options.log_cycles - whether to log cycle information (default: true)
- * @param options.log_order - whether to log publishing order (default: true)
- * @returns graph validation result with graph, publishing order, and detected cycles
- * @throws {TaskError} if production cycles detected and `throw_on_prod_cycles` is true
+ * @returns the graph, publishing order, and detected cycles
  */
-export declare const validate_dependency_graph: (repos: Array<LocalRepo>, options?: {
-    log?: Logger;
-    throw_on_prod_cycles?: boolean;
-    log_cycles?: boolean;
-    log_order?: boolean;
-}) => GraphValidationResult;
-/** Cycles, wildcard deps, and missing peers produced by `DependencyGraphBuilder.analyze`. */
-export type DependencyAnalysis = ReturnType<DependencyGraphBuilder['analyze']>;
+export declare const validate_dependency_graph: (repos: Array<LocalRepo>) => GraphValidationResult;
 export interface RepoAnalysis {
     graph: DependencyGraph;
     analysis: DependencyAnalysis;
@@ -49,8 +39,7 @@ export interface RepoAnalysis {
 /**
  * Builds the dependency graph and runs cycle/wildcard analysis, tolerating cycles
  * (reports rather than throws). The shared core of `gitops_analyze` and
- * `gitops_validate`, which format the result themselves — so this stays silent
- * (no `log`) to avoid emitting a redundant "Analyzing dependencies" line.
+ * `gitops_validate`, which format the result themselves.
  */
 export declare const analyze_repos: (repos: Array<LocalRepo>) => RepoAnalysis;
 //# sourceMappingURL=graph_validation.d.ts.map

package/dist/graph_validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_validation.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/graph_validation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAIpD,OAAO,EAAC,eAAe,EAAE,sBAAsB,EAAC,MAAM,uBAAuB,CAAC;AAC9E,OAAO,EAAc,KAAK,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAE5D,MAAM,WAAW,qBAAqB;IACrC,KAAK,EAAE,eAAe,CAAC;IACvB,gBAAgB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAChC,iBAAiB,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;IACxC,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB,GACrC,OAAO,KAAK,CAAC,SAAS,CAAC,EACvB,UAAS;IACR,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;CACf,KACJ,qBA8DF,CAAC;AAEF,6FAA6F;AAC7F,MAAM,MAAM,kBAAkB,GAAG,UAAU,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAC,CAAC;AAE/E,MAAM,WAAW,YAAY;IAC5B,KAAK,EAAE,eAAe,CAAC;IACvB,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,sFAAsF;IACtF,gBAAgB,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;CACvC;AAED;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,KAAK,CAAC,SAAS,CAAC,KAAG,YASvD,CAAC"}
+{"version":3,"file":"graph_validation.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/graph_validation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,eAAe,EAAE,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACjF,OAAO,EAAe,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE9D,MAAM,WAAW,qBAAqB;IACrC,KAAK,EAAE,eAAe,CAAC;IACvB,gBAAgB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAChC,iBAAiB,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;IACxC,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;IACjC,sFAAsF;IACtF,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,GAAI,OAAO,KAAK,CAAC,SAAS,CAAC,KAAG,qBAoBnE,CAAC;AAEF,MAAM,WAAW,YAAY;IAC5B,KAAK,EAAE,eAAe,CAAC;IACvB,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,sFAAsF;IACtF,gBAAgB,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;CACvC;AAED;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,KAAK,CAAC,SAAS,CAAC,KAAG,YAQvD,CAAC"}

package/dist/graph_validation.js

@@ -1,75 +1,36 @@
 /**
- * Shared dependency graph validation logic used across multiple workflows.
+ * Dependency graph validation shared by the publishing plan and the analysis tasks.
  *
- * Consolidates graph building, cycle detection, and publishing order computation
- * that was duplicated in three places: `multi_repo_publisher.ts`, `publishing_plan.ts`,
- * and `gitops_analyze.task.ts`.
+ * Builds the graph, detects cycles by type, and computes the publishing order,
+ * reporting cycles and sort failures in the result rather than throwing, so
+ * each caller decides how to surface them: the plan turns them into errors,
+ * `gitops_analyze` and `gitops_validate` format them.
  *
- * Options pattern supports different behaviors: analyze can tolerate cycles for
- * reporting, while publish must throw on production cycles.
- *
- * See also: `dependency_graph.ts` for core graph data structure and algorithms.
+ * See also: `dependency_graph.ts` for the core graph data structure and algorithms.
  *
  * @module
  */
-import { TaskError } from '@fuzdev/gro';
-import { styleText as st } from 'node:util';
-import { DependencyGraph, DependencyGraphBuilder } from './dependency_graph.js';
+import { DependencyGraph } from './dependency_graph.js';
 import { repo_is_npm } from './local_repo.js';
 /**
- * Shared utility for building dependency graph, detecting cycles, and computing publishing order.
- * This centralizes logic that was duplicated across `multi_repo_publisher`, `publishing_plan`, and `gitops_analyze`.
+ * Builds the dependency graph, detects cycles, and computes the publishing order
+ * (prod/peer dependencies only, so dev cycles don't block it).
+ *
+ * Never throws on cycles: a production/peer cycle leaves `publishing_order` empty
+ * and sets `sort_error`, and the caller reports it.
  *
- * @param options.throw_on_prod_cycles - whether to throw an error if production cycles are detected (default: true)
- * @param options.log_cycles - whether to log cycle information (default: true)
- * @param options.log_order - whether to log publishing order (default: true)
- * @returns graph validation result with graph, publishing order, and detected cycles
- * @throws {TaskError} if production cycles detected and `throw_on_prod_cycles` is true
+ * @returns the graph, publishing order, and detected cycles
  */
-export const validate_dependency_graph = (repos, options = {}) => {
-    const { log, throw_on_prod_cycles = true, log_cycles = true, log_order = true } = options;
-    // Build dependency graph
-    log?.info('📊 Analyzing dependencies...');
-    const builder = new DependencyGraphBuilder();
-    const graph = builder.build_from_repos(repos);
-    // Check for cycles
+export const validate_dependency_graph = (repos) => {
+    const graph = new DependencyGraph(repos);
     const { production_cycles, dev_cycles } = graph.detect_cycles_by_type();
-    // Log production cycles
-    if (production_cycles.length > 0 && log_cycles) {
-        log?.error(st('red', '❌ Production/peer dependency cycles detected:'));
-        for (const cycle of production_cycles) {
-            log?.error(`  ${cycle.join(' → ')}`);
-        }
-        if (throw_on_prod_cycles) {
-            throw new TaskError(`Cannot publish with production/peer dependency cycles. ` +
-                `These must be resolved before publishing.`);
-        }
-    }
-    // Log dev cycles (informational, not an error)
-    if (dev_cycles.length > 0 && log_cycles) {
-        log?.info(st('dim', 'ℹ️  Dev dependency cycles detected (this is normal):'));
-        for (const cycle of dev_cycles) {
-            log?.info(st('dim', `  ${cycle.join(' → ')}`));
-        }
-    }
-    // Compute publishing order
     let publishing_order;
     let sort_error;
     try {
         publishing_order = graph.topological_sort(true); // exclude dev deps to break cycles
-        if (log_order && publishing_order.length > 0) {
-            log?.info(`  Publishing order: ${publishing_order.join(' → ')}`);
-        }
     }
     catch (error) {
-        // Capture the sort error message for callers to report
         sort_error = 'Failed to compute publishing order: ' + error;
-        // If topological sort fails (due to cycles), return empty array
-        // Only throw if production cycles exist AND throw_on_prod_cycles is true
-        if (production_cycles.length > 0 && throw_on_prod_cycles) {
-            throw new TaskError(sort_error);
-        }
-        // Otherwise, return empty publishing order (let caller handle it)
         publishing_order = [];
     }
     return {
@@ -77,22 +38,20 @@ export const validate_dependency_graph = (repos, options = {}) => {
         publishing_order,
         production_cycles,
         dev_cycles,
-        sort_error,
+        sort_error
     };
 };
 /**
  * Builds the dependency graph and runs cycle/wildcard analysis, tolerating cycles
  * (reports rather than throws). The shared core of `gitops_analyze` and
- * `gitops_validate`, which format the result themselves — so this stays silent
- * (no `log`) to avoid emitting a redundant "Analyzing dependencies" line.
+ * `gitops_validate`, which format the result themselves.
  */
 export const analyze_repos = (repos) => {
-    // Only npm packages form the dependency graph; non-npm repos (e.g. cargo) are excluded.
-    const { graph, publishing_order: order } = validate_dependency_graph(repos.filter(repo_is_npm), {
-        throw_on_prod_cycles: false, // report, don't throw
-        log_cycles: false, // callers format their own cycle output
-        log_order: false,
-    });
-    const analysis = new DependencyGraphBuilder().analyze(graph);
-    return { graph, analysis, publishing_order: order.length > 0 ? order : null };
+    // only npm packages form the dependency graph; non-npm repos (e.g. cargo) are excluded
+    const { graph, publishing_order } = validate_dependency_graph(repos.filter(repo_is_npm));
+    return {
+        graph,
+        analysis: graph.analyze(),
+        publishing_order: publishing_order.length > 0 ? publishing_order : null
+    };
 };