@deimoscloud/coreai 0.1.0

package/src/skills/generator.ts

@@ -0,0 +1,491 @@
+/**
+ * Skill Generator
+ *
+ * Generates Claude skills from templates based on project configuration.
+ * Skills are output to .claude/commands/ directory.
+ */
+
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, statSync } from 'fs';
+import { join, basename } from 'path';
+import type { ResolvedCoreAIConfig } from '../config/types.js';
+import type {
+  SkillTemplate,
+  SkillVariables,
+  GenerateSkillsOptions,
+  GenerateSkillsResult,
+  GeneratedSkill,
+  SkillDependency,
+} from './types.js';
+import { builtInSkills } from './templates.js';
+
+/**
+ * Extract variables from config for template substitution
+ */
+export function extractVariables(config?: ResolvedCoreAIConfig | null): SkillVariables {
+  const vars: SkillVariables = {};
+
+  if (!config) {
+    return vars;
+  }
+
+  // Project variables
+  vars.PROJECT_NAME = config.project.name;
+  vars.PROJECT_ROOT = config.project.root;
+  if (config.project.type) {
+    vars.PROJECT_TYPE = config.project.type;
+  }
+
+  // Issue tracker variables
+  if (config.integrations?.issue_tracker) {
+    const tracker = config.integrations.issue_tracker;
+    if (tracker.config?.project_key) {
+      vars.JIRA_PROJECT = tracker.config.project_key;
+    }
+    if (tracker.config?.base_url) {
+      vars.JIRA_URL = tracker.config.base_url;
+    }
+  }
+
+  // Git variables
+  if (config.integrations?.git) {
+    const git = config.integrations.git;
+    if (git.config?.repo) {
+      vars.GITHUB_REPO = git.config.repo;
+    }
+    if (git.config?.owner) {
+      vars.GITHUB_OWNER = git.config.owner;
+    }
+    if (git.config?.default_branch) {
+      vars.DEFAULT_BRANCH = git.config.default_branch;
+    }
+  }
+
+  // Documentation variables
+  if (config.integrations?.documentation) {
+    const docs = config.integrations.documentation;
+    if (docs.config?.space_key) {
+      vars.CONFLUENCE_SPACE = docs.config.space_key;
+    }
+    if (docs.config?.base_url) {
+      vars.CONFLUENCE_URL = docs.config.base_url;
+    }
+    if (docs.config?.base_path) {
+      vars.DOCS_PATH = docs.config.base_path;
+    }
+  }
+
+  // Quality gate commands
+  if (config.quality_gates) {
+    const gates = config.quality_gates;
+    // Map common gate names to variables
+    const gateMappings: Record<string, keyof SkillVariables> = {
+      lint: 'LINT_CMD',
+      test: 'TEST_CMD',
+      build: 'BUILD_CMD',
+      static_analysis: 'STATIC_ANALYSIS_CMD',
+      staticAnalysis: 'STATIC_ANALYSIS_CMD',
+    };
+
+    for (const [gateName, gate] of Object.entries(gates)) {
+      const varName = gateMappings[gateName];
+      if (varName) {
+        vars[varName] = gate.command;
+      }
+    }
+  }
+
+  // Tech stack
+  if (config.tech_stack?.primary_language) {
+    vars.PRIMARY_LANGUAGE = config.tech_stack.primary_language;
+  }
+
+  return vars;
+}
+
+/**
+ * Substitute variables in template content
+ */
+export function substituteVariables(content: string, variables: SkillVariables): string {
+  let result = content;
+
+  for (const [key, value] of Object.entries(variables)) {
+    if (value !== undefined) {
+      // Replace {{VARIABLE}} pattern
+      const pattern = new RegExp(`\\{\\{${key}\\}\\}`, 'g');
+      result = result.replace(pattern, value);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Check if a skill's dependencies are satisfied
+ */
+export function checkDependencies(
+  skill: SkillTemplate,
+  config?: ResolvedCoreAIConfig | null
+): { satisfied: boolean; missing: SkillDependency[] } {
+  if (!skill.dependencies || skill.dependencies.length === 0) {
+    return { satisfied: true, missing: [] };
+  }
+
+  const missing: SkillDependency[] = [];
+
+  for (const dep of skill.dependencies) {
+    if (!dep.required) {
+      // Optional dependencies don't block skill generation
+      continue;
+    }
+
+    // Check if the integration is configured
+    let hasIntegration = false;
+
+    if (config?.integrations) {
+      switch (dep.type) {
+        case 'issue_tracker':
+          hasIntegration = !!config.integrations.issue_tracker;
+          break;
+        case 'git':
+          hasIntegration = !!config.integrations.git;
+          break;
+        case 'documentation':
+          hasIntegration = !!config.integrations.documentation;
+          break;
+        case 'state':
+          hasIntegration = !!config.integrations.state;
+          break;
+      }
+    }
+
+    if (!hasIntegration) {
+      missing.push(dep);
+    }
+  }
+
+  return {
+    satisfied: missing.length === 0,
+    missing,
+  };
+}
+
+/**
+ * Load custom skill templates from a directory
+ */
+export function loadCustomTemplates(templatesDir: string): SkillTemplate[] {
+  const templates: SkillTemplate[] = [];
+
+  if (!existsSync(templatesDir)) {
+    return templates;
+  }
+
+  const files = readdirSync(templatesDir);
+
+  for (const file of files) {
+    if (!file.endsWith('.md')) continue;
+
+    const filePath = join(templatesDir, file);
+    const stat = statSync(filePath);
+    if (!stat.isFile()) continue;
+
+    try {
+      const content = readFileSync(filePath, 'utf-8');
+      const template = parseSkillTemplate(file, content);
+      templates.push(template);
+    } catch {
+      // Skip invalid templates
+    }
+  }
+
+  return templates;
+}
+
+/**
+ * Parse a skill template from markdown content
+ */
+function parseSkillTemplate(filename: string, content: string): SkillTemplate {
+  const name = basename(filename, '.md');
+
+  // Parse frontmatter
+  const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+
+  let description = name;
+  let argumentHint: string | undefined;
+  const dependencies: SkillDependency[] = [];
+
+  if (frontmatterMatch) {
+    const frontmatter = frontmatterMatch[1] ?? '';
+    const lines = frontmatter.split(/\r?\n/);
+
+    for (const line of lines) {
+      const colonIndex = line.indexOf(':');
+      if (colonIndex === -1) continue;
+
+      const key = line.slice(0, colonIndex).trim();
+      let value = line.slice(colonIndex + 1).trim();
+
+      // Remove quotes
+      if (
+        (value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))
+      ) {
+        value = value.slice(1, -1);
+      }
+
+      switch (key) {
+        case 'description':
+          description = value;
+          break;
+        case 'argument-hint':
+          argumentHint = value;
+          break;
+        case 'requires':
+          if (value.startsWith('[') && value.endsWith(']')) {
+            const items = value
+              .slice(1, -1)
+              .split(',')
+              .map((s) => s.trim().replace(/['"]/g, ''));
+            for (const item of items) {
+              if (item) {
+                dependencies.push({
+                  type: mapIntegrationName(item),
+                  required: true,
+                });
+              }
+            }
+          }
+          break;
+        case 'optional':
+          if (value.startsWith('[') && value.endsWith(']')) {
+            const items = value
+              .slice(1, -1)
+              .split(',')
+              .map((s) => s.trim().replace(/['"]/g, ''));
+            for (const item of items) {
+              if (item) {
+                dependencies.push({
+                  type: mapIntegrationName(item),
+                  required: false,
+                });
+              }
+            }
+          }
+          break;
+      }
+    }
+  }
+
+  const template: SkillTemplate = {
+    name,
+    description,
+    category: 'custom',
+    content,
+  };
+
+  if (argumentHint) {
+    template.argumentHint = argumentHint;
+  }
+
+  if (dependencies.length > 0) {
+    template.dependencies = dependencies;
+  }
+
+  return template;
+}
+
+/**
+ * Map integration name to adapter type
+ */
+function mapIntegrationName(name: string): 'issue_tracker' | 'git' | 'documentation' | 'state' {
+  const lower = name.toLowerCase();
+
+  if (['jira', 'linear', 'issue_tracker', 'issues', 'github-issues'].includes(lower)) {
+    return 'issue_tracker';
+  }
+  if (['git', 'github', 'gitlab', 'bitbucket'].includes(lower)) {
+    return 'git';
+  }
+  if (['docs', 'documentation', 'confluence', 'notion', 'wiki'].includes(lower)) {
+    return 'documentation';
+  }
+
+  return 'state';
+}
+
+/**
+ * Generate skills from templates
+ */
+export function generateSkills(
+  config: ResolvedCoreAIConfig | undefined,
+  options: GenerateSkillsOptions = {}
+): GenerateSkillsResult {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const outputDir = options.outputDir ?? join(projectRoot, '.claude', 'commands');
+  const includeCoreSkills = options.includeCoreSkills ?? true;
+  const includeOptionalSkills = options.includeOptionalSkills ?? true;
+  const overwrite = options.overwrite ?? false;
+
+  const result: GenerateSkillsResult = {
+    generated: [],
+    errors: [],
+    variables: {},
+  };
+
+  // Extract variables from config
+  const variables = extractVariables(config);
+
+  // Merge custom variables
+  if (options.variables) {
+    Object.assign(variables, options.variables);
+  }
+
+  result.variables = variables;
+
+  // Collect templates to generate
+  let templates: SkillTemplate[] = [];
+
+  // Add built-in skills
+  if (includeCoreSkills) {
+    templates.push(...builtInSkills.filter((s) => s.category === 'core'));
+  }
+  if (includeOptionalSkills) {
+    templates.push(...builtInSkills.filter((s) => s.category === 'optional'));
+  }
+
+  // Add custom templates
+  if (options.customTemplatesDir && existsSync(options.customTemplatesDir)) {
+    templates.push(...loadCustomTemplates(options.customTemplatesDir));
+  }
+
+  // Filter to specific skills if requested
+  if (options.skills && options.skills.length > 0) {
+    const skillsToInclude = options.skills;
+    templates = templates.filter((t) => skillsToInclude.includes(t.name));
+  }
+
+  // Ensure output directory exists
+  if (!existsSync(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+  }
+
+  // Generate each skill
+  for (const template of templates) {
+    try {
+      const generated = generateSkill(template, variables, config, outputDir, overwrite);
+      result.generated.push(generated);
+    } catch (error) {
+      result.errors.push({
+        name: template.name,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Generate a single skill from a template
+ */
+function generateSkill(
+  template: SkillTemplate,
+  variables: SkillVariables,
+  config: ResolvedCoreAIConfig | undefined,
+  outputDir: string,
+  overwrite: boolean
+): GeneratedSkill {
+  const outputPath = join(outputDir, `${template.name}.md`);
+
+  // Check if file exists and we shouldn't overwrite
+  if (existsSync(outputPath) && !overwrite) {
+    return {
+      name: template.name,
+      category: template.category,
+      outputPath,
+      action: 'skipped',
+      skipReason: 'File already exists',
+    };
+  }
+
+  // Check dependencies
+  const { satisfied, missing } = checkDependencies(template, config);
+
+  if (!satisfied) {
+    const missingTypes = missing.map((d) => d.type).join(', ');
+    return {
+      name: template.name,
+      category: template.category,
+      outputPath,
+      action: 'skipped',
+      skipReason: `Missing required integrations: ${missingTypes}`,
+    };
+  }
+
+  // Substitute variables in content
+  const content = substituteVariables(template.content, variables);
+
+  // Check if content changed (for update vs create)
+  const isUpdate = existsSync(outputPath);
+
+  // Write the skill file
+  writeFileSync(outputPath, content, 'utf-8');
+
+  return {
+    name: template.name,
+    category: template.category,
+    outputPath,
+    action: isUpdate ? 'updated' : 'created',
+  };
+}
+
+/**
+ * Format skill generation result for display
+ */
+export function formatGenerateResult(result: GenerateSkillsResult): string {
+  const lines: string[] = [];
+
+  const created = result.generated.filter((g) => g.action === 'created');
+  const updated = result.generated.filter((g) => g.action === 'updated');
+  const skipped = result.generated.filter((g) => g.action === 'skipped');
+
+  if (created.length > 0) {
+    lines.push(`Created ${created.length} skill(s):`);
+    for (const skill of created) {
+      lines.push(`  ✓ ${skill.name}`);
+    }
+    lines.push('');
+  }
+
+  if (updated.length > 0) {
+    lines.push(`Updated ${updated.length} skill(s):`);
+    for (const skill of updated) {
+      lines.push(`  ✓ ${skill.name}`);
+    }
+    lines.push('');
+  }
+
+  if (skipped.length > 0) {
+    lines.push(`Skipped ${skipped.length} skill(s):`);
+    for (const skill of skipped) {
+      lines.push(`  - ${skill.name}: ${skill.skipReason}`);
+    }
+    lines.push('');
+  }
+
+  if (result.errors.length > 0) {
+    lines.push(`Failed to generate ${result.errors.length} skill(s):`);
+    for (const error of result.errors) {
+      lines.push(`  ✗ ${error.name}: ${error.error}`);
+    }
+    lines.push('');
+  }
+
+  const total = created.length + updated.length;
+  if (total > 0) {
+    lines.push(`Generated ${total} skill(s) to .claude/commands/`);
+  } else if (result.generated.length === 0 && result.errors.length === 0) {
+    lines.push('No skills to generate.');
+  }
+
+  return lines.join('\n');
+}

package/src/skills/index.ts

@@ -0,0 +1,27 @@
+/**
+ * Skills Module
+ *
+ * Generates Claude skills from templates based on project configuration.
+ */
+
+export {
+  extractVariables,
+  substituteVariables,
+  checkDependencies,
+  loadCustomTemplates,
+  generateSkills,
+  formatGenerateResult,
+} from './generator.js';
+
+export { builtInSkills } from './templates.js';
+
+export type {
+  SkillTemplate,
+  SkillVariables,
+  SkillCategory,
+  SkillDependency,
+  GenerateSkillsOptions,
+  GenerateSkillsResult,
+  GeneratedSkill,
+  SkillError,
+} from './types.js';