agentic-documents 0.0.0-stage → 0.1.0

package/dist/chunk-5Y66UCTE.js

@@ -0,0 +1,7 @@
+// src/version.ts
+import { createRequire } from "module";
+var VERSION = createRequire(import.meta.url)("../package.json").version;
+
+export {
+  VERSION
+};

package/dist/chunk-BSXUNQDR.js

@@ -0,0 +1,224 @@
+import {
+  DocError
+} from "./chunk-4YVWD5PH.js";
+
+// src/adapters/file-blobs.ts
+import { createHash, randomUUID } from "crypto";
+import { link, mkdir, open, readFile, rename, rm, stat, writeFile } from "fs/promises";
+import { resolve } from "path";
+import { assertBlobPutOptions, assertResponseHeaders, parseRegion } from "agentic-identity";
+var sleep = (ms) => new Promise((done) => setTimeout(done, ms));
+var missing = (error) => error.code === "ENOENT";
+var HEADER = 4;
+function pack(data, contentType) {
+  const head = Buffer.from(JSON.stringify(contentType === void 0 ? {} : { contentType }));
+  const length = Buffer.alloc(HEADER);
+  length.writeUInt32BE(head.length);
+  return Buffer.concat([length, head, data]);
+}
+function unpack(file) {
+  const end = HEADER + file.readUInt32BE(0);
+  const { contentType } = JSON.parse(file.subarray(HEADER, end).toString("utf8"));
+  return {
+    data: new Uint8Array(file.subarray(end)),
+    version: createHash("sha256").update(file).digest("hex"),
+    ...contentType === void 0 ? {} : { contentType }
+  };
+}
+function createLocker(root, options = {}) {
+  const staleMs = options.lockStaleMs ?? 1e4;
+  const timeoutMs = options.lockTimeoutMs ?? 5e3;
+  async function clearStale(lock) {
+    let token;
+    let age;
+    try {
+      token = await readFile(lock, "utf8");
+      age = Date.now() - (await stat(lock)).mtimeMs;
+    } catch (error) {
+      if (missing(error)) return true;
+      throw error;
+    }
+    if (!(age > staleMs)) return false;
+    const moved = `${lock}.stale-${randomUUID()}`;
+    try {
+      await rename(lock, moved);
+    } catch (error) {
+      if (missing(error)) return true;
+      throw error;
+    }
+    if (await readFile(moved, "utf8").catch(() => token) !== token) await link(moved, lock).catch(() => void 0);
+    await rm(moved, { force: true });
+    return true;
+  }
+  async function locked(full, run) {
+    await mkdir(root, { recursive: true });
+    const lock = `${full}.lock`;
+    const token = randomUUID();
+    const deadline = Date.now() + timeoutMs;
+    for (; ; ) {
+      try {
+        const file = await open(lock, "wx");
+        await file.writeFile(token).finally(() => file.close());
+        break;
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+        if (await clearStale(lock)) continue;
+        if (Date.now() >= deadline) throw new DocError("LOCKED", "another writer holds this document; try again");
+        await sleep(5 + Math.random() * 20);
+      }
+    }
+    const held = async () => await readFile(lock, "utf8").catch(() => null) === token;
+    try {
+      return await run(held);
+    } finally {
+      if (await held()) await rm(lock, { force: true });
+    }
+  }
+  return locked;
+}
+function createFileBlobs(dir, options = {}) {
+  const root = resolve(dir);
+  const locked = createLocker(root, options);
+  const now = options.now ?? Date.now;
+  const path = (key) => {
+    if (key === "") throw new Error("blob key must not be empty");
+    return resolve(root, createHash("sha256").update(key).digest("hex"));
+  };
+  async function read(full) {
+    try {
+      return unpack(await readFile(full));
+    } catch (error) {
+      if (missing(error)) return null;
+      throw error;
+    }
+  }
+  return {
+    region: options.region === void 0 ? "unknown" : parseRegion(options.region),
+    async put(key, data, opts) {
+      const full = path(key);
+      assertBlobPutOptions(opts);
+      return locked(full, async (held) => {
+        if (opts?.ifNoneMatch === "*" || opts?.ifMatch !== void 0) {
+          const current = await read(full);
+          if (opts.ifNoneMatch === "*" ? current !== null : current?.version !== opts.ifMatch) return null;
+        }
+        const file = pack(data, opts?.contentType);
+        const temp = `${full}.${randomUUID()}.tmp`;
+        try {
+          await writeFile(temp, file);
+          if (!await held()) throw new DocError("LOCKED", "the lock was taken over while writing; try again");
+          await rename(temp, full);
+        } finally {
+          await rm(temp, { force: true });
+        }
+        return { version: createHash("sha256").update(file).digest("hex") };
+      });
+    },
+    get: (key) => read(path(key)),
+    async head(key) {
+      const found = await read(path(key));
+      return found ? { size: found.data.length, version: found.version, ...found.contentType === void 0 ? {} : { contentType: found.contentType } } : null;
+    },
+    async delete(key) {
+      const full = path(key);
+      await locked(full, () => rm(full, { force: true }));
+    },
+    /** A local path with its expiry. Nothing serves or checks it: it exists so the port is whole. */
+    async signedUrl(key, opts) {
+      const full = path(key);
+      const { method, expiresInSeconds } = opts;
+      if (!Number.isInteger(expiresInSeconds) || expiresInSeconds < 1 || expiresInSeconds > 604800) {
+        throw new RangeError("expiresInSeconds must be an integer from 1 to 604800");
+      }
+      assertResponseHeaders(opts);
+      const extra = [
+        opts.responseContentDisposition === void 0 ? "" : `&disposition=${encodeURIComponent(opts.responseContentDisposition)}`,
+        opts.responseContentType === void 0 ? "" : `&type=${encodeURIComponent(opts.responseContentType)}`
+      ].join("");
+      return `file://${full}?method=${method}&expires=${now() + expiresInSeconds * 1e3}${extra}`;
+    }
+  };
+}
+
+// src/adapters/file-store.ts
+import { createMemoryStore, StoreConflictError } from "agentic-identity";
+import { resolve as resolve2 } from "path";
+var KEY = "store";
+var ATTEMPTS = 64;
+function createFileStore(dir, options = {}) {
+  const { shared: _shared, ...rest } = options;
+  const memoryOptions = { region: rest.region, now: rest.now };
+  const blobs = createFileBlobs(dir, options);
+  const locked = createLocker(resolve2(dir), options);
+  const mutex = resolve2(dir, "store-mutex");
+  const region = createMemoryStore(memoryOptions).region;
+  async function load() {
+    const found = await blobs.get(KEY);
+    const rows = /* @__PURE__ */ new Map();
+    const memory = createMemoryStore(memoryOptions);
+    if (found) {
+      for (const row of JSON.parse(new TextDecoder().decode(found.data))) {
+        rows.set(JSON.stringify([row[0], row[1]]), row);
+        await memory.put(row[0], row[1], row[2]);
+      }
+    }
+    return { memory, rows, version: found?.version };
+  }
+  async function save(rows, changes, version) {
+    if (changes.length === 0) return true;
+    for (const [collection, id, doc] of changes) {
+      const key = JSON.stringify([collection, id]);
+      if (doc === null) rows.delete(key);
+      else rows.set(key, [collection, id, doc]);
+    }
+    const data = new TextEncoder().encode(JSON.stringify([...rows.values()]));
+    const saved = await blobs.put(KEY, data, version === void 0 ? { ifNoneMatch: "*" } : { ifMatch: version });
+    return saved !== null;
+  }
+  const recording = (ops, changes) => ({
+    ...ops,
+    put: async (collection, id, doc) => {
+      await ops.put(collection, id, doc);
+      changes.push([collection, id, doc]);
+    },
+    delete: async (collection, id) => {
+      await ops.delete(collection, id);
+      changes.push([collection, id, null]);
+    }
+  });
+  const transaction = async (fn) => {
+    for (let attempt = 0; attempt < ATTEMPTS; attempt++) {
+      const done = await locked(mutex, async (held) => {
+        const { memory, rows, version } = await load();
+        let changes = [];
+        const result = await memory.transaction((tx) => {
+          changes = [];
+          return fn(recording(tx, changes));
+        });
+        if (changes.length > 0 && !await held()) throw new DocError("LOCKED", "the lock was taken over during the transaction; try again");
+        return await save(rows, changes, version) ? { result } : void 0;
+      });
+      if (done) return done.result;
+    }
+    throw new StoreConflictError(`transaction kept conflicting after ${ATTEMPTS} attempts`);
+  };
+  return {
+    region,
+    get: async (collection, id) => (await load()).memory.get(collection, id),
+    query: async (collection, query) => (await load()).memory.query(collection, query),
+    put: (collection, id, doc) => transaction(async (tx) => {
+      await tx.get(collection, id);
+      await tx.put(collection, id, doc);
+    }),
+    delete: (collection, id) => transaction(async (tx) => {
+      await tx.get(collection, id);
+      await tx.delete(collection, id);
+    }),
+    transaction
+  };
+}
+
+export {
+  createFileBlobs,
+  createFileStore
+};

package/dist/chunk-LRPLNXOF.js

@@ -0,0 +1,67 @@
+import {
+  AgenticDoc,
+  DocError,
+  PRINCIPAL_KINDS
+} from "./chunk-4YVWD5PH.js";
+
+// src/service.ts
+var ATTEMPTS = 64;
+var ID = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+var CATALOG = "documents";
+var DocsService = class {
+  constructor(ports, options = {}) {
+    this.options = options;
+    this.blobs = ports.blobs;
+    this.store = ports.store;
+  }
+  options;
+  blobs;
+  store;
+  key(id) {
+    if (!ID.test(id)) throw new DocError("INVALID_INPUT", `invalid document id "${id}": use 1 to 64 of a-z, 0-9, "-" and "_"`);
+    return `${id}.ydoc`;
+  }
+  async create(id, markdown, author) {
+    const key = this.key(id);
+    const created = await this.blobs.put(key, AgenticDoc.fromMarkdown(markdown, author, this.options).encode(), { ifNoneMatch: "*" });
+    if (!created) throw new DocError("DOCUMENT_EXISTS", `document "${id}" already exists`);
+    await this.store.transaction(async (tx) => {
+      if (await tx.get(CATALOG, id) === null) await tx.put(CATALOG, id, { createdBy: { kind: author.kind, name: author.name }, createdAt: Date.now() });
+    });
+  }
+  /** Who created the document and when, or null when it has no catalog entry (made before the catalog, or a failed catalog write). */
+  async info(id) {
+    this.key(id);
+    const entry = await this.store.get(CATALOG, id);
+    if (entry === null) return null;
+    const { createdBy, createdAt } = entry;
+    if (!createdBy || !PRINCIPAL_KINDS.includes(createdBy.kind) || typeof createdBy.name !== "string" || typeof createdAt !== "number") {
+      throw new DocError("INVALID_INPUT", `the catalog entry for "${id}" is damaged`);
+    }
+    return { createdBy, createdAt };
+  }
+  async read(id, run) {
+    const found = await this.blobs.get(this.key(id));
+    if (!found) throw new DocError("NO_DOCUMENT", `no document with id "${id}"`);
+    return run(AgenticDoc.fromUpdate(found.data, this.options));
+  }
+  /**
+   * Load, run the change, and save only if nobody saved in between. When someone did, load again and
+   * run the change again, so a check such as "is it still pending" sees the new state.
+   */
+  async write(id, run) {
+    const key = this.key(id);
+    for (let attempt = 0; attempt < ATTEMPTS; attempt++) {
+      const found = await this.blobs.get(key);
+      if (!found) throw new DocError("NO_DOCUMENT", `no document with id "${id}"`);
+      const doc = AgenticDoc.fromUpdate(found.data, this.options);
+      const result = run(doc);
+      if (await this.blobs.put(key, doc.encode(), { ifMatch: found.version })) return result;
+    }
+    throw new DocError("CONFLICT", `document "${id}" kept changing; try again`);
+  }
+};
+
+export {
+  DocsService
+};

package/dist/cli.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+declare function main(argv: string[], env?: NodeJS.ProcessEnv): Promise<number>;
+
+export { main };

package/dist/cli.js

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+import {
+  createFileBlobs,
+  createFileStore
+} from "./chunk-BSXUNQDR.js";
+import {
+  DocsService
+} from "./chunk-LRPLNXOF.js";
+import {
+  VERSION
+} from "./chunk-5Y66UCTE.js";
+import {
+  DocError,
+  commands,
+  parseAuthor
+} from "./chunk-4YVWD5PH.js";
+
+// src/cli.ts
+import { readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { parseArgs } from "util";
+var NAME = "agentic-documents";
+var flagNames = [...new Set(commands.flatMap((c) => Object.keys(c.shape)))].filter((k) => k !== "id");
+var options = {
+  ...Object.fromEntries(flagNames.map((k) => [k, { type: "string" }])),
+  as: { type: "string" },
+  scopes: { type: "string" },
+  dir: { type: "string" },
+  file: { type: "string" },
+  out: { type: "string" },
+  help: { type: "boolean", short: "h" },
+  version: { type: "boolean", short: "V" }
+};
+function help() {
+  const lines = commands.map((c) => `  ${c.name.padEnd(12)}${c.description}`);
+  return [
+    `${NAME} ${VERSION}`,
+    "",
+    `Usage: ${NAME} <command> <id> [flags]`,
+    "",
+    "Commands:",
+    ...lines,
+    "  mcp         Start the MCP server on stdio.",
+    "",
+    "Flags:",
+    "  --as <kind:name>  Who makes the change. Or set AGENTIC_DOCS_AS. Kinds: human, agent_of_human,",
+    "                    agent_of_agent, agent, user_token.",
+    "  --scopes <a,b>    Rights for the author, such as docs:accept. Or set AGENTIC_DOCS_SCOPES. An agent",
+    "                    needs docs:accept to accept a suggestion.",
+    "  --dir <path>      Where documents live. Or set AGENTIC_DOCS_DIR. Default: .agentic-documents",
+    "  --file <path>     Read content (or markdown for new) from a file.",
+    "  --out <path>      Write the export to a file.",
+    "  --<field> <value> Any field of the command, such as --text, --section, --occurrence."
+  ].join("\n");
+}
+function bindValues(argv) {
+  const out = [];
+  for (let i = 0; i < argv.length; i++) {
+    const name = argv[i].startsWith("--") && !argv[i].includes("=") ? argv[i].slice(2) : void 0;
+    const takesValue = name !== void 0 && options[name]?.type === "string";
+    out.push(takesValue && i + 1 < argv.length ? `${argv[i]}=${argv[++i]}` : argv[i]);
+  }
+  return out;
+}
+async function main(argv, env = process.env) {
+  let parsed;
+  try {
+    parsed = parseArgs({ args: bindValues(argv), options, allowPositionals: true });
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return 2;
+  }
+  const { values, positionals } = parsed;
+  const [name, id] = positionals;
+  if (values.version || values.help || name === void 0) {
+    console.log(values.version ? VERSION : help());
+    return 0;
+  }
+  const dir = values.dir ?? env.AGENTIC_DOCS_DIR ?? ".agentic-documents";
+  const service = new DocsService({ blobs: createFileBlobs(join(dir, "blobs")), store: createFileStore(join(dir, "store")) });
+  const scopes = (values.scopes ?? env.AGENTIC_DOCS_SCOPES)?.split(",").map((s) => s.trim()).filter(Boolean);
+  const named = parseAuthor(values.as ?? env.AGENTIC_DOCS_AS);
+  const author = named && scopes?.length ? { ...named, scopes } : named;
+  if (name === "mcp") {
+    const { startMcp } = await import("./mcp-2VZIGHIX.js");
+    await startMcp(service, author);
+    return 0;
+  }
+  const command = commands.find((c) => c.name === name);
+  if (!command) {
+    console.error(`unknown command "${name}". Run "${NAME} --help".`);
+    return 2;
+  }
+  const { as: _as, scopes: _scopes, dir: _dir, file, out, help: _help, version: _version, ...fields } = values;
+  const input = { ...command.shape.id ? { id } : {}, ...fields };
+  try {
+    if (file !== void 0) {
+      const key = "content" in command.shape ? "content" : "markdown" in command.shape ? "markdown" : void 0;
+      if (!key) throw new DocError("INVALID_INPUT", `"${name}" takes no --file`);
+      if (key in input) throw new DocError("INVALID_INPUT", `pass --file or --${key}, not both`);
+      input[key] = readFileSync(file, "utf8");
+    }
+    const result = await command.run(service, input, author);
+    if (name === "export") {
+      const { data, encoding } = result;
+      const bytes = encoding === "base64" ? Buffer.from(data, "base64") : data;
+      if (out === void 0) process.stdout.write(bytes);
+      else writeFileSync(out, bytes);
+    } else console.log(typeof result === "string" ? result.replace(/\n$/, "") : JSON.stringify(result, null, 2));
+    return 0;
+  } catch (error) {
+    if (!(error instanceof DocError)) throw error;
+    console.error(`${error.code}: ${error.message}`);
+    for (const m of error.matches) console.error(`  ${m.occurrence}: ...${m.context}...`);
+    return error.code === "INVALID_INPUT" ? 2 : 1;
+  }
+}
+main(process.argv.slice(2)).then(
+  (code) => {
+    if (code !== 0) process.exit(code);
+  },
+  (error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+);
+export {
+  main
+};

package/dist/index.d.ts

@@ -0,0 +1,145 @@
+import { P as Principal, A as Anchor, a as AgenticDoc, T as TextTarget, b as AnchorTarget, D as DocsService, c as PmNode } from './service-eYISo6-b.js';
+export { d as DocInfo, e as DocOptions, f as DocsPorts, E as EditEntry, g as PRINCIPAL_KINDS, h as PrincipalKind, S as Section, i as SectionTarget, j as Target, k as blocksToMarkdown, m as markdownToBlocks, p as parseAuthor } from './service-eYISo6-b.js';
+import { Schema } from 'prosemirror-model';
+import { z } from 'zod';
+import { AdapterOptions, Blobs, Store } from 'agentic-identity';
+import 'yjs';
+
+type DocErrorCode = "NO_MATCH" | "AMBIGUOUS_MATCH" | "STALE_ANCHOR" | "NO_SECTION" | "INVALID_AUTHOR" | "INVALID_INPUT" | "NO_THREAD" | "NO_SUGGESTION" | "ALREADY_DECIDED" | "FORBIDDEN" | "NO_DOCUMENT" | "DOCUMENT_EXISTS" | "LOCKED" | "CONFLICT" | "MISCONFIGURED";
+declare class DocError extends Error {
+    readonly code: DocErrorCode;
+    readonly matches: {
+        occurrence: number;
+        context: string;
+    }[];
+    constructor(code: DocErrorCode, message: string, matches?: {
+        occurrence: number;
+        context: string;
+    }[]);
+}
+
+declare const schema: Schema<string, string>;
+
+interface Message {
+    id: string;
+    at: string;
+    author: Principal;
+    body: string;
+}
+interface Thread {
+    id: string;
+    anchor: Anchor;
+    status: "open" | "resolved";
+    resolvedBy?: Principal;
+    resolvedAt?: string;
+    messages: Message[];
+    /** The anchored text no longer matches what the comment was made on. */
+    stale: boolean;
+    /** The text now under the anchor, or null when it is gone. */
+    currentText: string | null;
+}
+interface Suggestion {
+    id: string;
+    kind: "insert" | "replace" | "delete";
+    at?: "before" | "after";
+    anchor: Anchor;
+    replacement: string;
+    author: Principal;
+    createdAt: string;
+    status: "pending" | "accepted" | "rejected";
+    decidedBy?: Principal;
+    decidedAt?: string;
+    stale: boolean;
+}
+/** Comment threads anchored to text. Replies and status merge across replicas. */
+declare class Threads {
+    private readonly doc;
+    constructor(doc: AgenticDoc);
+    private get map();
+    private get;
+    private message;
+    add(target: TextTarget | AnchorTarget, body: string, author: Principal): string;
+    reply(id: string, body: string, author: Principal): void;
+    private setStatus;
+    resolve(id: string, author: Principal): void;
+    reopen(id: string, author: Principal): void;
+    list(filter?: {
+        status?: Thread["status"];
+    }): Thread[];
+}
+/** Suggested edits. Nothing changes in the text until a person, or an agent with the accept scope, accepts one. */
+declare class Suggestions {
+    private readonly doc;
+    constructor(doc: AgenticDoc);
+    private get map();
+    private get;
+    private read;
+    /** An `at` on the target means insert. An empty replacement means delete. */
+    add(target: TextTarget | AnchorTarget, replacement: string, author: Principal): string;
+    private decide;
+    /**
+     * Apply the edit as the accepting author. The check and the edit share one transaction. Accepting
+     * an accepted suggestion changes nothing. A stale anchor throws and the suggestion stays pending.
+     */
+    accept(id: string, author: Principal): void;
+    /** Same right as accept. A person can withdraw their own suggestion. An agent can never decide its own. */
+    reject(id: string, author: Principal): void;
+    list(filter?: {
+        status?: Suggestion["status"];
+    }): Suggestion[];
+}
+
+/** One table drives the CLI, the MCP server, and the HTTP API, so they stay the same. */
+interface Command {
+    name: string;
+    description: string;
+    shape: z.ZodRawShape;
+    readOnly: boolean;
+    run(service: DocsService, input: Record<string, unknown>, author: Principal | undefined): Promise<unknown>;
+}
+declare const commands: Command[];
+
+declare const EXPORT_FORMATS: readonly ["md", "html", "odt"];
+type ExportFormat = (typeof EXPORT_FORMATS)[number];
+interface ExportOptions {
+    /** Keep `<img>` for web and relative sources. Opening the page then asks those hosts for the image. Off by default. */
+    remoteImages?: boolean;
+}
+interface ExportResult {
+    format: ExportFormat;
+    contentType: string;
+    encoding: "utf8" | "base64";
+    data: string;
+}
+declare function exportDoc(doc: AgenticDoc, format: ExportFormat, options?: ExportOptions): ExportResult;
+
+interface FileBlobsOptions extends AdapterOptions {
+    /** A lock older than this is taken over. Default 10 seconds. A save takes milliseconds. */
+    lockStaleMs?: number;
+    /** How long a writer waits for a lock before it fails with LOCKED. Default 5 seconds. */
+    lockTimeoutMs?: number;
+}
+/**
+ * Blobs kept as files under one directory. File names are key hashes, so no key leaves the folder.
+ * A write takes a lock file, checks the condition again, then writes a temp file and renames it into
+ * place. A reader never sees a torn file, and two processes cannot both pass the version check.
+ */
+declare function createFileBlobs(dir: string, options?: FileBlobsOptions): Blobs;
+
+/**
+ * A Store kept in one file. The file holds every doc as one snapshot, saved through the file Blobs
+ * adapter with a conditional write. Each call loads the newest snapshot, so several processes (CLI
+ * runs, MCP servers) share one dataset. A transaction holds a lock file from its first read to its
+ * commit, so a rival write waits and lands after it. The conditional write is a second guard: if the
+ * lock was lost and the snapshot changed, the transaction runs again on the new snapshot.
+ * The store re-reads and re-writes the whole snapshot on each call: it suits a small local catalog.
+ */
+declare function createFileStore(dir: string, options?: AdapterOptions & Pick<FileBlobsOptions, "lockStaleMs" | "lockTimeoutMs"> & {
+    shared?: string;
+}): Store;
+
+declare const ODT_MIME = "application/vnd.oasis.opendocument.text";
+/** Write blocks as an OpenDocument text file (.odt): content, styles, and images as embedded files. */
+declare function exportOdt(blocks: PmNode[]): Uint8Array;
+
+export { AgenticDoc, Anchor, AnchorTarget, type Command, DocError, type DocErrorCode, DocsService, EXPORT_FORMATS, type ExportFormat, type ExportOptions, type ExportResult, type FileBlobsOptions, type Message, ODT_MIME, PmNode, Principal, type Suggestion, Suggestions, TextTarget, type Thread, Threads, commands, createFileBlobs, createFileStore, exportDoc, exportOdt, schema };

package/dist/index.js

@@ -0,0 +1,42 @@
+import {
+  createFileBlobs,
+  createFileStore
+} from "./chunk-BSXUNQDR.js";
+import {
+  DocsService
+} from "./chunk-LRPLNXOF.js";
+import {
+  AgenticDoc,
+  DocError,
+  EXPORT_FORMATS,
+  ODT_MIME,
+  PRINCIPAL_KINDS,
+  Suggestions,
+  Threads,
+  blocksToMarkdown,
+  commands,
+  exportDoc,
+  exportOdt,
+  markdownToBlocks,
+  parseAuthor,
+  schema
+} from "./chunk-4YVWD5PH.js";
+export {
+  AgenticDoc,
+  DocError,
+  DocsService,
+  EXPORT_FORMATS,
+  ODT_MIME,
+  PRINCIPAL_KINDS,
+  Suggestions,
+  Threads,
+  blocksToMarkdown,
+  commands,
+  createFileBlobs,
+  createFileStore,
+  exportDoc,
+  exportOdt,
+  markdownToBlocks,
+  parseAuthor,
+  schema
+};

package/dist/mcp-2VZIGHIX.js

@@ -0,0 +1,38 @@
+import {
+  VERSION
+} from "./chunk-5Y66UCTE.js";
+import {
+  DocError,
+  commands
+} from "./chunk-4YVWD5PH.js";
+
+// src/mcp.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+function createMcpServer(service, author) {
+  const server = new McpServer({ name: "agentic-documents", version: VERSION });
+  for (const command of commands) {
+    server.registerTool(
+      `doc_${command.name}`,
+      { description: command.description, inputSchema: command.shape, annotations: { readOnlyHint: command.readOnly } },
+      async (input) => {
+        try {
+          const result = await command.run(service, input, author);
+          return { content: [{ type: "text", text: typeof result === "string" ? result : JSON.stringify(result) }] };
+        } catch (error) {
+          if (!(error instanceof DocError)) throw error;
+          const body = { error: { code: error.code, message: error.message, matches: error.matches } };
+          return { content: [{ type: "text", text: JSON.stringify(body) }], isError: true };
+        }
+      }
+    );
+  }
+  return server;
+}
+async function startMcp(service, author) {
+  await createMcpServer(service, author).connect(new StdioServerTransport());
+}
+export {
+  createMcpServer,
+  startMcp
+};