@raketa-cloud/cli 1.1.0

package/src/commands/skills/index.js

@@ -0,0 +1,89 @@
+import { createCommand } from 'commander';
+import { ListSkillsCommand } from './list/index.js';
+import { ListAllSkillsCommand } from './list-all/index.js';
+import { ListRemoteSkillsCommand } from './list-remote/index.js';
+import { NewSkillCommand } from './new/index.js';
+import { InstallSkillCommand } from './install/index.js';
+import { InstallGlobalSkillCommand } from './install-global/index.js';
+import { RemoveSkillCommand } from './rm/index.js';
+import { RemoveGlobalSkillCommand } from './rm-global/index.js';
+
+export function createSkillsCommand() {
+  const skills = createCommand('skills');
+  skills.description('Manage skills');
+
+  // LIST command
+  skills
+    .command('list')
+    .description('List local skills')
+    .action(async (options) => {
+      const command = new ListSkillsCommand(options);
+      await command.process();
+    });
+
+  // LIST-ALL command
+  skills
+    .command('list-all')
+    .description('List both local and global skills')
+    .action(async (options) => {
+      const command = new ListAllSkillsCommand(options);
+      await command.process();
+    });
+
+  // LIST-REMOTE command
+  skills
+    .command('list-remote')
+    .description('List skills from remote repository')
+    .action(async (options) => {
+      const command = new ListRemoteSkillsCommand(options);
+      await command.process();
+    });
+
+  // NEW command
+  skills
+    .command('new')
+    .description('Create a new local skill')
+    .option('--name <value>', 'Skill name')
+    .action(async (options) => {
+      const command = new NewSkillCommand(options);
+      await command.process();
+    });
+
+  // INSTALL command
+  skills
+    .command('install <skillName>')
+    .description('Install a skill from remote repository to local .claude/skills/')
+    .action(async (skillName, options) => {
+      const command = new InstallSkillCommand({ skillName });
+      await command.process();
+    });
+
+  // INSTALL-GLOBAL command
+  skills
+    .command('install-global <skillName>')
+    .description('Install a skill from remote repository to global ~/.claude/skills/')
+    .action(async (skillName, options) => {
+      const command = new InstallGlobalSkillCommand({ skillName });
+      await command.process();
+    });
+
+  // RM command
+  skills
+    .command('rm <skillName>')
+    .description('Remove a skill from local .claude/skills/')
+    .action(async (skillName, options) => {
+      const command = new RemoveSkillCommand({ skillName });
+      await command.process();
+    });
+
+  // RM-GLOBAL command
+  skills
+    .command('rm-global <skillName>')
+    .description('Remove a skill from global ~/.claude/skills/')
+    .action(async (skillName, options) => {
+      const command = new RemoveGlobalSkillCommand({ skillName });
+      await command.process();
+    });
+
+  return skills;
+}

package/src/commands/skills/install/index.js

@@ -0,0 +1,40 @@
+import { Command } from '../../../lib/Command.js';
+import { join } from 'path';
+import { homedir } from 'os';
+import { ensureRemoteRepo, copySkillFromCache } from '../../../lib/skillsUtils.js';
+
+export class InstallSkillCommand extends Command {
+  async process() {
+    const options = this.getOptions();
+
+    // Validate skillName
+    if (!options.skillName) {
+      console.error('Error: skill name is required');
+      console.error('Usage: skills install <skillName>');
+      process.exit(1);
+    }
+
+    const skillName = options.skillName;
+    const REMOTE_REPO = 'git@github.com:studioraketa/claude-skills.git';
+    const cachePath = join(homedir(), '.claude', 'cache', 'remote-skills');
+    const destPath = join(this.getCWD(), '.claude', 'skills');
+
+    try {
+      // Ensure repo is cloned/updated
+      await ensureRemoteRepo(REMOTE_REPO, cachePath);
+
+      // Copy skill from cache to local
+      await copySkillFromCache(skillName, cachePath, destPath, true);
+
+      // Output success message
+      const installedPath = join(destPath, skillName);
+      console.log(`✓ Installed skill '${skillName}' to ${installedPath}`);
+      console.log();
+      console.log('The skill is now available to Claude in this directory.');
+
+    } catch (error) {
+      console.error(`Error: ${error.message}`);
+      process.exit(1);
+    }
+  }
+}

package/src/commands/skills/install-global/index.js

@@ -0,0 +1,40 @@
+import { Command } from '../../../lib/Command.js';
+import { join } from 'path';
+import { homedir } from 'os';
+import { ensureRemoteRepo, copySkillFromCache } from '../../../lib/skillsUtils.js';
+
+export class InstallGlobalSkillCommand extends Command {
+  async process() {
+    const options = this.getOptions();
+
+    // Validate skillName
+    if (!options.skillName) {
+      console.error('Error: skill name is required');
+      console.error('Usage: skills install-global <skillName>');
+      process.exit(1);
+    }
+
+    const skillName = options.skillName;
+    const REMOTE_REPO = 'git@github.com:studioraketa/claude-skills.git';
+    const cachePath = join(homedir(), '.claude', 'cache', 'remote-skills');
+    const destPath = join(homedir(), '.claude', 'skills');
+
+    try {
+      // Ensure repo is cloned/updated
+      await ensureRemoteRepo(REMOTE_REPO, cachePath);
+
+      // Copy skill from cache to global
+      await copySkillFromCache(skillName, cachePath, destPath, true);
+
+      // Output success message
+      const installedPath = join(destPath, skillName);
+      console.log(`✓ Installed skill '${skillName}' globally to ${installedPath}`);
+      console.log();
+      console.log('The skill is now available to Claude globally.');
+
+    } catch (error) {
+      console.error(`Error: ${error.message}`);
+      process.exit(1);
+    }
+  }
+}

package/src/commands/skills/list/index.js

@@ -0,0 +1,43 @@
+import { Command } from '../../../lib/Command.js';
+import { access } from 'fs/promises';
+import { join } from 'path';
+import { getSkillsWithDescriptions, formatSkillWithDescription } from '../../../lib/skillsUtils.js';
+
+export class ListSkillsCommand extends Command {
+  async process() {
+    try {
+      const cwd = this.getCWD();
+      const skillsPath = join(cwd, '.claude', 'skills');
+
+      // Check if skills directory exists (graceful handling)
+      try {
+        await access(skillsPath);
+      } catch {
+        console.log('No local skills found');
+        console.log(`(Looked in: ${skillsPath})`);
+        return;
+      }
+
+      // Get skills with descriptions
+      const validSkills = await getSkillsWithDescriptions(skillsPath);
+
+      if (validSkills.length === 0) {
+        console.log('No local skills found');
+        return;
+      }
+
+      // Print header
+      console.log(`Local skills (${validSkills.length}):`);
+      console.log();
+
+      // Print each skill with description
+      validSkills.forEach(({ name, description }) => {
+        console.log(formatSkillWithDescription(name, description));
+      });
+
+    } catch (error) {
+      console.error('Error listing local skills:', error.message);
+      process.exit(1);
+    }
+  }
+}

package/src/commands/skills/list-all/index.js

@@ -0,0 +1,56 @@
+import { Command } from '../../../lib/Command.js';
+import { join } from 'path';
+import { homedir } from 'os';
+import { getSkillsWithDescriptions, formatSkillWithDescription } from '../../../lib/skillsUtils.js';
+
+export class ListAllSkillsCommand extends Command {
+  async process() {
+    try {
+      const cwd = this.getCWD();
+      const localSkillsPath = join(cwd, '.claude', 'skills');
+      const globalSkillsPath = join(homedir(), '.claude', 'skills');
+
+      // Get local skills
+      const localSkills = await this.getSkillsFromPath(localSkillsPath);
+
+      // Get global skills
+      const globalSkills = await this.getSkillsFromPath(globalSkillsPath);
+
+      // Display local skills section
+      if (localSkills.length > 0) {
+        console.log(`Local skills (${localSkills.length}):`);
+        console.log();
+        localSkills.forEach(({ name, description }) => {
+          console.log(formatSkillWithDescription(name, description));
+        });
+      } else {
+        console.log('Local skills (0):');
+        console.log();
+        console.log('  No local skills');
+      }
+      console.log();
+
+      // Display global skills section
+      if (globalSkills.length > 0) {
+        console.log(`Global skills (${globalSkills.length}):`);
+        console.log();
+        globalSkills.forEach(({ name, description }) => {
+          console.log(formatSkillWithDescription(name, description));
+        });
+      } else {
+        console.log('Global skills (0):');
+        console.log();
+        console.log('  No global skills');
+      }
+
+    } catch (error) {
+      console.error('Error listing skills:', error.message);
+      process.exit(1);
+    }
+  }
+
+  async getSkillsFromPath(skillsPath) {
+    // Use shared utility to get skills with descriptions
+    return await getSkillsWithDescriptions(skillsPath);
+  }
+}

package/src/commands/skills/list-remote/index.js

@@ -0,0 +1,35 @@
+import { Command } from '../../../lib/Command.js';
+import { join } from 'path';
+import { homedir } from 'os';
+import { ensureRemoteRepo, getSkillsWithDescriptions, formatSkillWithDescription } from '../../../lib/skillsUtils.js';
+
+export class ListRemoteSkillsCommand extends Command {
+  async process() {
+    const REMOTE_REPO = 'git@github.com:studioraketa/claude-skills.git';
+    const cachePath = join(homedir(), '.claude', 'cache', 'remote-skills');
+
+    try {
+      // Ensure repo is cloned/updated
+      await ensureRemoteRepo(REMOTE_REPO, cachePath);
+
+      // Get skills with descriptions
+      const skills = await getSkillsWithDescriptions(cachePath);
+
+      // Display results
+      if (skills.length === 0) {
+        console.log('No remote skills found');
+        return;
+      }
+
+      console.log(`Remote skills (${skills.length}):`);
+      console.log();
+      skills.forEach(({ name, description }) => {
+        console.log(formatSkillWithDescription(name, description));
+      });
+
+    } catch (error) {
+      console.error(`Error: ${error.message}`);
+      process.exit(1);
+    }
+  }
+}

package/src/commands/skills/new/index.js

@@ -0,0 +1,109 @@
+import { Command } from '../../../lib/Command.js';
+import { mkdir, writeFile, access } from 'fs/promises';
+import { join } from 'path';
+
+export class NewSkillCommand extends Command {
+  async process() {
+    const options = this.getOptions();
+
+    // Validate --name option
+    if (!options.name) {
+      console.error('Error: --name option is required');
+      console.error('Usage: skills new --name "my-skill"');
+      process.exit(1);
+    }
+
+    // Normalize and validate skill name
+    const skillName = normalizeSkillName(options.name);
+
+    if (!isValidSkillName(skillName)) {
+      console.error('Error: Skill name must contain only lowercase letters, numbers, and hyphens');
+      console.error('Examples: my-skill, code-review, bug-finder');
+      process.exit(1);
+    }
+
+    // Get CWD and build target path
+    const cwd = this.getCWD();
+    const skillsDir = join(cwd, '.claude', 'skills');
+    const skillPath = join(skillsDir, skillName);
+    const skillMdPath = join(skillPath, 'SKILL.md');
+
+    try {
+      // Create .claude/skills directory if it doesn't exist
+      await mkdir(skillsDir, { recursive: true });
+
+      // Check if skill already exists
+      try {
+        await access(skillPath);
+        console.error(`Error: Skill already exists at ${skillPath}`);
+        process.exit(1);
+      } catch {
+        // Skill doesn't exist, proceed
+      }
+
+      // Create skill directory
+      await mkdir(skillPath);
+
+      // Generate SKILL.md content
+      const skillContent = generateSkillTemplate(skillName);
+
+      // Write SKILL.md file
+      await writeFile(skillMdPath, skillContent, 'utf-8');
+
+      // Output success message
+      console.log(`✓ Created skill at: ${skillPath}`);
+      console.log();
+      console.log('File created:');
+      console.log('  - SKILL.md');
+      console.log();
+      console.log('Next steps:');
+      console.log(`1. Edit ${skillMdPath}`);
+      console.log('2. Update the name, description, and instructions');
+      console.log('3. The skill will be automatically available to Claude');
+
+    } catch (error) {
+      console.error('Error creating skill:', error.message);
+      process.exit(1);
+    }
+  }
+}
+
+// Helper function to normalize skill name
+function normalizeSkillName(name) {
+  // Convert to lowercase
+  let normalized = name.toLowerCase();
+
+  // Replace underscores and spaces with hyphens
+  normalized = normalized.replace(/[_\s]+/g, '-');
+
+  // Remove any non-alphanumeric characters except hyphens
+  normalized = normalized.replace(/[^a-z0-9-]/g, '');
+
+  // Remove leading/trailing hyphens
+  normalized = normalized.replace(/^-+|-+$/g, '');
+
+  // Collapse multiple hyphens
+  normalized = normalized.replace(/-+/g, '-');
+
+  return normalized;
+}
+
+// Helper function to validate skill name
+function isValidSkillName(name) {
+  // Must match: lowercase letters, numbers, hyphens only
+  // Must not be empty
+  // Must not start or end with hyphen
+  const validNameRegex = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+  return validNameRegex.test(name);
+}
+
+// Template generator
+function generateSkillTemplate(skillName) {
+  return `---
+name: ${skillName}
+description: Replace with description of the skill and when Claude should use it.
+---
+
+# Insert instructions below
+`;
+}

package/src/commands/skills/rm/index.js

@@ -0,0 +1,65 @@
+import { Command } from '../../../lib/Command.js';
+import { join } from 'path';
+import { access, rm } from 'fs/promises';
+import { parseSkillMetadata } from '../../../lib/skillsUtils.js';
+
+export class RemoveSkillCommand extends Command {
+  async process() {
+    const options = this.getOptions();
+
+    // Validate skillName
+    if (!options.skillName) {
+      console.error('Error: skill name is required');
+      console.error('Usage: skills rm <skillName>');
+      process.exit(1);
+    }
+
+    const skillName = options.skillName;
+    const skillsPath = join(this.getCWD(), '.claude', 'skills');
+    const skillPath = join(skillsPath, skillName);
+
+    try {
+      // Check if skills directory exists
+      try {
+        await access(skillsPath);
+      } catch {
+        console.error(`Error: No skills directory found at ${skillsPath}`);
+        console.error();
+        console.error('There are no skills to remove');
+        process.exit(1);
+      }
+
+      // Check if specific skill directory exists
+      try {
+        await access(skillPath);
+      } catch {
+        console.error(`Error: Skill '${skillName}' not found at ${skillPath}`);
+        console.error();
+        console.error(`Run 'skills list' to see available local skills`);
+        process.exit(1);
+      }
+
+      // Optional: Check for valid SKILL.md (warning only)
+      try {
+        const skillMdPath = join(skillPath, 'SKILL.md');
+        await access(skillMdPath);
+        const metadata = await parseSkillMetadata(skillMdPath);
+        if (!metadata) {
+          console.warn(`Warning: ${skillName} has invalid SKILL.md, removing anyway`);
+        }
+      } catch {
+        console.warn(`Warning: ${skillName} does not have SKILL.md, removing anyway`);
+      }
+
+      // Remove skill directory
+      await rm(skillPath, { recursive: true, force: true });
+
+      // Output success message
+      console.log(`✓ Removed skill '${skillName}' from ${skillPath}`);
+
+    } catch (error) {
+      console.error(`Error: Failed to remove skill '${skillName}': ${error.message}`);
+      process.exit(1);
+    }
+  }
+}

package/src/commands/skills/rm-global/index.js

@@ -0,0 +1,66 @@
+import { Command } from '../../../lib/Command.js';
+import { join } from 'path';
+import { homedir } from 'os';
+import { access, rm } from 'fs/promises';
+import { parseSkillMetadata } from '../../../lib/skillsUtils.js';
+
+export class RemoveGlobalSkillCommand extends Command {
+  async process() {
+    const options = this.getOptions();
+
+    // Validate skillName
+    if (!options.skillName) {
+      console.error('Error: skill name is required');
+      console.error('Usage: skills rm-global <skillName>');
+      process.exit(1);
+    }
+
+    const skillName = options.skillName;
+    const skillsPath = join(homedir(), '.claude', 'skills');
+    const skillPath = join(skillsPath, skillName);
+
+    try {
+      // Check if skills directory exists
+      try {
+        await access(skillsPath);
+      } catch {
+        console.error(`Error: No skills directory found at ${skillsPath}`);
+        console.error();
+        console.error('There are no skills to remove');
+        process.exit(1);
+      }
+
+      // Check if specific skill directory exists
+      try {
+        await access(skillPath);
+      } catch {
+        console.error(`Error: Skill '${skillName}' not found at ${skillPath}`);
+        console.error();
+        console.error(`Run 'skills list-all' to see available global skills`);
+        process.exit(1);
+      }
+
+      // Optional: Check for valid SKILL.md (warning only)
+      try {
+        const skillMdPath = join(skillPath, 'SKILL.md');
+        await access(skillMdPath);
+        const metadata = await parseSkillMetadata(skillMdPath);
+        if (!metadata) {
+          console.warn(`Warning: ${skillName} has invalid SKILL.md, removing anyway`);
+        }
+      } catch {
+        console.warn(`Warning: ${skillName} does not have SKILL.md, removing anyway`);
+      }
+
+      // Remove skill directory
+      await rm(skillPath, { recursive: true, force: true });
+
+      // Output success message
+      console.log(`✓ Removed global skill '${skillName}' from ${skillPath}`);
+
+    } catch (error) {
+      console.error(`Error: Failed to remove skill '${skillName}': ${error.message}`);
+      process.exit(1);
+    }
+  }
+}

package/src/commands/widgets/index.js

@@ -0,0 +1,29 @@
+import { createCommand } from 'commander';
+import { ListWidgetsCommand } from './list/index.js';
+import { NewWidgetCommand } from './new/index.js';
+
+export function createWidgetsCommand() {
+  const widgets = createCommand('widgets');
+  widgets.description('Manage widgets');
+
+  // LIST command
+  widgets
+    .command('list')
+    .description('List all widgets')
+    .action(async (options) => {
+      const command = new ListWidgetsCommand(options);
+      await command.process();
+    });
+
+  // NEW command
+  widgets
+    .command('new')
+    .description('Create a new widget')
+    .option('--name <value>', 'Widget name')
+    .action(async (options) => {
+      const command = new NewWidgetCommand(options);
+      await command.process();
+    });
+
+  return widgets;
+}

package/src/commands/widgets/list/index.js

@@ -0,0 +1,41 @@
+import { Command } from '../../../lib/Command.js';
+import { readdir, access } from 'fs/promises';
+import { join } from 'path';
+
+export class ListWidgetsCommand extends Command {
+  async process() {
+    try {
+      const cwd = this.getCWD();
+      const widgetsPath = join(cwd, 'src', 'components', 'widgets');
+
+      // Check if widgets directory exists
+      try {
+        await access(widgetsPath);
+      } catch {
+        console.error('Error: src/components/widgets directory not found');
+        console.error(`Looking in: ${widgetsPath}`);
+        process.exit(1);
+      }
+
+      // Read directory contents
+      const items = await readdir(widgetsPath, { withFileTypes: true });
+
+      // Filter for directories only
+      const widgets = items.filter(dirent => dirent.isDirectory());
+
+      if (widgets.length === 0) {
+        console.log('No widgets found');
+        return;
+      }
+
+      // Print each widget name
+      widgets.forEach(widget => {
+        console.log(widget.name);
+      });
+
+    } catch (error) {
+      console.error('Error listing widgets:', error.message);
+      process.exit(1);
+    }
+  }
+}