50c 3.0.13 → 3.1.0

package/bin/50c.js

@@ -600,8 +600,30 @@ function startMCPMode() {
       const clean = line.trim();
       if (!clean) return;
       const request = JSON.parse(clean);
+      
+      // Notifications (no id) don't get responses per JSON-RPC spec
+      if (request.method && request.method.startsWith('notifications/')) {
+        return;
+      }
+      
+      // Handle initialize locally
+      if (request.method === 'initialize') {
+        process.stdout.write(JSON.stringify({
+          jsonrpc: '2.0',
+          id: request.id,
+          result: {
+            protocolVersion: '2024-11-05',
+            serverInfo: { name: '50c', version: VERSION },
+            capabilities: { tools: {} }
+          }
+        }) + '\n');
+        return;
+      }
+      
       const response = await handleMCPRequest(request);
-      process.stdout.write(JSON.stringify(response) + '\n');
+      if (response) {
+        process.stdout.write(JSON.stringify(response) + '\n');
+      }
     } catch (e) {
       process.stdout.write(JSON.stringify({
         jsonrpc: '2.0',
@@ -648,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;
   
@@ -808,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
@@ -973,10 +1198,6 @@ function installMCP() {
     'playwright': {
       command: 'npx',
       args: ['-y', '@playwright/mcp@latest']
-    },
-    'filesystem': {
-      command: 'npx',
-      args: ['-y', '@modelcontextprotocol/server-filesystem@latest', home]
     }
   };
   
@@ -1024,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/lib/subagent.js

@@ -74,6 +74,7 @@ async function httpFetch(url, options = {}) {
 
 /**
  * SSH execution via native ssh command (spawned, not shell)
+ * Fixed: Uses explicit identity file for Windows compatibility
  */
 async function sshExec(server, command, options = {}) {
   const serverConfig = typeof server === 'string' ? KNOWN_SERVERS[server] : server;
@@ -84,12 +85,32 @@ async function sshExec(server, command, options = {}) {
 
   const { host, user = 'root', port = 22 } = serverConfig;
   const timeout = options.timeout || 30000;
+  
+  // Try to find SSH key - common locations
+  const os = require('os');
+  const homeDir = os.homedir();
+  const keyPaths = [
+    path.join(homeDir, '.ssh', 'id_rsa'),
+    path.join(homeDir, '.ssh', 'id_ed25519'),
+    options.keyFile
+  ].filter(Boolean);
+  
+  let identityArgs = [];
+  for (const keyPath of keyPaths) {
+    if (fs.existsSync(keyPath)) {
+      identityArgs = ['-i', keyPath];
+      break;
+    }
+  }
 
   return new Promise((resolve, reject) => {
     const args = [
       '-o', 'StrictHostKeyChecking=no',
+      '-o', 'UserKnownHostsFile=/dev/null',
       '-o', 'ConnectTimeout=10',
-      '-o', 'BatchMode=yes',
+      '-o', 'ServerAliveInterval=5',
+      '-o', 'ServerAliveCountMax=2',
+      ...identityArgs,
       '-p', String(port),
       `${user}@${host}`,
       command
@@ -97,7 +118,8 @@ async function sshExec(server, command, options = {}) {
 
     const proc = spawn('ssh', args, {
       stdio: ['pipe', 'pipe', 'pipe'],
-      timeout
+      timeout,
+      windowsHide: true
     });
 
     let stdout = '';

package/package.json

@@ -1,39 +1,39 @@
-{
-  "name": "50c",
-  "version": "3.0.13",
-  "description": "AI developer tools via MCP. Pay-per-use from $0.01. No subscriptions.",
-  "bin": {
-    "50c": "./bin/50c.js"
-  },
-  "scripts": {
-    "postinstall": "node -e \"console.log('\\n50c Hub installed. Run: 50c install\\n')\""
-  },
-  "keywords": [
-    "mcp",
-    "ai",
-    "llm",
-    "cli",
-    "agent",
-    "50c",
-    "hints",
-    "genius",
-    "beacon",
-    "developer-tools",
-    "context",
-    "compression",
-    "caz",
-    "file-memory"
-  ],
-  "author": "genxis",
-  "license": "SEE LICENSE IN LICENSE",
-  "homepage": "https://50c.ai",
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "files": [
-    "bin/",
-    "lib/",
-    "README.md",
-    "LICENSE"
-  ]
-}
+{
+  "name": "50c",
+  "version": "3.1.0",
+  "description": "AI developer tools via MCP. Pay-per-use from $0.01. No subscriptions.",
+  "bin": {
+    "50c": "./bin/50c.js"
+  },
+  "scripts": {
+    "postinstall": "node -e \"console.log('\\n50c Hub installed. Run: 50c install\\n')\""
+  },
+  "keywords": [
+    "mcp",
+    "ai",
+    "llm",
+    "cli",
+    "agent",
+    "50c",
+    "hints",
+    "genius",
+    "beacon",
+    "developer-tools",
+    "context",
+    "compression",
+    "caz",
+    "file-memory"
+  ],
+  "author": "genxis",
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://50c.ai",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md",
+    "LICENSE"
+  ]
+}