@deimoscloud/coreai 0.1.0

package/src/commands/loader.ts

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