@kbdavis07/openspec 1.5.0-nov.1

package/dist/core/command-generation/adapters/trae.js

@@ -0,0 +1,48 @@
+/**
+ * Trae Command Adapter
+ *
+ * Formats commands for Trae IDE following its command specification.
+ */
+import path from 'path';
+/**
+ * Escapes a string value for safe YAML output.
+ * Quotes the string if it contains special YAML characters.
+ */
+function escapeYamlValue(value) {
+    if (value === '') {
+        return '""';
+    }
+    // Check if value needs quoting (contains special YAML characters or starts/ends with whitespace)
+    const needsQuoting = /[:\n\r#{}[\],&*!|>'"%@`]|^\s|\s$/.test(value);
+    if (needsQuoting) {
+        // Use double quotes and escape internal double quotes, backslashes, and newlines
+        const escaped = value
+            .replace(/\\/g, '\\\\')
+            .replace(/"/g, '\\"')
+            .replace(/\n/g, '\\n')
+            .replace(/\r/g, '\\r');
+        return `"${escaped}"`;
+    }
+    return value;
+}
+/**
+ * Trae adapter for command generation.
+ * File path: .trae/commands/opsx-<id>.md
+ * Frontmatter: name, description
+ */
+export const traeAdapter = {
+    toolId: 'trae',
+    getFilePath(commandId) {
+        return path.join('.trae', 'commands', `opsx-${commandId}.md`);
+    },
+    formatFile(content) {
+        return `---
+name: ${escapeYamlValue(content.name)}
+description: ${escapeYamlValue(content.description)}
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=trae.js.map

package/dist/core/command-generation/adapters/windsurf.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Windsurf Command Adapter
+ *
+ * Formats commands for Windsurf following its frontmatter specification.
+ * Windsurf uses a similar format to Claude but may have different conventions.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Windsurf adapter for command generation.
+ * File path: .windsurf/workflows/opsx-<id>.md
+ * Frontmatter: name, description, category, tags
+ */
+export declare const windsurfAdapter: ToolCommandAdapter;
+//# sourceMappingURL=windsurf.d.ts.map

package/dist/core/command-generation/adapters/windsurf.js

@@ -0,0 +1,38 @@
+/**
+ * Windsurf Command Adapter
+ *
+ * Formats commands for Windsurf following its frontmatter specification.
+ * Windsurf uses a similar format to Claude but may have different conventions.
+ */
+import path from 'path';
+import { escapeYamlValue } from '../yaml.js';
+/**
+ * Formats a tags array as a YAML array with proper escaping.
+ */
+function formatTagsArray(tags) {
+    const escapedTags = tags.map((tag) => escapeYamlValue(tag));
+    return `[${escapedTags.join(', ')}]`;
+}
+/**
+ * Windsurf adapter for command generation.
+ * File path: .windsurf/workflows/opsx-<id>.md
+ * Frontmatter: name, description, category, tags
+ */
+export const windsurfAdapter = {
+    toolId: 'windsurf',
+    getFilePath(commandId) {
+        return path.join('.windsurf', 'workflows', `opsx-${commandId}.md`);
+    },
+    formatFile(content) {
+        return `---
+name: ${escapeYamlValue(content.name)}
+description: ${escapeYamlValue(content.description)}
+category: ${escapeYamlValue(content.category)}
+tags: ${formatTagsArray(content.tags)}
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=windsurf.js.map

package/dist/core/command-generation/generator.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Command Generator
+ *
+ * Functions for generating command files using tool adapters.
+ */
+import type { CommandContent, ToolCommandAdapter, GeneratedCommand } from './types.js';
+/**
+ * Generate a single command file using the provided adapter.
+ * @param content - The tool-agnostic command content
+ * @param adapter - The tool-specific adapter
+ * @returns Generated command with path and file content
+ */
+export declare function generateCommand(content: CommandContent, adapter: ToolCommandAdapter): GeneratedCommand;
+/**
+ * Generate multiple command files using the provided adapter.
+ * @param contents - Array of tool-agnostic command contents
+ * @param adapter - The tool-specific adapter
+ * @returns Array of generated commands with paths and file contents
+ */
+export declare function generateCommands(contents: CommandContent[], adapter: ToolCommandAdapter): GeneratedCommand[];
+//# sourceMappingURL=generator.d.ts.map

package/dist/core/command-generation/generator.js

@@ -0,0 +1,27 @@
+/**
+ * Command Generator
+ *
+ * Functions for generating command files using tool adapters.
+ */
+/**
+ * Generate a single command file using the provided adapter.
+ * @param content - The tool-agnostic command content
+ * @param adapter - The tool-specific adapter
+ * @returns Generated command with path and file content
+ */
+export function generateCommand(content, adapter) {
+    return {
+        path: adapter.getFilePath(content.id),
+        fileContent: adapter.formatFile(content),
+    };
+}
+/**
+ * Generate multiple command files using the provided adapter.
+ * @param contents - Array of tool-agnostic command contents
+ * @param adapter - The tool-specific adapter
+ * @returns Array of generated commands with paths and file contents
+ */
+export function generateCommands(contents, adapter) {
+    return contents.map((content) => generateCommand(content, adapter));
+}
+//# sourceMappingURL=generator.js.map

package/dist/core/command-generation/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Command Generation Module
+ *
+ * Generic command generation system with tool-specific adapters.
+ *
+ * Usage:
+ * ```typescript
+ * import { generateCommands, CommandAdapterRegistry, type CommandContent } from './command-generation/index.js';
+ *
+ * const contents: CommandContent[] = [...];
+ * const adapter = CommandAdapterRegistry.get('cursor');
+ * if (adapter) {
+ *   const commands = generateCommands(contents, adapter);
+ *   // Write commands to disk
+ * }
+ * ```
+ */
+export type { CommandContent, ToolCommandAdapter, GeneratedCommand, } from './types.js';
+export { CommandAdapterRegistry } from './registry.js';
+export { generateCommand, generateCommands } from './generator.js';
+export { claudeAdapter, cursorAdapter, windsurfAdapter } from './adapters/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/command-generation/index.js

@@ -0,0 +1,24 @@
+/**
+ * Command Generation Module
+ *
+ * Generic command generation system with tool-specific adapters.
+ *
+ * Usage:
+ * ```typescript
+ * import { generateCommands, CommandAdapterRegistry, type CommandContent } from './command-generation/index.js';
+ *
+ * const contents: CommandContent[] = [...];
+ * const adapter = CommandAdapterRegistry.get('cursor');
+ * if (adapter) {
+ *   const commands = generateCommands(contents, adapter);
+ *   // Write commands to disk
+ * }
+ * ```
+ */
+// Registry
+export { CommandAdapterRegistry } from './registry.js';
+// Generator functions
+export { generateCommand, generateCommands } from './generator.js';
+// Adapters (for direct access if needed)
+export { claudeAdapter, cursorAdapter, windsurfAdapter } from './adapters/index.js';
+//# sourceMappingURL=index.js.map

package/dist/core/command-generation/registry.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Command Adapter Registry
+ *
+ * Centralized registry for tool command adapters.
+ * Similar pattern to existing SlashCommandRegistry in the codebase.
+ */
+import type { ToolCommandAdapter } from './types.js';
+/**
+ * Registry for looking up tool command adapters.
+ */
+export declare class CommandAdapterRegistry {
+    private static adapters;
+    /**
+     * Register a tool command adapter.
+     * @param adapter - The adapter to register
+     */
+    static register(adapter: ToolCommandAdapter): void;
+    /**
+     * Get an adapter by tool ID.
+     * @param toolId - The tool identifier (e.g., 'claude', 'cursor')
+     * @returns The adapter or undefined if not registered
+     */
+    static get(toolId: string): ToolCommandAdapter | undefined;
+    /**
+     * Get all registered adapters.
+     * @returns Array of all registered adapters
+     */
+    static getAll(): ToolCommandAdapter[];
+    /**
+     * Check if an adapter is registered for a tool.
+     * @param toolId - The tool identifier
+     * @returns True if an adapter exists
+     */
+    static has(toolId: string): boolean;
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/core/command-generation/registry.js

@@ -0,0 +1,102 @@
+/**
+ * Command Adapter Registry
+ *
+ * Centralized registry for tool command adapters.
+ * Similar pattern to existing SlashCommandRegistry in the codebase.
+ */
+import { amazonQAdapter } from './adapters/amazon-q.js';
+import { antigravityAdapter } from './adapters/antigravity.js';
+import { auggieAdapter } from './adapters/auggie.js';
+import { bobAdapter } from './adapters/bob.js';
+import { claudeAdapter } from './adapters/claude.js';
+import { clineAdapter } from './adapters/cline.js';
+import { codexAdapter } from './adapters/codex.js';
+import { codebuddyAdapter } from './adapters/codebuddy.js';
+import { continueAdapter } from './adapters/continue.js';
+import { costrictAdapter } from './adapters/costrict.js';
+import { crushAdapter } from './adapters/crush.js';
+import { cursorAdapter } from './adapters/cursor.js';
+import { factoryAdapter } from './adapters/factory.js';
+import { geminiAdapter } from './adapters/gemini.js';
+import { githubCopilotAdapter } from './adapters/github-copilot.js';
+import { iflowAdapter } from './adapters/iflow.js';
+import { junieAdapter } from './adapters/junie.js';
+import { kilocodeAdapter } from './adapters/kilocode.js';
+import { kiroAdapter } from './adapters/kiro.js';
+import { ohMyPiAdapter } from './adapters/oh-my-pi.js';
+import { opencodeAdapter } from './adapters/opencode.js';
+import { piAdapter } from './adapters/pi.js';
+import { qoderAdapter } from './adapters/qoder.js';
+import { lingmaAdapter } from './adapters/lingma.js';
+import { qwenAdapter } from './adapters/qwen.js';
+import { roocodeAdapter } from './adapters/roocode.js';
+import { traeAdapter } from './adapters/trae.js';
+import { windsurfAdapter } from './adapters/windsurf.js';
+/**
+ * Registry for looking up tool command adapters.
+ */
+export class CommandAdapterRegistry {
+    static adapters = new Map();
+    // Static initializer - register built-in adapters
+    static {
+        CommandAdapterRegistry.register(amazonQAdapter);
+        CommandAdapterRegistry.register(antigravityAdapter);
+        CommandAdapterRegistry.register(auggieAdapter);
+        CommandAdapterRegistry.register(bobAdapter);
+        CommandAdapterRegistry.register(claudeAdapter);
+        CommandAdapterRegistry.register(clineAdapter);
+        CommandAdapterRegistry.register(codexAdapter);
+        CommandAdapterRegistry.register(codebuddyAdapter);
+        CommandAdapterRegistry.register(continueAdapter);
+        CommandAdapterRegistry.register(costrictAdapter);
+        CommandAdapterRegistry.register(crushAdapter);
+        CommandAdapterRegistry.register(cursorAdapter);
+        CommandAdapterRegistry.register(factoryAdapter);
+        CommandAdapterRegistry.register(geminiAdapter);
+        CommandAdapterRegistry.register(githubCopilotAdapter);
+        CommandAdapterRegistry.register(iflowAdapter);
+        CommandAdapterRegistry.register(junieAdapter);
+        CommandAdapterRegistry.register(kilocodeAdapter);
+        CommandAdapterRegistry.register(kiroAdapter);
+        CommandAdapterRegistry.register(ohMyPiAdapter);
+        CommandAdapterRegistry.register(opencodeAdapter);
+        CommandAdapterRegistry.register(piAdapter);
+        CommandAdapterRegistry.register(qoderAdapter);
+        CommandAdapterRegistry.register(lingmaAdapter);
+        CommandAdapterRegistry.register(qwenAdapter);
+        CommandAdapterRegistry.register(roocodeAdapter);
+        CommandAdapterRegistry.register(traeAdapter);
+        CommandAdapterRegistry.register(windsurfAdapter);
+    }
+    /**
+     * Register a tool command adapter.
+     * @param adapter - The adapter to register
+     */
+    static register(adapter) {
+        CommandAdapterRegistry.adapters.set(adapter.toolId, adapter);
+    }
+    /**
+     * Get an adapter by tool ID.
+     * @param toolId - The tool identifier (e.g., 'claude', 'cursor')
+     * @returns The adapter or undefined if not registered
+     */
+    static get(toolId) {
+        return CommandAdapterRegistry.adapters.get(toolId);
+    }
+    /**
+     * Get all registered adapters.
+     * @returns Array of all registered adapters
+     */
+    static getAll() {
+        return Array.from(CommandAdapterRegistry.adapters.values());
+    }
+    /**
+     * Check if an adapter is registered for a tool.
+     * @param toolId - The tool identifier
+     * @returns True if an adapter exists
+     */
+    static has(toolId) {
+        return CommandAdapterRegistry.adapters.has(toolId);
+    }
+}
+//# sourceMappingURL=registry.js.map

package/dist/core/command-generation/types.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Command Generation Types
+ *
+ * Tool-agnostic interfaces for command generation.
+ * These types separate "what to generate" from "how to format it".
+ */
+/**
+ * Tool-agnostic command data.
+ * Represents the content of a command without any tool-specific formatting.
+ */
+export interface CommandContent {
+    /** Command identifier (e.g., 'explore', 'apply', 'new') */
+    id: string;
+    /** Human-readable name (e.g., 'OpenSpec Explore') */
+    name: string;
+    /** Brief description of command purpose */
+    description: string;
+    /** Grouping category (e.g., 'Workflow') */
+    category: string;
+    /** Array of tag strings */
+    tags: string[];
+    /** The command instruction content (body text) */
+    body: string;
+}
+/**
+ * Per-tool formatting strategy.
+ * Each AI tool implements this interface to handle its specific file path
+ * and frontmatter format requirements.
+ */
+export interface ToolCommandAdapter {
+    /** Tool identifier matching AIToolOption.value (e.g., 'claude', 'cursor') */
+    toolId: string;
+    /**
+     * Returns the file path for a command.
+     * @param commandId - The command identifier (e.g., 'explore')
+     * @returns Path from project root (e.g., '.claude/commands/opsx/explore.md').
+     *          May be absolute for tools with global-scoped prompts (e.g., Codex).
+     */
+    getFilePath(commandId: string): string;
+    /**
+     * Formats the complete file content including frontmatter.
+     * @param content - The tool-agnostic command content
+     * @returns Complete file content ready to write
+     */
+    formatFile(content: CommandContent): string;
+}
+/**
+ * Result of generating a command file.
+ */
+export interface GeneratedCommand {
+    /** File path from project root, or absolute for global-scoped tools */
+    path: string;
+    /** Complete file content (frontmatter + body) */
+    fileContent: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/command-generation/types.js

@@ -0,0 +1,8 @@
+/**
+ * Command Generation Types
+ *
+ * Tool-agnostic interfaces for command generation.
+ * These types separate "what to generate" from "how to format it".
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/command-generation/yaml.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Shared YAML frontmatter helpers for command adapters.
+ *
+ * Several tool adapters emit YAML frontmatter and need to escape
+ * user-facing strings (name, description, category, tags) so the
+ * generated file stays valid YAML. This module centralizes that logic
+ * so the behavior is identical across adapters and fixed in one place.
+ */
+/**
+ * Escapes a string value for safe YAML output.
+ *
+ * Quotes the value with double quotes when it contains characters that
+ * carry special meaning in YAML (or leading/trailing whitespace), and
+ * escapes the characters that are not representable verbatim inside a
+ * double-quoted scalar: backslash, double quote, line feed and carriage
+ * return. Values without special characters are returned unquoted.
+ *
+ * @param value - The raw string to embed in YAML frontmatter.
+ * @returns The value, double-quoted and escaped when necessary.
+ */
+export declare function escapeYamlValue(value: string): string;
+//# sourceMappingURL=yaml.d.ts.map

package/dist/core/command-generation/yaml.js

@@ -0,0 +1,38 @@
+/**
+ * Shared YAML frontmatter helpers for command adapters.
+ *
+ * Several tool adapters emit YAML frontmatter and need to escape
+ * user-facing strings (name, description, category, tags) so the
+ * generated file stays valid YAML. This module centralizes that logic
+ * so the behavior is identical across adapters and fixed in one place.
+ */
+/**
+ * Escapes a string value for safe YAML output.
+ *
+ * Quotes the value with double quotes when it contains characters that
+ * carry special meaning in YAML (or leading/trailing whitespace), and
+ * escapes the characters that are not representable verbatim inside a
+ * double-quoted scalar: backslash, double quote, line feed and carriage
+ * return. Values without special characters are returned unquoted.
+ *
+ * @param value - The raw string to embed in YAML frontmatter.
+ * @returns The value, double-quoted and escaped when necessary.
+ */
+export function escapeYamlValue(value) {
+    // Check if value needs quoting (contains special YAML characters or starts/ends with whitespace)
+    const needsQuoting = /[:\n\r#{}[\],&*!|>'"%@`]|^\s|\s$/.test(value);
+    if (needsQuoting) {
+        // Use double quotes and escape characters that are not safe to emit
+        // verbatim inside a double-quoted YAML scalar. Carriage returns must be
+        // escaped too: a literal CR inside double quotes is subject to YAML line
+        // folding/normalization and would silently corrupt the round-tripped value.
+        const escaped = value
+            .replace(/\\/g, '\\\\')
+            .replace(/"/g, '\\"')
+            .replace(/\n/g, '\\n')
+            .replace(/\r/g, '\\r');
+        return `"${escaped}"`;
+    }
+    return value;
+}
+//# sourceMappingURL=yaml.js.map

package/dist/core/completions/command-registry.d.ts

@@ -0,0 +1,3 @@
+import type { CommandDefinition } from './types.js';
+export declare const COMMAND_REGISTRY: CommandDefinition[];
+//# sourceMappingURL=command-registry.d.ts.map