paseo-bm-plugin 0.0.0-placeholder.0

package/client/markdown.ts

@@ -0,0 +1,145 @@
+/**
+ * A small Markdown reader for bead descriptions.
+ *
+ * Plugins may only use React Native primitives, so there is no Markdown
+ * library to lean on. Bead descriptions use a narrow subset — headings,
+ * lists, task boxes, code blocks, quotes, tables and inline `code` / **bold** —
+ * and this turns exactly that into blocks a renderer can draw. Anything else
+ * stays a plain paragraph, so nothing is ever lost.
+ *
+ * Pure: no React, no React Native.
+ */
+
+export type Inline = { text: string; bold?: boolean; code?: boolean; italic?: boolean };
+
+export type MarkdownBlock =
+  | { kind: "heading"; level: number; spans: Inline[] }
+  | { kind: "paragraph"; spans: Inline[] }
+  | { kind: "bullet"; depth: number; spans: Inline[]; checked?: boolean }
+  | { kind: "numbered"; depth: number; number: string; spans: Inline[] }
+  | { kind: "quote"; spans: Inline[] }
+  | { kind: "code"; language: string | null; text: string }
+  | { kind: "table"; header: string[]; rows: string[][] }
+  | { kind: "rule" };
+
+/** `**bold**`, `*italic*`, `` `code` `` — no nesting, which bead text never needs. */
+export function parseInline(text: string): Inline[] {
+  const spans: Inline[] = [];
+  const pattern = /(`[^`]+`|\*\*[^*]+\*\*|__[^_]+__|\*[^*\s][^*]*\*)/g;
+  let last = 0;
+  for (const match of text.matchAll(pattern)) {
+    const index = match.index ?? 0;
+    if (index > last) spans.push({ text: text.slice(last, index) });
+    const token = match[0];
+    if (token.startsWith("`")) spans.push({ text: token.slice(1, -1), code: true });
+    else if (token.startsWith("**") || token.startsWith("__")) spans.push({ text: token.slice(2, -2), bold: true });
+    else spans.push({ text: token.slice(1, -1), italic: true });
+    last = index + token.length;
+  }
+  if (last < text.length) spans.push({ text: text.slice(last) });
+  return spans.length === 0 ? [{ text: "" }] : spans;
+}
+
+const cells = (line: string) =>
+  line
+    .trim()
+    .replace(/^\|/, "")
+    .replace(/\|$/, "")
+    .split("|")
+    .map((cell) => cell.trim());
+
+export function parseMarkdown(source: string): MarkdownBlock[] {
+  const lines = source.replace(/\r\n/g, "\n").split("\n");
+  const blocks: MarkdownBlock[] = [];
+  let paragraph: string[] = [];
+  const flush = () => {
+    if (paragraph.length > 0) blocks.push({ kind: "paragraph", spans: parseInline(paragraph.join(" ")) });
+    paragraph = [];
+  };
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index]!;
+
+    const fence = /^\s*```\s*([\w-]*)\s*$/.exec(line);
+    if (fence !== null) {
+      flush();
+      const body: string[] = [];
+      index += 1;
+      while (index < lines.length && !/^\s*```\s*$/.test(lines[index]!)) {
+        body.push(lines[index]!);
+        index += 1;
+      }
+      blocks.push({ kind: "code", language: fence[1] === "" ? null : fence[1]!, text: body.join("\n") });
+      continue;
+    }
+
+    if (line.trim() === "") {
+      flush();
+      continue;
+    }
+
+    const heading = /^(#{1,6})\s+(.*)$/.exec(line);
+    if (heading !== null) {
+      flush();
+      blocks.push({ kind: "heading", level: heading[1]!.length, spans: parseInline(heading[2]!.trim()) });
+      continue;
+    }
+
+    if (/^\s*([-*_])(\s*\1){2,}\s*$/.test(line)) {
+      flush();
+      blocks.push({ kind: "rule" });
+      continue;
+    }
+
+    const next = lines[index + 1];
+    if (line.includes("|") && next !== undefined && /^\s*\|?\s*:?-{2,}/.test(next)) {
+      flush();
+      const header = cells(line);
+      const rows: string[][] = [];
+      index += 2;
+      while (index < lines.length && lines[index]!.includes("|") && lines[index]!.trim() !== "") {
+        rows.push(cells(lines[index]!));
+        index += 1;
+      }
+      index -= 1;
+      blocks.push({ kind: "table", header, rows });
+      continue;
+    }
+
+    const bullet = /^(\s*)[-*+]\s+(?:\[([ xX])\]\s+)?(.*)$/.exec(line);
+    if (bullet !== null) {
+      flush();
+      const block: MarkdownBlock = {
+        kind: "bullet",
+        depth: Math.floor(bullet[1]!.length / 2),
+        spans: parseInline(bullet[3]!),
+      };
+      if (bullet[2] !== undefined) block.checked = bullet[2].toLowerCase() === "x";
+      blocks.push(block);
+      continue;
+    }
+
+    const numbered = /^(\s*)(\d+)[.)]\s+(.*)$/.exec(line);
+    if (numbered !== null) {
+      flush();
+      blocks.push({
+        kind: "numbered",
+        depth: Math.floor(numbered[1]!.length / 2),
+        number: numbered[2]!,
+        spans: parseInline(numbered[3]!),
+      });
+      continue;
+    }
+
+    const quote = /^\s*>\s?(.*)$/.exec(line);
+    if (quote !== null) {
+      flush();
+      blocks.push({ kind: "quote", spans: parseInline(quote[1]!) });
+      continue;
+    }
+
+    paragraph.push(line.trim());
+  }
+  flush();
+  return blocks;
+}

package/client/settings.tsx

@@ -0,0 +1,104 @@
+/**
+ * Plugin settings screen: the trace-store warning threshold
+ * (WP-211.2.1; REQ-055d, REQ-055e, REQ-055f).
+ *
+ * Paseo owns the storage and the revision handling through `useSettings`, so
+ * this screen only edits one number. Two things it must say out loud: the
+ * threshold is machine-wide (Paseo has no per-workspace settings), and an
+ * invalid value leaves the previous one in force.
+ *
+ * Client rules: React Native primitives only, colours from `theme.colors`, no
+ * Node import, no `server/` import.
+ */
+import { type PluginSurfaceProps, useSettings } from "@getpaseo/plugin/client";
+import { useMemo, useState } from "react";
+import { Pressable, ScrollView, Text, TextInput, View } from "react-native";
+import {
+  DEFAULT_WARN_ABOVE_BYTES,
+  dashboardSettings,
+} from "../shared/settings";
+import { HOST_SCOPE_NOTICE, dashboardStyles, formatBytes, toneColor } from "./dashboard-model";
+
+/** Settings screen id, used by `openSettings` from the Dashboard. */
+export const SETTINGS_SCREEN_ID = "paseo-bm-settings";
+export const SETTINGS_ICON = "Settings";
+
+const MEGABYTE = 1024 * 1024;
+
+export function DashboardSettingsScreen({ theme, layout }: PluginSurfaceProps) {
+  const styles = useMemo(() => dashboardStyles(theme, layout.compact), [theme, layout.compact]);
+  const settings = useSettings(dashboardSettings);
+  const [draft, setDraft] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  const current =
+    settings.status === "ready" ? settings.values.warnAboveBytes : DEFAULT_WARN_ABOVE_BYTES;
+  const shown = draft ?? String(Math.round(current / MEGABYTE));
+
+  const save = async () => {
+    if (settings.status !== "ready") return;
+    const megabytes = Number.parseInt(shown, 10);
+    if (!Number.isFinite(megabytes) || megabytes <= 0) {
+      // REQ-055f: refuse, and leave the stored threshold in force.
+      setError(`"${shown}" is not a size in MB. The current threshold stays at ${formatBytes(current)}.`);
+      return;
+    }
+    setError(null);
+    const saved = await settings.save({ warnAboveBytes: megabytes * MEGABYTE }, settings.revision);
+    if (!saved) setError(settings.saveError ?? "Could not save the setting.");
+    else setDraft(null);
+  };
+
+  return (
+    <ScrollView style={styles.screen} contentContainerStyle={styles.content}>
+      <Text style={styles.title}>Beads Dashboard</Text>
+      <Text style={styles.sectionTitle}>Trace store warning</Text>
+      <Text style={styles.body}>
+        The Dashboard warns when paseo-bm&apos;s trace store grows past this size. It never deletes
+        anything on its own. {HOST_SCOPE_NOTICE}
+      </Text>
+
+      <View style={styles.card}>
+        <Text style={styles.body}>Warn above (MB)</Text>
+        <TextInput
+          accessibilityLabel="Warn above, in megabytes"
+          keyboardType="number-pad"
+          value={shown}
+          onChangeText={(next) => setDraft(next)}
+          style={[styles.mono, { borderColor: theme.colors.border, borderWidth: 1, borderRadius: 8, padding: 8 }]}
+        />
+        <Text style={styles.body}>{`Currently ${formatBytes(current)}.`}</Text>
+        {error !== null ? (
+          <Text style={[styles.body, { color: toneColor(theme, "danger") }]}>{error}</Text>
+        ) : null}
+        {settings.status === "error" ? (
+          <Text style={[styles.body, { color: toneColor(theme, "danger") }]}>{settings.error}</Text>
+        ) : null}
+        <Pressable
+          accessibilityRole="button"
+          accessibilityLabel="Save the warning threshold"
+          accessibilityState={{ disabled: settings.saving }}
+          disabled={settings.saving}
+          onPress={() => {
+            void save();
+          }}
+          style={[styles.button, settings.saving ? { opacity: 0.5 } : null]}
+        >
+          <Text style={styles.buttonText}>{settings.saving ? "Saving…" : "Save"}</Text>
+        </Pressable>
+        <Pressable
+          accessibilityRole="button"
+          accessibilityLabel="Reset the warning threshold to the default"
+          onPress={() => {
+            setDraft(null);
+            setError(null);
+            void settings.reset();
+          }}
+          style={styles.secondaryButton}
+        >
+          <Text style={styles.secondaryButtonText}>{`Reset to ${formatBytes(DEFAULT_WARN_ABOVE_BYTES)}`}</Text>
+        </Pressable>
+      </View>
+    </ScrollView>
+  );
+}