@bendyline/squisq 2.0.1 → 2.2.0

package/src/doc/treeview/detect.ts

@@ -1,145 +0,0 @@
-/**
- * ASCII tree detection: is this fence content a file-tree / outline?
- *
- * The mirror image of the diagram detector. A diagram has ≥2 closed boxes;
- * a tree has ZERO closed boxes plus connector-branch structure. The two
- * partition the `├──` glyph space cleanly, so a fence is at most one of
- * them. Auto-detection is deliberately conservative (requires connector
- * branches — the unambiguous AI file-tree signal); the parser still handles
- * pure-indentation renditions for explicitly `{[tree]}`-annotated fences.
- */
-
-import type { MarkdownCodeBlock } from '../../markdown/types.js';
-import { parseAsciiDiagramWithStats } from '../asciiDiagram/parse.js';
-import { detectAsciiTimeline } from '../asciiTimeline/detect.js';
-import { parseTreeWithStats } from './parse.js';
-import type { TreeDetection } from './types.js';
-
-/** Fence languages eligible for tree detection (plus no language at all). */
-export const TREE_FENCE_LANGS: ReadonlySet<string> = new Set([
-  'text',
-  'txt',
-  'plaintext',
-  'plain',
-  'ascii',
-  'tree',
-]);
-
-const MAX_LINES = 400;
-const MIN_LINES = 2;
-const MIN_CONNECTOR_LINES = 2;
-const MIN_NODES = 2;
-
-/**
- * Box-drawing corners a file tree NEVER contains: top-left/right and
- * bottom-right in light, heavy, double, and rounded weights. Bottom-LEFT
- * corners (└ ┗ ╰ ╚ ╘) are excluded — the tree codec uses them as elbows.
- */
-const BOX_CORNER_RE = /[┌┐┘┏┓┛╔╗╝╭╮╯]/u;
-
-export function isEligibleTreeFenceLang(lang: string | null | undefined): boolean {
-  if (lang === null || lang === undefined) return true;
-  const normalized = lang.trim().toLowerCase();
-  return normalized === '' || TREE_FENCE_LANGS.has(normalized);
-}
-
-/**
- * True when the fence LANGUAGE is the explicit `tree` tag — an author-set
- * "this is a tree" marker that survives markdown ↔ Tiptap round-trips (the
- * language class round-trips; fence meta does not). Detection of a tagged
- * fence is lenient (no connector requirement) so a flattened/degenerate
- * tree stays a tree.
- */
-export function isExplicitTreeLang(lang: string | null | undefined): boolean {
-  return typeof lang === 'string' && lang.trim().toLowerCase() === 'tree';
-}
-
-export interface DetectTreeOptions {
-  /** The fence is explicitly `tree`-tagged: skip the connector requirement. */
-  explicit?: boolean;
-}
-
-export function detectTree(text: string, opts: DetectTreeOptions = {}): TreeDetection {
-  const explicit = opts.explicit === true;
-  const lines = text.replace(/\r\n?/g, '\n').split('\n');
-  const nonBlank = lines.filter((l) => l.trim().length > 0);
-  // A `tree`-tagged fence can be a single-node tree (e.g. the outline edited
-  // down to one item); an untagged fence needs ≥2 lines to auto-detect.
-  const minLines = explicit ? 1 : MIN_LINES;
-  if (nonBlank.length < minLines) {
-    return { isTree: false, reasons: [`too-few-lines(${nonBlank.length})`] };
-  }
-  if (lines.length > MAX_LINES) {
-    return { isTree: false, reasons: [`too-many-lines(${lines.length})`] };
-  }
-
-  // Markdown/GFM table shape → not a tree (even when explicitly tagged; it
-  // wouldn't parse into a sensible hierarchy anyway).
-  const pipeRows = nonBlank.filter((l) => /^\s*\|.*\|\s*$/.test(l)).length;
-  const hasGfmSeparator = nonBlank.some((l) => /^\s*\|?[\s:|-]+\|?\s*$/.test(l) && l.includes('-'));
-  if (pipeRows > nonBlank.length / 2 && hasGfmSeparator) {
-    return { isTree: false, reasons: ['markdown-table'] };
-  }
-
-  // Box-drawing CORNERS are an unambiguous box-diagram signal. A file tree /
-  // outline is built only from tees (├), elbows (└ ┗ ╰), rails (│), and dashes
-  // (─) — it never contains a TOP corner (┌ ┐) or a BOTTOM-RIGHT corner (┘).
-  // A fence with those is a diagram, even a MALFORMED one whose borders are
-  // misaligned so the tracer finds <2 closed boxes (e.g. hand-drawn art
-  // knocked out of alignment by a later rename that widened the labels).
-  // Without this, such art falls through to a mangled treeview. (Bottom-LEFT
-  // corners └ ┗ ╰ ╚ ╘ are deliberately excluded — they double as tree elbows.)
-  if (BOX_CORNER_RE.test(text)) {
-    return { isTree: false, reasons: ['has-box-corners'] };
-  }
-
-  // Timeline callout elbows can resemble tree branches. Give a qualifying
-  // marker+axis timeline ownership before the loose tree parser sees it.
-  if (!explicit && detectAsciiTimeline(text).isTimeline) {
-    return { isTree: false, reasons: ['is-timeline'] };
-  }
-
-  // Mutual exclusion with the diagram codec: a fence with ≥2 closed boxes is
-  // a diagram, not a tree.
-  const boxes = parseAsciiDiagramWithStats(text).diagram.nodes.length;
-  if (boxes >= 2) {
-    return { isTree: false, reasons: [`has-boxes(${boxes})`] };
-  }
-
-  const { tree, stats } = parseTreeWithStats(text);
-  const nodeCount = countNodes(tree.roots);
-  const minNodes = explicit ? 1 : MIN_NODES;
-  if (nodeCount < minNodes) {
-    return { isTree: false, reasons: [`too-few-nodes(${nodeCount})`] };
-  }
-  if (!explicit) {
-    // Auto-detection of an UNTAGGED fence requires the connector signal
-    // (pure-indentation art could be prose or a list). A `tree`-tagged fence
-    // trusts the author and skips this.
-    if (stats.connectorLines < MIN_CONNECTOR_LINES) {
-      return { isTree: false, reasons: [`too-few-connectors(${stats.connectorLines})`] };
-    }
-    if (stats.looseLines > stats.contentLines * 0.25) {
-      return { isTree: false, reasons: [`loose-ratio(${stats.looseLines}/${stats.contentLines})`] };
-    }
-  }
-
-  return {
-    isTree: true,
-    tree,
-    reasons: [`nodes(${nodeCount})`, explicit ? 'explicit' : `connectors(${stats.connectorLines})`],
-  };
-}
-
-/** Convenience gate for pipeline callers: lang allowlist + content detection. */
-export function isTreeFence(node: MarkdownCodeBlock): boolean {
-  if (node.type !== 'code') return false;
-  if (!isEligibleTreeFenceLang(node.lang)) return false;
-  return detectTree(node.value, { explicit: isExplicitTreeLang(node.lang) }).isTree;
-}
-
-function countNodes(nodes: readonly import('./types.js').TreeNode[]): number {
-  let n = 0;
-  for (const node of nodes) n += 1 + countNodes(node.children);
-  return n;
-}

package/src/doc/treeview/index.ts

@@ -1,30 +0,0 @@
-/**
- * ASCII treeview codec: detect / parse / render file-tree & outline art,
- * plus mapping helpers between the tree model and the template/layer data.
- *
- * The fence text is the source of truth end-to-end: the editor parses it
- * live for an interactive outline and re-renders it after each edit; the
- * doc pipeline derives `templateData.items` from it so the player renders
- * the same tree. Peer to the ASCII diagram codec.
- */
-
-export { parseTree, parseTreeWithStats } from './parse.js';
-export type { TreeLineStats } from './parse.js';
-export { renderTree } from './render.js';
-export type { RenderTreeOptions } from './render.js';
-export {
-  detectTree,
-  isTreeFence,
-  isEligibleTreeFenceLang,
-  isExplicitTreeLang,
-  TREE_FENCE_LANGS,
-} from './detect.js';
-export type { DetectTreeOptions } from './detect.js';
-export {
-  treeToTemplateData,
-  treeFromTemplateData,
-  treeFromMarkdownList,
-  findFirstList,
-} from './mapping.js';
-export type { TreeItem } from './mapping.js';
-export type { Tree, TreeNode, TreeDetection } from './types.js';

package/src/doc/treeview/mapping.ts

@@ -1,95 +0,0 @@
-/**
- * Mapping between the tree model and the template/layer data model, plus a
- * nested-markdown-list → tree walker (none exists in core — `extractListItems`
- * flattens, losing depth).
- */
-
-import type { MarkdownBlockNode, MarkdownList, MarkdownListItem } from '../../markdown/types.js';
-import { extractPlainText } from '../../markdown/utils.js';
-import type { Tree, TreeNode } from './types.js';
-
-/** JSON-serializable tree item carried on `templateData.items` / a `TreeLayer`. */
-export interface TreeItem {
-  id: string;
-  label: string;
-  isDir?: boolean;
-  comment?: string;
-  children: TreeItem[];
-}
-
-/** Tree model → template/layer items (structure-preserving). */
-export function treeToTemplateData(tree: Tree): { items: TreeItem[] } {
-  return { items: tree.roots.map(toItem) };
-}
-
-function toItem(node: TreeNode): TreeItem {
-  return {
-    id: node.id,
-    label: node.label,
-    ...(node.isDir ? { isDir: true } : {}),
-    ...(node.comment ? { comment: node.comment } : {}),
-    children: node.children.map(toItem),
-  };
-}
-
-/** Template/layer items → tree model (editor write-back / render). */
-export function treeFromTemplateData(
-  items: readonly TreeItem[],
-  options: { style?: 'unicode' | 'ascii' } = {},
-): Tree {
-  const roots = items.map(fromItem);
-  return { roots, style: options.style ?? 'unicode', warnings: [] };
-}
-
-function fromItem(item: TreeItem): TreeNode {
-  const children = Array.isArray(item.children) ? item.children.map(fromItem) : [];
-  return {
-    id: typeof item.id === 'string' && item.id ? item.id : 'node',
-    label: typeof item.label === 'string' ? item.label : '',
-    children,
-    isDir: item.isDir === true || children.length > 0,
-    ...(item.comment ? { comment: item.comment } : {}),
-  };
-}
-
-/**
- * Recursively convert a nested markdown bullet list into a tree. Used by
- * `deriveTemplateInputs` when an author explicitly `{[tree]}`-annotates a
- * block whose body is a nested list rather than a fence.
- */
-export function treeFromMarkdownList(list: MarkdownList): Tree {
-  const usedIds = new Map<string, number>();
-  const slugify = (s: string): string =>
-    s
-      .toLowerCase()
-      .replace(/[^a-z0-9]+/g, '-')
-      .replace(/^-+|-+$/g, '') || 'node';
-  const idFor = (label: string): string => {
-    const base = slugify(label.replace(/\/$/, ''));
-    const count = usedIds.get(base) ?? 0;
-    usedIds.set(base, count + 1);
-    return count === 0 ? base : `${base}-${count + 1}`;
-  };
-
-  const itemToNode = (item: MarkdownListItem): TreeNode => {
-    // The item's own label = its first non-list block's plain text.
-    const labelNode = item.children.find((c) => c.type !== 'list');
-    const label = labelNode ? extractPlainText(labelNode).trim() : '';
-    const childLists = item.children.filter((c): c is MarkdownList => c.type === 'list');
-    const children: TreeNode[] = [];
-    for (const cl of childLists) for (const ci of cl.children) children.push(itemToNode(ci));
-    return {
-      id: idFor(label),
-      label,
-      children,
-      isDir: label.endsWith('/') || children.length > 0,
-    };
-  };
-
-  return { roots: list.children.map(itemToNode), style: 'unicode', warnings: [] };
-}
-
-/** Find the first top-level markdown list in a block's body, if any. */
-export function findFirstList(contents: MarkdownBlockNode[] | undefined): MarkdownList | undefined {
-  return contents?.find((n): n is MarkdownList => n.type === 'list');
-}

package/src/doc/treeview/parse.ts

@@ -1,201 +0,0 @@
-/**
- * ASCII tree parser: file-tree / outline art → nested nodes.
- *
- * Pure, deterministic, never throws. Handles the many renditions AI emits:
- * Unicode connectors (`├── `/`└── `/`│   `), ASCII (`|-- `/`` `-- ``/`+-- `),
- * bullet-indented (`- `/`* `), and pure indentation. Depth is recovered by
- * finding where each line's LABEL begins (after any connector/indent
- * prefix) and running the standard outline indent-stack — this unifies all
- * renditions and tolerates ragged dedents.
- */
-
-import {
-  isBranchElbow,
-  isBranchTee,
-  isDashChar,
-  isRailChar,
-  isAsciiTreeChar,
-  isUnicodeTreeChar,
-} from './chars.js';
-import type { Tree, TreeNode } from './types.js';
-
-/** Internal per-line analysis fed to the reconstruction stack. */
-export interface TreeLineStats {
-  /** Non-blank content lines. */
-  contentLines: number;
-  /** Lines carrying a connector branch (`├──`/`└──`/`|--`/`` `--``/`+--`). */
-  connectorLines: number;
-  /** Lines that could not be analyzed as a node (loose text). */
-  looseLines: number;
-  /** Distinct label-start columns observed (a hierarchy has ≥2). */
-  indentLevels: number;
-}
-
-interface AnalyzedLine {
-  indent: number; // column where the label begins
-  label: string;
-  comment?: string;
-  hadConnector: boolean;
-}
-
-export function parseTree(text: string): Tree {
-  return parseTreeWithStats(text).tree;
-}
-
-export function parseTreeWithStats(text: string): { tree: Tree; stats: TreeLineStats } {
-  const warnings: string[] = [];
-  const rawLines = text.replace(/\r\n?/g, '\n').split('\n');
-
-  const style = detectStyle(rawLines);
-  const stats: TreeLineStats = {
-    contentLines: 0,
-    connectorLines: 0,
-    looseLines: 0,
-    indentLevels: 0,
-  };
-  const indentSet = new Set<number>();
-
-  const analyzed: AnalyzedLine[] = [];
-  for (const raw of rawLines) {
-    if (raw.trim().length === 0) continue;
-    stats.contentLines++;
-    const a = analyzeLine(raw);
-    if (!a || a.label.length === 0) {
-      stats.looseLines++;
-      continue;
-    }
-    if (a.hadConnector) stats.connectorLines++;
-    indentSet.add(a.indent);
-    analyzed.push(a);
-  }
-  stats.indentLevels = indentSet.size;
-
-  // ---- Reconstruct the hierarchy via an indent stack --------------------
-  const roots: TreeNode[] = [];
-  const stack: Array<{ indent: number; node: TreeNode }> = [];
-  for (const a of analyzed) {
-    const node: TreeNode = {
-      id: '',
-      label: a.label,
-      children: [],
-      ...(a.comment ? { comment: a.comment } : {}),
-    };
-    // Pop ancestors that are at the same or deeper indent.
-    while (stack.length > 0 && stack[stack.length - 1].indent >= a.indent) stack.pop();
-    if (stack.length === 0) {
-      roots.push(node);
-    } else {
-      stack[stack.length - 1].node.children.push(node);
-    }
-    stack.push({ indent: a.indent, node });
-  }
-
-  // ---- Post-pass: isDir + stable ids ------------------------------------
-  const usedIds = new Map<string, number>();
-  const finalize = (node: TreeNode): void => {
-    node.isDir = node.label.endsWith('/') || node.children.length > 0;
-    const base = slugify(stripTrailingSlash(node.label));
-    const count = usedIds.get(base) ?? 0;
-    usedIds.set(base, count + 1);
-    node.id = count === 0 ? base : `${base}-${count + 1}`;
-    for (const child of node.children) finalize(child);
-  };
-  for (const root of roots) finalize(root);
-
-  if (analyzed.length > 0 && stats.looseLines > 0) {
-    warnings.push(`loose-lines(${stats.looseLines})`);
-  }
-
-  return { tree: { roots, style, warnings }, stats };
-}
-
-// ---------------------------------------------------------------------------
-// Line analysis
-// ---------------------------------------------------------------------------
-
-/**
- * Strip a line's connector / indent prefix and return the column where the
- * label begins plus the cleaned label + trailing comment. Returns null for
- * a rails-only spacer line.
- */
-function analyzeLine(line: string): AnalyzedLine | null {
-  const chars = Array.from(line);
-  let i = 0;
-  let hadConnector = false;
-
-  // Consume leading whitespace + vertical rails. A rail is a rail glyph NOT
-  // immediately followed by a dash (which would make it an ASCII branch).
-  for (;;) {
-    while (i < chars.length && (chars[i] === ' ' || chars[i] === '\t')) i++;
-    const ch = chars[i];
-    if (ch === undefined) return null; // blank / rails-only
-    if (isRailChar(ch) && !isDashChar(chars[i + 1] ?? '')) {
-      i++;
-      continue;
-    }
-    break;
-  }
-
-  // Optional branch: a Unicode tee/elbow + dashes, or ASCII `|`/`` ` ``/`+`
-  // + dashes. The label follows (after any trailing spaces).
-  const ch = chars[i];
-  if (ch !== undefined) {
-    if (isBranchTee(ch) || isBranchElbow(ch)) {
-      i++;
-      while (i < chars.length && (isDashChar(chars[i]) || isRailChar(chars[i]))) i++;
-      hadConnector = true;
-    } else if ((ch === '|' || ch === '`' || ch === '+') && isDashChar(chars[i + 1] ?? '')) {
-      i++;
-      while (i < chars.length && isDashChar(chars[i])) i++;
-      hadConnector = true;
-    } else if ((ch === '-' || ch === '*' || ch === '+') && (chars[i + 1] ?? '') === ' ') {
-      // Markdown-style bullet (indent-based rendition).
-      i++;
-      hadConnector = false;
-    }
-  }
-  while (i < chars.length && (chars[i] === ' ' || chars[i] === '\t')) i++;
-
-  const indent = i;
-  let label = chars.slice(i).join('').replace(/\s+$/u, '');
-  if (label.length === 0) return null;
-
-  // Trailing comment: ` # …`, ` <-- …`, or ` // …` (needs a leading space).
-  let comment: string | undefined;
-  const commentMatch = /\s+(?:#|<--|\/\/)\s?(.*)$/.exec(label);
-  if (commentMatch) {
-    comment = commentMatch[1].trim() || undefined;
-    label = label.slice(0, commentMatch.index).replace(/\s+$/u, '');
-  }
-  if (label.length === 0) return null;
-
-  return { indent, label, hadConnector, ...(comment ? { comment } : {}) };
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function detectStyle(lines: string[]): 'unicode' | 'ascii' {
-  let unicode = 0;
-  let ascii = 0;
-  for (const line of lines) {
-    for (const ch of line) {
-      if (isUnicodeTreeChar(ch)) unicode++;
-      else if (isAsciiTreeChar(ch)) ascii++;
-    }
-  }
-  return ascii > unicode ? 'ascii' : 'unicode';
-}
-
-function stripTrailingSlash(s: string): string {
-  return s.endsWith('/') ? s.slice(0, -1) : s;
-}
-
-function slugify(s: string): string {
-  const slug = s
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '');
-  return slug || 'node';
-}

package/src/doc/treeview/render.ts

@@ -1,41 +0,0 @@
-/**
- * ASCII tree renderer: nested nodes → clean tree art.
- *
- * A deterministic depth-first walk emitting rail/branch prefixes. The
- * fixpoint is structural: `parseTree(renderTree(t))` preserves the node
- * hierarchy + labels + comments, and `renderTree(parseTree(renderTree(t)))`
- * is byte-identical (idempotent after one normalization cycle). Unlike the
- * diagram renderer there is no spatial layout, so jitter is impossible.
- */
-
-import { ASCII_TREE_VOCAB, UNICODE_TREE_VOCAB } from './chars.js';
-import type { Tree, TreeNode } from './types.js';
-
-export interface RenderTreeOptions {
-  /** Character vocabulary; defaults to the tree's own detected style. */
-  style?: 'unicode' | 'ascii';
-}
-
-export function renderTree(tree: Tree, options: RenderTreeOptions = {}): string {
-  const vocab = (options.style ?? tree.style) === 'ascii' ? ASCII_TREE_VOCAB : UNICODE_TREE_VOCAB;
-  const lines: string[] = [];
-
-  const label = (node: TreeNode): string =>
-    node.comment ? `${node.label}  # ${node.comment}` : node.label;
-
-  const walk = (nodes: readonly TreeNode[], prefix: string): void => {
-    nodes.forEach((node, i) => {
-      const last = i === nodes.length - 1;
-      lines.push(prefix + (last ? vocab.elbow : vocab.tee) + label(node));
-      walk(node.children, prefix + (last ? vocab.gap : vocab.rail));
-    });
-  };
-
-  // Roots sit at column 0 with no connector; their children get branches.
-  for (const root of tree.roots) {
-    lines.push(label(root));
-    walk(root.children, '');
-  }
-
-  return lines.join('\n');
-}

package/src/doc/treeview/types.ts

@@ -1,43 +0,0 @@
-/**
- * Public types for the ASCII treeview codec.
- *
- * A tree is a hierarchy of labelled nodes (file trees, dependency trees,
- * category outlines). Unlike the diagram codec's spatial grid model, the
- * tree model is a plain nested structure — rendering is a deterministic
- * tree-walk, so the parse↔render fixpoint is structural and trivially
- * byte-stable.
- */
-
-export interface TreeNode {
-  /**
-   * Stable id: slug of the label, deduplicated with `-2`/`-3` suffixes in
-   * document (depth-first) order. Identical art re-parses to identical ids
-   * (the outline widget's selection resolves by id).
-   */
-  id: string;
-  /** Display label, verbatim (may keep a trailing `/`). */
-  label: string;
-  /** Child nodes (empty for leaves). */
-  children: TreeNode[];
-  /** True when this node reads as a container (trailing `/` or has children). */
-  isDir?: boolean;
-  /** Trailing `# …` / `<-- …` comment, preserved across round-trips. */
-  comment?: string;
-}
-
-export interface Tree {
-  /** Top-level nodes (a forest — usually one root for a file tree). */
-  roots: TreeNode[];
-  /** Character vocabulary detected in the source; render emits the same. */
-  style: 'unicode' | 'ascii';
-  /** Non-fatal parse notes (ragged dedents, dropped lines, …). */
-  warnings: string[];
-}
-
-export interface TreeDetection {
-  isTree: boolean;
-  /** Present when `isTree` — avoids a second parse in callers. */
-  tree?: Tree;
-  /** Machine-greppable accept/reject reasons. */
-  reasons: string[];
-}