@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.18

package/dist/src/smiths/commandsmith/example.js

@@ -0,0 +1,220 @@
+/**
+ * CommandSmith Usage Examples
+ *
+ * Demonstrates how to generate and deploy platform-aware commands.
+ */
+import { generateCommand, deployCommand, generateAndDeploy, listCommands, validateCommand, } from './index.js';
+/**
+ * Example 1: Generate a simple utility command
+ */
+export async function generateSimpleUtility(projectPath) {
+    const command = await generateCommand({
+        name: 'backup-config',
+        description: 'Backup project configuration files',
+        template: 'utility',
+        platform: 'claude',
+        projectPath,
+        args: [
+            {
+                name: 'destination',
+                description: 'Backup location',
+                required: false,
+                default: './backups',
+            },
+        ],
+    });
+    console.log('Generated command:');
+    console.log(`  Name: ${command.name}`);
+    console.log(`  Path: ${command.path}`);
+    console.log(`  Template: ${command.template}`);
+    return command;
+}
+/**
+ * Example 2: Generate a transformation pipeline
+ */
+export async function generateTransformationPipeline(projectPath) {
+    const result = await generateAndDeploy({
+        name: 'convert-docs',
+        description: 'Convert documentation from Markdown to HTML',
+        template: 'transformation',
+        platform: 'claude',
+        projectPath,
+        args: [
+            { name: 'input', description: 'Input directory', required: true },
+            { name: 'output', description: 'Output directory', required: true },
+        ],
+        options: [
+            { name: 'theme', description: 'HTML theme', type: 'string', default: 'default' },
+            { name: 'minify', description: 'Minify output', type: 'boolean', default: false },
+        ],
+    }, { backup: true });
+    if (result.success) {
+        console.log(`✓ Deployed to ${result.command.path}`);
+        if (result.backed_up) {
+            console.log('  (existing file backed up)');
+        }
+    }
+    else {
+        console.error(`✗ Failed: ${result.error}`);
+    }
+    return result;
+}
+/**
+ * Example 3: Generate an orchestration workflow
+ */
+export async function generateOrchestrationWorkflow(projectPath) {
+    const result = await generateAndDeploy({
+        name: 'flow-security-audit',
+        description: 'Execute comprehensive security audit workflow',
+        template: 'orchestration',
+        platform: 'claude',
+        projectPath,
+        args: [
+            { name: 'scope', description: 'Audit scope', required: true },
+        ],
+        options: [
+            {
+                name: 'severity',
+                description: 'Minimum severity level',
+                type: 'string',
+                default: 'medium',
+            },
+        ],
+        guidance: 'Focus on OWASP Top 10 and supply chain security',
+    }, { force: false, backup: true });
+    return result;
+}
+/**
+ * Example 4: Deploy to multiple platforms
+ */
+export async function deployMultiPlatform(projectPath) {
+    const platforms = ['claude', 'factory', 'cursor'];
+    const results = [];
+    for (const platform of platforms) {
+        const result = await generateAndDeploy({
+            name: 'lint-all',
+            description: 'Run all linters on the codebase',
+            template: 'utility',
+            platform,
+            projectPath,
+            args: [
+                { name: 'fix', description: 'Auto-fix issues', required: false },
+            ],
+            options: [
+                { name: 'strict', description: 'Strict mode', type: 'boolean', default: false },
+            ],
+        });
+        results.push({ platform, success: result.success, path: result.command.path });
+    }
+    console.log('\nMulti-platform deployment:');
+    results.forEach(({ platform, success, path }) => {
+        console.log(`  ${success ? '✓' : '✗'} ${platform}: ${path}`);
+    });
+    return results;
+}
+/**
+ * Example 5: Validate before deploying
+ */
+export async function validateBeforeDeploy(projectPath) {
+    const command = await generateCommand({
+        name: 'invalid-command',
+        description: 'This will have validation issues',
+        template: 'utility',
+        platform: 'claude',
+        projectPath,
+    });
+    const validation = validateCommand(command);
+    if (!validation.valid) {
+        console.log('Validation errors:');
+        validation.issues
+            .filter(i => i.type === 'error')
+            .forEach(issue => {
+            console.log(`  ✗ ${issue.field}: ${issue.message}`);
+            if (issue.suggestion) {
+                console.log(`    Suggestion: ${issue.suggestion}`);
+            }
+        });
+        return null;
+    }
+    const result = await deployCommand(command, { backup: true });
+    return result;
+}
+/**
+ * Example 6: List existing commands
+ */
+export async function showExistingCommands(projectPath) {
+    const platforms = ['claude', 'factory', 'cursor'];
+    console.log('\nExisting commands by platform:');
+    for (const platform of platforms) {
+        const commands = await listCommands(platform, projectPath);
+        console.log(`\n${platform}:`);
+        if (commands.length === 0) {
+            console.log('  (no commands)');
+        }
+        else {
+            commands.forEach(cmd => console.log(`  - ${cmd}`));
+        }
+    }
+}
+/**
+ * Example 7: Dry run (preview without deploying)
+ */
+export async function previewCommand(projectPath) {
+    const result = await generateAndDeploy({
+        name: 'preview-example',
+        description: 'This is a preview command',
+        template: 'utility',
+        platform: 'claude',
+        projectPath,
+        dryRun: true,
+    }, { backup: true });
+    console.log('Preview (dry run):');
+    console.log(`  Would deploy to: ${result.command.path}`);
+    console.log(`  Content preview:\n${result.command.content.slice(0, 200)}...`);
+    return result;
+}
+/**
+ * Example 8: Generate Cursor-specific JSON command
+ */
+export async function generateCursorCommand(projectPath) {
+    const command = await generateCommand({
+        name: 'cursor-example',
+        description: 'Example command for Cursor',
+        template: 'utility',
+        platform: 'cursor',
+        projectPath,
+        args: [
+            { name: 'input', description: 'Input file', required: true },
+        ],
+        options: [
+            { name: 'format', description: 'Output format', type: 'string', default: 'json' },
+        ],
+    });
+    console.log('Cursor command (JSON format):');
+    console.log(JSON.parse(command.content));
+    return command;
+}
+/**
+ * Run all examples
+ */
+export async function runAllExamples() {
+    const projectPath = process.cwd();
+    console.log('=== CommandSmith Examples ===\n');
+    console.log('1. Simple utility command:');
+    await generateSimpleUtility(projectPath);
+    console.log('\n2. Transformation pipeline:');
+    await generateTransformationPipeline(projectPath);
+    console.log('\n3. Orchestration workflow:');
+    await generateOrchestrationWorkflow(projectPath);
+    console.log('\n4. Multi-platform deployment:');
+    await deployMultiPlatform(projectPath);
+    console.log('\n5. Validate before deploy:');
+    await validateBeforeDeploy(projectPath);
+    console.log('\n6. List existing commands:');
+    await showExistingCommands(projectPath);
+    console.log('\n7. Dry run preview:');
+    await previewCommand(projectPath);
+    console.log('\n8. Cursor JSON command:');
+    await generateCursorCommand(projectPath);
+}
+//# sourceMappingURL=example.js.map

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

@@ -0,0 +1,288 @@
+/**
+ * Command generation and deployment
+ */
+import { mkdir, writeFile, readFile, access } from 'fs/promises';
+import { join, dirname } from 'path';
+import { constants } from 'fs';
+import { generateCommandContent } from './templates.js';
+import { getCommandsDirectory, getFileExtension } from '../platform-paths.js';
+/**
+ * Validate command name (kebab-case)
+ */
+function validateCommandName(name) {
+    if (!name || name.trim() === '') {
+        return 'Command name cannot be empty';
+    }
+    if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+        return 'Command name must be kebab-case (lowercase letters, numbers, hyphens only, must start with letter)';
+    }
+    if (name.startsWith('-') || name.endsWith('-')) {
+        return 'Command name cannot start or end with a hyphen';
+    }
+    if (name.includes('--')) {
+        return 'Command name cannot contain consecutive hyphens';
+    }
+    return null;
+}
+/**
+ * Validate command options
+ */
+export function validateCommand(command) {
+    const issues = [];
+    // Validate name
+    const nameError = validateCommandName(command.name);
+    if (nameError) {
+        issues.push({
+            type: 'error',
+            field: 'name',
+            message: nameError,
+            suggestion: 'Use lowercase letters, numbers, and hyphens only (e.g., my-command)',
+        });
+    }
+    // Validate content
+    if (!command.content || command.content.trim() === '') {
+        issues.push({
+            type: 'error',
+            field: 'content',
+            message: 'Command content cannot be empty',
+        });
+    }
+    // Validate platform
+    const validPlatforms = ['claude', 'codex', 'copilot', 'cursor', 'factory', 'generic', 'windsurf'];
+    if (!validPlatforms.includes(command.platform)) {
+        issues.push({
+            type: 'error',
+            field: 'platform',
+            message: `Invalid platform: ${command.platform}`,
+            suggestion: `Must be one of: ${validPlatforms.join(', ')}`,
+        });
+    }
+    // Warn if content doesn't include standard options
+    if (!command.content.includes('--interactive') && !command.content.includes('--guidance')) {
+        issues.push({
+            type: 'warning',
+            field: 'content',
+            message: 'Command should support --interactive and --guidance options',
+            suggestion: 'Add these standard options to command arguments',
+        });
+    }
+    return {
+        valid: issues.filter(i => i.type === 'error').length === 0,
+        issues,
+        command,
+    };
+}
+/**
+ * Transform command content for Cursor platform (JSON format)
+ */
+function transformForCursor(name, description, options) {
+    const spec = {
+        name,
+        description,
+        arguments: (options.args || []).map(arg => ({
+            name: arg.name,
+            description: arg.description,
+            required: arg.required,
+            type: 'string',
+            default: arg.default,
+        })),
+        options: [
+            ...(options.options || []).map(opt => ({
+                name: opt.name,
+                description: opt.description,
+                type: opt.type,
+                default: opt.default,
+            })),
+            {
+                name: 'interactive',
+                description: 'Enable interactive mode with guided questions',
+                type: 'boolean',
+                default: false,
+            },
+            {
+                name: 'guidance',
+                description: 'Provide strategic guidance for execution',
+                type: 'string',
+            },
+        ],
+        execution: {
+            steps: [
+                'Validate inputs',
+                'Process request',
+                'Generate output',
+                'Report status',
+            ],
+        },
+        commandHint: {
+            modelRole: options.modelRole ?? 'efficiency',
+            modelTier: options.modelTier ?? 'economy',
+        },
+    };
+    return JSON.stringify(spec, null, 2);
+}
+/**
+ * Generate a command from options
+ */
+export async function generateCommand(options) {
+    // Validate command name
+    const nameError = validateCommandName(options.name);
+    if (nameError) {
+        throw new Error(nameError);
+    }
+    // Default template
+    const template = options.template || 'utility';
+    // Determine target directory
+    const targetDir = options.targetDir || getCommandsDirectory(options.platform, options.projectPath);
+    // Get file extension
+    const ext = getFileExtension(options.platform);
+    // Build file path
+    const filePath = join(targetDir, `${options.name}${ext}`);
+    const skillPath = join(options.projectPath, '.agents/skills', options.name, 'SKILL.md');
+    const modelRole = options.modelRole ?? (template === 'orchestration' ? 'coding' : 'efficiency');
+    const modelTier = options.modelTier ?? (template === 'orchestration' ? 'standard' : 'economy');
+    // Generate content based on platform
+    let content;
+    if (options.platform === 'cursor') {
+        // Cursor uses JSON format
+        content = transformForCursor(options.name, options.description, options);
+    }
+    else {
+        // Other platforms use markdown
+        content = generateCommandContent(template, options.name, options.description, options.args, options.options, options.guidance, modelRole, modelTier);
+    }
+    const skillContent = `---
+name: ${options.name}
+namespace: aiwg
+description: ${options.description}
+commandHint:
+  modelRole: ${modelRole}
+  modelTier: ${modelTier}
+---
+
+# ${options.name}
+
+${options.description}
+
+## Execution
+
+Use the generated provider command artifact for slash-command UX, but treat this SKILL.md as the canonical source for model policy and deployment translation.
+`;
+    return {
+        name: options.name,
+        path: filePath,
+        content,
+        skillContent,
+        skillPath,
+        platform: options.platform,
+        template,
+    };
+}
+/**
+ * Check if file exists
+ */
+async function fileExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Backup existing file
+ */
+async function backupFile(path) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
+    const backupPath = `${path}.backup-${timestamp}`;
+    const content = await readFile(path, 'utf-8');
+    await writeFile(backupPath, content, 'utf-8');
+    return backupPath;
+}
+/**
+ * Deploy a generated command to the filesystem
+ */
+export async function deployCommand(command, options = {}) {
+    try {
+        // Validate command first
+        const validation = validateCommand(command);
+        if (!validation.valid) {
+            const errors = validation.issues.filter(i => i.type === 'error').map(i => i.message);
+            return {
+                command,
+                success: false,
+                error: `Validation failed: ${errors.join('; ')}`,
+            };
+        }
+        // Check if file exists
+        const exists = await fileExists(command.path);
+        // Handle existing file
+        if (exists && !options.force) {
+            return {
+                command,
+                success: false,
+                error: `File already exists: ${command.path}. Use force option to overwrite.`,
+            };
+        }
+        // Backup if requested and file exists
+        let backed_up = false;
+        if (exists && options.backup) {
+            await backupFile(command.path);
+            backed_up = true;
+        }
+        // Ensure directory exists
+        const dir = dirname(command.path);
+        await mkdir(dir, { recursive: true });
+        await mkdir(dirname(command.skillPath), { recursive: true });
+        // Write command file
+        await writeFile(command.skillPath, command.skillContent, 'utf-8');
+        await writeFile(command.path, command.content, 'utf-8');
+        return {
+            command,
+            success: true,
+            backed_up,
+        };
+    }
+    catch (error) {
+        return {
+            command,
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Generate and deploy a command in one step
+ */
+export async function generateAndDeploy(options, deployOptions = {}) {
+    const command = await generateCommand(options);
+    // If dry run, don't deploy
+    if (options.dryRun) {
+        return {
+            command,
+            success: true,
+            error: undefined,
+        };
+    }
+    return deployCommand(command, deployOptions);
+}
+/**
+ * List existing commands in a project
+ */
+export async function listCommands(platform, projectPath) {
+    const commandsDir = getCommandsDirectory(platform, projectPath);
+    const ext = getFileExtension(platform);
+    try {
+        const { readdir } = await import('fs/promises');
+        const files = await readdir(commandsDir);
+        return files
+            .filter(f => f.endsWith(ext))
+            .map(f => f.replace(ext, ''))
+            .sort();
+    }
+    catch {
+        // Directory doesn't exist or is empty
+        return [];
+    }
+}
+//# sourceMappingURL=generator.js.map

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

@@ -0,0 +1,41 @@
+/**
+ * CommandSmith - Platform-Aware Slash Command Generator
+ *
+ * Generates slash commands with templates and multi-platform support.
+ *
+ * @example
+ * ```typescript
+ * import { generateCommand, deployCommand } from './commandsmith/index.js';
+ *
+ * // Generate a command
+ * const command = await generateCommand({
+ *   name: 'my-workflow',
+ *   description: 'Execute my custom workflow',
+ *   template: 'orchestration',
+ *   platform: 'claude',
+ *   projectPath: '/path/to/project',
+ *   args: [
+ *     { name: 'target', description: 'Target environment', required: true },
+ *   ],
+ *   options: [
+ *     { name: 'dry-run', description: 'Preview changes', type: 'boolean' },
+ *   ],
+ * });
+ *
+ * // Deploy the command
+ * const result = await deployCommand(command, { backup: true });
+ * if (result.success) {
+ *   console.log(`Command deployed to ${result.command.path}`);
+ * }
+ * ```
+ *
+ * @module commandsmith
+ */
+// Export template functions
+export { generateFrontmatter, generateArgumentsSection, generateOptionsSection, generateUtilityTemplate, generateTransformationTemplate, generateOrchestrationTemplate, generateCommandContent, } from './templates.js';
+// Export generator functions
+export { validateCommand, generateCommand, deployCommand, generateAndDeploy, listCommands, } from './generator.js';
+// Note: Platform type is exported from agentsmith to avoid conflicts with toolsmith
+// Export platform utilities (re-export from shared location)
+export { getCommandsDirectory, getAgentsDirectory, getSkillsDirectory, getFileExtension, getRulesDirectory, usesAggregatedFiles, getConfigFileName, getPlatformDirectories, } from '../platform-paths.js';
+//# sourceMappingURL=index.js.map