freeharness 0.4.1

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/command-generation/invocation.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Command Invocation
+ *
+ * How a tool spells an OpenSpec command has two parts, and only one of them
+ * can be read off the file the adapter writes:
+ *
+ * - The *name* comes from the file. `.../commands/opsx/<id>.md` is namespaced
+ *   by its directory, so the tool registers `opsx:<id>` (Claude Code, Gemini,
+ *   Crush, ...). `.../commands/opsx-<id>.md` names the command with the
+ *   filename, so the tool registers `opsx-<id>` (Cursor, GitHub Copilot,
+ *   OpenCode, ...).
+ * - The *prefix* is the tool's own and cannot be derived. Almost every tool
+ *   uses `/`; Amazon Q loads these files into its prompt library, which is
+ *   invoked with `@` (`@opsx-propose`), so its adapter declares that prefix.
+ *
+ * Deriving the name from `getFilePath` keeps generated cross-references and
+ * onboarding hints in step with the files OpenSpec actually writes. A
+ * hand-maintained list drifted before: only OpenCode was rewritten when the
+ * hyphen form was introduced (#727), and Cursor still advertised `/opsx:`
+ * commands its palette never registered (#1307). Carrying the prefix as
+ * adapter metadata rather than inferring it keeps the one tool that does not
+ * use a slash from being advertised as if it did.
+ */
+import type { ToolCommandAdapter } from './types.js';
+export type CommandInvocationStyle = 'namespaced' | 'flat';
+/**
+ * Everything needed to spell one of a tool's OpenSpec commands.
+ */
+export interface CommandInvocation {
+    /** How the command file names the command. */
+    style: CommandInvocationStyle;
+    /** What the user types before the name, e.g. `/` or Amazon Q's `@`. */
+    prefix: string;
+}
+/** The form these docs, command bodies, and skill templates are authored in. */
+export declare const CANONICAL_INVOCATION: CommandInvocation;
+/**
+ * Classifies a generated command file by the name the tool will answer to.
+ *
+ * The test is the filename, not the directory: an `opsx-` prefix means the
+ * filename is the command. Every other shape is treated as namespaced, which
+ * is what all seven `opsx/<id>.*` adapters need. An adapter that neither
+ * prefixes the filename nor nests under `opsx/` would land here too — none
+ * does, and the registry-wide test in invocation.test.ts fails if one appears.
+ *
+ * @param commandFilePath - Path returned by an adapter's `getFilePath`
+ * @returns 'flat' when the filename carries the `opsx-` prefix, otherwise
+ *          'namespaced'
+ */
+export declare function getInvocationStyleForPath(commandFilePath: string): CommandInvocationStyle;
+/**
+ * Resolves how a tool's generated commands are invoked: the name from the
+ * files its adapter writes, the prefix from the adapter's own declaration.
+ *
+ * @param adapter - The tool-specific command adapter
+ * @returns The invocation shared by every command that adapter generates
+ */
+export declare function getInvocationForAdapter(adapter: ToolCommandAdapter): CommandInvocation;
+/**
+ * Spells one command the way the tool registers it.
+ *
+ * @param invocation - The tool's invocation, from getInvocationForAdapter()
+ * @param commandId - The command identifier (e.g. 'apply')
+ * @returns What the user types, e.g. `/opsx:apply`, `/opsx-apply`, `@opsx-apply`
+ */
+export declare function formatCommandInvocation(invocation: CommandInvocation, commandId: string): string;
+/**
+ * Whether a tool's invocation differs from the canonical `/opsx:<id>` that
+ * command bodies and skill templates are authored in — that is, whether
+ * generated text has to be rewritten for that tool at all.
+ */
+export declare function needsInvocationRewrite(invocation: CommandInvocation): boolean;

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/command-generation/invocation.js

@@ -0,0 +1,76 @@
+/**
+ * Command Invocation
+ *
+ * How a tool spells an OpenSpec command has two parts, and only one of them
+ * can be read off the file the adapter writes:
+ *
+ * - The *name* comes from the file. `.../commands/opsx/<id>.md` is namespaced
+ *   by its directory, so the tool registers `opsx:<id>` (Claude Code, Gemini,
+ *   Crush, ...). `.../commands/opsx-<id>.md` names the command with the
+ *   filename, so the tool registers `opsx-<id>` (Cursor, GitHub Copilot,
+ *   OpenCode, ...).
+ * - The *prefix* is the tool's own and cannot be derived. Almost every tool
+ *   uses `/`; Amazon Q loads these files into its prompt library, which is
+ *   invoked with `@` (`@opsx-propose`), so its adapter declares that prefix.
+ *
+ * Deriving the name from `getFilePath` keeps generated cross-references and
+ * onboarding hints in step with the files OpenSpec actually writes. A
+ * hand-maintained list drifted before: only OpenCode was rewritten when the
+ * hyphen form was introduced (#727), and Cursor still advertised `/opsx:`
+ * commands its palette never registered (#1307). Carrying the prefix as
+ * adapter metadata rather than inferring it keeps the one tool that does not
+ * use a slash from being advertised as if it did.
+ */
+import path from 'path';
+/** The form these docs, command bodies, and skill templates are authored in. */
+export const CANONICAL_INVOCATION = { style: 'namespaced', prefix: '/' };
+/**
+ * Classifies a generated command file by the name the tool will answer to.
+ *
+ * The test is the filename, not the directory: an `opsx-` prefix means the
+ * filename is the command. Every other shape is treated as namespaced, which
+ * is what all seven `opsx/<id>.*` adapters need. An adapter that neither
+ * prefixes the filename nor nests under `opsx/` would land here too — none
+ * does, and the registry-wide test in invocation.test.ts fails if one appears.
+ *
+ * @param commandFilePath - Path returned by an adapter's `getFilePath`
+ * @returns 'flat' when the filename carries the `opsx-` prefix, otherwise
+ *          'namespaced'
+ */
+export function getInvocationStyleForPath(commandFilePath) {
+    return path.basename(commandFilePath).startsWith('opsx-') ? 'flat' : 'namespaced';
+}
+/**
+ * Resolves how a tool's generated commands are invoked: the name from the
+ * files its adapter writes, the prefix from the adapter's own declaration.
+ *
+ * @param adapter - The tool-specific command adapter
+ * @returns The invocation shared by every command that adapter generates
+ */
+export function getInvocationForAdapter(adapter) {
+    return {
+        // Any command id works: every adapter applies one naming rule to all of them.
+        style: getInvocationStyleForPath(adapter.getFilePath('explore')),
+        prefix: adapter.invocationPrefix ?? CANONICAL_INVOCATION.prefix,
+    };
+}
+/**
+ * Spells one command the way the tool registers it.
+ *
+ * @param invocation - The tool's invocation, from getInvocationForAdapter()
+ * @param commandId - The command identifier (e.g. 'apply')
+ * @returns What the user types, e.g. `/opsx:apply`, `/opsx-apply`, `@opsx-apply`
+ */
+export function formatCommandInvocation(invocation, commandId) {
+    const separator = invocation.style === 'namespaced' ? ':' : '-';
+    return `${invocation.prefix}opsx${separator}${commandId}`;
+}
+/**
+ * Whether a tool's invocation differs from the canonical `/opsx:<id>` that
+ * command bodies and skill templates are authored in — that is, whether
+ * generated text has to be rewritten for that tool at all.
+ */
+export function needsInvocationRewrite(invocation) {
+    return (invocation.style !== CANONICAL_INVOCATION.style ||
+        invocation.prefix !== CANONICAL_INVOCATION.prefix);
+}

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/command-generation/registry.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Command Adapter Registry
+ *
+ * Centralized registry for tool command adapters.
+ *
+ * FreeHarness trim: vendored from OpenSpec with the adapter set reduced to the
+ * two harnesses FreeHarness targets (Claude Code + OpenCode). The upstream
+ * registry registered 29 adapters; the other 27 imports/registrations were
+ * removed. Registry API is otherwise unchanged.
+ */
+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', 'opencode')
+     * @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;
+}

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/command-generation/registry.js

@@ -0,0 +1,53 @@
+/**
+ * Command Adapter Registry
+ *
+ * Centralized registry for tool command adapters.
+ *
+ * FreeHarness trim: vendored from OpenSpec with the adapter set reduced to the
+ * two harnesses FreeHarness targets (Claude Code + OpenCode). The upstream
+ * registry registered 29 adapters; the other 27 imports/registrations were
+ * removed. Registry API is otherwise unchanged.
+ */
+import { claudeAdapter } from './adapters/claude.js';
+import { opencodeAdapter } from './adapters/opencode.js';
+/**
+ * Registry for looking up tool command adapters.
+ */
+export class CommandAdapterRegistry {
+    static adapters = new Map();
+    // Static initializer - register built-in adapters (trimmed to claude + opencode)
+    static {
+        CommandAdapterRegistry.register(claudeAdapter);
+        CommandAdapterRegistry.register(opencodeAdapter);
+    }
+    /**
+     * 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', 'opencode')
+     * @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);
+    }
+}

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/command-generation/types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * 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 command files.
+     */
+    getFilePath(commandId: string): string;
+    /**
+     * What the user types before the command name, when it is not the default
+     * `/`. Amazon Q loads these files into its prompt library, which is invoked
+     * with `@` (`@opsx-propose`), so its adapter sets '@'. The name itself is
+     * still derived from getFilePath — see invocation.ts.
+     */
+    invocationPrefix?: 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 command files */
+    path: string;
+    /** Complete file content (frontmatter + body) */
+    fileContent: string;
+}

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/command-generation/types.js

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

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/command-generation/yaml.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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.
+ *
+ * Always emits a double-quoted scalar. Quoting unconditionally keeps the
+ * value a string no matter what it holds: an unquoted `true`, `null` or
+ * `123` would round-trip as a boolean, null or number, and an unquoted
+ * value opening with a block indicator (`|`, `>`) or containing `: `
+ * is not valid YAML at all.
+ *
+ * Inside the quotes it escapes everything that cannot appear verbatim in a
+ * double-quoted scalar: backslash, double quote, line feed, carriage
+ * return, and the non-printable characters YAML's `c-printable` production
+ * excludes (C0 controls, DEL and C1 controls). Lenient parsers accept a raw
+ * control byte, but strict ones reject the document outright, so escaping
+ * them here keeps the generated file portable across every tool's parser.
+ *
+ * @param value - The raw string to embed in YAML frontmatter.
+ * @returns The value as an escaped, double-quoted YAML scalar.
+ */
+export declare function escapeYamlValue(value: string): string;
+/**
+ * Formats a tags array as a YAML array with proper escaping.
+ *
+ * @param tags - Array of tag strings.
+ * @returns Formatted YAML array string, e.g. '[tag1, tag2]'.
+ */
+export declare function formatTagsArray(tags: string[]): string;

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/command-generation/yaml.js

@@ -0,0 +1,47 @@
+/**
+ * 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.
+ *
+ * Always emits a double-quoted scalar. Quoting unconditionally keeps the
+ * value a string no matter what it holds: an unquoted `true`, `null` or
+ * `123` would round-trip as a boolean, null or number, and an unquoted
+ * value opening with a block indicator (`|`, `>`) or containing `: `
+ * is not valid YAML at all.
+ *
+ * Inside the quotes it escapes everything that cannot appear verbatim in a
+ * double-quoted scalar: backslash, double quote, line feed, carriage
+ * return, and the non-printable characters YAML's `c-printable` production
+ * excludes (C0 controls, DEL and C1 controls). Lenient parsers accept a raw
+ * control byte, but strict ones reject the document outright, so escaping
+ * them here keeps the generated file portable across every tool's parser.
+ *
+ * @param value - The raw string to embed in YAML frontmatter.
+ * @returns The value as an escaped, double-quoted YAML scalar.
+ */
+export function escapeYamlValue(value) {
+    const escaped = value
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')
+        // Remaining non-printables have no dedicated escape; emit them as \xHH.
+        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g, (char) => `\\x${char.charCodeAt(0).toString(16).padStart(2, '0')}`);
+    return `"${escaped}"`;
+}
+/**
+ * Formats a tags array as a YAML array with proper escaping.
+ *
+ * @param tags - Array of tag strings.
+ * @returns Formatted YAML array string, e.g. '[tag1, tag2]'.
+ */
+export function formatTagsArray(tags) {
+    const escapedTags = tags.map((tag) => escapeYamlValue(tag));
+    return `[${escapedTags.join(', ')}]`;
+}

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/command-references.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Command Reference Utilities
+ *
+ * Utilities for transforming command references to tool-specific formats.
+ *
+ * FreeHarness trim: reduced to the single transform the vendored generator and
+ * initProject need. Upstream also carried skill-reference transformers for
+ * Codex ($name), Kimi (/skill:name), Rovo Dev (natural language) and the
+ * capability-aware getTransformerForTool selector. FreeHarness targets only
+ * Claude Code and OpenCode, so those code paths (and the command-surface.ts
+ * dependency they pulled in) were dropped. The invocation for a claude/opencode
+ * target is derived directly from its adapter in init.ts.
+ */
+import type { CommandInvocation } from './command-generation/invocation.js';
+/**
+ * Rewrites the canonical `/opsx:<command>` references that command bodies and
+ * skill templates are authored with into the form the target tool actually
+ * registers — `/opsx-<command>` for tools that name the command by filename
+ * (e.g. OpenCode). Claude Code keeps the canonical `/opsx:<command>` form, so
+ * for it this is a no-op the caller skips via needsInvocationRewrite().
+ *
+ * Only known command ids are rewritten, so a mistyped or invented
+ * `/opsx:<something>` is left as written rather than silently reshaped into a
+ * command that does not exist either.
+ *
+ * @param text - The text containing command references
+ * @param invocation - The tool's invocation, from getInvocationForAdapter()
+ * @returns Text with command references spelled the tool's way
+ *
+ * @example
+ * transformCommandInvocations('/opsx:new', { style: 'flat', prefix: '/' }) // '/opsx-new'
+ */
+export declare function transformCommandInvocations(text: string, invocation: CommandInvocation): string;

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/command-references.js

@@ -0,0 +1,55 @@
+/**
+ * Command Reference Utilities
+ *
+ * Utilities for transforming command references to tool-specific formats.
+ *
+ * FreeHarness trim: reduced to the single transform the vendored generator and
+ * initProject need. Upstream also carried skill-reference transformers for
+ * Codex ($name), Kimi (/skill:name), Rovo Dev (natural language) and the
+ * capability-aware getTransformerForTool selector. FreeHarness targets only
+ * Claude Code and OpenCode, so those code paths (and the command-surface.ts
+ * dependency they pulled in) were dropped. The invocation for a claude/opencode
+ * target is derived directly from its adapter in init.ts.
+ */
+import { formatCommandInvocation } from './command-generation/invocation.js';
+/**
+ * Rewrites the canonical `/opsx:<command>` references that command bodies and
+ * skill templates are authored with into the form the target tool actually
+ * registers — `/opsx-<command>` for tools that name the command by filename
+ * (e.g. OpenCode). Claude Code keeps the canonical `/opsx:<command>` form, so
+ * for it this is a no-op the caller skips via needsInvocationRewrite().
+ *
+ * Only known command ids are rewritten, so a mistyped or invented
+ * `/opsx:<something>` is left as written rather than silently reshaped into a
+ * command that does not exist either.
+ *
+ * @param text - The text containing command references
+ * @param invocation - The tool's invocation, from getInvocationForAdapter()
+ * @returns Text with command references spelled the tool's way
+ *
+ * @example
+ * transformCommandInvocations('/opsx:new', { style: 'flat', prefix: '/' }) // '/opsx-new'
+ */
+export function transformCommandInvocations(text, invocation) {
+    return text.replace(/\/opsx:([a-z-]+)/g, (match, commandId) => commandId in COMMAND_TO_SKILL_NAME
+        ? formatCommandInvocation(invocation, commandId)
+        : match);
+}
+/**
+ * Maps command short names to their skill names. Used to gate which
+ * `/opsx:<id>` references are rewritten (unknown ids are left untouched).
+ */
+const COMMAND_TO_SKILL_NAME = {
+    'explore': 'openspec-explore',
+    'new': 'openspec-new-change',
+    'continue': 'openspec-continue-change',
+    'apply': 'openspec-apply-change',
+    'update': 'openspec-update-change',
+    'ff': 'openspec-ff-change',
+    'sync': 'openspec-sync-specs',
+    'archive': 'openspec-archive-change',
+    'bulk-archive': 'openspec-bulk-archive-change',
+    'verify': 'openspec-verify-change',
+    'onboard': 'openspec-onboard',
+    'propose': 'openspec-propose',
+};

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/shared/allowed-tools.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Pre-approved tools for generated skills and slash commands, emitted as the
+ * `allowed-tools` frontmatter field (Agent Skills standard for SKILL.md;
+ * same field for Claude Code slash commands). Scoped to the OpenSpec CLI so
+ * agents that honor it stop prompting on each `openspec` call; the field
+ * only pre-approves — it does not restrict — so any other tool a skill or
+ * command needs (Read, Write, arbitrary Bash for builds/tests) stays
+ * available under the user's normal permission settings. Tools that don't
+ * recognize the field ignore it.
+ */
+export declare const OPENSPEC_CLI_ALLOWED_TOOLS = "Bash(openspec:*)";

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/shared/allowed-tools.js

@@ -0,0 +1,11 @@
+/**
+ * Pre-approved tools for generated skills and slash commands, emitted as the
+ * `allowed-tools` frontmatter field (Agent Skills standard for SKILL.md;
+ * same field for Claude Code slash commands). Scoped to the OpenSpec CLI so
+ * agents that honor it stop prompting on each `openspec` call; the field
+ * only pre-approves — it does not restrict — so any other tool a skill or
+ * command needs (Read, Write, arbitrary Bash for builds/tests) stays
+ * available under the user's normal permission settings. Tools that don't
+ * recognize the field ignore it.
+ */
+export const OPENSPEC_CLI_ALLOWED_TOOLS = 'Bash(openspec:*)';

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/shared/skill-generation.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Skill Generation Utilities
+ *
+ * Shared utilities for generating skill and command files.
+ */
+import { getOpsxExploreCommandTemplate, type SkillTemplate } from '../templates/skill-templates.js';
+import type { CommandContent } from '../command-generation/index.js';
+/**
+ * Skill template with directory name and workflow ID mapping.
+ */
+export interface SkillTemplateEntry {
+    template: SkillTemplate;
+    dirName: string;
+    workflowId: string;
+}
+/**
+ * Command template with ID mapping.
+ */
+export interface CommandTemplateEntry {
+    template: ReturnType<typeof getOpsxExploreCommandTemplate>;
+    id: string;
+}
+/**
+ * Gets skill templates with their directory names, optionally filtered by workflow IDs.
+ *
+ * @param workflowFilter - If provided, only return templates whose workflowId is in this array
+ */
+export declare function getSkillTemplates(workflowFilter?: readonly string[]): SkillTemplateEntry[];
+/**
+ * Gets command templates with their IDs, optionally filtered by workflow IDs.
+ *
+ * @param workflowFilter - If provided, only return templates whose id is in this array
+ */
+export declare function getCommandTemplates(workflowFilter?: readonly string[]): CommandTemplateEntry[];
+/**
+ * Converts command templates to CommandContent array, optionally filtered by workflow IDs.
+ *
+ * @param workflowFilter - If provided, only return contents whose id is in this array
+ */
+export declare function getCommandContents(workflowFilter?: readonly string[]): CommandContent[];
+/**
+ * Generates skill file content with YAML frontmatter.
+ *
+ * @param template - The skill template
+ * @param generatedByVersion - The OpenSpec version to embed in the file
+ * @param transformInstructions - Optional callback to transform the instructions content
+ */
+export declare function generateSkillContent(template: SkillTemplate, generatedByVersion: string, transformInstructions?: (instructions: string) => string): string;

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/shared/skill-generation.js

@@ -0,0 +1,99 @@
+/**
+ * Skill Generation Utilities
+ *
+ * Shared utilities for generating skill and command files.
+ */
+import { getExploreSkillTemplate, getNewChangeSkillTemplate, getContinueChangeSkillTemplate, getApplyChangeSkillTemplate, getUpdateChangeSkillTemplate, getFfChangeSkillTemplate, getSyncSpecsSkillTemplate, getArchiveChangeSkillTemplate, getBulkArchiveChangeSkillTemplate, getVerifyChangeSkillTemplate, getOnboardSkillTemplate, getOpsxProposeSkillTemplate, getOpsxExploreCommandTemplate, getOpsxNewCommandTemplate, getOpsxContinueCommandTemplate, getOpsxApplyCommandTemplate, getOpsxUpdateCommandTemplate, getOpsxFfCommandTemplate, getOpsxSyncCommandTemplate, getOpsxArchiveCommandTemplate, getOpsxBulkArchiveCommandTemplate, getOpsxVerifyCommandTemplate, getOpsxOnboardCommandTemplate, getOpsxProposeCommandTemplate, } from '../templates/skill-templates.js';
+import { OPENSPEC_CLI_ALLOWED_TOOLS } from './allowed-tools.js';
+/**
+ * Gets skill templates with their directory names, optionally filtered by workflow IDs.
+ *
+ * @param workflowFilter - If provided, only return templates whose workflowId is in this array
+ */
+export function getSkillTemplates(workflowFilter) {
+    const all = [
+        { template: getExploreSkillTemplate(), dirName: 'openspec-explore', workflowId: 'explore' },
+        { template: getNewChangeSkillTemplate(), dirName: 'openspec-new-change', workflowId: 'new' },
+        { template: getContinueChangeSkillTemplate(), dirName: 'openspec-continue-change', workflowId: 'continue' },
+        { template: getApplyChangeSkillTemplate(), dirName: 'openspec-apply-change', workflowId: 'apply' },
+        { template: getUpdateChangeSkillTemplate(), dirName: 'openspec-update-change', workflowId: 'update' },
+        { template: getFfChangeSkillTemplate(), dirName: 'openspec-ff-change', workflowId: 'ff' },
+        { template: getSyncSpecsSkillTemplate(), dirName: 'openspec-sync-specs', workflowId: 'sync' },
+        { template: getArchiveChangeSkillTemplate(), dirName: 'openspec-archive-change', workflowId: 'archive' },
+        { template: getBulkArchiveChangeSkillTemplate(), dirName: 'openspec-bulk-archive-change', workflowId: 'bulk-archive' },
+        { template: getVerifyChangeSkillTemplate(), dirName: 'openspec-verify-change', workflowId: 'verify' },
+        { template: getOnboardSkillTemplate(), dirName: 'openspec-onboard', workflowId: 'onboard' },
+        { template: getOpsxProposeSkillTemplate(), dirName: 'openspec-propose', workflowId: 'propose' },
+    ];
+    if (!workflowFilter)
+        return all;
+    const filterSet = new Set(workflowFilter);
+    return all.filter(entry => filterSet.has(entry.workflowId));
+}
+/**
+ * Gets command templates with their IDs, optionally filtered by workflow IDs.
+ *
+ * @param workflowFilter - If provided, only return templates whose id is in this array
+ */
+export function getCommandTemplates(workflowFilter) {
+    const all = [
+        { template: getOpsxExploreCommandTemplate(), id: 'explore' },
+        { template: getOpsxNewCommandTemplate(), id: 'new' },
+        { template: getOpsxContinueCommandTemplate(), id: 'continue' },
+        { template: getOpsxApplyCommandTemplate(), id: 'apply' },
+        { template: getOpsxUpdateCommandTemplate(), id: 'update' },
+        { template: getOpsxFfCommandTemplate(), id: 'ff' },
+        { template: getOpsxSyncCommandTemplate(), id: 'sync' },
+        { template: getOpsxArchiveCommandTemplate(), id: 'archive' },
+        { template: getOpsxBulkArchiveCommandTemplate(), id: 'bulk-archive' },
+        { template: getOpsxVerifyCommandTemplate(), id: 'verify' },
+        { template: getOpsxOnboardCommandTemplate(), id: 'onboard' },
+        { template: getOpsxProposeCommandTemplate(), id: 'propose' },
+    ];
+    if (!workflowFilter)
+        return all;
+    const filterSet = new Set(workflowFilter);
+    return all.filter(entry => filterSet.has(entry.id));
+}
+/**
+ * Converts command templates to CommandContent array, optionally filtered by workflow IDs.
+ *
+ * @param workflowFilter - If provided, only return contents whose id is in this array
+ */
+export function getCommandContents(workflowFilter) {
+    const commandTemplates = getCommandTemplates(workflowFilter);
+    return commandTemplates.map(({ template, id }) => ({
+        id,
+        name: template.name,
+        description: template.description,
+        category: template.category,
+        tags: template.tags,
+        body: template.content,
+    }));
+}
+/**
+ * Generates skill file content with YAML frontmatter.
+ *
+ * @param template - The skill template
+ * @param generatedByVersion - The OpenSpec version to embed in the file
+ * @param transformInstructions - Optional callback to transform the instructions content
+ */
+export function generateSkillContent(template, generatedByVersion, transformInstructions) {
+    const instructions = transformInstructions
+        ? transformInstructions(template.instructions)
+        : template.instructions;
+    return `---
+name: ${template.name}
+description: ${template.description}
+allowed-tools: ${OPENSPEC_CLI_ALLOWED_TOOLS}
+license: ${template.license || 'MIT'}
+compatibility: ${template.compatibility || 'Requires openspec CLI.'}
+metadata:
+  author: ${template.metadata?.author || 'openspec'}
+  version: "${template.metadata?.version || '1.0'}"
+  generatedBy: "${generatedByVersion}"
+---
+
+${instructions}
+`;
+}