@deimoscloud/coreai 0.1.0

package/src/cli/commands/build.test.ts

@@ -0,0 +1,248 @@
+/**
+ * Build Command Tests
+ */
+
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { build, formatBuildResult } from './build.js';
+
+describe('Build Command', () => {
+  let testDir: string;
+  let agentsDir: string;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `build-cmd-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    agentsDir = join(testDir, 'coreai', 'agents');
+    await fs.mkdir(agentsDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    try {
+      await fs.rm(testDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe('build', () => {
+    it('should build without config file', async () => {
+      const result = build({
+        projectRoot: testDir,
+        coreAgentsDir: join(testDir, 'core-agents'), // Non-existent, will use custom only
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.warnings).toBeDefined();
+      expect(result.warnings?.some((w) => w.includes('No configuration'))).toBe(true);
+    });
+
+    it('should build with config file', async () => {
+      const configPath = join(testDir, 'coreai.config.yaml');
+      await fs.writeFile(
+        configPath,
+        `version: "1.0"
+project:
+  name: test-project
+team:
+  agents: []
+`
+      );
+
+      const result = build({
+        projectRoot: testDir,
+        coreAgentsDir: join(testDir, 'core-agents'),
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.config).toBeDefined();
+    });
+
+    it('should report config errors', async () => {
+      const configPath = join(testDir, 'coreai.config.yaml');
+      await fs.writeFile(configPath, 'invalid: yaml: [');
+
+      const result = build({
+        projectRoot: testDir,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Configuration error');
+    });
+
+    it('should build custom agents', async () => {
+      // Create a custom agent
+      await fs.writeFile(
+        join(agentsDir, 'test-agent.yaml'),
+        `role: test-agent
+type: ic-engineer
+display_name: Test Agent
+description: A test agent
+responsibilities:
+  - Testing
+expertise:
+  primary:
+    - Testing
+`
+      );
+
+      const result = build({
+        projectRoot: testDir,
+        coreAgentsDir: join(testDir, 'non-existent'),
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.result?.compiled.length).toBeGreaterThan(0);
+      expect(result.result?.compiled.some((a) => a.role === 'test-agent')).toBe(true);
+    });
+
+    it('should filter agents when specified', async () => {
+      // Create multiple agents
+      await fs.writeFile(
+        join(agentsDir, 'agent-a.yaml'),
+        `role: agent-a
+type: ic-engineer
+display_name: Agent A
+description: Agent A
+responsibilities: []
+expertise:
+  primary: []
+`
+      );
+
+      await fs.writeFile(
+        join(agentsDir, 'agent-b.yaml'),
+        `role: agent-b
+type: ic-engineer
+display_name: Agent B
+description: Agent B
+responsibilities: []
+expertise:
+  primary: []
+`
+      );
+
+      const result = build({
+        projectRoot: testDir,
+        coreAgentsDir: join(testDir, 'non-existent'),
+        agents: ['agent-a'],
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.result?.compiled.length).toBe(1);
+      expect(result.result?.compiled[0].role).toBe('agent-a');
+    });
+
+    it('should use custom output directory', async () => {
+      await fs.writeFile(
+        join(agentsDir, 'test-agent.yaml'),
+        `role: test-agent
+type: ic-engineer
+display_name: Test Agent
+description: A test agent
+responsibilities: []
+expertise:
+  primary: []
+`
+      );
+
+      const outputDir = join(testDir, 'custom-output');
+
+      const result = build({
+        projectRoot: testDir,
+        coreAgentsDir: join(testDir, 'non-existent'),
+        outputDir,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.result?.compiled[0].outputPath).toContain('custom-output');
+    });
+  });
+
+  describe('formatBuildResult', () => {
+    it('should format success result', () => {
+      const result = {
+        success: true,
+        result: {
+          compiled: [
+            { role: 'agent-a', source: 'custom' as const, outputPath: '/path/to/agent-a.md' },
+          ],
+          errors: [],
+        },
+      };
+
+      const output = formatBuildResult(result);
+
+      expect(output).toContain('Compiled');
+      expect(output).toContain('agent-a');
+      expect(output).toContain('Build complete');
+    });
+
+    it('should format error result', () => {
+      const result = {
+        success: false,
+        error: 'Build failed',
+        result: {
+          compiled: [],
+          errors: [{ role: 'agent-a', error: 'Invalid definition' }],
+        },
+      };
+
+      const output = formatBuildResult(result);
+
+      expect(output).toContain('Build failed');
+      expect(output).toContain('agent-a');
+      expect(output).toContain('Invalid definition');
+    });
+
+    it('should show warnings', () => {
+      const result = {
+        success: true,
+        warnings: ['No config file found'],
+        result: {
+          compiled: [],
+          errors: [],
+        },
+      };
+
+      const output = formatBuildResult(result);
+
+      expect(output).toContain('⚠');
+      expect(output).toContain('No config file found');
+    });
+
+    it('should group agents by source', () => {
+      const result = {
+        success: true,
+        result: {
+          compiled: [
+            { role: 'core-agent', source: 'core' as const, outputPath: '/core.md' },
+            { role: 'custom-agent', source: 'custom' as const, outputPath: '/custom.md' },
+            { role: 'override-agent', source: 'override' as const, outputPath: '/override.md' },
+          ],
+          errors: [],
+        },
+      };
+
+      const output = formatBuildResult(result);
+
+      expect(output).toContain('Core agents');
+      expect(output).toContain('Custom agents');
+      expect(output).toContain('Override agents');
+    });
+
+    it('should handle no agents to compile', () => {
+      const result = {
+        success: true,
+        result: {
+          compiled: [],
+          errors: [],
+        },
+      };
+
+      const output = formatBuildResult(result);
+
+      expect(output).toContain('No agents to compile');
+    });
+  });
+});

package/src/cli/commands/build.ts

@@ -0,0 +1,244 @@
+/**
+ * Build Command
+ *
+ * Compiles agent definitions to Claude-compatible markdown files.
+ */
+
+import { configExists, loadConfig, ConfigError } from '../../config/loader.js';
+import type { ResolvedCoreAIConfig } from '../../config/types.js';
+import { compileAgents, type CompileOptions, type CompileResult } from '../../agents/index.js';
+import { initAgentKnowledgeLibrary } from '../../knowledge-library/index.js';
+
+/**
+ * Options for build command
+ */
+export interface BuildCommandOptions {
+  /**
+   * Project root directory
+   */
+  projectRoot?: string;
+
+  /**
+   * Path to core agents directory
+   */
+  coreAgentsDir?: string;
+
+  /**
+   * Output directory for compiled agents
+   */
+  outputDir?: string;
+
+  /**
+   * Watch for changes (not yet implemented)
+   */
+  watch?: boolean;
+
+  /**
+   * Only compile specific agents
+   */
+  agents?: string[];
+
+  /**
+   * Skip validation before build
+   */
+  skipValidation?: boolean;
+
+  /**
+   * Initialize KnowledgeLibrary directories for agents
+   */
+  initKnowledgeLibrary?: boolean;
+}
+
+/**
+ * Result of build command
+ */
+export interface BuildCommandResult {
+  success: boolean;
+  result?: CompileResult;
+  config?: ResolvedCoreAIConfig;
+  error?: string;
+  warnings?: string[];
+  knowledgeLibraryInitialized?: string[];
+}
+
+/**
+ * Build agents
+ */
+export function build(options: BuildCommandOptions = {}): BuildCommandResult {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const warnings: string[] = [];
+
+  // Load config if available
+  let config: ResolvedCoreAIConfig | undefined;
+  if (configExists(projectRoot)) {
+    try {
+      config = loadConfig(projectRoot);
+    } catch (error) {
+      if (error instanceof ConfigError) {
+        return {
+          success: false,
+          error: `Configuration error: ${error.message}`,
+        };
+      }
+      return {
+        success: false,
+        error: `Failed to load config: ${error instanceof Error ? error.message : String(error)}`,
+      };
+    }
+  } else {
+    warnings.push('No configuration file found. Building with defaults.');
+  }
+
+  // Set up compile options
+  const compileOptions: CompileOptions = {
+    projectRoot,
+  };
+
+  if (options.coreAgentsDir) {
+    compileOptions.coreAgentsDir = options.coreAgentsDir;
+  }
+
+  if (options.outputDir) {
+    compileOptions.outputDir = options.outputDir;
+  }
+
+  // Filter to specific agents if requested
+  if (options.agents && options.agents.length > 0) {
+    const agentsList = options.agents;
+    compileOptions.filter = (agent) => agentsList.includes(agent.role);
+  }
+
+  // Compile agents
+  try {
+    const result = compileAgents(config, compileOptions);
+
+    // Check for errors
+    if (result.errors.length > 0) {
+      return {
+        success: false,
+        result,
+        config,
+        error: `Failed to compile ${result.errors.length} agent(s)`,
+        warnings,
+      };
+    }
+
+    // Initialize KnowledgeLibrary for agents if requested
+    let knowledgeLibraryInitialized: string[] | undefined;
+    if (options.initKnowledgeLibrary) {
+      knowledgeLibraryInitialized = [];
+      for (const compiled of result.compiled) {
+        const initResult = initAgentKnowledgeLibrary(compiled.role, {
+          projectRoot,
+          createDefaults: true,
+        });
+        if (initResult.success && initResult.createdDirs.length > 0) {
+          knowledgeLibraryInitialized.push(compiled.role);
+        }
+      }
+    }
+
+    return {
+      success: true,
+      result,
+      config,
+      warnings: warnings.length > 0 ? warnings : undefined,
+      knowledgeLibraryInitialized,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Build failed: ${error instanceof Error ? error.message : String(error)}`,
+      warnings: warnings.length > 0 ? warnings : undefined,
+    };
+  }
+}
+
+/**
+ * Format build result for display
+ */
+export function formatBuildResult(result: BuildCommandResult): string {
+  const lines: string[] = [];
+
+  // Warnings
+  if (result.warnings && result.warnings.length > 0) {
+    for (const warning of result.warnings) {
+      lines.push(`⚠ ${warning}`);
+    }
+    lines.push('');
+  }
+
+  if (!result.success) {
+    lines.push(`Build failed: ${result.error}`);
+
+    // Show individual errors
+    if (result.result?.errors && result.result.errors.length > 0) {
+      lines.push('');
+      for (const error of result.result.errors) {
+        lines.push(`  ✗ ${error.role}: ${error.error}`);
+      }
+    }
+
+    return lines.join('\n');
+  }
+
+  const compileResult = result.result;
+  if (!compileResult) {
+    lines.push('No agents to compile.');
+    return lines.join('\n');
+  }
+
+  if (compileResult.compiled.length === 0) {
+    lines.push('No agents to compile.');
+    return lines.join('\n');
+  }
+
+  lines.push(`Compiled ${compileResult.compiled.length} agent(s):\n`);
+
+  // Group by source
+  const coreAgents = compileResult.compiled.filter((a) => a.source === 'core');
+  const customAgents = compileResult.compiled.filter((a) => a.source === 'custom');
+  const overrideAgents = compileResult.compiled.filter((a) => a.source === 'override');
+
+  if (coreAgents.length > 0) {
+    lines.push('Core agents:');
+    for (const agent of coreAgents) {
+      lines.push(`  ✓ ${agent.role}`);
+      lines.push(`    → ${agent.outputPath}`);
+    }
+    lines.push('');
+  }
+
+  if (customAgents.length > 0) {
+    lines.push('Custom agents:');
+    for (const agent of customAgents) {
+      lines.push(`  ✓ ${agent.role}`);
+      lines.push(`    → ${agent.outputPath}`);
+    }
+    lines.push('');
+  }
+
+  if (overrideAgents.length > 0) {
+    lines.push('Override agents:');
+    for (const agent of overrideAgents) {
+      lines.push(`  ✓ ${agent.role} (overrides core)`);
+      lines.push(`    → ${agent.outputPath}`);
+    }
+    lines.push('');
+  }
+
+  // KnowledgeLibrary initialization
+  if (result.knowledgeLibraryInitialized && result.knowledgeLibraryInitialized.length > 0) {
+    lines.push(
+      `KnowledgeLibrary initialized for ${result.knowledgeLibraryInitialized.length} agent(s):`
+    );
+    for (const agent of result.knowledgeLibraryInitialized) {
+      lines.push(`  ✓ ${agent}`);
+    }
+    lines.push('');
+  }
+
+  lines.push('Build complete!');
+
+  return lines.join('\n');
+}

package/src/cli/commands/cache.test.ts

@@ -0,0 +1,221 @@
+/**
+ * Cache Commands Tests
+ */
+
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { FileCacheProvider } from '../../cache/provider.js';
+import {
+  cacheStatus,
+  cacheClear,
+  cacheClearExpired,
+  formatCacheStatus,
+  formatBytes,
+} from './cache.js';
+
+describe('Cache Commands', () => {
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `cache-cmd-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    await fs.mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    try {
+      await fs.rm(testDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe('cacheStatus', () => {
+    it('should return initialized for new directory', async () => {
+      // Cache auto-initializes when called
+      const result = await cacheStatus({ cachePath: join(testDir, 'new-cache') });
+
+      expect(result.initialized).toBe(true);
+      expect(result.stats).not.toBeNull();
+      expect(result.entries).toHaveLength(0);
+    });
+
+    it('should return status for initialized cache', async () => {
+      // Initialize cache with some entries
+      const provider = new FileCacheProvider({ basePath: testDir });
+      await provider.initialize();
+      await provider.set('test-key', 'test content', {
+        source: 'github',
+        sourceUrl: 'https://github.com/test',
+      });
+
+      const result = await cacheStatus({ cachePath: testDir });
+
+      expect(result.initialized).toBe(true);
+      expect(result.stats).not.toBeNull();
+      expect(result.stats?.totalEntries).toBe(1);
+      expect(result.entries).toHaveLength(1);
+      expect(result.entries[0].key).toBe('test-key');
+      expect(result.entries[0].source).toBe('github');
+    });
+
+    it('should include entry status', async () => {
+      const provider = new FileCacheProvider({ basePath: testDir });
+      await provider.initialize();
+      await provider.set(
+        'valid-entry',
+        'content',
+        { source: 'local', sourceUrl: '' },
+        { ttl: 3600 }
+      );
+
+      const result = await cacheStatus({ cachePath: testDir });
+
+      expect(result.entries[0].status).toBe('valid');
+    });
+  });
+
+  describe('cacheClear', () => {
+    it('should clear all cache entries', async () => {
+      const provider = new FileCacheProvider({ basePath: testDir });
+      await provider.initialize();
+      await provider.set('key1', 'content1', { source: 'local', sourceUrl: '' });
+      await provider.set('key2', 'content2', { source: 'local', sourceUrl: '' });
+
+      const result = await cacheClear({ cachePath: testDir });
+
+      expect(result.success).toBe(true);
+      expect(result.cleared).toBe(2);
+
+      // Verify cache is empty
+      const status = await cacheStatus({ cachePath: testDir });
+      expect(status.entries).toHaveLength(0);
+    });
+
+    it('should handle empty cache', async () => {
+      const provider = new FileCacheProvider({ basePath: testDir });
+      await provider.initialize();
+
+      const result = await cacheClear({ cachePath: testDir });
+
+      expect(result.success).toBe(true);
+      expect(result.cleared).toBe(0);
+    });
+
+    it('should handle uninitialized cache directory', async () => {
+      const result = await cacheClear({ cachePath: join(testDir, 'new-cache') });
+
+      expect(result.success).toBe(true);
+      expect(result.cleared).toBe(0);
+    });
+  });
+
+  describe('cacheClearExpired', () => {
+    it('should only clear expired entries', async () => {
+      const provider = new FileCacheProvider({ basePath: testDir });
+      await provider.initialize();
+
+      // Add a valid entry
+      await provider.set('valid', 'content', { source: 'local', sourceUrl: '' }, { ttl: 3600 });
+
+      // Add an "expired" entry by manipulating the metadata
+      await provider.set('expired', 'content', { source: 'local', sourceUrl: '' }, { ttl: 1 });
+
+      // Wait for expiration
+      await new Promise((resolve) => setTimeout(resolve, 1100));
+
+      const result = await cacheClearExpired({ cachePath: testDir });
+
+      expect(result.success).toBe(true);
+      expect(result.cleared).toBe(1);
+
+      // Valid entry should still exist
+      const status = await cacheStatus({ cachePath: testDir });
+      expect(status.entries.map((e) => e.key)).toContain('valid');
+    });
+  });
+
+  describe('formatBytes', () => {
+    it('should format bytes correctly', () => {
+      expect(formatBytes(0)).toBe('0 B');
+      expect(formatBytes(100)).toBe('100 B');
+      expect(formatBytes(1024)).toBe('1 KB');
+      expect(formatBytes(1536)).toBe('1.5 KB');
+      expect(formatBytes(1048576)).toBe('1 MB');
+      expect(formatBytes(1073741824)).toBe('1 GB');
+    });
+  });
+
+  describe('formatCacheStatus', () => {
+    it('should format uninitialized cache', () => {
+      const result = formatCacheStatus({
+        initialized: false,
+        path: '/test/cache',
+        stats: null,
+        entries: [],
+      });
+
+      expect(result).toContain('Not initialized');
+      expect(result).toContain('/test/cache');
+    });
+
+    it('should format initialized cache with entries', () => {
+      const result = formatCacheStatus({
+        initialized: true,
+        path: '/test/cache',
+        stats: {
+          totalEntries: 2,
+          totalSize: 1024,
+          validEntries: 1,
+          staleEntries: 1,
+          expiredEntries: 0,
+          bySource: { github: 2, confluence: 0, notion: 0, local: 0, custom: 0 },
+          newestEntry: '2024-01-01T00:00:00Z',
+        },
+        entries: [
+          {
+            key: 'entry1',
+            source: 'github',
+            status: 'valid',
+            size: 512,
+            cachedAt: '2024-01-01T00:00:00Z',
+            expiresAt: '2024-01-02T00:00:00Z',
+          },
+          {
+            key: 'entry2',
+            source: 'github',
+            status: 'stale',
+            size: 512,
+            cachedAt: '2024-01-01T00:00:00Z',
+            expiresAt: '2024-01-02T00:00:00Z',
+          },
+        ],
+      });
+
+      expect(result).toContain('Initialized');
+      expect(result).toContain('Entries: 2');
+      expect(result).toContain('1 KB');
+      expect(result).toContain('github');
+      expect(result).toContain('entry1');
+      expect(result).toContain('entry2');
+    });
+
+    it('should format empty cache', () => {
+      const result = formatCacheStatus({
+        initialized: true,
+        path: '/test/cache',
+        stats: {
+          totalEntries: 0,
+          totalSize: 0,
+          validEntries: 0,
+          staleEntries: 0,
+          expiredEntries: 0,
+          bySource: { github: 0, confluence: 0, notion: 0, local: 0, custom: 0 },
+        },
+        entries: [],
+      });
+
+      expect(result).toContain('No entries in cache');
+    });
+  });
+});