weavatrix 0.3.10 → 0.3.11

package/README.md

@@ -186,10 +186,18 @@ realpath escapes. Report suspected vulnerabilities privately as described in [SE
 
 ## Languages
 
-JavaScript · TypeScript · TSX · Python · Go · Java · C# · Rust · HTML · CSS — parsed with
+JavaScript · TypeScript · TSX · Python · Go · Java · C# · Rust · Solidity · HTML · CSS — parsed with
 [web-tree-sitter](https://github.com/tree-sitter/tree-sitter) WASM grammars; no Python install and no
 native compilation.
 
+SQL is indexed without a grammar: `.sql` files contribute tables, views, columns, functions, indexes
+and triggers as first-class graph symbols, and SQL found in string literals of any other language
+links the enclosing function to the table it queries. That makes schema objects visible to
+`change_impact`/`get_dependents` (who touches this table?) and lets the dead-code check flag columns
+no statement references — conservatively: verdicts require literal-SQL evidence in the repo, and
+`SELECT *`-consumed tables never have their columns judged by name (ORM-generated SQL stays invisible
+and is therefore never judged either).
+
 Test surfaces are classified per file (path conventions plus `.weavatrix.json` overrides) and, for
 Rust, per symbol: `#[cfg(test)]` modules and `#[test]`/`#[bench]` items inside production `.rs` files
 carry a node-level `test_surface` flag, so dead-code, query, hot-path and hub tools treat them as
@@ -204,9 +212,9 @@ npm run benchmark        # full TS/JS/Python/Go/Java/Rust + MCP lifecycle gate
 npm run benchmark:real   # locally available real repos vs source-free 0.2.1 baselines
 ```
 
-Maintained JavaScript/TypeScript under `src`, `bin`, `scripts`, `test` (and HTML/CSS/JS under `site`)
-has a hard 300-line physical ceiling enforced by the release suite; larger concerns split into
-owner-focused modules behind slim facades.
+Maintained JavaScript/TypeScript under `src`, `bin`, `scripts`, `test` has a hard 300-line physical
+ceiling enforced by the release suite; larger concerns split into owner-focused modules behind slim
+facades. The weavatrix.com landing site lives in its own repository (`weavatrix-site`).
 
 ## Release history
 

package/docs/releases/v0.3.11.md

@@ -0,0 +1,55 @@
+# Weavatrix 0.3.11
+
+0.3.11 teaches the graph two new surfaces. SQL schemas become first-class graph
+citizens with honest, evidence-gated dead-code verdicts, and Solidity joins the
+parsed languages at zero dependency cost. The weavatrix.com site moved to its
+own repository, so the engine repo now ships engine only.
+
+## SQL: the graph reaches the database schema
+
+No SQL grammar ships in the pinned tree-sitter-wasms, so `.sql` indexing runs
+on a dependency-free statement scanner (a new `textOnly` language-module class)
+built for the graph's needs — symbols and references, not SQL semantics.
+String literals and comments are blanked before structural scanning, so quoted
+text can never fabricate a reference.
+
+- `CREATE TABLE`/`VIEW`/`FUNCTION`/`PROCEDURE`/`INDEX`/`TRIGGER` become graph
+  symbols; table columns (including `ALTER TABLE ADD COLUMN`) are member
+  symbols with `member_of`, and tables carry their columns as `field_types`.
+- References resolve inside `.sql` files (a view's `SELECT`, an index's `ON`
+  table, a trigger's `EXECUTE FUNCTION`, foreign-key `REFERENCES`) — and, the
+  real point, from application code: literal SQL found in string literals of
+  any indexed language links the enclosing function to the table it queries.
+  `change_impact` and `get_dependents` on a table now answer "which code
+  touches this?"
+- Dead-code verdicts stay honest. Schema objects are judged only when the
+  repository demonstrably uses literal SQL the scanner can read — an
+  ORM-driven repo produces silence, not guesses. Columns of a
+  `SELECT *`-consumed table are never judged by name, and indexes/triggers
+  (DB-engine surface) are never judged at all. A flagged column reports
+  "no SQL statement in the indexed sources references it".
+
+## Solidity
+
+The tree-sitter-solidity grammar already shipped inside the pinned
+tree-sitter-wasms package — 0.3.11 registers it (and pins its SHA-256 in the
+parser-artifact allowlist), so Solidity support adds zero new dependencies.
+Contracts, interfaces, libraries, functions, constructors, modifiers, events,
+errors, structs, enums and state variables are extracted with visibility and
+membership; `is` inheritance, modifier invocations, `emit`, `new Contract()`
+and `using X for Y` all feed the call/heritage resolvers. Imports resolve
+through relative paths, Foundry remappings (`remappings.txt` / `foundry.toml`)
+and root-anchored specs; npm-style specs (`@openzeppelin/...`) are recorded as
+external dependencies. `.sol` files share directory scope like Go/C#/Rust,
+which makes Solidity's plain `import "./Base.sol"` — a statement that names no
+symbols — resolvable for siblings without guessing.
+
+`extractorSchemaV` 6 → 7; cached graphs rebuild once, automatically.
+
+## Repository
+
+The weavatrix.com landing site (pages, Cloudflare Worker config, deploy
+workflow and its asset checks) moved byte-identically to the separate
+`weavatrix-site` repository, removing ~1.2 MB of page assets from the engine
+repo. The MCPB icon the site used to own is vendored at `mcpb/icon.png`; the
+published npm package contents are unchanged.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weavatrix",
-  "version": "0.3.10",
+  "version": "0.3.11",
   "type": "module",
   "description": "Local repository intelligence MCP for AI coding agents: an always-fresh architecture graph with production-first evidence — blast radius, dead code, endpoints, clones, history, Health and architecture safeguards, with honestly labeled precision.",
   "author": "Sergii Ziborov <sergii.ziborov@gmail.com>",
@@ -44,6 +44,7 @@
     "docs/releases/v0.3.8.md",
     "docs/releases/v0.3.9.md",
     "docs/releases/v0.3.10.md",
+    "docs/releases/v0.3.11.md",
     "docs/releases/v0.2.19.md",
     "README.md",
     "SECURITY.md",

package/src/analysis/dead-check.js

@@ -6,6 +6,7 @@
 // and is fully testable with no filesystem. It only needs {nodes, links} + source text. See [[graph-builder-internalization]].
 import { posix } from "node:path";
 import { isStructuralRelation } from "../graph/relations.js";
+import { createSqlDeadVerdict } from "../graph/builder/lang-sql.js";
 import { createPathClassifier, hasPathClass } from "../path-classification.js";
 
 const IDENT_RE = /[A-Za-z_$][\w$]*/g;
@@ -198,12 +199,11 @@ export function computeDead(graph, sources, { entrySet = new Set() } = {}) {
     return isDecorated(n);                                       // framework-registered via decorator
   };
 
+  const sqlVerdict = createSqlDeadVerdict({ nodes, links, ep, bareName });   // gated SQL verdicts — ORM blindness stays silent
   const deadSymbols = [];
   for (const n of symById.values()) {
-    if (isReferenced(n)) continue;
-    // test_surface: extractor-proven test-only symbols (Rust #[cfg(test)]) live in production paths.
-    const test = isTestFile(n.source_file) || n.test_surface === true;
-    deadSymbols.push({ id: n.id, file: n.source_file, label: n.label, test, reason: "no inbound edge and name unreferenced outside its file" });
+    if (isReferenced(n) || sqlVerdict.veto(n)) continue;
+    deadSymbols.push({ id: n.id, file: n.source_file, label: n.label, test: isTestFile(n.source_file) || n.test_surface === true, reason: sqlVerdict.reason(n) || "no inbound edge and name unreferenced outside its file" });
   }
   const deadSet = new Set(deadSymbols.map((s) => s.id));
 

package/src/graph/builder/lang-solidity.js

@@ -0,0 +1,126 @@
+// Solidity extractor. Symbols: contract/interface/library (space "both" so `is Base` heritage and
+// `new Vault()` both resolve through the value-space resolver), functions/constructors/modifiers/
+// events/errors/structs/enums/state vars (members carry memberOf + visibility). Imports: relative
+// paths, Foundry remappings (remappings.txt / foundry.toml), and root-anchored specs resolve to repo
+// files; everything else (npm-style @openzeppelin/…, absent lib/ submodules) is RECORDED as an
+// external import for dependency analysis. Calls: bare `f()`, modifier invocations, `emit Event(…)`,
+// `new Contract(…)`, and `using Lib for T` all feed the calls resolver. Same-dir symbols share scope
+// (see sharesDirScope): Solidity's flat project namespace makes plain `import "./Base.sol"` — which
+// names no symbols — resolvable for siblings without guessing; cross-dir plain imports still produce
+// the file-level import edge, so blast radius stays correct even where symbol edges are unknowable.
+import { specToPkg } from "./spec-pkg.js";
+
+const CONTAINERS = new Set(["contract_declaration", "interface_declaration", "library_declaration"]);
+const KIND_BY_CONTAINER = {
+  contract_declaration: "contract",
+  interface_declaration: "interface",
+  library_declaration: "library",
+};
+// external/public functions are the deployed ABI — callable by any transaction, not just repo code.
+const VISIBILITY = { external: "public", public: "public", internal: "protected", private: "private" };
+
+function enclosingContainer(node) {
+  for (let parent = node?.parent; parent; parent = parent.parent) {
+    if (CONTAINERS.has(parent.type)) return parent;
+  }
+  return null;
+}
+
+const identifierOf = (node) => node?.namedChildren?.find((child) => child.type === "identifier") || null;
+const childOfType = (node, type) => node?.namedChildren?.find((child) => child.type === type) || null;
+const parameterCount = (node) => (node?.namedChildren || []).filter((child) => child.type === "parameter").length;
+
+export default {
+  family: "solidity",
+  grammars: ["solidity"],
+  exts: { ".sol": "solidity" },
+  isWeb: false,
+  calls: `[(call_expression (identifier) @callee) (modifier_invocation (identifier) @callee) (emit_statement (identifier) @callee) (new_expression (type_name (user_defined_type (identifier) @callee))) (using_directive (type_alias (identifier) @callee))]`,
+  heritage: [`(inheritance_specifier (user_defined_type (identifier) @base))`],
+
+  pass1(ctx) {
+    const { grammar, tree, fileRel, caps, addSym, addImportEdge, addExternalImport, imports, links, nameToId, resolveSolidityImport } = ctx;
+
+    // ---- containers (contract/interface/library) ----
+    for (const cap of caps(grammar, `[(contract_declaration (identifier) @c) (interface_declaration (identifier) @c) (library_declaration (identifier) @c)]`, tree.rootNode)) {
+      addSym(cap.node.text, cap.node.startPosition.row + 1, false, {
+        sourceNode: cap.node.parent,
+        selectionNode: cap.node,
+        symbolKind: KIND_BY_CONTAINER[cap.node.parent.type],
+        symbolSpace: "both",
+        exported: true,
+        moduleDeclaration: true,
+      });
+    }
+
+    // ---- functions (free + members), constructors, modifiers ----
+    const ownedMembers = [];
+    const addMember = (name, node, selection, extra) => {
+      const container = enclosingContainer(node);
+      const ownerName = container ? identifierOf(container)?.text || null : null;
+      const id = addSym(name, (selection || node).startPosition.row + 1, extra.callable !== false, {
+        sourceNode: node,
+        selectionNode: selection || undefined,
+        ...(ownerName ? { memberOf: ownerName } : { exported: true, moduleDeclaration: true }),
+        ...extra,
+      });
+      if (ownerName && id) ownedMembers.push({ ownerName, id });
+      return id;
+    };
+    for (const cap of caps(grammar, `(function_definition (identifier) @fn)`, tree.rootNode)) {
+      const definition = cap.node.parent;
+      const visibility = VISIBILITY[childOfType(definition, "visibility")?.text || ""];
+      addMember(cap.node.text, definition, cap.node, {
+        symbolKind: enclosingContainer(definition) ? "method" : "function",
+        ...(visibility ? { visibility } : {}),
+        parameterCount: parameterCount(definition),
+      });
+    }
+    for (const cap of caps(grammar, `(constructor_definition) @ctor`, tree.rootNode))
+      addMember("constructor", cap.node, null, { symbolKind: "constructor", parameterCount: parameterCount(cap.node) });
+    for (const cap of caps(grammar, `(modifier_definition (identifier) @m)`, tree.rootNode))
+      addMember(cap.node.text, cap.node.parent, cap.node, { symbolKind: "modifier", parameterCount: parameterCount(cap.node.parent) });
+
+    // ---- data/type declarations ----
+    for (const cap of caps(grammar, `[(event_definition (identifier) @n) (error_declaration (identifier) @n)]`, tree.rootNode))
+      addMember(cap.node.text, cap.node.parent, cap.node, { callable: false, symbolKind: cap.node.parent.type === "event_definition" ? "event" : "error" });
+    for (const cap of caps(grammar, `[(struct_declaration (identifier) @n) (enum_declaration (identifier) @n)]`, tree.rootNode))
+      addMember(cap.node.text, cap.node.parent, cap.node, { callable: false, symbolKind: cap.node.parent.type === "struct_declaration" ? "struct" : "enum", symbolSpace: "both" });
+    // capture the DECLARATION and take its first identifier child (the name): an initializer such as
+    // `uint x = OTHER_CONST;` can place a second bare identifier under the same declaration node.
+    for (const cap of caps(grammar, `(constant_variable_declaration) @d`, tree.rootNode)) {
+      const name = identifierOf(cap.node);
+      if (name) addMember(name.text, cap.node, name, { callable: false, symbolKind: "constant" });
+    }
+    for (const cap of caps(grammar, `(state_variable_declaration) @d`, tree.rootNode)) {
+      const name = identifierOf(cap.node);
+      const visibility = VISIBILITY[childOfType(cap.node, "visibility")?.text || ""] || "protected"; // Solidity default: internal
+      if (name) addMember(name.text, cap.node, name, { callable: false, symbolKind: "variable", visibility });
+    }
+    for (const member of ownedMembers) {
+      const ownerId = nameToId.get(member.ownerName);
+      if (ownerId) links.push({ source: ownerId, target: member.id, relation: "contains", confidence: "EXTRACTED" });
+    }
+
+    // ---- imports ----
+    for (const cap of caps(grammar, `(import_directive) @imp`, tree.rootNode)) {
+      const specNode = childOfType(cap.node, "string");
+      if (!specNode) continue;
+      const spec = specNode.text.replace(/^["']|["']$/g, "");
+      const line = specNode.startPosition.row + 1;
+      const target = resolveSolidityImport(fileRel, spec);
+      if (target) {
+        addImportEdge(target, { specifier: spec, line });
+        // `import {A, B} from "./x.sol"` — bind each named symbol. A lone identifier may instead be a
+        // `* as Alias` namespace name; binding it the same way is harmless (no same-named symbol → no edge).
+        for (const named of cap.node.namedChildren.filter((child) => child.type === "identifier"))
+          imports.set(named.text, { imported: named.text, targetFile: target });
+        continue;
+      }
+      if (spec.startsWith(".")) { addExternalImport({ spec, kind: "sol-import", line, unresolved: true }); continue; }
+      const r = specToPkg(spec);
+      if (r) addExternalImport({ spec, pkg: r.pkg, builtin: false, kind: "sol-import", line });
+      else addExternalImport({ spec, kind: "sol-import", line, unresolved: true });
+    }
+  },
+};

package/src/graph/builder/lang-sql.js

@@ -0,0 +1,263 @@
+// SQL extractor. No SQL grammar ships in the pinned tree-sitter-wasms, so this module is textOnly:
+// a dependency-free statement scanner built for the graph's needs (symbols + references), NOT a SQL
+// parser. Symbols: CREATE TABLE/VIEW (+ columns as member symbols, ALTER TABLE ADD COLUMN included),
+// FUNCTION/PROCEDURE, INDEX, TRIGGER. References: FROM/JOIN/INSERT INTO/UPDATE…SET/DELETE FROM/
+// TRUNCATE/REFERENCES/EXECUTE FUNCTION/CALL inside .sql files, plus the same verbs found in string
+// literals of every other indexed language (scanEmbeddedSql) — that is what ties the code graph to
+// the database schema: a query in app code becomes a `references` edge onto the table it touches.
+// Known blind spots (kept honest downstream, see dead-check.js): ORM-generated SQL is invisible,
+// `SELECT *` consumes columns namelessly (tables get sql_star), DROP statements are not replayed.
+// String literals and comments are blanked before structural scanning so a quoted "SELECT" can
+// never fabricate a reference; dollar-quoted function bodies stay scannable on purpose.
+
+const NAME = String.raw`((?:[\`"\[]?[A-Za-z_][\w$]*[\`"\]]?\.)*[\`"\[]?[A-Za-z_][\w$]*[\`"\]]?)`;
+const cleanName = (raw) => String(raw || "").replace(/[`"\[\]]/g, "").split(".").pop();
+const CONSTRAINT_START = /^(?:CONSTRAINT|PRIMARY|FOREIGN|UNIQUE|CHECK|EXCLUDE|KEY|INDEX|LIKE|PERIOD)\b/i;
+
+// strings ('…' with '' doubling) and comments (-- …, /* … */) become spaces of equal length,
+// so offsets/line numbers survive and quoted text can't match structural patterns.
+function sanitizeSql(text) {
+  const out = text.split("");
+  let i = 0;
+  const blank = (from, to) => { for (let k = from; k < to; k++) if (out[k] !== "\n") out[k] = " "; };
+  while (i < text.length) {
+    const ch = text[i], next = text[i + 1];
+    if (ch === "-" && next === "-") { let j = i; while (j < text.length && text[j] !== "\n") j++; blank(i, j); i = j; continue; }
+    if (ch === "/" && next === "*") { let j = text.indexOf("*/", i + 2); j = j < 0 ? text.length : j + 2; blank(i, j); i = j; continue; }
+    if (ch === "'") {
+      let j = i + 1;
+      while (j < text.length) { if (text[j] === "'") { if (text[j + 1] === "'") { j += 2; continue; } break; } j++; }
+      blank(i + 1, Math.min(j, text.length)); i = j + 1; continue;
+    }
+    i++;
+  }
+  return out.join("");
+}
+
+const lineIndex = (text) => {
+  const starts = [0];
+  for (let i = 0; i < text.length; i++) if (text[i] === "\n") starts.push(i + 1);
+  return (offset) => {
+    let lo = 0, hi = starts.length - 1;
+    while (lo < hi) { const mid = (lo + hi + 1) >> 1; if (starts[mid] <= offset) lo = mid; else hi = mid - 1; }
+    return lo + 1;
+  };
+};
+
+// split a CREATE TABLE body on top-level commas, keeping each part's offset
+function splitColumns(body, base) {
+  const parts = [];
+  let depth = 0, start = 0;
+  for (let i = 0; i < body.length; i++) {
+    const ch = body[i];
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    else if (ch === "," && depth === 0) { parts.push({ text: body.slice(start, i), offset: base + start }); start = i + 1; }
+  }
+  parts.push({ text: body.slice(start), offset: base + start });
+  return parts;
+}
+
+const REF_PATTERNS = [
+  new RegExp(String.raw`\bFROM\s+${NAME}`, "gi"),
+  new RegExp(String.raw`\bJOIN\s+${NAME}`, "gi"),
+  new RegExp(String.raw`\bINSERT\s+INTO\s+${NAME}`, "gi"),
+  new RegExp(String.raw`\bMERGE\s+INTO\s+${NAME}`, "gi"),
+  new RegExp(String.raw`\bUPDATE\s+(?:ONLY\s+)?${NAME}\s+SET\b`, "gi"),
+  new RegExp(String.raw`\bTRUNCATE\s+(?:TABLE\s+)?${NAME}`, "gi"),
+  new RegExp(String.raw`\bREFERENCES\s+${NAME}`, "gi"),
+  new RegExp(String.raw`\bEXECUTE\s+(?:FUNCTION|PROCEDURE)\s+${NAME}`, "gi"),
+];
+const STAR_RE = /\bSELECT\s+(?:[A-Za-z_]\w*\.)?\*/i;
+
+export default {
+  family: "sql",
+  grammars: [],
+  exts: { ".sql": "sql" },
+  isWeb: false,
+  textOnly: true,
+  calls: null,
+  heritage: [],
+
+  pass1(ctx) {
+    const { fileRel, code, addSym, links, sqlRefs } = ctx;
+    const text = sanitizeSql(String(code || ""));
+    const lineOf = lineIndex(text);
+    const fakeNode = (startOffset, endOffset) => ({
+      startPosition: { row: lineOf(startOffset) - 1, column: 0 },
+      endPosition: { row: lineOf(Math.max(startOffset, endOffset - 1)) - 1, column: 0 },
+    });
+
+    // statements with offsets (';' inside dollar-quoted bodies splits early — refs/lines still land right)
+    const statements = [];
+    let cursor = 0;
+    while (cursor <= text.length) {
+      let end = text.indexOf(";", cursor);
+      if (end < 0) end = text.length;
+      if (text.slice(cursor, end).trim()) statements.push({ text: text.slice(cursor, end), offset: cursor });
+      cursor = end + 1;
+    }
+
+    const addRef = (table, offset, star) => {
+      const name = cleanName(table);
+      if (/^[A-Za-z_][\w$]*$/.test(name)) sqlRefs.push({ file: fileRel, line: lineOf(offset), table: name, star: !!star });
+    };
+
+    for (const stmt of statements) {
+      const at = (m) => stmt.offset + m.index;
+      const definedHere = new Set();
+      const defineSym = (raw, m, callable, extra) => {
+        const name = cleanName(raw);
+        definedHere.add(name);
+        return addSym(name, lineOf(at(m)), callable, {
+          sourceNode: fakeNode(at(m), stmt.offset + stmt.text.length),
+          exported: true, moduleDeclaration: true, ...extra,
+        });
+      };
+
+      let m;
+      if ((m = stmt.text.match(new RegExp(String.raw`\bCREATE\s+(?:GLOBAL\s+|LOCAL\s+)?(?:TEMP(?:ORARY)?\s+|UNLOGGED\s+)?TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?${NAME}\s*\(`, "i")))) {
+        const tableName = cleanName(m[1]);
+        const open = stmt.offset + m.index + m[0].length - 1;
+        let depth = 0, close = open;
+        for (let i = open; i < text.length; i++) { if (text[i] === "(") depth++; else if (text[i] === ")" && --depth === 0) { close = i; break; } }
+        const fieldTypes = {};
+        const columns = [];
+        for (const part of splitColumns(text.slice(open + 1, close), open + 1)) {
+          const trimmed = part.text.trim();
+          if (!trimmed || CONSTRAINT_START.test(trimmed)) continue;
+          const col = trimmed.match(new RegExp(String.raw`^${NAME}\s+([A-Za-z_]\w*(?:\([^)]*\))?)`));
+          if (!col) continue;
+          const colName = cleanName(col[1]);
+          if (!/^[A-Za-z_][\w$]*$/.test(colName)) continue;
+          fieldTypes[colName] = col[2];
+          columns.push({ name: colName, offset: part.offset + part.text.indexOf(col[1]) });
+        }
+        const tableId = defineSym(m[1], m, false, { symbolKind: "table", fieldTypes });
+        for (const column of columns) {
+          const columnId = addSym(column.name, lineOf(column.offset), false, {
+            sourceNode: fakeNode(column.offset, column.offset + 1),
+            symbolKind: "column", memberOf: tableName,
+          });
+          if (tableId && columnId) links.push({ source: tableId, target: columnId, relation: "contains", confidence: "EXTRACTED" });
+        }
+      } else if ((m = stmt.text.match(new RegExp(String.raw`\bCREATE\s+(?:OR\s+REPLACE\s+)?(?:MATERIALIZED\s+)?VIEW\s+(?:IF\s+NOT\s+EXISTS\s+)?${NAME}`, "i")))) {
+        defineSym(m[1], m, false, { symbolKind: "view" });
+      } else if ((m = stmt.text.match(new RegExp(String.raw`\bCREATE\s+(?:OR\s+REPLACE\s+)?(?:FUNCTION|PROCEDURE)\s+${NAME}`, "i")))) {
+        defineSym(m[1], m, true, { symbolKind: "function" });
+      } else if ((m = stmt.text.match(new RegExp(String.raw`\bCREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:CONCURRENTLY\s+)?(?:IF\s+NOT\s+EXISTS\s+)?${NAME}\s+ON\s+(?:ONLY\s+)?${NAME}`, "i")))) {
+        defineSym(m[1], m, false, { symbolKind: "index" });
+        addRef(m[2], at(m), false);
+      } else if ((m = stmt.text.match(new RegExp(String.raw`\bCREATE\s+(?:OR\s+REPLACE\s+)?(?:CONSTRAINT\s+)?TRIGGER\s+${NAME}[\s\S]*?\bON\s+${NAME}`, "i")))) {
+        defineSym(m[1], m, false, { symbolKind: "trigger" });
+        addRef(m[2], at(m), false);
+      } else if ((m = stmt.text.match(new RegExp(String.raw`\bALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?(?:ONLY\s+)?${NAME}`, "i")))) {
+        const tableName = cleanName(m[1]);
+        addRef(m[1], at(m), false);
+        const addColumn = new RegExp(String.raw`\bADD\s+(?:COLUMN\s+)?(?:IF\s+NOT\s+EXISTS\s+)?(?!CONSTRAINT\b|PRIMARY\b|FOREIGN\b|UNIQUE\b|CHECK\b|EXCLUDE\b)${NAME}\s+[A-Za-z_]`, "gi");
+        for (const colMatch of stmt.text.matchAll(addColumn)) {
+          const colName = cleanName(colMatch[1]);
+          if (!/^[A-Za-z_][\w$]*$/.test(colName)) continue;
+          addSym(colName, lineOf(stmt.offset + colMatch.index), false, {
+            sourceNode: fakeNode(stmt.offset + colMatch.index, stmt.offset + colMatch.index + 1),
+            symbolKind: "column", memberOf: tableName,
+          });
+        }
+      }
+
+      const star = STAR_RE.test(stmt.text);
+      for (const pattern of REF_PATTERNS) {
+        pattern.lastIndex = 0;
+        for (const refMatch of stmt.text.matchAll(pattern)) {
+          const name = cleanName(refMatch[1]);
+          if (!definedHere.has(name)) addRef(refMatch[1], stmt.offset + refMatch.index, star);
+        }
+      }
+    }
+  },
+};
+
+// SQL verbs inside string literals of any host language — the cross-link between app code and schema.
+// Runs on RAW text (strings are exactly where the queries live); comments can over-match, which only
+// errs toward "referenced" and carries INFERRED confidence.
+const EMBEDDED = [
+  { re: new RegExp(String.raw`\bSELECT\b[^;]{0,2000}?\bFROM\s+${NAME}`, "gi"), star: true },
+  { re: new RegExp(String.raw`\bINSERT\s+INTO\s+${NAME}`, "gi") },
+  { re: new RegExp(String.raw`\bUPDATE\s+${NAME}\s+SET\b`, "gi") },
+  { re: new RegExp(String.raw`\bDELETE\s+FROM\s+${NAME}`, "gi") },
+  { re: new RegExp(String.raw`\bJOIN\s+${NAME}\b`, "gi") },
+  { re: new RegExp(String.raw`\bCALL\s+${NAME}\s*\(`, "gi") },
+];
+const EMBEDDED_PREFILTER = /\b(?:select|insert|update|delete|join|call)\b/i;
+
+export function scanEmbeddedSql(code, fileRel, sqlRefs) {
+  const text = String(code || "");
+  if (!EMBEDDED_PREFILTER.test(text)) return;
+  const lineOf = lineIndex(text);
+  for (const { re, star } of EMBEDDED) {
+    re.lastIndex = 0;
+    for (const m of text.matchAll(re)) {
+      const name = cleanName(m[1]);
+      if (!/^[A-Za-z_][\w$]*$/.test(name)) continue;
+      sqlRefs.push({ file: fileRel, line: lineOf(m.index), table: name, star: !!(star && STAR_RE.test(m[0])) });
+    }
+  }
+}
+
+// Dead-code policy for SQL schema objects, consumed by analysis/dead-check.js. Static liveness can
+// only be judged where the repo demonstrably uses literal SQL the scanner can read: without a single
+// embedded-SQL edge from host code, DB consumers (ORMs, external services) are invisible and every
+// verdict would be a guess. Indexes and triggers are DB-engine surface — never judged. Columns of a
+// `SELECT *`-consumed table are consumed namelessly — never judged by name.
+export function createSqlDeadVerdict({ nodes, links, ep, bareName }) {
+  const usageFromCode = links.some((l) => l.usage === "sql" && !String(ep(l.source)).split("#")[0].endsWith(".sql"));
+  const starTables = new Set(nodes.filter((n) => n.sql_star).map((n) => bareName(n.label)));
+  const classify = (n) => {
+    if (!String(n.source_file || "").endsWith(".sql")) return null;
+    const kind = String(n.symbol_kind || "");
+    if (kind === "index" || kind === "trigger" || !usageFromCode) return "veto";
+    if (kind === "column" && starTables.has(String(n.member_of || ""))) return "veto";
+    return "flag";
+  };
+  return {
+    veto: (n) => classify(n) === "veto",
+    reason: (n) => (classify(n) === "flag" ? "no SQL statement in the indexed sources references it" : null),
+  };
+}
+
+// After both passes: resolve collected refs against every table/view/function DEFINED in .sql files.
+// Unknown names drop silently — only schema objects the repo actually declares can gain edges.
+export function resolveSqlReferences({ sqlRefs, links, nodeById, perFileSymbols }) {
+  if (!sqlRefs?.length) return;
+  const index = new Map();
+  for (const [file, syms] of perFileSymbols) {
+    if (!file.endsWith(".sql")) continue;
+    for (const sym of syms) {
+      if (!["table", "view", "function"].includes(sym.symbolKind)) continue;
+      (index.get(sym.name) || index.set(sym.name, []).get(sym.name)).push(sym.id);
+    }
+  }
+  if (!index.size) return;
+  const enclosing = (file, line) => {
+    let best = null;
+    for (const symbol of perFileSymbols.get(file) || []) {
+      if (line < symbol.start || line > symbol.end) continue;
+      if (!best || symbol.start > best.start || (symbol.start === best.start && symbol.end < best.end)) best = symbol;
+    }
+    return best;
+  };
+  const seen = new Set();
+  for (const ref of sqlRefs) {
+    const targets = index.get(ref.table);
+    if (!targets) continue;
+    const source = enclosing(ref.file, ref.line)?.id || ref.file;
+    for (const target of targets) {
+      if (ref.star) { const node = nodeById.get(target); if (node) node.sql_star = true; }
+      if (target === source) continue;
+      const key = source + ">" + target;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      links.push({ source, target, relation: "references", confidence: "INFERRED", usage: "sql", line: ref.line });
+    }
+  }
+}

package/src/graph/builder/pass2-resolution.js

@@ -1,6 +1,8 @@
 export function createPass2Resolution({symIdsByFileName, nodeById, importedLocals, symByFileName}) {
     const dirSymbols = new Map(), dirMethods = new Map(), dirMethodsByName = new Map(), dirTypes = new Map()
-    const sharesDirScope = (file) => file.endsWith('.go') || file.endsWith('.cs') || file.endsWith('.rs')
+    // .sol shares dir scope because Solidity's project namespace is flat: `import "./Base.sol"` names no
+    // symbols yet pulls every declaration into scope, so same-dir name resolution is the honest static proxy.
+    const sharesDirScope = (file) => file.endsWith('.go') || file.endsWith('.cs') || file.endsWith('.rs') || file.endsWith('.sol')
     for (const [file, names] of symIdsByFileName) {
         if (!sharesDirScope(file)) continue
         const dir = file.includes('/') ? file.slice(0, file.lastIndexOf('/')) : ''

package/src/graph/freshness-probe.js

@@ -27,7 +27,7 @@ const CURRENT_GRAPH_SCHEMA = Object.freeze({
     barrelResolutionV: 1,
     reExportOccurrencesV: 1,
     symbolSpacesV: 1,
-    extractorSchemaV: 6,
+    extractorSchemaV: 7,
 })
 const CONTROL_FILES = ['.gitignore', '.weavatrixignore', '.weavatrix.json']
 const MAX_CONTROL_BYTES = 1_000_000

package/src/graph/incremental-refresh.js

@@ -184,7 +184,7 @@ export async function refreshGraphIncrementally(repoDir, existingGraph, {
 
   if (!existingGraph || !existingGraph.fileHashes || !existingGraph.fileExportSignatures
     || !existingGraph.controlHashes || !existingGraph.jsExportRecords || Number(existingGraph.barrelResolutionV) < 1
-    || Number(existingGraph.extractorSchemaV) < 6 || Number(existingGraph.physicalFileLocV) < 1
+    || Number(existingGraph.extractorSchemaV) < 7 || Number(existingGraph.physicalFileLocV) < 1
     || Number(existingGraph.reExportOccurrencesV) < 1
     || Number(existingGraph.symbolSpacesV) < 1 || Number(existingGraph.edgeProvenanceV) < 1) {
     return full("incremental-baseline-unavailable");

package/src/graph/internal-builder.build.js

@@ -8,6 +8,7 @@ import { specToPkg } from "./builder/spec-pkg.js";
 import { analyzeSyntaxComplexity } from "../analysis/source-complexity.js";
 import { Parser, Query, GRAMMARS, LANGS, EXT_LANG, FAMILY, isDataFile, isDocFile, MAX_PARSE_BYTES, ensureParser, walk } from "./internal-builder.langs.js";
 import { buildResolvers } from "./internal-builder.resolvers.js";
+import { scanEmbeddedSql, resolveSqlReferences } from "./builder/lang-sql.js";
 import { assignDeterministicCommunities } from "./community.js";
 import { snapshotRepository } from "./incremental-refresh.js";
 import { EDGE_PROVENANCE_V, stampEdgeProvenance } from "./edge-provenance.js";
@@ -72,6 +73,9 @@ export async function buildInternalGraph(repoDir, opts = {}) {
   // Bare-package imports (axios, node:fs, @scope/x) — the graph can't resolve them to a repo file, but
   // dependency analysis NEEDS them (unused/missing deps). Additive top-level array; nodes/links untouched.
   const externalImports = [];
+  // SQL references (from .sql statements AND string literals in host-language code) collect during
+  // pass 1 and resolve after both passes, once every schema object the repo declares is indexed.
+  const sqlRefs = [];
 
   const resolvers = buildResolvers(repoDir, fileSet);          // aliases, go.mod, java index, href, selectors
   const { selectorIndex, htmlUsages } = resolvers;
@@ -90,13 +94,16 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     }  // config/infra/docs file-only node
     let code; try { code = readFileSync(abs, "utf8"); } catch { addNode(fileNode); continue; }
     addNode({ ...fileNode, physical_loc: physicalLineCount(code) });
-    const grammar = EXT_LANG[ext]; const lang = LANGS[FAMILY[grammar]]; if (!lang || !langs[grammar]) continue;
+    const grammar = EXT_LANG[ext]; const lang = LANGS[FAMILY[grammar]]; if (!lang || (!langs[grammar] && !lang.textOnly)) continue;
     // giant / generated / minified file → keep the file NODE but don't parse symbols (avoids a wedged parse)
     if (code.length > MAX_PARSE_BYTES) { perFileSymbols.set(fileRel, []); symByFileName.set(fileRel, new Map()); symIdsByFileName.set(fileRel, new Map()); continue; }
     if ((++_parsed % 24) === 0) await new Promise((r) => setImmediate(r)); // breathe: let the UI paint between chunks
     if (typeof opts.onParseFile === "function") opts.onParseFile(fileRel);
-    const parser = new Parser(); parser.setLanguage(langs[grammar]);
-    let tree; try { tree = parser.parse(code); } catch { continue; }
+    let tree = null;   // textOnly languages (SQL) scan `code` directly — no grammar, no parse
+    if (!lang.textOnly) {
+      const parser = new Parser(); parser.setLanguage(langs[grammar]);
+      try { tree = parser.parse(code); } catch { continue; }
+    }
 
     const syms = []; const nameToId = new Map(); const nameToIds = new Map(); const moduleNameToId = new Map();
     const addSym = (name, line, callable, extra) => {
@@ -214,8 +221,10 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     // Post-hoc export flag (export {a}, export default X, CJS module.exports) — declarations are flagged at addSym time.
     const markExported = (name) => { const id = moduleNameToId.get(name); const n = id && nodeById.get(id); if (n) n.exported = true; };
 
-    try { lang.pass1({ grammar, tree, fileRel, code, caps, field, addSym, addNode, links, nodeIds, syms, nameToId, imports, addImportEdge, addExternalImport, markExported, recordJsExport, fileSet, ...resolvers }); }
+    try { lang.pass1({ grammar, tree, fileRel, code, caps, field, addSym, addNode, links, nodeIds, syms, nameToId, imports, addImportEdge, addExternalImport, markExported, recordJsExport, fileSet, sqlRefs, ...resolvers }); }
     catch (e) { /* one bad file never sinks the whole build */ void e; }
+    // string-literal SQL in host-language code → schema reference candidates (resolved post-pass-2)
+    if (!lang.textOnly && !lang.isWeb) try { scanEmbeddedSql(code, fileRel, sqlRefs); } catch { /* never sinks the build */ }
 
     syms.sort((a, b) => a.start - b.start);
     const eof = code.split("\n").length;
@@ -223,7 +232,7 @@ export async function buildInternalGraph(repoDir, opts = {}) {
       if (!syms[i].end || syms[i].end < syms[i].start) syms[i].end = i + 1 < syms.length ? syms[i + 1].start - 1 : eof;
     }
     perFileSymbols.set(fileRel, syms); symByFileName.set(fileRel, nameToId); symIdsByFileName.set(fileRel, nameToIds);
-    tree.delete();
+    if (tree) tree.delete();
   }
 
   // ---- pass 2: scope-aware calls + inheritance (Go package = whole dir → same-dir symbols share scope;
@@ -243,6 +252,8 @@ export async function buildInternalGraph(repoDir, opts = {}) {
       links.push({ source: u.htmlFile, target: cssFile, relation: "references", confidence: "INFERRED" });
     }
   }
+  // code/SQL → schema-object edges (tables/views/functions declared in .sql files)
+  try { resolveSqlReferences({ sqlRefs, links, nodeById, perFileSymbols }); } catch { /* never sinks the build */ }
 
   // community = folder bucket (top 2 path parts) — deterministic, mirrors the folder-based module grouping the
   // app already uses (graph-builder-analysis.js). Populates Modules/community cards without a heavy clustering pass.
@@ -266,7 +277,7 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     barrelResolutionV: 1,
     reExportOccurrencesV: 1,
     symbolSpacesV: 1,
-    extractorSchemaV: 6,
+    extractorSchemaV: 7,   // v7 = Solidity + SQL indexing (schema objects, embedded-SQL edges)
     reExportOccurrences,
     jsExportRecords: Object.fromEntries([...jsExports.entries()].sort(([a], [b]) => a.localeCompare(b))),
     fileHashes: snapshot.fileHashes,

package/src/graph/internal-builder.langs.js

@@ -16,6 +16,8 @@ import LANG_GO from "./builder/lang-go.js";
 import LANG_JAVA from "./builder/lang-java.js";
 import LANG_CSHARP from "./builder/lang-csharp.js";
 import LANG_RUST from "./builder/lang-rust.js";
+import LANG_SOLIDITY from "./builder/lang-solidity.js";
+import LANG_SQL from "./builder/lang-sql.js";
 import LANG_HTML from "./builder/lang-html.js";
 import LANG_CSS from "./builder/lang-css.js";
 
@@ -27,7 +29,7 @@ const NODE_MODULES = dirname(WTS_DIR);
 const DEFAULT_WASM_DIR = join(NODE_MODULES, "tree-sitter-wasms", "out");
 
 // ---- language registry (derived from the per-language modules) ----
-const LANG_MODULES = [LANG_JS, LANG_PY, LANG_GO, LANG_JAVA, LANG_CSHARP, LANG_RUST, LANG_HTML, LANG_CSS];
+const LANG_MODULES = [LANG_JS, LANG_PY, LANG_GO, LANG_JAVA, LANG_CSHARP, LANG_RUST, LANG_SOLIDITY, LANG_SQL, LANG_HTML, LANG_CSS];
 const LANGS = {};                 // family -> module
 const EXT_LANG = {};              // ext -> grammar
 const FAMILY = {};                // grammar -> family

package/src/graph/internal-builder.resolvers.js

@@ -207,6 +207,36 @@ export function buildResolvers(repoDir, fileSet) {
     if (seg[0] === "src" && seg.length > 2) pyTopDirs.add(seg[1]);
   }
 
+  // Solidity: relative imports, Foundry remappings (remappings.txt beats foundry.toml, longest prefix
+  // wins), then root-anchored specs (`src/X.sol` — forge resolves those against the project root).
+  // Nested remapping files are intentionally not scoped per-package: one remapping table per repo is the
+  // overwhelmingly common layout, and a wrong guess here would fabricate cross-package edges.
+  const solRemappings = [];
+  const addRemapping = (entry) => {
+    const m = /^\s*([^=\s]+)\s*=\s*(\S+)\s*$/.exec(String(entry || ""));
+    if (m && !solRemappings.some((r) => r.prefix === m[1])) solRemappings.push({ prefix: m[1], target: cleanRel(m[2]) });
+  };
+  // neither file has an indexed extension, so probe the filesystem directly rather than fileSet
+  try { for (const line of readLocal("remappings.txt").split(/\r?\n/)) addRemapping(line); } catch { /* absent/unreadable */ }
+  try {
+    const toml = readLocal("foundry.toml");
+    for (const m of toml.matchAll(/remappings\s*=\s*\[([^\]]*)\]/g)) for (const s of m[1].matchAll(/["']([^"']+)["']/g)) addRemapping(s[1]);
+  } catch { /* absent/unreadable */ }
+  solRemappings.sort((a, b) => b.prefix.length - a.prefix.length);
+  const resolveSolidityImport = (fromRel, spec) => {
+    if (!spec || !spec.endsWith(".sol")) return null;
+    if (spec.startsWith(".")) {
+      const candidate = cleanRel(join(dirname(fromRel), spec));
+      return fileSet.has(candidate) ? candidate : null;
+    }
+    for (const { prefix, target } of solRemappings) {
+      if (spec !== prefix && !spec.startsWith(prefix)) continue;
+      const candidate = cleanRel(target + "/" + spec.slice(prefix.length)).replace(/\/+/g, "/");
+      if (fileSet.has(candidate)) return candidate;
+    }
+    return fileSet.has(spec) ? spec : null;
+  };
+
   const selectorIndex = new Map();
   const htmlUsages = [];
   const resolveHref = (fromRel, href) => {
@@ -217,5 +247,5 @@ export function buildResolvers(repoDir, fileSet) {
     return fileSet.has(cand) ? cand : null;
   };
 
-  return { resolveJsImport, resolveAlias, resolvePyPath, pyBaseDir, pyTopDirs, resolveGoImport, dirFiles, resolveRustMod, resolveRustPath, resolveJavaImport, resolveHref, selectorIndex, htmlUsages, goModule, goModules, goRequires };
+  return { resolveJsImport, resolveAlias, resolvePyPath, pyBaseDir, pyTopDirs, resolveGoImport, dirFiles, resolveRustMod, resolveRustPath, resolveJavaImport, resolveSolidityImport, resolveHref, selectorIndex, htmlUsages, goModule, goModules, goRequires };
 }

package/src/graph/parser-artifact-boundary.js

@@ -17,6 +17,7 @@ const GRAMMAR_SHA256 = Object.freeze({
   java: '637aac4415fb39a211a4f4292d63c66b5ce9c32fa2cd35464af4f681d91b9a1f',
   c_sharp: '6266a7e32d68a3459104d994dc848df15d5672b0ea8e86d327274b694f8e6991',
   rust: '4409921a70d0aa5bec7d1d7ce809a557a8ee1cf6ace901e3ac6a76e62cfea903',
+  solidity: '160745e470f234cae903a9ba445d19e758d0b02e1197401fc765976c6254d2b6',
   html: '11b3405c1543fb012f5ed7f8ee73125076dce8b168301e1e787e4c717da6b456',
   css: '5fc615467b1b98420ed7517e5bf9e1f88468132dd903d842dfb13714f6a1cb0c',
 })

package/src/mcp/actions/graph-lifecycle.mjs

@@ -76,7 +76,7 @@ export async function tOpenRepo(g, args, ctx) {
             savedPrecision = ['lsp', 'off'].includes(saved.graphPrecisionMode) ? saved.graphPrecisionMode : defaultPrecisionMode()
             schemaUpgrade = !Number.isInteger(saved.edgeTypesV) || saved.edgeTypesV < 2
                 || !Number.isInteger(saved.edgeProvenanceV) || saved.edgeProvenanceV < 1
-                || !Number.isInteger(saved.extractorSchemaV) || saved.extractorSchemaV < 6
+                || !Number.isInteger(saved.extractorSchemaV) || saved.extractorSchemaV < 7
                 || !Number.isInteger(saved.reExportOccurrencesV) || saved.reExportOccurrencesV < 1
                 || !Number.isInteger(saved.symbolSpacesV) || saved.symbolSpacesV < 1
                 || !Number.isInteger(saved.physicalFileLocV) || saved.physicalFileLocV < 1

package/src/mcp/architecture-starter.mjs

@@ -28,7 +28,7 @@ const BUDGET_PROPOSALS = Object.freeze(Object.entries(PROVISIONAL_BUDGETS)
 const SOURCE_ROOTS = new Set(['src', 'app', 'lib', 'packages', 'services'])
 const CODE_EXTENSIONS = new Set([
     '.cjs', '.cs', '.css', '.go', '.htm', '.html', '.java', '.js', '.jsx', '.less', '.mjs', '.py', '.pyi',
-    '.rs', '.scss', '.ts', '.tsx',
+    '.rs', '.scss', '.sol', '.sql', '.ts', '.tsx',
 ])
 const CLASSIFIED = ['test', 'e2e', 'generated', 'mock', 'story', 'docs', 'benchmark', 'temp']
 const EDGE_RELATIONS = new Set(['imports', 're_exports', 'calls', 'references'])

package/src/mcp/graph/context-seeds.mjs

@@ -17,11 +17,12 @@ const TOOL_EXECUTION_TERMS = QUERY_INTENTS.find(([id]) => id === 'tool-execution
 const TOOL_EXECUTION_TRIGGERS = new Set(['tool', 'tools', 'tooling', 'mcp'])
 const wordsOf = (value) => String(value ?? '').replace(/([a-z0-9])([A-Z])/g, '$1 $2').toLowerCase().split(/[^a-z0-9_]+/).filter(Boolean)
 const normPath = (value) => String(value ?? '').replace(/\\/g, '/').replace(/^\.\//, '').toLowerCase()
-const CODE_FILE_RE = /\.(?:[cm]?[jt]sx?|py|go|java|rs|kt|kts|cs|rb|php)$/i
+const CODE_FILE_RE = /\.(?:[cm]?[jt]sx?|py|go|java|rs|kt|kts|cs|rb|php|sol|sql)$/i
 const DATA_OR_PROSE_RE = /\.(?:json|ya?ml|toml|ini|md|mdx|rst|adoc|html?|css|scss|less|svg)$/i
 const LANGUAGE_EXTENSIONS = Object.freeze({
     rust: ['rs'], python: ['py', 'pyi'], typescript: ['ts', 'tsx', 'mts', 'cts'],
     javascript: ['js', 'jsx', 'mjs', 'cjs'], go: ['go'], java: ['java'], csharp: ['cs'],
+    solidity: ['sol'], sql: ['sql'],
 })
 
 function requestedLanguages(query) {
@@ -33,6 +34,8 @@ function requestedLanguages(query) {
     if (words.has('golang') || /(?:^|[^A-Za-z])Go(?:[^A-Za-z]|$)/.test(raw)) requested.add('go')
     if (words.has('java')) requested.add('java')
     if (words.has('csharp') || words.has('dotnet') || /csharp|(?:^|[^A-Za-z])C#(?:[^A-Za-z]|$)/i.test(raw)) requested.add('csharp')
+    if (words.has('solidity') || words.has('contract') || words.has('contracts')) requested.add('solidity')
+    if (words.has('sql') || words.has('schema') || words.has('migration') || words.has('migrations')) requested.add('sql')
     return new Set([...requested].flatMap((language) => LANGUAGE_EXTENSIONS[language]))
 }
 
@@ -141,7 +144,7 @@ function conceptScore(g, node, concept, queryContext) {
         else if (term.length >= 4 && term !== 'tool' && term !== 'tools' && (id.includes(term) || label.includes(term))) match = Math.max(match, primary ? 12 : 7)
     })
     const extension = (/\.([^.\/]+)$/.exec(source) || [])[1] || ''
-    const languageConcept = {rust: ['rs'], python: ['py', 'pyi'], py: ['py', 'pyi'], typescript: ['ts', 'tsx', 'mts', 'cts'], ts: ['ts', 'tsx', 'mts', 'cts'], javascript: ['js', 'jsx', 'mjs', 'cjs'], js: ['js', 'jsx', 'mjs', 'cjs'], nodejs: ['js', 'jsx', 'mjs', 'cjs'], golang: ['go'], go: ['go'], java: ['java'], csharp: ['cs'], dotnet: ['cs']}[concept.raw]
+    const languageConcept = {rust: ['rs'], python: ['py', 'pyi'], py: ['py', 'pyi'], typescript: ['ts', 'tsx', 'mts', 'cts'], ts: ['ts', 'tsx', 'mts', 'cts'], javascript: ['js', 'jsx', 'mjs', 'cjs'], js: ['js', 'jsx', 'mjs', 'cjs'], nodejs: ['js', 'jsx', 'mjs', 'cjs'], golang: ['go'], go: ['go'], java: ['java'], csharp: ['cs'], dotnet: ['cs'], solidity: ['sol'], sql: ['sql'], schema: ['sql']}[concept.raw]
     if (languageConcept?.includes(extension) && queryContext.languageExtensions.has(extension)) match = Math.max(match, 58)
     const fileNode = !isSymbol(node.id), depth = source ? source.split('/').length : 9
     if (concept.id === 'bootstrap') match = Math.max(match, entrypointSignal(g, node, source, stem))