@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/chunk-5BVAH26D.js

@@ -0,0 +1,340 @@
+import {
+  checkFileFreshness
+} from "./chunk-QLK6ED4Q.js";
+import {
+  ASTEngine
+} from "./chunk-3ZTOHHSW.js";
+
+// src/ast/safety-primitives.ts
+var NON_LEAF_IDENTIFIER_TYPES = /* @__PURE__ */ new Set([
+  "scoped_identifier",
+  "scoped_type_identifier",
+  "qualified_identifier",
+  "aliased_identifier",
+  "qualified_name"
+]);
+var EXTRA_REFERENCE_TYPES = /* @__PURE__ */ new Set([
+  "variable_name",
+  // PHP $var, Bash $var
+  "simple_variable",
+  // PowerShell $var
+  "variable",
+  // Haskell function/pattern var, PowerShell $var (named node)
+  "constructor",
+  // Haskell data constructor
+  "type",
+  // Haskell type name (named node; anonymous `type` keywords are excluded by isNamed)
+  "module",
+  // Haskell module name (named node)
+  "constant"
+  // Ruby CONST
+]);
+function isIdentifierNodeType(type) {
+  if (!type || NON_LEAF_IDENTIFIER_TYPES.has(type)) return false;
+  return type === "identifier" || type.endsWith("identifier") || EXTRA_REFERENCE_TYPES.has(type);
+}
+function isCommentNodeType(type) {
+  const t = type.toLowerCase();
+  return t === "comment" || t.endsWith("comment") || // line_comment, block_comment, doc_comment, container_doc_comment, documentation_comment
+  t === "shebang" || t === "haddock" || // Haskell doc comments
+  t === "marginalia";
+}
+function isStringNodeType(type) {
+  const t = type.toLowerCase();
+  return t.includes("string") || // string, string_content, string_fragment, string_literal, raw_string, template_string, string_value, string_scalar, interpolated_string, here_string, triple_quoted_string, verbatim_string_literal, multiline_string_literal, string_start/end, line_string_literal, …
+  t.includes("heredoc") || // heredoc, heredoc_body, heredoc_beginning, heredoc_end, heredoc_template
+  t === "charlist" || // Elixir '...'
+  t === "str_lit" || // Clojure "..."
+  t === "char_lit" || // Clojure \a character literal
+  t === "literal" || // SQL string/numeric literal; Haskell literal container (string/integer/char — all non-reference bytes)
+  t === "double_quote_scalar" || // YAML "..."
+  t === "single_quote_scalar" || // YAML '...'
+  t.startsWith("block_scalar");
+}
+var MEMBER_NODE_TYPES = /* @__PURE__ */ new Set([
+  "property_identifier",
+  "field_identifier",
+  "shorthand_property_identifier",
+  "statement_identifier",
+  "label_name"
+]);
+var MEMBER_ACCESS_OBJECT_FIELDS = ["object", "receiver"];
+var MEMBER_ACCESS_NAME_FIELDS = ["name", "property", "field", "attribute", "member"];
+var PARENT_FIELD_CANDIDATES = [
+  "name",
+  "value",
+  "left",
+  "right",
+  "key",
+  "target",
+  "pattern",
+  "object",
+  "receiver",
+  "property",
+  "field",
+  "attribute",
+  "member",
+  "alias",
+  "operator",
+  "type",
+  "body",
+  "expression",
+  "arguments",
+  "initializer",
+  "declarator"
+];
+function parentFieldOf(node) {
+  const parent = node?.parent;
+  if (!parent || typeof parent.childForFieldName !== "function") return null;
+  for (const f of PARENT_FIELD_CANDIDATES) {
+    const child = parent.childForFieldName(f);
+    if (child && child.startIndex === node.startIndex && child.endIndex === node.endIndex) return f;
+  }
+  return null;
+}
+function isMemberNameNode(node) {
+  if (MEMBER_NODE_TYPES.has(node.type)) return true;
+  const parent = node.parent;
+  if (!parent) return false;
+  const objNode = MEMBER_ACCESS_OBJECT_FIELDS.map((f) => typeof parent.childForFieldName === "function" ? parent.childForFieldName(f) : null).find((n) => n != null);
+  if (!objNode) return false;
+  if (objNode.startIndex === node.startIndex && objNode.endIndex === node.endIndex) return false;
+  const isName = MEMBER_ACCESS_NAME_FIELDS.map((f) => typeof parent.childForFieldName === "function" ? parent.childForFieldName(f) : null).some((n) => n != null && n.startIndex === node.startIndex && n.endIndex === node.endIndex);
+  return isName;
+}
+function isBodyNodeType(type) {
+  const t = type.toLowerCase();
+  return t.endsWith("body") || // function_body, class_body, interface_body, enum_body, method_body, constructor_body, accessor_body, object_body, impl_body, script_block_body, enum_class_body
+  t === "block" || // Rust, Go, Java, C#, Python, Lua, Dart
+  t === "compound_statement" || // C/C++, Bash
+  t === "statement_block" || // TypeScript/JavaScript
+  t === "body_statement" || // Ruby
+  t === "do_block" || // Elixir
+  t === "script_block" || // PowerShell
+  t === "declaration_list" || // C# class/interface/enum body
+  t === "field_declaration_list" || // Rust struct / Go struct body
+  t === "enum_variant_list";
+}
+var INTERPOLATION_NODE_TYPES = /* @__PURE__ */ new Set([
+  "template_substitution",
+  // JS/TS `${...}`
+  "interpolation",
+  // Ruby #{...}, Python f-string {...}
+  "interpolation_expression",
+  // Swift \(...)
+  "string_interpolation",
+  // Scala s"...${...}", Dart $expr / ${expr}
+  "expansion",
+  // Bash $var / $(...) / ${...}
+  "simple_expansion",
+  // Bash $var
+  "command_substitution",
+  // Bash $(...)
+  "arithmetic_expansion",
+  // Bash $((...))
+  "process_substitution",
+  // Bash <(...)
+  "subshell",
+  // Bash (...)
+  "variable_name",
+  // PHP $var / Bash $var (live code reference)
+  "interpolated_expression"
+  // PHP {$var}
+]);
+function walkNodes(rootNode) {
+  const stack = [rootNode];
+  return (function* () {
+    while (stack.length > 0) {
+      const node = stack.pop();
+      yield node;
+      const children = node.children;
+      for (let i = children.length - 1; i >= 0; i--) stack.push(children[i]);
+    }
+  })();
+}
+function collectMaskedRanges(tree) {
+  const masked = [];
+  const code = [];
+  for (const node of walkNodes(tree.rootNode)) {
+    const type = node.type;
+    if (isCommentNodeType(type)) {
+      masked.push({ startIndex: node.startIndex, endIndex: node.endIndex, kind: "comment", nodeType: type });
+      continue;
+    }
+    if (isStringNodeType(type)) {
+      masked.push({ startIndex: node.startIndex, endIndex: node.endIndex, kind: "string", nodeType: type });
+    }
+    if (INTERPOLATION_NODE_TYPES.has(type)) {
+      code.push({ startIndex: node.startIndex, endIndex: node.endIndex, kind: "string", nodeType: type });
+    }
+  }
+  return { masked, code };
+}
+function buildMaskFromRanges(masked, code, contentLength) {
+  const len = Math.max(0, contentLength);
+  const mask = new Uint8Array(len);
+  mask.fill(1);
+  for (const r of masked) {
+    const end = Math.min(r.endIndex, len);
+    for (let i = r.startIndex; i < end; i++) mask[i] = 0;
+  }
+  for (const r of code) {
+    const end = Math.min(r.endIndex, len);
+    for (let i = r.startIndex; i < end; i++) mask[i] = 1;
+  }
+  return mask;
+}
+function isDeclarationContainerType(type) {
+  const t = type.toLowerCase();
+  return t.includes("declarator") || // C/C++ function_declarator; JS/TS variable_declarator
+  t.includes("declaration") || // function_declaration, method_declaration, function_declaration_left (F#)
+  t.includes("definition") || // function_definition (Python/PHP/Scala), method_definition (TS/JS)
+  t.includes("signature") || // Dart function_signature
+  t.endsWith("_item") || // Rust function_item
+  t.endsWith("_spec") || // Go type_spec
+  t === "function" || // Haskell top-level binding
+  t === "function_clause" || // Erlang
+  // C#: a bare `int Target() { … }` fragment is not inside a class, so the
+  // grammar parses it as a LOCAL FUNCTION. Measured shape; without this entry
+  // a full C# method declaration is invisible to the structural detector.
+  t === "local_function_statement" || t === "method" || // Ruby `def`
+  t === "class" || // Ruby class (bare `class` node)
+  t === "module" || // Ruby module
+  t === "constructor";
+}
+function collectDeclaredNames(tree) {
+  const out = [];
+  for (const node of walkNodes(tree.rootNode)) {
+    if (!node.isNamed) continue;
+    if (!isDeclarationContainerType(node.type)) continue;
+    const named = typeof node.childForFieldName === "function" ? node.childForFieldName("name") : null;
+    let nameNode = named && named.namedChildCount === 0 ? named : null;
+    if (nameNode === null && named === null) {
+      nameNode = (node.children ?? []).find(
+        (child) => child && child.isNamed && child.namedChildCount === 0 && isIdentifierNodeType(String(child.type))
+      ) ?? null;
+    }
+    if (!nameNode) continue;
+    const text = String(nameNode.text ?? "");
+    if (text.length === 0) continue;
+    out.push({
+      text,
+      startIndex: nameNode.startIndex,
+      endIndex: nameNode.endIndex,
+      declarationType: node.type,
+      declarationStart: node.startIndex,
+      declarationEnd: node.endIndex
+    });
+  }
+  return out;
+}
+function collectBodyRanges(tree) {
+  const out = [];
+  for (const node of walkNodes(tree.rootNode)) {
+    if (!node.isNamed) continue;
+    if (!isBodyNodeType(node.type)) continue;
+    out.push({ startIndex: node.startIndex, endIndex: node.endIndex, nodeType: node.type });
+  }
+  return out;
+}
+function extractIdentifierOccurrences(tree, content) {
+  const out = [];
+  for (const node of walkNodes(tree.rootNode)) {
+    const type = node.type;
+    if (isCommentNodeType(type)) continue;
+    if (!node.isNamed) continue;
+    if (!isIdentifierNodeType(type)) continue;
+    if (node.namedChildCount !== 0) continue;
+    const text = content.substring(node.startIndex, node.endIndex);
+    if (text.length === 0) continue;
+    out.push({
+      text,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex,
+      nodeType: type,
+      parentType: node.parent ? node.parent.type : "",
+      isMemberName: isMemberNameNode(node),
+      parentField: parentFieldOf(node),
+      startLine: node.startPosition.row + 1,
+      startColumn: node.startPosition.column + 1,
+      endLine: node.endPosition.row + 1,
+      endColumn: node.endPosition.column + 1
+    });
+  }
+  return out;
+}
+function extractCommentSites(tree) {
+  const out = [];
+  const stack = tree?.rootNode ? [tree.rootNode] : [];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node === null || node === void 0) continue;
+    if (isCommentNodeType(String(node.type))) {
+      out.push({ endLine: Number(node?.endPosition?.row ?? 0) + 1, text: String(node?.text ?? "") });
+    }
+    const children = node?.children ?? [];
+    for (let i = children.length - 1; i >= 0; i--) {
+      if (children[i] !== null && children[i] !== void 0) stack.push(children[i]);
+    }
+  }
+  return out;
+}
+async function parseForSafety(filePath, content) {
+  const { language, tree, parser, transientLuaGrammar } = await ASTEngine.parseTree(filePath, content);
+  try {
+    const { masked, code } = collectMaskedRanges(tree);
+    return {
+      language,
+      content,
+      mask: buildMaskFromRanges(masked, code, content.length),
+      occurrences: extractIdentifierOccurrences(tree, content),
+      maskedRanges: masked,
+      codeRanges: code,
+      bodyRanges: collectBodyRanges(tree),
+      commentSites: extractCommentSites(tree),
+      declaredNames: collectDeclaredNames(tree),
+      hasSyntaxError: Boolean(tree?.rootNode?.hasError)
+    };
+  } finally {
+    try {
+      if (tree && typeof tree.delete === "function") tree.delete();
+    } catch {
+    }
+    if (language === "lua") {
+      try {
+        if (parser && typeof parser.delete === "function") parser.delete();
+      } catch {
+      }
+      try {
+        if (transientLuaGrammar && typeof transientLuaGrammar.delete === "function") transientLuaGrammar.delete();
+      } catch {
+      }
+    }
+  }
+}
+function collectStaleFiles(raw, fileIds) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const fileId of fileIds) {
+    if (!fileId || seen.has(fileId)) continue;
+    seen.add(fileId);
+    const f = checkFileFreshness(raw, fileId);
+    if (f && f.status !== "fresh") out.push({ fileId, path: f.path, status: f.status });
+  }
+  return out;
+}
+function assertFreshFiles(raw, fileIds, context) {
+  const stale = collectStaleFiles(raw, fileIds);
+  if (stale.length > 0) {
+    const detail = stale.map((s) => `${s.path} (${s.status})`).join(", ");
+    throw new Error(`${context}: ${stale.length} file(s) are not fresh \u2014 ${detail}`);
+  }
+}
+
+export {
+  isIdentifierNodeType,
+  isCommentNodeType,
+  extractIdentifierOccurrences,
+  parseForSafety,
+  assertFreshFiles
+};