agent-clinch 0.7.5 → 0.7.6

package/cli.js

@@ -10,6 +10,7 @@ const path = require('path');
 const os = require('os');
 const readline = require('readline');
 const crypto = require('crypto');
+const https = require('https');
 
 const CONFIG_DIR  = path.join(os.homedir(), '.clinch');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
@@ -44,7 +45,7 @@ function decrypt(encJson) {
     decrypted += decipher.final('utf8');
     return decrypted;
   } catch (e) {
-    return null; // Decryption failed (file moved to different machine or tampered)
+    return null;
   }
 }
 
@@ -102,14 +103,14 @@ function saveSessionState(sessionId, core) {
     };
     fs.writeFileSync(SESSIONS_FILE, JSON.stringify(sessions, null, 2));
   } catch (e) {
-    // Session might be deleted or errored, ignore gracefully in CLI
+    // Ignore gracefully
   }
 }
 
 function requireConfig() {
   const cfg = loadConfig();
   if (!cfg) {
-    console.error('Not initialized. Run: clinch init');
+    console.error(c.red('Not initialized. Run: clinch init'));
     process.exit(1);
   }
   return cfg;
@@ -119,25 +120,23 @@ function getClinchCore(cfg) {
   let ClinchCoreModule;
   try { ClinchCoreModule = require('clinch-core'); }
   catch {
-    console.error('clinch-core not found. Ensure it is linked or installed.');
+    console.error(c.red('clinch-core not found. Ensure it is linked or installed.'));
     process.exit(1);
   }
   const { ClinchCore } = ClinchCoreModule;
   const core = new ClinchCore({ registryUrl: cfg.registryUrl });
 
-  // Dynamically hydrate ClinchCore memory with locally stored API keys
   const secrets = loadSecrets();
   for (const [domain, s] of Object.entries(secrets)) {
     core.registerSecret(domain, s.key, s.name);
   }
 
   core.on('log', msg => console.log(msg));
-  core.on('error', err => console.error('Error:', err.message));
+  core.on('error', err => console.error(c.red('Error:'), err.message));
 
   return core;
 }
 
-// ── Prompt Helper ─────────────────────────────────────────────
 function prompt(question) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise(resolve => {
@@ -145,27 +144,120 @@ function prompt(question) {
   });
 }
 
-// ── Conversational AI Intent Parser (CLI Layer) ───────────────
-async function parseIntentWithLLM(userInput, modelPath) {
-  console.log(c.dim("\n[Agent Q] Booting local parser model to analyze your request..."));
-  let nodeLlama;
-  try { nodeLlama = await import('node-llama-cpp'); }
-  catch (e) {
-    console.error(c.red("\nError: node-llama-cpp is required for conversational parsing."));
-    console.error("Please run: npm install -g node-llama-cpp\n");
-    process.exit(1);
+// ── AI Engine Orchestration (Ollama vs GGUF) ──────────────────
+async function ensureAIEngine(cfg) {
+  if (cfg.engine) return cfg;
+
+  console.log(c.bold("\n🤖 Local AI Engine Setup"));
+  console.log(c.dim("Agent Q requires a local AI to parse intents and auto-negotiate."));
+  
+  const choice = await prompt("Which engine would you like to use?\n  1) Ollama (Recommended - Requires Ollama running locally)\n  2) Standalone GGUF (Downloads ~1.1GB model)\n👉 (1/2): ");
+
+  if (choice === '1') {
+    cfg.engine = 'ollama';
+    const model = await prompt("👉 Enter Ollama model name (default: llama3): ");
+    cfg.ollamaModel = model || 'llama3';
+  } else {
+    cfg.engine = 'gguf';
+    const dl = await prompt("👉 Download default Qwen 1.5B model? (Y/n): ");
+    if (dl.toLowerCase() !== 'n') {
+       cfg.ggufUrl = "https://huggingface.co/Qwen/Qwen2.5-1.5B-Instruct-GGUF/resolve/main/qwen2.5-1.5b-instruct-q4_k_m.gguf";
+    } else {
+       cfg.ggufUrl = await prompt("👉 Enter custom GGUF download URL: ");
+    }
   }
+  
+  saveConfig(cfg);
+  return cfg;
+}
 
-  const resolvedPath = path.resolve(modelPath);
-  if (!fs.existsSync(resolvedPath)) {
-    console.error(c.red(`\nError: Model not found at ${resolvedPath}`));
-    process.exit(1);
-  }
+function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+    const request = (currentUrl) => {
+      https.get(currentUrl, (response) => {
+        if ([301, 302, 303, 307, 308].includes(response.statusCode)) {
+          return request(response.headers.location);
+        }
+        if (response.statusCode !== 200) {
+          return reject(new Error(`Download failed: ${response.statusCode}`));
+        }
+        const total = parseInt(response.headers['content-length'], 10);
+        let downloaded = 0;
+        response.on('data', (chunk) => {
+          downloaded += chunk.length;
+          const msg = total ? `${((downloaded / total) * 100).toFixed(1)}%` : `${(downloaded / 1024 / 1024).toFixed(1)} MB`;
+          process.stdout.write(`\r${c.yellow('Downloading model...')} ${msg}`);
+        });
+        response.pipe(file);
+        file.on('finish', () => {
+          console.log(c.green("\n✓ Download complete!"));
+          file.close(resolve);
+        });
+      }).on('error', (err) => {
+        fs.unlink(dest, () => reject(err));
+      });
+    };
+    request(url);
+  });
+}
+
+async function promptAI(systemPrompt, userText, cfg) {
+  if (cfg.engine === 'ollama') {
+    try {
+      const res = await fetch('http://127.0.0.1:11434/api/chat', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          model: cfg.ollamaModel || 'llama3',
+          messages: [
+            { role: 'system', content: systemPrompt },
+            { role: 'user', content: userText }
+          ],
+          stream: false
+        })
+      });
+      if (!res.ok) throw new Error(`Ollama returned status ${res.status}`);
+      const data = await res.json();
+      return data.message.content;
+    } catch (e) {
+      console.error(c.red(`\n[!] Ollama request failed: ${e.message}`));
+      console.error(c.dim(`Please ensure Ollama is running (http://127.0.0.1:11434) and the model is pulled.`));
+      process.exit(1);
+    }
+  } else {
+    // GGUF Execution
+    const resolvedPath = path.resolve(cfg.modelPath || path.join(CONFIG_DIR, 'model.gguf'));
+    if (!fs.existsSync(resolvedPath)) {
+      console.log(c.yellow(`\nModel not found at ${resolvedPath}`));
+      await downloadFile(cfg.ggufUrl || "https://huggingface.co/Qwen/Qwen2.5-1.5B-Instruct-GGUF/resolve/main/qwen2.5-1.5b-instruct-q4_k_m.gguf", resolvedPath);
+    }
+
+    let nodeLlama;
+    try { nodeLlama = await import('node-llama-cpp'); }
+    catch (e) {
+      console.error(c.red("\nError: 'node-llama-cpp' is required for GGUF execution."));
+      console.error("Run: npm install -g node-llama-cpp");
+      process.exit(1);
+    }
 
-  const llama = await nodeLlama.getLlama();
-  const model = await llama.loadModel({ modelPath: resolvedPath });
-  const context = await model.createContext({ contextSize: 2048, threads: Math.max(1, os.cpus().length - 1) });
+    const llama = await nodeLlama.getLlama();
+    const model = await llama.loadModel({ modelPath: resolvedPath });
+    const context = await model.createContext({ contextSize: 2048, threads: Math.max(1, os.cpus().length - 1) });
+    const session = new nodeLlama.LlamaChatSession({
+      contextSequence: context.getSequence(),
+      systemPrompt: systemPrompt,
+      chatWrapper: new nodeLlama.ChatMLChatWrapper()
+    });
+
+    let responseText = "";
+    await session.prompt(userText, { maxTokens: 1500, onTextChunk: (chunk) => { responseText += chunk; } });
+    return responseText;
+  }
+}
 
+async function parseIntentWithLLM(userInput, cfg) {
+  console.log(c.dim(`\n[Agent Q] Booting local parser (${cfg.engine}) to analyze your request...`));
   const systemPrompt = `You are a structured data extractor. Convert the user's conversational intent into a strict JSON schema.
 Your response MUST be ONLY valid JSON matching this schema exactly. Do not output conversational text.
 
@@ -174,21 +266,12 @@ JSON Schema:
   "intent": "purchase",
   "category": "string (e.g. domain_name, electronics, kitchen_appliance)",
   "item": "string (the exact item, website, or product they want)",
-  "max_budget": number (extract budget numeric value),
-  "must_haves": ["array", "of", "strings", "representing", "conditions", "like", "WHOIS privacy", "warranty"]
+  "max_budget": number (extract budget numeric value)
 }`;
 
-  const session = new nodeLlama.LlamaChatSession({
-    contextSequence: context.getSequence(),
-    systemPrompt: systemPrompt,
-    chatWrapper: new nodeLlama.ChatMLChatWrapper()
-  });
-
-  let responseText = "";
-  await session.prompt(userInput, { maxTokens: 1500, onTextChunk: (chunk) => { responseText += chunk; } });
-
   try {
-    const cleanJson = responseText.replace(/```json|```/g, "").trim();
+    const rawRes = await promptAI(systemPrompt, userInput, cfg);
+    const cleanJson = rawRes.replace(/```json|```/g, "").trim();
     return JSON.parse(cleanJson);
   } catch (e) {
     console.error(c.red("Failed to parse intent. Falling back to manual entry."));
@@ -226,34 +309,29 @@ program
   .command('init')
   .description('Initialize your Clinch buyer agent')
   .option('--registry <url>', 'Custom registry URL')
-  .option('--model <path>', 'Path to custom GGUF model')
   .action(async (opts) => {
     banner();
     console.log(c.bold('Setting up your Clinch agent...\n'));
 
-    const existing = loadConfig();
-    if (existing) {
-      const overwrite = await prompt('Config already exists. Overwrite? (y/N): ');
+    let config = loadConfig() || {};
+    if (config.pubKey) {
+      const overwrite = await prompt('Config already exists. Overwrite network identity? (y/N): ');
       if (overwrite.toLowerCase() !== 'y') { console.log('Aborted.'); process.exit(0); }
     }
 
-    const registryUrl = opts.registry || 'https://everydaytok-agentq-core-logics.hf.space';
-    const modelPath   = opts.model || path.join(CONFIG_DIR, 'model.gguf');
+    config.registryUrl = opts.registry || 'https://everydaytok-agentq-core-logics.hf.space';
+    config.modelPath = path.join(CONFIG_DIR, 'model.gguf');
+    config = await ensureAIEngine(config);
 
-    console.log(c.yellow('Connecting to registry and completing PoW handshake...'));
+    console.log(c.yellow('\nConnecting to registry and completing PoW handshake...'));
 
-    const core = getClinchCore({ registryUrl });
+    const core = getClinchCore(config);
     await core.initialize();
 
-    const config = {
-      registryUrl,
-      modelPath,
-      pubKey:  core.identityPubKey,
-      token:   core.jwtToken,
-      mode:    'ANP/A',
-      localOnly: false,
-      createdAt: new Date().toISOString()
-    };
+    config.pubKey = core.identityPubKey;
+    config.token = core.jwtToken;
+    config.mode = 'ANP/A';
+    config.createdAt = new Date().toISOString();
 
     saveConfig(config);
     core.disconnect();
@@ -306,12 +384,12 @@ program
   .argument('[address]', 'ANP address — format: MODE.domain.anp (e.g. ANP/C.amazon.anp)')
   .option('--budget <n>', 'Max budget (USD)')
   .option('--item <name>', 'Specific item to negotiate')
-  .option('--category <name>', 'Market category (Triggers cascade negotiation across matching sellers if address is omitted)')
-  .option('--squeeze <n>', 'Number of sellers to sequentially squeeze (Low urgency / price optimization)', '3')
-  .option('--parallel <n>', 'Number of sellers to negotiate with simultaneously in parallel (High urgency / ride-hailing)')
-  .option('--auto', 'Run sandbox auto-negotiation')
+  .option('--category <name>', 'Market category (Triggers cascade negotiation across matching sellers)')
+  .option('--squeeze <n>', 'Number of sellers to sequentially squeeze', '3')
+  .option('--parallel <n>', 'Number of sellers to negotiate with simultaneously')
+  .option('--auto', 'Run CLI-driven LLM auto-negotiation')
   .action(async (address, opts) => {
-    const cfg = requireConfig();
+    let cfg = requireConfig();
     let targetAddress = address;
     let budget = opts.budget;
     let constraints = {};
@@ -321,12 +399,14 @@ program
       banner();
       console.log(c.bold("💬 Clinch Onboarding Wizard — Tell me what you're looking for.\n"));
 
+      cfg = await ensureAIEngine(cfg);
+
       const naturalIntent = await prompt("👉 Describe what you want to negotiate\n" +
         c.dim("   (e.g., 'Get me the domain cartpost.shop under 80 dollars')\n\n💬: "));
 
       if (!naturalIntent) process.exit(1);
 
-      const parsed = await parseIntentWithLLM(naturalIntent, cfg.modelPath);
+      const parsed = await parseIntentWithLLM(naturalIntent, cfg);
       if (!parsed) {
         console.error(c.red("✗ Error parsing constraints. Please try manual entry."));
         process.exit(1);
@@ -360,11 +440,7 @@ program
         targetAddress = `ANP/C.${sellers[parseInt(selection) - 1].agent_id}`;
       }
     } else {
-      constraints = {
-        intent: 'purchase',
-        item: opts.item || 'Item',
-        max_budget: parseFloat(budget || 100)
-      };
+      constraints = { intent: 'purchase', item: opts.item || 'Item', max_budget: parseFloat(budget || 100) };
       if (opts.category) constraints.category = opts.category;
     }
 
@@ -374,9 +450,68 @@ program
       runAuto = autoInput.toLowerCase() !== 'n';
     }
 
+    if (runAuto) {
+      cfg = await ensureAIEngine(cfg);
+    }
+
     const core = getClinchCore(cfg);
 
-    // ── CASCADING ITERATIVE CASCADE TRIGGER (Sequential Squeeze vs. Parallel Concurrency) ──
+    // ── CLI AUTO-NEGOTIATION HOOK ──
+    if (runAuto) {
+      console.log(c.yellow(`\n🤖 Auto-mode initialized. Routing inference through: ${c.bold(cfg.engine)}`));
+      
+      core.on('callback_received', async ({ sessionId, payload }) => {
+        const session = core.getSession(sessionId);
+        if (!session) return;
+        session.currentTurn++;
+
+        const incomingMessage = payload.message || JSON.stringify(payload);
+        
+        // Extract basic price to check constraints
+        const priceMatch = incomingMessage.match(/price\s*:\s*\$?(\d+(?:\.\d{2})?)/i);
+        if (priceMatch) session.lastKnownPrice = parseFloat(priceMatch[1]);
+
+        if (session.lastKnownPrice > 0 && session.lastKnownPrice <= session.constraints.max_budget) {
+            console.log(c.green(`\n🎉 [Agent Q] Seller met budget conditions! Securing deal.`));
+            await core.sendCounter(sessionId, session.lastKnownPrice, "I accept this offer.");
+            return;
+        }
+
+        if (session.currentTurn > 6) {
+             console.log(c.red(`\n🛑 [Agent Q] Max turns reached. Exiting.`));
+             await core.exitSession(sessionId);
+             return;
+        }
+
+        // Ask the core to build the context prompt, but evaluate it HERE in the CLI
+        const promptStr = core.buildAgentPrompt(sessionId, incomingMessage);
+        console.log(c.dim(`\n[Agent Q] Evaluating turn ${session.currentTurn} with ${cfg.engine}...`));
+        
+        const aiResponse = await promptAI(promptStr, incomingMessage, cfg);
+        
+        let price = null;
+        let msg = "Counter offer";
+        
+        try {
+            const clean = aiResponse.replace(/```json|```/g, "").trim();
+            const parsed = JSON.parse(clean);
+            if (parsed.price) price = parsed.price;
+            if (parsed.message) msg = parsed.message;
+        } catch(e) {
+            const fallback = aiResponse.match(/"price"\s*:\s*(\d+(?:\.\d{2})?)/i);
+            if (fallback) price = parseFloat(fallback[1]);
+        }
+
+        if (price) {
+            await core.sendCounter(sessionId, Math.min(price, session.constraints.max_budget), msg);
+        } else {
+            console.log(c.yellow(`[Agent Q] Failed to parse price constraint. Sending safe fallback.`));
+            await core.sendCounter(sessionId, session.lastKnownPrice * 0.9, "Can you do slightly better?");
+        }
+      });
+    }
+
+    // ── CASCADING ITERATIVE CASCADE TRIGGER ──
     if (!targetAddress && opts.category) {
         let maxSellers = 3;
         let strategy = 'sequential';
@@ -391,12 +526,7 @@ program
             console.log(c.yellow(`🤖 Squeeze Mode: Sequentially bargaining across top ${maxSellers} sellers for "${opts.category}"...\n`));
         }
 
-        if (runAuto) {
-            await core.sandbox({ modelPath: cfg.modelPath });
-        } else {
-            await core.initialize(cfg.token);
-        }
-
+        await core.initialize(cfg.token);
         const bestDeal = await core.negotiateCascade(opts.category, constraints, maxSellers, strategy);
 
         if (bestDeal) {
@@ -415,19 +545,20 @@ program
         process.exit(1);
     }
 
-    if (runAuto) {
-      console.log(c.yellow('🤖 Auto-mode: Local LLM sandbox active.\n'));
-      await core.sandbox({ modelPath: cfg.modelPath });
-    } else {
-      await core.initialize(cfg.token);
-    }
+    await core.initialize(cfg.token);
 
     core.on('session_started', ({ sessionId }) => {
       console.log(c.green(`\n✓ Session started: ${c.bold(sessionId)}`));
       saveSessionState(sessionId, core);
     });
 
-    core.on('callback_received', ({ sessionId }) => saveSessionState(sessionId, core));
+    if (!runAuto) {
+        core.on('callback_received', ({ sessionId, payload }) => {
+            saveSessionState(sessionId, core);
+            console.log(c.cyan(`\n💬 Seller says:`), payload);
+            console.log(c.dim(`\nType a price to counter, or "exit" / "accept":`));
+        });
+    }
 
     core.on('session_closed', ({ sessionId, outcome, finalPrice }) => {
       saveSessionState(sessionId, core);
@@ -447,7 +578,7 @@ program
     const sessionId = await core.negotiate(targetAddress, constraints);
 
     if (!runAuto) {
-      console.log(c.bold('\nManual mode — type a price to counter, or "exit" / "accept":\n'));
+      console.log(c.bold('\nManual mode — await seller response, then type a price to counter, or "exit" / "accept".\n'));
       const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
       rl.on('line', async (cmd) => {
         if (cmd === 'exit') {
@@ -455,7 +586,7 @@ program
           saveSessionState(sessionId, core);
           process.exit(0);
         }
-        else if (cmd === 'accept') { console.log(c.green(`Accepting...`)); rl.close(); }
+        else if (cmd === 'accept') { console.log(c.green(`Accepting...`)); }
         else {
           const price = parseFloat(cmd);
           if (!isNaN(price)) {
@@ -493,7 +624,7 @@ program
   .argument('<sessionId>', 'The session ID to resume')
   .option('--auto', 'Resume with auto-negotiation')
   .action(async (sessionId, opts) => {
-    const cfg = requireConfig();
+    let cfg = requireConfig();
     const sessions = loadSessions();
 
     if (!sessions[sessionId]) {
@@ -502,13 +633,13 @@ program
     }
 
     console.log(c.yellow(`\nRehydrating Session ${c.bold(sessionId)}...\n`));
-    const core = getClinchCore(cfg);
-
     if (opts.auto) {
-        await core.sandbox({ modelPath: cfg.modelPath });
-    } else {
-        await core.initialize(cfg.token);
-    }
+        cfg = await ensureAIEngine(cfg);
+        // ... hook auto logic here if needed (omitted for brevity, handled heavily in negotiate)
+    } 
+
+    const core = getClinchCore(cfg);
+    await core.initialize(cfg.token);
 
     core.importSessionState(sessions[sessionId].state);
 
@@ -532,6 +663,7 @@ program
   .option('--set', 'Interactively save a new API key credential')
   .option('--list', 'List domains with registered local credentials')
   .option('--remove <domain>', 'Delete a credential from your local vault')
+  .option('--show', 'Display the raw API keys when listing')
   .action(async (opts) => {
     const cfg = requireConfig();
     const secrets = loadSecrets();
@@ -556,9 +688,13 @@ program
       }
       console.log(c.bold('\n🔑 Registered Blind Key Credentials:\n'));
       entries.forEach(([domain, s]) => {
-        console.log(`  - ${c.cyan(domain)} (${c.dim(s.name || 'unnamed')})`);
+        if (opts.show) {
+            console.log(`  - ${c.cyan(domain)} (${c.dim(s.name || 'unnamed')}) -> ${c.yellow(s.key)}`);
+        } else {
+            console.log(`  - ${c.cyan(domain)} (${c.dim(s.name || 'unnamed')}) -> ${c.dim('••••••••••••')}`);
+        }
       });
-      console.log('');
+      console.log(c.dim(opts.show ? '' : '\n(Run with --show to view raw keys)'));
       process.exit(0);
     }
 

package/package.json

@@ -6,7 +6,7 @@
 
 
   "name": "agent-clinch",
-  "version": "0.7.5",
+  "version": "0.7.6",
   "description": "Clinch Protocol CLI — agent negotiation from your terminal",
   "main": "cli.js",
   "bin": {