@clawplays/ospec-cli 0.1.1

package/dist/workflow/PluginWorkflowComposer.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginWorkflowComposer = exports.DEFAULT_CHECKPOINT_PLUGIN_CONFIG = exports.DEFAULT_STITCH_PLUGIN_CONFIG = void 0;
+const ConfigurableWorkflow_1 = require("./ConfigurableWorkflow");
+exports.DEFAULT_STITCH_PLUGIN_CONFIG = {
+    enabled: false,
+    blocking: true,
+    project: {
+        project_id: '',
+        project_url: '',
+        save_on_first_run: true,
+        enforce_single_project: true,
+    },
+    gemini: {
+        model: 'gemini-3-flash-preview',
+        auto_switch_on_limit: true,
+        save_on_fallback: true,
+    },
+    codex: {
+        model: '',
+        mcp_server: 'stitch',
+    },
+    runner: {
+        mode: 'command',
+        command: 'node',
+        args: ['${ospec_package_path}/dist/adapters/gemini-stitch-adapter.js', '--change', '${change_path}', '--project', '${project_path}'],
+        cwd: '${project_path}',
+        timeout_ms: 900000,
+        token_env: '',
+        extra_env: {},
+    },
+    provider: 'gemini',
+    capabilities: {
+        page_design_review: {
+            enabled: false,
+            step: 'stitch_design_review',
+            activate_when_flags: ['ui_change', 'page_design', 'landing_page'],
+        },
+    },
+};
+exports.DEFAULT_CHECKPOINT_PLUGIN_CONFIG = {
+    enabled: false,
+    blocking: true,
+    runtime: {
+        base_url: '',
+        startup: {
+            command: '',
+            args: [],
+            cwd: '${project_path}',
+            timeout_ms: 600000,
+        },
+        readiness: {
+            type: 'url',
+            url: '',
+            timeout_ms: 180000,
+        },
+        auth: {
+            command: '',
+            args: [],
+            cwd: '${project_path}',
+            timeout_ms: 300000,
+            when: 'missing_storage_state',
+        },
+        shutdown: {
+            command: '',
+            args: [],
+            cwd: '${project_path}',
+            timeout_ms: 120000,
+        },
+        storage_state: '.ospec/plugins/checkpoint/auth/storage-state.json',
+    },
+    runner: {
+        mode: 'command',
+        command: 'node',
+        args: ['${ospec_package_path}/dist/adapters/playwright-checkpoint-adapter.js', '--change', '${change_path}', '--project', '${project_path}'],
+        cwd: '${project_path}',
+        timeout_ms: 900000,
+        token_env: '',
+        extra_env: {},
+    },
+    capabilities: {
+        ui_review: {
+            enabled: false,
+            step: 'checkpoint_ui_review',
+            activate_when_flags: ['ui_change', 'page_design', 'landing_page'],
+        },
+        flow_check: {
+            enabled: false,
+            step: 'checkpoint_flow_check',
+            activate_when_flags: ['feature_flow', 'api_change', 'backend_change', 'integration_change'],
+        },
+    },
+    stitch_integration: {
+        enabled: true,
+        auto_pass_stitch_review: true,
+    },
+};
+class PluginWorkflowComposer {
+    constructor(config) {
+        this.config = config;
+    }
+    getBaseConfig() {
+        return this.config.workflow || ConfigurableWorkflow_1.WORKFLOW_PRESETS[this.config.mode] || ConfigurableWorkflow_1.WORKFLOW_PRESETS.full;
+    }
+    getCoreSteps() {
+        return Array.isArray(this.getBaseConfig().core_required)
+            ? [...this.getBaseConfig().core_required]
+            : [];
+    }
+    getBaseOptionalSteps() {
+        return this.getBaseConfig().optional_steps || {};
+    }
+    getActivatedBaseSteps(featureFlags) {
+        const activated = [];
+        for (const [stepName, stepConfig] of Object.entries(this.getBaseOptionalSteps())) {
+            if (!stepConfig?.enabled) {
+                continue;
+            }
+            if ((stepConfig.when || []).some(flag => featureFlags.includes(flag))) {
+                activated.push(stepName);
+            }
+        }
+        return activated;
+    }
+    getEnabledPlugins() {
+        const plugins = [];
+        const stitchConfig = this.config.plugins?.stitch;
+        if (stitchConfig?.enabled) {
+            plugins.push({
+                name: 'stitch',
+                blocking: stitchConfig.blocking !== false,
+            });
+        }
+        const checkpointConfig = this.config.plugins?.checkpoint;
+        if (checkpointConfig?.enabled) {
+            plugins.push({
+                name: 'checkpoint',
+                blocking: checkpointConfig.blocking !== false,
+            });
+        }
+        return plugins;
+    }
+    getStitchCapabilities() {
+        return this.getPluginCapabilities().filter(item => item.plugin === 'stitch');
+    }
+    getCheckpointCapabilities() {
+        return this.getPluginCapabilities().filter(item => item.plugin === 'checkpoint');
+    }
+    getPluginCapabilities() {
+        const capabilities = [];
+        const stitchConfig = this.config.plugins?.stitch;
+        if (stitchConfig?.enabled) {
+            const pageDesignReview = stitchConfig.capabilities?.page_design_review;
+            if (pageDesignReview?.enabled) {
+                capabilities.push({
+                    plugin: 'stitch',
+                    capability: 'page_design_review',
+                    step: pageDesignReview.step,
+                    activateWhenFlags: [...pageDesignReview.activate_when_flags],
+                    blocking: stitchConfig.blocking !== false,
+                });
+            }
+        }
+        const checkpointConfig = this.config.plugins?.checkpoint;
+        if (checkpointConfig?.enabled) {
+            const uiReview = checkpointConfig.capabilities?.ui_review;
+            if (uiReview?.enabled) {
+                capabilities.push({
+                    plugin: 'checkpoint',
+                    capability: 'ui_review',
+                    step: uiReview.step,
+                    activateWhenFlags: [...uiReview.activate_when_flags],
+                    blocking: checkpointConfig.blocking !== false,
+                });
+            }
+            const flowCheck = checkpointConfig.capabilities?.flow_check;
+            if (flowCheck?.enabled) {
+                capabilities.push({
+                    plugin: 'checkpoint',
+                    capability: 'flow_check',
+                    step: flowCheck.step,
+                    activateWhenFlags: [...flowCheck.activate_when_flags],
+                    blocking: checkpointConfig.blocking !== false,
+                });
+            }
+        }
+        return capabilities;
+    }
+    getPluginContributedSteps() {
+        return Array.from(new Set(this.getPluginCapabilities().map(item => item.step)));
+    }
+    getActivatedPluginSteps(featureFlags) {
+        return this.getPluginCapabilities()
+            .filter(item => item.activateWhenFlags.some(flag => featureFlags.includes(flag)))
+            .map(item => item.step);
+    }
+    getActivatedSteps(featureFlags) {
+        return Array.from(new Set([
+            ...this.getActivatedBaseSteps(featureFlags),
+            ...this.getActivatedPluginSteps(featureFlags),
+        ]));
+    }
+    getSupportedFlags() {
+        const baseFlags = Array.isArray(this.getBaseConfig().feature_flags?.supported)
+            ? this.getBaseConfig().feature_flags.supported
+            : [];
+        const pluginFlags = this.getPluginCapabilities()
+            .flatMap(item => item.activateWhenFlags);
+        return Array.from(new Set([...baseFlags, ...pluginFlags]));
+    }
+    getArchiveGate() {
+        return this.getBaseConfig().archive_gate;
+    }
+    validateFlags(flags) {
+        const supported = new Set(this.getSupportedFlags());
+        const unsupported = flags.filter(flag => !supported.has(flag));
+        return {
+            valid: unsupported.length === 0,
+            unsupported,
+        };
+    }
+    getSummary(featureFlags) {
+        const activatedSteps = this.getActivatedSteps(featureFlags);
+        const activatedPluginSteps = this.getActivatedPluginSteps(featureFlags);
+        const validation = this.validateFlags(featureFlags);
+        return {
+            mode: this.config.mode,
+            coreSteps: this.getCoreSteps().length,
+            optionalSteps: activatedSteps,
+            pluginSteps: activatedPluginSteps,
+            totalSteps: this.getCoreSteps().length + activatedSteps.length,
+            enabledPlugins: this.getEnabledPlugins().map(plugin => plugin.name),
+            flags: featureFlags,
+            unsupportedFlags: validation.unsupported,
+        };
+    }
+}
+exports.PluginWorkflowComposer = PluginWorkflowComposer;
+//# sourceMappingURL=PluginWorkflowComposer.js.map

package/dist/workflow/SkillUpdateEngine.d.ts

@@ -0,0 +1,26 @@
+import { FeatureState } from '../core/types';
+export interface SkillMetadata {
+    name: string;
+    version: string;
+    description?: string;
+    tags?: string[];
+    dependencies?: string[];
+    lastUpdated?: string;
+}
+export declare class SkillUpdateEngine {
+    generateSkillIndex(featureDir: string): Promise<Record<string, SkillMetadata>>;
+    updateSkill(featureDir: string, skillName: string, content: string, metadata?: Partial<SkillMetadata>): Promise<void>;
+    getSkillHistory(featureDir: string, skillName: string): Promise<Array<{
+        version: string;
+        date: string;
+        changes: string[];
+    }>>;
+    validateSkillUpdate(featureState: FeatureState): Promise<{
+        valid: boolean;
+        errors: string[];
+        warnings: string[];
+    }>;
+    exportSkillPackage(featureDir: string): Promise<Buffer>;
+}
+export declare const skillUpdateEngine: SkillUpdateEngine;
+//# sourceMappingURL=SkillUpdateEngine.d.ts.map

package/dist/workflow/SkillUpdateEngine.js

@@ -0,0 +1,113 @@
+"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.skillUpdateEngine = exports.SkillUpdateEngine = void 0;
+const path = __importStar(require("path"));
+const services_1 = require("../services");
+class SkillUpdateEngine {
+    async generateSkillIndex(featureDir) {
+        const skillsDir = path.join(featureDir, 'skills');
+        try {
+            const files = await services_1.services.fileService.readDir(skillsDir);
+            const skillFiles = files.filter(file => file.endsWith('.md'));
+            const index = {};
+            for (const file of skillFiles) {
+                const filePath = path.join(skillsDir, file);
+                const content = await services_1.services.fileService.readFile(filePath);
+                const parsed = services_1.services.skillParser.parseSkillFile(content);
+                index[file] = {
+                    name: parsed.frontmatter.name,
+                    version: '1.0.0',
+                    description: parsed.frontmatter.name,
+                    tags: parsed.frontmatter.tags,
+                    lastUpdated: new Date().toISOString(),
+                };
+            }
+            return index;
+        }
+        catch {
+            return {};
+        }
+    }
+    async updateSkill(featureDir, skillName, content, metadata) {
+        const skillPath = path.join(featureDir, 'skills', `${skillName}.md`);
+        const frontmatter = {
+            name: metadata?.name || skillName,
+            tags: metadata?.tags || [],
+            version: metadata?.version || '1.0.0',
+        };
+        const fmContent = `---
+name: ${frontmatter.name}
+version: ${frontmatter.version}
+tags: ${JSON.stringify(frontmatter.tags)}
+---
+
+${content}`;
+        await services_1.services.fileService.writeFile(skillPath, fmContent);
+    }
+    async getSkillHistory(featureDir, skillName) {
+        void featureDir;
+        void skillName;
+        return [
+            {
+                version: '1.0.0',
+                date: new Date().toISOString(),
+                changes: ['Initial version'],
+            },
+        ];
+    }
+    async validateSkillUpdate(featureState) {
+        const errors = [];
+        const warnings = [];
+        if (!featureState.completed.includes('skill_updated')) {
+            warnings.push('Skill documentation has not been marked as updated yet');
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    async exportSkillPackage(featureDir) {
+        const content = {
+            timestamp: new Date().toISOString(),
+            skills: await this.generateSkillIndex(featureDir),
+        };
+        return Buffer.from(JSON.stringify(content, null, 2));
+    }
+}
+exports.SkillUpdateEngine = SkillUpdateEngine;
+exports.skillUpdateEngine = new SkillUpdateEngine();
+//# sourceMappingURL=SkillUpdateEngine.js.map

package/dist/workflow/VerificationSystem.d.ts

@@ -0,0 +1,24 @@
+import { FeatureState } from '../core/types';
+export interface VerificationResult {
+    name: string;
+    status: 'pass' | 'fail' | 'warn';
+    message: string;
+    details?: unknown;
+}
+export declare class VerificationSystem {
+    verifyProposal(featureState: FeatureState): Promise<VerificationResult[]>;
+    verifyTasks(featureState: FeatureState): Promise<VerificationResult[]>;
+    verifyImplementation(featureState: FeatureState): Promise<VerificationResult[]>;
+    runFullVerification(featureState: FeatureState): Promise<{
+        passed: boolean;
+        results: VerificationResult[];
+        summary: string;
+    }>;
+    getVerificationChecklist(): Array<{
+        name: string;
+        description: string;
+        critical: boolean;
+    }>;
+}
+export declare const verificationSystem: VerificationSystem;
+//# sourceMappingURL=VerificationSystem.d.ts.map

package/dist/workflow/VerificationSystem.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verificationSystem = exports.VerificationSystem = void 0;
+class VerificationSystem {
+    async verifyProposal(featureState) {
+        const results = [];
+        if (!featureState.feature || featureState.feature.trim() === '') {
+            results.push({
+                name: 'Change Name',
+                status: 'fail',
+                message: 'Change name is required',
+            });
+        }
+        if (!featureState.affects || featureState.affects.length === 0) {
+            results.push({
+                name: 'Affected Modules',
+                status: 'warn',
+                message: 'No affected modules specified',
+            });
+        }
+        results.push({
+            name: 'Proposal Format',
+            status: 'pass',
+            message: 'Proposal format is valid',
+        });
+        return results;
+    }
+    async verifyTasks(featureState) {
+        const results = [];
+        if (featureState.pending.length === 0 && featureState.completed.length === 0) {
+            results.push({
+                name: 'Tasks Defined',
+                status: 'warn',
+                message: 'No tasks have been defined',
+            });
+        }
+        results.push({
+            name: 'Task Structure',
+            status: 'pass',
+            message: 'Task structure is valid',
+        });
+        return results;
+    }
+    async verifyImplementation(featureState) {
+        const results = [];
+        const coreSteps = ['proposal_complete', 'tasks_complete', 'implementation_complete'];
+        const completedCoreSteps = coreSteps.filter(step => featureState.completed.includes(step));
+        results.push({
+            name: 'Core Steps Completion',
+            status: completedCoreSteps.length === coreSteps.length ? 'pass' : 'warn',
+            message: `${completedCoreSteps.length}/${coreSteps.length} core steps completed`,
+            details: {
+                completed: completedCoreSteps,
+                remaining: coreSteps.filter(step => !completedCoreSteps.includes(step)),
+            },
+        });
+        return results;
+    }
+    async runFullVerification(featureState) {
+        const allResults = [
+            ...(await this.verifyProposal(featureState)),
+            ...(await this.verifyTasks(featureState)),
+            ...(await this.verifyImplementation(featureState)),
+        ];
+        const passed = allResults.every(result => result.status !== 'fail');
+        const failCount = allResults.filter(result => result.status === 'fail').length;
+        const warnCount = allResults.filter(result => result.status === 'warn').length;
+        const summary = failCount > 0
+            ? `${failCount} verification(s) failed`
+            : warnCount > 0
+                ? `${warnCount} warning(s) found`
+                : 'All verifications passed';
+        return {
+            passed,
+            results: allResults,
+            summary,
+        };
+    }
+    getVerificationChecklist() {
+        return [
+            {
+                name: 'Proposal Written',
+                description: 'Change proposal has been written',
+                critical: true,
+            },
+            {
+                name: 'Tasks Defined',
+                description: 'Implementation tasks have been defined',
+                critical: true,
+            },
+            {
+                name: 'Implementation Complete',
+                description: 'Change has been implemented',
+                critical: true,
+            },
+            {
+                name: 'Tests Pass',
+                description: 'All tests pass successfully',
+                critical: true,
+            },
+            {
+                name: 'Code Review',
+                description: 'Code has been reviewed',
+                critical: false,
+            },
+            {
+                name: 'Documentation Updated',
+                description: 'Documentation has been updated',
+                critical: false,
+            },
+        ];
+    }
+}
+exports.VerificationSystem = VerificationSystem;
+exports.verificationSystem = new VerificationSystem();
+//# sourceMappingURL=VerificationSystem.js.map

package/dist/workflow/WorkflowEngine.d.ts

@@ -0,0 +1,15 @@
+import { FeatureState, FeatureStatus, WorkflowStep } from '../core/types';
+export declare class WorkflowEngine {
+    canExecuteStep(featureState: FeatureState, step: WorkflowStep): Promise<boolean>;
+    executeStep(featureState: FeatureState, step: WorkflowStep): Promise<FeatureState>;
+    private getStepDependencies;
+    transitionStatus(currentStatus: FeatureStatus, targetStatus: FeatureStatus): Promise<void>;
+    getNextSteps(featureState: FeatureState): WorkflowStep[];
+    getProgress(featureState: FeatureState): {
+        completed: number;
+        total: number;
+        percentage: number;
+    };
+}
+export declare const workflowEngine: WorkflowEngine;
+//# sourceMappingURL=WorkflowEngine.d.ts.map

package/dist/workflow/WorkflowEngine.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workflowEngine = exports.WorkflowEngine = void 0;
+const constants_1 = require("../core/constants");
+const errors_1 = require("../core/errors");
+class WorkflowEngine {
+    async canExecuteStep(featureState, step) {
+        const dependencies = this.getStepDependencies(step);
+        const completed = new Set(featureState.completed);
+        return dependencies.every(dep => completed.has(dep));
+    }
+    async executeStep(featureState, step) {
+        if (!(await this.canExecuteStep(featureState, step))) {
+            throw new errors_1.WorkflowError(`Cannot execute step ${step}. Dependencies not met.`);
+        }
+        featureState.current_step = step;
+        if (!featureState.completed.includes(step)) {
+            featureState.completed.push(step);
+        }
+        featureState.pending = featureState.pending.filter(pendingStep => pendingStep !== step);
+        featureState.last_updated = new Date().toISOString();
+        return featureState;
+    }
+    getStepDependencies(step) {
+        const dependencies = {
+            proposal_complete: [],
+            tasks_complete: ['proposal_complete'],
+            implementation_complete: ['tasks_complete'],
+            skill_updated: ['implementation_complete'],
+            index_regenerated: ['skill_updated'],
+            tests_passed: ['implementation_complete'],
+            verification_passed: ['tests_passed', 'index_regenerated'],
+            archived: ['verification_passed'],
+        };
+        return dependencies[step] || [];
+    }
+    async transitionStatus(currentStatus, targetStatus) {
+        if (!constants_1.STATE_TRANSITIONS[currentStatus]?.includes(targetStatus)) {
+            throw new errors_1.InvalidStateTransitionError(currentStatus, targetStatus);
+        }
+    }
+    getNextSteps(featureState) {
+        return (featureState.pending || []);
+    }
+    getProgress(featureState) {
+        const total = featureState.completed.length + featureState.pending.length;
+        const completed = featureState.completed.length;
+        return {
+            completed,
+            total,
+            percentage: total === 0 ? 0 : Math.round((completed / total) * 100),
+        };
+    }
+}
+exports.WorkflowEngine = WorkflowEngine;
+exports.workflowEngine = new WorkflowEngine();
+//# sourceMappingURL=WorkflowEngine.js.map

package/dist/workflow/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 工作流层导出
+ */
+export { WorkflowEngine, workflowEngine } from './WorkflowEngine';
+export { VerificationSystem, verificationSystem } from './VerificationSystem';
+export type { VerificationResult } from './VerificationSystem';
+export { HookSystem, hookSystem } from './HookSystem';
+export type { Hook, HookEvent } from './HookSystem';
+export { SkillUpdateEngine, skillUpdateEngine } from './SkillUpdateEngine';
+export type { SkillMetadata } from './SkillUpdateEngine';
+export { IndexRegenerator, indexRegenerator } from './IndexRegenerator';
+export type { IndexEntry, ProjectIndex } from './IndexRegenerator';
+export { ArchiveGate, archiveGate } from './ArchiveGate';
+export type { ArchiveGateConfig, ArchiveCheckResult } from './ArchiveGate';
+export { ConfigurableWorkflow, WORKFLOW_PRESETS } from './ConfigurableWorkflow';
+export type { CoreStep, OptionalStep, OptionalStepConfig, WorkflowConfigType } from './ConfigurableWorkflow';
+export { PluginWorkflowComposer, DEFAULT_STITCH_PLUGIN_CONFIG, DEFAULT_CHECKPOINT_PLUGIN_CONFIG } from './PluginWorkflowComposer';
+export type { EnabledPluginSummary, PluginCapabilitySummary } from './PluginWorkflowComposer';
+//# sourceMappingURL=index.d.ts.map

package/dist/workflow/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * 工作流层导出
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginWorkflowComposer = exports.DEFAULT_CHECKPOINT_PLUGIN_CONFIG = exports.DEFAULT_STITCH_PLUGIN_CONFIG = exports.WORKFLOW_PRESETS = exports.ConfigurableWorkflow = exports.archiveGate = exports.ArchiveGate = exports.indexRegenerator = exports.IndexRegenerator = exports.skillUpdateEngine = exports.SkillUpdateEngine = exports.hookSystem = exports.HookSystem = exports.verificationSystem = exports.VerificationSystem = exports.workflowEngine = exports.WorkflowEngine = void 0;
+var WorkflowEngine_1 = require("./WorkflowEngine");
+Object.defineProperty(exports, "WorkflowEngine", { enumerable: true, get: function () { return WorkflowEngine_1.WorkflowEngine; } });
+Object.defineProperty(exports, "workflowEngine", { enumerable: true, get: function () { return WorkflowEngine_1.workflowEngine; } });
+var VerificationSystem_1 = require("./VerificationSystem");
+Object.defineProperty(exports, "VerificationSystem", { enumerable: true, get: function () { return VerificationSystem_1.VerificationSystem; } });
+Object.defineProperty(exports, "verificationSystem", { enumerable: true, get: function () { return VerificationSystem_1.verificationSystem; } });
+var HookSystem_1 = require("./HookSystem");
+Object.defineProperty(exports, "HookSystem", { enumerable: true, get: function () { return HookSystem_1.HookSystem; } });
+Object.defineProperty(exports, "hookSystem", { enumerable: true, get: function () { return HookSystem_1.hookSystem; } });
+var SkillUpdateEngine_1 = require("./SkillUpdateEngine");
+Object.defineProperty(exports, "SkillUpdateEngine", { enumerable: true, get: function () { return SkillUpdateEngine_1.SkillUpdateEngine; } });
+Object.defineProperty(exports, "skillUpdateEngine", { enumerable: true, get: function () { return SkillUpdateEngine_1.skillUpdateEngine; } });
+var IndexRegenerator_1 = require("./IndexRegenerator");
+Object.defineProperty(exports, "IndexRegenerator", { enumerable: true, get: function () { return IndexRegenerator_1.IndexRegenerator; } });
+Object.defineProperty(exports, "indexRegenerator", { enumerable: true, get: function () { return IndexRegenerator_1.indexRegenerator; } });
+var ArchiveGate_1 = require("./ArchiveGate");
+Object.defineProperty(exports, "ArchiveGate", { enumerable: true, get: function () { return ArchiveGate_1.ArchiveGate; } });
+Object.defineProperty(exports, "archiveGate", { enumerable: true, get: function () { return ArchiveGate_1.archiveGate; } });
+var ConfigurableWorkflow_1 = require("./ConfigurableWorkflow");
+Object.defineProperty(exports, "ConfigurableWorkflow", { enumerable: true, get: function () { return ConfigurableWorkflow_1.ConfigurableWorkflow; } });
+Object.defineProperty(exports, "WORKFLOW_PRESETS", { enumerable: true, get: function () { return ConfigurableWorkflow_1.WORKFLOW_PRESETS; } });
+var PluginWorkflowComposer_1 = require("./PluginWorkflowComposer");
+Object.defineProperty(exports, "DEFAULT_STITCH_PLUGIN_CONFIG", { enumerable: true, get: function () { return PluginWorkflowComposer_1.DEFAULT_STITCH_PLUGIN_CONFIG; } });
+Object.defineProperty(exports, "DEFAULT_CHECKPOINT_PLUGIN_CONFIG", { enumerable: true, get: function () { return PluginWorkflowComposer_1.DEFAULT_CHECKPOINT_PLUGIN_CONFIG; } });
+Object.defineProperty(exports, "PluginWorkflowComposer", { enumerable: true, get: function () { return PluginWorkflowComposer_1.PluginWorkflowComposer; } });
+//# sourceMappingURL=index.js.map