@fission-ai/openspec 1.13.2 → 1.14.1

package/dist/commands/workset.js

@@ -8,7 +8,6 @@
  */
 import * as os from 'node:os';
 import { createRequire } from 'node:module';
-import { Option } from 'commander';
 import { buildWorksetCodeWorkspaceJson, getWorkset, getWorksetCodeWorkspacePath, listWorksets, readWorksetsState, removeWorkset, updateWorksetsState, validateWorksetName, withWorkset, withWorksetsLock, worksetNotFoundError, } from '../core/worksets.js';
 import { buildLaunchCommand, findOpener, isOpenerCommandAvailable, isOpenerEnabled, listOpenerChoices, mergeOpenerTable, } from '../core/openers.js';
 import { pathIsDirectory, writeFileAtomically } from '../core/file-state.js';
@@ -18,7 +17,6 @@ import { isInteractive } from '../utils/interactive.js';
 import { asErrorMessage, emitFailure, isPromptCancellationError, printJson, } from './shared-output.js';
 import { finalizeWorkset, firstInstalledAlternative, formatMemberRows, noToolInstalledError, resolveMemberFlags, toolUnavailableError, toolUnknownError, } from './workset-input.js';
 import { composeInteractively, confirmRemoveInteractively, promptOpenNow, promptToolFromChoices, } from './workset-prompts.js';
-import { COMMAND_REGISTRY } from '../core/completions/command-registry.js';
 // cross-spawn is CJS with no types and only `workset open` needs it -
 // loaded lazily so every other CLI invocation skips its module graph.
 let cachedSpawn;
@@ -93,7 +91,7 @@ export function exitCodeForLaunch(result) {
     }
     return result.code ?? 0;
 }
-class WorksetCommand {
+export class WorksetCommand {
     async create(name, options = {}) {
         try {
             const interactive = !options.json && isInteractive();
@@ -358,89 +356,4 @@ class WorksetCommand {
         }
     }
 }
-function collectMember(value, previous) {
-    return [...previous, value];
-}
-export function registerWorksetCommand(program) {
-    const worksetCommand = new WorksetCommand();
-    const groupDescription = COMMAND_REGISTRY.find((entry) => entry.name === 'workset')?.description ??
-        'Compose, keep, and open personal working views (purely local)';
-    const workset = program.command('workset').description(groupDescription);
-    // Parsed at the group level so `openspec workset --json` keeps the
-    // one-JSON-document contract instead of a raw Commander error. The
-    // parent option matches anywhere; actions read optsWithGlobals().
-    workset.addOption(new Option('--json', 'Output as JSON').hideHelp());
-    workset
-        .command('create [name]')
-        .description('Compose and save a named working view of folders you choose')
-        .option('--member <member>', 'Member folder as <path> or <name>=<path>; repeatable, first is the primary', collectMember, [])
-        .option('--tool <id>', 'Preferred tool to open this workset with')
-        .option('--json', 'Output as JSON')
-        .action(async (name, _options, command) => {
-        await worksetCommand.create(name, command.optsWithGlobals());
-    });
-    workset
-        .command('list')
-        .alias('ls')
-        .description('Show saved worksets with their members')
-        .option('--json', 'Output as JSON')
-        .action(async (_options, command) => {
-        await worksetCommand.list(command.optsWithGlobals());
-    });
-    workset
-        .command('open <name>')
-        .description('Open a saved workset in your tool (editor window or agent session)')
-        .option('--tool <id>', 'Open with this tool just this once')
-        .addOption(
-    // Parsed so Commander never owns the error; rejected in the
-    // action with one JSON document. Hidden because help should not
-    // advertise a mode that only rejects.
-    new Option('--json', 'Not supported for open').hideHelp())
-        .action(async (name, _options, command) => {
-        await worksetCommand.open(name, command.optsWithGlobals());
-    });
-    workset
-        .command('remove <name>')
-        .description('Delete a saved workset (member folders are never touched)')
-        .option('--yes', 'Confirm removal non-interactively')
-        .option('--json', 'Output as JSON')
-        .action(async (name, _options, command) => {
-        await worksetCommand.remove(name, command.optsWithGlobals());
-    });
-    const subcommandsLine = workset.commands
-        .map((subcommand) => {
-        const aliases = subcommand.aliases();
-        return aliases.length > 0
-            ? `${subcommand.name()} (${aliases.join(', ')})`
-            : subcommand.name();
-    })
-        .join(', ');
-    // One handler owns missing AND unknown subcommands: known
-    // subcommands dispatch above; everything else lands in this action
-    // (allowExcessArguments routes the unknown operand here), keeping
-    // the one-JSON-document contract for `--json` probes.
-    workset.allowExcessArguments(true);
-    workset.action(() => {
-        const attempted = workset.args.filter((operand) => !operand.startsWith('-'));
-        const message = attempted.length > 0
-            ? `Unknown command '${attempted[0]}' for 'openspec workset'. Workset subcommands: ${subcommandsLine}.`
-            : `Missing subcommand for 'openspec workset'. Workset subcommands: ${subcommandsLine}.`;
-        if (workset.opts().json) {
-            printJson({
-                status: [
-                    {
-                        severity: 'error',
-                        code: 'unknown_workset_subcommand',
-                        message,
-                        fix: 'Run one of the workset subcommands.',
-                    },
-                ],
-            });
-        }
-        else {
-            console.error(`Error: ${message}`);
-        }
-        process.exitCode = 1;
-    });
-}
 //# sourceMappingURL=workset.js.map

package/dist/core/archive.js

@@ -9,7 +9,7 @@ import chalk from 'chalk';
 import { emitStoreRootBanner, isRootSelectionError, resolveOpenSpecRoot, toRootOutput, withStoreFlag, isStoreSelectedRoot, } from './root-selection.js';
 import { findSpecUpdates, buildUpdatedSpec, writeUpdatedSpec, retireSpec, finalizeRetiredSpec, pruneEmptyDirs, } from './specs-apply.js';
 import { discoverSpecFiles, findUnreadDeltaFiles, hasAnyFileUnder } from '../utils/spec-discovery.js';
-import { METADATA_FILENAME, readRetireCapabilitiesMarker, readSkipSpecsMarker } from '../utils/change-metadata.js';
+import { METADATA_FILENAME, formatUnknownChangeMetadataKeysMessage, readRetireCapabilitiesMarker, readSkipSpecsMarker, readUnknownChangeMetadataKeys, } from '../utils/change-metadata.js';
 import { confirmPrompt, isNonInteractivePromptError } from '../utils/interactive.js';
 import { FileSystemUtils } from '../utils/file-system.js';
 import { folderStyleNameProblem } from './id.js';
@@ -247,6 +247,14 @@ function toArchiveDiagnostic(error) {
     if (isRootSelectionError(error)) {
         return error.diagnostic;
     }
+    if (error instanceof RetirementCleanupError) {
+        return {
+            severity: 'error',
+            code: 'archive_retirement_cleanup_failed',
+            message: error.message,
+            fix: 'Inspect the archived change and all recovery paths in this diagnostic; preserve any needed content before cleanup.',
+        };
+    }
     return {
         severity: 'error',
         code: 'archive_error',
@@ -379,7 +387,7 @@ async function assertCopiedDirectoryUnchanged(stagedSource, destination, expecte
  */
 class MoveDestinationRetainedError extends Error {
 }
-class RetirementBackupsRetainedError extends Error {
+class RetirementCleanupError extends Error {
 }
 function isFallbackRenameCode(code) {
     return code === 'EPERM' || code === 'EXDEV';
@@ -1012,12 +1020,12 @@ async function finalizeRetirementBackups(snapshots, mainSpecsDir) {
             snapshot.displacedPath = undefined;
         }
         catch (error) {
-            errors.push(`Could not remove the committed retirement backup at ${displacedPath} ` +
+            errors.push(`Could not finalize the retirement backup at ${displacedPath} ` +
                 `(${error instanceof Error ? error.message : String(error)}).`);
         }
     }
     if (errors.length > 0) {
-        throw new RetirementBackupsRetainedError(`${errors.join(' ')} The change remains archived and each listed backup was retained for recovery.`);
+        throw new RetirementCleanupError(`${errors.join(' ')} The change was archived, but retirement cleanup did not complete. Inspect all reported recovery paths before recovery or cleanup.`);
     }
 }
 export class ArchiveCommand {
@@ -1125,6 +1133,13 @@ export class ArchiveCommand {
         if (nested) {
             throw new ArchiveBlockedError('archive_change_is_namespace_folder', `Cannot archive '${changeName}': ${describeNestedChange(nested)}`, `Rename openspec/changes/${nested.nested[0]}/ to a flat change directory, then archive it.`);
         }
+        const unknownMetadataKeys = readUnknownChangeMetadataKeys(changeDir);
+        const unknownMetadataWarning = unknownMetadataKeys.length > 0
+            ? formatUnknownChangeMetadataKeysMessage(unknownMetadataKeys)
+            : undefined;
+        if (unknownMetadataWarning && !json) {
+            console.warn(chalk.yellow(unknownMetadataWarning));
+        }
         const skipValidation = options.validate === false || options.noValidate === true;
         // Validate specs and change before archiving
         if (!skipValidation) {
@@ -1770,11 +1785,11 @@ export class ArchiveCommand {
                                     await finalizeRetirementBackups(specSnapshots, mainSpecsDir);
                                 }
                                 catch (cleanupError) {
-                                    throw new RetirementBackupsRetainedError(`${error.message} ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+                                    throw new RetirementCleanupError(`${error.message} ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
                                 }
                                 throw error;
                             }
-                            if (error instanceof RetirementBackupsRetainedError)
+                            if (error instanceof RetirementCleanupError)
                                 throw error;
                             const rollbackErrors = [];
                             try {
@@ -1827,7 +1842,13 @@ export class ArchiveCommand {
                 path: archivePath,
                 specsUpdated,
                 ...(totals ? { totals } : {}),
-                ...(specWarnings.length > 0 ? { warnings: specWarnings } : {}),
+                ...(specWarnings.length > 0 || unknownMetadataWarning
+                    ? {
+                        warnings: unknownMetadataWarning
+                            ? [...specWarnings, unknownMetadataWarning]
+                            : specWarnings,
+                    }
+                    : {}),
             };
         }
         finally {

package/dist/core/artifact-graph/instruction-loader.d.ts

@@ -32,6 +32,8 @@ export interface ChangeContext {
     planningHome?: PlanningHome;
     /** Parsed change metadata, when present */
     metadata?: ChangeMetadata;
+    /** Non-fatal metadata diagnostics for text and JSON command surfaces */
+    warnings?: string[];
     /**
      * Artifact IDs counted as complete only because the change declares
      * skip_specs, not because their files exist. Kept separate so status can
@@ -85,6 +87,8 @@ export interface ArtifactInstructions {
     skipped?: boolean;
     /** Present only when skipped: tells the consumer not to create the artifact */
     warning?: string;
+    /** Non-fatal metadata diagnostics */
+    warnings?: string[];
 }
 /**
  * Warning attached to instructions for an artifact skipped via skip_specs.
@@ -152,6 +156,8 @@ export interface ChangeStatus {
     applyRequires: string[];
     /** Status of each artifact */
     artifacts: ArtifactStatus[];
+    /** Non-fatal metadata diagnostics */
+    warnings?: string[];
 }
 export interface ArtifactPathSummary {
     outputPath: string;
@@ -211,5 +217,6 @@ export declare function generateInstructions(context: ChangeContext, artifactId:
  */
 export declare function formatChangeStatus(context: ChangeContext, options?: {
     storeId?: string;
+    implementationRoot?: string;
 }): ChangeStatus;
 //# sourceMappingURL=instruction-loader.d.ts.map

package/dist/core/artifact-graph/instruction-loader.js

@@ -4,7 +4,7 @@ import { getSchemaDir, resolveSchema, listSchemasWithInfo } from './resolver.js'
 import { ArtifactGraph } from './graph.js';
 import { detectCompleted } from './state.js';
 import { isSpecsArtifactPath, resolveArtifactOutputPath, resolveArtifactOutputs, } from './outputs.js';
-import { readChangeMetadata, resolveSchemaForChange } from '../../utils/change-metadata.js';
+import { formatUnknownChangeMetadataKeysMessage, readChangeMetadata, readUnknownChangeMetadataKeys, resolveSchemaForChange, } from '../../utils/change-metadata.js';
 import { FileSystemUtils } from '../../utils/file-system.js';
 import { buildActionContext, buildNextSteps, summarizePlanningHome, } from '../change-status-policy.js';
 import { readProjectConfig, validateConfigRules } from '../project-config.js';
@@ -78,6 +78,10 @@ export function loadTemplate(schemaName, templatePath, projectRoot) {
 export function loadChangeContext(projectRoot, changeName, schemaName, options = {}) {
     const changeDir = FileSystemUtils.canonicalizeExistingPath(options.changeDir ?? path.join(projectRoot, 'openspec', 'changes', changeName));
     const metadata = readChangeMetadata(changeDir, projectRoot) ?? undefined;
+    const unknownMetadataKeys = readUnknownChangeMetadataKeys(changeDir);
+    const warnings = unknownMetadataKeys.length > 0
+        ? [formatUnknownChangeMetadataKeysMessage(unknownMetadataKeys)]
+        : [];
     const resolvedSchemaName = resolveSchemaForChange(changeDir, schemaName, projectRoot, {
         metadata: metadata ?? null,
         projectConfig: options.projectConfig,
@@ -107,6 +111,7 @@ export function loadChangeContext(projectRoot, changeName, schemaName, options =
         projectRoot,
         ...(options.planningHome ? { planningHome: options.planningHome } : {}),
         ...(metadata ? { metadata } : {}),
+        ...(warnings.length > 0 ? { warnings } : {}),
         ...(skippedArtifacts.size > 0 ? { skippedArtifacts } : {}),
     };
 }
@@ -164,6 +169,7 @@ export function generateInstructions(context, artifactId, projectRoot, options =
         context: configContext,
         rules: configRules,
         ...(options.references !== undefined ? { references: options.references } : {}),
+        ...(context.warnings ? { warnings: context.warnings } : {}),
         ...(context.skippedArtifacts?.has(artifact.id)
             ? { skipped: true, warning: SKIP_SPECS_INSTRUCTIONS_WARNING }
             : {}),
@@ -279,8 +285,19 @@ export function formatChangeStatus(context, options = {}) {
         actionContext: buildActionContext({
             projectRoot: context.projectRoot,
             artifactIds,
+            ...(options.storeId
+                ? {
+                    store: {
+                        id: options.storeId,
+                        ...(options.implementationRoot
+                            ? { implementationRoot: options.implementationRoot }
+                            : {}),
+                    },
+                }
+                : {}),
         }),
         artifacts: artifactStatuses,
+        ...(context.warnings ? { warnings: context.warnings } : {}),
     };
 }
 //# sourceMappingURL=instruction-loader.js.map

package/dist/core/change-metadata/schema.d.ts

@@ -5,6 +5,9 @@ export declare const InitiativeLinkSchema: z.ZodObject<{
     id: z.ZodString;
 }, z.core.$strict>;
 export type InitiativeLink = z.infer<typeof InitiativeLinkSchema>;
+/** Top-level keys ChangeMetadataSchema recognizes. Anything else is ignored. */
+export declare const CHANGE_METADATA_KNOWN_KEYS: readonly ["schema", "created", "goal", "affected_areas", "initiative", "skip_specs", "retire_capabilities"];
+export type ChangeMetadataKnownKey = (typeof CHANGE_METADATA_KNOWN_KEYS)[number];
 export declare const ChangeMetadataSchema: z.ZodObject<{
     schema: z.ZodString;
     created: z.ZodOptional<z.ZodString>;

package/dist/core/change-metadata/schema.js

@@ -13,6 +13,16 @@ export const InitiativeLinkSchema = z.object({
     store: KebabIdentifierSchema('Store id'),
     id: KebabIdentifierSchema('Initiative id'),
 }).strict();
+/** Top-level keys ChangeMetadataSchema recognizes. Anything else is ignored. */
+export const CHANGE_METADATA_KNOWN_KEYS = [
+    'schema',
+    'created',
+    'goal',
+    'affected_areas',
+    'initiative',
+    'skip_specs',
+    'retire_capabilities',
+];
 // Per-change metadata schema. The schema field is validated against available
 // workflow schemas when metadata is read or written.
 export const ChangeMetadataSchema = z.object({

package/dist/core/change-status-policy.d.ts

@@ -30,6 +30,14 @@ export interface ChangeNextStepsInput {
 export interface ActionContextInput {
     projectRoot: string;
     artifactIds: string[];
+    /**
+     * Set when the root is a store: the store holds the planning artifacts,
+     * and `implementationRoot` is the project that declares it, if any.
+     */
+    store?: {
+        id: string;
+        implementationRoot?: string;
+    };
 }
 export declare function summarizePlanningHome(planningHome: PlanningHome | undefined): PlanningHomeSummary | undefined;
 export declare function buildActionContext(input: ActionContextInput): ActionContext;

package/dist/core/change-status-policy.js

@@ -10,14 +10,45 @@ export function summarizePlanningHome(planningHome) {
     };
 }
 export function buildActionContext(input) {
+    const scope = editScope(input);
+    // Keys stay in the published contract order.
     return {
         mode: 'repo-local',
         sourceOfTruth: 'repo',
         planningArtifacts: input.artifactIds,
         linkedContext: [],
-        allowedEditRoots: [input.projectRoot],
+        allowedEditRoots: scope.allowedEditRoots,
         requiresAffectedAreaSelection: false,
-        constraints: ['Repo-local change artifacts and implementation edits are scoped to this project.'],
+        constraints: scope.constraints,
+    };
+}
+/**
+ * A store holds planning artifacts only. The CLI does not route tasks to
+ * repos, so it names the declaring project on the current path as the edit
+ * root and has the agent ask before going anywhere else (#2013).
+ */
+function editScope(input) {
+    if (!input.store) {
+        return {
+            allowedEditRoots: [input.projectRoot],
+            constraints: ['Repo-local change artifacts and implementation edits are scoped to this project.'],
+        };
+    }
+    const planning = `Change artifacts live in store '${input.store.id}' (${input.projectRoot}).`;
+    const { implementationRoot } = input.store;
+    if (implementationRoot) {
+        return {
+            allowedEditRoots: [implementationRoot, input.projectRoot],
+            constraints: [
+                `${planning} Implementation edits go in ${implementationRoot}, the project on the current path that declares this store; ask the user before editing any other repository.`,
+            ],
+        };
+    }
+    return {
+        allowedEditRoots: [input.projectRoot],
+        constraints: [
+            `${planning} OpenSpec could not determine which repository implements this change; ask the user which repository to edit, and make implementation edits there.`,
+        ],
     };
 }
 export function resolveNextStep(input) {

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

@@ -0,0 +1,24 @@
+/**
+ * AtomCode Command Adapter
+ *
+ * Formats project commands for AtomCode.
+ * https://github.com/atomgit-atomcode/atomcode#custom-commands
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * AtomCode adapter for command generation.
+ * File path: .atomcode/commands/opsx-<id>.md
+ * Frontmatter: name, description, args
+ *
+ * AtomCode's custom-command parser reads name and args literally without YAML
+ * unquoting, so these controlled identifiers must stay unquoted.
+ * The command name matches the filename.
+ *
+ * `args` mirrors what the workflow actually accepts. AtomCode executes an
+ * `args: none` command straight from the slash menu, while `optional` completes
+ * to `/name ` and waits for a second Enter. Advertising arguments a workflow
+ * never reads would cost every user that extra keystroke, so only workflows
+ * carrying an `**Input**:` contract declare `optional` and receive $ARGUMENTS.
+ */
+export declare const atomcodeAdapter: ToolCommandAdapter;
+//# sourceMappingURL=atomcode.d.ts.map

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

@@ -0,0 +1,46 @@
+/**
+ * AtomCode Command Adapter
+ *
+ * Formats project commands for AtomCode.
+ * https://github.com/atomgit-atomcode/atomcode#custom-commands
+ */
+import path from 'path';
+import { stringify } from 'yaml';
+/** A workflow declares its invocation input with an `**Input**:` heading. */
+const INPUT_HEADING = /^\*\*Input\*\*:/m;
+/**
+ * AtomCode adapter for command generation.
+ * File path: .atomcode/commands/opsx-<id>.md
+ * Frontmatter: name, description, args
+ *
+ * AtomCode's custom-command parser reads name and args literally without YAML
+ * unquoting, so these controlled identifiers must stay unquoted.
+ * The command name matches the filename.
+ *
+ * `args` mirrors what the workflow actually accepts. AtomCode executes an
+ * `args: none` command straight from the slash menu, while `optional` completes
+ * to `/name ` and waits for a second Enter. Advertising arguments a workflow
+ * never reads would cost every user that extra keystroke, so only workflows
+ * carrying an `**Input**:` contract declare `optional` and receive $ARGUMENTS.
+ */
+export const atomcodeAdapter = {
+    toolId: 'atomcode',
+    getFilePath(commandId) {
+        return path.join('.atomcode', 'commands', `opsx-${commandId}.md`);
+    },
+    formatFile(content) {
+        // Keep ordinary descriptions plain for the literal custom-command parser,
+        // while keeping special values valid YAML for frontmatter consumers.
+        const description = stringify({ description: content.description }, { lineWidth: 0, blockQuote: false });
+        const acceptsInput = INPUT_HEADING.test(content.body);
+        const argumentsBlock = acceptsInput ? '\n**Provided arguments**: $ARGUMENTS\n' : '';
+        return `---
+name: opsx-${content.id}
+${description}args: ${acceptsInput ? 'optional' : 'none'}
+---
+${argumentsBlock}
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=atomcode.js.map

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

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

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

@@ -0,0 +1,27 @@
+/**
+ * Code Studio Command Adapter
+ *
+ * Formats commands for Syncfusion Code Studio following its .prompt.md specification.
+ */
+import path from 'path';
+import { escapeYamlValue } from '../yaml.js';
+/**
+ * Code Studio adapter for command generation.
+ * File path: .codestudio/prompts/opsx-<id>.prompt.md
+ * Frontmatter: description
+ */
+export const codeStudioAdapter = {
+    toolId: 'codestudio',
+    getFilePath(commandId) {
+        return path.join('.codestudio', 'prompts', `opsx-${commandId}.prompt.md`);
+    },
+    formatFile(content) {
+        return `---
+description: ${escapeYamlValue(content.description)}
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=codestudio.js.map

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

@@ -0,0 +1,17 @@
+/**
+ * EasyCode Command Adapter
+ *
+ * Formats commands for OrionStarAI/EasyCode using its TOML command format.
+ * https://github.com/OrionStarAI/EasyCode
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * EasyCode adapter for command generation.
+ * File path: .easycode/commands/opsx/<id>.toml
+ *
+ * Format:
+ *   description = "<basic-string>"         single-line, backslash/quote-safe
+ *   prompt = """<multiline-string>"""       multiline, backslash/triple-quote-safe
+ */
+export declare const easycodeAdapter: ToolCommandAdapter;
+//# sourceMappingURL=easycode.d.ts.map

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

@@ -0,0 +1,28 @@
+/**
+ * EasyCode Command Adapter
+ *
+ * Formats commands for OrionStarAI/EasyCode using its TOML command format.
+ * https://github.com/OrionStarAI/EasyCode
+ */
+import path from 'path';
+import { escapeTomlBasicString, escapeTomlMultilineBasicString } from '../toml.js';
+/**
+ * EasyCode adapter for command generation.
+ * File path: .easycode/commands/opsx/<id>.toml
+ *
+ * Format:
+ *   description = "<basic-string>"         single-line, backslash/quote-safe
+ *   prompt = """<multiline-string>"""       multiline, backslash/triple-quote-safe
+ */
+export const easycodeAdapter = {
+    toolId: 'easycode',
+    getFilePath(commandId) {
+        return path.join('.easycode', 'commands', 'opsx', `${commandId}.toml`);
+    },
+    formatFile(content) {
+        const safeDesc = escapeTomlBasicString(content.description);
+        const safeBody = escapeTomlMultilineBasicString(content.body);
+        return `description = "${safeDesc}"\n\nprompt = """\n${safeBody}\n"""\n`;
+    },
+};
+//# sourceMappingURL=easycode.js.map

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

@@ -4,41 +4,7 @@
  * Formats commands for Gemini CLI following its TOML specification.
  */
 import path from 'path';
-/**
- * Control characters (C0 except tab/newline/carriage return, plus DEL) are
- * invalid inside TOML strings and must be written as escapes.
- */
-const TOML_CONTROL_CHARS = new RegExp('[\\u0000-\\u0008\\u000b\\u000c\\u000e-\\u001f\\u007f]', 'g');
-/**
- * TOML basic strings are escape-active: a backslash or double quote in the
- * value breaks the file if written raw. Newlines cannot appear in a
- * single-line basic string at all, so they are escaped too.
- */
-function escapeTomlBasicString(value) {
-    return value
-        .replace(/\\/g, '\\\\')
-        .replace(/"/g, '\\"')
-        .replace(/\n/g, '\\n')
-        .replace(/\r/g, '\\r')
-        .replace(/\t/g, '\\t')
-        .replace(TOML_CONTROL_CHARS, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, '0')}`);
-}
-/**
- * Multiline basic strings keep raw newlines and tabs, but backslashes are
- * still escape-active, any run of three quotes would end the string, and the
- * same control characters are invalid as in single-line basic strings — a
- * lone carriage return included (only LF and CRLF may appear raw; CRLF is
- * normalized away so the emitted file is single-convention). Escapes are
- * introduced after backslash-doubling so they are not re-doubled.
- */
-function escapeTomlMultilineBasicString(value) {
-    return value
-        .replace(/\r\n/g, '\n')
-        .replace(/\\/g, '\\\\')
-        .replace(/"""/g, '""\\"')
-        .replace(/\r/g, '\\r')
-        .replace(TOML_CONTROL_CHARS, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, '0')}`);
-}
+import { escapeTomlBasicString, escapeTomlMultilineBasicString } from '../toml.js';
 /**
  * Gemini adapter for command generation.
  * File path: .gemini/commands/opsx/<id>.toml

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

@@ -0,0 +1,17 @@
+/**
+ * GigaCode Command Adapter
+ *
+ * Formats commands for GigaCode using its Markdown custom command format.
+ * Project commands live in `.gigacode/commands/` and accept an optional
+ * `description` field in YAML frontmatter.
+ *
+ * @see https://gitverse.ru/docs/ai/ai-assistant-gigacode/gigacode-cli/commands
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * GigaCode adapter for command generation.
+ * File path: .gigacode/commands/opsx-<id>.md
+ * Format: Markdown with description frontmatter
+ */
+export declare const gigacodeAdapter: ToolCommandAdapter;
+//# sourceMappingURL=gigacode.d.ts.map

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

@@ -0,0 +1,31 @@
+/**
+ * GigaCode Command Adapter
+ *
+ * Formats commands for GigaCode using its Markdown custom command format.
+ * Project commands live in `.gigacode/commands/` and accept an optional
+ * `description` field in YAML frontmatter.
+ *
+ * @see https://gitverse.ru/docs/ai/ai-assistant-gigacode/gigacode-cli/commands
+ */
+import path from 'path';
+import { escapeYamlValue } from '../yaml.js';
+/**
+ * GigaCode adapter for command generation.
+ * File path: .gigacode/commands/opsx-<id>.md
+ * Format: Markdown with description frontmatter
+ */
+export const gigacodeAdapter = {
+    toolId: 'gigacode',
+    getFilePath(commandId) {
+        return path.join('.gigacode', 'commands', `opsx-${commandId}.md`);
+    },
+    formatFile(content) {
+        return `---
+description: ${escapeYamlValue(content.description)}
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=gigacode.js.map