@clawplays/ospec-cli 0.1.1

package/dist/workflow/ConfigurableWorkflow.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * 可配置工作流系统
+ * 基于 OSpec 官方规范实现
+ * 支持核心步骤 + 可选步骤 + Feature Flags
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurableWorkflow = exports.WORKFLOW_PRESETS = void 0;
+/**
+ * 3种预定义工作流模板
+ */
+exports.WORKFLOW_PRESETS = {
+    lite: {
+        core_required: ['proposal', 'tasks', 'state', 'verification', 'skill_update', 'index_regenerated'],
+        optional_steps: {
+            code_review: { enabled: true, when: ['high_risk', 'multi_file_change'] },
+            design_doc: { enabled: false, when: [] },
+            plan_doc: { enabled: false, when: [] },
+            security_review: { enabled: false, when: [] },
+            adr: { enabled: false, when: [] },
+            db_change_doc: { enabled: false, when: [] },
+            api_change_doc: { enabled: false, when: [] },
+        },
+        archive_gate: {
+            require_verification: true,
+            require_skill_update: true,
+            require_index_regenerated: true,
+            require_optional_steps_passed: true,
+        },
+        feature_flags: {
+            supported: ['high_risk', 'multi_file_change'],
+        },
+    },
+    standard: {
+        core_required: ['proposal', 'tasks', 'state', 'verification', 'skill_update', 'index_regenerated'],
+        optional_steps: {
+            code_review: { enabled: true, when: ['high_risk', 'multi_file_change'] },
+            design_doc: { enabled: true, when: ['cross_module', 'complex_feature'] },
+            plan_doc: { enabled: true, when: ['large_feature', 'multi_phase'] },
+            security_review: { enabled: true, when: ['security_related', 'auth', 'payment'] },
+            adr: { enabled: false, when: [] },
+            db_change_doc: { enabled: false, when: [] },
+            api_change_doc: { enabled: true, when: ['public_api_change'] },
+        },
+        archive_gate: {
+            require_verification: true,
+            require_skill_update: true,
+            require_index_regenerated: true,
+            require_optional_steps_passed: true,
+        },
+        feature_flags: {
+            supported: [
+                'cross_module', 'complex_feature', 'large_feature', 'multi_phase',
+                'high_risk', 'multi_file_change', 'security_related', 'auth', 'payment', 'public_api_change',
+            ],
+        },
+    },
+    full: {
+        core_required: ['proposal', 'tasks', 'state', 'verification', 'skill_update', 'index_regenerated'],
+        optional_steps: {
+            code_review: { enabled: true, when: ['high_risk', 'cross_module', 'multi_file_change'] },
+            design_doc: { enabled: true, when: ['cross_module', 'complex_feature', 'architecture_change'] },
+            plan_doc: { enabled: true, when: ['large_feature', 'multi_phase', 'important_decision'] },
+            security_review: { enabled: true, when: ['security_related', 'auth', 'payment', 'external_api'] },
+            adr: { enabled: true, when: ['architecture_change', 'important_decision'] },
+            db_change_doc: { enabled: true, when: ['db_schema_change'] },
+            api_change_doc: { enabled: true, when: ['public_api_change'] },
+        },
+        archive_gate: {
+            require_verification: true,
+            require_skill_update: true,
+            require_index_regenerated: true,
+            require_optional_steps_passed: true,
+        },
+        feature_flags: {
+            supported: [
+                'cross_module', 'complex_feature', 'large_feature', 'multi_phase',
+                'architecture_change', 'important_decision', 'multi_file_change',
+                'security_related', 'auth', 'payment', 'external_api',
+                'db_schema_change', 'public_api_change', 'high_risk',
+            ],
+        },
+    },
+};
+class ConfigurableWorkflow {
+    constructor(mode) {
+        this.mode = mode;
+        this.config = exports.WORKFLOW_PRESETS[mode];
+    }
+    /**
+     * 根据 feature flags 确定激活的可选步骤
+     */
+    getActivatedSteps(featureFlags) {
+        const activated = [];
+        for (const [stepName, stepConfig] of Object.entries(this.config.optional_steps)) {
+            if (!stepConfig.enabled)
+                continue;
+            // 检查 feature flags 与 step.when 是否有交集
+            const hasMatch = stepConfig.when.some(flag => featureFlags.includes(flag));
+            if (hasMatch) {
+                activated.push(stepName);
+            }
+        }
+        return activated;
+    }
+    /**
+     * 获取完整的工作流步骤（核心 + 激活的可选）
+     */
+    getFullWorkflow(featureFlags) {
+        const activated = this.getActivatedSteps(featureFlags);
+        return [...this.config.core_required, ...activated];
+    }
+    /**
+     * 获取核心步骤
+     */
+    getCoreSteps() {
+        return this.config.core_required;
+    }
+    /**
+     * 获取所有支持的 feature flags
+     */
+    getSupportedFlags() {
+        return this.config.feature_flags.supported;
+    }
+    /**
+     * 验证 feature flags
+     */
+    validateFlags(flags) {
+        const supported = new Set(this.config.feature_flags.supported);
+        const unsupported = flags.filter(flag => !supported.has(flag));
+        return {
+            valid: unsupported.length === 0,
+            unsupported,
+        };
+    }
+    /**
+     * 获取步骤的依赖关系
+     */
+    getStepDependencies(step) {
+        const dependencies = {
+            code_review: ['verify'],
+            design_doc: ['proposal'],
+            plan_doc: ['proposal'],
+            security_review: ['verify'],
+            adr: ['proposal'],
+            db_change_doc: ['verify'],
+            api_change_doc: ['verify'],
+        };
+        return dependencies[step] || [];
+    }
+    /**
+     * 获取工作流配置
+     */
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * 获取存档门禁配置
+     */
+    getArchiveGate() {
+        return this.config.archive_gate;
+    }
+    /**
+     * 生成工作流摘要
+     */
+    getSummary(featureFlags) {
+        const activated = this.getActivatedSteps(featureFlags);
+        const validation = this.validateFlags(featureFlags);
+        return {
+            mode: this.mode,
+            coreSteps: this.config.core_required.length,
+            optionalSteps: activated,
+            totalSteps: this.config.core_required.length + activated.length,
+            flags: featureFlags,
+            unsupportedFlags: validation.unsupported,
+        };
+    }
+    /**
+     * 获取当前模式
+     */
+    getMode() {
+        return this.mode;
+    }
+}
+exports.ConfigurableWorkflow = ConfigurableWorkflow;
+//# sourceMappingURL=ConfigurableWorkflow.js.map

package/dist/workflow/HookSystem.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 钩子系统
+ * 执行工作流前后的回调
+ */
+export type HookEvent = 'pre-init' | 'post-init' | 'pre-new' | 'post-new' | 'pre-verify' | 'post-verify' | 'pre-archive' | 'post-archive' | 'pre-commit' | 'post-merge';
+export interface Hook {
+    event: HookEvent;
+    handler: (context: any) => Promise<void> | void;
+    priority?: number;
+}
+export declare class HookSystem {
+    private hooks;
+    /**
+     * 注册钩子
+     */
+    register(event: HookEvent, handler: (context: any) => Promise<void> | void, priority?: number): void;
+    /**
+     * 执行钩子
+     */
+    execute(event: HookEvent, context?: any): Promise<void>;
+    /**
+     * 移除钩子
+     */
+    unregister(event: HookEvent, handler: (context: any) => Promise<void> | void): void;
+    /**
+     * 清空所有钩子
+     */
+    clear(): void;
+    /**
+     * 获取已注册的钩子列表
+     */
+    getHooks(event?: HookEvent): {
+        event: HookEvent;
+        count: number;
+    }[];
+}
+export declare const hookSystem: HookSystem;
+//# sourceMappingURL=HookSystem.d.ts.map

package/dist/workflow/HookSystem.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * 钩子系统
+ * 执行工作流前后的回调
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hookSystem = exports.HookSystem = void 0;
+class HookSystem {
+    constructor() {
+        this.hooks = new Map();
+    }
+    /**
+     * 注册钩子
+     */
+    register(event, handler, priority = 0) {
+        if (!this.hooks.has(event)) {
+            this.hooks.set(event, []);
+        }
+        const hookList = this.hooks.get(event);
+        hookList.push({ event, handler, priority });
+        // 按优先级排序（降序）
+        hookList.sort((a, b) => (b.priority || 0) - (a.priority || 0));
+    }
+    /**
+     * 执行钩子
+     */
+    async execute(event, context = {}) {
+        const hookList = this.hooks.get(event) || [];
+        for (const hook of hookList) {
+            await Promise.resolve(hook.handler(context));
+        }
+    }
+    /**
+     * 移除钩子
+     */
+    unregister(event, handler) {
+        if (!this.hooks.has(event))
+            return;
+        const hookList = this.hooks.get(event);
+        const index = hookList.findIndex(h => h.handler === handler);
+        if (index >= 0) {
+            hookList.splice(index, 1);
+        }
+    }
+    /**
+     * 清空所有钩子
+     */
+    clear() {
+        this.hooks.clear();
+    }
+    /**
+     * 获取已注册的钩子列表
+     */
+    getHooks(event) {
+        if (event) {
+            const count = this.hooks.get(event)?.length || 0;
+            return [{ event, count }];
+        }
+        return Array.from(this.hooks.entries())
+            .map(([event, hooks]) => ({ event, count: hooks.length }))
+            .filter(h => h.count > 0);
+    }
+}
+exports.HookSystem = HookSystem;
+exports.hookSystem = new HookSystem();
+//# sourceMappingURL=HookSystem.js.map

package/dist/workflow/IndexRegenerator.d.ts

@@ -0,0 +1,49 @@
+/**
+ * 索引再生成引擎
+ * 重新生成项目的功能索引
+ */
+export interface IndexEntry {
+    name: string;
+    path: string;
+    status: string;
+    lastUpdated: string;
+    tags?: string[];
+}
+export interface ProjectIndex {
+    version: string;
+    generated: string;
+    features: IndexEntry[];
+    stats: {
+        total: number;
+        draft: number;
+        active: number;
+        completed: number;
+    };
+}
+export declare class IndexRegenerator {
+    /**
+     * 生成完整索引
+     */
+    regenerateIndex(projectDir: string): Promise<ProjectIndex>;
+    /**
+     * 保存索引文件
+     */
+    private saveIndex;
+    /**
+     * 读取现有索引
+     */
+    readIndex(projectDir: string): Promise<ProjectIndex | null>;
+    /**
+     * 获取索引统计
+     */
+    getIndexStats(projectDir: string): Promise<ProjectIndex['stats']>;
+    /**
+     * 验证索引完整性
+     */
+    validateIndex(projectDir: string): Promise<{
+        valid: boolean;
+        errors: string[];
+    }>;
+}
+export declare const indexRegenerator: IndexRegenerator;
+//# sourceMappingURL=IndexRegenerator.d.ts.map

package/dist/workflow/IndexRegenerator.js

@@ -0,0 +1,147 @@
+"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.indexRegenerator = exports.IndexRegenerator = void 0;
+const path = __importStar(require("path"));
+const services_1 = require("../services");
+const constants_1 = require("../core/constants");
+class IndexRegenerator {
+    /**
+     * 生成完整索引
+     */
+    async regenerateIndex(projectDir) {
+        const featuresDir = path.join(projectDir, 'features');
+        const features = [];
+        try {
+            const featureFolders = await services_1.services.fileService.readDir(featuresDir);
+            for (const featureName of featureFolders) {
+                const featurePath = path.join(featuresDir, featureName);
+                const stat = await services_1.services.fileService.stat(featurePath);
+                if (!stat.isDirectory())
+                    continue;
+                try {
+                    const statePath = path.join(featurePath, constants_1.FILE_NAMES.STATE);
+                    const state = await services_1.services.fileService.readJSON(statePath);
+                    features.push({
+                        name: featureName,
+                        path: featurePath,
+                        status: state.status || 'unknown',
+                        lastUpdated: state.last_updated || new Date().toISOString(),
+                        tags: state.tags || [],
+                    });
+                }
+                catch (error) {
+                    // 如果没有状态文件，跳过
+                    services_1.services.logger.warn(`No state file for feature: ${featureName}`);
+                }
+            }
+        }
+        catch (error) {
+            services_1.services.logger.warn(`Features directory not found: ${featuresDir}`);
+        }
+        // 生成统计数据
+        const stats = {
+            total: features.length,
+            draft: features.filter(f => f.status === 'draft').length,
+            active: features.filter(f => f.status === 'active').length,
+            completed: features.filter(f => f.status === 'completed').length,
+        };
+        const index = {
+            version: '1.0',
+            generated: new Date().toISOString(),
+            features: features.sort((a, b) => a.name.localeCompare(b.name)),
+            stats,
+        };
+        // 保存索引文件
+        await this.saveIndex(projectDir, index);
+        return index;
+    }
+    /**
+     * 保存索引文件
+     */
+    async saveIndex(projectDir, index) {
+        const indexPath = path.join(projectDir, constants_1.FILE_NAMES.INDEX);
+        await services_1.services.fileService.writeJSON(indexPath, index);
+    }
+    /**
+     * 读取现有索引
+     */
+    async readIndex(projectDir) {
+        try {
+            const indexPath = path.join(projectDir, constants_1.FILE_NAMES.INDEX);
+            return await services_1.services.fileService.readJSON(indexPath);
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * 获取索引统计
+     */
+    async getIndexStats(projectDir) {
+        const index = await this.readIndex(projectDir);
+        return index?.stats || { total: 0, draft: 0, active: 0, completed: 0 };
+    }
+    /**
+     * 验证索引完整性
+     */
+    async validateIndex(projectDir) {
+        const index = await this.readIndex(projectDir);
+        const errors = [];
+        if (!index) {
+            errors.push('Index file not found');
+            return { valid: false, errors };
+        }
+        // 验证所有条目
+        for (const entry of index.features) {
+            const statePath = path.join(entry.path, constants_1.FILE_NAMES.STATE);
+            const exists = await services_1.services.fileService.exists(statePath);
+            if (!exists) {
+                errors.push(`State file missing for feature: ${entry.name}`);
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+}
+exports.IndexRegenerator = IndexRegenerator;
+exports.indexRegenerator = new IndexRegenerator();
+//# sourceMappingURL=IndexRegenerator.js.map

package/dist/workflow/PluginWorkflowComposer.d.ts

@@ -0,0 +1,138 @@
+import { SkillrcConfig } from '../core/types';
+export declare const DEFAULT_STITCH_PLUGIN_CONFIG: {
+    enabled: boolean;
+    blocking: boolean;
+    project: {
+        project_id: string;
+        project_url: string;
+        save_on_first_run: boolean;
+        enforce_single_project: boolean;
+    };
+    gemini: {
+        model: string;
+        auto_switch_on_limit: boolean;
+        save_on_fallback: boolean;
+    };
+    codex: {
+        model: string;
+        mcp_server: string;
+    };
+    runner: {
+        mode: string;
+        command: string;
+        args: string[];
+        cwd: string;
+        timeout_ms: number;
+        token_env: string;
+        extra_env: {};
+    };
+    provider: string;
+    capabilities: {
+        page_design_review: {
+            enabled: boolean;
+            step: string;
+            activate_when_flags: string[];
+        };
+    };
+};
+export declare const DEFAULT_CHECKPOINT_PLUGIN_CONFIG: {
+    enabled: boolean;
+    blocking: boolean;
+    runtime: {
+        base_url: string;
+        startup: {
+            command: string;
+            args: never[];
+            cwd: string;
+            timeout_ms: number;
+        };
+        readiness: {
+            type: string;
+            url: string;
+            timeout_ms: number;
+        };
+        shutdown: {
+            command: string;
+            args: never[];
+            cwd: string;
+            timeout_ms: number;
+        };
+        storage_state: string;
+    };
+    runner: {
+        mode: string;
+        command: string;
+        args: string[];
+        cwd: string;
+        timeout_ms: number;
+        token_env: string;
+        extra_env: {};
+    };
+    capabilities: {
+        ui_review: {
+            enabled: boolean;
+            step: string;
+            activate_when_flags: string[];
+        };
+        flow_check: {
+            enabled: boolean;
+            step: string;
+            activate_when_flags: string[];
+        };
+    };
+    stitch_integration: {
+        enabled: boolean;
+        auto_pass_stitch_review: boolean;
+    };
+};
+export interface EnabledPluginSummary {
+    name: string;
+    blocking: boolean;
+}
+export interface PluginCapabilitySummary {
+    plugin: string;
+    capability: string;
+    step: string;
+    activateWhenFlags: string[];
+    blocking: boolean;
+}
+export declare class PluginWorkflowComposer {
+    private config;
+    constructor(config: SkillrcConfig);
+    private getBaseConfig;
+    getCoreSteps(): string[];
+    getBaseOptionalSteps(): Record<string, {
+        enabled: boolean;
+        when: string[];
+    }>;
+    getActivatedBaseSteps(featureFlags: string[]): string[];
+    getEnabledPlugins(): EnabledPluginSummary[];
+    getStitchCapabilities(): PluginCapabilitySummary[];
+    getCheckpointCapabilities(): PluginCapabilitySummary[];
+    getPluginCapabilities(): PluginCapabilitySummary[];
+    getPluginContributedSteps(): string[];
+    getActivatedPluginSteps(featureFlags: string[]): string[];
+    getActivatedSteps(featureFlags: string[]): string[];
+    getSupportedFlags(): string[];
+    getArchiveGate(): {
+        require_verification: boolean;
+        require_skill_update: boolean;
+        require_index_regenerated: boolean;
+        require_optional_steps_passed: boolean;
+    };
+    validateFlags(flags: string[]): {
+        valid: boolean;
+        unsupported: string[];
+    };
+    getSummary(featureFlags: string[]): {
+        mode: string;
+        coreSteps: number;
+        optionalSteps: string[];
+        pluginSteps: string[];
+        totalSteps: number;
+        enabledPlugins: string[];
+        flags: string[];
+        unsupportedFlags: string[];
+    };
+}
+//# sourceMappingURL=PluginWorkflowComposer.d.ts.map