@clawplays/ospec-cli 0.1.1

package/dist/commands/IndexCommand.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexCommand = void 0;
+const services_1 = require("../services");
+const subcommandHelp_1 = require("../utils/subcommandHelp");
+const BaseCommand_1 = require("./BaseCommand");
+class IndexCommand extends BaseCommand_1.BaseCommand {
+    async execute(action = 'check', projectPath) {
+        try {
+            if ((0, subcommandHelp_1.isHelpAction)(action)) {
+                this.info((0, subcommandHelp_1.getIndexHelpText)());
+                return;
+            }
+            const targetPath = projectPath || process.cwd();
+            switch (action) {
+                case 'build': {
+                    const index = await services_1.services.projectService.rebuildIndex(targetPath);
+                    this.success(`Index rebuilt at ${index.path}`);
+                    if (index.stats) {
+                        this.info(`  Files: ${index.stats.totalFiles}, Modules: ${index.stats.totalModules}, Sections: ${index.stats.totalSections}`);
+                    }
+                    break;
+                }
+                case 'check': {
+                    const index = await services_1.services.projectService.getIndexStatus(targetPath);
+                    console.log('\nIndex Status');
+                    console.log('============\n');
+                    console.log(`Present: ${index.exists ? 'yes' : 'no'}`);
+                    console.log(`Path: ${index.path}`);
+                    console.log(`Updated: ${index.updatedAt ?? 'unknown'}`);
+                    console.log(`Needs rebuild: ${index.needsRebuild ? 'yes' : 'no'}`);
+                    console.log(`Stale: ${index.stale ? 'yes' : 'no'}`);
+                    console.log(`Latest source update: ${index.latestSourceUpdatedAt ?? 'unknown'}`);
+                    if (index.stats) {
+                        console.log(`Stats: ${index.stats.totalFiles} files, ${index.stats.totalModules} modules, ${index.stats.totalSections} sections`);
+                    }
+                    if (index.reasons.length > 0) {
+                        console.log('Reasons:');
+                        for (const reason of index.reasons) {
+                            console.log(`  - ${reason}`);
+                        }
+                    }
+                    console.log('');
+                    break;
+                }
+                default:
+                    this.info((0, subcommandHelp_1.getIndexHelpText)());
+            }
+        }
+        catch (error) {
+            this.error(`Index command failed: ${error}`);
+            throw error;
+        }
+    }
+}
+exports.IndexCommand = IndexCommand;
+//# sourceMappingURL=IndexCommand.js.map

package/dist/commands/InitCommand.d.ts

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

package/dist/commands/InitCommand.js

@@ -0,0 +1,65 @@
+"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.InitCommand = void 0;
+const path = __importStar(require("path"));
+const services_1 = require("../services");
+const BaseCommand_1 = require("./BaseCommand");
+class InitCommand extends BaseCommand_1.BaseCommand {
+    async execute(rootDir) {
+        try {
+            const targetDir = rootDir || process.cwd();
+            this.logger.info(`Initializing OSpec project at ${targetDir}`);
+            const structure = await services_1.services.projectService.detectProjectStructure(targetDir);
+            if (structure.initialized) {
+                this.warn('Project already initialized');
+                return;
+            }
+            const config = await services_1.services.configManager.createDefaultConfig('full');
+            await services_1.services.projectService.initializeProtocolShellProject(targetDir, config.mode, {
+                projectName: path.basename(targetDir),
+            });
+            this.success(`${structure.initialized ? 'Protocol shell refreshed' : 'Protocol shell initialized'} at ${targetDir}`);
+            this.info(`  Created OSpec protocol shell for ${path.basename(targetDir)}`);
+            this.info('  Added .skillrc, changes/, .ospec/, for-ai protocol docs, root SKILL.md, and SKILL.index.json');
+        }
+        catch (error) {
+            this.error(`Failed to initialize project: ${error}`);
+            throw error;
+        }
+    }
+}
+exports.InitCommand = InitCommand;
+//# sourceMappingURL=InitCommand.js.map

package/dist/commands/NewCommand.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from './BaseCommand';
+export interface NewCommandOptions {
+    flags?: string[];
+    placement?: 'active' | 'queued';
+    source?: string;
+}
+export declare class NewCommand extends BaseCommand {
+    execute(featureName: string, rootDir?: string, options?: NewCommandOptions): Promise<void>;
+    private normalizeFlags;
+}
+//# sourceMappingURL=NewCommand.d.ts.map

package/dist/commands/NewCommand.js

@@ -0,0 +1,262 @@
+"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.NewCommand = void 0;
+const path = __importStar(require("path"));
+const constants_1 = require("../core/constants");
+const services_1 = require("../services");
+const PathUtils_1 = require("../utils/PathUtils");
+const PluginWorkflowComposer_1 = require("../workflow/PluginWorkflowComposer");
+const BaseCommand_1 = require("./BaseCommand");
+class NewCommand extends BaseCommand_1.BaseCommand {
+    async execute(featureName, rootDir, options = {}) {
+        try {
+            this.validateArgs([featureName], 1);
+            services_1.services.validationService.validateFeatureName(featureName);
+            const targetDir = rootDir || process.cwd();
+            const placement = options.placement === constants_1.DIR_NAMES.QUEUED ? constants_1.DIR_NAMES.QUEUED : constants_1.DIR_NAMES.ACTIVE;
+            const featureDir = PathUtils_1.PathUtils.getChangeDir(targetDir, placement, featureName);
+            this.logger.info(`Creating ${placement === constants_1.DIR_NAMES.QUEUED ? 'queued change' : 'change'}: ${featureName}`);
+            await this.ensureChangeNameAvailable(targetDir, featureName);
+            await services_1.services.fileService.ensureDir(path.join(targetDir, constants_1.DIR_NAMES.CHANGES, placement));
+            await services_1.services.fileService.ensureDir(featureDir);
+            const config = await services_1.services.configManager.loadConfig(targetDir);
+            const composer = new PluginWorkflowComposer_1.PluginWorkflowComposer(config);
+            const flags = this.normalizeFlags(options.flags);
+            const activatedSteps = composer.getActivatedSteps(flags);
+            const validation = composer.validateFlags(flags);
+            if (validation.unsupported.length > 0) {
+                this.warn(`Unsupported workflow flags: ${validation.unsupported.join(', ')}`);
+            }
+            const projectContext = await services_1.services.projectService.getFeatureProjectContext(targetDir, []);
+            const documentLanguage = await this.resolveDocumentLanguage(targetDir, config);
+            await services_1.services.fileService.writeJSON(path.join(featureDir, constants_1.FILE_NAMES.STATE), services_1.services.stateManager.createInitialState(featureName, [], config.mode, placement === constants_1.DIR_NAMES.QUEUED
+                ? {
+                    queued: true,
+                    source: options.source,
+                }
+                : undefined));
+            await services_1.services.fileService.writeFile(path.join(featureDir, constants_1.FILE_NAMES.PROPOSAL), services_1.services.templateEngine.generateProposalTemplate({
+                feature: featureName,
+                mode: config.mode,
+                placement,
+                projectContext,
+                flags,
+                optionalSteps: activatedSteps,
+                documentLanguage,
+            }));
+            await services_1.services.fileService.writeFile(path.join(featureDir, constants_1.FILE_NAMES.TASKS), services_1.services.templateEngine.generateTasksTemplate({
+                feature: featureName,
+                mode: config.mode,
+                placement,
+                projectContext,
+                flags,
+                optionalSteps: activatedSteps,
+                documentLanguage,
+            }));
+            await services_1.services.fileService.writeFile(path.join(featureDir, constants_1.FILE_NAMES.VERIFICATION), services_1.services.templateEngine.generateVerificationTemplate({
+                feature: featureName,
+                mode: config.mode,
+                placement,
+                projectContext,
+                flags,
+                optionalSteps: activatedSteps,
+                documentLanguage,
+            }));
+            await services_1.services.fileService.writeFile(path.join(featureDir, constants_1.FILE_NAMES.REVIEW), services_1.services.templateEngine.generateReviewTemplate({
+                feature: featureName,
+                mode: config.mode,
+                placement,
+                projectContext,
+                flags,
+                optionalSteps: activatedSteps,
+                documentLanguage,
+            }));
+            await this.writePluginArtifacts(featureDir, activatedSteps);
+            this.success(`${placement === constants_1.DIR_NAMES.QUEUED ? 'Queued change' : 'Change'} ${featureName} created at ${featureDir}`);
+            if (flags.length > 0) {
+                this.info(`  Flags: ${flags.join(', ')}`);
+            }
+            if (activatedSteps.length > 0) {
+                this.info(`  Activated optional steps: ${activatedSteps.join(', ')}`);
+            }
+        }
+        catch (error) {
+            this.error(`Failed to create change: ${error}`);
+            throw error;
+        }
+    }
+    async resolveDocumentLanguage(targetDir, config) {
+        const configLanguage = this.normalizeDocumentLanguage(config?.documentLanguage);
+        if (configLanguage) {
+            return configLanguage;
+        }
+        const manifestLanguage = await this.readDocumentLanguageFromAssetManifest(targetDir);
+        if (manifestLanguage) {
+            return manifestLanguage;
+        }
+        const guideLanguage = await this.readDocumentLanguageFromAiGuide(targetDir);
+        if (guideLanguage) {
+            return guideLanguage;
+        }
+        return 'zh-CN';
+    }
+    normalizeDocumentLanguage(input) {
+        return input === 'en-US' || input === 'zh-CN' ? input : null;
+    }
+    async readDocumentLanguageFromAssetManifest(targetDir) {
+        const manifestPath = path.join(targetDir, '.ospec', 'asset-sources.json');
+        if (!(await services_1.services.fileService.exists(manifestPath))) {
+            return null;
+        }
+        try {
+            const manifest = await services_1.services.fileService.readJSON(manifestPath);
+            const manifestLanguage = this.normalizeDocumentLanguage(manifest?.documentLanguage);
+            if (manifestLanguage) {
+                return manifestLanguage;
+            }
+            const assets = Array.isArray(manifest?.assets) ? manifest.assets : [];
+            for (const targetRelativePath of ['for-ai/ai-guide.md', 'for-ai/execution-protocol.md']) {
+                const asset = assets.find(item => item?.targetRelativePath === targetRelativePath);
+                const sourceRelativePath = typeof asset?.sourceRelativePath === 'string' ? asset.sourceRelativePath : '';
+                if (sourceRelativePath.includes('/en-US/')) {
+                    return 'en-US';
+                }
+                if (sourceRelativePath.includes('/zh-CN/')) {
+                    return 'zh-CN';
+                }
+            }
+        }
+        catch {
+            return null;
+        }
+        return null;
+    }
+    async readDocumentLanguageFromAiGuide(targetDir) {
+        const aiGuidePath = path.join(targetDir, 'for-ai', 'ai-guide.md');
+        if (!(await services_1.services.fileService.exists(aiGuidePath))) {
+            return null;
+        }
+        try {
+            const content = await services_1.services.fileService.readFile(aiGuidePath);
+            if (/[一-龥]/.test(content)) {
+                return 'zh-CN';
+            }
+            if (/[A-Za-z]/.test(content)) {
+                return 'en-US';
+            }
+        }
+        catch {
+            return null;
+        }
+        return null;
+    }
+    async ensureChangeNameAvailable(targetDir, featureName) {
+        const activeDir = PathUtils_1.PathUtils.getChangeDir(targetDir, constants_1.DIR_NAMES.ACTIVE, featureName);
+        const queuedDir = PathUtils_1.PathUtils.getChangeDir(targetDir, constants_1.DIR_NAMES.QUEUED, featureName);
+        const conflicts = [];
+        if (await services_1.services.fileService.exists(activeDir)) {
+            conflicts.push('changes/active');
+        }
+        if (await services_1.services.fileService.exists(queuedDir)) {
+            conflicts.push('changes/queued');
+        }
+        if (conflicts.length === 0) {
+            return;
+        }
+        throw new Error(`Change ${featureName} already exists in ${conflicts.join(' and ')}. Continue the existing change instead of creating a duplicate.`);
+    }
+    async writePluginArtifacts(featureDir, activatedSteps) {
+        const checkpointSteps = activatedSteps.filter(step => step === 'checkpoint_ui_review' || step === 'checkpoint_flow_check');
+        if (checkpointSteps.length > 0) {
+            const checkpointDir = path.join(featureDir, 'artifacts', 'checkpoint');
+            await services_1.services.fileService.ensureDir(checkpointDir);
+            await services_1.services.fileService.ensureDir(path.join(checkpointDir, 'screenshots'));
+            await services_1.services.fileService.ensureDir(path.join(checkpointDir, 'diffs'));
+            await services_1.services.fileService.ensureDir(path.join(checkpointDir, 'traces'));
+            await services_1.services.fileService.writeJSON(path.join(checkpointDir, 'gate.json'), {
+                plugin: 'checkpoint',
+                status: 'pending',
+                blocking: true,
+                executed_at: '',
+                steps: Object.fromEntries(checkpointSteps.map(step => [step, {
+                        status: 'pending',
+                        issues: [],
+                    }])),
+                stitch_sync: {
+                    attempted: false,
+                    status: 'skipped',
+                    message: '',
+                },
+                issues: [],
+            });
+            await services_1.services.fileService.writeJSON(path.join(checkpointDir, 'result.json'), {
+                plugin: 'checkpoint',
+                status: 'pending',
+                executed_at: '',
+                active_steps: checkpointSteps,
+                output: {},
+            });
+            await services_1.services.fileService.writeFile(path.join(checkpointDir, 'summary.md'), '# Checkpoint Summary\n\n- Status: pending\n- The checkpoint runner has not been executed yet.\n');
+        }
+        if (!activatedSteps.includes('stitch_design_review')) {
+            return;
+        }
+        const stitchDir = path.join(featureDir, 'artifacts', 'stitch');
+        await services_1.services.fileService.ensureDir(stitchDir);
+        await services_1.services.fileService.writeJSON(path.join(stitchDir, 'approval.json'), {
+            plugin: 'stitch',
+            capability: 'page_design_review',
+            step: 'stitch_design_review',
+            status: 'pending',
+            blocking: true,
+            preview_url: '',
+            submitted_at: '',
+            reviewed_at: '',
+            reviewer: '',
+            notes: '',
+        });
+    }
+    normalizeFlags(flags) {
+        if (!Array.isArray(flags)) {
+            return [];
+        }
+        return Array.from(new Set(flags
+            .map(flag => String(flag).trim())
+            .filter(Boolean)));
+    }
+}
+exports.NewCommand = NewCommand;
+//# sourceMappingURL=NewCommand.js.map

package/dist/commands/PluginsCommand.d.ts

@@ -0,0 +1,58 @@
+import { BaseCommand } from './BaseCommand';
+export declare class PluginsCommand extends BaseCommand {
+    execute(action: string, ...args: string[]): Promise<void>;
+    private listPlugins;
+    private showStatus;
+    private setPluginEnabled;
+    private doctorPlugin;
+    private doctorStitch;
+    private doctorCheckpoint;
+    private checkCommandAvailability;
+    private inspectGeminiCliStitch;
+    private runPlugin;
+    private runCheckpoint;
+    private runStitch;
+    private setPluginApproval;
+    private getChangeRuntimePaths;
+    private findProjectRoot;
+    private readVerification;
+    private syncVerificationOptionalStep;
+    private loadOrCreateStitchApproval;
+    private parseCheckpointRunnerOutput;
+    private normalizeCheckpointRunnerResult;
+    private buildCheckpointSummaryMarkdown;
+    private writeCheckpointArtifacts;
+    private syncCheckpointOptionalSteps;
+    private applyCheckpointStitchIntegration;
+    private parsePluginProjectArgs;
+    private isHttpUrl;
+    private ensureFileIfMissing;
+    private ensureGitkeep;
+    private ensureStitchWorkspaceScaffold;
+    private ensureCheckpointWorkspaceScaffold;
+    private resolveRunnerCommand;
+    private resolveReferencedPath;
+    private replaceRunnerTokens;
+    private parseStitchRunnerOutput;
+    private normalizeRunnerResult;
+    private extractStitchProjectRef;
+    private normalizeRunnerArtifacts;
+    private createDefaultCheckpointPluginConfig;
+    private createDefaultStitchPluginConfig;
+    private getDefaultCheckpointRunnerArgs;
+    private getDefaultRunnerArgs;
+    private getStitchProvider;
+    private getStitchGeminiConfig;
+    private getStitchCodexConfig;
+    private inspectCodexCliStitch;
+    private getGeminiModelCandidates;
+    private classifyStitchRunnerFailure;
+    private isGeminiModelFallbackEligible;
+    private getEffectiveStitchRunnerConfig;
+    private isBuiltInGeminiRunner;
+    private isBuiltInCodexRunner;
+    private getEffectiveCheckpointRunnerConfig;
+    private isBuiltInCheckpointRunner;
+    private getPluginEntries;
+}
+//# sourceMappingURL=PluginsCommand.d.ts.map