@deimoscloud/coreai 0.1.9 → 0.1.11

package/src/commands/runner.test.ts

@@ -1,297 +0,0 @@
-/**
- * Command Runner Tests
- */
-
-import { createCommandRegistry } from './registry.js';
-import { createCommandContext } from './context.js';
-import {
-  runCommand,
-  executeWithDegradation,
-  createDegradingHandler,
-  StepTracker,
-} from './runner.js';
-import type { CommandDefinition, IntegrationDependency } from './types.js';
-
-describe('Command Runner', () => {
-  describe('runCommand', () => {
-    it('should run a registered command', async () => {
-      const registry = createCommandRegistry();
-      const cmd: CommandDefinition<object, string> = {
-        name: 'greet',
-        description: 'Say hello',
-        category: 'core',
-        handler: async (args) => ({
-          success: true,
-          data: `Hello, ${args[0] ?? 'World'}!`,
-        }),
-      };
-
-      registry.register(cmd);
-
-      const result = await runCommand<string>(registry, 'greet', ['Test'], {});
-
-      expect(result.success).toBe(true);
-      expect(result.data).toBe('Hello, Test!');
-    });
-
-    it('should return error for non-existent command', async () => {
-      const registry = createCommandRegistry();
-
-      const result = await runCommand(registry, 'non-existent', [], {});
-
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('not found');
-    });
-
-    it('should return error for unavailable command', async () => {
-      const registry = createCommandRegistry();
-      registry.register({
-        name: 'needs-jira',
-        description: 'Needs Jira',
-        category: 'optional',
-        dependencies: [{ type: 'issue_tracker', required: true }],
-        handler: async () => ({ success: true }),
-      });
-
-      const result = await runCommand(registry, 'needs-jira', [], {});
-
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Missing required integrations');
-    });
-
-    it('should use provided context', async () => {
-      const registry = createCommandRegistry();
-      let capturedRoot = '';
-
-      registry.register({
-        name: 'check-context',
-        description: 'Check context',
-        category: 'core',
-        handler: async (_args, _opts, ctx) => {
-          capturedRoot = ctx.projectRoot;
-          return { success: true };
-        },
-      });
-
-      const context = createCommandContext({ projectRoot: '/custom/path' });
-
-      await runCommand(registry, 'check-context', [], { context });
-
-      expect(capturedRoot).toBe('/custom/path');
-    });
-
-    it('should handle handler errors', async () => {
-      const registry = createCommandRegistry();
-      registry.register({
-        name: 'error-cmd',
-        description: 'Throws error',
-        category: 'core',
-        handler: async () => {
-          throw new Error('Handler failed');
-        },
-      });
-
-      const result = await runCommand(registry, 'error-cmd', [], {});
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Handler failed');
-    });
-
-    it('should track skipped steps for missing optional deps', async () => {
-      const registry = createCommandRegistry();
-      registry.register({
-        name: 'with-optional',
-        description: 'Has optional deps',
-        category: 'core',
-        dependencies: [{ type: 'documentation', required: false, description: 'For docs' }],
-        handler: async () => ({ success: true, data: 'done' }),
-      });
-
-      const result = await runCommand(registry, 'with-optional', [], {});
-
-      expect(result.success).toBe(true);
-      expect(result.skippedSteps).toBeDefined();
-      expect(result.skippedSteps?.length).toBeGreaterThan(0);
-    });
-  });
-
-  describe('executeWithDegradation', () => {
-    it('should execute step when integration available', async () => {
-      // Create a mock context that has the integration
-      const mockContext = {
-        config: null,
-        adapterFactory: null,
-        projectRoot: process.cwd(),
-        hasIntegration: () => true,
-        getAdapterSafe: async () => ({}),
-      };
-
-      const dep: IntegrationDependency = {
-        type: 'git',
-        required: false,
-      };
-
-      const result = await executeWithDegradation(mockContext, dep, async () => 'executed');
-
-      expect(result.skipped).toBe(false);
-      expect(result.result).toBe('executed');
-    });
-
-    it('should skip optional step when integration missing', async () => {
-      const mockContext = {
-        config: null,
-        adapterFactory: null,
-        projectRoot: process.cwd(),
-        hasIntegration: () => false,
-        getAdapterSafe: async () => null,
-      };
-
-      const dep: IntegrationDependency = {
-        type: 'issue_tracker',
-        required: false,
-        description: 'For issue tracking',
-      };
-
-      const result = await executeWithDegradation(mockContext, dep, async () => 'should not run');
-
-      expect(result.skipped).toBe(true);
-      expect(result.result).toBeNull();
-      expect(result.reason).toContain('issue tracking');
-    });
-
-    it('should throw for missing required integration', async () => {
-      const mockContext = {
-        config: null,
-        adapterFactory: null,
-        projectRoot: process.cwd(),
-        hasIntegration: () => false,
-        getAdapterSafe: async () => null,
-      };
-
-      const dep: IntegrationDependency = {
-        type: 'git',
-        required: true,
-      };
-
-      await expect(
-        executeWithDegradation(mockContext, dep, async () => 'should not run')
-      ).rejects.toThrow('Required integration missing');
-    });
-
-    it('should use fallback when available', async () => {
-      const mockContext = {
-        config: null,
-        adapterFactory: null,
-        projectRoot: process.cwd(),
-        hasIntegration: () => false,
-        getAdapterSafe: async () => null,
-      };
-
-      const dep: IntegrationDependency = {
-        type: 'documentation',
-        required: false,
-      };
-
-      const result = await executeWithDegradation(
-        mockContext,
-        dep,
-        async () => 'main step',
-        async () => 'fallback step'
-      );
-
-      expect(result.skipped).toBe(false);
-      expect(result.result).toBe('fallback step');
-    });
-  });
-
-  describe('createDegradingHandler', () => {
-    it('should create handler that tracks steps', async () => {
-      const handler = createDegradingHandler<object, string>(
-        async (_args, _opts, _ctx, tracker) => {
-          tracker.skip('Optional step', 'Not configured');
-          tracker.warn('Something to note');
-          return 'completed';
-        }
-      );
-
-      const mockContext = {
-        config: null,
-        adapterFactory: null,
-        projectRoot: process.cwd(),
-        hasIntegration: () => false,
-        getAdapterSafe: async () => null,
-      };
-
-      const result = await handler([], {}, mockContext);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toBe('completed');
-      expect(result.skippedSteps).toHaveLength(1);
-      expect(result.warnings).toHaveLength(1);
-    });
-
-    it('should handle errors gracefully', async () => {
-      const handler = createDegradingHandler<object, string>(async () => {
-        throw new Error('Handler error');
-      });
-
-      const mockContext = {
-        config: null,
-        adapterFactory: null,
-        projectRoot: process.cwd(),
-        hasIntegration: () => false,
-        getAdapterSafe: async () => null,
-      };
-
-      const result = await handler([], {}, mockContext);
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Handler error');
-    });
-  });
-
-  describe('StepTracker', () => {
-    it('should track skipped steps', () => {
-      const tracker = new StepTracker();
-
-      tracker.skip('Step 1', 'Reason 1');
-      tracker.skip('Step 2', 'Reason 2');
-
-      expect(tracker.skippedSteps).toHaveLength(2);
-      expect(tracker.skippedSteps[0].step).toBe('Step 1');
-      expect(tracker.skippedSteps[0].reason).toBe('Reason 1');
-    });
-
-    it('should track warnings', () => {
-      const tracker = new StepTracker();
-
-      tracker.warn('Warning 1');
-      tracker.warn('Warning 2');
-
-      expect(tracker.warnings).toHaveLength(2);
-      expect(tracker.warnings[0]).toBe('Warning 1');
-    });
-
-    it('should try step with degradation', async () => {
-      const tracker = new StepTracker();
-      const mockContext = {
-        config: null,
-        adapterFactory: null,
-        projectRoot: process.cwd(),
-        hasIntegration: () => false,
-        getAdapterSafe: async () => null,
-      };
-
-      const result = await tracker.tryStep(
-        'Update docs',
-        mockContext,
-        { type: 'documentation', required: false },
-        async () => 'updated'
-      );
-
-      expect(result).toBeNull();
-      expect(tracker.skippedSteps).toHaveLength(1);
-      expect(tracker.skippedSteps[0].step).toBe('Update docs');
-    });
-  });
-});

package/src/commands/runner.ts

@@ -1,222 +0,0 @@
-/**
- * Command Runner
- *
- * Executes commands with graceful degradation support.
- */
-
-import type {
-  CommandDefinition,
-  CommandResult,
-  CommandContext,
-  BaseCommandOptions,
-  IntegrationDependency,
-} from './types.js';
-import type { CommandRegistry } from './registry.js';
-import { createCommandContext, cleanupContext, type CreateContextOptions } from './context.js';
-
-/**
- * Options for running a command
- */
-export interface RunCommandOptions extends BaseCommandOptions {
-  /**
-   * Pre-created command context
-   */
-  context?: CommandContext;
-
-  /**
-   * Whether to clean up context after execution
-   */
-  cleanupAfter?: boolean;
-}
-
-/**
- * Run a registered command
- */
-export async function runCommand<TResult = unknown>(
-  registry: CommandRegistry,
-  name: string,
-  args: string[],
-  options: RunCommandOptions = {}
-): Promise<CommandResult<TResult>> {
-  const entry = registry.get(name);
-
-  if (!entry) {
-    return {
-      success: false,
-      error: `Command not found: ${name}`,
-    };
-  }
-
-  if (!entry.metadata.available) {
-    return {
-      success: false,
-      error: entry.metadata.unavailableReason ?? 'Command is unavailable',
-    };
-  }
-
-  if (!entry.definition) {
-    return {
-      success: false,
-      error: `Command ${name} is a markdown command and cannot be executed programmatically`,
-    };
-  }
-
-  // Create or use provided context
-  const contextOptions: CreateContextOptions = {};
-  if (options.projectRoot) {
-    contextOptions.projectRoot = options.projectRoot;
-  }
-  const context = options.context ?? createCommandContext(contextOptions);
-
-  try {
-    const result = (await entry.definition.handler(
-      args,
-      options,
-      context
-    )) as CommandResult<TResult>;
-
-    // Add skipped steps for optional integrations that aren't available
-    if (entry.metadata.dependencies) {
-      // Find optional deps that can't be accessed in the current context
-      const optionalDeps = entry.metadata.dependencies.filter((d) => !d.required);
-      const optionalUnavailable = optionalDeps.filter((d) => !context.hasIntegration(d.type));
-
-      if (optionalUnavailable.length > 0) {
-        result.skippedSteps = result.skippedSteps ?? [];
-        for (const dep of optionalUnavailable) {
-          result.skippedSteps.push({
-            step: `${dep.type} integration`,
-            reason: dep.description ?? `${dep.type} not configured`,
-          });
-        }
-      }
-    }
-
-    return result;
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error),
-    };
-  } finally {
-    if (options.cleanupAfter !== false && !options.context) {
-      await cleanupContext(context);
-    }
-  }
-}
-
-/**
- * Execute a step with graceful degradation
- *
- * If the required integration is not available, returns a skip result instead of failing.
- */
-export async function executeWithDegradation<T>(
-  context: CommandContext,
-  dependency: IntegrationDependency,
-  step: () => Promise<T>,
-  fallback?: () => Promise<T>
-): Promise<{ result: T | null; skipped: boolean; reason?: string }> {
-  if (!context.hasIntegration(dependency.type)) {
-    if (dependency.required) {
-      throw new Error(`Required integration missing: ${dependency.type}`);
-    }
-
-    // Optional integration missing, try fallback or skip
-    if (fallback) {
-      try {
-        const result = await fallback();
-        return { result, skipped: false };
-      } catch {
-        return {
-          result: null,
-          skipped: true,
-          reason: dependency.description ?? `${dependency.type} not available`,
-        };
-      }
-    }
-
-    return {
-      result: null,
-      skipped: true,
-      reason: dependency.description ?? `${dependency.type} not available`,
-    };
-  }
-
-  // Integration available, execute step
-  const result = await step();
-  return { result, skipped: false };
-}
-
-/**
- * Create a command handler with automatic degradation tracking
- */
-export function createDegradingHandler<TOptions extends BaseCommandOptions, TResult>(
-  handler: (
-    args: string[],
-    options: TOptions,
-    context: CommandContext,
-    track: StepTracker
-  ) => Promise<TResult>
-): CommandDefinition<TOptions, TResult>['handler'] {
-  return async (args, options, context) => {
-    const tracker = new StepTracker();
-
-    try {
-      const data = await handler(args, options, context, tracker);
-      return {
-        success: true,
-        data,
-        warnings: tracker.warnings,
-        skippedSteps: tracker.skippedSteps,
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-        warnings: tracker.warnings,
-        skippedSteps: tracker.skippedSteps,
-      };
-    }
-  };
-}
-
-/**
- * Tracks skipped steps and warnings during command execution
- */
-export class StepTracker {
-  readonly skippedSteps: { step: string; reason: string }[] = [];
-  readonly warnings: string[] = [];
-
-  /**
-   * Record a skipped step
-   */
-  skip(step: string, reason: string): void {
-    this.skippedSteps.push({ step, reason });
-  }
-
-  /**
-   * Record a warning
-   */
-  warn(message: string): void {
-    this.warnings.push(message);
-  }
-
-  /**
-   * Execute a step with optional fallback
-   */
-  async tryStep<T>(
-    stepName: string,
-    context: CommandContext,
-    dependency: IntegrationDependency,
-    step: () => Promise<T>,
-    fallback?: () => Promise<T>
-  ): Promise<T | null> {
-    const result = await executeWithDegradation(context, dependency, step, fallback);
-
-    if (result.skipped) {
-      this.skip(stepName, result.reason ?? 'Integration not available');
-    }
-
-    return result.result;
-  }
-}