@deimoscloud/coreai 0.1.8 → 0.1.10

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

@@ -1,221 +0,0 @@
-/**
- * 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');
-    });
-  });
-});

package/src/cli/commands/cache.ts

@@ -1,229 +0,0 @@
-/**
- * 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.ROOT);
-}
-
-/**
- * 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

@@ -1,63 +0,0 @@
-/**
- * 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

@@ -1,173 +0,0 @@
-/**
- * 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');
-    });
-  });
-});