@signstack/cli 0.1.1

package/dist/apps/signstack-cli/src/commands/test.js

@@ -0,0 +1,25 @@
+import boxen from 'boxen';
+import chalk from 'chalk';
+import { Command } from '@oclif/core';
+export default class Test extends Command {
+    static description = 'Test the CLI installation';
+    static examples = ['<%= config.bin %> test'];
+    async run() {
+        await this.parse(Test);
+        const message = [
+            chalk.bold.cyan('Modern Sign CLI'),
+            '',
+            `${chalk.green('✓')} CLI is installed and working correctly`,
+            '',
+            chalk.dim(`Version: ${this.config.version}`),
+            chalk.dim(`Node: ${process.version}`),
+            chalk.dim(`Platform: ${process.platform}-${process.arch}`),
+        ].join('\n');
+        this.log(boxen(message, {
+            padding: 1,
+            borderColor: 'cyan',
+            borderStyle: 'round',
+        }));
+    }
+}
+//# sourceMappingURL=test.js.map

package/dist/apps/signstack-cli/src/commands/test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.js","sourceRoot":"","sources":["../../../../../src/commands/test.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtC,MAAM,CAAC,OAAO,OAAO,IAAK,SAAQ,OAAO;IACvC,MAAM,CAAU,WAAW,GAAG,2BAA2B,CAAC;IAE1D,MAAM,CAAU,QAAQ,GAAG,CAAC,wBAAwB,CAAC,CAAC;IAE/C,KAAK,CAAC,GAAG;QACd,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAEvB,MAAM,OAAO,GAAG;YACd,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC;YAClC,EAAE;YACF,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,yCAAyC;YAC5D,EAAE;YACF,KAAK,CAAC,GAAG,CAAC,YAAY,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YAC5C,KAAK,CAAC,GAAG,CAAC,SAAS,OAAO,CAAC,OAAO,EAAE,CAAC;YACrC,KAAK,CAAC,GAAG,CAAC,aAAa,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;SAC3D,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAEb,IAAI,CAAC,GAAG,CACN,KAAK,CAAC,OAAO,EAAE;YACb,OAAO,EAAE,CAAC;YACV,WAAW,EAAE,MAAM;YACnB,WAAW,EAAE,OAAO;SACrB,CAAC,CACH,CAAC;IACJ,CAAC"}

package/dist/apps/signstack-cli/src/commands/validate.d.ts

@@ -0,0 +1,59 @@
+import { AuthenticatedCommand } from '../lib/base-command.js';
+export default class Validate extends AuthenticatedCommand {
+    static description: string;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    static args: {
+        resource: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        kind: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        dir: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'no-deps': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'no-remote': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'api-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private runSingle;
+    /**
+     * Resolve the resource kind — from --kind flag or inferred from YAML files.
+     */
+    private resolveResourceKind;
+    /**
+     * Validate that all dependencies exist — locally in the graph or remotely on the API.
+     * Dependencies found on the API are reported as warnings (not errors).
+     */
+    private validateDependencies;
+    /**
+     * Validate that spec.file references exist (scoped to given IDs)
+     */
+    private validateFileReferences;
+    /**
+     * Validate that versioned resources do not depend on draft resources.
+     */
+    private validateDraftDependencies;
+    /**
+     * Print the dependency graph for the subtree
+     */
+    private printDependencyGraph;
+    /**
+     * Print cycle detection errors
+     */
+    private printCycleErrors;
+    /**
+     * Print validation result for a single document
+     */
+    private printResult;
+    /**
+     * Print resource validation summary
+     */
+    private printResourceSummary;
+    /**
+     * Print simple summary (used for early exit on parse errors)
+     */
+    private printSummary;
+}

package/dist/apps/signstack-cli/src/commands/validate.js

@@ -0,0 +1,558 @@
+import { Args, Flags } from '@oclif/core';
+import { existsSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import pc from 'picocolors';
+import { DependencyGraph, } from '@signstack/base';
+import { AuthenticatedCommand } from '../lib/base-command.js';
+import { promptResourceSelection } from '../lib/resource-scanner.js';
+import { getSchemaValidator } from '../lib/schema-validator.js';
+import { SCHEMA_KIND_TO_BACKEND, KIND_TO_ENDPOINT, } from '../lib/resource-puller.js';
+import { discoverYamlFiles, parseAllYamlFiles, SEPARATOR_LENGTH, } from '../lib/yaml-document-parser.js';
+import { CLI_FLAG_TO_SCHEMA_KIND, getAvailableSchemaKinds, SchemaKind, SCHEMA_FLAG_OPTIONS, ValidationErrorKeyword, } from '../types/schema.types.js';
+export default class Validate extends AuthenticatedCommand {
+    static description = 'Validate resources and their dependencies against SignStack schemas with dependency analysis.';
+    static examples = [
+        {
+            command: '<%= config.bin %> validate my_blueprint@1.0.0 --kind blueprint',
+            description: 'Validate a blueprint and all its dependencies in the current directory',
+        },
+        {
+            command: '<%= config.bin %> validate my_template@1.0.0 -d ./my-project',
+            description: 'Validate a template (kind inferred) from a specific directory',
+        },
+        {
+            command: '<%= config.bin %> validate my_blueprint@1.0.0 --kind blueprint --verbose',
+            description: 'Validate with detailed output including dependency graph',
+        },
+        {
+            command: '<%= config.bin %> validate my_blueprint@1.0.0 --kind blueprint --no-deps',
+            description: 'Validate without dependency ordering (faster)',
+        },
+    ];
+    static args = {
+        resource: Args.string({
+            description: 'Resource reference as key@version (e.g., my_blueprint@1.0.0)',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        kind: Flags.string({
+            char: 'k',
+            description: 'Resource kind (optional — inferred from YAML files if omitted)',
+            required: false,
+            options: SCHEMA_FLAG_OPTIONS,
+        }),
+        dir: Flags.string({
+            char: 'd',
+            description: 'Directory containing YAML resource files. The specified resource and all its dependencies must be present in this directory.',
+            default: '.',
+        }),
+        verbose: Flags.boolean({
+            char: 'v',
+            description: 'Show detailed validation output',
+            default: false,
+        }),
+        'no-deps': Flags.boolean({
+            description: 'Skip dependency ordering and validation',
+            default: false,
+        }),
+        'no-remote': Flags.boolean({
+            description: 'Skip checking missing dependencies against the API (local only)',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output in JSON format',
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Validate);
+        return this.runSingle(args, flags);
+    }
+    // ─── Single resource mode ───────────────────────────────────
+    async runSingle(args, flags) {
+        // Step 1: Resolve directory
+        const folderPath = resolve(flags.dir);
+        if (!existsSync(folderPath)) {
+            this.error(`Directory not found: ${folderPath}`, { exit: 1 });
+        }
+        // Step 2: Parse resource reference or prompt for selection
+        let ref;
+        let selectedKind;
+        if (args.resource) {
+            ref = this.sanitizeInput(args.resource);
+        }
+        else {
+            if (flags.json) {
+                this.error('Provide a resource reference when using --json.', {
+                    exit: 1,
+                    suggestions: [
+                        'signstack validate my_blueprint@1.0.0 --json',
+                    ],
+                });
+            }
+            const selected = await promptResourceSelection(folderPath, getAvailableSchemaKinds(), 'Select a resource to validate');
+            if (!selected) {
+                this.error('No resources found in the specified directory.', {
+                    exit: 1,
+                    suggestions: [
+                        'Ensure the directory contains valid SignStack YAML files',
+                        'Use -d to specify a different directory',
+                    ],
+                });
+            }
+            ref = selected.ref;
+            selectedKind = selected.kind;
+        }
+        const { key, version: parsedVersion } = this.parseResourceRef(ref, 'resource', true);
+        const version = parsedVersion;
+        // ── Step 3: Discover and parse YAML files ────────────────────
+        const filePaths = await discoverYamlFiles(folderPath);
+        if (filePaths.length === 0) {
+            this.error('No YAML files found in the specified directory', {
+                exit: 1,
+                suggestions: ['Ensure the directory contains .yaml or .yml files'],
+            });
+        }
+        if (flags.verbose) {
+            this.log(pc.dim(`\nFound ${filePaths.length} YAML file(s) in ${folderPath}\n`));
+        }
+        const { documents, parseErrors } = parseAllYamlFiles(filePaths);
+        if (documents.length === 0 && parseErrors.length > 0) {
+            this.printSummary({
+                total: parseErrors.length,
+                passed: 0,
+                failed: parseErrors.length,
+                results: parseErrors,
+                hasCycles: false,
+            });
+            this.exit(1);
+        }
+        // ── Step 4: Resolve resource kind ────────────────────────────
+        const schemaKind = selectedKind ?? this.resolveResourceKind(flags.kind, key, version, documents);
+        // ── Step 5: Build dependency graph and extract subtree ────────
+        const graph = DependencyGraph.fromDocuments(documents);
+        const rootId = DependencyGraph.createId(schemaKind, key, version);
+        if (!graph.nodes.has(rootId)) {
+            this.error(`Resource ${schemaKind}:${key}@${version} not found in ${folderPath}.`, {
+                exit: 1,
+                suggestions: [
+                    'Ensure the YAML file for this resource is present in the directory',
+                    `Check that metadata.key is "${key}" and metadata.version is "${version}"`,
+                ],
+            });
+        }
+        const subtreeIds = graph.getTransitiveDependencies(rootId);
+        this.log(pc.cyan(`\nValidating ${schemaKind}:${key}@${version} and ${subtreeIds.size - 1} dependenc${subtreeIds.size - 1 === 1 ? 'y' : 'ies'}\n`));
+        // Display dependency graph
+        this.printDependencyGraph(graph, subtreeIds, flags.verbose);
+        // ── Step 6: Determine validation order ───────────────────────
+        let filteredOrder;
+        let sortResult;
+        if (flags['no-deps']) {
+            filteredOrder = Array.from(subtreeIds);
+        }
+        else {
+            sortResult = graph.topologicalSort();
+            filteredOrder = sortResult.order.filter((id) => subtreeIds.has(id));
+            // Add any subtree nodes not in sort result (cycle members)
+            const orderedSet = new Set(filteredOrder);
+            for (const id of subtreeIds) {
+                if (!orderedSet.has(id) && graph.nodes.has(id)) {
+                    filteredOrder.push(id);
+                }
+            }
+        }
+        // ── Step 7: Run validations ──────────────────────────────────
+        const validator = getSchemaValidator();
+        const results = [...parseErrors];
+        // Schema validation in topological order
+        for (const resourceId of filteredOrder) {
+            const doc = graph.nodes.get(resourceId);
+            if (!doc)
+                continue;
+            const result = validator.validate(doc.content, doc.filePath, doc.kind, doc.documentIndex);
+            results.push(result);
+            this.printResult(result, flags.verbose);
+        }
+        // Dependency and file reference validation (if not skipped)
+        if (!flags['no-deps']) {
+            const depErrors = await this.validateDependencies(graph, subtreeIds, flags.verbose, flags['no-remote']);
+            results.push(...depErrors);
+            const fileRefErrors = this.validateFileReferences(graph, subtreeIds, flags.verbose);
+            results.push(...fileRefErrors);
+            const draftErrors = this.validateDraftDependencies(graph, subtreeIds, flags.verbose);
+            results.push(...draftErrors);
+        }
+        // ── Step 8: Build and print summary ──────────────────────────
+        const hasCycles = sortResult ? !sortResult.isAcyclic : false;
+        // Only report cycles that involve subtree resources
+        const relevantCycles = sortResult?.cycles?.filter((cycle) => cycle.some((id) => subtreeIds.has(id)));
+        const summary = {
+            total: results.length,
+            passed: results.filter((r) => r.valid).length,
+            failed: results.filter((r) => !r.valid).length,
+            results,
+            graphStats: graph.getStats(),
+            hasCycles: (relevantCycles?.length ?? 0) > 0,
+            cycles: relevantCycles,
+        };
+        if (flags.json) {
+            this.log(JSON.stringify({
+                total: summary.total,
+                passed: summary.passed,
+                failed: summary.failed,
+                hasCycles: summary.hasCycles,
+                cycles: summary.cycles,
+                graphStats: summary.graphStats,
+                results: summary.results.map((r) => ({
+                    valid: r.valid,
+                    filePath: r.filePath,
+                    schemaKind: r.schemaKind,
+                    resourceKey: r.resourceKey,
+                    resourceVersion: r.resourceVersion,
+                    errors: r.errors,
+                })),
+            }));
+            if (summary.failed > 0 || summary.hasCycles)
+                this.exit(1);
+            return;
+        }
+        if (summary.hasCycles && summary.cycles && summary.cycles.length > 0) {
+            this.printCycleErrors(summary.cycles);
+        }
+        this.printResourceSummary(summary, flags.verbose);
+        if (summary.failed > 0 || summary.hasCycles) {
+            this.exit(1);
+        }
+    }
+    // ─── Kind Resolution ─────────────────────────────────────────
+    /**
+     * Resolve the resource kind — from --kind flag or inferred from YAML files.
+     */
+    resolveResourceKind(kindFlag, key, version, documents) {
+        if (kindFlag) {
+            return CLI_FLAG_TO_SCHEMA_KIND[kindFlag];
+        }
+        const matches = documents.filter((doc) => doc.key === key && doc.version === version);
+        if (matches.length === 0) {
+            this.error(`No resource with key "${key}" and version "${version}" found in the directory.`, {
+                exit: 1,
+                suggestions: [
+                    'Check that your YAML files contain a resource with the specified key and version',
+                    'Use --kind to specify the resource kind explicitly',
+                ],
+            });
+        }
+        if (matches.length === 1) {
+            this.log(pc.dim(`Inferred kind: ${matches[0].kind} (from ${matches[0].filePath})\n`));
+            return matches[0].kind;
+        }
+        const kindList = matches.map((m) => m.kind).join(', ');
+        this.error(`Multiple resources found for ${key}@${version}: ${kindList}. Use --kind to disambiguate.`, {
+            exit: 1,
+            suggestions: matches.map((m) => `validate ${key}@${version} --kind ${Object.entries(CLI_FLAG_TO_SCHEMA_KIND).find(([, v]) => v === m.kind)?.[0] ?? m.kind.toLowerCase()}`),
+        });
+    }
+    // ─── Dependency & File Ref Validation ────────────────────────
+    /**
+     * Validate that all dependencies exist — locally in the graph or remotely on the API.
+     * Dependencies found on the API are reported as warnings (not errors).
+     */
+    async validateDependencies(graph, scopeIds, verbose, noRemote = false) {
+        const errors = [];
+        const missing = graph.getMissingDependencies();
+        // Collect all missing deps to check against API in batch
+        const missingToCheck = [];
+        for (const [sourceId, missingDeps] of missing) {
+            if (!scopeIds.has(sourceId))
+                continue;
+            const sourceDoc = graph.nodes.get(sourceId);
+            if (!sourceDoc)
+                continue;
+            for (const missingId of missingDeps) {
+                const { kind, key, version } = DependencyGraph.parseId(missingId);
+                const ref = sourceDoc.references.find((r) => r.key === key && r.version === version && r.targetKind === kind);
+                missingToCheck.push({
+                    sourceDoc,
+                    missingId,
+                    kind,
+                    key,
+                    version,
+                    sourcePath: ref?.sourcePath ?? '/',
+                });
+            }
+        }
+        if (missingToCheck.length === 0)
+            return errors;
+        if (noRemote) {
+            // --no-remote: all missing are errors without API check
+            for (const dep of missingToCheck) {
+                const error = {
+                    valid: false,
+                    errors: [
+                        {
+                            path: dep.sourcePath,
+                            message: `Referenced ${dep.kind} '${dep.key}@${dep.version}' not found locally`,
+                            keyword: ValidationErrorKeyword.DependencyMissing,
+                        },
+                    ],
+                    schemaKind: dep.sourceDoc.kind,
+                    filePath: dep.sourceDoc.filePath,
+                    documentIndex: dep.sourceDoc.documentIndex,
+                    resourceKey: dep.sourceDoc.key,
+                    resourceVersion: dep.sourceDoc.version,
+                };
+                errors.push(error);
+                this.printResult(error, verbose);
+            }
+            return errors;
+        }
+        // Check each missing dep against the API
+        const remoteResults = await Promise.all(missingToCheck.map(async (dep) => {
+            const backendKind = SCHEMA_KIND_TO_BACKEND[dep.kind];
+            if (!backendKind)
+                return { ...dep, existsRemotely: false };
+            try {
+                const endpoint = KIND_TO_ENDPOINT[backendKind];
+                await this.apiClient.get(`/v1/orgs/${this.cliConfig.orgId}/namespaces/${this.cliConfig.namespaceKey}/${endpoint}/${encodeURIComponent(dep.key)}?version=${encodeURIComponent(dep.version)}`);
+                return { ...dep, existsRemotely: true };
+            }
+            catch {
+                return { ...dep, existsRemotely: false };
+            }
+        }));
+        for (const dep of remoteResults) {
+            if (dep.existsRemotely) {
+                // Dependency exists on the API — informational only
+                if (verbose) {
+                    this.log(pc.dim(`  ${dep.kind}:${dep.key}@${dep.version} — not local, found on API`));
+                }
+            }
+            else {
+                // Dependency missing both locally and remotely — error
+                const error = {
+                    valid: false,
+                    errors: [
+                        {
+                            path: dep.sourcePath,
+                            message: `Referenced ${dep.kind} '${dep.key}@${dep.version}' not found locally or on the API`,
+                            keyword: ValidationErrorKeyword.DependencyMissing,
+                        },
+                    ],
+                    schemaKind: dep.sourceDoc.kind,
+                    filePath: dep.sourceDoc.filePath,
+                    documentIndex: dep.sourceDoc.documentIndex,
+                    resourceKey: dep.sourceDoc.key,
+                    resourceVersion: dep.sourceDoc.version,
+                };
+                errors.push(error);
+                this.printResult(error, verbose);
+            }
+        }
+        return errors;
+    }
+    /**
+     * Validate that spec.file references exist (scoped to given IDs)
+     */
+    validateFileReferences(graph, scopeIds, verbose) {
+        const errors = [];
+        for (const id of scopeIds) {
+            const doc = graph.nodes.get(id);
+            if (!doc)
+                continue;
+            if (doc.kind !== SchemaKind.Schema && doc.kind !== SchemaKind.Asset) {
+                continue;
+            }
+            const spec = doc.content['spec'];
+            const filePath = spec?.['file'];
+            if (!filePath)
+                continue;
+            const baseDir = dirname(doc.filePath);
+            const resolvedPath = resolve(baseDir, filePath);
+            if (!existsSync(resolvedPath)) {
+                const error = {
+                    valid: false,
+                    errors: [
+                        {
+                            path: 'spec.file',
+                            message: `Referenced file '${filePath}' not found (resolved: ${resolvedPath})`,
+                            keyword: ValidationErrorKeyword.FileReferenceMissing,
+                        },
+                    ],
+                    schemaKind: doc.kind,
+                    filePath: doc.filePath,
+                    documentIndex: doc.documentIndex,
+                    resourceKey: doc.key,
+                    resourceVersion: doc.version,
+                };
+                errors.push(error);
+                this.printResult(error, verbose);
+            }
+        }
+        return errors;
+    }
+    /**
+     * Validate that versioned resources do not depend on draft resources.
+     */
+    validateDraftDependencies(graph, scopeIds, verbose) {
+        const errors = [];
+        const draftErrors = graph.validateDraftDependencies();
+        for (const err of draftErrors) {
+            if (!scopeIds.has(err.sourceId))
+                continue;
+            const sourceDoc = graph.nodes.get(err.sourceId);
+            if (!sourceDoc)
+                continue;
+            const error = {
+                valid: false,
+                errors: [
+                    {
+                        path: '/',
+                        message: err.message,
+                        keyword: ValidationErrorKeyword.DraftDependency,
+                    },
+                ],
+                schemaKind: sourceDoc.kind,
+                filePath: sourceDoc.filePath,
+                documentIndex: sourceDoc.documentIndex,
+                resourceKey: sourceDoc.key,
+                resourceVersion: sourceDoc.version,
+            };
+            errors.push(error);
+            this.printResult(error, verbose);
+        }
+        return errors;
+    }
+    // ─── Display Helpers ─────────────────────────────────────────
+    /**
+     * Print the dependency graph for the subtree
+     */
+    printDependencyGraph(graph, subtreeIds, verbose) {
+        if (!verbose)
+            return;
+        this.log(pc.cyan('Dependency Graph'));
+        // Group subtree nodes by kind
+        const nodesByKind = new Map();
+        for (const id of subtreeIds) {
+            if (!graph.nodes.has(id))
+                continue;
+            const { kind } = DependencyGraph.parseId(id);
+            if (!nodesByKind.has(kind)) {
+                nodesByKind.set(kind, []);
+            }
+            nodesByKind.get(kind).push(id);
+        }
+        const kindOrder = [
+            SchemaKind.Blueprint,
+            SchemaKind.Template,
+            SchemaKind.JsonataFunction,
+            SchemaKind.Schema,
+            SchemaKind.Asset,
+        ];
+        for (const kind of kindOrder) {
+            const nodes = nodesByKind.get(kind);
+            if (!nodes || nodes.length === 0)
+                continue;
+            this.log(pc.yellow(`   ${kind} (${nodes.length})`));
+            for (const id of nodes.sort()) {
+                const { key, version } = DependencyGraph.parseId(id);
+                const deps = graph.edges.get(id) ?? new Set();
+                const existingDeps = Array.from(deps).filter((d) => graph.nodes.has(d));
+                if (existingDeps.length === 0) {
+                    this.log(pc.dim(`   ├─ ${key}@${version}`));
+                }
+                else {
+                    this.log(`   ├─ ${key}@${version}`);
+                    for (let i = 0; i < existingDeps.length; i++) {
+                        const depId = existingDeps[i];
+                        const { kind: depKind, key: depKey, version: depVersion, } = DependencyGraph.parseId(depId);
+                        const prefix = i === existingDeps.length - 1 ? '└──' : '├──';
+                        this.log(pc.dim(`   │  ${prefix} ${depKind}:${depKey}@${depVersion}`));
+                    }
+                }
+            }
+            this.log('');
+        }
+    }
+    /**
+     * Print cycle detection errors
+     */
+    printCycleErrors(cycles) {
+        this.log('');
+        this.log(pc.red('Circular dependencies detected:'));
+        for (const cycle of cycles) {
+            const cycleStr = cycle
+                .map((id) => {
+                const { kind, key, version } = DependencyGraph.parseId(id);
+                return `${kind}:${key}@${version}`;
+            })
+                .join(' → ');
+            this.log(pc.red(`  • ${cycleStr}`));
+        }
+        this.log('');
+    }
+    /**
+     * Print validation result for a single document
+     */
+    printResult(result, verbose) {
+        const fileDisplay = result.resourceKey && result.resourceVersion
+            ? `${result.filePath} [${result.resourceKey}@${result.resourceVersion}]`
+            : result.documentIndex !== undefined
+                ? `${result.filePath} [document ${result.documentIndex + 1}]`
+                : result.filePath;
+        if (result.valid) {
+            this.log(`${pc.green('✓')} ${fileDisplay}`);
+            if (verbose) {
+                this.log(pc.dim(`  Schema: ${result.schemaKind}`));
+                this.log('');
+            }
+        }
+        else {
+            this.log(`${pc.red('✗')} ${fileDisplay}`);
+            this.log(pc.dim(`  Schema: ${result.schemaKind}`));
+            this.log('');
+            this.log(pc.red('  Errors:'));
+            for (const error of result.errors) {
+                const path = error.path === '/' ? '(root)' : error.path;
+                this.log(`    ${pc.red('•')} ${error.message}`);
+                this.log(pc.dim(`      Path: ${path}`));
+                if (verbose && error.params) {
+                    this.log(pc.dim(`      Details: ${JSON.stringify(error.params)}`));
+                }
+            }
+            this.log('');
+        }
+    }
+    /**
+     * Print resource validation summary
+     */
+    printResourceSummary(summary, verbose) {
+        const { total, passed, failed, graphStats, hasCycles } = summary;
+        this.log(pc.dim('─'.repeat(SEPARATOR_LENGTH)));
+        if (verbose && graphStats) {
+            this.log(pc.dim(`\nGraph: ${graphStats.totalNodes} resources, ${graphStats.totalEdges} dependencies`));
+        }
+        if (failed === 0 && !hasCycles) {
+            this.log(pc.green(`\nValidation complete: ${total} document(s) checked, all passed ✓\n`));
+        }
+        else {
+            const parts = [`\nValidation complete: ${total} document(s) checked`];
+            if (passed > 0)
+                parts.push(pc.green(`${passed} passed`));
+            if (failed > 0)
+                parts.push(pc.red(`${failed} failed`));
+            if (hasCycles)
+                parts.push(pc.red('circular dependencies detected'));
+            this.log(parts.join(', ') + '\n');
+        }
+    }
+    /**
+     * Print simple summary (used for early exit on parse errors)
+     */
+    printSummary(summary) {
+        this.printResourceSummary(summary, false);
+    }
+}
+//# sourceMappingURL=validate.js.map