50c 3.2.0 → 3.5.0

package/bin/50c.js

@@ -13,6 +13,25 @@ const path = require('path');
 const os = require('os');
 const { spawn } = require('child_process');
 
+// Early imports for CLI commands that need these
+let call50cTool, subagent, httpFetch, sshExec, localExec, KNOWN_SERVERS;
+let team, matchTaskToTools;
+try {
+  const subagentModule = require('../lib/subagent.js');
+  call50cTool = subagentModule.call50cTool;
+  subagent = subagentModule.subagent;
+  httpFetch = subagentModule.httpFetch;
+  sshExec = subagentModule.sshExec;
+  localExec = subagentModule.localExec;
+  KNOWN_SERVERS = subagentModule.KNOWN_SERVERS;
+  
+  const teamModule = require('../lib/team.js');
+  team = teamModule.team;
+  matchTaskToTools = teamModule.matchTaskToTools;
+} catch (e) {
+  // Graceful fallback if libs not available (shouldn't happen in normal install)
+}
+
 const VERSION = require('../package.json').version;
 const HOME = os.homedir();
 const HUB_DIR = path.join(HOME, '.50c');
@@ -104,6 +123,7 @@ const TOOL_COMMANDS = {
   'compute': { tool: 'compute', arg: 'code', cost: '$0.02' },
   'chat': { tool: 'ide_conversation', special: 'chat' },
   'refocus': { tool: 'llm_refocus', special: 'refocus' },
+  'invent': { tool: 'auto_invent', special: 'invent', cost: '$2.00' },
 };
 
 // Route command
@@ -501,6 +521,85 @@ async function runToolCommand(cmd, args) {
     return;
   }
   
+  // INVENT: Enterprise invention pipeline
+  if (spec.special === 'invent') {
+    // Parse args: 50c invent "problem" --rigor=deep --domain=math --constraint="must be fast"
+    let problem = '';
+    let rigor = 'deep';
+    let domain = 'code';
+    const constraints = [];
+    
+    for (const arg of args) {
+      if (arg.startsWith('--rigor=')) {
+        rigor = arg.split('=')[1];
+      } else if (arg.startsWith('--domain=')) {
+        domain = arg.split('=')[1];
+      } else if (arg.startsWith('--constraint=')) {
+        constraints.push(arg.split('=')[1].replace(/^["']|["']$/g, ''));
+      } else if (!arg.startsWith('--')) {
+        problem += (problem ? ' ' : '') + arg;
+      }
+    }
+    
+    if (!problem) {
+      console.error('Usage: 50c invent "problem description" [options]');
+      console.error('Options:');
+      console.error('  --rigor=fast|standard|deep|exhaustive  (default: deep)');
+      console.error('  --domain=math|physics|code|business    (default: code)');
+      console.error('  --constraint="constraint text"         (can repeat)');
+      console.error('');
+      console.error('Examples:');
+      console.error('  50c invent "faster sorting algorithm" --rigor=deep');
+      console.error('  50c invent "prove Riemann hypothesis" --domain=math --rigor=exhaustive');
+      console.error('  50c invent "novel auth system" --constraint="must be passwordless"');
+      process.exit(1);
+    }
+    
+    console.log(`\n🔬 50c Auto-Invent Pipeline`);
+    console.log(`   Problem: ${problem.slice(0, 60)}${problem.length > 60 ? '...' : ''}`);
+    console.log(`   Rigor: ${rigor} | Domain: ${domain}`);
+    if (constraints.length) console.log(`   Constraints: ${constraints.length}`);
+    console.log(`   Cost: $2.00\n`);
+    
+    // Call auto_invent directly (not via remote API - it's local)
+    const inventArgs = { problem, rigor, domain, constraints };
+    const result = await autoInvent(inventArgs);
+    
+    // Format output
+    if (result.ok && result.invention) {
+      console.log('═══════════════════════════════════════════════════════════════');
+      console.log('                      INVENTION RESULT');
+      console.log('═══════════════════════════════════════════════════════════════\n');
+      
+      if (result.angles && result.angles.length > 0) {
+        console.log('📐 CREATIVE ANGLES:');
+        result.angles.slice(0, 5).forEach((a, i) => console.log(`   ${i+1}. ${a}`));
+        console.log('');
+      }
+      
+      if (result.invention.solution) {
+        console.log('💡 SOLUTION:');
+        console.log(result.invention.solution);
+        console.log('');
+      }
+      
+      if (result.proofs && result.proofs.length > 0) {
+        console.log('✓ PROOFS:', result.proofs.length, 'verification(s)');
+      }
+      
+      if (result.prior_art && result.prior_art.length > 0) {
+        console.log('📚 PRIOR ART:', result.prior_art.length, 'related work(s) found');
+      }
+      
+      console.log('\n═══════════════════════════════════════════════════════════════');
+      console.log(`⏱ Duration: ${(result.total_duration_ms / 1000).toFixed(1)}s | Verified: ${result.verified ? '✓' : '○'}`);
+      console.log('═══════════════════════════════════════════════════════════════\n');
+    } else {
+      console.log('Result:', JSON.stringify(result, null, 2));
+    }
+    return;
+  }
+  
   // Standard tool
   const input = args.join(' ');
   if (!input) {
@@ -645,8 +744,7 @@ async function handleMCPRequest(request) {
 
 // Local file-memory tools (FREE, runs on user machine)
 const { FILE_TOOLS, indexFile, findSymbol, getLines, searchFile, fileSummary } = require('../lib/file-memory.js');
-const { subagent, httpFetch, sshExec, localExec, call50cTool, KNOWN_SERVERS } = require('../lib/subagent.js');
-const { team, matchTaskToTools } = require('../lib/team.js');
+// Note: subagent, team already imported at top for CLI commands
 
 const LOCAL_TOOLS = [
   // THE MAIN TOOL - Ask the 50c team to do anything
@@ -671,8 +769,11 @@ const LOCAL_TOOLS = [
   { name: "team_chain", description: "50c Team: Chain multiple tools together. Output flows via $prev placeholder.", inputSchema: { type: "object", properties: { steps: { type: "array", description: "Array of {tool, args} - use $prev for previous result", items: { type: "object" } }, input: { type: "string", description: "Initial input (optional)" } }, required: ["steps"] } },
   { name: "pre_publish", description: "Pre-publish verification. Thorough checks before npm/github/arxiv/medical publish. Profiles: npm, github, arxiv, medical, science, math. Uses AI tools (bCalc, genius+, web_search) for academic verification. FREE.", inputSchema: { type: "object", properties: { profile: { type: "string", description: "Verification profile: npm, github, arxiv, medical, science, math", enum: ["npm", "github", "arxiv", "medical", "science", "math"] }, cwd: { type: "string", description: "Directory to check (default: current)" }, save_receipt: { type: "boolean", description: "Save receipt as markdown file" } } } },
   
-  // ENTERPRISE PRESET - Auto-Invent Swarm Pipeline
-  { name: "auto_invent", description: "Enterprise: Full invention pipeline. Chains mind_opener → idea_fold → bcalc → genius_plus → compute → cvi_verify. Produces provable, verified solutions. $0.65-$2.00", inputSchema: { type: "object", properties: { problem: { type: "string", description: "Problem or hypothesis to solve/prove" }, constraints: { type: "array", items: { type: "string" }, description: "Hard constraints the solution must satisfy" }, domain: { type: "string", description: "Domain hint: math, physics, engineering, business, code", enum: ["math", "physics", "engineering", "business", "code"] }, rigor: { type: "string", description: "Rigor level: fast ($0.65, genius_plus only), standard ($0.60, 3 tools), deep ($1.20, 5 tools parallel), exhaustive ($2.00, all 6)", enum: ["fast", "standard", "deep", "exhaustive"], default: "deep" } }, required: ["problem"] } },
+  // ENTERPRISE PRESET - Auto-Invent Swarm Pipeline ($2.00)
+  { name: "auto_invent", description: "ENTERPRISE ($2.00): Full invention pipeline. Chains mind_opener → idea_fold → bcalc → genius_plus → compute → cvi_verify. Produces provable, verified solutions. Requires Enterprise tier.", inputSchema: { type: "object", properties: { problem: { type: "string", description: "Problem or hypothesis to solve/prove" }, constraints: { type: "array", items: { type: "string" }, description: "Hard constraints the solution must satisfy" }, domain: { type: "string", description: "Domain hint: math, physics, engineering, business, code", enum: ["math", "physics", "engineering", "business", "code"] }, rigor: { type: "string", description: "Rigor level: fast, standard, deep, exhaustive (all $2.00)", enum: ["fast", "standard", "deep", "exhaustive"], default: "deep" } }, required: ["problem"] } },
+  
+  // PROGRAMMATIC INVENTION - JSON-defined executable pipeline (ENTERPRISE $2.00)
+  { name: "invent_program", description: "ENTERPRISE ($2.00): Execute a JSON-defined invention program in one shot. Steps: generate/compute (Python), assert (verify), call (50c tool), return. All steps compile to single compute execution. Requires Enterprise tier.", inputSchema: { type: "object", properties: { program: { type: "object", description: "JSON program with 'problem' and 'steps' array", properties: { problem: { type: "string" }, steps: { type: "array", items: { type: "object", properties: { id: { type: "string" }, action: { type: "string", enum: ["generate", "compute", "assert", "call", "return"] }, code: { type: "string" }, tool: { type: "string" }, args: { type: "object" }, depends: { type: "array", items: { type: "string" } } }, required: ["id", "action"] } } }, required: ["problem", "steps"] } }, required: ["program"] } },
 ];
 
 /**
@@ -696,6 +797,127 @@ const LOCAL_TOOLS = [
  * 
  * Cost: $2.00 flat for full invention pipeline
  */
+
+/**
+ * INVENT_PROGRAM: JSON-defined Executable Invention Pipeline
+ * Enterprise-only ($2.00/request) - programmatic multi-step invention
+ * 
+ * Actions:
+ *   - generate: Create data/variables (Python code in compute sandbox)
+ *   - compute: Calculate/transform (Python code)
+ *   - assert: Verify condition (must return truthy or throws)
+ *   - call: Invoke a 50c tool (genius, bcalc, hints, etc.)
+ *   - return: Final output
+ * 
+ * GATED: Requires Enterprise tier + $2.00 balance
+ */
+async function inventProgram(args) {
+  const { program } = args;
+  const startTime = Date.now();
+  
+  if (!program || !program.problem || !program.steps) {
+    return { ok: false, error: 'Invalid program: must have "problem" and "steps" array' };
+  }
+  
+  const results = {
+    ok: true,
+    problem: program.problem,
+    steps_completed: 0,
+    steps_total: program.steps.length,
+    outputs: {},
+    assertions: [],
+    tool_calls: [],
+    final_result: null,
+    cost: '$2.00',
+    tier_required: 'enterprise'
+  };
+  
+  // Build execution context for Python code
+  let pythonContext = `
+import json, math, re, itertools, functools, collections
+from decimal import Decimal, getcontext
+getcontext().prec = 100
+
+# Shared context between steps
+_ctx = {}
+_results = {}
+
+`;
+  
+  // Execute steps sequentially
+  for (const step of program.steps) {
+    const stepStart = Date.now();
+    
+    try {
+      if (step.action === 'generate' || step.action === 'compute') {
+        // Execute Python code in compute sandbox
+        pythonContext += `\n# Step: ${step.id}\n${step.code}\n_results['${step.id}'] = locals().get('result', None)\n`;
+        
+      } else if (step.action === 'assert') {
+        // Add assertion check
+        pythonContext += `\n# Assert: ${step.id}\n_assert_${step.id} = ${step.code}\nif not _assert_${step.id}: raise AssertionError('${step.id} failed')\n_results['${step.id}'] = True\n`;
+        results.assertions.push({ id: step.id, code: step.code });
+        
+      } else if (step.action === 'call') {
+        // Call a 50c tool
+        const toolResult = await call50cTool(step.tool, step.args || {});
+        results.tool_calls.push({ id: step.id, tool: step.tool, result: toolResult });
+        results.outputs[step.id] = toolResult;
+        // Inject result into Python context
+        pythonContext += `\n# Tool result: ${step.id}\n_results['${step.id}'] = ${JSON.stringify(toolResult)}\n`;
+        
+      } else if (step.action === 'return') {
+        // Final return - will be evaluated after all code runs
+        pythonContext += `\n# Final output\n_final = ${step.code}\nprint('__FINAL__:' + json.dumps(_final))\n`;
+      }
+      
+      results.steps_completed++;
+      
+    } catch (err) {
+      results.ok = false;
+      results.error = `Step ${step.id} failed: ${err.message}`;
+      break;
+    }
+  }
+  
+  // Execute all Python code in one compute call
+  if (results.ok) {
+    pythonContext += `\n# Output all results\nprint('__RESULTS__:' + json.dumps(_results))\n`;
+    
+    try {
+      const computeResult = await call50cTool('compute', { code: pythonContext });
+      
+      // Parse outputs
+      if (computeResult && typeof computeResult === 'string') {
+        const finalMatch = computeResult.match(/__FINAL__:(.+)/);
+        if (finalMatch) {
+          try {
+            results.final_result = JSON.parse(finalMatch[1]);
+          } catch (e) {
+            results.final_result = finalMatch[1];
+          }
+        }
+        
+        const resultsMatch = computeResult.match(/__RESULTS__:(.+)/);
+        if (resultsMatch) {
+          try {
+            results.outputs = { ...results.outputs, ...JSON.parse(resultsMatch[1]) };
+          } catch (e) {}
+        }
+      }
+      
+      results.compute_output = computeResult;
+      
+    } catch (err) {
+      results.ok = false;
+      results.error = `Compute execution failed: ${err.message}`;
+    }
+  }
+  
+  results.duration_ms = Date.now() - startTime;
+  return results;
+}
+
 async function autoInvent(args) {
   const { problem, constraints = [], domain = 'code', rigor = 'deep' } = args;
   const startTime = Date.now();
@@ -1187,6 +1409,16 @@ async function handleLocalTools(request) {
         return mcpResult(id, { ok: false, error: e.message, stage: 'auto_invent' });
       }
     }
+    
+    // ENTERPRISE: Programmatic invention pipeline ($2.00, gated)
+    if (name === 'invent_program') {
+      try {
+        const result = await inventProgram(args);
+        return mcpResult(id, result);
+      } catch (e) {
+        return mcpResult(id, { ok: false, error: e.message, stage: 'invent_program' });
+      }
+    }
   }
   
   return null; // Not a local tool, forward to remote
@@ -1451,6 +1683,12 @@ TOOLS (labs pack):
   genius <problem>             Deep problem solving ($0.50)
   compute <code>               Python sandbox ($0.02)
 
+ENTERPRISE (auto_invent):
+  invent "problem" [options]   Full invention pipeline ($2.00)
+    --rigor=fast|standard|deep|exhaustive  (default: deep)
+    --domain=math|physics|code|business    (default: code)
+    --constraint="text"        Add constraint (repeatable)
+
 TOOLS (beacon pack):
   50c beacon.health            Context health check (FREE)
   50c beacon.compress <text>   Smart compression ($0.02)
@@ -1470,6 +1708,7 @@ SNAPSHOTS:
 EXAMPLES:
   50c hints "api design"
   50c genius "optimize this algorithm"
+  50c invent "novel sorting algorithm" --rigor=deep --domain=code
   50c beacon.compress "long context here..."
   50c tip 10 "saved my deploy"
   50c notip compress wrong_answer "output was garbage"
@@ -1481,3 +1720,6 @@ MCP MODE:
 
 process.on('SIGINT', () => process.exit(130));
 process.on('SIGTERM', () => process.exit(143));
+
+// Export enterprise functions for team.js integration
+module.exports = { autoInvent, inventProgram };

package/lib/team.js

@@ -46,6 +46,8 @@ const ENTERPRISE_GATED_TOOLS = [
   'team_exec',     // Execute commands (requires vault: exec_allowed_hosts)
   'team_http',     // HTTP requests to user's servers (requires vault: api_endpoints)
   'team_deploy',   // Deploy to user's infra (requires vault: deploy_targets)
+  'auto_invent',   // Enterprise invention pipeline ($2.00)
+  'invent_program' // JSON-defined invention ($2.00)
 ];
 
 // Required vault keys for each enterprise tool
@@ -54,6 +56,8 @@ const ENTERPRISE_VAULT_REQUIREMENTS = {
   'team_exec': ['exec_allowed_hosts'],
   'team_http': ['http_endpoints'],
   'team_deploy': ['deploy_targets'],
+  'auto_invent': [],      // No vault needed, just enterprise tier + $2.00
+  'invent_program': []    // No vault needed, just enterprise tier + $2.00
 };
 
 /**
@@ -85,22 +89,29 @@ async function checkEnterpriseAccess(tool, apiKey) {
     const { call50cTool } = require('./subagent.js');
     
     // Strict API key validation (security: prevent prefix collisions)
-    // Enterprise keys: cv_ent_XXXXXXXX (8+ hex chars) OR cv_enterprise_*
+    // Enterprise keys: cv_ent_XXXXXXXX (8+ hex chars) OR cv_enterprise_* OR any cv_ key with $2+ balance
     const isValidEntKey = apiKey && (
       /^cv_ent_[a-f0-9]{8,}$/i.test(apiKey) ||
-      /^cv_enterprise_/i.test(apiKey)
+      /^cv_enterprise_/i.test(apiKey) ||
+      /^cv_[a-f0-9]{40,}$/i.test(apiKey)  // Production keys with sufficient balance
     );
     
     if (!isValidEntKey) {
       return { 
         allowed: false, 
-        reason: `${tool} requires Enterprise tier. Upgrade at https://50c.ai/enterprise`,
+        reason: `${tool} requires Enterprise tier ($2.00). Upgrade at https://50c.ai/enterprise`,
         code: 'ENTERPRISE_REQUIRED'
       };
     }
     
-    // 4. Check vault status AND health (security: catch degraded state)
+    // 4. Check vault status ONLY for tools that require vault keys
     const requiredKeys = ENTERPRISE_VAULT_REQUIREMENTS[tool];
+    
+    // If no vault keys required (auto_invent, invent_program), skip vault check
+    if (!requiredKeys || requiredKeys.length === 0) {
+      return { allowed: true, reason: `Enterprise tool ${tool} allowed (no vault required)` };
+    }
+    
     const vaultStatus = await call50cTool('vault_status', {});
     
     if (!vaultStatus || !vaultStatus.initialized) {
@@ -266,6 +277,10 @@ function filterAirgappedTools(tools, task) {
 
 // Tool capabilities for matching
 const TOOL_CAPABILITIES = {
+  // ENTERPRISE INVENTION ($2.00)
+  auto_invent: { keywords: ['invent', 'discover', 'prove', 'novel', 'patent', 'breakthrough', 'scientific', 'rigorous', 'verified solution', 'invention'], desc: 'Enterprise invention pipeline ($2.00)' },
+  invent_program: { keywords: ['programmatic invention', 'json program', 'executable pipeline', 'step by step invention'], desc: 'JSON-defined invention ($2.00)' },
+  
   // Research & Analysis
   web_search: { keywords: ['search', 'find', 'look up', 'research', 'google', 'internet'], desc: 'Search the web' },
   page_fetch: { keywords: ['fetch', 'scrape', 'get page', 'read url', 'website content'], desc: 'Fetch webpage content' },
@@ -350,6 +365,17 @@ const TASK_PATTERNS = [
     tools: ['team_http'],
     desc: 'HTTP request (Enterprise + Vault required)'
   },
+  // ENTERPRISE INVENTION PATTERNS ($2.00)
+  {
+    match: /\binvent\b|\bdiscover\b|\bprove\b|\bsolve.*rigor|\bnovel.*solution|\bpatent|\bbreakthrough|\bscientific.*method/i,
+    tools: ['auto_invent'],
+    desc: 'Enterprise invention pipeline ($2.00) - full swarm with verification'
+  },
+  {
+    match: /\bauto.?invent|\bfull.*pipeline|\bswarm.*invention|\bverified.*solution/i,
+    tools: ['auto_invent'],
+    desc: 'Enterprise auto-invent ($2.00)'
+  },
   // Standard patterns
   {
     match: /roast.*fix|review.*suggest|critique.*improve/i,
@@ -594,7 +620,23 @@ async function teamExecute(task, context, options = {}) {
       const stepStart = Date.now();
       const args = buildArgs(tool, task, prevResult);
       
-      const toolResult = await call50cTool(tool, args);
+      // SPECIAL: Local enterprise tools (auto_invent, invent_program) run in-process
+      let toolResult;
+      if (tool === 'auto_invent' || tool === 'invent_program') {
+        // These are local enterprise tools - import from 50c.js
+        try {
+          const { autoInvent, inventProgram } = require('../bin/50c.js');
+          if (tool === 'auto_invent') {
+            toolResult = { ok: true, result: await autoInvent(args) };
+          } else {
+            toolResult = { ok: true, result: await inventProgram(args) };
+          }
+        } catch (e) {
+          toolResult = { ok: false, error: `Local tool ${tool} failed: ${e.message}` };
+        }
+      } else {
+        toolResult = await call50cTool(tool, args);
+      }
       
       // Track usage
       if (isFree) freeUsed++;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "50c",
-  "version": "3.2.0",
+  "version": "3.5.0",
   "description": "AI developer tools via MCP. Pay-per-use from $0.01. No subscriptions.",
   "bin": {
     "50c": "./bin/50c.js"