@clawplays/ospec-cli 0.1.1

package/dist/commands/ProgressCommand.d.ts

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

package/dist/commands/ProgressCommand.js

@@ -0,0 +1,103 @@
+"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.ProgressCommand = void 0;
+const path = __importStar(require("path"));
+const constants_1 = require("../core/constants");
+const services_1 = require("../services");
+const BaseCommand_1 = require("./BaseCommand");
+class ProgressCommand extends BaseCommand_1.BaseCommand {
+    async execute(featurePath) {
+        try {
+            const targetPath = featurePath || process.cwd();
+            this.logger.info(`Checking progress for change at ${targetPath}`);
+            const statePath = path.join(targetPath, constants_1.FILE_NAMES.STATE);
+            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 statuses = [
+                'draft',
+                'proposed',
+                'planned',
+                'implementing',
+                'verifying',
+                'ready_to_archive',
+                'archived',
+            ];
+            const completedPhases = Math.max(statuses.indexOf(featureState.status), 0);
+            const totalPhases = statuses.length - 1;
+            const percentage = Math.round((completedPhases / totalPhases) * 100);
+            const barLength = 30;
+            const filledLength = Math.round((completedPhases / totalPhases) * barLength);
+            const bar = '#'.repeat(filledLength) + '-'.repeat(barLength - filledLength);
+            console.log('\nWorkflow Progress:');
+            console.log('==================\n');
+            console.log(`Change: ${featureState.feature}`);
+            console.log(`Status: ${featureState.status}`);
+            console.log(`Current Step: ${featureState.current_step}\n`);
+            console.log(`Progress: [${bar}] ${percentage}%`);
+            console.log(`Completed: ${completedPhases}/${totalPhases} phases\n`);
+            console.log('Completed Items:');
+            if ((featureState.completed || []).length === 0) {
+                console.log('  - None');
+            }
+            else {
+                featureState.completed.forEach((step) => {
+                    console.log(`  - ${step}`);
+                });
+            }
+            console.log('\nPending Items:');
+            if ((featureState.pending || []).length === 0) {
+                console.log('  - None');
+            }
+            else {
+                featureState.pending.slice(0, 5).forEach((step) => {
+                    console.log(`  - ${step}`);
+                });
+                if (featureState.pending.length > 5) {
+                    console.log(`  ... and ${featureState.pending.length - 5} more`);
+                }
+            }
+            console.log('\n' + '='.repeat(20) + '\n');
+        }
+        catch (error) {
+            this.error(`Failed to check progress: ${error}`);
+            throw error;
+        }
+    }
+}
+exports.ProgressCommand = ProgressCommand;
+//# sourceMappingURL=ProgressCommand.js.map

package/dist/commands/QueueCommand.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from './BaseCommand';
+export declare class QueueCommand extends BaseCommand {
+    execute(action?: string, ...args: string[]): Promise<void>;
+    private add;
+    private showStatus;
+    private activate;
+    private activateNext;
+    private parseAddArgs;
+}
+//# sourceMappingURL=QueueCommand.d.ts.map

package/dist/commands/QueueCommand.js

@@ -0,0 +1,147 @@
+"use strict";
+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") result[k[i]] = mod[k[i]];
+        result.default = mod;
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueCommand = void 0;
+const path = __importStar(require("path"));
+const services_1 = require("../services");
+const subcommandHelp_1 = require("../utils/subcommandHelp");
+const BaseCommand_1 = require("./BaseCommand");
+const NewCommand_1 = require("./NewCommand");
+class QueueCommand extends BaseCommand_1.BaseCommand {
+    async execute(action = 'status', ...args) {
+        try {
+            const normalizedAction = action || 'status';
+            if ((0, subcommandHelp_1.isHelpAction)(normalizedAction)) {
+                this.info((0, subcommandHelp_1.getQueueHelpText)());
+                return;
+            }
+            switch (normalizedAction) {
+                case 'status':
+                case 'list':
+                    await this.showStatus(args[0]);
+                    return;
+                case 'add':
+                    await this.add(args);
+                    return;
+                case 'activate':
+                    if (!args[0]) {
+                        console.error('Usage: ospec queue activate <change-name> [path]');
+                        process.exit(1);
+                    }
+                    await this.activate(args[0], args[1]);
+                    return;
+                case 'next':
+                    await this.activateNext(args[0]);
+                    return;
+                default:
+                    this.info((0, subcommandHelp_1.getQueueHelpText)());
+            }
+        }
+        catch (error) {
+            this.error(`Queue command failed: ${error}`);
+            throw error;
+        }
+    }
+    async add(args) {
+        const parsed = this.parseAddArgs(args);
+        if (!parsed.changeName) {
+            console.error('Usage: ospec queue add <change-name> [path] [--flags flag1,flag2]');
+            process.exit(1);
+        }
+        const newCommand = new NewCommand_1.NewCommand();
+        await newCommand.execute(parsed.changeName, parsed.projectPath, {
+            flags: parsed.flags,
+            placement: 'queued',
+            source: 'queue',
+        });
+    }
+    async showStatus(rootDir) {
+        const targetDir = path.resolve(rootDir || process.cwd());
+        const queuedChanges = await services_1.services.queueService.getQueuedChanges(targetDir);
+        console.log('\nQueued Changes');
+        console.log('==============\n');
+        console.log(`Total queued: ${queuedChanges.length}\n`);
+        if (queuedChanges.length === 0) {
+            console.log('No queued changes.\n');
+            return;
+        }
+        queuedChanges.forEach((change, index) => {
+            console.log(`${index + 1}. ${change.name}`);
+            console.log(`   Path: ${change.path}`);
+            console.log(`   Status: ${change.status}`);
+            console.log(`   Current step: ${change.currentStep}`);
+            if (change.flags.length > 0) {
+                console.log(`   Flags: ${change.flags.join(', ')}`);
+            }
+            console.log(`   Queued at: ${change.queuedAt ?? 'unknown'}`);
+            console.log(`   Source: ${change.source ?? 'unknown'}`);
+            console.log('');
+        });
+    }
+    async activate(changeName, rootDir) {
+        const targetDir = path.resolve(rootDir || process.cwd());
+        const activated = await services_1.services.queueService.activateQueuedChange(targetDir, changeName, 'queue');
+        this.success(`Queued change ${changeName} activated at ${activated.path}`);
+    }
+    async activateNext(rootDir) {
+        const targetDir = path.resolve(rootDir || process.cwd());
+        const activated = await services_1.services.queueService.activateNextQueuedChange(targetDir, 'queue');
+        if (!activated) {
+            this.success('No queued changes to activate.');
+            return;
+        }
+        this.success(`Activated next queued change: ${activated.name}`);
+    }
+    parseAddArgs(args) {
+        const changeName = args[0];
+        let projectPath;
+        const flags = [];
+        for (let index = 1; index < args.length; index += 1) {
+            const value = args[index];
+            if (value === '--flags') {
+                const rawFlags = args[index + 1];
+                if (!rawFlags || rawFlags.startsWith('--')) {
+                    throw new Error('Queue add requires a value after --flags.');
+                }
+                flags.push(...rawFlags.split(',').map(flag => flag.trim()).filter(Boolean));
+                index += 1;
+                continue;
+            }
+            if (value.startsWith('--flags=')) {
+                flags.push(...value.slice('--flags='.length).split(',').map(flag => flag.trim()).filter(Boolean));
+                continue;
+            }
+            if (value.startsWith('--')) {
+                throw new Error(`Unknown queue add flag: ${value}`);
+            }
+            if (!projectPath) {
+                projectPath = value;
+                continue;
+            }
+            throw new Error(`Unexpected queue add argument: ${value}`);
+        }
+        return {
+            changeName,
+            projectPath,
+            flags: Array.from(new Set(flags)),
+        };
+    }
+}
+exports.QueueCommand = QueueCommand;
+//# sourceMappingURL=QueueCommand.js.map

package/dist/commands/RunCommand.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from './BaseCommand';
+export declare class RunCommand extends BaseCommand {
+    execute(action?: string, ...args: string[]): Promise<void>;
+    private start;
+    private status;
+    private step;
+    private resume;
+    private stop;
+    private logs;
+    private printReport;
+    private parseStartArgs;
+}
+//# sourceMappingURL=RunCommand.d.ts.map

package/dist/commands/RunCommand.js

@@ -0,0 +1,200 @@
+"use strict";
+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") result[k[i]] = mod[k[i]];
+        result.default = mod;
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunCommand = void 0;
+const path = __importStar(require("path"));
+const services_1 = require("../services");
+const subcommandHelp_1 = require("../utils/subcommandHelp");
+const BaseCommand_1 = require("./BaseCommand");
+class RunCommand extends BaseCommand_1.BaseCommand {
+    async execute(action = 'status', ...args) {
+        try {
+            const normalizedAction = action || 'status';
+            if ((0, subcommandHelp_1.isHelpAction)(normalizedAction)) {
+                this.info((0, subcommandHelp_1.getRunHelpText)());
+                return;
+            }
+            switch (normalizedAction) {
+                case 'start':
+                    await this.start(args);
+                    return;
+                case 'status':
+                    await this.status(args[0]);
+                    return;
+                case 'step':
+                case 'tick':
+                case 'advance':
+                    await this.step(args[0]);
+                    return;
+                case 'resume':
+                    await this.resume(args[0]);
+                    return;
+                case 'stop':
+                case 'pause':
+                    await this.stop(args[0]);
+                    return;
+                case 'logs':
+                    await this.logs(args[0]);
+                    return;
+                default:
+                    this.info((0, subcommandHelp_1.getRunHelpText)());
+            }
+        }
+        catch (error) {
+            this.error(`Run command failed: ${error}`);
+            throw error;
+        }
+    }
+    async start(args) {
+        const parsed = this.parseStartArgs(args);
+        const targetPath = path.resolve(parsed.projectPath || process.cwd());
+        const report = await services_1.services.runService.start(targetPath, {
+            profileId: parsed.profileId,
+        });
+        this.printReport(report, targetPath);
+    }
+    async status(projectPath) {
+        const targetPath = path.resolve(projectPath || process.cwd());
+        const report = await services_1.services.runService.getStatusReport(targetPath);
+        this.printReport(report, targetPath);
+    }
+    async step(projectPath) {
+        const targetPath = path.resolve(projectPath || process.cwd());
+        const report = await services_1.services.runService.step(targetPath);
+        this.printReport(report, targetPath);
+    }
+    async resume(projectPath) {
+        const targetPath = path.resolve(projectPath || process.cwd());
+        const report = await services_1.services.runService.resume(targetPath);
+        this.printReport(report, targetPath);
+    }
+    async stop(projectPath) {
+        const targetPath = path.resolve(projectPath || process.cwd());
+        const report = await services_1.services.runService.stop(targetPath);
+        this.printReport(report, targetPath);
+    }
+    async logs(projectPath) {
+        const targetPath = path.resolve(projectPath || process.cwd());
+        const lines = await services_1.services.runService.getLogTail(targetPath, 30);
+        console.log('\nQueue Run Logs');
+        console.log('==============\n');
+        if (lines.length === 0) {
+            console.log('No queue run logs yet.\n');
+            return;
+        }
+        for (const line of lines) {
+            console.log(line);
+        }
+        console.log('');
+    }
+    printReport(report, projectPath) {
+        console.log('\nQueue Run Status');
+        console.log('================\n');
+        console.log(`Project: ${projectPath}`);
+        if (!report.currentRun) {
+            console.log('Run: idle');
+            console.log(`Queued changes: ${report.queuedChanges.length}`);
+            if (report.nextInstruction) {
+                console.log(`Next: ${report.nextInstruction}`);
+            }
+            console.log('');
+            return;
+        }
+        console.log(`Run ID: ${report.currentRun.id}`);
+        console.log(`Status: ${report.currentRun.status}`);
+        if (report.stage) {
+            console.log(`Stage: ${report.stage}`);
+        }
+        console.log(`Executor: ${report.currentRun.executor}`);
+        console.log(`Profile: ${report.currentRun.profileId}`);
+        console.log(`Started at: ${report.currentRun.startedAt}`);
+        console.log(`Updated at: ${report.currentRun.updatedAt}`);
+        console.log(`Completed changes: ${report.currentRun.completedChanges.length}`);
+        console.log(`Queued remaining: ${report.currentRun.remainingChanges.length}`);
+        if (report.activeChange) {
+            console.log(`Active change: ${report.activeChange.name} [${report.activeChange.status}]`);
+            console.log(`Active path: ${report.activeChange.path}`);
+        }
+        else {
+            console.log('Active change: none');
+        }
+        if (report.currentRun.failedChange) {
+            console.log(`Failed marker: ${report.currentRun.failedChange.name}`);
+            if (report.currentRun.failedChange.note) {
+                console.log(`Failure note: ${report.currentRun.failedChange.note}`);
+            }
+        }
+        if (report.queuedChanges.length > 0) {
+            console.log('\nQueued changes:');
+            for (const change of report.queuedChanges) {
+                console.log(`  - ${change.name} [${change.status}]`);
+            }
+        }
+        if (report.nextInstruction) {
+            console.log('\nNext instruction:');
+            console.log(`  ${report.nextInstruction}`);
+        }
+        if (report.logTail.length > 0) {
+            console.log('\nRecent log lines:');
+            for (const line of report.logTail.slice(-10)) {
+                console.log(`  ${line}`);
+            }
+        }
+        console.log('');
+    }
+    parseStartArgs(args) {
+        let projectPath;
+        let profileId;
+        for (let index = 0; index < args.length; index += 1) {
+            const value = args[index];
+            if (!value) {
+                continue;
+            }
+            if (value === '--profile') {
+                profileId = args[index + 1];
+                if (!profileId) {
+                    throw new Error('Run start requires a value after --profile.');
+                }
+                index += 1;
+                continue;
+            }
+            if (value.startsWith('--profile=')) {
+                profileId = value.slice('--profile='.length);
+                if (!profileId) {
+                    throw new Error('Run start requires a value after --profile=');
+                }
+                continue;
+            }
+            if (value.startsWith('--')) {
+                throw new Error(`Unknown run start flag: ${value}`);
+            }
+            if (!projectPath) {
+                projectPath = value;
+                continue;
+            }
+            throw new Error(`Unexpected run start argument: ${value}`);
+        }
+        return {
+            projectPath,
+            profileId,
+        };
+    }
+}
+exports.RunCommand = RunCommand;
+//# sourceMappingURL=RunCommand.js.map

package/dist/commands/SkillCommand.d.ts

@@ -0,0 +1,31 @@
+import { BaseCommand } from './BaseCommand';
+export declare class SkillCommand extends BaseCommand {
+    execute(action?: string, skillNameOrTargetDir?: string, targetDir?: string): Promise<void>;
+    private resolveAction;
+    private getInstallAction;
+    private resolveSkillSelection;
+    private isKnownSkillName;
+    private getAvailableSkillNames;
+    private installSkill;
+    private getInstalledSkillStatus;
+    private buildSkillPackage;
+    private getSkillDefinition;
+    private buildPrimarySkillDefinition;
+    private buildPackageAssets;
+    private buildLegacyAliasPackage;
+    private syncSkillFiles;
+    private isPackageInSync;
+    private buildCodexSkillYaml;
+    private buildOpenAiYaml;
+    private resolvePackageRoot;
+    private resolvePrimarySourceFiles;
+    private withClaudeFrontmatter;
+    private stripFrontmatter;
+    private buildSkillMarkdown;
+    private escapeYaml;
+    private extractInterfaceDefaultPrompt;
+    private buildCodexLegacyAliasFiles;
+    private resolveTargetDir;
+    private resolveProviderHome;
+}
+//# sourceMappingURL=SkillCommand.d.ts.map