@suss/adapter-ruby 0.3.2-0

package/dist/index.js

@@ -0,0 +1,869 @@
+// src/ast.ts
+function rangeOf(node) {
+  return {
+    start: node.startPosition.row + 1,
+    end: node.endPosition.row + 1
+  };
+}
+function field(node, name) {
+  return node.childForFieldName(name);
+}
+function bodyStatements(body) {
+  return body.namedChildren.filter((child) => child !== null);
+}
+function symbolValue(node) {
+  return node.type === "simple_symbol" ? node.text.slice(1) : null;
+}
+function instanceMethodsByName(body) {
+  const methods = /* @__PURE__ */ new Map();
+  for (const stmt of bodyStatements(body)) {
+    if (stmt.type !== "method") {
+      continue;
+    }
+    const name = field(stmt, "name")?.text;
+    if (name !== void 0) {
+      methods.set(name, stmt);
+    }
+  }
+  return methods;
+}
+function bareCallArgumentGroups(body, name) {
+  const groups = [];
+  for (const stmt of bodyStatements(body)) {
+    if (stmt.type !== "call" || field(stmt, "receiver") !== null) {
+      continue;
+    }
+    if (field(stmt, "method")?.text !== name) {
+      continue;
+    }
+    const args = field(stmt, "arguments");
+    groups.push(args === null ? [] : bodyStatements(args));
+  }
+  return groups;
+}
+function methodHasStatements(method) {
+  const body = field(method, "body");
+  if (body === null) {
+    return false;
+  }
+  if (body.type !== "body_statement") {
+    return true;
+  }
+  return bodyStatements(body).length > 0;
+}
+function hashKeySymbolName(node) {
+  return node.type === "hash_key_symbol" ? node.text : null;
+}
+function booleanLiteralValue(node) {
+  if (node.type === "true") {
+    return true;
+  }
+  if (node.type === "false") {
+    return false;
+  }
+  return null;
+}
+function readCallArgs(argumentList) {
+  const positional = [];
+  const keyword = {};
+  if (argumentList === null) {
+    return { positional, keyword };
+  }
+  for (const child of bodyStatements(argumentList)) {
+    if (child.type === "pair") {
+      const keyNode = field(child, "key");
+      const valueNode = field(child, "value");
+      const name = keyNode !== null ? hashKeySymbolName(keyNode) : null;
+      if (name !== null && valueNode !== null) {
+        keyword[name] = valueNode;
+      }
+      continue;
+    }
+    positional.push(child);
+  }
+  return { positional, keyword };
+}
+
+// src/constantPath.ts
+import fs from "fs";
+import path from "path";
+function underscoreConstantPath(qualifiedName) {
+  return qualifiedName.replaceAll("::", "/").replace(/([A-Z\d]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").replaceAll("-", "_").toLowerCase();
+}
+var PATH_CONVENTIONS = {
+  railsUnderscore: underscoreConstantPath
+};
+function resolveConstantFile(root, qualifiedName, convention) {
+  const relative = PATH_CONVENTIONS[convention](qualifiedName);
+  const file = path.join(root, `${relative}.rb`);
+  return fs.existsSync(file) ? file : null;
+}
+
+// src/scope.ts
+function qualifyConstantRef(node, nesting) {
+  if (node.type === "scope_resolution") {
+    return node.text;
+  }
+  if (node.type === "constant") {
+    const innermost = nesting[0] ?? null;
+    return innermost === null ? node.text : `${innermost}::${node.text}`;
+  }
+  return null;
+}
+function shadowingClassFor(node, nesting, knownClasses) {
+  if (node.type !== "constant") {
+    return null;
+  }
+  for (const level of nesting) {
+    const candidate = `${level}::${node.text}`;
+    if (knownClasses.has(candidate)) {
+      return candidate;
+    }
+  }
+  return knownClasses.has(node.text) ? node.text : null;
+}
+function walkClasses(root, visit) {
+  walkDefinitions(root, (info) => {
+    if (info.kind === "class") {
+      visit(info);
+    }
+  });
+}
+function walkDefinitions(root, visit) {
+  walkBody(bodyStatements(root), [], visit);
+}
+function walkBody(statements, nesting, visit) {
+  for (const stmt of statements) {
+    if (stmt.type === "class") {
+      visitClass(stmt, nesting, visit);
+      continue;
+    }
+    if (stmt.type === "module") {
+      visitModule(stmt, nesting, visit);
+    }
+  }
+}
+function ownIdentity(nameNode, outerNesting) {
+  const qualifiedName = qualifyConstantRef(nameNode, outerNesting);
+  if (qualifiedName === null) {
+    return null;
+  }
+  return { qualifiedName, bodyNesting: [qualifiedName, ...outerNesting] };
+}
+function visitClass(node, nesting, visit) {
+  const nameNode = field(node, "name");
+  const identity = nameNode !== null ? ownIdentity(nameNode, nesting) : null;
+  if (identity === null) {
+    return;
+  }
+  const superclassWrapper = field(node, "superclass");
+  const superclassExpr = superclassWrapper?.namedChild(0) ?? null;
+  const superclassQualifiedName = superclassExpr !== null ? qualifyConstantRef(superclassExpr, nesting) : null;
+  const bodyNode = field(node, "body");
+  visit({
+    node,
+    kind: "class",
+    qualifiedName: identity.qualifiedName,
+    superclassQualifiedName,
+    bodyNode,
+    bodyNesting: identity.bodyNesting
+  });
+  if (bodyNode !== null) {
+    walkBody(bodyStatements(bodyNode), identity.bodyNesting, visit);
+  }
+}
+function visitModule(node, nesting, visit) {
+  const nameNode = field(node, "name");
+  const identity = nameNode !== null ? ownIdentity(nameNode, nesting) : null;
+  if (identity === null) {
+    return;
+  }
+  const bodyNode = field(node, "body");
+  visit({
+    node,
+    kind: "module",
+    qualifiedName: identity.qualifiedName,
+    superclassQualifiedName: null,
+    bodyNode,
+    bodyNesting: identity.bodyNesting
+  });
+  if (bodyNode !== null) {
+    walkBody(bodyStatements(bodyNode), identity.bodyNesting, visit);
+  }
+}
+function stripTypeSuffixName(qualifiedName) {
+  const shortName = qualifiedName.split("::").at(-1) ?? qualifiedName;
+  return shortName.endsWith("Type") ? shortName.slice(0, -4) : shortName;
+}
+var TYPE_NAME_CONVENTIONS = {
+  stripTypeSuffix: stripTypeSuffixName
+};
+function graphqlTypeNameFromQualified(qualifiedName, convention) {
+  return TYPE_NAME_CONVENTIONS[convention](qualifiedName);
+}
+
+// src/ancestry.ts
+var INCLUDE_CALL = "include";
+var PREPEND_CALL = "prepend";
+var DEFINE_METHOD_CALL = "define_method";
+async function reachDefinition(qualifiedName, lookup) {
+  const filePath = resolveConstantFile(
+    lookup.root,
+    qualifiedName,
+    lookup.pathConvention
+  );
+  const fileRoot = filePath === null ? null : await lookup.parsedFile(filePath);
+  if (fileRoot === null) {
+    return null;
+  }
+  const all = [];
+  walkDefinitions(fileRoot, (info) => all.push(info));
+  const matches = all.filter((info) => info.qualifiedName === qualifiedName);
+  if (matches.length === 0) {
+    return null;
+  }
+  const knownClasses = new Set(all.map((info) => info.qualifiedName));
+  return matches.map((info) => ({ info, knownClasses }));
+}
+function ancestryOf(name, blocks, lookup) {
+  return chainOf(
+    { type: "bodies", name, blocks: [...blocks] },
+    lookup,
+    /* @__PURE__ */ new Set([name])
+  );
+}
+async function chainOf(self, lookup, active) {
+  const superChain = await superclassChain(self, lookup, active);
+  const present = new Set(superChain.map((ancestor) => ancestor.name));
+  present.add(self.name);
+  const mixins = await mixinChain(self, INCLUDE_CALL, lookup, active, present);
+  const prepends = await mixinChain(
+    self,
+    PREPEND_CALL,
+    lookup,
+    active,
+    present
+  );
+  return [...prepends, self, ...mixins, ...superChain];
+}
+async function superclassChain(self, lookup, active) {
+  const superclass = superclassOf(self.blocks);
+  if (superclass === null || lookup.ancestryRootClassNames.includes(superclass) || active.has(superclass)) {
+    return [];
+  }
+  return chainFor(superclass, lookup, active);
+}
+async function mixinChain(self, callName, lookup, active, present) {
+  let chain = [];
+  for (const ref of moduleRefs(self.blocks, callName)) {
+    if (present.has(ref.name)) {
+      continue;
+    }
+    if (!ref.readable) {
+      present.add(ref.name);
+      chain = [{ type: "unfollowed", name: ref.name }, ...chain];
+      continue;
+    }
+    const inserted = (await chainFor(ref.name, lookup, active)).filter(
+      (ancestor) => !present.has(ancestor.name)
+    );
+    for (const ancestor of inserted) {
+      present.add(ancestor.name);
+    }
+    chain = [...inserted, ...chain];
+  }
+  return chain;
+}
+async function chainFor(qualifiedName, lookup, active) {
+  const blocks = await reachDefinition(qualifiedName, lookup);
+  if (blocks === null) {
+    return [{ type: "unfollowed", name: qualifiedName }];
+  }
+  return chainOf(
+    { type: "bodies", name: qualifiedName, blocks },
+    lookup,
+    /* @__PURE__ */ new Set([...active, qualifiedName])
+  );
+}
+function moduleRefs(blocks, callName) {
+  const refs = [];
+  for (const block of blocks) {
+    if (block.info.bodyNode === null) {
+      continue;
+    }
+    for (const group of bareCallArgumentGroups(block.info.bodyNode, callName)) {
+      for (const arg of [...group].reverse()) {
+        const qualified = qualifyConstantRef(arg, block.info.bodyNesting);
+        refs.push(
+          qualified !== null ? { name: qualified, readable: true } : { name: arg.text, readable: false }
+        );
+      }
+    }
+  }
+  return refs;
+}
+function superclassOf(blocks) {
+  for (const block of blocks) {
+    if (block.info.superclassQualifiedName !== null) {
+      return block.info.superclassQualifiedName;
+    }
+  }
+  return null;
+}
+function methodInAncestry(ancestry, name) {
+  for (const entry of ancestry) {
+    if (entry.type === "unfollowed") {
+      return {
+        type: "unsettled",
+        reason: `inherited from ${entry.name}, which this run did not read`
+      };
+    }
+    const found = definitionIn(entry.blocks, name);
+    if (found.method !== null) {
+      return { type: "found", method: found.method };
+    }
+    if (found.dynamic) {
+      return {
+        type: "unsettled",
+        reason: "defined with define_method, which this reader does not follow"
+      };
+    }
+  }
+  return { type: "none" };
+}
+function definitionIn(blocks, name) {
+  let method = null;
+  let dynamic = false;
+  for (const block of blocks) {
+    const body = block.info.bodyNode;
+    if (body === null) {
+      continue;
+    }
+    method = instanceMethodsByName(body).get(name) ?? method;
+    dynamic ||= bareCallArgumentGroups(body, DEFINE_METHOD_CALL).length > 0;
+  }
+  return { method, dynamic };
+}
+function inheritedStatements(ancestry) {
+  const statements = [];
+  for (const entry of [...ancestry].reverse()) {
+    if (entry.type !== "bodies") {
+      continue;
+    }
+    for (const block of entry.blocks) {
+      const body = block.info.bodyNode;
+      if (body === null) {
+        continue;
+      }
+      for (const statement of bodyStatements(body)) {
+        statements.push({ block, statement });
+      }
+    }
+  }
+  return statements;
+}
+
+// src/discovery.ts
+import { dispatchByType, graphqlResolverBinding } from "@suss/behavioral-ir";
+import { unreadableReading } from "@suss/extractor";
+
+// src/typeShape.ts
+function scalarLookupName(qualifiedName, prefixes) {
+  for (const prefix of prefixes) {
+    if (qualifiedName.startsWith(prefix)) {
+      return qualifiedName.slice(prefix.length);
+    }
+  }
+  return qualifiedName;
+}
+function typeShapeFromNode(node, ctx) {
+  if (node.type === "array") {
+    const inner = node.namedChild(0);
+    if (inner === null) {
+      return null;
+    }
+    const items = typeShapeFromNode(inner, ctx);
+    return items === null ? null : { type: "array", items };
+  }
+  if (node.type === "constant") {
+    const shadow = shadowingClassFor(node, ctx.nesting, ctx.knownClasses);
+    if (shadow !== null) {
+      return {
+        type: "ref",
+        name: graphqlTypeNameFromQualified(shadow, ctx.typeNameConvention)
+      };
+    }
+    const bareScalar = ctx.scalars[node.text];
+    if (bareScalar !== void 0) {
+      return bareScalar;
+    }
+    const qualified = qualifyConstantRef(node, ctx.nesting);
+    return qualified === null ? null : {
+      type: "ref",
+      name: graphqlTypeNameFromQualified(qualified, ctx.typeNameConvention)
+    };
+  }
+  if (node.type === "scope_resolution") {
+    const qualified = node.text;
+    const scalar = ctx.scalars[scalarLookupName(qualified, ctx.scalarNamePrefixes)];
+    if (scalar !== void 0) {
+      return scalar;
+    }
+    return {
+      type: "ref",
+      name: graphqlTypeNameFromQualified(qualified, ctx.typeNameConvention)
+    };
+  }
+  return null;
+}
+
+// src/discovery.ts
+function createFileCache(parse, readFile) {
+  const trees = /* @__PURE__ */ new Map();
+  return {
+    async get(absPath) {
+      const cached = trees.get(absPath);
+      if (cached !== void 0) {
+        return cached;
+      }
+      const source = readFile(absPath);
+      const tree = source !== null ? await parse(source) : null;
+      trees.set(absPath, tree);
+      return tree;
+    }
+  };
+}
+function fieldReadContext(pattern, cache) {
+  return {
+    pattern,
+    cache,
+    lookup: {
+      root: pattern.root,
+      pathConvention: pattern.pathConvention,
+      ancestryRootClassNames: pattern.ancestryRootClassNames,
+      parsedFile: (absPath) => cache.get(absPath)
+    }
+  };
+}
+function typeContext(scope, pattern) {
+  return {
+    nesting: scope.nesting,
+    knownClasses: scope.knownClasses,
+    scalars: pattern.scalars,
+    scalarNamePrefixes: pattern.scalarNamePrefixes,
+    typeNameConvention: pattern.typeNameConvention
+  };
+}
+async function discoverUnits(root, options) {
+  const classes = [];
+  walkClasses(root, (info) => classes.push(info));
+  const knownClasses = new Set(classes.map((info) => info.qualifiedName));
+  const units = [];
+  for (const info of classes) {
+    const ownBlocks = classes.filter((other) => other.qualifiedName === info.qualifiedName).map((other) => ({ info: other, knownClasses }));
+    for (const pack of options.packs) {
+      for (const pattern of pack.discovery) {
+        units.push(
+          ...await unitsFor(pattern, pack, info, ownBlocks, options)
+        );
+      }
+    }
+  }
+  return units;
+}
+function unitsFor(pattern, pack, info, ownBlocks, options) {
+  const table = {
+    graphqlObjectFields: (p) => graphqlObjectFieldUnits(p, pack, info, ownBlocks, options)
+  };
+  return dispatchByType(table, pattern);
+}
+async function graphqlObjectFieldUnits(pattern, pack, info, ownBlocks, options) {
+  if (info.superclassQualifiedName === null || !pattern.baseClassNames.includes(info.superclassQualifiedName) || info.bodyNode === null) {
+    return [];
+  }
+  const typeName = graphqlTypeNameFromQualified(
+    info.qualifiedName,
+    pattern.typeNameConvention
+  );
+  const ctx = fieldReadContext(pattern, options.cache);
+  const knownClasses = ownBlocks[0]?.knownClasses ?? /* @__PURE__ */ new Set();
+  const scope = { nesting: info.bodyNesting, knownClasses };
+  const ancestry = await ancestryOf(info.qualifiedName, ownBlocks, ctx.lookup);
+  const declsByName = /* @__PURE__ */ new Map();
+  for (const stmt of bodyStatements(info.bodyNode)) {
+    const decl = await readFieldCall(stmt, scope, ctx, ancestry);
+    if (decl !== null) {
+      declsByName.set(decl.fieldName, decl);
+    }
+  }
+  return [...declsByName.values()].map(
+    (decl) => buildFieldUnit(pack, typeName, decl, options.filePath)
+  );
+}
+function bodyOfMethod(method) {
+  return {
+    bodyContent: methodHasStatements(method) ? "statements" : "empty",
+    readings: []
+  };
+}
+var NO_METHOD_BEHIND_IT = {
+  bodyContent: "absent",
+  readings: []
+};
+function methodNotSettled(reason, range) {
+  return { readings: [unreadableReading(reason, range)] };
+}
+function bodyFromLookup(found, range, subject, nothingThere) {
+  const table = {
+    found: (lookup) => bodyOfMethod(lookup.method),
+    unsettled: (lookup) => methodNotSettled(
+      `${subject} could be answered by a method ${lookup.reason}, so whether one exists was not settled here`,
+      range
+    ),
+    none: () => nothingThere
+  };
+  return dispatchByType(table, found);
+}
+async function readFieldCall(stmt, scope, ctx, ancestry) {
+  if (stmt.type !== "call" || field(stmt, "receiver") !== null) {
+    return null;
+  }
+  if (field(stmt, "method")?.text !== ctx.pattern.fieldCallName) {
+    return null;
+  }
+  const callArgs = readCallArgs(field(stmt, "arguments"));
+  const nameArg = callArgs.positional[0];
+  const symbol = nameArg !== void 0 ? symbolValue(nameArg) : null;
+  if (symbol === null) {
+    return null;
+  }
+  const read = await readFieldShape(
+    symbol,
+    callArgs,
+    scope,
+    ctx,
+    ancestry,
+    rangeOf(stmt)
+  );
+  return {
+    fieldName: resolvedName(symbol, callArgs, ctx.pattern),
+    node: stmt,
+    contract: read.contract,
+    body: read.body
+  };
+}
+function wiringReference(callArgs, wiringKeywords) {
+  for (const keyword of wiringKeywords) {
+    const ref = callArgs.keyword[keyword];
+    if (ref !== void 0) {
+      return ref;
+    }
+  }
+  return null;
+}
+async function readFieldShape(symbol, callArgs, scope, ctx, ancestry, range) {
+  const oneHopRef = wiringReference(callArgs, ctx.pattern.wiringKeywords);
+  if (oneHopRef !== null) {
+    return readWiredClass(oneHopRef, scope, ctx);
+  }
+  return {
+    contract: literalContract(callArgs, scope, ctx),
+    body: bodyFromLookup(
+      methodInAncestry(ancestry, symbol),
+      range,
+      "This field",
+      NO_METHOD_BEHIND_IT
+    )
+  };
+}
+function literalContract(callArgs, scope, ctx) {
+  const typeArg = callArgs.positional[1];
+  if (typeArg === void 0) {
+    return null;
+  }
+  const returnType = typeShapeFromNode(
+    typeArg,
+    typeContext(scope, ctx.pattern)
+  );
+  return returnType === null ? null : { returnType, args: [] };
+}
+async function readWiredClass(ref, scope, ctx) {
+  const range = rangeOf(ref);
+  const targetQualifiedName = qualifyConstantRef(ref, scope.nesting);
+  if (targetQualifiedName === null) {
+    return {
+      contract: null,
+      body: methodNotSettled(
+        `This field is wired to ${ref.text}, which is not a constant path this reader follows, so nothing about what it does was read here`,
+        range
+      )
+    };
+  }
+  const reached = await reachDefinition(targetQualifiedName, ctx.lookup);
+  if (reached === null) {
+    return {
+      contract: null,
+      body: methodNotSettled(
+        `This field is wired to ${targetQualifiedName}, which this run did not read, so nothing about what it does was read here`,
+        range
+      )
+    };
+  }
+  const ancestry = await ancestryOf(targetQualifiedName, reached, ctx.lookup);
+  return {
+    contract: readClassContract(ancestry, ctx.pattern),
+    body: bodyFromLookup(
+      methodInAncestry(ancestry, ctx.pattern.resolverMethodName),
+      range,
+      `This field's ${targetQualifiedName}`,
+      methodNotSettled(
+        `This field is wired to ${targetQualifiedName}, which defines no ${ctx.pattern.resolverMethodName} method anywhere in its ancestry, so nothing about what it does was read here`,
+        range
+      )
+    )
+  };
+}
+function readTypeCall(callArgs, scope, pattern, out) {
+  const typeArg = callArgs.positional[0];
+  if (typeArg !== void 0) {
+    out.typeCallShape = typeShapeFromNode(typeArg, typeContext(scope, pattern));
+  }
+}
+function readPayloadFieldCall(callArgs, scope, pattern, out) {
+  const nameArg = callArgs.positional[0];
+  const symbol = nameArg !== void 0 ? symbolValue(nameArg) : null;
+  const typeArg = callArgs.positional[1];
+  if (symbol === null || typeArg === void 0) {
+    return;
+  }
+  const name = resolvedName(symbol, callArgs, pattern);
+  out.fieldProperties[name] = typeShapeFromNode(
+    typeArg,
+    typeContext(scope, pattern)
+  ) ?? { type: "unknown" };
+}
+function readArgumentCall(callArgs, scope, pattern, out) {
+  const nameArg = callArgs.positional[0];
+  const symbol = nameArg !== void 0 ? symbolValue(nameArg) : null;
+  if (symbol === null) {
+    return;
+  }
+  const typeArg = callArgs.positional[1];
+  const shape = typeArg !== void 0 ? typeShapeFromNode(typeArg, typeContext(scope, pattern)) : null;
+  const requiredNode = callArgs.keyword[pattern.requiredKeyword];
+  const required = requiredNode !== void 0 ? booleanLiteralValue(requiredNode) ?? pattern.requiredDefault : pattern.requiredDefault;
+  const name = resolvedName(symbol, callArgs, pattern);
+  out.args.set(name, {
+    name,
+    type: shape ?? { type: "unknown" },
+    required,
+    typeText: typeArg?.text ?? null
+  });
+}
+function classCallHandlers(pattern) {
+  return {
+    [pattern.typeCallName]: readTypeCall,
+    [pattern.fieldCallName]: readPayloadFieldCall,
+    [pattern.argumentCallName]: readArgumentCall
+  };
+}
+function readClassContract(ancestry, pattern) {
+  const out = {
+    typeCallShape: null,
+    fieldProperties: {},
+    args: /* @__PURE__ */ new Map()
+  };
+  const handlers = classCallHandlers(pattern);
+  for (const { block, statement } of inheritedStatements(ancestry)) {
+    if (statement.type !== "call" || field(statement, "receiver") !== null) {
+      continue;
+    }
+    const method = field(statement, "method")?.text;
+    const handler = method !== void 0 ? handlers[method] : void 0;
+    if (handler === void 0) {
+      continue;
+    }
+    const scope = {
+      nesting: block.info.bodyNesting,
+      knownClasses: block.knownClasses
+    };
+    handler(readCallArgs(field(statement, "arguments")), scope, pattern, out);
+  }
+  const returnType = out.typeCallShape ?? (Object.keys(out.fieldProperties).length > 0 ? { type: "record", properties: out.fieldProperties } : null);
+  return returnType === null ? null : { returnType, args: [...out.args.values()] };
+}
+function resolvedName(symbol, callArgs, pattern) {
+  const override = callArgs.keyword[pattern.camelizeKeyword];
+  const camelizeThis = override !== void 0 ? booleanLiteralValue(override) ?? pattern.camelizeDefault : pattern.camelizeDefault;
+  return camelizeThis ? toCamelCase(symbol) : symbol;
+}
+function toCamelCase(name) {
+  const [first, ...rest] = name.split("_");
+  return [
+    first,
+    ...rest.map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+  ].join("");
+}
+function buildFieldUnit(pack, typeName, decl, filePath) {
+  const parameters = (decl.contract?.args ?? []).map(
+    (arg, position) => ({
+      name: arg.name,
+      position,
+      role: "args",
+      typeText: arg.typeText
+    })
+  );
+  const graphqlDeclaredContract = decl.contract !== null ? {
+    returnType: decl.contract.returnType,
+    args: decl.contract.args.map((a) => ({
+      name: a.name,
+      type: a.type,
+      required: a.required
+    })),
+    provenance: "derived",
+    framework: pack.name
+  } : void 0;
+  return {
+    identity: {
+      name: `${typeName}.${decl.fieldName}`,
+      nameKind: "label",
+      kind: "resolver",
+      file: filePath,
+      range: rangeOf(decl.node),
+      exportName: null,
+      exportPath: null
+    },
+    boundaryBinding: graphqlResolverBinding({
+      transport: pack.protocol,
+      recognition: pack.name,
+      typeName,
+      fieldName: decl.fieldName
+    }),
+    parameters,
+    branches: [],
+    ...decl.body.bodyContent !== void 0 ? { bodyContent: decl.body.bodyContent } : {},
+    dependencyCalls: [],
+    declaredContract: null,
+    ...decl.body.readings.length > 0 ? { readings: decl.body.readings } : {},
+    ...graphqlDeclaredContract !== void 0 ? { graphqlDeclaredContract } : {}
+  };
+}
+
+// src/facts.ts
+function unitKey(filePath, range, name) {
+  return `${filePath}:${range.start}-${range.end}#${name}`;
+}
+function emitEntryFact(db, filePath, range, name) {
+  db.add("entry", [unitKey(filePath, range, name)]);
+}
+
+// src/parser.ts
+import fs2 from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+import { Language, Parser } from "web-tree-sitter";
+var GRAMMAR_PATH = path2.join(
+  path2.dirname(fileURLToPath(import.meta.url)),
+  "..",
+  "grammar",
+  "tree-sitter-ruby.wasm"
+);
+var languagePromise = null;
+function loadLanguage() {
+  languagePromise ??= (async () => {
+    if (!fs2.existsSync(GRAMMAR_PATH)) {
+      throw new Error(
+        `Ruby grammar not found at ${GRAMMAR_PATH}. See grammar/README.md.`
+      );
+    }
+    await Parser.init();
+    return Language.load(GRAMMAR_PATH);
+  })();
+  return languagePromise;
+}
+async function parseRuby(source) {
+  const language = await loadLanguage();
+  const parser = new Parser();
+  parser.setLanguage(language);
+  try {
+    const tree = parser.parse(source);
+    if (tree === null) {
+      throw new Error("tree-sitter produced no tree for this source");
+    }
+    return tree;
+  } finally {
+    parser.delete();
+  }
+}
+
+// src/project.ts
+import fs3 from "fs";
+import path3 from "path";
+import { Database } from "@suss/datalog";
+import { assembleSummary } from "@suss/extractor";
+async function extractRubyProject(options) {
+  const db = new Database();
+  const summaries = [];
+  const cache = createFileCache(
+    (source) => parseRuby(source).then((tree) => tree.rootNode),
+    (absPath) => fs3.existsSync(absPath) ? fs3.readFileSync(absPath, "utf8") : null
+  );
+  for (const file of options.files) {
+    const root = await cache.get(file);
+    if (root === null) {
+      continue;
+    }
+    const displayPath = options.workspaceRoot !== void 0 ? path3.relative(options.workspaceRoot, file) : file;
+    const rawUnits = await discoverUnits(root, {
+      packs: options.packs,
+      filePath: displayPath,
+      cache
+    });
+    for (const raw of rawUnits) {
+      const summary = assembleSummary(raw, { gapHandling: "permissive" });
+      summary.confidence = { source: "inferred_static", level: "low" };
+      summaries.push(summary);
+      emitEntryFact(db, file, raw.identity.range, raw.identity.name);
+    }
+  }
+  return { summaries, facts: db };
+}
+var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set(["vendor", "node_modules", "tmp", ".git"]);
+function findRubyFiles(root) {
+  const found = [];
+  const walk = (dir) => {
+    for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        if (!SKIPPED_DIRECTORIES.has(entry.name)) {
+          walk(path3.join(dir, entry.name));
+        }
+        continue;
+      }
+      if (entry.isFile() && entry.name.endsWith(".rb")) {
+        found.push(path3.join(dir, entry.name));
+      }
+    }
+  };
+  walk(root);
+  return found.sort();
+}
+export {
+  ancestryOf,
+  createFileCache,
+  discoverUnits,
+  emitEntryFact,
+  extractRubyProject,
+  findRubyFiles,
+  graphqlTypeNameFromQualified,
+  inheritedStatements,
+  methodInAncestry,
+  parseRuby,
+  qualifyConstantRef,
+  reachDefinition,
+  resolveConstantFile,
+  typeShapeFromNode,
+  underscoreConstantPath,
+  unitKey,
+  walkClasses,
+  walkDefinitions
+};