@open-skills-hub/cli 1.0.0

package/src/commands/create.ts

@@ -0,0 +1,490 @@
+/**
+ * Open Skills Hub CLI - Create Command
+ * Creates a new skill from template
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import * as fs from 'fs';
+import * as path from 'path';
+import inquirer from 'inquirer';
+import { isValidSkillName } from '@open-skills-hub/core';
+
+type TemplateType = 'basic' | 'with-scripts' | 'advanced';
+
+interface SkillOptions {
+  name: string;
+  description: string;
+  license?: string;
+  author?: string;
+  template: TemplateType;
+  derivedFrom?: string;
+}
+
+function generateSkillMd(options: SkillOptions): string {
+  const frontmatter: string[] = [
+    '---',
+    `name: ${options.name}`,
+    `description: ${options.description}`,
+  ];
+
+  if (options.license) {
+    frontmatter.push(`license: ${options.license}`);
+  }
+
+  if (options.derivedFrom) {
+    frontmatter.push(`derivedFrom:`);
+    frontmatter.push(`  name: ${options.derivedFrom.split('@')[0]}`);
+    frontmatter.push(`  version: ${options.derivedFrom.split('@')[1] || '1.0.0'}`);
+  }
+
+  frontmatter.push(`metadata:`);
+  if (options.author) {
+    frontmatter.push(`  author: ${options.author}`);
+  }
+  frontmatter.push(`  version: "1.0.0"`);
+  frontmatter.push('---');
+
+  const body = `
+# ${toTitleCase(options.name)}
+
+${options.description}
+
+## Overview
+
+This skill helps with [describe the main purpose].
+
+## When to Use
+
+Use this skill when:
+- [Condition 1]
+- [Condition 2]
+- [Condition 3]
+
+## Instructions
+
+### Step 1: [First Step]
+
+[Describe what to do]
+
+### Step 2: [Second Step]
+
+[Describe what to do]
+
+## Examples
+
+### Example 1
+
+**Input:**
+\`\`\`
+[Example input]
+\`\`\`
+
+**Output:**
+\`\`\`
+[Example output]
+\`\`\`
+
+## Notes
+
+- [Important note 1]
+- [Important note 2]
+`;
+
+  return frontmatter.join('\n') + '\n' + body;
+}
+
+function generateReadme(options: SkillOptions): string {
+  return `# ${toTitleCase(options.name)}
+
+${options.description}
+
+## Installation
+
+\`\`\`bash
+skills use ${options.name}
+\`\`\`
+
+## Usage
+
+This skill can be activated when [describe activation conditions].
+
+## Structure
+
+\`\`\`
+${options.name}/
+├── SKILL.md          # Skill definition
+${options.template !== 'basic' ? `├── scripts/          # Executable scripts
+` : ''}${options.template === 'advanced' ? `├── references/       # Reference documentation
+├── assets/           # Static resources
+` : ''}└── README.md         # This file
+\`\`\`
+
+## License
+
+${options.license || 'MIT'}
+`;
+}
+
+function generateLicense(license: string, author: string): string {
+  const year = new Date().getFullYear();
+  
+  if (license === 'MIT') {
+    return `MIT License
+
+Copyright (c) ${year} ${author}
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+`;
+  }
+
+  if (license === 'Apache-2.0') {
+    return `Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+Copyright ${year} ${author}
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+`;
+  }
+
+  return `Copyright (c) ${year} ${author}
+
+${license}
+`;
+}
+
+function generateSampleScript(): string {
+  return `#!/usr/bin/env python3
+"""
+Sample Script for ${'{skill_name}'}
+
+Usage:
+    python main.py <input> [options]
+
+Description:
+    This script demonstrates the basic structure for skill scripts.
+"""
+
+import sys
+import argparse
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Sample skill script')
+    parser.add_argument('input', help='Input file or data')
+    parser.add_argument('--output', '-o', help='Output file (default: stdout)')
+    parser.add_argument('--verbose', '-v', action='store_true', help='Verbose output')
+    
+    args = parser.parse_args()
+    
+    try:
+        # TODO: Implement your logic here
+        result = process(args.input, verbose=args.verbose)
+        
+        if args.output:
+            with open(args.output, 'w') as f:
+                f.write(result)
+        else:
+            print(result)
+            
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def process(input_data: str, verbose: bool = False) -> str:
+    """
+    Process the input data.
+    
+    Args:
+        input_data: The input to process
+        verbose: Whether to print verbose output
+        
+    Returns:
+        Processed result as string
+    """
+    if verbose:
+        print(f"Processing: {input_data}", file=sys.stderr)
+    
+    # TODO: Implement actual processing logic
+    return f"Processed: {input_data}"
+
+
+if __name__ == '__main__':
+    main()
+`;
+}
+
+function generateReference(): string {
+  return `# Reference Documentation
+
+## API Reference
+
+### Functions
+
+#### \`process(input, options)\`
+
+Processes the input data according to the specified options.
+
+**Parameters:**
+- \`input\` (string): The input data to process
+- \`options\` (object): Processing options
+  - \`verbose\` (boolean): Enable verbose output
+
+**Returns:**
+- \`string\`: The processed result
+
+**Example:**
+\`\`\`python
+result = process("hello", {"verbose": True})
+\`\`\`
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| \`DEBUG\` | Enable debug mode | \`false\` |
+
+## Troubleshooting
+
+### Common Issues
+
+#### Issue 1: [Description]
+
+**Solution:** [How to fix]
+
+#### Issue 2: [Description]
+
+**Solution:** [How to fix]
+`;
+}
+
+function toTitleCase(str: string): string {
+  return str
+    .split('-')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+}
+
+function validateSkillName(name: string): string | true {
+  if (!name) return 'Name is required';
+  if (name.length > 64) return 'Name must be 64 characters or less';
+  if (!isValidSkillName(name)) {
+    return 'Name must be lowercase letters, numbers, and hyphens only';
+  }
+  if (name.startsWith('-') || name.endsWith('-')) {
+    return 'Name cannot start or end with a hyphen';
+  }
+  if (name.includes('--')) {
+    return 'Name cannot contain consecutive hyphens';
+  }
+  return true;
+}
+
+export const createCommand = new Command('create')
+  .description('Create a new skill from template')
+  .argument('[name]', 'Skill name (lowercase, hyphens allowed)')
+  .option('-t, --template <template>', 'Template type: basic, with-scripts, advanced', 'basic')
+  .option('-d, --description <description>', 'Skill description')
+  .option('-l, --license <license>', 'License (MIT, Apache-2.0, etc.)')
+  .option('-a, --author <author>', 'Author name')
+  .option('--from <skill>', 'Derive from existing skill (name@version)')
+  .option('-y, --yes', 'Skip prompts and use defaults')
+  .option('-o, --output <path>', 'Output directory (default: current directory)')
+  .action(async (nameArg, options) => {
+    let skillOptions: SkillOptions;
+
+    if (options.yes && nameArg) {
+      // Non-interactive mode
+      const validation = validateSkillName(nameArg);
+      if (validation !== true) {
+        console.log(chalk.red(`Error: ${validation}`));
+        process.exit(1);
+      }
+
+      skillOptions = {
+        name: nameArg,
+        description: options.description || `A skill for ${nameArg}`,
+        license: options.license || 'MIT',
+        author: options.author || process.env.USER || 'anonymous',
+        template: options.template as TemplateType,
+        derivedFrom: options.from,
+      };
+    } else {
+      // Interactive mode
+      console.log(chalk.cyan('\n📦 Create New Skill\n'));
+
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'name',
+          message: 'Skill name:',
+          default: nameArg,
+          validate: validateSkillName,
+        },
+        {
+          type: 'input',
+          name: 'description',
+          message: 'Description:',
+          default: options.description,
+          validate: (input: string) => {
+            if (!input) return 'Description is required';
+            if (input.length > 1024) return 'Description must be 1024 characters or less';
+            return true;
+          },
+        },
+        {
+          type: 'list',
+          name: 'template',
+          message: 'Template:',
+          default: options.template,
+          choices: [
+            { name: 'Basic (SKILL.md only)', value: 'basic' },
+            { name: 'With Scripts (includes scripts/)', value: 'with-scripts' },
+            { name: 'Advanced (full structure)', value: 'advanced' },
+          ],
+        },
+        {
+          type: 'input',
+          name: 'license',
+          message: 'License:',
+          default: options.license || 'MIT',
+        },
+        {
+          type: 'input',
+          name: 'author',
+          message: 'Author:',
+          default: options.author || process.env.USER || '',
+        },
+        {
+          type: 'input',
+          name: 'derivedFrom',
+          message: 'Derived from (leave empty for none):',
+          default: options.from || '',
+        },
+      ]);
+
+      skillOptions = {
+        name: answers.name,
+        description: answers.description,
+        license: answers.license,
+        author: answers.author,
+        template: answers.template,
+        derivedFrom: answers.derivedFrom || undefined,
+      };
+    }
+
+    // Determine output directory
+    const outputBase = options.output || process.cwd();
+    const skillDir = path.join(outputBase, skillOptions.name);
+
+    // Check if directory exists
+    if (fs.existsSync(skillDir)) {
+      console.log(chalk.red(`\nError: Directory already exists: ${skillDir}`));
+      process.exit(1);
+    }
+
+    // Create directory structure
+    console.log(chalk.cyan(`\nCreating skill in ${skillDir}...\n`));
+
+    fs.mkdirSync(skillDir, { recursive: true });
+
+    // Create SKILL.md
+    const skillMdContent = generateSkillMd(skillOptions);
+    fs.writeFileSync(path.join(skillDir, 'SKILL.md'), skillMdContent);
+    console.log(chalk.green('  ✓ SKILL.md'));
+
+    // Create README.md
+    const readmeContent = generateReadme(skillOptions);
+    fs.writeFileSync(path.join(skillDir, 'README.md'), readmeContent);
+    console.log(chalk.green('  ✓ README.md'));
+
+    // Create LICENSE.txt
+    if (skillOptions.license) {
+      const licenseContent = generateLicense(skillOptions.license, skillOptions.author || 'Anonymous');
+      fs.writeFileSync(path.join(skillDir, 'LICENSE.txt'), licenseContent);
+      console.log(chalk.green('  ✓ LICENSE.txt'));
+    }
+
+    // Create template-specific directories
+    if (skillOptions.template === 'with-scripts' || skillOptions.template === 'advanced') {
+      const scriptsDir = path.join(skillDir, 'scripts');
+      fs.mkdirSync(scriptsDir, { recursive: true });
+      
+      const sampleScript = generateSampleScript().replace('{skill_name}', skillOptions.name);
+      fs.writeFileSync(path.join(scriptsDir, 'main.py'), sampleScript);
+      console.log(chalk.green('  ✓ scripts/main.py'));
+    }
+
+    if (skillOptions.template === 'advanced') {
+      // Create references directory
+      const refsDir = path.join(skillDir, 'references');
+      fs.mkdirSync(refsDir, { recursive: true });
+      
+      const referenceContent = generateReference();
+      fs.writeFileSync(path.join(refsDir, 'REFERENCE.md'), referenceContent);
+      console.log(chalk.green('  ✓ references/REFERENCE.md'));
+
+      // Create assets directory
+      const assetsDir = path.join(skillDir, 'assets');
+      fs.mkdirSync(assetsDir, { recursive: true });
+      fs.writeFileSync(path.join(assetsDir, '.gitkeep'), '');
+      console.log(chalk.green('  ✓ assets/'));
+    }
+
+    // Print success message
+    console.log(chalk.green('\n✓ Skill created successfully!\n'));
+    
+    console.log('  ' + chalk.cyan(skillOptions.name) + '/');
+    console.log('  ├── SKILL.md');
+    console.log('  ├── README.md');
+    if (skillOptions.license) {
+      console.log('  ├── LICENSE.txt');
+    }
+    if (skillOptions.template === 'with-scripts' || skillOptions.template === 'advanced') {
+      console.log('  ├── scripts/');
+      console.log('  │   └── main.py');
+    }
+    if (skillOptions.template === 'advanced') {
+      console.log('  ├── references/');
+      console.log('  │   └── REFERENCE.md');
+      console.log('  └── assets/');
+    }
+
+    console.log(chalk.cyan('\nNext steps:'));
+    console.log(`  cd ${skillOptions.name}`);
+    console.log('  # Edit SKILL.md with your skill content');
+    console.log('  skills validate .');
+    console.log('  skills publish .');
+    console.log('');
+  });

package/src/commands/feedback.ts

@@ -0,0 +1,161 @@
+/**
+ * Open Skills Hub CLI - Feedback Command
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import {
+  getStorage,
+  getConfig,
+  generateUUID,
+  now,
+  parseSkillFullName,
+  buildSkillFullName,
+} from '@open-skills-hub/core';
+import type { Feedback, FeedbackQueueItem } from '@open-skills-hub/core';
+
+export const feedbackCommand = new Command('feedback')
+  .description('Submit feedback for a skill')
+  .argument('<name>', 'Skill name')
+  .option('-v, --version <version>', 'Skill version')
+  .option('-r, --rating <rating>', 'Rating (1-5)')
+  .option('-t, --type <type>', 'Feedback type: success, failure, suggestion, bug', 'success')
+  .option('-c, --comment <comment>', 'Feedback comment')
+  .option('-i, --interactive', 'Interactive mode')
+  .action(async (name, options) => {
+    const spinner = ora('Loading skill info...').start();
+
+    try {
+      const storage = await getStorage();
+      await storage.initialize();
+
+      // Parse name
+      const { scope, name: skillName } = parseSkillFullName(name);
+      const fullName = buildSkillFullName(skillName, scope);
+
+      // Get skill
+      const skill = await storage.getSkillByName(fullName);
+      if (!skill) {
+        spinner.fail(`Skill '${fullName}' not found`);
+        process.exit(1);
+      }
+
+      // Get version
+      let version;
+      if (options.version) {
+        version = await storage.getVersion(skill.id, options.version);
+        if (!version) {
+          spinner.fail(`Version '${options.version}' not found`);
+          process.exit(1);
+        }
+      } else {
+        version = await storage.getLatestVersion(skill.id);
+        if (!version) {
+          spinner.fail('No versions found');
+          process.exit(1);
+        }
+      }
+
+      spinner.succeed(`Found ${fullName}@${version.version}`);
+
+      // Interactive mode
+      let rating = options.rating ? parseInt(options.rating, 10) : undefined;
+      let feedbackType = options.type;
+      let comment = options.comment;
+
+      if (options.interactive) {
+        const answers = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'type',
+            message: 'What type of feedback?',
+            choices: [
+              { name: '✓ Success - It worked well', value: 'success' },
+              { name: '✗ Failure - It didn\'t work', value: 'failure' },
+              { name: '💡 Suggestion - I have an idea', value: 'suggestion' },
+              { name: '🐛 Bug - Something is broken', value: 'bug' },
+            ],
+            default: feedbackType,
+          },
+          {
+            type: 'list',
+            name: 'rating',
+            message: 'How would you rate this skill?',
+            choices: [
+              { name: '⭐⭐⭐⭐⭐ (5) - Excellent', value: 5 },
+              { name: '⭐⭐⭐⭐ (4) - Good', value: 4 },
+              { name: '⭐⭐⭐ (3) - Average', value: 3 },
+              { name: '⭐⭐ (2) - Below average', value: 2 },
+              { name: '⭐ (1) - Poor', value: 1 },
+            ],
+            default: rating ?? 4,
+          },
+          {
+            type: 'input',
+            name: 'comment',
+            message: 'Any additional comments? (optional)',
+            default: comment,
+          },
+        ]);
+
+        feedbackType = answers.type;
+        rating = answers.rating;
+        comment = answers.comment || undefined;
+      }
+
+      // Validate rating
+      if (!rating || rating < 1 || rating > 5) {
+        console.log(chalk.red('Rating must be between 1 and 5'));
+        process.exit(1);
+      }
+
+      // Submit feedback
+      const submitSpinner = ora('Submitting feedback...').start();
+
+      const feedback: Feedback = {
+        id: generateUUID(),
+        skillId: skill.id,
+        skillVersion: version.version,
+        feedbackType: feedbackType as Feedback['feedbackType'],
+        rating,
+        comment,
+        context: {},
+        status: 'pending',
+        createdAt: now(),
+      };
+
+      await storage.createFeedback(feedback);
+
+      // Update skill rating
+      const feedbacks = await storage.getFeedbacks(skill.id, { limit: 1000 });
+      const ratings = feedbacks.items.map(f => f.rating).filter((r): r is number => r !== undefined);
+      const averageRating = ratings.length > 0
+        ? ratings.reduce((sum, r) => sum + r, 0) / ratings.length
+        : 0;
+
+      await storage.updateSkill(skill.id, {
+        rating: {
+          average: Math.round(averageRating * 10) / 10,
+          count: ratings.length,
+        },
+      });
+
+      submitSpinner.succeed('Feedback submitted');
+
+      console.log('\n' + chalk.gray('─'.repeat(50)));
+      console.log(chalk.bold.green('✓ Thank you for your feedback!\n'));
+      console.log(`  ${chalk.cyan('Skill:')}   ${fullName}@${version.version}`);
+      console.log(`  ${chalk.cyan('Type:')}    ${feedbackType}`);
+      console.log(`  ${chalk.cyan('Rating:')}  ${'⭐'.repeat(rating)} (${rating}/5)`);
+      if (comment) {
+        console.log(`  ${chalk.cyan('Comment:')} ${comment}`);
+      }
+      console.log(chalk.gray('─'.repeat(50)) + '\n');
+
+      await storage.close();
+    } catch (error) {
+      throw error;
+    }
+  });