@fission-ai/openspec 1.13.2 → 1.14.0

package/dist/cli/index.js

@@ -7,7 +7,7 @@ import { fileURLToPath } from 'url';
 import { existsSync, promises as fs } from 'fs';
 import { AI_TOOLS, TOOL_ID_ALIASES } from '../core/config.js';
 import { UpdateCommand } from '../core/update.js';
-import { getAvailableCliUpdate, displayCliUpdateNote, shouldOfferUpgrade, getInstallDir, offerCliUpgrade, rerunUpdateWithUpgradedCli, displayUpgradeCommand, isSourceCheckout, } from '../core/version-check.js';
+import { getAvailableCliUpdate, displayCliUpdateNote, shouldOfferUpgrade, getInstallDir, offerCliUpgrade, rerunUpdateWithUpgradedCli, displayUpgradeCommand, isSourceCheckout, checkForCliUpdate, getCliInstallInfo, getCliUpdateCommand, canSelfUpgrade, buildVersionReportLines, } from '../core/version-check.js';
 import { ListCommand } from '../core/list.js';
 import { ArchiveCommand } from '../core/archive.js';
 import { ViewCommand } from '../core/view.js';
@@ -118,6 +118,37 @@ program
     .version(version);
 // Global options
 program.option('--no-color', 'Disable color output');
+program
+    .command('version')
+    .description('Report the installed OpenSpec version and update availability')
+    .option('--json', 'Output as JSON')
+    .option('--check', 'Check the registry for a newer version')
+    .action(async (options) => {
+    const install = getCliInstallInfo();
+    const update = options.check ? await checkForCliUpdate() : undefined;
+    const command = update?.status === 'available' ? getCliUpdateCommand(install) : null;
+    const output = {
+        schemaVersion: 1,
+        version,
+        install,
+        ...(update
+            ? {
+                update: {
+                    ...update,
+                    command,
+                    canSelfUpgrade: update.status === 'available'
+                        ? canSelfUpgrade(install.location, process.cwd())
+                        : false,
+                },
+            }
+            : {}),
+    };
+    if (options.json) {
+        console.log(JSON.stringify(output, null, 2));
+        return;
+    }
+    console.log(buildVersionReportLines(version, install, update, command).join('\n'));
+});
 // Apply global flags and telemetry before any command runs
 // Note: preAction receives (thisCommand, actionCommand) where:
 // - thisCommand: the command where hook was added (root program)
@@ -296,12 +327,17 @@ program
     .description('List items (changes by default). Use --specs to list specs.')
     .option('--specs', 'List specs instead of changes')
     .option('--changes', 'List changes explicitly (default)')
+    .option('--archived', 'Show only archived changes')
+    .option('--all', 'Show both active and archived changes')
     .option('--sort <order>', 'Sort order: "recent" (default) or "name"', 'recent')
     .option('--json', 'Output as JSON (for programmatic use)')
     .option('--store <id>', STORE_OPTION_DESCRIPTION)
     .addOption(hiddenStorePathOption())
     .action(async (options) => {
     try {
+        if (options?.specs && (options.archived || options.all)) {
+            throw new Error('--archived and --all can only be used when listing changes.');
+        }
         const root = await resolveRootForCommand(options ?? {}, {
             json: options?.json,
             failurePayload: options?.specs ? { specs: [], root: null } : { changes: [], root: null },
@@ -318,6 +354,8 @@ program
         await listCommand.execute(root.path, mode, {
             sort,
             json: options?.json,
+            archived: options?.archived,
+            all: options?.all,
             ...(options?.json ? { root: toRootOutput(root) } : {}),
         });
     }

package/dist/commands/spec.js

@@ -45,6 +45,7 @@ function filterSpec(spec, options) {
     const filteredRequirements = (requirementIndex !== undefined
         ? [spec.requirements[requirementIndex]]
         : spec.requirements).map(req => ({
+        name: req.name,
         text: req.text,
         scenarios: includeScenarios ? req.scenarios : [],
     }));

package/dist/commands/workflow/instructions.js

@@ -103,6 +103,14 @@ export function printInstructionsText(instructions, isBlocked) {
         ` change="${escapeEnvelopeAttribute(changeName)}"` +
         ` schema="${escapeEnvelopeAttribute(schemaName)}">`);
     console.log();
+    if (instructions.warnings) {
+        for (const warning of instructions.warnings) {
+            console.log('<warning>');
+            console.log(escapeEnvelopeTags(warning));
+            console.log('</warning>');
+            console.log();
+        }
+    }
     // Artifacts skipped via skip_specs get no creation directive: emitting the
     // task/template anyway would prompt an agent to write spec files that
     // validate then rejects as conflicting with the marker.
@@ -215,9 +223,16 @@ export function printInstructionsText(instructions, isBlocked) {
     // Closing tag
     console.log('</artifact>');
 }
-// -----------------------------------------------------------------------------
-// Apply Instructions Command
-// -----------------------------------------------------------------------------
+/** Adds one-based source locations to parsed tasks without changing task parsing. */
+function parseLocatedTasks(content, sourcePath) {
+    const tasks = [];
+    for (const [index, line] of content.split('\n').entries()) {
+        const [task] = parseTaskLines(line);
+        if (task)
+            tasks.push({ ...task, sourcePath, line: index + 1 });
+    }
+    return tasks;
+}
 /**
  * Turns parsed task lines into the listed task items.
  *
@@ -238,6 +253,8 @@ function toTaskItems(parsed) {
             id: `${tasks.length + 1}`,
             description: task.description,
             done: task.done,
+            sourcePath: task.sourcePath,
+            line: task.line,
         });
     }
     return tasks;
@@ -406,7 +423,7 @@ export async function generateApplyInstructions(projectRoot, changeName, schemaN
         for (const tracksPath of tracksPaths) {
             try {
                 const tasksContent = await fs.promises.readFile(tracksPath, 'utf-8');
-                parsedTasks.push(...parseTaskLines(tasksContent));
+                parsedTasks.push(...parseLocatedTasks(tasksContent, tracksPath));
             }
             catch (error) {
                 const code = error?.code;
@@ -483,13 +500,16 @@ export async function generateApplyInstructions(projectRoot, changeName, schemaN
             .join('\n');
         instruction += `\nTask completion is not verified because tracking evidence was unavailable:\n${unavailableDetails}`;
     }
-    const warnings = await collectApplyWarnings({
-        state,
-        schema,
-        changeDir,
-        changeName,
-        skippedArtifacts: context.skippedArtifacts,
-    });
+    const warnings = [
+        ...(context.warnings ?? []),
+        ...(await collectApplyWarnings({
+            state,
+            schema,
+            changeDir,
+            changeName,
+            skippedArtifacts: context.skippedArtifacts,
+        })),
+    ];
     return {
         changeName,
         changeDir,

package/dist/commands/workflow/shared.d.ts

@@ -16,6 +16,8 @@ export interface TaskItem {
     id: string;
     description: string;
     done: boolean;
+    sourcePath: string;
+    line: number;
 }
 export interface ApplyInstructions {
     changeName: string;

package/dist/commands/workflow/status.js

@@ -6,7 +6,7 @@
 import ora from 'ora';
 import chalk from 'chalk';
 import { getChangeDir } from '../../core/planning-home.js';
-import { resolveRootForCommand, toPlanningHome, toRootOutput, withStoreFlag, isStoreSelectedRoot, } from '../../core/root-selection.js';
+import { resolveRootForCommand, toPlanningHome, toRootOutput, withStoreFlag, isStoreSelectedRoot, findDeclaringProjectRoot, } from '../../core/root-selection.js';
 import { loadChangeContext, formatChangeStatus, } from '../../core/artifact-graph/index.js';
 import { resolveNextStep } from '../../core/change-status-policy.js';
 import { asStatus } from '../shared-output.js';
@@ -43,12 +43,20 @@ export async function statusCommand(options) {
         // `Next:` line, so a store-selected root can never carry `--store` in one
         // and drop it from the other.
         const storeOptions = isStoreSelectedRoot(root) ? { storeId: root.storeId } : {};
+        // A store holds planning artifacts only; the project declaring it is
+        // where implementation edits go (#2013).
+        const implementationRoot = isStoreSelectedRoot(root)
+            ? findDeclaringProjectRoot(root.storeId)
+            : null;
+        const statusOptions = implementationRoot
+            ? { ...storeOptions, implementationRoot }
+            : storeOptions;
         // Single definition of "load one change's status" so the batch and
         // single-change payloads can never drift apart.
         const loadStatus = (changeName) => formatChangeStatus(loadChangeContext(projectRoot, changeName, options.schema, {
             changeDir: getChangeDir(planningHome, changeName),
             planningHome,
-        }), storeOptions);
+        }), statusOptions);
         // Handle no-changes case gracefully — status is informational,
         // so "no changes" is a valid state, not an error.
         if (!options.change) {
@@ -157,6 +165,11 @@ export function printStatusText(status, options = {}) {
     const total = status.artifacts.length - skippedCount;
     console.log(`Change: ${status.changeName}`);
     console.log(`Schema: ${status.schemaName}`);
+    if (status.warnings) {
+        for (const warning of status.warnings) {
+            console.log(chalk.yellow(`Warning: ${warning}`));
+        }
+    }
     if (status.changeRoot) {
         console.log(`Change root: ${status.changeRoot}`);
     }

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';
@@ -1125,6 +1125,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) {
@@ -1827,7 +1834,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