ucn 3.6.28 → 3.7.0

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 Python, JS/TS, 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 Python, JS/TS, Go, Rust, Java, HTML (inline scripts).
 
 ## 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 Python, JS/TS, Go, Rust, Java, HTML)
 - Finding files by name — use glob
 
 ## The 5 Commands You'll Use Most

package/README.md

@@ -91,15 +91,9 @@ Instead of reading entire files, ask precise questions:
                           │
                     tree-sitter AST
                           │
-              ┌───────────┼───────────┐
-              │           │           │
-          ┌───┴───┐  ┌────┴────┐  ┌───┴──┐
-          │ JS/TS │  │ Python  │  │  Go  │
-          └───────┘  └─────────┘  └──────┘
-              ┌───────────┼───────────┐
-          ┌───┴───┐              ┌────┴───┐
-          │ Rust  │              │  Java  │
-          └───────┘              └────────┘
+            ┌─────────────┴─────────────┐
+            │    Supported Languages    │ 
+            └───────────────────────────┘
 ```
 
 No cloud. No API keys. Parses locally, stays local.
@@ -502,7 +496,7 @@ ucn toc                                   # Project overview
   │  Limitation              │  What happens                            │
   ├──────────────────────────┼──────────────────────────────────────────┤
   │                          │                                          │
-  │  5 languages only        │  JS/TS, Python, Go, Rust, Java.          │
+  │  6 languages only        │  JS/TS, Python, Go, Rust, Java, HTML.    │
   │  (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,24 @@ 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) continue;
+                    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) => {

package/languages/html.js

@@ -0,0 +1,237 @@
+/**
+ * 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 };
+}
+
+// ── 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 result = extractJS(code, parser);
+    if (!result) return [];
+    return result.jsModule.findCallsInCode(result.virtualJS, result.jsParser);
+}
+
+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
+};

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). 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.0",
   "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",

package/test/parser.test.js

@@ -12001,5 +12001,541 @@ module.exports = { process_data };
     });
 });
 
+// ============================================================================
+// HTML PARSING
+// ============================================================================
+
+describe('HTML Parsing', () => {
+    const { getParser, getLanguageModule } = require('../languages');
+
+    function getHtmlTools() {
+        return {
+            parser: getParser('html'),
+            mod: getLanguageModule('html')
+        };
+    }
+
+    // -- Language detection --
+
+    it('detects HTML files', () => {
+        assert.strictEqual(detectLanguage('file.html'), 'html');
+        assert.strictEqual(detectLanguage('page.htm'), 'html');
+        assert.strictEqual(detectLanguage('INDEX.HTML'), 'html');
+    });
+
+    // -- Script extraction basics --
+
+    it('finds functions in a single script block', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = '<html><body><script>\nfunction hello() { return 1; }\n</script></body></html>';
+        const fns = mod.findFunctions(html, parser);
+        assert.strictEqual(fns.length, 1);
+        assert.strictEqual(fns[0].name, 'hello');
+    });
+
+    it('finds functions from multiple script blocks', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = `<script>
+function foo() {}
+</script>
+<div>content</div>
+<script>
+function bar() {}
+</script>`;
+        const fns = mod.findFunctions(html, parser);
+        const names = fns.map(f => f.name);
+        assert.ok(names.includes('foo'), `Expected foo in ${names}`);
+        assert.ok(names.includes('bar'), `Expected bar in ${names}`);
+    });
+
+    it('returns empty results for HTML with no script tags', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = '<html><body><h1>Hello</h1></body></html>';
+        const result = mod.parse(html, parser);
+        assert.strictEqual(result.functions.length, 0);
+        assert.strictEqual(result.classes.length, 0);
+        assert.strictEqual(result.language, 'html');
+    });
+
+    it('returns empty results for empty script tag', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = '<html><body><script></script></body></html>';
+        const result = mod.parse(html, parser);
+        assert.strictEqual(result.functions.length, 0);
+    });
+
+    it('returns empty results when only external scripts present', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = '<script src="app.js"></script>\n<script src="vendor.js"></script>';
+        const result = mod.parse(html, parser);
+        assert.strictEqual(result.functions.length, 0);
+    });
+
+    // -- Type attribute filtering --
+
+    it('parses type="module" scripts', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = '<script type="module">\nfunction modFn() {}\n</script>';
+        const fns = mod.findFunctions(html, parser);
+        assert.strictEqual(fns.length, 1);
+        assert.strictEqual(fns[0].name, 'modFn');
+    });
+
+    it('parses type="text/javascript" scripts', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = '<script type="text/javascript">\nfunction textJsFn() {}\n</script>';
+        const fns = mod.findFunctions(html, parser);
+        assert.strictEqual(fns.length, 1);
+        assert.strictEqual(fns[0].name, 'textJsFn');
+    });
+
+    it('parses type="application/javascript" scripts', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = '<script type="application/javascript">\nfunction appJsFn() {}\n</script>';
+        const fns = mod.findFunctions(html, parser);
+        assert.strictEqual(fns.length, 1);
+        assert.strictEqual(fns[0].name, 'appJsFn');
+    });
+
+    it('skips type="application/json" scripts', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = '<script type="application/json">{"key": "value"}</script>\n<script>\nfunction realFn() {}\n</script>';
+        const fns = mod.findFunctions(html, parser);
+        assert.strictEqual(fns.length, 1);
+        assert.strictEqual(fns[0].name, 'realFn');
+    });
+
+    it('skips type="importmap" scripts', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = '<script type="importmap">{"imports": {}}</script>';
+        const result = mod.parse(html, parser);
+        assert.strictEqual(result.functions.length, 0);
+    });
+
+    it('parses scripts with no type attribute (default is JS)', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = '<script>\nfunction defaultFn() {}\n</script>';
+        const fns = mod.findFunctions(html, parser);
+        assert.strictEqual(fns.length, 1);
+        assert.strictEqual(fns[0].name, 'defaultFn');
+    });
+
+    it('skips scripts with src attribute', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = '<script src="app.js"></script>\n<script>\nfunction inlineFn() {}\n</script>';
+        const fns = mod.findFunctions(html, parser);
+        assert.strictEqual(fns.length, 1);
+        assert.strictEqual(fns[0].name, 'inlineFn');
+    });
+
+    // -- Line number accuracy --
+
+    it('reports correct line numbers for functions', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = `<html>
+<head>
+  <title>Test</title>
+</head>
+<body>
+  <script>
+    function atLine7() { return 1; }
+    function atLine8() { return 2; }
+  </script>
+</body>
+</html>`;
+        const fns = mod.findFunctions(html, parser);
+        const fn7 = fns.find(f => f.name === 'atLine7');
+        const fn8 = fns.find(f => f.name === 'atLine8');
+        assert.ok(fn7, 'atLine7 should be found');
+        assert.ok(fn8, 'atLine8 should be found');
+        assert.strictEqual(fn7.startLine, 7, `atLine7 should be on line 7, got ${fn7.startLine}`);
+        assert.strictEqual(fn8.startLine, 8, `atLine8 should be on line 8, got ${fn8.startLine}`);
+    });
+
+    it('reports correct line numbers across multiple script blocks with HTML gaps', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = `<script>
+function first() {}
+</script>
+<div>gap line 4</div>
+<div>gap line 5</div>
+<script>
+function second() {}
+</script>`;
+        const fns = mod.findFunctions(html, parser);
+        const first = fns.find(f => f.name === 'first');
+        const second = fns.find(f => f.name === 'second');
+        assert.ok(first && second, 'Both functions should be found');
+        assert.strictEqual(first.startLine, 2, `first should be at line 2, got ${first.startLine}`);
+        assert.strictEqual(second.startLine, 7, `second should be at line 7, got ${second.startLine}`);
+    });
+
+    it('reports correct line numbers for classes', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = `<html>
+<body>
+<script>
+class MyApp {
+    constructor() {}
+    render() {}
+}
+</script>
+</body>
+</html>`;
+        const classes = mod.findClasses(html, parser);
+        assert.strictEqual(classes.length, 1);
+        assert.strictEqual(classes[0].name, 'MyApp');
+        assert.strictEqual(classes[0].startLine, 4, `MyApp should start at line 4, got ${classes[0].startLine}`);
+    });
+
+    it('reports correct line numbers for state objects', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = `<html>
+<head>
+<script>
+const CONFIG = { debug: true, version: '1.0' };
+</script>
+</head>
+</html>`;
+        const states = mod.findStateObjects(html, parser);
+        const config = states.find(s => s.name === 'CONFIG');
+        assert.ok(config, 'CONFIG should be found');
+        assert.strictEqual(config.startLine, 4, `CONFIG should be at line 4, got ${config.startLine}`);
+    });
+
+    // -- Feature integration --
+
+    it('detects function calls between functions', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = `<script>
+function initApp() { renderUI(); loadData(); }
+function renderUI() { console.log('render'); }
+function loadData() { fetch('/api'); }
+</script>`;
+        const calls = mod.findCallsInCode(html, parser);
+        const callNames = calls.map(c => c.name);
+        assert.ok(callNames.includes('renderUI'), `Expected renderUI call, got: ${callNames}`);
+        assert.ok(callNames.includes('loadData'), `Expected loadData call, got: ${callNames}`);
+    });
+
+    it('detects cross-block function calls', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = `<script>
+function initApp() { renderUI(); }
+</script>
+<div>separator</div>
+<script>
+function renderUI() { console.log('render'); }
+</script>`;
+        const calls = mod.findCallsInCode(html, parser);
+        const callNames = calls.map(c => c.name);
+        assert.ok(callNames.includes('renderUI'), `Expected cross-block renderUI call, got: ${callNames}`);
+    });
+
+    it('finds usages within script blocks', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = `<script>
+const API_URL = '/api';
+function fetchData() { return fetch(API_URL); }
+</script>`;
+        const usages = mod.findUsagesInCode(html, 'API_URL', parser);
+        assert.ok(usages.length >= 1, `Expected at least 1 usage of API_URL, got ${usages.length}`);
+    });
+
+    it('finds imports in type="module" scripts', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = `<script type="module">
+import { createApp } from './app.js';
+createApp();
+</script>`;
+        const imports = mod.findImportsInCode(html, parser);
+        assert.ok(imports.length >= 1, `Expected imports, got ${imports.length}`);
+    });
+
+    it('finds classes and state objects', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = `<script>
+const SETTINGS = { theme: 'dark', lang: 'en' };
+class GameEngine {
+    constructor() {}
+    start() {}
+}
+</script>`;
+        const result = mod.parse(html, parser);
+        assert.ok(result.classes.length >= 1, 'Should find GameEngine class');
+        assert.strictEqual(result.classes[0].name, 'GameEngine');
+        const settings = result.stateObjects.find(s => s.name === 'SETTINGS');
+        assert.ok(settings, 'Should find SETTINGS state object');
+    });
+
+    // -- Edge cases --
+
+    it('handles script content on same line as script tag (column offset)', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = '<div><script>function inline() { return 42; }</script></div>';
+        const fns = mod.findFunctions(html, parser);
+        assert.strictEqual(fns.length, 1);
+        assert.strictEqual(fns[0].name, 'inline');
+    });
+
+    it('handles mixed JS and non-JS script blocks in same file', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = `<script type="application/json">{"not": "js"}</script>
+<script type="importmap">{"imports": {"a": "b"}}</script>
+<script>function realJS() {}</script>
+<script type="text/template"><div>{{template}}</div></script>`;
+        const fns = mod.findFunctions(html, parser);
+        assert.strictEqual(fns.length, 1);
+        assert.strictEqual(fns[0].name, 'realJS');
+    });
+
+    it('parse() returns language html', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = '<script>var x = 1;</script>';
+        const result = mod.parse(html, parser);
+        assert.strictEqual(result.language, 'html');
+    });
+
+    it('totalLines matches HTML file line count, not JS line count', () => {
+        const { parser, mod } = getHtmlTools();
+        const html = `<html>
+<head>
+  <title>Page</title>
+</head>
+<body>
+  <script>
+    var x = 1;
+  </script>
+</body>
+</html>`;
+        const result = mod.parse(html, parser);
+        assert.strictEqual(result.totalLines, 10, `Expected 10 lines, got ${result.totalLines}`);
+    });
+
+    // -- Project integration --
+
+    it('indexes HTML files in project mode', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-html-project-'));
+        fs.writeFileSync(path.join(tmpDir, 'index.html'), `<html>
+<body>
+<script>
+function initApp() { renderUI(); }
+function renderUI() { console.log('hello'); }
+const CONFIG = { debug: true };
+</script>
+</body>
+</html>`);
+        fs.writeFileSync(path.join(tmpDir, 'package.json'), '{"name":"test"}');
+
+        const { ProjectIndex } = require('../core/project');
+        const index = new ProjectIndex(tmpDir);
+        index.build(null, { quiet: true });
+
+        // Functions should be found
+        const initDefs = index.find('initApp');
+        assert.ok(initDefs.length > 0, 'initApp should be found in project index');
+        assert.strictEqual(initDefs[0].startLine, 4, 'initApp should be at line 4');
+
+        // Callers should work
+        const renderDefs = index.find('renderUI');
+        assert.ok(renderDefs.length > 0, 'renderUI should be found');
+        const callers = index.findCallers('renderUI');
+        const callerNames = callers.map(c => c.callerName);
+        assert.ok(callerNames.includes('initApp'), `initApp should call renderUI, got: ${callerNames}`);
+
+        // State objects should be found
+        const configDefs = index.find('CONFIG');
+        assert.ok(configDefs.length > 0, 'CONFIG should be found');
+
+        fs.rmSync(tmpDir, { recursive: true });
+    });
+
+    it('extractCode works with HTML files', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-html-extract-'));
+        const htmlContent = `<html>
+<body>
+<script>
+function greet(name) {
+    return 'Hello ' + name;
+}
+</script>
+</body>
+</html>`;
+        fs.writeFileSync(path.join(tmpDir, 'page.html'), htmlContent);
+        fs.writeFileSync(path.join(tmpDir, 'package.json'), '{"name":"test"}');
+
+        const { ProjectIndex } = require('../core/project');
+        const index = new ProjectIndex(tmpDir);
+        index.build(null, { quiet: true });
+
+        const defs = index.find('greet');
+        assert.ok(defs.length > 0, 'greet should be found');
+        const code = index.extractCode(defs[0]);
+        assert.ok(code.includes('function greet'), `Extracted code should contain function: ${code}`);
+        assert.ok(code.includes('Hello'), `Extracted code should contain body: ${code}`);
+
+        fs.rmSync(tmpDir, { recursive: true });
+    });
+
+    // -- extractScriptBlocks and buildVirtualJSContent unit tests --
+
+    it('extractScriptBlocks returns correct block positions', () => {
+        const { extractScriptBlocks } = require('../languages/html');
+        const parser = getParser('html');
+        const html = `<html>
+<body>
+<script>
+var x = 1;
+</script>
+</body>
+</html>`;
+        const blocks = extractScriptBlocks(html, parser);
+        assert.strictEqual(blocks.length, 1);
+        assert.strictEqual(blocks[0].startRow, 2, `Block should start at row 2 (0-indexed, raw_text starts after <script> closing >), got ${blocks[0].startRow}`);
+        assert.ok(blocks[0].text.includes('var x = 1'), `Block text should contain JS: ${blocks[0].text}`);
+    });
+
+    it('buildVirtualJSContent preserves line positions', () => {
+        const { buildVirtualJSContent } = require('../languages/html');
+        const html = `line0
+line1
+<script>
+var x = 1;
+</script>
+line5`;
+        const blocks = [{ text: '\nvar x = 1;\n', startRow: 2, startCol: 8 }];
+        const virtual = buildVirtualJSContent(html, blocks);
+        const lines = virtual.split('\n');
+        assert.strictEqual(lines.length, 6, `Should have 6 lines, got ${lines.length}`);
+        assert.strictEqual(lines[0], '', 'Line 0 should be empty (HTML)');
+        assert.strictEqual(lines[1], '', 'Line 1 should be empty (HTML)');
+        assert.strictEqual(lines[3].trim(), 'var x = 1;', 'Line 3 should have JS content');
+        assert.strictEqual(lines[5], '', 'Line 5 should be empty (HTML)');
+    });
+
+    // Bug fix tests
+    // ─────────────────────────────────────────────────────────────
+
+    it('cleanHtmlScriptTags strips script tags from same-line scripts', () => {
+        const { cleanHtmlScriptTags } = require('../core/parser');
+
+        // Same-line script: <script>function foo() { return 1; }</script>
+        const lines1 = ['<script>function foo() { return 1; }</script>'];
+        cleanHtmlScriptTags(lines1, 'html');
+        assert.strictEqual(lines1[0], 'function foo() { return 1; }');
+
+        // Multi-line: only first/last lines affected
+        const lines2 = ['    <script type="module">', '        function bar() {', '        }', '    </script>'];
+        cleanHtmlScriptTags(lines2, 'html');
+        assert.strictEqual(lines2[0], '    ', 'First line should have only indentation');
+        assert.strictEqual(lines2[1], '        function bar() {', 'Middle lines unchanged');
+        assert.strictEqual(lines2[3], '    ', 'Last line should have only indentation');
+
+        // Non-HTML language: no changes
+        const lines3 = ['<script>function foo() {}</script>'];
+        cleanHtmlScriptTags(lines3, 'javascript');
+        assert.strictEqual(lines3[0], '<script>function foo() {}</script>', 'Non-HTML should be unchanged');
+
+        // Uppercase SCRIPT tag
+        const lines4 = ['<SCRIPT>function foo() {}</SCRIPT>'];
+        cleanHtmlScriptTags(lines4, 'html');
+        assert.strictEqual(lines4[0], 'function foo() {}');
+    });
+
+    it('extractCode strips script tags for HTML files', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-html-extract-'));
+        const htmlFile = path.join(tmpDir, 'test.html');
+        fs.writeFileSync(htmlFile, `<!DOCTYPE html>
+<html>
+<body>
+<script>function oneLiner() { return 42; }</script>
+<script>
+function multiLine() {
+    return 99;
+}
+</script>
+</body>
+</html>`);
+
+        const { ProjectIndex } = require('../core/project');
+        const index = new ProjectIndex(tmpDir);
+        index.build();
+
+        // Find oneLiner and check its extracted code
+        const oneLineDefs = index.find('oneLiner');
+        assert.ok(oneLineDefs.length > 0, 'Should find oneLiner');
+        const code = index.extractCode(oneLineDefs[0]);
+        assert.ok(!code.includes('<script>'), 'extractCode should not include <script> tag');
+        assert.ok(!code.includes('</script>'), 'extractCode should not include </script> tag');
+        assert.ok(code.includes('function oneLiner'), 'extractCode should include function body');
+
+        // Multi-line function should not be affected
+        const multiDefs = index.find('multiLine');
+        assert.ok(multiDefs.length > 0, 'Should find multiLine');
+        const multiCode = index.extractCode(multiDefs[0]);
+        assert.ok(!multiCode.includes('<script>'), 'Multi-line extractCode should not include <script>');
+        assert.ok(multiCode.includes('function multiLine'), 'Multi-line extractCode should include function body');
+
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('smart respects --file disambiguation', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-html-smart-'));
+        // Create two files with same function name
+        fs.writeFileSync(path.join(tmpDir, 'a.html'), `<html><body>
+<script>
+function myFunc() { return 'from html'; }
+</script>
+</body></html>`);
+        fs.writeFileSync(path.join(tmpDir, 'b.js'), `function myFunc() { return 'from js'; }\n`);
+        // Need package.json for discovery
+        fs.writeFileSync(path.join(tmpDir, 'package.json'), '{"name": "test"}');
+
+        const { ProjectIndex } = require('../core/project');
+        const index = new ProjectIndex(tmpDir);
+        index.build();
+
+        // Without --file, picks best scoring (b.js is not in tests/ so it should win)
+        const result1 = index.smart('myFunc');
+        assert.ok(result1, 'smart should find myFunc');
+
+        // With --file=a.html, should pick the HTML file
+        const result2 = index.smart('myFunc', { file: 'a.html' });
+        assert.ok(result2, 'smart with file filter should find myFunc');
+        assert.ok(result2.target.file.endsWith('a.html'), `Should resolve to a.html, got ${result2.target.file}`);
+
+        // With --file=b.js, should pick the JS file
+        const result3 = index.smart('myFunc', { file: 'b.js' });
+        assert.ok(result3, 'smart with file filter should find myFunc in b.js');
+        assert.ok(result3.target.file.endsWith('b.js'), `Should resolve to b.js, got ${result3.target.file}`);
+
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('deadcode buildUsageIndex parses HTML inline scripts', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-html-deadcode-'));
+        fs.writeFileSync(path.join(tmpDir, 'app.html'), `<html><body>
+<script>
+function helper() { return 42; }
+function main() { return helper(); }
+</script>
+</body></html>`);
+        fs.writeFileSync(path.join(tmpDir, 'package.json'), '{"name": "test"}');
+
+        const { ProjectIndex } = require('../core/project');
+        const index = new ProjectIndex(tmpDir);
+        index.build();
+
+        // helper is called by main, so it should NOT be dead code
+        const dead = index.deadcode({ includeExported: true });
+        const deadNames = dead.map(d => d.name);
+        assert.ok(!deadNames.includes('helper'), `helper should not be dead code (called by main), got: ${deadNames.join(', ')}`);
+        // main has no callers, so it should be dead
+        assert.ok(deadNames.includes('main'), 'main should be dead code (no callers)');
+
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+});
+
 console.log('UCN v3 Test Suite');
 console.log('Run with: node --test test/parser.test.js');