@flyingrobots/graft 0.7.0 → 0.8.0

package/src/parser/markdown.ts

@@ -1,197 +0,0 @@
-// ---------------------------------------------------------------------------
-// Markdown outline extraction — heading-based structural summary
-// ---------------------------------------------------------------------------
-
-import { OutlineEntry, JumpEntry } from "./types.js";
-import type { OutlineResult } from "./types.js";
-
-interface MarkdownHeading {
-  level: number;
-  name: string;
-  start: number;
-  end: number;
-}
-
-interface MarkdownHeadingNode extends MarkdownHeading {
-  children: MarkdownHeadingNode[];
-}
-
-// ---------------------------------------------------------------------------
-// Fence detection
-// ---------------------------------------------------------------------------
-
-function isFenceLine(line: string): { marker: "`" | "~"; length: number } | null {
-  const match = /^\s*([`~])\1{2,}.*$/.exec(line);
-  if (match === null) return null;
-
-  const marker = match[1];
-  if (marker !== "`" && marker !== "~") return null;
-  const markerRun = /^([`~]+)/.exec(match[0].trimStart());
-  if (markerRun === null) return null;
-  const run = markerRun[1];
-  if (run === undefined) return null;
-  return { marker, length: run.length };
-}
-
-function isFenceClose(line: string, marker: "`" | "~", length: number): boolean {
-  const pattern = marker === "`"
-    ? new RegExp(`^\\s*\`{${String(length)},}\\s*$`)
-    : new RegExp(`^\\s*~{${String(length)},}\\s*$`);
-  return pattern.test(line);
-}
-
-// ---------------------------------------------------------------------------
-// Heading parsing
-// ---------------------------------------------------------------------------
-
-function parseAtxHeading(line: string, lineNumber: number): MarkdownHeading | null {
-  const match = /^\s{0,3}(#{1,6})[ \t]+(.+?)\s*#*\s*$/.exec(line);
-  if (match === null) return null;
-
-  const hashes = match[1];
-  const rawName = match[2]?.trim() ?? "";
-  if (hashes === undefined || rawName.length === 0) return null;
-
-  return {
-    level: hashes.length,
-    name: rawName,
-    start: lineNumber,
-    end: lineNumber,
-  };
-}
-
-function parseSetextHeading(
-  currentLine: string,
-  nextLine: string | undefined,
-  lineNumber: number,
-): MarkdownHeading | null {
-  if (nextLine === undefined) return null;
-  if (currentLine.trim().length === 0) return null;
-  if (parseAtxHeading(currentLine, lineNumber) !== null) return null;
-
-  if (/^\s{0,3}=+\s*$/.test(nextLine)) {
-    return { level: 1, name: currentLine.trim(), start: lineNumber, end: lineNumber + 1 };
-  }
-  if (/^\s{0,3}-+\s*$/.test(nextLine)) {
-    return { level: 2, name: currentLine.trim(), start: lineNumber, end: lineNumber + 1 };
-  }
-
-  return null;
-}
-
-// ---------------------------------------------------------------------------
-// Hierarchy and range finalization
-// ---------------------------------------------------------------------------
-
-function finalizeMarkdownRanges(headings: MarkdownHeading[], totalLines: number): void {
-  for (let i = 0; i < headings.length; i++) {
-    const current = headings[i];
-    if (current === undefined) continue;
-    let end = totalLines;
-    for (let j = i + 1; j < headings.length; j++) {
-      const next = headings[j];
-      if (next === undefined) continue;
-      if (next.level <= current.level) {
-        end = next.start - 1;
-        break;
-      }
-    }
-    current.end = end;
-  }
-}
-
-function buildMarkdownHierarchy(headings: readonly MarkdownHeading[]): MarkdownHeadingNode[] {
-  const roots: MarkdownHeadingNode[] = [];
-  const stack: MarkdownHeadingNode[] = [];
-
-  for (const heading of headings) {
-    const node: MarkdownHeadingNode = { ...heading, children: [] };
-    while (stack.length > 0) {
-      const last = stack[stack.length - 1];
-      if (last === undefined || last.level < node.level) break;
-      stack.pop();
-    }
-    const parent = stack[stack.length - 1];
-    if (parent === undefined) roots.push(node);
-    else parent.children.push(node);
-    stack.push(node);
-  }
-
-  return roots;
-}
-
-// ---------------------------------------------------------------------------
-// Conversion
-// ---------------------------------------------------------------------------
-
-function toOutlineEntry(node: MarkdownHeadingNode): OutlineEntry {
-  return new OutlineEntry({
-    kind: "heading",
-    name: node.name,
-    exported: false,
-    ...(node.children.length > 0
-      ? { children: node.children.map((child) => toOutlineEntry(child)) }
-      : {}),
-  });
-}
-
-function buildMarkdownJumpEntry(heading: MarkdownHeading): JumpEntry {
-  return new JumpEntry({
-    symbol: heading.name,
-    kind: "heading",
-    start: heading.start,
-    end: heading.end,
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-export function extractMarkdownOutline(source: string): OutlineResult {
-  const lines = source.split("\n");
-  const headings: MarkdownHeading[] = [];
-  let inFence = false;
-  let activeFence: { marker: "`" | "~"; length: number } | null = null;
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (line === undefined) continue;
-    const lineNumber = i + 1;
-    const fence = isFenceLine(line);
-
-    if (inFence) {
-      if (activeFence !== null && isFenceClose(line, activeFence.marker, activeFence.length)) {
-        inFence = false;
-        activeFence = null;
-      }
-      continue;
-    }
-
-    if (fence !== null) {
-      inFence = true;
-      activeFence = fence;
-      continue;
-    }
-
-    const atx = parseAtxHeading(line, lineNumber);
-    if (atx !== null) {
-      headings.push(atx);
-      continue;
-    }
-
-    const setext = parseSetextHeading(line, lines[i + 1], lineNumber);
-    if (setext !== null) {
-      headings.push(setext);
-      i++;
-    }
-  }
-
-  finalizeMarkdownRanges(headings, lines.length);
-  const hierarchy = buildMarkdownHierarchy(headings);
-
-  return {
-    entries: hierarchy.map((node) => toOutlineEntry(node)),
-    jumpTable: headings.map((heading) => buildMarkdownJumpEntry(heading)),
-  };
-}

package/src/parser/outline.ts

@@ -1,316 +0,0 @@
-import { detectStructuredFormat } from "./lang.js";
-import type { SupportedStructuredFormat } from "./lang.js";
-import { OutlineEntry, JumpEntry } from "./types.js";
-import type { OutlineResult } from "./types.js";
-import { parseStructuredTree } from "./runtime.js";
-import { extractMarkdownOutline } from "./markdown.js";
-
-const MAX_SIGNATURE_LENGTH = 199;
-
-// ---------------------------------------------------------------------------
-// Signature helpers
-// ---------------------------------------------------------------------------
-
-/** Compact object-literal default values: `= { ... }` becomes `= {…}`. */
-function compactObjectDefaults(sig: string): string {
-  return sig.replace(/=\s*\{[^}]*\}/g, "= {…}");
-}
-
-/** Truncate a signature to fit within MAX_SIGNATURE_LENGTH. */
-function boundSignature(raw: string): string {
-  let sig = compactObjectDefaults(raw);
-  if (sig.length >= MAX_SIGNATURE_LENGTH) {
-    sig = sig.slice(0, MAX_SIGNATURE_LENGTH - 1) + "…";
-  }
-  return sig;
-}
-
-// ---------------------------------------------------------------------------
-// Tree-sitter node interface (avoids importing the Node class directly)
-// ---------------------------------------------------------------------------
-
-type TSNode = import("web-tree-sitter").SyntaxNode;
-
-// ---------------------------------------------------------------------------
-// Node kind mapping
-// ---------------------------------------------------------------------------
-
-type EntryKind = OutlineEntry["kind"];
-
-function nodeKind(nodeType: string): EntryKind | undefined {
-  switch (nodeType) {
-    case "function_declaration":
-    case "generator_function_declaration":
-      return "function";
-    case "class_declaration":
-      return "class";
-    case "method_definition":
-      return "method";
-    case "interface_declaration":
-      return "interface";
-    case "type_alias_declaration":
-      return "type";
-    case "enum_declaration":
-      return "enum";
-    default:
-      return undefined;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Tree-sitter extraction helpers
-// ---------------------------------------------------------------------------
-
-function extractFunctionSignature(node: TSNode): string | undefined {
-  const nameNode = node.childForFieldName("name");
-  if (!nameNode) return undefined;
-
-  const params = node.childForFieldName("parameters");
-  const returnType = node.childForFieldName("return_type");
-
-  let sig = nameNode.text;
-  if (params) {
-    sig += params.text;
-  }
-  if (returnType) {
-    // return_type node text includes the leading `: ` in some grammars
-    const rt = returnType.text.replace(/^:\s*/, "");
-    sig += ": " + rt;
-  }
-
-  return boundSignature(sig);
-}
-
-function extractName(node: TSNode): string | undefined {
-  const nameNode = node.childForFieldName("name");
-  return nameNode?.text;
-}
-
-function extractClassChildren(node: TSNode): OutlineEntry[] {
-  const body = node.childForFieldName("body");
-  if (!body) return [];
-
-  const children: OutlineEntry[] = [];
-  for (const child of body.namedChildren) {
-    if (child.type === "method_definition") {
-      const name = extractName(child);
-      if (!name) continue;
-
-      const sig = extractFunctionSignature(child);
-      children.push(new OutlineEntry({
-        kind: "method",
-        name,
-        exported: false,
-        ...(sig !== undefined ? { signature: sig } : {}),
-      }));
-    }
-  }
-  return children;
-}
-
-function processDeclaration(
-  node: TSNode,
-  exported: boolean,
-): OutlineEntry | undefined {
-  const kind = nodeKind(node.type);
-  if (!kind) return undefined;
-
-  const name = extractName(node);
-  if (!name) return undefined;
-
-  const sig = kind === "function" ? extractFunctionSignature(node) : undefined;
-  const children = kind === "class" ? extractClassChildren(node) : undefined;
-
-  return new OutlineEntry({
-    kind,
-    name,
-    exported,
-    ...(sig !== undefined ? { signature: sig } : {}),
-    ...(children !== undefined && children.length > 0 ? { children } : {}),
-  });
-}
-
-function extractArrowSignature(name: string, arrowNode: TSNode): string | undefined {
-  const params = arrowNode.childForFieldName("parameters");
-  const returnType = arrowNode.childForFieldName("return_type");
-
-  let sig = name;
-  if (params) {
-    sig += params.text;
-  }
-  if (returnType) {
-    const rt = returnType.text.replace(/^:\s*/, "");
-    sig += ": " + rt;
-  }
-
-  return boundSignature(sig);
-}
-
-function processLexicalExport(node: TSNode): OutlineEntry[] {
-  const entries: OutlineEntry[] = [];
-  for (const child of node.namedChildren) {
-    if (child.type === "variable_declarator") {
-      const name = extractName(child);
-      if (!name) continue;
-
-      // Check if the value is an arrow function or function expression
-      const value = child.childForFieldName("value");
-      if (value && (value.type === "arrow_function" || value.type === "function")) {
-        const sig = extractArrowSignature(name, value);
-        entries.push(new OutlineEntry({
-          kind: "function",
-          name,
-          exported: true,
-          ...(sig !== undefined ? { signature: sig } : {}),
-        }));
-      } else {
-        entries.push(new OutlineEntry({ kind: "export", name, exported: true }));
-      }
-    }
-  }
-  return entries;
-}
-
-// ---------------------------------------------------------------------------
-// Jump table builder
-// ---------------------------------------------------------------------------
-
-function buildJumpEntry(
-  name: string,
-  kind: string,
-  node: TSNode,
-): JumpEntry {
-  return new JumpEntry({
-    symbol: name,
-    kind,
-    start: node.startPosition.row + 1,
-    end: node.endPosition.row + 1,
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Main extraction
-// ---------------------------------------------------------------------------
-
-/**
- * Extract a structural outline from source code.
- *
- * @param source - The source code text.
- * @param lang - Structured format identifier. Defaults to `"ts"`.
- * @returns An {@link OutlineResult} with entries, jump table, and partial flag.
- */
-export function extractOutline(
-  source: string,
-  lang: SupportedStructuredFormat = "ts",
-): OutlineResult {
-  if (lang === "md") {
-    return extractMarkdownOutline(source);
-  }
-  const parsed = parseStructuredTree(lang, source);
-  const root = parsed.root;
-
-  const entries: OutlineEntry[] = [];
-  const jumpTable: JumpEntry[] = [];
-  const hasError = root.hasError();
-
-  for (const child of root.children) {
-    if (child.type === "export_statement") {
-      // export_statement wraps a declaration
-      const inner = child.namedChildren.find(
-        (c) =>
-          c.type === "function_declaration" ||
-          c.type === "generator_function_declaration" ||
-          c.type === "class_declaration" ||
-          c.type === "interface_declaration" ||
-          c.type === "type_alias_declaration" ||
-          c.type === "enum_declaration",
-      );
-
-      if (inner) {
-        const entry = processDeclaration(inner, true);
-        if (entry) {
-          entries.push(entry);
-          jumpTable.push(buildJumpEntry(entry.name, entry.kind, child));
-        }
-        continue;
-      }
-
-      // Check for lexical declaration (const/let exports)
-      const lexical = child.namedChildren.find(
-        (c) => c.type === "lexical_declaration",
-      );
-      if (lexical) {
-        const lexEntries = processLexicalExport(lexical);
-        for (const entry of lexEntries) {
-          entries.push(entry);
-          jumpTable.push(buildJumpEntry(entry.name, entry.kind, child));
-        }
-        continue;
-      }
-
-      // Re-exports: export { A, B } from './x'
-      const exportClause = child.namedChildren.find(
-        (c) => c.type === "export_clause",
-      );
-      if (exportClause) {
-        for (const spec of exportClause.namedChildren) {
-          if (spec.type === "export_specifier") {
-            const nameNode = spec.childForFieldName("alias") ?? spec.childForFieldName("name");
-            if (nameNode) {
-              entries.push(new OutlineEntry({ kind: "export", name: nameNode.text, exported: true }));
-              jumpTable.push(buildJumpEntry(nameNode.text, "export", child));
-            }
-          }
-        }
-        continue;
-      }
-
-      // Wildcard re-export: export * from './x'
-      const moduleSpecifier = child.namedChildren.find((c) => c.type === "string");
-      const hasWildcard = child.children.some((c) => c.type === "*" || c.type === "namespace_export");
-      if (hasWildcard && moduleSpecifier) {
-        const name = `* from ${moduleSpecifier.text}`;
-        entries.push(new OutlineEntry({ kind: "export", name, exported: true }));
-        jumpTable.push(buildJumpEntry(name, "export", child));
-        continue;
-      }
-
-      // Other export forms — skip
-    } else {
-      // Non-exported top-level declaration
-      const kind = nodeKind(child.type);
-      if (kind) {
-        const entry = processDeclaration(child, false);
-        if (entry) {
-          entries.push(entry);
-          jumpTable.push(buildJumpEntry(entry.name, entry.kind, child));
-        }
-      }
-    }
-  }
-
-  parsed.delete();
-
-  const result: OutlineResult = {
-    entries,
-    jumpTable,
-  };
-
-  if (hasError) {
-    result.partial = true;
-  }
-
-  return result;
-}
-
-export function extractOutlineForFile(
-  filePath: string,
-  source: string,
-): OutlineResult | null {
-  const lang = detectStructuredFormat(filePath);
-  if (lang === null) {
-    return null;
-  }
-
-  return extractOutline(source, lang);
-}

package/src/parser/runtime.ts

@@ -1,71 +0,0 @@
-import Parser from "web-tree-sitter";
-import { createRequire } from "node:module";
-import { detectLang } from "./lang.js";
-import type { SupportedLang } from "./lang.js";
-
-const esmRequire = createRequire(import.meta.url);
-
-await Parser.init();
-
-const tsLang = await Parser.Language.load(
-  esmRequire.resolve("tree-sitter-wasms/out/tree-sitter-typescript.wasm"),
-);
-const tsxLang = await Parser.Language.load(
-  esmRequire.resolve("tree-sitter-wasms/out/tree-sitter-tsx.wasm"),
-);
-const jsLang = await Parser.Language.load(
-  esmRequire.resolve("tree-sitter-wasms/out/tree-sitter-javascript.wasm"),
-);
-
-function languageFor(format: SupportedLang): Parser.Language {
-  switch (format) {
-    case "ts":
-      return tsLang;
-    case "tsx":
-      return tsxLang;
-    case "js":
-      return jsLang;
-  }
-}
-
-export interface ParsedTree {
-  readonly format: SupportedLang;
-  readonly parser: Parser;
-  readonly tree: Parser.Tree;
-  readonly root: Parser.SyntaxNode;
-  readonly source: string;
-  delete(): void;
-}
-
-export function parseStructuredTree(
-  format: SupportedLang,
-  source: string,
-): ParsedTree {
-  const parser = new Parser();
-  parser.setLanguage(languageFor(format));
-  const tree = parser.parse(source);
-  const root = tree.rootNode;
-
-  return {
-    format,
-    parser,
-    tree,
-    root,
-    source,
-    delete() {
-      tree.delete();
-      parser.delete();
-    },
-  };
-}
-
-export function parseStructuredTreeForFile(
-  filePath: string,
-  source: string,
-): ParsedTree | null {
-  const format = detectLang(filePath);
-  if (format === null) {
-    return null;
-  }
-  return parseStructuredTree(format, source);
-}

package/src/parser/types.ts

@@ -1,75 +0,0 @@
-/** The kind of a top-level or member declaration. */
-export type EntryKind =
-  | "function"
-  | "class"
-  | "method"
-  | "interface"
-  | "type"
-  | "enum"
-  | "export"
-  | "heading";
-
-/** A single entry in a file outline. */
-export class OutlineEntry {
-  /** @internal Brand prevents structural forgery from plain objects. */
-  private readonly _brand = "OutlineEntry" as const;
-  readonly kind: EntryKind;
-  readonly name: string;
-  readonly signature?: string;
-  readonly exported: boolean;
-  readonly children?: readonly OutlineEntry[];
-
-  constructor(opts: {
-    kind: EntryKind;
-    name: string;
-    exported: boolean;
-    signature?: string;
-    children?: readonly OutlineEntry[];
-  }) {
-    if (opts.name.trim().length === 0) {
-      throw new Error("OutlineEntry: name must be non-empty");
-    }
-    this.kind = opts.kind;
-    this.name = opts.name.trim();
-    this.exported = opts.exported;
-    if (opts.signature !== undefined) this.signature = opts.signature;
-    if (opts.children !== undefined) this.children = Object.freeze([...opts.children]);
-    Object.freeze(this);
-  }
-}
-
-/** A jump-table entry mapping a symbol to its 1-based line range. */
-export class JumpEntry {
-  /** @internal Brand prevents structural forgery from plain objects. */
-  private readonly _brand = "JumpEntry" as const;
-  readonly symbol: string;
-  readonly kind: string;
-  readonly start: number; // 1-based line
-  readonly end: number; // 1-based line
-
-  constructor(opts: {
-    symbol: string;
-    kind: string;
-    start: number;
-    end: number;
-  }) {
-    if (!Number.isInteger(opts.start) || opts.start < 1) {
-      throw new Error("JumpEntry: start must be an integer >= 1");
-    }
-    if (!Number.isInteger(opts.end) || opts.end < opts.start) {
-      throw new Error("JumpEntry: end must be an integer >= start");
-    }
-    this.symbol = opts.symbol;
-    this.kind = opts.kind;
-    this.start = opts.start;
-    this.end = opts.end;
-    Object.freeze(this);
-  }
-}
-
-/** Result of outline extraction. */
-export interface OutlineResult {
-  entries: OutlineEntry[];
-  jumpTable?: JumpEntry[];
-  partial?: boolean;
-}