@aisystemresources/emdee 0.1.0

package/src/lib/mcp/tools/get_image.ts

@@ -0,0 +1,62 @@
+import { readVaultFile, validatePath } from "./vault";
+import type { ToolContext } from "./types";
+
+function err(text: string) {
+  return { content: [{ type: "text" as const, text: JSON.stringify({ error: text }) }] };
+}
+
+/**
+ * Fetch an image doc from the vault and return both its metadata and the raw
+ * image bytes as an MCP image content block so Claude can visually analyze it.
+ *
+ * Workflow for batch labelling:
+ *   1. list_docs → find images/*.md with "_description pending_" in summary
+ *   2. get_image(doc_path) → Claude sees the image
+ *   3. patch_preamble → write a real description as the blockquote summary
+ *   4. add_association → link to relevant project / person / event docs
+ */
+export async function getImage(ctx: ToolContext, args: Record<string, unknown>): Promise<unknown> {
+  const docPath = String(args.doc_path ?? "").trim();
+  if (!docPath) return err("doc_path is required");
+
+  try { validatePath(docPath); } catch (e) { return err(String(e)); }
+
+  const raw = await readVaultFile(ctx, docPath);
+  if (!raw) return err(`doc not found: ${docPath}`);
+
+  // Extract the first image URL from the doc body.
+  const m = raw.match(/!\[.*?\]\((https?:\/\/[^)]+)\)/);
+  if (!m) return err(`no image URL found in ${docPath}`);
+  const imageUrl = m[1];
+
+  // Fetch the image binary.
+  let imageResp: Response;
+  try {
+    imageResp = await fetch(imageUrl);
+  } catch (e) {
+    return err(`failed to fetch image: ${String(e)}`);
+  }
+  if (!imageResp.ok) return err(`image fetch returned ${imageResp.status}`);
+
+  const contentType = imageResp.headers.get("content-type") ?? "image/jpeg";
+  const mimeType = contentType.split(";")[0].trim();
+
+  const buffer = Buffer.from(await imageResp.arrayBuffer());
+  if (buffer.length === 0) return err("image fetch returned empty body");
+
+  const base64 = buffer.toString("base64");
+
+  return {
+    content: [
+      {
+        type: "text" as const,
+        text: JSON.stringify({ doc_path: docPath, image_url: imageUrl }),
+      },
+      {
+        type: "image" as const,
+        data: base64,
+        mimeType,
+      },
+    ],
+  };
+}

package/src/lib/mcp/tools/get_neighbors.ts

@@ -0,0 +1,96 @@
+import { loadVaultIndex } from "./vault";
+import type { DocIndex, DocNode, Link, ToolContext } from "./types";
+import { getPrevNextSiblings } from "../../../core/siblings";
+import { resolveWikiLink } from "../../../core/resolveLink";
+
+function json(value: unknown) {
+  return { content: [{ type: "text" as const, text: JSON.stringify(value, null, 2) }] };
+}
+
+interface NeighborRef { path: string; title: string; summary: string; note: string; }
+
+function buildNeighbors(idx: DocIndex, focal: DocNode) {
+  const byPath = new Map(idx.docs.map((d) => [d.path, d]));
+  // Locality-aware resolver: bullets like `[[DAY1]]` are disambiguated
+  // by the focal's path when two docs share the title or slug.
+  const resolve = (t: string) => byPath.get(t) ?? resolveWikiLink(idx, t, focal.path);
+  const refFor = (n: DocNode, note: string): NeighborRef => ({ path: n.path, title: n.title, summary: n.summary, note });
+
+  const declaredParents = new Map<string, NeighborRef>();
+  const declaredChildren = new Map<string, NeighborRef>();
+  const declaredAssoc = new Map<string, NeighborRef>();
+  for (const l of focal.parents) { const n = resolve(l.title); if (n) declaredParents.set(n.path, refFor(n, l.note)); }
+  for (const l of focal.children) { const n = resolve(l.title); if (n) declaredChildren.set(n.path, refFor(n, l.note)); }
+  // Compute focal's parent paths once for the sibling check below.
+  const focalParentPaths = new Set(
+    focal.parents
+      .map((l) => resolve(l.title)?.path)
+      .filter((p): p is string => !!p)
+  );
+  for (const l of focal.associates) {
+    const n = resolve(l.title);
+    if (!n) continue;
+    // Hierarchy beats associate — if the target is already a parent or
+    // child of this focal, drop the assoc entry.
+    if (declaredParents.has(n.path) || declaredChildren.has(n.path)) continue;
+    // Sibling beats associate — if the target shares one of this focal's
+    // parents, the relationship is already conveyed by the hierarchy.
+    if (focalParentPaths.size > 0) {
+      const candidateParentPaths = n.parents
+        .map((pl) => resolve(pl.title)?.path)
+        .filter((p): p is string => !!p);
+      if (candidateParentPaths.some((p) => focalParentPaths.has(p))) continue;
+    }
+    declaredAssoc.set(n.path, refFor(n, l.note));
+  }
+
+  const focalTitleLower = focal.title.toLowerCase();
+  const matchesFocal = (l: Link) => l.title.toLowerCase() === focalTitleLower;
+  for (const other of idx.docs) {
+    if (other.path === focal.path) continue;
+    const asChild = other.children.find(matchesFocal);
+    if (asChild && !declaredParents.has(other.path)) declaredParents.set(other.path, refFor(other, asChild.note));
+    const asParent = other.parents.find(matchesFocal);
+    if (asParent && !declaredChildren.has(other.path)) declaredChildren.set(other.path, refFor(other, asParent.note));
+    const asAssoc = other.associates.find(matchesFocal);
+    if (asAssoc && !declaredAssoc.has(other.path)) declaredAssoc.set(other.path, refFor(other, asAssoc.note));
+  }
+
+  const declared = new Set([...declaredParents.keys(), ...declaredChildren.keys(), ...declaredAssoc.keys()]);
+  const mentionedIn = idx.docs
+    .filter((d) => d.path !== focal.path && !declared.has(d.path) && d.mentions.some((m) => m.toLowerCase() === focalTitleLower))
+    .map((d) => ({ path: d.path, title: d.title, summary: d.summary }));
+
+  // Prev/next sibling — shared helper. Uses the parent's `## Parent of`
+  // bullet order, augmented with any other doc whose primary parent
+  // matches focal's primary parent (catches asymmetric edges where the
+  // child declared `Child of` but the parent didn't reciprocate).
+  let prev_sibling: { path: string; title: string; summary: string } | null = null;
+  let next_sibling: { path: string; title: string; summary: string } | null = null;
+  const { prevPath, nextPath } = getPrevNextSiblings(idx, focal.path);
+  if (prevPath) {
+    const p = idx.docs.find((d) => d.path === prevPath);
+    if (p) prev_sibling = { path: p.path, title: p.title, summary: p.summary };
+  }
+  if (nextPath) {
+    const n = idx.docs.find((d) => d.path === nextPath);
+    if (n) next_sibling = { path: n.path, title: n.title, summary: n.summary };
+  }
+
+  return {
+    path: focal.path, title: focal.title, summary: focal.summary,
+    parents: [...declaredParents.values()],
+    children: [...declaredChildren.values()],
+    associated: [...declaredAssoc.values()],
+    mentioned_in: mentionedIn,
+    prev_sibling,
+    next_sibling,
+  };
+}
+
+export async function getNeighbors(ctx: ToolContext, args: Record<string, unknown>): Promise<unknown> {
+  const idx = await loadVaultIndex(ctx);
+  const focal = idx.docs.find((d) => d.path === String(args.path));
+  if (!focal) throw new Error(`no such doc: ${args.path}`);
+  return json(buildNeighbors(idx, focal));
+}

package/src/lib/mcp/tools/get_summary.ts

@@ -0,0 +1,18 @@
+import { loadVaultIndex } from "./vault";
+import type { ToolContext } from "./types";
+
+function json(value: unknown) {
+  return { content: [{ type: "text" as const, text: JSON.stringify(value, null, 2) }] };
+}
+
+function text(value: string) {
+  return { content: [{ type: "text" as const, text: value }] };
+}
+
+export async function getSummary(ctx: ToolContext, args: Record<string, unknown>): Promise<unknown> {
+  const idx = await loadVaultIndex(ctx);
+  const doc = idx.docs.find((d) => d.path === String(args.path));
+  if (!doc) throw new Error(`no such doc: ${args.path}`);
+  if (args.format === "text") return text(doc.summary ?? "");
+  return json({ path: doc.path, title: doc.title, summary: doc.summary });
+}

package/src/lib/mcp/tools/index.ts

@@ -0,0 +1,26 @@
+export { listDocs } from "./list_docs";
+export { listSummaryDrift } from "./list_summary_drift";
+export { getSummary } from "./get_summary";
+export { getNeighbors } from "./get_neighbors";
+export { getContext } from "./get_context";
+export { getDoc } from "./get_doc";
+export { readDocSection } from "./read_doc_section";
+export { search } from "./search";
+export { appendSection } from "./append_section";
+export { patchSection } from "./patch_section";
+export { writeDocPreview } from "./write_doc_preview";
+export { writeDoc } from "./write_doc";
+export { deleteDoc } from "./delete_doc";
+export { splitDoc } from "./split_doc";
+export { materializeSubgroup } from "./materialize_subgroup";
+export { renameDoc } from "./rename_doc";
+export { patchPreamble } from "./patch_preamble";
+export { appendDoc } from "./append_doc";
+export { lintDoc } from "./lint_doc";
+export { distillDoc } from "./distill_doc";
+export { createChild } from "./create_child";
+export { addAssociation } from "./add_association";
+export { moveDoc } from "./move_doc";
+export { trashDoc } from "./trash_doc";
+export { restoreDoc } from "./restore_doc";
+export { getImage } from "./get_image";