50c 3.0.14 → 3.1.0

package/bin/50c.js

@@ -670,8 +670,201 @@ const LOCAL_TOOLS = [
   { name: "team_ask", description: "50c Team: Ask the team to run any 50c tool. Uses your API key.", inputSchema: { type: "object", properties: { tool: { type: "string", description: "50c tool name (e.g., hints, roast, genius, bcalc)" }, args: { type: "object", description: "Tool arguments" } }, required: ["tool"] } },
   { 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 pipeline
+  { name: "auto_invent", description: "Enterprise: Full invention pipeline. Chains mind_opener → idea_fold → bcalc → genius_plus → compute → cvi_verify. Produces provable, verified solutions. $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: standard (3 tools), deep (5 tools), exhaustive (all 6)", enum: ["standard", "deep", "exhaustive"], default: "deep" } }, required: ["problem"] } },
 ];
 
+/**
+ * AUTO-INVENT: Enterprise invention pipeline
+ * Chains tools in order to produce provable, verified inventive solutions
+ * 
+ * Pipeline (exhaustive):
+ *   1. mind_opener - 5 curious angles to explore the problem space
+ *   2. idea_fold - Test top angle through STEM lenses  
+ *   3. bcalc - Mathematical discovery/verification
+ *   4. genius_plus - Self-improving code generation
+ *   5. compute - Execute and validate the solution
+ *   6. cvi_verify - Verify output against constraints
+ * 
+ * Cost: ~$2.00 for exhaustive, ~$1.20 for deep, ~$0.60 for standard
+ */
+async function autoInvent(args) {
+  const { problem, constraints = [], domain = 'code', rigor = 'deep' } = args;
+  const startTime = Date.now();
+  
+  // Define pipeline stages by rigor level
+  const PIPELINES = {
+    standard: ['mind_opener', 'genius_plus', 'cvi_verify'],
+    deep: ['mind_opener', 'idea_fold', 'bcalc', 'genius_plus', 'cvi_verify'],
+    exhaustive: ['mind_opener', 'idea_fold', 'bcalc', 'genius_plus', 'compute', 'cvi_verify']
+  };
+  
+  const pipeline = PIPELINES[rigor] || PIPELINES.deep;
+  const results = {
+    ok: true,
+    problem,
+    domain,
+    rigor,
+    constraints,
+    stages: [],
+    invention: null,
+    verified: false,
+    proofs: [],
+    cost_estimate: rigor === 'exhaustive' ? '$2.00' : rigor === 'deep' ? '$1.20' : '$0.60'
+  };
+  
+  let context = problem;
+  let bestAngle = null;
+  let mathProof = null;
+  let generatedCode = null;
+  
+  for (const stage of pipeline) {
+    const stageStart = Date.now();
+    let stageResult = null;
+    
+    try {
+      switch (stage) {
+        case 'mind_opener':
+          // Get 5 curious angles on the problem
+          stageResult = await call50cTool('mind_opener', { problem: context });
+          if (stageResult.angles && stageResult.angles.length > 0) {
+            bestAngle = stageResult.angles[0]; // Take the first/best angle
+            context = `${problem}\n\nApproach: ${bestAngle}`;
+          }
+          break;
+          
+        case 'idea_fold':
+          // Test the chosen angle through STEM lenses
+          stageResult = await call50cTool('idea_fold', { 
+            claim: bestAngle || problem,
+            context: `Domain: ${domain}. Problem: ${problem}`
+          });
+          if (stageResult.synthesis) {
+            context = `${context}\n\nSTEM Analysis: ${stageResult.synthesis}`;
+          }
+          break;
+          
+        case 'bcalc':
+          // Mathematical discovery/verification
+          const mathQuery = domain === 'math' ? problem : 
+            `Mathematical model for: ${bestAngle || problem}`;
+          stageResult = await call50cTool('bcalc', { 
+            expression: mathQuery,
+            mode: 'explore'
+          });
+          if (stageResult.discovery || stageResult.result) {
+            mathProof = stageResult;
+            results.proofs.push({ type: 'mathematical', data: stageResult });
+            context = `${context}\n\nMath foundation: ${JSON.stringify(stageResult.discovery || stageResult.result)}`;
+          }
+          break;
+          
+        case 'genius_plus':
+          // Self-improving code generation
+          const codePrompt = domain === 'code' ? 
+            `${context}\n\nConstraints: ${constraints.join(', ')}` :
+            `Implement solution for: ${context}\n\nDomain: ${domain}\nConstraints: ${constraints.join(', ')}`;
+          stageResult = await call50cTool('genius_plus', { problem: codePrompt });
+          if (stageResult.code || stageResult.solution) {
+            generatedCode = stageResult.code || stageResult.solution;
+            results.invention = {
+              code: generatedCode,
+              explanation: stageResult.explanation || stageResult.reasoning,
+              iterations: stageResult.iterations || 1
+            };
+          }
+          break;
+          
+        case 'compute':
+          // Execute and validate (only if we have code)
+          if (generatedCode) {
+            stageResult = await call50cTool('compute', { code: generatedCode });
+            results.proofs.push({ type: 'execution', data: stageResult });
+            if (stageResult.error) {
+              results.invention.execution_error = stageResult.error;
+            } else {
+              results.invention.execution_result = stageResult.result || stageResult.output;
+            }
+          } else {
+            stageResult = { skipped: true, reason: 'No code to execute' };
+          }
+          break;
+          
+        case 'cvi_verify':
+          // Verify against constraints
+          if (constraints.length > 0 && results.invention) {
+            const output = typeof results.invention === 'string' ? 
+              results.invention : JSON.stringify(results.invention);
+            stageResult = await call50cTool('cvi_verify', { 
+              constraints,
+              output
+            });
+            results.verified = stageResult.passed || stageResult.all_passed || false;
+            results.proofs.push({ type: 'constraint_verification', data: stageResult });
+          } else {
+            stageResult = { skipped: true, reason: constraints.length === 0 ? 'No constraints specified' : 'No invention to verify' };
+            results.verified = constraints.length === 0; // Vacuously true if no constraints
+          }
+          break;
+      }
+      
+      results.stages.push({
+        name: stage,
+        success: true,
+        duration_ms: Date.now() - stageStart,
+        output_summary: summarizeStageOutput(stage, stageResult)
+      });
+      
+    } catch (e) {
+      results.stages.push({
+        name: stage,
+        success: false,
+        error: e.message,
+        duration_ms: Date.now() - stageStart
+      });
+      // Continue pipeline even if a stage fails (graceful degradation)
+    }
+  }
+  
+  results.total_duration_ms = Date.now() - startTime;
+  results.pipeline_completed = results.stages.filter(s => s.success).length;
+  results.pipeline_total = pipeline.length;
+  
+  // Final verdict
+  if (results.invention && results.verified) {
+    results.verdict = 'INVENTION_VERIFIED';
+  } else if (results.invention) {
+    results.verdict = 'INVENTION_UNVERIFIED';
+  } else {
+    results.verdict = 'EXPLORATION_ONLY';
+  }
+  
+  return results;
+}
+
+function summarizeStageOutput(stage, result) {
+  if (!result) return 'No output';
+  if (result.skipped) return `Skipped: ${result.reason}`;
+  
+  switch (stage) {
+    case 'mind_opener':
+      return result.angles ? `${result.angles.length} angles found` : 'Angles generated';
+    case 'idea_fold':
+      return result.synthesis ? 'STEM synthesis complete' : 'Folded through lenses';
+    case 'bcalc':
+      return result.discovery ? 'Mathematical discovery made' : 'Math exploration done';
+    case 'genius_plus':
+      return result.code ? `Code generated (${result.iterations || 1} iterations)` : 'Solution generated';
+    case 'compute':
+      return result.error ? `Execution error: ${result.error}` : 'Execution successful';
+    case 'cvi_verify':
+      return result.passed || result.all_passed ? 'All constraints verified' : 'Verification incomplete';
+    default:
+      return 'Complete';
+  }
+}
+
 async function handleLocalTools(request) {
   const { id, method, params } = request;
   
@@ -830,6 +1023,16 @@ async function handleLocalTools(request) {
         return mcpResult(id, { ok: false, error: e.message });
       }
     }
+    
+    // AUTO-INVENT: Enterprise invention pipeline
+    if (name === 'auto_invent') {
+      try {
+        const result = await autoInvent(args);
+        return mcpResult(id, result);
+      } catch (e) {
+        return mcpResult(id, { ok: false, error: e.message, stage: 'auto_invent' });
+      }
+    }
   }
   
   return null; // Not a local tool, forward to remote
@@ -995,10 +1198,6 @@ function installMCP() {
     'playwright': {
       command: 'npx',
       args: ['-y', '@playwright/mcp@latest']
-    },
-    'filesystem': {
-      command: 'npx',
-      args: ['-y', '@modelcontextprotocol/server-filesystem@latest', home]
     }
   };
   
@@ -1046,7 +1245,6 @@ function installMCP() {
     console.log('MCPs added:');
     console.log('  50c        - AI dev tools ($0.01-$0.65)');
     console.log('  playwright - Browser automation (free)');
-    console.log('  filesystem - File system access (free)');
     console.log('');
     console.log('Optional: npx 50c-vault init  # Secure credentials (Windows Hello/Touch ID)');
     if (!API_KEY) {

package/package.json

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