@deimoscloud/coreai 0.1.0

package/src/cli/commands/status.ts

@@ -0,0 +1,332 @@
+/**
+ * Status Command
+ *
+ * Shows agent states and pending messages.
+ */
+
+import { configExists, loadConfig, ConfigError } from '../../config/loader.js';
+import type { ResolvedCoreAIConfig } from '../../config/types.js';
+import {
+  getKnowledgeLibraryState,
+  getAgentKnowledgeState,
+  initKnowledgeLibrary,
+  type KnowledgeLibraryState,
+} from '../../knowledge-library/index.js';
+
+/**
+ * Options for status command
+ */
+export interface StatusCommandOptions {
+  /**
+   * Project root directory
+   */
+  projectRoot?: string;
+
+  /**
+   * Show status for specific agent only
+   */
+  agent?: string;
+
+  /**
+   * Show detailed status including message subjects
+   */
+  detailed?: boolean;
+
+  /**
+   * Initialize KnowledgeLibrary if not exists
+   */
+  init?: boolean;
+}
+
+/**
+ * Agent status info
+ */
+export interface AgentStatus {
+  /**
+   * Agent name/role
+   */
+  name: string;
+
+  /**
+   * Whether the agent's KnowledgeLibrary is initialized
+   */
+  initialized: boolean;
+
+  /**
+   * Current status (e.g., "idle", "working")
+   */
+  status?: string;
+
+  /**
+   * Current task
+   */
+  currentTask?: string;
+
+  /**
+   * Current ticket
+   */
+  currentTicket?: string;
+
+  /**
+   * Number of pending inbox messages
+   */
+  pendingMessages: number;
+
+  /**
+   * Last activity timestamp
+   */
+  lastActivity?: Date;
+
+  /**
+   * Message details (if detailed mode)
+   */
+  messageDetails?: {
+    type: string;
+    from: string;
+    subject: string;
+    date?: Date;
+  }[];
+}
+
+/**
+ * Result of status command
+ */
+export interface StatusCommandResult {
+  success: boolean;
+  knowledgeLibrary?: KnowledgeLibraryState;
+  agents: AgentStatus[];
+  error?: string;
+  warnings?: string[];
+}
+
+/**
+ * Get status of agents and KnowledgeLibrary
+ */
+export function status(options: StatusCommandOptions = {}): StatusCommandResult {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const warnings: string[] = [];
+
+  // Load config if available to get team agents
+  let config: ResolvedCoreAIConfig | undefined;
+  let configuredAgents: string[] = [];
+
+  if (configExists(projectRoot)) {
+    try {
+      config = loadConfig(projectRoot);
+      if (config.team?.agents) {
+        configuredAgents = config.team.agents;
+      }
+    } catch (error) {
+      if (error instanceof ConfigError) {
+        warnings.push(`Configuration error: ${error.message}`);
+      } else {
+        warnings.push(
+          `Failed to load config: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  } else {
+    warnings.push('No configuration file found.');
+  }
+
+  // Get KnowledgeLibrary state
+  let klState = getKnowledgeLibraryState({ projectRoot });
+
+  // Initialize if requested and doesn't exist
+  if (!klState && options.init) {
+    const initResult = initKnowledgeLibrary({ projectRoot, createDefaults: true });
+    if (initResult.success) {
+      klState = getKnowledgeLibraryState({ projectRoot });
+    } else {
+      return {
+        success: false,
+        agents: [],
+        error: `Failed to initialize KnowledgeLibrary: ${initResult.error}`,
+        warnings: warnings.length > 0 ? warnings : undefined,
+      };
+    }
+  }
+
+  if (!klState) {
+    return {
+      success: true,
+      agents: [],
+      warnings: [
+        ...warnings,
+        'KnowledgeLibrary not initialized. Run `coreai status --init` to create it.',
+      ],
+    };
+  }
+
+  // Determine which agents to show status for
+  let agentsToCheck: string[];
+  if (options.agent) {
+    agentsToCheck = [options.agent];
+  } else {
+    // Combine configured agents and discovered agents
+    agentsToCheck = [...new Set([...configuredAgents, ...klState.agents])];
+  }
+
+  // Get status for each agent
+  const agentStatuses: AgentStatus[] = [];
+
+  for (const agentName of agentsToCheck) {
+    const agentState = getAgentKnowledgeState(agentName, { projectRoot });
+
+    const agentStatus: AgentStatus = {
+      name: agentName,
+      initialized: agentState.initialized,
+      pendingMessages: agentState.pendingMessages.length,
+    };
+
+    if (agentState.context) {
+      agentStatus.status = agentState.context.status;
+      agentStatus.currentTask = agentState.context.currentTask;
+      agentStatus.currentTicket = agentState.context.currentTicket;
+      agentStatus.lastActivity = agentState.context.lastUpdated;
+    }
+
+    // Add message details if detailed mode
+    if (options.detailed && agentState.pendingMessages.length > 0) {
+      agentStatus.messageDetails = agentState.pendingMessages.map((msg) => ({
+        type: msg.metadata.type ?? 'unknown',
+        from: msg.metadata.from ?? 'unknown',
+        subject: msg.metadata.subject ?? msg.filename,
+        date: msg.metadata.date,
+      }));
+    }
+
+    agentStatuses.push(agentStatus);
+  }
+
+  // Sort by pending messages (most first), then by name
+  agentStatuses.sort((a, b) => {
+    if (b.pendingMessages !== a.pendingMessages) {
+      return b.pendingMessages - a.pendingMessages;
+    }
+    return a.name.localeCompare(b.name);
+  });
+
+  return {
+    success: true,
+    knowledgeLibrary: klState,
+    agents: agentStatuses,
+    warnings: warnings.length > 0 ? warnings : undefined,
+  };
+}
+
+/**
+ * Format status result for display
+ */
+export function formatStatusResult(result: StatusCommandResult): 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(`Error: ${result.error}`);
+    return lines.join('\n');
+  }
+
+  if (result.agents.length === 0) {
+    lines.push('No agents found.');
+    return lines.join('\n');
+  }
+
+  lines.push('Agent Status\n');
+
+  // Summary table header
+  const activeAgents = result.agents.filter((a) => a.status === 'working');
+  const idleAgents = result.agents.filter(
+    (a) => a.initialized && (!a.status || a.status === 'idle')
+  );
+  const uninitializedAgents = result.agents.filter((a) => !a.initialized);
+  const totalPending = result.agents.reduce((sum, a) => sum + a.pendingMessages, 0);
+
+  lines.push(`Total agents: ${result.agents.length}`);
+  if (activeAgents.length > 0) {
+    lines.push(`  Active: ${activeAgents.length}`);
+  }
+  if (idleAgents.length > 0) {
+    lines.push(`  Idle: ${idleAgents.length}`);
+  }
+  if (uninitializedAgents.length > 0) {
+    lines.push(`  Not initialized: ${uninitializedAgents.length}`);
+  }
+  if (totalPending > 0) {
+    lines.push(`  Total pending messages: ${totalPending}`);
+  }
+  lines.push('');
+
+  // Detailed agent list
+  for (const agent of result.agents) {
+    const statusIcon = !agent.initialized ? '○' : agent.pendingMessages > 0 ? '●' : '◎';
+    const statusText = !agent.initialized ? 'not initialized' : (agent.status ?? 'idle');
+
+    lines.push(`${statusIcon} ${agent.name}`);
+    lines.push(`    Status: ${statusText}`);
+
+    if (agent.currentTask) {
+      lines.push(`    Task: ${agent.currentTask}`);
+    }
+
+    if (agent.currentTicket) {
+      lines.push(`    Ticket: ${agent.currentTicket}`);
+    }
+
+    if (agent.pendingMessages > 0) {
+      lines.push(`    Pending messages: ${agent.pendingMessages}`);
+
+      // Show message details if available
+      if (agent.messageDetails && agent.messageDetails.length > 0) {
+        for (const msg of agent.messageDetails) {
+          const dateStr = msg.date ? msg.date.toISOString().slice(0, 16).replace('T', ' ') : '';
+          lines.push(`      - [${msg.type}] from ${msg.from}: ${msg.subject}`);
+          if (dateStr) {
+            lines.push(`        ${dateStr}`);
+          }
+        }
+      }
+    }
+
+    if (agent.lastActivity) {
+      const activityStr = agent.lastActivity.toISOString().slice(0, 16).replace('T', ' ');
+      lines.push(`    Last activity: ${activityStr}`);
+    }
+
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Format a compact status summary
+ */
+export function formatStatusSummary(result: StatusCommandResult): string {
+  if (!result.success) {
+    return `Error: ${result.error}`;
+  }
+
+  const activeCount = result.agents.filter((a) => a.status === 'working').length;
+  const pendingCount = result.agents.reduce((sum, a) => sum + a.pendingMessages, 0);
+
+  const parts: string[] = [];
+  parts.push(`${result.agents.length} agents`);
+
+  if (activeCount > 0) {
+    parts.push(`${activeCount} active`);
+  }
+
+  if (pendingCount > 0) {
+    parts.push(`${pendingCount} pending messages`);
+  }
+
+  return parts.join(', ');
+}

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

@@ -0,0 +1,213 @@
+/**
+ * Sync Command Tests
+ */
+
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { FileCacheProvider } from '../../cache/provider.js';
+import { sync, formatSyncResult } from './sync.js';
+
+describe('Sync Command', () => {
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `sync-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('sync', () => {
+    it('should return success for empty cache', async () => {
+      const provider = new FileCacheProvider({ basePath: testDir });
+      await provider.initialize();
+
+      const result = await sync({ cachePath: testDir });
+
+      expect(result.success).toBe(true);
+      expect(result.result).not.toBeNull();
+      expect(result.result?.added).toBe(0);
+      expect(result.result?.updated).toBe(0);
+      expect(result.result?.failed).toBe(0);
+    });
+
+    it('should attempt to sync cached entries', async () => {
+      const provider = new FileCacheProvider({ basePath: testDir });
+      await provider.initialize();
+      await provider.set('cached-entry', 'content', {
+        source: 'github',
+        sourceUrl: 'https://github.com/test/repo',
+      });
+
+      const result = await sync({
+        cachePath: testDir,
+        continueOnError: true,
+      });
+
+      // Should fail because there's no real fetcher configured
+      expect(result.sources).toContain('github');
+      // The placeholder fetcher will fail
+      expect(result.result?.failed).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should filter by source', async () => {
+      const provider = new FileCacheProvider({ basePath: testDir });
+      await provider.initialize();
+      await provider.set('github-entry', 'content', {
+        source: 'github',
+        sourceUrl: 'https://github.com/test',
+      });
+      await provider.set('confluence-entry', 'content', {
+        source: 'confluence',
+        sourceUrl: 'https://confluence.test.com/page',
+      });
+
+      const result = await sync({
+        cachePath: testDir,
+        source: 'github',
+        continueOnError: true,
+      });
+
+      expect(result.sources).toContain('github');
+      expect(result.sources).not.toContain('confluence');
+    });
+
+    it('should handle uninitialized cache', async () => {
+      const result = await sync({ cachePath: join(testDir, 'new-cache') });
+
+      // Should initialize and return empty result
+      expect(result.success).toBe(true);
+      expect(result.result?.added).toBe(0);
+    });
+
+    it('should call progress callback', async () => {
+      const provider = new FileCacheProvider({ basePath: testDir });
+      await provider.initialize();
+      await provider.set('entry', 'content', {
+        source: 'github',
+        sourceUrl: 'https://github.com/test',
+      });
+
+      const progressCalls: { completed: number; total: number; message: string }[] = [];
+
+      await sync({
+        cachePath: testDir,
+        continueOnError: true,
+        onProgress: (completed, total, message) => {
+          progressCalls.push({ completed, total, message });
+        },
+      });
+
+      expect(progressCalls.length).toBeGreaterThan(0);
+      expect(progressCalls[0].message).toContain('Starting');
+    });
+  });
+
+  describe('formatSyncResult', () => {
+    it('should format error result', () => {
+      const result = formatSyncResult({
+        success: false,
+        result: null,
+        error: 'Connection failed',
+        sources: [],
+      });
+
+      expect(result).toContain('Error');
+      expect(result).toContain('Connection failed');
+    });
+
+    it('should format empty cache result', () => {
+      const result = formatSyncResult({
+        success: true,
+        result: {
+          added: 0,
+          updated: 0,
+          removed: 0,
+          failed: 0,
+          errors: [],
+          duration: 0,
+        },
+        sources: [],
+      });
+
+      expect(result).toContain('empty');
+      expect(result).toContain('Nothing to sync');
+    });
+
+    it('should format successful sync', () => {
+      const result = formatSyncResult({
+        success: true,
+        result: {
+          added: 2,
+          updated: 3,
+          removed: 1,
+          failed: 0,
+          errors: [],
+          duration: 1500,
+        },
+        sources: ['github', 'confluence'],
+      });
+
+      expect(result).toContain('Duration: 1500ms');
+      expect(result).toContain('Added: 2');
+      expect(result).toContain('Updated: 3');
+      expect(result).toContain('Removed: 1');
+      expect(result).toContain('github');
+      expect(result).toContain('confluence');
+    });
+
+    it('should format sync with errors', () => {
+      const result = formatSyncResult({
+        success: false,
+        result: {
+          added: 1,
+          updated: 0,
+          removed: 0,
+          failed: 2,
+          errors: [
+            { key: 'entry1', error: 'Network error' },
+            { key: 'entry2', error: 'Not found' },
+          ],
+          duration: 500,
+        },
+        sources: ['github'],
+      });
+
+      expect(result).toContain('Failed: 2');
+      expect(result).toContain('Errors:');
+      expect(result).toContain('entry1');
+      expect(result).toContain('Network error');
+      expect(result).toContain('entry2');
+      expect(result).toContain('Not found');
+    });
+
+    it('should truncate long error lists', () => {
+      const errors = Array.from({ length: 15 }, (_, i) => ({
+        key: `entry${i}`,
+        error: `Error ${i}`,
+      }));
+
+      const result = formatSyncResult({
+        success: false,
+        result: {
+          added: 0,
+          updated: 0,
+          removed: 0,
+          failed: 15,
+          errors,
+          duration: 100,
+        },
+        sources: ['github'],
+      });
+
+      expect(result).toContain('and 5 more errors');
+    });
+  });
+});