50c 3.3.0 → 3.7.0

package/bin/50c.js

@@ -124,6 +124,8 @@ const TOOL_COMMANDS = {
   'chat': { tool: 'ide_conversation', special: 'chat' },
   'refocus': { tool: 'llm_refocus', special: 'refocus' },
   'invent': { tool: 'auto_invent', special: 'invent', cost: '$2.00' },
+  'invent-ui': { tool: 'auto_invent', special: 'invent-ui', cost: '$2.00' },
+  'tv': { tool: null, special: 'mcp-tv', cost: 'FREE' },
 };
 
 // Route command
@@ -521,6 +523,62 @@ async function runToolCommand(cmd, args) {
     return;
   }
   
+  // INVENT-UI: Visual invention pipeline with browser UI
+  if (spec.special === 'invent-ui') {
+    let problem = '';
+    let rigor = 'deep';
+    let domain = 'code';
+    
+    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('--')) problem += (problem ? ' ' : '') + arg;
+    }
+    
+    if (!problem) {
+      console.error('Usage: 50c invent-ui "problem" [--rigor=deep] [--domain=math]');
+      console.error('Opens a browser window with real-time swarm visualization.');
+      process.exit(1);
+    }
+    
+    const { runInventWithUI } = require('../lib/invent-ui.js');
+    await runInventWithUI(problem, { domain, rigor });
+    return;
+  }
+  
+  // MCP-TV: Universal MCP Visualization Platform (FREE)
+  if (spec.special === 'mcp-tv') {
+    let port = 50888;
+    let noOpen = false;
+    
+    for (const arg of args) {
+      if (arg.startsWith('--port=')) port = parseInt(arg.split('=')[1]);
+      if (arg === '--no-open') noOpen = true;
+    }
+    
+    const { createServer } = require('../lib/mcp-tv.js');
+    const { spawn } = require('child_process');
+    
+    createServer(port);
+    
+    if (!noOpen) {
+      setTimeout(() => {
+        const url = `http://localhost:${port}`;
+        const platform = process.platform;
+        if (platform === 'win32') {
+          spawn('cmd', ['/c', 'start', url], { detached: true, stdio: 'ignore' }).unref();
+        } else if (platform === 'darwin') {
+          spawn('open', [url], { detached: true, stdio: 'ignore' }).unref();
+        } else {
+          spawn('xdg-open', [url], { detached: true, stdio: 'ignore' }).unref();
+        }
+      }, 500);
+    }
+    
+    // Keep process alive
+    return new Promise(() => {});
+  }
+  
   // INVENT: Enterprise invention pipeline
   if (spec.special === 'invent') {
     // Parse args: 50c invent "problem" --rigor=deep --domain=math --constraint="must be fast"
@@ -769,8 +827,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"] } },
 ];
 
 /**
@@ -794,6 +855,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();
@@ -1285,6 +1467,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
@@ -1554,6 +1746,16 @@ ENTERPRISE (auto_invent):
     --rigor=fast|standard|deep|exhaustive  (default: deep)
     --domain=math|physics|code|business    (default: code)
     --constraint="text"        Add constraint (repeatable)
+  invent-ui "problem" [opts]   Same as invent, but opens browser UI
+                               Real-time swarm visualization (MCP TV!)
+
+MCP-TV (FREE):
+  tv                           Start MCP-TV server - universal MCP visualizer
+  tv --port=3000               Custom port (default: 50888)
+  
+  Any MCP can stream events to MCP-TV:
+    POST http://localhost:50888/stream
+    { "channel": "my-mcp", "event": "stage", "data": {...} }
 
 TOOLS (beacon pack):
   50c beacon.health            Context health check (FREE)
@@ -1586,3 +1788,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 };