@clawplays/ospec-cli 0.1.1

package/dist/commands/VerifyCommand.js

@@ -0,0 +1,278 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerifyCommand = void 0;
+const path = __importStar(require("path"));
+const gray_matter_1 = __importDefault(require("gray-matter"));
+const constants_1 = require("../core/constants");
+const services_1 = require("../services");
+const PluginWorkflowComposer_1 = require("../workflow/PluginWorkflowComposer");
+const BaseCommand_1 = require("./BaseCommand");
+class VerifyCommand extends BaseCommand_1.BaseCommand {
+    async execute(featurePath) {
+        try {
+            const targetPath = featurePath || process.cwd();
+            this.logger.info(`Verifying change at ${targetPath}`);
+            const statePath = path.join(targetPath, constants_1.FILE_NAMES.STATE);
+            const proposalPath = path.join(targetPath, constants_1.FILE_NAMES.PROPOSAL);
+            const tasksPath = path.join(targetPath, constants_1.FILE_NAMES.TASKS);
+            const verificationPath = path.join(targetPath, constants_1.FILE_NAMES.VERIFICATION);
+            const [stateExists, proposalExists, tasksExists, verificationExists] = await Promise.all([
+                services_1.services.fileService.exists(statePath),
+                services_1.services.fileService.exists(proposalPath),
+                services_1.services.fileService.exists(tasksPath),
+                services_1.services.fileService.exists(verificationPath),
+            ]);
+            if (!stateExists) {
+                throw new Error('Change state file not found. Expected changes/active/<change>/state.json');
+            }
+            const featureState = await services_1.services.fileService.readJSON(statePath);
+            const projectRoot = path.resolve(targetPath, '..', '..', '..');
+            const config = await services_1.services.configManager.loadConfig(projectRoot);
+            const workflow = new PluginWorkflowComposer_1.PluginWorkflowComposer(config);
+            const checks = [
+                {
+                    name: 'proposal.md',
+                    status: proposalExists ? 'pass' : 'fail',
+                    message: proposalExists ? 'Proposal file exists' : 'proposal.md is missing',
+                },
+                {
+                    name: 'tasks.md',
+                    status: tasksExists ? 'pass' : 'fail',
+                    message: tasksExists ? 'Tasks file exists' : 'tasks.md is missing',
+                },
+                {
+                    name: 'verification.md',
+                    status: verificationExists ? 'pass' : 'fail',
+                    message: verificationExists
+                        ? 'Verification file exists'
+                        : 'verification.md is missing',
+                },
+            ];
+            let activatedSteps = [];
+            if (proposalExists) {
+                const proposal = (0, gray_matter_1.default)(await services_1.services.fileService.readFile(proposalPath));
+                const flags = Array.isArray(proposal.data.flags) ? proposal.data.flags : [];
+                activatedSteps = workflow.getActivatedSteps(flags);
+                checks.push({
+                    name: 'proposal.flags',
+                    status: 'pass',
+                    message: activatedSteps.length > 0
+                        ? `Activated optional steps: ${activatedSteps.join(', ')}`
+                        : 'No optional steps activated',
+                });
+            }
+            if (tasksExists) {
+                const tasksContent = await services_1.services.fileService.readFile(tasksPath);
+                const tasks = (0, gray_matter_1.default)(tasksContent);
+                const optionalSteps = Array.isArray(tasks.data.optional_steps)
+                    ? tasks.data.optional_steps
+                    : [];
+                const missing = activatedSteps.filter(step => !optionalSteps.includes(step));
+                checks.push({
+                    name: 'tasks.optional_steps',
+                    status: missing.length === 0 ? 'pass' : 'fail',
+                    message: missing.length === 0
+                        ? 'All activated optional steps are present in tasks.md'
+                        : `Missing optional steps in tasks.md: ${missing.join(', ')}`,
+                });
+                checks.push({
+                    name: 'tasks checklist',
+                    status: /- \[ \]/.test(tasksContent) ? 'warn' : 'pass',
+                    message: /- \[ \]/.test(tasksContent)
+                        ? 'tasks.md still has unchecked items'
+                        : 'tasks.md checklist is complete',
+                });
+            }
+            if (verificationExists) {
+                const verificationContent = await services_1.services.fileService.readFile(verificationPath);
+                const verification = (0, gray_matter_1.default)(verificationContent);
+                const optionalSteps = Array.isArray(verification.data.optional_steps)
+                    ? verification.data.optional_steps
+                    : [];
+                const missing = activatedSteps.filter(step => !optionalSteps.includes(step));
+                checks.push({
+                    name: 'verification.optional_steps',
+                    status: missing.length === 0 ? 'pass' : 'fail',
+                    message: missing.length === 0
+                        ? 'All activated optional steps are present in verification.md'
+                        : `Missing optional steps in verification.md: ${missing.join(', ')}`,
+                });
+                checks.push({
+                    name: 'verification checklist',
+                    status: /- \[ \]/.test(verificationContent) ? 'warn' : 'pass',
+                    message: /- \[ \]/.test(verificationContent)
+                        ? 'verification.md still has unchecked items'
+                        : 'verification.md checklist is complete',
+                });
+            }
+            if (activatedSteps.includes('stitch_design_review')) {
+                const approvalPath = path.join(targetPath, 'artifacts', 'stitch', 'approval.json');
+                const approvalExists = await services_1.services.fileService.exists(approvalPath);
+                checks.push({
+                    name: 'stitch.approval',
+                    status: approvalExists ? 'pass' : 'fail',
+                    message: approvalExists
+                        ? 'Stitch approval artifact exists'
+                        : 'artifacts/stitch/approval.json is missing',
+                });
+                if (approvalExists) {
+                    const approval = await services_1.services.fileService.readJSON(approvalPath);
+                    const approvalStatus = typeof approval.status === 'string' ? approval.status : 'pending';
+                    const validStep = approval.step === 'stitch_design_review';
+                    const hasPreviewUrl = typeof approval.preview_url === 'string' && approval.preview_url.trim().length > 0;
+                    const hasSubmittedAt = typeof approval.submitted_at === 'string' && approval.submitted_at.trim().length > 0;
+                    checks.push({
+                        name: 'stitch.approval.step',
+                        status: validStep ? 'pass' : 'fail',
+                        message: validStep
+                            ? 'Stitch approval step matches stitch_design_review'
+                            : 'Stitch approval step does not match stitch_design_review',
+                    });
+                    checks.push({
+                        name: 'stitch.approval.preview_url',
+                        status: hasPreviewUrl ? 'pass' : 'fail',
+                        message: hasPreviewUrl
+                            ? 'Stitch preview URL is recorded'
+                            : 'Stitch preview URL is missing',
+                    });
+                    checks.push({
+                        name: 'stitch.approval.submitted_at',
+                        status: hasSubmittedAt ? 'pass' : 'fail',
+                        message: hasSubmittedAt
+                            ? 'Stitch submission timestamp is recorded'
+                            : 'Stitch submission timestamp is missing',
+                    });
+                    checks.push({
+                        name: 'stitch.approval.status',
+                        status: approvalStatus === 'approved' ? 'pass' : 'fail',
+                        message: approvalStatus === 'approved'
+                            ? 'Stitch design review approved'
+                            : `Stitch design review is ${approvalStatus}`,
+                    });
+                }
+            }
+            const activeCheckpointSteps = activatedSteps.filter(step => step === 'checkpoint_ui_review' || step === 'checkpoint_flow_check');
+            if (activeCheckpointSteps.length > 0) {
+                const checkpointDir = path.join(targetPath, 'artifacts', 'checkpoint');
+                const gatePath = path.join(checkpointDir, 'gate.json');
+                const resultPath = path.join(checkpointDir, 'result.json');
+                const summaryPath = path.join(checkpointDir, 'summary.md');
+                const gateExists = await services_1.services.fileService.exists(gatePath);
+                checks.push({
+                    name: 'checkpoint.gate',
+                    status: gateExists ? 'pass' : 'fail',
+                    message: gateExists
+                        ? 'Checkpoint gate artifact exists'
+                        : 'artifacts/checkpoint/gate.json is missing',
+                });
+                if (gateExists) {
+                    const gate = await services_1.services.fileService.readJSON(gatePath);
+                    checks.push({
+                        name: 'checkpoint.gate.plugin',
+                        status: gate.plugin === 'checkpoint' ? 'pass' : 'fail',
+                        message: gate.plugin === 'checkpoint'
+                            ? 'Checkpoint gate plugin matches checkpoint'
+                            : `Checkpoint gate plugin is ${gate.plugin || '(missing)'}`,
+                    });
+                    checks.push({
+                        name: 'checkpoint.gate.status',
+                        status: gate.status === 'passed' ? 'pass' : 'fail',
+                        message: gate.status === 'passed'
+                            ? 'Checkpoint gate passed'
+                            : `Checkpoint gate status is ${gate.status || '(missing)'}`,
+                    });
+                    for (const stepName of activeCheckpointSteps) {
+                        const stepStatus = gate.steps?.[stepName]?.status || 'missing';
+                        checks.push({
+                            name: `checkpoint.${stepName}`,
+                            status: stepStatus === 'passed' ? 'pass' : 'fail',
+                            message: stepStatus === 'passed'
+                                ? `${stepName} passed`
+                                : `${stepName} status is ${stepStatus}`,
+                        });
+                    }
+                }
+                const resultExists = await services_1.services.fileService.exists(resultPath);
+                const summaryExists = await services_1.services.fileService.exists(summaryPath);
+                checks.push({
+                    name: 'checkpoint.artifacts',
+                    status: resultExists || summaryExists ? 'pass' : 'fail',
+                    message: resultExists || summaryExists
+                        ? `Checkpoint artifacts present${resultExists && summaryExists ? ' (result.json and summary.md)' : resultExists ? ' (result.json)' : ' (summary.md)'}`
+                        : 'Checkpoint result.json or summary.md is required',
+                });
+            }
+            checks.push({
+                name: 'state.json',
+                status: 'pass',
+                message: `Status is ${featureState.status}, current step is ${featureState.current_step}`,
+            });
+            const failCount = checks.filter(check => check.status === 'fail').length;
+            const warnCount = checks.filter(check => check.status === 'warn').length;
+            const passed = failCount === 0;
+            const summary = failCount > 0
+                ? `${failCount} verification(s) failed`
+                : warnCount > 0
+                    ? `${warnCount} warning(s) found`
+                    : 'All verifications passed';
+            console.log('\nChange Verification Results:');
+            console.log('====================\n');
+            for (const check of checks) {
+                const icon = check.status === 'pass' ? 'PASS' : check.status === 'warn' ? 'WARN' : 'FAIL';
+                console.log(`${icon} ${check.name}: ${check.message}`);
+            }
+            console.log('\n' + '='.repeat(24));
+            console.log(`Summary: ${summary}`);
+            console.log('='.repeat(24) + '\n');
+            if (passed) {
+                this.success('All verifications passed');
+            }
+            else {
+                this.warn('Some verifications failed');
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            this.error(`Verification failed: ${error}`);
+            throw error;
+        }
+    }
+}
+exports.VerifyCommand = VerifyCommand;
+//# sourceMappingURL=VerifyCommand.js.map

package/dist/commands/WorkflowCommand.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 工作流命令
+ * 显示和管理工作流配置
+ */
+import { BaseCommand } from './BaseCommand';
+export declare class WorkflowCommand extends BaseCommand {
+    execute(action: string, ...args: string[]): Promise<void>;
+    private showWorkflow;
+    private listSupportedFlags;
+    private setMode;
+}
+//# sourceMappingURL=WorkflowCommand.d.ts.map

package/dist/commands/WorkflowCommand.js

@@ -0,0 +1,150 @@
+"use strict";
+/**
+ * 工作流命令
+ * 显示和管理工作流配置
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowCommand = void 0;
+const BaseCommand_1 = require("./BaseCommand");
+const services_1 = require("../services");
+const subcommandHelp_1 = require("../utils/subcommandHelp");
+const workflow_1 = require("../workflow");
+class WorkflowCommand extends BaseCommand_1.BaseCommand {
+    async execute(action, ...args) {
+        try {
+            if ((0, subcommandHelp_1.isHelpAction)(action)) {
+                this.info((0, subcommandHelp_1.getWorkflowHelpText)());
+                return;
+            }
+            switch (action) {
+                case 'show': {
+                    await this.showWorkflow(args[0] || process.cwd());
+                    break;
+                }
+                case 'list-flags': {
+                    await this.listSupportedFlags(args[0] || process.cwd());
+                    break;
+                }
+                case 'set-mode': {
+                    if (args.length === 0) {
+                        console.error('Usage: ospec workflow set-mode <lite|standard|full> [path]');
+                        process.exit(1);
+                    }
+                    await this.setMode(args[0], args[1] || process.cwd());
+                    break;
+                }
+                case 'simulate': {
+                    // 需要传入 mode 和 flags
+                    console.error('Usage: ospec workflow simulate <mode> <flags...>');
+                    break;
+                }
+                default:
+                    this.info((0, subcommandHelp_1.getWorkflowHelpText)());
+            }
+        }
+        catch (error) {
+            this.error(`Workflow command failed: ${error}`);
+            throw error;
+        }
+    }
+    async showWorkflow(projectPath) {
+        try {
+            // ?????????
+            const config = await services_1.services.configManager.loadConfig(projectPath);
+            const mode = config.mode;
+            const workflow = new workflow_1.ConfigurableWorkflow(mode);
+            const composer = new workflow_1.PluginWorkflowComposer(config);
+            console.log('\n?? Workflow Configuration:');
+            console.log('=========================\n');
+            console.log(`Mode: ${mode.toUpperCase()}\n`);
+            console.log('Core Steps (Required):');
+            const coreSteps = composer.getCoreSteps();
+            coreSteps.forEach((step, i) => {
+                console.log(`  ${i + 1}. ${step}`);
+            });
+            console.log('\nOptional Steps:');
+            const optionalSteps = config.workflow?.optional_steps || workflow.getConfig().optional_steps;
+            for (const [name, config] of Object.entries(optionalSteps)) {
+                if (config.enabled) {
+                    console.log(`  ? ${name}`);
+                    console.log(`    Triggers: ${config.when.join(', ')}`);
+                }
+            }
+            console.log('\nEnabled Plugins:');
+            const enabledPlugins = composer.getEnabledPlugins();
+            if (enabledPlugins.length === 0) {
+                console.log('  (none)');
+            }
+            else {
+                enabledPlugins.forEach(plugin => {
+                    console.log(`  ? ${plugin.name}${plugin.blocking ? ' (blocking)' : ''}`);
+                });
+            }
+            const pluginCapabilities = composer.getPluginCapabilities();
+            if (pluginCapabilities.length > 0) {
+                console.log('\nPlugin-Contributed Steps:');
+                pluginCapabilities.forEach(capability => {
+                    console.log(`  ? ${capability.step}`);
+                    console.log(`    Plugin: ${capability.plugin}`);
+                    console.log(`    Capability: ${capability.capability}`);
+                    console.log(`    Triggers: ${capability.activateWhenFlags.join(', ')}`);
+                });
+            }
+            console.log('\nSupported Workflow Flags:');
+            const flags = composer.getSupportedFlags();
+            flags.forEach((flag, i) => {
+                if ((i + 1) % 3 === 0) {
+                    console.log(`  ${flag}`);
+                }
+                else {
+                    process.stdout.write(`  ${flag}\n`);
+                }
+            });
+            console.log('\n' + '='.repeat(25) + '\n');
+        }
+        catch (error) {
+            this.error(`Failed to show workflow: ${error}`);
+            throw error;
+        }
+    }
+    async listSupportedFlags(projectPath) {
+        try {
+            const config = await services_1.services.configManager.loadConfig(projectPath);
+            const composer = new workflow_1.PluginWorkflowComposer(config);
+            const flags = composer.getSupportedFlags();
+            console.log('\n???? Supported Workflow Flags:');
+            console.log('===========================\n');
+            flags.forEach(flag => {
+                console.log(`  ? ${flag}`);
+            });
+            console.log('\n' + '='.repeat(27) + '\n');
+        }
+        catch (error) {
+            this.error(`Failed to list flags: ${error}`);
+            throw error;
+        }
+    }
+    async setMode(mode, projectPath) {
+        try {
+            const supportedModes = new Set(['lite', 'standard', 'full']);
+            if (!supportedModes.has(mode)) {
+                throw new Error(`Unsupported workflow mode: ${mode}`);
+            }
+            const config = await services_1.services.configManager.loadConfig(projectPath);
+            const nextConfig = {
+                ...config,
+                mode,
+                workflow: JSON.parse(JSON.stringify(workflow_1.WORKFLOW_PRESETS[mode])),
+            };
+            await services_1.services.configManager.saveConfig(projectPath, nextConfig);
+            this.success(`Workflow mode set to ${mode.toUpperCase()} for ${projectPath}`);
+            this.info('  Updated .skillrc mode and workflow preset');
+        }
+        catch (error) {
+            this.error(`Failed to set workflow mode: ${error}`);
+            throw error;
+        }
+    }
+}
+exports.WorkflowCommand = WorkflowCommand;
+//# sourceMappingURL=WorkflowCommand.js.map

package/dist/commands/index.d.ts

@@ -0,0 +1,43 @@
+/**
+
+ * 命令导出
+
+ */
+
+export { BaseCommand } from './BaseCommand';
+
+export { InitCommand } from './InitCommand';
+
+export { NewCommand } from './NewCommand';
+
+export { VerifyCommand } from './VerifyCommand';
+
+export { ProgressCommand } from './ProgressCommand';
+
+export { ArchiveCommand } from './ArchiveCommand';
+
+export { FinalizeCommand } from './FinalizeCommand';
+
+export { StatusCommand } from './StatusCommand';
+
+export { BatchCommand } from './BatchCommand';
+
+export { WorkflowCommand } from './WorkflowCommand';
+
+export { DocsCommand } from './DocsCommand';
+
+export { SkillCommand } from './SkillCommand';
+
+export { SkillsCommand } from './SkillsCommand';
+
+export { PluginsCommand } from './PluginsCommand';
+
+export { IndexCommand } from './IndexCommand';
+
+export { QueueCommand } from './QueueCommand';
+
+export { RunCommand } from './RunCommand';
+
+export { UpdateCommand } from './UpdateCommand';
+
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/index.js

@@ -0,0 +1,85 @@
+"use strict";
+
+/**
+
+ * 命令导出
+
+ */
+
+Object.defineProperty(exports, "__esModule", { value: true });
+
+exports.UpdateCommand = exports.RunCommand = exports.QueueCommand = exports.IndexCommand = exports.PluginsCommand = exports.SkillsCommand = exports.SkillCommand = exports.DocsCommand = exports.WorkflowCommand = exports.BatchCommand = exports.StatusCommand = exports.FinalizeCommand = exports.ArchiveCommand = exports.ProgressCommand = exports.VerifyCommand = exports.NewCommand = exports.InitCommand = exports.BaseCommand = void 0;
+
+var BaseCommand_1 = require("./BaseCommand");
+
+Object.defineProperty(exports, "BaseCommand", { enumerable: true, get: function () { return BaseCommand_1.BaseCommand; } });
+
+var InitCommand_1 = require("./InitCommand");
+
+Object.defineProperty(exports, "InitCommand", { enumerable: true, get: function () { return InitCommand_1.InitCommand; } });
+
+var NewCommand_1 = require("./NewCommand");
+
+Object.defineProperty(exports, "NewCommand", { enumerable: true, get: function () { return NewCommand_1.NewCommand; } });
+
+var VerifyCommand_1 = require("./VerifyCommand");
+
+Object.defineProperty(exports, "VerifyCommand", { enumerable: true, get: function () { return VerifyCommand_1.VerifyCommand; } });
+
+var ProgressCommand_1 = require("./ProgressCommand");
+
+Object.defineProperty(exports, "ProgressCommand", { enumerable: true, get: function () { return ProgressCommand_1.ProgressCommand; } });
+
+var ArchiveCommand_1 = require("./ArchiveCommand");
+
+Object.defineProperty(exports, "ArchiveCommand", { enumerable: true, get: function () { return ArchiveCommand_1.ArchiveCommand; } });
+
+var FinalizeCommand_1 = require("./FinalizeCommand");
+
+Object.defineProperty(exports, "FinalizeCommand", { enumerable: true, get: function () { return FinalizeCommand_1.FinalizeCommand; } });
+
+var StatusCommand_1 = require("./StatusCommand");
+
+Object.defineProperty(exports, "StatusCommand", { enumerable: true, get: function () { return StatusCommand_1.StatusCommand; } });
+
+var BatchCommand_1 = require("./BatchCommand");
+
+Object.defineProperty(exports, "BatchCommand", { enumerable: true, get: function () { return BatchCommand_1.BatchCommand; } });
+
+var WorkflowCommand_1 = require("./WorkflowCommand");
+
+Object.defineProperty(exports, "WorkflowCommand", { enumerable: true, get: function () { return WorkflowCommand_1.WorkflowCommand; } });
+
+var DocsCommand_1 = require("./DocsCommand");
+
+Object.defineProperty(exports, "DocsCommand", { enumerable: true, get: function () { return DocsCommand_1.DocsCommand; } });
+
+var SkillCommand_1 = require("./SkillCommand");
+
+Object.defineProperty(exports, "SkillCommand", { enumerable: true, get: function () { return SkillCommand_1.SkillCommand; } });
+
+var SkillsCommand_1 = require("./SkillsCommand");
+
+Object.defineProperty(exports, "SkillsCommand", { enumerable: true, get: function () { return SkillsCommand_1.SkillsCommand; } });
+
+var PluginsCommand_1 = require("./PluginsCommand");
+
+Object.defineProperty(exports, "PluginsCommand", { enumerable: true, get: function () { return PluginsCommand_1.PluginsCommand; } });
+
+var IndexCommand_1 = require("./IndexCommand");
+
+Object.defineProperty(exports, "IndexCommand", { enumerable: true, get: function () { return IndexCommand_1.IndexCommand; } });
+
+var QueueCommand_1 = require("./QueueCommand");
+
+Object.defineProperty(exports, "QueueCommand", { enumerable: true, get: function () { return QueueCommand_1.QueueCommand; } });
+
+var RunCommand_1 = require("./RunCommand");
+
+Object.defineProperty(exports, "RunCommand", { enumerable: true, get: function () { return RunCommand_1.RunCommand; } });
+
+var UpdateCommand_1 = require("./UpdateCommand");
+
+Object.defineProperty(exports, "UpdateCommand", { enumerable: true, get: function () { return UpdateCommand_1.UpdateCommand; } });
+
+//# sourceMappingURL=index.js.map

package/dist/core/constants.d.ts

@@ -0,0 +1,41 @@
+export declare const STATE_TRANSITIONS: Record<string, string[]>;
+export declare const CORE_REQUIRED_STEPS: string[];
+export declare const FILE_NAMES: {
+    SKILLRC: string;
+    SKILL_MD: string;
+    SKILL_INDEX: string;
+    README: string;
+    BUILD_INDEX_SCRIPT: string;
+    AI_GUIDE: string;
+    EXECUTION_PROTOCOL: string;
+    PROPOSAL: string;
+    TASKS: string;
+    VERIFICATION: string;
+    STATE: string;
+    REVIEW: string;
+    INDEX: string;
+};
+export declare const DIR_NAMES: {
+    CHANGES: string;
+    ACTIVE: string;
+    ARCHIVED: string;
+    FOR_AI: string;
+    DOCS: string;
+    PROJECT: string;
+    DESIGN: string;
+    PLANNING: string;
+    API: string;
+    SRC: string;
+    MODULES: string;
+    CORE: string;
+    TESTS: string;
+    DIST: string;
+};
+export declare const NAMING_RULES: {
+    FEATURE_NAME: RegExp;
+    ARCHIVED_DIR: RegExp;
+};
+export declare const DATE_FORMAT = "YYYY-MM-DD";
+export declare const DATETIME_FORMAT = "YYYY-MM-DDTHH:mm:ssZ";
+export declare const WORKFLOW_STEPS: readonly ["proposal_complete", "tasks_complete", "implementation_complete", "skill_updated", "index_regenerated", "tests_passed", "verification_passed", "archived"];
+//# sourceMappingURL=constants.d.ts.map