@deimoscloud/coreai 0.1.8 → 0.1.10

package/src/agents/loader.test.ts

@@ -1,319 +0,0 @@
-import { mkdtempSync, writeFileSync, rmSync } from 'fs';
-import { join, dirname } from 'path';
-import { tmpdir } from 'os';
-import { fileURLToPath } from 'url';
-import { jest } from '@jest/globals';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-import {
-  parseAgentYaml,
-  validateAgentDefinition,
-  loadAgentFromFile,
-  loadAgentsFromDirectory,
-  getRoleFromFilename,
-  AgentError,
-} from './loader.js';
-import type { AgentDefinition } from './types.js';
-
-/**
- * Helper to check AgentError with specific code
- */
-function expectAgentError(fn: () => unknown, code: string): void {
-  try {
-    fn();
-    fail('Expected AgentError to be thrown');
-  } catch (error) {
-    expect(error).toBeInstanceOf(AgentError);
-    expect((error as AgentError).code).toBe(code);
-  }
-}
-
-/**
- * Create a valid minimal agent definition
- */
-function createMinimalAgent(overrides: Partial<AgentDefinition> = {}): AgentDefinition {
-  return {
-    role: 'test-agent',
-    type: 'ic-engineer',
-    display_name: 'Test Agent',
-    description: 'A test agent for unit tests',
-    ...overrides,
-  };
-}
-
-describe('Agent Loader', () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'coreai-agent-test-'));
-  });
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  describe('parseAgentYaml', () => {
-    it('should parse valid YAML', () => {
-      const yaml = `
-role: backend-engineer
-type: ic-engineer
-display_name: Backend Engineer
-description: Backend development specialist
-`;
-      const result = parseAgentYaml(yaml);
-      expect(result).toEqual({
-        role: 'backend-engineer',
-        type: 'ic-engineer',
-        display_name: 'Backend Engineer',
-        description: 'Backend development specialist',
-      });
-    });
-
-    it('should throw AgentError for invalid YAML', () => {
-      const invalidYaml = `
-role: "test
-  invalid: yaml
-`;
-      expectAgentError(() => parseAgentYaml(invalidYaml), 'PARSE_ERROR');
-    });
-  });
-
-  describe('validateAgentDefinition', () => {
-    it('should validate a minimal valid agent', () => {
-      const agent = createMinimalAgent();
-      const result = validateAgentDefinition(agent);
-      expect(result).toEqual(agent);
-    });
-
-    it('should validate a full agent definition', () => {
-      const agent: AgentDefinition = {
-        role: 'backend-engineer',
-        type: 'ic-engineer',
-        display_name: 'Backend Engineer',
-        description: 'Backend development specialist',
-        responsibilities: ['Implement APIs', 'Write tests'],
-        expertise: {
-          primary: ['API design', 'Database design'],
-          tech_stack: '${config.tech_stack}',
-        },
-        skills: ['Code review', 'Debugging'],
-        principles: {
-          code_quality: ['Write clean code', 'Follow SOLID'],
-          testing: ['Write tests first'],
-        },
-        behaviors: {
-          workflow: 'ticket-implementation',
-          quality_gates: '${config.quality_gates}',
-        },
-        context_sources: {
-          shared: ['${remote.documentation}/architecture'],
-          personal: ['KnowledgeLibrary/${agent.name}/context'],
-        },
-        communication: {
-          inbox: 'KnowledgeLibrary/${agent.name}/inbox',
-          outbox: 'KnowledgeLibrary/${agent.name}/outbox',
-        },
-      };
-
-      const result = validateAgentDefinition(agent);
-      expect(result).toEqual(agent);
-    });
-
-    it('should throw for missing required fields', () => {
-      const agent = { type: 'ic-engineer' }; // missing role, display_name, description
-      expectAgentError(() => validateAgentDefinition(agent), 'VALIDATION_ERROR');
-    });
-
-    it('should throw for invalid role format', () => {
-      const agent = createMinimalAgent({ role: 'Invalid Role' }); // uppercase and space
-      expectAgentError(() => validateAgentDefinition(agent), 'VALIDATION_ERROR');
-    });
-
-    it('should throw for invalid type', () => {
-      const agent = { ...createMinimalAgent(), type: 'invalid-type' };
-      expectAgentError(() => validateAgentDefinition(agent), 'VALIDATION_ERROR');
-    });
-
-    it('should throw for invalid workflow', () => {
-      const agent = createMinimalAgent();
-      agent.behaviors = { workflow: 'invalid-workflow' as never };
-      expectAgentError(() => validateAgentDefinition(agent), 'VALIDATION_ERROR');
-    });
-  });
-
-  describe('loadAgentFromFile', () => {
-    it('should load and validate an agent file', () => {
-      const agentPath = join(tempDir, 'test-agent.yaml');
-      writeFileSync(
-        agentPath,
-        `
-role: test-agent
-type: ic-engineer
-display_name: Test Agent
-description: A test agent
-`
-      );
-
-      const result = loadAgentFromFile(agentPath);
-      expect(result.role).toBe('test-agent');
-      expect(result.type).toBe('ic-engineer');
-    });
-
-    it('should throw for non-existent file', () => {
-      const agentPath = join(tempDir, 'nonexistent.yaml');
-      expectAgentError(() => loadAgentFromFile(agentPath), 'NOT_FOUND');
-    });
-
-    it('should throw for invalid agent', () => {
-      const agentPath = join(tempDir, 'invalid.yaml');
-      writeFileSync(agentPath, 'invalid: content');
-      expectAgentError(() => loadAgentFromFile(agentPath), 'VALIDATION_ERROR');
-    });
-  });
-
-  describe('loadAgentsFromDirectory', () => {
-    it('should load all agents from a directory', () => {
-      // Create multiple agent files
-      writeFileSync(
-        join(tempDir, 'agent-one.yaml'),
-        `
-role: agent-one
-type: ic-engineer
-display_name: Agent One
-description: First agent
-`
-      );
-      writeFileSync(
-        join(tempDir, 'agent-two.yaml'),
-        `
-role: agent-two
-type: manager
-display_name: Agent Two
-description: Second agent
-`
-      );
-
-      const agents = loadAgentsFromDirectory(tempDir, 'core');
-
-      expect(agents.size).toBe(2);
-      expect(agents.get('agent-one')?.definition.role).toBe('agent-one');
-      expect(agents.get('agent-two')?.definition.role).toBe('agent-two');
-      expect(agents.get('agent-one')?.source).toBe('core');
-    });
-
-    it('should return empty map for non-existent directory', () => {
-      const agents = loadAgentsFromDirectory(join(tempDir, 'nonexistent'), 'core');
-      expect(agents.size).toBe(0);
-    });
-
-    it('should skip invalid files and continue loading', () => {
-      writeFileSync(
-        join(tempDir, 'valid.yaml'),
-        `
-role: valid-agent
-type: ic-engineer
-display_name: Valid Agent
-description: A valid agent
-`
-      );
-      writeFileSync(join(tempDir, 'invalid.yaml'), 'invalid: content');
-
-      // Suppress console.warn for this test
-      const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => undefined);
-
-      const agents = loadAgentsFromDirectory(tempDir, 'core');
-
-      expect(agents.size).toBe(1);
-      expect(agents.get('valid-agent')).toBeDefined();
-      expect(warnSpy).toHaveBeenCalled();
-
-      warnSpy.mockRestore();
-    });
-
-    it('should handle .yml extension', () => {
-      writeFileSync(
-        join(tempDir, 'agent.yml'),
-        `
-role: yml-agent
-type: specialist
-display_name: YML Agent
-description: Agent with .yml extension
-`
-      );
-
-      const agents = loadAgentsFromDirectory(tempDir, 'custom');
-      expect(agents.size).toBe(1);
-      expect(agents.get('yml-agent')?.source).toBe('custom');
-    });
-  });
-
-  describe('getRoleFromFilename', () => {
-    it('should extract role from .yaml filename', () => {
-      expect(getRoleFromFilename('/path/to/backend-engineer.yaml')).toBe('backend-engineer');
-    });
-
-    it('should extract role from .yml filename', () => {
-      expect(getRoleFromFilename('/path/to/frontend-engineer.yml')).toBe('frontend-engineer');
-    });
-
-    it('should handle simple filename', () => {
-      expect(getRoleFromFilename('devops.yaml')).toBe('devops');
-    });
-  });
-
-  describe('Core Agent Definitions', () => {
-    const coreAgentsDir = join(__dirname, '../../agents');
-
-    it('should load all core agents from agents/ directory', () => {
-      const agents = loadAgentsFromDirectory(coreAgentsDir, 'core');
-
-      expect(agents.size).toBe(4);
-      expect(agents.has('backend-engineer')).toBe(true);
-      expect(agents.has('frontend-engineer')).toBe(true);
-      expect(agents.has('devops-engineer')).toBe(true);
-      expect(agents.has('engineering-manager')).toBe(true);
-    });
-
-    it('should validate backend-engineer agent', () => {
-      const agent = loadAgentFromFile(join(coreAgentsDir, 'backend-engineer.yaml'));
-
-      expect(agent.role).toBe('backend-engineer');
-      expect(agent.type).toBe('ic-engineer');
-      expect(agent.display_name).toBe('Backend Engineer');
-      expect(agent.responsibilities).toBeDefined();
-      expect(agent.expertise?.primary).toBeDefined();
-      expect(agent.behaviors?.workflow).toBe('ticket-implementation');
-    });
-
-    it('should validate frontend-engineer agent', () => {
-      const agent = loadAgentFromFile(join(coreAgentsDir, 'frontend-engineer.yaml'));
-
-      expect(agent.role).toBe('frontend-engineer');
-      expect(agent.type).toBe('ic-engineer');
-      expect(agent.display_name).toBe('Frontend Engineer');
-      expect(agent.responsibilities).toBeDefined();
-      expect(agent.behaviors?.workflow).toBe('ticket-implementation');
-    });
-
-    it('should validate devops-engineer agent', () => {
-      const agent = loadAgentFromFile(join(coreAgentsDir, 'devops-engineer.yaml'));
-
-      expect(agent.role).toBe('devops-engineer');
-      expect(agent.type).toBe('specialist');
-      expect(agent.display_name).toBe('DevOps Engineer');
-      expect(agent.responsibilities).toBeDefined();
-      expect(agent.behaviors?.workflow).toBe('ticket-implementation');
-    });
-
-    it('should validate engineering-manager agent', () => {
-      const agent = loadAgentFromFile(join(coreAgentsDir, 'engineering-manager.yaml'));
-
-      expect(agent.role).toBe('engineering-manager');
-      expect(agent.type).toBe('manager');
-      expect(agent.display_name).toBe('Engineering Manager');
-      expect(agent.responsibilities).toBeDefined();
-      expect(agent.behaviors?.workflow).toBe('planning-estimation');
-    });
-  });
-});

package/src/agents/loader.ts

@@ -1,143 +0,0 @@
-/**
- * Agent Loader
- *
- * Handles loading and validating agent YAML definitions.
- */
-
-import { existsSync, readdirSync, readFileSync } from 'fs';
-import { basename, extname, join } from 'path';
-import { parse as parseYaml } from 'yaml';
-import Ajv, { type ErrorObject } from 'ajv';
-import type { AgentDefinition, AgentMetadata, AgentSource } from './types.js';
-
-// Import schema as JSON
-import { createRequire } from 'module';
-const require = createRequire(import.meta.url);
-const agentSchema = require('../../schemas/agent.schema.json') as object;
-
-export class AgentError extends Error {
-  constructor(
-    message: string,
-    public readonly code: AgentErrorCode,
-    public readonly details?: unknown
-  ) {
-    super(message);
-    this.name = 'AgentError';
-  }
-}
-
-export type AgentErrorCode = 'NOT_FOUND' | 'PARSE_ERROR' | 'VALIDATION_ERROR' | 'READ_ERROR';
-
-/**
- * Parse YAML content into an agent definition
- */
-export function parseAgentYaml(content: string, filePath?: string): unknown {
-  try {
-    return parseYaml(content);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Unknown parse error';
-    throw new AgentError(
-      `Failed to parse agent YAML${filePath ? ` in ${filePath}` : ''}: ${message}`,
-      'PARSE_ERROR',
-      error
-    );
-  }
-}
-
-/**
- * Validate parsed YAML against agent schema
- */
-export function validateAgentDefinition(agent: unknown): AgentDefinition {
-  const ajv = new Ajv.default({ allErrors: true, strict: false });
-  const validate = ajv.compile<AgentDefinition>(agentSchema);
-  const valid = validate(agent);
-
-  if (!valid) {
-    const errors: ErrorObject[] = validate.errors ?? [];
-    const errorMessages = errors.map((err: ErrorObject) => {
-      const path = err.instancePath || 'root';
-      return `${path}: ${err.message ?? 'unknown error'}`;
-    });
-
-    throw new AgentError(
-      `Agent validation failed:\n  - ${errorMessages.join('\n  - ')}`,
-      'VALIDATION_ERROR',
-      errors
-    );
-  }
-
-  return agent as AgentDefinition;
-}
-
-/**
- * Load and validate an agent definition from a file
- */
-export function loadAgentFromFile(filePath: string): AgentDefinition {
-  if (!existsSync(filePath)) {
-    throw new AgentError(`Agent file not found: ${filePath}`, 'NOT_FOUND');
-  }
-
-  let content: string;
-  try {
-    content = readFileSync(filePath, 'utf-8');
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Unknown read error';
-    throw new AgentError(`Failed to read agent file ${filePath}: ${message}`, 'READ_ERROR', error);
-  }
-
-  const parsed = parseAgentYaml(content, filePath);
-  return validateAgentDefinition(parsed);
-}
-
-/**
- * List all YAML files in a directory
- */
-function listYamlFiles(dir: string): string[] {
-  if (!existsSync(dir)) {
-    return [];
-  }
-
-  return readdirSync(dir)
-    .filter((file) => {
-      const ext = extname(file).toLowerCase();
-      return ext === '.yaml' || ext === '.yml';
-    })
-    .map((file) => join(dir, file));
-}
-
-/**
- * Load all agents from a directory
- */
-export function loadAgentsFromDirectory(
-  dir: string,
-  source: AgentSource
-): Map<string, AgentMetadata> {
-  const agents = new Map<string, AgentMetadata>();
-  const files = listYamlFiles(dir);
-
-  for (const filePath of files) {
-    try {
-      const definition = loadAgentFromFile(filePath);
-      agents.set(definition.role, {
-        definition,
-        source,
-        filePath,
-      });
-    } catch (error) {
-      // Log warning but continue loading other agents
-      const fileName = basename(filePath);
-      console.warn(`Warning: Failed to load agent from ${fileName}: ${(error as Error).message}`);
-    }
-  }
-
-  return agents;
-}
-
-/**
- * Get the agent role name from a filename
- */
-export function getRoleFromFilename(filePath: string): string {
-  const fileName = basename(filePath);
-  const ext = extname(fileName);
-  return fileName.slice(0, -ext.length);
-}