@abraca/dabra 1.8.2 → 2.0.0

package/src/ContentManager.ts

@@ -0,0 +1,228 @@
+/**
+ * ContentManager — read/write document content via markdown ↔ Y.js conversion.
+ *
+ * Extracted from `mcp/tools/content.ts` and `cli/commands/content.ts`.
+ */
+import * as Y from "yjs";
+import type { PageMeta } from "./DocTypes.ts";
+import { toPlain } from "./DocUtils.ts";
+import {
+	yjsToMarkdown,
+	populateYDocFromMarkdown,
+	parseFrontmatter,
+	buildHeadingElement,
+	buildParagraphElement,
+	buildBulletListElement,
+	buildOrderedListElement,
+	buildTaskListElement,
+	buildCodeBlockElement,
+	buildBlockquoteElement,
+	buildHorizontalRuleElement,
+	buildBlocksFromMarkdown,
+	readBlocksFromFragment,
+	type DocumentBlock,
+} from "./DocConverters.ts";
+export type { DocumentBlock } from "./DocConverters.ts";
+import type { DocumentManager } from "./DocumentManager.ts";
+
+export interface DocumentContent {
+	label: string;
+	type?: string;
+	meta?: PageMeta;
+	title: string;
+	markdown: string;
+	children: Array<{
+		id: string;
+		label: string;
+		type?: string;
+		meta?: PageMeta;
+	}>;
+}
+
+export class ContentManager {
+	constructor(private dm: DocumentManager) {}
+
+	/**
+	 * Read document content as markdown.
+	 * Returns the title extracted from the TipTap documentHeader, the markdown
+	 * body, tree metadata, and immediate children.
+	 */
+	async read(docId: string): Promise<DocumentContent> {
+		const provider = await this.dm.getChildProvider(docId);
+		const fragment = provider.document.getXmlFragment("default");
+
+		const { title, markdown } = yjsToMarkdown(fragment);
+
+		// Get tree metadata + immediate children
+		const treeMap = this.dm.getTreeMap();
+		let label = title;
+		let type: string | undefined;
+		let meta: PageMeta | undefined;
+		const childrenWithOrder: Array<{
+			id: string;
+			label: string;
+			type?: string;
+			meta?: PageMeta;
+			order: number;
+		}> = [];
+
+		if (treeMap) {
+			const raw = treeMap.get(docId);
+			if (raw) {
+				const entry = toPlain(raw) as Record<string, unknown>;
+				label = (entry.label as string) || title;
+				type = entry.type as string | undefined;
+				meta = entry.meta as PageMeta | undefined;
+			}
+			// Collect immediate children sorted by order
+			treeMap.forEach((rawChild: unknown, id: string) => {
+				const value = toPlain(rawChild) as Record<string, unknown>;
+				if (value && value.parentId === docId) {
+					childrenWithOrder.push({
+						id,
+						label: (value.label as string) || "Untitled",
+						type: value.type as string | undefined,
+						meta: value.meta as PageMeta | undefined,
+						order: (value.order as number) ?? 0,
+					});
+				}
+			});
+			childrenWithOrder.sort((a, b) => a.order - b.order);
+		}
+
+		const children = childrenWithOrder.map(({ id, label, type, meta }) => ({
+			id,
+			label,
+			type,
+			meta,
+		}));
+
+		return { label, type, meta, title, markdown, children };
+	}
+
+	/**
+	 * Write markdown content to a document.
+	 * Supports optional YAML frontmatter for title and metadata.
+	 *
+	 * @param mode - "replace" clears existing content first (default),
+	 *               "append" adds to the end.
+	 */
+	async write(
+		docId: string,
+		markdown: string,
+		mode: "replace" | "append" = "replace",
+	): Promise<void> {
+		const provider = await this.dm.getChildProvider(docId);
+		const doc = provider.document;
+		const fragment = doc.getXmlFragment("default");
+
+		// Parse optional frontmatter
+		const { title, meta, body } = parseFrontmatter(markdown);
+
+		// Update tree metadata if frontmatter provided title or meta
+		if (title || Object.keys(meta).length > 0) {
+			const treeMap = this.dm.getTreeMap();
+			const rootDoc = this.dm.rootDocument;
+			if (treeMap && rootDoc) {
+				const entry = treeMap.get(docId);
+				if (entry) {
+					rootDoc.transact(() => {
+						const updates: Record<string, unknown> = {
+							...entry,
+							updatedAt: Date.now(),
+						};
+						if (title) updates.label = title;
+						if (Object.keys(meta).length > 0) {
+							updates.meta = {
+								...(entry.meta ?? {}),
+								...meta,
+							};
+						}
+						treeMap.set(docId, updates);
+					});
+				}
+			}
+		}
+
+		if (mode === "replace") {
+			// Clear existing content
+			doc.transact(() => {
+				while (fragment.length > 0) {
+					fragment.delete(0);
+				}
+			});
+		}
+
+		// Write new content
+		const contentToWrite = body || markdown;
+		const fallbackTitle = title || "Untitled";
+		populateYDocFromMarkdown(fragment, contentToWrite, fallbackTitle);
+	}
+
+	private async _appendElements(docId: string, els: Y.XmlElement[]): Promise<void> {
+		const provider = await this.dm.getChildProvider(docId);
+		const doc = provider.document;
+		const fragment = doc.getXmlFragment("default");
+		doc.transact(() => {
+			fragment.insert(fragment.length, els);
+		});
+	}
+
+	async appendHeading(docId: string, text: string, opts?: { level?: 1|2|3|4|5|6 }): Promise<void> {
+		return this._appendElements(docId, [buildHeadingElement(text, opts?.level)]);
+	}
+
+	async appendParagraph(docId: string, text: string): Promise<void> {
+		return this._appendElements(docId, [buildParagraphElement(text)]);
+	}
+
+	async appendBulletList(docId: string, items: string[]): Promise<void> {
+		return this._appendElements(docId, [buildBulletListElement(items)]);
+	}
+
+	async appendOrderedList(docId: string, items: string[]): Promise<void> {
+		return this._appendElements(docId, [buildOrderedListElement(items)]);
+	}
+
+	async appendTaskList(docId: string, items: Array<{ text: string; checked?: boolean }>): Promise<void> {
+		return this._appendElements(docId, [buildTaskListElement(items)]);
+	}
+
+	async appendCodeBlock(docId: string, code: string, opts?: { language?: string }): Promise<void> {
+		return this._appendElements(docId, [buildCodeBlockElement(code, opts?.language)]);
+	}
+
+	async appendBlockquote(docId: string, text: string): Promise<void> {
+		return this._appendElements(docId, [buildBlockquoteElement(text)]);
+	}
+
+	async appendHorizontalRule(docId: string): Promise<void> {
+		return this._appendElements(docId, [buildHorizontalRuleElement()]);
+	}
+
+	async appendMarkdown(docId: string, markdown: string): Promise<void> {
+		return this._appendElements(docId, buildBlocksFromMarkdown(markdown));
+	}
+
+	async getBlocks(docId: string): Promise<DocumentBlock[]> {
+		const provider = await this.dm.getChildProvider(docId);
+		return readBlocksFromFragment(provider.document.getXmlFragment("default"));
+	}
+
+	/**
+	 * Get the raw Y.XmlFragment for a document (the 'default' fragment
+	 * that TipTap uses for document content).
+	 */
+	async getFragment(docId: string): Promise<Y.XmlFragment> {
+		const provider = await this.dm.getChildProvider(docId);
+		return provider.document.getXmlFragment("default");
+	}
+
+	/**
+	 * Get the raw Y.Doc for a document (synced).
+	 */
+	async getDoc(docId: string): Promise<Y.Doc> {
+		const provider = await this.dm.getChildProvider(docId);
+		return provider.document;
+	}
+}

package/src/CryptoIdentityKeystore.ts

@@ -357,7 +357,7 @@ export class CryptoIdentityKeystore {
 			} else {
 				const all = await dbGetAll(db);
 				if (all.length > 0) {
-					await dbPut(db, all[0].key, { ...all[0].value, username });
+					await dbPut(db, String(all[0].key), { ...all[0].value, username });
 				}
 			}
 		} finally {
@@ -557,7 +557,7 @@ export class CryptoIdentityKeystore {
 					challenge: crypto.getRandomValues(new Uint8Array(32)),
 					rp: { id: rpId, name: rpName },
 					user: {
-						id: fromBase64url(kp.publicKeyB64),
+						id: fromBase64url(kp.publicKeyB64) as BufferSource,
 						name: kp.publicKeyB64.slice(0, 16),
 						displayName: kp.publicKeyB64.slice(0, 16),
 					},
@@ -663,7 +663,7 @@ export class CryptoIdentityKeystore {
 
 		if (credentialIdHint) {
 			allowCredentials.push({
-				id: fromBase64url(credentialIdHint),
+				id: fromBase64url(credentialIdHint) as BufferSource,
 				type: "public-key",
 			});
 		} else {