algomath-extract 1.0.0

package/bin/install.js

@@ -0,0 +1,349 @@
+#!/usr/bin/env node
+
+/**
+* AlgoMath Installer
+*
+* Usage: npx algomath@latest
+*
+* Installs AlgoMath to opencode (and optionally other runtimes)
+*/
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Check if running with flags
+const args = process.argv.slice(2);
+const isOpencode = args.includes('--opencode') || args.includes('--all');
+const isClaude = args.includes('--claude') || args.includes('--all');
+const isGlobal = args.includes('--global') || args.includes('-g');
+const isLocal = args.includes('--local') || args.includes('-l');
+const skipPrompts = isOpencode || isClaude || isGlobal || isLocal;
+
+async function main() {
+console.log('\n╔════════════════════════════════════════════════════╗');
+console.log('║ AlgoMath Framework Installer ║');
+console.log('║ Mathematical Algorithm Extraction & Code ║');
+console.log('╚════════════════════════════════════════════════════╝\n');
+
+try {
+// Step 1: Check Python
+console.log('Step 1: Checking Python installation...');
+const pythonOk = await checkPython();
+if (!pythonOk) {
+console.error('\n❌ Python 3.11+ is required but not found.');
+console.log('\nPlease install Python 3.11 or later:');
+console.log(' macOS: brew install python@3.11');
+console.log(' Ubuntu: sudo apt install python3.11');
+console.log(' Windows: python.org/downloads\n');
+process.exit(1);
+}
+console.log('✓ Python 3.11+ detected\n');
+
+// Step 2: Determine installation targets
+let targets = [];
+let location = 'global';
+
+if (skipPrompts) {
+// Non-interactive mode
+if (isOpencode) targets.push('opencode');
+if (isClaude) targets.push('claude');
+if (isLocal) location = 'local';
+} else {
+// Interactive mode
+targets = await promptForRuntimes();
+location = await promptForLocation();
+}
+
+if (targets.length === 0) {
+console.log('No runtimes selected. Exiting.');
+process.exit(0);
+}
+
+// Step 3: Install Python dependencies
+console.log('Step 2: Installing Python dependencies...');
+await installPythonDependencies();
+console.log('✓ Python dependencies installed\n');
+
+// Step 4: Install to each runtime
+console.log('Step 3: Installing AlgoMath commands...');
+for (const target of targets) {
+await installToRuntime(target, location);
+}
+
+// Step 5: Display completion
+console.log('\n╔════════════════════════════════════════════════════╗');
+console.log('║ Installation Complete! ✓ ║');
+console.log('╚════════════════════════════════════════════════════╝\n');
+
+console.log('AlgoMath is now ready to use.\n');
+console.log('Try these commands:');
+console.log(' /algo-extract <file.pdf> - Extract algorithm from PDF');
+console.log(' /algo-generate - Generate Python code');
+console.log(' /algo-run - Execute the code');
+console.log(' /algo-verify - Verify results');
+console.log(' /algo-help - Show all commands\n');
+
+if (location === 'global') {
+console.log('Installed globally - available in all projects.\n');
+} else {
+console.log('Installed locally - available in this project only.\n');
+}
+
+} catch (error) {
+console.error('\n❌ Installation failed:', error.message);
+console.error(error.stack);
+process.exit(1);
+}
+}
+
+function findPython() {
+const candidates = ['python3', 'python'];
+for (const cmd of candidates) {
+try {
+const version = execSync(`${cmd} --version`, { encoding: 'utf8', stdio: 'pipe' });
+const match = version.match(/Python 3\.(\d+)/);
+if (match) {
+const minor = parseInt(match[1]);
+if (minor >= 11) {
+return { cmd, minor };
+}
+}
+} catch (e) {
+// Try next candidate
+}
+}
+return null;
+}
+
+async function checkPython() {
+const found = findPython();
+return found !== null;
+}
+
+function findPip() {
+const candidates = ['pip3', 'pip'];
+for (const cmd of candidates) {
+try {
+execSync(`${cmd} --version`, { stdio: 'pipe' });
+return cmd;
+} catch (e) {
+// Try next candidate
+}
+}
+return null;
+}
+
+async function promptForRuntimes() {
+// Simple prompt (in real version would use inquirer)
+console.log('Select runtime(s):');
+console.log(' 1. OpenCode (recommended)');
+console.log(' 2. Claude Code');
+console.log(' 3. Both');
+console.log(' 4. Skip\n');
+
+// For now, auto-select OpenCode
+console.log('Auto-selecting: OpenCode\n');
+return ['opencode'];
+}
+
+async function promptForLocation() {
+console.log('Installation location:');
+console.log(' 1. Global (~/.opencode/) - All projects');
+console.log(' 2. Local (./.opencode/) - This project only\n');
+
+// For now, auto-select global
+console.log('Auto-selecting: Global\n');
+return 'global';
+}
+
+function checkPythonDeps() {
+const pythonInfo = findPython();
+if (!pythonInfo) return false;
+
+try {
+execSync(`${pythonInfo.cmd} -c "import pdfplumber; import fitz; import pydantic"`, {
+stdio: 'pipe'
+});
+return true;
+} catch (e) {
+return false;
+}
+}
+
+async function installPythonDependencies() {
+const requirementsPath = path.join(__dirname, '..', 'requirements.txt');
+
+if (!fs.existsSync(requirementsPath)) {
+console.log('Creating requirements.txt...');
+const requirements = `# AlgoMath Dependencies
+pdfplumber>=0.10.0
+pymupdf>=1.23.0
+pydantic>=2.0.0
+typing-extensions>=4.0.0
+`;
+fs.writeFileSync(requirementsPath, requirements);
+}
+
+// Check if dependencies are already installed
+if (checkPythonDeps()) {
+console.log('✓ Python dependencies already installed\n');
+return;
+}
+
+// Find python and try pip module first
+const pythonInfo = findPython();
+if (!pythonInfo) {
+console.error('\n❌ Python 3.11+ is required but not found.');
+process.exit(1);
+}
+
+const pythonCmd = pythonInfo.cmd;
+let installCmd = null;
+
+// Try python -m pip first (most reliable)
+try {
+execSync(`${pythonCmd} -m pip --version`, { stdio: 'pipe' });
+installCmd = `${pythonCmd} -m pip`;
+} catch (e) {
+// Fall back to pip command
+const pipCmd = findPip();
+if (pipCmd) {
+installCmd = pipCmd;
+}
+}
+
+if (!installCmd) {
+console.log('\n⚠️  pip is not available. Attempting to install without pip...');
+console.log('   If you encounter issues, please install dependencies manually:');
+console.log('   macOS: brew install python@3.11 && python3 -m ensurepip --upgrade');
+console.log('   Ubuntu: sudo apt install python3-pip');
+console.log('   NixOS: nix-shell -p python311 python311Packages.pip python311Packages.pdfplumber python311Packages.pymupdf python311Packages.pydantic\n');
+return; // Don't fail, let the user handle dependencies manually
+}
+
+try {
+execSync(`${installCmd} install -r "${requirementsPath}"`, {
+stdio: 'inherit',
+cwd: path.join(__dirname, '..')
+});
+} catch (e) {
+console.log('\n⚠️  Failed to install Python dependencies automatically.');
+console.log('   Please install them manually if you encounter issues.\n');
+}
+}
+
+function isWritable(dir) {
+try {
+fs.accessSync(dir, fs.constants.W_OK);
+return true;
+} catch (e) {
+return false;
+}
+}
+
+async function installToRuntime(runtime, location) {
+const homeDir = os.homedir();
+const platform = os.platform();
+let targetDir;
+
+if (runtime === 'opencode') {
+targetDir = location === 'global'
+? path.join(homeDir, '.config', 'opencode')
+: path.join(process.cwd(), '.opencode');
+} else if (runtime === 'claude') {
+targetDir = location === 'global'
+? path.join(homeDir, '.claude')
+: path.join(process.cwd(), '.claude');
+} else {
+throw new Error(`Unknown runtime: ${runtime}`);
+}
+
+// Check if we need elevated permissions
+const needsElevated = !fs.existsSync(targetDir) || !isWritable(targetDir);
+const isWindows = platform === 'win32';
+const isMac = platform === 'darwin';
+
+if (needsElevated) {
+console.log(` Installing to ${runtime} requires elevated permissions...`);
+if (isWindows) {
+console.log(` Please run this installer as Administrator.`);
+console.log(` Right-click Command Prompt/PowerShell and select 'Run as Administrator'.`);
+process.exit(1);
+} else {
+console.log(` Running with sudo...`);
+}
+}
+
+// Create directories
+const commandDir = path.join(targetDir, 'command');
+if (needsElevated && !isWindows) {
+execSync(`sudo mkdir -p "${commandDir}"`, { stdio: 'inherit' });
+// Ensure the directory is writable by the user for future updates
+const parentDir = path.dirname(targetDir);
+execSync(`sudo chown -R $(whoami) "${parentDir}"`, { stdio: 'inherit' });
+} else {
+fs.mkdirSync(commandDir, { recursive: true });
+}
+
+// Copy command files
+const sourceDir = path.join(__dirname, '..', 'commands');
+const files = fs.readdirSync(sourceDir).filter(f => f.endsWith('.md'));
+
+for (const file of files) {
+const source = path.join(sourceDir, file);
+const dest = path.join(commandDir, file);
+if (needsElevated && !isWindows) {
+execSync(`sudo cp "${source}" "${dest}"`, { stdio: 'pipe' });
+} else {
+fs.copyFileSync(source, dest);
+}
+}
+
+// Create opencode.json if it doesn't exist
+const configPath = path.join(targetDir, 'opencode.json');
+if (!fs.existsSync(configPath)) {
+const config = {
+"type": "commonjs",
+"permissions": {
+"allow": [
+"Bash(python3:*)",
+"Bash(pip3:*)",
+"Read(*)",
+"Write(*)",
+"Glob(*)",
+"Grep(*)",
+"Bash(git:*)",
+"Bash(cat:*)",
+"Bash(ls:*)",
+"Bash(mkdir:*)",
+"Bash(rm:*)",
+"Bash(cp:*)",
+"Bash(mv:*)",
+"Bash(date:*)",
+"Bash(echo:*)",
+"Bash(head:*)",
+"Bash(tail:*)",
+"Bash(wc:*)",
+"Bash(sort:*)",
+"Bash(grep:*)",
+"Bash(find:*)"
+]
+}
+};
+if (needsElevated && !isWindows) {
+const tempConfig = path.join(os.tmpdir(), 'opencode-config.json');
+fs.writeFileSync(tempConfig, JSON.stringify(config, null, 2));
+execSync(`sudo cp "${tempConfig}" "${configPath}"`, { stdio: 'pipe' });
+fs.unlinkSync(tempConfig);
+} else {
+fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+}
+
+console.log(` ✓ Installed to ${runtime} (${location})`);
+}
+
+// Run installer
+main().catch(console.error);

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "algomath-extract",
+  "version": "1.0.0",
+  "description": "AlgoMath Framework - Transform AI assistants into reliable mathematical problem-solving environments",
+  "main": "index.js",
+  "bin": {
+    "algomath": "bin/install.js",
+    "algoextract": "bin/algo-extract.js",
+    "algogenerate": "bin/algo-generate.js",
+    "algorun": "bin/algo-run.js",
+    "algoverify": "bin/algo-verify.js",
+    "algostatus": "bin/algo-status.js",
+    "algolist": "bin/algo-list.js",
+    "algohelp": "bin/algo-help.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js",
+    "test": "node scripts/test.js"
+  },
+  "keywords": [
+    "algorithm",
+    "mathematics",
+    "ai",
+    "code-generation",
+    "extraction",
+    "verification"
+  ],
+  "author": "AlgoMath Team",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    "src/",
+    "requirements.txt",
+    "README.md"
+  ],
+  "dependencies": {
+    "commander": "^11.0.0",
+    "inquirer": "^9.2.0",
+    "chalk": "^5.3.0",
+    "ora": "^7.0.0"
+  },
+  "devDependencies": {
+    "eslint": "^8.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yourusername/algomath.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yourusername/algomath/issues"
+  },
+  "homepage": "https://github.com/yourusername/algomath#readme"
+}

package/requirements.txt

@@ -0,0 +1,20 @@
+# AlgoMath Python Dependencies
+
+# PDF Processing
+pdfplumber>=0.10.0
+pymupdf>=1.23.0
+
+# Data Validation
+pydantic>=2.0.0
+
+# Type Hints
+typing-extensions>=4.0.0
+
+# Testing (optional)
+pytest>=7.0.0
+pytest-cov>=4.0.0
+
+# Development (optional)
+black>=23.0.0
+flake8>=6.0.0
+mypy>=1.0.0

package/src/cli/cli_entry.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+"""
+CLI Entry Point for AlgoMath
+
+This module provides a command-line interface for the AlgoMath framework,
+allowing Node.js to call Python functions via subprocess.
+"""
+
+import sys
+import json
+import argparse
+from pathlib import Path
+
+# Add project root to Python path
+project_root = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from src.cli.commands import (
+    extract_command,
+    generate_command,
+    run_command,
+    verify_command,
+    status_command,
+    list_command,
+    help_command
+)
+
+
+def main():
+    """Main entry point for CLI."""
+    parser = argparse.ArgumentParser(description='AlgoMath CLI')
+    subparsers = parser.add_subparsers(dest='command', help='Available commands')
+    
+    # Extract command
+    extract_parser = subparsers.add_parser('extract', help='Extract algorithm from text')
+    extract_parser.add_argument('text', help='Mathematical text')
+    extract_parser.add_argument('--name', '-n', help='Algorithm name', default=None)
+    
+    # Generate command
+    generate_parser = subparsers.add_parser('generate', help='Generate code from steps')
+    
+    # Run command
+    run_parser = subparsers.add_parser('run', help='Execute generated code')
+    run_parser.add_argument('--skip', action='store_true', help='Skip execution')
+    
+    # Verify command
+    verify_parser = subparsers.add_parser('verify', help='Verify execution results')
+    verify_parser.add_argument('--step', type=int, help='Explain specific step')
+    verify_parser.add_argument('--detailed', action='store_true', help='Show detailed explanation')
+    verify_parser.add_argument('--diagnostic', action='store_true', help='Run diagnostic mode')
+    
+    # Status command
+    status_parser = subparsers.add_parser('status', help='Show current state')
+    
+    # List command
+    list_parser = subparsers.add_parser('list', help='List saved algorithms')
+    
+    # Help command
+    help_parser = subparsers.add_parser('help', help='Show help')
+    
+    args = parser.parse_args()
+    
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+    
+    try:
+        # Route to appropriate command
+        if args.command == 'extract':
+            result = extract_command(args.text, args.name)
+        elif args.command == 'generate':
+            result = generate_command()
+        elif args.command == 'run':
+            result = run_command(skip=args.skip)
+        elif args.command == 'verify':
+            result = verify_command(
+                step=args.step,
+                detailed=args.detailed,
+                diagnostic=args.diagnostic
+            )
+        elif args.command == 'status':
+            result = status_command()
+        elif args.command == 'list':
+            result = list_command()
+        elif args.command == 'help':
+            result = help_command()
+        else:
+            print(json.dumps({
+                'status': 'error',
+                'message': f'Unknown command: {args.command}'
+            }))
+            sys.exit(1)
+        
+        # Output result as JSON for Node.js to parse
+        print(json.dumps(result))
+        
+    except Exception as e:
+        print(json.dumps({
+            'status': 'error',
+            'message': str(e)
+        }))
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()