@ai-setting/roy-agent-cli 1.3.19 → 1.3.22

package/dist/core/src/env/workflow/service/registry.test.js

@@ -1,90 +0,0 @@
-/**
- * Registry Tests
- */
-import { describe, it, expect, beforeEach } from 'vitest';
-import { WorkflowServiceRegistry, registerWorkflowService, getWorkflowService } from "./registry.js";
-import { WorkflowService } from "./workflow-service.js";
-import { MockWorkflowRepository, MockRunRepository, MockWorkflowEngine } from "../storage/mock-repositories.js";
-describe('WorkflowServiceRegistry', () => {
-    let mockEngine;
-    beforeEach(() => {
-        // Reset registry before each test
-        WorkflowServiceRegistry.getInstance().reset();
-        mockEngine = new MockWorkflowEngine();
-    });
-    const createService = () => new WorkflowService(new MockWorkflowRepository(), new MockRunRepository(), (workflow, options) => mockEngine);
-    describe('getInstance', () => {
-        it('should return the same instance on multiple calls', () => {
-            const instance1 = WorkflowServiceRegistry.getInstance();
-            const instance2 = WorkflowServiceRegistry.getInstance();
-            expect(instance1).toBe(instance2);
-        });
-    });
-    describe('register', () => {
-        it('should register a service', () => {
-            const registry = WorkflowServiceRegistry.getInstance();
-            const service = createService();
-            registry.register(service);
-            expect(registry.isRegistered()).toBe(true);
-        });
-    });
-    describe('get', () => {
-        it('should return the registered service', () => {
-            const registry = WorkflowServiceRegistry.getInstance();
-            const service = createService();
-            registry.register(service);
-            expect(registry.get()).toBe(service);
-        });
-        it('should throw error if no service registered', () => {
-            const registry = WorkflowServiceRegistry.getInstance();
-            expect(() => registry.get()).toThrow('WorkflowService is not registered');
-        });
-    });
-    describe('isRegistered', () => {
-        it('should return false if no service registered', () => {
-            const registry = WorkflowServiceRegistry.getInstance();
-            expect(registry.isRegistered()).toBe(false);
-        });
-        it('should return true after service is registered', () => {
-            const registry = WorkflowServiceRegistry.getInstance();
-            const service = new WorkflowService(new MockWorkflowRepository(), new MockRunRepository(), mockEngine);
-            registry.register(service);
-            expect(registry.isRegistered()).toBe(true);
-        });
-    });
-    describe('reset', () => {
-        it('should reset the registry', () => {
-            const registry = WorkflowServiceRegistry.getInstance();
-            const service = createService();
-            registry.register(service);
-            registry.reset();
-            expect(registry.isRegistered()).toBe(false);
-        });
-    });
-});
-describe('convenience functions', () => {
-    let mockEngine;
-    beforeEach(() => {
-        WorkflowServiceRegistry.getInstance().reset();
-        mockEngine = new MockWorkflowEngine();
-    });
-    const createService = () => new WorkflowService(new MockWorkflowRepository(), new MockRunRepository(), (workflow, options) => mockEngine);
-    describe('registerWorkflowService', () => {
-        it('should register service via convenience function', () => {
-            const service = createService();
-            registerWorkflowService(service);
-            expect(WorkflowServiceRegistry.getInstance().isRegistered()).toBe(true);
-        });
-    });
-    describe('getWorkflowService', () => {
-        it('should get service via convenience function', () => {
-            const service = createService();
-            registerWorkflowService(service);
-            expect(getWorkflowService()).toBe(service);
-        });
-        it('should throw if service not registered', () => {
-            expect(() => getWorkflowService()).toThrow('WorkflowService is not registered');
-        });
-    });
-});
-//# sourceMappingURL=registry.test.js.map

package/dist/core/src/env/workflow/service/workflow-service.d.ts

@@ -1,162 +0,0 @@
-/**
- * WorkflowService - Session-based Workflow Execution
- *
- * After session-based refactoring, workflow runs are managed via SessionComponent.
- * The workflows table is still used for storing workflow definitions.
- *
- * Key concepts:
- * - Session IS a workflow run (no separate runId concept)
- * - Session.metadata stores workflow run state (status, input, agentSessions)
- * - Session.messages stores node execution history with workflow.node.* roles
- * - Resume is based on session state and messages
- */
-import type { Workflow, WorkflowDefinition, RunOptions, RunResult, WorkflowMetadata, WorkflowConfig } from '../types';
-export interface WorkflowRepository {
-    create(workflow: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'>): Workflow;
-    getById(id: string): Workflow | null;
-    getByName(name: string): Workflow | null;
-    list(options?: ListOptions): Workflow[];
-    update(id: string, updates: Partial<Workflow>): Workflow | null;
-    delete(id: string): boolean;
-}
-import type { NodeDefinition } from '../types';
-export interface CreateOptions {
-    tags?: string[];
-    metadata?: WorkflowMetadata;
-    taskId?: number;
-    force?: boolean;
-}
-export interface ListOptions {
-    tag?: string;
-    taskId?: number;
-    search?: string;
-    limit?: number;
-    offset?: number;
-}
-export interface WorkflowUpdates {
-    definition?: WorkflowDefinition;
-    config?: WorkflowConfig;
-    tags?: string[];
-    metadata?: WorkflowMetadata;
-}
-export interface WorkflowEngine {
-    createSession(workflowId: string, options?: {
-        input?: Record<string, any>;
-        workflowName?: string;
-        workflowVersion?: string;
-    }): Promise<string>;
-    run(sessionId: string, options?: RunOptions): Promise<RunResult>;
-    runWorkflow(workflow: Workflow | WorkflowDefinition, options?: RunOptions): Promise<RunResult>;
-    stop(sessionId: string, reason?: string): Promise<void>;
-    addNode(sessionId: string, nodeDefinition: NodeDefinition): Promise<void>;
-    removeNode(sessionId: string, nodeId: string): Promise<void>;
-}
-export type WorkflowEngineFactory = (workflow: Workflow, options?: RunOptions) => Pick<WorkflowEngine, 'run' | 'stop' | 'runWorkflow'>;
-export interface SessionInfo {
-    id: string;
-    title: string;
-    metadata: WorkflowSessionMetadata;
-    createdAt: Date;
-    updatedAt: Date;
-}
-export interface WorkflowSessionMetadata {
-    type: 'workflow';
-    runId?: string;
-    workflowId?: string;
-    workflowName: string;
-    workflowVersion?: string;
-    status: 'running' | 'paused' | 'completed' | 'failed';
-    input?: any;
-    rootNodeId?: string;
-    agentSessions?: AgentSessionRef[];
-}
-export interface AgentSessionRef {
-    nodeId: string;
-    sessionId: string;
-    status: 'active' | 'paused' | 'completed';
-}
-export declare class WorkflowService {
-    private workflowRepository;
-    private engineFactory;
-    private sessionComponent?;
-    constructor(workflowRepository: WorkflowRepository, engineFactory: WorkflowEngineFactory, sessionComponent?: {
-        create(options: {
-            id?: string;
-            title: string;
-            metadata: any;
-        }): Promise<{
-            id: string;
-        }>;
-        get(id: string): Promise<SessionInfo | null | undefined>;
-        list?(options?: {
-            limit?: number;
-            offset?: number;
-        }): Promise<SessionInfo[]>;
-        update(id: string, updates: {
-            metadata?: any;
-        }): Promise<boolean>;
-        addMessage(sessionId: string, message: any): Promise<string>;
-        getMessages(sessionId: string): Promise<any[]>;
-    });
-    /**
-     * Create a new workflow from definition
-     */
-    createWorkflow(definition: WorkflowDefinition, options?: CreateOptions): Promise<Workflow>;
-    /**
-     * Get workflow by id or name
-     */
-    getWorkflow(idOrName: string): Workflow | null;
-    /**
-     * Get workflow by id
-     */
-    getWorkflowById(id: string): Workflow | null;
-    /**
-     * Get workflow by name
-     */
-    getWorkflowByName(name: string): Workflow | null;
-    /**
-     * List workflows with optional filters
-     */
-    listWorkflows(options?: ListOptions): Workflow[];
-    /**
-     * Update an existing workflow
-     */
-    updateWorkflow(idOrName: string, updates: WorkflowUpdates, options?: {
-        tags?: string[];
-    }): Promise<Workflow>;
-    /**
-     * Delete a workflow by name or id
-     */
-    deleteWorkflow(idOrName: string): Promise<boolean>;
-    /**
-     * Run a workflow by definition or name
-     *
-     * This creates a Session that represents the workflow run.
-     * The Session ID is used as the run identifier for pause/resume.
-     */
-    runWorkflow(idOrNameOrDefinition: string | WorkflowDefinition, input?: Record<string, any>, options?: RunOptions): Promise<RunResult>;
-    /**
-     * Run workflow by name (convenience method)
-     */
-    runWorkflowByName(name: string, input?: Record<string, any>, options?: RunOptions): Promise<RunResult>;
-    /**
-     * Stop a running workflow session
-     */
-    stopRun(sessionId: string, reason?: string): Promise<void>;
-    /**
-     * Get workflow session by ID
-     */
-    getSession(sessionId: string): Promise<SessionInfo | null>;
-    /**
-     * List workflow sessions
-     */
-    listSessions(options?: {
-        limit?: number;
-        offset?: number;
-    }): Promise<SessionInfo[]>;
-    /**
-     * Get messages from a workflow session
-     */
-    getSessionMessages(sessionId: string): Promise<any[]>;
-}
-//# sourceMappingURL=workflow-service.d.ts.map

package/dist/core/src/env/workflow/service/workflow-service.js

@@ -1,244 +0,0 @@
-/**
- * WorkflowService - Session-based Workflow Execution
- *
- * After session-based refactoring, workflow runs are managed via SessionComponent.
- * The workflows table is still used for storing workflow definitions.
- *
- * Key concepts:
- * - Session IS a workflow run (no separate runId concept)
- * - Session.metadata stores workflow run state (status, input, agentSessions)
- * - Session.messages stores node execution history with workflow.node.* roles
- * - Resume is based on session state and messages
- */
-// ==================== WorkflowService ====================
-export class WorkflowService {
-    workflowRepository;
-    engineFactory;
-    sessionComponent;
-    constructor(workflowRepository, engineFactory, sessionComponent) {
-        this.workflowRepository = workflowRepository;
-        this.engineFactory = engineFactory;
-        this.sessionComponent = sessionComponent;
-    }
-    // ==================== Workflow CRUD ====================
-    /**
-     * Create a new workflow from definition
-     */
-    async createWorkflow(definition, options) {
-        // Check if workflow with same name exists
-        const existing = this.workflowRepository.getByName(definition.name);
-        if (existing) {
-            if (options?.force !== true) {
-                throw new Error(`Workflow already exists: ${definition.name}`);
-            }
-            // Update existing workflow
-            return this.workflowRepository.update(existing.id, {
-                name: definition.name,
-                version: definition.version,
-                description: definition.description || existing.description,
-                definition,
-                config: definition.config || {},
-                metadata: {
-                    ...options.metadata || definition.metadata || existing.metadata || {},
-                    taskId: options.taskId || definition.metadata?.taskId || existing.metadata?.taskId,
-                },
-                tags: options.tags || definition.metadata?.tags || [],
-            });
-        }
-        // Create new workflow
-        const workflow = {
-            name: definition.name,
-            version: definition.version,
-            description: definition.description,
-            definition,
-            config: definition.config || {},
-            metadata: {
-                ...options?.metadata || definition.metadata || {},
-                taskId: options?.taskId || definition.metadata?.taskId,
-            },
-            tags: options?.tags || definition.metadata?.tags || [],
-        };
-        return this.workflowRepository.create(workflow);
-    }
-    /**
-     * Get workflow by id or name
-     */
-    getWorkflow(idOrName) {
-        // Try by id first
-        let workflow = this.workflowRepository.getById(idOrName);
-        if (workflow)
-            return workflow;
-        // Then try by name
-        return this.workflowRepository.getByName(idOrName);
-    }
-    /**
-     * Get workflow by id
-     */
-    getWorkflowById(id) {
-        return this.workflowRepository.getById(id);
-    }
-    /**
-     * Get workflow by name
-     */
-    getWorkflowByName(name) {
-        return this.workflowRepository.getByName(name);
-    }
-    /**
-     * List workflows with optional filters
-     */
-    listWorkflows(options) {
-        return this.workflowRepository.list(options);
-    }
-    /**
-     * Update an existing workflow
-     */
-    async updateWorkflow(idOrName, updates, options) {
-        // Find the workflow
-        let workflow = this.workflowRepository.getByName(idOrName);
-        if (!workflow) {
-            workflow = this.workflowRepository.getById(idOrName);
-        }
-        if (!workflow) {
-            throw new Error(`Workflow not found: ${idOrName}`);
-        }
-        const updateData = {
-            ...updates,
-        };
-        if (options?.tags !== undefined) {
-            updateData.tags = options.tags;
-        }
-        const updated = this.workflowRepository.update(workflow.id, updateData);
-        if (!updated) {
-            throw new Error(`Failed to update workflow: ${idOrName}`);
-        }
-        return updated;
-    }
-    /**
-     * Delete a workflow by name or id
-     */
-    async deleteWorkflow(idOrName) {
-        // Find the workflow
-        let workflow = this.workflowRepository.getByName(idOrName);
-        if (!workflow) {
-            workflow = this.workflowRepository.getById(idOrName);
-        }
-        if (!workflow) {
-            return false;
-        }
-        return this.workflowRepository.delete(workflow.id);
-    }
-    // ==================== Workflow Execution (Session-based) ====================
-    /**
-     * Run a workflow by definition or name
-     *
-     * This creates a Session that represents the workflow run.
-     * The Session ID is used as the run identifier for pause/resume.
-     */
-    async runWorkflow(idOrNameOrDefinition, input, options) {
-        // Resolve workflow
-        let workflow = null;
-        let definition = null;
-        if (typeof idOrNameOrDefinition === 'string') {
-            // Running by name - workflow must exist
-            workflow = this.getWorkflow(idOrNameOrDefinition);
-            if (!workflow) {
-                throw new Error(`Workflow not found: ${idOrNameOrDefinition}`);
-            }
-            definition = workflow.definition;
-        }
-        else {
-            // Running by definition - create inline workflow if needed
-            definition = idOrNameOrDefinition;
-            workflow = this.getWorkflowByName(definition.name);
-            // If workflow doesn't exist, create a temporary one for execution
-            if (!workflow) {
-                workflow = {
-                    id: `wf_inline_${definition.name}`,
-                    name: definition.name,
-                    version: definition.version,
-                    description: definition.description,
-                    definition,
-                    config: definition.config || {},
-                    metadata: definition.metadata || {},
-                    tags: definition.metadata?.tags || [],
-                    createdAt: new Date(),
-                    updatedAt: new Date(),
-                };
-            }
-        }
-        // Create engine and run workflow directly
-        // Note: engine.runWorkflow() handles session creation and state management
-        const engine = this.engineFactory(workflow, {
-            ...options,
-            input,
-        });
-        // Run the workflow (this creates the session internally)
-        const result = await engine.runWorkflow(workflow, {
-            ...options,
-            input,
-        });
-        return {
-            ...result,
-            runId: result.runId || result.sessionId || '',
-            sessionId: result.sessionId || result.runId || '',
-        };
-    }
-    /**
-     * Run workflow by name (convenience method)
-     */
-    async runWorkflowByName(name, input, options) {
-        const workflow = this.getWorkflowByName(name);
-        if (!workflow) {
-            throw new Error(`Workflow not found: ${name}`);
-        }
-        return this.runWorkflow(name, input, options);
-    }
-    /**
-     * Stop a running workflow session
-     */
-    async stopRun(sessionId, reason) {
-        const session = await this.sessionComponent?.get(sessionId);
-        if (!session) {
-            throw new Error(`Session not found: ${sessionId}`);
-        }
-        const metadata = session.metadata;
-        if (metadata.type !== 'workflow') {
-            throw new Error(`Session is not a workflow session: ${sessionId}`);
-        }
-        const workflow = this.getWorkflowByName(metadata.workflowName);
-        if (!workflow) {
-            throw new Error(`Workflow not found: ${metadata.workflowName}`);
-        }
-        const engine = this.engineFactory(workflow);
-        await engine.stop(sessionId, reason);
-    }
-    /**
-     * Get workflow session by ID
-     */
-    async getSession(sessionId) {
-        if (!this.sessionComponent) {
-            return null;
-        }
-        const session = await this.sessionComponent.get(sessionId);
-        return session ?? null;
-    }
-    /**
-     * List workflow sessions
-     */
-    async listSessions(options) {
-        if (!this.sessionComponent?.list) {
-            return [];
-        }
-        return this.sessionComponent.list(options);
-    }
-    /**
-     * Get messages from a workflow session
-     */
-    async getSessionMessages(sessionId) {
-        if (!this.sessionComponent) {
-            return [];
-        }
-        return this.sessionComponent.getMessages(sessionId);
-    }
-}
-//# sourceMappingURL=workflow-service.js.map

package/dist/core/src/env/workflow/service/workflow-service.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * WorkflowService Tests - Session-based Design
- */
-export {};
-//# sourceMappingURL=workflow-service.test.d.ts.map