@deimoscloud/coreai 0.1.0

package/src/cli/commands/sync.ts

@@ -0,0 +1,251 @@
+/**
+ * Sync Command
+ *
+ * Syncs shared context from remote sources.
+ */
+
+import { join } from 'path';
+import {
+  FileCacheProvider,
+  CACHE_PATHS,
+  type SyncResult,
+  type CacheSource,
+} from '../../cache/index.js';
+import { CacheManager } from '../../cache/manager.js';
+import type { RemoteFetcher } from '../../cache/interfaces.js';
+
+/**
+ * Options for sync command
+ */
+export interface SyncCommandOptions {
+  /**
+   * Project root directory
+   */
+  projectRoot?: string;
+
+  /**
+   * Custom cache path
+   */
+  cachePath?: string;
+
+  /**
+   * Force refresh all entries
+   */
+  force?: boolean;
+
+  /**
+   * Filter by source type
+   */
+  source?: CacheSource;
+
+  /**
+   * Continue on error
+   */
+  continueOnError?: boolean;
+
+  /**
+   * Maximum concurrent fetches
+   */
+  concurrency?: number;
+
+  /**
+   * Progress callback
+   */
+  onProgress?: (completed: number, total: number, message: string) => void;
+}
+
+/**
+ * Result of sync command
+ */
+export interface SyncCommandResult {
+  success: boolean;
+  result: SyncResult | null;
+  error?: string;
+  sources: string[];
+}
+
+/**
+ * Create a mock fetcher for a source (placeholder until real fetchers are implemented)
+ *
+ * In a real implementation, these would be replaced with actual fetchers
+ * that use the documentation adapter interfaces.
+ */
+function createPlaceholderFetcher(source: string): RemoteFetcher {
+  return {
+    async fetch(url: string) {
+      // This is a placeholder - real implementation would use adapters
+      throw new Error(
+        `No fetcher implementation for source "${source}". ` +
+          `URL: ${url}. Configure a documentation provider in coreai.config.yaml.`
+      );
+    },
+    async hasChanged(_url: string, _etag?: string) {
+      // Always return true for placeholder
+      return true;
+    },
+  };
+}
+
+/**
+ * Get the cache path for a project
+ */
+function getCachePath(options: SyncCommandOptions): string {
+  if (options.cachePath) {
+    return options.cachePath;
+  }
+  const root = options.projectRoot ?? process.cwd();
+  return join(root, CACHE_PATHS.base);
+}
+
+/**
+ * Sync cached entries from remote sources
+ *
+ * This command refreshes cached content by re-fetching from remote sources.
+ * If --force is specified, it clears stale/expired status and fetches fresh content.
+ */
+export async function sync(options: SyncCommandOptions = {}): Promise<SyncCommandResult> {
+  const cachePath = getCachePath(options);
+
+  const provider = new FileCacheProvider({ basePath: cachePath });
+
+  try {
+    await provider.initialize();
+  } catch (error) {
+    return {
+      success: false,
+      result: null,
+      error: `Failed to initialize cache: ${error instanceof Error ? error.message : String(error)}`,
+      sources: [],
+    };
+  }
+
+  // Get all cached entries
+  const entries = await provider.list({ source: options.source });
+
+  if (entries.length === 0) {
+    return {
+      success: true,
+      result: {
+        added: 0,
+        updated: 0,
+        removed: 0,
+        failed: 0,
+        errors: [],
+        duration: 0,
+      },
+      sources: [],
+    };
+  }
+
+  // Create cache manager
+  const manager = new CacheManager({
+    cache: provider,
+    defaultTtl: 3600,
+  });
+
+  // Collect unique sources and register placeholder fetchers
+  const sources = new Set<string>();
+  for (const entry of entries) {
+    sources.add(entry.source);
+  }
+
+  // Register fetchers for each source
+  // In a real implementation, these would be actual fetcher implementations
+  for (const source of sources) {
+    if (!manager.hasFetcher(source)) {
+      manager.registerFetcher(source, createPlaceholderFetcher(source));
+    }
+  }
+
+  // Get keys to sync
+  const keys = entries.map((e) => e.key);
+
+  // Report progress
+  if (options.onProgress) {
+    options.onProgress(0, keys.length, 'Starting sync...');
+  }
+
+  // Sync entries
+  try {
+    const result = await manager.syncEntries(keys, {
+      force: options.force,
+      continueOnError: options.continueOnError ?? true,
+      concurrency: options.concurrency ?? 5,
+      onProgress: (completed, total) => {
+        if (options.onProgress) {
+          options.onProgress(completed, total, `Syncing ${completed}/${total} entries...`);
+        }
+      },
+    });
+
+    return {
+      success: result.failed === 0 || options.continueOnError === true,
+      result,
+      sources: Array.from(sources),
+    };
+  } catch (error) {
+    return {
+      success: false,
+      result: null,
+      error: error instanceof Error ? error.message : String(error),
+      sources: Array.from(sources),
+    };
+  }
+}
+
+/**
+ * Format sync result for terminal output
+ */
+export function formatSyncResult(result: SyncCommandResult): string {
+  const lines: string[] = [];
+
+  lines.push('Sync Results');
+  lines.push('============');
+  lines.push('');
+
+  if (!result.success && result.error) {
+    lines.push(`Error: ${result.error}`);
+    return lines.join('\n');
+  }
+
+  if (!result.result) {
+    lines.push('No sync operation performed.');
+    return lines.join('\n');
+  }
+
+  const r = result.result;
+
+  if (r.added === 0 && r.updated === 0 && r.removed === 0 && r.failed === 0) {
+    lines.push('Cache is empty. Nothing to sync.');
+    lines.push('');
+    lines.push('Tip: Add context sources to your coreai.config.yaml to fetch remote content.');
+    return lines.join('\n');
+  }
+
+  lines.push(`Duration: ${r.duration}ms`);
+  lines.push('');
+
+  if (result.sources.length > 0) {
+    lines.push(`Sources: ${result.sources.join(', ')}`);
+    lines.push('');
+  }
+
+  lines.push('Summary:');
+  if (r.added > 0) lines.push(`  ✓ Added: ${r.added}`);
+  if (r.updated > 0) lines.push(`  ✓ Updated: ${r.updated}`);
+  if (r.removed > 0) lines.push(`  ○ Removed: ${r.removed}`);
+  if (r.failed > 0) lines.push(`  ✗ Failed: ${r.failed}`);
+
+  if (r.errors.length > 0) {
+    lines.push('');
+    lines.push('Errors:');
+    for (const err of r.errors.slice(0, 10)) {
+      lines.push(`  - ${err.key}: ${err.error}`);
+    }
+    if (r.errors.length > 10) {
+      lines.push(`  ... and ${r.errors.length - 10} more errors`);
+    }
+  }
+
+  return lines.join('\n');
+}

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

@@ -0,0 +1,216 @@
+/**
+ * Validate Command Tests
+ */
+
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { validate, formatValidateResult } from './validate.js';
+
+describe('Validate Command', () => {
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = join(
+      tmpdir(),
+      `validate-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('validate', () => {
+    it('should report error if no config exists', () => {
+      const result = validate({
+        projectRoot: testDir,
+        checkAgents: false,
+        checkDirs: false,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.valid).toBe(false);
+      expect(result.summary.errors).toBeGreaterThan(0);
+      expect(result.issues.some((i) => i.message.includes('No CoreAI configuration'))).toBe(true);
+    });
+
+    it('should validate valid config', async () => {
+      const configPath = join(testDir, 'coreai.config.yaml');
+      await fs.writeFile(
+        configPath,
+        `version: "1.0"
+project:
+  name: test-project
+  type: software
+team:
+  agents:
+    - backend-engineer
+`
+      );
+
+      const result = validate({
+        projectRoot: testDir,
+        checkAgents: false,
+        checkDirs: false,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.config).toBeDefined();
+      expect(result.config?.project.name).toBe('test-project');
+    });
+
+    it('should report config syntax errors', async () => {
+      const configPath = join(testDir, 'coreai.config.yaml');
+      await fs.writeFile(configPath, 'invalid: yaml: content: [');
+
+      const result = validate({
+        projectRoot: testDir,
+        checkAgents: false,
+        checkDirs: false,
+      });
+
+      expect(result.valid).toBe(false);
+      expect(result.issues.some((i) => i.category === 'config' && i.level === 'error')).toBe(true);
+    });
+
+    it('should check for missing directories', async () => {
+      const configPath = join(testDir, 'coreai.config.yaml');
+      await fs.writeFile(
+        configPath,
+        `version: "1.0"
+project:
+  name: test-project
+`
+      );
+
+      const result = validate({
+        projectRoot: testDir,
+        checkAgents: false,
+        checkDirs: true,
+      });
+
+      expect(result.issues.some((i) => i.category === 'directories')).toBe(true);
+    });
+
+    it('should report info for unconfigured integrations', async () => {
+      const configPath = join(testDir, 'coreai.config.yaml');
+      await fs.writeFile(
+        configPath,
+        `version: "1.0"
+project:
+  name: test-project
+`
+      );
+
+      const result = validate({
+        projectRoot: testDir,
+        checkAgents: false,
+        checkDirs: false,
+      });
+
+      expect(result.issues.some((i) => i.category === 'integrations' && i.level === 'info')).toBe(
+        true
+      );
+    });
+
+    it('should warn about incomplete git integration', async () => {
+      const configPath = join(testDir, 'coreai.config.yaml');
+      await fs.writeFile(
+        configPath,
+        `version: "1.0"
+project:
+  name: test-project
+integrations:
+  git:
+    provider: github
+`
+      );
+
+      const result = validate({
+        projectRoot: testDir,
+        checkAgents: false,
+        checkDirs: false,
+      });
+
+      expect(
+        result.issues.some((i) => i.category === 'integrations' && i.level === 'warning')
+      ).toBe(true);
+    });
+
+    it('should calculate correct summary', async () => {
+      const result = validate({
+        projectRoot: testDir,
+        checkAgents: false,
+        checkDirs: true,
+      });
+
+      expect(result.summary.errors + result.summary.warnings + result.summary.info).toBe(
+        result.issues.length
+      );
+    });
+  });
+
+  describe('formatValidateResult', () => {
+    it('should format valid result', () => {
+      const result = {
+        success: true,
+        valid: true,
+        issues: [],
+        summary: { errors: 0, warnings: 0, info: 0 },
+      };
+
+      const output = formatValidateResult(result);
+
+      expect(output).toContain('✓');
+      expect(output).toContain('valid');
+    });
+
+    it('should format invalid result', () => {
+      const result = {
+        success: true,
+        valid: false,
+        issues: [
+          {
+            level: 'error' as const,
+            category: 'config' as const,
+            message: 'Config missing',
+            fix: 'Run coreai init',
+          },
+        ],
+        summary: { errors: 1, warnings: 0, info: 0 },
+      };
+
+      const output = formatValidateResult(result);
+
+      expect(output).toContain('✗');
+      expect(output).toContain('errors');
+      expect(output).toContain('Config missing');
+      expect(output).toContain('Run coreai init');
+    });
+
+    it('should group issues by category', () => {
+      const result = {
+        success: true,
+        valid: false,
+        issues: [
+          { level: 'error' as const, category: 'config' as const, message: 'Config error' },
+          { level: 'warning' as const, category: 'directories' as const, message: 'Dir warning' },
+          { level: 'info' as const, category: 'integrations' as const, message: 'Int info' },
+        ],
+        summary: { errors: 1, warnings: 1, info: 1 },
+      };
+
+      const output = formatValidateResult(result);
+
+      expect(output).toContain('Config');
+      expect(output).toContain('Directories');
+      expect(output).toContain('Integrations');
+    });
+  });
+});