@exaudeus/workrail 0.8.6 → 0.9.0

package/dist/application/use-cases/get-next-step.js

@@ -1,12 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createGetNextStep = createGetNextStep;
-exports.getNextStep = getNextStep;
 function createGetNextStep(service) {
-    return async (workflowId, completedSteps, context) => {
-        return service.getNextStep(workflowId, completedSteps, context);
+    return async (workflowId, state, event, context) => {
+        return service.getNextStep(workflowId, state, event, context);
     };
 }
-async function getNextStep(service, workflowId, completedSteps, context) {
-    return createGetNextStep(service)(workflowId, completedSteps, context);
-}

package/dist/application/use-cases/get-workflow.d.ts

@@ -1,19 +1,21 @@
 import { WorkflowService } from '../services/workflow-service';
-import { Workflow, WorkflowStep } from '../../types/mcp-types';
+import { Workflow, WorkflowStepDefinition } from '../../types/workflow';
+import { type Result } from '../../domain/execution/result';
+import { type DomainError } from '../../domain/execution/error';
 export type WorkflowGetMode = 'metadata' | 'preview' | undefined;
 export interface WorkflowMetadata {
     id: string;
     name: string;
     description: string;
     version: string;
-    preconditions?: string[] | undefined;
-    clarificationPrompts?: string[] | undefined;
-    metaGuidance?: string[] | undefined;
+    preconditions?: readonly string[];
+    clarificationPrompts?: readonly string[];
+    metaGuidance?: readonly string[];
     totalSteps: number;
 }
 export interface WorkflowPreview extends WorkflowMetadata {
-    firstStep: WorkflowStep | null;
+    firstStep: WorkflowStepDefinition | null;
 }
 export type WorkflowGetResult = Workflow | WorkflowMetadata | WorkflowPreview;
-export declare function createGetWorkflow(service: WorkflowService): (workflowId: string, mode?: WorkflowGetMode) => Promise<WorkflowGetResult>;
+export declare function createGetWorkflow(service: WorkflowService): (workflowId: string, mode?: WorkflowGetMode) => Promise<Result<WorkflowGetResult, DomainError>>;
 export declare function getWorkflow(service: WorkflowService, workflowId: string): Promise<Workflow>;

package/dist/application/use-cases/get-workflow.js

@@ -3,50 +3,59 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createGetWorkflow = createGetWorkflow;
 exports.getWorkflow = getWorkflow;
 const error_handler_1 = require("../../core/error-handler");
-const condition_evaluator_1 = require("../../utils/condition-evaluator");
+const state_1 = require("../../domain/execution/state");
+const result_1 = require("../../domain/execution/result");
+const error_1 = require("../../domain/execution/error");
 function createGetWorkflow(service) {
     return async (workflowId, mode = 'preview') => {
         const workflow = await service.getWorkflowById(workflowId);
         if (!workflow) {
-            throw new error_handler_1.WorkflowNotFoundError(workflowId);
+            return (0, result_1.err)(error_1.Err.workflowNotFound(workflowId));
         }
+        const optional = {
+            ...(workflow.definition.preconditions !== undefined
+                ? { preconditions: workflow.definition.preconditions }
+                : {}),
+            ...(workflow.definition.clarificationPrompts !== undefined
+                ? { clarificationPrompts: workflow.definition.clarificationPrompts }
+                : {}),
+            ...(workflow.definition.metaGuidance !== undefined
+                ? { metaGuidance: workflow.definition.metaGuidance }
+                : {}),
+        };
         switch (mode) {
             case 'metadata':
-                return {
-                    id: workflow.id,
-                    name: workflow.name,
-                    description: workflow.description,
-                    version: workflow.version,
-                    preconditions: workflow.preconditions,
-                    clarificationPrompts: workflow.clarificationPrompts,
-                    metaGuidance: workflow.metaGuidance,
-                    totalSteps: workflow.steps.length
-                };
+                return (0, result_1.ok)({
+                    id: workflow.definition.id,
+                    name: workflow.definition.name,
+                    description: workflow.definition.description,
+                    version: workflow.definition.version,
+                    ...optional,
+                    totalSteps: workflow.definition.steps.length,
+                });
             case 'preview':
             default:
-                const firstStep = findFirstEligibleStep(workflow.steps);
-                return {
-                    id: workflow.id,
-                    name: workflow.name,
-                    description: workflow.description,
-                    version: workflow.version,
-                    preconditions: workflow.preconditions,
-                    clarificationPrompts: workflow.clarificationPrompts,
-                    metaGuidance: workflow.metaGuidance,
-                    totalSteps: workflow.steps.length,
-                    firstStep
-                };
+                const next = await service.getNextStep(workflowId, (0, state_1.initialExecutionState)(), undefined, {});
+                const firstStep = next.isOk() ? (next.value.next ? next.value.next.step : null) : null;
+                return (0, result_1.ok)({
+                    id: workflow.definition.id,
+                    name: workflow.definition.name,
+                    description: workflow.definition.description,
+                    version: workflow.definition.version,
+                    ...optional,
+                    totalSteps: workflow.definition.steps.length,
+                    firstStep,
+                });
         }
     };
 }
-function findFirstEligibleStep(steps, context = {}) {
-    return steps.find((step) => {
-        if (step.runCondition) {
-            return (0, condition_evaluator_1.evaluateCondition)(step.runCondition, context);
-        }
-        return true;
-    }) || null;
-}
 async function getWorkflow(service, workflowId) {
-    return createGetWorkflow(service)(workflowId, 'preview');
+    const result = await createGetWorkflow(service)(workflowId, 'preview');
+    if (result.isErr()) {
+        if (result.error._tag === 'WorkflowNotFound') {
+            throw new error_handler_1.WorkflowNotFoundError(workflowId);
+        }
+        throw new Error(result.error.message);
+    }
+    return result.value;
 }

package/dist/application/use-cases/list-workflows.d.ts

@@ -1,4 +1,4 @@
 import { WorkflowService } from '../services/workflow-service';
-import { WorkflowSummary } from '../../types/mcp-types';
-export declare function createListWorkflows(service: WorkflowService): () => Promise<WorkflowSummary[]>;
-export declare function listWorkflows(service: WorkflowService): Promise<WorkflowSummary[]>;
+import { WorkflowSummary } from '../../types/workflow';
+export declare function createListWorkflows(service: WorkflowService): () => Promise<readonly WorkflowSummary[]>;
+export declare function listWorkflows(service: WorkflowService): Promise<readonly WorkflowSummary[]>;

package/dist/application/use-cases/validate-step-output.d.ts

@@ -1,11 +1,11 @@
 import { WorkflowService } from '../services/workflow-service';
 export declare function createValidateStepOutput(service: WorkflowService): (workflowId: string, stepId: string, output: string) => Promise<{
     valid: boolean;
-    issues: string[];
-    suggestions: string[];
+    issues: readonly string[];
+    suggestions: readonly string[];
 }>;
 export declare function validateStepOutput(service: WorkflowService, workflowId: string, stepId: string, output: string): Promise<{
     valid: boolean;
-    issues: string[];
-    suggestions: string[];
+    issues: readonly string[];
+    suggestions: readonly string[];
 }>;

package/dist/application/use-cases/validate-workflow-file.d.ts

@@ -0,0 +1,46 @@
+import type { Workflow, WorkflowDefinition } from '../../types/workflow.js';
+import type { ValidationResult } from '../../types/validation.js';
+export interface SchemaValidationResult {
+    readonly valid: boolean;
+    readonly errors: readonly string[];
+}
+export type ValidateWorkflowFileResult = {
+    kind: 'file_not_found';
+    filePath: string;
+} | {
+    kind: 'read_error';
+    filePath: string;
+    message: string;
+    code?: string;
+} | {
+    kind: 'json_parse_error';
+    filePath: string;
+    message: string;
+} | {
+    kind: 'schema_invalid';
+    filePath: string;
+    errors: readonly string[];
+} | {
+    kind: 'valid';
+    filePath: string;
+    warnings?: readonly string[];
+    info?: readonly string[];
+    suggestions?: readonly string[];
+} | {
+    kind: 'structural_invalid';
+    filePath: string;
+    issues: readonly string[];
+    warnings?: readonly string[];
+    info?: readonly string[];
+    suggestions?: readonly string[];
+};
+export interface ValidateWorkflowFileDeps {
+    readonly resolvePath: (filePath: string) => string;
+    readonly existsSync: (resolvedPath: string) => boolean;
+    readonly readFileSyncUtf8: (resolvedPath: string) => string;
+    readonly parseJson: (content: string) => unknown;
+    readonly schemaValidate: (definition: WorkflowDefinition) => SchemaValidationResult;
+    readonly makeRuntimeWorkflow: (definition: WorkflowDefinition, resolvedPath: string) => Workflow;
+    readonly validateRuntimeWorkflow: (workflow: Workflow) => ValidationResult;
+}
+export declare function createValidateWorkflowFileUseCase(deps: ValidateWorkflowFileDeps): (filePath: string) => ValidateWorkflowFileResult;

package/dist/application/use-cases/validate-workflow-file.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createValidateWorkflowFileUseCase = createValidateWorkflowFileUseCase;
+function createValidateWorkflowFileUseCase(deps) {
+    return function validateWorkflowFile(filePath) {
+        const resolvedPath = deps.resolvePath(filePath);
+        if (!deps.existsSync(resolvedPath)) {
+            return { kind: 'file_not_found', filePath };
+        }
+        let content;
+        try {
+            content = deps.readFileSyncUtf8(resolvedPath);
+        }
+        catch (err) {
+            return {
+                kind: 'read_error',
+                filePath,
+                message: err?.message ?? String(err),
+                code: err?.code,
+            };
+        }
+        let parsed;
+        try {
+            parsed = deps.parseJson(content);
+        }
+        catch (err) {
+            return { kind: 'json_parse_error', filePath, message: err?.message ?? String(err) };
+        }
+        const definition = parsed;
+        const schemaResult = deps.schemaValidate(definition);
+        if (!schemaResult.valid) {
+            return { kind: 'schema_invalid', filePath, errors: schemaResult.errors };
+        }
+        const runtimeWorkflow = deps.makeRuntimeWorkflow(definition, resolvedPath);
+        const structural = deps.validateRuntimeWorkflow(runtimeWorkflow);
+        if (structural.valid) {
+            const warnings = structural.warnings?.length ? structural.warnings : undefined;
+            const info = structural.info?.length ? structural.info : undefined;
+            const suggestions = structural.suggestions.length ? structural.suggestions : undefined;
+            return {
+                kind: 'valid',
+                filePath,
+                warnings,
+                info,
+                suggestions,
+            };
+        }
+        return {
+            kind: 'structural_invalid',
+            filePath,
+            issues: structural.issues,
+            warnings: structural.warnings,
+            info: structural.info,
+            suggestions: structural.suggestions.length ? structural.suggestions : undefined,
+        };
+    };
+}

package/dist/cli/commands/cleanup.d.ts

@@ -0,0 +1,8 @@
+import type { CliResult } from '../types/cli-result.js';
+export interface CleanupCommandDeps {
+    readonly fullCleanup: () => Promise<number>;
+}
+export interface CleanupCommandOptions {
+    readonly force?: boolean;
+}
+export declare function executeCleanupCommand(deps: CleanupCommandDeps, _options?: CleanupCommandOptions): Promise<CliResult>;

package/dist/cli/commands/cleanup.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeCleanupCommand = executeCleanupCommand;
+const cli_result_js_1 = require("../types/cli-result.js");
+async function executeCleanupCommand(deps, _options = {}) {
+    try {
+        const count = await deps.fullCleanup();
+        if (count > 0) {
+            return (0, cli_result_js_1.success)({
+                message: `Cleaned up ${count} orphaned process(es)`,
+            });
+        }
+        return (0, cli_result_js_1.success)({
+            message: 'No orphaned processes found',
+        });
+    }
+    catch (error) {
+        return (0, cli_result_js_1.failure)(`Cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

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

@@ -0,0 +1,7 @@
+export { executeInitCommand, type InitCommandDeps } from './init.js';
+export { executeSourcesCommand, getWorkflowSources, type SourcesCommandDeps, type WorkflowSource } from './sources.js';
+export { executeListCommand, type ListCommandDeps, type ListCommandOptions } from './list.js';
+export { executeValidateCommand, type ValidateCommandDeps } from './validate.js';
+export { executeStartCommand, type StartCommandDeps, type RpcServer } from './start.js';
+export { executeCleanupCommand, type CleanupCommandDeps, type CleanupCommandOptions } from './cleanup.js';
+export { executeMigrateCommand, migrateWorkflow, migrateWorkflowFile, detectWorkflowVersion, type MigrationResult, type FileMigrationResult, type MigrateCommandOptions, type MigrateFileDeps, type MigrateFileOptions, } from './migrate.js';

package/dist/cli/commands/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectWorkflowVersion = exports.migrateWorkflowFile = exports.migrateWorkflow = exports.executeMigrateCommand = exports.executeCleanupCommand = exports.executeStartCommand = exports.executeValidateCommand = exports.executeListCommand = exports.getWorkflowSources = exports.executeSourcesCommand = exports.executeInitCommand = void 0;
+var init_js_1 = require("./init.js");
+Object.defineProperty(exports, "executeInitCommand", { enumerable: true, get: function () { return init_js_1.executeInitCommand; } });
+var sources_js_1 = require("./sources.js");
+Object.defineProperty(exports, "executeSourcesCommand", { enumerable: true, get: function () { return sources_js_1.executeSourcesCommand; } });
+Object.defineProperty(exports, "getWorkflowSources", { enumerable: true, get: function () { return sources_js_1.getWorkflowSources; } });
+var list_js_1 = require("./list.js");
+Object.defineProperty(exports, "executeListCommand", { enumerable: true, get: function () { return list_js_1.executeListCommand; } });
+var validate_js_1 = require("./validate.js");
+Object.defineProperty(exports, "executeValidateCommand", { enumerable: true, get: function () { return validate_js_1.executeValidateCommand; } });
+var start_js_1 = require("./start.js");
+Object.defineProperty(exports, "executeStartCommand", { enumerable: true, get: function () { return start_js_1.executeStartCommand; } });
+var cleanup_js_1 = require("./cleanup.js");
+Object.defineProperty(exports, "executeCleanupCommand", { enumerable: true, get: function () { return cleanup_js_1.executeCleanupCommand; } });
+var migrate_js_1 = require("./migrate.js");
+Object.defineProperty(exports, "executeMigrateCommand", { enumerable: true, get: function () { return migrate_js_1.executeMigrateCommand; } });
+Object.defineProperty(exports, "migrateWorkflow", { enumerable: true, get: function () { return migrate_js_1.migrateWorkflow; } });
+Object.defineProperty(exports, "migrateWorkflowFile", { enumerable: true, get: function () { return migrate_js_1.migrateWorkflowFile; } });
+Object.defineProperty(exports, "detectWorkflowVersion", { enumerable: true, get: function () { return migrate_js_1.detectWorkflowVersion; } });

package/dist/cli/commands/init.d.ts

@@ -0,0 +1,11 @@
+import type { CliResult } from '../types/cli-result.js';
+export interface InitCommandDeps {
+    readonly mkdir: (path: string, options: {
+        recursive: boolean;
+    }) => Promise<string | undefined>;
+    readonly readdir: (path: string) => Promise<string[]>;
+    readonly writeFile: (path: string, content: string) => Promise<void>;
+    readonly homedir: () => string;
+    readonly joinPath: (...paths: string[]) => string;
+}
+export declare function executeInitCommand(deps: InitCommandDeps): Promise<CliResult>;

package/dist/cli/commands/init.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeInitCommand = executeInitCommand;
+const cli_result_js_1 = require("../types/cli-result.js");
+const SAMPLE_WORKFLOW = {
+    id: 'my-custom-workflow',
+    name: 'My Custom Workflow',
+    description: 'A template for creating custom workflows',
+    version: '1.0.0',
+    steps: [
+        {
+            id: 'step-1',
+            title: 'First Step',
+            prompt: 'Replace this with your custom step',
+            agentRole: 'You are helping the user with their custom workflow',
+        },
+    ],
+};
+async function executeInitCommand(deps) {
+    const userDir = deps.joinPath(deps.homedir(), '.workrail', 'workflows');
+    try {
+        await deps.mkdir(userDir, { recursive: true });
+        const entries = await deps.readdir(userDir);
+        if (entries.length === 0) {
+            const samplePath = deps.joinPath(userDir, 'my-custom-workflow.json');
+            await deps.writeFile(samplePath, JSON.stringify(SAMPLE_WORKFLOW, null, 2));
+        }
+        return (0, cli_result_js_1.success)({
+            message: 'User workflow directory initialized',
+            details: [
+                `Directory: ${userDir}`,
+                entries.length === 0
+                    ? 'Created sample workflow: my-custom-workflow.json'
+                    : `Found ${entries.length} existing file(s)`,
+            ],
+            suggestions: [
+                'Edit the sample workflow in the directory above',
+                'Create new workflow JSON files following the schema',
+                'Run "workrail list" to see your workflows',
+                'Use "workrail validate <file>" to check your workflow syntax',
+            ],
+        });
+    }
+    catch (error) {
+        return (0, cli_result_js_1.failure)(`Failed to initialize user workflow directory: ${error instanceof Error ? error.message : String(error)}`, {
+            suggestions: ['Check that you have write permissions to your home directory'],
+        });
+    }
+}

package/dist/cli/commands/list.d.ts

@@ -0,0 +1,9 @@
+import type { CliResult } from '../types/cli-result.js';
+import type { WorkflowSummary } from '../../types/workflow.js';
+export interface ListCommandDeps {
+    readonly listWorkflowSummaries: () => Promise<readonly WorkflowSummary[]>;
+}
+export interface ListCommandOptions {
+    readonly verbose?: boolean;
+}
+export declare function executeListCommand(deps: ListCommandDeps, options?: ListCommandOptions): Promise<CliResult>;

package/dist/cli/commands/list.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeListCommand = executeListCommand;
+const cli_result_js_1 = require("../types/cli-result.js");
+async function executeListCommand(deps, options = {}) {
+    try {
+        const workflows = await deps.listWorkflowSummaries();
+        if (workflows.length === 0) {
+            return (0, cli_result_js_1.success)({
+                message: 'No workflows found',
+                suggestions: ['Run "workrail init" to create your first workflow'],
+            });
+        }
+        const details = workflows.flatMap((workflow, index) => {
+            const lines = [
+                `${index + 1}. ${workflow.name}`,
+                `   ID: ${workflow.id}`,
+                `   ${workflow.description}`,
+            ];
+            if (options.verbose) {
+                lines.push(`   Version: ${workflow.version}`);
+            }
+            return lines;
+        });
+        details.push(``, `Total: ${workflows.length} workflows`);
+        return (0, cli_result_js_1.success)({
+            message: 'Available workflows',
+            details,
+        });
+    }
+    catch (error) {
+        return (0, cli_result_js_1.failure)(`Failed to list workflows: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/cli/commands/migrate.d.ts

@@ -0,0 +1,78 @@
+import type { WorkflowDefinition } from '../../types/workflow-definition.js';
+import type { CliResult } from '../types/cli-result.js';
+export type MigrationResult = {
+    kind: 'migrated';
+    originalVersion: string;
+    targetVersion: string;
+    changes: readonly string[];
+    warnings: readonly string[];
+    workflow: WorkflowDefinition;
+} | {
+    kind: 'already_current';
+    version: string;
+    workflow: WorkflowDefinition;
+} | {
+    kind: 'cannot_downgrade';
+    originalVersion: string;
+    targetVersion: string;
+} | {
+    kind: 'invalid_workflow';
+    errors: readonly string[];
+} | {
+    kind: 'migration_error';
+    message: string;
+};
+export type FileMigrationResult = {
+    kind: 'file_migrated';
+    migration: Extract<MigrationResult, {
+        kind: 'migrated';
+    }>;
+    outputPath: string;
+    backupPath?: string;
+} | {
+    kind: 'file_already_current';
+    migration: Extract<MigrationResult, {
+        kind: 'already_current';
+    }>;
+} | {
+    kind: 'dry_run';
+    migration: Extract<MigrationResult, {
+        kind: 'migrated' | 'already_current';
+    }>;
+} | {
+    kind: 'file_read_error';
+    message: string;
+} | {
+    kind: 'file_parse_error';
+    message: string;
+} | {
+    kind: 'file_write_error';
+    message: string;
+} | {
+    kind: 'backup_error';
+    message: string;
+} | {
+    kind: 'migration_failed';
+    migration: Exclude<MigrationResult, {
+        kind: 'migrated' | 'already_current';
+    }>;
+};
+export declare function detectWorkflowVersion(workflow: unknown): string;
+export declare function migrateWorkflow(workflow: unknown): MigrationResult;
+export interface MigrateFileDeps {
+    readonly readFile: (path: string) => Promise<string>;
+    readonly writeFile: (path: string, content: string) => Promise<void>;
+    readonly copyFile: (src: string, dest: string) => Promise<void>;
+}
+export interface MigrateFileOptions {
+    readonly outputPath?: string;
+    readonly dryRun?: boolean;
+    readonly backup?: boolean;
+}
+export declare function migrateWorkflowFile(inputPath: string, options: MigrateFileOptions, deps: MigrateFileDeps): Promise<FileMigrationResult>;
+export interface MigrateCommandOptions {
+    readonly output?: string;
+    readonly dryRun?: boolean;
+    readonly backup?: boolean;
+}
+export declare function executeMigrateCommand(filePath: string, options: MigrateCommandOptions, deps: MigrateFileDeps): Promise<CliResult>;