@exaudeus/workrail 0.8.6 → 0.9.0

package/dist/mcp/error-mapper.d.ts

@@ -0,0 +1,9 @@
+import type { DomainError } from '../domain/execution/error.js';
+import type { ErrorCode } from './types.js';
+export interface ToolErrorMapping {
+    readonly code: ErrorCode;
+    readonly message: string;
+    readonly suggestion?: string;
+}
+export declare function mapDomainErrorToToolError(err: DomainError): ToolErrorMapping;
+export declare function mapUnknownErrorToToolError(err: unknown): ToolErrorMapping;

package/dist/mcp/error-mapper.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapDomainErrorToToolError = mapDomainErrorToToolError;
+exports.mapUnknownErrorToToolError = mapUnknownErrorToToolError;
+const bounded_json_js_1 = require("./validation/bounded-json.js");
+function assertNever(x) {
+    throw new Error(`Unhandled DomainError variant: ${JSON.stringify(x)}`);
+}
+function mapDomainErrorToToolError(err) {
+    switch (err._tag) {
+        case 'WorkflowNotFound':
+            return {
+                code: 'NOT_FOUND',
+                message: err.message,
+                suggestion: `Check available workflows with workflow_list`,
+            };
+        case 'InvalidState':
+            return {
+                code: 'VALIDATION_ERROR',
+                message: err.message,
+                suggestion: `Use the "state" returned by the last workflow_next call.\n` +
+                    `If you are completing a step, send an event like:\n` +
+                    (0, bounded_json_js_1.toBoundedJsonString)({
+                        kind: 'step_completed',
+                        stepInstanceId: {
+                            stepId: '<previous next.stepInstanceId.stepId>',
+                            loopPath: [],
+                        },
+                    }, 512),
+            };
+        case 'InvalidLoop':
+            return {
+                code: 'VALIDATION_ERROR',
+                message: err.message,
+                suggestion: 'Validate the workflow definition and ensure loop/body step IDs are consistent',
+            };
+        case 'MissingContext':
+            return {
+                code: 'PRECONDITION_FAILED',
+                message: err.message,
+                suggestion: 'Provide the required keys in the `context` object for condition evaluation and loop inputs.\n' +
+                    'Example:\n' +
+                    (0, bounded_json_js_1.toBoundedJsonString)({ context: { '<requiredKey>': '<value>' } }, 256),
+            };
+        case 'ConditionEvalFailed':
+            return {
+                code: 'INTERNAL_ERROR',
+                message: err.message,
+                suggestion: 'Validate workflow JSON and condition expressions with workflow_validate_json',
+            };
+        case 'MaxIterationsExceeded':
+            return {
+                code: 'PRECONDITION_FAILED',
+                message: err.message,
+                suggestion: `Increase maxIterations for loop '${err.loopId}' or adjust its condition/body`,
+            };
+        default:
+            return assertNever(err);
+    }
+}
+function mapUnknownErrorToToolError(err) {
+    if (err instanceof Error) {
+        return { code: 'INTERNAL_ERROR', message: err.message };
+    }
+    return { code: 'INTERNAL_ERROR', message: String(err) };
+}

package/dist/mcp/handlers/session.d.ts

@@ -0,0 +1,34 @@
+import type { ToolContext, ToolResult } from '../types.js';
+import type { CreateSessionInput, UpdateSessionInput, ReadSessionInput, OpenDashboardInput } from '../tools.js';
+export interface CreateSessionOutput {
+    sessionId: string;
+    workflowId: string;
+    path: string;
+    dashboardUrl: string | null;
+    createdAt: string;
+}
+export interface UpdateSessionOutput {
+    updatedAt: string;
+}
+export interface ReadSessionOutput {
+    query: string;
+    data: unknown;
+}
+export interface SchemaOverview {
+    description: string;
+    mainSections: Record<string, string>;
+    commonQueries: Record<string, string>;
+    updatePatterns: Record<string, string>;
+    fullSchemaDoc: string;
+}
+export interface ReadSessionSchemaOutput {
+    query: '$schema';
+    schema: SchemaOverview;
+}
+export interface OpenDashboardOutput {
+    url: string;
+}
+export declare function handleCreateSession(input: CreateSessionInput, ctx: ToolContext): Promise<ToolResult<CreateSessionOutput>>;
+export declare function handleUpdateSession(input: UpdateSessionInput, ctx: ToolContext): Promise<ToolResult<UpdateSessionOutput>>;
+export declare function handleReadSession(input: ReadSessionInput, ctx: ToolContext): Promise<ToolResult<ReadSessionOutput | ReadSessionSchemaOutput>>;
+export declare function handleOpenDashboard(input: OpenDashboardInput, ctx: ToolContext): Promise<ToolResult<OpenDashboardOutput>>;

package/dist/mcp/handlers/session.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleCreateSession = handleCreateSession;
+exports.handleUpdateSession = handleUpdateSession;
+exports.handleReadSession = handleReadSession;
+exports.handleOpenDashboard = handleOpenDashboard;
+const types_js_1 = require("../types.js");
+const output_schemas_js_1 = require("../output-schemas.js");
+const error_mapper_js_1 = require("../error-mapper.js");
+const SESSION_SCHEMA_OVERVIEW = {
+    description: 'Bug Investigation Session Data Structure',
+    mainSections: {
+        dashboard: 'Real-time UI display (progress, confidence, currentPhase, status)',
+        bugSummary: 'Initial bug context (title, description, impact, reproduction)',
+        phases: 'Detailed phase progress (phase-0, phase-1, etc.)',
+        hypotheses: 'Array of investigation theories with status tracking',
+        ruledOut: 'Array of rejected hypotheses',
+        timeline: 'Array of timestamped events',
+        confidenceJourney: 'Array of confidence changes over time',
+        codebaseMap: 'Spatial understanding of components (optional)',
+        rootCause: 'Final diagnosis (set in Phase 6)',
+        fix: 'Proposed solution (set in Phase 6)',
+        recommendations: 'Future prevention steps (set in Phase 6)',
+        metadata: 'Technical details (workflowVersion, projectType, etc.)',
+    },
+    commonQueries: {
+        'dashboard': 'Get all dashboard fields',
+        'dashboard.progress': 'Get just progress percentage',
+        'timeline': 'Get all timeline events',
+        'hypotheses': 'Get all hypotheses',
+        'hypotheses[0]': 'Get first hypothesis',
+        'phases.phase-1': 'Get Phase 1 data',
+        'confidenceJourney': 'Get confidence history',
+    },
+    updatePatterns: {
+        incrementalProgress: 'workrail_update_session(wf, id, {"dashboard.progress": 35, "dashboard.currentPhase": "Phase 2"})',
+        addTimelineEvent: 'Read timeline array, append event, write back',
+        updateConfidence: 'Update both dashboard.confidence AND confidenceJourney array',
+        completePhase: 'Set phases.phase-X.complete = true and add summary',
+    },
+    fullSchemaDoc: 'See docs/dashboard-architecture/bug-investigation-session-schema.md for complete details',
+};
+function requireSessionTools(ctx) {
+    if (!ctx.sessionManager || !ctx.httpServer) {
+        return (0, types_js_1.error)('PRECONDITION_FAILED', 'Session tools are not enabled', 'Set WORKRAIL_ENABLE_SESSION_TOOLS=true to enable session tools');
+    }
+    return null;
+}
+async function handleCreateSession(input, ctx) {
+    const guardError = requireSessionTools(ctx);
+    if (guardError)
+        return guardError;
+    const sessionManager = ctx.sessionManager;
+    const httpServer = ctx.httpServer;
+    try {
+        const session = await sessionManager.createSession(input.workflowId, input.sessionId, input.initialData);
+        const baseUrl = httpServer.getBaseUrl();
+        const dashboardUrl = baseUrl ? `${baseUrl}?session=${input.sessionId}` : null;
+        const payload = output_schemas_js_1.CreateSessionOutputSchema.parse({
+            sessionId: session.id,
+            workflowId: session.workflowId,
+            path: sessionManager.getSessionPath(input.workflowId, input.sessionId),
+            dashboardUrl,
+            createdAt: session.createdAt,
+        });
+        return (0, types_js_1.success)(payload);
+    }
+    catch (err) {
+        const mapped = (0, error_mapper_js_1.mapUnknownErrorToToolError)(err);
+        return (0, types_js_1.error)(mapped.code, mapped.message, mapped.suggestion);
+    }
+}
+async function handleUpdateSession(input, ctx) {
+    const guardError = requireSessionTools(ctx);
+    if (guardError)
+        return guardError;
+    const sessionManager = ctx.sessionManager;
+    try {
+        await sessionManager.updateSession(input.workflowId, input.sessionId, input.updates);
+        const payload = output_schemas_js_1.UpdateSessionOutputSchema.parse({ updatedAt: new Date().toISOString() });
+        return (0, types_js_1.success)(payload);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.toLowerCase().includes('not found')) {
+            return (0, types_js_1.error)('NOT_FOUND', message, 'Make sure the session exists. Use workrail_create_session() first.');
+        }
+        const mapped = (0, error_mapper_js_1.mapUnknownErrorToToolError)(err);
+        return (0, types_js_1.error)(mapped.code, mapped.message, mapped.suggestion);
+    }
+}
+async function handleReadSession(input, ctx) {
+    const guardError = requireSessionTools(ctx);
+    if (guardError)
+        return guardError;
+    const sessionManager = ctx.sessionManager;
+    if (input.path === '$schema') {
+        const payload = output_schemas_js_1.ReadSessionSchemaOutputSchema.parse({
+            query: '$schema',
+            schema: SESSION_SCHEMA_OVERVIEW,
+        });
+        return (0, types_js_1.success)(payload);
+    }
+    try {
+        const data = await sessionManager.readSession(input.workflowId, input.sessionId, input.path);
+        const payload = output_schemas_js_1.ReadSessionOutputSchema.parse({
+            query: input.path ?? '(full session)',
+            data,
+        });
+        return (0, types_js_1.success)(payload);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.toLowerCase().includes('not found')) {
+            return (0, types_js_1.error)('NOT_FOUND', message, 'Make sure the session exists. Use workrail_create_session() first.');
+        }
+        const mapped = (0, error_mapper_js_1.mapUnknownErrorToToolError)(err);
+        return (0, types_js_1.error)(mapped.code, mapped.message, mapped.suggestion);
+    }
+}
+async function handleOpenDashboard(input, ctx) {
+    const guardError = requireSessionTools(ctx);
+    if (guardError)
+        return guardError;
+    const httpServer = ctx.httpServer;
+    try {
+        const url = await httpServer.openDashboard(input.sessionId);
+        const payload = output_schemas_js_1.OpenDashboardOutputSchema.parse({ url });
+        return (0, types_js_1.success)(payload);
+    }
+    catch (err) {
+        const mapped = (0, error_mapper_js_1.mapUnknownErrorToToolError)(err);
+        return (0, types_js_1.error)(mapped.code, mapped.message, mapped.suggestion);
+    }
+}

package/dist/mcp/handlers/v2-workflow.d.ts

@@ -0,0 +1,4 @@
+import type { ToolContext, ToolResult } from '../types.js';
+import type { V2InspectWorkflowInput, V2ListWorkflowsInput } from '../v2/tools.js';
+export declare function handleV2ListWorkflows(_input: V2ListWorkflowsInput, ctx: ToolContext): Promise<ToolResult<unknown>>;
+export declare function handleV2InspectWorkflow(input: V2InspectWorkflowInput, ctx: ToolContext): Promise<ToolResult<unknown>>;

package/dist/mcp/handlers/v2-workflow.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleV2ListWorkflows = handleV2ListWorkflows;
+exports.handleV2InspectWorkflow = handleV2InspectWorkflow;
+const types_js_1 = require("../types.js");
+const error_mapper_js_1 = require("../error-mapper.js");
+const output_schemas_js_1 = require("../output-schemas.js");
+const v1_to_v2_shim_js_1 = require("../../v2/read-only/v1-to-v2-shim.js");
+const index_js_1 = require("../../v2/infra/local/crypto/index.js");
+const index_js_2 = require("../../v2/infra/local/data-dir/index.js");
+const index_js_3 = require("../../v2/infra/local/pinned-workflow-store/index.js");
+const hashing_js_1 = require("../../v2/durable-core/canonical/hashing.js");
+const TIMEOUT_MS = 30000;
+async function withTimeout(operation, timeoutMs, name) {
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error(`${name} timed out after ${timeoutMs}ms`)), timeoutMs);
+    });
+    return Promise.race([operation, timeoutPromise]);
+}
+async function handleV2ListWorkflows(_input, ctx) {
+    try {
+        const summaries = await withTimeout(ctx.workflowService.listWorkflowSummaries(), TIMEOUT_MS, 'list_workflows');
+        const crypto = new index_js_1.NodeCryptoV2();
+        const dataDir = new index_js_2.LocalDataDirV2(process.env);
+        const pinnedStore = new index_js_3.LocalPinnedWorkflowStoreV2(dataDir);
+        const compiled = await Promise.all(summaries.map(async (s) => {
+            const wf = await ctx.workflowService.getWorkflowById(s.id);
+            if (!wf) {
+                return {
+                    workflowId: s.id,
+                    name: s.name,
+                    description: s.description,
+                    version: s.version,
+                    workflowHash: null,
+                    kind: 'workflow',
+                };
+            }
+            const snapshot = (0, v1_to_v2_shim_js_1.compileV1WorkflowToV2CompiledSnapshotV1)(wf);
+            const hashRes = (0, hashing_js_1.workflowHashForCompiledSnapshot)(snapshot, crypto);
+            if (hashRes.isErr()) {
+                return {
+                    workflowId: s.id,
+                    name: s.name,
+                    description: s.description,
+                    version: s.version,
+                    workflowHash: null,
+                    kind: 'workflow',
+                };
+            }
+            const hash = hashRes.value;
+            const existing = await pinnedStore.get(hash).match((v) => v, () => null);
+            if (!existing) {
+                await pinnedStore.put(hash, snapshot).match(() => undefined, () => undefined);
+            }
+            return {
+                workflowId: s.id,
+                name: s.name,
+                description: s.description,
+                version: s.version,
+                workflowHash: hash,
+                kind: 'workflow',
+            };
+        }));
+        const payload = output_schemas_js_1.V2WorkflowListOutputSchema.parse({
+            workflows: compiled.sort((a, b) => a.workflowId.localeCompare(b.workflowId)),
+        });
+        return (0, types_js_1.success)(payload);
+    }
+    catch (err) {
+        const mapped = (0, error_mapper_js_1.mapUnknownErrorToToolError)(err);
+        return (0, types_js_1.error)(mapped.code, mapped.message, mapped.suggestion);
+    }
+}
+async function handleV2InspectWorkflow(input, ctx) {
+    try {
+        const workflow = await withTimeout(ctx.workflowService.getWorkflowById(input.workflowId), TIMEOUT_MS, 'inspect_workflow');
+        if (!workflow) {
+            return (0, types_js_1.error)('NOT_FOUND', `Workflow not found: ${input.workflowId}`);
+        }
+        const crypto = new index_js_1.NodeCryptoV2();
+        const dataDir = new index_js_2.LocalDataDirV2(process.env);
+        const pinnedStore = new index_js_3.LocalPinnedWorkflowStoreV2(dataDir);
+        const snapshot = (0, v1_to_v2_shim_js_1.compileV1WorkflowToV2CompiledSnapshotV1)(workflow);
+        const hashRes = (0, hashing_js_1.workflowHashForCompiledSnapshot)(snapshot, crypto);
+        if (hashRes.isErr()) {
+            return (0, types_js_1.error)('INTERNAL_ERROR', hashRes.error.message);
+        }
+        const workflowHash = hashRes.value;
+        const existing = await pinnedStore.get(workflowHash).match((v) => v, () => null);
+        if (!existing) {
+            const wrote = await pinnedStore.put(workflowHash, snapshot).match(() => ({ ok: true }), (e) => ({ ok: false, error: e }));
+            if (!wrote.ok) {
+                return (0, types_js_1.error)('INTERNAL_ERROR', wrote.error.message);
+            }
+        }
+        const compiled = (await pinnedStore.get(workflowHash).match((v) => v, () => null)) ?? snapshot;
+        const body = input.mode === 'metadata'
+            ? { schemaVersion: compiled.schemaVersion, sourceKind: compiled.sourceKind, workflowId: compiled.workflowId }
+            : compiled;
+        const payload = output_schemas_js_1.V2WorkflowInspectOutputSchema.parse({
+            workflowId: input.workflowId,
+            workflowHash,
+            mode: input.mode,
+            compiled: body,
+        });
+        return (0, types_js_1.success)(payload);
+    }
+    catch (err) {
+        const mapped = (0, error_mapper_js_1.mapUnknownErrorToToolError)(err);
+        return (0, types_js_1.error)(mapped.code, mapped.message, mapped.suggestion);
+    }
+}

package/dist/mcp/handlers/workflow.d.ts

@@ -0,0 +1,45 @@
+import type { ToolContext, ToolResult } from '../types.js';
+import type { WorkflowListInput, WorkflowGetInput, WorkflowNextInput, WorkflowValidateJsonInput, WorkflowGetSchemaInput } from '../tools.js';
+export interface WorkflowSummary {
+    id: string;
+    name: string;
+    description: string;
+    version: string;
+}
+export interface WorkflowListOutput {
+    workflows: readonly WorkflowSummary[];
+}
+export interface WorkflowGetOutput {
+    workflow: unknown;
+}
+export interface WorkflowNextOutput {
+    state: unknown;
+    next: unknown | null;
+    isComplete: boolean;
+}
+export interface WorkflowValidateJsonOutput {
+    valid: boolean;
+    errors?: Array<{
+        message: string;
+        path?: string;
+    }>;
+    suggestions?: string[];
+}
+export interface WorkflowGetSchemaOutput {
+    schema: unknown;
+    metadata: {
+        version: string;
+        description: string;
+        usage: string;
+        schemaPath: string;
+    };
+    commonPatterns: {
+        basicWorkflow: Record<string, string>;
+        stepStructure: Record<string, string>;
+    };
+}
+export declare function handleWorkflowList(_input: WorkflowListInput, ctx: ToolContext): Promise<ToolResult<WorkflowListOutput>>;
+export declare function handleWorkflowGet(input: WorkflowGetInput, ctx: ToolContext): Promise<ToolResult<WorkflowGetOutput>>;
+export declare function handleWorkflowNext(input: WorkflowNextInput, ctx: ToolContext): Promise<ToolResult<WorkflowNextOutput>>;
+export declare function handleWorkflowValidateJson(input: WorkflowValidateJsonInput, ctx: ToolContext): Promise<ToolResult<WorkflowValidateJsonOutput>>;
+export declare function handleWorkflowGetSchema(_input: WorkflowGetSchemaInput, ctx: ToolContext): Promise<ToolResult<WorkflowGetSchemaOutput>>;

package/dist/mcp/handlers/workflow.js

@@ -0,0 +1,167 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleWorkflowList = handleWorkflowList;
+exports.handleWorkflowGet = handleWorkflowGet;
+exports.handleWorkflowNext = handleWorkflowNext;
+exports.handleWorkflowValidateJson = handleWorkflowValidateJson;
+exports.handleWorkflowGetSchema = handleWorkflowGetSchema;
+const types_js_1 = require("../types.js");
+const output_schemas_js_1 = require("../output-schemas.js");
+const error_mapper_js_1 = require("../error-mapper.js");
+const TIMEOUT_MS = 30000;
+async function withTimeout(operation, timeoutMs, operationName) {
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+            reject(new Error(`${operationName} timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+    });
+    return Promise.race([operation, timeoutPromise]);
+}
+async function handleWorkflowList(_input, ctx) {
+    try {
+        const workflows = await withTimeout(ctx.workflowService.listWorkflowSummaries(), TIMEOUT_MS, 'workflow_list');
+        const payload = output_schemas_js_1.WorkflowListOutputSchema.parse({ workflows });
+        return (0, types_js_1.success)(payload);
+    }
+    catch (err) {
+        const mapped = (0, error_mapper_js_1.mapUnknownErrorToToolError)(err);
+        return (0, types_js_1.error)(mapped.code, mapped.message, mapped.suggestion);
+    }
+}
+async function handleWorkflowGet(input, ctx) {
+    try {
+        const { createGetWorkflow } = await Promise.resolve().then(() => __importStar(require('../../application/use-cases/get-workflow.js')));
+        const getWorkflowUseCase = createGetWorkflow(ctx.workflowService);
+        const result = await withTimeout(getWorkflowUseCase(input.id, input.mode), TIMEOUT_MS, 'workflow_get');
+        if (result.isErr()) {
+            const mapped = (0, error_mapper_js_1.mapDomainErrorToToolError)(result.error);
+            return (0, types_js_1.error)(mapped.code, mapped.message, mapped.suggestion);
+        }
+        const payload = output_schemas_js_1.WorkflowGetOutputSchema.parse({ workflow: result.value });
+        return (0, types_js_1.success)(payload);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes('timed out')) {
+            return (0, types_js_1.error)('TIMEOUT', message);
+        }
+        const mapped = (0, error_mapper_js_1.mapUnknownErrorToToolError)(err);
+        return (0, types_js_1.error)(mapped.code, mapped.message, mapped.suggestion);
+    }
+}
+async function handleWorkflowNext(input, ctx) {
+    const startTime = Date.now();
+    try {
+        console.error(`[workflow_next] Starting with workflowId=${input.workflowId}, ` +
+            `stateKind=${input.state.kind}, ` +
+            `eventKind=${input.event?.kind ?? 'none'}, ` +
+            `contextKeys=${Object.keys(input.context ?? {})}`);
+        const result = await withTimeout(ctx.workflowService.getNextStep(input.workflowId, input.state, input.event, input.context), TIMEOUT_MS, 'workflow_next');
+        console.error(`[workflow_next] Completed in ${Date.now() - startTime}ms, ` +
+            `returned=${result.isOk() ? 'ok' : 'err'}`);
+        if (result.isErr()) {
+            const mapped = (0, error_mapper_js_1.mapDomainErrorToToolError)(result.error);
+            return (0, types_js_1.error)(mapped.code, mapped.message, mapped.suggestion);
+        }
+        const payload = output_schemas_js_1.WorkflowNextOutputSchema.parse(result.value);
+        return (0, types_js_1.success)(payload);
+    }
+    catch (err) {
+        const elapsed = Date.now() - startTime;
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`[workflow_next] Failed after ${elapsed}ms: ${message}`);
+        if (message.includes('timed out')) {
+            return (0, types_js_1.error)('TIMEOUT', message);
+        }
+        const mapped = (0, error_mapper_js_1.mapUnknownErrorToToolError)(err);
+        return (0, types_js_1.error)(mapped.code, mapped.message, mapped.suggestion);
+    }
+}
+async function handleWorkflowValidateJson(input, ctx) {
+    void ctx;
+    try {
+        const { createValidateWorkflowJson } = await Promise.resolve().then(() => __importStar(require('../../application/use-cases/validate-workflow-json.js')));
+        const validateWorkflowJsonUseCase = createValidateWorkflowJson();
+        const result = await validateWorkflowJsonUseCase(input.workflowJson);
+        const payload = output_schemas_js_1.WorkflowValidateJsonOutputSchema.parse(result);
+        return (0, types_js_1.success)(payload);
+    }
+    catch (err) {
+        const mapped = (0, error_mapper_js_1.mapUnknownErrorToToolError)(err);
+        return (0, types_js_1.error)(mapped.code, mapped.message, mapped.suggestion);
+    }
+}
+async function handleWorkflowGetSchema(_input, ctx) {
+    void ctx;
+    try {
+        const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+        const path = await Promise.resolve().then(() => __importStar(require('path')));
+        const schemaPath = path.resolve(__dirname, '../../../spec/workflow.schema.json');
+        const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
+        const schema = JSON.parse(schemaContent);
+        const result = {
+            schema,
+            metadata: {
+                version: '1.0.0',
+                description: 'Complete JSON schema for workflow files',
+                usage: 'This schema defines the structure, required fields, and validation rules for workflow JSON files',
+                schemaPath: 'spec/workflow.schema.json',
+            },
+            commonPatterns: {
+                basicWorkflow: {
+                    id: 'string (required): Unique identifier using lowercase letters, numbers, and hyphens',
+                    name: 'string (required): Human-readable workflow name',
+                    description: 'string (required): Detailed description of the workflow purpose',
+                    version: 'string (required): Semantic version (e.g., "1.0.0")',
+                    steps: 'array (required): List of workflow steps, minimum 1 item',
+                },
+                stepStructure: {
+                    id: 'string (required): Unique step identifier',
+                    title: 'string (required): Human-readable step title',
+                    prompt: 'string (required): Instructions for the step',
+                    agentRole: 'string (required): Role description for the agent',
+                    validationCriteria: 'array (optional): Validation rules for step output',
+                },
+            },
+        };
+        const payload = output_schemas_js_1.WorkflowGetSchemaOutputSchema.parse(result);
+        return (0, types_js_1.success)(payload);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return (0, types_js_1.error)('INTERNAL_ERROR', message, 'Ensure the workflow schema file exists at spec/workflow.schema.json');
+    }
+}

package/dist/mcp/index.d.ts

@@ -0,0 +1,16 @@
+export type { ErrorCode, ToolSuccess, ToolError, ToolResult, ToolContext, ToolHandler, } from './types.js';
+export { success, error, } from './types.js';
+export type { ToolAnnotations, ToolDefinition, ToolConfig, ToolBuilder, } from './tool-factory.js';
+export { createToolFactory } from './tool-factory.js';
+export type { DescriptionMode, WorkflowToolName, ToolDescriptionMap, DescriptionsByMode, } from './types/tool-description-types.js';
+export { DESCRIPTION_MODES, WORKFLOW_TOOL_NAMES, isDescriptionMode, isWorkflowToolName, } from './types/tool-description-types.js';
+export type { IToolDescriptionProvider } from './tool-description-provider.js';
+export { ToolDescriptionProvider, StaticToolDescriptionProvider, } from './tool-description-provider.js';
+export { DESCRIPTIONS } from './tool-descriptions.js';
+export { WorkflowListInput, WorkflowGetInput, WorkflowNextInput, WorkflowValidateJsonInput, WorkflowGetSchemaInput, WORKFLOW_TOOL_ANNOTATIONS, WORKFLOW_TOOL_TITLES, CreateSessionInput, UpdateSessionInput, ReadSessionInput, OpenDashboardInput, createSessionTool, updateSessionTool, readSessionTool, openDashboardTool, sessionTools, } from './tools.js';
+export { handleWorkflowList, handleWorkflowGet, handleWorkflowNext, handleWorkflowValidateJson, handleWorkflowGetSchema, } from './handlers/workflow.js';
+export type { WorkflowSummary, WorkflowListOutput, WorkflowGetOutput, WorkflowNextOutput, WorkflowValidateJsonOutput, WorkflowGetSchemaOutput, } from './handlers/workflow.js';
+export { handleCreateSession, handleUpdateSession, handleReadSession, handleOpenDashboard, } from './handlers/session.js';
+export type { CreateSessionOutput, UpdateSessionOutput, ReadSessionOutput, ReadSessionSchemaOutput, SchemaOverview, OpenDashboardOutput, } from './handlers/session.js';
+export { createToolContext, startServer, } from './server.js';
+export { zodToJsonSchema } from './zod-to-json-schema.js';

package/dist/mcp/index.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zodToJsonSchema = exports.startServer = exports.createToolContext = exports.handleOpenDashboard = exports.handleReadSession = exports.handleUpdateSession = exports.handleCreateSession = exports.handleWorkflowGetSchema = exports.handleWorkflowValidateJson = exports.handleWorkflowNext = exports.handleWorkflowGet = exports.handleWorkflowList = exports.sessionTools = exports.openDashboardTool = exports.readSessionTool = exports.updateSessionTool = exports.createSessionTool = exports.OpenDashboardInput = exports.ReadSessionInput = exports.UpdateSessionInput = exports.CreateSessionInput = exports.WORKFLOW_TOOL_TITLES = exports.WORKFLOW_TOOL_ANNOTATIONS = exports.WorkflowGetSchemaInput = exports.WorkflowValidateJsonInput = exports.WorkflowNextInput = exports.WorkflowGetInput = exports.WorkflowListInput = exports.DESCRIPTIONS = exports.StaticToolDescriptionProvider = exports.ToolDescriptionProvider = exports.isWorkflowToolName = exports.isDescriptionMode = exports.WORKFLOW_TOOL_NAMES = exports.DESCRIPTION_MODES = exports.createToolFactory = exports.error = exports.success = void 0;
+var types_js_1 = require("./types.js");
+Object.defineProperty(exports, "success", { enumerable: true, get: function () { return types_js_1.success; } });
+Object.defineProperty(exports, "error", { enumerable: true, get: function () { return types_js_1.error; } });
+var tool_factory_js_1 = require("./tool-factory.js");
+Object.defineProperty(exports, "createToolFactory", { enumerable: true, get: function () { return tool_factory_js_1.createToolFactory; } });
+var tool_description_types_js_1 = require("./types/tool-description-types.js");
+Object.defineProperty(exports, "DESCRIPTION_MODES", { enumerable: true, get: function () { return tool_description_types_js_1.DESCRIPTION_MODES; } });
+Object.defineProperty(exports, "WORKFLOW_TOOL_NAMES", { enumerable: true, get: function () { return tool_description_types_js_1.WORKFLOW_TOOL_NAMES; } });
+Object.defineProperty(exports, "isDescriptionMode", { enumerable: true, get: function () { return tool_description_types_js_1.isDescriptionMode; } });
+Object.defineProperty(exports, "isWorkflowToolName", { enumerable: true, get: function () { return tool_description_types_js_1.isWorkflowToolName; } });
+var tool_description_provider_js_1 = require("./tool-description-provider.js");
+Object.defineProperty(exports, "ToolDescriptionProvider", { enumerable: true, get: function () { return tool_description_provider_js_1.ToolDescriptionProvider; } });
+Object.defineProperty(exports, "StaticToolDescriptionProvider", { enumerable: true, get: function () { return tool_description_provider_js_1.StaticToolDescriptionProvider; } });
+var tool_descriptions_js_1 = require("./tool-descriptions.js");
+Object.defineProperty(exports, "DESCRIPTIONS", { enumerable: true, get: function () { return tool_descriptions_js_1.DESCRIPTIONS; } });
+var tools_js_1 = require("./tools.js");
+Object.defineProperty(exports, "WorkflowListInput", { enumerable: true, get: function () { return tools_js_1.WorkflowListInput; } });
+Object.defineProperty(exports, "WorkflowGetInput", { enumerable: true, get: function () { return tools_js_1.WorkflowGetInput; } });
+Object.defineProperty(exports, "WorkflowNextInput", { enumerable: true, get: function () { return tools_js_1.WorkflowNextInput; } });
+Object.defineProperty(exports, "WorkflowValidateJsonInput", { enumerable: true, get: function () { return tools_js_1.WorkflowValidateJsonInput; } });
+Object.defineProperty(exports, "WorkflowGetSchemaInput", { enumerable: true, get: function () { return tools_js_1.WorkflowGetSchemaInput; } });
+Object.defineProperty(exports, "WORKFLOW_TOOL_ANNOTATIONS", { enumerable: true, get: function () { return tools_js_1.WORKFLOW_TOOL_ANNOTATIONS; } });
+Object.defineProperty(exports, "WORKFLOW_TOOL_TITLES", { enumerable: true, get: function () { return tools_js_1.WORKFLOW_TOOL_TITLES; } });
+Object.defineProperty(exports, "CreateSessionInput", { enumerable: true, get: function () { return tools_js_1.CreateSessionInput; } });
+Object.defineProperty(exports, "UpdateSessionInput", { enumerable: true, get: function () { return tools_js_1.UpdateSessionInput; } });
+Object.defineProperty(exports, "ReadSessionInput", { enumerable: true, get: function () { return tools_js_1.ReadSessionInput; } });
+Object.defineProperty(exports, "OpenDashboardInput", { enumerable: true, get: function () { return tools_js_1.OpenDashboardInput; } });
+Object.defineProperty(exports, "createSessionTool", { enumerable: true, get: function () { return tools_js_1.createSessionTool; } });
+Object.defineProperty(exports, "updateSessionTool", { enumerable: true, get: function () { return tools_js_1.updateSessionTool; } });
+Object.defineProperty(exports, "readSessionTool", { enumerable: true, get: function () { return tools_js_1.readSessionTool; } });
+Object.defineProperty(exports, "openDashboardTool", { enumerable: true, get: function () { return tools_js_1.openDashboardTool; } });
+Object.defineProperty(exports, "sessionTools", { enumerable: true, get: function () { return tools_js_1.sessionTools; } });
+var workflow_js_1 = require("./handlers/workflow.js");
+Object.defineProperty(exports, "handleWorkflowList", { enumerable: true, get: function () { return workflow_js_1.handleWorkflowList; } });
+Object.defineProperty(exports, "handleWorkflowGet", { enumerable: true, get: function () { return workflow_js_1.handleWorkflowGet; } });
+Object.defineProperty(exports, "handleWorkflowNext", { enumerable: true, get: function () { return workflow_js_1.handleWorkflowNext; } });
+Object.defineProperty(exports, "handleWorkflowValidateJson", { enumerable: true, get: function () { return workflow_js_1.handleWorkflowValidateJson; } });
+Object.defineProperty(exports, "handleWorkflowGetSchema", { enumerable: true, get: function () { return workflow_js_1.handleWorkflowGetSchema; } });
+var session_js_1 = require("./handlers/session.js");
+Object.defineProperty(exports, "handleCreateSession", { enumerable: true, get: function () { return session_js_1.handleCreateSession; } });
+Object.defineProperty(exports, "handleUpdateSession", { enumerable: true, get: function () { return session_js_1.handleUpdateSession; } });
+Object.defineProperty(exports, "handleReadSession", { enumerable: true, get: function () { return session_js_1.handleReadSession; } });
+Object.defineProperty(exports, "handleOpenDashboard", { enumerable: true, get: function () { return session_js_1.handleOpenDashboard; } });
+var server_js_1 = require("./server.js");
+Object.defineProperty(exports, "createToolContext", { enumerable: true, get: function () { return server_js_1.createToolContext; } });
+Object.defineProperty(exports, "startServer", { enumerable: true, get: function () { return server_js_1.startServer; } });
+var zod_to_json_schema_js_1 = require("./zod-to-json-schema.js");
+Object.defineProperty(exports, "zodToJsonSchema", { enumerable: true, get: function () { return zod_to_json_schema_js_1.zodToJsonSchema; } });