@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.18

package/dist/src/smiths/skillsmith/generator.js

@@ -0,0 +1,316 @@
+/**
+ * SkillSmith Skill Generator
+ *
+ * Generates skills with platform-aware deployment.
+ *
+ * @module smiths/skillsmith/generator
+ */
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { PlatformSkillResolver } from './platform-resolver.js';
+/**
+ * Generate a skill from options
+ */
+export async function generateSkill(options) {
+    // Validate skill name
+    const nameValidation = PlatformSkillResolver.validateSkillName(options.name);
+    if (!nameValidation.valid) {
+        throw new Error(`Invalid skill name: ${nameValidation.error}`);
+    }
+    // Description is REQUIRED. Codex rejects SKILL.md files without a non-empty
+    // description field; Claude Code uses it for natural-language invocation.
+    // Never allow generation of a SKILL.md with a missing or blank description.
+    if (typeof options.description !== 'string' ||
+        options.description.trim() === '') {
+        throw new Error(`Skill description is required and must be non-empty. ` +
+            `Codex (and other platforms) reject SKILL.md files without a description. ` +
+            `Skill: '${options.name}'`);
+    }
+    // Check if platform supports skills natively
+    const supportsSkills = PlatformSkillResolver.supportsSkills(options.platform);
+    if (!supportsSkills) {
+        const alternative = PlatformSkillResolver.getAlternativeStrategy(options.platform);
+        console.warn(`Platform '${options.platform}' does not natively support skills.`);
+        if (alternative) {
+            console.warn(`Consider deploying as ${alternative} instead.`);
+        }
+    }
+    // Generate skill content
+    const content = generateSkillContent(options);
+    // Generate references if requested
+    const references = options.createReferences
+        ? generateDefaultReferences(options)
+        : undefined;
+    // Resolve deployment path
+    const deployPath = PlatformSkillResolver.getSkillPath(options.platform, options.projectPath, options.name);
+    return {
+        name: options.name,
+        path: deployPath,
+        content,
+        platform: options.platform,
+        references,
+        version: options.version || '1.0.0',
+    };
+}
+/**
+ * Deploy a generated skill to the target platform
+ */
+export async function deploySkill(skill, projectPath, dryRun = false) {
+    const filesCreated = [];
+    try {
+        if (dryRun) {
+            console.log(`[DRY RUN] Would deploy skill to: ${skill.path}`);
+            return {
+                skill,
+                success: true,
+                deployPath: skill.path,
+                filesCreated: [],
+            };
+        }
+        // Create skill directory
+        await fs.mkdir(skill.path, { recursive: true });
+        // Write SKILL.md
+        const skillFilePath = PlatformSkillResolver.getSkillFilePath(skill.platform, projectPath, skill.name);
+        await fs.writeFile(skillFilePath, skill.content, 'utf-8');
+        filesCreated.push(skillFilePath);
+        // Create references directory and files
+        if (skill.references && skill.references.length > 0) {
+            const referencesPath = PlatformSkillResolver.getReferencesPath(skill.platform, projectPath, skill.name);
+            await fs.mkdir(referencesPath, { recursive: true });
+            for (const ref of skill.references) {
+                const refPath = path.join(referencesPath, ref.filename);
+                await fs.writeFile(refPath, ref.content, 'utf-8');
+                filesCreated.push(refPath);
+            }
+        }
+        return {
+            skill,
+            success: true,
+            deployPath: skill.path,
+            filesCreated,
+        };
+    }
+    catch (error) {
+        return {
+            skill,
+            success: false,
+            deployPath: skill.path,
+            error: error instanceof Error ? error.message : String(error),
+            filesCreated,
+        };
+    }
+}
+/**
+ * Generate SKILL.md content
+ */
+function generateSkillContent(options) {
+    const frontmatter = generateFrontmatter(options);
+    const body = generateSkillBody(options);
+    return `${frontmatter}\n${body}`;
+}
+/**
+ * Generate frontmatter YAML
+ *
+ * `description` is REQUIRED — Codex rejects SKILL.md files without a non-empty
+ * description, and Claude Code relies on it for natural-language invocation.
+ * This function throws rather than emitting a frontmatter block with a missing
+ * or blank description (which would otherwise produce `description: ""` —
+ * a silent failure that breaks deployments).
+ */
+function generateFrontmatter(options) {
+    if (typeof options.description !== 'string' ||
+        options.description.trim() === '') {
+        throw new Error(`generateFrontmatter: 'description' is required and must be non-empty ` +
+            `(skill: '${options.name ?? '<unnamed>'}'). Codex and other platforms ` +
+            `reject SKILL.md files without a description.`);
+    }
+    const fm = {
+        name: options.name,
+        description: options.description.trim(),
+        version: options.version || '1.0.0',
+        commandHint: {
+            modelRole: options.modelRole ?? 'efficiency',
+            modelTier: options.modelTier ?? 'economy',
+            ...(options.modelRationale ? { modelRationale: options.modelRationale } : {}),
+        },
+    };
+    if (options.tools && options.tools.length > 0) {
+        fm.tools = options.tools.join(', ');
+    }
+    const lines = ['---'];
+    lines.push(`name: ${fm.name}`);
+    lines.push(`namespace: aiwg`);
+    lines.push(`description: ${fm.description}`);
+    lines.push(`version: ${fm.version}`);
+    if (fm.tools) {
+        lines.push(`tools: ${fm.tools}`);
+    }
+    lines.push('commandHint:');
+    lines.push(`  modelRole: ${fm.commandHint.modelRole}`);
+    lines.push(`  modelTier: ${fm.commandHint.modelTier}`);
+    if (fm.commandHint.modelRationale) {
+        lines.push(`  modelRationale: ${fm.commandHint.modelRationale}`);
+    }
+    lines.push('---');
+    return lines.join('\n');
+}
+/**
+ * Generate skill body content
+ */
+function generateSkillBody(options) {
+    const sections = [];
+    // Title
+    sections.push(`# ${toTitleCase(options.name)} Skill`);
+    sections.push('');
+    // Purpose
+    sections.push('## Purpose');
+    sections.push('');
+    sections.push(options.description);
+    sections.push('');
+    // Trigger Phrases
+    sections.push('## Trigger Phrases');
+    sections.push('');
+    sections.push('Activate this skill when the user says:');
+    if (options.triggerPhrases && options.triggerPhrases.length > 0) {
+        options.triggerPhrases.forEach((phrase) => {
+            sections.push(`- "${phrase}"`);
+        });
+    }
+    else {
+        sections.push(`- "${options.name}"`);
+        sections.push('- "use ' + options.name + '"');
+    }
+    sections.push('');
+    // Input
+    sections.push('## Input');
+    sections.push('');
+    sections.push('This skill expects:');
+    sections.push('- User request or content to process');
+    if (options.guidance) {
+        sections.push(`- ${options.guidance}`);
+    }
+    sections.push('');
+    // Execution Process
+    sections.push('## Execution Process');
+    sections.push('');
+    sections.push('1. Validate input requirements');
+    sections.push('2. Process the request');
+    sections.push('3. Generate output');
+    sections.push('4. Return results to user');
+    sections.push('');
+    // Output
+    sections.push('## Output');
+    sections.push('');
+    sections.push('This skill produces:');
+    sections.push('- Processed result based on input');
+    sections.push('- Status information');
+    sections.push('');
+    // Examples
+    sections.push('## Examples');
+    sections.push('');
+    sections.push('### Example 1: Basic Usage');
+    sections.push(`**User**: "${options.triggerPhrases?.[0] || options.name}"`);
+    sections.push(`**Result**: Skill executes and returns result`);
+    sections.push('');
+    // Tools (if specified)
+    if (options.tools && options.tools.length > 0) {
+        sections.push('## Tools Used');
+        sections.push('');
+        options.tools.forEach((tool) => {
+            sections.push(`- ${tool}`);
+        });
+        sections.push('');
+    }
+    // References (if creating reference directory)
+    if (options.createReferences) {
+        sections.push('## References');
+        sections.push('');
+        sections.push('See `references/` directory for:');
+        sections.push('- Usage examples');
+        sections.push('- Configuration options');
+        sections.push('- Troubleshooting guide');
+        sections.push('');
+    }
+    return sections.join('\n');
+}
+/**
+ * Generate default reference files
+ */
+function generateDefaultReferences(options) {
+    const references = [];
+    // Usage examples
+    references.push({
+        filename: 'usage-examples.md',
+        description: 'Usage examples and patterns',
+        content: generateUsageExamplesContent(options),
+    });
+    // Configuration
+    references.push({
+        filename: 'configuration.md',
+        description: 'Configuration options',
+        content: generateConfigurationContent(options),
+    });
+    return references;
+}
+/**
+ * Generate usage examples content
+ */
+function generateUsageExamplesContent(options) {
+    const triggers = options.triggerPhrases || [options.name];
+    return `# Usage Examples: ${toTitleCase(options.name)}
+
+## Basic Usage
+
+\`\`\`
+User: "${triggers[0]}"
+\`\`\`
+
+## Alternative Triggers
+
+${triggers.slice(1).map(t => `- "${t}"`).join('\n') || '_No alternative triggers defined_'}
+
+## Common Patterns
+
+This skill can be combined with other workflows for enhanced results.
+See the main README for integration examples.
+`;
+}
+/**
+ * Generate configuration content
+ */
+function generateConfigurationContent(options) {
+    return `# Configuration: ${toTitleCase(options.name)}
+
+## Platform Support
+
+**${options.platform}**: ${PlatformSkillResolver.supportsSkills(options.platform)
+        ? 'Native skill support'
+        : 'Skills mapped to commands'}
+
+## Options
+
+This skill uses default configuration. Custom options can be added to the skill manifest.
+
+## Environment Variables
+
+No environment variables required for basic operation.
+`;
+}
+/**
+ * Convert kebab-case to Title Case
+ */
+function toTitleCase(kebab) {
+    return kebab
+        .split('-')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}
+/**
+ * Interactive skill design workflow
+ */
+export async function interactiveSkillDesign() {
+    // This would be implemented with user prompts in a real CLI
+    // For now, return a stub
+    throw new Error('Interactive mode not yet implemented. Use --guidance to provide design input.');
+}
+//# sourceMappingURL=generator.js.map

package/dist/src/smiths/skillsmith/index.js

@@ -0,0 +1,12 @@
+/**
+ * SkillSmith - Skill Generation System
+ *
+ * Generates skills with platform-aware deployment.
+ *
+ * @module smiths/skillsmith
+ */
+export * from './types.js';
+export * from './generator.js';
+export * from './platform-resolver.js';
+export * from './namespace-adapter.js';
+//# sourceMappingURL=index.js.map

package/dist/src/smiths/skillsmith/namespace-adapter.js

@@ -0,0 +1,180 @@
+/**
+ * Namespace-aware Skill Deployment Adapter
+ *
+ * Implements per-platform namespace deployment strategy per ADR:
+ * .aiwg/architecture/adr-skill-namespace-strategy.md
+ *
+ * Platform groups:
+ *   Group A (deep-recursion): Claude Code, Cursor, Codex, OpenCode, OpenClaw
+ *     → Deploy both canonical subdir layout AND prefixed slug fallback.
+ *   Group B (one-level):      Factory AI, Warp, Windsurf
+ *     → Deploy only the prefixed slug; no subdir (would break one-level discovery).
+ *   Group C (unknown):        GitHub Copilot
+ *     → Deploy only the prefixed slug (safe default until recursion depth confirmed).
+ *   Group D (mcp-skip):       Hermes
+ *     → Skip file deployment, emit guidance pointing to hermes-quickstart.md.
+ *
+ * @implements #704
+ * @see collision-detector.ts for pre-deployment collision checking (#697)
+ */
+import * as os from 'os';
+import * as path from 'path';
+import { listProviderDefinitions } from '../../providers/provider-definitions.js';
+// ============================================
+// Adapter Definitions
+// ============================================
+/**
+ * Per-platform adapter table.
+ * Derived from ProviderDefinition.skillNamespace; includes a 'generic' fallback.
+ */
+export const NAMESPACE_ADAPTERS = Object.fromEntries(listProviderDefinitions().map((definition) => [
+    definition.id,
+    {
+        platform: definition.id,
+        deploymentGroup: definition.skillNamespace.deploymentGroup,
+        pathType: definition.skillNamespace.pathType,
+        skillsBaseDir: definition.skillNamespace.skillsBaseDir,
+        subdirLayout: definition.skillNamespace.subdirLayout,
+        maxNameLength: definition.skillNamespace.maxNameLength,
+        maxDescriptionLength: definition.skillNamespace.maxDescriptionLength,
+        appendToDescription: definition.skillNamespace.appendToDescription,
+    },
+]));
+// ============================================
+// Helpers
+// ============================================
+/**
+ * Resolve absolute skills root for a platform + project combination.
+ * Home-dir platforms (Codex, OpenClaw, OpenHuman, Hermes) use os.homedir().
+ */
+export function resolveSkillsRoot(adapter, projectPath) {
+    if (adapter.pathType === 'home-dir') {
+        return path.join(os.homedir(), adapter.skillsBaseDir);
+    }
+    return path.join(projectPath, adapter.skillsBaseDir);
+}
+/**
+ * Compute canonical namespaced slug.
+ * Idempotent: if `skillName` already starts with `{namespace}-`, returns it unchanged.
+ *
+ * @example
+ * computePrefixedSlug('sync', 'aiwg')      // → 'aiwg-sync'
+ * computePrefixedSlug('aiwg-sync', 'aiwg') // → 'aiwg-sync'
+ */
+export function computePrefixedSlug(skillName, namespace) {
+    const prefix = `${namespace}-`;
+    return skillName.startsWith(prefix) ? skillName : `${prefix}${skillName}`;
+}
+/**
+ * Apply platform-specific frontmatter mutations to SKILL.md content.
+ *
+ * Mutations applied (when configured):
+ * - Inject `namespace: {namespace}` into frontmatter if not present
+ * - Truncate `name` to `maxNameLength`
+ * - Append `appendToDescription` suffix to `description`
+ * - Truncate `description` to `maxDescriptionLength`
+ *
+ * Returns the original content unchanged when no mutations are needed.
+ */
+export function mutateFrontmatter(content, adapter, namespace) {
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (!fmMatch)
+        return content;
+    let [, frontmatter, body] = fmMatch;
+    let changed = false;
+    // Inject namespace field if missing
+    if (!/^namespace:\s*/m.test(frontmatter)) {
+        frontmatter = `namespace: ${namespace}\n${frontmatter}`;
+        changed = true;
+    }
+    // Truncate name
+    if (adapter.maxNameLength) {
+        frontmatter = frontmatter.replace(/^(name:\s*)(.+)$/m, (_, key, val) => {
+            const truncated = val.slice(0, adapter.maxNameLength);
+            if (truncated !== val)
+                changed = true;
+            return `${key}${truncated}`;
+        });
+    }
+    // Append to description and/or truncate
+    if (adapter.appendToDescription || adapter.maxDescriptionLength) {
+        frontmatter = frontmatter.replace(/^(description:\s*)(.+)$/m, (_, key, val) => {
+            let desc = val;
+            if (adapter.appendToDescription && !desc.includes(adapter.appendToDescription)) {
+                desc = `${desc} ${adapter.appendToDescription}`;
+                changed = true;
+            }
+            if (adapter.maxDescriptionLength && desc.length > adapter.maxDescriptionLength) {
+                desc = desc.slice(0, adapter.maxDescriptionLength);
+                changed = true;
+            }
+            return `${key}${desc}`;
+        });
+    }
+    if (!changed)
+        return content;
+    return `---\n${frontmatter}\n---\n${body}`;
+}
+// ============================================
+// Public API
+// ============================================
+/**
+ * Get the namespace adapter for a platform.
+ * Falls back to 'generic' for unrecognised platforms.
+ */
+export function getAdapter(platform) {
+    return NAMESPACE_ADAPTERS[platform] ?? NAMESPACE_ADAPTERS.generic;
+}
+/**
+ * Resolve deployment plans for a skill on a given platform.
+ *
+ * Calls `checkCollisions()` before writing should be done at the call site
+ * (see collision-detector.ts, #697).
+ *
+ * @param platform     - Target platform
+ * @param projectPath  - Absolute project root directory
+ * @param skillName    - Skill folder name (e.g. 'sync', 'aiwg-sync')
+ * @param sourceContent - Raw content of the source SKILL.md file
+ * @param namespace    - Namespace prefix (default: 'aiwg')
+ * @returns NamespaceDeployResult with plans to execute (or skip=true for Hermes)
+ */
+export function getDeploymentPlans(platform, projectPath, skillName, sourceContent, namespace = 'aiwg') {
+    const adapter = getAdapter(platform);
+    const plat = platform;
+    // Group D: MCP Skip — emit guidance, write no files
+    if (adapter.deploymentGroup === 'mcp-skip') {
+        return {
+            platform: plat,
+            skillName,
+            plans: [],
+            skip: true,
+            skipMessage: `Hermes skills are not deployed by aiwg use.\n` +
+                `  See docs/integrations/hermes-quickstart.md for manual skill setup.`,
+        };
+    }
+    const skillsRoot = resolveSkillsRoot(adapter, projectPath);
+    const slug = computePrefixedSlug(skillName, namespace);
+    const content = mutateFrontmatter(sourceContent, adapter, namespace);
+    const plans = [];
+    // Group A: canonical subdir layout — {baseDir}/{namespace}/{slug}/SKILL.md
+    if (adapter.subdirLayout) {
+        plans.push({
+            targetPath: path.join(skillsRoot, namespace, slug, 'SKILL.md'),
+            content,
+            label: `${namespace}/${slug}/SKILL.md (canonical subdir)`,
+        });
+    }
+    // Groups A, B, C: universal prefixed slug — {baseDir}/{slug}/SKILL.md
+    plans.push({
+        targetPath: path.join(skillsRoot, slug, 'SKILL.md'),
+        content,
+        label: `${slug}/SKILL.md (universal slug)`,
+    });
+    return {
+        platform: plat,
+        skillName,
+        plans,
+        skip: false,
+    };
+}
+//# sourceMappingURL=namespace-adapter.js.map

package/dist/src/smiths/skillsmith/platform-resolver.js

@@ -0,0 +1,157 @@
+/**
+ * Platform-specific skill deployment path resolution
+ *
+ * @module smiths/skillsmith/platform-resolver
+ */
+import { homedir } from 'os';
+import * as path from 'path';
+import { getProviderDefinition } from '../../providers/provider-definitions.js';
+/**
+ * Platform-specific skill configuration derived from ProviderDefinition.
+ */
+function getPlatformSkillConfig(platform) {
+    const definition = getProviderDefinition(platform);
+    if (!definition)
+        throw new Error(`Unknown platform: ${platform}`);
+    const namespace = definition.skillNamespace;
+    const baseDir = namespace.pathType === 'home-dir'
+        ? `~/${namespace.skillsBaseDir}`
+        : namespace.skillsBaseDir;
+    return {
+        baseDir,
+        extension: definition.smithPaths.fileExtension,
+        supportsSkills: true,
+        supportsSubdirectory: namespace.subdirLayout,
+    };
+}
+/**
+ * Resolve platform-specific skill paths
+ */
+export class PlatformSkillResolver {
+    /**
+     * Get platform configuration for skills
+     */
+    static getConfig(platform) {
+        return getPlatformSkillConfig(platform);
+    }
+    /**
+     * Get base directory for skills on a platform.
+     * Supports home-dir paths (baseDir starting with `~/`) for platforms like Codex and OpenClaw.
+     */
+    static getBaseDir(platform, projectPath) {
+        const config = this.getConfig(platform);
+        if (config.baseDir.startsWith('~/')) {
+            return path.join(homedir(), config.baseDir.slice(2));
+        }
+        return path.join(projectPath, config.baseDir);
+    }
+    /**
+     * Get path for a specific skill
+     */
+    static getSkillPath(platform, projectPath, skillName) {
+        const baseDir = this.getBaseDir(platform, projectPath);
+        return path.join(baseDir, skillName);
+    }
+    /**
+     * Get path for SKILL.md file
+     */
+    static getSkillFilePath(platform, projectPath, skillName) {
+        const skillPath = this.getSkillPath(platform, projectPath, skillName);
+        const config = this.getConfig(platform);
+        return path.join(skillPath, `SKILL${config.extension}`);
+    }
+    /**
+     * Get path for references directory
+     */
+    static getReferencesPath(platform, projectPath, skillName) {
+        const skillPath = this.getSkillPath(platform, projectPath, skillName);
+        return path.join(skillPath, 'references');
+    }
+    /**
+     * Check if platform natively supports skills
+     */
+    static supportsSkills(platform) {
+        return this.getConfig(platform).supportsSkills;
+    }
+    /**
+     * Get alternative deployment strategy for platforms without skill support
+     */
+    static getAlternativeStrategy(platform) {
+        return this.getConfig(platform).alternativeStrategy;
+    }
+    /**
+     * Compute the canonical namespaced slug for a skill.
+     *
+     * Idempotent: if `name` already starts with `{namespace}-`, returns `name` unchanged.
+     * This prevents double-prefixing existing `aiwg-*` skills (e.g. `aiwg-sync` → `aiwg-sync`,
+     * not `aiwg-aiwg-sync`).
+     *
+     * @param name - Skill folder name (e.g. 'sync', 'aiwg-sync')
+     * @param namespace - Namespace prefix (e.g. 'aiwg')
+     * @returns Canonical slug (e.g. 'aiwg-sync')
+     */
+    static computeCanonicalSlug(name, namespace) {
+        const prefix = `${namespace}-`;
+        return name.startsWith(prefix) ? name : `${prefix}${name}`;
+    }
+    /**
+     * Get path for a namespaced skill deployment.
+     *
+     * Platforms with subdirectory support deploy under `{baseDir}/{namespace}/{slug}/`.
+     * Windsurf (1-level discovery) deploys flat at `{baseDir}/{slug}/`.
+     *
+     * @param platform - Target platform
+     * @param projectPath - Project root directory
+     * @param skillName - Skill folder name (e.g. 'sync')
+     * @param namespace - Namespace prefix (e.g. 'aiwg')
+     * @returns Full deployment directory path
+     */
+    static getNamespacedSkillPath(platform, projectPath, skillName, namespace) {
+        const config = this.getConfig(platform);
+        const slug = this.computeCanonicalSlug(skillName, namespace);
+        const baseDir = this.getBaseDir(platform, projectPath);
+        if (config.supportsSubdirectory) {
+            return path.join(baseDir, namespace, slug);
+        }
+        // Windsurf and other flat-discovery platforms: slug only, no namespace subdir
+        return path.join(baseDir, slug);
+    }
+    /**
+     * Get path for the SKILL.md file under namespaced deployment layout.
+     *
+     * @param platform - Target platform
+     * @param projectPath - Project root directory
+     * @param skillName - Skill folder name
+     * @param namespace - Namespace prefix (e.g. 'aiwg')
+     * @returns Full path to SKILL.md
+     */
+    static getNamespacedSkillFilePath(platform, projectPath, skillName, namespace) {
+        const skillDir = this.getNamespacedSkillPath(platform, projectPath, skillName, namespace);
+        const config = this.getConfig(platform);
+        return path.join(skillDir, `SKILL${config.extension}`);
+    }
+    /**
+     * Validate skill name format
+     */
+    static validateSkillName(name) {
+        // kebab-case: lowercase letters, numbers, hyphens
+        const kebabRegex = /^[a-z][a-z0-9-]*[a-z0-9]$/;
+        if (!name) {
+            return { valid: false, error: 'Skill name cannot be empty' };
+        }
+        if (name.length < 2) {
+            return { valid: false, error: 'Skill name must be at least 2 characters' };
+        }
+        if (name.startsWith('-') || name.endsWith('-')) {
+            return { valid: false, error: 'Skill name cannot start or end with hyphen' };
+        }
+        if (!kebabRegex.test(name)) {
+            return {
+                valid: false,
+                error: 'Skill name must be kebab-case (lowercase, alphanumeric, hyphens)',
+            };
+        }
+        return { valid: true };
+    }
+}
+//# sourceMappingURL=platform-resolver.js.map

package/dist/src/smiths/skillsmith/types.js

@@ -0,0 +1,9 @@
+/**
+ * SkillSmith Type Definitions
+ *
+ * Types for generating skills with platform-aware deployment.
+ *
+ * @module smiths/skillsmith
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/src/smiths/toolsmith/index.js

@@ -0,0 +1,10 @@
+/**
+ * Toolsmith - Tool Specification Generator
+ *
+ * Generates tool specifications for subagent scenarios where context
+ * is discarded and only tool specifications return.
+ *
+ * @module smiths/toolsmith
+ */
+export * from './types.js';
+//# sourceMappingURL=index.js.map