@specship/specship-darwin-arm64 0.29.0 → 0.30.0

package/lib/dist/extraction/tree-sitter.js

@@ -140,6 +140,52 @@ const INSTANTIATION_KINDS = new Set([
     'object_creation_expression', // java / c#
     'instance_creation_expression', // some grammars
 ]);
+/**
+ * Languages whose grammar lexes Annex-B HTML-like comments (`<!--`, `-->`),
+ * including inside regex literals — the case parseWithLiteralMask repairs.
+ */
+const JS_FAMILY = new Set(['typescript', 'tsx', 'javascript', 'jsx']);
+/**
+ * One pre-order walk over a tree: the start offset of every `html_comment`
+ * node, and the number of `ERROR` / missing nodes.
+ */
+function scanParseTree(tree) {
+    const htmlCommentStarts = [];
+    let errorCount = 0;
+    const cursor = tree.walk();
+    try {
+        for (;;) {
+            const node = cursor.currentNode;
+            if (node.type === 'html_comment')
+                htmlCommentStarts.push(node.startIndex);
+            else if (node.type === 'ERROR' || node.isMissing)
+                errorCount++;
+            if (cursor.gotoFirstChild())
+                continue;
+            while (!cursor.gotoNextSibling()) {
+                if (!cursor.gotoParent())
+                    return { htmlCommentStarts, errorCount };
+            }
+        }
+    }
+    finally {
+        cursor.delete();
+    }
+}
+/**
+ * Declaration kinds whose range, when it fully encloses a parse-error region,
+ * means the region's code still produced a declaration (REQ-HTMLLEX-003).
+ * Locals (variables, constants, properties) never count: a malformed function
+ * whose body still yields local constants must warn.
+ */
+const PARSE_REGION_ENCLOSING_KINDS = new Set([
+    'function', 'method', 'class', 'struct', 'interface', 'trait', 'enum',
+    'type_alias', 'namespace', 'module', 'component', 'route',
+]);
+/** Number of `<!--` and `-->` occurrences — the bound on mask attempts. */
+function countHtmlCommentDelimiters(source) {
+    return (source.match(/<!--|-->/g) ?? []).length;
+}
 /**
  * TreeSitterExtractor - Main extraction class
  */
@@ -161,6 +207,69 @@ class TreeSitterExtractor {
         this.language = language || (0, grammars_1.detectLanguage)(filePath, source);
         this.extractor = languages_1.EXTRACTORS[this.language] || null;
     }
+    /**
+     * Parse `this.source`, repairing the JS-family grammar's habit of lexing
+     * `<!--` / `-->` inside regex literals as HTML-like comments, which turns the
+     * enclosing declaration into an ERROR node (REQ-HTMLLEX-001).
+     *
+     * When the first parse contains `html_comment` nodes, each comment's opening
+     * delimiter is masked with a same-length string (`<!--` → `<!-_`,
+     * `-->` → `-_>`) in a copy of the source and the copy is reparsed. Offsets,
+     * rows and columns are unchanged, and node text is always sliced from the
+     * original `this.source`. A mask is kept only when the reparse has fewer
+     * ERROR nodes, or the same number and fewer `html_comment` nodes (a
+     * mis-lexed comment can swallow the rest of a line without any ERROR).
+     * A genuine HTML comment in a legacy script makes the reparse worse, so it
+     * keeps its meaning. Non-JS languages return the first parse untouched.
+     */
+    parseWithLiteralMask(parser) {
+        const original = parser.parse(this.source) ?? null;
+        if (!original || !JS_FAMILY.has(this.language))
+            return original;
+        if (!this.source.includes('<!--') && !this.source.includes('-->'))
+            return original;
+        let best = original;
+        let bestScan = scanParseTree(best);
+        if (bestScan.htmlCommentStarts.length === 0)
+            return original;
+        const chars = this.source.split('');
+        const tried = new Set();
+        let budget = countHtmlCommentDelimiters(this.source);
+        let improved = true;
+        while (improved && budget > 0) {
+            improved = false;
+            for (const start of bestScan.htmlCommentStarts) {
+                if (tried.has(start) || budget <= 0)
+                    continue;
+                tried.add(start);
+                const saved = chars.slice(start, start + 4);
+                if (this.source.startsWith('<!--', start))
+                    chars[start + 3] = '_';
+                else if (this.source.startsWith('-->', start))
+                    chars[start + 1] = '_';
+                else
+                    continue;
+                budget--;
+                const candidate = parser.parse(chars.join('')) ?? null;
+                const scan = candidate ? scanParseTree(candidate) : null;
+                if (candidate && scan && (scan.errorCount < bestScan.errorCount ||
+                    (scan.errorCount === bestScan.errorCount &&
+                        scan.htmlCommentStarts.length < bestScan.htmlCommentStarts.length))) {
+                    if (best !== original)
+                        best.delete();
+                    best = candidate;
+                    bestScan = scan;
+                    improved = true;
+                    break;
+                }
+                candidate?.delete();
+                chars.splice(start, saved.length, ...saved);
+            }
+        }
+        if (best !== original)
+            original.delete();
+        return best;
+    }
     /**
      * Parse and extract from the source code
      */
@@ -200,7 +309,7 @@ class TreeSitterExtractor {
             };
         }
         try {
-            this.tree = parser.parse(this.source) ?? null;
+            this.tree = this.parseWithLiteralMask(parser);
             if (!this.tree) {
                 throw new Error('Parser returned null tree');
             }
@@ -230,6 +339,7 @@ class TreeSitterExtractor {
             if (packageNodeId)
                 this.nodeStack.push(packageNodeId);
             this.visitNode(this.tree.rootNode);
+            this.reportParseErrorRegions(this.tree.rootNode);
             if (packageNodeId)
                 this.nodeStack.pop();
             this.nodeStack.pop();
@@ -267,6 +377,63 @@ class TreeSitterExtractor {
             durationMs: Date.now() - startTime,
         };
     }
+    /**
+     * Report parse-error regions that may have swallowed declarations
+     * (REQ-HTMLLEX-003). Collects every outermost `ERROR` node and emits one
+     * `warning`-severity `parse_error_region` error for each region that is not
+     * fully enclosed by an extracted declaration (function, method, class, …).
+     * A region inside an extracted function's body stays silent; a region at
+     * program level always warns, even when local constants were extracted from
+     * inside it. Only appends to `this.errors` — nodes and edges are untouched,
+     * so retrieval output is unchanged. Clean trees cost one `hasError` check.
+     */
+    reportParseErrorRegions(root) {
+        if (!root.hasError)
+            return;
+        const regions = [];
+        const stack = [root];
+        while (stack.length > 0) {
+            const node = stack.pop();
+            if (node.isError) {
+                regions.push({
+                    startLine: node.startPosition.row + 1,
+                    startColumn: node.startPosition.column,
+                    endLine: node.endPosition.row + 1,
+                    endColumn: node.endPosition.column,
+                });
+                continue; // outermost only — don't descend into an ERROR node
+            }
+            for (let i = node.childCount - 1; i >= 0; i--) {
+                const child = node.child(i);
+                if (child && child.hasError)
+                    stack.push(child);
+            }
+        }
+        if (regions.length === 0)
+            return;
+        const enclosing = this.nodes.filter((n) => PARSE_REGION_ENCLOSING_KINDS.has(n.kind));
+        regions.sort((a, b) => a.startLine - b.startLine);
+        for (const region of regions) {
+            // Position-precise: a stray `}` right after a function's own closing
+            // brace sits on the function's last line but outside its range.
+            const enclosed = enclosing.some((n) => (n.startLine < region.startLine ||
+                (n.startLine === region.startLine && n.startColumn <= region.startColumn)) &&
+                (n.endLine > region.endLine ||
+                    (n.endLine === region.endLine && n.endColumn >= region.endColumn)));
+            if (enclosed)
+                continue;
+            const range = region.startLine === region.endLine
+                ? `line ${region.startLine}`
+                : `lines ${region.startLine}–${region.endLine}`;
+            this.errors.push({
+                message: `Parse error region at ${range} produced no enclosing declaration; some declarations may be missing`,
+                filePath: this.filePath,
+                line: region.startLine,
+                severity: 'warning',
+                code: 'parse_error_region',
+            });
+        }
+    }
     /**
      * Visit a node and extract information
      */