@devtrack-solution/codesdd 1.2.2

package/dist/core/cli/command-matrix.js

@@ -0,0 +1,123 @@
+import { CLI_NAME } from '../branding.js';
+function commandSegments(command, prefix = []) {
+    const name = command.name();
+    if (!name || name === CLI_NAME) {
+        return prefix;
+    }
+    return [...prefix, name];
+}
+export function collectCliLeafCommands(command, prefix = []) {
+    const segments = commandSegments(command, prefix);
+    const children = command.commands ?? [];
+    if (children.length === 0) {
+        return [
+            {
+                commandPath: segments.join(':'),
+                description: command.description(),
+                aliases: command.aliases(),
+                hidden: command._hidden === true,
+            },
+        ];
+    }
+    return children.flatMap((child) => collectCliLeafCommands(child, segments));
+}
+export const CLI_COMMAND_MATRIX = [
+    { commandPath: 'init', strategy: 'contract', rationale: 'Project bootstrap is deterministic and already decomposes into testable setup services.' },
+    { commandPath: 'install', strategy: 'spawned-e2e', rationale: 'Full installation composes base bootstrap plus SDD initialization and should keep a spawned smoke path.' },
+    { commandPath: 'experimental', strategy: 'exception', rationale: 'Deprecated compatibility alias inherits init behavior and only needs lightweight regression coverage.' },
+    { commandPath: 'update', strategy: 'contract', rationale: 'Update flow is deterministic and validated through targeted service and CLI contract tests.' },
+    { commandPath: 'list', strategy: 'contract', rationale: 'Listing is a stable read-only surface that is well-suited to direct contract assertions.' },
+    { commandPath: 'view', strategy: 'exception', rationale: 'Interactive dashboard behavior depends on terminal rendering; keep it on targeted view tests instead of broad spawned smoke.' },
+    { commandPath: 'change:show', strategy: 'contract', rationale: 'Change rendering is deterministic and already covered through direct command tests.' },
+    { commandPath: 'change:list', strategy: 'contract', rationale: 'Deprecated list wrapper can be validated through CLI contract coverage without full process smoke.' },
+    { commandPath: 'change:validate', strategy: 'contract', rationale: 'Validation output is deterministic and fits contract-style tests with fixture workspaces.' },
+    { commandPath: 'archive', strategy: 'spawned-e2e', rationale: 'Archive updates change state and specs together, so it is lifecycle-sensitive and worth spawned smoke coverage.' },
+    { commandPath: 'spec:show', strategy: 'contract', rationale: 'Spec rendering is deterministic and already maps cleanly to fixture-based contract tests.' },
+    { commandPath: 'spec:list', strategy: 'contract', rationale: 'Spec listing is read-only and easy to validate with direct CLI assertions.' },
+    { commandPath: 'spec:validate', strategy: 'contract', rationale: 'Spec validation is a deterministic contract surface with fixture-driven expectations.' },
+    { commandPath: 'config:path', strategy: 'contract', rationale: 'Config path output is deterministic and scriptable.' },
+    { commandPath: 'config:list', strategy: 'contract', rationale: 'Config listing is a stable read-only contract.' },
+    { commandPath: 'config:get', strategy: 'contract', rationale: 'Config key retrieval is a stable scriptable surface.' },
+    { commandPath: 'config:set', strategy: 'contract', rationale: 'Config writes can be asserted directly against temporary config fixtures.' },
+    { commandPath: 'config:unset', strategy: 'contract', rationale: 'Config key removal is deterministic with temporary config fixtures.' },
+    { commandPath: 'config:reset', strategy: 'contract', rationale: 'Reset behavior is deterministic once prompts are bypassed in tests.' },
+    { commandPath: 'config:edit', strategy: 'exception', rationale: 'This command delegates to an external editor process and only needs focused environment-sensitive coverage.' },
+    { commandPath: 'config:profile', strategy: 'contract', rationale: 'Profile inspection is scriptable and deterministic.' },
+    { commandPath: 'schema:which', strategy: 'contract', rationale: 'Schema resolution is deterministic with fixture directories.' },
+    { commandPath: 'schema:validate', strategy: 'contract', rationale: 'Schema validation produces deterministic reports from fixture inputs.' },
+    { commandPath: 'schema:fork', strategy: 'contract', rationale: 'Schema fork output is a filesystem contract that can be asserted directly.' },
+    { commandPath: 'schema:init', strategy: 'contract', rationale: 'Schema initialization is deterministic over temporary workspaces.' },
+    { commandPath: 'sdd:init', strategy: 'spawned-e2e', rationale: 'SDD init seeds canonical state and generated views, so it should keep lifecycle smoke coverage.' },
+    { commandPath: 'sdd:init-context', strategy: 'spawned-e2e', rationale: 'Context bootstrap reads repository structure and writes canonical state, which benefits from spawned smoke coverage.' },
+    { commandPath: 'sdd:fingerprint', strategy: 'contract', rationale: 'Fingerprint backfill is a deterministic batch operation over change fixtures.' },
+    { commandPath: 'sdd:insight', strategy: 'spawned-e2e', rationale: 'Insight creation is the first discovery lifecycle write and should stay covered in spawned flow tests.' },
+    { commandPath: 'sdd:ingest-deposito', strategy: 'spawned-e2e', rationale: 'Ingestion coordinates discovery inputs, indexing, and trail generation across filesystem boundaries.' },
+    { commandPath: 'sdd:debate', strategy: 'spawned-e2e', rationale: 'Debate creation is part of the canonical discovery lifecycle and should stay in end-to-end smoke scope.' },
+    { commandPath: 'sdd:decide', strategy: 'spawned-e2e', rationale: 'Decide changes discovery state and promotes artifacts across lifecycle stages.' },
+    { commandPath: 'sdd:breakdown', strategy: 'spawned-e2e', rationale: 'Breakdown materializes executable FEAT workspaces and needs lifecycle smoke coverage.' },
+    { commandPath: 'sdd:mcp-manifest', strategy: 'contract', rationale: 'Manifest rendering is deterministic and provider-profile driven.' },
+    { commandPath: 'sdd:mcp-call', strategy: 'contract', rationale: 'The MCP bridge reuses canonical services and is best guarded with direct contract assertions.' },
+    { commandPath: 'sdd:start', strategy: 'spawned-e2e', rationale: 'Start transitions planned work into active execution and is a core lifecycle boundary.' },
+    { commandPath: 'sdd:frontend-impact', strategy: 'spawned-e2e', rationale: 'Frontend impact is a required lifecycle declaration that should remain part of spawned finalize-path smoke.' },
+    { commandPath: 'sdd:finalize', strategy: 'spawned-e2e', rationale: 'Finalize is the highest-risk lifecycle transition and must keep spawned smoke coverage.' },
+    { commandPath: 'sdd:context', strategy: 'contract', rationale: 'Context output is deterministic once workspace state is prepared.' },
+    { commandPath: 'sdd:onboard', strategy: 'contract', rationale: 'Onboard is a read-oriented guidance surface with deterministic ranking output.' },
+    { commandPath: 'sdd:aprovar', strategy: 'contract', rationale: 'Approval transitions are deterministic and fit fixture-driven lifecycle assertions.' },
+    { commandPath: 'sdd:next', strategy: 'contract', rationale: 'Next is ranking logic over canonical state and is naturally contract-testable.' },
+    { commandPath: 'sdd:audit', strategy: 'contract', rationale: 'Audit is a deterministic report over canonical state.' },
+    { commandPath: 'sdd:check', strategy: 'contract', rationale: 'Check is a deterministic health summary with strict output contracts.' },
+    { commandPath: 'sdd:rebuild', strategy: 'spawned-e2e', rationale: 'Rebuild reconstructs canonical state from filesystem artifacts and needs real-bin recovery smoke coverage.' },
+    { commandPath: 'sdd:metrics', strategy: 'spawned-e2e', rationale: 'Metrics aggregate transition-log lifecycle data and should keep real-bin smoke coverage for reporting windows.' },
+    { commandPath: 'sdd:dedup', strategy: 'spawned-e2e', rationale: 'Dedup apply reconciles historical warning_links across canonical state and needs real-bin mutation smoke coverage.' },
+    { commandPath: 'sdd:lint:feature', strategy: 'spawned-e2e', rationale: 'Feature lint evaluates workspace scope heuristics and should keep real-bin smoke coverage for strict/non-strict behavior.' },
+    { commandPath: 'sdd:migrate', strategy: 'contract', rationale: 'Migration planning and reporting are deterministic over fixture state.' },
+    { commandPath: 'sdd:migrate-workspace', strategy: 'contract', rationale: 'Workspace migration is deterministic and already aligns with fixture-based validation.' },
+    { commandPath: 'sdd:import-openspec', strategy: 'spawned-e2e', rationale: 'Legacy import crosses filesystem and generated-state boundaries, so a spawned smoke path is valuable.' },
+    { commandPath: 'sdd:skills:bundles', strategy: 'contract', rationale: 'Bundle listing is a stable read-only catalog contract.' },
+    { commandPath: 'sdd:skills:sync', strategy: 'contract', rationale: 'Skill sync can be asserted directly against temporary memory roots and tool targets.' },
+    { commandPath: 'sdd:skills:suggest', strategy: 'contract', rationale: 'Suggestion ranking is deterministic over the catalog state.' },
+    { commandPath: 'sdd:skills:usar', strategy: 'contract', rationale: 'Prompt assembly is deterministic over selected skill inputs and workspace context.' },
+    { commandPath: 'sdd:diagnose', strategy: 'contract', rationale: 'Diagnose emits deterministic structural findings and is suited to direct contract coverage.' },
+    { commandPath: 'sdd:scan-naming', strategy: 'contract', rationale: 'Naming-contract scan emits deterministic violations over tracked files.' },
+    { commandPath: 'sdd:sanitize:rollback', strategy: 'contract', rationale: 'Rollback behavior is deterministic over sanitizer manifests.' },
+    { commandPath: 'sdd:fgap:add', strategy: 'contract', rationale: 'Frontend gap recording is a deterministic state write.' },
+    { commandPath: 'sdd:fgap:done', strategy: 'contract', rationale: 'Frontend gap closure is deterministic over canonical state.' },
+    { commandPath: 'validate', strategy: 'contract', rationale: 'Top-level validation already exposes deterministic reports for fixture-driven contract tests.' },
+    { commandPath: 'show', strategy: 'contract', rationale: 'Top-level show is a deterministic wrapper over change/spec rendering contracts.' },
+    { commandPath: 'feedback', strategy: 'contract', rationale: 'Feedback command behavior is a stable CLI contract with explicit output.' },
+    { commandPath: 'completion:generate', strategy: 'contract', rationale: 'Completion script generation is deterministic and scriptable.' },
+    { commandPath: 'completion:install', strategy: 'spawned-e2e', rationale: 'Shell completion installation touches user-shell integration and should keep spawned smoke coverage.' },
+    { commandPath: 'completion:uninstall', strategy: 'spawned-e2e', rationale: 'Shell completion removal is integration-sensitive and belongs in spawned smoke coverage.' },
+    { commandPath: '__complete', strategy: 'contract', rationale: 'Machine-readable completion output is deterministic and should stay under direct contract assertions.' },
+    { commandPath: 'status', strategy: 'contract', rationale: 'Status is a deterministic report over workflow artifacts.' },
+    { commandPath: 'instructions', strategy: 'contract', rationale: 'Instruction rendering is deterministic over known artifacts and schemas.' },
+    { commandPath: 'templates', strategy: 'contract', rationale: 'Template resolution is a stable scriptable contract.' },
+    { commandPath: 'schemas', strategy: 'contract', rationale: 'Schema listing is a deterministic read-only surface.' },
+    { commandPath: 'new:change', strategy: 'spawned-e2e', rationale: 'Change creation writes scaffolded workflow artifacts and should retain spawned smoke coverage.' },
+];
+export function validateCliCommandMatrix(program) {
+    const leafCommands = collectCliLeafCommands(program).sort((left, right) => left.commandPath.localeCompare(right.commandPath));
+    const leafPaths = new Set(leafCommands.map((entry) => entry.commandPath));
+    const seen = new Set();
+    const duplicateEntries = CLI_COMMAND_MATRIX.filter((entry) => {
+        if (seen.has(entry.commandPath)) {
+            return true;
+        }
+        seen.add(entry.commandPath);
+        return false;
+    }).map((entry) => entry.commandPath);
+    const matrixPaths = new Set(CLI_COMMAND_MATRIX.map((entry) => entry.commandPath));
+    const missingEntries = leafCommands
+        .map((entry) => entry.commandPath)
+        .filter((commandPath) => !matrixPaths.has(commandPath));
+    const extraEntries = CLI_COMMAND_MATRIX
+        .map((entry) => entry.commandPath)
+        .filter((commandPath) => !leafPaths.has(commandPath));
+    return {
+        leafCommands,
+        duplicateEntries,
+        missingEntries,
+        extraEntries,
+    };
+}
+//# sourceMappingURL=command-matrix.js.map

package/dist/core/command-generation/adapters/amazon-q.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Amazon Q Developer Command Adapter
+ *
+ * Formats commands for Amazon Q Developer following its frontmatter specification.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Amazon Q adapter for command generation.
+ * File path: .amazonq/prompts/opsx-<id>.md
+ * Frontmatter: description
+ */
+export declare const amazonQAdapter: ToolCommandAdapter;
+//# sourceMappingURL=amazon-q.d.ts.map

package/dist/core/command-generation/adapters/amazon-q.js

@@ -0,0 +1,26 @@
+/**
+ * Amazon Q Developer Command Adapter
+ *
+ * Formats commands for Amazon Q Developer following its frontmatter specification.
+ */
+import path from 'path';
+/**
+ * Amazon Q adapter for command generation.
+ * File path: .amazonq/prompts/opsx-<id>.md
+ * Frontmatter: description
+ */
+export const amazonQAdapter = {
+    toolId: 'amazon-q',
+    getFilePath(commandId) {
+        return path.join('.amazonq', 'prompts', `opsx-${commandId}.md`);
+    },
+    formatFile(content) {
+        return `---
+description: ${content.description}
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=amazon-q.js.map

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

@@ -0,0 +1,13 @@
+/**
+ * Antigravity Command Adapter
+ *
+ * Formats commands for Antigravity following its frontmatter specification.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Antigravity adapter for command generation.
+ * File path: .agent/workflows/opsx-<id>.md
+ * Frontmatter: description
+ */
+export declare const antigravityAdapter: ToolCommandAdapter;
+//# sourceMappingURL=antigravity.d.ts.map

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

@@ -0,0 +1,26 @@
+/**
+ * Antigravity Command Adapter
+ *
+ * Formats commands for Antigravity following its frontmatter specification.
+ */
+import path from 'path';
+/**
+ * Antigravity adapter for command generation.
+ * File path: .agent/workflows/opsx-<id>.md
+ * Frontmatter: description
+ */
+export const antigravityAdapter = {
+    toolId: 'antigravity',
+    getFilePath(commandId) {
+        return path.join('.agent', 'workflows', `opsx-${commandId}.md`);
+    },
+    formatFile(content) {
+        return `---
+description: ${content.description}
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=antigravity.js.map

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

@@ -0,0 +1,13 @@
+/**
+ * Auggie (Augment CLI) Command Adapter
+ *
+ * Formats commands for Auggie following its frontmatter specification.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Auggie adapter for command generation.
+ * File path: .augment/commands/opsx-<id>.md
+ * Frontmatter: description, argument-hint
+ */
+export declare const auggieAdapter: ToolCommandAdapter;
+//# sourceMappingURL=auggie.d.ts.map

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

@@ -0,0 +1,27 @@
+/**
+ * Auggie (Augment CLI) Command Adapter
+ *
+ * Formats commands for Auggie following its frontmatter specification.
+ */
+import path from 'path';
+/**
+ * Auggie adapter for command generation.
+ * File path: .augment/commands/opsx-<id>.md
+ * Frontmatter: description, argument-hint
+ */
+export const auggieAdapter = {
+    toolId: 'auggie',
+    getFilePath(commandId) {
+        return path.join('.augment', 'commands', `opsx-${commandId}.md`);
+    },
+    formatFile(content) {
+        return `---
+description: ${content.description}
+argument-hint: command arguments
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=auggie.js.map

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

@@ -0,0 +1,13 @@
+/**
+ * Claude Code Command Adapter
+ *
+ * Formats commands for Claude Code following its frontmatter specification.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Claude Code adapter for command generation.
+ * File path: .claude/commands/opsx/<id>.md
+ * Frontmatter: name, description, category, tags
+ */
+export declare const claudeAdapter: ToolCommandAdapter;
+//# sourceMappingURL=claude.d.ts.map

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

@@ -0,0 +1,50 @@
+/**
+ * Claude Code Command Adapter
+ *
+ * Formats commands for Claude Code following its frontmatter 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) {
+    // 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 and backslashes
+        const escaped = value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
+        return `"${escaped}"`;
+    }
+    return value;
+}
+/**
+ * Formats a tags array as a YAML array with proper escaping.
+ */
+function formatTagsArray(tags) {
+    const escapedTags = tags.map((tag) => escapeYamlValue(tag));
+    return `[${escapedTags.join(', ')}]`;
+}
+/**
+ * Claude Code adapter for command generation.
+ * File path: .claude/commands/opsx/<id>.md
+ * Frontmatter: name, description, category, tags
+ */
+export const claudeAdapter = {
+    toolId: 'claude',
+    getFilePath(commandId) {
+        return path.join('.claude', 'commands', '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=claude.js.map

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

@@ -0,0 +1,14 @@
+/**
+ * Cline Command Adapter
+ *
+ * Formats commands for Cline following its workflow specification.
+ * Cline uses markdown headers instead of YAML frontmatter.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Cline adapter for command generation.
+ * File path: .clinerules/workflows/opsx-<id>.md
+ * Format: Markdown header with description
+ */
+export declare const clineAdapter: ToolCommandAdapter;
+//# sourceMappingURL=cline.d.ts.map

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

@@ -0,0 +1,27 @@
+/**
+ * Cline Command Adapter
+ *
+ * Formats commands for Cline following its workflow specification.
+ * Cline uses markdown headers instead of YAML frontmatter.
+ */
+import path from 'path';
+/**
+ * Cline adapter for command generation.
+ * File path: .clinerules/workflows/opsx-<id>.md
+ * Format: Markdown header with description
+ */
+export const clineAdapter = {
+    toolId: 'cline',
+    getFilePath(commandId) {
+        return path.join('.clinerules', 'workflows', `opsx-${commandId}.md`);
+    },
+    formatFile(content) {
+        return `# ${content.name}
+
+${content.description}
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=cline.js.map

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

@@ -0,0 +1,13 @@
+/**
+ * CodeBuddy Command Adapter
+ *
+ * Formats commands for CodeBuddy following its frontmatter specification.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * CodeBuddy adapter for command generation.
+ * File path: .codebuddy/commands/opsx/<id>.md
+ * Frontmatter: name, description, argument-hint
+ */
+export declare const codebuddyAdapter: ToolCommandAdapter;
+//# sourceMappingURL=codebuddy.d.ts.map

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

@@ -0,0 +1,28 @@
+/**
+ * CodeBuddy Command Adapter
+ *
+ * Formats commands for CodeBuddy following its frontmatter specification.
+ */
+import path from 'path';
+/**
+ * CodeBuddy adapter for command generation.
+ * File path: .codebuddy/commands/opsx/<id>.md
+ * Frontmatter: name, description, argument-hint
+ */
+export const codebuddyAdapter = {
+    toolId: 'codebuddy',
+    getFilePath(commandId) {
+        return path.join('.codebuddy', 'commands', 'opsx', `${commandId}.md`);
+    },
+    formatFile(content) {
+        return `---
+name: ${content.name}
+description: "${content.description}"
+argument-hint: "[command arguments]"
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=codebuddy.js.map

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

@@ -0,0 +1,16 @@
+/**
+ * Codex Command Adapter
+ *
+ * Formats commands for Codex following its frontmatter specification.
+ * Codex custom prompts live in the global home directory (~/.codex/prompts/)
+ * and are not shared through the repository. The CODEX_HOME env var can
+ * override the default ~/.codex location.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Codex adapter for command generation.
+ * File path: <CODEX_HOME>/prompts/opsx-<id>.md (absolute, global)
+ * Frontmatter: description, argument-hint
+ */
+export declare const codexAdapter: ToolCommandAdapter;
+//# sourceMappingURL=codex.d.ts.map

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

@@ -0,0 +1,39 @@
+/**
+ * Codex Command Adapter
+ *
+ * Formats commands for Codex following its frontmatter specification.
+ * Codex custom prompts live in the global home directory (~/.codex/prompts/)
+ * and are not shared through the repository. The CODEX_HOME env var can
+ * override the default ~/.codex location.
+ */
+import os from 'os';
+import path from 'path';
+/**
+ * Returns the Codex home directory.
+ * Respects the CODEX_HOME env var, defaulting to ~/.codex.
+ */
+function getCodexHome() {
+    const envHome = process.env.CODEX_HOME?.trim();
+    return path.resolve(envHome ? envHome : path.join(os.homedir(), '.codex'));
+}
+/**
+ * Codex adapter for command generation.
+ * File path: <CODEX_HOME>/prompts/opsx-<id>.md (absolute, global)
+ * Frontmatter: description, argument-hint
+ */
+export const codexAdapter = {
+    toolId: 'codex',
+    getFilePath(commandId) {
+        return path.join(getCodexHome(), 'prompts', `opsx-${commandId}.md`);
+    },
+    formatFile(content) {
+        return `---
+description: ${content.description}
+argument-hint: command arguments
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=codex.js.map

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

@@ -0,0 +1,13 @@
+/**
+ * Continue Command Adapter
+ *
+ * Formats commands for Continue following its .prompt specification.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Continue adapter for command generation.
+ * File path: .continue/prompts/opsx-<id>.prompt
+ * Frontmatter: name, description, invokable
+ */
+export declare const continueAdapter: ToolCommandAdapter;
+//# sourceMappingURL=continue.d.ts.map

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

@@ -0,0 +1,28 @@
+/**
+ * Continue Command Adapter
+ *
+ * Formats commands for Continue following its .prompt specification.
+ */
+import path from 'path';
+/**
+ * Continue adapter for command generation.
+ * File path: .continue/prompts/opsx-<id>.prompt
+ * Frontmatter: name, description, invokable
+ */
+export const continueAdapter = {
+    toolId: 'continue',
+    getFilePath(commandId) {
+        return path.join('.continue', 'prompts', `opsx-${commandId}.prompt`);
+    },
+    formatFile(content) {
+        return `---
+name: opsx-${content.id}
+description: ${content.description}
+invokable: true
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=continue.js.map

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

@@ -0,0 +1,13 @@
+/**
+ * CoStrict Command Adapter
+ *
+ * Formats commands for CoStrict following its frontmatter specification.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * CoStrict adapter for command generation.
+ * File path: .cospec/openspec/commands/opsx-<id>.md
+ * Frontmatter: description, argument-hint
+ */
+export declare const costrictAdapter: ToolCommandAdapter;
+//# sourceMappingURL=costrict.d.ts.map

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

@@ -0,0 +1,27 @@
+/**
+ * CoStrict Command Adapter
+ *
+ * Formats commands for CoStrict following its frontmatter specification.
+ */
+import path from 'path';
+/**
+ * CoStrict adapter for command generation.
+ * File path: .cospec/openspec/commands/opsx-<id>.md
+ * Frontmatter: description, argument-hint
+ */
+export const costrictAdapter = {
+    toolId: 'costrict',
+    getFilePath(commandId) {
+        return path.join('.cospec', 'openspec', 'commands', `opsx-${commandId}.md`);
+    },
+    formatFile(content) {
+        return `---
+description: "${content.description}"
+argument-hint: command arguments
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=costrict.js.map

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

@@ -0,0 +1,13 @@
+/**
+ * Crush Command Adapter
+ *
+ * Formats commands for Crush following its frontmatter specification.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Crush adapter for command generation.
+ * File path: .crush/commands/opsx/<id>.md
+ * Frontmatter: name, description, category, tags
+ */
+export declare const crushAdapter: ToolCommandAdapter;
+//# sourceMappingURL=crush.d.ts.map

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

@@ -0,0 +1,30 @@
+/**
+ * Crush Command Adapter
+ *
+ * Formats commands for Crush following its frontmatter specification.
+ */
+import path from 'path';
+/**
+ * Crush adapter for command generation.
+ * File path: .crush/commands/opsx/<id>.md
+ * Frontmatter: name, description, category, tags
+ */
+export const crushAdapter = {
+    toolId: 'crush',
+    getFilePath(commandId) {
+        return path.join('.crush', 'commands', 'opsx', `${commandId}.md`);
+    },
+    formatFile(content) {
+        const tagsStr = content.tags.join(', ');
+        return `---
+name: ${content.name}
+description: ${content.description}
+category: ${content.category}
+tags: [${tagsStr}]
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=crush.js.map

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

@@ -0,0 +1,14 @@
+/**
+ * Cursor Command Adapter
+ *
+ * Formats commands for Cursor following its frontmatter specification.
+ * Cursor uses a different frontmatter format and file naming convention.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Cursor adapter for command generation.
+ * File path: .cursor/commands/opsx-<id>.md
+ * Frontmatter: name (as /opsx-<id>), id, category, description
+ */
+export declare const cursorAdapter: ToolCommandAdapter;
+//# sourceMappingURL=cursor.d.ts.map

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

@@ -0,0 +1,44 @@
+/**
+ * Cursor Command Adapter
+ *
+ * Formats commands for Cursor following its frontmatter specification.
+ * Cursor uses a different frontmatter format and file naming convention.
+ */
+import path from 'path';
+/**
+ * Escapes a string value for safe YAML output.
+ * Quotes the string if it contains special YAML characters.
+ */
+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 internal double quotes and backslashes
+        const escaped = value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
+        return `"${escaped}"`;
+    }
+    return value;
+}
+/**
+ * Cursor adapter for command generation.
+ * File path: .cursor/commands/opsx-<id>.md
+ * Frontmatter: name (as /opsx-<id>), id, category, description
+ */
+export const cursorAdapter = {
+    toolId: 'cursor',
+    getFilePath(commandId) {
+        return path.join('.cursor', 'commands', `opsx-${commandId}.md`);
+    },
+    formatFile(content) {
+        return `---
+name: /opsx-${content.id}
+id: opsx-${content.id}
+category: ${escapeYamlValue(content.category)}
+description: ${escapeYamlValue(content.description)}
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=cursor.js.map