@patricio0312rev/skillset 0.1.0

package/src/index.js

@@ -0,0 +1,168 @@
+/**
+ * SkillSet - Programmatic API
+ *
+ * This module exports the main functions for use by:
+ * - CLI (this package)
+ * - VSCode Extension
+ * - Other integrations
+ */
+
+const { generateSkills } = require('./lib/generator');
+const { TOOLS, DOMAINS } = require('./lib/config');
+
+/**
+ * Generate development skills configuration programmatically
+ * @param {Object} config - Configuration object
+ * @param {string} config.tool - AI tool (claude-code, cursor, copilot, other)
+ * @param {string} config.folder - Target folder name
+ * @param {string[]} config.domains - List of domains to include
+ * @param {string[]} [config.skills] - Optional: specific skills to include
+ * @returns {Promise<Object>} Result object with success status and details
+ *
+ * @example
+ * const skillset = require('@patricio0312rev/skillset');
+ *
+ * const result = await skillset.generate({
+ *   tool: 'claude-code',
+ *   folder: '.claude/skills',
+ *   domains: ['backend', 'frontend', 'testing'],
+ *   skills: ['api-endpoint-generator', 'unit-test-generator']
+ * });
+ *
+ * console.log(`Generated ${result.skillsGenerated} skills`);
+ */
+async function generate(config) {
+  // Validate config
+  const validation = validateConfig(config);
+  if (!validation.isValid) {
+    throw new Error(`Invalid configuration: ${validation.errors.join(', ')}`);
+  }
+
+  return await generateSkills(config);
+}
+
+/**
+ * Get list of available tools
+ * @returns {Object} Tools configuration
+ *
+ * @example
+ * const tools = skillset.getTools();
+ * console.log(Object.keys(tools)); // ['claude-code', 'cursor', 'copilot', 'other']
+ */
+function getTools() {
+  return { ...TOOLS };
+}
+
+/**
+ * Get list of available domains
+ * @returns {Object} Domains configuration
+ *
+ * @example
+ * const domains = skillset.getDomains();
+ * console.log(domains.backend.skills); // ['api-endpoint-generator', ...]
+ */
+function getDomains() {
+  return { ...DOMAINS };
+}
+
+/**
+ * Get skills for a specific domain
+ * @param {string} domain - Domain name
+ * @returns {string[]} List of skill names
+ *
+ * @example
+ * const skills = skillset.getSkillsForDomain('backend');
+ * console.log(skills); // ['api-endpoint-generator', 'auth-module-builder', ...]
+ */
+function getSkillsForDomain(domain) {
+  return DOMAINS[domain]?.skills || [];
+}
+
+/**
+ * Get all available skills across all domains
+ * @returns {Object} Object with domain as key and skills array as value
+ *
+ * @example
+ * const allSkills = skillset.getAllSkills();
+ * console.log(allSkills.backend); // ['api-endpoint-generator', ...]
+ */
+function getAllSkills() {
+  const result = {};
+  Object.entries(DOMAINS).forEach(([domain, info]) => {
+    result[domain] = [...info.skills];
+  });
+  return result;
+}
+
+/**
+ * Validate configuration
+ * @param {Object} config - Configuration to validate
+ * @returns {Object} Validation result with isValid and errors
+ *
+ * @example
+ * const validation = skillset.validateConfig({
+ *   tool: 'claude-code',
+ *   folder: '.claude/skills',
+ *   domains: ['backend']
+ * });
+ *
+ * if (!validation.isValid) {
+ *   console.error(validation.errors);
+ * }
+ */
+function validateConfig(config) {
+  const errors = [];
+
+  // Validate tool
+  if (!config.tool) {
+    errors.push('Tool is required');
+  } else if (!TOOLS[config.tool]) {
+    errors.push(`Invalid tool: ${config.tool}. Valid options: ${Object.keys(TOOLS).join(', ')}`);
+  }
+
+  // Validate folder
+  if (!config.folder) {
+    errors.push('Folder is required');
+  } else if (typeof config.folder !== 'string') {
+    errors.push('Folder must be a string');
+  } else if (config.folder.includes(' ')) {
+    errors.push('Folder name cannot contain spaces');
+  }
+
+  // Validate domains
+  if (!config.domains) {
+    errors.push('Domains are required');
+  } else if (!Array.isArray(config.domains)) {
+    errors.push('Domains must be an array');
+  } else if (config.domains.length === 0) {
+    errors.push('At least one domain is required');
+  } else {
+    config.domains.forEach(domain => {
+      if (!DOMAINS[domain]) {
+        errors.push(`Invalid domain: ${domain}. Valid options: ${Object.keys(DOMAINS).join(', ')}`);
+      }
+    });
+  }
+
+  // Validate skills if provided
+  if (config.skills && !Array.isArray(config.skills)) {
+    errors.push('Skills must be an array');
+  }
+
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+
+// Export all functions
+module.exports = {
+  generate,
+  getTools,
+  getDomains,
+  getSkillsForDomain,
+  getAllSkills,
+  validateConfig,
+  TOOLS,
+  DOMAINS
+};

package/src/lib/config.js

@@ -0,0 +1,200 @@
+const TOOLS = {
+  'claude-code': {
+    name: 'Claude Code',
+    folder: '.claude/skills',
+    description: 'Skills with native support',
+    fileStructure: 'multi-file',
+    fileExtension: 'SKILL.md'
+  },
+  'copilot': {
+    name: 'GitHub Copilot (Agent Skills)',
+    folder: '.github/skills',
+    description: 'Agent Skills for GitHub Copilot',
+    fileStructure: 'multi-file',
+    fileExtension: 'SKILL.md',
+    fallbackFolder: '.claude/skills'
+  },
+  'cursor': {
+    name: 'Cursor',
+    folder: '.cursor/rules',
+    description: 'Project Rules for Cursor',
+    fileStructure: 'multi-file',
+    fileExtension: 'RULE.md'
+  },
+  'other': {
+    name: 'Other AI Tools',
+    folder: '.claude/skills',
+    description: 'Universal skills format',
+    fileStructure: 'multi-file',
+    fileExtension: 'SKILL.md'
+  }
+};
+
+const DOMAINS = {
+  foundation: {
+    name: 'Foundation',
+    description: 'Project setup, development environment, and documentation',
+    skills: [
+      'changelog-writer',
+      'code-formatter-installer',
+      'codebase-summarizer',
+      'dependency-doctor',
+      'dev-environment-bootstrapper',
+      'dev-onboarding-builder',
+      'docs-starter-kit',
+      'explaining-code',
+      'git-hygiene-enforcer',
+      'project-scaffolder',
+      'repo-structure-linter'
+    ]
+  },
+  frontend: {
+    name: 'Frontend',
+    description: 'React, UI components, and user experience',
+    skills: [
+      'animation-micro-interaction-pack',
+      'component-scaffold-generator',
+      'design-to-component-translator',
+      'form-wizard-builder',
+      'frontend-refactor-planner',
+      'i18n-frontend-implementer',
+      'modal-drawer-system',
+      'page-layout-builder',
+      'state-ux-flow-builder',
+      'table-builder'
+    ]
+  },
+  backend: {
+    name: 'Backend',
+    description: 'APIs, authentication, and server-side logic',
+    skills: [
+      'api-contract-normalizer',
+      'api-endpoint-generator',
+      'auth-module-builder',
+      'background-jobs-designer',
+      'caching-strategist',
+      'error-handling-standardizer',
+      'rate-limiting-abuse-protection',
+      'rbac-permissions-builder',
+      'service-layer-extractor',
+      'webhook-receiver-hardener'
+    ]
+  },
+  'ai-engineering': {
+    name: 'AI Engineering',
+    description: 'LLMs, RAG, agents, and AI systems',
+    skills: [
+      'agent-orchestration-planner',
+      'cost-latency-optimizer',
+      'doc-to-vector-dataset-generator',
+      'evaluation-harness',
+      'guardrails-safety-filter-builder',
+      'llm-debugger',
+      'prompt-regression-tester',
+      'prompt-template-builder',
+      'rag-pipeline-builder',
+      'tool-function-schema-designer'
+    ]
+  },
+  architecture: {
+    name: 'Architecture',
+    description: 'System design, scalability, and technical decisions',
+    skills: [
+      'adr-writer',
+      'api-versioning-deprecation-planner',
+      'domain-model-boundaries-mapper',
+      'migration-planner',
+      'performance-budget-setter',
+      'reliability-strategy-builder',
+      'rfc-generator',
+      'scalability-playbook',
+      'system-design-generator',
+      'tech-debt-prioritizer'
+    ]
+  },
+  'ci-cd': {
+    name: 'CI/CD',
+    description: 'Automation, deployments, and release management',
+    skills: [
+      'artifact-sbom-publisher',
+      'caching-strategy-optimizer',
+      'deployment-checklist-generator',
+      'github-actions-pipeline-creator',
+      'monorepo-ci-optimizer',
+      'preview-environments-builder',
+      'quality-gates-enforcer',
+      'release-automation-builder',
+      'rollback-workflow-builder',
+      'secrets-env-manager'
+    ]
+  },
+  'db-management': {
+    name: 'Database Management',
+    description: 'Migrations, optimization, and data engineering',
+    skills: [
+      'backup-restore-runbook-generator',
+      'data-integrity-auditor',
+      'data-retention-archiving-planner',
+      'data-seeding-fixtures-builder',
+      'db-performance-watchlist',
+      'etl-sync-job-builder',
+      'multi-tenant-safety-checker',
+      'prisma-migration-assistant',
+      'schema-consistency-checker',
+      'sql-query-optimizer'
+    ]
+  },
+  testing: {
+    name: 'Testing',
+    description: 'Quality assurance and test coverage',
+    skills: [
+      'contract-testing-builder',
+      'coverage-strategist',
+      'e2e-test-builder',
+      'flaky-test-detective',
+      'integration-test-builder',
+      'mocking-assistant',
+      'snapshot-test-refactorer',
+      'test-data-factory-builder',
+      'test-reporting-triage-skill',
+      'unit-test-generator'
+    ]
+  },
+  security: {
+    name: 'Security',
+    description: 'Security hardening and privacy protection',
+    skills: [
+      'auth-security-reviewer',
+      'dependency-vulnerability-triage',
+      'input-validation-sanitization-auditor',
+      'pii-redaction-logging-policy-builder',
+      'rbac-policy-tester',
+      'secrets-scanner',
+      'secure-headers-csp-builder',
+      'security-incident-playbook-generator',
+      'security-pr-checklist-skill',
+      'threat-model-generator'
+    ]
+  },
+  performance: {
+    name: 'Performance',
+    description: 'Observability, monitoring, and optimization',
+    skills: [
+      'alerting-dashboard-builder',
+      'backend-latency-profiler-helper',
+      'caching-cdn-strategy-planner',
+      'capacity-planning-helper',
+      'core-web-vitals-tuner',
+      'incident-runbook-generator',
+      'load-test-scenario-builder',
+      'observability-setup',
+      'postmortem-writer',
+      'structured-logging-standardizer'
+    ]
+  }
+};
+
+module.exports = {
+  TOOLS,
+  DOMAINS
+};

package/src/lib/generator.js

@@ -0,0 +1,166 @@
+const fs = require("fs-extra");
+const path = require("path");
+const { TOOLS, DOMAINS } = require("./config");
+const { generateReadme } = require("../utils/readme");
+const { generateToolSpecificFiles } = require("../utils/tool-specific");
+
+/**
+ * Main generator function that creates skill configuration
+ * @param {Object} config - Configuration object
+ * @returns {Promise<Object>} Generation result
+ */
+async function generateSkills(config) {
+  const targetDir = path.join(process.cwd(), config.folder);
+  const result = {
+    success: false,
+    targetDir,
+    skillsGenerated: 0,
+    filesCreated: [],
+    errors: [],
+  };
+
+  try {
+    // Ensure target directory exists
+    await fs.ensureDir(targetDir);
+
+    // Generate domain folders and skill files
+    const skillResult = await generateDomainSkills(config, targetDir);
+    result.skillsGenerated = skillResult.count;
+    result.filesCreated.push(...skillResult.files);
+
+    // Generate README
+    const readmePath = path.join(targetDir, "README.md");
+    const readmeContent = generateReadme(config, result);
+    await fs.writeFile(readmePath, readmeContent);
+    result.filesCreated.push(readmePath);
+
+    // Generate tool-specific files
+    const toolFiles = await generateToolSpecificFiles(
+      config,
+      targetDir,
+      skillResult.skillsList
+    );
+    result.filesCreated.push(...toolFiles);
+
+    result.success = true;
+    return result;
+  } catch (error) {
+    result.errors.push(error.message);
+    throw error;
+  }
+}
+
+/**
+ * Generate domain folders and copy skill files
+ * @param {Object} config - Configuration object
+ * @param {string} targetDir - Target directory path
+ * @returns {Promise<Object>} Result with count and file list
+ */
+async function generateDomainSkills(config, targetDir) {
+  let count = 0;
+  const files = [];
+  const skillsList = [];
+
+  for (const domain of config.domains) {
+    const domainInfo = DOMAINS[domain];
+    if (!domainInfo) continue;
+
+    // Determine which skills to generate
+    let skillsToGenerate = domainInfo.skills;
+
+    // Filter if specific skills were selected
+    if (config.skills && config.skills.length > 0) {
+      skillsToGenerate = skillsToGenerate.filter((skill) => {
+        // Support both "skill-name" and "domain/skill-name" formats
+        return (
+          config.skills.includes(skill) ||
+          config.skills.includes(`${domain}/${skill}`)
+        );
+      });
+    }
+
+    // Copy/generate each skill file directly in target directory
+    for (const skill of skillsToGenerate) {
+      const skillFile = await generateSkillFile(domain, skill, targetDir, config);
+      if (skillFile) {
+        files.push(skillFile);
+        skillsList.push({ domain, skill, file: skillFile });
+        count++;
+      }
+    }
+  }
+
+  return { count, files, skillsList };
+}
+
+/**
+ * Generate or copy an individual skill file
+ * @param {string} domain - Domain name
+ * @param {string} skill - Skill name
+ * @param {string} domainDir - Domain directory path
+ * @param {Object} config - Configuration object
+ * @returns {Promise<string|null>} Path to created file or null
+ */
+async function generateSkillFile(domain, skill, domainDir, config) {
+  const toolInfo = TOOLS[config.tool];
+  const fileExtension = toolInfo.fileExtension || 'SKILL.md';
+
+  // Source file in templates (always SKILL.md)
+  const sourceDir = path.join(
+    __dirname,
+    "../../templates",
+    domain,
+    skill
+  );
+  const sourceFile = path.join(sourceDir, " SKILL.md");
+
+  // Target file with appropriate extension
+  const targetSkillDir = path.join(domainDir, skill);
+  const targetFile = path.join(targetSkillDir, fileExtension);
+
+  try {
+    // Ensure target skill directory exists
+    await fs.ensureDir(targetSkillDir);
+
+    // Check if template exists
+    if (await fs.pathExists(sourceFile)) {
+      let content = await fs.readFile(sourceFile, "utf8");
+
+      // Process content based on tool (e.g., rename SKILL.md to RULE.md for Cursor)
+      if (config.tool === 'cursor') {
+        // For Cursor, change the filename reference in frontmatter if needed
+        content = content.replace(/SKILL\.md/g, 'RULE.md');
+      }
+
+      await fs.writeFile(targetFile, content);
+
+      // Copy references and other folders if they exist
+      const referencesDir = path.join(sourceDir, "references");
+      if (await fs.pathExists(referencesDir)) {
+        const targetReferencesDir = path.join(targetSkillDir, "references");
+        await fs.copy(referencesDir, targetReferencesDir);
+      }
+
+      // Copy templates folder if it exists
+      const templatesDir = path.join(sourceDir, "templates");
+      if (await fs.pathExists(templatesDir)) {
+        const targetTemplatesDir = path.join(targetSkillDir, "templates");
+        await fs.copy(templatesDir, targetTemplatesDir);
+      }
+
+      return targetFile;
+    } else {
+      console.warn(`Warning: Template not found for ${domain}/${skill}`);
+      return null;
+    }
+  } catch (error) {
+    console.error(`Error generating skill ${skill}:`, error.message);
+    return null;
+  }
+}
+
+module.exports = {
+  generateSkills,
+  generateDomainSkills,
+  generateSkillFile,
+};

package/src/utils/display.js

@@ -0,0 +1,95 @@
+const chalk = require("chalk");
+
+function displayBanner() {
+  const version = require("../../package.json").version;
+  console.log(
+    chalk.cyan(
+      "\n" +
+        "  ╔═══════════════════════════════════════════╗\n" +
+        "  ║                                           ║\n" +
+        "  ║      📚  SkillSet CLI v" +
+        version.padEnd(19) +
+        "║\n" +
+        "  ║                                           ║\n" +
+        "  ║     Import development skills for         ║\n" +
+        "  ║     Claude Code, Cursor, Copilot & more   ║\n" +
+        "  ║                                           ║\n" +
+        "  ╚═══════════════════════════════════════════╝\n"
+    )
+  );
+}
+
+function displaySuccess(message) {
+  console.log(chalk.green(`\n✓ ${message}\n`));
+}
+
+function displayError(message) {
+  console.log(chalk.red(`\n✗ ${message}\n`));
+}
+
+function displayWarning(message) {
+  console.log(chalk.yellow(`\n⚠ ${message}\n`));
+}
+
+function displayInfo(message) {
+  console.log(chalk.blue(`\nℹ ${message}\n`));
+}
+
+/**
+ * Display content in a nice box with consistent formatting
+ * @param {string} title - Box title
+ * @param {string} content - Box content
+ */
+function displayBox(title, content) {
+  const lines = content.split("\n");
+
+  // Calculate max width needed
+  const contentWidth = Math.max(
+    ...lines.map((line) => stripAnsi(line).length),
+    stripAnsi(title).length
+  );
+
+  // Set minimum and maximum width
+  const minWidth = 50;
+  const maxWidth = 80;
+  const width = Math.min(Math.max(contentWidth, minWidth), maxWidth);
+
+  // Top border
+  console.log(chalk.cyan("┌" + "─".repeat(width + 2) + "┐"));
+
+  // Title
+  const titlePadded = title + " ".repeat(width - stripAnsi(title).length);
+  console.log(chalk.cyan("│ ") + chalk.bold(titlePadded) + chalk.cyan(" │"));
+
+  // Separator
+  console.log(chalk.cyan("├" + "─".repeat(width + 2) + "┤"));
+
+  // Content lines
+  lines.forEach((line) => {
+    const lineLength = stripAnsi(line).length;
+    const padding = " ".repeat(width - lineLength);
+    console.log(chalk.cyan("│ ") + line + padding + chalk.cyan(" │"));
+  });
+
+  // Bottom border
+  console.log(chalk.cyan("└" + "─".repeat(width + 2) + "┘\n"));
+}
+
+/**
+ * Strip ANSI color codes to get actual string length
+ * @param {string} str - String with potential ANSI codes
+ * @returns {string} Clean string
+ */
+function stripAnsi(str) {
+  // eslint-disable-next-line no-control-regex
+  return str.replace(/\x1B\[\d+m/g, "");
+}
+
+module.exports = {
+  displayBanner,
+  displaySuccess,
+  displayError,
+  displayWarning,
+  displayInfo,
+  displayBox,
+};