@deimoscloud/coreai 0.1.9 → 0.1.11

package/src/skills/generator.ts

@@ -1,491 +0,0 @@
-/**
- * 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

@@ -1,27 +0,0 @@
-/**
- * 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';