@ai-setting/roy-agent-cli 1.3.15 → 1.3.17

package/dist/cli/src/commands/workflow/commands/validate.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview Workflow validate command
+ */
+import { CommandModule } from 'yargs';
+export interface WorkflowValidateOptions {
+    input?: string;
+    yaml?: string;
+    json?: boolean;
+}
+/**
+ * WorkflowValidateCommand - Validate workflow YAML
+ */
+export declare const WorkflowValidateCommand: CommandModule<object, WorkflowValidateOptions>;
+//# sourceMappingURL=validate.d.ts.map

package/dist/cli/src/commands/workflow/commands/validate.js

@@ -0,0 +1,118 @@
+/**
+ * @fileoverview Workflow validate command
+ */
+import chalk from 'chalk';
+import { readFileSync } from 'fs';
+import { WorkflowValidator } from "../validators/workflow-validator.js";
+/**
+ * Parse workflow from various input formats
+ */
+async function parseWorkflowInput(input, yamlStr) {
+    // Helper to parse YAML
+    const parseYaml = async (content) => {
+        const YAML = await import('yaml');
+        return YAML.parse(content);
+    };
+    // From file path
+    if (input && !yamlStr) {
+        try {
+            const content = readFileSync(input, 'utf-8');
+            return await parseYaml(content);
+        }
+        catch (error) {
+            throw new Error(`Failed to read file "${input}": ${error.message}`);
+        }
+    }
+    // From --yaml flag
+    if (yamlStr) {
+        try {
+            return await parseYaml(yamlStr);
+        }
+        catch (error) {
+            throw new Error(`Failed to parse YAML: ${error.message}`);
+        }
+    }
+    // From workflow ID (requires database lookup)
+    if (input && !input.includes(':') && !input.includes('-')) {
+        // TODO: Load from database if needed
+        throw new Error('Workflow ID lookup not implemented yet. Please use file path or --yaml flag.');
+    }
+    throw new Error('Please provide workflow input: file path, --yaml string, or workflow ID');
+}
+/**
+ * Render validation result
+ */
+function renderResult(result, options) {
+    // JSON output
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    // Text output
+    if (result.valid) {
+        console.log(chalk.green('\n✅ Workflow validation PASSED\n'));
+        console.log(chalk.bold(`Workflow: ${result.workflowName}`));
+        console.log(`Nodes: ${result.nodeCount}`);
+        // List valid nodes
+        console.log('\nValid nodes:');
+        // Since we don't track valid nodes separately, we just show the count
+        console.log(chalk.green('  ✓ All nodes passed validation'));
+    }
+    else {
+        console.log(chalk.red(`\n❌ Workflow validation FAILED (${result.errors.length} errors found)\n`));
+        result.errors.forEach((error, index) => {
+            console.log(chalk.red(`[Error ${index + 1}/${result.errors.length}]${error.nodeId ? ` Node "${error.nodeId}"` : ''}`));
+            console.log(`  ${chalk.bold('Type:')} ${error.type}`);
+            console.log(`  ${chalk.bold('Description:')} ${error.description}`);
+            console.log(`  ${chalk.bold('Expected:')} ${error.expected}`);
+            console.log(`  ${chalk.bold('Actual:')} ${error.actual}`);
+            console.log(`  ${chalk.green('Fix:')} ${error.fix}`);
+            console.log();
+        });
+    }
+}
+/**
+ * WorkflowValidateCommand - Validate workflow YAML
+ */
+export const WorkflowValidateCommand = {
+    command: 'validate [input]',
+    describe: 'Validate workflow YAML syntax and node configurations',
+    builder: (yargs) => yargs
+        .positional('input', {
+        describe: 'Workflow file path or workflow ID',
+        type: 'string',
+    })
+        .option('yaml', {
+        describe: 'YAML content string (alternative to positional input)',
+        type: 'string',
+        alias: 'y',
+    })
+        .option('json', {
+        describe: 'Output in JSON format',
+        type: 'boolean',
+        alias: 'j',
+    }),
+    async handler(args) {
+        const options = args;
+        try {
+            // Parse input
+            const workflow = await parseWorkflowInput(options.input, options.yaml);
+            if (!workflow) {
+                console.error(chalk.red('Failed to parse workflow input'));
+                process.exit(1);
+            }
+            // Validate
+            const validator = new WorkflowValidator();
+            const result = validator.validate(workflow);
+            // Render result
+            renderResult(result, options);
+            // Exit with appropriate code
+            process.exit(result.valid ? 0 : 1);
+        }
+        catch (error) {
+            console.error(chalk.red(`\nError: ${error.message}`));
+            process.exit(1);
+        }
+    },
+};
+//# sourceMappingURL=validate.js.map

package/dist/cli/src/commands/workflow/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview Workflow Command - Main entry point
+ *
+ * Workflow DAG management and execution CLI commands
+ *
+ * Note: Resume functionality is unified into `workflow run -s <sessionId>`.
+ * Use `workflow run -s <sessionId> --input "response"` to resume a paused workflow.
+ */
+import { CommandModule } from 'yargs';
+import { WorkflowListCommand } from './commands/list';
+import { WorkflowAddCommand } from './commands/add';
+import { WorkflowGetCommand } from './commands/get';
+import { WorkflowUpdateCommand } from './commands/update';
+import { WorkflowRemoveCommand } from './commands/remove';
+import { WorkflowRunCommand } from './commands/run';
+import { WorkflowStopCommand } from './commands/stop';
+import { WorkflowStatusCommand } from './commands/status';
+import { WorkflowNodesCommand } from './commands/nodes';
+import { WorkflowValidateCommand } from './commands/validate';
+export interface WorkflowOptions {
+    command?: string;
+}
+/**
+ * WorkflowCommand - Workflow DAG management
+ */
+export declare const WorkflowCommand: CommandModule<object, WorkflowOptions>;
+export { WorkflowListCommand, WorkflowAddCommand, WorkflowGetCommand, WorkflowUpdateCommand, WorkflowRemoveCommand, WorkflowRunCommand, WorkflowStopCommand, WorkflowStatusCommand, WorkflowNodesCommand, WorkflowValidateCommand, };
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/src/commands/workflow/index.js

@@ -0,0 +1,44 @@
+/**
+ * @fileoverview Workflow Command - Main entry point
+ *
+ * Workflow DAG management and execution CLI commands
+ *
+ * Note: Resume functionality is unified into `workflow run -s <sessionId>`.
+ * Use `workflow run -s <sessionId> --input "response"` to resume a paused workflow.
+ */
+import { WorkflowListCommand } from "./commands/list.js";
+import { WorkflowAddCommand } from "./commands/add.js";
+import { WorkflowGetCommand } from "./commands/get.js";
+import { WorkflowUpdateCommand } from "./commands/update.js";
+import { WorkflowRemoveCommand } from "./commands/remove.js";
+import { WorkflowRunCommand } from "./commands/run.js";
+import { WorkflowStopCommand } from "./commands/stop.js";
+import { WorkflowStatusCommand } from "./commands/status.js";
+import { WorkflowNodesCommand } from "./commands/nodes.js";
+import { WorkflowValidateCommand } from "./commands/validate.js";
+/**
+ * WorkflowCommand - Workflow DAG management
+ */
+export const WorkflowCommand = {
+    command: 'workflow',
+    describe: 'Workflow DAG management and execution - create, run, and monitor workflows',
+    builder: (yargs) => yargs
+        .command(WorkflowListCommand)
+        .command(WorkflowAddCommand)
+        .command(WorkflowNodesCommand)
+        .command(WorkflowValidateCommand)
+        .command(WorkflowGetCommand)
+        .command(WorkflowUpdateCommand)
+        .command(WorkflowRemoveCommand)
+        .command(WorkflowRunCommand)
+        .command(WorkflowStopCommand)
+        .command(WorkflowStatusCommand)
+        .demandCommand(1, '请指定子命令：list、add、validate、nodes、get、update、remove、run、stop、status\n\nResume: 使用 `workflow run -s <sessionId>` 恢复暂停的工作流')
+        .help(),
+    handler() {
+        // Default to help (handled by yargs demandCommand)
+    },
+};
+// Export subcommands
+export { WorkflowListCommand, WorkflowAddCommand, WorkflowGetCommand, WorkflowUpdateCommand, WorkflowRemoveCommand, WorkflowRunCommand, WorkflowStopCommand, WorkflowStatusCommand, WorkflowNodesCommand, WorkflowValidateCommand, };
+//# sourceMappingURL=index.js.map

package/dist/cli/src/commands/workflow/renderers.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview Workflow CLI Renderers
+ *
+ * Output formatters for workflow CLI commands
+ */
+import type { Workflow, WorkflowRun } from '@ai-setting/roy-agent-core/env/workflow/types';
+/**
+ * 渲染 Workflow 列表
+ */
+export declare function renderWorkflowList(workflows: Workflow[], options?: {
+    json?: boolean;
+}): string;
+/**
+ * 渲染 Workflow 详情
+ */
+export declare function renderWorkflowDetail(workflow: Workflow, options?: {
+    includeRuns?: WorkflowRun[];
+}): string;
+/**
+ * 渲染 Runs 列表
+ */
+export declare function renderRunsList(runs: WorkflowRun[], options?: {
+    json?: boolean;
+}): string;
+/**
+ * 渲染 Run 详情
+ */
+export declare function renderRunDetail(run: WorkflowRun): string;
+/**
+ * 渲染工作流已添加成功
+ */
+export declare function renderWorkflowAdded(workflow: Workflow): string;
+/**
+ * 渲染工作流已更新成功
+ */
+export declare function renderWorkflowUpdated(workflow: Workflow): string;
+/**
+ * 渲染工作流已删除成功
+ */
+export declare function renderWorkflowDeleted(name: string): string;
+/**
+ * 渲染工作流运行结果
+ */
+export declare function renderRunResult(result: {
+    runId: string;
+    status: string;
+    output?: any;
+    error?: string;
+    durationMs?: number;
+}): string;
+/**
+ * 渲染节点列表
+ */
+export declare function renderNodesList(nodes: Array<{
+    id?: string;
+    type?: string;
+    name?: string;
+    depends_on?: string[];
+}>): string;
+//# sourceMappingURL=renderers.d.ts.map

package/dist/cli/src/commands/workflow/renderers.js

@@ -0,0 +1,320 @@
+/**
+ * @fileoverview Workflow CLI Renderers
+ *
+ * Output formatters for workflow CLI commands
+ */
+import chalk from 'chalk';
+/**
+ * 计算字符串的视觉宽度（中文字符占2格）
+ */
+function visualWidth(str) {
+    let width = 0;
+    for (const char of str) {
+        if (char.charCodeAt(0) > 255) {
+            width += 2;
+        }
+        else {
+            width += 1;
+        }
+    }
+    return width;
+}
+/**
+ * 按视觉宽度截断字符串
+ */
+function truncateVisual(str, maxWidth) {
+    if (!str)
+        return '-';
+    let result = '';
+    let width = 0;
+    for (const char of str) {
+        const charWidth = char.charCodeAt(0) > 255 ? 2 : 1;
+        if (width + charWidth > maxWidth)
+            break;
+        result += char;
+        width += charWidth;
+    }
+    return result || '-';
+}
+/**
+ * 格式化时间
+ */
+function formatDate(date) {
+    if (!date)
+        return '-';
+    const d = typeof date === 'string' ? new Date(date) : date;
+    return d.toLocaleString('zh-CN');
+}
+/**
+ * 格式化时长
+ */
+function formatDuration(ms) {
+    if (ms === undefined || ms === null)
+        return '-';
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    if (ms < 3600000)
+        return `${Math.floor(ms / 60000)}m ${Math.floor((ms % 60000) / 1000)}s`;
+    return `${Math.floor(ms / 3600000)}h ${Math.floor((ms % 3600000) / 60000)}m`;
+}
+/**
+ * 获取状态颜色
+ */
+function statusColor(status) {
+    switch (status) {
+        case 'completed':
+            return chalk.green;
+        case 'running':
+        case 'idle':
+            return chalk.blue;
+        case 'paused':
+            return chalk.yellow;
+        case 'failed':
+            return chalk.red;
+        case 'stopped':
+            return chalk.gray;
+        default:
+            return chalk.white;
+    }
+}
+/**
+ * 渲染 Workflow 列表
+ */
+export function renderWorkflowList(workflows, options) {
+    if (options?.json) {
+        return JSON.stringify({
+            workflows: workflows.map(w => ({
+                id: w.id,
+                name: w.name,
+                version: w.version,
+                description: w.description,
+                tags: w.tags,
+                createdAt: w.createdAt.toISOString(),
+                updatedAt: w.updatedAt.toISOString(),
+            })),
+            total: workflows.length,
+        }, null, 2);
+    }
+    if (workflows.length === 0) {
+        return chalk.yellow('No workflows found');
+    }
+    const NAME_WIDTH = 30;
+    const VERSION_WIDTH = 10;
+    const TAGS_WIDTH = 20;
+    const UPDATED_WIDTH = 20;
+    const GAP = '  ';
+    const headerLine = [
+        chalk.bold('NAME'.padEnd(NAME_WIDTH)),
+        chalk.bold('VER'.padEnd(VERSION_WIDTH)),
+        chalk.bold('TAGS'.padEnd(TAGS_WIDTH)),
+        chalk.bold('UPDATED'),
+    ].join(GAP);
+    const sepLine = '─'.repeat(NAME_WIDTH + VERSION_WIDTH + TAGS_WIDTH + UPDATED_WIDTH + GAP.length * 3);
+    const rows = workflows.map(w => {
+        const name = truncateVisual(w.name, NAME_WIDTH).padEnd(NAME_WIDTH);
+        const version = w.version.padEnd(VERSION_WIDTH);
+        const tags = truncateVisual(w.tags.join(', '), TAGS_WIDTH).padEnd(TAGS_WIDTH);
+        const updated = formatDate(w.updatedAt);
+        return `${name}${GAP}${version}${GAP}${tags}${GAP}${updated}`;
+    });
+    return [headerLine, sepLine, ...rows].join('\n');
+}
+/**
+ * 渲染 Workflow 详情
+ */
+export function renderWorkflowDetail(workflow, options) {
+    const lines = [];
+    lines.push(chalk.bold('\n📋 Workflow Details\n'));
+    lines.push(`  ${chalk.cyan('ID:')}          ${workflow.id}`);
+    lines.push(`  ${chalk.cyan('Name:')}        ${workflow.name}`);
+    lines.push(`  ${chalk.cyan('Version:')}     ${workflow.version}`);
+    lines.push(`  ${chalk.cyan('Description:')} ${workflow.description || '-'}`);
+    lines.push(`  ${chalk.cyan('Tags:')}        ${workflow.tags.join(', ') || '-'}`);
+    lines.push(`  ${chalk.cyan('Created:')}     ${formatDate(workflow.createdAt)}`);
+    lines.push(`  ${chalk.cyan('Updated:')}     ${formatDate(workflow.updatedAt)}`);
+    // Nodes summary
+    const nodeCount = workflow.definition.nodes.length;
+    lines.push(chalk.bold('\n📊 Nodes Summary\n'));
+    lines.push(`  Total: ${nodeCount} nodes`);
+    // Group nodes by type
+    const nodesByType = {};
+    for (const node of workflow.definition.nodes) {
+        nodesByType[node.type] = (nodesByType[node.type] || 0) + 1;
+    }
+    for (const [type, count] of Object.entries(nodesByType)) {
+        lines.push(`    - ${type}: ${count}`);
+    }
+    // Config summary
+    if (workflow.definition.config) {
+        lines.push(chalk.bold('\n⚙️  Configuration\n'));
+        if (workflow.definition.config.parallel_limit !== undefined) {
+            lines.push(`  parallel_limit: ${workflow.definition.config.parallel_limit}`);
+        }
+        if (workflow.definition.config.timeout !== undefined) {
+            lines.push(`  timeout: ${workflow.definition.config.timeout}ms`);
+        }
+        if (workflow.definition.config.debug !== undefined) {
+            lines.push(`  debug: ${workflow.definition.config.debug}`);
+        }
+    }
+    // Runs summary (if included)
+    if (options?.includeRuns && options.includeRuns.length > 0) {
+        lines.push(chalk.bold('\n📜 Recent Runs\n'));
+        lines.push(renderRunsList(options.includeRuns.slice(0, 5)));
+    }
+    return lines.join('\n');
+}
+/**
+ * 渲染 Runs 列表
+ */
+export function renderRunsList(runs, options) {
+    if (options?.json) {
+        return JSON.stringify({
+            runs: runs.map(r => ({
+                id: r.id,
+                workflowId: r.workflowId,
+                status: r.status,
+                startedAt: r.startedAt?.toISOString(),
+                completedAt: r.completedAt?.toISOString(),
+                durationMs: r.durationMs,
+                error: r.error,
+            })),
+            total: runs.length,
+        }, null, 2);
+    }
+    if (runs.length === 0) {
+        return chalk.yellow('No runs found');
+    }
+    const ID_WIDTH = 20;
+    const STATUS_WIDTH = 12;
+    const DURATION_WIDTH = 12;
+    const UPDATED_WIDTH = 20;
+    const GAP = '  ';
+    const headerLine = [
+        chalk.bold('RUN ID'.padEnd(ID_WIDTH)),
+        chalk.bold('STATUS'.padEnd(STATUS_WIDTH)),
+        chalk.bold('DURATION'.padEnd(DURATION_WIDTH)),
+        chalk.bold('STARTED'),
+    ].join(GAP);
+    const sepLine = '─'.repeat(ID_WIDTH + STATUS_WIDTH + DURATION_WIDTH + UPDATED_WIDTH + GAP.length * 3);
+    const rows = runs.map(r => {
+        const id = truncateVisual(r.id, ID_WIDTH).padEnd(ID_WIDTH);
+        const status = statusColor(r.status)(r.status.padEnd(STATUS_WIDTH));
+        const duration = formatDuration(r.durationMs).padEnd(DURATION_WIDTH);
+        const started = formatDate(r.startedAt);
+        return `${id}${GAP}${status}${GAP}${duration}${GAP}${started}`;
+    });
+    return [headerLine, sepLine, ...rows].join('\n');
+}
+/**
+ * 渲染 Run 详情
+ */
+export function renderRunDetail(run) {
+    const lines = [];
+    lines.push(chalk.bold('\n🏃 Run Details\n'));
+    lines.push(`  ${chalk.cyan('Run ID:')}     ${run.id}`);
+    lines.push(`  ${chalk.cyan('Workflow:')}  ${run.workflowId}`);
+    lines.push(`  ${chalk.cyan('Status:')}    ${statusColor(run.status)(run.status)}`);
+    lines.push(`  ${chalk.cyan('Started:')}   ${formatDate(run.startedAt)}`);
+    if (run.pausedAt) {
+        lines.push(`  ${chalk.cyan('Paused:')}    ${formatDate(run.pausedAt)}`);
+    }
+    if (run.resumedAt) {
+        lines.push(`  ${chalk.cyan('Resumed:')}   ${formatDate(run.resumedAt)}`);
+    }
+    if (run.stoppedAt) {
+        lines.push(`  ${chalk.cyan('Stopped:')}   ${formatDate(run.stoppedAt)}`);
+    }
+    if (run.completedAt) {
+        lines.push(`  ${chalk.cyan('Completed:')} ${formatDate(run.completedAt)}`);
+    }
+    lines.push(`  ${chalk.cyan('Duration:')}  ${formatDuration(run.durationMs)}`);
+    if (run.error) {
+        lines.push(chalk.bold('\n❌ Error\n'));
+        lines.push(`  ${chalk.red(run.error)}`);
+    }
+    if (run.output) {
+        lines.push(chalk.bold('\n📤 Output\n'));
+        lines.push('  ' + JSON.stringify(run.output, null, 2).split('\n').join('\n  '));
+    }
+    return lines.join('\n');
+}
+/**
+ * 渲染工作流已添加成功
+ */
+export function renderWorkflowAdded(workflow) {
+    return chalk.green(`\n✅ Workflow '${workflow.name}' added successfully\n`) +
+        `   ID: ${workflow.id}\n` +
+        `   Version: ${workflow.version}\n`;
+}
+/**
+ * 渲染工作流已更新成功
+ */
+export function renderWorkflowUpdated(workflow) {
+    return chalk.green(`\n✅ Workflow '${workflow.name}' updated successfully\n`) +
+        `   ID: ${workflow.id}\n`;
+}
+/**
+ * 渲染工作流已删除成功
+ */
+export function renderWorkflowDeleted(name) {
+    return chalk.green(`\n✅ Workflow '${name}' deleted successfully\n`);
+}
+/**
+ * 渲染工作流运行结果
+ */
+export function renderRunResult(result) {
+    const lines = [];
+    if (result.status === 'completed') {
+        lines.push(chalk.green('\n✅ Workflow completed successfully'));
+    }
+    else if (result.status === 'failed') {
+        lines.push(chalk.red('\n❌ Workflow failed'));
+    }
+    else if (result.status === 'stopped') {
+        lines.push(chalk.yellow('\n⚠️  Workflow stopped'));
+    }
+    else {
+        lines.push(chalk.blue(`\n🔄 Workflow ${result.status}`));
+    }
+    lines.push(`   Run ID: ${result.runId}`);
+    if (result.durationMs) {
+        lines.push(`   Duration: ${formatDuration(result.durationMs)}`);
+    }
+    if (result.error) {
+        lines.push(chalk.red(`\n   Error: ${result.error}`));
+    }
+    if (result.output) {
+        lines.push(chalk.bold('\n📤 Output:'));
+        lines.push(JSON.stringify(result.output, null, 2));
+    }
+    return lines.join('\n');
+}
+/**
+ * 渲染节点列表
+ */
+export function renderNodesList(nodes) {
+    const ID_WIDTH = 25;
+    const TYPE_WIDTH = 12;
+    const NAME_WIDTH = 20;
+    const DEPS_WIDTH = 20;
+    const GAP = '  ';
+    const headerLine = [
+        chalk.bold('NODE ID'.padEnd(ID_WIDTH)),
+        chalk.bold('TYPE'.padEnd(TYPE_WIDTH)),
+        chalk.bold('NAME'.padEnd(NAME_WIDTH)),
+        chalk.bold('DEPENDS ON'),
+    ].join(GAP);
+    const sepLine = '─'.repeat(ID_WIDTH + TYPE_WIDTH + NAME_WIDTH + DEPS_WIDTH + GAP.length * 3);
+    const rows = nodes.map(n => {
+        const id = truncateVisual(n.id || '-', ID_WIDTH).padEnd(ID_WIDTH);
+        const type = (n.type || '-').padEnd(TYPE_WIDTH);
+        const name = truncateVisual(n.name || '-', NAME_WIDTH).padEnd(NAME_WIDTH);
+        const deps = n.depends_on?.join(', ') || '-';
+        return `${id}${GAP}${type}${GAP}${name}${GAP}${deps}`;
+    });
+    return [headerLine, sepLine, ...rows].join('\n');
+}
+//# sourceMappingURL=renderers.js.map

package/dist/cli/src/commands/workflow/validators/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview Workflow validators exports
+ */
+export * from './types';
+export * from './node-validator';
+export * from './workflow-validator';
+export * from './node-validator-factory';
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/src/commands/workflow/validators/index.js

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview Workflow validators exports
+ */
+export * from "./types.js";
+export * from "./node-validator.js";
+export * from "./workflow-validator.js";
+export * from "./node-validator-factory.js";
+//# sourceMappingURL=index.js.map

package/dist/cli/src/commands/workflow/validators/node-validator-factory.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @fileoverview Node validator factory
+ */
+import type { NodeValidator } from './node-validator';
+/**
+ * Get validator for a node type
+ */
+export declare function getNodeValidator(type: string): NodeValidator | null;
+/**
+ * Get all supported node types
+ */
+export declare function getSupportedNodeTypes(): string[];
+//# sourceMappingURL=node-validator-factory.d.ts.map

package/dist/cli/src/commands/workflow/validators/node-validator-factory.js

@@ -0,0 +1,35 @@
+/**
+ * @fileoverview Node validator factory
+ */
+import { ToolNodeValidator } from "./nodes/tool-node-validator.js";
+import { SkillNodeValidator } from "./nodes/skill-node-validator.js";
+import { AgentNodeValidator } from "./nodes/agent-node-validator.js";
+import { WorkflowNodeValidator } from "./nodes/workflow-node-validator.js";
+import { ConditionNodeValidator } from "./nodes/condition-node-validator.js";
+import { MergeNodeValidator } from "./nodes/merge-node-validator.js";
+import { DecoratorNodeValidator } from "./nodes/decorator-node-validator.js";
+/**
+ * Registry of node validators
+ */
+const validators = new Map();
+// Register built-in validators
+validators.set('tool', new ToolNodeValidator());
+validators.set('skill', new SkillNodeValidator());
+validators.set('agent', new AgentNodeValidator());
+validators.set('workflow', new WorkflowNodeValidator());
+validators.set('condition', new ConditionNodeValidator());
+validators.set('merge', new MergeNodeValidator());
+validators.set('decorator', new DecoratorNodeValidator());
+/**
+ * Get validator for a node type
+ */
+export function getNodeValidator(type) {
+    return validators.get(type) || null;
+}
+/**
+ * Get all supported node types
+ */
+export function getSupportedNodeTypes() {
+    return Array.from(validators.keys());
+}
+//# sourceMappingURL=node-validator-factory.js.map