@clawplays/ospec-cli 0.1.1

package/dist/services/SkillParser.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * SKILL 解析服务
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skillParser = exports.SkillParser = void 0;
+const gray_matter_1 = __importDefault(require("gray-matter"));
+class SkillParser {
+    normalizeLineEndings(content) {
+        return String(content || '').replace(/\r\n?/g, '\n');
+    }
+    /**
+     * 解析 SKILL.md 的前置信息和内容
+     */
+    parseFrontmatter(content) {
+        const normalizedContent = this.normalizeLineEndings(content);
+        const { data, content: body } = (0, gray_matter_1.default)(normalizedContent);
+        const tags = Array.isArray(data.tags)
+            ? data.tags.map(tag => String(tag).trim()).filter(Boolean)
+            : typeof data.tags === 'string'
+                ? data.tags.split(',').map(tag => tag.trim()).filter(Boolean)
+                : [];
+        const title = typeof data.title === 'string' && data.title.trim().length > 0
+            ? data.title.trim()
+            : this.extractDocumentTitle(body);
+        const name = typeof data.name === 'string' && data.name.trim().length > 0
+            ? data.name.trim()
+            : title || 'Unknown';
+        return {
+            data: {
+                name,
+                title: title || undefined,
+                tags,
+            },
+            content: body,
+        };
+    }
+    /**
+     * 提取 Markdown 中的标题结构
+     */
+    extractSections(content) {
+        const sections = {};
+        const headingRegex = /^(#{1,6})\s+(.+?)$/gm;
+        const matches = [];
+        let match;
+        while ((match = headingRegex.exec(content)) !== null) {
+            matches.push({
+                level: match[1].length,
+                title: match[2].trim(),
+                start: match.index,
+                headerEnd: match.index + match[0].length,
+            });
+        }
+        for (let index = 0; index < matches.length; index += 1) {
+            const current = matches[index];
+            const next = matches[index + 1];
+            sections[current.title] = {
+                level: current.level,
+                title: current.title,
+                start: current.start,
+                end: next ? next.start : content.length,
+            };
+        }
+        return sections;
+    }
+    /**
+     * 完整解析 SKILL.md 文件
+     */
+    parseSkillFile(content) {
+        const { data, content: body } = this.parseFrontmatter(this.normalizeLineEndings(content));
+        const sections = this.extractSections(body);
+        return {
+            frontmatter: data,
+            sections,
+            content: body,
+        };
+    }
+    extractDocumentTitle(content) {
+        const titleMatch = content.match(/^#\s+(.+)$/m);
+        return titleMatch?.[1]?.trim() || null;
+    }
+}
+exports.SkillParser = SkillParser;
+exports.skillParser = new SkillParser();
+//# sourceMappingURL=SkillParser.js.map

package/dist/services/StateManager.d.ts

@@ -0,0 +1,16 @@
+import { FeatureState, FeatureStatus, ProjectMode } from '../core/types';
+import { FileService } from './FileService';
+export declare class StateManager {
+    private fileService;
+    constructor(fileService: FileService);
+    readState(featurePath: string): Promise<FeatureState>;
+    writeState(featurePath: string, state: FeatureState): Promise<void>;
+    validateTransition(currentStatus: FeatureStatus, targetStatus: FeatureStatus): boolean;
+    transitionStatus(featurePath: string, targetStatus: FeatureStatus): Promise<void>;
+    createInitialState(feature: string, affects: string[], mode?: ProjectMode, options?: {
+        queued?: boolean;
+        source?: string;
+    }): FeatureState;
+}
+export declare function createStateManager(fileService: FileService): StateManager;
+//# sourceMappingURL=StateManager.d.ts.map

package/dist/services/StateManager.js

@@ -0,0 +1,127 @@
+"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.StateManager = void 0;
+exports.createStateManager = createStateManager;
+const path = __importStar(require("path"));
+const constants_1 = require("../core/constants");
+const errors_1 = require("../core/errors");
+class StateManager {
+    constructor(fileService) {
+        this.fileService = fileService;
+    }
+    async readState(featurePath) {
+        const statePath = path.join(featurePath, constants_1.FILE_NAMES.STATE);
+        try {
+            return await this.fileService.readJSON(statePath);
+        }
+        catch {
+            throw new errors_1.FeatureNotFoundError(featurePath);
+        }
+    }
+    async writeState(featurePath, state) {
+        const statePath = path.join(featurePath, constants_1.FILE_NAMES.STATE);
+        state.last_updated = new Date().toISOString();
+        await this.fileService.writeJSON(statePath, state);
+    }
+    validateTransition(currentStatus, targetStatus) {
+        const allowedTransitions = constants_1.STATE_TRANSITIONS[currentStatus];
+        return Boolean(allowedTransitions && allowedTransitions.includes(targetStatus));
+    }
+    async transitionStatus(featurePath, targetStatus) {
+        const state = await this.readState(featurePath);
+        const currentStatus = state.status;
+        if (!this.validateTransition(currentStatus, targetStatus)) {
+            throw new errors_1.InvalidStateTransitionError(currentStatus, targetStatus);
+        }
+        state.status = targetStatus;
+        state.current_step = targetStatus;
+        await this.writeState(featurePath, state);
+    }
+    createInitialState(feature, affects, mode = 'standard', options = {}) {
+        const now = new Date().toISOString();
+        if (options.queued) {
+            return {
+                version: '1.0',
+                feature,
+                mode,
+                status: 'queued',
+                current_step: 'queued',
+                affects,
+                completed: [],
+                pending: [
+                    'proposal_complete',
+                    'tasks_complete',
+                    'implementation_complete',
+                    'skill_updated',
+                    'index_regenerated',
+                    'tests_passed',
+                    'verification_passed',
+                    'archived',
+                ],
+                blocked_by: ['awaiting_activation'],
+                queued_at: now,
+                queue_source: options.source ?? 'queue',
+                last_updated: now,
+            };
+        }
+        return {
+            version: '1.0',
+            feature,
+            mode,
+            status: 'draft',
+            current_step: 'write_proposal',
+            affects,
+            completed: [],
+            pending: [
+                'proposal_complete',
+                'tasks_complete',
+                'implementation_complete',
+                'skill_updated',
+                'index_regenerated',
+                'tests_passed',
+                'verification_passed',
+                'archived',
+            ],
+            blocked_by: ['missing_proposal'],
+            last_updated: now,
+        };
+    }
+}
+exports.StateManager = StateManager;
+function createStateManager(fileService) {
+    return new StateManager(fileService);
+}
+//# sourceMappingURL=StateManager.js.map

package/dist/services/TemplateEngine.d.ts

@@ -0,0 +1,43 @@
+import { ProjectMode } from '../core/types';
+export type { BootstrapFieldKey, BootstrapFieldSource, FeatureProjectContext, FeatureProjectReference, FeatureTemplateInput, NormalizedFeatureTemplateInput, NormalizedProjectBootstrapInput, PlannedProjectFile, ProjectBootstrapInput, TemplateDocumentLanguage, } from './templates/templateTypes';
+import { FeatureTemplateInput, NormalizedFeatureTemplateInput, NormalizedProjectBootstrapInput, ProjectBootstrapInput } from './templates/templateTypes';
+export declare class TemplateEngine {
+    private readonly inputFactory;
+    private readonly executionBuilder;
+    private readonly projectBuilder;
+    render(template: string, context: Record<string, unknown>): string;
+    parseSkillMetadata(content: string): {
+        title: string | null;
+        tags: string[];
+    };
+    normalizeFeatureTemplateInput(input: string | FeatureTemplateInput): NormalizedFeatureTemplateInput;
+    normalizeProjectBootstrapInput(input: ProjectBootstrapInput | undefined, fallbackName: string, mode: ProjectMode, inferredDefaults?: Partial<ProjectBootstrapInput>, presetDefaults?: Partial<ProjectBootstrapInput>): NormalizedProjectBootstrapInput;
+    generateProposalTemplate(input: string | FeatureTemplateInput): string;
+    generateTasksTemplate(input: string | FeatureTemplateInput): string;
+    generateVerificationTemplate(input: string | FeatureTemplateInput): string;
+    generateReviewTemplate(input: string | FeatureTemplateInput): string;
+    generateProjectReadmeTemplate(fallbackName: string, mode: ProjectMode, input?: ProjectBootstrapInput): string;
+    generateRootSkillTemplate(fallbackName: string, mode: ProjectMode, input?: ProjectBootstrapInput): string;
+    generateDocsSkillTemplate(fallbackName: string, input?: ProjectBootstrapInput): string;
+    generateSrcSkillTemplate(fallbackName: string, input?: ProjectBootstrapInput): string;
+    generateCoreSkillTemplate(fallbackName: string, input?: ProjectBootstrapInput): string;
+    generateTestsSkillTemplate(fallbackName: string, input?: ProjectBootstrapInput): string;
+    generateProjectOverviewTemplate(fallbackName: string, mode: ProjectMode, input?: ProjectBootstrapInput): string;
+    generateTechStackTemplate(fallbackName: string, input?: ProjectBootstrapInput): string;
+    generateArchitectureTemplate(fallbackName: string, input?: ProjectBootstrapInput): string;
+    generateModuleMapTemplate(fallbackName: string, input?: ProjectBootstrapInput): string;
+    generateApiOverviewTemplate(fallbackName: string, input?: ProjectBootstrapInput): string;
+    generateDesignDocsTemplate(fallbackName: string, input?: ProjectBootstrapInput): string;
+    generatePlanningDocsTemplate(fallbackName: string, input?: ProjectBootstrapInput): string;
+    generateApiDocsTemplate(fallbackName: string, input?: ProjectBootstrapInput): string;
+    generateModuleSkillTemplate(fallbackName: string, moduleName: string, input?: ProjectBootstrapInput, moduleSlug?: string): string;
+    generateApiAreaDocTemplate(fallbackName: string, apiAreaName: string, input?: ProjectBootstrapInput): string;
+    generateModuleApiDocTemplate(fallbackName: string, moduleName: string, input?: ProjectBootstrapInput, moduleSlug?: string): string;
+    generateDesignDocTemplate(fallbackName: string, docName: string, input?: ProjectBootstrapInput): string;
+    generatePlanningDocTemplate(fallbackName: string, docName: string, input?: ProjectBootstrapInput): string;
+    generateAiGuideTemplate(input?: ProjectBootstrapInput): string;
+    generateExecutionProtocolTemplate(input?: ProjectBootstrapInput): string;
+    generateBuildIndexScriptTemplate(): string;
+}
+export declare const templateEngine: TemplateEngine;
+//# sourceMappingURL=TemplateEngine.d.ts.map

package/dist/services/TemplateEngine.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templateEngine = exports.TemplateEngine = void 0;
+const ExecutionTemplateBuilder_1 = require("./templates/ExecutionTemplateBuilder");
+const ProjectTemplateBuilder_1 = require("./templates/ProjectTemplateBuilder");
+const TemplateInputFactory_1 = require("./templates/TemplateInputFactory");
+class TemplateEngine {
+    constructor() {
+        this.inputFactory = new TemplateInputFactory_1.TemplateInputFactory();
+        this.executionBuilder = new ExecutionTemplateBuilder_1.ExecutionTemplateBuilder(this.inputFactory);
+        this.projectBuilder = new ProjectTemplateBuilder_1.ProjectTemplateBuilder(this.inputFactory);
+    }
+    render(template, context) {
+        return template.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+            return context[key] !== undefined ? String(context[key]) : match;
+        });
+    }
+    parseSkillMetadata(content) {
+        const titleMatch = content.match(/^#\s+(.+)$/m);
+        const tagsMatch = content.match(/^tags:\s*\[(.*)\]\s*$/m);
+        const tags = tagsMatch?.[1]
+            ? tagsMatch[1]
+                .split(',')
+                .map(tag => tag.trim())
+                .filter(Boolean)
+            : [];
+        return {
+            title: titleMatch?.[1]?.trim() || null,
+            tags,
+        };
+    }
+    normalizeFeatureTemplateInput(input) {
+        return this.inputFactory.normalizeFeatureTemplateInput(input);
+    }
+    normalizeProjectBootstrapInput(input, fallbackName, mode, inferredDefaults, presetDefaults) {
+        return this.inputFactory.normalizeProjectBootstrapInput(input, fallbackName, mode, inferredDefaults, presetDefaults);
+    }
+    generateProposalTemplate(input) {
+        return this.executionBuilder.generateProposalTemplate(input);
+    }
+    generateTasksTemplate(input) {
+        return this.executionBuilder.generateTasksTemplate(input);
+    }
+    generateVerificationTemplate(input) {
+        return this.executionBuilder.generateVerificationTemplate(input);
+    }
+    generateReviewTemplate(input) {
+        return this.executionBuilder.generateReviewTemplate(input);
+    }
+    generateProjectReadmeTemplate(fallbackName, mode, input) {
+        return this.projectBuilder.generateProjectReadmeTemplate(fallbackName, mode, input);
+    }
+    generateRootSkillTemplate(fallbackName, mode, input) {
+        return this.projectBuilder.generateRootSkillTemplate(fallbackName, mode, input);
+    }
+    generateDocsSkillTemplate(fallbackName, input) {
+        return this.projectBuilder.generateDocsSkillTemplate(fallbackName, input);
+    }
+    generateSrcSkillTemplate(fallbackName, input) {
+        return this.projectBuilder.generateSrcSkillTemplate(fallbackName, input);
+    }
+    generateCoreSkillTemplate(fallbackName, input) {
+        return this.projectBuilder.generateCoreSkillTemplate(fallbackName, input);
+    }
+    generateTestsSkillTemplate(fallbackName, input) {
+        return this.projectBuilder.generateTestsSkillTemplate(fallbackName, input);
+    }
+    generateProjectOverviewTemplate(fallbackName, mode, input) {
+        return this.projectBuilder.generateProjectOverviewTemplate(fallbackName, mode, input);
+    }
+    generateTechStackTemplate(fallbackName, input) {
+        return this.projectBuilder.generateTechStackTemplate(fallbackName, input);
+    }
+    generateArchitectureTemplate(fallbackName, input) {
+        return this.projectBuilder.generateArchitectureTemplate(fallbackName, input);
+    }
+    generateModuleMapTemplate(fallbackName, input) {
+        return this.projectBuilder.generateModuleMapTemplate(fallbackName, input);
+    }
+    generateApiOverviewTemplate(fallbackName, input) {
+        return this.projectBuilder.generateApiOverviewTemplate(fallbackName, input);
+    }
+    generateDesignDocsTemplate(fallbackName, input) {
+        return this.projectBuilder.generateDesignDocsTemplate(fallbackName, input);
+    }
+    generatePlanningDocsTemplate(fallbackName, input) {
+        return this.projectBuilder.generatePlanningDocsTemplate(fallbackName, input);
+    }
+    generateApiDocsTemplate(fallbackName, input) {
+        return this.projectBuilder.generateApiDocsTemplate(fallbackName, input);
+    }
+    generateModuleSkillTemplate(fallbackName, moduleName, input, moduleSlug) {
+        return this.projectBuilder.generateModuleSkillTemplate(fallbackName, moduleName, input, moduleSlug);
+    }
+    generateApiAreaDocTemplate(fallbackName, apiAreaName, input) {
+        return this.projectBuilder.generateApiAreaDocTemplate(fallbackName, apiAreaName, input);
+    }
+    generateModuleApiDocTemplate(fallbackName, moduleName, input, moduleSlug) {
+        return this.projectBuilder.generateModuleApiDocTemplate(fallbackName, moduleName, input, moduleSlug);
+    }
+    generateDesignDocTemplate(fallbackName, docName, input) {
+        return this.projectBuilder.generateDesignDocTemplate(fallbackName, docName, input);
+    }
+    generatePlanningDocTemplate(fallbackName, docName, input) {
+        return this.projectBuilder.generatePlanningDocTemplate(fallbackName, docName, input);
+    }
+    generateAiGuideTemplate(input) {
+        return this.projectBuilder.generateAiGuideTemplate(input);
+    }
+    generateExecutionProtocolTemplate(input) {
+        return this.projectBuilder.generateExecutionProtocolTemplate(input);
+    }
+    generateBuildIndexScriptTemplate() {
+        return this.projectBuilder.generateBuildIndexScriptTemplate();
+    }
+}
+exports.TemplateEngine = TemplateEngine;
+exports.templateEngine = new TemplateEngine();
+//# sourceMappingURL=TemplateEngine.js.map

package/dist/services/TemplateGenerator.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 模板生成服务
+ * 负责生成 proposal.md、tasks.md、verification.md 等模板文件
+ */
+import { FeatureState } from '../core/types';
+export declare class TemplateGenerator {
+    /**
+     * 生成 proposal.md 模板
+     */
+    static generateProposalTemplate(featureName: string, affects?: string[]): string;
+    /**
+     * 生成 tasks.md 模板
+     */
+    static generateTasksTemplate(featureName: string, coreRequiredSteps?: string[], optionalSteps?: string[]): string;
+    /**
+     * 生成 verification.md 模板
+     */
+    static generateVerificationTemplate(featureName: string, optionalSteps?: string[]): string;
+    /**
+     * 生成 state.json 内容
+     */
+    static generateStateJson(featureName: string, affects?: string[], mode?: 'lite' | 'standard' | 'full'): FeatureState;
+    /**
+     * 创建 feature 目录和文件
+     */
+    static createFeatureDirectory(projectRoot: string, featureName: string, affects?: string[], coreRequiredSteps?: string[], optionalSteps?: string[]): Promise<void>;
+    /**
+     * 生成项目初始化文件
+     */
+    static initializeProject(projectRoot: string, mode?: 'lite' | 'standard' | 'full'): Promise<void>;
+    /**
+     * 生成 AI 指南
+     */
+    private static generateAiGuide;
+    /**
+     * 生成执行协议
+     */
+    private static generateExecutionProtocol;
+}
+//# sourceMappingURL=TemplateGenerator.d.ts.map