@clawplays/ospec-cli 0.1.1

package/dist/commands/ArchiveCommand.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from './BaseCommand';
+interface ArchiveCommandOptions {
+    checkOnly?: boolean;
+}
+export declare class ArchiveCommand extends BaseCommand {
+    execute(featurePath?: string, options?: ArchiveCommandOptions): Promise<void>;
+    run(featurePath?: string, options?: ArchiveCommandOptions): Promise<string | void>;
+    private performArchive;
+    private updateProposalStatus;
+    private resolveArchiveDirName;
+    private toRelativePath;
+}
+export {};
+//# sourceMappingURL=ArchiveCommand.d.ts.map

package/dist/commands/ArchiveCommand.js

@@ -0,0 +1,241 @@
+"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.ArchiveCommand = 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 ArchiveGate_1 = require("../workflow/ArchiveGate");
+const PluginWorkflowComposer_1 = require("../workflow/PluginWorkflowComposer");
+const BaseCommand_1 = require("./BaseCommand");
+class ArchiveCommand extends BaseCommand_1.BaseCommand {
+    async execute(featurePath, options = {}) {
+        await this.run(featurePath, options);
+    }
+    async run(featurePath, options = {}) {
+        try {
+            const targetPath = path.resolve(featurePath || process.cwd());
+            const checkOnly = options.checkOnly === true;
+            this.logger.info(`${checkOnly ? 'Checking archive readiness' : 'Archiving 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 projectRoot = path.resolve(targetPath, '..', '..', '..');
+            const expectedParent = path.join(projectRoot, constants_1.DIR_NAMES.CHANGES, constants_1.DIR_NAMES.ACTIVE);
+            if (path.dirname(targetPath) !== expectedParent) {
+                throw new Error('Archive target must be a change directory under changes/active.');
+            }
+            if (!(await services_1.services.fileService.exists(statePath))) {
+                throw new Error('Change state file not found.');
+            }
+            const featureState = await services_1.services.fileService.readJSON(statePath);
+            const config = await services_1.services.configManager.loadConfig(projectRoot);
+            const workflow = new PluginWorkflowComposer_1.PluginWorkflowComposer(config);
+            const proposal = (0, gray_matter_1.default)(await services_1.services.fileService.readFile(proposalPath));
+            const tasks = (0, gray_matter_1.default)(await services_1.services.fileService.readFile(tasksPath));
+            const verification = (0, gray_matter_1.default)(await services_1.services.fileService.readFile(verificationPath));
+            const flags = Array.isArray(proposal.data.flags) ? proposal.data.flags : [];
+            const activatedSteps = workflow.getActivatedSteps(flags);
+            const tasksOptionalSteps = Array.isArray(tasks.data.optional_steps)
+                ? tasks.data.optional_steps
+                : [];
+            const verificationOptionalSteps = Array.isArray(verification.data.optional_steps)
+                ? verification.data.optional_steps
+                : [];
+            const passedOptionalSteps = Array.isArray(verification.data.passed_optional_steps)
+                ? verification.data.passed_optional_steps
+                : [];
+            const archiveConfig = config.workflow?.archive_gate || {
+                require_verification: true,
+                require_skill_update: true,
+                require_index_regenerated: true,
+                require_optional_steps_passed: true,
+            };
+            const result = await ArchiveGate_1.archiveGate.checkArchiveReadiness(featureState, archiveConfig, {
+                activatedSteps,
+                tasksOptionalSteps,
+                verificationOptionalSteps,
+                passedOptionalSteps,
+                tasksComplete: !/- \[ \]/.test(tasks.content),
+                verificationComplete: !/- \[ \]/.test(verification.content),
+            });
+            if (activatedSteps.includes('stitch_design_review')) {
+                const approvalPath = path.join(targetPath, 'artifacts', 'stitch', 'approval.json');
+                const approvalExists = await services_1.services.fileService.exists(approvalPath);
+                if (!approvalExists) {
+                    result.blockers.push('artifacts/stitch/approval.json is required before archiving');
+                }
+                else {
+                    const approval = await services_1.services.fileService.readJSON(approvalPath);
+                    const approvalStatus = typeof approval.status === 'string' ? approval.status : 'pending';
+                    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;
+                    if (approval.step !== 'stitch_design_review') {
+                        result.blockers.push('Stitch approval artifact step must be stitch_design_review');
+                    }
+                    if (!hasPreviewUrl) {
+                        result.blockers.push('Stitch preview URL must be recorded before archiving');
+                    }
+                    if (!hasSubmittedAt) {
+                        result.blockers.push('Stitch submission timestamp must be recorded before archiving');
+                    }
+                    if (approvalStatus !== 'approved') {
+                        result.blockers.push(`Stitch design review must be approved before archiving (current: ${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);
+                if (!gateExists) {
+                    result.blockers.push('artifacts/checkpoint/gate.json is required before archiving');
+                }
+                else {
+                    const gate = await services_1.services.fileService.readJSON(gatePath);
+                    if (gate.plugin !== 'checkpoint') {
+                        result.blockers.push('Checkpoint gate artifact plugin must be checkpoint');
+                    }
+                    if (gate.status !== 'passed') {
+                        result.blockers.push(`Checkpoint gate must be passed before archiving (current: ${gate.status || 'missing'})`);
+                    }
+                    for (const stepName of activeCheckpointSteps) {
+                        const stepStatus = gate.steps?.[stepName]?.status || 'missing';
+                        if (stepStatus !== 'passed') {
+                            result.blockers.push(`Checkpoint step ${stepName} must be passed before archiving (current: ${stepStatus})`);
+                        }
+                    }
+                }
+                const resultExists = await services_1.services.fileService.exists(resultPath);
+                const summaryExists = await services_1.services.fileService.exists(summaryPath);
+                if (!resultExists && !summaryExists) {
+                    result.blockers.push('Checkpoint result.json or summary.md is required before archiving');
+                }
+            }
+            result.canArchive = result.blockers.length === 0;
+            console.log('\nArchive Gate Check:');
+            console.log('===================\n');
+            for (const check of result.checks) {
+                const icon = check.passed ? 'PASS' : 'FAIL';
+                console.log(`${icon} ${check.name}`);
+                console.log(`  ${check.message}\n`);
+            }
+            if (result.blockers.length > 0) {
+                console.log('Blockers:');
+                result.blockers.forEach(blocker => {
+                    console.log(`  - ${blocker}`);
+                });
+                console.log();
+            }
+            if (result.warnings.length > 0) {
+                console.log('Warnings:');
+                result.warnings.forEach(warning => {
+                    console.log(`  - ${warning}`);
+                });
+                console.log();
+            }
+            console.log('='.repeat(21) + '\n');
+            if (result.canArchive) {
+                if (checkOnly) {
+                    this.success('Change is ready to archive');
+                    return;
+                }
+                const archivePath = await this.performArchive(targetPath, projectRoot, featureState);
+                this.success(`Change archived to ${archivePath}`);
+                return archivePath;
+            }
+            else {
+                this.error('Change cannot be archived. Please resolve blockers.');
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            this.error(`Archive check failed: ${error}`);
+            throw error;
+        }
+    }
+    async performArchive(targetPath, projectRoot, featureState) {
+        const archivedRoot = path.join(projectRoot, constants_1.DIR_NAMES.CHANGES, constants_1.DIR_NAMES.ARCHIVED);
+        await services_1.services.fileService.ensureDir(archivedRoot);
+        const archiveDirName = await this.resolveArchiveDirName(archivedRoot, featureState.feature);
+        const archivePath = path.join(archivedRoot, archiveDirName);
+        const nextState = {
+            ...featureState,
+            status: 'archived',
+            current_step: 'archived',
+            completed: Array.from(new Set([...featureState.completed, 'archived'])).sort((a, b) => a.localeCompare(b)),
+            pending: featureState.pending.filter(step => step !== 'archived'),
+            blocked_by: [],
+        };
+        await services_1.services.fileService.move(targetPath, archivePath);
+        await services_1.services.stateManager.writeState(archivePath, nextState);
+        await this.updateProposalStatus(archivePath, 'archived');
+        await services_1.services.projectService.rebuildIndex(projectRoot);
+        return this.toRelativePath(projectRoot, archivePath);
+    }
+    async updateProposalStatus(targetPath, status) {
+        const proposalPath = path.join(targetPath, constants_1.FILE_NAMES.PROPOSAL);
+        if (!(await services_1.services.fileService.exists(proposalPath))) {
+            return;
+        }
+        const proposal = (0, gray_matter_1.default)(await services_1.services.fileService.readFile(proposalPath));
+        proposal.data.status = status;
+        await services_1.services.fileService.writeFile(proposalPath, gray_matter_1.default.stringify(proposal.content, proposal.data));
+    }
+    async resolveArchiveDirName(archivedRoot, featureName) {
+        const datePrefix = new Date().toISOString().slice(0, 10);
+        const baseName = `${datePrefix}-${featureName}`;
+        let candidate = baseName;
+        let index = 2;
+        while (await services_1.services.fileService.exists(path.join(archivedRoot, candidate))) {
+            candidate = `${baseName}-${index}`;
+            index += 1;
+        }
+        return candidate;
+    }
+    toRelativePath(rootDir, targetPath) {
+        return path.relative(rootDir, targetPath).replace(/\\/g, '/');
+    }
+}
+exports.ArchiveCommand = ArchiveCommand;
+//# sourceMappingURL=ArchiveCommand.js.map

package/dist/commands/BaseCommand.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 命令基类
+ */
+import { Logger } from '../services/Logger';
+export declare abstract class BaseCommand {
+    protected logger: Logger;
+    constructor();
+    /**
+     * 执行命令
+     */
+    abstract execute(...args: any[]): Promise<void>;
+    /**
+     * 验证命令参数
+     */
+    protected validateArgs(args: any[], requiredCount: number): void;
+    /**
+     * 打印成功信息
+     */
+    protected success(message: string): void;
+    /**
+     * 打印信息
+     */
+    protected info(message: string): void;
+    /**
+     * 打印错误信息
+     */
+    protected error(message: string): void;
+    /**
+     * 打印警告信息
+     */
+    protected warn(message: string): void;
+}
+//# sourceMappingURL=BaseCommand.d.ts.map

package/dist/commands/BaseCommand.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * 命令基类
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCommand = void 0;
+const services_1 = require("../services");
+class BaseCommand {
+    constructor() {
+        this.logger = services_1.services.logger;
+    }
+    /**
+     * 验证命令参数
+     */
+    validateArgs(args, requiredCount) {
+        if (args.length < requiredCount) {
+            throw new Error(`Invalid arguments. Expected at least ${requiredCount} arguments.`);
+        }
+    }
+    /**
+     * 打印成功信息
+     */
+    success(message) {
+        console.log(`✓ ${message}`);
+    }
+    /**
+     * 打印信息
+     */
+    info(message) {
+        console.log(message);
+    }
+    /**
+     * 打印错误信息
+     */
+    error(message) {
+        console.error(`✗ ${message}`);
+    }
+    /**
+     * 打印警告信息
+     */
+    warn(message) {
+        console.warn(`⚠ ${message}`);
+    }
+}
+exports.BaseCommand = BaseCommand;
+//# sourceMappingURL=BaseCommand.js.map

package/dist/commands/BatchCommand.d.ts

@@ -0,0 +1,5 @@
+import { BaseCommand } from './BaseCommand';
+export declare class BatchCommand extends BaseCommand {
+    execute(action: string, projectPath?: string): Promise<void>;
+}
+//# sourceMappingURL=BatchCommand.d.ts.map

package/dist/commands/BatchCommand.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchCommand = void 0;
+const advanced_1 = require("../advanced");
+const subcommandHelp_1 = require("../utils/subcommandHelp");
+const BaseCommand_1 = require("./BaseCommand");
+class BatchCommand extends BaseCommand_1.BaseCommand {
+    async execute(action, projectPath) {
+        try {
+            if ((0, subcommandHelp_1.isHelpAction)(action)) {
+                this.info((0, subcommandHelp_1.getBatchHelpText)());
+                return;
+            }
+            const targetPath = projectPath || process.cwd();
+            switch (action) {
+                case 'export': {
+                    const result = await advanced_1.batchOperations.exportFeatures(targetPath, {});
+                    console.log(`\nExported ${result.count} features\n`);
+                    break;
+                }
+                case 'stats': {
+                    const stats = await advanced_1.batchOperations.getStatistics(targetPath);
+                    console.log('\nStatistics:');
+                    console.log(`Total: ${stats.total}\n`);
+                    for (const [status, count] of Object.entries(stats.byStatus)) {
+                        console.log(`${status}: ${count}`);
+                    }
+                    console.log();
+                    break;
+                }
+                default:
+                    this.info((0, subcommandHelp_1.getBatchHelpText)());
+            }
+        }
+        catch (error) {
+            this.error(`Batch operation failed: ${error}`);
+            throw error;
+        }
+    }
+}
+exports.BatchCommand = BatchCommand;
+//# sourceMappingURL=BatchCommand.js.map

package/dist/commands/ChangesCommand.d.ts

@@ -0,0 +1,3 @@
+export declare class ChangesCommand {
+    execute(action?: string, projectPath?: string): Promise<void>;
+}

package/dist/commands/ChangesCommand.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangesCommand = void 0;
+const services_1 = require("../services");
+const BaseCommand_1 = require("./BaseCommand");
+class ChangesCommand extends BaseCommand_1.BaseCommand {
+    async execute(action = 'status', projectPath) {
+        try {
+            const targetPath = projectPath || process.cwd();
+            switch (action) {
+                case 'status':
+                default: {
+                    const [report, queuedChanges] = await Promise.all([
+                        services_1.services.projectService.getActiveChangeStatusReport(targetPath),
+                        services_1.services.queueService.getQueuedChanges(targetPath),
+                    ]);
+                    console.log('');
+                    console.log('Active Changes');
+                    console.log('==============');
+                    console.log('');
+                    console.log(`Total: ${report.totalActiveChanges}`);
+                    console.log(`Queued: ${queuedChanges.length}`);
+                    console.log(`PASS ${report.totals.pass} | WARN ${report.totals.warn} | FAIL ${report.totals.fail}`);
+                    console.log('');
+                    if (report.changes.length === 0) {
+                        console.log('No active changes.');
+                        if (queuedChanges.length > 0) {
+                            console.log('Queued changes are waiting.');
+                        }
+                        console.log('');
+                        return;
+                    }
+                    for (const change of report.changes) {
+                        console.log(`${change.summaryStatus.toUpperCase()} ${change.name} [${change.status}] ${change.progress}%`);
+                        console.log(`  Path: ${change.path}`);
+                        console.log(`  Step: ${change.currentStep}`);
+                        if (change.flags.length > 0) {
+                            console.log(`  Flags: ${change.flags.join(', ')}`);
+                        }
+                        const issues = change.checks.filter(check => check.status !== 'pass');
+                        if (issues.length === 0) {
+                            console.log('  Checks: all pass');
+                        }
+                        else {
+                            for (const issue of issues.slice(0, 5)) {
+                                console.log(`  ${issue.status.toUpperCase()} ${issue.name}: ${issue.message}`);
+                            }
+                        }
+                        console.log('');
+                    }
+                    if (queuedChanges.length > 0) {
+                        console.log('Queued Changes');
+                        console.log('--------------');
+                        queuedChanges.forEach(change => {
+                            console.log(`QUEUED ${change.name} [${change.status}]`);
+                            console.log(`  Path: ${change.path}`);
+                            console.log(`  Step: ${change.currentStep}`);
+                        });
+                        console.log('');
+                    }
+                }
+            }
+        }
+        catch (error) {
+            this.error(`Changes command failed: ${error}`);
+            throw error;
+        }
+    }
+}
+exports.ChangesCommand = ChangesCommand;
+//# sourceMappingURL=ChangesCommand.js.map

package/dist/commands/DocsCommand.d.ts

@@ -0,0 +1,5 @@
+import { BaseCommand } from './BaseCommand';
+export declare class DocsCommand extends BaseCommand {
+    execute(action?: string, projectPath?: string): Promise<void>;
+}
+//# sourceMappingURL=DocsCommand.d.ts.map

package/dist/commands/DocsCommand.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocsCommand = void 0;
+const services_1 = require("../services");
+const subcommandHelp_1 = require("../utils/subcommandHelp");
+const BaseCommand_1 = require("./BaseCommand");
+class DocsCommand extends BaseCommand_1.BaseCommand {
+    async execute(action = 'status', projectPath) {
+        try {
+            if ((0, subcommandHelp_1.isHelpAction)(action)) {
+                this.info((0, subcommandHelp_1.getDocsHelpText)());
+                return;
+            }
+            const targetPath = projectPath || process.cwd();
+            switch (action) {
+                case 'generate': {
+                    const structure = await services_1.services.projectService.detectProjectStructure(targetPath);
+                    if (!structure.initialized) {
+                        throw new Error('Project is not initialized. Run "ospec init" first.');
+                    }
+                    const result = await services_1.services.projectService.generateProjectKnowledge(targetPath);
+                    console.log('\nProject Knowledge Generated');
+                    console.log('=========================\n');
+                    console.log(`Project: ${result.projectName}`);
+                    console.log(`Mode: ${result.mode}`);
+                    console.log(`Created files: ${result.createdFiles.length}`);
+                    console.log(`Refreshed files: ${result.refreshedFiles.length}`);
+                    console.log(`Skipped existing files: ${result.skippedFiles.length}`);
+                    console.log(`Direct-copy assets created: ${result.directCopyCreatedFiles.length}`);
+                    console.log(`Hooks installed: ${result.hookInstalledFiles.length}`);
+                    console.log(`Runtime-generated files: ${result.runtimeGeneratedFiles.join(', ') || '-'}`);
+                    console.log('Business scaffold: not applied by docs generate');
+                    console.log('Bootstrap summary: not generated by docs generate');
+                    if (result.firstChangeSuggestion) {
+                        console.log(`Suggested first change: ${result.firstChangeSuggestion.name}`);
+                    }
+                    console.log('');
+                    break;
+                }
+                case 'sync-protocol': {
+                    const structure = await services_1.services.projectService.detectProjectStructure(targetPath);
+                    if (!structure.initialized) {
+                        throw new Error('Project is not initialized. Run "ospec init" first.');
+                    }
+                    const result = await services_1.services.projectService.syncProtocolGuidance(targetPath);
+                    console.log('\nProtocol Guidance Synced');
+                    console.log('========================\n');
+                    console.log(`Project: ${result.projectName}`);
+                    console.log(`Mode: ${result.mode}`);
+                    console.log(`Document language: ${result.documentLanguage}`);
+                    console.log(`Created files: ${result.createdFiles.length}`);
+                    console.log(`Refreshed files: ${result.refreshedFiles.length}`);
+                    console.log(`Skipped files: ${result.skippedFiles.length}`);
+                    if (result.refreshedFiles.length > 0) {
+                        console.log(`Refreshed: ${result.refreshedFiles.join(', ')}`);
+                    }
+                    if (result.createdFiles.length > 0) {
+                        console.log(`Created: ${result.createdFiles.join(', ')}`);
+                    }
+                    console.log('Scope: protocol/AI guidance only; existing changes are not migrated.');
+                    console.log('');
+                    break;
+                }
+                case 'status': {
+                    const docs = await services_1.services.projectService.getDocsStatus(targetPath);
+                    console.log('\nDocs Status');
+                    console.log('===========\n');
+                    console.log(`Coverage: ${docs.coverage}% (${docs.existing}/${docs.total})`);
+                    console.log(`Updated: ${docs.updatedAt ?? 'unknown'}`);
+                    console.log('\nTracked docs:');
+                    for (const item of docs.items) {
+                        console.log(`  ${item.exists ? '✓' : '✗'} ${item.path}`);
+                    }
+                    if (docs.apiDocs.length > 0) {
+                        console.log('\nAPI docs:');
+                        for (const item of docs.apiDocs) {
+                            console.log(`  ✓ ${item.path}`);
+                        }
+                    }
+                    if (docs.designDocs.length > 0) {
+                        console.log('\nDesign docs:');
+                        for (const item of docs.designDocs) {
+                            console.log(`  ✓ ${item.path}`);
+                        }
+                    }
+                    if (docs.planningDocs.length > 0) {
+                        console.log('\nPlanning docs:');
+                        for (const item of docs.planningDocs) {
+                            console.log(`  ✓ ${item.path}`);
+                        }
+                    }
+                    if (docs.missingRequired.length > 0) {
+                        console.log('\nMissing required docs:');
+                        for (const item of docs.missingRequired) {
+                            console.log(`  - ${item}`);
+                        }
+                    }
+                    if (docs.missingRecommended.length > 0) {
+                        console.log('\nMissing recommended docs:');
+                        for (const item of docs.missingRecommended) {
+                            console.log(`  - ${item}`);
+                        }
+                    }
+                    console.log('');
+                    break;
+                }
+                default:
+                    this.info((0, subcommandHelp_1.getDocsHelpText)());
+            }
+        }
+        catch (error) {
+            this.error(`Docs command failed: ${error}`);
+            throw error;
+        }
+    }
+}
+exports.DocsCommand = DocsCommand;
+//# sourceMappingURL=DocsCommand.js.map

package/dist/commands/FinalizeCommand.d.ts

@@ -0,0 +1,3 @@
+export declare class FinalizeCommand {
+    execute(featurePath?: string): Promise<void>;
+}

package/dist/commands/FinalizeCommand.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FinalizeCommand = void 0;
+const path = require("path");
+const services_1 = require("../services");
+const BaseCommand_1 = require("./BaseCommand");
+const VerifyCommand_1 = require("./VerifyCommand");
+class FinalizeCommand extends BaseCommand_1.BaseCommand {
+    async execute(featurePath) {
+        try {
+            const targetPath = featurePath || process.cwd();
+            this.info(`Finalizing change at ${targetPath}`);
+            const verifyCmd = new VerifyCommand_1.VerifyCommand();
+            await verifyCmd.execute(targetPath);
+            const result = await services_1.services.projectService.finalizeChange(path.resolve(targetPath));
+            this.success(`Change finalized: ${result.archivePath}`);
+        }
+        catch (error) {
+            this.error(`Finalize failed: ${error}`);
+            throw error;
+        }
+    }
+}
+exports.FinalizeCommand = FinalizeCommand;

package/dist/commands/IndexCommand.d.ts

@@ -0,0 +1,5 @@
+import { BaseCommand } from './BaseCommand';
+export declare class IndexCommand extends BaseCommand {
+    execute(action?: string, projectPath?: string): Promise<void>;
+}
+//# sourceMappingURL=IndexCommand.d.ts.map