@niujiajie/freespec 0.0.0-stage → 1.15.0

package/dist/core/command-generation/types.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Command Generation Types
+ *
+ * Tool-agnostic interfaces for command generation.
+ * These types separate "what to generate" from "how to format it".
+ */
+/**
+ * Tool-agnostic command data.
+ * Represents the content of a command without any tool-specific formatting.
+ */
+export interface CommandContent {
+    /** Command identifier (e.g., 'explore', 'apply', 'new') */
+    id: string;
+    /** Human-readable name (e.g., 'FreeSpec Explore') */
+    name: string;
+    /** Brief description of command purpose */
+    description: string;
+    /** Grouping category (e.g., 'Workflow') */
+    category: string;
+    /** Array of tag strings */
+    tags: string[];
+    /** The command instruction content (body text) */
+    body: string;
+}
+/**
+ * Per-tool formatting strategy.
+ * Each AI tool implements this interface to handle its specific file path
+ * and frontmatter format requirements.
+ */
+export interface ToolCommandAdapter {
+    /** Tool identifier matching AIToolOption.value (e.g., 'claude', 'cursor') */
+    toolId: string;
+    /**
+     * Returns the file path for a command.
+     * @param commandId - The command identifier (e.g., 'explore')
+     * @returns Path from project root (e.g., '.claude/commands/freespec/explore.md').
+     *          May be absolute for tools with global-scoped command files.
+     */
+    getFilePath(commandId: string): string;
+    /**
+     * What the user types before the command name, when it is not the default
+     * `/`. Amazon Q loads these files into its prompt library, which is invoked
+     * with `@` (`@freespec-propose`), so its adapter sets '@'. The name itself is
+     * still derived from getFilePath — see invocation.ts.
+     */
+    invocationPrefix?: string;
+    /**
+     * Formats the complete file content including frontmatter.
+     * @param content - The tool-agnostic command content
+     * @returns Complete file content ready to write
+     */
+    formatFile(content: CommandContent): string;
+}
+/**
+ * Result of generating a command file.
+ */
+export interface GeneratedCommand {
+    /** File path from project root, or absolute for global-scoped command files */
+    path: string;
+    /** Complete file content (frontmatter + body) */
+    fileContent: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/command-generation/types.js

@@ -0,0 +1,8 @@
+/**
+ * Command Generation Types
+ *
+ * Tool-agnostic interfaces for command generation.
+ * These types separate "what to generate" from "how to format it".
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/command-generation/yaml.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Shared YAML frontmatter helpers for command adapters.
+ *
+ * Several tool adapters emit YAML frontmatter and need to escape
+ * user-facing strings (name, description, category, tags) so the
+ * generated file stays valid YAML. This module centralizes that logic
+ * so the behavior is identical across adapters and fixed in one place.
+ */
+/**
+ * Escapes a string value for safe YAML output.
+ *
+ * Always emits a double-quoted scalar. Quoting unconditionally keeps the
+ * value a string no matter what it holds: an unquoted `true`, `null` or
+ * `123` would round-trip as a boolean, null or number, and an unquoted
+ * value opening with a block indicator (`|`, `>`) or containing `: `
+ * is not valid YAML at all.
+ *
+ * Inside the quotes it escapes everything that cannot appear verbatim in a
+ * double-quoted scalar: backslash, double quote, line feed, carriage
+ * return, and the non-printable characters YAML's `c-printable` production
+ * excludes (C0 controls, DEL and C1 controls). Lenient parsers accept a raw
+ * control byte, but strict ones reject the document outright, so escaping
+ * them here keeps the generated file portable across every tool's parser.
+ *
+ * @param value - The raw string to embed in YAML frontmatter.
+ * @returns The value as an escaped, double-quoted YAML scalar.
+ */
+export declare function escapeYamlValue(value: string): string;
+/**
+ * Formats a tags array as a YAML array with proper escaping.
+ *
+ * @param tags - Array of tag strings.
+ * @returns Formatted YAML array string, e.g. '[tag1, tag2]'.
+ */
+export declare function formatTagsArray(tags: string[]): string;
+//# sourceMappingURL=yaml.d.ts.map

package/dist/core/command-generation/yaml.js

@@ -0,0 +1,48 @@
+/**
+ * Shared YAML frontmatter helpers for command adapters.
+ *
+ * Several tool adapters emit YAML frontmatter and need to escape
+ * user-facing strings (name, description, category, tags) so the
+ * generated file stays valid YAML. This module centralizes that logic
+ * so the behavior is identical across adapters and fixed in one place.
+ */
+/**
+ * Escapes a string value for safe YAML output.
+ *
+ * Always emits a double-quoted scalar. Quoting unconditionally keeps the
+ * value a string no matter what it holds: an unquoted `true`, `null` or
+ * `123` would round-trip as a boolean, null or number, and an unquoted
+ * value opening with a block indicator (`|`, `>`) or containing `: `
+ * is not valid YAML at all.
+ *
+ * Inside the quotes it escapes everything that cannot appear verbatim in a
+ * double-quoted scalar: backslash, double quote, line feed, carriage
+ * return, and the non-printable characters YAML's `c-printable` production
+ * excludes (C0 controls, DEL and C1 controls). Lenient parsers accept a raw
+ * control byte, but strict ones reject the document outright, so escaping
+ * them here keeps the generated file portable across every tool's parser.
+ *
+ * @param value - The raw string to embed in YAML frontmatter.
+ * @returns The value as an escaped, double-quoted YAML scalar.
+ */
+export function escapeYamlValue(value) {
+    const escaped = value
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')
+        // Remaining non-printables have no dedicated escape; emit them as \xHH.
+        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g, (char) => `\\x${char.charCodeAt(0).toString(16).padStart(2, '0')}`);
+    return `"${escaped}"`;
+}
+/**
+ * Formats a tags array as a YAML array with proper escaping.
+ *
+ * @param tags - Array of tag strings.
+ * @returns Formatted YAML array string, e.g. '[tag1, tag2]'.
+ */
+export function formatTagsArray(tags) {
+    const escapedTags = tags.map((tag) => escapeYamlValue(tag));
+    return `[${escapedTags.join(', ')}]`;
+}
+//# sourceMappingURL=yaml.js.map

package/dist/core/command-surface.d.ts

@@ -0,0 +1,15 @@
+import { type CommandInvocation } from './command-generation/invocation.js';
+import type { Delivery } from './global-config.js';
+export type CommandSurfaceCapability = 'adapter-backed' | 'skills-invocable' | 'none';
+/**
+ * How the tool spells its FreeSpec commands: the name from the command files
+ * its adapter writes, the prefix the adapter declares. Returns undefined for
+ * tools with no command adapter, which have no command names to spell.
+ */
+export declare function resolveCommandInvocation(toolId: string): CommandInvocation | undefined;
+export declare function resolveCommandSurfaceCapability(toolId: string): CommandSurfaceCapability;
+export declare function shouldGenerateSkillsForTool(toolId: string, delivery: Delivery): boolean;
+export declare function shouldRemoveSkillsForTool(toolId: string, delivery: Delivery): boolean;
+export declare function shouldGenerateCommandsForTool(toolId: string, delivery: Delivery): boolean;
+export declare function shouldReconcileCommandFilesForTool(toolId: string, delivery: Delivery): boolean;
+//# sourceMappingURL=command-surface.d.ts.map

package/dist/core/command-surface.js

@@ -0,0 +1,33 @@
+import { CommandAdapterRegistry } from './command-generation/index.js';
+import { getInvocationForAdapter } from './command-generation/invocation.js';
+/**
+ * How the tool spells its FreeSpec commands: the name from the command files
+ * its adapter writes, the prefix the adapter declares. Returns undefined for
+ * tools with no command adapter, which have no command names to spell.
+ */
+export function resolveCommandInvocation(toolId) {
+    const adapter = CommandAdapterRegistry.get(toolId);
+    return adapter ? getInvocationForAdapter(adapter) : undefined;
+}
+export function resolveCommandSurfaceCapability(toolId) {
+    if (CommandAdapterRegistry.has(toolId)) {
+        return 'adapter-backed';
+    }
+    if (toolId === 'codex' || toolId === 'warp') {
+        return 'skills-invocable';
+    }
+    return 'none';
+}
+export function shouldGenerateSkillsForTool(toolId, delivery) {
+    return delivery !== 'commands' || resolveCommandSurfaceCapability(toolId) === 'skills-invocable';
+}
+export function shouldRemoveSkillsForTool(toolId, delivery) {
+    return delivery === 'commands' && resolveCommandSurfaceCapability(toolId) !== 'skills-invocable';
+}
+export function shouldGenerateCommandsForTool(toolId, delivery) {
+    return delivery !== 'skills' && resolveCommandSurfaceCapability(toolId) === 'adapter-backed';
+}
+export function shouldReconcileCommandFilesForTool(toolId, delivery) {
+    return delivery === 'skills' && resolveCommandSurfaceCapability(toolId) === 'adapter-backed';
+}
+//# sourceMappingURL=command-surface.js.map

package/dist/core/config-prompts.d.ts

@@ -0,0 +1,9 @@
+import type { ProjectConfig } from './project-config.js';
+/**
+ * Serialize config to YAML string with helpful comments.
+ *
+ * @param config - Partial config object (schema required, other fields optional)
+ * @returns YAML string ready to write to file
+ */
+export declare function serializeConfig(config: Partial<ProjectConfig>): string;
+//# sourceMappingURL=config-prompts.d.ts.map

package/dist/core/config-prompts.js

@@ -0,0 +1,56 @@
+/**
+ * Serialize config to YAML string with helpful comments.
+ *
+ * @param config - Partial config object (schema required, other fields optional)
+ * @returns YAML string ready to write to file
+ */
+export function serializeConfig(config) {
+    const lines = [];
+    // Schema (required)
+    lines.push(`schema: ${config.schema}`);
+    lines.push('');
+    if (config.context !== undefined) {
+        lines.push('context: |');
+        for (const line of config.context.split('\n')) {
+            lines.push(`  ${line}`);
+        }
+        lines.push('');
+    }
+    else {
+        // Context section with comments
+        lines.push('# Project context (optional)');
+        lines.push('# Add only constraints that should guide FreeSpec artifacts and workflows.');
+        lines.push('# Include constraints an agent cannot infer by reading the code.');
+        lines.push('# Keep general project documentation and discoverable codebase facts out.');
+        lines.push('# Example:');
+        lines.push('#   context: |');
+        lines.push('#     Designs and tasks must cover Windows, macOS, and Linux');
+        lines.push('#     Write all artifacts in Spanish');
+        lines.push('');
+    }
+    // Rules section with comments
+    lines.push('# Per-artifact rules (optional)');
+    lines.push('# Add custom rules for specific artifacts.');
+    lines.push('# Example:');
+    lines.push('#   rules:');
+    lines.push('#     proposal:');
+    lines.push('#       - Keep proposals under 500 words');
+    lines.push('#       - Always state what is out of scope');
+    lines.push('#     tasks:');
+    lines.push('#       - Break tasks into chunks of max 2 hours');
+    lines.push('');
+    // Operation guidance section with comments
+    lines.push('# Per-operation guidance (optional)');
+    lines.push('# Add advisory guidance for how apply and archive work should be conducted.');
+    lines.push('# This is separate from artifact rules above.');
+    lines.push('# Example:');
+    lines.push('#   operations:');
+    lines.push('#     apply:');
+    lines.push('#       guidance:');
+    lines.push('#         - Keep test summaries concise');
+    lines.push('#     archive:');
+    lines.push('#       guidance:');
+    lines.push('#         - Summarize the archive outcome before finishing');
+    return lines.join('\n') + '\n';
+}
+//# sourceMappingURL=config-prompts.js.map

package/dist/core/config-schema.d.ts

@@ -0,0 +1,98 @@
+import { z } from 'zod';
+/**
+ * Zod schema for global FreeSpec configuration.
+ * Uses passthrough() to preserve unknown fields for forward compatibility.
+ */
+export declare const GlobalConfigSchema: z.ZodObject<{
+    featureFlags: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>>;
+    profile: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        custom: "custom";
+        core: "core";
+    }>>>;
+    delivery: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        both: "both";
+        skills: "skills";
+        commands: "commands";
+    }>>>;
+    workflows: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    defaultStore: z.ZodOptional<z.ZodString>;
+    telemetry: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>;
+    completionTipSeen: z.ZodOptional<z.ZodBoolean>;
+    standaloneTipSeen: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export type GlobalConfigType = z.infer<typeof GlobalConfigSchema>;
+/**
+ * Default configuration values.
+ */
+export declare const DEFAULT_CONFIG: GlobalConfigType;
+/**
+ * True when a dot-notation key path contains a prototype-reaching segment.
+ * Callers that bypass key validation (e.g. --allow-unknown) still must not bypass this.
+ */
+export declare function hasUnsafeKeySegment(path: string): boolean;
+/**
+ * Validate a config key path for CLI set operations.
+ * Unknown top-level keys are rejected unless explicitly allowed by the caller.
+ */
+export declare function validateConfigKeyPath(path: string): {
+    valid: boolean;
+    reason?: string;
+};
+/**
+ * Get a nested value from an object using dot notation.
+ *
+ * @param obj - The object to access
+ * @param path - Dot-separated path (e.g., "featureFlags.someFlag")
+ * @returns The value at the path, or undefined if not found
+ */
+export declare function getNestedValue(obj: Record<string, unknown>, path: string): unknown;
+/**
+ * Set a nested value in an object using dot notation.
+ * Creates intermediate objects as needed.
+ *
+ * @param obj - The object to modify (mutated in place)
+ * @param path - Dot-separated path (e.g., "featureFlags.someFlag")
+ * @param value - The value to set
+ */
+export declare function setNestedValue(obj: Record<string, unknown>, path: string, value: unknown): void;
+/**
+ * Delete a nested value from an object using dot notation.
+ *
+ * @param obj - The object to modify (mutated in place)
+ * @param path - Dot-separated path (e.g., "featureFlags.someFlag")
+ * @returns true if the key existed and was deleted, false otherwise
+ */
+export declare function deleteNestedValue(obj: Record<string, unknown>, path: string): boolean;
+/**
+ * Coerce a string value to its appropriate type.
+ * - "true" / "false" -> boolean
+ * - Numeric strings -> number
+ * - JSON arrays/objects -> parsed containers
+ * - Everything else -> string
+ *
+ * @param value - The string value to coerce
+ * @param forceString - If true, always return the value as a string
+ * @returns The coerced value
+ */
+export declare function coerceValue(value: string, forceString?: boolean): string | number | boolean | unknown[] | Record<string, unknown>;
+/**
+ * Format a value for YAML-like display.
+ *
+ * @param value - The value to format
+ * @param indent - Current indentation level
+ * @returns Formatted string
+ */
+export declare function formatValueYaml(value: unknown, indent?: number): string;
+/**
+ * Validate a configuration object against the schema.
+ *
+ * @param config - The configuration to validate
+ * @returns Validation result with success status and optional error message
+ */
+export declare function validateConfig(config: unknown): {
+    success: boolean;
+    error?: string;
+};
+//# sourceMappingURL=config-schema.d.ts.map

package/dist/core/config-schema.js

@@ -0,0 +1,308 @@
+import { z } from 'zod';
+/**
+ * Zod schema for global FreeSpec configuration.
+ * Uses passthrough() to preserve unknown fields for forward compatibility.
+ */
+export const GlobalConfigSchema = z
+    .object({
+    featureFlags: z
+        .record(z.string(), z.boolean())
+        .optional()
+        .default({}),
+    profile: z
+        .enum(['core', 'custom'])
+        .optional()
+        .default('core'),
+    delivery: z
+        .enum(['both', 'skills', 'commands'])
+        .optional()
+        .default('both'),
+    workflows: z
+        .array(z.string())
+        .optional(),
+    defaultStore: z
+        .string()
+        .optional()
+        .describe('Store id used as fallback root when no explicit --store, local root, or project-level store: pointer resolves'),
+    // passthrough keeps runtime-managed fields (anonymousId, noticeSeen) valid
+    // under CLI validate when users only set telemetry.enabled.
+    telemetry: z
+        .object({
+        enabled: z.boolean().optional(),
+    })
+        .passthrough()
+        .optional(),
+    // Runtime-managed (like telemetry.noticeSeen); not user-settable via CLI set.
+    completionTipSeen: z.boolean().optional(),
+    standaloneTipSeen: z.boolean().optional(),
+})
+    .passthrough();
+/**
+ * Default configuration values.
+ */
+export const DEFAULT_CONFIG = {
+    featureFlags: {},
+    profile: 'core',
+    delivery: 'both',
+};
+const KNOWN_TOP_LEVEL_KEYS = new Set([
+    ...Object.keys(DEFAULT_CONFIG),
+    'workflows',
+    'defaultStore',
+    'telemetry',
+]);
+/** Nested keys users may set under `telemetry` via the CLI. */
+const TELEMETRY_SETTABLE_KEYS = new Set(['enabled']);
+/**
+ * Key segments that would reach the prototype chain instead of the config object.
+ * Never valid as configuration keys, so rejecting them costs nothing.
+ */
+const UNSAFE_KEY_SEGMENTS = new Set(['__proto__', 'constructor', 'prototype']);
+function hasUnsafeSegment(keys) {
+    return keys.some((key) => UNSAFE_KEY_SEGMENTS.has(key));
+}
+/**
+ * True when a dot-notation key path contains a prototype-reaching segment.
+ * Callers that bypass key validation (e.g. --allow-unknown) still must not bypass this.
+ */
+export function hasUnsafeKeySegment(path) {
+    return hasUnsafeSegment(path.split('.'));
+}
+/**
+ * Validate a config key path for CLI set operations.
+ * Unknown top-level keys are rejected unless explicitly allowed by the caller.
+ */
+export function validateConfigKeyPath(path) {
+    const rawKeys = path.split('.');
+    if (rawKeys.length === 0 || rawKeys.some((key) => key.trim() === '')) {
+        return { valid: false, reason: 'Key path must not be empty' };
+    }
+    const unsafeKey = rawKeys.find((key) => UNSAFE_KEY_SEGMENTS.has(key));
+    if (unsafeKey) {
+        return { valid: false, reason: `Key segment "${unsafeKey}" is not allowed` };
+    }
+    const rootKey = rawKeys[0];
+    if (!KNOWN_TOP_LEVEL_KEYS.has(rootKey)) {
+        return { valid: false, reason: `Unknown top-level key "${rootKey}"` };
+    }
+    if (rootKey === 'featureFlags') {
+        if (rawKeys.length > 2) {
+            return { valid: false, reason: 'featureFlags values are booleans and do not support nested keys' };
+        }
+        return { valid: true };
+    }
+    if (rootKey === 'telemetry') {
+        if (rawKeys.length === 1) {
+            return { valid: false, reason: 'Set nested keys under telemetry (e.g. telemetry.enabled)' };
+        }
+        if (rawKeys.length !== 2 || !TELEMETRY_SETTABLE_KEYS.has(rawKeys[1])) {
+            return {
+                valid: false,
+                reason: `Unknown telemetry key "${rawKeys.slice(1).join('.')}" (allowed: enabled)`,
+            };
+        }
+        return { valid: true };
+    }
+    if (rawKeys.length > 1) {
+        return { valid: false, reason: `"${rootKey}" does not support nested keys` };
+    }
+    return { valid: true };
+}
+/**
+ * Get a nested value from an object using dot notation.
+ *
+ * @param obj - The object to access
+ * @param path - Dot-separated path (e.g., "featureFlags.someFlag")
+ * @returns The value at the path, or undefined if not found
+ */
+export function getNestedValue(obj, path) {
+    const keys = path.split('.');
+    if (hasUnsafeSegment(keys)) {
+        return undefined;
+    }
+    let current = obj;
+    for (const key of keys) {
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        if (typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[key];
+    }
+    return current;
+}
+/**
+ * Set a nested value in an object using dot notation.
+ * Creates intermediate objects as needed.
+ *
+ * @param obj - The object to modify (mutated in place)
+ * @param path - Dot-separated path (e.g., "featureFlags.someFlag")
+ * @param value - The value to set
+ */
+export function setNestedValue(obj, path, value) {
+    const keys = path.split('.');
+    // Compared literally rather than through a helper, so the guard is plain to a
+    // reader and to static analysis. Checked for the whole path before anything is
+    // written, so a rejected key never leaves half-created objects behind.
+    for (const key of keys) {
+        if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+            return;
+        }
+    }
+    let current = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const key = keys[i];
+        if (current[key] === undefined || current[key] === null || typeof current[key] !== 'object') {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    const lastKey = keys[keys.length - 1];
+    current[lastKey] = value;
+}
+/**
+ * Delete a nested value from an object using dot notation.
+ *
+ * @param obj - The object to modify (mutated in place)
+ * @param path - Dot-separated path (e.g., "featureFlags.someFlag")
+ * @returns true if the key existed and was deleted, false otherwise
+ */
+export function deleteNestedValue(obj, path) {
+    const keys = path.split('.');
+    for (const key of keys) {
+        if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+            return false;
+        }
+    }
+    let current = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const key = keys[i];
+        if (current[key] === undefined || current[key] === null || typeof current[key] !== 'object') {
+            return false;
+        }
+        current = current[key];
+    }
+    const lastKey = keys[keys.length - 1];
+    if (lastKey in current) {
+        delete current[lastKey];
+        return true;
+    }
+    return false;
+}
+/**
+ * Coerce a string value to its appropriate type.
+ * - "true" / "false" -> boolean
+ * - Numeric strings -> number
+ * - JSON arrays/objects -> parsed containers
+ * - Everything else -> string
+ *
+ * @param value - The string value to coerce
+ * @param forceString - If true, always return the value as a string
+ * @returns The coerced value
+ */
+export function coerceValue(value, forceString = false) {
+    if (forceString) {
+        return value;
+    }
+    // Boolean coercion
+    if (value === 'true') {
+        return true;
+    }
+    if (value === 'false') {
+        return false;
+    }
+    // Number coercion - must be a valid finite number
+    const num = Number(value);
+    if (!isNaN(num) && isFinite(num) && value.trim() !== '') {
+        return num;
+    }
+    const jsonContainer = parseJsonContainer(value);
+    if (jsonContainer !== undefined) {
+        return jsonContainer;
+    }
+    return value;
+}
+function parseJsonContainer(value) {
+    const trimmed = value.trim();
+    const looksLikeContainer = (trimmed.startsWith('[') && trimmed.endsWith(']')) ||
+        (trimmed.startsWith('{') && trimmed.endsWith('}'));
+    if (!looksLikeContainer) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed)) {
+            return parsed;
+        }
+        if (parsed !== null && typeof parsed === 'object') {
+            return parsed;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+/**
+ * Format a value for YAML-like display.
+ *
+ * @param value - The value to format
+ * @param indent - Current indentation level
+ * @returns Formatted string
+ */
+export function formatValueYaml(value, indent = 0) {
+    const indentStr = '  '.repeat(indent);
+    if (value === null || value === undefined) {
+        return 'null';
+    }
+    if (typeof value === 'boolean' || typeof value === 'number') {
+        return String(value);
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return '[]';
+        }
+        return value.map((item) => `${indentStr}- ${formatValueYaml(item, indent + 1)}`).join('\n');
+    }
+    if (typeof value === 'object') {
+        const entries = Object.entries(value);
+        if (entries.length === 0) {
+            return '{}';
+        }
+        return entries
+            .map(([key, val]) => {
+            const formattedVal = formatValueYaml(val, indent + 1);
+            if (typeof val === 'object' && val !== null && Object.keys(val).length > 0) {
+                return `${indentStr}${key}:\n${formattedVal}`;
+            }
+            return `${indentStr}${key}: ${formattedVal}`;
+        })
+            .join('\n');
+    }
+    return String(value);
+}
+/**
+ * Validate a configuration object against the schema.
+ *
+ * @param config - The configuration to validate
+ * @returns Validation result with success status and optional error message
+ */
+export function validateConfig(config) {
+    try {
+        GlobalConfigSchema.parse(config);
+        return { success: true };
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            const zodError = error;
+            const messages = zodError.issues.map((e) => `${e.path.join('.')}: ${e.message}`);
+            return { success: false, error: messages.join('; ') };
+        }
+        return { success: false, error: 'Unknown validation error' };
+    }
+}
+//# sourceMappingURL=config-schema.js.map