@cyanautomation/kaseki-agent 1.4.1

package/src/cli/commands/ConfigCommand.ts

@@ -0,0 +1,145 @@
+/**
+ * Config Command
+ * Manage configuration
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { BaseCommand } from '../BaseCommand';
+import { createLogger } from '../../logger';
+
+const logger = createLogger('config-cmd');
+
+export class ConfigCommand extends BaseCommand {
+  async execute(args: string[]): Promise<number> {
+    try {
+      const { positional, flags } = this.parseArgs(args);
+      const subcommand = positional[0];
+      const key = positional[1];
+      const value = positional.slice(2).join(' ');
+
+      await this.configManager.load();
+
+      switch (subcommand) {
+      case 'get': {
+        if (!key) {
+          console.error('Usage: kaseki-agent config get <KEY>');
+          return 1;
+        }
+        const result = this.configManager.get(key);
+        if (result === undefined) {
+          console.log('(not set)');
+        } else {
+          console.log(result);
+        }
+        return 0;
+      }
+
+      case 'set': {
+        if (!key || !value) {
+          console.error('Usage: kaseki-agent config set <KEY> <VALUE>');
+          return 1;
+        }
+
+        const useGlobal = flags.has('global');
+        const configPath = useGlobal
+          ? path.join(os.homedir(), '.kaseki', 'config.json')
+          : 'kaseki-agent.json';
+
+        // Ensure directory exists
+        const configDir = path.dirname(configPath);
+        await fs.mkdir(configDir, { recursive: true });
+
+        // Read existing config
+        let config = {};
+        try {
+          const content = await fs.readFile(configPath, 'utf-8');
+          config = JSON.parse(content);
+        } catch {
+          // File doesn't exist, that's fine
+        }
+
+        // Set value using dot notation
+        this.setNestedValue(config, key, value);
+
+        // Write back
+        await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+
+        console.log(`✓ Set ${key} = ${value}`);
+        console.log(`  Config file: ${configPath}`);
+        return 0;
+      }
+
+      case 'show': {
+        const useGlobal = flags.has('global');
+        const configPath = useGlobal
+          ? path.join(os.homedir(), '.kaseki', 'config.json')
+          : 'kaseki-agent.json';
+
+        try {
+          const content = await fs.readFile(configPath, 'utf-8');
+          const config = JSON.parse(content);
+          console.log(`Configuration from: ${configPath}\n`);
+          console.log(JSON.stringify(config, null, 2));
+        } catch (error) {
+          console.log(`No configuration found at ${configPath}`);
+          logger.debug(`Failed to read config: ${error}`);
+        }
+        return 0;
+      }
+
+      case 'locations': {
+        console.log('Configuration locations (in precedence order):\n');
+        console.log('1. CLI flags (--key=value)');
+        console.log('2. kaseki-agent.json (project-local)');
+        console.log('3. ~/.kaseki/config.json (user-global)');
+        console.log('4. Environment variables (KASEKI_*, OPENROUTER_*)');
+        console.log('5. Built-in defaults\n');
+
+        console.log('Examples:');
+        console.log('  kaseki-agent config set agent.timeout_seconds 1800 --global');
+        console.log('  kaseki-agent config get agent.model');
+        console.log('  kaseki-agent config show --global');
+        return 0;
+      }
+
+      default:
+        console.error('Unknown subcommand: ' + subcommand);
+        console.error('\nUsage:');
+        console.error('  kaseki-agent config get <KEY>');
+        console.error('  kaseki-agent config set <KEY> <VALUE> [--global]');
+        console.error('  kaseki-agent config show [--global]');
+        console.error('  kaseki-agent config locations');
+        return 1;
+      }
+    } catch (error) {
+      logger.error(`Config command failed: ${error}`);
+      return 1;
+    }
+  }
+
+  /**
+   * Set nested object value using dot notation
+   */
+  private setNestedValue(obj: any, path: string, value: string): void {
+    const keys = path.split('.');
+    let current = obj;
+
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i];
+      if (!current[key] || typeof current[key] !== 'object') {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+
+    const lastKey = keys[keys.length - 1];
+    // Try to parse as JSON if possible
+    try {
+      current[lastKey] = JSON.parse(value);
+    } catch {
+      current[lastKey] = value;
+    }
+  }
+}

package/src/cli/commands/DoctorCommand.ts

@@ -0,0 +1,329 @@
+/**
+ * Doctor Command
+ * Health checks and dependency validation
+ */
+
+import { execSync } from 'child_process';
+import { BaseCommand } from '../BaseCommand';
+import { SecretsManager } from '../../secrets/SecretsManager';
+import { createLogger } from '../../logger';
+
+const logger = createLogger('doctor-cmd');
+
+interface Check {
+  name: string;
+  status: 'pass' | 'warn' | 'fail';
+  message: string;
+  fixable?: boolean;
+}
+
+export class DoctorCommand extends BaseCommand {
+  async execute(args: string[]): Promise<number> {
+    try {
+      const { flags } = this.parseArgs(args);
+      const isJson = flags.has('json');
+      const _isFix = flags.has('fix');
+      // Note: --verbose is parsed but not yet used in non-verbose output
+
+      console.log('🏥 Kaseki Agent Health Check\n');
+
+      // Load configuration
+      await this.configManager.load();
+
+      // Run all checks
+      const checks: Check[] = [
+        await this.checkDocker(),
+        await this.checkNodejs(),
+        await this.checkNpm(),
+        await this.checkGit(),
+        await this.checkAPIKey(),
+        await this.checkDockkerImage(),
+        await this.checkDiskSpace(),
+      ];
+
+      // Output results
+      if (isJson) {
+        console.log(JSON.stringify(checks, null, 2));
+      } else {
+        this.printResults(checks);
+      }
+
+      // Attempt fixes if requested
+      if (_isFix) {
+        console.log('\n🔧 Attempting auto-remediation...\n');
+        for (const check of checks) {
+          if (check.status !== 'pass' && check.fixable) {
+            await this.attemptFix(check);
+          }
+        }
+
+        // Re-run checks after fixes
+        console.log('\n🏥 Running checks again...\n');
+        const rechecks: Check[] = [
+          await this.checkDocker(),
+          await this.checkDockkerImage(),
+        ];
+        this.printResults(rechecks);
+      }
+
+      // Return exit code based on failures
+      const failures = checks.filter((c) => c.status === 'fail').length;
+      return failures > 0 ? 1 : 0;
+    } catch (error) {
+      logger.error(`Doctor check failed: ${error}`);
+      return 1;
+    }
+  }
+
+  /**
+   * Check Docker installation and daemon
+   */
+  private async checkDocker(): Promise<Check> {
+    try {
+      execSync('docker --version', { stdio: 'ignore' });
+      execSync('docker ps', { stdio: 'ignore' });
+      return {
+        name: 'Docker',
+        status: 'pass',
+        message: '✓ Docker installed and daemon running',
+      };
+    } catch {
+      return {
+        name: 'Docker',
+        status: 'fail',
+        message: '❌ Docker not installed or daemon not running',
+        fixable: true,
+      };
+    }
+  }
+
+  /**
+   * Check Node.js version
+   */
+  private async checkNodejs(): Promise<Check> {
+    try {
+      const version = execSync('node --version', { encoding: 'utf-8' }).trim();
+      const major = parseInt(version.replace('v', '').split('.')[0], 10);
+      if (major >= 24) {
+        return {
+          name: 'Node.js',
+          status: 'pass',
+          message: `✓ Node.js ${version}`,
+        };
+      } else {
+        return {
+          name: 'Node.js',
+          status: 'fail',
+          message: `❌ Node.js v24+ required, found ${version}`,
+        };
+      }
+    } catch {
+      return {
+        name: 'Node.js',
+        status: 'fail',
+        message: '❌ Node.js not installed',
+      };
+    }
+  }
+
+  /**
+   * Check npm installation
+   */
+  private async checkNpm(): Promise<Check> {
+    try {
+      const version = execSync('npm --version', { encoding: 'utf-8' }).trim();
+      return {
+        name: 'npm',
+        status: 'pass',
+        message: `✓ npm ${version}`,
+      };
+    } catch {
+      return {
+        name: 'npm',
+        status: 'fail',
+        message: '❌ npm not installed',
+      };
+    }
+  }
+
+  /**
+   * Check git installation
+   */
+  private async checkGit(): Promise<Check> {
+    try {
+      const version = execSync('git --version', { encoding: 'utf-8' }).trim();
+      return {
+        name: 'git',
+        status: 'pass',
+        message: `✓ ${version}`,
+      };
+    } catch {
+      return {
+        name: 'git',
+        status: 'fail',
+        message: '❌ git not installed',
+      };
+    }
+  }
+
+  /**
+   * Check API key accessibility
+   */
+  private async checkAPIKey(): Promise<Check> {
+    try {
+      const secretsManager = new SecretsManager();
+      const apiKeyFile = this.configManager.get('auth.openrouter_api_key_file', '');
+
+      if (!apiKeyFile) {
+        return {
+          name: 'OpenRouter API Key',
+          status: 'warn',
+          message: '⚠️  API key file path not configured',
+        };
+      }
+
+      const key = await secretsManager.retrieve('openrouter_api_key');
+      if (key) {
+        return {
+          name: 'OpenRouter API Key',
+          status: 'pass',
+          message: '✓ API key found and readable',
+        };
+      } else {
+        return {
+          name: 'OpenRouter API Key',
+          status: 'fail',
+          message: '❌ API key not found. Run: kaseki-agent setup',
+        };
+      }
+    } catch (error) {
+      return {
+        name: 'OpenRouter API Key',
+        status: 'fail',
+        message: `❌ API key check failed: ${error}`,
+      };
+    }
+  }
+
+  /**
+   * Check Docker image availability
+   */
+  private async checkDockkerImage(): Promise<Check> {
+    try {
+      const image = this.configManager.get('docker.image', '');
+
+      if (!image) {
+        return {
+          name: 'Docker Image',
+          status: 'fail',
+          message: '❌ Docker image not configured',
+        };
+      }
+
+      // Check if image exists locally
+      try {
+        execSync(`docker inspect ${image} > /dev/null 2>&1`, { stdio: 'ignore' });
+        return {
+          name: 'Docker Image',
+          status: 'pass',
+          message: `✓ Docker image available: ${image}`,
+        };
+      } catch {
+        return {
+          name: 'Docker Image',
+          status: 'warn',
+          message: `⚠️  Docker image not found locally: ${image}. Will auto-pull on first run.`,
+          fixable: true,
+        };
+      }
+    } catch (error) {
+      return {
+        name: 'Docker Image',
+        status: 'fail',
+        message: `❌ Docker image check failed: ${error}`,
+      };
+    }
+  }
+
+  /**
+   * Check disk space
+   */
+  private async checkDiskSpace(): Promise<Check> {
+    try {
+      const kasekiRoot = this.configManager.get('directories.root', '/agents');
+      const result = execSync(`df -B1 ${kasekiRoot} | awk 'NR==2 {print $4}'`, {
+        encoding: 'utf-8',
+      }).trim();
+
+      const availableBytes = parseInt(result, 10);
+      const availableGB = availableBytes / (1024 ** 3);
+
+      if (availableGB > 10) {
+        return {
+          name: 'Disk Space',
+          status: 'pass',
+          message: `✓ Sufficient disk space available (${availableGB.toFixed(1)} GB)`,
+        };
+      } else if (availableGB > 1) {
+        return {
+          name: 'Disk Space',
+          status: 'warn',
+          message: `⚠️  Limited disk space: ${availableGB.toFixed(1)} GB available`,
+        };
+      } else {
+        return {
+          name: 'Disk Space',
+          status: 'fail',
+          message: `❌ Insufficient disk space: ${availableGB.toFixed(2)} GB available`,
+        };
+      }
+    } catch {
+      return {
+        name: 'Disk Space',
+        status: 'warn',
+        message: '⚠️  Could not determine disk space',
+      };
+    }
+  }
+
+  /**
+   * Print check results in human-readable format
+   */
+  private printResults(checks: Check[]): void {
+    for (const check of checks) {
+      console.log(`${check.message}`);
+    }
+
+    const summary = {
+      pass: checks.filter((c) => c.status === 'pass').length,
+      warn: checks.filter((c) => c.status === 'warn').length,
+      fail: checks.filter((c) => c.status === 'fail').length,
+    };
+
+    console.log(
+      `\nSummary: ${summary.pass} passed, ${summary.warn} warnings, ${summary.fail} failed`
+    );
+
+    if (summary.fail > 0) {
+      console.log('Fix issues with: kaseki-agent doctor --fix');
+    }
+  }
+
+  /**
+   * Attempt to fix identified issues
+   */
+  private async attemptFix(check: Check): Promise<void> {
+    if (check.name === 'Docker') {
+      console.log('Install Docker from: https://docs.docker.com/install/');
+    } else if (check.name === 'Docker Image') {
+      try {
+        console.log(`Pulling Docker image: ${this.configManager.get('docker.image')}...`);
+        const image = this.configManager.get('docker.image', '');
+        execSync(`docker pull ${image}`, { stdio: 'inherit' });
+        console.log('✓ Image pulled successfully');
+      } catch {
+        console.log('❌ Failed to pull Docker image');
+      }
+    }
+  }
+}

package/src/cli/commands/ListCommand.ts

@@ -0,0 +1,105 @@
+/**
+ * List Command
+ * List all kaseki instances
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { BaseCommand } from '../BaseCommand';
+import { createLogger } from '../../logger';
+
+const logger = createLogger('list-cmd');
+
+interface InstanceSummary {
+  id: string;
+  status: string;
+  createdAt: string;
+  duration?: number;
+  exitCode?: number;
+}
+
+export class ListCommand extends BaseCommand {
+  async execute(args: string[]): Promise<number> {
+    try {
+      const { flags } = this.parseArgs(args);
+      const statusFilter = flags.get('status') as string | undefined;
+
+      console.log('📋 Kaseki Instances\n');
+
+      // Load configuration
+      await this.configManager.load();
+
+      const kasekiRoot = this.configManager.get('directories.root');
+      const resultsDir = path.join(kasekiRoot, 'kaseki-results');
+
+      // Read instances
+      const instances: InstanceSummary[] = [];
+
+      try {
+        const entries = await fs.readdir(resultsDir, { withFileTypes: true });
+
+        for (const entry of entries) {
+          if (entry.isDirectory() && entry.name.startsWith('kaseki-')) {
+            try {
+              const metadataPath = path.join(resultsDir, entry.name, 'metadata.json');
+              const content = await fs.readFile(metadataPath, 'utf-8');
+              const metadata = JSON.parse(content);
+
+              // Apply status filter
+              if (statusFilter && metadata.status !== statusFilter) {
+                continue;
+              }
+
+              instances.push({
+                id: metadata.id,
+                status: metadata.status,
+                createdAt: metadata.createdAt,
+                duration: metadata.stages?.['agent-run']?.duration,
+                exitCode: metadata.exitCode,
+              });
+            } catch (error) {
+              logger.debug(`Failed to read metadata for ${entry.name}: ${error}`);
+            }
+          }
+        }
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+          logger.error(`Failed to read results directory: ${error}`);
+          return 1;
+        }
+        // Directory doesn't exist yet
+      }
+
+      // Sort by creation date (newest first)
+      instances.sort((a, b) =>
+        new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+      );
+
+      // Display results
+      if (instances.length === 0) {
+        console.log('No instances found.');
+        return 0;
+      }
+
+      // Print as table
+      console.log('ID              | Status    | Created                | Duration (s)');
+      console.log('----------------|-----------|------------------------|---------------');
+
+      for (const inst of instances) {
+        const id = inst.id.padEnd(15);
+        const status = inst.status.padEnd(9);
+        const created = new Date(inst.createdAt).toISOString().substring(0, 19);
+        const duration = inst.duration ? inst.duration.toFixed(1) : '-';
+
+        console.log(`${id} | ${status} | ${created} | ${duration}`);
+      }
+
+      console.log(`\nTotal: ${instances.length} instance(s)`);
+
+      return 0;
+    } catch (error) {
+      logger.error(`List failed: ${error}`);
+      return 1;
+    }
+  }
+}

package/src/cli/commands/ReportCommand.ts

@@ -0,0 +1,110 @@
+/**
+ * Report Command
+ * Generate report for completed instance
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { BaseCommand } from '../BaseCommand';
+import { createLogger } from '../../logger';
+
+const logger = createLogger('report-cmd');
+
+export class ReportCommand extends BaseCommand {
+  async execute(args: string[]): Promise<number> {
+    try {
+      const { positional } = this.parseArgs(args);
+      const instanceId = positional[0];
+      void args; // TODO: use remaining args when implemented
+
+      if (!instanceId) {
+        console.error('Usage: kaseki-agent report <INSTANCE_ID>');
+        return 1;
+      }
+
+      console.log(`📊 Report: ${instanceId}\n`);
+
+      // Load configuration
+      await this.configManager.load();
+
+      const kasekiRoot = this.configManager.get('directories.root');
+      const resultsDir = path.join(kasekiRoot, 'kaseki-results', instanceId);
+
+      // Read metadata
+      try {
+        const metadataPath = path.join(resultsDir, 'metadata.json');
+        const content = await fs.readFile(metadataPath, 'utf-8');
+        const metadata = JSON.parse(content);
+
+        // Display metadata
+        console.log('Instance Information');
+        console.log('-------------------');
+        console.log(`ID:        ${metadata.id}`);
+        console.log(`Status:    ${metadata.status}`);
+        console.log(`Created:   ${new Date(metadata.createdAt).toLocaleString()}`);
+
+        if (metadata.completedAt) {
+          console.log(`Completed: ${new Date(metadata.completedAt).toLocaleString()}`);
+        }
+
+        if (metadata.repoUrl) {
+          console.log(`Repo:      ${metadata.repoUrl}`);
+        }
+
+        if (metadata.gitRef) {
+          console.log(`Ref:       ${metadata.gitRef}`);
+        }
+
+        if (metadata.model) {
+          console.log(`Model:     ${metadata.model}`);
+        }
+
+        // Display stages
+        if (metadata.stages && Object.keys(metadata.stages).length > 0) {
+          console.log('\nStages');
+          console.log('------');
+
+          for (const [stage, info] of Object.entries(metadata.stages)) {
+            const stageInfo = info as any;
+            console.log(`${stage}:`);
+            if (stageInfo.duration) {
+              console.log(`  Duration: ${stageInfo.duration.toFixed(1)}s`);
+            }
+            if (stageInfo.exitCode !== undefined) {
+              console.log(`  Exit Code: ${stageInfo.exitCode}`);
+            }
+          }
+        }
+
+        // Display summary
+        if (metadata.status === 'completed' && metadata.exitCode === 0) {
+          console.log('\n✅ Instance completed successfully');
+        } else if (metadata.status === 'completed') {
+          console.log(`\n❌ Instance failed with exit code ${metadata.exitCode}`);
+        } else {
+          console.log(`\n⏳ Instance status: ${metadata.status}`);
+        }
+
+        // Try to read and show summary
+        try {
+          const summaryPath = path.join(resultsDir, 'result-summary.md');
+          const summary = await fs.readFile(summaryPath, 'utf-8');
+          console.log('\nDetailed Summary');
+          console.log('----------------');
+          console.log(summary);
+        } catch {
+          // Summary file not found, that's okay
+        }
+
+        return metadata.exitCode === 0 ? 0 : 1;
+      } catch (error) {
+        console.error(`Instance not found: ${instanceId}`);
+        logger.debug(`Failed to read instance: ${error}`);
+        return 1;
+      }
+    } catch (error) {
+      logger.error(`Report failed: ${error}`);
+      return 1;
+    }
+  }
+}