algomath-extract 1.0.0

package/bin/algo-run.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+
+/**
+ * AlgoMath Run Command
+ * 
+ * Execute generated Python code
+ * Usage: /algo-run [--skip]
+ */
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const ora = require('ora');
+const { spawn } = require('child_process');
+const path = require('path');
+
+const program = new Command();
+
+program
+  .name('algo-run')
+  .description('Execute generated Python code')
+  .option('--skip', 'Skip execution and proceed directly to verification')
+  .action(async (options) => {
+    console.log(chalk.blue.bold('╔════════════════════════════════════════╗'));
+    console.log(chalk.blue.bold('║      AlgoMath - Execute Code           ║'));
+    console.log(chalk.blue.bold('╚════════════════════════════════════════╝'));
+    console.log();
+
+    try {
+      if (options.skip) {
+        console.log(chalk.yellow('⚠ Skipping execution (proceeding to verification)'));
+        console.log();
+      }
+
+      const spinner = ora(options.skip ? 'Skipping...' : 'Executing code...').start();
+
+      const pythonScript = path.join(__dirname, '..', 'src', 'cli', 'cli_entry.py');
+      const args = ['run'];
+      if (options.skip) {
+        args.push('--skip');
+      }
+      
+      const result = await runPython(pythonScript, args);
+      
+      if (options.skip) {
+        spinner.succeed('Execution skipped');
+      } else {
+        spinner.succeed('Execution complete!');
+      }
+      
+      const output = JSON.parse(result);
+      displayResult(output);
+
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+function runPython(script, args) {
+  return new Promise((resolve, reject) => {
+    const python = spawn('python3', [script, ...args], {
+      cwd: path.join(__dirname, '..')
+    });
+
+    let output = '';
+    let error = '';
+
+    python.stdout.on('data', (data) => {
+      output += data.toString();
+    });
+
+    python.stderr.on('data', (data) => {
+      error += data.toString();
+    });
+
+    python.on('close', (code) => {
+      if (code !== 0) {
+        reject(new Error(error || `Python process exited with code ${code}`));
+      } else {
+        resolve(output);
+      }
+    });
+  });
+}
+
+function displayResult(output) {
+  console.log();
+  
+  if (output.status === 'success') {
+    console.log(chalk.green.bold('✓ Code executed successfully'));
+    console.log();
+    
+    if (output.stdout) {
+      console.log(chalk.cyan('Output:'));
+      console.log(chalk.white(output.stdout));
+      console.log();
+    }
+    
+    console.log(chalk.cyan('Runtime:'), output.runtime_seconds || 'N/A', 'seconds');
+    console.log();
+    
+    if (output.next_steps) {
+      console.log(chalk.gray('Next steps:'));
+      output.next_steps.forEach(step => {
+        console.log(chalk.gray(`  • ${step}`));
+      });
+    }
+  } else if (output.status === 'skipped') {
+    console.log(chalk.yellow('⚠ Execution skipped'));
+    console.log(chalk.gray(output.message));
+    console.log();
+    
+    if (output.next_steps) {
+      console.log(chalk.gray('Next steps:'));
+      output.next_steps.forEach(step => {
+        console.log(chalk.gray(`  • ${step}`));
+      });
+    }
+  } else {
+    console.log(chalk.red('✗ Execution failed'));
+    console.log(chalk.red('Error:'), output.message);
+    if (output.stderr) {
+      console.log();
+      console.log(chalk.gray('Error details:'));
+      console.log(chalk.gray(output.stderr));
+    }
+    console.log();
+    
+    if (output.next_steps) {
+      console.log(chalk.gray('Next steps:'));
+      output.next_steps.forEach(step => {
+        console.log(chalk.gray(`  • ${step}`));
+      });
+    }
+  }
+  
+  console.log();
+  console.log(chalk.blue('Use /algo-verify to check results and verify correctness'));
+}
+
+program.parse();

package/bin/algo-status.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+
+/**
+ * algo-status command
+ * 
+ * Usage: npx algomath status
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+
+async function main() {
+  console.log('\n╔════════════════════════════════════════════════════╗');
+  console.log('║ AlgoMath Status ║');
+  console.log('╚════════════════════════════════════════════════════╝\n');
+
+  try {
+    // Check Python
+    const pythonInfo = checkPython();
+    console.log(`Python: ${pythonInfo ? pythonInfo.version : '❌ Not found'}\n`);
+
+    // Check dependencies
+    const depsOk = checkPythonDeps();
+    console.log(`Dependencies: ${depsOk ? '✓ Installed' : '⚠️  Missing'}\n`);
+
+    // Check workspace
+    const workspace = process.cwd();
+    console.log(`Workspace: ${workspace}\n`);
+
+    // Check saved algorithms
+    console.log('Saved Algorithms:');
+    listAlgorithms();
+
+  } catch (error) {
+    console.error('Error:', error.message);
+    process.exit(1);
+  }
+}
+
+function checkPython() {
+  try {
+    const version = execSync('python3 --version', { encoding: 'utf8', stdio: 'pipe' });
+    return { version: version.trim() };
+  } catch (e) {
+    try {
+      const version = execSync('python --version', { encoding: 'utf8', stdio: 'pipe' });
+      return { version: version.trim() };
+    } catch (e2) {
+      return null;
+    }
+  }
+}
+
+function checkPythonDeps() {
+  const pythonCmd = checkPython() ? 'python3' : null;
+  if (!pythonCmd) return false;
+  
+  try {
+    execSync(`${pythonCmd} -c "import pdfplumber; import fitz; import pydantic"`, { stdio: 'pipe' });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function listAlgorithms() {
+  const fs = require('fs');
+  const homeDir = require('os').homedir();
+  const algorithmsDir = path.join(homeDir, '.algomath', 'algorithms');
+  
+  if (!fs.existsSync(algorithmsDir)) {
+    console.log('  No algorithms found\n');
+    return;
+  }
+  
+  const algorithms = fs.readdirSync(algorithmsDir)
+    .filter(f => f.endsWith('.json'))
+    .map(f => f.replace('.json', ''));
+  
+  if (algorithms.length === 0) {
+    console.log('  No algorithms found\n');
+  } else {
+    algorithms.forEach(name => console.log(`  - ${name}`));
+    console.log();
+  }
+}
+
+main();

package/bin/algo-verify.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+
+/**
+ * AlgoMath Verify Command
+ * 
+ * Verify execution results and explain algorithm behavior
+ * Usage: /algo-verify [--step N] [--detailed] [--diagnostic]
+ */
+
+const { Command } = require('commander');
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const ora = require('ora');
+const { spawn } = require('child_process');
+const path = require('path');
+
+const program = new Command();
+
+program
+  .name('algo-verify')
+  .description('Verify execution results and explain algorithm behavior')
+  .option('-s, --step <number>', 'Explain specific step number', parseInt)
+  .option('-d, --detailed', 'Show detailed step-by-step explanation')
+  .option('--diagnostic', 'Run diagnostic mode for failed executions')
+  .action(async (options) => {
+    console.log(chalk.blue.bold('╔════════════════════════════════════════╗'));
+    console.log(chalk.blue.bold('║    AlgoMath - Verify Results           ║'));
+    console.log(chalk.blue.bold('╚════════════════════════════════════════╝'));
+    console.log();
+
+    try {
+      // If step is specified, explain that step
+      if (options.step !== undefined) {
+        console.log(chalk.cyan(`Explaining step ${options.step}...`));
+        console.log();
+      } else if (options.diagnostic) {
+        console.log(chalk.yellow('Running diagnostic mode...'));
+        console.log();
+      }
+
+      const spinner = ora('Verifying...').start();
+
+      const pythonScript = path.join(__dirname, '..', 'src', 'cli', 'cli_entry.py');
+      const args = ['verify'];
+      
+      if (options.step !== undefined) {
+        args.push('--step', options.step.toString());
+      }
+      if (options.detailed) {
+        args.push('--detailed');
+      }
+      if (options.diagnostic) {
+        args.push('--diagnostic');
+      }
+      
+      const result = await runPython(pythonScript, args);
+      
+      spinner.succeed('Verification complete!');
+      
+      const output = JSON.parse(result);
+      displayResult(output, options);
+
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+function runPython(script, args) {
+  return new Promise((resolve, reject) => {
+    const python = spawn('python3', [script, ...args], {
+      cwd: path.join(__dirname, '..')
+    });
+
+    let output = '';
+    let error = '';
+
+    python.stdout.on('data', (data) => {
+      output += data.toString();
+    });
+
+    python.stderr.on('data', (data) => {
+      error += data.toString();
+    });
+
+    python.on('close', (code) => {
+      if (code !== 0) {
+        reject(new Error(error || `Python process exited with code ${code}`));
+      } else {
+        resolve(output);
+      }
+    });
+  });
+}
+
+function displayResult(output, options) {
+  console.log();
+  
+  if (output.status === 'verified' || output.status === 'already_verified') {
+    console.log(chalk.green.bold('✓ Verification complete'));
+    console.log();
+    
+    if (output.message) {
+      console.log(chalk.white(output.message));
+      console.log();
+    }
+    
+    // Show verification report if available
+    if (output.verification_report) {
+      const report = output.verification_report;
+      
+      if (report.summary) {
+        console.log(chalk.cyan('Summary:'));
+        console.log(chalk.white(report.summary));
+        console.log();
+      }
+      
+      if (report.execution) {
+        console.log(chalk.cyan('Execution:'));
+        console.log(chalk.white(`  Status: ${report.execution.status}`));
+        console.log(chalk.white(`  Runtime: ${report.execution.runtime}s`));
+        console.log();
+      }
+      
+      if (report.explanation && options.detailed) {
+        console.log(chalk.cyan('Explanation:'));
+        console.log(chalk.white(report.explanation.text || report.explanation));
+        console.log();
+      }
+      
+      if (report.edge_cases && report.edge_cases.length > 0) {
+        console.log(chalk.cyan('Edge Cases:'));
+        report.edge_cases.forEach(ec => {
+          const icon = ec.severity === 'error' ? '✗' : '⚠';
+          console.log(chalk.white(`  ${icon} ${ec.description}`));
+        });
+        console.log();
+      }
+    }
+    
+    if (output.next_steps) {
+      console.log(chalk.gray('Next steps:'));
+      output.next_steps.forEach(step => {
+        if (step) console.log(chalk.gray(`  • ${step}`));
+      });
+    }
+  } else if (output.status === 'diagnostic_complete') {
+    console.log(chalk.yellow.bold('⚠ Diagnostic Report'));
+    console.log();
+    
+    if (output.diagnostic_report) {
+      const diag = output.diagnostic_report;
+      
+      if (diag.failure_point) {
+        console.log(chalk.cyan('Failure point:'), diag.failure_point);
+      }
+      
+      if (diag.possible_fixes && diag.possible_fixes.length > 0) {
+        console.log(chalk.cyan('Possible fixes:'));
+        diag.possible_fixes.forEach(fix => {
+          console.log(chalk.white(`  • ${fix}`));
+        });
+      }
+    }
+    
+    console.log();
+    if (output.next_steps) {
+      console.log(chalk.gray('Next steps:'));
+      output.next_steps.forEach(step => {
+        console.log(chalk.gray(`  • ${step}`));
+      });
+    }
+  } else {
+    console.log(chalk.yellow('⚠'), output.message);
+    console.log();
+    
+    if (output.next_steps) {
+      console.log(chalk.gray('Next steps:'));
+      output.next_steps.forEach(step => {
+        console.log(chalk.gray(`  • ${step}`));
+      });
+    }
+  }
+  
+  console.log();
+  console.log(chalk.blue('Use /algo-extract to start with a new algorithm'));
+}
+
+program.parse();