@deimoscloud/coreai 0.1.9 → 0.1.11

package/src/commands/types.ts

@@ -1,361 +0,0 @@
-/**
- * Command Framework Types
- *
- * Type definitions for the CoreAI command registration and execution system.
- */
-
-import type { ResolvedCoreAIConfig } from '../config/types.js';
-import type { AdapterFactory, AdapterType } from '../adapters/index.js';
-
-/**
- * Command category for organization
- */
-export type CommandCategory = 'core' | 'optional' | 'custom';
-
-/**
- * Integration dependency for a command
- */
-export interface IntegrationDependency {
-  /**
-   * Adapter type required
-   */
-  type: AdapterType;
-
-  /**
-   * Whether this integration is required or optional
-   * If required and missing, command won't be registered
-   * If optional and missing, command degrades gracefully
-   */
-  required: boolean;
-
-  /**
-   * Description of what this integration is used for
-   */
-  description?: string;
-}
-
-/**
- * Command metadata parsed from markdown frontmatter
- */
-export interface CommandMetadata {
-  /**
-   * Command name (derived from filename)
-   */
-  name: string;
-
-  /**
-   * Human-readable description
-   */
-  description: string;
-
-  /**
-   * Hint for command arguments
-   */
-  argumentHint?: string;
-
-  /**
-   * Command category
-   */
-  category: CommandCategory;
-
-  /**
-   * Integration dependencies
-   */
-  dependencies: IntegrationDependency[];
-
-  /**
-   * Path to the source markdown file
-   */
-  sourcePath: string;
-
-  /**
-   * Whether command is available (all required deps satisfied)
-   */
-  available: boolean;
-
-  /**
-   * Reason command is unavailable (if not available)
-   */
-  unavailableReason?: string;
-}
-
-/**
- * Runtime context available during command execution
- */
-export interface CommandContext {
-  /**
-   * Loaded configuration (may be null if no config file)
-   */
-  config: ResolvedCoreAIConfig | null;
-
-  /**
-   * Adapter factory for accessing integrations
-   */
-  adapterFactory: AdapterFactory | null;
-
-  /**
-   * Project root directory
-   */
-  projectRoot: string;
-
-  /**
-   * Check if an integration is available
-   */
-  hasIntegration(type: AdapterType): boolean;
-
-  /**
-   * Get adapter with graceful handling
-   * Returns null if not available instead of throwing
-   */
-  getAdapterSafe<T>(type: AdapterType): Promise<T | null>;
-}
-
-/**
- * Base options available to all commands
- */
-export interface BaseCommandOptions {
-  /**
-   * Output format
-   */
-  format?: 'text' | 'json';
-
-  /**
-   * Verbose output
-   */
-  verbose?: boolean;
-
-  /**
-   * Project root directory override
-   */
-  projectRoot?: string;
-}
-
-/**
- * Result of command execution
- */
-export interface CommandResult<T = unknown> {
-  /**
-   * Whether command completed successfully
-   */
-  success: boolean;
-
-  /**
-   * Result data (command-specific)
-   */
-  data?: T;
-
-  /**
-   * Error message if failed
-   */
-  error?: string;
-
-  /**
-   * Warnings that occurred during execution
-   */
-  warnings?: string[];
-
-  /**
-   * Steps that were skipped due to missing integrations
-   */
-  skippedSteps?: {
-    step: string;
-    reason: string;
-  }[];
-}
-
-/**
- * Command handler function signature
- */
-export type CommandHandler<TOptions = BaseCommandOptions, TResult = unknown> = (
-  args: string[],
-  options: TOptions,
-  context: CommandContext
-) => Promise<CommandResult<TResult>>;
-
-/**
- * Command definition for programmatic commands
- */
-export interface CommandDefinition<TOptions = BaseCommandOptions, TResult = unknown> {
-  /**
-   * Command name
-   */
-  name: string;
-
-  /**
-   * Human-readable description
-   */
-  description: string;
-
-  /**
-   * Command category
-   */
-  category: CommandCategory;
-
-  /**
-   * Integration dependencies
-   */
-  dependencies?: IntegrationDependency[];
-
-  /**
-   * Option definitions for Commander.js
-   */
-  options?: CommandOptionDefinition[];
-
-  /**
-   * Positional argument definitions
-   */
-  arguments?: CommandArgumentDefinition[];
-
-  /**
-   * Command handler
-   */
-  handler: CommandHandler<TOptions, TResult>;
-
-  /**
-   * Subcommands (for command groups like 'agents list', 'agents show')
-   */
-  subcommands?: CommandDefinition[];
-}
-
-/**
- * Command option definition
- */
-export interface CommandOptionDefinition {
-  /**
-   * Option flags (e.g., '-f, --force')
-   */
-  flags: string;
-
-  /**
-   * Description
-   */
-  description: string;
-
-  /**
-   * Default value
-   */
-  defaultValue?: unknown;
-
-  /**
-   * Whether option is required
-   */
-  required?: boolean;
-}
-
-/**
- * Command argument definition
- */
-export interface CommandArgumentDefinition {
-  /**
-   * Argument name
-   */
-  name: string;
-
-  /**
-   * Description
-   */
-  description: string;
-
-  /**
-   * Whether argument is required
-   */
-  required?: boolean;
-
-  /**
-   * Default value
-   */
-  defaultValue?: unknown;
-}
-
-/**
- * Markdown command definition (parsed from file)
- */
-export interface MarkdownCommand {
-  /**
-   * Command metadata
-   */
-  metadata: CommandMetadata;
-
-  /**
-   * Raw markdown content (instructions for agents)
-   */
-  content: string;
-
-  /**
-   * Parsed sections from markdown
-   */
-  sections: {
-    title?: string;
-    instructions?: string;
-    fallbacks?: string;
-    outputFormat?: string;
-  };
-}
-
-/**
- * Command registry entry
- */
-export interface RegistryEntry {
-  /**
-   * Command metadata
-   */
-  metadata: CommandMetadata;
-
-  /**
-   * Command definition (for programmatic commands)
-   */
-  definition?: CommandDefinition;
-
-  /**
-   * Markdown command (for agent commands)
-   */
-  markdownCommand?: MarkdownCommand;
-
-  /**
-   * Source type
-   */
-  source: 'programmatic' | 'markdown';
-}
-
-/**
- * Options for loading commands from directory
- */
-export interface CommandLoaderOptions {
-  /**
-   * Directory to load commands from
-   */
-  directory: string;
-
-  /**
-   * Category to assign to loaded commands
-   */
-  category: CommandCategory;
-
-  /**
-   * Recursively search subdirectories
-   */
-  recursive?: boolean;
-
-  /**
-   * Filter function to include/exclude commands
-   */
-  filter?: (metadata: CommandMetadata) => boolean;
-}
-
-/**
- * Result of loading commands
- */
-export interface CommandLoadResult {
-  /**
-   * Successfully loaded commands
-   */
-  loaded: MarkdownCommand[];
-
-  /**
-   * Failed to load
-   */
-  errors: {
-    path: string;
-    error: string;
-  }[];
-}

package/src/config/index.ts

@@ -1,19 +0,0 @@
-/**
- * Configuration Module
- *
- * Provides configuration loading, validation, and management for CoreAI.
- */
-
-export * from './types.js';
-export {
-  loadConfig,
-  loadConfigFromFile,
-  findConfigFile,
-  parseConfig,
-  validateConfig,
-  applyDefaults,
-  configExists,
-  getConfigPath,
-  ConfigError,
-  type ConfigErrorCode,
-} from './loader.js';

package/src/config/loader.test.ts

@@ -1,262 +0,0 @@
-import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import {
-  findConfigFile,
-  parseConfig,
-  validateConfig,
-  applyDefaults,
-  loadConfigFromFile,
-  configExists,
-  getConfigPath,
-  ConfigError,
-} from './loader.js';
-import type { CoreAIConfig } from './types.js';
-
-/**
- * Helper to check ConfigError with specific code
- */
-function expectConfigError(fn: () => unknown, code: string): void {
-  try {
-    fn();
-    fail('Expected ConfigError to be thrown');
-  } catch (error) {
-    expect(error).toBeInstanceOf(ConfigError);
-    expect((error as ConfigError).code).toBe(code);
-  }
-}
-
-describe('Config Loader', () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'coreai-test-'));
-  });
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  describe('findConfigFile', () => {
-    it('should find config file in current directory', () => {
-      const configPath = join(tempDir, 'coreai.config.yaml');
-      writeFileSync(configPath, 'version: "1.0"\nproject:\n  name: test');
-
-      const result = findConfigFile(tempDir);
-      expect(result).toBe(configPath);
-    });
-
-    it('should find config file with .yml extension', () => {
-      const configPath = join(tempDir, 'coreai.config.yml');
-      writeFileSync(configPath, 'version: "1.0"\nproject:\n  name: test');
-
-      const result = findConfigFile(tempDir);
-      expect(result).toBe(configPath);
-    });
-
-    it('should find config file in parent directory', () => {
-      const subDir = join(tempDir, 'subdir');
-      mkdirSync(subDir);
-      const configPath = join(tempDir, 'coreai.config.yaml');
-      writeFileSync(configPath, 'version: "1.0"\nproject:\n  name: test');
-
-      const result = findConfigFile(subDir);
-      expect(result).toBe(configPath);
-    });
-
-    it('should return null when no config file exists in temp dir', () => {
-      // Create an isolated deep directory structure to avoid finding project root config
-      const deepDir = join(tempDir, 'a', 'b', 'c', 'd', 'e');
-      mkdirSync(deepDir, { recursive: true });
-
-      // findConfigFile walks up, so we test from within tempDir where we control the env
-      const result = findConfigFile(deepDir);
-      // It might find the project root config, so we just check it doesn't find one in tempDir
-      if (result !== null) {
-        expect(result.startsWith(tempDir)).toBe(false);
-      }
-    });
-  });
-
-  describe('parseConfig', () => {
-    it('should parse valid YAML', () => {
-      const yaml = `
-version: "1.0"
-project:
-  name: "Test Project"
-  type: software
-`;
-      const result = parseConfig(yaml);
-      expect(result).toEqual({
-        version: '1.0',
-        project: {
-          name: 'Test Project',
-          type: 'software',
-        },
-      });
-    });
-
-    it('should throw ConfigError for invalid YAML', () => {
-      const invalidYaml = `
-version: "1.0"
-project:
-  name: "Test
-  invalid: yaml
-`;
-      expectConfigError(() => parseConfig(invalidYaml), 'PARSE_ERROR');
-    });
-  });
-
-  describe('validateConfig', () => {
-    it('should validate a minimal valid config', () => {
-      const config = {
-        version: '1.0',
-        project: { name: 'Test' },
-      };
-
-      const result = validateConfig(config);
-      expect(result).toEqual(config);
-    });
-
-    it('should validate a full config', () => {
-      const config: CoreAIConfig = {
-        version: '1.0',
-        project: { name: 'Test', type: 'software' },
-        team: { agents: ['backend-engineer'] },
-        integrations: {
-          git: { provider: 'github', config: { repo: 'org/repo' } },
-          issue_tracker: { provider: 'jira', config: { project_key: 'TEST' } },
-        },
-        quality_gates: {
-          lint: { command: 'npm run lint', required: true },
-        },
-        tech_stack: { primary_language: 'typescript' },
-      };
-
-      const result = validateConfig(config);
-      expect(result).toEqual(config);
-    });
-
-    it('should throw for missing required fields', () => {
-      const config = { version: '1.0' }; // missing project
-      expectConfigError(() => validateConfig(config), 'VALIDATION_ERROR');
-    });
-
-    it('should throw for invalid version', () => {
-      const config = {
-        version: '2.0', // invalid version
-        project: { name: 'Test' },
-      };
-      expectConfigError(() => validateConfig(config), 'VALIDATION_ERROR');
-    });
-
-    it('should throw for invalid provider', () => {
-      const config = {
-        version: '1.0',
-        project: { name: 'Test' },
-        integrations: {
-          git: { provider: 'invalid-provider' },
-        },
-      };
-      expectConfigError(() => validateConfig(config), 'VALIDATION_ERROR');
-    });
-  });
-
-  describe('applyDefaults', () => {
-    it('should apply default project type', () => {
-      const config: CoreAIConfig = {
-        version: '1.0',
-        project: { name: 'Test' },
-      };
-
-      const result = applyDefaults(config);
-      expect(result.project.type).toBe('software');
-    });
-
-    it('should apply default agents', () => {
-      const config: CoreAIConfig = {
-        version: '1.0',
-        project: { name: 'Test' },
-      };
-
-      const result = applyDefaults(config);
-      expect(result.team.agents).toEqual([
-        'backend-engineer',
-        'frontend-engineer',
-        'devops-engineer',
-        'engineering-manager',
-      ]);
-    });
-
-    it('should preserve explicit values', () => {
-      const config: CoreAIConfig = {
-        version: '1.0',
-        project: { name: 'Test', type: 'infrastructure' },
-        team: { agents: ['devops-engineer'] },
-      };
-
-      const result = applyDefaults(config);
-      expect(result.project.type).toBe('infrastructure');
-      expect(result.team.agents).toEqual(['devops-engineer']);
-    });
-  });
-
-  describe('loadConfigFromFile', () => {
-    it('should load and validate a config file', () => {
-      const configPath = join(tempDir, 'coreai.config.yaml');
-      writeFileSync(
-        configPath,
-        `
-version: "1.0"
-project:
-  name: "Test Project"
-`
-      );
-
-      const result = loadConfigFromFile(configPath);
-      expect(result.project.name).toBe('Test Project');
-      expect(result.project.type).toBe('software'); // default applied
-    });
-
-    it('should throw for non-existent file', () => {
-      const configPath = join(tempDir, 'nonexistent.yaml');
-      expectConfigError(() => loadConfigFromFile(configPath), 'READ_ERROR');
-    });
-
-    it('should throw for invalid config', () => {
-      const configPath = join(tempDir, 'coreai.config.yaml');
-      writeFileSync(configPath, 'invalid: config');
-      expectConfigError(() => loadConfigFromFile(configPath), 'VALIDATION_ERROR');
-    });
-  });
-
-  describe('configExists', () => {
-    it('should return true when config exists', () => {
-      const configPath = join(tempDir, 'coreai.config.yaml');
-      writeFileSync(configPath, 'version: "1.0"\nproject:\n  name: test');
-
-      expect(configExists(tempDir)).toBe(true);
-    });
-
-    it('should return false when no config in temp directory tree', () => {
-      // We can't truly test "no config exists" because findConfigFile walks up
-      // to the filesystem root. Instead, test that configExists returns a boolean.
-      const result = configExists(tempDir);
-      expect(typeof result).toBe('boolean');
-    });
-  });
-
-  describe('getConfigPath', () => {
-    it('should return path when config exists', () => {
-      const configPath = join(tempDir, 'coreai.config.yaml');
-      writeFileSync(configPath, 'version: "1.0"\nproject:\n  name: test');
-
-      expect(getConfigPath(tempDir)).toBe(configPath);
-    });
-
-    it('should return string or null', () => {
-      const result = getConfigPath(tempDir);
-      expect(result === null || typeof result === 'string').toBe(true);
-    });
-  });
-});