mulmoclaude 0.9.0 → 0.9.2

package/src/lib/wiki-page/index-parse.ts

@@ -1,221 +0,0 @@
-// Pure parsers for `data/wiki/index.md` content. Used by:
-//   - server/api/routes/wiki.ts — page resolver + lint
-//   - frontend lint preview (future) — same parser, no fork
-//
-// All exports here are pure string ops; no `node:*` imports allowed.
-// If a future caller needs to walk the filesystem, that wrapper goes
-// in a sibling Node-only file (today nothing under `src/lib/wiki-page/`
-// touches disk except `paths.ts`).
-
-import { parseWikiLink } from "./link.js";
-import { wikiSlugify } from "./slug.js";
-
-export interface WikiPageEntry {
-  title: string;
-  slug: string;
-  description: string;
-  tags: string[];
-}
-
-// ── Patterns ──────────────────────────────────────────────────
-// Bullet patterns live here (not server/utils/regex.ts) because the
-// index parser is the only consumer and the regexes are part of the
-// public surface that callers may want to reason about in tests.
-// Linear in line length: every `[^x]+` runs over a fixed exclusion
-// set with a hard delimiter; the optional summary group's `(.*)` is
-// a single greedy run with no nested overlap.
-
-// eslint-disable-next-line security/detect-unsafe-regex -- bullet-link parser; bounded captures with hard delimiters
-export const BULLET_LINK_PATTERN = /^[-*]\s+\[([^\]]+)\]\(([^)]*)\)(?:\s*[—–-]\s*(.*))?/;
-// eslint-disable-next-line security/detect-unsafe-regex -- same shape as BULLET_LINK_PATTERN
-export const BULLET_WIKI_LINK_PATTERN = /^[-*]\s+\[\[([^\]]+)\]\](?:\s*[—–-]\s*(.*))?/;
-
-const TABLE_SEPARATOR_PATTERN = /^\|[\s|:-]+\|$/;
-
-// Unicode-aware tag body: any letter or number in any script (so
-// Japanese / Chinese / Korean tags like `#クラウド` or `#可視化` work),
-// plus `-` and `_` as internal joiners. First char is a letter or
-// number only — no leading punctuation.
-const HASHTAG_PATTERN = /(?:^|\s)#([\p{L}\p{N}][\p{L}\p{N}_-]*)/gu;
-
-// ── Tag extraction ────────────────────────────────────────────
-
-/** Extract `#tag` tokens from a bullet description, returning the
- *  stripped description and a sorted, deduped, lowercased tag list.
- *  Only matches at word boundaries so mid-word `#` (e.g. anchor
- *  URLs) is left alone. */
-export function extractHashTags(text: string): { description: string; tags: string[] } {
-  const tags: string[] = [];
-  HASHTAG_PATTERN.lastIndex = 0;
-  let match: RegExpExecArray | null;
-  while ((match = HASHTAG_PATTERN.exec(text)) !== null) {
-    tags.push(match[1].toLowerCase());
-  }
-  const description = text.replace(HASHTAG_PATTERN, "").replace(/\s+/g, " ").trim();
-  const deduped = [...new Set(tags)].sort();
-  return { description, tags: deduped };
-}
-
-/** Split a table Tags cell — tolerates comma, whitespace, or `#`
- *  prefixes. Empty cell yields an empty list. */
-export function parseTagsCell(cell: string): string[] {
-  const tokens = cell
-    .split(/[,\s]+/)
-    .map((token) => token.trim().replace(/^#/, "").toLowerCase())
-    .filter((token) => token.length > 0);
-  return [...new Set(tokens)].sort();
-}
-
-// ── Table parser ──────────────────────────────────────────────
-
-/** Map header cell names → column indices, case- and whitespace-
- *  tolerant. Used by the row parser to locate the Tags column (and
- *  any other named column) without assuming a fixed position, so
- *  older 3- and 4-column tables keep working. */
-export function buildTableColumnMap(headerRow: string): Map<string, number> {
-  const cells = headerRow
-    .split("|")
-    .slice(1, -1)
-    // Mirror parseTableRow's cell-normalising: strip the surrounding
-    // backticks that commonly wrap cell values in wiki tables.
-    // Without this, a `| \`tags\` |` header maps to the key "`tags`"
-    // and the subsequent `columnMap.get("tags")` lookup silently
-    // misses the column, falling back to `tags: []`.
-    .map((cell) => cell.trim().replace(/^`|`$/g, "").toLowerCase());
-  const map = new Map<string, number>();
-  cells.forEach((cell, i) => {
-    if (cell) map.set(cell, i);
-  });
-  return map;
-}
-
-interface TableColumnIndices {
-  slug: number;
-  title: number;
-  summary: number;
-  /** Undefined when the table has no `tags` column — caller skips
-   *  the tags lookup entirely and the row gets `tags: []`. */
-  tags: number | undefined;
-}
-
-/** Resolve the per-column indices the row parser needs. Falls back
- *  to positional defaults (0/1/2) when the table has no header map.
- *  "summary" is the canonical column name; "description" is accepted
- *  as a legacy alias used by older fixtures. */
-function resolveTableColumnIndices(columnMap: Map<string, number> | null): TableColumnIndices {
-  return {
-    slug: columnMap?.get("slug") ?? 0,
-    title: columnMap?.get("title") ?? 1,
-    summary: columnMap?.get("summary") ?? columnMap?.get("description") ?? 2,
-    tags: columnMap?.get("tags"),
-  };
-}
-
-function parseTableRow(trimmed: string, columnMap: Map<string, number> | null): WikiPageEntry | null {
-  const cols = trimmed
-    .split("|")
-    .slice(1, -1)
-    .map((column) => column.trim().replace(/^`|`$/g, ""));
-  if (cols.length < 2) return null;
-
-  const idx = resolveTableColumnIndices(columnMap);
-  const slug = cols[idx.slug] ?? "";
-  const title = cols[idx.title] || slug;
-  if (!slug || !title) return null;
-
-  const description = cols[idx.summary] ?? "";
-  const tags = idx.tags !== undefined ? parseTagsCell(cols[idx.tags] ?? "") : [];
-  return { title, slug, description, tags };
-}
-
-// ── Bullet-row parsers ────────────────────────────────────────
-
-/** Extract the slug segment from a bullet link's href. Accepts the
- *  canonical `pages/<slug>.md`, a bare `<slug>.md`, or just `<slug>`
- *  — the three forms produced by different historical writers of
- *  index.md. Returns "" for hrefs that don't look like a wiki page
- *  reference (e.g. `https://example.com`) so the caller can fall
- *  back to title-based slugification. */
-export function extractSlugFromBulletHref(rawHref: string): string {
-  const href = rawHref.trim();
-  if (!href) return "";
-  if (/^[a-z]+:\/\//i.test(href)) return "";
-  const lastSegment = href.split("/").pop() ?? href;
-  return lastSegment.replace(/\.md$/i, "");
-}
-
-function parseBulletLinkRow(trimmed: string): WikiPageEntry | null {
-  const match = BULLET_LINK_PATTERN.exec(trimmed);
-  if (!match) return null;
-  const title = match[1].trim();
-  const href = match[2] ?? "";
-  const raw = match[3]?.trim() ?? "";
-  const { description, tags } = extractHashTags(raw);
-  // Prefer the slug embedded in the href so non-ASCII titles keep
-  // a navigable slug. Fall back to slugifying the title only when
-  // the href has no recognisable slug (rare — usually means the
-  // author put an external URL here).
-  const slug = extractSlugFromBulletHref(href) || wikiSlugify(title);
-  return { title, slug, description, tags };
-}
-
-function parseBulletWikiLinkRow(trimmed: string): WikiPageEntry | null {
-  const match = BULLET_WIKI_LINK_PATTERN.exec(trimmed);
-  if (!match) return null;
-  // Split `[[target|display]]` so the bullet entry's slug derives
-  // from the TARGET (which is already a slug-shaped identifier
-  // when the author wrote the alias form) and the title shows
-  // the DISPLAY half. Pre-#1297 the parser slugified the full
-  // `target|display` body, which collapses `|` to "" and
-  // produces a wrong slug — Codex review on PR #1312.
-  const { target, display } = parseWikiLink(match[1]);
-  const title = (display || target).trim();
-  const slug = target ? wikiSlugify(target) : wikiSlugify(title);
-  const raw = match[2]?.trim() ?? "";
-  const { description, tags } = extractHashTags(raw);
-  return { title, slug, description, tags };
-}
-
-// ── Top-level parser ──────────────────────────────────────────
-
-/** Parse entries from index.md. Supports three formats:
- *  1. Table: `| slug | Title | Summary | (Tags) |`
- *  2. Bullet link: `- [Title](pages/slug.md) — description`
- *  3. Wiki link: `- [[Title]] — description`
- *
- *  Returns entries in source order. Any unrecognised line is
- *  silently skipped — index.md is freeform markdown otherwise. */
-export function parseIndexEntries(content: string): WikiPageEntry[] {
-  const entries: WikiPageEntry[] = [];
-  let inTable = false;
-  let columnMap: Map<string, number> | null = null;
-
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-
-    if (trimmed.startsWith("|")) {
-      if (TABLE_SEPARATOR_PATTERN.test(trimmed)) {
-        inTable = true;
-        continue;
-      }
-      if (!inTable) {
-        // First `|`-line before the separator is the header. Capture
-        // the column map so parseTableRow can locate the Tags
-        // column (if any) by name rather than position.
-        columnMap = buildTableColumnMap(trimmed);
-        inTable = true;
-        continue;
-      }
-      const entry = parseTableRow(trimmed, columnMap);
-      if (entry) entries.push(entry);
-      continue;
-    }
-
-    inTable = false;
-    columnMap = null;
-
-    const bullet = parseBulletLinkRow(trimmed) ?? parseBulletWikiLinkRow(trimmed);
-    if (bullet) entries.push(bullet);
-  }
-  return entries;
-}

package/src/lib/wiki-page/link.ts

@@ -1,62 +0,0 @@
-// Pure helpers for `[[wiki-link]]` syntax. Used by the lint
-// (`server/api/routes/wiki.ts`), the page resolver, and the
-// frontend renderer (`src/plugins/wiki/helpers.ts`) — before this
-// module the three sites each had their own implementation and
-// none of them handled the `[[target|display]]` form, producing
-// false-positive "broken link" warnings on slug-aliased links
-// (issue #1297).
-//
-// All functions are pure string operations; safe to import from
-// browser bundles. No `node:*` imports anywhere in this file.
-
-/** Inline `[[...]]` link pattern. The capture group is the raw
- *  text between the brackets — the caller is expected to feed it
- *  through `parseWikiLink` to split off any `|display` suffix.
- *
- *  Body length is capped at 200 chars to keep the regex linear:
- *  catastrophic backtracking isn't possible (no nested
- *  alternation), but a malicious page with thousands of
- *  unmatched `[[` could still pin the CPU. 200 is well above the
- *  longest legitimate title we've seen and matches the cap the
- *  server-side `WIKI_LINK_PATTERN` constant has carried since the
- *  original implementation in #951. */
-export const WIKI_LINK_PATTERN = /\[\[([^\][\r\n]{1,200})\]\]/g;
-
-/** The structural shape of an inline `[[target|display]]` link.
- *  `target` is what the resolver / lint compares against page
- *  slugs; `display` is what the renderer shows to the user.
- *  When the user writes `[[foo]]` (no pipe), both fields hold
- *  `foo`. */
-export interface WikiLink {
-  target: string;
-  display: string;
-}
-
-/** Split the raw text inside `[[...]]` into target + display.
- *
- *  - `[[foo|Bar Baz]]` → `{ target: "foo", display: "Bar Baz" }`
- *  - `[[foo]]`         → `{ target: "foo", display: "foo" }`
- *  - `[[|empty target]]` → `{ target: "", display: "empty target" }`
- *    (caller decides whether an empty target is meaningful;
- *    typically lint flags it, renderer shows the display text raw)
- *  - `[[foo|]]`        → `{ target: "foo", display: "" }`
- *    (same — caller decides)
- *
- *  Whitespace around the pipe is preserved on the display side
- *  (so the user can write `[[foo| ある記事 ]]` and get the
- *  spacing intentionally) but TRIMMED on the target side, since
- *  a slug-comparable target with leading/trailing whitespace is
- *  always a typo.
- *
- *  Only the FIRST pipe splits. `[[a|b|c]]` becomes
- *  `{ target: "a", display: "b|c" }` so display strings can
- *  legitimately contain a literal `|`. */
-export function parseWikiLink(inner: string): WikiLink {
-  const pipeIdx = inner.indexOf("|");
-  if (pipeIdx === -1) {
-    return { target: inner, display: inner };
-  }
-  const target = inner.slice(0, pipeIdx).trim();
-  const display = inner.slice(pipeIdx + 1);
-  return { target, display };
-}

package/src/lib/wiki-page/lint.ts

@@ -1,105 +0,0 @@
-// Pure wiki lint rules.
-//
-// Each rule takes plain inputs (Sets, page-entry arrays, raw file
-// contents) so the whole pipeline can be unit-tested without
-// filesystem fixtures. The Express route at
-// `server/api/routes/wiki.ts` is a thin shell that reads the disk,
-// calls these rules, formats the result. A future frontend "lint
-// preview before save" would call the same functions over an
-// in-memory snapshot.
-
-import type { WikiPageEntry } from "./index-parse.js";
-import { WIKI_LINK_PATTERN, parseWikiLink } from "./link.js";
-import { wikiSlugify } from "./slug.js";
-
-/** Files on disk that aren't referenced by index.md. */
-export function findOrphanPages(fileSlugs: ReadonlySet<string>, indexedSlugs: ReadonlySet<string>): string[] {
-  const issues: string[] = [];
-  for (const slug of fileSlugs) {
-    if (!indexedSlugs.has(slug)) {
-      issues.push(`- **Orphan page**: \`${slug}.md\` exists but is missing from index.md`);
-    }
-  }
-  return issues;
-}
-
-/** Slugs referenced by index.md that have no corresponding file. */
-export function findMissingFiles(pageEntries: readonly WikiPageEntry[], fileSlugs: ReadonlySet<string>): string[] {
-  const issues: string[] = [];
-  for (const entry of pageEntries) {
-    if (!fileSlugs.has(entry.slug)) {
-      issues.push(`- **Missing file**: index.md references \`${entry.slug}\` but the file does not exist`);
-    }
-  }
-  return issues;
-}
-
-/** Walk a page's body for `[[…]]` links and flag any whose
- *  resolved slug doesn't exist in the file set.
- *
- *  Critically: this routes through `parseWikiLink` so
- *  `[[slug|display]]` is split correctly — the lint slugifies the
- *  TARGET, not the full bracket body. Pre-#1297 the lint
- *  slugified the entire content (`slug|display`), which collapsed
- *  to a slug that always missed and produced ~168 false-positive
- *  "broken link" warnings. */
-export function findBrokenLinksInPage(fileName: string, content: string, fileSlugs: ReadonlySet<string>): string[] {
-  const issues: string[] = [];
-  const matches = [...content.matchAll(WIKI_LINK_PATTERN)];
-  for (const match of matches) {
-    const { target } = parseWikiLink(match[1]);
-    const linkSlug = wikiSlugify(target);
-    // Empty target is its own diagnostic — `[[|display]]` or
-    // `[[]]` slugifies to "" and would otherwise be flagged
-    // identically to a real broken link. Keep the original raw
-    // bracket body in the report so the user can grep their pages
-    // for the malformed link.
-    if (linkSlug.length === 0) {
-      issues.push(`- **Broken link** in \`${fileName}\`: [[${match[1]}]] → empty target`);
-      continue;
-    }
-    if (!fileSlugs.has(linkSlug)) {
-      issues.push(`- **Broken link** in \`${fileName}\`: [[${match[1]}]] → \`${linkSlug}.md\` not found`);
-    }
-  }
-  return issues;
-}
-
-function formatTagList(tags: readonly string[]): string {
-  return `[${[...tags].sort().join(", ")}]`;
-}
-
-/** Flag any slug whose index.md tags differ from the page's own
- *  frontmatter `tags:` field. Comparison is set-based and order-
- *  insensitive; both sides are lowercased at parse time. Slugs
- *  missing from `frontmatterTagsBySlug` are ignored here — the
- *  missing file itself is already reported by `findMissingFiles`. */
-export function findTagDrift(pageEntries: readonly WikiPageEntry[], frontmatterTagsBySlug: ReadonlyMap<string, readonly string[]>): string[] {
-  const issues: string[] = [];
-  for (const entry of pageEntries) {
-    // Lowercase on lookup — the caller keys the map with
-    // lowercased slugs, so a `MyPage.md` filename still matches
-    // an `entry.slug` of `mypage` produced by `wikiSlugify` on the
-    // wiki-link parser path.
-    const pageTags = frontmatterTagsBySlug.get(entry.slug.toLowerCase());
-    if (pageTags === undefined) continue;
-    const pageSet = new Set(pageTags);
-    const indexSet = new Set(entry.tags);
-    if (pageSet.size !== indexSet.size || [...pageSet].some((tag) => !indexSet.has(tag))) {
-      issues.push(`- **Tag drift**: \`${entry.slug}.md\` frontmatter has ${formatTagList(pageTags)} but index.md has ${formatTagList(entry.tags)}`);
-    }
-  }
-  return issues;
-}
-
-/** Render the final markdown report from the accumulated issues
- *  list. Empty input yields the "wiki is healthy" sentinel so the
- *  caller can write the same file every time without branching on
- *  presence. */
-export function formatLintReport(issues: readonly string[]): string {
-  if (issues.length === 0) {
-    return "# Wiki Lint Report\n\n✓ No issues found. Wiki is healthy.";
-  }
-  const noun = `issue${issues.length !== 1 ? "s" : ""}`;
-  return `# Wiki Lint Report\n\n${issues.length} ${noun} found:\n\n${issues.join("\n")}`;
-}

package/src/lib/wiki-page/paths.ts

@@ -1,35 +0,0 @@
-// Node-only wiki-page helpers — anything that needs `node:path`
-// lives here so the rest of `src/lib/wiki-page/` stays pure
-// (string-only, importable from both browser and Node bundles).
-// Frontend code MUST NOT import this file directly; use the pure
-// modules instead.
-
-import path from "node:path";
-import { isSafeSlug } from "./slug.js";
-
-/** Given an absolute path and the absolute `pagesDir`, return the
- *  slug if `absPath` is a direct `.md` child of `pagesDir`, else
- *  null. Pure path-string math — no fs IO, no symlink resolution.
- *
- *  Caller responsibility: pass already-realpath'd values for both
- *  arguments. Mixing a realpath'd `absPath` with a symlinked
- *  `pagesDir` (or vice versa) silently mismatches because
- *  `path.relative` is plain string arithmetic. The trap caused
- *  #883 review-iter-1 — a symlinked workspace silently routed
- *  wiki writes through the generic writer. */
-export function wikiSlugFromAbsPath(absPath: string, pagesDir: string): string | null {
-  const rel = path.relative(pagesDir, absPath);
-  if (rel.length === 0) return null;
-  if (path.isAbsolute(rel)) return null;
-  // Direct child only — no nested layout today. Any separator
-  // means the path either escapes (`../secret.md`) or descends
-  // (`subdir/foo.md`). A literal page name like `..foo.md` is a
-  // single segment without a separator and is allowed (codex
-  // iter-3 #883 — the prior `startsWith("..")` rule wrongly
-  // rejected it).
-  if (rel.includes(path.sep)) return null;
-  if (!rel.endsWith(".md")) return null;
-  const slug = rel.slice(0, -".md".length);
-  if (!isSafeSlug(slug)) return null;
-  return slug;
-}

package/src/lib/wiki-page/slug.ts

@@ -1,54 +0,0 @@
-// Pure wiki-page slug helpers — string-only, no Node / browser
-// dependencies, importable from any bundle.
-//
-// Used by:
-//   - server/workspace/wiki-pages/io.ts (the write chokepoint)
-//   - server/workspace/hooks/handlers/wikiSnapshot.ts (the
-//     PostToolUse handler that fires on Write/Edit of a wiki page)
-//   - server/api/routes/wiki.ts (page resolver + lint)
-//   - server/api/routes/wiki/history.ts (history slug guard)
-//   - src/plugins/wiki/route.ts (router slug guard — replaces the
-//     local `isSafeWikiSlug` duplicate that existed before the
-//     pure-lib refactor)
-//   - src/plugins/wiki/helpers.ts (renderer slugify for [[…]] links)
-//
-// Any helper that needs `node:path` lives in `./paths.ts` so that
-// importing this file from frontend code never pulls in Node
-// builtins.
-
-/** Reject slugs that would escape `data/wiki/pages/` once
- *  joined back into a path, or that are otherwise invalid as
- *  page filenames. The chokepoint must defend itself even when
- *  callers derive the slug from a trusted source — a typo or
- *  future caller mistake should fail loud, not silently write
- *  outside the wiki tree.
- *
- *  The rule is intentionally narrow — separators / `..` / NUL /
- *  empty — so it only rejects unambiguous violations. Aesthetic
- *  concerns (e.g. dot-prefixed filenames) are out of scope: a
- *  pre-existing `data/wiki/pages/.foo.md` should remain writable
- *  through the chokepoint (codex review iter-2 #883). */
-export function isSafeSlug(slug: string): boolean {
-  if (slug.length === 0) return false;
-  if (slug === "." || slug === "..") return false;
-  if (slug.includes("/") || slug.includes("\\")) return false;
-  if (slug.includes("\0")) return false;
-  return true;
-}
-
-/** Slug rules for `[[wiki link]]` text → slug derivation:
- *  lowercase, spaces collapsed to hyphens, every non-ASCII /
- *  non-alphanumeric / non-hyphen character stripped.
- *
- *  Pure: no normalisation, no transliteration — this is the
- *  same shape the index parser, page resolver, and frontend
- *  renderer all need to agree on. Non-ASCII titles (e.g.
- *  Japanese) collapse to an empty string here; callers fall back
- *  to other strategies (title-match in the index, or the agent
- *  pre-resolving to a slug-form target via `[[slug|display]]`). */
-export function wikiSlugify(text: string): string {
-  return text
-    .toLowerCase()
-    .replace(/\s+/g, "-")
-    .replace(/[^a-z0-9-]/g, "");
-}

package/src/plugins/accounting/Preview.vue

@@ -1,103 +0,0 @@
-<template>
-  <!-- Compact inline summary for non-openBook tool results. The
-       openBook envelope routes to View.vue (full app) instead of
-       this component; everything that lands here is a
-       compact-result action (addEntries, getReport, …). -->
-  <div class="text-sm text-gray-700" data-testid="accounting-preview">
-    <span class="material-icons text-base align-middle mr-1">account_balance</span>
-    <span>{{ summary }}</span>
-  </div>
-</template>
-
-<script setup lang="ts">
-import { computed } from "vue";
-import { useI18n } from "vue-i18n";
-import { formatAmountNumeric } from "./currencies";
-
-const { t } = useI18n();
-
-const props = defineProps<{ data?: unknown; jsonData?: Record<string, unknown> }>();
-
-interface BalanceSheetSection {
-  type: string;
-  total?: number;
-}
-interface BalanceSheetLike {
-  balanceSheet?: { asOf?: string; sections?: BalanceSheetSection[]; imbalance?: number };
-}
-interface ProfitLossLike {
-  profitLoss?: { from?: string; to?: string; netIncome?: number };
-}
-interface EntriesLike {
-  entries?: { id?: string; date?: string }[];
-}
-interface BookLike {
-  book?: { id?: string; name?: string };
-}
-
-// Each summarise* helper returns null when its branch doesn't apply,
-// keeping the dispatch in `summary` linear (no nested if-trees).
-
-function summariseError(json: Record<string, unknown>): string | null {
-  const { error } = json as { error?: unknown };
-  if (typeof error !== "string") return null;
-  return t("pluginAccounting.previewError", { error });
-}
-
-function summariseEntry(json: Record<string, unknown>): string | null {
-  // addEntries returns `{ entries: [...] }`. The compact preview
-  // card shows one date — use the first entry's so single-entry
-  // batches (the common case from the manual UI) read naturally
-  // and multi-entry batches still anchor to a meaningful date.
-  const { entries } = json as EntriesLike;
-  if (!Array.isArray(entries) || entries.length === 0) return null;
-  const [first] = entries;
-  if (!first?.id || !first?.date) return null;
-  return t("pluginAccounting.preview.entry", { date: first.date });
-}
-
-function summarisePl(json: Record<string, unknown>): string | null {
-  const { profitLoss } = json as ProfitLossLike;
-  if (!profitLoss || typeof profitLoss.netIncome !== "number") return null;
-  return t("pluginAccounting.preview.pl", {
-    from: profitLoss.from ?? "?",
-    to: profitLoss.to ?? "?",
-    net: formatAmountNumeric(profitLoss.netIncome),
-  });
-}
-
-function summariseBs(json: Record<string, unknown>): string | null {
-  const { balanceSheet } = json as BalanceSheetLike;
-  if (!balanceSheet?.asOf || !balanceSheet.sections) return null;
-  const assets = balanceSheet.sections.find((section) => section.type === "asset");
-  return t("pluginAccounting.preview.bs", {
-    date: balanceSheet.asOf,
-    assets: assets ? formatAmountNumeric(assets.total ?? 0) : "?",
-  });
-}
-
-function summariseBook(json: Record<string, unknown>): string | null {
-  const { book } = json as BookLike;
-  if (!book?.id || !book?.name) return null;
-  return t("pluginAccounting.preview.bookCreated", { name: book.name, id: book.id });
-}
-
-function summariseFallback(json: Record<string, unknown>): string {
-  const { bookId } = json as { bookId?: unknown };
-  if (typeof bookId === "string") return t("pluginAccounting.previewSummary", { bookId });
-  return t("pluginAccounting.previewGeneric");
-}
-
-function asObject(value: unknown): Record<string, unknown> {
-  // Some renderers pass the structured payload via `data`, others
-  // via `jsonData`. Accept either so a tool-result like
-  // `{ entry: ... }` resolves to the right summariser regardless
-  // of which prop the host harness picks.
-  return value && typeof value === "object" ? (value as Record<string, unknown>) : {};
-}
-
-const summary = computed<string>(() => {
-  const json = { ...asObject(props.data), ...asObject(props.jsonData) };
-  return summariseError(json) ?? summariseEntry(json) ?? summarisePl(json) ?? summariseBs(json) ?? summariseBook(json) ?? summariseFallback(json);
-});
-</script>