@fuzdev/fuz_gitops 0.57.0

package/dist/gitops_publish.task.js

@@ -0,0 +1,178 @@
+import { z } from 'zod';
+import { createInterface } from 'node:readline/promises';
+import { styleText as st } from 'node:util';
+import { get_gitops_ready } from './gitops_task_helpers.js';
+import { publish_repos, } from './multi_repo_publisher.js';
+import { generate_publishing_plan, log_publishing_plan } from './publishing_plan.js';
+import { format_and_output } from './output_helpers.js';
+/** @nodocs */
+export const Args = z.strictObject({
+    path: z
+        .string()
+        .meta({ description: 'path to the gitops config file, absolute or relative to the cwd' })
+        .default('gitops.config.ts'),
+    dir: z
+        .string()
+        .meta({ description: 'path containing the repos, defaults to the parent of the `path` dir' })
+        .optional(),
+    peer_strategy: z
+        .enum(['exact', 'caret', 'tilde'])
+        .meta({ description: 'version strategy for peer dependencies' })
+        .default('caret'),
+    dry_run: z
+        .boolean()
+        .meta({ description: 'perform a dry run without actually publishing' })
+        .default(false),
+    format: z
+        .enum(['stdout', 'json', 'markdown'])
+        .meta({ description: 'output format' })
+        .default('stdout'),
+    deploy: z.boolean().meta({ description: 'deploy all repos after publishing' }).default(false),
+    plan: z.boolean().meta({ description: 'dual of no-plan' }).default(true),
+    'no-plan': z
+        .boolean()
+        .meta({ description: 'skip plan confirmation before publishing' })
+        .default(false),
+    max_wait: z
+        .number()
+        .meta({ description: 'max time to wait for npm propagation in ms' })
+        .default(600000), // 10 minutes
+    skip_install: z
+        .boolean()
+        .meta({ description: 'skip npm install after dependency updates' })
+        .default(false),
+    outfile: z.string().meta({ description: 'write output to file instead of logging' }).optional(),
+    verbose: z.boolean().meta({ description: 'show additional details in plan output' }).default(false),
+});
+/** @nodocs */
+export const task = {
+    summary: 'publish all repos in dependency order',
+    Args,
+    run: async ({ args, log }) => {
+        const { path, dir, peer_strategy, dry_run, format, deploy, plan, max_wait, skip_install, outfile, verbose, } = args;
+        // Load repos
+        const { local_repos: repos } = await get_gitops_ready({
+            path,
+            dir,
+            download: false, // Don't download if missing
+            log,
+        });
+        // Show plan if requested (skip for dry runs)
+        if (plan && !dry_run) {
+            log.info(st('cyan', 'Publishing Plan'));
+            const plan_result = await generate_publishing_plan(repos, { log, verbose });
+            log_publishing_plan(plan_result, log, { verbose });
+            if (plan_result.errors.length > 0) {
+                throw new Error('Cannot proceed with publishing due to errors');
+            }
+            // Ask for confirmation
+            log.info(st('yellow', '⚠️  This will publish the packages shown above.'));
+            process.stdout.write('Continue with publishing? (y/n): ');
+            const confirmed = await prompt_for_confirmation();
+            if (!confirmed) {
+                log.info('Publishing cancelled');
+                process.exit(0);
+            }
+        }
+        // Publishing options
+        const options = {
+            dry_run,
+            update_deps: true, // Always update dependencies
+            version_strategy: peer_strategy,
+            deploy,
+            max_wait,
+            skip_install,
+            log,
+        };
+        // Execute publishing (may throw on fatal errors like circular dependencies)
+        let result;
+        let fatal_error = null;
+        try {
+            result = await publish_repos(repos, options);
+        }
+        catch (error) {
+            // Construct a failure result for fatal errors so output can still be generated
+            fatal_error = error instanceof Error ? error : new Error(String(error));
+            result = {
+                ok: false,
+                published: [],
+                // Note: FATAL_ERROR is a placeholder - only fatal_error.message is displayed in output
+                failed: [{ name: 'FATAL_ERROR', error: fatal_error }],
+                duration: 0,
+            };
+        }
+        // Format and output result (always runs, even on fatal errors)
+        // Note: stdout format is handled by publish_repos function's logging
+        if (format !== 'stdout') {
+            await format_and_output({ result, fatal_error }, create_publish_formatters(), {
+                format,
+                outfile,
+                log,
+            });
+        }
+        // Exit with error if failed
+        if (!result.ok || fatal_error) {
+            process.exit(1);
+        }
+    },
+};
+const create_publish_formatters = () => ({
+    json: (data) => JSON.stringify(data.result, null, 2),
+    markdown: (data) => format_result_markdown(data.result, data.fatal_error),
+    stdout: () => {
+        // stdout format is handled by publish_repos function's logging
+        // This should never be called due to early return in task
+    },
+});
+// Format the publishing result as markdown
+const format_result_markdown = (result, fatal_error) => {
+    const lines = [];
+    lines.push('# Publishing Result');
+    lines.push('');
+    // Show fatal error prominently if present
+    if (fatal_error) {
+        lines.push('## ❌ Fatal Error');
+        lines.push('');
+        lines.push(`**Error**: ${fatal_error.message}`);
+        lines.push('');
+        lines.push('Publishing could not proceed due to the error above.');
+        lines.push('');
+        return lines;
+    }
+    lines.push(`**Status**: ${result.ok ? '✅ Success' : '❌ Failed'}`);
+    lines.push(`**Duration**: ${(result.duration / 1000).toFixed(1)}s`);
+    lines.push(`**Published**: ${result.published.length} packages`);
+    if (result.failed.length > 0) {
+        lines.push(`**Failed**: ${result.failed.length} packages`);
+    }
+    if (result.published.length > 0) {
+        lines.push('');
+        lines.push('## Published Packages');
+        lines.push('');
+        for (const pkg of result.published) {
+            lines.push(`- \`${pkg.name}\`: ${pkg.old_version} → ${pkg.new_version}`);
+        }
+    }
+    if (result.failed.length > 0) {
+        lines.push('');
+        lines.push('## Failed Packages');
+        lines.push('');
+        for (const { name, error } of result.failed) {
+            lines.push(`- \`${name}\`: ${error.message}`);
+        }
+    }
+    return lines;
+};
+/**
+ * Prompts user for y/n confirmation.
+ * Returns true if user enters 'y', false otherwise.
+ */
+const prompt_for_confirmation = async () => {
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const answer = await rl.question('');
+    rl.close();
+    return answer.toLowerCase() === 'y';
+};

package/dist/gitops_sync.task.d.ts

@@ -0,0 +1,18 @@
+import { type Task } from '@ryanatkn/gro';
+import { z } from 'zod';
+/** @nodocs */
+export declare const Args: z.ZodObject<{
+    path: z.ZodDefault<z.ZodString>;
+    dir: z.ZodOptional<z.ZodString>;
+    outdir: z.ZodOptional<z.ZodString>;
+    download: z.ZodDefault<z.ZodBoolean>;
+    check: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type Args = z.infer<typeof Args>;
+/**
+ * This is a task not a `.gen.` file because it makes network calls.
+ *
+ * @nodocs
+ */
+export declare const task: Task<Args>;
+//# sourceMappingURL=gitops_sync.task.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gitops_sync.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gitops_sync.task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,IAAI,EAAC,MAAM,eAAe,CAAC;AACnD,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAetB,cAAc;AACd,eAAO,MAAM,IAAI;;;;;;kBAkBf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC;;;;GAIG;AACH,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CAiE3B,CAAC"}

package/dist/gitops_sync.task.js

@@ -0,0 +1,95 @@
+import { TaskError } from '@ryanatkn/gro';
+import { z } from 'zod';
+import { readFile, writeFile } from 'node:fs/promises';
+import { format_file } from '@ryanatkn/gro/format_file.js';
+import { basename, resolve } from 'node:path';
+import { print_path } from '@ryanatkn/gro/paths.js';
+import { load_from_env } from '@ryanatkn/gro/env.js';
+import { load_package_json } from '@ryanatkn/gro/package_json.js';
+import { existsSync } from 'node:fs';
+import { fetch_repo_data } from './fetch_repo_data.js';
+import { create_fs_fetch_value_cache } from './fs_fetch_value_cache.js';
+import { get_gitops_ready } from './gitops_task_helpers.js';
+// TODO add flag to ignore or invalidate cache -- no-cache? clean?
+/** @nodocs */
+export const Args = z.strictObject({
+    path: z
+        .string()
+        .meta({ description: 'path to the gitops config file, absolute or relative to the cwd' })
+        .default('gitops.config.ts'),
+    dir: z
+        .string()
+        .meta({ description: 'path containing the repos, defaults to the parent of the `path` dir' })
+        .optional(),
+    outdir: z
+        .string()
+        .meta({ description: 'path to the directory for the generated files, defaults to $routes/' })
+        .optional(),
+    download: z.boolean().meta({ description: 'download all missing local repos' }).default(false),
+    check: z
+        .boolean()
+        .meta({ description: 'check repos are ready without fetching remote data' })
+        .default(false),
+});
+/**
+ * This is a task not a `.gen.` file because it makes network calls.
+ *
+ * @nodocs
+ */
+export const task = {
+    Args,
+    summary: 'syncs local repos and generates UI data from repo metadata',
+    run: async ({ args, log, svelte_config, invoke_task }) => {
+        const { path, dir, outdir = svelte_config.routes_path, download, check } = args;
+        const { local_repos } = await get_gitops_ready({ path, dir, download, log });
+        const outfile = resolve(outdir, 'repos.ts');
+        // This searches the parent directory for the env var, so we don't use SvelteKit's $env imports
+        const token = load_from_env('SECRET_GITHUB_API_TOKEN');
+        if (!token) {
+            throw new TaskError('the env var SECRET_GITHUB_API_TOKEN was not found');
+        }
+        // Exit early if only checking repo readiness
+        if (check) {
+            log.info('repos are ready');
+            return;
+        }
+        const cache = await create_fs_fetch_value_cache('repos');
+        log.info('fetching remote repo data');
+        const repos_json = await fetch_repo_data(local_repos, token, cache.data, log);
+        // TODO should package_json be provided in the Gro task/gen contexts? check if it's always loaded
+        const package_json = await load_package_json();
+        const repo_specifier = package_json.name === '@fuzdev/fuz_gitops'
+            ? '$lib/repo.svelte.js'
+            : '@fuzdev/fuz_gitops/repo.svelte.js';
+        log.info('generating ' + outfile);
+        // TODO the `basename` is used here because we don't have an `origin_id` like with gen,
+        // and this file gets re-exported,
+        // and we don't want the file to change based on where it's being generated,
+        // because for example linking to a local package would change the contents
+        const contents = `
+			// generated by ${basename(import.meta.filename)} !! do not edit directly or risk lost data
+			
+			import type {RepoJson} from '${repo_specifier}';
+
+			export const repos_json: Array<RepoJson> = ${JSON.stringify(repos_json, null, '\t')};
+		`;
+        // TODO think about possibly using the `gen` functionality in this task, not sure what the API design could look like
+        const formatted = await format_file(contents, { filepath: outfile });
+        const existing = existsSync(outfile) ? await readFile(outfile, 'utf8') : '';
+        if (existing === formatted) {
+            log.info(`no changes to ${print_path(outfile)}`);
+        }
+        else {
+            log.info(`writing changes to ${print_path(outfile)}`);
+            await writeFile(outfile, formatted);
+            await invoke_task('gen');
+        }
+        const changed = await cache.save();
+        if (changed) {
+            log.info('repos cache updated');
+        }
+        else {
+            log.info('repos cache did not change');
+        }
+    },
+};

package/dist/gitops_task_helpers.d.ts

@@ -0,0 +1,63 @@
+/**
+ * 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
+ *
+ * Used by: `gitops_sync.task.ts`, `gitops_analyze.task.ts`, `gitops_plan.task.ts`,
+ * `gitops_publish.task.ts`, and `gitops_validate.task.ts`.
+ *
+ * Accepts `git_ops` and `npm_ops` parameters to support testing via operations pattern
+ * (see `operations.ts` for dependency injection details).
+ */
+import type { Logger } from '@fuzdev/fuz_util/log.js';
+import { type GitopsConfig } from './gitops_config.js';
+import { type LocalRepo } from './local_repo.js';
+import type { GitOperations, NpmOperations } from './operations.js';
+export interface GetGitopsReadyOptions {
+    path: string;
+    dir?: string;
+    download: boolean;
+    log?: Logger;
+    git_ops?: GitOperations;
+    npm_ops?: NpmOperations;
+}
+/**
+ * Central initialization function for all gitops tasks.
+ *
+ * Initialization sequence:
+ * 1. Loads and normalizes config from `gitops.config.ts`
+ * 2. Resolves local repo paths (creates missing with `--download`)
+ * 3. Switches branches and pulls latest changes
+ * 4. Auto-installs deps if package.json changed during pull
+ *
+ * Priority for path resolution:
+ * - `dir` argument (explicit override)
+ * - Config `repos_dir` setting
+ * - `DEFAULT_REPOS_DIR` constant
+ *
+ * @param options.git_ops for testing (defaults to real git operations)
+ * @param options.npm_ops for testing (defaults to real npm operations)
+ * @returns initialized config and fully loaded repos ready for operations
+ * @throws {TaskError} if config loading or repo resolution fails
+ */
+export declare const get_gitops_ready: (options: GetGitopsReadyOptions) => Promise<{
+    config_path: string;
+    repos_dir: string;
+    gitops_config: GitopsConfig;
+    local_repos: Array<LocalRepo>;
+}>;
+export interface ResolveGitopsPathsOptions {
+    path: string;
+    dir?: string;
+    config_repos_dir?: string;
+}
+export declare const resolve_gitops_paths: (options: ResolveGitopsPathsOptions) => {
+    config_path: string;
+    repos_dir: string;
+};
+export declare const import_gitops_config: (config_path: string) => Promise<GitopsConfig>;
+//# sourceMappingURL=gitops_task_helpers.d.ts.map

package/dist/gitops_task_helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gitops_task_helpers.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gitops_task_helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAEpD,OAAO,EAAqB,KAAK,YAAY,EAAC,MAAM,oBAAoB,CAAC;AACzE,OAAO,EAAuC,KAAK,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAGrF,OAAO,KAAK,EAAC,aAAa,EAAE,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAElE,MAAM,WAAW,qBAAqB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,OAAO,CAAC,EAAE,aAAa,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,gBAAgB,GAC5B,SAAS,qBAAqB,KAC5B,OAAO,CAAC;IACV,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,YAAY,CAAC;IAC5B,WAAW,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;CAC9B,CA8BA,CAAC;AAEF,MAAM,WAAW,yBAAyB;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,eAAO,MAAM,oBAAoB,GAChC,SAAS,yBAAyB,KAChC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAczC,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAU,aAAa,MAAM,KAAG,OAAO,CAAC,YAAY,CAMpF,CAAC"}

package/dist/gitops_task_helpers.js

@@ -0,0 +1,84 @@
+/**
+ * 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
+ *
+ * Used by: `gitops_sync.task.ts`, `gitops_analyze.task.ts`, `gitops_plan.task.ts`,
+ * `gitops_publish.task.ts`, and `gitops_validate.task.ts`.
+ *
+ * Accepts `git_ops` and `npm_ops` parameters to support testing via operations pattern
+ * (see `operations.ts` for dependency injection details).
+ */
+import { TaskError } from '@ryanatkn/gro';
+import { styleText as st } from 'node:util';
+import { resolve, dirname } from 'node:path';
+import { print_path } from '@ryanatkn/gro/paths.js';
+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';
+/**
+ * Central initialization function for all gitops tasks.
+ *
+ * Initialization sequence:
+ * 1. Loads and normalizes config from `gitops.config.ts`
+ * 2. Resolves local repo paths (creates missing with `--download`)
+ * 3. Switches branches and pulls latest changes
+ * 4. Auto-installs deps if package.json changed during pull
+ *
+ * Priority for path resolution:
+ * - `dir` argument (explicit override)
+ * - Config `repos_dir` setting
+ * - `DEFAULT_REPOS_DIR` constant
+ *
+ * @param options.git_ops for testing (defaults to real git operations)
+ * @param options.npm_ops for testing (defaults to real npm operations)
+ * @returns initialized config and fully loaded repos ready for operations
+ * @throws {TaskError} if config loading or repo resolution fails
+ */
+export const get_gitops_ready = async (options) => {
+    const { path, dir, download, log, git_ops, npm_ops } = options;
+    const config_path = resolve(path);
+    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({
+        path,
+        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 });
+    return { config_path, repos_dir, gitops_config, local_repos };
+};
+export const resolve_gitops_paths = (options) => {
+    const { path, dir, config_repos_dir } = options;
+    const config_path = resolve(path);
+    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 };
+};
+export const import_gitops_config = async (config_path) => {
+    const gitops_config = await load_gitops_config(config_path);
+    if (!gitops_config) {
+        throw new TaskError(st('red', `No gitops config found at ${print_path(config_path)}`));
+    }
+    return gitops_config;
+};

package/dist/gitops_validate.task.d.ts

@@ -0,0 +1,12 @@
+import type { Task } from '@ryanatkn/gro';
+import { z } from 'zod';
+/** @nodocs */
+export declare const Args: z.ZodObject<{
+    path: z.ZodDefault<z.ZodString>;
+    dir: z.ZodOptional<z.ZodString>;
+    verbose: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type Args = z.infer<typeof Args>;
+/** @nodocs */
+export declare const task: Task<Args>;
+//# sourceMappingURL=gitops_validate.task.d.ts.map

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

@@ -0,0 +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,eAAe,CAAC;AACxC,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAUtB,cAAc;AACd,eAAO,MAAM,IAAI;;;;kBAUf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,cAAc;AACd,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CA6N3B,CAAC"}

package/dist/gitops_validate.task.js

@@ -0,0 +1,210 @@
+import { z } from 'zod';
+import { styleText as st } from 'node:util';
+import { get_gitops_ready } from './gitops_task_helpers.js';
+import { validate_dependency_graph } from './graph_validation.js';
+import { DependencyGraphBuilder } from './dependency_graph.js';
+import { generate_publishing_plan, log_publishing_plan } from './publishing_plan.js';
+import { publish_repos } from './multi_repo_publisher.js';
+import { log_dependency_analysis } from './log_helpers.js';
+/** @nodocs */
+export const Args = z.strictObject({
+    path: z
+        .string()
+        .meta({ description: 'path to the gitops config file, absolute or relative to the cwd' })
+        .default('gitops.config.ts'),
+    dir: z
+        .string()
+        .meta({ description: 'path containing the repos, defaults to the parent of the `path` dir' })
+        .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 { path, dir, 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)
+        log.info(st('dim', 'Loading repositories...'));
+        const { local_repos } = await get_gitops_ready({ path, dir, download: false, log });
+        log.info(st('dim', `   Found ${local_repos.length} local repos`));
+        // 1. Run gitops_analyze
+        log.info(st('yellow', 'Running gitops_analyze...'));
+        const analyze_start = Date.now();
+        try {
+            // Build dependency graph and validate (but don't throw on cycles for analyze)
+            const { graph } = validate_dependency_graph(local_repos, {
+                throw_on_prod_cycles: false, // Analyze should report, not throw
+                log_cycles: false, // We'll collect our own statistics
+                log_order: false,
+            });
+            // Perform additional analysis
+            const builder = new DependencyGraphBuilder();
+            const analysis = builder.analyze(graph);
+            const analyze_duration = Date.now() - analyze_start;
+            // Collect warnings, info, and errors
+            const warning_details = [];
+            const info_details = [];
+            if (analysis.wildcard_deps.length > 0) {
+                warning_details.push('wildcard dependencies');
+            }
+            if (analysis.dev_cycles.length > 0) {
+                info_details.push('dev circular dependencies');
+            }
+            const warnings = warning_details.length;
+            const errors = analysis.production_cycles.length > 0 ? 1 : 0;
+            results.push({
+                command: 'gitops_analyze',
+                success: true,
+                warnings,
+                errors,
+                duration: analyze_duration,
+                warning_details,
+                info_details,
+                analysis,
+            });
+            log.info(st('green', `  ✓ gitops_analyze completed in ${analyze_duration}ms`));
+            // Print detailed analysis
+            log_dependency_analysis(analysis, log, '  ');
+            if (errors > 0) {
+                log.error(st('red', `  ❌ Found ${errors} error(s)`));
+            }
+        }
+        catch (error) {
+            const analyze_duration = Date.now() - analyze_start;
+            results.push({
+                command: 'gitops_analyze',
+                success: false,
+                warnings: 0,
+                errors: 1,
+                duration: analyze_duration,
+            });
+            log.error(st('red', `  ✗ gitops_analyze failed: ${error}`));
+        }
+        // 2. Run gitops_plan
+        log.info(st('yellow', 'Running gitops_plan...'));
+        const plan_start = Date.now();
+        try {
+            const plan = await generate_publishing_plan(local_repos, { log: undefined, verbose });
+            const plan_duration = Date.now() - plan_start;
+            const warnings = plan.warnings.length;
+            const errors = plan.errors.length;
+            results.push({
+                command: 'gitops_plan',
+                success: true,
+                warnings,
+                errors,
+                duration: plan_duration,
+            });
+            log.info(st('green', `  ✓ gitops_plan completed in ${plan_duration}ms`));
+            if (verbose) {
+                log_publishing_plan(plan, log, { verbose });
+            }
+            if (warnings > 0) {
+                log.warn(st('yellow', `  ⚠️  Found ${warnings} warning(s)`));
+            }
+            if (errors > 0) {
+                log.error(st('red', `  ❌ Found ${errors} error(s)`));
+            }
+        }
+        catch (error) {
+            const plan_duration = Date.now() - plan_start;
+            results.push({
+                command: 'gitops_plan',
+                success: false,
+                warnings: 0,
+                errors: 1,
+                duration: plan_duration,
+            });
+            log.error(st('red', `  ✗ gitops_plan failed: ${error}`));
+        }
+        // 3. Run gitops_publish --dry_run
+        log.info(st('yellow', 'Running gitops_publish --dry_run...'));
+        const dry_start = Date.now();
+        try {
+            const options = {
+                dry_run: true,
+                update_deps: true,
+                log: undefined, // Silent for validation
+            };
+            const result = await publish_repos(local_repos, options);
+            const dry_duration = Date.now() - dry_start;
+            // Dry run doesn't have warnings/errors in the same format
+            // We'll just check if it succeeded
+            const errors = result.ok ? 0 : result.failed.length;
+            results.push({
+                command: 'gitops_publish --dry_run',
+                success: result.ok,
+                warnings: 0,
+                errors,
+                duration: dry_duration,
+            });
+            log.info(st('green', `  ✓ gitops_publish --dry_run completed in ${dry_duration}ms`));
+            if (errors > 0) {
+                log.error(st('red', `  ❌ Found ${errors} error(s)`));
+            }
+        }
+        catch (error) {
+            const dry_duration = Date.now() - dry_start;
+            results.push({
+                command: 'gitops_publish --dry_run',
+                success: false,
+                warnings: 0,
+                errors: 1,
+                duration: dry_duration,
+            });
+            log.error(st('red', `  ✗ gitops_publish --dry_run failed: ${error}`));
+        }
+        // Summary
+        const total_duration = Date.now() - start_time;
+        const all_success = results.every((r) => r.success);
+        const total_warnings = results.reduce((sum, r) => sum + r.warnings, 0);
+        const total_errors = results.reduce((sum, r) => sum + r.errors, 0);
+        log.info(st('cyan', 'Validation Summary'));
+        log.info(`  Total duration: ${(total_duration / 1000).toFixed(1)}s`);
+        log.info(`  Commands run: ${results.length}`);
+        log.info(`  Commands succeeded: ${results.filter((r) => r.success).length}`);
+        log.info(`  Commands failed: ${results.filter((r) => !r.success).length}`);
+        log.info(`  Total warnings: ${total_warnings}`);
+        log.info(`  Total errors: ${total_errors}`);
+        // Individual command results
+        log.info(st('cyan', 'Command Results:'));
+        for (const result of results) {
+            const status_icon = result.success ? '✓' : '✗';
+            const status_color = result.success ? 'green' : 'red';
+            const duration = (result.duration / 1000).toFixed(1);
+            log.info(st(status_color, `  ${status_icon} ${result.command} (${duration}s)`));
+            if (result.warnings > 0) {
+                const details = result.warning_details?.length
+                    ? ` (${result.warning_details.join(', ')})`
+                    : '';
+                log.info(st('yellow', `    ⚠️  ${result.warnings} warning(s)${details}`));
+            }
+            if (result.info_details && result.info_details.length > 0) {
+                log.info(st('dim', `    ℹ️  ${result.info_details.join(', ')}`));
+            }
+            if (result.errors > 0) {
+                log.info(st('red', `    ❌ ${result.errors} error(s)`));
+            }
+        }
+        // Final verdict
+        log.info('');
+        if (all_success && total_errors === 0) {
+            log.info(st('green', '✓ All validation checks passed'));
+            if (total_warnings > 0) {
+                log.warn(st('yellow', `⚠️  Note: ${total_warnings} warning(s) found - review output above.`));
+            }
+        }
+        else if (all_success && total_errors > 0) {
+            log.warn(st('yellow', '⚠️  Validation completed but found errors - review output above.'));
+        }
+        else {
+            log.error(st('red', '❌ Validation failed - one or more commands did not complete.'));
+            throw new Error('Validation failed');
+        }
+    },
+};