thinkpool-pair 0.7.353 → 0.7.354

package/bridge.mjs

@@ -59,6 +59,7 @@ import { cleanTerminalName, modelTerminalNameInput } from './terminal-name.mjs'
 import { defaultStructuredMode, normalizeStructuredEffort, shouldDeferStructuredRuntime, structuredModeForSlice, structuredModeLocked, structuredModesForLane, structuredRuntimeForCommand, structuredRuntimeMetadata, structuredRuntimeSupportsMode } from './runtime-registry.mjs'
 import { commandCatalogForRuntime, commandHelpLine, reconcileCommandCatalog } from './command-catalog.mjs'
 import { gitDiffReport } from './git-diff-report.mjs'
+import { repoSearch } from './repo-search.mjs'
 import { probeHermesRuntime } from './hermes-probe.mjs'
 import { hermesRequiredMcpTools, hermesRoleFor } from './hermes-policy.mjs'
 import { canonicalRoomFilePath, waitForNativeImages } from './codex-images.mjs'
@@ -4539,7 +4540,7 @@ channel
       // Display the clean body (web sends `body` when the agent `text` carries host
       // file paths) + the uploaded attachments, so the partner shows the image — not
       // a raw /var path. The agent already got the full `text` via sendTurn above.
-      const evt = { kind: 'you', text: payload.body != null ? String(payload.body) : text, cid: payload.cid, by: payload.by, ...(payload.authorId ? { authorId: payload.authorId } : {}), ...(Array.isArray(payload.files) && payload.files.length ? { files: payload.files } : {}), ...(Array.isArray(payload.pastes) && payload.pastes.length ? { pastes: payload.pastes } : {}) }
+      const evt = { kind: 'you', text: payload.body != null ? String(payload.body) : text, cid: payload.cid, by: payload.by, ...(payload.authorId ? { authorId: payload.authorId } : {}), ...(payload.steered ? { steered: true } : {}), ...(Array.isArray(payload.files) && payload.files.length ? { files: payload.files } : {}), ...(Array.isArray(payload.pastes) && payload.pastes.length ? { pastes: payload.pastes } : {}) }
       pushLog(s, evt)
       bcast('code-event', { term: payload.term, evt })
     }
@@ -4577,6 +4578,19 @@ channel
       } catch { ctlLine('Working-tree diff unavailable outside a readable Git checkout') }
       return
     }
+    const findMatch = text.match(/^\/find(?:\s+([\s\S]+))?$/i)
+    if (findMatch) {
+      const search = repoSearch({ cwd: s.cwd || process.cwd(), query: findMatch[1] || '' })
+      const evt = {
+        kind: 'repo-search',
+        ...search,
+        by: payload.by,
+        cid: payload.cid,
+      }
+      pushLog(s, evt)
+      bcast('code-event', { term: payload.term, evt })
+      return
+    }
     if (/^\/credits\s*$/.test(text) && s.runtime !== 'hermes') {
       if (s.runtime !== 'codex' || typeof s.session?.accountUsage !== 'function') {
         ctlLine('Credit balance is unavailable for this runtime; use /usage for provider limits')

package/code-event-contract.mjs

@@ -47,6 +47,7 @@ export const CODE_EVENT_REGISTRY = Object.freeze({
   'side-handback': P,
   answer: C,
   control: C,
+  'repo-search': C,
   clear: C,
   'queue-add': C,
   'queue-cancel': C,

package/command-catalog.mjs

@@ -19,6 +19,7 @@ export const CODE_ROOM_COMMANDS = Object.freeze([
   command('/usage', 'session usage and provider limits', 'control'),
   command('/context', 'current context-window usage', 'control'),
   command('/diff', 'Git changes and branch status', 'control'),
+  command('/find', 'find relevant files in this repository', 'control', 'query'),
   command('/compact', 'compact context', 'runtime'),
   command('/clear', 'clear context · confirms', 'clear'),
   command('/model', 'pick model — opens selector', 'model'),

package/git-diff-report.mjs

@@ -16,8 +16,11 @@ function defaultRunGit(args, cwd) {
 }
 
 function cleanLine(value, max = 240) {
-  return String(value || '')
-    .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, '')
+  return Array.from(String(value || ''), (character) => {
+    const code = character.charCodeAt(0)
+    const removableControl = (code <= 0x1f && code !== 0x09 && code !== 0x0a && code !== 0x0d) || code === 0x7f
+    return removableControl ? '' : character
+  }).join('')
     .replace(/\s+/g, ' ')
     .trim()
     .slice(0, max)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.353",
+  "version": "0.7.354",
   "description": "Connect Claude Code, Codex, or Hermes on your computer to a Thinkpool Code room.",
   "type": "module",
   "bin": {
@@ -49,6 +49,7 @@
     "hermes-delegation-guard.mjs",
     "runtime-registry.mjs",
     "command-catalog.mjs",
+    "repo-search.mjs",
     "git-diff-report.mjs",
     "runtime-session.mjs",
     "turn-stall.mjs",

package/repo-search.mjs

@@ -0,0 +1,188 @@
+import { execFileSync } from 'node:child_process'
+
+const MAX_QUERY_CHARS = 160
+const DEFAULT_MAX_RESULTS = 8
+const MAX_FILES_BUFFER = 16 * 1024 * 1024
+
+const STOP_WORDS = new Set([
+  'a', 'an', 'and', 'every', 'file', 'files', 'find', 'for', 'from', 'in',
+  'inside', 'is', 'locate', 'me', 'of', 'please', 'show', 'the', 'to', 'under',
+  'where', 'with',
+])
+
+const EXPANSIONS = Object.freeze({
+  api: ['endpoint', 'route', 'server'],
+  auth: ['login', 'session', 'oauth'],
+  component: ['card', 'panel', 'view', 'widget'],
+  config: ['configuration', 'settings'],
+  database: ['db', 'sql', 'schema'],
+  image: ['asset', 'gallery', 'media', 'photo', 'picture', 'thumbnail'],
+  library: ['catalog', 'collection', 'index', 'lib'],
+  login: ['auth', 'oauth', 'session'],
+  session: ['auth', 'login'],
+  style: ['css', 'theme'],
+  styles: ['css', 'theme'],
+  test: ['spec'],
+  tests: ['spec'],
+})
+
+const cleanQuery = (value) => String(value || '')
+  .replace(/[\u0000-\u001f\u007f]/g, ' ')
+  .replace(/\s+/g, ' ')
+  .trim()
+
+const unique = (values) => [...new Set(values.filter(Boolean))]
+const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+const normalizePath = (value) => String(value || '').replace(/\\/g, '/').replace(/^\.\//, '')
+const wordish = (value) => String(value || '').toLowerCase().replace(/[^\p{L}\p{N}]+/gu, ' ').trim()
+const pathContainsSegment = (path, segment) => `/${normalizePath(path).toLowerCase()}/`.includes(`/${segment.toLowerCase().replace(/^\/+|\/+$/g, '')}/`)
+
+function queryTokens(query) {
+  return unique((query.toLowerCase().match(/[\p{L}\p{N}][\p{L}\p{N}_-]*/gu) || [])
+    .map((token) => token.replace(/^[-_]+|[-_]+$/g, ''))
+    .filter((token) => token && !STOP_WORDS.has(token)))
+}
+
+function locationHints(query) {
+  return unique([...query.toLowerCase().matchAll(/\b(?:from|in|inside|under)\s+([\p{L}\p{N}_.\/-]+)/gu)]
+    .map((match) => match[1].replace(/^\/+|\/+$/g, ''))
+    .filter(Boolean))
+}
+
+function defaultRun(command, args, cwd) {
+  return execFileSync(command, args, {
+    cwd,
+    encoding: 'utf8',
+    timeout: command === 'rg' ? 1400 : 3000,
+    maxBuffer: MAX_FILES_BUFFER,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  })
+}
+
+function listedFiles(run, cwd) {
+  const raw = String(run('git', ['ls-files', '-z', '--cached', '--others', '--exclude-standard'], cwd) || '')
+  return unique(raw.split('\0').map(normalizePath).filter(Boolean))
+}
+
+function contentMatches(run, cwd, terms, knownFiles) {
+  const matches = new Map()
+  if (!terms.length) return matches
+  const pattern = terms.slice().sort((a, b) => b.length - a.length).map(escapeRegex).join('|')
+  let raw = ''
+  try {
+    raw = String(run('rg', [
+      '--json',
+      '--ignore-case',
+      '--max-count', '4',
+      '--no-messages',
+      '--regexp', pattern,
+      '.',
+    ], cwd) || '')
+  } catch {
+    // `rg` is the fast path. A host without it still gets filename/path search;
+    // repository search must never block the room or fall through to an LLM turn.
+    return matches
+  }
+  for (const line of raw.split(/\r?\n/)) {
+    if (!line) continue
+    let record
+    try { record = JSON.parse(line) } catch { continue }
+    if (record?.type !== 'match') continue
+    const path = normalizePath(record.data?.path?.text)
+    if (!knownFiles.has(path)) continue
+    const lineNumber = Number(record.data?.line_number)
+    const text = String(record.data?.lines?.text || '').toLowerCase()
+    const prior = matches.get(path)
+    if (!prior) matches.set(path, { line: Number.isFinite(lineNumber) ? lineNumber : null, text })
+    else prior.text += ` ${text}`
+  }
+  return matches
+}
+
+function candidateScore(path, original, expanded, content) {
+  const lowerPath = path.toLowerCase()
+  const base = lowerPath.split('/').at(-1) || lowerPath
+  const pathWords = ` ${wordish(lowerPath)} `
+  const contentText = content?.text || ''
+  let score = 0
+
+  const phrase = original.join(' ')
+  if (phrase && pathWords.includes(` ${phrase} `)) score += 100
+  for (const token of original) {
+    if (base.includes(token)) score += 30
+    if (lowerPath.includes(token)) score += 16
+    if (pathWords.includes(` ${token} `)) score += 8
+    if (contentText.includes(token)) score += 8
+  }
+  for (const token of expanded) {
+    if (base.includes(token)) score += 8
+    else if (lowerPath.includes(token)) score += 5
+    if (contentText.includes(token)) score += 2
+  }
+
+  const rootMatches = (haystack) => original.filter((token) =>
+    haystack.includes(token) || (EXPANSIONS[token] || []).some((alias) => haystack.includes(alias)))
+  const pathCoverage = rootMatches(lowerPath).length
+  const coverage = rootMatches(`${lowerPath} ${contentText}`).length
+  score += (coverage ** 2) * 18 + (pathCoverage ** 2) * 22
+
+  const ext = base.includes('.') ? base.slice(base.lastIndexOf('.')) : ''
+  const componentFile = ['.jsx', '.tsx', '.vue', '.svelte'].includes(ext)
+  if (original.includes('component') && componentFile) score += 60
+  if (original.some((token) => token === 'test' || token === 'tests') && /(?:^|\/)(?:test|tests|spec|specs)(?:\/|$)|\.(?:test|spec)\./.test(lowerPath)) score += 10
+  if (original.some((token) => token === 'asset' || token === 'assets') && /(?:^|\/)assets?(?:\/|$)/.test(lowerPath)) score += 10
+  const testPath = /(?:^|\/)(?:test|tests|spec|specs)(?:\/|$)|\.(?:test|spec)\./.test(lowerPath)
+  if (testPath && !original.some((token) => token === 'test' || token === 'tests')) score -= 25
+  if (/^(?:docs|marketing|archive|\.claude)\//.test(lowerPath)) score -= 35
+  if (/^(?:src|app|lib|api|bridge|server|client|components|packages)\//.test(lowerPath)) score += 12
+  return { score, coverage, pathCoverage, componentFile }
+}
+
+export function repoSearch({
+  cwd = process.cwd(),
+  query,
+  maxResults = DEFAULT_MAX_RESULTS,
+  run = defaultRun,
+  now = () => Date.now(),
+} = {}) {
+  const startedAt = now()
+  const cleaned = cleanQuery(query)
+  const finish = (result) => ({ ...result, durationMs: Math.max(0, Math.round(now() - startedAt)) })
+
+  if (!cleaned) return finish({ query: '', results: [], total: 0, truncated: false, error: 'Use /find followed by a filename, symbol, or code concept.' })
+  if (cleaned.length > MAX_QUERY_CHARS) return finish({ query: cleaned.slice(0, MAX_QUERY_CHARS), results: [], total: 0, truncated: false, error: `Keep /find queries under ${MAX_QUERY_CHARS} characters.` })
+
+  const original = queryTokens(cleaned)
+  if (!original.length) return finish({ query: cleaned, results: [], total: 0, truncated: false, error: 'Try a filename, symbol, or code concept.' })
+  const expanded = unique(original.flatMap((token) => EXPANSIONS[token] || []))
+
+  let files
+  try { files = listedFiles(run, cwd) } catch {
+    return finish({ query: cleaned, results: [], total: 0, truncated: false, error: 'Repository search is unavailable outside a readable Git checkout.' })
+  }
+  const activeLocations = locationHints(cleaned).filter((hint) => files.some((path) => pathContainsSegment(path, hint)))
+  const eligibleFiles = activeLocations.length
+    ? files.filter((path) => activeLocations.every((hint) => pathContainsSegment(path, hint)))
+    : files
+  const knownFiles = new Set(eligibleFiles)
+  const matches = contentMatches(run, cwd, unique([...original, ...expanded]), knownFiles)
+  const minimumCoverage = Math.max(1, Math.ceil(original.length * 0.6))
+  const ranked = eligibleFiles
+    .map((path) => {
+      const rank = candidateScore(path, original, expanded, matches.get(path))
+      return { path, line: matches.get(path)?.line || null, ...rank }
+    })
+    .filter((item) => item.score > 0 && (
+      item.coverage >= minimumCoverage
+      || (original.includes('component') && item.componentFile && item.coverage >= 2)
+    ))
+    .sort((a, b) => b.score - a.score || b.pathCoverage - a.pathCoverage || a.path.length - b.path.length || a.path.localeCompare(b.path))
+
+  const limit = Math.max(1, Math.min(20, Number(maxResults) || DEFAULT_MAX_RESULTS))
+  return finish({
+    query: cleaned,
+    results: ranked.slice(0, limit).map(({ path, line }) => ({ path, ...(line ? { line } : {}) })),
+    total: ranked.length,
+    truncated: ranked.length > limit,
+  })
+}