@fission-ai/openspec 1.2.0 → 1.3.1

package/README.md

@@ -36,27 +36,20 @@ Our philosophy:
 > [!TIP]
 > **New workflow now available!** We've rebuilt OpenSpec with a new artifact-guided workflow.
 >
-> Run `/opsx:onboard` to get started. → [Learn more here](docs/opsx.md)
+> Run `/opsx:propose "your idea"` to get started. → [Learn more here](docs/opsx.md)
 
 <p align="center">
   Follow <a href="https://x.com/0xTab">@0xTab on X</a> for updates · Join the <a href="https://discord.gg/YctCnvvshC">OpenSpec Discord</a> for help and questions.
 </p>
 
-### Teams
-
-Using OpenSpec in a team? [Email here](mailto:teams@openspec.dev) for access to our Slack channel.
-
-<!-- TODO: Add GIF demo of /opsx:new → /opsx:archive workflow -->
+<!-- TODO: Add GIF demo of /opsx:propose → /opsx:archive workflow -->
 
 ## See it in action
 
 ```text
-You: /opsx:new add-dark-mode
+You: /opsx:propose add-dark-mode
 AI:  Created openspec/changes/add-dark-mode/
-     Ready to create: proposal
-
-You: /opsx:ff   # "fast-forward" - generate all planning docs
-AI:  ✓ proposal.md — why we're doing this, what's changing
+     ✓ proposal.md — why we're doing this, what's changing
      ✓ specs/       — requirements and scenarios
      ✓ design.md    — technical approach
      ✓ tasks.md     — implementation checklist
@@ -101,10 +94,12 @@ cd your-project
 openspec init
 ```
 
-Now tell your AI: `/opsx:new <what-you-want-to-build>`
+Now tell your AI: `/opsx:propose <what-you-want-to-build>`
+
+If you want the expanded workflow (`/opsx:new`, `/opsx:continue`, `/opsx:ff`, `/opsx:verify`, `/opsx:sync`, `/opsx:bulk-archive`, `/opsx:onboard`), select it with `openspec config profile` and apply with `openspec update`.
 
 > [!NOTE]
-> Not sure if your tool is supported? [View the full list](docs/supported-tools.md) – we support 20+ tools and growing.
+> Not sure if your tool is supported? [View the full list](docs/supported-tools.md) – we support 25+ tools and growing.
 >
 > Also works with pnpm, yarn, bun, and nix. [See installation options](docs/installation.md).
 

package/dist/commands/workflow/instructions.js

@@ -7,13 +7,13 @@
 import ora from 'ora';
 import path from 'path';
 import * as fs from 'fs';
-import { loadChangeContext, generateInstructions, resolveSchema, } from '../../core/artifact-graph/index.js';
+import { loadChangeContext, generateInstructions, resolveSchema, resolveArtifactOutputs, } from '../../core/artifact-graph/index.js';
 import { validateChangeExists, validateSchemaExists, } from './shared.js';
 // -----------------------------------------------------------------------------
 // Artifact Instructions Command
 // -----------------------------------------------------------------------------
 export async function instructionsCommand(artifactId, options) {
-    const spinner = ora('Generating instructions...').start();
+    const spinner = options.json ? undefined : ora('Generating instructions...').start();
     try {
         const projectRoot = process.cwd();
         const changeName = await validateChangeExists(options.change, projectRoot);
@@ -24,19 +24,19 @@ export async function instructionsCommand(artifactId, options) {
         // loadChangeContext will auto-detect schema from metadata if not provided
         const context = loadChangeContext(projectRoot, changeName, options.schema);
         if (!artifactId) {
-            spinner.stop();
+            spinner?.stop();
             const validIds = context.graph.getAllArtifacts().map((a) => a.id);
             throw new Error(`Missing required argument <artifact>. Valid artifacts:\n  ${validIds.join('\n  ')}`);
         }
         const artifact = context.graph.getArtifact(artifactId);
         if (!artifact) {
-            spinner.stop();
+            spinner?.stop();
             const validIds = context.graph.getAllArtifacts().map((a) => a.id);
             throw new Error(`Artifact '${artifactId}' not found in schema '${context.schemaName}'. Valid artifacts:\n  ${validIds.join('\n  ')}`);
         }
         const instructions = generateInstructions(context, artifactId, projectRoot);
         const isBlocked = instructions.dependencies.some((d) => !d.done);
-        spinner.stop();
+        spinner?.stop();
         if (options.json) {
             console.log(JSON.stringify(instructions, null, 2));
             return;
@@ -44,7 +44,7 @@ export async function instructionsCommand(artifactId, options) {
         printInstructionsText(instructions, isBlocked);
     }
     catch (error) {
-        spinner.stop();
+        spinner?.stop();
         throw error;
     }
 }
@@ -161,63 +161,6 @@ function parseTasksFile(content) {
     }
     return tasks;
 }
-/**
- * Checks if an artifact output exists in the change directory.
- * Supports glob patterns (e.g., "specs/*.md") by verifying at least one matching file exists.
- */
-function artifactOutputExists(changeDir, generates) {
-    // Normalize the generates path to use platform-specific separators
-    const normalizedGenerates = generates.split('/').join(path.sep);
-    const fullPath = path.join(changeDir, normalizedGenerates);
-    // If it's a glob pattern (contains ** or *), check for matching files
-    if (generates.includes('*')) {
-        // Extract the directory part before the glob pattern
-        const parts = normalizedGenerates.split(path.sep);
-        const dirParts = [];
-        let patternPart = '';
-        for (const part of parts) {
-            if (part.includes('*')) {
-                patternPart = part;
-                break;
-            }
-            dirParts.push(part);
-        }
-        const dirPath = path.join(changeDir, ...dirParts);
-        // Check if directory exists
-        if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) {
-            return false;
-        }
-        // Extract expected extension from pattern (e.g., "*.md" -> ".md")
-        const extMatch = patternPart.match(/\*(\.[a-zA-Z0-9]+)$/);
-        const expectedExt = extMatch ? extMatch[1] : null;
-        // Recursively check for matching files
-        const hasMatchingFiles = (dir) => {
-            try {
-                const entries = fs.readdirSync(dir, { withFileTypes: true });
-                for (const entry of entries) {
-                    if (entry.isDirectory()) {
-                        // For ** patterns, recurse into subdirectories
-                        if (generates.includes('**') && hasMatchingFiles(path.join(dir, entry.name))) {
-                            return true;
-                        }
-                    }
-                    else if (entry.isFile()) {
-                        // Check if file matches expected extension (or any file if no extension specified)
-                        if (!expectedExt || entry.name.endsWith(expectedExt)) {
-                            return true;
-                        }
-                    }
-                }
-            }
-            catch {
-                return false;
-            }
-            return false;
-        };
-        return hasMatchingFiles(dirPath);
-    }
-    return fs.existsSync(fullPath);
-}
 /**
  * Generates apply instructions for implementing tasks from a change.
  * Schema-aware: reads apply phase configuration from schema to determine
@@ -226,7 +169,7 @@ function artifactOutputExists(changeDir, generates) {
 export async function generateApplyInstructions(projectRoot, changeName, schemaName) {
     // loadChangeContext will auto-detect schema from metadata if not provided
     const context = loadChangeContext(projectRoot, changeName, schemaName);
-    const changeDir = path.join(projectRoot, 'openspec', 'changes', changeName);
+    const changeDir = context.changeDir;
     // Get the full schema to access the apply phase configuration
     const schema = resolveSchema(context.schemaName, projectRoot);
     const applyConfig = schema.apply;
@@ -239,15 +182,16 @@ export async function generateApplyInstructions(projectRoot, changeName, schemaN
     const missingArtifacts = [];
     for (const artifactId of requiredArtifactIds) {
         const artifact = schema.artifacts.find((a) => a.id === artifactId);
-        if (artifact && !artifactOutputExists(changeDir, artifact.generates)) {
+        if (artifact && resolveArtifactOutputs(changeDir, artifact.generates).length === 0) {
             missingArtifacts.push(artifactId);
         }
     }
     // Build context files from all existing artifacts in schema
     const contextFiles = {};
     for (const artifact of schema.artifacts) {
-        if (artifactOutputExists(changeDir, artifact.generates)) {
-            contextFiles[artifact.id] = path.join(changeDir, artifact.generates);
+        const outputs = resolveArtifactOutputs(changeDir, artifact.generates);
+        if (outputs.length > 0) {
+            contextFiles[artifact.id] = outputs;
         }
     }
     // Parse tasks if tracking file exists
@@ -310,7 +254,7 @@ export async function generateApplyInstructions(projectRoot, changeName, schemaN
     };
 }
 export async function applyInstructionsCommand(options) {
-    const spinner = ora('Generating apply instructions...').start();
+    const spinner = options.json ? undefined : ora('Generating apply instructions...').start();
     try {
         const projectRoot = process.cwd();
         const changeName = await validateChangeExists(options.change, projectRoot);
@@ -320,7 +264,7 @@ export async function applyInstructionsCommand(options) {
         }
         // generateApplyInstructions uses loadChangeContext which auto-detects schema
         const instructions = await generateApplyInstructions(projectRoot, changeName, options.schema);
-        spinner.stop();
+        spinner?.stop();
         if (options.json) {
             console.log(JSON.stringify(instructions, null, 2));
             return;
@@ -328,7 +272,7 @@ export async function applyInstructionsCommand(options) {
         printApplyInstructionsText(instructions);
     }
     catch (error) {
-        spinner.stop();
+        spinner?.stop();
         throw error;
     }
 }
@@ -349,8 +293,10 @@ export function printApplyInstructionsText(instructions) {
     const contextFileEntries = Object.entries(contextFiles);
     if (contextFileEntries.length > 0) {
         console.log('### Context Files');
-        for (const [artifactId, filePath] of contextFileEntries) {
-            console.log(`- ${artifactId}: ${filePath}`);
+        for (const [artifactId, filePaths] of contextFileEntries) {
+            for (const filePath of filePaths) {
+                console.log(`- ${artifactId}: ${filePath}`);
+            }
         }
         console.log();
     }

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

@@ -13,7 +13,7 @@ export interface ApplyInstructions {
     changeName: string;
     changeDir: string;
     schemaName: string;
-    contextFiles: Record<string, string>;
+    contextFiles: Record<string, string[]>;
     progress: {
         total: number;
         complete: number;
@@ -37,6 +37,11 @@ export declare function getStatusColor(status: 'done' | 'ready' | 'blocked'): (t
  * Gets the status indicator for an artifact.
  */
 export declare function getStatusIndicator(status: 'done' | 'ready' | 'blocked'): string;
+/**
+ * Returns the list of available change directory names under openspec/changes/.
+ * Excludes the archive directory and hidden directories.
+ */
+export declare function getAvailableChanges(projectRoot: string): Promise<string[]>;
 /**
  * Validates that a change exists and returns available changes if not.
  * Checks directory existence directly to support scaffolded changes (without proposal.md).

package/dist/commands/workflow/shared.js

@@ -52,26 +52,31 @@ export function getStatusIndicator(status) {
             return color('[-]');
     }
 }
+/**
+ * Returns the list of available change directory names under openspec/changes/.
+ * Excludes the archive directory and hidden directories.
+ */
+export async function getAvailableChanges(projectRoot) {
+    const changesPath = path.join(projectRoot, 'openspec', 'changes');
+    try {
+        const entries = await fs.promises.readdir(changesPath, { withFileTypes: true });
+        return entries
+            .filter((e) => e.isDirectory() && e.name !== 'archive' && !e.name.startsWith('.'))
+            .map((e) => e.name);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+}
 /**
  * Validates that a change exists and returns available changes if not.
  * Checks directory existence directly to support scaffolded changes (without proposal.md).
  */
 export async function validateChangeExists(changeName, projectRoot) {
-    const changesPath = path.join(projectRoot, 'openspec', 'changes');
-    // Get all change directories (not just those with proposal.md)
-    const getAvailableChanges = async () => {
-        try {
-            const entries = await fs.promises.readdir(changesPath, { withFileTypes: true });
-            return entries
-                .filter((e) => e.isDirectory() && e.name !== 'archive' && !e.name.startsWith('.'))
-                .map((e) => e.name);
-        }
-        catch {
-            return [];
-        }
-    };
     if (!changeName) {
-        const available = await getAvailableChanges();
+        const available = await getAvailableChanges(projectRoot);
         if (available.length === 0) {
             throw new Error('No changes found. Create one with: openspec new change <name>');
         }
@@ -83,10 +88,10 @@ export async function validateChangeExists(changeName, projectRoot) {
         throw new Error(`Invalid change name '${changeName}': ${nameValidation.error}`);
     }
     // Check directory existence directly
-    const changePath = path.join(changesPath, changeName);
+    const changePath = path.join(projectRoot, 'openspec', 'changes', changeName);
     const exists = fs.existsSync(changePath) && fs.statSync(changePath).isDirectory();
     if (!exists) {
-        const available = await getAvailableChanges();
+        const available = await getAvailableChanges(projectRoot);
         if (available.length === 0) {
             throw new Error(`Change '${changeName}' not found. No changes exist. Create one with: openspec new change <name>`);
         }

package/dist/commands/workflow/status.js

@@ -6,14 +6,31 @@
 import ora from 'ora';
 import chalk from 'chalk';
 import { loadChangeContext, formatChangeStatus, } from '../../core/artifact-graph/index.js';
-import { validateChangeExists, validateSchemaExists, getStatusIndicator, getStatusColor, } from './shared.js';
+import { validateChangeExists, validateSchemaExists, getAvailableChanges, getStatusIndicator, getStatusColor, } from './shared.js';
 // -----------------------------------------------------------------------------
 // Command Implementation
 // -----------------------------------------------------------------------------
 export async function statusCommand(options) {
-    const spinner = ora('Loading change status...').start();
+    const spinner = options.json ? undefined : ora('Loading change status...').start();
     try {
         const projectRoot = process.cwd();
+        // Handle no-changes case gracefully — status is informational,
+        // so "no changes" is a valid state, not an error.
+        if (!options.change) {
+            const available = await getAvailableChanges(projectRoot);
+            if (available.length === 0) {
+                spinner?.stop();
+                if (options.json) {
+                    console.log(JSON.stringify({ changes: [], message: 'No active changes.' }, null, 2));
+                    return;
+                }
+                console.log('No active changes. Create one with: openspec new change <name>');
+                return;
+            }
+            // Changes exist but --change not provided
+            spinner?.stop();
+            throw new Error(`Missing required option --change. Available changes:\n  ${available.join('\n  ')}`);
+        }
         const changeName = await validateChangeExists(options.change, projectRoot);
         // Validate schema if explicitly provided
         if (options.schema) {
@@ -22,7 +39,7 @@ export async function statusCommand(options) {
         // loadChangeContext will auto-detect schema from metadata if not provided
         const context = loadChangeContext(projectRoot, changeName, options.schema);
         const status = formatChangeStatus(context);
-        spinner.stop();
+        spinner?.stop();
         if (options.json) {
             console.log(JSON.stringify(status, null, 2));
             return;
@@ -30,7 +47,7 @@ export async function statusCommand(options) {
         printStatusText(status);
     }
     catch (error) {
-        spinner.stop();
+        spinner?.stop();
         throw error;
     }
 }

package/dist/commands/workflow/templates.js

@@ -6,12 +6,13 @@
 import ora from 'ora';
 import path from 'path';
 import { resolveSchema, getSchemaDir, ArtifactGraph, } from '../../core/artifact-graph/index.js';
+import { FileSystemUtils } from '../../utils/file-system.js';
 import { validateSchemaExists, DEFAULT_SCHEMA } from './shared.js';
 // -----------------------------------------------------------------------------
 // Command Implementation
 // -----------------------------------------------------------------------------
 export async function templatesCommand(options) {
-    const spinner = ora('Loading templates...').start();
+    const spinner = options.json ? undefined : ora('Loading templates...').start();
     try {
         const projectRoot = process.cwd();
         const schemaName = validateSchemaExists(options.schema ?? DEFAULT_SCHEMA, projectRoot);
@@ -40,10 +41,10 @@ export async function templatesCommand(options) {
         }
         const templates = graph.getAllArtifacts().map((artifact) => ({
             artifactId: artifact.id,
-            templatePath: path.join(schemaDir, 'templates', artifact.template),
+            templatePath: FileSystemUtils.canonicalizeExistingPath(path.join(schemaDir, 'templates', artifact.template)),
             source,
         }));
-        spinner.stop();
+        spinner?.stop();
         if (options.json) {
             const output = {};
             for (const t of templates) {
@@ -61,7 +62,7 @@ export async function templatesCommand(options) {
         }
     }
     catch (error) {
-        spinner.stop();
+        spinner?.stop();
         throw error;
     }
 }

package/dist/core/artifact-graph/index.d.ts

@@ -2,6 +2,7 @@ export { ArtifactSchema, SchemaYamlSchema, type Artifact, type SchemaYaml, type
 export { loadSchema, parseSchema, SchemaValidationError } from './schema.js';
 export { ArtifactGraph } from './graph.js';
 export { detectCompleted } from './state.js';
+export { artifactOutputExists, isGlobPattern, resolveArtifactOutputs } from './outputs.js';
 export { resolveSchema, listSchemas, listSchemasWithInfo, getSchemaDir, getPackageSchemasDir, getUserSchemasDir, SchemaLoadError, type SchemaInfo, } from './resolver.js';
 export { loadTemplate, loadChangeContext, generateInstructions, formatChangeStatus, TemplateLoadError, type ChangeContext, type ArtifactInstructions, type DependencyInfo, type ArtifactStatus, type ChangeStatus, } from './instruction-loader.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/artifact-graph/index.js

@@ -6,6 +6,7 @@ export { loadSchema, parseSchema, SchemaValidationError } from './schema.js';
 export { ArtifactGraph } from './graph.js';
 // State detection
 export { detectCompleted } from './state.js';
+export { artifactOutputExists, isGlobPattern, resolveArtifactOutputs } from './outputs.js';
 // Schema resolution
 export { resolveSchema, listSchemas, listSchemasWithInfo, getSchemaDir, getPackageSchemasDir, getUserSchemasDir, SchemaLoadError, } from './resolver.js';
 // Instruction loading

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

@@ -4,6 +4,7 @@ import { getSchemaDir, resolveSchema } from './resolver.js';
 import { ArtifactGraph } from './graph.js';
 import { detectCompleted } from './state.js';
 import { resolveSchemaForChange } from '../../utils/change-metadata.js';
+import { FileSystemUtils } from '../../utils/file-system.js';
 import { readProjectConfig, validateConfigRules } from '../project-config.js';
 // Session-level cache for validation warnings (avoid repeating same warnings)
 const shownWarnings = new Set();
@@ -32,10 +33,11 @@ export function loadTemplate(schemaName, templatePath, projectRoot) {
     if (!schemaDir) {
         throw new TemplateLoadError(`Schema '${schemaName}' not found`, templatePath);
     }
-    const fullPath = path.join(schemaDir, 'templates', templatePath);
-    if (!fs.existsSync(fullPath)) {
-        throw new TemplateLoadError(`Template not found: ${fullPath}`, fullPath);
+    const templatePathOnDisk = path.join(schemaDir, 'templates', templatePath);
+    if (!fs.existsSync(templatePathOnDisk)) {
+        throw new TemplateLoadError(`Template not found: ${templatePathOnDisk}`, templatePathOnDisk);
     }
+    const fullPath = FileSystemUtils.canonicalizeExistingPath(templatePathOnDisk);
     try {
         return fs.readFileSync(fullPath, 'utf-8');
     }
@@ -58,7 +60,7 @@ export function loadTemplate(schemaName, templatePath, projectRoot) {
  * @returns Change context with graph, completed set, and metadata
  */
 export function loadChangeContext(projectRoot, changeName, schemaName) {
-    const changeDir = path.join(projectRoot, 'openspec', 'changes', changeName);
+    const changeDir = FileSystemUtils.canonicalizeExistingPath(path.join(projectRoot, 'openspec', 'changes', changeName));
     // Resolve schema: explicit > metadata > default
     const resolvedSchemaName = resolveSchemaForChange(changeDir, schemaName);
     const schema = resolveSchema(resolvedSchemaName, projectRoot);

package/dist/core/artifact-graph/outputs.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Checks if a path contains glob pattern characters.
+ */
+export declare function isGlobPattern(pattern: string): boolean;
+/**
+ * Resolves an artifact's output path(s) to concrete files that currently exist.
+ * Returns absolute file paths. Glob matches are sorted for deterministic output.
+ */
+export declare function resolveArtifactOutputs(changeDir: string, generates: string): string[];
+/**
+ * Checks if an artifact has at least one resolved output file.
+ */
+export declare function artifactOutputExists(changeDir: string, generates: string): boolean;
+//# sourceMappingURL=outputs.d.ts.map

package/dist/core/artifact-graph/outputs.js

@@ -0,0 +1,39 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import fg from 'fast-glob';
+import { FileSystemUtils } from '../../utils/file-system.js';
+/**
+ * Checks if a path contains glob pattern characters.
+ */
+export function isGlobPattern(pattern) {
+    return pattern.includes('*') || pattern.includes('?') || pattern.includes('[');
+}
+/**
+ * Resolves an artifact's output path(s) to concrete files that currently exist.
+ * Returns absolute file paths. Glob matches are sorted for deterministic output.
+ */
+export function resolveArtifactOutputs(changeDir, generates) {
+    if (!isGlobPattern(generates)) {
+        const fullPath = path.join(changeDir, generates);
+        try {
+            return fs.statSync(fullPath).isFile()
+                ? [FileSystemUtils.canonicalizeExistingPath(fullPath)]
+                : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    const normalizedPattern = FileSystemUtils.toPosixPath(generates);
+    const matches = fg
+        .sync(normalizedPattern, { cwd: changeDir, onlyFiles: true, absolute: true })
+        .map((match) => FileSystemUtils.canonicalizeExistingPath(path.normalize(match)));
+    return Array.from(new Set(matches)).sort();
+}
+/**
+ * Checks if an artifact has at least one resolved output file.
+ */
+export function artifactOutputExists(changeDir, generates) {
+    return resolveArtifactOutputs(changeDir, generates).length > 0;
+}
+//# sourceMappingURL=outputs.js.map

package/dist/core/artifact-graph/state.js

@@ -1,7 +1,5 @@
 import * as fs from 'node:fs';
-import * as path from 'node:path';
-import fg from 'fast-glob';
-import { FileSystemUtils } from '../../utils/file-system.js';
+import { artifactOutputExists } from './outputs.js';
 /**
  * Detects which artifacts are completed by checking file existence in the change directory.
  * Returns a Set of completed artifact IDs.
@@ -28,27 +26,6 @@ export function detectCompleted(graph, changeDir) {
  * Supports both simple paths and glob patterns.
  */
 function isArtifactComplete(generates, changeDir) {
-    const fullPattern = path.join(changeDir, generates);
-    // Check if it's a glob pattern
-    if (isGlobPattern(generates)) {
-        return hasGlobMatches(fullPattern);
-    }
-    // Simple file path - check if file exists
-    return fs.existsSync(fullPattern);
-}
-/**
- * Checks if a path contains glob pattern characters.
- */
-function isGlobPattern(pattern) {
-    return pattern.includes('*') || pattern.includes('?') || pattern.includes('[');
-}
-/**
- * Checks if a glob pattern has any matches.
- * Normalizes Windows backslashes to forward slashes for cross-platform glob compatibility.
- */
-function hasGlobMatches(pattern) {
-    const normalizedPattern = FileSystemUtils.toPosixPath(pattern);
-    const matches = fg.sync(normalizedPattern, { onlyFiles: true });
-    return matches.length > 0;
+    return artifactOutputExists(changeDir, generates);
 }
 //# sourceMappingURL=state.js.map

package/dist/core/available-tools.d.ts

@@ -9,8 +9,9 @@ import { type AIToolOption } from './config.js';
  * Scans the project path for AI tool configuration directories and returns
  * the tools that are present.
  *
- * Checks for each tool's `skillsDir` (e.g., `.claude/`, `.cursor/`) at the
- * project root. Only tools with a `skillsDir` property are considered.
+ * For tools with `detectionPaths`, checks those specific paths (files or
+ * directories). Otherwise checks for the tool's `skillsDir` directory at
+ * the project root. Only tools with a `skillsDir` property are considered.
  */
 export declare function getAvailableTools(projectPath: string): AIToolOption[];
 //# sourceMappingURL=available-tools.d.ts.map

package/dist/core/available-tools.js

@@ -11,13 +11,26 @@ import { AI_TOOLS } from './config.js';
  * Scans the project path for AI tool configuration directories and returns
  * the tools that are present.
  *
- * Checks for each tool's `skillsDir` (e.g., `.claude/`, `.cursor/`) at the
- * project root. Only tools with a `skillsDir` property are considered.
+ * For tools with `detectionPaths`, checks those specific paths (files or
+ * directories). Otherwise checks for the tool's `skillsDir` directory at
+ * the project root. Only tools with a `skillsDir` property are considered.
  */
 export function getAvailableTools(projectPath) {
     return AI_TOOLS.filter((tool) => {
         if (!tool.skillsDir)
             return false;
+        if (tool.detectionPaths && tool.detectionPaths.length > 0) {
+            // statSync without .isDirectory() — detection paths can be files or directories
+            return tool.detectionPaths.some((p) => {
+                try {
+                    fs.statSync(path.join(projectPath, p));
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            });
+        }
         const dirPath = path.join(projectPath, tool.skillsDir);
         try {
             return fs.statSync(dirPath).isDirectory();

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

@@ -0,0 +1,14 @@
+/**
+ * Bob Shell Command Adapter
+ *
+ * Formats commands for Bob Shell following its markdown specification.
+ * Commands are stored in .bob/commands/ directory.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Bob Shell adapter for command generation.
+ * File path: .bob/commands/opsx-<id>.md
+ * Frontmatter: description, argument-hint
+ */
+export declare const bobAdapter: ToolCommandAdapter;
+//# sourceMappingURL=bob.d.ts.map

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

@@ -0,0 +1,45 @@
+/**
+ * Bob Shell Command Adapter
+ *
+ * Formats commands for Bob Shell following its markdown specification.
+ * Commands are stored in .bob/commands/ directory.
+ */
+import path from 'path';
+import { transformToHyphenCommands } from '../../../utils/command-references.js';
+/**
+ * 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;
+}
+/**
+ * Bob Shell adapter for command generation.
+ * File path: .bob/commands/opsx-<id>.md
+ * Frontmatter: description, argument-hint
+ */
+export const bobAdapter = {
+    toolId: 'bob',
+    getFilePath(commandId) {
+        return path.join('.bob', 'commands', `opsx-${commandId}.md`);
+    },
+    formatFile(content) {
+        // Transform command references from colon to hyphen format for Bob
+        const transformedBody = transformToHyphenCommands(content.body);
+        return `---
+description: ${escapeYamlValue(content.description)}
+argument-hint: command arguments
+---
+
+${transformedBody}
+`;
+    },
+};
+//# sourceMappingURL=bob.js.map