@silverbulletmd/silverbullet 2.8.0 → 2.9.0

package/README.md

@@ -5,18 +5,22 @@
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/silverbulletmd/silverbullet)
 
 # SilverBullet
-SilverBullet is a Programmable, Private, Browser-based, Open Source, Self Hosted, Personal Knowledge Management Platform.
+SilverBullet is a Programmable, Private, Browser-based, Open Source, Self Hosted, Personal Knowledge Database — a fancy term for a "notes app on steroids".
 
 _Yowza!_ That surely is a lot of adjectives to describe a browser-based Markdown editor programmable with Lua.
 
 Let’s get more specific.
 
+SilverBullet combines a clean live-preview editor with wiki-style linking, a built-in database and query language, and a fully integrated Space Lua scripting environment, turning your notes into a programmable system that grows with you.
+
 In SilverBullet you keep your content as a collection of Markdown Pages (called a Space). You navigate your space using the Page Picker like a traditional notes app, or through Links like a wiki (except they are bi-directional).
 
-If you are the **writer** type, you’ll appreciate SilverBullet as a clean Markdown editor with Live Preview. If you have more of an **outliner** personality, SilverBullet has Outlining tools for you. Productivity freak? Have a look at Tasks. More of a **database** person? You will appreciate Objects and Queries. 
+If you are the **writer** type, you’ll appreciate SilverBullet as a clean Markdown editor with Live Preview. If you have more of an **outliner** personality, SilverBullet has Outlining tools for you. Productivity freak? Have a look at Tasks. More of a **database** person? You will appreciate Objects and Queries (SLIQ). 
 
 And if you are comfortable **programming** a little bit — now we’re really talking. You will love _dynamically generating content_ with Space Lua (SilverBullet’s Lua dialect), or to use it to create custom Commands, Page Templates or Widgets.
 
+You were told there’s no such thing as a silver bullet. You were told wrong.
+
 [Much more detail can be found on silverbullet.md](https://silverbullet.md)
 
 ## Installing SilverBullet

package/client/plugos/syscalls/editor.ts

@@ -219,10 +219,12 @@ export function editorSyscalls(client: Client): SysCallMapping {
         );
       } else if (
         ref.details &&
-        !["position", "linecolumn", "header"].includes(ref.details.type)
+        !["position", "linecolumn", "header", "anchor"].includes(
+          ref.details.type,
+        )
       ) {
         throw new Error(
-          "ref.details.type has to be 'position', 'linecolumn' or 'header'",
+          "ref.details.type has to be 'position', 'linecolumn', 'header' or 'anchor'",
         );
       }
 
@@ -244,6 +246,11 @@ export function editorSyscalls(client: Client): SysCallMapping {
         throw new Error(
           "ref.details.line and ref.details.column has to be of type `number`",
         );
+      } else if (
+        ref.details?.type === "anchor" &&
+        typeof ref.details.name !== "string"
+      ) {
+        throw new Error("ref.details.name has to be of type `string`");
       }
 
       await client.navigate(ref, replaceState, newWindow);
@@ -464,20 +471,14 @@ export function editorSyscalls(client: Client): SysCallMapping {
       }
     },
     "editor.moveCursor": (_ctx, pos: number, center = false) => {
+      // Always scroll into view so callers don't strand the cursor
+      // off-screen; `nearest` (default) is a no-op when already visible.
       client.editorView.dispatch({
-        selection: {
-          anchor: pos,
-        },
+        selection: { anchor: pos },
+        effects: [
+          EditorView.scrollIntoView(pos, center ? { y: "center" } : {}),
+        ],
       });
-      if (center) {
-        client.editorView.dispatch({
-          effects: [
-            EditorView.scrollIntoView(pos, {
-              y: "center",
-            }),
-          ],
-        });
-      }
       client.editorView.focus();
     },
     "editor.moveCursorToLine": (
@@ -541,8 +542,12 @@ export function editorSyscalls(client: Client): SysCallMapping {
     ): Promise<string | undefined> => {
       return client.ui.prompt(message, defaultValue);
     },
-    "editor.confirm": (_ctx, message: string): Promise<boolean> => {
-      return client.ui.confirm(message);
+    "editor.confirm": (
+      _ctx,
+      message: string,
+      options?: { destructive?: boolean },
+    ): Promise<boolean> => {
+      return client.ui.confirm(message, options);
     },
     "editor.alert": (_ctx, message: string) => {
       alert(message);

package/client/plugos/syscalls/index.ts

@@ -17,15 +17,57 @@ export function indexSyscalls(
   client: Client,
 ): SysCallMapping {
   return {
+    // Query collection API
     "index.tag": (_ctx, tagName: string): LuaQueryCollection => {
-      return objectIndex.tag(tagName);
+      return objectIndex.objectsWithTag(tagName);
     },
-    "index.contentPages": (): LuaQueryCollection => {
-      return objectIndex.contentPages();
+    // Alias for tag
+    "index.objects": (_ctx, tagName: string): LuaQueryCollection => {
+      return objectIndex.objectsWithTag(tagName);
+    },
+    "index.pages": (_ctx, tagName?: string): LuaQueryCollection => {
+      return objectIndex.rootTaggedObjects("page", tagName);
+    },
+    "index.subPages": (_ctx, pageName: string): LuaQueryCollection => {
+      return objectIndex.subPages(pageName);
+    },
+    "index.documents": (): LuaQueryCollection => {
+      return objectIndex.objectsWithTag("document");
+    },
+    "index.links": (): LuaQueryCollection => {
+      return objectIndex.objectsWithTag("link");
+    },
+    "index.relations": (): LuaQueryCollection => {
+      return objectIndex.objectsWithTag("relation");
+    },
+    "index.contentPages": (_ctx, tagName?: string): LuaQueryCollection => {
+      return objectIndex.contentPages(tagName);
     },
     "index.metaPages": (): LuaQueryCollection => {
       return objectIndex.metaPages();
     },
+    "index.tasks": (_ctx, tagName?: string): LuaQueryCollection => {
+      return objectIndex.rootTaggedObjects("task", tagName);
+    },
+    "index.headers": (_ctx, tagName?: string): LuaQueryCollection => {
+      return objectIndex.rootTaggedObjects("header", tagName);
+    },
+    "index.items": (_ctx, tagName?: string): LuaQueryCollection => {
+      return objectIndex.rootTaggedObjects("item", tagName);
+    },
+    "index.paragraphs": (_ctx, tagName?: string): LuaQueryCollection => {
+      return objectIndex.rootTaggedObjects("paragraph", tagName);
+    },
+    "index.tables": (_ctx, tagName?: string): LuaQueryCollection => {
+      return objectIndex.rootTaggedObjects("table", tagName);
+    },
+    "index.tags": (): LuaQueryCollection => {
+      return objectIndex.objectsWithTag("tag");
+    },
+    "index.aspiringPages": (): LuaQueryCollection => {
+      return objectIndex.aspiringPages();
+    },
+    // Internals
     "index.aggregates": (): LuaQueryCollection => {
       return objectIndex.aggregates();
     },

package/client/plugos/syscalls/lua.ts

@@ -1,6 +1,11 @@
 import type { SysCallMapping } from "../system.ts";
 import { evalExpression } from "../../space_lua/eval.ts";
-import { parse, parseExpressionString } from "../../space_lua/parse.ts";
+import { parseBlock, parseExpressionString } from "../../space_lua/parse.ts";
+import {
+  type PrintOptions,
+  prettyPrintBlock,
+  prettyPrintExpression,
+} from "../../space_lua/pretty_print.ts";
 import {
   LuaStackFrame,
   luaToString,
@@ -13,12 +18,30 @@ import type { ClientSystem } from "../../client_system.ts";
 
 export function luaSyscalls(clientSystem: ClientSystem): SysCallMapping {
   return {
+    "lua.parseBlock": (_ctx, code: string): LuaBlock => {
+      return parseBlock(code);
+    },
+    // Deprecated alias for `lua.parseBlock`, kept for backwards compatibility.
     "lua.parse": (_ctx, code: string): LuaBlock => {
-      return parse(code);
+      return parseBlock(code);
     },
     "lua.parseExpression": (_ctx, expression: string): LuaExpression => {
       return parseExpressionString(expression);
     },
+    "lua.prettyPrintBlock": (
+      _ctx,
+      block: LuaBlock,
+      opts?: PrintOptions,
+    ): string => {
+      return prettyPrintBlock(block, opts);
+    },
+    "lua.prettyPrintExpression": (
+      _ctx,
+      expression: LuaExpression,
+      opts?: PrintOptions,
+    ): string => {
+      return prettyPrintExpression(expression, opts);
+    },
     /**
      * Evaluates a Lua expression and returns the result as a JavaScript value
      * @param _ctx

package/client/space_lua/parse.ts

@@ -67,7 +67,7 @@ function parseChunk(t: ParseTree, ctx: ASTCtx): LuaBlock {
   if (t.type !== "Chunk") {
     throw new Error(`Expected Chunk, got ${t.type}`);
   }
-  return parseBlock(t.children![0], ctx);
+  return parseBlockNode(t.children![0], ctx);
 }
 
 function hasCloseLocal(names: LuaAttName[] | undefined): boolean {
@@ -636,7 +636,7 @@ function exprCapturesNames(e: LuaExpression, names: Set<string>): boolean {
   }
 }
 
-function parseBlock(t: ParseTree, ctx: ASTCtx): LuaBlock {
+function parseBlockNode(t: ParseTree, ctx: ASTCtx): LuaBlock {
   if (t.type !== "Block") {
     throw new Error(`Expected Block, got ${t.type}`);
   }
@@ -846,20 +846,20 @@ function parseStatement(t: ParseTree, ctx: ASTCtx): LuaStatement {
         ctx: context(t, ctx),
       };
     case "Scope":
-      return parseBlock(t.children![1], ctx);
+      return parseBlockNode(t.children![1], ctx);
     case ";":
       return { type: "Semicolon", ctx: context(t, ctx) };
     case "WhileStatement":
       return {
         type: "While",
         condition: parseExpression(t.children![1], ctx),
-        block: parseBlock(t.children![3], ctx),
+        block: parseBlockNode(t.children![3], ctx),
         ctx: context(t, ctx),
       };
     case "RepeatStatement":
       return {
         type: "Repeat",
-        block: parseBlock(t.children![1], ctx),
+        block: parseBlockNode(t.children![1], ctx),
         condition: parseExpression(t.children![3], ctx),
         ctx: context(t, ctx),
       };
@@ -880,12 +880,12 @@ function parseStatement(t: ParseTree, ctx: ASTCtx): LuaStatement {
         if (token === "if" || token === "elseif") {
           conditions.push({
             condition: parseExpression(t.children![i + 1], ctx),
-            block: parseBlock(t.children![i + 3], ctx),
+            block: parseBlockNode(t.children![i + 3], ctx),
             from: child.from,
             to: child.to,
           });
         } else if (token === "else") {
-          elseBlock = parseBlock(t.children![i + 1], ctx);
+          elseBlock = parseBlockNode(t.children![i + 1], ctx);
         } else if (token === "end") {
           break;
         } else {
@@ -903,7 +903,7 @@ function parseStatement(t: ParseTree, ctx: ASTCtx): LuaStatement {
       if (t.children![1].type === "ForNumeric") {
         const forNumeric = t.children![1];
         const name = forNumeric.children![0].children![0].text!;
-        const block = parseBlock(t.children![3], ctx);
+        const block = parseBlockNode(t.children![3], ctx);
         const node: LuaStatement = {
           type: "For",
           name,
@@ -923,7 +923,7 @@ function parseStatement(t: ParseTree, ctx: ASTCtx): LuaStatement {
       }
       const forGeneric = t.children![1];
       const names = parseNameList(forGeneric.children![0]);
-      const block = parseBlock(t.children![3], ctx);
+      const block = parseBlockNode(t.children![3], ctx);
       const node: LuaStatement = {
         type: "ForIn",
         names,
@@ -1512,7 +1512,7 @@ function parseFunctionBody(t: ParseTree, ctx: ASTCtx): LuaFunctionBody {
         (c) => c.type && ["Name", "Ellipsis"].includes(c.type),
       )
       .map((c) => c.children![0].text!),
-    block: parseBlock(t.children![3], ctx),
+    block: parseBlockNode(t.children![3], ctx),
     ctx: context(t, ctx),
   };
 }
@@ -1686,7 +1686,7 @@ export function stripLuaComments(s: string): string {
   return result;
 }
 
-export function parse(s: string, ctx: ASTCtx = {}): LuaBlock {
+export function parseBlock(s: string, ctx: ASTCtx = {}): LuaBlock {
   try {
     const t = parseToAST(stripLuaComments(s));
     // console.log("Clean tree", JSON.stringify(t, null, 2));
@@ -1743,6 +1743,6 @@ function luaUnexpectedSymbolMessage(src: string, from: number): string {
  * Helper function to parse a Lua expression string
  */
 export function parseExpressionString(expr: string): LuaExpression {
-  const parsedLua = parse(`_(${expr})`) as LuaBlock;
+  const parsedLua = parseBlock(`_(${expr})`) as LuaBlock;
   return (parsedLua.statements[0] as LuaFunctionCallStatement).call.args[0];
 }

package/client/space_lua/pretty_print.ts

@@ -0,0 +1,391 @@
+import type {
+  LuaBlock,
+  LuaExpression,
+  LuaOrderBy,
+  LuaQueryClause,
+  LuaStatement,
+  LuaTableField,
+} from "./ast.ts";
+import { luaFormatNumber } from "./runtime.ts";
+
+export type PrintOptions = {
+  indentWidth?: number;
+  quote?: "double" | "single";
+  trailingComma?: boolean;
+};
+
+type ResolvedOptions = {
+  indentWidth: number;
+  quote: "double" | "single";
+  trailingComma: boolean;
+};
+
+function resolveOptions(opts?: PrintOptions): ResolvedOptions {
+  return {
+    indentWidth: opts?.indentWidth ?? 2,
+    quote: opts?.quote ?? "double",
+    trailingComma: opts?.trailingComma ?? true,
+  };
+}
+
+const RESERVED = new Set([
+  "and", "break", "do", "else", "elseif", "end", "false", "for", "function",
+  "goto", "if", "in", "local", "nil", "not", "or", "repeat", "return", "then",
+  "true", "until", "while",
+]);
+
+function isLuaIdentifier(s: string): boolean {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(s) && !RESERVED.has(s);
+}
+
+const BINARY_PREC: Record<string, number> = {
+  "or": 1,
+  "and": 2,
+  "<": 3, ">": 3, "<=": 3, ">=": 3, "~=": 3, "==": 3,
+  "|": 4,
+  "~": 5, // binary bitwise xor
+  "&": 6,
+  "<<": 7, ">>": 7,
+  "..": 8,
+  "+": 9, "-": 9,
+  "*": 10, "/": 10, "//": 10, "%": 10,
+  "^": 12,
+};
+const UNARY_PREC = 11;
+const RIGHT_ASSOC = new Set(["..", "^"]);
+const ATOM_PREC = 99;
+
+function exprPrec(e: LuaExpression): number {
+  if (e.type === "Binary") return BINARY_PREC[e.operator] ?? ATOM_PREC;
+  if (e.type === "Unary") return UNARY_PREC;
+  return ATOM_PREC;
+}
+
+class Printer {
+  constructor(private opts: ResolvedOptions) { }
+
+  private indent(depth: number): string {
+    return " ".repeat(depth * this.opts.indentWidth);
+  }
+
+  private quoteString(s: string): string {
+    const q = this.opts.quote === "double" ? '"' : "'";
+    let out = q;
+    for (const ch of s) {
+      switch (ch) {
+        case "\\":
+          out += "\\\\";
+          break;
+        case "\n":
+          out += "\\n";
+          break;
+        case "\r":
+          out += "\\r";
+          break;
+        case "\t":
+          out += "\\t";
+          break;
+        case "\0":
+          out += "\\0";
+          break;
+        default:
+          out += ch === q ? `\\${ch}` : ch;
+      }
+    }
+    return out + q;
+  }
+
+  expression(e: LuaExpression, depth = 0): string {
+    switch (e.type) {
+      case "Nil":
+        return "nil";
+      case "Boolean":
+        return e.value ? "true" : "false";
+      case "Number":
+        return luaFormatNumber(e.value, e.numericType);
+      case "String":
+        return this.quoteString(e.value);
+      case "Variable":
+        return e.name;
+      case "PropertyAccess":
+        return `${this.expression(e.object, depth)}.${e.property}`;
+      case "TableAccess":
+        return `${this.expression(e.object, depth)}[${this.expression(e.key, depth)}]`;
+      case "Parenthesized":
+        return `(${this.expression(e.expression, depth)})`;
+      case "Binary": {
+        const p = BINARY_PREC[e.operator] ?? ATOM_PREC;
+        const rightAssoc = RIGHT_ASSOC.has(e.operator);
+        const left = this.operand(e.left, p, false, rightAssoc, depth);
+        const right = this.operand(e.right, p, true, rightAssoc, depth);
+        return `${left} ${e.operator} ${right}`;
+      }
+      case "Unary": {
+        const arg = this.unaryOperand(e.argument, depth);
+        return /^[a-z]+$/.test(e.operator)
+          ? `${e.operator} ${arg}`
+          : `${e.operator}${arg}`;
+      }
+      case "TableConstructor":
+        return this.tableConstructor(e.fields, depth);
+      case "FunctionDefinition":
+        return "function" +
+          this.functionRest(e.body.parameters, e.body.block, depth);
+      case "FunctionCall":
+        return this.functionCall(e, depth);
+      case "Query": {
+        const lines = e.clauses.map((c) =>
+          this.indent(depth + 1) + this.queryClause(c, depth + 1)
+        );
+        return `query[[\n${lines.join("\n")}\n${this.indent(depth)}]]`;
+      }
+      case "FilteredCall":
+        return `${this.expression(e.call, depth)} filter ${this.expression(e.filter, depth)
+          }`;
+      case "AggregateCall":
+        return `${this.expression(e.call, depth)} order by ${this.orderByList(e.orderBy, depth)
+          }`;
+      default:
+        throw new Error(
+          `pretty_print: unsupported expression type: ${(e as any).type}`,
+        );
+    }
+  }
+
+  private operand(
+    e: LuaExpression,
+    parentPrec: number,
+    isRight: boolean,
+    parentRightAssoc: boolean,
+    depth: number,
+  ): string {
+    const cp = exprPrec(e);
+    let parens = false;
+    if (cp < parentPrec) {
+      parens = true;
+    } else if (cp === parentPrec) {
+      // left-assoc parent: the right child of equal precedence needs parens.
+      // right-assoc parent: the left child of equal precedence needs parens.
+      parens = parentRightAssoc ? !isRight : isRight;
+    }
+    const s = this.expression(e, depth);
+    return parens ? `(${s})` : s;
+  }
+
+  private unaryOperand(e: LuaExpression, depth: number): string {
+    const s = this.expression(e, depth);
+    return exprPrec(e) < UNARY_PREC ? `(${s})` : s;
+  }
+
+  private field(f: LuaTableField, depth: number): string {
+    switch (f.type) {
+      case "PropField":
+        return isLuaIdentifier(f.key)
+          ? `${f.key} = ${this.expression(f.value, depth)}`
+          : `[${this.quoteString(f.key)}] = ${this.expression(f.value, depth)}`;
+      case "DynamicField":
+        return `[${this.expression(f.key, depth)}] = ${this.expression(f.value, depth)}`;
+      case "ExpressionField":
+        return this.expression(f.value, depth);
+    }
+  }
+
+  private tableConstructor(fields: LuaTableField[], depth: number): string {
+    if (fields.length === 0) return "{}";
+    if (fields.length === 1) return `{${this.field(fields[0], depth)}}`;
+    const lines = fields.map((f) =>
+      this.indent(depth + 1) + this.field(f, depth + 1)
+    );
+    const tail = this.opts.trailingComma ? "," : "";
+    return `{\n${lines.join(",\n")}${tail}\n${this.indent(depth)}}`;
+  }
+
+  // returns the part of a function after the `function` keyword (+ optional
+  // name): "(params) end"  or  "(params)\n  <body>\nend"
+  private functionRest(
+    params: string[],
+    body: LuaBlock,
+    depth: number,
+  ): string {
+    const head = `(${params.join(", ")})`;
+    const rendered = this.block(body, depth + 1);
+    if (!rendered) return `${head} end`;
+    return `${head}\n${rendered}\n${this.indent(depth)}end`;
+  }
+
+  private functionCall(
+    e: Extract<LuaExpression, { type: "FunctionCall" }>,
+    depth: number,
+  ): string {
+    let base = this.expression(e.prefix, depth);
+    if (e.name) base += `:${e.name}`;
+    const args = e.args;
+    const orderBy = e.orderBy
+      ? ` order by ${this.orderByList(e.orderBy, depth)}`
+      : "";
+    if (
+      !e.orderBy && args.length === 1 &&
+      (args[0].type === "TableConstructor" || args[0].type === "String")
+    ) {
+      return `${base} ${this.expression(args[0], depth)}`;
+    }
+    return `${base}(${args.map((a) => this.expression(a, depth)).join(", ")})${orderBy}`;
+  }
+
+  private fieldList(fields: LuaTableField[], depth: number): string {
+    return fields.map((f) => this.field(f, depth)).join(", ");
+  }
+
+  private orderByList(orders: LuaOrderBy[], depth: number): string {
+    return orders
+      .map((o) => {
+        let s = this.expression(o.expression, depth);
+        if (o.direction === "desc") s += " desc";
+        if (o.nulls) s += ` nulls ${o.nulls}`;
+        return s;
+      })
+      .join(", ");
+  }
+
+  private queryClause(c: LuaQueryClause, depth: number): string {
+    switch (c.type) {
+      case "From":
+        return `from ${this.fieldList(c.fields, depth)}`;
+      case "Where":
+        return `where ${this.expression(c.expression, depth)}`;
+      case "Limit":
+        return `limit ${this.expression(c.limit, depth)}` +
+          (c.offset ? ` offset ${this.expression(c.offset, depth)}` : "");
+      case "Offset":
+        return `offset ${this.expression(c.offset, depth)}`;
+      case "OrderBy":
+        return `order by ${this.orderByList(c.orderBy, depth)}`;
+      case "Select":
+        return `select ${this.fieldList(c.fields, depth)}`;
+      case "GroupBy":
+        return `group by ${this.fieldList(c.fields, depth)}`;
+      case "Having":
+        return `having ${this.expression(c.expression, depth)}`;
+    }
+  }
+
+  block(b: LuaBlock, depth: number): string {
+    const stmts = b.statements.filter((s) => s.type !== "Semicolon");
+    const isDef = (s: LuaStatement) =>
+      s.type === "Function" || s.type === "LocalFunction";
+    let out = "";
+    for (let i = 0; i < stmts.length; i++) {
+      if (i > 0) {
+        out += "\n";
+        // blank line separating function definitions from neighbours
+        if (isDef(stmts[i - 1]) || isDef(stmts[i])) out += "\n";
+      }
+      out += this.statement(stmts[i], depth);
+    }
+    return out;
+  }
+
+  private statement(s: LuaStatement, depth: number): string {
+    const ind = this.indent(depth);
+    switch (s.type) {
+      case "Local": {
+        const names = s.names
+          .map((n) =>
+            n.name +
+            (n.attribute
+              ? ` <${n.attribute}>`
+              : (n.attributes?.length ? ` <${n.attributes[0]}>` : ""))
+          )
+          .join(", ");
+        const exprs = s.expressions?.length
+          ? ` = ${s.expressions.map((e) => this.expression(e, depth)).join(", ")}`
+          : "";
+        return `${ind}local ${names}${exprs}`;
+      }
+      case "Assignment":
+        return `${ind}${s.variables.map((v) => this.expression(v, depth)).join(", ")
+          } = ${s.expressions.map((e) => this.expression(e, depth)).join(", ")}`;
+      case "Return":
+        return s.expressions.length
+          ? `${ind}return ${s.expressions.map((e) => this.expression(e, depth)).join(", ")
+          }`
+          : `${ind}return`;
+      case "FunctionCallStatement":
+        return ind + this.expression(s.call, depth);
+      case "Break":
+        return `${ind}break`;
+      case "Goto":
+        return `${ind}goto ${s.name}`;
+      case "Label":
+        return `${ind}::${s.name}::`;
+      case "Block": {
+        const body = this.block(s, depth + 1);
+        return body ? `${ind}do\n${body}\n${ind}end` : `${ind}do end`;
+      }
+      case "If": {
+        let out = "";
+        s.conditions.forEach((c, i) => {
+          const kw = i === 0 ? "if" : "elseif";
+          const head = i === 0 ? `${ind}${kw} ` : `\n${ind}${kw} `;
+          const body = this.block(c.block, depth + 1);
+          out += `${head}${this.expression(c.condition, depth)} then` +
+            (body ? `\n${body}` : "");
+        });
+        if (s.elseBlock) {
+          const body = this.block(s.elseBlock, depth + 1);
+          out += `\n${ind}else${body ? `\n${body}` : ""}`;
+        }
+        out += `\n${ind}end`;
+        return out;
+      }
+      case "While": {
+        const body = this.block(s.block, depth + 1);
+        return `${ind}while ${this.expression(s.condition, depth)} do` +
+          (body ? `\n${body}` : "") + `\n${ind}end`;
+      }
+      case "Repeat": {
+        const body = this.block(s.block, depth + 1);
+        return `${ind}repeat` + (body ? `\n${body}` : "") +
+          `\n${ind}until ${this.expression(s.condition, depth)}`;
+      }
+      case "For": {
+        const step = s.step ? `, ${this.expression(s.step, depth)}` : "";
+        const body = this.block(s.block, depth + 1);
+        return `${ind}for ${s.name} = ${this.expression(s.start, depth)}, ${this.expression(s.end, depth)
+          }${step} do${body ? `\n${body}` : ""}\n${ind}end`;
+      }
+      case "ForIn": {
+        const body = this.block(s.block, depth + 1);
+        return `${ind}for ${s.names.join(", ")} in ${s.expressions.map((e) => this.expression(e, depth)).join(", ")
+          } do${body ? `\n${body}` : ""}\n${ind}end`;
+      }
+      case "Function": {
+        const name = s.name.propNames.join(".") +
+          (s.name.colonName ? `:${s.name.colonName}` : "");
+        return `${ind}function ${name}` +
+          this.functionRest(s.body.parameters, s.body.block, depth);
+      }
+      case "LocalFunction":
+        return `${ind}local function ${s.name}` +
+          this.functionRest(s.body.parameters, s.body.block, depth);
+      default:
+        throw new Error(
+          `pretty_print: unsupported statement type: ${(s as any).type}`,
+        );
+    }
+  }
+}
+
+export function prettyPrintExpression(
+  expr: LuaExpression,
+  opts?: PrintOptions,
+): string {
+  return new Printer(resolveOptions(opts)).expression(expr, 0);
+}
+
+export function prettyPrintBlock(
+  block: LuaBlock,
+  opts?: PrintOptions,
+): string {
+  return new Printer(resolveOptions(opts)).block(block, 0);
+}

package/client/space_lua/query_collection.ts

@@ -193,7 +193,7 @@ export interface LuaQueryCollection {
  * Implements a query collection for a regular JavaScript array
  */
 export class ArrayQueryCollection<T> implements LuaQueryCollection {
-  constructor(private readonly array: T[]) {}
+  constructor(private readonly array: T[]) { }
   query(
     query: LuaCollectionQuery,
     env: LuaEnv,
@@ -842,7 +842,7 @@ export async function applyQuery(
 
   const mkEnv = grouped
     ? (ov: string | undefined, item: any, e: LuaEnv, s: LuaStackFrame) =>
-        buildGroupItemEnv(ov, groupByNames, item, e, s)
+      buildGroupItemEnv(ov, groupByNames, item, e, s)
     : buildItemEnvLocal;
 
   let selectResults: any[] | undefined;
@@ -915,9 +915,7 @@ export async function applyQuery(
     for (let i = 0; i < violated.length; i++) {
       if (violated[i]) {
         throw new LuaRuntimeError(
-          `order by #${
-            i + 1
-          }: 'using' comparator violates strict weak ordering`,
+          `order by #${i + 1}: 'using' comparator violates strict weak ordering`,
           sf,
         );
       }
@@ -1004,6 +1002,8 @@ export async function queryLua<T = any>(
   for await (let { key, value } of kv.query({ prefix })) {
     if (enricher) {
       value = enricher(key, value);
+      // Enrichers may return undefined to filter a row out 
+      if (value === undefined) continue;
     }
     results.push(value);
   }
@@ -1056,7 +1056,7 @@ export class DataStoreQueryCollection implements LuaQueryCollection {
   constructor(
     private readonly dataStore: DataStore,
     readonly prefix: string[],
-  ) {}
+  ) { }
   query(
     query: LuaCollectionQuery,
     env: LuaEnv,

package/client/space_lua/stdlib/load.ts

@@ -5,7 +5,7 @@ import {
   type LuaStackFrame,
   type LuaValue,
 } from "../runtime.ts";
-import { parse } from "../parse.ts";
+import { parseBlock } from "../parse.ts";
 import { evalStatement } from "../eval.ts";
 
 // Returns a function (callable chunk) or (nil, "error message") pair.
@@ -13,7 +13,7 @@ export function luaLoad(code: LuaValue, sf: LuaStackFrame): LuaValue {
   const s = typeof code === "string" ? code : String(code);
 
   try {
-    const block = parse(s, sf.astCtx || {});
+    const block = parseBlock(s, sf.astCtx || {});
     const globalEnvMaybe = sf.threadLocal.get("_GLOBAL");
 
     // Be vocal when no _GLOBAL is set

package/client/space_lua/stdlib/space_lua.ts

@@ -1,6 +1,11 @@
-import { parseExpressionString } from "../parse.ts";
-import type { LuaExpression } from "../ast.ts";
+import { parseBlock, parseExpressionString } from "../parse.ts";
+import type { LuaBlock, LuaExpression } from "../ast.ts";
 import { evalExpression } from "../eval.ts";
+import {
+  type PrintOptions,
+  prettyPrintBlock,
+  prettyPrintExpression,
+} from "../pretty_print.ts";
 import {
   jsToLuaValue,
   LuaBuiltinFunction,
@@ -101,6 +106,25 @@ export async function interpolateLuaString(
   return result;
 }
 
+/**
+ * Converts an optional Lua options table into a `PrintOptions` object,
+ * keeping only the recognised keys with the expected types.
+ */
+function toPrintOptions(
+  sf: LuaStackFrame,
+  opts?: LuaTable,
+): PrintOptions | undefined {
+  if (!opts) return undefined;
+  const js = luaValueToJS(opts, sf) as Record<string, unknown>;
+  const result: PrintOptions = {};
+  if (typeof js.indentWidth === "number") result.indentWidth = js.indentWidth;
+  if (js.quote === "double" || js.quote === "single") result.quote = js.quote;
+  if (typeof js.trailingComma === "boolean") {
+    result.trailingComma = js.trailingComma;
+  }
+  return result;
+}
+
 export const spaceluaApi = new LuaTable({
   /**
    * Parses a lua expression and returns the parsed expression.
@@ -112,6 +136,42 @@ export const spaceluaApi = new LuaTable({
   parseExpression: new LuaBuiltinFunction((_sf, luaExpression: string) => {
     return parseExpressionString(luaExpression);
   }),
+  /**
+   * Parses a lua chunk (block) and returns the parsed AST block.
+   *
+   * @param sf - The current space_lua state.
+   * @param code - The lua code to parse.
+   * @returns The parsed block.
+   */
+  parseBlock: new LuaBuiltinFunction((_sf, code: string): LuaBlock => {
+    return parseBlock(code);
+  }),
+  /**
+   * Pretty-prints a parsed lua block AST back to formatted source.
+   *
+   * @param sf - The current space_lua state.
+   * @param block - The parsed lua block.
+   * @param opts - Optional formatting options.
+   * @returns The formatted lua source.
+   */
+  prettyPrintBlock: new LuaBuiltinFunction(
+    (sf, block: LuaBlock, opts?: LuaTable): string => {
+      return prettyPrintBlock(block, toPrintOptions(sf, opts));
+    },
+  ),
+  /**
+   * Pretty-prints a parsed lua expression AST back to formatted source.
+   *
+   * @param sf - The current space_lua state.
+   * @param expr - The parsed lua expression.
+   * @param opts - Optional formatting options.
+   * @returns The formatted lua source.
+   */
+  prettyPrintExpression: new LuaBuiltinFunction(
+    (sf, expr: LuaExpression, opts?: LuaTable): string => {
+      return prettyPrintExpression(expr, toPrintOptions(sf, opts));
+    },
+  ),
   /**
    * Evaluates a parsed lua expression and returns the result.
    *

package/client/space_lua/stdlib.ts

@@ -26,7 +26,7 @@ import { osApi } from "./stdlib/os.ts";
 import { jsApi } from "./stdlib/js.ts";
 import { spaceluaApi } from "./stdlib/space_lua.ts";
 import { mathApi } from "./stdlib/math.ts";
-import { parse } from "./parse.ts";
+import { parseBlock } from "./parse.ts";
 import { evalStatement } from "./eval.ts";
 import { encodingApi } from "./stdlib/encoding.ts";
 import { luaToNumberDetailed } from "./tonumber.ts";
@@ -350,7 +350,7 @@ const dofileFunction = new LuaBuiltinFunction(async (sf, filename: string) => {
   )) as Uint8Array;
   const code = new TextDecoder().decode(file);
   try {
-    const parsedExpr = parse(code);
+    const parsedExpr = parseBlock(code);
     const env = new LuaEnv(global);
     await evalStatement(parsedExpr, env, sf.withCtx(parsedExpr.ctx));
   } catch (e: any) {

package/dist/plug-compile.js

@@ -4,7 +4,7 @@
 import { Command } from "commander";
 
 // version.ts
-var version = "2.8.0";
+var version = "2.9.0";
 
 // client/plugos/plug_compile.ts
 import * as path from "node:path";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@silverbulletmd/silverbullet",
-  "version": "2.8.0",
+  "version": "2.9.0",
   "type": "module",
   "description": "A self-hosted, web-based note taking app",
   "publishConfig": {
@@ -10,6 +10,7 @@
     "./syscall": "./plug-api/syscall.ts",
     "./syscalls": "./plug-api/syscalls.ts",
     "./constants": "./plug-api/constants.ts",
+    "./ui": "./plug-api/ui/index.ts",
     "./lib/json": "./plug-api/lib/json.ts",
     "./lib/tree": "./plug-api/lib/tree.ts",
     "./lib/ref": "./plug-api/lib/ref.ts",
@@ -61,9 +62,13 @@
     "fmt": "biome format --write .",
     "fmt:check": "biome format .",
     "bench": "vitest bench",
+    "index-stats": "tsx plugs/index/index_stats.ts",
     "test:e2e": "npx playwright test",
     "test:e2e:headed": "npx playwright test --headed"
   },
+  "peerDependencies": {
+    "preact": "^10.25.0"
+  },
   "dependencies": {
     "@cfworker/json-schema": "^4.1.1",
     "@codemirror/autocomplete": "6.20.1",
@@ -91,10 +96,11 @@
     "@replit/codemirror-vim": "6.3.0",
     "commander": "^14.0.3",
     "crelt": "1.0.6",
+    "d3-force": "^3.0.0",
     "esbuild": "^0.27.3",
     "fast-diff": "1.3.0",
+    "force-graph": "^1.49.0",
     "fast-glob": "^3.3.3",
-    "fuse.js": "7.1.0",
     "gitignore-parser": "0.0.2",
     "idb": "8.0.3",
     "js-yaml": "^4.1.1",
@@ -110,11 +116,13 @@
     "@biomejs/biome": "2.4.6",
     "@playwright/test": "^1.58.2",
     "@preact/preset-vite": "^2.10.3",
+    "@types/d3-force": "^3.0.10",
     "@types/gitignore-parser": "^0.0.3",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.0.0",
     "@types/turndown": "^5.0.6",
     "fake-indexeddb": "6.0.1",
+    "preact-render-to-string": "^6.7.0",
     "tsx": "^4.19.0",
     "typescript": "^5.9.3",
     "vite": "^7.3.1",

package/plug-api/syscalls/editor.ts

@@ -374,10 +374,15 @@ export function prompt(
 /**
  * Prompt the user for confirmation
  * @param message the message to show in the confirmation dialog
+ * @param options optional settings; set `destructive: true` to style the
+ *   confirm button as a destructive (danger) action
  * @returns
  */
-export function confirm(message: string): Promise<boolean> {
-  return syscall("editor.confirm", message);
+export function confirm(
+  message: string,
+  options?: { destructive?: boolean },
+): Promise<boolean> {
+  return syscall("editor.confirm", message, options);
 }
 
 /**

package/plug-api/syscalls/index.ts

@@ -1,4 +1,7 @@
-import type { LuaCollectionQuery } from "../../client/space_lua/query_collection.ts";
+import type {
+  LuaCollectionQuery,
+  LuaQueryCollection,
+} from "../../client/space_lua/query_collection.ts";
 import { syscall } from "@silverbulletmd/silverbullet/syscall";
 import type { ObjectValue } from "../../plug-api/types/index.ts";
 
@@ -39,6 +42,98 @@ export function previewProcessedObjects(
   return syscall("index.previewProcessedObjects", page, objects);
 }
 
+/**
+ * Returns objects carrying the given tag as a query collection.
+ */
+export function objects(tagName: string): Promise<LuaQueryCollection> {
+  return syscall("index.objects", tagName);
+}
+
+/**
+ * Returns all pages (optionally filtered by an additional tag) as a query collection.
+ */
+export function pages(tagName?: string): Promise<LuaQueryCollection> {
+  return syscall("index.pages", tagName);
+}
+
+/**
+ * Returns all sub-pages of the given page (pages whose name starts with `<pageName>/`)
+ * as a query collection.
+ */
+export function subPages(pageName: string): Promise<LuaQueryCollection> {
+  return syscall("index.subPages", pageName);
+}
+
+/**
+ * Returns all documents as a query collection.
+ */
+export function documents(): Promise<LuaQueryCollection> {
+  return syscall("index.documents");
+}
+
+/**
+ * Returns all links as a query collection.
+ */
+export function links(): Promise<LuaQueryCollection> {
+  return syscall("index.links");
+}
+
+/**
+ * Returns all relation objects as a query collection.
+ */
+export function relations(): Promise<LuaQueryCollection> {
+  return syscall("index.relations");
+}
+
+/**
+ * Returns all tasks (optionally filtered by an additional tag) as a query collection.
+ */
+export function tasks(tagName?: string): Promise<LuaQueryCollection> {
+  return syscall("index.tasks", tagName);
+}
+
+/**
+ * Returns all headers (optionally filtered by an additional tag) as a query collection.
+ */
+export function headers(tagName?: string): Promise<LuaQueryCollection> {
+  return syscall("index.headers", tagName);
+}
+
+/**
+ * Returns all list items (optionally filtered by an additional tag) as a query collection.
+ */
+export function items(tagName?: string): Promise<LuaQueryCollection> {
+  return syscall("index.items", tagName);
+}
+
+/**
+ * Returns all paragraphs (optionally filtered by an additional tag) as a query collection.
+ */
+export function paragraphs(tagName?: string): Promise<LuaQueryCollection> {
+  return syscall("index.paragraphs", tagName);
+}
+
+/**
+ * Returns all tables (optionally filtered by an additional tag) as a query collection.
+ */
+export function tables(tagName?: string): Promise<LuaQueryCollection> {
+  return syscall("index.tables", tagName);
+}
+
+/**
+ * Returns all aspiring (referenced but not yet created) pages as a query collection.
+ */
+export function aspiringPages(): Promise<LuaQueryCollection> {
+  return syscall("index.aspiringPages");
+}
+
+/**
+ * Returns all tag objects as a query collection.
+ */
+export function tags(): Promise<LuaQueryCollection> {
+  return syscall("index.tags");
+}
+
 /**
  * Queries objects using a Lua-based collection query
  * @param tag - The tag to filter objects by

package/plug-api/syscalls/lua.ts

@@ -1,8 +1,14 @@
 import { syscall } from "../syscall.ts";
 import type { LuaBlock, LuaExpression } from "../../client/space_lua/ast.ts";
+import type { PrintOptions } from "../../client/space_lua/pretty_print.ts";
 
+export function parseBlock(code: string): Promise<LuaBlock> {
+  return syscall("lua.parseBlock", code);
+}
+
+/** @deprecated use {@link parseBlock} instead */
 export function parse(code: string): Promise<LuaBlock> {
-  return syscall("lua.parse", code);
+  return syscall("lua.parseBlock", code);
 }
 
 export function parseExpression(expression: string): Promise<LuaExpression> {
@@ -12,3 +18,17 @@ export function parseExpression(expression: string): Promise<LuaExpression> {
 export function evalExpression(expression: string): Promise<any> {
   return syscall("lua.evalExpression", expression);
 }
+
+export function prettyPrintBlock(
+  block: LuaBlock,
+  opts?: PrintOptions,
+): Promise<string> {
+  return syscall("lua.prettyPrintBlock", block, opts);
+}
+
+export function prettyPrintExpression(
+  expression: LuaExpression,
+  opts?: PrintOptions,
+): Promise<string> {
+  return syscall("lua.prettyPrintExpression", expression, opts);
+}

package/plug-api/types/config.ts

@@ -7,7 +7,7 @@ export type QueryCollationConfig = {
   options?: object;
 };
 
-type vimMode = "normal" | "insert" | "visual";
+type vimMode = "normal" | "insert" | "visual" | "operator";
 
 export type VimConfig = {
   unmap?: (string | { key: string; mode?: vimMode })[];

package/plug-api/ui/cx.ts

@@ -0,0 +1,6 @@
+/** Join class-name parts, dropping falsy values. */
+export function cx(
+  ...parts: Array<string | false | null | undefined>
+): string {
+  return parts.filter(Boolean).join(" ");
+}

package/plug-api/ui/index.ts

@@ -0,0 +1,19 @@
+export { Button } from "./button.tsx";
+export type { ButtonProps, ButtonVariant } from "./button.tsx";
+export { Input } from "./input.tsx";
+export type { InputProps } from "./input.tsx";
+export { Select } from "./select.tsx";
+export type { SelectProps } from "./select.tsx";
+export { Checkbox } from "./checkbox.tsx";
+export type { CheckboxProps } from "./checkbox.tsx";
+export { Tabs } from "./tabs.tsx";
+export type { TabItem, TabsProps } from "./tabs.tsx";
+export { Alert } from "./alert.tsx";
+export type { AlertProps, AlertVariant } from "./alert.tsx";
+export { Badge } from "./badge.tsx";
+export type { BadgeProps } from "./badge.tsx";
+export { Progress } from "./progress.tsx";
+export type { ProgressProps } from "./progress.tsx";
+export { cx } from "./cx.ts";
+export { panelStyles } from "./panel_styles.ts";
+export type { PanelStylesOptions } from "./panel_styles.ts";

package/plug-api/ui/panel_styles.ts

@@ -0,0 +1,32 @@
+import { getUiOption } from "../syscalls/editor.ts";
+
+export type PanelStylesOptions = {
+  /** Include the shared component stylesheet link (default true). */
+  components?: boolean;
+  /** Include the user's space-style CSS (default true). */
+  spaceStyles?: boolean;
+};
+
+/**
+ * Build an HTML preamble that styles a plug panel/widget iframe like the rest
+ * of SilverBullet: the shared component stylesheet plus the user's space-style
+ * CSS. Prepend the result to the HTML you pass to `editor.showPanel`.
+ *
+ * Order: components first (base), then space styles (so user theming wins),
+ * leaving any plug-specific CSS you append afterwards highest-precedence.
+ */
+export async function panelStyles(
+  { components = true, spaceStyles = true }: PanelStylesOptions = {},
+): Promise<string> {
+  let out = "";
+  if (components) {
+    out += `<link rel="stylesheet" href=".client/components.css">`;
+  }
+  if (spaceStyles) {
+    const custom = await getUiOption("customStyles");
+    if (typeof custom === "string" && custom) {
+      out += custom;
+    }
+  }
+  return out;
+}

package/plugs/builtin_plugs.ts

@@ -7,6 +7,7 @@ export const builtinPlugNames = [
   "emoji",
   "image-viewer",
   "configuration-manager",
+  "object-graph",
 ];
 
 export const builtinPlugPaths = builtinPlugNames.map(