mulmoclaude 0.9.0 → 0.9.2

package/server/workspace/feeds/index.ts

@@ -1,8 +0,0 @@
-// Public surface of the Feeds module. Routes + the scheduler import
-// from here.
-
-export { listFeeds, removeFeed } from "./registry.js";
-export { refreshOne, refreshDue, type RefreshResult } from "./engine.js";
-export { feedsRoot, feedDir, feedStatePath, FEEDS_DIR } from "./paths.js";
-export { readFeedState, type FeedState } from "./state.js";
-export { INGEST_KINDS, FEED_SCHEDULES, isFeedSchedule, type IngestSpec, type IngestKind, type FeedSchedule } from "./ingestTypes.js";

package/server/workspace/feeds/ingestTypes.ts

@@ -1,62 +0,0 @@
-// Declarative retrieval config for the "Feeds" mechanism. A Feed is a
-// CollectionSchema plus this `ingest` block, registered as data (NOT as
-// a skill) under `<workspace>/feeds/<slug>/schema.json`. The host's
-// retrieval engine reads it to periodically refill the collection's
-// records via the shared collections io layer.
-//
-// The ingest vocab (INGEST_KINDS / FEED_SCHEDULES + their literal-union types)
-// now lives in @mulmoclaude/collection-plugin alongside the schema contract, so
-// the package's schema validator can enforce it. Re-exported here so the feeds
-// engine's existing importers resolve them unchanged.
-import { type CollectionIngest, INGEST_KINDS, FEED_SCHEDULES, type IngestKind, type FeedSchedule } from "@mulmoclaude/collection-plugin";
-//
-// Declarative-only for now; the `kind` enum reserves room for future
-// "code" (LLM-generated transform) and "prompt" (LLM-performed fetch)
-// retrievers without reshaping the engine.
-
-export { INGEST_KINDS, FEED_SCHEDULES, type IngestKind, type FeedSchedule };
-
-const FEED_SCHEDULE_SET: ReadonlySet<string> = new Set(FEED_SCHEDULES);
-
-export function isFeedSchedule(value: unknown): value is FeedSchedule {
-  return typeof value === "string" && FEED_SCHEDULE_SET.has(value);
-}
-
-/** Default cap on stored records per feed when `ingest.maxItems` is
- *  omitted. Keeps high-volume feeds (news / podcasts) bounded. */
-export const DEFAULT_FEED_MAX_ITEMS = 100;
-
-/** Declarative field map: target collection field name → source path
- *  into the raw item (dot/bracket path, e.g. `"title"` or
- *  `"data.name"`). */
-export type IngestFieldMap = Record<string, string>;
-
-/** The `ingest` block carried on a Feed's `CollectionSchema`. The canonical
- *  schema (in @mulmoclaude/collection-plugin) only promises the minimal
- *  `CollectionIngest` (kind/url/schedule as plain strings); this feeds-only
- *  subtype narrows those + adds the retrieval fields the engine needs. */
-export interface IngestSpec extends CollectionIngest {
-  /** Which retriever handles this feed. */
-  kind: IngestKind;
-  /** Endpoint to fetch (http/https). */
-  url: string;
-  /** Refresh cadence. */
-  schedule: FeedSchedule;
-  /** `http-json` only: dot/bracket path to the array of items in the
-   *  response (e.g. `"hourly[]"` or `"data.results[]"`). Ignored for
-   *  `rss`/`atom`, which yield items natively. */
-  itemsAt?: string;
-  /** target field → source path. Projects each raw item into a record
-   *  whose keys match the schema's `fields`. */
-  map: IngestFieldMap;
-  /** Optional source path used to derive the primaryKey value when the
-   *  mapped record's primaryKey is empty (e.g. `"feedId"`). Falls back
-   *  to a content hash of the record. */
-  idFrom?: string;
-  /** Cap on stored records. After each fetch the feed keeps only the
-   *  newest `maxItems` (ordered by the schema's first `date` field) and
-   *  deletes the rest. Defaults to {@link DEFAULT_FEED_MAX_ITEMS} when
-   *  omitted; `0` disables the cap (keep everything). Pruning is skipped
-   *  when the schema has no `date` field to order by. */
-  maxItems?: number;
-}

package/server/workspace/feeds/pathResolver.ts

@@ -1,74 +0,0 @@
-// Tiny dot/bracket path resolver used by the declarative `ingest.map`
-// and `ingest.itemsAt`. Pure, no I/O, exhaustively unit-testable.
-//
-// Supported syntax:
-//   "title"                → root.title
-//   "data.name"            → root.data.name
-//   "results[0].id"        → root.results[0].id
-//   "hourly[]"             → root.hourly        (trailing [] = "the array
-//                            here"; the marker is a no-op for value reads)
-//   "data.results[]"       → root.data.results
-//
-// Any miss (wrong type, out-of-range index, absent key) yields
-// `undefined` rather than throwing — declarative configs fail soft.
-
-interface KeyToken {
-  kind: "key";
-  key: string;
-}
-interface IndexToken {
-  kind: "index";
-  index: number;
-}
-type PathToken = KeyToken | IndexToken;
-
-const BRACKET_RE = /\[(\d*)\]/g;
-
-/** Split one dot-segment (`results[0]`, `hourly[]`, `name`) into tokens.
- *  An empty `[]` is an array-identity marker and emits no token — the
- *  array value is read by the preceding key. */
-function parseSegment(segment: string, tokens: PathToken[]): void {
-  const bracketStart = segment.indexOf("[");
-  const name = bracketStart === -1 ? segment : segment.slice(0, bracketStart);
-  if (name.length > 0) tokens.push({ kind: "key", key: name });
-  if (bracketStart === -1) return;
-  for (const match of segment.slice(bracketStart).matchAll(BRACKET_RE)) {
-    const [, inner] = match;
-    if (inner.length > 0) tokens.push({ kind: "index", index: Number(inner) });
-  }
-}
-
-function tokenize(path: string): PathToken[] {
-  const tokens: PathToken[] = [];
-  for (const segment of path.split(".")) {
-    if (segment.length > 0) parseSegment(segment, tokens);
-  }
-  return tokens;
-}
-
-function step(current: unknown, token: PathToken): unknown {
-  if (current === null || current === undefined) return undefined;
-  if (token.kind === "key") {
-    if (typeof current !== "object" || Array.isArray(current)) return undefined;
-    return (current as Record<string, unknown>)[token.key];
-  }
-  return Array.isArray(current) ? current[token.index] : undefined;
-}
-
-/** Resolve a dot/bracket path against `root`, or `undefined` on any miss. */
-export function getByPath(root: unknown, path: string): unknown {
-  let current: unknown = root;
-  for (const token of tokenize(path)) {
-    current = step(current, token);
-  }
-  return current;
-}
-
-/** Locate the array of raw items for a fetch. With `itemsAt` set, walk
- *  to it; without it, the response itself must be the array. Non-arrays
- *  yield `[]` so a malformed response is a no-op, not a crash. */
-export function getItemsArray(root: unknown, itemsAt: string | undefined): unknown[] {
-  if (!itemsAt) return Array.isArray(root) ? root : [];
-  const value = getByPath(root, itemsAt);
-  return Array.isArray(value) ? value : [];
-}

package/server/workspace/feeds/paths.ts

@@ -1,30 +0,0 @@
-// Path helpers for the non-skill Feeds registry. Each feed lives at
-// `<workspace>/feeds/<slug>/schema.json` (a CollectionSchema + `ingest`
-// block) with its retrieval state alongside at
-// `<workspace>/feeds/<slug>/_state.json`. Records land wherever the
-// schema's `dataPath` points (validated by `resolveDataDir`), exactly
-// like every other collection.
-//
-// Slugs reaching these helpers must already have passed `safeSlugName`
-// (from `../collections/paths.js`) — these joins do not re-sanitize.
-
-import path from "node:path";
-import { workspacePath } from "../workspace.js";
-
-export const FEEDS_DIR = "feeds";
-export const FEED_STATE_FILE = "_state.json";
-
-/** Absolute path to the feeds registry root for a workspace. */
-export function feedsRoot(workspaceRoot: string = workspacePath): string {
-  return path.join(workspaceRoot, FEEDS_DIR);
-}
-
-/** Absolute path to one feed's directory (`<root>/<slug>/`). */
-export function feedDir(slug: string, workspaceRoot: string = workspacePath): string {
-  return path.join(feedsRoot(workspaceRoot), slug);
-}
-
-/** Absolute path to one feed's retrieval-state file. */
-export function feedStatePath(slug: string, workspaceRoot: string = workspacePath): string {
-  return path.join(feedsRoot(workspaceRoot), slug, FEED_STATE_FILE);
-}

package/server/workspace/feeds/projectItem.ts

@@ -1,92 +0,0 @@
-// Project one raw retrieved item (a parsed RSS entry, or a JSON object)
-// into a CollectionItem whose keys match the schema's fields, using the
-// declarative `ingest.map`. Also derives the record's id.
-//
-// Id rule: a collection record's filename IS its primaryKey value, and
-// that value must be a safe slug. Feed-native keys (RSS guids/URLs,
-// ISO datetimes) usually are NOT slug-safe, so we slugify the natural
-// key into a deterministic, stable id — same natural key → same id, so
-// re-fetches upsert in place. The natural key comes from the mapped
-// primaryKey value, then `ingest.idFrom`, then a content hash.
-
-import { createHash } from "node:crypto";
-import { getByPath } from "./pathResolver.js";
-import type { CollectionItem, CollectionSchema } from "../collections/index.js";
-import type { IngestSpec } from "./ingestTypes.js";
-
-function asKeyString(value: unknown): string | null {
-  if (typeof value === "string" && value.trim().length > 0) return value.trim();
-  if (typeof value === "number" && Number.isFinite(value)) return String(value);
-  return null;
-}
-
-/** Collapse an XML element object that carries body text alongside
- *  attributes (`{ "#text": "v", "@_x": "..." }`) or CDATA to its text.
- *  Generic — the host knows no field names, only this fast-xml-parser
- *  shape — so a tag like `<guid isPermaLink="false">id</guid>` maps to
- *  its text without the caller needing to write `.#text`. */
-function unwrapTextNode(value: unknown): unknown {
-  if (value && typeof value === "object" && !Array.isArray(value)) {
-    const obj = value as Record<string, unknown>;
-    if (typeof obj["#text"] === "string") return obj["#text"];
-    if (typeof obj["#cdata"] === "string") return obj["#cdata"];
-  }
-  return value;
-}
-
-/** Normalize a mapped value generically — driven by the SCHEMA's declared
- *  field type, never by the source field name. Today: unwrap XML text
- *  nodes, and coerce anything mapped into a `date` field to a `YYYY-MM-DD`
- *  civil date (the collection `date` type + calendar are day-granularity
- *  and parse strictly — a full RFC-3339 timestamp would be rejected). */
-function normalizeValue(value: unknown, fieldType: string | undefined): unknown {
-  const unwrapped = unwrapTextNode(value);
-  if (fieldType === "date" && typeof unwrapped === "string") {
-    const millis = Date.parse(unwrapped);
-    if (Number.isFinite(millis)) return new Date(millis).toISOString().slice(0, 10);
-  }
-  return unwrapped;
-}
-
-/** Slugify a natural key into a stable, filename-safe id. Short, safe
- *  keys pass through (lowercased); long or unsafe keys collapse to a
- *  hash so the filename stays bounded and valid. */
-function toSafeId(natural: string): string {
-  const collapsed = natural
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-");
-  // eslint-disable-next-line sonarjs/slow-regex -- anchored hyphen trim, linear, no catastrophic backtracking
-  const slug = collapsed.replace(/^-+|-+$/g, "");
-  if (slug.length > 0 && slug.length <= 80) return slug;
-  const hash = createHash("sha256")
-    .update(natural || "item", "utf-8")
-    .digest("hex")
-    .slice(0, 16);
-  return slug.length > 80 ? `${slug.slice(0, 60)}-${hash}` : `feed-${hash}`;
-}
-
-function naturalKey(record: CollectionItem, rawItem: unknown, ingest: IngestSpec, schema: CollectionSchema): string {
-  const fromMapped = asKeyString(record[schema.primaryKey]);
-  if (fromMapped) return fromMapped;
-  if (ingest.idFrom) {
-    const fromId = asKeyString(unwrapTextNode(getByPath(rawItem, ingest.idFrom)));
-    if (fromId) return fromId;
-  }
-  return JSON.stringify(record);
-}
-
-/** Build a record from a raw fetched item (a parsed RSS/Atom element or a
- *  JSON object) using `ingest.map`. Each source path is resolved against
- *  the raw item and normalized per the target field's declared type. The
- *  returned record's primaryKey is set to the derived safe id (so it
- *  doubles as the filename). */
-export function projectRecord(rawItem: unknown, ingest: IngestSpec, schema: CollectionSchema): CollectionItem {
-  const record: CollectionItem = {};
-  for (const [targetField, sourcePath] of Object.entries(ingest.map)) {
-    const value = normalizeValue(getByPath(rawItem, sourcePath), schema.fields?.[targetField]?.type);
-    if (value !== undefined) record[targetField] = value;
-  }
-  record[schema.primaryKey] = toSafeId(naturalKey(record, rawItem, ingest, schema));
-  return record;
-}

package/server/workspace/feeds/registry.ts

@@ -1,43 +0,0 @@
-// List the registered data-source feeds. Feeds are CREATED / REMOVED by
-// the agent writing / deleting `feeds/<slug>/schema.json` directly (see
-// config/helps/feeds.md) — the host only discovers + retrieves them.
-// icon / dataPath defaults for agent-authored feed schemas are applied in
-// `collections/discovery.ts` (source === "feed").
-
-import { rm } from "node:fs/promises";
-import { workspacePath } from "../workspace.js";
-import { log } from "../../system/logger/index.js";
-import { discoverCollections, type LoadedCollection } from "../collections/index.js";
-import { resolveDataDir, safeSlugName } from "@mulmoclaude/collection-plugin/server";
-import { feedDir } from "./paths.js";
-
-/** Every registered feed, as a discovered collection (carrying its
- *  validated schema, `ingest`, and resolved `dataDir`). */
-export async function listFeeds(workspaceRoot: string = workspacePath): Promise<LoadedCollection[]> {
-  const all = await discoverCollections({ workspaceRoot });
-  return all.filter((collection) => collection.source === "feed");
-}
-
-/** Delete a feed entirely: its records AND its `feeds/<slug>/` directory
- *  (schema + state). Idempotent. Host-side only (backs the UI delete
- *  button); the agent removes a feed by deleting both directories itself.
- *
- *  The records dir is derived from the SLUG (`data/feeds/<slug>`), never
- *  from the schema's `dataPath` — feeds are forced into that namespace at
- *  discovery, so a malformed/hostile `dataPath` can't redirect this delete
- *  at another app's data (e.g. `data/wiki`). `resolveDataDir` also rejects
- *  any path that escapes the workspace. */
-export async function removeFeed(workspaceRoot: string, slug: string): Promise<boolean> {
-  const safe = safeSlugName(slug);
-  if (safe === null) return false;
-  const recordsDir = resolveDataDir(`data/feeds/${safe}`, workspaceRoot);
-  try {
-    if (recordsDir) await rm(recordsDir, { recursive: true, force: true });
-    await rm(feedDir(safe, workspaceRoot), { recursive: true, force: true });
-    log.info("feeds", "feed + records removed", { slug: safe });
-    return true;
-  } catch (error) {
-    log.warn("feeds", "feed remove failed", { slug: safe, error: String(error) });
-    return false;
-  }
-}

package/server/workspace/feeds/retrievers/httpJson.ts

@@ -1,19 +0,0 @@
-// Generic JSON-API retriever. Fetches JSON, walks `ingest.itemsAt` to
-// the array of raw items, and projects each through `ingest.map` (whose
-// source paths are dot/bracket paths into each raw item).
-
-import { fetchJson } from "../fetch/httpClient.js";
-import { getItemsArray } from "../pathResolver.js";
-import { projectRecord } from "../projectItem.js";
-import { registerRetriever, type RetrieveFn } from "./index.js";
-
-const retrieveHttpJson: RetrieveFn = async (ingest, schema) => {
-  const json = await fetchJson(ingest.url);
-  const rawItems = getItemsArray(json, ingest.itemsAt);
-  const items = rawItems.map((raw) => projectRecord(raw, ingest, schema));
-  return { items, cursor: {} };
-};
-
-registerRetriever("http-json", retrieveHttpJson);
-
-export { retrieveHttpJson };

package/server/workspace/feeds/retrievers/index.ts

@@ -1,27 +0,0 @@
-// Pluggable retriever registry. Each `ingest.kind` maps to one
-// RetrieveFn that fetches the endpoint and returns projected records.
-// Side-effect registration keeps the engine decoupled from the kinds.
-// New kinds (`code`, `prompt`) register here without touching the engine.
-
-import type { CollectionItem, CollectionSchema } from "../../collections/index.js";
-import type { IngestSpec } from "../ingestTypes.js";
-import type { FeedState } from "../state.js";
-
-export interface RetrieveResult {
-  /** Projected records, keyed by primaryKey (the engine upserts them). */
-  items: CollectionItem[];
-  /** Updated retriever cursor to persist (incremental fetches). */
-  cursor: Record<string, string>;
-}
-
-export type RetrieveFn = (ingest: IngestSpec, schema: CollectionSchema, state: FeedState) => Promise<RetrieveResult>;
-
-const registry = new Map<string, RetrieveFn>();
-
-export function registerRetriever(kind: string, retriever: RetrieveFn): void {
-  registry.set(kind, retriever);
-}
-
-export function getRetriever(kind: string): RetrieveFn | undefined {
-  return registry.get(kind);
-}

package/server/workspace/feeds/retrievers/registerAll.ts

@@ -1,5 +0,0 @@
-// Side-effect import that registers every built-in retriever. Import
-// this once (the engine does) before dispatching on `ingest.kind`.
-
-import "./rss.js";
-import "./httpJson.js";

package/server/workspace/feeds/retrievers/rss.ts

@@ -1,24 +0,0 @@
-// RSS / Atom retriever. Fetches the feed, parses it, and projects each
-// item's RAW parsed XML element through `ingest.map`. The map's source
-// paths are the item's own tags/attributes (e.g. `title`, `pubDate`,
-// `enclosure.@_url`, `itunes:duration`) — the host hard-codes no field
-// list; the caller inspects the feed and maps what it carries.
-
-import { fetchText } from "../fetch/httpClient.js";
-import { parseFeed } from "../fetch/rssParser.js";
-import { projectRecord } from "../projectItem.js";
-import { registerRetriever, type RetrieveFn } from "./index.js";
-
-const retrieveRss: RetrieveFn = async (ingest, schema) => {
-  const body = await fetchText(ingest.url);
-  const feed = parseFeed(body);
-  if (!feed) return { items: [], cursor: {} };
-  const items = feed.items.map((item) => projectRecord(item.raw, ingest, schema));
-  return { items, cursor: {} };
-};
-
-// Atom shares the same parser + projection path.
-registerRetriever("rss", retrieveRss);
-registerRetriever("atom", retrieveRss);
-
-export { retrieveRss };

package/server/workspace/feeds/state.ts

@@ -1,55 +0,0 @@
-// Per-feed retrieval state — when we last fetched, the retriever's
-// cursor (for incremental fetches), and a consecutive-failure counter.
-// NOT committed to git; lives at `<workspace>/feeds/<slug>/_state.json`.
-// Deliberately minimal: the legacy `sources` tree carries richer backoff
-// state, but the Feeds engine starts simple and grows on real need.
-
-import { mkdir, readFile } from "node:fs/promises";
-import { writeFileAtomic } from "../../utils/files/atomic.js";
-import { log } from "../../system/logger/index.js";
-import { feedDir, feedStatePath } from "./paths.js";
-
-export interface FeedState {
-  slug: string;
-  /** ISO timestamp of the last successful fetch, or null if never. */
-  lastFetchedAt: string | null;
-  /** Free-form retriever cursor (e.g. last-seen id / etag). */
-  cursor: Record<string, string>;
-  /** Consecutive failed fetches; reset to 0 on success. */
-  consecutiveFailures: number;
-}
-
-export function defaultFeedState(slug: string): FeedState {
-  return { slug, lastFetchedAt: null, cursor: {}, consecutiveFailures: 0 };
-}
-
-function normalizeState(slug: string, parsed: Partial<FeedState>): FeedState {
-  const base = defaultFeedState(slug);
-  const cursor = parsed.cursor && typeof parsed.cursor === "object" ? (parsed.cursor as Record<string, string>) : base.cursor;
-  return {
-    slug,
-    lastFetchedAt: typeof parsed.lastFetchedAt === "string" ? parsed.lastFetchedAt : base.lastFetchedAt,
-    cursor,
-    consecutiveFailures: typeof parsed.consecutiveFailures === "number" ? parsed.consecutiveFailures : base.consecutiveFailures,
-  };
-}
-
-/** Read a feed's state, tolerating a missing file (first run → default). */
-export async function readFeedState(workspaceRoot: string, slug: string): Promise<FeedState> {
-  try {
-    const raw = await readFile(feedStatePath(slug, workspaceRoot), "utf-8");
-    return normalizeState(slug, JSON.parse(raw) as Partial<FeedState>);
-  } catch (err) {
-    const error = err as { code?: string };
-    if (error.code !== "ENOENT") {
-      log.warn("feeds", "failed to read feed state, using default", { slug, error: String(err) });
-    }
-    return defaultFeedState(slug);
-  }
-}
-
-/** Persist a feed's state atomically (creating the feed dir if needed). */
-export async function writeFeedState(workspaceRoot: string, slug: string, state: FeedState): Promise<void> {
-  await mkdir(feedDir(slug, workspaceRoot), { recursive: true });
-  await writeFileAtomic(feedStatePath(slug, workspaceRoot), `${JSON.stringify(state, null, 2)}\n`);
-}

package/src/composables/useAccountingChannel.ts

@@ -1,58 +0,0 @@
-// Subscribe to per-book accounting events.
-//
-// Returns a `version` ref that bumps every time the server publishes a
-// change for the given bookId — addEntries, voidEntry,
-// setOpeningBalances, upsertAccount, snapshot rebuild completion. View
-// components watch `version` to drive `refetch` calls.
-//
-// `bookId` is reactive: switching the active book in BookSwitcher
-// flips it; the composable unsubscribes from the old channel and
-// subscribes to the new one.
-//
-// `onPayload` is an optional fine-grained hook for callers that want to
-// inspect the event kind (e.g. show a "rebuilding…" indicator on
-// `kind: "snapshots-rebuilding"`).
-
-import { ref, watch, onUnmounted, type Ref } from "vue";
-import { usePubSub } from "./usePubSub";
-import { accountingBookChannel, PUBSUB_CHANNELS, type AccountingBookChannelPayload } from "../config/pubsubChannels";
-
-export interface UseAccountingChannelReturn {
-  /** Bumps on every accountingBookChannel event for the current
-   *  bookId. Resets to 0 when bookId changes. */
-  version: Ref<number>;
-}
-
-export function useAccountingChannel(bookId: Ref<string | null>, onPayload?: (payload: AccountingBookChannelPayload) => void): UseAccountingChannelReturn {
-  const version = ref(0);
-  const { subscribe } = usePubSub();
-  let unsubscribe: (() => void) | null = null;
-
-  function bind(nextBookId: string | null): void {
-    unsubscribe?.();
-    unsubscribe = null;
-    version.value = 0;
-    if (!nextBookId) return;
-    unsubscribe = subscribe(accountingBookChannel(nextBookId), (data) => {
-      const event = data as AccountingBookChannelPayload;
-      version.value += 1;
-      onPayload?.(event);
-    });
-  }
-
-  watch(bookId, bind, { immediate: true });
-  onUnmounted(() => {
-    unsubscribe?.();
-    unsubscribe = null;
-  });
-  return { version };
-}
-
-/** Subscribe to "the list of books changed" events. Use in
- *  BookSwitcher.vue to refetch the dropdown contents when a sibling
- *  tab adds / deletes a book. */
-export function useAccountingBooksChannel(onChange: () => void): void {
-  const { subscribe } = usePubSub();
-  const unsubscribe = subscribe(PUBSUB_CHANNELS.accountingBooks, onChange);
-  onUnmounted(() => unsubscribe());
-}

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

@@ -1,108 +0,0 @@
-// Pure builder for the wiki page→page link graph. Used by:
-//   - server/api/routes/wiki.ts — the `graph` action endpoint
-//   - src/plugins/wiki/View.vue — backlinks ("linked references") +
-//     the Graph tab
-//
-// All functions are pure string / collection ops; no `node:*` imports,
-// so the frontend bundle can import them directly (same discipline as
-// the sibling `link.ts` / `lint.ts` / `index-parse.ts` modules).
-//
-// NOTE: this is page→page link structure, distinct from the
-// `server/workspace/wiki-backlinks/` module, which appends *session*
-// backlinks (a page → the chat that edited it, #109). Different concept
-// — do not conflate.
-
-import { WIKI_LINK_PATTERN, parseWikiLink } from "./link.js";
-import { wikiSlugify } from "./slug.js";
-import type { WikiPageEntry } from "./index-parse.js";
-
-export interface WikiGraphNode {
-  slug: string;
-  title: string;
-}
-
-export interface WikiGraphEdge {
-  from: string;
-  to: string;
-}
-
-export interface WikiGraph {
-  nodes: WikiGraphNode[];
-  edges: WikiGraphEdge[];
-}
-
-/** One page's raw body plus its canonical (file-derived) slug. */
-export interface WikiPageContent {
-  slug: string;
-  content: string;
-}
-
-/** Resolve a raw `[[link]]` target to an existing page slug, or null.
- *  Mirrors the route resolver's strategy: slugify first, then fall
- *  back to matching an index entry title so non-ASCII targets like
- *  `[[さくらインターネット]]` resolve to their ASCII file slug. */
-export function resolveLinkTarget(target: string, fileSlugs: ReadonlySet<string>, slugByTitle: ReadonlyMap<string, string>): string | null {
-  const slug = wikiSlugify(target);
-  if (slug.length > 0 && fileSlugs.has(slug)) return slug;
-  const byTitle = slugByTitle.get(target.trim());
-  if (byTitle !== undefined && fileSlugs.has(byTitle)) return byTitle;
-  return null;
-}
-
-/** Resolved, deduped outgoing slugs for one page body. Self-links and
- *  links to non-existent pages are dropped (the latter are already a
- *  lint "broken link", not a graph edge). */
-export function pageOutgoingSlugs(fromSlug: string, content: string, fileSlugs: ReadonlySet<string>, slugByTitle: ReadonlyMap<string, string>): string[] {
-  const out = new Set<string>();
-  for (const match of content.matchAll(WIKI_LINK_PATTERN)) {
-    const { target } = parseWikiLink(match[1]);
-    const resolved = resolveLinkTarget(target, fileSlugs, slugByTitle);
-    if (resolved !== null && resolved !== fromSlug) out.add(resolved);
-  }
-  return [...out];
-}
-
-function buildTitleMaps(entries: readonly WikiPageEntry[]): { titleBySlug: Map<string, string>; slugByTitle: Map<string, string> } {
-  const titleBySlug = new Map<string, string>();
-  const slugByTitle = new Map<string, string>();
-  for (const entry of entries) {
-    if (!titleBySlug.has(entry.slug)) titleBySlug.set(entry.slug, entry.title);
-    if (entry.title.length > 0 && !slugByTitle.has(entry.title)) slugByTitle.set(entry.title, entry.slug);
-  }
-  return { titleBySlug, slugByTitle };
-}
-
-/** Build the full page→page graph. Nodes are the existing page files
- *  (titled from index.md, falling back to the slug for un-indexed
- *  pages); edges are the resolved `[[links]]`, deduped per (from,to). */
-export function buildWikiGraph(pages: readonly WikiPageContent[], entries: readonly WikiPageEntry[]): WikiGraph {
-  const fileSlugs = new Set(pages.map((page) => page.slug));
-  const { titleBySlug, slugByTitle } = buildTitleMaps(entries);
-  const nodes: WikiGraphNode[] = pages.map((page) => ({ slug: page.slug, title: titleBySlug.get(page.slug) ?? page.slug }));
-  const edges: WikiGraphEdge[] = [];
-  const seen = new Set<string>();
-  for (const page of pages) {
-    for (const toSlug of pageOutgoingSlugs(page.slug, page.content, fileSlugs, slugByTitle)) {
-      // Newline cannot appear in a wiki slug, so it is a safe pair key.
-      const key = [page.slug, toSlug].join("\n");
-      if (seen.has(key)) continue;
-      seen.add(key);
-      edges.push({ from: page.slug, to: toSlug });
-    }
-  }
-  return { nodes, edges };
-}
-
-/** Pages that link TO `slug` (incoming edges), deduped, as nodes. */
-export function incomingLinks(graph: WikiGraph, slug: string): WikiGraphNode[] {
-  const nodeBySlug = new Map(graph.nodes.map((node) => [node.slug, node]));
-  const result: WikiGraphNode[] = [];
-  const seen = new Set<string>();
-  for (const edge of graph.edges) {
-    if (edge.to !== slug || seen.has(edge.from)) continue;
-    seen.add(edge.from);
-    const node = nodeBySlug.get(edge.from);
-    if (node) result.push(node);
-  }
-  return result;
-}