@fission-ai/openspec 1.1.1 → 1.3.0

package/README.md

@@ -36,7 +36,7 @@ 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.
@@ -46,17 +46,14 @@ Our philosophy:
 
 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 +98,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/cli/index.js

@@ -70,6 +70,7 @@ program
     .description('Initialize OpenSpec in your project')
     .option('--tools <tools>', toolsOptionDescription)
     .option('--force', 'Auto-cleanup legacy files without prompting')
+    .option('--profile <profile>', 'Override global config profile (core or custom)')
     .action(async (targetPath = '.', options) => {
     try {
         // Validate that the path is a valid directory
@@ -96,6 +97,7 @@ program
         const initCommand = new InitCommand({
             tools: options?.tools,
             force: options?.force,
+            profile: options?.profile,
         });
         await initCommand.execute(targetPath);
     }

package/dist/commands/config.d.ts

@@ -1,8 +1,36 @@
 import { Command } from 'commander';
+import { GlobalConfig } from '../core/global-config.js';
+import type { Profile, Delivery } from '../core/global-config.js';
+interface ProfileState {
+    profile: Profile;
+    delivery: Delivery;
+    workflows: string[];
+}
+interface ProfileStateDiff {
+    hasChanges: boolean;
+    lines: string[];
+}
+/**
+ * Resolve the effective current profile state from global config defaults.
+ */
+export declare function resolveCurrentProfileState(config: GlobalConfig): ProfileState;
+/**
+ * Derive profile type from selected workflows.
+ */
+export declare function deriveProfileFromWorkflowSelection(selectedWorkflows: string[]): Profile;
+/**
+ * Format a compact workflow summary for the profile header.
+ */
+export declare function formatWorkflowSummary(workflows: readonly string[], profile: Profile): string;
+/**
+ * Build a user-facing diff summary between two profile states.
+ */
+export declare function diffProfileState(before: ProfileState, after: ProfileState): ProfileStateDiff;
 /**
  * Register the config command and all its subcommands.
  *
  * @param program - The Commander program instance
  */
 export declare function registerConfigCommand(program: Command): void;
+export {};
 //# sourceMappingURL=config.d.ts.map

package/dist/commands/config.js

@@ -1,7 +1,147 @@
-import { spawn } from 'node:child_process';
+import { spawn, execSync } from 'node:child_process';
 import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { getGlobalConfigPath, getGlobalConfig, saveGlobalConfig, } from '../core/global-config.js';
 import { getNestedValue, setNestedValue, deleteNestedValue, coerceValue, formatValueYaml, validateConfigKeyPath, validateConfig, DEFAULT_CONFIG, } from '../core/config-schema.js';
+import { CORE_WORKFLOWS, ALL_WORKFLOWS, getProfileWorkflows } from '../core/profiles.js';
+import { OPENSPEC_DIR_NAME } from '../core/config.js';
+import { hasProjectConfigDrift } from '../core/profile-sync-drift.js';
+const WORKFLOW_PROMPT_META = {
+    propose: {
+        name: 'Propose change',
+        description: 'Create proposal, design, and tasks from a request',
+    },
+    explore: {
+        name: 'Explore ideas',
+        description: 'Investigate a problem before implementation',
+    },
+    new: {
+        name: 'New change',
+        description: 'Create a new change scaffold quickly',
+    },
+    continue: {
+        name: 'Continue change',
+        description: 'Resume work on an existing change',
+    },
+    apply: {
+        name: 'Apply tasks',
+        description: 'Implement tasks from the current change',
+    },
+    ff: {
+        name: 'Fast-forward',
+        description: 'Run a faster implementation workflow',
+    },
+    sync: {
+        name: 'Sync specs',
+        description: 'Sync change artifacts with specs',
+    },
+    archive: {
+        name: 'Archive change',
+        description: 'Finalize and archive a completed change',
+    },
+    'bulk-archive': {
+        name: 'Bulk archive',
+        description: 'Archive multiple completed changes together',
+    },
+    verify: {
+        name: 'Verify change',
+        description: 'Run verification checks against a change',
+    },
+    onboard: {
+        name: 'Onboard',
+        description: 'Guided onboarding flow for OpenSpec',
+    },
+};
+function isPromptCancellationError(error) {
+    return (error instanceof Error &&
+        (error.name === 'ExitPromptError' || error.message.includes('force closed the prompt with SIGINT')));
+}
+/**
+ * Resolve the effective current profile state from global config defaults.
+ */
+export function resolveCurrentProfileState(config) {
+    const profile = config.profile || 'core';
+    const delivery = config.delivery || 'both';
+    const workflows = [
+        ...getProfileWorkflows(profile, config.workflows ? [...config.workflows] : undefined),
+    ];
+    return { profile, delivery, workflows };
+}
+/**
+ * Derive profile type from selected workflows.
+ */
+export function deriveProfileFromWorkflowSelection(selectedWorkflows) {
+    const isCoreMatch = selectedWorkflows.length === CORE_WORKFLOWS.length &&
+        CORE_WORKFLOWS.every((w) => selectedWorkflows.includes(w));
+    return isCoreMatch ? 'core' : 'custom';
+}
+/**
+ * Format a compact workflow summary for the profile header.
+ */
+export function formatWorkflowSummary(workflows, profile) {
+    return `${workflows.length} selected (${profile})`;
+}
+function stableWorkflowOrder(workflows) {
+    const seen = new Set();
+    const ordered = [];
+    for (const workflow of ALL_WORKFLOWS) {
+        if (workflows.includes(workflow) && !seen.has(workflow)) {
+            ordered.push(workflow);
+            seen.add(workflow);
+        }
+    }
+    const extras = workflows.filter((w) => !ALL_WORKFLOWS.includes(w));
+    extras.sort();
+    for (const extra of extras) {
+        if (!seen.has(extra)) {
+            ordered.push(extra);
+            seen.add(extra);
+        }
+    }
+    return ordered;
+}
+/**
+ * Build a user-facing diff summary between two profile states.
+ */
+export function diffProfileState(before, after) {
+    const lines = [];
+    if (before.delivery !== after.delivery) {
+        lines.push(`delivery: ${before.delivery} -> ${after.delivery}`);
+    }
+    if (before.profile !== after.profile) {
+        lines.push(`profile: ${before.profile} -> ${after.profile}`);
+    }
+    const beforeOrdered = stableWorkflowOrder(before.workflows);
+    const afterOrdered = stableWorkflowOrder(after.workflows);
+    const beforeSet = new Set(beforeOrdered);
+    const afterSet = new Set(afterOrdered);
+    const added = afterOrdered.filter((w) => !beforeSet.has(w));
+    const removed = beforeOrdered.filter((w) => !afterSet.has(w));
+    if (added.length > 0 || removed.length > 0) {
+        const tokens = [];
+        if (added.length > 0) {
+            tokens.push(`added ${added.join(', ')}`);
+        }
+        if (removed.length > 0) {
+            tokens.push(`removed ${removed.join(', ')}`);
+        }
+        lines.push(`workflows: ${tokens.join('; ')}`);
+    }
+    return {
+        hasChanges: lines.length > 0,
+        lines,
+    };
+}
+function maybeWarnConfigDrift(projectDir, state, colorize) {
+    const openspecDir = path.join(projectDir, OPENSPEC_DIR_NAME);
+    if (!fs.existsSync(openspecDir)) {
+        return;
+    }
+    if (!hasProjectConfigDrift(projectDir, state.workflows, state.delivery)) {
+        return;
+    }
+    console.log(colorize('Warning: Global config is not applied to this project. Run `openspec update` to sync.'));
+}
 /**
  * Register the config command and all its subcommands.
  *
@@ -37,7 +177,33 @@ export function registerConfigCommand(program) {
             console.log(JSON.stringify(config, null, 2));
         }
         else {
+            // Read raw config to determine which values are explicit vs defaults
+            const configPath = getGlobalConfigPath();
+            let rawConfig = {};
+            try {
+                if (fs.existsSync(configPath)) {
+                    rawConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                }
+            }
+            catch {
+                // If reading fails, treat all as defaults
+            }
             console.log(formatValueYaml(config));
+            // Annotate profile settings
+            const profileSource = rawConfig.profile !== undefined ? '(explicit)' : '(default)';
+            const deliverySource = rawConfig.delivery !== undefined ? '(explicit)' : '(default)';
+            console.log(`\nProfile settings:`);
+            console.log(`  profile: ${config.profile} ${profileSource}`);
+            console.log(`  delivery: ${config.delivery} ${deliverySource}`);
+            if (config.profile === 'core') {
+                console.log(`  workflows: ${CORE_WORKFLOWS.join(', ')} (from core profile)`);
+            }
+            else if (config.workflows && config.workflows.length > 0) {
+                console.log(`  workflows: ${config.workflows.join(', ')} (explicit)`);
+            }
+            else {
+                console.log(`  workflows: (none)`);
+            }
         }
     });
     // config get
@@ -123,10 +289,21 @@ export function registerConfigCommand(program) {
         }
         if (!options.yes) {
             const { confirm } = await import('@inquirer/prompts');
-            const confirmed = await confirm({
-                message: 'Reset all configuration to defaults?',
-                default: false,
-            });
+            let confirmed;
+            try {
+                confirmed = await confirm({
+                    message: 'Reset all configuration to defaults?',
+                    default: false,
+                });
+            }
+            catch (error) {
+                if (isPromptCancellationError(error)) {
+                    console.log('Reset cancelled.');
+                    process.exitCode = 130;
+                    return;
+                }
+                throw error;
+            }
             if (!confirmed) {
                 console.log('Reset cancelled.');
                 return;
@@ -194,5 +371,182 @@ export function registerConfigCommand(program) {
             process.exitCode = 1;
         }
     });
+    // config profile [preset]
+    configCmd
+        .command('profile [preset]')
+        .description('Configure workflow profile (interactive picker or preset shortcut)')
+        .action(async (preset) => {
+        // Preset shortcut: `openspec config profile core`
+        if (preset === 'core') {
+            const config = getGlobalConfig();
+            config.profile = 'core';
+            config.workflows = [...CORE_WORKFLOWS];
+            // Preserve delivery setting
+            saveGlobalConfig(config);
+            console.log('Config updated. Run `openspec update` in your projects to apply.');
+            return;
+        }
+        if (preset) {
+            console.error(`Error: Unknown profile preset "${preset}". Available presets: core`);
+            process.exitCode = 1;
+            return;
+        }
+        // Non-interactive check
+        if (!process.stdout.isTTY) {
+            console.error('Interactive mode required. Use `openspec config profile core` or set config via environment/flags.');
+            process.exitCode = 1;
+            return;
+        }
+        // Interactive picker
+        const { select, checkbox, confirm } = await import('@inquirer/prompts');
+        const chalk = (await import('chalk')).default;
+        try {
+            const config = getGlobalConfig();
+            const currentState = resolveCurrentProfileState(config);
+            console.log(chalk.bold('\nCurrent profile settings'));
+            console.log(`  Delivery: ${currentState.delivery}`);
+            console.log(`  Workflows: ${formatWorkflowSummary(currentState.workflows, currentState.profile)}`);
+            console.log(chalk.dim('  Delivery = where workflows are installed (skills, commands, or both)'));
+            console.log(chalk.dim('  Workflows = which actions are available (propose, explore, apply, etc.)'));
+            console.log();
+            const action = await select({
+                message: 'What do you want to configure?',
+                choices: [
+                    {
+                        value: 'both',
+                        name: 'Delivery and workflows',
+                        description: 'Update install mode and available actions together',
+                    },
+                    {
+                        value: 'delivery',
+                        name: 'Delivery only',
+                        description: 'Change where workflows are installed',
+                    },
+                    {
+                        value: 'workflows',
+                        name: 'Workflows only',
+                        description: 'Change which workflow actions are available',
+                    },
+                    {
+                        value: 'keep',
+                        name: 'Keep current settings (exit)',
+                        description: 'Leave configuration unchanged and exit',
+                    },
+                ],
+            });
+            if (action === 'keep') {
+                console.log('No config changes.');
+                maybeWarnConfigDrift(process.cwd(), currentState, chalk.yellow);
+                return;
+            }
+            const nextState = {
+                profile: currentState.profile,
+                delivery: currentState.delivery,
+                workflows: [...currentState.workflows],
+            };
+            if (action === 'both' || action === 'delivery') {
+                const deliveryChoices = [
+                    {
+                        value: 'both',
+                        name: 'Both (skills + commands)',
+                        description: 'Install workflows as both skills and slash commands',
+                    },
+                    {
+                        value: 'skills',
+                        name: 'Skills only',
+                        description: 'Install workflows only as skills',
+                    },
+                    {
+                        value: 'commands',
+                        name: 'Commands only',
+                        description: 'Install workflows only as slash commands',
+                    },
+                ];
+                for (const choice of deliveryChoices) {
+                    if (choice.value === currentState.delivery) {
+                        choice.name += ' [current]';
+                    }
+                }
+                nextState.delivery = await select({
+                    message: 'Delivery mode (how workflows are installed):',
+                    choices: deliveryChoices,
+                    default: currentState.delivery,
+                });
+            }
+            if (action === 'both' || action === 'workflows') {
+                const formatWorkflowChoice = (workflow) => {
+                    const metadata = WORKFLOW_PROMPT_META[workflow] ?? {
+                        name: workflow,
+                        description: `Workflow: ${workflow}`,
+                    };
+                    return {
+                        value: workflow,
+                        name: metadata.name,
+                        description: metadata.description,
+                        short: metadata.name,
+                        checked: currentState.workflows.includes(workflow),
+                    };
+                };
+                const selectedWorkflows = await checkbox({
+                    message: 'Select workflows to make available:',
+                    instructions: 'Space to toggle, Enter to confirm',
+                    pageSize: ALL_WORKFLOWS.length,
+                    theme: {
+                        icon: {
+                            checked: '[x]',
+                            unchecked: '[ ]',
+                        },
+                    },
+                    choices: ALL_WORKFLOWS.map(formatWorkflowChoice),
+                });
+                nextState.workflows = selectedWorkflows;
+                nextState.profile = deriveProfileFromWorkflowSelection(selectedWorkflows);
+            }
+            const diff = diffProfileState(currentState, nextState);
+            if (!diff.hasChanges) {
+                console.log('No config changes.');
+                maybeWarnConfigDrift(process.cwd(), nextState, chalk.yellow);
+                return;
+            }
+            console.log(chalk.bold('\nConfig changes:'));
+            for (const line of diff.lines) {
+                console.log(`  ${line}`);
+            }
+            console.log();
+            config.profile = nextState.profile;
+            config.delivery = nextState.delivery;
+            config.workflows = nextState.workflows;
+            saveGlobalConfig(config);
+            // Check if inside an OpenSpec project
+            const projectDir = process.cwd();
+            const openspecDir = path.join(projectDir, OPENSPEC_DIR_NAME);
+            if (fs.existsSync(openspecDir)) {
+                const applyNow = await confirm({
+                    message: 'Apply changes to this project now?',
+                    default: true,
+                });
+                if (applyNow) {
+                    try {
+                        execSync('npx openspec update', { stdio: 'inherit', cwd: projectDir });
+                        console.log('Run `openspec update` in your other projects to apply.');
+                    }
+                    catch {
+                        console.error('`openspec update` failed. Please run it manually to apply the profile changes.');
+                        process.exitCode = 1;
+                    }
+                    return;
+                }
+            }
+            console.log('Config updated. Run `openspec update` in your projects to apply.');
+        }
+        catch (error) {
+            if (isPromptCancellationError(error)) {
+                console.log('Config profile cancelled.');
+                process.exitCode = 130;
+                return;
+            }
+            throw error;
+        }
+    });
 }
 //# sourceMappingURL=config.js.map

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

@@ -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,7 +6,7 @@
 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
 // -----------------------------------------------------------------------------
@@ -14,6 +14,23 @@ export async function statusCommand(options) {
     const spinner = 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) {

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

@@ -0,0 +1,17 @@
+/**
+ * Available Tools Detection
+ *
+ * Detects which AI tools are available in a project by scanning
+ * for their configuration directories.
+ */
+import { type AIToolOption } from './config.js';
+/**
+ * Scans the project path for AI tool configuration directories and returns
+ * the tools that are present.
+ *
+ * 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

@@ -0,0 +1,43 @@
+/**
+ * Available Tools Detection
+ *
+ * Detects which AI tools are available in a project by scanning
+ * for their configuration directories.
+ */
+import path from 'path';
+import * as fs from 'fs';
+import { AI_TOOLS } from './config.js';
+/**
+ * Scans the project path for AI tool configuration directories and returns
+ * the tools that are present.
+ *
+ * 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();
+        }
+        catch {
+            return false;
+        }
+    });
+}
+//# sourceMappingURL=available-tools.js.map

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