@deimoscloud/coreai 0.1.0

package/src/cli/commands/skills.ts

@@ -0,0 +1,348 @@
+/**
+ * Skills Command
+ *
+ * Generates Claude skills from templates based on project configuration.
+ */
+
+import { configExists, loadConfig, ConfigError } from '../../config/loader.js';
+import type { ResolvedCoreAIConfig } from '../../config/types.js';
+import {
+  generateSkills,
+  formatGenerateResult,
+  builtInSkills,
+  loadCustomTemplates,
+  type GenerateSkillsOptions,
+  type GenerateSkillsResult,
+} from '../../skills/index.js';
+
+/**
+ * Options for skills generate command
+ */
+export interface SkillsGenerateOptions {
+  /**
+   * Project root directory
+   */
+  projectRoot?: string;
+
+  /**
+   * Output directory for generated skills
+   */
+  outputDir?: string;
+
+  /**
+   * Directory containing custom skill templates
+   */
+  customTemplatesDir?: string;
+
+  /**
+   * Only generate specific skills
+   */
+  skills?: string[];
+
+  /**
+   * Include core skills (default: true)
+   */
+  includeCoreSkills?: boolean;
+
+  /**
+   * Include optional skills (default: true)
+   */
+  includeOptionalSkills?: boolean;
+
+  /**
+   * Overwrite existing skill files
+   */
+  overwrite?: boolean;
+
+  /**
+   * Additional variables for template substitution
+   */
+  variables?: Record<string, string>;
+}
+
+/**
+ * Result of skills generate command
+ */
+export interface SkillsGenerateResult {
+  success: boolean;
+  result?: GenerateSkillsResult;
+  config?: ResolvedCoreAIConfig;
+  error?: string;
+  warnings?: string[];
+}
+
+/**
+ * Generate skills from templates
+ */
+export function skillsGenerate(options: SkillsGenerateOptions = {}): SkillsGenerateResult {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const warnings: string[] = [];
+
+  // Load config if available
+  let config: ResolvedCoreAIConfig | undefined;
+  if (configExists(projectRoot)) {
+    try {
+      config = loadConfig(projectRoot);
+    } catch (error) {
+      if (error instanceof ConfigError) {
+        return {
+          success: false,
+          error: `Configuration error: ${error.message}`,
+        };
+      }
+      return {
+        success: false,
+        error: `Failed to load config: ${error instanceof Error ? error.message : String(error)}`,
+      };
+    }
+  } else {
+    warnings.push('No configuration file found. Generating skills with defaults.');
+  }
+
+  // Set up generate options
+  const generateOptions: GenerateSkillsOptions = {
+    projectRoot,
+    includeCoreSkills: options.includeCoreSkills ?? true,
+    includeOptionalSkills: options.includeOptionalSkills ?? true,
+    overwrite: options.overwrite ?? false,
+  };
+
+  if (options.outputDir) {
+    generateOptions.outputDir = options.outputDir;
+  }
+
+  if (options.customTemplatesDir) {
+    generateOptions.customTemplatesDir = options.customTemplatesDir;
+  }
+
+  if (options.skills && options.skills.length > 0) {
+    generateOptions.skills = options.skills;
+  }
+
+  if (options.variables) {
+    generateOptions.variables = options.variables;
+  }
+
+  // Generate skills
+  try {
+    const result = generateSkills(config, generateOptions);
+
+    // Check for errors
+    if (result.errors.length > 0) {
+      return {
+        success: false,
+        result,
+        config,
+        error: `Failed to generate ${result.errors.length} skill(s)`,
+        warnings: warnings.length > 0 ? warnings : undefined,
+      };
+    }
+
+    return {
+      success: true,
+      result,
+      config,
+      warnings: warnings.length > 0 ? warnings : undefined,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Skill generation failed: ${error instanceof Error ? error.message : String(error)}`,
+      warnings: warnings.length > 0 ? warnings : undefined,
+    };
+  }
+}
+
+/**
+ * Format skills generate result for display
+ */
+export function formatSkillsGenerateResult(result: SkillsGenerateResult): string {
+  const lines: string[] = [];
+
+  // Warnings
+  if (result.warnings && result.warnings.length > 0) {
+    for (const warning of result.warnings) {
+      lines.push(`⚠ ${warning}`);
+    }
+    lines.push('');
+  }
+
+  if (!result.success) {
+    lines.push(`Skill generation failed: ${result.error}`);
+
+    // Show individual errors
+    if (result.result?.errors && result.result.errors.length > 0) {
+      lines.push('');
+      for (const error of result.result.errors) {
+        lines.push(`  ✗ ${error.name}: ${error.error}`);
+      }
+    }
+
+    return lines.join('\n');
+  }
+
+  // Use the generator's format function for the detailed output
+  if (result.result) {
+    return formatGenerateResult(result.result);
+  }
+
+  lines.push('No skills to generate.');
+  return lines.join('\n');
+}
+
+/**
+ * List available skills
+ */
+export interface SkillsListOptions {
+  /**
+   * Project root directory
+   */
+  projectRoot?: string;
+
+  /**
+   * Directory containing custom skill templates
+   */
+  customTemplatesDir?: string;
+
+  /**
+   * Include core skills
+   */
+  includeCoreSkills?: boolean;
+
+  /**
+   * Include optional skills
+   */
+  includeOptionalSkills?: boolean;
+}
+
+/**
+ * Information about an available skill
+ */
+export interface SkillInfo {
+  name: string;
+  description: string;
+  category: string;
+  dependencies?: string[];
+  argumentHint?: string;
+}
+
+/**
+ * Result of skills list command
+ */
+export interface SkillsListResult {
+  success: boolean;
+  skills?: SkillInfo[];
+  error?: string;
+}
+
+/**
+ * List available skills
+ */
+export function skillsList(options: SkillsListOptions = {}): SkillsListResult {
+  try {
+    const skills: SkillInfo[] = [];
+
+    // Add built-in skills
+    const includeCoreSkills = options.includeCoreSkills ?? true;
+    const includeOptionalSkills = options.includeOptionalSkills ?? true;
+
+    for (const skill of builtInSkills) {
+      if (skill.category === 'core' && !includeCoreSkills) continue;
+      if (skill.category === 'optional' && !includeOptionalSkills) continue;
+
+      skills.push({
+        name: skill.name,
+        description: skill.description,
+        category: skill.category,
+        dependencies: skill.dependencies?.filter((d) => d.required).map((d) => d.type),
+        argumentHint: skill.argumentHint,
+      });
+    }
+
+    // Add custom skills if directory specified
+    if (options.customTemplatesDir) {
+      const customSkills = loadCustomTemplates(options.customTemplatesDir);
+      for (const skill of customSkills) {
+        skills.push({
+          name: skill.name,
+          description: skill.description,
+          category: skill.category,
+          dependencies: skill.dependencies?.filter((d) => d.required).map((d) => d.type),
+          argumentHint: skill.argumentHint,
+        });
+      }
+    }
+
+    return {
+      success: true,
+      skills,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to list skills: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
+/**
+ * Format skills list result for display
+ */
+export function formatSkillsListResult(result: SkillsListResult): string {
+  if (!result.success) {
+    return `Error: ${result.error}`;
+  }
+
+  if (!result.skills || result.skills.length === 0) {
+    return 'No skills available.';
+  }
+
+  const lines: string[] = [];
+  lines.push('Available skills:\n');
+
+  // Group by category
+  const coreSkills = result.skills.filter((s) => s.category === 'core');
+  const optionalSkills = result.skills.filter((s) => s.category === 'optional');
+  const customSkills = result.skills.filter((s) => s.category === 'custom');
+
+  if (coreSkills.length > 0) {
+    lines.push('Core skills:');
+    for (const skill of coreSkills) {
+      lines.push(`  ${skill.name}`);
+      lines.push(`    ${skill.description}`);
+      if (skill.argumentHint) {
+        lines.push(`    Argument: ${skill.argumentHint}`);
+      }
+    }
+    lines.push('');
+  }
+
+  if (optionalSkills.length > 0) {
+    lines.push('Optional skills:');
+    for (const skill of optionalSkills) {
+      const deps = skill.dependencies?.length
+        ? ` (requires: ${skill.dependencies.join(', ')})`
+        : '';
+      lines.push(`  ${skill.name}${deps}`);
+      lines.push(`    ${skill.description}`);
+      if (skill.argumentHint) {
+        lines.push(`    Argument: ${skill.argumentHint}`);
+      }
+    }
+    lines.push('');
+  }
+
+  if (customSkills.length > 0) {
+    lines.push('Custom skills:');
+    for (const skill of customSkills) {
+      lines.push(`  ${skill.name}`);
+      lines.push(`    ${skill.description}`);
+      if (skill.argumentHint) {
+        lines.push(`    Argument: ${skill.argumentHint}`);
+      }
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}