openzoo 0.50.76 → 0.50.77

package/bin/openzoo.js

@@ -284,6 +284,9 @@ async function main() {
         ? process.argv[ei + 1].split(',').map((e) => (e.startsWith('.') ? e : `.${e}`))
         : undefined;
       const mb = (n) => (n / 1048576).toFixed(1);
+      // Delta uploads are routinely a few KB against a multi-MB corpus; "0.0MB
+      // of 3.2MB" reads as a bug. Pick the unit per number.
+      const hb = (n) => (n >= 1048576 ? `${(n / 1048576).toFixed(1)}MB` : n >= 1024 ? `${(n / 1024).toFixed(0)}KB` : `${n}B`);
       const out = await bindPath(target, {
         exts,
         force: process.argv.includes('--force'),
@@ -291,9 +294,23 @@ async function main() {
           if (p.stage === 'reused') console.log(`already bound — ${mb(p.bytes)}MB across ${p.files} file(s) reused, nothing uploaded`);
           if (p.stage === 'start') console.log(`binding ${mb(p.bytes)}MB from ${p.files} file(s) in ${p.parts} part(s)...`);
           if (p.stage === 'part') console.log(`  part ${p.index}/${p.of} bound (${mb(p.bytes)}MB)`);
+          // DELTA: the server already holds most of a re-bound repo, so say
+          // how much is actually crossing the wire — that number is the reason
+          // re-binding after an edit is cheap, and hiding it makes the feature
+          // look like a no-op.
+          if (p.stage === 'delta') {
+            console.log(p.missing === 0
+              ? `delta: server already holds all ${p.chunks} chunk(s) of ${hb(p.bytes)} — nothing to upload`
+              : `delta: ${p.missing} of ${p.chunks} chunk(s) missing on the server, uploading only those...`);
+          }
+          if (p.stage === 'delta-fill') console.log(`  shipped ${hb(p.shipped)} of ${hb(p.of)}${p.remaining ? ` (${p.remaining} still missing)` : ''}`);
         },
       });
       console.log('');
+      if (out.delta) {
+        const pct = out.bytes ? ((100 * out.shipped) / out.bytes).toFixed(1) : '0.0';
+        console.log(`bound via delta — uploaded ${hb(out.shipped)} of ${hb(out.bytes)} (${pct}%)`);
+      }
       console.log(`context: ${out.contextId}`);
       console.log(`ask it:  npx openzoo ask "your question" --context ${out.contextId}`);
       console.log('or send X-HRR-Context: <id> with a small body to /v1/chat/completions');

package/lib/bindpath.js

@@ -144,14 +144,17 @@ export function splitIntoParts(text, maxBytes = MAX_PART_BYTES) {
  */
 const sha256 = (t) => createHash('sha256').update(t, 'utf8').digest('hex');
 
+const ddbg = (...a) => { if (process.env.OPENZOO_BIND_DEBUG) console.error('[delta]', ...a); };
+
 async function postDelta(payload) {
   const r = await fetch(`${config.apiBase}/v1/hrr/delta`, {
     method: 'POST',
     headers: withNamespace({ 'content-type': 'application/json' }),
     body: JSON.stringify(payload),
   });
-  if (r.status !== 200) return null;
+  if (r.status !== 200) { ddbg('HTTP', r.status, (await r.text().catch(() => '')).slice(0, 200)); return null; }
   const j = await r.json().catch(() => null);
+  if (!(j && Array.isArray(j.missing))) ddbg('bad shape', JSON.stringify(j).slice(0, 200));
   return j && Array.isArray(j.missing) ? j : null;
 }
 
@@ -175,19 +178,19 @@ async function bindDelta(fileTexts, shardKey, onProgress) {
     let size = 0;
     for (const h of missing) {
       const t = byHash.get(h);
-      if (t === undefined) return null;
+      if (t === undefined) { ddbg('missing hash not in byHash', h); return null; }
       if (size && size + Buffer.byteLength(t) > MAX_PART_BYTES) break;
       batch[h] = t; size += Buffer.byteLength(t);
     }
-    if (!Object.keys(batch).length) return null;
+    if (!Object.keys(batch).length) { ddbg('empty batch'); return null; }
     last = await postDelta({ chunk_hashes: hashes, chunks: batch, shard_key: shardKey });
     if (!last) return null;
     shipped += size;
     onProgress?.({ stage: 'delta-fill', shipped, of: total, remaining: last.missing.length });
-    if (last.missing.length >= missing.length) return null;   // no progress: refused chunks
+    if (last.missing.length >= missing.length) { ddbg('no progress', last.missing.length, missing.length, JSON.stringify(last.refused)); return null; }   // no progress: refused chunks
     missing = last.missing;
   }
-  if (!last.complete || !last.context_id) return null;
+  if (!last.complete || !last.context_id) { ddbg('incomplete', JSON.stringify(last).slice(0, 200)); return null; }
   return { contextId: last.context_id, chunks: chunks.length, shipped, bytes: total };
 }
 
@@ -259,7 +262,7 @@ export async function bindPath(target, { exts, onProgress, force = false } = {})
         rememberContext(config.apiBase, hash, d.contextId);
         return { contextId: d.contextId, files, parts: d.chunks, bytes, reused: false, delta: true, shipped: d.shipped };
       }
-    } catch { /* fall through to the whole bind */ }
+    } catch (e) { ddbg('threw', e?.message); /* fall through to the whole bind */ }
   }
 
   const parts = splitIntoParts(text);

package/lib/mcp.js

@@ -413,6 +413,10 @@ export function buildMcpServer() {
         files: out.files.length,
         parts: out.parts,
         reused: out.reused,
+        // A delta bind uploaded only the chunks the server lacked. `uploaded_bytes`
+        // against `bound_bytes` is the saving; an agent re-binding a repo after
+        // one edit should see a small number here, not the whole tree.
+        ...(out.delta ? { delta: true, uploaded_bytes: out.shipped } : {}),
         next: `zoo_ask with context_id="${out.contextId}" and a question answers from this corpus; it is already bound, so pasting it into the prompt would send it twice.`,
       });
     } catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.50.76",
+  "version": "0.50.77",
   "description": "Local x402-paying proxy + MCP server for openzoo.fun — point any OpenAI-compatible harness (Cursor, Claude Code, aider, SDKs) at localhost and it pays per call from a local burner wallet. Solana and Base rails live; Robinhood experimental.",
   "license": "MIT",
   "type": "module",