sweet-search 2.5.5 → 2.5.7

package/core/banner/render-banner.js

@@ -0,0 +1,209 @@
+/**
+ * Animated terminal banner — universal renderer.
+ *
+ * Decodes the pre-baked lossless WebP sprite-sheet (assets/banner/) once with sharp,
+ * then animates it via the best path the terminal supports:
+ *
+ *   Kitty graphics  (Ghostty, kitty, WezTerm, Konsole)        — pixel-perfect
+ *   iTerm2 inline   (iTerm.app)                                — pixel-perfect
+ *   Sixel           (Windows Terminal, Konsole, xterm, foot…) — crisp raster
+ *   half-blocks     (everything else: Apple Terminal, VS Code, SSH, CI-tty) — truecolor ▀
+ *
+ * Zero prerequisites for users: the only dependency is sharp (already a package dep,
+ * auto-installed per-platform by npm). Chrome is used ONLY at bake time (scripts/bake-banner.mjs).
+ *
+ * Safe by construction: renders only to an interactive TTY, never throws, honours
+ * NO_BANNER / SWEET_SEARCH_NO_BANNER / CI, and leaves the final frame in place when done.
+ */
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { encodeSixelFrame, buildPalette, makeMapper, sampleColors } from './sixel.js';
+
+const require = createRequire(import.meta.url);
+
+const ASSET_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'assets', 'banner');
+const ESC = '\x1b', BEL = '\x07', ST = ESC + '\\';
+const SYNC_ON = `${ESC}[?2026h`, SYNC_OFF = `${ESC}[?2026l`;
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+
+// ---------------- gating ----------------
+function shouldRender(stream, env) {
+  if (env.SWEET_SEARCH_NO_BANNER || env.NO_BANNER) return false;
+  if (env.CI) return false;
+  if (!stream || !stream.isTTY) return false;
+  if ((env.TERM || '') === 'dumb') return false;
+  return true;
+}
+
+// ---------------- terminal capability query (DA1 + text-area size) ----------------
+function queryTerminal(stream, env, timeout = 140) {
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    if (env.SS_NO_QUERY || !stdin || !stdin.isTTY) { resolve({}); return; }
+    let buf = '', done = false, t;
+    const finish = () => {
+      if (done) return; done = true;
+      try { stdin.removeListener('data', onData); stdin.setRawMode(false); stdin.pause(); } catch { /* noop */ }
+      clearTimeout(t);
+      const da1 = (buf.match(/\x1b\[\?([0-9;]+)c/) || [])[1] || '';
+      const size = buf.match(/\x1b\[4;(\d+);(\d+)t/);
+      resolve({ sixel: da1.split(';').includes('4'), areaH: size ? +size[1] : 0, areaW: size ? +size[2] : 0 });
+    };
+    const onData = (d) => { buf += d.toString('latin1'); if (/\x1b\[\?[0-9;]+c/.test(buf) && (/\x1b\[4;\d+;\d+t/.test(buf) || buf.length > 64)) finish(); };
+    try { stdin.setRawMode(true); stdin.resume(); stdin.on('data', onData); } catch { resolve({}); return; }
+    stream.write(`${ESC}[14t${ESC}[c`);     // text-area pixel size, then primary device attributes
+    t = setTimeout(finish, timeout);
+  });
+}
+
+function detectProto(env, caps) {
+  if (env.SS_PROTO) return env.SS_PROTO;
+  const tp = env.TERM_PROGRAM || '';
+  if (env.KITTY_WINDOW_ID || env.GHOSTTY_RESOURCES_DIR || tp === 'ghostty' || tp === 'WezTerm' || /kitty/i.test(env.TERM || '')) return 'kitty';
+  if (tp === 'iTerm.app') return 'iterm';
+  if (caps.sixel || env.WT_SESSION || /foot|contour|mlterm/i.test(env.TERM || '')) return 'sixel';
+  return 'blocks';
+}
+
+// ---------------- color (truecolor default; 256 fallback) ----------------
+function rgb256(r, g, b) {
+  if (Math.abs(r - g) < 10 && Math.abs(g - b) < 10) { if (r < 8) return 16; if (r > 248) return 231; return 232 + Math.round(((r - 8) / 247) * 24); }
+  return 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
+}
+const GHALF = [' ', '▀', '▄', '█'];
+function sextantChar(v) {
+  if (v === 0) return ' '; if (v === 63) return '█'; if (v === 21) return '▌'; if (v === 42) return '▐';
+  return String.fromCodePoint(0x1FB00 + (v - 1 - (v > 21 ? 1 : 0) - (v > 42 ? 1 : 0)));
+}
+
+// ---------------- main ----------------
+export async function showBanner(opts = {}) {
+  const env = opts.env || process.env;
+  const out = opts.stream || process.stdout;
+  let onSig = null;
+  try {
+    if (!shouldRender(out, env)) return false;
+
+    const sharp = require('sharp');
+    const man = JSON.parse(readFileSync(join(ASSET_DIR, 'banner-manifest.json'), 'utf8'));
+    const { gridCols: GC, cellW: CW, cellH: CH, count: N, frameMs } = man;
+    const maxMs = opts.maxMs ?? Number(env.SS_BANNER_MS || 2600);
+    const color = opts.color || env.SS_COLOR || 'truecolor';
+    const cellMode = opts.cells || env.SS_CELLS || 'half';
+
+    const caps = opts.query === false ? {} : await queryTerminal(out, env);
+    const proto = opts.proto || detectProto(env, caps);
+    const capCols = Number(opts.cols || env.SS_COLS || 120);
+    const cols = Math.max(20, Math.min((out.columns || 80) - 2, capCols));
+
+    // decode the sprite sheet once
+    const { data: big, info } = await sharp(join(ASSET_DIR, man.file)).raw().toBuffer({ resolveWithObject: true });
+    const BW = info.width, ch = info.channels;
+    const frameRaw = (i) => {
+      const gx = (i % GC) * CW, gy = Math.floor(i / GC) * CH, f = Buffer.allocUnsafe(CW * CH * 4);
+      for (let y = 0; y < CH; y++) { const so = ((gy + y) * BW + gx) * ch; big.copy(f, y * CW * 4, so, so + CW * 4); }
+      return f;
+    };
+
+    const fg = color === '256' ? (r, g, b) => `${ESC}[38;5;${rgb256(r, g, b)}m` : (r, g, b) => `${ESC}[38;2;${r};${g};${b}m`;
+    const bg = color === '256' ? (r, g, b) => `${ESC}[48;5;${rgb256(r, g, b)}m` : (r, g, b) => `${ESC}[48;2;${r};${g};${b}m`;
+    const RESET = `${ESC}[0m`;
+
+    // ---------------- per-protocol lazy frame builder (build only frames we show) ----------------
+    let renderRows = Math.max(4, Math.round(cols / 6));
+    const cache = new Map();
+    let buildOne;
+
+    if (proto === 'kitty' || proto === 'iterm') {
+      buildOne = async (i) => (await sharp(frameRaw(i), { raw: { width: CW, height: CH, channels: 4 } }).png().toBuffer()).toString('base64');
+    } else if (proto === 'sixel') {
+      const cellWpx = caps.areaW && out.columns ? caps.areaW / out.columns : 8;
+      const Wp = Math.min(1000, Math.max(360, Math.round(cols * cellWpx)));
+      const Hp = Math.round(Wp / 3);
+      const cellHpx = caps.areaH && out.rows ? caps.areaH / out.rows : 16;
+      renderRows = Math.max(4, Math.round(Hp / cellHpx));
+      const sixelPx = async (i) => (await sharp(frameRaw(i), { raw: { width: CW, height: CH, channels: 4 } }).resize(Wp, Hp, { fit: 'fill' }).raw().toBuffer());
+      // global palette from 2 representative frames (colours are stable across the loop)
+      const samp = [...sampleColors(await sixelPx(0), 9), ...sampleColors(await sixelPx((N / 2) | 0), 9)];
+      const palette = buildPalette(samp, 255), mapper = makeMapper(palette);
+      buildOne = async (i) => encodeSixelFrame(await sixelPx(i), Wp, Hp, palette, mapper);
+    } else {
+      const [sc, sr] = cellMode === 'sextant' ? [2, 3] : [1, 2];
+      const R = Math.max(3, Math.round((cols * sc) * CH / CW / sr)); renderRows = R;
+      const W = cols * sc, H = R * sr;
+      const glyph = cellMode === 'sextant' ? sextantChar : (v) => GHALF[v];
+      buildOne = async (i) => {
+        const { data: px } = await sharp(frameRaw(i), { raw: { width: CW, height: CH, channels: 4 } }).resize(W, H, { fit: 'fill', kernel: 'lanczos3' }).sharpen({ sigma: 0.7 }).raw().toBuffer({ resolveWithObject: true });
+        let s = '';
+        for (let cy = 0; cy < R; cy++) {
+          for (let cx = 0; cx < cols; cx++) {
+            const sub = []; let anyT = false, anyO = false;
+            for (let y = 0; y < sr; y++) for (let x = 0; x < sc; x++) { const o = ((cy * sr + y) * W + (cx * sc + x)) * 4, a = px[o + 3]; sub.push({ r: px[o], g: px[o + 1], b: px[o + 2], a }); if (a < 128) anyT = true; else anyO = true; }
+            if (!anyO) { s += RESET + ' '; continue; }
+            const op = sub.filter(p => p.a >= 128), lum = p => 0.299 * p.r + 0.587 * p.g + 0.114 * p.b;
+            let lo = op[0], hi = op[0];
+            for (const p of op) { if (lum(p) < lum(lo)) lo = p; if (lum(p) > lum(hi)) hi = p; }
+            const dist = (p, q) => (p.r - q.r) ** 2 + (p.g - q.g) ** 2 + (p.b - q.b) ** 2;
+            let fr = 0, fG = 0, fb = 0, fn = 0, br = 0, bG = 0, bb = 0, bn = 0, bits = 0;
+            for (let k = 0; k < sub.length; k++) { const p = sub[k]; if (p.a < 128) continue; if (dist(p, hi) <= dist(p, lo)) { bits |= (1 << k); fr += p.r; fG += p.g; fb += p.b; fn++; } else { br += p.r; bG += p.g; bb += p.b; bn++; } }
+            const fc = fn ? [Math.round(fr / fn), Math.round(fG / fn), Math.round(fb / fn)] : null;
+            const bc = bn ? [Math.round(br / bn), Math.round(bG / bn), Math.round(bb / bn)] : null;
+            const full = (1 << sub.length) - 1;
+            if (anyT) s += bits === 0 ? RESET + ' ' : RESET + fg(...(fc || bc)) + glyph(bits);
+            else if (bits === 0) s += bg(...bc) + ' ';
+            else if (bits === full) s += fg(...fc) + glyph(bits);
+            else s += bg(...bc) + fg(...fc) + glyph(bits);
+          }
+          s += RESET; if (cy < R - 1) s += '\r\n';
+        }
+        return s;
+      };
+    }
+    const getFrame = async (i) => { let v = cache.get(i); if (v === undefined) { v = await buildOne(i); cache.set(i, v); } return v; };
+
+    // ---------------- emit / animate (bounded) ----------------
+    const CHUNK = 4096;
+    const kittyFrame = (b64, id) => {
+      if (b64.length <= CHUNK) { out.write(`${ESC}_Gf=100,a=T,q=2,c=${cols},C=1,i=${id};${b64}${ST}`); return; }
+      for (let i = 0; i < b64.length; i += CHUNK) { const piece = b64.slice(i, i + CHUNK), more = i + CHUNK < b64.length ? 1 : 0; out.write(i === 0 ? `${ESC}_Gf=100,a=T,q=2,c=${cols},C=1,i=${id},m=1;${piece}${ST}` : `${ESC}_Gm=${more};${piece}${ST}`); }
+    };
+    const kittyDel = (id) => out.write(`${ESC}_Ga=d,d=i,i=${id},q=2${ST}`);
+
+    await getFrame(0);                    // build first frame before clearing space (hide latency)
+    out.write(ESC + '[?25l');
+    // Restore the cursor if interrupted mid-animation (else Ctrl-C leaves it hidden).
+    onSig = () => { try { out.write(`${ESC}[0m${ESC}[?25h`); } catch { /* noop */ } process.exit(130); };
+    process.once('SIGINT', onSig);
+    if (proto === 'blocks' || proto === 'sixel') { for (let r = 0; r < renderRows; r++) out.write('\n'); out.write(`${ESC}[${renderRows}A`); }
+    else out.write('\n');
+    out.write(ESC + '7');
+
+    let prevId = 0, flip = 1;
+    const start = Date.now();
+    let i = 0;
+    while (Date.now() - start < maxMs) {
+      const frame = await getFrame(i);
+      out.write(SYNC_ON + ESC + '8');
+      if (proto === 'kitty') { const id = flip; kittyFrame(frame, id); if (prevId) kittyDel(prevId); prevId = id; flip = flip === 1 ? 2 : 1; }
+      else if (proto === 'iterm') out.write(`${ESC}]1337;File=inline=1;width=${cols};height=${renderRows};preserveAspectRatio=1:${frame}${BEL}`);
+      else out.write(frame);
+      out.write(SYNC_OFF);
+      await sleep(frameMs);
+      i = (i + 1) % N;
+    }
+    out.write(ESC + '8');                 // settle: leave final frame, move below
+    out.write('\n'.repeat(renderRows + 1));
+    out.write(RESET + ESC + '[?25h');
+    if (onSig) process.removeListener('SIGINT', onSig);   // hand Ctrl-C back to the caller
+    return true;
+  } catch (err) {
+    if (onSig) process.removeListener('SIGINT', onSig);
+    if (env.SS_BANNER_DEBUG) process.stderr.write(`[banner] ${err && err.stack || err}\n`);
+    try { out.write(`${ESC}[0m${ESC}[?25h`); } catch { /* noop */ }
+    return false;
+  }
+}
+
+export default showBanner;

package/core/banner/sixel.js

@@ -0,0 +1,126 @@
+/**
+ * Minimal, dependency-free Sixel encoder for the terminal banner.
+ *
+ * Sixel renders crisp raster images on Windows Terminal (>=1.22), Konsole, xterm,
+ * foot, Contour and much of Linux — terminals that lack the Kitty graphics protocol.
+ *
+ * We build ONE shared palette across all frames (pixel art reuses colours, so a global
+ * palette is both faster and lets frames share colour definitions) and emit each frame
+ * with run-length-encoded sixel bands. Fully-transparent pixels are left unset so the
+ * terminal background shows through (rounded banner corners).
+ */
+
+const TRANSPARENT = -1;
+
+function boxStats(box) {
+  let rMin = 255, rMax = 0, gMin = 255, gMax = 0, bMin = 255, bMax = 0;
+  for (const [r, g, b] of box) {
+    if (r < rMin) rMin = r; if (r > rMax) rMax = r;
+    if (g < gMin) gMin = g; if (g > gMax) gMax = g;
+    if (b < bMin) bMin = b; if (b > bMax) bMax = b;
+  }
+  const dr = rMax - rMin, dg = gMax - gMin, db = bMax - bMin;
+  const range = Math.max(dr, dg, db);
+  const channel = range === dr ? 0 : range === dg ? 1 : 2;
+  return { range, channel };
+}
+function avgColor(box) {
+  let r = 0, g = 0, b = 0;
+  for (const c of box) { r += c[0]; g += c[1]; b += c[2]; }
+  const n = box.length || 1;
+  return [Math.round(r / n), Math.round(g / n), Math.round(b / n)];
+}
+
+/** Median-cut quantisation over a sample of opaque colours. Returns up to maxColors [r,g,b]. */
+export function buildPalette(samples, maxColors = 255) {
+  if (samples.length === 0) return [[0, 0, 0]];
+  let boxes = [samples];
+  while (boxes.length < maxColors) {
+    let bi = -1, best = -1;
+    for (let i = 0; i < boxes.length; i++) {
+      if (boxes[i].length < 2) continue;
+      const { range } = boxStats(boxes[i]);
+      if (range > best) { best = range; bi = i; }
+    }
+    if (bi < 0) break;
+    const box = boxes[bi];
+    const { channel } = boxStats(box);
+    box.sort((a, b) => a[channel] - b[channel]);
+    const mid = box.length >> 1;
+    boxes.splice(bi, 1, box.slice(0, mid), box.slice(mid));
+  }
+  return boxes.map(avgColor);
+}
+
+/** Fast rgb->palette-index mapper with a per-colour cache (pixel art has few unique colours). */
+export function makeMapper(palette) {
+  const cache = new Map();
+  return (r, g, b) => {
+    const key = (r << 16) | (g << 8) | b;
+    const hit = cache.get(key);
+    if (hit !== undefined) return hit;
+    let best = 0, bestD = Infinity;
+    for (let i = 0; i < palette.length; i++) {
+      const p = palette[i];
+      const d = (p[0] - r) ** 2 + (p[1] - g) ** 2 + (p[2] - b) ** 2;
+      if (d < bestD) { bestD = d; best = i; }
+    }
+    cache.set(key, best);
+    return best;
+  };
+}
+
+/** Collect a colour sample from a raw RGBA frame (every `step`-th opaque pixel). */
+export function sampleColors(rgba, step = 7) {
+  const out = [];
+  for (let i = 0; i < rgba.length; i += 4 * step) {
+    if (rgba[i + 3] >= 128) out.push([rgba[i], rgba[i + 1], rgba[i + 2]]);
+  }
+  return out;
+}
+
+/** Encode one RGBA frame to a Sixel string using a shared palette + mapper. */
+export function encodeSixelFrame(rgba, width, height, palette, mapper) {
+  // index buffer: palette index per pixel, or TRANSPARENT
+  const idx = new Int16Array(width * height);
+  for (let p = 0, o = 0; p < idx.length; p++, o += 4) {
+    idx[p] = rgba[o + 3] < 128 ? TRANSPARENT : mapper(rgba[o], rgba[o + 1], rgba[o + 2]);
+  }
+
+  let s = '\x1bP0;1;0q';                 // DCS; P2=1 => 0-bit pixels stay transparent
+  s += `"1;1;${width};${height}`;        // raster attributes (1:1 aspect)
+  for (let i = 0; i < palette.length; i++) {
+    const [r, g, b] = palette[i];
+    s += `#${i};2;${Math.round(r / 255 * 100)};${Math.round(g / 255 * 100)};${Math.round(b / 255 * 100)}`;
+  }
+
+  const used = [];
+  for (let by = 0; by < height; by += 6) {
+    const bandH = Math.min(6, height - by);
+    // which palette indices appear in this band
+    used.length = 0;
+    const seen = new Set();
+    for (let y = by; y < by + bandH; y++) {
+      const row = y * width;
+      for (let x = 0; x < width; x++) { const c = idx[row + x]; if (c !== TRANSPARENT && !seen.has(c)) { seen.add(c); used.push(c); } }
+    }
+    for (let u = 0; u < used.length; u++) {
+      const ci = used[u];
+      if (u > 0) s += '$';               // return to band start, overlay next colour
+      s += `#${ci}`;
+      let runChar = -1, runLen = 0, line = '';
+      for (let x = 0; x < width; x++) {
+        let bits = 0;
+        for (let k = 0; k < bandH; k++) if (idx[(by + k) * width + x] === ci) bits |= (1 << k);
+        const ch = 63 + bits;
+        if (ch === runChar) { runLen++; }
+        else { if (runLen) line += runLen > 3 ? `!${runLen}${String.fromCharCode(runChar)}` : String.fromCharCode(runChar).repeat(runLen); runChar = ch; runLen = 1; }
+      }
+      if (runLen) line += runLen > 3 ? `!${runLen}${String.fromCharCode(runChar)}` : String.fromCharCode(runChar).repeat(runLen);
+      s += line;
+    }
+    s += '-';                            // graphics newline
+  }
+  s += '\x1b\\';                         // ST
+  return s;
+}

package/core/embedding/embedding-local-model.js

@@ -172,6 +172,7 @@ export function buildLocalSessionOptions(quantLabel = 'q8', coremlAvailable = fa
 
   const sessionOptions = {
     graphOptimizationLevel: 'all',
+    logSeverityLevel: 3, // ERROR — silence ORT's expected "optimized model is machine-specific" warning
     intraOpNumThreads: intraOpThreads,
     interOpNumThreads: interOpThreads,
     executionMode,

package/core/graph/relationship-resolver.js

@@ -160,7 +160,11 @@ export function resolveRelationshipTargets(db) {
 
   resolveAll();
 
-  console.log(`  ✓ Resolved ${resolved}/${unresolved.length} relationships`);
+  if (resolved > 0) {
+    console.log(`  ✓ Linked ${resolved}/${unresolved.length} references to local definitions`);
+  } else {
+    console.log(`  ${unresolved.length} references resolve to external/library symbols (no local definition to link)`);
+  }
   if (ambiguous > 0) {
     console.log(`  ⚠ ${ambiguous} ambiguous targets (multiple matches)`);
   }

package/core/indexing/index-codebase-v21.js

@@ -121,6 +121,11 @@ async function main() {
     setVerboseMode(true);
   }
 
+  // Animated banner (best-effort; interactive TTY only, never in CI / quiet / stdin-fed runs).
+  if (!quiet && !help && !filesFromStdin && process.stdout.isTTY && !process.env.CI && !process.env.NO_BANNER && !process.env.SWEET_SEARCH_NO_BANNER) {
+    try { const { showBanner } = await import('../banner/render-banner.js'); await showBanner(); } catch { /* non-fatal */ }
+  }
+
   // Apply late interaction model overrides before any model code runs.
   // Precedence: --no-late-interaction > --late-interaction-model=… > env
   // var (already honoured by LATE_INTERACTION_CONFIG.model at module load) >
@@ -135,10 +140,6 @@ async function main() {
     applyPersistedLiModel(process.env.SWEET_SEARCH_PROJECT_ROOT || process.cwd());
   }
 
-  log(`${colors.bright}╔═══════════════════════════════════════════════════╗${colors.reset}`, 'bright');
-  log(`${colors.bright}║   Sweet Search Codebase Indexer v2.3 (SOTA Dec'25) ║${colors.reset}`, 'bright');
-  log(`${colors.bright}╚═══════════════════════════════════════════════════╝${colors.reset}`, 'bright');
-
   if (vectorsOnly) {
     log('⚠ WARNING: --vectors-only skips code graph rebuild', 'yellow');
     log('  GraphRAG structural queries will use stale data', 'yellow');
@@ -333,13 +334,13 @@ Output:
     }
 
     // =========================================================================
-    // PHASE 3: Code Graph + HCGS Preparation (if not --vectors-only)
+    // PHASE 1: Code Graph (if not --vectors-only)
     // =========================================================================
     let graphStats = { entities: 0, relationships: 0 };
     let hcgsPromise = null;
 
     if (!vectorsOnly) {
-      const graphResult = await runPhase('Code Graph + HCGS Prep', buildCodeGraphWithHCGSPhase, {
+      const graphResult = await runPhase('Code Graph', buildCodeGraphWithHCGSPhase, {
         allFiles,
         filesToIndex,
         dryRun,

package/core/indexing/indexer-ann.js

@@ -396,7 +396,7 @@ function diversityFirstPermutationRowids(filePaths) {
 // =============================================================================
 
 export async function incrementalUpdateHNSW(dbPath, changedFiles, dryRun = false) {
-  log('\n━━━ Phase 3: HNSW Index (Incremental) ━━━', 'bright');
+  log('\n━━━ Phase 4: HNSW Index (Incremental) ━━━', 'bright');
 
   if (dryRun) {
     log('DRY RUN: Skipping HNSW incremental update', 'magenta');
@@ -510,7 +510,7 @@ export async function incrementalUpdateHNSW(dbPath, changedFiles, dryRun = false
 // =============================================================================
 
 export async function buildHNSWIndex(dbPath, dryRun = false) {
-  log('\n━━━ Phase 3: HNSW Index ━━━', 'bright');
+  log('\n━━━ Phase 4: HNSW Index ━━━', 'bright');
 
   if (dryRun) {
     log('DRY RUN: Skipping HNSW index', 'magenta');
@@ -650,7 +650,7 @@ export async function buildHNSWIndex(dbPath, dryRun = false) {
             });
             fsyncFile(sidecarPath);
             fsyncDirectory(path.dirname(checkpointPath));
-            log(`  checkpoint: ${added}/${totalVectors} vectors`, 'dim');
+            if (process.env.DEBUG) log(`  checkpoint: ${added}/${totalVectors} vectors`, 'dim');
           }
           lastCheckpointTime = Date.now();
           vectorsSinceCheckpoint = 0;
@@ -705,7 +705,7 @@ export async function buildLateInteractionIndex(chunks, dryRun = false, filesToR
     segmentSize = null, // override SSLX-v3 segment threshold (default 10k)
     projectRoot,        // honored by LI skip policy for .sweet-search.config.json excludes
   } = options;
-  log('\n━━━ Phase 4: Late Interaction Index (LateOn-Code) ━━━', 'bright');
+  log('\n━━━ Phase 3: Late Interaction Index (LateOn-Code) ━━━', 'bright');
 
   if (dryRun) {
     log('DRY RUN: Skipping late interaction index', 'magenta');

package/core/indexing/indexer-build.js

@@ -643,7 +643,7 @@ export async function chunkFiles(files) {
     try {
       const enriched = await enrichChunksFromGraph(allChunks, ASTChunker);
       if (enriched > 0) {
-        log(`✓ Enriched ${enriched}/${allChunks.length} chunks with scope/import context`, 'green');
+        log(`✓ Added scope/import context to ${enriched} code chunks`, 'green');
       }
     } catch (err) {
       log(`⚠ Chunk enrichment skipped: ${err.message}`, 'yellow');

package/core/indexing/indexer-utils.js

@@ -109,32 +109,79 @@ export function isVerboseMode() {
   return verboseMode;
 }
 
+// ---------------------------------------------------------------------------
+// Progress rendering — a live region of animated, in-place bars.
+//
+// On a TTY (verbose included), each phase's bar animates in place via cursor
+// moves + erase-to-EOL, with smooth 1/8-block fill. Multiple bars can run at
+// once (e.g. Embedding + Late Interaction in parallel) — they share one pinned
+// region at the bottom and update independently. While bars are live, log()
+// prints its line above the region and redraws the bars below, so diagnostics
+// never split a bar. The region "commits" (stays on screen) once every bar in
+// it has reached 100%. Non-TTY (pipes / CI) falls back to throttled newlines.
+// ---------------------------------------------------------------------------
+const BAR_WIDTH = 30;
+const LABEL_COL = 17;           // pad "Label:" to this width so every bar's [ ] aligns
+const SUB_BLOCKS = ['', '▏', '▎', '▍', '▌', '▋', '▊', '▉']; // eighth-block partial fills
+const CLEAR_EOL = '\x1b[K';
+const liveBars = new Map();     // label -> { current, total }; insertion order = display order
+let regionLines = 0;            // bar lines currently pinned at the bottom (TTY)
+let lastLoggedPercent = {};
+
+function renderBar(current, total, label) {
+  const ratio = total > 0 ? Math.max(0, Math.min(1, current / total)) : 1;
+  const eighths = Math.round(ratio * BAR_WIDTH * 8);
+  const full = Math.floor(eighths / 8);
+  const partial = SUB_BLOCKS[eighths % 8];
+  const bar = '█'.repeat(full) + partial;
+  const empty = '░'.repeat(Math.max(0, BAR_WIDTH - full - (partial ? 1 : 0)));
+  const head = `${label}:`.padEnd(LABEL_COL);            // right border aligns across phases
+  const pct = (ratio * 100).toFixed(1).padStart(5);
+  return `${colors.cyan}${head}[${bar}${empty}] ${pct}% (${current}/${total})${colors.reset}`;
+}
+
+function drawRegion() {
+  let out = regionLines > 0 ? `\x1b[${regionLines}A\r` : '\r';
+  for (const [label, b] of liveBars) out += renderBar(b.current, b.total, label) + CLEAR_EOL + '\n';
+  process.stdout.write(out);
+  regionLines = liveBars.size;
+}
+
 export function log(message, color = 'reset') {
   if (quietMode) return;
-  console.log(`${colors[color]}${message}${colors.reset}`);
+  const line = `${colors[color]}${message}${colors.reset}`;
+  if (regionLines > 0 && process.stdout.isTTY) {
+    // Print the line above the pinned bars, then redraw the bars below it.
+    let out = `\x1b[${regionLines}A\r${line}${CLEAR_EOL}\n`;
+    for (const [label, b] of liveBars) out += renderBar(b.current, b.total, label) + CLEAR_EOL + '\n';
+    process.stdout.write(out);
+  } else {
+    console.log(line);
+  }
 }
 
-let lastLoggedPercent = {};
-
 export function logProgress(current, total, label) {
   if (quietMode) return;
-  const percentNum = (current / total) * 100;
-  const percent = percentNum.toFixed(1);
-  const bar = '█'.repeat(Math.floor(current / total * 30));
-  const empty = '░'.repeat(30 - bar.length);
-  // In verbose mode or non-TTY, use newlines so output isn't swallowed by pipes.
-  // Throttle to every ~2% to avoid flooding.
-  if (verboseMode || !process.stdout.isTTY) {
+  if (!process.stdout.isTTY) {
+    // Pipes / CI: throttle to ~2% and emit newlines so output isn't swallowed.
+    const percentNum = total > 0 ? (current / total) * 100 : 100;
     const lastPct = lastLoggedPercent[label] || 0;
-    if (percentNum - lastPct >= 2 || current === total || current <= 1) {
+    if (percentNum - lastPct >= 2 || current >= total || current <= 1) {
       lastLoggedPercent[label] = percentNum;
-      console.log(`${colors.cyan}${label}: [${bar}${empty}] ${percent}% (${current}/${total})${colors.reset}`);
-    }
-  } else {
-    process.stdout.write(`\r${colors.cyan}${label}: [${bar}${empty}] ${percent}% (${current}/${total})${colors.reset}`);
-    if (current === total) {
-      process.stdout.write('\n');
+      console.log(renderBar(current, total, label));
     }
+    return;
+  }
+  // Interactive TTY: update this bar in the live region and redraw.
+  liveBars.set(label, { current, total });
+  drawRegion();
+  // Once every live bar is complete, commit the region (leave it on screen).
+  let allDone = true;
+  for (const b of liveBars.values()) if (b.current < b.total) { allDone = false; break; }
+  if (allDone) {
+    for (const k of liveBars.keys()) lastLoggedPercent[k] = 0;
+    liveBars.clear();
+    regionLines = 0;
   }
 }
 

package/core/infrastructure/onnx-session-utils.js

@@ -192,6 +192,7 @@ export function buildSessionOptions(modelId, suffix, coremlAvailable = false, ru
     ?? parseInt(process.env.SWEET_SEARCH_ORT_INTER_OP_THREADS || '1', 10);
   const opts = {
     graphOptimizationLevel: 'all',
+    logSeverityLevel: 3, // ERROR — silence ORT's expected "optimized model is machine-specific" warning
     intraOpNumThreads: runtimeOptions.intraOpThreads ?? bestIntraOpThreads(runtimeOptions),
     interOpNumThreads: interOpThreads,
     executionMode,

package/core/infrastructure/simd-distance.js

@@ -72,12 +72,17 @@ async function initWasm() {
 
       initDone = true;
 
-      if (nativeMaxsim) {
-        console.error('[MaxSim] Tier 1: Native Rust + Rayon (parallel SIMD)');
-      } else if (maxsimExports || wasmExports?.maxsim_f32) {
-        console.error('[MaxSim] Tier 2: WASM SIMD f32x4');
-      } else {
-        console.error('[MaxSim] Tier 3: JS fallback');
+      // Load-time tier diagnostic — gated behind DEBUG so it doesn't precede the
+      // banner / clutter normal output (the active tier is also shown in `init`'s
+      // summary as "MaxSim: …"). Set DEBUG=1 to surface it.
+      if (process.env.DEBUG) {
+        if (nativeMaxsim) {
+          console.error('[MaxSim] Tier 1: Native Rust + Rayon (parallel SIMD)');
+        } else if (maxsimExports || wasmExports?.maxsim_f32) {
+          console.error('[MaxSim] Tier 2: WASM SIMD f32x4');
+        } else {
+          console.error('[MaxSim] Tier 3: JS fallback');
+        }
       }
 
       return true;

package/core/ranking/late-interaction-model.js

@@ -193,6 +193,7 @@ async function loadModel() {
   const { getOptimizedGraphPath } = await import('../infrastructure/onnx-session-utils.js');
   const session = await ort.InferenceSession.create(onnxPath, {
     executionProviders: ['cpu'],
+    logSeverityLevel: 3, // ERROR — silence ORT's expected "optimized model is machine-specific" warning
     intraOpNumThreads: lateInteractionRuntimeConfig.intraOpThreads ?? bestIntraOpThreads(),
     interOpNumThreads: 1,
     optimizedModelFilePath: getOptimizedGraphPath(modelConfig.hfId, 'lateon'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sweet-search",
-  "version": "2.5.5",
+  "version": "2.5.7",
   "description": "Sweet Search - SOTA Hybrid Code Search Engine with WASM CatBoost Query Router, Semantic/Lexical/Structural Search, and Multilingual Support",
   "type": "module",
   "main": "core/search/sweet-search.js",
@@ -13,12 +13,12 @@
   "author": "Marko Sladojevic <marko@panonit.com> (https://panonit.com)",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/panonitorg/sweet-search.git"
+    "url": "git+https://github.com/mrsladoje/sweet-search.git"
   },
   "bugs": {
-    "url": "https://github.com/panonitorg/sweet-search/issues"
+    "url": "https://github.com/mrsladoje/sweet-search/issues"
   },
-  "homepage": "https://github.com/panonitorg/sweet-search#readme",
+  "homepage": "https://github.com/mrsladoje/sweet-search#readme",
   "keywords": [
     "sweet-search",
     "code-search",
@@ -50,8 +50,11 @@
     "core/vector-store/",
     "core/query/",
     "core/skills/",
+    "core/banner/",
+    "assets/banner/",
     "mcp/",
     "scripts/benchmark-harness.js",
+    "scripts/postinstall-banner.js",
     "scripts/init.js",
     "scripts/uninstall.js",
     "scripts/verify-runtime.js",
@@ -78,6 +81,8 @@
   ],
   "scripts": {
     "init": "node scripts/init.js",
+    "postinstall": "node scripts/postinstall-banner.js",
+    "bake:banner": "node scripts/bake-banner.mjs",
     "build:assets": "node scripts/generate-asset-manifest.js",
     "lint": "eslint core/",
     "build": "node -e \"import('./core/search/sweet-search.js')\" && echo 'Build OK'",
@@ -152,17 +157,18 @@
     "eslint": "^9.39.4",
     "fast-check": "^4.5.3",
     "p-map": "^7.0.4",
+    "puppeteer-core": "^25.1.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.16"
   },
   "optionalDependencies": {
     "usearch": "^2.21.4",
-    "@sweet-search/native-darwin-arm64": "2.5.5",
-    "@sweet-search/native-darwin-x64": "2.5.5",
-    "@sweet-search/native-linux-arm64-gnu": "2.5.5",
-    "@sweet-search/native-linux-arm64-gnu-cuda": "2.5.5",
-    "@sweet-search/native-linux-x64-gnu": "2.5.5",
-    "@sweet-search/native-linux-x64-gnu-cuda": "2.5.5"
+    "@sweet-search/native-darwin-arm64": "2.5.7",
+    "@sweet-search/native-darwin-x64": "2.5.7",
+    "@sweet-search/native-linux-arm64-gnu": "2.5.7",
+    "@sweet-search/native-linux-arm64-gnu-cuda": "2.5.7",
+    "@sweet-search/native-linux-x64-gnu": "2.5.7",
+    "@sweet-search/native-linux-x64-gnu-cuda": "2.5.7"
   },
   "engines": {
     "node": ">=18.0.0"