weavatrix 0.2.13 → 0.2.14

package/src/precision/lsp-overlay/store.js

@@ -0,0 +1,150 @@
+import {existsSync, readFileSync} from 'node:fs'
+import {dirname, resolve} from 'node:path'
+import {atomicWriteFileSync} from '../../graph/file-lock.js'
+import {edgeProvenance} from '../../graph/edge-provenance.js'
+import {
+  PRECISION_FILE,
+  PRECISION_OVERLAY_V,
+  baseOverlay,
+  endpoint,
+  precisionOverlayMatches,
+} from './contract.js'
+
+export function precisionPathForGraph(graphPath) {
+  return resolve(dirname(graphPath), PRECISION_FILE)
+}
+
+export function readPrecisionOverlay(graphPath, graph) {
+  const path = precisionPathForGraph(graphPath)
+  if (!existsSync(path)) return null
+  try {
+    const overlay = JSON.parse(readFileSync(path, 'utf8'))
+    return precisionOverlayMatches(overlay, graph) ? overlay : null
+  } catch { return null }
+}
+
+export function precisionSummary(overlay) {
+  if (!overlay) return {
+    state: 'UNAVAILABLE',
+    provider: null,
+    verifiedEdges: 0,
+    candidates: 0,
+    queried: 0,
+    reason: 'no revision-matched precision overlay',
+  }
+  const engine = Array.isArray(overlay.engines) ? overlay.engines[0] : null
+  return {
+    state: String(overlay.state || 'UNAVAILABLE'),
+    provider: engine?.provider || null,
+    providerVersion: engine?.version || null,
+    typescriptVersion: engine?.typescriptVersion || null,
+    verifiedEdges: Number(overlay.coverage?.verifiedEdges) || 0,
+    candidates: Number(overlay.coverage?.candidates) || 0,
+    selected: Number(overlay.coverage?.selected) || 0,
+    queried: Number(overlay.coverage?.queried) || 0,
+    references: Number(overlay.coverage?.references) || 0,
+    unclassifiedReferences: Number(overlay.coverage?.unclassifiedReferences) || 0,
+    referenceEvidence: Array.isArray(overlay.referenceEvidence) ? overlay.referenceEvidence.length : 0,
+    truncated: overlay.coverage?.truncated === true,
+    reason: overlay.reason || engine?.reason || null,
+    noReferenceSymbols: Array.isArray(overlay.noReferenceSymbols) ? overlay.noReferenceSymbols.length : 0,
+  }
+}
+
+export function mergePrecisionOverlay(graph, overlay) {
+  if (!precisionOverlayMatches(overlay, graph)) return {...graph, precision: precisionSummary(null)}
+  const nodes = Array.isArray(graph.nodes) ? graph.nodes : []
+  const ids = new Set(nodes.map((node) => String(node.id)))
+  const links = (Array.isArray(graph.links) ? graph.links : []).map((link) => ({...link}))
+  for (const exact of Array.isArray(overlay.links) ? overlay.links : []) {
+    const source = endpoint(exact.source)
+    const target = endpoint(exact.target)
+    if (!ids.has(source) || !ids.has(target) || source === target) continue
+    const relation = String(exact.relation || 'references')
+    const exactLine = Number.isInteger(exact.line) ? exact.line : null
+    const exactCharacter = Number.isInteger(exact.character) ? exact.character : null
+    let matched = false
+    for (const link of links) {
+      if (edgeProvenance(link) !== 'EXACT_LSP') continue
+      if (endpoint(link.source) !== source || endpoint(link.target) !== target
+        || String(link.relation || '') !== relation) continue
+      if (exactLine != null && (!Number.isInteger(link.line) || link.line !== exactLine)) continue
+      if (exactCharacter != null
+        && (!Number.isInteger(link.character) || link.character !== exactCharacter)) continue
+      link.provenance = 'EXACT_LSP'
+      link.confidence = 'EXACT_LSP'
+      link.precisionProvider = String(exact.provider || 'typescript-language-server')
+      if (exact.typeOnly === true) link.typeOnly = true
+      else delete link.typeOnly
+      if (exact.compileOnly === true) link.compileOnly = true
+      else delete link.compileOnly
+      matched = true
+      break
+    }
+    if (!matched) links.push({
+      source,
+      target,
+      relation: relation || 'references',
+      provenance: 'EXACT_LSP',
+      confidence: 'EXACT_LSP',
+      precisionProvider: String(exact.provider || 'typescript-language-server'),
+      ...(exact.typeOnly === true ? {typeOnly: true} : {}),
+      ...(exact.compileOnly === true ? {compileOnly: true} : {}),
+      ...(exactLine != null ? {line: exactLine} : {}),
+      ...(exactCharacter != null ? {character: exactCharacter} : {}),
+      ...(Number.isInteger(exact.endLine) ? {endLine: exact.endLine} : {}),
+      ...(Number.isInteger(exact.endCharacter) ? {endCharacter: exact.endCharacter} : {}),
+    })
+  }
+  return {
+    ...graph,
+    links,
+    precisionOverlayV: PRECISION_OVERLAY_V,
+    precision: precisionSummary(overlay),
+    precisionNoReferenceSymbols: Array.isArray(overlay.noReferenceSymbols)
+      ? overlay.noReferenceSymbols.filter((id) => ids.has(String(id))).map(String) : [],
+    precisionReferenceEvidence: Array.isArray(overlay.referenceEvidence)
+      ? overlay.referenceEvidence.filter((evidence) => ids.has(endpoint(evidence.source))
+        && ids.has(endpoint(evidence.target))).map((evidence) => ({
+        source: endpoint(evidence.source),
+        target: endpoint(evidence.target),
+        ...(Number.isInteger(evidence.line) ? {line: evidence.line} : {}),
+        ...(Number.isInteger(evidence.character) ? {character: evidence.character} : {}),
+        classification: String(evidence.classification || 'unknown'),
+        provider: String(evidence.provider || 'typescript-language-server'),
+      })) : [],
+  }
+}
+
+export function writePrecisionOverlay(graphPath, overlay) {
+  atomicWriteFileSync(precisionPathForGraph(graphPath), JSON.stringify(overlay), 'utf8')
+  return overlay
+}
+
+const SAFE_INVALIDATION_REASON = 'repository changed while semantic precision was running'
+
+export function invalidatePrecisionOverlay(graphPath, graph, reason = SAFE_INVALIDATION_REASON) {
+  if (!graphPath || !graph) throw new Error('precision invalidation requires graphPath and graph')
+  const previous = readPrecisionOverlay(graphPath, graph)
+  const safeReason = typeof reason === 'string'
+    && reason.length > 0 && reason.length <= 160
+    && /^[A-Za-z0-9 _.,()-]+$/.test(reason) ? reason : SAFE_INVALIDATION_REASON
+  const engines = (Array.isArray(previous?.engines) && previous.engines.length
+    ? previous.engines
+    : [{
+      provider: 'typescript-language-server', version: null,
+      language: 'typescript/javascript', capability: 'textDocument/references',
+    }]).map((engine) => ({...engine, status: 'PARTIAL'}))
+  return writePrecisionOverlay(graphPath, baseOverlay(graph, 'PARTIAL', {
+    ...(previous?.request ? {request: previous.request} : {}),
+    reason: safeReason,
+    engines,
+    coverage: {
+      candidates: 0, selected: 0, queried: 0, references: 0,
+      unclassifiedReferences: 0, verifiedEdges: 0, truncated: true,
+    },
+    links: [],
+    referenceEvidence: [],
+    noReferenceSymbols: [],
+  }))
+}

package/src/precision/lsp-overlay/target-index.js

@@ -0,0 +1,147 @@
+import {realpathSync} from 'node:fs'
+import {isAbsolute, relative, resolve, sep} from 'node:path'
+import {fileURLToPath} from 'node:url'
+import {edgeProvenance} from '../../graph/edge-provenance.js'
+import {isStructuralRelation} from '../../graph/relations.js'
+import {isPathInside} from '../../repo-path.js'
+import {JS_TS_FILE, endpoint, norm} from './contract.js'
+
+const lineNumber = (value) => {
+  const match = /L(\d+)/.exec(String(value || ''))
+  return match ? Number(match[1]) : 0
+}
+
+export function repoFileFromLocation(repoRoot, location) {
+  if (location?.file) {
+    try {
+      const root = realpathSync.native(repoRoot)
+      const path = realpathSync.native(resolve(root, String(location.file)))
+      if (!isPathInside(root, path)) return null
+      const rel = relative(root, path)
+      return rel && !rel.startsWith(`..${sep}`) && !isAbsolute(rel) ? norm(rel) : null
+    } catch { return null }
+  }
+  const uri = typeof location === 'string' ? location : location?.uri || location?.targetUri
+  if (!uri || !String(uri).startsWith('file:')) return null
+  try {
+    const root = realpathSync.native(repoRoot)
+    const path = realpathSync.native(fileURLToPath(uri))
+    if (!isPathInside(root, path)) return null
+    const rel = relative(root, path)
+    if (!rel || rel === '..' || rel.startsWith(`..${sep}`) || isAbsolute(rel)) return null
+    return norm(rel)
+  } catch { return null }
+}
+
+export function locationStart(location) {
+  return location?.range?.start || location?.targetSelectionRange?.start
+    || location?.targetRange?.start || null
+}
+
+const comparePosition = (left, right) => left.line - right.line || left.character - right.character
+
+export function symbolIndex(graph) {
+  const files = new Set()
+  const byFile = new Map()
+  for (const node of graph.nodes || []) {
+    const id = String(node.id)
+    const file = norm(node.source_file || (id.includes('#') ? id.slice(0, id.indexOf('#')) : id))
+    if (!file) continue
+    if (!id.includes('#')) files.add(file)
+    else {
+      const start = lineNumber(node.source_location) || Number(node.selection_start?.line) + 1 || 0
+      const end = lineNumber(node.source_end) || start
+      if (!start) continue
+      const range = node.source_range
+      const hasRange = Number.isInteger(range?.start?.line)
+        && Number.isInteger(range?.start?.character)
+        && Number.isInteger(range?.end?.line)
+        && Number.isInteger(range?.end?.character)
+      const rows = byFile.get(file) || []
+      rows.push({id, start, end: Math.max(start, end), ...(hasRange ? {range} : {})})
+      byFile.set(file, rows)
+    }
+  }
+  for (const rows of byFile.values()) rows.sort((a, b) => {
+    if (a.range && b.range) {
+      return comparePosition(b.range.start, a.range.start)
+        || comparePosition(a.range.end, b.range.end)
+        || a.id.localeCompare(b.id)
+    }
+    return (a.end - a.start) - (b.end - b.start) || b.start - a.start || a.id.localeCompare(b.id)
+  })
+  return {files, byFile}
+}
+
+export function sourceAt(index, file, position) {
+  if (!Number.isInteger(position?.line) || !Number.isInteger(position?.character)) {
+    return index.files.has(file) ? file : null
+  }
+  const line = position.line + 1
+  const rows = (index.byFile.get(file) || []).filter((row) => row.range
+    ? comparePosition(row.range.start, position) <= 0 && comparePosition(position, row.range.end) < 0
+    : row.start < line && line < row.end)
+  if (rows.length) {
+    const first = rows[0]
+    const span = first.range ? null : first.end - first.start
+    const tied = rows.filter((row) => {
+      if (first.range || row.range) return Boolean(first.range && row.range
+        && comparePosition(first.range.start, row.range.start) === 0
+        && comparePosition(first.range.end, row.range.end) === 0)
+      return row.end - row.start === span
+    })
+    if (tied.length === 1) return tied[0].id
+  }
+  return index.files.has(file) ? file : null
+}
+
+export function eligibleTargets(graph, limit, requestedIds = null) {
+  const byId = new Map((graph.nodes || []).map((node) => [String(node.id), node]))
+  if (Array.isArray(requestedIds) && requestedIds.length) {
+    const ids = [...new Set(requestedIds.map(String))]
+    const targets = ids.map((id) => byId.get(id))
+      .filter((node) => node?.selection_start && JS_TS_FILE.test(String(node.source_file || '')))
+      .slice(0, limit)
+    return {targets, total: ids.length, orphanIds: new Set()}
+  }
+  const ranked = new Map()
+  const inbound = new Set()
+  for (const link of graph.links || []) {
+    const relation = String(link.relation || '')
+    if (!isStructuralRelation(relation)) inbound.add(endpoint(link.target))
+    if (isStructuralRelation(relation)
+      || !['calls', 'references', 'inherits', 'implements'].includes(relation)) continue
+    if (edgeProvenance(link) === 'EXACT_LSP') continue
+    const target = endpoint(link.target)
+    const node = byId.get(target)
+    if (!node?.selection_start || !JS_TS_FILE.test(String(node.source_file || ''))) continue
+    const score = (relation === 'calls' ? 30 : relation === 'inherits' || relation === 'implements' ? 20 : 10)
+      + (edgeProvenance(link) === 'INFERRED' ? 8 : 0)
+    ranked.set(target, Math.max(ranked.get(target) || 0, score))
+  }
+  const orphans = new Set()
+  for (const node of byId.values()) {
+    const id = String(node.id)
+    const visibility = String(node.visibility || '').toLowerCase()
+    if (!node.selection_start || !JS_TS_FILE.test(String(node.source_file || '')) || inbound.has(id)) continue
+    if (node.exported === true || visibility === 'public' || visibility === 'protected') continue
+    if (!/\(\)$/.test(String(node.label || ''))
+      && !['function', 'method', 'constructor'].includes(String(node.symbol_kind || '').toLowerCase())) continue
+    if (!ranked.has(id)) { ranked.set(id, 4); orphans.add(id) }
+  }
+  const all = [...ranked.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+  const positive = all.filter(([id]) => !orphans.has(id))
+  const orphan = all.filter(([id]) => orphans.has(id))
+  const reserve = orphan.length ? Math.min(8, Math.ceil(limit / 4), limit) : 0
+  const selected = positive.slice(0, Math.max(0, limit - reserve))
+  selected.push(...orphan.slice(0, reserve))
+  if (selected.length < limit) {
+    const selectedIds = new Set(selected.map(([id]) => id))
+    selected.push(...all.filter(([id]) => !selectedIds.has(id)).slice(0, limit - selected.length))
+  }
+  return {
+    targets: selected.map(([id]) => byId.get(id)),
+    total: all.length,
+    orphanIds: new Set(orphan.map(([id]) => id)),
+  }
+}

package/src/precision/lsp-overlay/target-query.js

@@ -0,0 +1,55 @@
+import {isStructuralRelation} from '../../graph/relations.js'
+import {JS_TS_FILE, endpoint, norm} from './contract.js'
+import {
+  ensureBudget,
+  ensureFullUniverse,
+  ensureOpen,
+  requestReferences,
+} from './source-session.js'
+
+function supportFilesFor(session, target, relPath) {
+  const supportFiles = []
+  for (const link of session.graph.links || []) {
+    if (endpoint(link.target) !== String(target.id) || isStructuralRelation(link.relation)) continue
+    const sourceId = endpoint(link.source)
+    const sourceFile = norm(session.nodesById.get(sourceId)?.source_file
+      || (sourceId.includes('#') ? sourceId.slice(0, sourceId.indexOf('#')) : sourceId))
+    if (sourceFile && JS_TS_FILE.test(sourceFile)
+      && sourceFile !== relPath && !supportFiles.includes(sourceFile)) supportFiles.push(sourceFile)
+    if (supportFiles.length >= 12) break
+  }
+  return supportFiles
+}
+
+export async function queryPrecisionTarget(session, target) {
+  const relPath = norm(target.source_file)
+  await ensureOpen(session, relPath)
+  for (const file of supportFilesFor(session, target, relPath)) await ensureOpen(session, file)
+  if (session.universe.complete
+    && session.universe.files.every((file) => session.opened.has(file))) {
+    session.fullUniverseOpened = true
+  }
+  let locations = await requestReferences(session, relPath, target.selection_start)
+  if (!Array.isArray(locations)) throw new Error('language server returned an invalid references result')
+  session.queried++
+  if (locations.length !== 0) return locations
+  ensureBudget(session)
+  const configRel = session.semanticInputs.fileConfigs?.[relPath]
+  const project = configRel ? session.semanticInputs.projects?.[configRel] : null
+  const configuredFiles = [...new Set((project?.projectFiles || [])
+    .map(norm).filter((file) => JS_TS_FILE.test(file)))].sort()
+  const projectFiles = new Set(configuredFiles)
+  const exactlyCoversUniverse = session.universe.complete
+    && configuredFiles.length === session.universe.files.length
+    && session.universe.files.every((file) => projectFiles.has(file))
+  ensureBudget(session)
+  if (configRel && projectFiles.has(relPath) && exactlyCoversUniverse) {
+    const alreadyComplete = session.fullUniverseOpened
+    if (alreadyComplete || await ensureFullUniverse(session)) {
+      if (!alreadyComplete) locations = await requestReferences(session, relPath, target.selection_start)
+      if (!Array.isArray(locations)) throw new Error('language server returned an invalid references result')
+      if (locations.length === 0) session.noReferenceSymbols.push(String(target.id))
+    }
+  }
+  return locations
+}