@deimoscloud/coreai 0.1.0

package/src/cli/commands/cache.ts

@@ -0,0 +1,229 @@
+/**
+ * Cache Commands
+ *
+ * Commands for managing the local cache.
+ */
+
+import { join } from 'path';
+import { FileCacheProvider, CACHE_PATHS, type CacheStats } from '../../cache/index.js';
+
+/**
+ * Options for cache commands
+ */
+export interface CacheCommandOptions {
+  /**
+   * Project root directory
+   */
+  projectRoot?: string;
+
+  /**
+   * Custom cache path (overrides default)
+   */
+  cachePath?: string;
+
+  /**
+   * Output format
+   */
+  format?: 'text' | 'json';
+}
+
+/**
+ * Result of cache status command
+ */
+export interface CacheStatusResult {
+  initialized: boolean;
+  path: string;
+  stats: CacheStats | null;
+  entries: {
+    key: string;
+    source: string;
+    status: string;
+    size: number;
+    cachedAt: string;
+    expiresAt: string;
+  }[];
+}
+
+/**
+ * Result of cache clear command
+ */
+export interface CacheClearResult {
+  cleared: number;
+  success: boolean;
+  error?: string;
+}
+
+/**
+ * Get the cache path for a project
+ */
+function getCachePath(options: CacheCommandOptions): string {
+  if (options.cachePath) {
+    return options.cachePath;
+  }
+  const root = options.projectRoot ?? process.cwd();
+  return join(root, CACHE_PATHS.base);
+}
+
+/**
+ * Get cache status
+ */
+export async function cacheStatus(options: CacheCommandOptions = {}): Promise<CacheStatusResult> {
+  const cachePath = getCachePath(options);
+
+  const provider = new FileCacheProvider({ basePath: cachePath });
+
+  try {
+    await provider.initialize();
+  } catch {
+    return {
+      initialized: false,
+      path: cachePath,
+      stats: null,
+      entries: [],
+    };
+  }
+
+  const stats = await provider.getStats();
+  const metadataList = await provider.list();
+
+  const entries = await Promise.all(
+    metadataList.map(async (metadata) => {
+      const status = await provider.getStatus(metadata.key);
+      return {
+        key: metadata.key,
+        source: metadata.source,
+        status: status ?? 'unknown',
+        size: metadata.size,
+        cachedAt: metadata.cachedAt,
+        expiresAt: metadata.expiresAt,
+      };
+    })
+  );
+
+  return {
+    initialized: true,
+    path: cachePath,
+    stats,
+    entries,
+  };
+}
+
+/**
+ * Clear all cache entries
+ */
+export async function cacheClear(options: CacheCommandOptions = {}): Promise<CacheClearResult> {
+  const cachePath = getCachePath(options);
+
+  const provider = new FileCacheProvider({ basePath: cachePath });
+
+  try {
+    await provider.initialize();
+    const cleared = await provider.clear();
+    return { cleared, success: true };
+  } catch (error) {
+    return {
+      cleared: 0,
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+/**
+ * Clear expired cache entries
+ */
+export async function cacheClearExpired(
+  options: CacheCommandOptions = {}
+): Promise<CacheClearResult> {
+  const cachePath = getCachePath(options);
+
+  const provider = new FileCacheProvider({ basePath: cachePath });
+
+  try {
+    await provider.initialize();
+    const cleared = await provider.clearExpired();
+    return { cleared, success: true };
+  } catch (error) {
+    return {
+      cleared: 0,
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+/**
+ * Format bytes to human-readable string
+ */
+export function formatBytes(bytes: number): string {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+/**
+ * Format cache status for terminal output
+ */
+export function formatCacheStatus(result: CacheStatusResult): string {
+  const lines: string[] = [];
+
+  lines.push('Cache Status');
+  lines.push('============');
+  lines.push('');
+
+  if (!result.initialized) {
+    lines.push(`Path: ${result.path}`);
+    lines.push('Status: Not initialized (no cache found)');
+    return lines.join('\n');
+  }
+
+  lines.push(`Path: ${result.path}`);
+  lines.push('Status: Initialized');
+  lines.push('');
+
+  if (result.stats) {
+    lines.push('Statistics:');
+    lines.push(`  Entries: ${result.stats.totalEntries}`);
+    lines.push(`  Total size: ${formatBytes(result.stats.totalSize)}`);
+    lines.push(
+      `  Valid: ${result.stats.validEntries}, Stale: ${result.stats.staleEntries}, Expired: ${result.stats.expiredEntries}`
+    );
+    if (result.stats.newestEntry) {
+      lines.push(`  Last updated: ${result.stats.newestEntry}`);
+    }
+  }
+
+  if (result.entries.length > 0) {
+    lines.push('');
+    lines.push('Entries:');
+    lines.push('');
+
+    // Group by source
+    const bySource = new Map<string, typeof result.entries>();
+    for (const entry of result.entries) {
+      const source = entry.source;
+      if (!bySource.has(source)) {
+        bySource.set(source, []);
+      }
+      const entries = bySource.get(source);
+      if (entries) {
+        entries.push(entry);
+      }
+    }
+
+    for (const [source, entries] of bySource) {
+      lines.push(`  ${source}:`);
+      for (const entry of entries) {
+        const statusIcon = entry.status === 'valid' ? '✓' : entry.status === 'stale' ? '○' : '✗';
+        lines.push(`    ${statusIcon} ${entry.key} (${formatBytes(entry.size)})`);
+      }
+    }
+  } else {
+    lines.push('');
+    lines.push('No entries in cache.');
+  }
+
+  return lines.join('\n');
+}

package/src/cli/commands/index.ts

@@ -0,0 +1,63 @@
+/**
+ * CLI Commands
+ *
+ * Command implementations for the CoreAI CLI.
+ */
+
+// Cache commands
+export {
+  cacheStatus,
+  cacheClear,
+  cacheClearExpired,
+  formatCacheStatus,
+  formatBytes,
+  type CacheCommandOptions,
+  type CacheStatusResult,
+  type CacheClearResult,
+} from './cache.js';
+
+// Sync commands
+export { sync, formatSyncResult, type SyncCommandOptions, type SyncCommandResult } from './sync.js';
+
+// Init command
+export { init, formatInitResult, type InitCommandOptions, type InitCommandResult } from './init.js';
+
+// Build command
+export {
+  build,
+  formatBuildResult,
+  type BuildCommandOptions,
+  type BuildCommandResult,
+} from './build.js';
+
+// Validate command
+export {
+  validate,
+  formatValidateResult,
+  type ValidateCommandOptions,
+  type ValidateCommandResult,
+  type ValidationIssue,
+} from './validate.js';
+
+// Skills commands
+export {
+  skillsGenerate,
+  formatSkillsGenerateResult,
+  skillsList,
+  formatSkillsListResult,
+  type SkillsGenerateOptions,
+  type SkillsGenerateResult,
+  type SkillsListOptions,
+  type SkillsListResult,
+  type SkillInfo,
+} from './skills.js';
+
+// Status command
+export {
+  status,
+  formatStatusResult,
+  formatStatusSummary,
+  type StatusCommandOptions,
+  type StatusCommandResult,
+  type AgentStatus,
+} from './status.js';

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

@@ -0,0 +1,173 @@
+/**
+ * Init Command Tests
+ */
+
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { init, formatInitResult } from './init.js';
+
+describe('Init Command', () => {
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `init-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('init', () => {
+    it('should create config file with defaults', async () => {
+      const result = init({
+        projectRoot: testDir,
+        name: 'test-project',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.configPath).toBe(join(testDir, 'coreai.config.yaml'));
+
+      // Verify file exists
+      const configPath = result.configPath ?? '';
+      const content = await fs.readFile(configPath, 'utf-8');
+      expect(content).toContain('name: "test-project"');
+      expect(content).toContain('type: software');
+    });
+
+    it('should create directory structure', async () => {
+      const result = init({
+        projectRoot: testDir,
+        name: 'test-project',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.createdDirs).toBeDefined();
+      expect(result.createdDirs?.length).toBeGreaterThan(0);
+
+      // Verify directories exist
+      const coreaiDir = join(testDir, 'coreai', 'agents');
+      const stat = await fs.stat(coreaiDir);
+      expect(stat.isDirectory()).toBe(true);
+    });
+
+    it('should skip directory creation when skipDirs is true', async () => {
+      const result = init({
+        projectRoot: testDir,
+        name: 'test-project',
+        skipDirs: true,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.createdDirs).toEqual([]);
+    });
+
+    it('should fail if config already exists without force', async () => {
+      // Create existing config
+      await fs.writeFile(join(testDir, 'coreai.config.yaml'), 'version: "1.0"');
+
+      const result = init({
+        projectRoot: testDir,
+        name: 'test-project',
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('already exists');
+    });
+
+    it('should overwrite config with force option', async () => {
+      // Create existing config
+      await fs.writeFile(join(testDir, 'coreai.config.yaml'), 'version: "1.0"');
+
+      const result = init({
+        projectRoot: testDir,
+        name: 'new-project',
+        force: true,
+      });
+
+      expect(result.success).toBe(true);
+
+      const configPath2 = result.configPath ?? '';
+      const content = await fs.readFile(configPath2, 'utf-8');
+      expect(content).toContain('name: "new-project"');
+    });
+
+    it('should use custom project type', async () => {
+      const result = init({
+        projectRoot: testDir,
+        name: 'mobile-app',
+        type: 'mobile',
+      });
+
+      expect(result.success).toBe(true);
+
+      const configPath3 = result.configPath ?? '';
+      const content = await fs.readFile(configPath3, 'utf-8');
+      expect(content).toContain('type: mobile');
+    });
+
+    it('should detect project name from directory', async () => {
+      const result = init({
+        projectRoot: testDir,
+      });
+
+      expect(result.success).toBe(true);
+
+      // Should use directory name as project name
+      const configPath4 = result.configPath ?? '';
+      const content = await fs.readFile(configPath4, 'utf-8');
+      expect(content).toContain('name:');
+    });
+  });
+
+  describe('formatInitResult', () => {
+    it('should format success result', () => {
+      const result = {
+        success: true,
+        configPath: '/path/to/coreai.config.yaml',
+        createdDirs: ['/path/to/coreai/agents'],
+      };
+
+      const output = formatInitResult(result);
+
+      expect(output).toContain('initialized successfully');
+      expect(output).toContain('coreai.config.yaml');
+      expect(output).toContain('Next steps');
+    });
+
+    it('should format error result', () => {
+      const result = {
+        success: false,
+        error: 'Config already exists',
+      };
+
+      const output = formatInitResult(result);
+
+      expect(output).toContain('Error');
+      expect(output).toContain('Config already exists');
+    });
+
+    it('should show detected git info', () => {
+      const result = {
+        success: true,
+        configPath: '/path/to/config.yaml',
+        createdDirs: [],
+        gitInfo: {
+          provider: 'github' as const,
+          owner: 'test-owner',
+          repo: 'test-repo',
+        },
+      };
+
+      const output = formatInitResult(result);
+
+      expect(output).toContain('github');
+      expect(output).toContain('test-owner/test-repo');
+    });
+  });
+});