@probelabs/visor 0.1.106 → 0.1.107

package/dist/examples/calculator-sdk-automated.ts

@@ -0,0 +1,340 @@
+#!/usr/bin/env node
+
+/**
+ * Calculator SDK - Fully Automated (Non-Interactive)
+ *
+ * This example shows how to:
+ * - Run calculations without user interaction
+ * - Provide inputs programmatically
+ * - Get pure JSON output
+ * - Use for testing or automation
+ *
+ * Usage:
+ *   npm run build
+ *   bun examples/calculator-sdk-automated.ts
+ *   bun examples/calculator-sdk-automated.ts 10 5 +
+ */
+
+import { HumanInputRequest, VisorConfig } from '../src/types/config';
+import { HumanInputCheckProvider } from '../src/providers/human-input-check-provider';
+import { CheckExecutionEngine } from '../src/check-execution-engine';
+
+// ============================================================================
+// CONFIGURATION
+// ============================================================================
+
+const calculatorConfig: VisorConfig = {
+  version: "1.0",
+
+  memory: {
+    namespace: "calculator",
+    persist: false
+  },
+
+  checks: {
+    "get-number1": {
+      type: "human-input",
+      prompt: "Enter the first number:",
+    },
+
+    "store-number1": {
+      type: "memory",
+      depends_on: ["get-number1"],
+      operation: "set",
+      namespace: "calculator",
+      key: "number1",
+      value_js: "parseFloat(outputs['get-number1'])"
+    },
+
+    "get-number2": {
+      type: "human-input",
+      depends_on: ["store-number1"],
+      prompt: "Enter the second number:",
+    },
+
+    "store-number2": {
+      type: "memory",
+      depends_on: ["get-number2"],
+      operation: "set",
+      namespace: "calculator",
+      key: "number2",
+      value_js: "parseFloat(outputs['get-number2'])"
+    },
+
+    "get-operation": {
+      type: "human-input",
+      depends_on: ["store-number2"],
+      prompt: "Select operation (+, -, *, /):",
+    },
+
+    "store-operation": {
+      type: "memory",
+      depends_on: ["get-operation"],
+      operation: "set",
+      namespace: "calculator",
+      key: "operation",
+      value_js: "outputs['get-operation'].trim()",
+      fail_if: "!['+', '-', '*', '/'].includes(outputs['get-operation'].trim())"
+    },
+
+    "calculate": {
+      type: "script",
+      depends_on: ["store-operation"],
+      content: `
+        const num1 = memory.get('number1', 'calculator');
+        const num2 = memory.get('number2', 'calculator');
+        const op = memory.get('operation', 'calculator');
+
+        let result;
+        switch(op) {
+          case '+': result = num1 + num2; break;
+          case '-': result = num1 - num2; break;
+          case '*': result = num1 * num2; break;
+          case '/':
+            if (num2 === 0) throw new Error('Division by zero!');
+            result = num1 / num2;
+            break;
+          default: throw new Error('Invalid operation: ' + op);
+        }
+
+        return result;
+      `
+    }
+  }
+};
+
+// ============================================================================
+// AUTOMATED INPUT PROVIDER
+// ============================================================================
+
+interface CalculatorInputs {
+  'get-number1': string;
+  'get-number2': string;
+  'get-operation': string;
+}
+
+/**
+ * Create an automated input handler with predefined values
+ */
+function createAutomatedInputHandler(inputs: CalculatorInputs) {
+  return async (request: HumanInputRequest): Promise<string> => {
+    const checkId = request.checkId as keyof CalculatorInputs;
+    const value = inputs[checkId];
+
+    if (value === undefined) {
+      throw new Error(`No automated input provided for check: ${checkId}`);
+    }
+
+    return value;
+  };
+}
+
+// ============================================================================
+// SUPPRESS ALL CONSOLE OUTPUT
+// ============================================================================
+
+function suppressAllOutput() {
+  const noop = () => {};
+  const originalLog = console.log;
+  const originalError = console.error;
+  const originalWarn = console.warn;
+  const originalInfo = console.info;
+  const originalDebug = console.debug;
+
+  console.log = noop;
+  console.error = noop;
+  console.warn = noop;
+  console.info = noop;
+  console.debug = noop;
+
+  return {
+    restore: () => {
+      console.log = originalLog;
+      console.error = originalError;
+      console.warn = originalWarn;
+      console.info = originalInfo;
+      console.debug = originalDebug;
+    }
+  };
+}
+
+// ============================================================================
+// CALCULATION FUNCTION
+// ============================================================================
+
+interface CalculationResult {
+  success: boolean;
+  calculation?: {
+    number1: number;
+    number2: number;
+    operation: string;
+    result: number;
+    expression: string;
+  };
+  executionTime?: number;
+  issues?: any[];
+  error?: string;
+}
+
+async function calculate(
+  num1: string,
+  num2: string,
+  operation: string,
+  options: { verbose?: boolean; suppressOutput?: boolean } = {}
+): Promise<CalculationResult> {
+  const { verbose = false, suppressOutput = true } = options;
+
+  try {
+    // Set up automated inputs
+    HumanInputCheckProvider.setHooks({
+      onHumanInput: createAutomatedInputHandler({
+        'get-number1': num1,
+        'get-number2': num2,
+        'get-operation': operation
+      })
+    });
+
+    // Suppress console output if requested
+    const suppressor = suppressOutput ? suppressAllOutput() : null;
+
+    // Create execution engine
+    const engine = new CheckExecutionEngine();
+
+    // Execute all checks
+    const checksToRun = Object.keys(calculatorConfig.checks || {});
+
+    const result = await engine.executeChecks({
+      checks: checksToRun,
+      config: calculatorConfig,
+      outputFormat: 'json',
+      maxParallelism: 1,
+      debug: false
+    });
+
+    // Restore console
+    if (suppressor) suppressor.restore();
+
+    // Extract results from memory
+    const { MemoryStore } = await import('../src/memory-store');
+    const memoryStore = MemoryStore.getInstance(calculatorConfig.memory);
+
+    const n1 = memoryStore.get('number1', 'calculator');
+    const n2 = memoryStore.get('number2', 'calculator');
+    const op = memoryStore.get('operation', 'calculator');
+    const resultValue = memoryStore.get('result', 'calculator');
+
+    return {
+      success: true,
+      calculation: {
+        number1: n1,
+        number2: n2,
+        operation: op,
+        result: resultValue,
+        expression: `${n1} ${op} ${n2} = ${resultValue}`
+      },
+      executionTime: result.executionTime,
+      issues: result.summary?.issues || []
+    };
+
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+// ============================================================================
+// MAIN EXECUTION
+// ============================================================================
+
+async function main() {
+  // Parse command line arguments
+  const args = process.argv.slice(2);
+
+  let num1: string, num2: string, operation: string;
+
+  if (args.length >= 3) {
+    // Use command line arguments
+    [num1, num2, operation] = args;
+  } else {
+    // Use default values for demo
+    num1 = '10';
+    num2 = '5';
+    operation = '+';
+  }
+
+  console.log('🧮 Calculator SDK - Automated Mode\n');
+  console.log(`Input: ${num1} ${operation} ${num2}\n`);
+
+  // Run calculation
+  const result = await calculate(num1, num2, operation, {
+    verbose: false,
+    suppressOutput: true
+  });
+
+  // Display result
+  if (result.success && result.calculation) {
+    console.log('✅ Calculation Complete!\n');
+    console.log('📊 Result (JSON):\n');
+    console.log(JSON.stringify(result, null, 2));
+
+    console.log('\n' + '─'.repeat(50));
+    console.log('Expression:', result.calculation.expression);
+    console.log('─'.repeat(50));
+
+    if (result.issues && result.issues.length > 0) {
+      console.log(`\n⚠️  ${result.issues.length} issue(s) found`);
+    }
+  } else {
+    console.log('❌ Calculation Failed!\n');
+    console.log('Error:', result.error);
+  }
+
+  console.log();
+
+  // Run additional test cases
+  console.log('🧪 Running Test Cases...\n');
+
+  const testCases = [
+    { num1: '100', num2: '25', operation: '-', expected: 75 },
+    { num1: '7', num2: '8', operation: '*', expected: 56 },
+    { num1: '100', num2: '4', operation: '/', expected: 25 },
+    { num1: '15', num2: '3', operation: '+', expected: 18 },
+  ];
+
+  const results = await Promise.all(
+    testCases.map(tc =>
+      calculate(tc.num1, tc.num2, tc.operation, { suppressOutput: true })
+    )
+  );
+
+  console.log('Test Results:');
+  console.log('─'.repeat(70));
+  console.log('Input'.padEnd(20), 'Expected'.padEnd(15), 'Actual'.padEnd(15), 'Status');
+  console.log('─'.repeat(70));
+
+  results.forEach((result, idx) => {
+    const tc = testCases[idx];
+    const input = `${tc.num1} ${tc.operation} ${tc.num2}`;
+    const expected = tc.expected;
+    const actual = result.calculation?.result;
+    const status = actual === expected ? '✅ PASS' : '❌ FAIL';
+
+    console.log(
+      input.padEnd(20),
+      String(expected).padEnd(15),
+      String(actual).padEnd(15),
+      status
+    );
+  });
+
+  console.log('─'.repeat(70));
+  console.log('\n✨ Done!\n');
+}
+
+// Run main
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/dist/examples/calculator-sdk-example.ts

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+
+/**
+ * Calculator SDK Example
+ *
+ * This example demonstrates how to use the human-input provider with SDK hooks
+ * to create an interactive calculator that:
+ * 1. Asks user for first number
+ * 2. Asks user for second number
+ * 3. Asks user for operation (+, -, *, /)
+ * 4. Stores values in memory
+ * 5. Performs calculation using JavaScript
+ * 6. Outputs the result
+ *
+ * Usage:
+ *   node examples/calculator-sdk-example.ts
+ *
+ * Or with custom hook implementation:
+ *   ts-node examples/calculator-sdk-example.ts
+ */
+
+import * as readline from 'readline';
+import { HumanInputRequest } from '../src/types/config';
+
+// Mock the CheckExecutionEngine - in real usage, you'd import from '@probelabs/visor'
+// For this example, we'll simulate the workflow
+
+interface CalculatorConfig {
+  version: string;
+  checks: Record<string, any>;
+  output: any;
+  memory?: {
+    storage: 'memory';
+    namespace: string;
+  };
+}
+
+const calculatorConfig: CalculatorConfig = {
+  version: "1.0",
+
+  memory: {
+    storage: 'memory',
+    namespace: 'calculator'
+  },
+
+  checks: {
+    // Step 1: Get first number
+    "get-number1": {
+      type: "human-input",
+      prompt: "Enter the first number:",
+      placeholder: "e.g., 42",
+      allow_empty: false
+    },
+
+    // Step 2: Store first number in memory
+    "store-number1": {
+      type: "memory",
+      depends_on: ["get-number1"],
+      operation: "set",
+      namespace: "calculator",
+      key: "number1",
+      value_js: "parseFloat(outputs['get-number1'])"
+    },
+
+    // Step 3: Get second number
+    "get-number2": {
+      type: "human-input",
+      depends_on: ["store-number1"],
+      prompt: "Enter the second number:",
+      placeholder: "e.g., 7",
+      allow_empty: false
+    },
+
+    // Step 4: Store second number in memory
+    "store-number2": {
+      type: "memory",
+      depends_on: ["get-number2"],
+      operation: "set",
+      namespace: "calculator",
+      key: "number2",
+      value_js: "parseFloat(outputs['get-number2'])"
+    },
+
+    // Step 5: Get operation
+    "get-operation": {
+      type: "human-input",
+      depends_on: ["store-number2"],
+      prompt: "Select operation (+, -, *, /):",
+      placeholder: "Enter one of: + - * /",
+      allow_empty: false
+    },
+
+    // Step 6: Store operation in memory
+    "store-operation": {
+      type: "memory",
+      depends_on: ["get-operation"],
+      operation: "set",
+      namespace: "calculator",
+      key: "operation",
+      value_js: "outputs['get-operation'].trim()"
+    },
+
+    // Step 7: Perform calculation using memory and JavaScript
+    "calculate": {
+      type: "script",
+      depends_on: ["store-operation"],
+      content: `
+        // Get values from memory
+        const num1 = memory.get('number1', 'calculator');
+        const num2 = memory.get('number2', 'calculator');
+        const op = memory.get('operation', 'calculator');
+
+        // Log for debugging
+        log('Calculating:', num1, op, num2);
+
+        // Perform calculation
+        let result;
+        switch(op) {
+          case '+':
+            result = num1 + num2;
+            break;
+          case '-':
+            result = num1 - num2;
+            break;
+          case '*':
+            result = num1 * num2;
+            break;
+          case '/':
+            if (num2 === 0) {
+              throw new Error('Division by zero!');
+            }
+            result = num1 / num2;
+            break;
+          default:
+            throw new Error('Invalid operation: ' + op);
+        }
+
+        // Return result for output
+        return result;
+      `
+    },
+
+    // Step 8: Display the result
+    "show-result": {
+      type: "log",
+      depends_on: ["calculate"],
+      message: `
+╔════════════════════════════════════════╗
+║          CALCULATION RESULT            ║
+╠════════════════════════════════════════╣
+║                                        ║
+║  {{ memory.get('number1', 'calculator') }} {{ memory.get('operation', 'calculator') }} {{ memory.get('number2', 'calculator') }} = {{ memory.get('result', 'calculator') }}
+║                                        ║
+╚════════════════════════════════════════╝
+      `
+    }
+  },
+
+  output: {
+    pr_comment: {
+      format: "markdown",
+      group_by: "check",
+      collapse: false
+    }
+  }
+};
+
+/**
+ * Custom hook for handling human input via readline
+ * This is what users would implement in their SDK integration
+ */
+async function customHumanInputHandler(request: HumanInputRequest): Promise<string> {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    console.log('\n┌─────────────────────────────────────────┐');
+    console.log(`│ ${request.prompt.padEnd(39)} │`);
+    console.log('└─────────────────────────────────────────┘');
+
+    rl.question('> ', (answer) => {
+      rl.close();
+
+      const trimmed = answer.trim();
+      if (!trimmed && !request.allowEmpty) {
+        console.log('❌ Empty input not allowed. Please try again.\n');
+        // In real implementation, would retry
+        resolve('');
+      } else {
+        resolve(trimmed || request.default || '');
+      }
+    });
+  });
+}
+
+/**
+ * Main SDK example
+ */
+async function main() {
+  console.log('╔═══════════════════════════════════════════╗');
+  console.log('║   Visor SDK Calculator Example           ║');
+  console.log('║   Human Input + Memory + JavaScript      ║');
+  console.log('╚═══════════════════════════════════════════╝\n');
+
+  console.log('This example demonstrates:');
+  console.log('  • Using human-input checks with SDK hooks');
+  console.log('  • Storing data in memory between steps');
+  console.log('  • Performing calculations with JavaScript');
+  console.log('  • Sequential workflow with dependencies\n');
+
+  console.log('Configuration loaded:');
+  console.log(`  - ${Object.keys(calculatorConfig.checks).length} checks defined`);
+  console.log(`  - Memory namespace: ${calculatorConfig.memory?.namespace}\n`);
+
+  console.log('─'.repeat(45));
+  console.log('Starting interactive calculator workflow...');
+  console.log('─'.repeat(45));
+
+  // In a real implementation, you would:
+  //
+  // import { CheckExecutionEngine } from '@probelabs/visor';
+  // import { HumanInputCheckProvider } from '@probelabs/visor/providers';
+  //
+  // // Set the hook
+  // HumanInputCheckProvider.setHooks({
+  //   onHumanInput: customHumanInputHandler
+  // });
+  //
+  // // Run the checks
+  // const engine = new CheckExecutionEngine();
+  // const results = await engine.executeChecks(
+  //   prInfo,
+  //   calculatorConfig,
+  //   Object.keys(calculatorConfig.checks)
+  // );
+  //
+  // console.log('Results:', results);
+
+  console.log('\n📝 To run this example with actual Visor SDK:');
+  console.log('   1. Import CheckExecutionEngine and HumanInputCheckProvider');
+  console.log('   2. Set the onHumanInput hook with customHumanInputHandler');
+  console.log('   3. Execute the checks with the calculator configuration');
+  console.log('   4. The workflow will prompt for inputs and calculate result');
+
+  console.log('\n💡 Alternatively, run with CLI:');
+  console.log('   Save the config to calculator.yaml and run:');
+  console.log('   $ visor --config calculator.yaml');
+  console.log('   (Will use interactive terminal prompts automatically)');
+
+  // Save the config for CLI usage
+  const fs = require('fs');
+  const yaml = require('js-yaml');
+  const configPath = __dirname + '/calculator-config.yaml';
+
+  try {
+    const yamlContent = yaml.dump(calculatorConfig);
+    fs.writeFileSync(configPath, yamlContent);
+    console.log(`\n✅ Configuration saved to: ${configPath}`);
+  } catch (error) {
+    console.log('\n⚠️  Could not save YAML config (js-yaml not installed)');
+    console.log('   Install with: npm install js-yaml');
+  }
+}
+
+// Run if executed directly
+if (require.main === module) {
+  main().catch(error => {
+    console.error('Error:', error);
+    process.exit(1);
+  });
+}
+
+export { calculatorConfig, customHumanInputHandler };