50c 3.0.14 → 3.1.1

package/bin/50c.js

@@ -670,8 +670,193 @@ 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. $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"] } },
 ];
 
+/**
+ * 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 = {
+    fast: ['genius_plus'],  // Just genius_plus for quick results
+    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' : rigor === 'standard' ? '$0.60' : '$0.65'
+  };
+  
+  let context = problem;
+  let bestAngle = null;
+  let mathProof = null;
+  let generatedCode = null;
+  
+  // For deep/exhaustive, run first 3 stages in parallel to save time
+  if (rigor === 'deep' || rigor === 'exhaustive') {
+    const parallelStart = Date.now();
+    try {
+      const [mindResult, ideaResult, bcalcResult] = await Promise.all([
+        call50cTool('mind_opener', { problem }).catch(e => ({ error: e.message })),
+        call50cTool('idea_fold', { claim: problem, context: `Domain: ${domain}` }).catch(e => ({ error: e.message })),
+        call50cTool('bcalc', { expression: domain === 'math' ? problem : `Model for: ${problem}`, mode: 'explore' }).catch(e => ({ error: e.message }))
+      ]);
+      
+      // Process mind_opener
+      if (mindResult.angles && mindResult.angles.length > 0) {
+        bestAngle = mindResult.angles[0];
+        context = `${problem}\n\nApproach: ${bestAngle}`;
+      }
+      results.stages.push({ name: 'mind_opener', success: !mindResult.error, duration_ms: Date.now() - parallelStart, output_summary: mindResult.angles ? `${mindResult.angles.length} angles` : (mindResult.error || 'Done') });
+      
+      // Process idea_fold
+      if (ideaResult.synthesis) {
+        context = `${context}\n\nSTEM: ${ideaResult.synthesis}`;
+      }
+      results.stages.push({ name: 'idea_fold', success: !ideaResult.error, duration_ms: Date.now() - parallelStart, output_summary: ideaResult.synthesis ? 'STEM synthesis' : (ideaResult.error || 'Done') });
+      
+      // Process bcalc
+      if (bcalcResult.discovery || bcalcResult.result) {
+        mathProof = bcalcResult;
+        results.proofs.push({ type: 'mathematical', data: bcalcResult });
+        context = `${context}\n\nMath: ${JSON.stringify(bcalcResult.discovery || bcalcResult.result).slice(0, 200)}`;
+      }
+      results.stages.push({ name: 'bcalc', success: !bcalcResult.error, duration_ms: Date.now() - parallelStart, output_summary: bcalcResult.discovery ? 'Discovery made' : (bcalcResult.error || 'Done') });
+      
+    } catch (e) {
+      results.stages.push({ name: 'parallel_init', success: false, error: e.message });
+    }
+    
+    // Now run remaining stages sequentially
+    const remainingStages = pipeline.filter(s => !['mind_opener', 'idea_fold', 'bcalc'].includes(s));
+    for (const stage of remainingStages) {
+      const stageStart = Date.now();
+      try {
+        const stageResult = await runStage(stage, { context, problem, domain, constraints, bestAngle, generatedCode, results });
+        if (stageResult.generatedCode) generatedCode = stageResult.generatedCode;
+        if (stageResult.invention) results.invention = stageResult.invention;
+        if (stageResult.verified !== undefined) results.verified = stageResult.verified;
+        if (stageResult.proof) results.proofs.push(stageResult.proof);
+        results.stages.push({ name: stage, success: true, duration_ms: Date.now() - stageStart, output_summary: stageResult.summary });
+      } catch (e) {
+        results.stages.push({ name: stage, success: false, error: e.message, duration_ms: Date.now() - stageStart });
+      }
+    }
+  } else {
+    // For fast/standard, run sequentially
+    for (const stage of pipeline) {
+      const stageStart = Date.now();
+      try {
+        const stageResult = await runStage(stage, { context, problem, domain, constraints, bestAngle, generatedCode, results });
+        if (stageResult.context) context = stageResult.context;
+        if (stageResult.bestAngle) bestAngle = stageResult.bestAngle;
+        if (stageResult.generatedCode) generatedCode = stageResult.generatedCode;
+        if (stageResult.invention) results.invention = stageResult.invention;
+        if (stageResult.verified !== undefined) results.verified = stageResult.verified;
+        if (stageResult.proof) results.proofs.push(stageResult.proof);
+        results.stages.push({ name: stage, success: true, duration_ms: Date.now() - stageStart, output_summary: stageResult.summary });
+      } catch (e) {
+        results.stages.push({ name: stage, success: false, error: e.message, duration_ms: Date.now() - stageStart });
+      }
+    }
+  }
+  
+  results.total_duration_ms = Date.now() - startTime;
+  results.pipeline_completed = results.stages.filter(s => s.success).length;
+  results.pipeline_total = pipeline.length;
+  
+  if (results.invention && results.verified) {
+    results.verdict = 'INVENTION_VERIFIED';
+  } else if (results.invention) {
+    results.verdict = 'INVENTION_UNVERIFIED';
+  } else {
+    results.verdict = 'EXPLORATION_ONLY';
+  }
+  
+  return results;
+}
+
+async function runStage(stage, ctx) {
+  const { context, problem, domain, constraints, bestAngle, generatedCode, results } = ctx;
+  
+  switch (stage) {
+    case 'mind_opener': {
+      const r = await call50cTool('mind_opener', { problem: context });
+      return { 
+        bestAngle: r.angles?.[0],
+        context: r.angles?.[0] ? `${problem}\n\nApproach: ${r.angles[0]}` : context,
+        summary: r.angles ? `${r.angles.length} angles` : 'Done'
+      };
+    }
+    case 'idea_fold': {
+      const r = await call50cTool('idea_fold', { claim: bestAngle || problem, context: `Domain: ${domain}` });
+      return { context: r.synthesis ? `${context}\n\nSTEM: ${r.synthesis}` : context, summary: r.synthesis ? 'STEM synthesis' : 'Done' };
+    }
+    case 'bcalc': {
+      const r = await call50cTool('bcalc', { expression: domain === 'math' ? problem : `Model: ${bestAngle || problem}`, mode: 'explore' });
+      return { proof: r.discovery ? { type: 'mathematical', data: r } : null, summary: r.discovery ? 'Discovery' : 'Done' };
+    }
+    case 'genius_plus': {
+      const prompt = `${context}\n\nConstraints: ${constraints.join(', ')}`;
+      const r = await call50cTool('genius_plus', { problem: prompt });
+      const code = r.code || r.solution;
+      return {
+        generatedCode: code,
+        invention: code ? { code, explanation: r.explanation || r.reasoning, iterations: r.iterations || 1 } : null,
+        summary: code ? `Code (${r.iterations || 1} iter)` : 'Solution generated'
+      };
+    }
+    case 'compute': {
+      if (!generatedCode) return { summary: 'Skipped: no code' };
+      const r = await call50cTool('compute', { code: generatedCode });
+      return { 
+        proof: { type: 'execution', data: r },
+        summary: r.error ? `Error: ${r.error}` : 'Executed'
+      };
+    }
+    case 'cvi_verify': {
+      if (constraints.length === 0) return { verified: true, summary: 'No constraints' };
+      if (!results.invention) return { verified: false, summary: 'No invention' };
+      const r = await call50cTool('cvi_verify', { constraints, output: JSON.stringify(results.invention) });
+      return {
+        verified: r.passed || r.all_passed || false,
+        proof: { type: 'constraint_verification', data: r },
+        summary: r.passed ? 'Verified' : 'Unverified'
+      };
+    }
+    default:
+      return { summary: 'Unknown stage' };
+  }
+}
+
 async function handleLocalTools(request) {
   const { id, method, params } = request;
   
@@ -830,6 +1015,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 +1190,6 @@ function installMCP() {
     'playwright': {
       command: 'npx',
       args: ['-y', '@playwright/mcp@latest']
-    },
-    'filesystem': {
-      command: 'npx',
-      args: ['-y', '@modelcontextprotocol/server-filesystem@latest', home]
     }
   };
   
@@ -1046,7 +1237,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.1",
   "description": "AI developer tools via MCP. Pay-per-use from $0.01. No subscriptions.",
   "bin": {
     "50c": "./bin/50c.js"