offhands 0.1.15 → 0.1.16

package/dist/daemon.mjs

@@ -6831,6 +6831,12 @@ function extractTerms(prompt, maxTerms = 8) {
   }
   return deduped.slice().sort((a2, b2) => b2.length - a2.length).slice(0, maxTerms);
 }
+var JUNK_EXTS = [".stackdump", ".log", ".tmp", ".bak", ".orig", ".rej", ".swp", ".png", ".jpg", ".jpeg", ".gif", ".webp", ".mp4", ".mov", ".zip", ".tgz"];
+var JUNK_BASENAMES = /* @__PURE__ */ new Set([".ds_store", "thumbs.db"]);
+function isJunk(path) {
+  const base = (path.split(/[\\/]/).pop() ?? "").toLowerCase();
+  return JUNK_BASENAMES.has(base) || base.endsWith("~") || JUNK_EXTS.some((e) => base.endsWith(e));
+}
 var SECRET_BASENAMES = /* @__PURE__ */ new Set([".npmrc", ".netrc", "id_rsa", "id_dsa", "id_ecdsa", "id_ed25519", "credentials.json", "secrets.json"]);
 var SECRET_EXTS = [".pem", ".key", ".p12", ".pfx", ".keystore", ".jks", ".env"];
 var ENV_TEMPLATE_SUFFIXES = [".example", ".sample", ".template", ".dist"];
@@ -6842,16 +6848,16 @@ function isSecretLike(path) {
 }
 function parsePorcelainZ(out) {
   const parts = out.split("\0");
-  const paths = [];
+  const entries = [];
   for (let i2 = 0; i2 < parts.length; i2++) {
     const p2 = parts[i2];
     if (p2.length < 4) continue;
     const x2 = p2[0];
     const y2 = p2[1];
     if (x2 === "R" || x2 === "C" || y2 === "R" || y2 === "C") i2++;
-    paths.push(p2.slice(3));
+    entries.push({ path: p2.slice(3), untracked: x2 === "?" && y2 === "?" });
   }
-  return paths;
+  return entries;
 }
 function isDirectory(abs) {
   try {
@@ -6876,15 +6882,20 @@ function stem(word) {
 function pathWords(path) {
   const split = (s2) => s2.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter(Boolean).map(stem);
   const slash = path.lastIndexOf("/");
-  const base = new Set(split(path.slice(slash + 1)));
+  const file = path.slice(slash + 1);
+  const base = new Set(split(file));
   const all = /* @__PURE__ */ new Set([...split(path.slice(0, Math.max(slash, 0))), ...base]);
-  return { all, base };
+  const nameWords = split(file.replace(/\.[^.]+$/, ""));
+  return { all, base, last: nameWords[nameWords.length - 1] ?? "" };
 }
 var NOISE_FILES = /* @__PURE__ */ new Set(["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock", "composer.lock", "cargo.lock", "poetry.lock"]);
 var isNoise = (p2) => NOISE_FILES.has((p2.split("/").pop() ?? "").toLowerCase());
 var MAX_MATCHED_SHOWN = 14;
 var MAX_CONTENT_PROBES = 10;
 var MAX_CONTENT_MATCHES = 6;
+var COVERAGE_BONUS = 0.3;
+var ROLE_WORD_FACTOR = 0.4;
+var MIN_SOLID_TO_DROP_WEAK = 5;
 var MAX_UNMATCHED_WITH_MATCHES = 3;
 var MAX_NAME_MATCHES = 10;
 var MAX_DIRTY_ONLY = 8;
@@ -6915,14 +6926,23 @@ async function buildContext(workspace, prompt, opts = {}) {
   const { findings, retrievalOpsRun, ripgrepAvailable, gitState } = result;
   if (findings.length === 0) return null;
   const rank = (f2) => f2.matchScore > 0 ? f2.dirty ? 5 : 4 : f2.dirty ? 2 : 1;
-  findings.sort((a2, b2) => rank(b2) - rank(a2) || b2.matchScore - a2.matchScore);
+  const strength = (f2) => f2.matchScore * (1 + COVERAGE_BONUS * Math.max(f2.terms.size - 1, 0));
+  findings.sort((a2, b2) => rank(b2) - rank(a2) || strength(b2) - strength(a2));
   const strongMatches = findings.filter((f2) => f2.matchScore > 0).length;
   const unmatchedCap = strongMatches >= 3 ? MAX_UNMATCHED_WITH_MATCHES : Infinity;
+  const solidCount = findings.filter((f2) => f2.solid > 0).length;
+  const droppingWeak = solidCount >= MIN_SOLID_TO_DROP_WEAK;
+  const droppingUntracked = strongMatches >= 3;
   let unmatched = 0;
   let matchedShown = 0;
-  const shown = findings.filter(
-    (f2) => f2.matchScore > 0 ? ++matchedShown <= MAX_MATCHED_SHOWN : ++unmatched <= unmatchedCap
-  );
+  const shown = findings.filter((f2) => {
+    if (f2.matchScore > 0) {
+      if (droppingWeak && f2.solid === 0) return false;
+      return ++matchedShown <= MAX_MATCHED_SHOWN;
+    }
+    if (droppingUntracked && f2.untracked) return false;
+    return ++unmatched <= unmatchedCap;
+  });
   const { text: block, selectedCount } = formatBlock(prompt, shown, gitState, maxChars);
   if (selectedCount === 0) return null;
   return {
@@ -6945,7 +6965,7 @@ async function gatherFindings(workspace, prompt) {
   const touch = (path) => {
     let f2 = byPath.get(path);
     if (!f2) {
-      f2 = { path, reasons: [], dirty: false, matchScore: 0 };
+      f2 = { path, reasons: [], dirty: false, matchScore: 0, terms: /* @__PURE__ */ new Set(), solid: 0, untracked: false };
       byPath.set(path, f2);
     }
     return f2;
@@ -6973,7 +6993,8 @@ async function gatherFindings(workspace, prompt) {
   if (statusOut !== null) {
     const entries = parsePorcelainZ(statusOut);
     let missing = 0;
-    for (const p2 of entries) {
+    const untrackedSet = /* @__PURE__ */ new Set();
+    for (const { path: p2, untracked } of entries) {
       const rel = liveRel(p2);
       if (rel === null) {
         missing++;
@@ -6981,14 +7002,22 @@ async function gatherFindings(workspace, prompt) {
       }
       if (isSecretLike(rel)) continue;
       if (rel.endsWith("/") || isDirectory(join6(gitRoot, p2))) dirtyDirs.push(rel.replace(/\/?$/, "/"));
-      else dirtySet.add(rel);
+      else {
+        dirtySet.add(rel);
+        if (untracked) untrackedSet.add(rel);
+      }
     }
+    const dirtyOrder = [
+      ...[...dirtySet].filter((r2) => !untrackedSet.has(r2)),
+      ...[...dirtySet].filter((r2) => untrackedSet.has(r2) && !isJunk(r2))
+    ];
     let dirtyOnly = 0;
-    for (const rel of dirtySet) {
+    for (const rel of dirtyOrder) {
       if (dirtyOnly >= MAX_DIRTY_ONLY) break;
       if (isNoise(rel)) continue;
       const f2 = touch(rel);
       f2.dirty = true;
+      f2.untracked = untrackedSet.has(rel);
       note(f2, "currently dirty");
       dirtyOnly++;
     }
@@ -7011,6 +7040,14 @@ async function gatherFindings(workspace, prompt) {
         else if (!stems.has(stem(t2))) stems.set(stem(t2), t2);
       }
       const words = all.map(pathWords);
+      const lastByDir = /* @__PURE__ */ new Map();
+      words.forEach((w2, i2) => {
+        if (!w2.last) return;
+        const key = `${all[i2].slice(0, all[i2].lastIndexOf("/") + 1)}\0${w2.last}`;
+        lastByDir.set(key, (lastByDir.get(key) ?? 0) + 1);
+      });
+      const roleWords = /* @__PURE__ */ new Set();
+      for (const [key, n2] of lastByDir) if (n2 >= 2) roleWords.add(key.slice(key.indexOf("\0") + 1));
       const lowered = literals.length > 0 ? all.map((p2) => p2.toLowerCase()) : [];
       const idf = /* @__PURE__ */ new Map();
       const wording = /* @__PURE__ */ new Map();
@@ -7029,15 +7066,21 @@ async function gatherFindings(workspace, prompt) {
         const scored = [];
         for (let i2 = 0; i2 < all.length; i2++) {
           let score = 0;
+          let solid = 0;
           const matched = [];
           for (const [key, weight] of idf) {
             const isLiteral = literals.includes(key);
-            if (isLiteral ? lowered[i2].includes(key) : words[i2].base.has(key)) score += weight * 2;
-            else if (!isLiteral && words[i2].all.has(key)) score += weight;
-            else continue;
+            if (isLiteral ? lowered[i2].includes(key) : words[i2].base.has(key)) {
+              const roleOnly = !isLiteral && roleWords.has(key) && words[i2].last === key;
+              score += weight * 2 * (roleOnly ? ROLE_WORD_FACTOR : 1);
+              if (!roleOnly) solid += weight * 2;
+            } else if (!isLiteral && words[i2].all.has(key)) {
+              score += weight;
+              solid += weight;
+            } else continue;
             matched.push(wording.get(key));
           }
-          if (score > 0) scored.push({ path: all[i2], score, matched });
+          if (score > 0) scored.push({ path: all[i2], score, solid, matched });
         }
         scored.sort((a2, b2) => b2.score - a2.score);
         let taken = 0;
@@ -7046,6 +7089,8 @@ async function gatherFindings(workspace, prompt) {
           if (isSecretLike(s2.path) || !existsSync7(join6(workspace, s2.path))) continue;
           const f2 = touch(s2.path);
           f2.matchScore += s2.score;
+          f2.solid += s2.solid;
+          for (const m3 of s2.matched) f2.terms.add(stem(m3));
           if (isDirty2(s2.path)) f2.dirty = true;
           note(f2, `path matches ${s2.matched.map((m3) => `"${m3}"`).join(", ")}`);
           taken++;
@@ -7085,6 +7130,8 @@ async function gatherFindings(workspace, prompt) {
       if (isSecretLike(file) || !existsSync7(join6(workspace, file))) continue;
       const f2 = touch(file);
       f2.matchScore += score;
+      f2.solid += score;
+      for (const w2 of words) f2.terms.add(stem(w2));
       if (isDirty2(file)) f2.dirty = true;
       note(f2, `content mentions ${words.slice(0, 3).map((w2) => `"${w2}"`).join(", ")}`);
       taken++;
@@ -7099,6 +7146,8 @@ async function gatherFindings(workspace, prompt) {
       const term = terms.find((t2) => hit.text.toLowerCase().includes(t2));
       const f2 = touch(file);
       f2.matchScore += 1;
+      f2.solid += 1;
+      if (term) f2.terms.add(stem(term));
       if (isDirty2(file)) f2.dirty = true;
       note(f2, term ? `matched "${term}"` : "matched search terms");
     }
@@ -7110,7 +7159,7 @@ async function gatherFindings(workspace, prompt) {
     let taken = 0;
     for (const p2 of recent) {
       if (taken >= MAX_RECENT) break;
-      if (isSecretLike(p2) || isNoise(p2) || !existsSync7(join6(workspace, p2))) continue;
+      if (isSecretLike(p2) || isNoise(p2) || isJunk(p2) || !existsSync7(join6(workspace, p2))) continue;
       note(touch(p2), "recently changed");
       taken++;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "offhands",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "description": "Phone → coding-agent relay. Daemon runs on your laptop, PWA on your phone. E2E encrypted.",
   "license": "UNLICENSED",
   "type": "module",