ucn 3.6.28 → 3.7.1

package/.claude/skills/ucn/SKILL.md

@@ -1,13 +1,13 @@
 ---
 name: ucn
-description: "Code relationship analyzer (callers, call trees, impact, dead code) via tree-sitter AST. PREFER over grep+read when you need: who calls a function, what breaks if you change it, or the full call chain of a pipeline. One `ucn about` replaces 3-4 grep+read cycles. One `ucn trace` maps an entire execution flow without reading any files. Works on Python, JS/TS, Go, Rust, Java. Skip for plain text search or codebases under 500 LOC."
+description: "Code relationship analyzer (callers, call trees, impact, dead code) via tree-sitter AST. PREFER over grep+read when you need: who calls a function, what breaks if you change it, or the full call chain of a pipeline. One `ucn about` replaces 3-4 grep+read cycles. One `ucn trace` maps an entire execution flow without reading any files. Works on JS/TS, Python, Go, Rust, Java, HTML. Skip for plain text search or codebases under 500 LOC."
 allowed-tools: Bash(ucn *), Bash(npx ucn *)
 argument-hint: "[command] [symbol-name] [--flags]"
 ---
 
 # UCN — Universal Code Navigator
 
-Understands code structure via tree-sitter ASTs: who calls what, what breaks if you change something, full call trees, dead code. Works on Python, JS/TS, Go, Rust, Java.
+Understands code structure via tree-sitter ASTs: who calls what, what breaks if you change something, full call trees, dead code. Works on JS/TS, Python, Go, Rust, Java. Also parses HTML files (inline scripts and event handlers).
 
 ## When to Reach for UCN Instead of Grep/Read
 
@@ -23,7 +23,7 @@ Understands code structure via tree-sitter ASTs: who calls what, what breaks if
 
 - Searching for a string literal, error message, TODO, or config value
 - The codebase is under 500 LOC — just read the files
-- Language not supported (only Python, JS/TS, Go, Rust, Java)
+- Language not supported (only JS/TS, Python, Go, Rust, Java, HTML)
 - Finding files by name — use glob
 
 ## The 5 Commands You'll Use Most

package/README.md

@@ -2,6 +2,8 @@
 
 UCN is designed to work with large files and codebases, helping AI agents ingest exactly the data they need. Its surgical output discourages agents from cutting corners, and without UCN, agents working with large codebases tend to skip parts of the code structure, assuming they have "enough data."
 
+Supported languages: JS/TS, Python, Go, Rust, Java. Also parses HTML files (inline scripts and event handlers).
+
 ---
 
 ## Three Ways to Use UCN
@@ -91,15 +93,10 @@ Instead of reading entire files, ask precise questions:
                           │
                     tree-sitter AST
                           │
-              ┌───────────┼───────────┐
-              │           │           │
-          ┌───┴───┐  ┌────┴────┐  ┌───┴──┐
-          │ JS/TS │  │ Python  │  │  Go  │
-          └───────┘  └─────────┘  └──────┘
-              ┌───────────┼───────────┐
-          ┌───┴───┐              ┌────┴───┐
-          │ Rust  │              │  Java  │
-          └───────┘              └────────┘
+      ┌───────────────────┴─────────────────┐
+      │          Supported Languages        │
+      │ JS/TS, Python, Go, Rust, Java, HTML │
+      └─────────────────────────────────────┘
 ```
 
 No cloud. No API keys. Parses locally, stays local.
@@ -502,7 +499,7 @@ ucn toc                                   # Project overview
   │  Limitation              │  What happens                            │
   ├──────────────────────────┼──────────────────────────────────────────┤
   │                          │                                          │
-  │  5 languages only        │  JS/TS, Python, Go, Rust, Java.          │
+  │  5 languages + HTML      │  JS/TS, Python, Go, Rust, Java.          │
   │  (no C, Ruby, PHP, etc.) │  Agents fall back to grep for the rest.  │
   │                          │  UCN complements, doesn't replace.       │
   │                          │                                          │

package/cli/index.js

@@ -10,7 +10,7 @@
 const fs = require('fs');
 const path = require('path');
 
-const { parse, parseFile, extractFunction, extractClass, detectLanguage, isSupported } = require('../core/parser');
+const { parse, parseFile, extractFunction, extractClass, cleanHtmlScriptTags, detectLanguage, isSupported } = require('../core/parser');
 const { getParser, getLanguageModule } = require('../languages');
 const { ProjectIndex } = require('../core/project');
 const { expandGlob, findProjectRoot, isTestFile } = require('../core/discovery');
@@ -823,6 +823,7 @@ function runProjectCommand(rootDir, command, arg) {
         case 'smart': {
             requireArg(arg, 'Usage: ucn . smart <name>');
             const smart = index.smart(arg, {
+                file: flags.file,
                 withTypes: flags.withTypes,
                 includeMethods: flags.includeMethods,
                 includeUncertain: flags.includeUncertain
@@ -1069,7 +1070,8 @@ function extractFunctionFromProject(index, name) {
             const m = matches[i];
             const code = fs.readFileSync(m.file, 'utf-8');
             const lines = code.split('\n');
-            const fnCode = lines.slice(m.startLine - 1, m.endLine).join('\n');
+            const extracted = lines.slice(m.startLine - 1, m.endLine);
+            const fnCode = cleanHtmlScriptTags(extracted, detectLanguage(m.file)).join('\n');
             if (i > 0) console.log('');
             if (flags.json) {
                 console.log(output.formatFunctionJson(m, fnCode));
@@ -1093,7 +1095,8 @@ function extractFunctionFromProject(index, name) {
     // Extract code directly using symbol index location (works for class methods and overloads)
     const code = fs.readFileSync(match.file, 'utf-8');
     const lines = code.split('\n');
-    const fnCode = lines.slice(match.startLine - 1, match.endLine).join('\n');
+    const extracted = lines.slice(match.startLine - 1, match.endLine);
+    const fnCode = cleanHtmlScriptTags(extracted, detectLanguage(match.file)).join('\n');
 
     if (flags.json) {
         console.log(output.formatFunctionJson(match, fnCode));
@@ -1118,7 +1121,8 @@ function extractClassFromProject(index, name) {
             const m = matches[i];
             const code = fs.readFileSync(m.file, 'utf-8');
             const codeLines = code.split('\n');
-            const clsCode = codeLines.slice(m.startLine - 1, m.endLine).join('\n');
+            const extracted = codeLines.slice(m.startLine - 1, m.endLine);
+            const clsCode = cleanHtmlScriptTags(extracted, detectLanguage(m.file)).join('\n');
             if (i > 0) console.log('');
             if (flags.json) {
                 console.log(JSON.stringify({ ...m, code: clsCode }, null, 2));
@@ -1142,7 +1146,8 @@ function extractClassFromProject(index, name) {
     // Use index data directly instead of re-parsing the file
     const code = fs.readFileSync(match.file, 'utf-8');
     const codeLines = code.split('\n');
-    const clsCode = codeLines.slice(match.startLine - 1, match.endLine).join('\n');
+    const extracted = codeLines.slice(match.startLine - 1, match.endLine);
+    const clsCode = cleanHtmlScriptTags(extracted, detectLanguage(match.file)).join('\n');
 
     if (flags.json) {
         console.log(JSON.stringify({ ...match, code: clsCode }, null, 2));
@@ -1673,7 +1678,7 @@ function isCommentOrString(line) {
 function printUsage() {
     console.log(`UCN - Universal Code Navigator
 
-Supported: JavaScript, TypeScript, Python, Go, Rust, Java
+Supported: JavaScript, TypeScript, Python, Go, Rust, Java, HTML
 
 Usage:
   ucn [command] [args]            Project mode (current directory)
@@ -1928,7 +1933,7 @@ function executeInteractiveCommand(index, command, arg) {
                 console.log('Usage: smart <name>');
                 return;
             }
-            const smart = index.smart(arg, { includeUncertain: flags.includeUncertain });
+            const smart = index.smart(arg, { file: flags.file, includeUncertain: flags.includeUncertain });
             if (smart) {
                 console.log(output.formatSmart(smart, {
                     uncertainHint: 'use --include-uncertain to include all'

package/core/discovery.js

@@ -389,7 +389,7 @@ function detectProjectPattern(projectRoot) {
     // Helper to check for config files in a directory
     const checkDir = (dir) => {
         if (fs.existsSync(path.join(dir, 'package.json'))) {
-            extensions.push('js', 'jsx', 'ts', 'tsx', 'mjs', 'cjs');
+            extensions.push('js', 'jsx', 'ts', 'tsx', 'mjs', 'cjs', 'html', 'htm');
         }
 
         if (fs.existsSync(path.join(dir, 'pyproject.toml')) ||
@@ -433,7 +433,7 @@ function detectProjectPattern(projectRoot) {
         return `**/*.{${unique.join(',')}}`;
     }
 
-    return '**/*.{js,jsx,ts,tsx,py,go,java,rs,rb,php,c,cpp,h,hpp}';
+    return '**/*.{js,jsx,ts,tsx,py,go,java,rs,rb,php,c,cpp,h,hpp,html,htm}';
 }
 
 /**

package/core/parser.js

@@ -128,7 +128,8 @@ function extractFunction(code, language, name) {
         return { fn: null, code: '' };
     }
 
-    const fnCode = lines.slice(fn.startLine - 1, fn.endLine).join('\n');
+    const extracted = lines.slice(fn.startLine - 1, fn.endLine);
+    const fnCode = cleanHtmlScriptTags(extracted, language).join('\n');
     return { fn, code: fnCode };
 }
 
@@ -148,7 +149,8 @@ function extractClass(code, language, name) {
         return { cls: null, code: '' };
     }
 
-    const clsCode = lines.slice(cls.startLine - 1, cls.endLine).join('\n');
+    const extracted = lines.slice(cls.startLine - 1, cls.endLine);
+    const clsCode = cleanHtmlScriptTags(extracted, language).join('\n');
     return { cls, code: clsCode };
 }
 
@@ -266,6 +268,22 @@ function getExportedSymbols(result) {
     return exported;
 }
 
+/**
+ * Strip <script> and </script> tags from extracted code lines for HTML files.
+ * Only affects the first and last lines when they contain script tags alongside JS code.
+ * @param {string[]} lines - Extracted lines
+ * @param {string} language - Language name
+ * @returns {string[]} Cleaned lines (same array mutated)
+ */
+function cleanHtmlScriptTags(lines, language) {
+    if (language === 'html' && lines.length > 0) {
+        lines[0] = lines[0].replace(/^(\s*)<script[^>]*>/i, '$1');
+        const last = lines.length - 1;
+        lines[last] = lines[last].replace(/<\/script>\s*$/i, '');
+    }
+    return lines;
+}
+
 module.exports = {
     parse,
     parseFile,
@@ -274,6 +292,7 @@ module.exports = {
     getToc,
     findSymbol,
     getExportedSymbols,
+    cleanHtmlScriptTags,
     detectLanguage,
     isSupported
 };

package/core/project.js

@@ -11,7 +11,7 @@ const crypto = require('crypto');
 const { execSync } = require('child_process');
 const { expandGlob, findProjectRoot, detectProjectPattern, isTestFile, parseGitignore, DEFAULT_IGNORES } = require('./discovery');
 const { extractImports, extractExports, resolveImport } = require('./imports');
-const { parseFile } = require('./parser');
+const { parseFile, cleanHtmlScriptTags } = require('./parser');
 const { detectLanguage, getParser, getLanguageModule, PARSE_OPTIONS, safeParse } = require('../languages');
 const { getTokenTypeAtPosition } = require('../languages/utils');
 
@@ -1881,7 +1881,9 @@ class ProjectIndex {
         try {
             const content = fs.readFileSync(symbol.file, 'utf-8');
             const lines = content.split('\n');
-            return lines.slice(symbol.startLine - 1, symbol.endLine).join('\n');
+            const extracted = lines.slice(symbol.startLine - 1, symbol.endLine);
+            cleanHtmlScriptTags(extracted, detectLanguage(symbol.file));
+            return extracted.join('\n');
         } catch (e) {
             return '';
         }
@@ -2605,11 +2607,26 @@ class ProjectIndex {
                 const language = detectLanguage(filePath);
                 if (!language) continue;
 
-                const parser = getParser(language);
-                if (!parser) continue;
-
                 const content = fs.readFileSync(filePath, 'utf-8');
-                const tree = parser.parse(content, undefined, PARSE_OPTIONS);
+
+                // For HTML files, parse the virtual JS content instead of raw HTML
+                // (HTML tree-sitter sees script content as raw_text, not JS identifiers)
+                let tree;
+                if (language === 'html') {
+                    const htmlModule = getLanguageModule('html');
+                    const htmlParser = getParser('html');
+                    const jsParser = getParser('javascript');
+                    const blocks = htmlModule.extractScriptBlocks(content, htmlParser);
+                    if (blocks.length === 0 && !htmlModule.extractEventHandlerCalls) continue;
+                    if (blocks.length > 0) {
+                        const virtualJS = htmlModule.buildVirtualJSContent(content, blocks);
+                        tree = jsParser.parse(virtualJS, undefined, PARSE_OPTIONS);
+                    }
+                } else {
+                    const parser = getParser(language);
+                    if (!parser) continue;
+                    tree = parser.parse(content, undefined, PARSE_OPTIONS);
+                }
 
                 // Collect all identifiers from this file in one pass
                 const traverse = (node) => {
@@ -2634,7 +2651,25 @@ class ProjectIndex {
                         traverse(node.child(i));
                     }
                 };
-                traverse(tree.rootNode);
+                if (tree) traverse(tree.rootNode);
+
+                // For HTML files, also extract identifiers from event handler attributes
+                // (onclick="foo()" etc. — these are in HTML, not in <script> blocks)
+                if (language === 'html') {
+                    const htmlModule = getLanguageModule('html');
+                    const htmlParser = getParser('html');
+                    const handlerCalls = htmlModule.extractEventHandlerCalls(content, htmlParser);
+                    for (const call of handlerCalls) {
+                        if (!usageIndex.has(call.name)) {
+                            usageIndex.set(call.name, []);
+                        }
+                        usageIndex.get(call.name).push({
+                            file: filePath,
+                            line: call.line,
+                            relativePath: fileEntry.relativePath
+                        });
+                    }
+                }
             } catch (e) {
                 // Skip files that can't be processed
             }

package/languages/html.js

@@ -0,0 +1,318 @@
+/**
+ * languages/html.js - HTML file support via inline <script> extraction
+ *
+ * Parses HTML with tree-sitter-html, extracts inline JavaScript from <script> blocks,
+ * builds a line-preserving virtual JS string, and delegates to javascript.js for analysis.
+ * Line numbers are automatically correct because the virtual JS has the same line count
+ * as the original HTML file, with empty lines for non-script content.
+ */
+
+const { getParser, getLanguageModule } = require('./index');
+
+// Script type values that indicate JavaScript content
+const JS_TYPES = new Set([
+    'text/javascript',
+    'application/javascript',
+    'module',
+    ''
+]);
+
+/**
+ * Extract inline script blocks from HTML using tree-sitter-html AST.
+ * Skips external scripts (src=...) and non-JS types (application/json, importmap, etc.).
+ *
+ * @param {string} htmlContent - Raw HTML source
+ * @param {object} htmlParser - tree-sitter parser configured for HTML
+ * @returns {Array<{text: string, startRow: number, startCol: number}>}
+ */
+function extractScriptBlocks(htmlContent, htmlParser) {
+    const { safeParse, getParseOptions } = require('./index');
+    const tree = safeParse(htmlParser, htmlContent, undefined, getParseOptions(htmlContent.length));
+    const blocks = [];
+
+    // Walk the AST looking for script_element nodes
+    const visit = (node) => {
+        if (node.type === 'script_element') {
+            const startTag = node.childForFieldName('start_tag') ||
+                node.children.find(c => c.type === 'start_tag');
+            const rawText = node.children.find(c => c.type === 'raw_text');
+
+            if (!startTag || !rawText || !rawText.text) return;
+
+            // Check attributes on start_tag
+            let hasSrc = false;
+            let typeValue = null;
+
+            for (let i = 0; i < startTag.childCount; i++) {
+                const attr = startTag.child(i);
+                if (attr.type !== 'attribute') continue;
+
+                const nameNode = attr.children.find(c => c.type === 'attribute_name');
+                if (!nameNode) continue;
+                const attrName = nameNode.text.toLowerCase();
+
+                if (attrName === 'src') {
+                    hasSrc = true;
+                    break;
+                }
+
+                if (attrName === 'type') {
+                    const valueNode = attr.children.find(c =>
+                        c.type === 'quoted_attribute_value' || c.type === 'attribute_value'
+                    );
+                    if (valueNode) {
+                        // Extract value text - strip quotes if quoted_attribute_value
+                        const innerValue = valueNode.type === 'quoted_attribute_value'
+                            ? valueNode.children.find(c => c.type === 'attribute_value')
+                            : valueNode;
+                        typeValue = innerValue ? innerValue.text.toLowerCase().trim() : '';
+                    } else {
+                        typeValue = '';
+                    }
+                }
+            }
+
+            // Skip external scripts
+            if (hasSrc) return;
+
+            // Skip non-JS types
+            if (typeValue !== null && !JS_TYPES.has(typeValue)) return;
+
+            blocks.push({
+                text: rawText.text,
+                startRow: rawText.startPosition.row,
+                startCol: rawText.startPosition.column
+            });
+            return; // Don't recurse into script_element children
+        }
+
+        for (let i = 0; i < node.childCount; i++) {
+            visit(node.child(i));
+        }
+    };
+
+    visit(tree.rootNode);
+    return blocks;
+}
+
+/**
+ * Build a virtual JS string with the same line count as the HTML file.
+ * Script block lines are placed at their original positions; everything else is empty.
+ * The first line of each block is padded with spaces to match its column offset.
+ *
+ * @param {string} htmlContent - Raw HTML source
+ * @param {Array<{text: string, startRow: number, startCol: number}>} blocks
+ * @returns {string}
+ */
+function buildVirtualJSContent(htmlContent, blocks) {
+    const totalLines = htmlContent.split('\n').length;
+    const lines = new Array(totalLines).fill('');
+
+    for (const block of blocks) {
+        const blockLines = block.text.split('\n');
+        for (let i = 0; i < blockLines.length; i++) {
+            const row = block.startRow + i;
+            if (row >= totalLines) break;
+            if (i === 0 && block.startCol > 0) {
+                // Pad first line to match column offset
+                lines[row] = ' '.repeat(block.startCol) + blockLines[i];
+            } else {
+                lines[row] = blockLines[i];
+            }
+        }
+    }
+
+    return lines.join('\n');
+}
+
+/**
+ * Extract JavaScript from HTML and prepare for JS parsing.
+ * Returns null if no inline scripts found.
+ *
+ * @param {string} htmlContent - Raw HTML source
+ * @param {object} htmlParser - tree-sitter parser configured for HTML
+ * @returns {{virtualJS: string, jsParser: object, jsModule: object}|null}
+ */
+function extractJS(htmlContent, htmlParser) {
+    const blocks = extractScriptBlocks(htmlContent, htmlParser);
+    if (blocks.length === 0) return null;
+
+    const virtualJS = buildVirtualJSContent(htmlContent, blocks);
+    const jsParser = getParser('javascript');
+    const jsModule = getLanguageModule('javascript');
+
+    return { virtualJS, jsParser, jsModule };
+}
+
+/**
+ * Extract function calls from HTML event handler attributes (onclick, onchange, etc.).
+ * Walks the HTML AST for elements with on* attributes, extracts function names
+ * from the attribute values using regex, and returns call objects.
+ *
+ * @param {string} htmlContent - Raw HTML source
+ * @param {object} htmlParser - tree-sitter parser configured for HTML
+ * @returns {Array<{name: string, line: number, isMethod: boolean, enclosingFunction: null, uncertain: boolean, isEventHandler: boolean}>}
+ */
+function extractEventHandlerCalls(htmlContent, htmlParser) {
+    const { safeParse, getParseOptions } = require('./index');
+    const tree = safeParse(htmlParser, htmlContent, undefined, getParseOptions(htmlContent.length));
+    const calls = [];
+
+    const JS_KEYWORDS = new Set([
+        'if', 'for', 'while', 'switch', 'catch', 'function', 'return',
+        'typeof', 'void', 'delete', 'new', 'throw', 'class', 'const',
+        'let', 'var', 'true', 'false', 'null', 'undefined', 'this'
+    ]);
+
+    const visit = (node) => {
+        // Skip script elements — their content is handled separately
+        if (node.type === 'script_element') return;
+
+        if (node.type === 'attribute') {
+            const nameNode = node.children.find(c => c.type === 'attribute_name');
+            if (!nameNode || !nameNode.text.toLowerCase().startsWith('on')) {
+                for (let i = 0; i < node.childCount; i++) visit(node.child(i));
+                return;
+            }
+
+            const valueNode = node.children.find(c =>
+                c.type === 'quoted_attribute_value' || c.type === 'attribute_value'
+            );
+            if (!valueNode) return;
+
+            let valueText;
+            if (valueNode.type === 'quoted_attribute_value') {
+                const inner = valueNode.children.find(c => c.type === 'attribute_value');
+                valueText = inner ? inner.text : '';
+            } else {
+                valueText = valueNode.text;
+            }
+            if (!valueText) return;
+
+            const line = nameNode.startPosition.row + 1; // 1-indexed
+
+            // Extract standalone function calls (not method calls like obj.method())
+            const regex = /([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/g;
+            let match;
+            while ((match = regex.exec(valueText)) !== null) {
+                const fnName = match[1];
+                if (JS_KEYWORDS.has(fnName)) continue;
+                // Skip if preceded by dot (method call on object)
+                if (match.index > 0 && valueText[match.index - 1] === '.') continue;
+
+                calls.push({
+                    name: fnName,
+                    line,
+                    isMethod: false,
+                    enclosingFunction: null,
+                    uncertain: false,
+                    isEventHandler: true
+                });
+            }
+            return;
+        }
+
+        for (let i = 0; i < node.childCount; i++) visit(node.child(i));
+    };
+
+    visit(tree.rootNode);
+    return calls;
+}
+
+// ── Exported language module interface ──────────────────────────────────────
+
+function parse(code, parser) {
+    const result = extractJS(code, parser);
+    if (!result) {
+        return {
+            language: 'html',
+            totalLines: code.split('\n').length,
+            functions: [],
+            classes: [],
+            stateObjects: [],
+            imports: [],
+            exports: []
+        };
+    }
+
+    const jsResult = result.jsModule.parse(result.virtualJS, result.jsParser);
+    jsResult.language = 'html';
+    jsResult.totalLines = code.split('\n').length;
+    return jsResult;
+}
+
+function findFunctions(code, parser) {
+    const result = extractJS(code, parser);
+    if (!result) return [];
+    return result.jsModule.findFunctions(result.virtualJS, result.jsParser);
+}
+
+function findClasses(code, parser) {
+    const result = extractJS(code, parser);
+    if (!result) return [];
+    return result.jsModule.findClasses(result.virtualJS, result.jsParser);
+}
+
+function findStateObjects(code, parser) {
+    const result = extractJS(code, parser);
+    if (!result) return [];
+    return result.jsModule.findStateObjects(result.virtualJS, result.jsParser);
+}
+
+function findCallsInCode(code, parser) {
+    const scriptCalls = (() => {
+        const result = extractJS(code, parser);
+        if (!result) return [];
+        return result.jsModule.findCallsInCode(result.virtualJS, result.jsParser);
+    })();
+    const handlerCalls = extractEventHandlerCalls(code, parser);
+    if (handlerCalls.length === 0) return scriptCalls;
+    return scriptCalls.concat(handlerCalls);
+}
+
+function findCallbackUsages(code, name, parser) {
+    const result = extractJS(code, parser);
+    if (!result) return [];
+    return result.jsModule.findCallbackUsages(result.virtualJS, name, result.jsParser);
+}
+
+function findReExports(code, parser) {
+    const result = extractJS(code, parser);
+    if (!result) return [];
+    return result.jsModule.findReExports(result.virtualJS, result.jsParser);
+}
+
+function findImportsInCode(code, parser) {
+    const result = extractJS(code, parser);
+    if (!result) return [];
+    return result.jsModule.findImportsInCode(result.virtualJS, result.jsParser);
+}
+
+function findExportsInCode(code, parser) {
+    const result = extractJS(code, parser);
+    if (!result) return [];
+    return result.jsModule.findExportsInCode(result.virtualJS, result.jsParser);
+}
+
+function findUsagesInCode(code, name, parser) {
+    const result = extractJS(code, parser);
+    if (!result) return [];
+    return result.jsModule.findUsagesInCode(result.virtualJS, name, result.jsParser);
+}
+
+module.exports = {
+    parse,
+    findFunctions,
+    findClasses,
+    findStateObjects,
+    findCallsInCode,
+    findCallbackUsages,
+    findReExports,
+    findImportsInCode,
+    findExportsInCode,
+    findUsagesInCode,
+    // Exported for testing
+    extractScriptBlocks,
+    buildVirtualJSContent,
+    extractEventHandlerCalls
+};

package/languages/index.js

@@ -55,6 +55,12 @@ const LANGUAGES = {
         extensions: ['.java'],
         treeSitterLang: 'java',
         module: () => require('./java')
+    },
+    html: {
+        name: 'html',
+        extensions: ['.html', '.htm'],
+        treeSitterLang: 'html',
+        module: () => require('./html')
     }
 };
 
@@ -124,6 +130,9 @@ function getParser(language) {
             case 'rust':
                 lang = require('tree-sitter-rust');
                 break;
+            case 'html':
+                lang = require('tree-sitter-html');
+                break;
             default:
                 throw new Error(`No tree-sitter grammar for: ${language}`);
         }
@@ -238,9 +247,12 @@ function safeParse(parser, content, oldTree = undefined, options = {}) {
         } catch (e) {
             lastError = e;
             // Only retry on buffer-related errors
-            if (!e.message?.toLowerCase().includes('buffer') &&
-                !e.message?.toLowerCase().includes('memory') &&
-                !e.message?.toLowerCase().includes('alloc')) {
+            // tree-sitter throws "Invalid argument" when buffer is too small
+            const msg = e.message?.toLowerCase() || '';
+            if (!msg.includes('buffer') &&
+                !msg.includes('memory') &&
+                !msg.includes('alloc') &&
+                !msg.includes('invalid argument')) {
                 throw e; // Non-buffer error, don't retry
             }
             // Continue to next buffer size

package/mcp/server.js

@@ -169,7 +169,7 @@ function requireName(name) {
 // CONSOLIDATED TOOL REGISTRATION
 // ============================================================================
 
-const TOOL_DESCRIPTION = `Universal Code Navigator powered by tree-sitter ASTs. Analyzes code structure — functions, callers, callees, dependencies — across JavaScript/TypeScript, Python, Go, Rust, and Java. Use instead of grep/read for code relationships.
+const TOOL_DESCRIPTION = `Universal Code Navigator powered by tree-sitter ASTs. Analyzes code structure — functions, callers, callees, dependencies — across JavaScript/TypeScript, Python, Go, Rust, Java, and HTML (inline scripts and event handlers). Use instead of grep/read for code relationships.
 
 TOP 5 (covers 90% of tasks): about, impact, trace, find, deadcode
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucn",
-  "version": "3.6.28",
+  "version": "3.7.1",
   "description": "Universal Code Navigator — function relationships, call trees, and impact analysis across large codebases without reading entire files.",
   "main": "index.js",
   "bin": {
@@ -21,6 +21,7 @@
     "go",
     "rust",
     "java",
+    "html",
     "ai",
     "agent"
   ],
@@ -34,6 +35,7 @@
   "dependencies": {
     "tree-sitter": "^0.21.0",
     "tree-sitter-go": "^0.21.0",
+    "tree-sitter-html": "^0.23.0",
     "tree-sitter-java": "^0.21.0",
     "tree-sitter-javascript": "^0.21.0",
     "tree-sitter-python": "^0.21.0",