onbuzz 4.7.2 → 4.8.1

package/src/tools/codeMapTool.js

@@ -9,9 +9,33 @@
 import { BaseTool } from './baseTool.js';
 import fs from 'fs';
 import path from 'path';
+import {
+  isWhitespace,
+  skipWhitespace,
+  readIdent,
+  startsWithKeyword,
+  consumeKeyword,
+  consumeAnyKeyword,
+  trimmedStartsWithAny,
+  indexOfWord,
+  containsWord,
+  stripStringsAndLineComments,
+  countChar,
+  consumeDottedAssignTail,
+  trimmedEndsWith,
+  isIdentStart,
+  isWordChar,
+} from './parserHelpers.js';
 
 const CODE_MAP_CONFIG = {
-  SUPPORTED_EXTENSIONS: new Set(['.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs', '.py']),
+  SUPPORTED_EXTENSIONS: new Set([
+    '.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs', '.py',
+    // C / C++ via a focused regex pass — see _parseC below. The
+    // proper tree-sitter migration that would replace the JS + Python
+    // regex parsers also covers these and adds full accuracy; this
+    // pass is the v1 that unblocks `code-map` on C/CPP codebases today.
+    '.c', '.h', '.cc', '.cpp', '.cxx', '.hpp', '.hh', '.hxx',
+  ]),
   MAX_FILES: 500,
   MAX_FILE_SIZE: 5 * 1024 * 1024, // 5MB per file
   MAX_READ_RANGE: 500,            // Max lines per read-range call
@@ -43,7 +67,7 @@ SKELETON LEVELS:
 - B.0: All signatures (public + private + methods) — DEFAULT
 - B.1: All signatures + comments/docstrings
 
-Supported files: .js, .ts, .jsx, .tsx, .mjs, .cjs, .py
+Supported files: .js, .ts, .jsx, .tsx, .mjs, .cjs, .py, .c, .h, .cc, .cpp, .cxx, .hpp, .hh, .hxx
 Respects .gitignore rules. Skips node_modules, __pycache__, .git, dist, build.
 
 USAGE — Skeleton scan:
@@ -270,7 +294,7 @@ XML format also supported:
         totalFiles: 0,
         totalEntries: 0,
         message: 'No supported files found in the specified path.',
-        guidance: 'Try a different path or verify the directory contains .js, .ts, .jsx, .tsx, .mjs, .cjs, or .py files.'
+        guidance: 'Try a different path or verify the directory contains supported files (.js, .ts, .jsx, .tsx, .mjs, .cjs, .py, .c, .h, .cc, .cpp, .cxx, .hpp, .hh, .hxx).'
       };
     }
 
@@ -291,9 +315,10 @@ XML format also supported:
         const lines = content.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
         const lang = this._langOf(file);
 
-        const entries = lang === 'python'
-          ? this._parsePython(lines, parseOptions)
-          : this._parseJS(lines, parseOptions);
+        const entries =
+          lang === 'python' ? this._parsePython(lines, parseOptions) :
+          lang === 'c'      ? this._parseC(lines, parseOptions) :
+                              this._parseJS(lines, parseOptions);
 
         if (entries.length === 0) continue;
 
@@ -564,10 +589,371 @@ XML format also supported:
   // ── Language detection ────────────────────────────────────────────────────
 
   _langOf(file) {
-    return path.extname(file).toLowerCase() === '.py' ? 'python' : 'js';
+    const ext = path.extname(file).toLowerCase();
+    if (ext === '.py') return 'python';
+    if (['.c', '.h', '.cc', '.cpp', '.cxx', '.hpp', '.hh', '.hxx'].includes(ext)) return 'c';
+    return 'js';
   }
 
   // ── JS / TS parser ────────────────────────────────────────────────────────
+  //
+  // No-regex implementation. Pattern matchers below each return either
+  // `true`/`false` or `null`/idx, using the primitives from
+  // parserHelpers.js. This trades five lines of regex for ten lines of
+  // explicit cursor-walking, but the result is far more debuggable and
+  // every behavior is locked by parserHelpers.test.js + codeMapTool.test.js.
+
+  // Modifier keywords that can precede a class-method name (used by the
+  // "method inside class" matcher).
+  static _METHOD_MODIFIERS = new Set([
+    'private', 'protected', 'public', 'readonly', 'abstract',
+    'override', 'async', 'static', 'get', 'set',
+  ]);
+
+  // Reserved words that look like methods but aren't — `if (x) {` etc.
+  static _METHOD_KEYWORD_EXCLUDE = new Set([
+    'if', 'for', 'while', 'switch', 'catch', 'return', 'throw', 'new',
+    'typeof', 'delete', 'void', 'await', 'class', 'function',
+    'const', 'let', 'var', 'super', 'this',
+  ]);
+
+  /**
+   * Does the RHS of an assignment (starting at idx) look like a function
+   * or arrow expression? Recognizes:
+   *   function …
+   *   async function …
+   *   () => …       or       (a, b) => …
+   *   ident => …    or       async ident => …
+   *
+   * Returns true on hit. Allocation-free.
+   */
+  _rhsLooksLikeFunction(s, idx) {
+    let i = skipWhitespace(s, idx);
+    // optional `async`
+    const afterAsync = consumeKeyword(s, 'async', i);
+    if (afterAsync !== -1) i = skipWhitespace(s, afterAsync);
+    if (startsWithKeyword(s, 'function', i)) return true;
+
+    // `(…) =>`  — find a balanced paren run, then `=>`
+    if (s[i] === '(') {
+      let depth = 1; let j = i + 1;
+      while (j < s.length && depth > 0) {
+        if (s[j] === '(') depth += 1;
+        else if (s[j] === ')') depth -= 1;
+        j += 1;
+      }
+      const k = skipWhitespace(s, j);
+      if (s[k] === '=' && s[k + 1] === '>') return true;
+      return false;
+    }
+
+    // `ident =>`
+    const id = readIdent(s, i);
+    if (id) {
+      const k = skipWhitespace(s, id.nextIdx);
+      if (s[k] === '=' && s[k + 1] === '>') return true;
+    }
+    return false;
+  }
+
+  /** Line is `import ...` (ESM). */
+  _isImportLine(raw) {
+    const i = skipWhitespace(raw, 0);
+    return startsWithKeyword(raw, 'import', i);
+  }
+  /** Line contains `require(` as a whole word call. */
+  _hasRequireCall(raw) {
+    const i = indexOfWord(raw, 'require');
+    if (i === -1) return false;
+    const j = skipWhitespace(raw, i + 'require'.length);
+    return raw[j] === '(';
+  }
+
+  /** Walks across the prefix keywords `export default abstract async ...`. */
+  _skipDecoratorPrefix(raw) {
+    let i = skipWhitespace(raw, 0);
+    // export, then optional `default`
+    const afterExport = consumeKeyword(raw, 'export', i);
+    if (afterExport !== -1) i = skipWhitespace(raw, afterExport);
+    const afterDefault = consumeKeyword(raw, 'default', i);
+    if (afterDefault !== -1) i = skipWhitespace(raw, afterDefault);
+    const afterAbstract = consumeKeyword(raw, 'abstract', i);
+    if (afterAbstract !== -1) i = skipWhitespace(raw, afterAbstract);
+    const afterAsync = consumeKeyword(raw, 'async', i);
+    if (afterAsync !== -1) i = skipWhitespace(raw, afterAsync);
+    return i;
+  }
+
+  /**
+   * The line starts with one of these declaration keywords (after the
+   * optional `export [default] [abstract] [async]` prefix run):
+   *   function | class | const | let | var | enum | interface | type
+   *
+   * Returns true if so.
+   */
+  _isExportableDecl(raw) {
+    const i = this._skipDecoratorPrefix(raw);
+    return (
+      startsWithKeyword(raw, 'function',  i) ||
+      startsWithKeyword(raw, 'class',     i) ||
+      startsWithKeyword(raw, 'const',     i) ||
+      startsWithKeyword(raw, 'let',       i) ||
+      startsWithKeyword(raw, 'var',       i) ||
+      startsWithKeyword(raw, 'enum',      i) ||
+      startsWithKeyword(raw, 'interface', i) ||
+      startsWithKeyword(raw, 'type',      i) ||
+      startsWithKeyword(raw, 'abstract',  i)    // bare `export abstract foo`
+    );
+  }
+
+  /** `module.exports = …` (whole or property: `module.exports.foo = …`). */
+  _isModuleExportsAssign(raw) {
+    const i = skipWhitespace(raw, 0);
+    if (!startsWithKeyword(raw, 'module', i)) return false;
+    let j = i + 'module'.length;
+    if (raw[j] !== '.') return false;
+    j += 1;
+    if (!startsWithKeyword(raw, 'exports', j)) return false;
+    j += 'exports'.length;
+    // optional `.ident`
+    if (raw[j] === '.') {
+      const id = readIdent(raw, j + 1);
+      if (!id) return false;
+      j = id.nextIdx;
+    }
+    j = skipWhitespace(raw, j);
+    return raw[j] === '=' && raw[j + 1] !== '=';
+  }
+
+  /** `exports.foo = …` */
+  _isExportsAssign(raw) {
+    const i = skipWhitespace(raw, 0);
+    if (!startsWithKeyword(raw, 'exports', i)) return false;
+    let j = i + 'exports'.length;
+    if (raw[j] !== '.') return false;
+    const id = readIdent(raw, j + 1);
+    if (!id) return false;
+    j = skipWhitespace(raw, id.nextIdx);
+    return raw[j] === '=' && raw[j + 1] !== '=';
+  }
+
+  /** `(async) function name(…)` top-level form. */
+  _isTopLevelFunctionDecl(raw) {
+    let i = skipWhitespace(raw, 0);
+    const aa = consumeKeyword(raw, 'async', i);
+    if (aa !== -1) i = skipWhitespace(raw, aa);
+    if (!startsWithKeyword(raw, 'function', i)) return false;
+    i = skipWhitespace(raw, i + 'function'.length);
+    return readIdent(raw, i) !== null;
+  }
+
+  /** `(abstract) class Name`. */
+  _isTopLevelClassDecl(raw) {
+    let i = skipWhitespace(raw, 0);
+    const aa = consumeKeyword(raw, 'abstract', i);
+    if (aa !== -1) i = skipWhitespace(raw, aa);
+    if (!startsWithKeyword(raw, 'class', i)) return false;
+    i = skipWhitespace(raw, i + 'class'.length);
+    return readIdent(raw, i) !== null;
+  }
+
+  /** `const|let|var name = <function-ish>`. */
+  _isConstAssignedFunction(raw) {
+    let i = skipWhitespace(raw, 0);
+    const dk = consumeAnyKeyword(raw, ['const', 'let', 'var'], i);
+    if (!dk) return false;
+    i = skipWhitespace(raw, dk.nextIdx);
+    const id = readIdent(raw, i);
+    if (!id) return false;
+    i = skipWhitespace(raw, id.nextIdx);
+    if (raw[i] !== '=' || raw[i + 1] === '=' || raw[i + 1] === '>') return false;
+    return this._rhsLooksLikeFunction(raw, i + 1);
+  }
+
+  /** Class-with-an-opening-brace check for the brace stack. */
+  _isClassDeclWithOpenBrace(raw, opens) {
+    if (opens <= 0) return false;
+    let i = skipWhitespace(raw, 0);
+    const ex = consumeKeyword(raw, 'export', i);
+    if (ex !== -1) i = skipWhitespace(raw, ex);
+    const df = consumeKeyword(raw, 'default', i);
+    if (df !== -1) i = skipWhitespace(raw, df);
+    const ab = consumeKeyword(raw, 'abstract', i);
+    if (ab !== -1) i = skipWhitespace(raw, ab);
+    return startsWithKeyword(raw, 'class', i);
+  }
+
+  /** IIFE prefix-op form: `!function`, `+function`, `~function`, `-function`. */
+  _isIifePrefixOp(raw) {
+    const i = skipWhitespace(raw, 0);
+    const ch = raw[i];
+    if (ch !== '!' && ch !== '+' && ch !== '~' && ch !== '-') return false;
+    let j = skipWhitespace(raw, i + 1);
+    const aa = consumeKeyword(raw, 'async', j);
+    if (aa !== -1) j = skipWhitespace(raw, aa);
+    return startsWithKeyword(raw, 'function', j);
+  }
+
+  /** IIFE paren-wrapped form: `(function ...)` or `(async function ...)`. */
+  _isIifeParens(raw) {
+    const i = skipWhitespace(raw, 0);
+    if (raw[i] !== '(') return false;
+    let j = skipWhitespace(raw, i + 1);
+    const aa = consumeKeyword(raw, 'async', j);
+    if (aa !== -1) j = skipWhitespace(raw, aa);
+    return startsWithKeyword(raw, 'function', j);
+  }
+
+  /**
+   * Global/namespace assignment of a function-ish value:
+   *   window.X.Y = function   /   globalThis.X = () =>   /   MyApp.foo = …
+   * Conditions:
+   *   - LHS head is `window|globalThis|self` (and optional dotted tail)
+   *     OR a TitleCase identifier followed by AT LEAST one dotted tail
+   *     segment (so we don't grab bare `Foo = …`)
+   *   - RHS is function or arrow
+   */
+  _isGlobalAssign(raw) {
+    let i = skipWhitespace(raw, 0);
+    const headKw = consumeAnyKeyword(raw, ['window', 'globalThis', 'self'], i);
+    let after;
+    let hadGlobalHead = false;
+    if (headKw) {
+      hadGlobalHead = true;
+      after = consumeDottedAssignTail(raw, headKw.nextIdx);
+    } else {
+      // TitleCase ident + at least one dotted tail
+      const id = readIdent(raw, i);
+      if (!id) return false;
+      // TitleCase = uppercase first char
+      const first = id.ident[0];
+      if (first < 'A' || first > 'Z') return false;
+      // Need at least one '.ident' before '='
+      if (raw[id.nextIdx] !== '.') return false;
+      after = consumeDottedAssignTail(raw, id.nextIdx);
+    }
+    if (after === -1) return false;
+    return this._rhsLooksLikeFunction(raw, after);
+  }
+
+  /**
+   * Prototype-method assignment: `Foo.prototype.bar = function|=>…`.
+   * Note: leverages `_isGlobalAssign`'s tail logic but requires
+   * `.prototype.<ident>` somewhere in the LHS.
+   */
+  _isPrototypeAssign(raw) {
+    let i = skipWhitespace(raw, 0);
+    const id = readIdent(raw, i);
+    if (!id) return false;
+    let j = id.nextIdx;
+    // walk `.ident*` until we hit `.prototype`
+    let sawPrototype = false;
+    while (raw[j] === '.') {
+      // peek the next ident
+      if (startsWithKeyword(raw, 'prototype', j + 1)) {
+        sawPrototype = true;
+        j = j + 1 + 'prototype'.length;
+        break;
+      }
+      const more = readIdent(raw, j + 1);
+      if (!more) return false;
+      j = more.nextIdx;
+    }
+    if (!sawPrototype) return false;
+    // Need `.ident` + `=` + function-ish
+    if (raw[j] !== '.') return false;
+    const methodId = readIdent(raw, j + 1);
+    if (!methodId) return false;
+    j = skipWhitespace(raw, methodId.nextIdx);
+    if (raw[j] !== '=' || raw[j + 1] === '=') return false;
+    return this._rhsLooksLikeFunction(raw, j + 1);
+  }
+
+  /** jQuery-style plugin: `$.fn.X = function …` / `jQuery.fn.X = function …`. */
+  _isJqueryPluginAssign(raw) {
+    let i = skipWhitespace(raw, 0);
+    let afterHead;
+    if (raw[i] === '$') {
+      afterHead = i + 1;
+    } else if (startsWithKeyword(raw, 'jQuery', i)) {
+      afterHead = i + 'jQuery'.length;
+    } else {
+      return false;
+    }
+    if (raw[afterHead] !== '.') return false;
+    if (!startsWithKeyword(raw, 'fn', afterHead + 1)) return false;
+    let j = afterHead + 1 + 'fn'.length;
+    if (raw[j] !== '.') return false;
+    const id = readIdent(raw, j + 1);
+    if (!id) return false;
+    j = skipWhitespace(raw, id.nextIdx);
+    if (raw[j] !== '=' || raw[j + 1] === '=') return false;
+    // We only insist on `function` here (matches the original regex).
+    let r = skipWhitespace(raw, j + 1);
+    const aa = consumeKeyword(raw, 'async', r);
+    if (aa !== -1) r = skipWhitespace(raw, aa);
+    return startsWithKeyword(raw, 'function', r);
+  }
+
+  /** `document.addEventListener(` or `window.addEventListener(`. */
+  _isAddEventListenerCall(raw) {
+    const i = skipWhitespace(raw, 0);
+    const head = consumeAnyKeyword(raw, ['document', 'window'], i);
+    if (!head) return false;
+    let j = head.nextIdx;
+    if (raw[j] !== '.') return false;
+    if (!startsWithKeyword(raw, 'addEventListener', j + 1)) return false;
+    j = skipWhitespace(raw, j + 1 + 'addEventListener'.length);
+    return raw[j] === '(';
+  }
+
+  /**
+   * Method inside a class. Caller already established `classDepth > 0`
+   * and `braceDepthBeforeLine === methodDepth`. We just decide if the
+   * line LOOKS like a method declaration vs a method call.
+   *
+   * Returns the method name or null.
+   */
+  _detectMethodName(raw) {
+    // Must start with at least one space (methods are indented).
+    if (raw[0] !== ' ' && raw[0] !== '\t') return null;
+    let i = skipWhitespace(raw, 0);
+    // Walk through any sequence of modifier keywords.
+    while (true) {
+      const id = readIdent(raw, i);
+      if (!id) return null;
+      if (!CodeMapTool._METHOD_MODIFIERS.has(id.ident)) {
+        // This is the method name candidate.
+        const afterName = skipWhitespace(raw, id.nextIdx);
+        if (raw[afterName] !== '(' && raw[afterName] !== '<') return null;
+        // Excluded reserved words (`if`, `for`, …)
+        if (CodeMapTool._METHOD_KEYWORD_EXCLUDE.has(id.ident)) return null;
+        // Is this a call rather than a definition?
+        // Calls end with `)` (optionally `;`) and have NO `) {` or `) : …`.
+        const trimmed = raw.trim();
+        const endsWithClose = trimmedEndsWith(trimmed, ')');
+        const endsWithCloseBrace = trimmedEndsWith(trimmed, ') {');
+        // `): Type` — a TS-style return-type annotation continuation
+        const hasReturnTypeAnnotation = (() => {
+          // Walk past the open paren to find the matching `)`, then check
+          // if the next non-ws char is `:` followed by a non-empty token.
+          let k = afterName + 1;
+          let depth = 1;
+          while (k < raw.length && depth > 0) {
+            if (raw[k] === '(') depth += 1;
+            else if (raw[k] === ')') depth -= 1;
+            k += 1;
+          }
+          k = skipWhitespace(raw, k);
+          return raw[k] === ':' && raw[k + 1] !== '\0' && raw[k + 1] !== undefined;
+        })();
+        if (endsWithClose && !endsWithCloseBrace && !hasReturnTypeAnnotation) return null;
+        return id.ident;
+      }
+      // It WAS a modifier — consume + continue.
+      i = skipWhitespace(raw, id.nextIdx);
+    }
+  }
 
   _parseJS(lines, { publicOnly, withComments, includeImports }) {
     const entries = [];
@@ -580,25 +966,24 @@ XML format also supported:
     let braceDepth = 0;
     let methodDepths = [];
 
-    for (let i = 0; i < lines.length; i++) {
+    for (let i = 0; i < lines.length; i += 1) {
       const lineNum = i + 1;
       const raw = lines[i];
-      const trimmed = raw.trim();
+      const start = skipWhitespace(raw, 0);
 
       // block-comment tracking
       if (inBlockComment) {
         blockCommentLines.push({ line: lineNum, text: raw, kind: 'comment' });
-        if (trimmed.includes('*/')) {
+        if (raw.includes('*/')) {
           inBlockComment = false;
           pendingComments = blockCommentLines;
           blockCommentLines = [];
         }
         continue;
       }
-
-      if (trimmed.startsWith('/*')) {
+      if (raw[start] === '/' && raw[start + 1] === '*') {
         blockCommentLines = [{ line: lineNum, text: raw, kind: 'comment' }];
-        if (trimmed.includes('*/')) {
+        if (raw.slice(start + 2).includes('*/')) {
           pendingComments = blockCommentLines;
           blockCommentLines = [];
         } else {
@@ -606,88 +991,75 @@ XML format also supported:
         }
         continue;
       }
-
-      if (trimmed.startsWith('//')) {
+      if (raw[start] === '/' && raw[start + 1] === '/') {
         pendingComments.push({ line: lineNum, text: raw, kind: 'comment' });
         continue;
       }
 
       // imports
       if (includeImports) {
-        if (/^\s*import\s/.test(raw) || /\brequire\s*\(/.test(raw)) {
+        if (this._isImportLine(raw) || this._hasRequireCall(raw)) {
           entries.push({ line: lineNum, text: raw, kind: 'import' });
           pendingComments = [];
           continue;
         }
       }
 
-      // brace tracking for class context
-      const stripped = trimmed
-        .replace(/\/\/.*$/, '')
-        .replace(/`[^`]*`/g, '')
-        .replace(/"(?:[^"\\]|\\.)*"/g, '')
-        .replace(/'(?:[^'\\]|\\.)*'/g, '');
-      const opens = (stripped.match(/\{/g) || []).length;
-      const closes = (stripped.match(/\}/g) || []).length;
-
+      // Brace tracking for class context — mask strings + line comments
+      // before counting so e.g. `var s = "class Foo {"` doesn't push a
+      // bogus class frame.
+      const masked = stripStringsAndLineComments(raw);
+      const opens  = countChar(masked, '{');
+      const closes = countChar(masked, '}');
       const braceDepthBeforeLine = braceDepth;
 
-      if (/^\s*(export\s+)?(default\s+)?(abstract\s+)?class\s/.test(raw) && opens > 0) {
+      if (this._isClassDeclWithOpenBrace(raw, opens)) {
         braceStack.push({ depth: braceDepth, type: 'class' });
         methodDepths.push(braceDepth + 1);
-        classDepth++;
+        classDepth += 1;
       }
-
       braceDepth += opens - closes;
-
       while (braceStack.length > 0 && braceDepth <= braceStack[braceStack.length - 1].depth) {
         const popped = braceStack.pop();
         if (popped.type === 'class') {
-          classDepth--;
+          classDepth -= 1;
           methodDepths.pop();
         }
       }
 
-      // detect signatures
-      const isExport = /^\s*export\s/.test(raw);
-      const isModuleExports = /^\s*module\.exports(\.\w+)?\s*=/.test(raw);
-      const isExportsAssign = /^\s*exports\.\w+\s*=/.test(raw);
-      const isPublic = isExport || isModuleExports || isExportsAssign;
+      // Signature detection
+      const isExport         = startsWithKeyword(raw, 'export', start);
+      const isModuleExports  = this._isModuleExportsAssign(raw);
+      const isExportsAssign  = this._isExportsAssign(raw);
+      const isPublic         = isExport || isModuleExports || isExportsAssign;
 
       let matched = false;
 
-      if (isExport) {
-        if (/^\s*export\s+(default\s+)?(async\s+)?(function\b|class\b|const\b|let\b|var\b|enum\b|interface\b|type\b|abstract\b)/.test(raw)) {
-          matched = true;
-        }
-      }
-
-      if (isModuleExports || isExportsAssign) {
-        matched = true;
-      }
+      if (isExport && this._isExportableDecl(raw))   matched = true;
+      if (isModuleExports || isExportsAssign)        matched = true;
 
       if (!matched && !publicOnly) {
-        if (/^\s*(async\s+)?function\s+\w+/.test(raw)) matched = true;
-        if (/^\s*(abstract\s+)?class\s+\w+/.test(raw)) matched = true;
-        if (/^\s*(const|let|var)\s+\w+\s*=\s*(async\s+)?\(/.test(raw) && raw.includes('=>')) matched = true;
-        if (/^\s*(const|let|var)\s+\w+\s*=\s*(async\s+)?function/.test(raw)) matched = true;
-        if (/^\s*(const|let|var)\s+\w+\s*=\s*(async\s+)?\w+\s*=>/.test(raw)) matched = true;
-
-        // method inside class
-        const atMethodDepth = methodDepths.length > 0 && braceDepthBeforeLine === methodDepths[methodDepths.length - 1];
-        if (classDepth > 0 && atMethodDepth && /^\s+(?:(?:private|protected|public|readonly|abstract|override|async|static|get|set)\s+)*(\w+)\s*[\(<]/.test(raw) && !isExport) {
-          const methodMatch = raw.match(/^\s+(?:(?:private|protected|public|readonly|abstract|override|async|static|get|set)\s+)*(\w+)\s*[\(<]/);
-          if (methodMatch) {
-            const name = methodMatch[1];
-            const isCall = /\)\s*;?\s*$/.test(trimmed) && !/\)\s*\{/.test(trimmed) && !/\)\s*:\s*\S/.test(trimmed);
-            const excluded = ['if', 'for', 'while', 'switch', 'catch', 'return', 'throw', 'new', 'typeof', 'delete', 'void', 'await', 'class', 'function', 'const', 'let', 'var', 'super', 'this'];
-            if (!isCall && !excluded.includes(name)) matched = true;
-          }
+        if (this._isTopLevelFunctionDecl(raw))      matched = true;
+        if (this._isTopLevelClassDecl(raw))          matched = true;
+        if (this._isConstAssignedFunction(raw))      matched = true;
+
+        // Browser-JS / pre-ESM patterns
+        if (this._isIifePrefixOp(raw))               matched = true;
+        if (this._isIifeParens(raw))                 matched = true;
+        if (this._isGlobalAssign(raw))               matched = true;
+        if (this._isPrototypeAssign(raw))            matched = true;
+        if (this._isJqueryPluginAssign(raw))         matched = true;
+        if (this._isAddEventListenerCall(raw))       matched = true;
+
+        // Method inside class
+        const atMethodDepth = methodDepths.length > 0 &&
+                              braceDepthBeforeLine === methodDepths[methodDepths.length - 1];
+        if (classDepth > 0 && atMethodDepth && !isExport) {
+          if (this._detectMethodName(raw)) matched = true;
         }
       }
 
       if (!matched && isPublic) matched = true;
-
       if (matched && publicOnly && !isPublic) {
         pendingComments = [];
         continue;
@@ -703,11 +1075,58 @@ XML format also supported:
         pendingComments = [];
       }
     }
-
     return entries;
   }
 
   // ── Python parser ─────────────────────────────────────────────────────────
+  //
+  // No-regex implementation. Identifiers are ASCII per PEP 8's
+  // recommendation; this is a documented tradeoff vs. the previous
+  // Unicode-aware (\p{L}) regex. The alternative — bundling a Unicode
+  // category table — adds ~50 KB for a feature ~0.1 % of Python
+  // codebases use. If users surface a non-ASCII-identifier Python
+  // codebase the fix is to bring in tree-sitter (already planned for
+  // #5 follow-on) which is Unicode-correct by default.
+
+  /** Try to read a `def` or `async def` head. Returns the function name or null. */
+  _readPythonDefName(raw) {
+    let i = skipWhitespace(raw, 0);
+    // optional `async`
+    const aa = consumeKeyword(raw, 'async', i);
+    if (aa !== -1) i = skipWhitespace(raw, aa);
+    if (!startsWithKeyword(raw, 'def', i)) return null;
+    i = skipWhitespace(raw, i + 'def'.length);
+    const id = readIdent(raw, i);
+    if (!id) return null;
+    i = skipWhitespace(raw, id.nextIdx);
+    if (raw[i] !== '(') return null;
+    return id.ident;
+  }
+  /** Try to read a `class Foo` head. Returns class name or null. */
+  _readPythonClassName(raw) {
+    let i = skipWhitespace(raw, 0);
+    if (!startsWithKeyword(raw, 'class', i)) return null;
+    i = skipWhitespace(raw, i + 'class'.length);
+    const id = readIdent(raw, i);
+    return id ? id.ident : null;
+  }
+
+  /**
+   * Returns true if `s` (at or after leading whitespace) starts with a
+   * Python triple-quote prefix (`"""` or `'''`). Returns null otherwise.
+   * On hit returns the 3-char quote string.
+   */
+  _pythonTripleQuoteAtStart(s) {
+    const i = skipWhitespace(s, 0);
+    if (s[i] === '"' && s[i + 1] === '"' && s[i + 2] === '"') return '"""';
+    if (s[i] === "'" && s[i + 1] === "'" && s[i + 2] === "'") return "'''";
+    return null;
+  }
+  /** True if the single-line docstring on a triple-quote line is closed on the same line. */
+  _pythonTripleQuoteClosedOnLine(s, quote) {
+    const i = skipWhitespace(s, 0);
+    return s.indexOf(quote, i + 3) !== -1;
+  }
 
   _parsePython(lines, { publicOnly, withComments, includeImports }) {
     const entries = [];
@@ -717,52 +1136,81 @@ XML format also supported:
     while (i < lines.length) {
       const lineNum = i + 1;
       const raw = lines[i];
-      const trimmed = raw.trim();
+      const start = skipWhitespace(raw, 0);
 
-      // imports
+      // imports — `import …` or `from <module> import …`
       if (includeImports) {
-        if (/^\s*(import\s|from\s+\S+\s+import\s)/.test(raw)) {
+        if (startsWithKeyword(raw, 'import', start)) {
           entries.push({ line: lineNum, text: raw, kind: 'import' });
           pendingComments = [];
-          i++;
-          continue;
+          i += 1; continue;
+        }
+        if (startsWithKeyword(raw, 'from', start)) {
+          // require a non-empty module then `import`
+          let j = skipWhitespace(raw, start + 'from'.length);
+          // Read the dotted module path; allow leading dots (relative).
+          let progressed = false;
+          while (j < raw.length && raw[j] === '.') { j += 1; progressed = true; }
+          const id = readIdent(raw, j);
+          if (id) { j = id.nextIdx; progressed = true; }
+          while (raw[j] === '.') {
+            const more = readIdent(raw, j + 1);
+            if (!more) { progressed = true; break; }
+            j = more.nextIdx;
+          }
+          j = skipWhitespace(raw, j);
+          if (progressed && startsWithKeyword(raw, 'import', j)) {
+            entries.push({ line: lineNum, text: raw, kind: 'import' });
+            pendingComments = [];
+            i += 1; continue;
+          }
         }
       }
 
       // # comments
-      if (trimmed.startsWith('#')) {
+      if (raw[start] === '#') {
         pendingComments.push({ line: lineNum, text: raw, kind: 'comment' });
-        i++;
-        continue;
+        i += 1; continue;
       }
-
       // decorators
-      if (trimmed.startsWith('@')) {
+      if (raw[start] === '@') {
         pendingComments.push({ line: lineNum, text: raw, kind: 'decorator' });
-        i++;
-        continue;
+        i += 1; continue;
       }
 
       // def / async def / class
-      const ID = /[\p{L}\p{N}_]+/u.source;
-      const defMatch = raw.match(new RegExp(`^(\\s*)(async\\s+)?def\\s+(${ID})\\s*\\(`, 'u'));
-      const classMatch = !defMatch ? raw.match(new RegExp(`^(\\s*)(class)\\s+(${ID})`, 'u')) : null;
-      const sigMatch = defMatch || classMatch;
+      const defName   = this._readPythonDefName(raw);
+      const className = defName ? null : this._readPythonClassName(raw);
+      const name = defName || className;
 
-      if (sigMatch) {
-        const name = sigMatch[3];
+      if (name) {
         const isPublic = !name.startsWith('_');
 
+        // Helper: continuation lines for a multi-line signature like
+        //   def foo(
+        //     x: int,
+        //     y: int,
+        //   ) -> int:
+        // The original advanced past the line that closes with `):` or
+        // a line starting with `)` containing `:`. Preserve that logic.
+        const advancePastMultilineSig = () => {
+          // Only def's have parameter parens; class doesn't.
+          if (!defName) return;
+          if (raw.includes('):')) return;
+          if (raw.includes(')'))  return;
+          // walk forward
+          while (i < lines.length) {
+            const pline = lines[i].trim();
+            i += 1;
+            if (pline.includes('):') ||
+                (pline.startsWith(')') && pline.includes(':'))) break;
+          }
+        };
+
         if (publicOnly && !isPublic) {
           pendingComments = [];
-          i++;
-          if (defMatch && !raw.includes('):') && !raw.includes(')')) {
-            while (i < lines.length) {
-              const pline = lines[i].trim();
-              i++;
-              if (pline.includes('):') || (pline.startsWith(')') && pline.includes(':'))) break;
-            }
-          }
+          i += 1;
+          advancePastMultilineSig();
           i = this._skipPythonDocstring(lines, i);
           continue;
         }
@@ -772,15 +1220,8 @@ XML format also supported:
         }
         entries.push({ line: lineNum, text: raw, kind: 'signature' });
         pendingComments = [];
-        i++;
-
-        if (defMatch && !raw.includes('):') && !raw.includes(')')) {
-          while (i < lines.length) {
-            const pline = lines[i].trim();
-            i++;
-            if (pline.includes('):') || (pline.startsWith(')') && pline.includes(':'))) break;
-          }
-        }
+        i += 1;
+        advancePastMultilineSig();
 
         if (withComments) {
           const dsLines = this._collectPythonDocstring(lines, i);
@@ -792,26 +1233,34 @@ XML format also supported:
         continue;
       }
 
-      // top-level assignments
-      if (/^\S/.test(raw) && new RegExp(`^[\\p{L}_][\\p{L}\\p{N}_]*\\s*=\\s*.+`, 'u').test(trimmed)) {
-        const varMatch = trimmed.match(new RegExp(`^([\\p{L}_][\\p{L}\\p{N}_]*)\\s*=`, 'u'));
-        if (varMatch) {
-          const varName = varMatch[1];
-          const isPublicVar = !varName.startsWith('_');
-          if (!publicOnly || isPublicVar) {
-            if (withComments && pendingComments.length > 0) {
-              for (const c of pendingComments) entries.push(c);
+      // Top-level assignments (data lines):
+      //   ident = expr      (only when starting at column 0; indented
+      //                      lines are method-internal and ignored)
+      if (raw.length > 0 && !isWhitespace(raw[0]) && raw[0] !== '\n') {
+        const id = readIdent(raw, 0);
+        if (id) {
+          let j = skipWhitespace(raw, id.nextIdx);
+          if (raw[j] === '=' && raw[j + 1] !== '=') {
+            // looks like `ident = …`
+            // require there to BE an RHS — `name =` alone is invalid
+            const afterEq = skipWhitespace(raw, j + 1);
+            if (afterEq < raw.length) {
+              const isPublicVar = !id.ident.startsWith('_');
+              if (!publicOnly || isPublicVar) {
+                if (withComments && pendingComments.length > 0) {
+                  for (const c of pendingComments) entries.push(c);
+                }
+                entries.push({ line: lineNum, text: raw, kind: 'data' });
+              }
+              pendingComments = [];
+              i += 1; continue;
             }
-            entries.push({ line: lineNum, text: raw, kind: 'data' });
           }
         }
-        pendingComments = [];
-        i++;
-        continue;
       }
 
       pendingComments = [];
-      i++;
+      i += 1;
     }
 
     return entries;
@@ -819,18 +1268,16 @@ XML format also supported:
 
   _collectPythonDocstring(lines, startIdx) {
     if (startIdx >= lines.length) return [];
-    const first = lines[startIdx].trim();
-
-    if (/^("""|''').*\1\s*$/.test(first)) {
-      return [{ line: startIdx + 1, text: lines[startIdx], kind: 'comment' }];
+    const first = lines[startIdx];
+    const quote = this._pythonTripleQuoteAtStart(first);
+    if (!quote) return [];
+    // single-line case: triple-quote opens AND closes on the same line
+    if (this._pythonTripleQuoteClosedOnLine(first, quote)) {
+      return [{ line: startIdx + 1, text: first, kind: 'comment' }];
     }
-
-    const tripleMatch = first.match(/^("""|''')/);
-    if (!tripleMatch) return [];
-
-    const quote = tripleMatch[1];
-    const result = [{ line: startIdx + 1, text: lines[startIdx], kind: 'comment' }];
-    for (let j = startIdx + 1; j < lines.length; j++) {
+    // multi-line: collect until the closing triple-quote
+    const result = [{ line: startIdx + 1, text: first, kind: 'comment' }];
+    for (let j = startIdx + 1; j < lines.length; j += 1) {
       result.push({ line: j + 1, text: lines[j], kind: 'comment' });
       if (lines[j].includes(quote)) break;
     }
@@ -839,18 +1286,235 @@ XML format also supported:
 
   _skipPythonDocstring(lines, startIdx) {
     if (startIdx >= lines.length) return startIdx;
-    const first = lines[startIdx].trim();
+    const first = lines[startIdx];
+    const quote = this._pythonTripleQuoteAtStart(first);
+    if (!quote) return startIdx;
+    if (this._pythonTripleQuoteClosedOnLine(first, quote)) return startIdx + 1;
+    for (let j = startIdx + 1; j < lines.length; j += 1) {
+      if (lines[j].includes(quote)) return j + 1;
+    }
+    return lines.length;
+  }
+
+  // ── C / C++ parser ────────────────────────────────────────────────────────
+  //
+  // Regex-based, same approach as the JS path: walk lines, match a set
+  // of declaration patterns. Mirrors what _parseJS does for JS — gets
+  // the agent a high-level skeleton of any C/CPP file (functions,
+  // classes/structs, includes, top-level macros) without bringing in
+  // a full C parser. The proper tree-sitter migration (see #5 plan)
+  // replaces this for full accuracy on edge cases like multi-line
+  // function signatures, templated declarations, and trailing return
+  // types — those work in 90 % of real code already because most
+  // declarations fit on one line.
+  //
+  // Patterns covered:
+  //   - #include <...> / #include "..."  → 'import' kind
+  //   - #define MACRO ...                → 'signature' kind
+  //   - class Foo {                       → 'signature'
+  //   - struct Foo {                      → 'signature'
+  //   - enum class Foo {                  → 'signature'
+  //   - namespace foo {                   → 'signature'
+  //   - typedef … name;                   → 'signature'
+  //   - using name = …;                   → 'signature'
+  //   - free-function: `<type> name(args) {`  → 'signature'
+  //   - method: `<type> Class::name(args) {`  → 'signature'
+  //   - constructor: `Class::Class(args) {`   → 'signature'
+  //   - destructor: `Class::~Class()`         → 'signature'
+  //
+  // Skipped (intentional):
+  //   - Function prototypes (declarations w/o body) — too noisy in
+  //     headers; the user usually wants the definitions
+  //   - Lambdas — covered by treating the enclosing function as the
+  //     signature
+  _parseC(lines, { publicOnly, withComments, includeImports }) {
+    const entries = [];
+    let pendingComments = [];
+    let inBlockComment = false;
+
+    // C/C++ tokens we accept at the head of a function/type declaration.
+    // The classifier walks them one at a time using consumeKeyword —
+    // no regex. After the keyword run we require at least one
+    // additional token before the `(` so we don't misidentify a bare
+    // function call as a definition.
+    const C_TYPE_KEYWORDS = [
+      'static', 'inline', 'extern', 'constexpr', 'virtual', 'explicit',
+      'friend', 'const', 'mutable', 'register', 'volatile',
+      'signed', 'unsigned', 'short', 'long',
+      // Built-in primitive types — frequently followed by an ident.
+      'void', 'bool', 'char', 'int', 'float', 'double',
+      'auto', 'wchar_t', 'char16_t', 'char32_t',
+    ];
+
+    for (let i = 0; i < lines.length; i += 1) {
+      const lineNum = i + 1;
+      const raw = lines[i];
+      const start = skipWhitespace(raw, 0);
 
-    if (/^("""|''').*\1\s*$/.test(first)) return startIdx + 1;
+      // ── block + line comments ────────────────────────────────────
+      if (inBlockComment) {
+        if (withComments) pendingComments.push({ line: lineNum, text: raw, kind: 'comment' });
+        if (raw.includes('*/')) inBlockComment = false;
+        continue;
+      }
+      if (raw[start] === '/' && raw[start + 1] === '*') {
+        if (withComments) pendingComments.push({ line: lineNum, text: raw, kind: 'comment' });
+        // The block-comment scan checks anywhere on the line; templates
+        // / preproc lines don't typically contain '*/' so this is safe.
+        if (!raw.slice(start + 2).includes('*/')) inBlockComment = true;
+        continue;
+      }
+      if (raw[start] === '/' && raw[start + 1] === '/') {
+        if (withComments) pendingComments.push({ line: lineNum, text: raw, kind: 'comment' });
+        continue;
+      }
 
-    const tripleMatch = first.match(/^("""|''')/);
-    if (!tripleMatch) return startIdx;
+      // ── #include ─────────────────────────────────────────────────
+      if (includeImports && raw[start] === '#') {
+        const afterHash = skipWhitespace(raw, start + 1);
+        if (startsWithKeyword(raw, 'include', afterHash)) {
+          entries.push({ line: lineNum, text: raw, kind: 'import' });
+          pendingComments = [];
+          continue;
+        }
+      }
 
-    const quote = tripleMatch[1];
-    for (let j = startIdx + 1; j < lines.length; j++) {
-      if (lines[j].includes(quote)) return j + 1;
+      let matched = false;
+
+      // ── #define MACRO … ──────────────────────────────────────────
+      if (raw[start] === '#') {
+        const afterHash = skipWhitespace(raw, start + 1);
+        if (startsWithKeyword(raw, 'define', afterHash)) {
+          const afterKw = skipWhitespace(raw, afterHash + 'define'.length);
+          if (readIdent(raw, afterKw)) matched = true;
+        }
+      }
+
+      // ── namespace / class / struct / union / enum (incl. `enum class`) ──
+      // Tip: also handle a leading `template <…>` by skipping over it.
+      let probeIdx = start;
+      if (startsWithKeyword(raw, 'template', probeIdx)) {
+        // skip "template" + optional whitespace + `<…>` if present
+        let j = skipWhitespace(raw, probeIdx + 'template'.length);
+        if (raw[j] === '<') {
+          let depth = 1;
+          j += 1;
+          while (j < raw.length && depth > 0) {
+            if (raw[j] === '<') depth += 1;
+            else if (raw[j] === '>') depth -= 1;
+            j += 1;
+          }
+          probeIdx = skipWhitespace(raw, j);
+        }
+      }
+      const typeHit = consumeAnyKeyword(raw, ['class', 'struct', 'union', 'enum', 'namespace'], probeIdx);
+      if (typeHit) {
+        let after = skipWhitespace(raw, typeHit.nextIdx);
+        // `enum class Color` — accept either form
+        if (typeHit.keyword === 'enum' && startsWithKeyword(raw, 'class', after)) {
+          after = skipWhitespace(raw, after + 'class'.length);
+        }
+        if (readIdent(raw, after)) matched = true;
+      }
+
+      // ── typedef … name; ──────────────────────────────────────────
+      if (!matched && startsWithKeyword(raw, 'typedef', start)) {
+        // very permissive — just require a `;` somewhere after typedef
+        if (raw.indexOf(';', start) !== -1) matched = true;
+      }
+
+      // ── using name = … ───────────────────────────────────────────
+      if (!matched && startsWithKeyword(raw, 'using', start)) {
+        const afterKw = skipWhitespace(raw, start + 'using'.length);
+        const id = readIdent(raw, afterKw);
+        if (id) {
+          const afterId = skipWhitespace(raw, id.nextIdx);
+          if (raw[afterId] === '=' && raw[afterId + 1] !== '=') matched = true;
+        }
+      }
+
+      // ── Function definition: <type-tokens> name(…) ───────────────
+      // Walk past at least one type-ish token before the function name.
+      // The "type-ish" tokens are either keywords from C_TYPE_KEYWORDS
+      // or any plain identifier (could be a user-defined type) — we
+      // require AT LEAST TWO tokens before the `(` so a bare call
+      // `foo(x)` isn't misidentified.
+      if (!matched) {
+        let j = probeIdx;
+        let tokensBeforeParen = 0;
+        let lastWasIdent = false;
+        while (j < raw.length) {
+          // pointer / reference / qualifiers in between tokens
+          if (raw[j] === '*' || raw[j] === '&') { j += 1; continue; }
+          j = skipWhitespace(raw, j);
+          if (j >= raw.length) break;
+          if (raw[j] === '(') break;
+          // accept a templated type like `vector<int>` — skip the `<…>`
+          if (raw[j] === '<' && lastWasIdent) {
+            let depth = 1; j += 1;
+            while (j < raw.length && depth > 0) {
+              if (raw[j] === '<') depth += 1;
+              else if (raw[j] === '>') depth -= 1;
+              j += 1;
+            }
+            continue;
+          }
+          // qualifier keyword?
+          const kw = consumeAnyKeyword(raw, C_TYPE_KEYWORDS, j);
+          if (kw) { j = kw.nextIdx; tokensBeforeParen += 1; lastWasIdent = false; continue; }
+          // plain identifier (possibly `Foo::bar`)
+          const id = readIdent(raw, j);
+          if (!id) break;
+          j = id.nextIdx;
+          // handle `Foo::bar` and similar
+          while (raw[j] === ':' && raw[j + 1] === ':') {
+            j += 2;
+            const more = readIdent(raw, j);
+            if (!more) break;
+            j = more.nextIdx;
+          }
+          tokensBeforeParen += 1;
+          lastWasIdent = true;
+        }
+        if (raw[j] === '(' && tokensBeforeParen >= 2) {
+          // Reject "looks like a call" — `name(args);` ending tail.
+          // For a definition we expect either `) {` or just `,` (multi-line)
+          // or `)` ending the line. A call ends with `);`.
+          const endsWithCallSemi = trimmedEndsWith(raw, ');');
+          if (!endsWithCallSemi) matched = true;
+        }
+      }
+
+      // ── Constructor / destructor: `Foo::Foo(...)` / `Foo::~Foo(...)` ──
+      if (!matched) {
+        const id1 = readIdent(raw, start);
+        if (id1 && raw[id1.nextIdx] === ':' && raw[id1.nextIdx + 1] === ':') {
+          let k = id1.nextIdx + 2;
+          if (raw[k] === '~') k += 1;
+          const id2 = readIdent(raw, k);
+          if (id2) {
+            const afterName = skipWhitespace(raw, id2.nextIdx);
+            if (raw[afterName] === '(') matched = true;
+          }
+        }
+      }
+
+      // publicOnly is a no-op for C — left intact for API parity with
+      // _parseJS. Could later mean "header-public only".
+      void publicOnly;
+
+      if (matched) {
+        if (withComments && pendingComments.length > 0) {
+          for (const c of pendingComments) entries.push(c);
+        }
+        entries.push({ line: lineNum, text: raw, kind: 'signature' });
+        pendingComments = [];
+      } else {
+        pendingComments = [];
+      }
     }
-    return lines.length;
+
+    return entries;
   }
 }