pi-hashline-edit-pro 6.1.2 → 6.3.0

package/src/outline/vendor/README.md

@@ -0,0 +1,17 @@
+# Vendored tree-sitter parsers
+
+These files are copied from [pi-codebase-reader](https://github.com/HanzCEO/pi-codebase-reader) 0.8.0, licensed under Apache-2.0 (see `LICENSE`), with these modifications:
+
+- `parsers/manager.ts` loads every grammar from `../wasm/` instead of resolving WASM files from npm grammar packages.
+- `parsers/manager.ts` no longer supports Smali: the published `tree-sitter-smali` package ships no WASM, so `parsers/smali.ts` is not vendored.
+- `parsers/manager.ts` recurses into the bodies of exported classes, interfaces, and enums. Upstream looked for the body on the `export_statement` node, which dropped every member of an exported declaration.
+- `parsers/manager.ts` extracts Markdown with the upstream regex parser instead of a tree-sitter grammar; the `markdown` entry in its grammar registry supplies only the display label, and no Markdown WASM is shipped.
+- `parsers/manager.ts` extracts anonymous default exports (`export default function`/`class`), function expressions, top-level variable declarators, and nested `describe`/`test`/`it` calls, so entry-point, config, data, and test files outline instead of falling back to a preview.
+- `parsers/manager.ts` adds PHP support: `parsers/php.ts` outlines classes, interfaces, traits, enums, methods, properties, constants, top-level functions, and assigned closures.
+- `parsers/manager.ts` adds Blade support: `parsers/blade.ts` outlines `@section`/`@push`/`@once`/`@php` blocks, named directives such as `@extends` and `@include`, and `<x-…>`/`<livewire:…>` components.
+
+The `wasm/` grammars come from the MIT-licensed `tree-sitter-javascript`, `tree-sitter-typescript`, `tree-sitter-python`, `tree-sitter-go`, `tree-sitter-rust`, `tree-sitter-solidity`, and `tree-sitter-java` packages, plus pi-codebase-reader's vendored Sass and SCSS grammars, the VS Code WebAssembly build of `tree-sitter-php`, and `tree-sitter-blade` built from v0.12.3; see `wasm/LICENSES.md` for the per-grammar copyright notices. Comments in these files are upstream prose and are exempt from this repository's no-comments rule.
+
+## Rebuilding the Blade grammar
+
+`tree-sitter-blade.wasm` is built from tag `v0.12.3` of [tree-sitter-blade](https://github.com/EmranMR/tree-sitter-blade) with `tree-sitter-cli` 0.25.6. Run `npx -y tree-sitter-cli@0.25.6 build --wasm` in the grammar checkout with `emcc` on `PATH`, or dispatch the `build-blade-wasm` workflow and copy its artifact into `wasm/`.

package/src/outline/vendor/parsers/blade.ts

@@ -0,0 +1,138 @@
+import type { Node } from "web-tree-sitter";
+import type { SymbolInfo } from "../types.js";
+
+const BLOCK_LABELS: Record<string, string> = {
+  section: "section",
+  stack: "stack",
+  once: "once",
+  php_statement: "php",
+};
+
+const SKIPPED_TYPES = new Set([
+  "attribute",
+  "quoted_attribute_value",
+  "attribute_value",
+  "start_tag",
+  "end_tag",
+  "self_closing_tag",
+  "erroneous_end_tag",
+  "parameter",
+]);
+
+function textOf(node: Node, source: string): string {
+  return source.slice(node.startIndex, node.endIndex);
+}
+
+function rangeOf(node: Node): [number, number] {
+  return [node.startPosition.row + 1, node.endPosition.row + 1];
+}
+
+function findChild(node: Node, type: string): Node | undefined {
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child !== null && child.type === type) return child;
+  }
+  return undefined;
+}
+
+function unquote(text: string): string | undefined {
+  const trimmed = text.trim();
+  const quoted =
+    trimmed.length >= 2 &&
+    ((trimmed.startsWith("'") && trimmed.endsWith("'")) || (trimmed.startsWith('"') && trimmed.endsWith('"')));
+  return quoted ? trimmed.slice(1, -1) : undefined;
+}
+
+function parameterName(node: Node, source: string): string {
+  const parameter = findChild(node, "parameter");
+  if (parameter === undefined) return "";
+  const raw = textOf(parameter, source);
+  return unquote(raw) ?? raw.trim();
+}
+
+function bodyStart(node: Node): number {
+  const children = node.namedChildren;
+  let index = 0;
+  const first = children[index];
+  if (first !== null && first !== undefined && (first.type === "directive" || first.type === "directive_start")) {
+    index += 1;
+  }
+  while (index < children.length && children[index]?.type === "parameter") index += 1;
+  return index;
+}
+
+function blockSymbol(node: Node, source: string): SymbolInfo | null {
+  const label = BLOCK_LABELS[node.type];
+  if (label === undefined) return null;
+  const [startLine, endLine] = rangeOf(node);
+  return { name: parameterName(node, source), type: label, startLine, endLine };
+}
+
+function directiveSymbol(node: Node, parameter: Node | null, source: string): SymbolInfo | null {
+  if (parameter === null || parameter.type !== "parameter") return null;
+  const label = textOf(node, source).replace(/^@/, "");
+  if (label.length === 0) return null;
+  const [startLine, endLine] = rangeOf(node);
+  const raw = textOf(parameter, source);
+  const quoted = unquote(raw);
+  return quoted === undefined
+    ? { name: "", type: label, startLine, endLine, detail: raw.trim() }
+    : { name: quoted, type: label, startLine, endLine };
+}
+
+function componentSymbol(node: Node, source: string): SymbolInfo | null {
+  const tag = findChild(node, "start_tag") ?? findChild(node, "self_closing_tag");
+  if (tag === undefined) return null;
+  const tagName = findChild(tag, "tag_name");
+  if (tagName === undefined) return null;
+  const name = textOf(tagName, source);
+  const [startLine, endLine] = rangeOf(node);
+  if (name.startsWith("x-")) return { name, type: "component", startLine, endLine };
+  if (name.startsWith("livewire:")) {
+    return { name: name.slice("livewire:".length), type: "livewire", startLine, endLine };
+  }
+  return null;
+}
+
+function collect(node: Node, source: string, depth: number, maxDepth: number, sink: SymbolInfo[], start = 0): void {
+  if (SKIPPED_TYPES.has(node.type)) return;
+  const children = node.namedChildren;
+  for (let i = start; i < children.length; i++) {
+    const child = children[i];
+    if (child === null || child === undefined) continue;
+    const block = blockSymbol(child, source);
+    if (block !== null) {
+      sink.push(block);
+      if (depth < maxDepth) {
+        const nested: SymbolInfo[] = [];
+        collect(child, source, depth + 1, maxDepth, nested, bodyStart(child));
+        if (nested.length > 0) block.children = nested;
+      }
+      continue;
+    }
+    if (child.type === "directive") {
+      const symbol = directiveSymbol(child, children[i + 1] ?? null, source);
+      if (symbol !== null) sink.push(symbol);
+      continue;
+    }
+    if (child.type === "element") {
+      const symbol = componentSymbol(child, source);
+      if (symbol !== null) {
+        sink.push(symbol);
+        if (depth < maxDepth) {
+          const nested: SymbolInfo[] = [];
+          collect(child, source, depth + 1, maxDepth, nested);
+          if (nested.length > 0) symbol.children = nested;
+        }
+        continue;
+      }
+    }
+    collect(child, source, depth, maxDepth, sink);
+  }
+}
+
+export function extractBlade(node: Node, source: string, depth: number): SymbolInfo[] {
+  const results: SymbolInfo[] = [];
+  collect(node, source, depth, depth + 10, results);
+  return results;
+}

package/src/outline/vendor/parsers/index.ts

@@ -0,0 +1,75 @@
+/**
+ * Parser dispatcher.
+ *
+ * Maps file extensions to the appropriate parser, maintaining a shared
+ * tree-sitter parser manager for WASM-based grammars.
+ */
+
+import type { SymbolInfo } from "../types.js";
+import {
+  detectLanguage,
+  languageLabel,
+  parseCode,
+  parseFileImports,
+  type ImportInfo,
+} from "./manager.js";
+
+export { detectLanguage, languageLabel, parseFileImports };
+export type { ImportInfo };
+
+export interface ParseFileResult {
+  symbols: SymbolInfo[];
+  language: string | null;
+  languageName: string;
+}
+
+/**
+ * Parse a source file's content and extract structural symbols.
+ * Returns empty symbols array if language is unsupported or parsing fails.
+ */
+export async function parseSourceFile(
+  filePath: string,
+  content: string,
+): Promise<ParseFileResult> {
+  const lang = detectLanguage(filePath);
+
+  if (!lang) {
+    return { symbols: [], language: null, languageName: "Unknown" };
+  }
+
+  try {
+    const symbols = await parseCode(lang, content);
+    return { symbols, language: lang, languageName: languageLabel(lang) };
+  } catch (err) {
+    console.warn(
+      `[codebase-reader] Parse failed for ${filePath}:`,
+      err instanceof Error ? err.message : String(err),
+    );
+    return { symbols: [], language: lang, languageName: languageLabel(lang) };
+  }
+}
+
+/**
+ * Extract import statements from a source file.
+ * Returns empty array if language is unsupported or parsing fails.
+ */
+export async function extractFileImports(
+  filePath: string,
+  content: string,
+): Promise<ImportInfo[]> {
+  const lang = detectLanguage(filePath);
+
+  if (!lang) {
+    return [];
+  }
+
+  try {
+    return await parseFileImports(lang, content);
+  } catch (err) {
+    console.warn(
+      `[codebase-reader] Import parse failed for ${filePath}:`,
+      err instanceof Error ? err.message : String(err),
+    );
+    return [];
+  }
+}