getdoorman 1.0.0

package/src/scope-analyzer.js

@@ -0,0 +1,685 @@
+/**
+ * Lightweight scope-aware analysis engine.
+ *
+ * Performs structural analysis of source code without a full AST parser,
+ * tracking block nesting, function/class boundaries, imports, and context
+ * (comments, strings, test blocks, try/catch, loops, callbacks).
+ *
+ * Export: analyzeScope(content, language) -> ScopeContext
+ */
+
+const JS_EXT_SET = new Set(['javascript', 'typescript', 'js', 'ts', 'jsx', 'tsx']);
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function isJSLike(language) {
+  return JS_EXT_SET.has((language || '').toLowerCase());
+}
+
+function isPython(language) {
+  return (language || '').toLowerCase() === 'python';
+}
+
+// Detect language from file extension
+function languageFromPath(filePath) {
+  if (!filePath) return 'javascript';
+  if (/\.(js|jsx|mjs|cjs)$/i.test(filePath)) return 'javascript';
+  if (/\.(ts|tsx)$/i.test(filePath)) return 'typescript';
+  if (/\.py$/i.test(filePath)) return 'python';
+  if (/\.rb$/i.test(filePath)) return 'ruby';
+  if (/\.go$/i.test(filePath)) return 'go';
+  return 'javascript';
+}
+
+// ---------------------------------------------------------------------------
+// Scope context class
+// ---------------------------------------------------------------------------
+
+class ScopeContext {
+  constructor(content, language) {
+    this.content = content;
+    this.language = language;
+    this.lines = content.split('\n');
+    this.lineCount = this.lines.length;
+
+    // Per-line metadata (indexed by 0-based line number)
+    this.lineDepth = new Array(this.lineCount).fill(0);
+    this.lineInsideComment = new Array(this.lineCount).fill(false);
+    this.lineInsideString = new Array(this.lineCount).fill(false);
+
+    // Block tracking
+    this.functions = [];    // { name, startLine, endLine, params, isAsync, isExported, isArrow, isMethod }
+    this.classes = [];      // { name, startLine, endLine, isExported }
+    this.tryCatches = [];   // { tryStart, catchStart, catchEnd, catchBodyLines }
+    this.loops = [];        // { startLine, endLine, type }
+    this.callbacks = [];    // { startLine, endLine }
+    this.testBlocks = [];   // { startLine, endLine }
+
+    // Imports
+    this.imports = [];      // { module, alias, line }
+    this.importedModules = new Set();
+
+    // Route handlers
+    this.routeHandlers = []; // { startLine, endLine, method, path }
+
+    // Whether the file itself is a test file
+    this.isTestFile = false;
+
+    // Exported symbols
+    this.exportedNames = new Set();
+  }
+
+  // Query methods -------------------------------------------------------
+
+  isInsideFunction(lineNum) {
+    return this.functions.some(f => lineNum >= f.startLine && lineNum <= f.endLine);
+  }
+
+  getFunctionAt(lineNum) {
+    return this.functions.find(f => lineNum >= f.startLine && lineNum <= f.endLine) || null;
+  }
+
+  isInsideClass(lineNum) {
+    return this.classes.some(c => lineNum >= c.startLine && lineNum <= c.endLine);
+  }
+
+  getClassAt(lineNum) {
+    return this.classes.find(c => lineNum >= c.startLine && lineNum <= c.endLine) || null;
+  }
+
+  isInsideTryCatch(lineNum) {
+    return this.tryCatches.some(t => lineNum >= t.tryStart && lineNum <= t.catchEnd);
+  }
+
+  isInsideCatchBlock(lineNum) {
+    return this.tryCatches.some(t => lineNum >= t.catchStart && lineNum <= t.catchEnd);
+  }
+
+  isInsideLoop(lineNum) {
+    return this.loops.some(l => lineNum >= l.startLine && lineNum <= l.endLine);
+  }
+
+  getLoopAt(lineNum) {
+    return this.loops.find(l => lineNum >= l.startLine && lineNum <= l.endLine) || null;
+  }
+
+  isInsideCallback(lineNum) {
+    return this.callbacks.some(cb => lineNum >= cb.startLine && lineNum <= cb.endLine);
+  }
+
+  isInsideTest(lineNum) {
+    if (this.isTestFile) return true;
+    return this.testBlocks.some(t => lineNum >= t.startLine && lineNum <= t.endLine);
+  }
+
+  isInsideComment(lineNum) {
+    return this.lineInsideComment[lineNum - 1] || false;
+  }
+
+  isInsideString(lineNum) {
+    return this.lineInsideString[lineNum - 1] || false;
+  }
+
+  isExported(lineNum) {
+    const fn = this.getFunctionAt(lineNum);
+    if (fn && fn.isExported) return true;
+    const cls = this.getClassAt(lineNum);
+    if (cls && cls.isExported) return true;
+    return false;
+  }
+
+  getNestingDepth(lineNum) {
+    return this.lineDepth[lineNum - 1] || 0;
+  }
+
+  hasImport(moduleName) {
+    return this.importedModules.has(moduleName);
+  }
+
+  hasAnyImport(moduleNames) {
+    return moduleNames.some(m => this.importedModules.has(m));
+  }
+
+  getFunctionLines(fn) {
+    return fn.endLine - fn.startLine + 1;
+  }
+
+  getClassLines(cls) {
+    return cls.endLine - cls.startLine + 1;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main analysis
+// ---------------------------------------------------------------------------
+
+export function analyzeScope(content, language) {
+  const lang = language || 'javascript';
+  const ctx = new ScopeContext(content, lang);
+
+  if (isJSLike(lang)) {
+    analyzeJS(ctx);
+  } else if (isPython(lang)) {
+    analyzePython(ctx);
+  } else {
+    // Fallback: treat as JS-like
+    analyzeJS(ctx);
+  }
+
+  return ctx;
+}
+
+// ---------------------------------------------------------------------------
+// JS / TS analysis
+// ---------------------------------------------------------------------------
+
+function analyzeJS(ctx) {
+  const lines = ctx.lines;
+  let inBlockComment = false;
+  let inTemplateLiteral = false;
+  let depth = 0;
+
+  // Track brace-based block stack for assigning end lines
+  // Stack entries: { type, startLine, ref }  ref = the object in ctx.functions / ctx.classes etc.
+  const blockStack = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const lineNum = i + 1;
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // --- Multi-line comment tracking ---
+    if (inBlockComment) {
+      ctx.lineInsideComment[i] = true;
+      if (trimmed.includes('*/')) {
+        inBlockComment = false;
+      }
+      ctx.lineDepth[i] = depth;
+      continue;
+    }
+
+    if (trimmed.startsWith('/*') && !trimmed.includes('*/')) {
+      inBlockComment = true;
+      ctx.lineInsideComment[i] = true;
+      ctx.lineDepth[i] = depth;
+      continue;
+    }
+
+    // Single-line block comment /* ... */ or single-line comment //
+    if (trimmed.startsWith('//') || (trimmed.startsWith('/*') && trimmed.includes('*/'))) {
+      ctx.lineInsideComment[i] = true;
+      ctx.lineDepth[i] = depth;
+      // Still parse for depth changes on comment lines that contain braces? No, skip.
+      parseLineForContext(ctx, line, lineNum, blockStack);
+      continue;
+    }
+
+    // --- Template literal tracking (simplified) ---
+    if (inTemplateLiteral) {
+      ctx.lineInsideString[i] = true;
+      if (line.includes('`')) {
+        inTemplateLiteral = false;
+      }
+      ctx.lineDepth[i] = depth;
+      continue;
+    }
+
+    // Check for template literal start without close on same line
+    const backtickCount = (line.match(/`/g) || []).length;
+    if (backtickCount % 2 !== 0) {
+      inTemplateLiteral = true;
+    }
+
+    // --- Imports ---
+    parseJSImport(ctx, trimmed, lineNum);
+
+    // --- Exports ---
+    if (/^export\s/.test(trimmed)) {
+      const exportMatch = trimmed.match(/export\s+(?:default\s+)?(?:async\s+)?(?:function|class|const|let|var)\s+(\w+)/);
+      if (exportMatch) {
+        ctx.exportedNames.add(exportMatch[1]);
+      }
+    }
+
+    // --- Brace depth ---
+    const openBraces = (stripStringsAndComments(line).match(/\{/g) || []).length;
+    const closeBraces = (stripStringsAndComments(line).match(/\}/g) || []).length;
+
+    ctx.lineDepth[i] = depth;
+
+    // Parse line for function/class/control structures before updating depth
+    parseLineForContext(ctx, line, lineNum, blockStack);
+
+    depth += openBraces - closeBraces;
+    if (depth < 0) depth = 0;
+
+    // Close blocks when depth decreases
+    let remaining = closeBraces;
+    while (remaining > 0 && blockStack.length > 0) {
+      const top = blockStack[blockStack.length - 1];
+      if (depth <= top.depth) {
+        blockStack.pop();
+        remaining--;
+        if (top.ref) {
+          top.ref.endLine = lineNum;
+        }
+      } else {
+        break;
+      }
+    }
+  }
+
+  // Close any remaining open blocks
+  for (const block of blockStack) {
+    if (block.ref && !block.ref.endLine) {
+      block.ref.endLine = lines.length;
+    }
+  }
+
+  // Post-process try/catch: compute catchEnd by brace-matching from catchStart
+  for (const tc of ctx.tryCatches) {
+    if (tc.catchStart > 0 && tc.catchEnd === 0) {
+      tc.catchEnd = findBraceEnd(lines, tc.catchStart - 1);
+    }
+    // If catchEnd still 0, set it equal to catchStart
+    if (tc.catchEnd === 0 && tc.catchStart > 0) {
+      tc.catchEnd = tc.catchStart;
+    }
+    // Compute catchBodyLines (lines between catch { and })
+    if (tc.catchStart > 0 && tc.catchEnd > 0) {
+      tc.catchBodyLines = Math.max(0, tc.catchEnd - tc.catchStart - 1);
+    }
+  }
+
+  // Detect test file
+  ctx.isTestFile = detectTestFile(ctx);
+
+  // Build test blocks
+  detectTestBlocks(ctx);
+}
+
+/**
+ * Find the line number where the brace block starting at startIdx closes.
+ * startIdx is 0-based line index. Returns 1-based line number.
+ */
+function findBraceEnd(lines, startIdx) {
+  let depth = 0;
+  for (let i = startIdx; i < lines.length; i++) {
+    const cleaned = stripStringsAndComments(lines[i]);
+    const opens = (cleaned.match(/\{/g) || []).length;
+    const closes = (cleaned.match(/\}/g) || []).length;
+    depth += opens - closes;
+    if (depth <= 0 && opens + closes > 0 && i > startIdx) {
+      return i + 1; // 1-based
+    }
+    // Handle single-line: try { ... } catch(e) { ... }
+    if (i === startIdx && opens > 0 && depth <= 0) {
+      return i + 1;
+    }
+  }
+  return lines.length;
+}
+
+function stripStringsAndComments(line) {
+  // Remove string literals and comments to count braces accurately
+  let result = '';
+  let inSingle = false;
+  let inDouble = false;
+  let inTemplate = false;
+  let escape = false;
+
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (escape) { escape = false; continue; }
+    if (ch === '\\') { escape = true; continue; }
+
+    if (!inSingle && !inDouble && !inTemplate) {
+      if (ch === '/' && line[i + 1] === '/') break; // rest is comment
+      if (ch === '/' && line[i + 1] === '*') {
+        // skip to */
+        const end = line.indexOf('*/', i + 2);
+        if (end >= 0) { i = end + 1; continue; }
+        break;
+      }
+      if (ch === "'") { inSingle = true; continue; }
+      if (ch === '"') { inDouble = true; continue; }
+      if (ch === '`') { inTemplate = true; continue; }
+      result += ch;
+    } else {
+      if (inSingle && ch === "'") inSingle = false;
+      if (inDouble && ch === '"') inDouble = false;
+      if (inTemplate && ch === '`') inTemplate = false;
+    }
+  }
+  return result;
+}
+
+function parseJSImport(ctx, trimmed, lineNum) {
+  // import X from 'mod'
+  let m = trimmed.match(/^import\s+.*\s+from\s+['"]([^'"]+)['"]/);
+  if (m) {
+    ctx.imports.push({ module: m[1], line: lineNum });
+    ctx.importedModules.add(m[1]);
+    return;
+  }
+  // import 'mod'
+  m = trimmed.match(/^import\s+['"]([^'"]+)['"]/);
+  if (m) {
+    ctx.imports.push({ module: m[1], line: lineNum });
+    ctx.importedModules.add(m[1]);
+    return;
+  }
+  // const X = require('mod')
+  m = trimmed.match(/(?:const|let|var)\s+\w+\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+  if (m) {
+    ctx.imports.push({ module: m[1], line: lineNum });
+    ctx.importedModules.add(m[1]);
+    return;
+  }
+  // require('mod') standalone
+  m = trimmed.match(/^require\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+  if (m) {
+    ctx.imports.push({ module: m[1], line: lineNum });
+    ctx.importedModules.add(m[1]);
+  }
+}
+
+function parseLineForContext(ctx, line, lineNum, blockStack) {
+  const trimmed = line.trim();
+  const depth = ctx.lineDepth[lineNum - 1];
+
+  // --- Function declarations ---
+  // async function name(...)  /  function name(...)
+  let m = trimmed.match(/^(export\s+(?:default\s+)?)?(async\s+)?function\s*(\*?\s*\w+)?\s*\(([^)]*)\)/);
+  if (m) {
+    const isExported = !!m[1] || ctx.exportedNames.has((m[3] || '').trim());
+    const fn = {
+      name: (m[3] || '<anonymous>').trim(),
+      startLine: lineNum,
+      endLine: lineNum, // will be updated when block closes
+      params: parseParams(m[4]),
+      paramCount: parseParams(m[4]).length,
+      isAsync: !!m[2],
+      isExported,
+      isArrow: false,
+      isMethod: false,
+    };
+    ctx.functions.push(fn);
+    if (trimmed.includes('{')) {
+      blockStack.push({ type: 'function', depth, ref: fn });
+    }
+    detectRouteOrMiddleware(ctx, fn, trimmed, lineNum);
+    return;
+  }
+
+  // const name = (async) (...) => { ... }
+  m = trimmed.match(/^(export\s+(?:default\s+)?)?(?:const|let|var)\s+(\w+)\s*=\s*(async\s+)?(?:\([^)]*\)|[a-zA-Z_]\w*)\s*=>/);
+  if (m) {
+    const paramMatch = trimmed.match(/=\s*(?:async\s+)?\(([^)]*)\)\s*=>/);
+    const params = paramMatch ? parseParams(paramMatch[1]) : [];
+    const isExported = !!m[1] || ctx.exportedNames.has(m[2]);
+    const fn = {
+      name: m[2],
+      startLine: lineNum,
+      endLine: lineNum,
+      params,
+      paramCount: params.length,
+      isAsync: !!m[3],
+      isExported,
+      isArrow: true,
+      isMethod: false,
+    };
+    ctx.functions.push(fn);
+    if (trimmed.includes('{')) {
+      blockStack.push({ type: 'function', depth, ref: fn });
+    }
+    detectRouteOrMiddleware(ctx, fn, trimmed, lineNum);
+    return;
+  }
+
+  // Method: name(...) {  or  async name(...) {
+  m = trimmed.match(/^(async\s+)?(\w+)\s*\(([^)]*)\)\s*\{/);
+  if (m && !['if', 'for', 'while', 'switch', 'catch', 'with'].includes(m[2])) {
+    const fn = {
+      name: m[2],
+      startLine: lineNum,
+      endLine: lineNum,
+      params: parseParams(m[3]),
+      paramCount: parseParams(m[3]).length,
+      isAsync: !!m[1],
+      isExported: false,
+      isArrow: false,
+      isMethod: true,
+    };
+    ctx.functions.push(fn);
+    blockStack.push({ type: 'function', depth, ref: fn });
+    return;
+  }
+
+  // --- Class ---
+  m = trimmed.match(/^(export\s+(?:default\s+)?)?class\s+(\w+)/);
+  if (m) {
+    const cls = {
+      name: m[2],
+      startLine: lineNum,
+      endLine: lineNum,
+      isExported: !!m[1] || ctx.exportedNames.has(m[2]),
+    };
+    ctx.classes.push(cls);
+    if (trimmed.includes('{')) {
+      blockStack.push({ type: 'class', depth, ref: cls });
+    }
+    return;
+  }
+
+  // --- Try/catch ---
+  if (/^\s*try\s*\{/.test(line) || trimmed === 'try {' || trimmed === 'try{') {
+    const tc = { tryStart: lineNum, catchStart: 0, catchEnd: 0, catchBodyLines: 0 };
+    ctx.tryCatches.push(tc);
+    blockStack.push({ type: 'try', depth, ref: tc });
+    return;
+  }
+
+  if (/^\s*\}\s*catch\s*/.test(line) || /catch\s*\(/.test(trimmed)) {
+    // Find the most recent try block
+    const tc = ctx.tryCatches[ctx.tryCatches.length - 1];
+    if (tc && tc.catchStart === 0) {
+      tc.catchStart = lineNum;
+      // We need to count catch body lines. The catch block ref will update endLine.
+      const catchRef = { endLine: lineNum };
+      blockStack.push({ type: 'catch', depth, ref: catchRef });
+      // Store catch ref so we can compute body lines later
+      tc._catchRef = catchRef;
+    }
+    return;
+  }
+
+  // --- Loops ---
+  if (/^\s*(for|while|do)\s*[\({]/.test(line) || /^\s*for\s+/.test(line)) {
+    const loopType = trimmed.startsWith('for') ? 'for' : trimmed.startsWith('while') ? 'while' : 'do';
+    const loop = { startLine: lineNum, endLine: lineNum, type: loopType };
+    ctx.loops.push(loop);
+    if (trimmed.includes('{')) {
+      blockStack.push({ type: 'loop', depth, ref: loop });
+    }
+    return;
+  }
+
+  // --- Callbacks (function passed as argument) ---
+  if (/\.\w+\s*\(\s*(async\s+)?(?:function|\([^)]*\)\s*=>|\w+\s*=>)/.test(trimmed)) {
+    const cb = { startLine: lineNum, endLine: lineNum };
+    ctx.callbacks.push(cb);
+    if (trimmed.includes('{')) {
+      blockStack.push({ type: 'callback', depth, ref: cb });
+    }
+    return;
+  }
+
+  // --- Route handlers: app.get('/path', ...) / router.post(...) ---
+  m = trimmed.match(/(?:app|router)\.(get|post|put|patch|delete|use|all)\s*\(\s*['"]([^'"]*)['"]/);
+  if (m) {
+    const handler = { startLine: lineNum, endLine: lineNum, method: m[1], path: m[2] };
+    ctx.routeHandlers.push(handler);
+    if (trimmed.includes('{')) {
+      blockStack.push({ type: 'route', depth, ref: handler });
+    }
+  }
+}
+
+function detectRouteOrMiddleware(ctx, fn, trimmed, lineNum) {
+  // Detect middleware pattern: (req, res, next) or (req, res)
+  const hasReqRes = fn.params.some(p => p === 'req' || p === 'request') &&
+                    fn.params.some(p => p === 'res' || p === 'response');
+  if (hasReqRes) {
+    fn.isRouteHandler = true;
+    fn.isMiddleware = fn.params.some(p => p === 'next');
+  }
+}
+
+function parseParams(paramStr) {
+  if (!paramStr || !paramStr.trim()) return [];
+  return paramStr.split(',')
+    .map(p => p.trim().replace(/\s*=.*$/, '').replace(/:\s*\w+.*$/, '').replace(/\.\.\./, ''))
+    .filter(Boolean);
+}
+
+function detectTestFile(ctx) {
+  // Check imports for test frameworks
+  const testModules = ['jest', 'mocha', 'vitest', 'node:test', 'ava', 'tap', '@jest/globals'];
+  for (const imp of ctx.imports) {
+    if (testModules.includes(imp.module)) return true;
+  }
+
+  // Check for describe/it/test at top level
+  for (let i = 0; i < Math.min(ctx.lines.length, 30); i++) {
+    const line = ctx.lines[i].trim();
+    if (/^(describe|it|test)\s*\(/.test(line)) return true;
+    if (/^def\s+test_/.test(line)) return true;
+    if (/@Test/.test(line)) return true;
+  }
+
+  return false;
+}
+
+function detectTestBlocks(ctx) {
+  // Look for describe/it/test blocks
+  for (let i = 0; i < ctx.lines.length; i++) {
+    const line = ctx.lines[i].trim();
+    if (/^(?:describe|it|test|beforeEach|afterEach|beforeAll|afterAll)\s*\(/.test(line)) {
+      // Find matching function in callbacks or just estimate end
+      const cb = ctx.callbacks.find(c => c.startLine === i + 1);
+      if (cb) {
+        ctx.testBlocks.push({ startLine: i + 1, endLine: cb.endLine });
+      } else {
+        // Estimate: look for the block end
+        ctx.testBlocks.push({ startLine: i + 1, endLine: i + 1 });
+      }
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Python analysis (simplified)
+// ---------------------------------------------------------------------------
+
+function analyzePython(ctx) {
+  const lines = ctx.lines;
+  let inDocstring = false;
+  let inComment = false;
+  const indentStack = [0];
+
+  for (let i = 0; i < lines.length; i++) {
+    const lineNum = i + 1;
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Track indentation depth
+    const indent = line.search(/\S/);
+    const depth = indent >= 0 ? Math.floor(indent / 4) : 0;
+    ctx.lineDepth[i] = depth;
+
+    // Docstrings
+    if (inDocstring) {
+      ctx.lineInsideString[i] = true;
+      if (trimmed.includes('"""') || trimmed.includes("'''")) {
+        inDocstring = false;
+      }
+      continue;
+    }
+
+    if ((trimmed.startsWith('"""') || trimmed.startsWith("'''")) &&
+        !trimmed.endsWith('"""', trimmed.length) && !trimmed.endsWith("'''", trimmed.length)) {
+      const quote = trimmed.slice(0, 3);
+      if ((trimmed.match(new RegExp(quote.replace(/'/g, "\\'"), 'g')) || []).length === 1) {
+        inDocstring = true;
+        ctx.lineInsideString[i] = true;
+        continue;
+      }
+    }
+
+    // Comments
+    if (trimmed.startsWith('#')) {
+      ctx.lineInsideComment[i] = true;
+      continue;
+    }
+
+    // Imports
+    let m = trimmed.match(/^(?:from\s+(\S+)\s+)?import\s+(\S+)/);
+    if (m) {
+      const mod = m[1] || m[2];
+      ctx.imports.push({ module: mod, line: lineNum });
+      ctx.importedModules.add(mod);
+    }
+
+    // Functions
+    m = trimmed.match(/^(async\s+)?def\s+(\w+)\s*\(([^)]*)\)/);
+    if (m) {
+      const fn = {
+        name: m[2],
+        startLine: lineNum,
+        endLine: lineNum, // will be approximated
+        params: parseParams(m[3]),
+        paramCount: parseParams(m[3]).length,
+        isAsync: !!m[1],
+        isExported: !m[2].startsWith('_'),
+        isArrow: false,
+        isMethod: false,
+      };
+      // Find end line by indentation
+      fn.endLine = findPythonBlockEnd(lines, i);
+      ctx.functions.push(fn);
+    }
+
+    // Classes
+    m = trimmed.match(/^class\s+(\w+)/);
+    if (m) {
+      const cls = { name: m[1], startLine: lineNum, endLine: lineNum, isExported: !m[1].startsWith('_') };
+      cls.endLine = findPythonBlockEnd(lines, i);
+      ctx.classes.push(cls);
+    }
+
+    // Test functions
+    if (/^def\s+test_/.test(trimmed)) {
+      ctx.isTestFile = true;
+    }
+  }
+}
+
+function findPythonBlockEnd(lines, startIdx) {
+  const startIndent = lines[startIdx].search(/\S/);
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === '') continue;
+    const indent = line.search(/\S/);
+    if (indent <= startIndent) return i; // line i is no longer in the block
+  }
+  return lines.length;
+}
+
+// ---------------------------------------------------------------------------
+// Re-exports for convenience
+// ---------------------------------------------------------------------------
+
+export { ScopeContext, languageFromPath };