@deimoscloud/coreai 0.1.0

package/src/cli/commands/validate.ts

@@ -0,0 +1,340 @@
+/**
+ * Validate Command
+ *
+ * Validates CoreAI configuration and project setup.
+ */
+
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { configExists, loadConfig, ConfigError } from '../../config/loader.js';
+import type { ResolvedCoreAIConfig } from '../../config/types.js';
+import { loadAllAgents } from '../../agents/index.js';
+
+/**
+ * Options for validate command
+ */
+export interface ValidateCommandOptions {
+  /**
+   * Project root directory
+   */
+  projectRoot?: string;
+
+  /**
+   * Path to core agents directory
+   */
+  coreAgentsDir?: string;
+
+  /**
+   * Check if configured agents exist
+   */
+  checkAgents?: boolean;
+
+  /**
+   * Check directory structure
+   */
+  checkDirs?: boolean;
+
+  /**
+   * Check quality gates commands exist
+   */
+  checkQualityGates?: boolean;
+}
+
+/**
+ * Single validation issue
+ */
+export interface ValidationIssue {
+  level: 'error' | 'warning' | 'info';
+  category: 'config' | 'agents' | 'directories' | 'quality_gates' | 'integrations';
+  message: string;
+  fix?: string;
+}
+
+/**
+ * Result of validate command
+ */
+export interface ValidateCommandResult {
+  success: boolean;
+  valid: boolean;
+  config?: ResolvedCoreAIConfig;
+  issues: ValidationIssue[];
+  summary: {
+    errors: number;
+    warnings: number;
+    info: number;
+  };
+}
+
+/**
+ * Validate configuration file
+ */
+function validateConfig(projectRoot: string): {
+  config?: ResolvedCoreAIConfig;
+  issues: ValidationIssue[];
+} {
+  const issues: ValidationIssue[] = [];
+
+  if (!configExists(projectRoot)) {
+    issues.push({
+      level: 'error',
+      category: 'config',
+      message: 'No CoreAI configuration file found',
+      fix: 'Run `coreai init` to create a configuration file',
+    });
+    return { issues };
+  }
+
+  try {
+    const config = loadConfig(projectRoot);
+    return { config, issues };
+  } catch (error) {
+    if (error instanceof ConfigError) {
+      issues.push({
+        level: 'error',
+        category: 'config',
+        message: `Configuration error: ${error.message}`,
+        fix: 'Check coreai.config.yaml for syntax errors',
+      });
+    } else {
+      issues.push({
+        level: 'error',
+        category: 'config',
+        message: `Failed to load config: ${error instanceof Error ? error.message : String(error)}`,
+      });
+    }
+    return { issues };
+  }
+}
+
+/**
+ * Validate configured agents exist
+ */
+function validateAgents(
+  config: ResolvedCoreAIConfig,
+  coreAgentsDir: string,
+  projectRoot: string
+): ValidationIssue[] {
+  const issues: ValidationIssue[] = [];
+  const customAgentsDir = join(projectRoot, 'coreai', 'agents');
+
+  // Load available agents
+  let availableAgents: Map<string, unknown>;
+  try {
+    availableAgents = loadAllAgents({
+      coreAgentsDir,
+      customAgentsDir,
+    });
+  } catch (error) {
+    issues.push({
+      level: 'warning',
+      category: 'agents',
+      message: `Could not load agents: ${error instanceof Error ? error.message : String(error)}`,
+    });
+    return issues;
+  }
+
+  // Check each configured agent
+  const configuredAgents = config.team.agents;
+  for (const agentRole of configuredAgents) {
+    if (!availableAgents.has(agentRole)) {
+      issues.push({
+        level: 'error',
+        category: 'agents',
+        message: `Configured agent '${agentRole}' not found`,
+        fix: `Add agent definition to coreai/agents/${agentRole}.yaml or remove from config`,
+      });
+    }
+  }
+
+  // Info about available but not configured agents
+  const unconfigured = Array.from(availableAgents.keys()).filter(
+    (role) => !configuredAgents.includes(role)
+  );
+  if (unconfigured.length > 0) {
+    issues.push({
+      level: 'info',
+      category: 'agents',
+      message: `${unconfigured.length} available agent(s) not configured: ${unconfigured.join(', ')}`,
+    });
+  }
+
+  return issues;
+}
+
+/**
+ * Validate directory structure
+ */
+function validateDirectories(projectRoot: string): ValidationIssue[] {
+  const issues: ValidationIssue[] = [];
+
+  const requiredDirs = [{ path: 'coreai', description: 'CoreAI configuration directory' }];
+
+  const optionalDirs = [
+    { path: 'coreai/agents', description: 'Custom agent definitions' },
+    { path: 'coreai/commands', description: 'Custom command definitions' },
+    { path: '.coreai', description: 'CoreAI runtime directory' },
+    { path: '.coreai/cache', description: 'Cache directory' },
+    { path: '.claude/agents', description: 'Compiled agents output' },
+  ];
+
+  // Check required directories
+  for (const dir of requiredDirs) {
+    const fullPath = join(projectRoot, dir.path);
+    if (!existsSync(fullPath)) {
+      issues.push({
+        level: 'warning',
+        category: 'directories',
+        message: `Missing directory: ${dir.path} (${dir.description})`,
+        fix: `Run mkdir -p ${dir.path}`,
+      });
+    }
+  }
+
+  // Check optional directories (info only)
+  for (const dir of optionalDirs) {
+    const fullPath = join(projectRoot, dir.path);
+    if (!existsSync(fullPath)) {
+      issues.push({
+        level: 'info',
+        category: 'directories',
+        message: `Optional directory not found: ${dir.path} (${dir.description})`,
+      });
+    }
+  }
+
+  return issues;
+}
+
+/**
+ * Validate integrations configuration
+ */
+function validateIntegrations(config: ResolvedCoreAIConfig): ValidationIssue[] {
+  const issues: ValidationIssue[] = [];
+
+  if (!config.integrations) {
+    issues.push({
+      level: 'info',
+      category: 'integrations',
+      message: 'No integrations configured',
+    });
+    return issues;
+  }
+
+  // Check git integration
+  if (config.integrations.git) {
+    const git = config.integrations.git;
+    if (!git.config?.owner || !git.config?.repo) {
+      issues.push({
+        level: 'warning',
+        category: 'integrations',
+        message: 'Git integration configured but owner/repo not specified',
+        fix: 'Add integrations.git.config.owner and integrations.git.config.repo to config',
+      });
+    }
+  }
+
+  // Check issue tracker
+  if (config.integrations.issue_tracker) {
+    const tracker = config.integrations.issue_tracker;
+    if (tracker.provider === 'jira' && !tracker.config?.base_url) {
+      issues.push({
+        level: 'warning',
+        category: 'integrations',
+        message: 'Jira integration configured but base_url not specified',
+        fix: 'Add integrations.issue_tracker.config.base_url to config',
+      });
+    }
+  }
+
+  return issues;
+}
+
+/**
+ * Validate the CoreAI project
+ */
+export function validate(options: ValidateCommandOptions = {}): ValidateCommandResult {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const coreAgentsDir =
+    options.coreAgentsDir ?? join(projectRoot, 'node_modules', '@coreai', 'cli', 'agents');
+  const checkAgents = options.checkAgents ?? true;
+  const checkDirs = options.checkDirs ?? true;
+
+  const allIssues: ValidationIssue[] = [];
+
+  // Validate config
+  const { config, issues: configIssues } = validateConfig(projectRoot);
+  allIssues.push(...configIssues);
+
+  // If config loaded successfully, validate other aspects
+  if (config) {
+    // Validate agents
+    if (checkAgents) {
+      allIssues.push(...validateAgents(config, coreAgentsDir, projectRoot));
+    }
+
+    // Validate integrations
+    allIssues.push(...validateIntegrations(config));
+  }
+
+  // Validate directories (independent of config)
+  if (checkDirs) {
+    allIssues.push(...validateDirectories(projectRoot));
+  }
+
+  // Calculate summary
+  const summary = {
+    errors: allIssues.filter((i) => i.level === 'error').length,
+    warnings: allIssues.filter((i) => i.level === 'warning').length,
+    info: allIssues.filter((i) => i.level === 'info').length,
+  };
+
+  return {
+    success: true,
+    valid: summary.errors === 0,
+    config,
+    issues: allIssues,
+    summary,
+  };
+}
+
+/**
+ * Format validate result for display
+ */
+export function formatValidateResult(result: ValidateCommandResult): string {
+  const lines: string[] = [];
+
+  // Header
+  if (result.valid) {
+    lines.push('✓ Configuration is valid\n');
+  } else {
+    lines.push('✗ Configuration has errors\n');
+  }
+
+  // Group issues by category
+  const categories = ['config', 'agents', 'integrations', 'directories', 'quality_gates'] as const;
+
+  for (const category of categories) {
+    const categoryIssues = result.issues.filter((i) => i.category === category);
+    if (categoryIssues.length === 0) continue;
+
+    const categoryLabel = category.charAt(0).toUpperCase() + category.slice(1).replace('_', ' ');
+    lines.push(`${categoryLabel}:`);
+
+    for (const issue of categoryIssues) {
+      const prefix = issue.level === 'error' ? '  ✗' : issue.level === 'warning' ? '  ⚠' : '  ℹ';
+      lines.push(`${prefix} ${issue.message}`);
+      if (issue.fix) {
+        lines.push(`    → ${issue.fix}`);
+      }
+    }
+    lines.push('');
+  }
+
+  // Summary
+  lines.push('Summary:');
+  lines.push(`  Errors: ${result.summary.errors}`);
+  lines.push(`  Warnings: ${result.summary.warnings}`);
+  lines.push(`  Info: ${result.summary.info}`);
+
+  return lines.join('\n');
+}

package/src/cli/index.test.ts

@@ -0,0 +1,190 @@
+import { execSync } from 'child_process';
+import { join } from 'path';
+import { mkdtempSync, rmSync, existsSync, readFileSync } from 'fs';
+import { tmpdir } from 'os';
+
+const CLI_PATH = join(process.cwd(), 'dist', 'cli', 'index.js');
+
+function runCli(args: string, cwd?: string): string {
+  return execSync(`node ${CLI_PATH} ${args}`, {
+    encoding: 'utf-8',
+    cwd: cwd ?? process.cwd(),
+  });
+}
+
+function runCliWithError(args: string, cwd?: string): { stdout: string; stderr: string } {
+  try {
+    const stdout = execSync(`node ${CLI_PATH} ${args}`, {
+      encoding: 'utf-8',
+      cwd: cwd ?? process.cwd(),
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return { stdout, stderr: '' };
+  } catch (error) {
+    const e = error as { stdout?: string; stderr?: string };
+    return { stdout: e.stdout ?? '', stderr: e.stderr ?? '' };
+  }
+}
+
+describe('CoreAI CLI', () => {
+  describe('--version', () => {
+    it('should output the version number', () => {
+      const output = runCli('--version');
+      expect(output.trim()).toBe('0.1.0');
+    });
+  });
+
+  describe('--help', () => {
+    it('should display help information', () => {
+      const output = runCli('--help');
+      expect(output).toContain('coreai');
+      expect(output).toContain('A configurable, team-ready AI agent orchestration platform');
+    });
+
+    it('should list all commands', () => {
+      const output = runCli('--help');
+      expect(output).toContain('init');
+      expect(output).toContain('build');
+      expect(output).toContain('sync');
+      expect(output).toContain('validate');
+      expect(output).toContain('agents');
+      expect(output).toContain('cache');
+      expect(output).toContain('status');
+    });
+  });
+
+  describe('init command', () => {
+    it('should have --force option', () => {
+      const output = runCli('init --help');
+      expect(output).toContain('--force');
+      expect(output).toContain('overwrite existing configuration');
+    });
+  });
+
+  describe('build command', () => {
+    let tempDir: string;
+
+    beforeEach(() => {
+      tempDir = mkdtempSync(join(tmpdir(), 'coreai-cli-build-test-'));
+    });
+
+    afterEach(() => {
+      rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    it('should have --watch option', () => {
+      const output = runCli('build --help');
+      expect(output).toContain('--watch');
+    });
+
+    it('should have --output option', () => {
+      const output = runCli('build --help');
+      expect(output).toContain('--output');
+    });
+
+    it('should compile agents to output directory', () => {
+      const outputDir = join(tempDir, 'output');
+      const output = runCli(`build --output ${outputDir}`, tempDir);
+
+      expect(output).toContain('Building agents');
+      expect(output).toContain('Compiled');
+      expect(output).toContain('backend-engineer');
+      expect(output).toContain('Build complete');
+
+      // Verify files were created
+      expect(existsSync(join(outputDir, 'backend-engineer.md'))).toBe(true);
+      expect(existsSync(join(outputDir, 'frontend-engineer.md'))).toBe(true);
+      expect(existsSync(join(outputDir, 'devops-engineer.md'))).toBe(true);
+      expect(existsSync(join(outputDir, 'engineering-manager.md'))).toBe(true);
+    });
+
+    it('should generate valid markdown', () => {
+      const outputDir = join(tempDir, 'output');
+      runCli(`build --output ${outputDir}`, tempDir);
+
+      const content = readFileSync(join(outputDir, 'backend-engineer.md'), 'utf-8');
+      expect(content).toContain('# Backend Engineer');
+      expect(content).toContain('## Description');
+      expect(content).toContain('*Generated by CoreAI*');
+    });
+  });
+
+  describe('agents subcommand', () => {
+    it('should list subcommands', () => {
+      const output = runCli('agents --help');
+      expect(output).toContain('list');
+      expect(output).toContain('show');
+      expect(output).toContain('<name>');
+    });
+
+    describe('agents list', () => {
+      it('should list core agents', () => {
+        const output = runCli('agents list');
+        expect(output).toContain('backend-engineer');
+        expect(output).toContain('frontend-engineer');
+        expect(output).toContain('devops-engineer');
+        expect(output).toContain('engineering-manager');
+      });
+
+      it('should show agent types', () => {
+        const output = runCli('agents list');
+        expect(output).toContain('ic-engineer');
+        expect(output).toContain('specialist');
+        expect(output).toContain('manager');
+      });
+
+      it('should have --core option', () => {
+        const output = runCli('agents list --help');
+        expect(output).toContain('--core');
+      });
+
+      it('should have --custom option', () => {
+        const output = runCli('agents list --help');
+        expect(output).toContain('--custom');
+      });
+    });
+
+    describe('agents show', () => {
+      it('should show agent details', () => {
+        const output = runCli('agents show backend-engineer');
+        expect(output).toContain('Backend Engineer');
+        expect(output).toContain('backend-engineer');
+        expect(output).toContain('ic-engineer');
+        expect(output).toContain('Description:');
+      });
+
+      it('should show agent responsibilities', () => {
+        const output = runCli('agents show backend-engineer');
+        expect(output).toContain('Responsibilities:');
+      });
+
+      it('should support --json output', () => {
+        const output = runCli('agents show backend-engineer --json');
+        const agent = JSON.parse(output);
+        expect(agent.role).toBe('backend-engineer');
+        expect(agent.type).toBe('ic-engineer');
+      });
+
+      it('should support --markdown output', () => {
+        const output = runCli('agents show backend-engineer --markdown');
+        expect(output).toContain('# Backend Engineer');
+        expect(output).toContain('*Generated by CoreAI*');
+      });
+
+      it('should error for unknown agent', () => {
+        const result = runCliWithError('agents show unknown-agent');
+        // Error goes to stderr, available agents list goes to stdout
+        expect(result.stderr).toContain('Agent not found');
+        expect(result.stdout).toContain('Available agents');
+      });
+    });
+  });
+
+  describe('cache subcommand', () => {
+    it('should list subcommands', () => {
+      const output = runCli('cache --help');
+      expect(output).toContain('clear');
+      expect(output).toContain('status');
+    });
+  });
+});