@deimoscloud/coreai 0.1.8 → 0.1.10

package/src/commands/loader.ts

@@ -1,355 +0,0 @@
-/**
- * Command Loader
- *
- * Loads commands from markdown files in the coreai/commands/ directory.
- */
-
-import { promises as fs } from 'fs';
-import { join, basename, dirname, relative } from 'path';
-import type {
-  CommandMetadata,
-  MarkdownCommand,
-  CommandCategory,
-  IntegrationDependency,
-  CommandLoaderOptions,
-  CommandLoadResult,
-} from './types.js';
-import type { AdapterType } from '../adapters/types.js';
-
-/**
- * Frontmatter data from markdown file
- */
-interface CommandFrontmatter {
-  description?: string;
-  'argument-hint'?: string;
-  requires?: string[];
-  optional?: string[];
-}
-
-/**
- * Parse YAML-like frontmatter from markdown content
- */
-function parseFrontmatter(content: string): { frontmatter: CommandFrontmatter; body: string } {
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
-
-  if (!match) {
-    return { frontmatter: {}, body: content };
-  }
-
-  const frontmatterText = match[1] ?? '';
-  const body = match[2] ?? '';
-
-  // Simple YAML-like parsing (key: value)
-  const frontmatter: CommandFrontmatter = {};
-  const lines = frontmatterText.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();
-
-    // Handle arrays (simple format: [item1, item2])
-    if (value.startsWith('[') && value.endsWith(']')) {
-      const arrayContent = value.slice(1, -1);
-      const items = arrayContent.split(',').map((s) => s.trim().replace(/['"]/g, ''));
-      (frontmatter as Record<string, unknown>)[key] = items;
-    } else {
-      // Remove quotes if present
-      if (
-        (value.startsWith('"') && value.endsWith('"')) ||
-        (value.startsWith("'") && value.endsWith("'"))
-      ) {
-        value = value.slice(1, -1);
-      }
-      (frontmatter as Record<string, unknown>)[key] = value;
-    }
-  }
-
-  return { frontmatter, body };
-}
-
-/**
- * Parse markdown sections
- */
-function parseSections(body: string): MarkdownCommand['sections'] {
-  const sections: MarkdownCommand['sections'] = {};
-
-  // Extract title (first h1)
-  const titleMatch = body.match(/^#\s+(.+)$/m);
-  if (titleMatch?.[1]) {
-    sections.title = titleMatch[1].trim();
-  }
-
-  // Extract instructions section
-  const instructionsMatch = body.match(/##\s*Instructions?\s*\n([\s\S]*?)(?=\n##|$)/i);
-  if (instructionsMatch?.[1]) {
-    sections.instructions = instructionsMatch[1].trim();
-  }
-
-  // Extract fallbacks section
-  const fallbacksMatch = body.match(/##\s*Fallbacks?\s*\n([\s\S]*?)(?=\n##|$)/i);
-  if (fallbacksMatch?.[1]) {
-    sections.fallbacks = fallbacksMatch[1].trim();
-  }
-
-  // Extract output format section
-  const outputMatch = body.match(/##\s*Output\s*(Format)?\s*\n([\s\S]*?)(?=\n##|$)/i);
-  if (outputMatch?.[2]) {
-    sections.outputFormat = outputMatch[2].trim();
-  }
-
-  return sections;
-}
-
-/**
- * Map integration name to adapter type
- */
-function mapIntegrationToAdapterType(integration: string): AdapterType | null {
-  const mapping: Record<string, AdapterType> = {
-    // Issue tracker mappings
-    jira: 'issue_tracker',
-    issue_tracker: 'issue_tracker',
-    issues: 'issue_tracker',
-    linear: 'issue_tracker',
-    github_issues: 'issue_tracker',
-
-    // Git provider mappings
-    git: 'git',
-    github: 'git',
-    gitlab: 'git',
-    bitbucket: 'git',
-
-    // Documentation mappings
-    docs: 'documentation',
-    documentation: 'documentation',
-    confluence: 'documentation',
-    notion: 'documentation',
-    wiki: 'documentation',
-
-    // State mappings
-    state: 'state',
-    filesystem: 'state',
-  };
-
-  return mapping[integration.toLowerCase()] ?? null;
-}
-
-/**
- * Parse integration dependencies from frontmatter
- */
-function parseDependencies(frontmatter: CommandFrontmatter): IntegrationDependency[] {
-  const dependencies: IntegrationDependency[] = [];
-
-  // Required dependencies
-  if (frontmatter.requires && Array.isArray(frontmatter.requires)) {
-    for (const req of frontmatter.requires) {
-      const type = mapIntegrationToAdapterType(req);
-      if (type) {
-        dependencies.push({
-          type,
-          required: true,
-          description: `Requires ${req} integration`,
-        });
-      }
-    }
-  }
-
-  // Optional dependencies
-  if (frontmatter.optional && Array.isArray(frontmatter.optional)) {
-    for (const opt of frontmatter.optional) {
-      const type = mapIntegrationToAdapterType(opt);
-      if (type) {
-        dependencies.push({
-          type,
-          required: false,
-          description: `Optionally uses ${opt} integration`,
-        });
-      }
-    }
-  }
-
-  return dependencies;
-}
-
-/**
- * Derive command name from file path
- */
-function deriveCommandName(filePath: string, baseDir: string): string {
-  const relativePath = relative(baseDir, filePath);
-  const name = basename(filePath, '.md');
-
-  // Include parent directory for nested commands (e.g., core/check-inbox -> check-inbox)
-  // But not for simple structure
-  const dir = dirname(relativePath);
-  if (dir === '.' || dir === 'core' || dir === 'optional') {
-    return name;
-  }
-
-  // For deeper nesting, include the subdirectory
-  return name;
-}
-
-/**
- * Derive category from file path
- */
-function deriveCategoryFromPath(filePath: string, baseDir: string): CommandCategory {
-  const relativePath = relative(baseDir, filePath);
-  const parts = relativePath.split('/');
-
-  if (parts.includes('optional')) {
-    return 'optional';
-  }
-  if (parts.includes('core')) {
-    return 'core';
-  }
-
-  // Default to custom for project-specific commands
-  return 'custom';
-}
-
-/**
- * Load a single command from a markdown file
- */
-export async function loadCommandFromFile(
-  filePath: string,
-  baseDir: string,
-  categoryOverride?: CommandCategory
-): Promise<MarkdownCommand> {
-  const content = await fs.readFile(filePath, 'utf-8');
-  const { frontmatter, body } = parseFrontmatter(content);
-  const sections = parseSections(body);
-
-  const name = deriveCommandName(filePath, baseDir);
-  const category = categoryOverride ?? deriveCategoryFromPath(filePath, baseDir);
-  const dependencies = parseDependencies(frontmatter);
-
-  const metadata: CommandMetadata = {
-    name,
-    description: frontmatter.description ?? sections.title ?? name,
-    category,
-    dependencies,
-    sourcePath: filePath,
-    available: true, // Will be updated by registry
-  };
-  if (frontmatter['argument-hint']) {
-    metadata.argumentHint = frontmatter['argument-hint'];
-  }
-
-  return {
-    metadata,
-    content: body,
-    sections,
-  };
-}
-
-/**
- * Find all markdown files in a directory
- */
-async function findMarkdownFiles(dir: string, recursive: boolean): Promise<string[]> {
-  const files: string[] = [];
-
-  try {
-    const entries = await fs.readdir(dir, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const fullPath = join(dir, entry.name);
-
-      if (entry.isDirectory() && recursive) {
-        const subFiles = await findMarkdownFiles(fullPath, recursive);
-        files.push(...subFiles);
-      } else if (entry.isFile() && entry.name.endsWith('.md')) {
-        files.push(fullPath);
-      }
-    }
-  } catch (error) {
-    // Directory doesn't exist or can't be read
-    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
-      throw error;
-    }
-  }
-
-  return files;
-}
-
-/**
- * Load commands from a directory
- */
-export async function loadCommandsFromDirectory(
-  options: CommandLoaderOptions
-): Promise<CommandLoadResult> {
-  const result: CommandLoadResult = {
-    loaded: [],
-    errors: [],
-  };
-
-  const files = await findMarkdownFiles(options.directory, options.recursive ?? true);
-
-  for (const filePath of files) {
-    try {
-      const command = await loadCommandFromFile(filePath, options.directory, options.category);
-
-      // Apply filter if provided
-      if (options.filter && !options.filter(command.metadata)) {
-        continue;
-      }
-
-      result.loaded.push(command);
-    } catch (error) {
-      result.errors.push({
-        path: filePath,
-        error: error instanceof Error ? error.message : String(error),
-      });
-    }
-  }
-
-  return result;
-}
-
-/**
- * Load commands from the default CoreAI commands directory
- */
-export async function loadCoreAICommands(projectRoot: string): Promise<CommandLoadResult> {
-  const commandsDir = join(projectRoot, 'coreai', 'commands');
-  return loadCommandsFromDirectory({
-    directory: commandsDir,
-    category: 'core', // Will be overridden by path derivation
-    recursive: true,
-  });
-}
-
-/**
- * Load commands from both core and custom directories
- */
-export async function loadAllCommands(
-  coreCommandsDir: string,
-  customCommandsDir?: string
-): Promise<CommandLoadResult> {
-  const result: CommandLoadResult = {
-    loaded: [],
-    errors: [],
-  };
-
-  // Load core commands
-  const coreResult = await loadCommandsFromDirectory({
-    directory: coreCommandsDir,
-    category: 'core',
-    recursive: true,
-  });
-  result.loaded.push(...coreResult.loaded);
-  result.errors.push(...coreResult.errors);
-
-  // Load custom commands if directory specified
-  if (customCommandsDir) {
-    const customResult = await loadCommandsFromDirectory({
-      directory: customCommandsDir,
-      category: 'custom',
-      recursive: true,
-    });
-    result.loaded.push(...customResult.loaded);
-    result.errors.push(...customResult.errors);
-  }
-
-  return result;
-}