@ecsplico/editor 0.0.0-stage → 2.0.0

package/dist/features/ai/ai-apply.d.ts

@@ -0,0 +1,76 @@
+import { Translate } from "../../i18n/index.js";
+import { Notice } from "../../core/notify.js";
+import { DocAnchor } from "../../core/doc-anchors.js";
+import "../../core/index.js";
+import { AiReviewSkipReason } from "./ai-review.js";
+import { AiApplyMode, AiTask } from "./protocol/tasks.js";
+import "./protocol/index.js";
+import { Editor, JSONContent } from "@tiptap/core";
+import { Transaction } from "@tiptap/pm/state";
+import { Fragment, ResolvedPos } from "@tiptap/pm/model";
+//#region src/features/ai/ai-apply.d.ts
+export type AiTarget = {
+  mode: 'replace-selection';
+  anchor: DocAnchor;
+} |
+/** Collapsed anchor after the caret's top-level block. */
+{
+  mode: 'insert-after-block';
+  anchor: DocAnchor;
+} |
+/** After the document's last block at apply time. */
+{
+  mode: 'append-to-document';
+};
+/**
+ * Captures the apply target when the run starts as a DocAnchor, so it survives concurrent edits while the result
+ * streams. Release the anchor (`releaseRanges`) when the run is applied or discarded.
+ */
+export declare function captureTarget(editor: Editor, mode: AiApplyMode): AiTarget;
+/** Markdown of [from, to] as the model gets it; `selectionMarkdown` for the current selection. */
+export declare function rangeMarkdown(editor: Editor, { from, to }: {
+  from: number;
+  to: number;
+}): string;
+export declare function selectionMarkdown(editor: Editor): string;
+/** Document Markdown for the model, truncated to `limit` characters (whole-document tasks pass `AI_LIMITS.transcript`). */
+export declare function documentMarkdown(editor: Editor, limit?: number): string;
+/** How a selection result is applied: over the captured range, or as blocks below its last top-level block. */
+export type AiResultAction = 'replace' | 'insert-below';
+/** 'ok': inserted ('insert-below') or opened as in-document review ('replace'); otherwise why nothing happened. */
+export type AiApplyOutcome = 'ok' | AiReviewSkipReason;
+/** Notice for an apply that did not happen, in the language of `t`. */
+export declare function aiApplyFailure(outcome: Exclude<AiApplyOutcome, 'ok'>, t: Translate): Notice & {
+  description: string;
+  kind: 'error' | 'info';
+};
+/**
+ * Applies a result to a range captured when the run started (see `captureRange`) — the apply entry point of the
+ * selection AI menu and the AI sidebar's block generation. 'replace' does not write: it opens an in-document diff
+ * review of the range (see `startAiReview`), and only accepted changes reach the document.
+ */
+export declare function applyAiResult(editor: Editor, action: AiResultAction, anchor: DocAnchor, markdown: string): AiApplyOutcome;
+/**
+ * The result of a task as markdown the way it is shown and applied: a task with a heading gets it (in the language of
+ * `t`) as `##` title (`withTaskHeading`), or as the single `formatAiResult` contributor formats it (composite AI wraps it in a section).
+ */
+export declare function formatTaskResult(editor: Editor, task: AiTask, markdown: string, t: Translate): string;
+/** Result blocks as they get inserted: parsed (`parseBlocks`) and brought into the preferred structure (`structureBlocks`). */
+export declare function resultBlocks(editor: Editor, markdown: string): JSONContent[];
+/** Inserts the result as blocks after the top-level block containing `pos`. */
+export declare function insertBlocksBelow(editor: Editor, pos: number, markdown: string): boolean;
+/**
+ * Inserts the result as blocks at an insertion target (`captureTarget`): after the captured block, or after the
+ * document's last block. False when the anchor no longer exists or the result has no content.
+ */
+export declare function insertBlocksAtTarget(editor: Editor, target: Exclude<AiTarget, {
+  mode: 'replace-selection';
+}>, markdown: string): boolean;
+/**
+ * Inserts a result at a caret captured when the run started (`captureRange` of a collapsed range): the result blocks
+ * replace the caret's textblock while it is still empty (the line `/ai` was typed on), otherwise they go below its
+ * top-level block. Not a rewrite, so no diff review. False when the caret no longer exists or the result has no content.
+ */
+export declare function insertAtCaretLine(editor: Editor, anchor: DocAnchor, markdown: string): boolean;
+//#endregion
+//# sourceMappingURL=ai-apply.d.ts.map

package/dist/features/ai/ai-apply.js

@@ -0,0 +1,193 @@
+import { isWrapperBlock } from "../../core/convert.js";
+import { formatAiResultOf, parseBlocks, structureBlocks } from "../../core/pipeline.js";
+import { captureRange, resolveRange } from "../../core/doc-anchors.js";
+import { selectionRange } from "../../core/selection-range.js";
+import { AI_LIMITS, withTaskHeading } from "./protocol/tasks.js";
+import { startAiReview } from "./ai-review.js";
+import { Slice } from "@tiptap/pm/model";
+//#region src/features/ai/ai-apply.ts
+/**
+* Captures the apply target when the run starts as a DocAnchor, so it survives concurrent edits while the result
+* streams. Release the anchor (`releaseRanges`) when the run is applied or discarded.
+*/
+function captureTarget(editor, mode) {
+	if (mode === "append-to-document") return { mode };
+	if (mode === "replace-selection") return {
+		mode,
+		anchor: captureRange(editor, selectionRange(editor.state))
+	};
+	const { $to } = editor.state.selection;
+	const pos = $to.depth ? $to.after(1) : $to.pos;
+	return {
+		mode,
+		anchor: captureRange(editor, {
+			from: pos,
+			to: pos
+		})
+	};
+}
+/** Markdown of [from, to] as the model gets it; `selectionMarkdown` for the current selection. */
+function rangeMarkdown(editor, { from, to }) {
+	const { doc } = editor.state;
+	const $from = doc.resolve(from);
+	const $to = doc.resolve(to);
+	if ($from.sameParent($to) && $from.parent.isTextblock) {
+		const content = $from.parent.slice($from.parentOffset, $to.parentOffset).content.toJSON();
+		return editor.markdown.serialize({
+			type: "doc",
+			content: [{
+				type: "paragraph",
+				content: content ?? []
+			}]
+		});
+	}
+	return editor.markdown.serialize(doc.cut(from, to).toJSON());
+}
+function selectionMarkdown(editor) {
+	return rangeMarkdown(editor, selectionRange(editor.state));
+}
+/** Document Markdown for the model, truncated to `limit` characters (whole-document tasks pass `AI_LIMITS.transcript`). */
+function documentMarkdown(editor, limit = AI_LIMITS.context) {
+	return editor.getMarkdown().slice(0, limit);
+}
+/** Catalog keys and severity of the notice of an apply that did not happen. */
+const AI_APPLY_FAILURES = {
+	missing: {
+		titleKey: "ai.apply.missing.title",
+		descriptionKey: "ai.apply.missing.description",
+		kind: "error"
+	},
+	empty: {
+		titleKey: "ai.apply.empty.title",
+		descriptionKey: "ai.apply.empty.description",
+		kind: "error"
+	},
+	unchanged: {
+		titleKey: "ai.apply.unchanged.title",
+		descriptionKey: "ai.apply.unchanged.description",
+		kind: "info"
+	},
+	overlap: {
+		titleKey: "ai.apply.overlap.title",
+		descriptionKey: "ai.apply.overlap.description",
+		kind: "error"
+	}
+};
+/** Notice for an apply that did not happen, in the language of `t`. */
+function aiApplyFailure(outcome, t) {
+	const { titleKey, descriptionKey, kind } = AI_APPLY_FAILURES[outcome];
+	return {
+		title: t(titleKey),
+		description: t(descriptionKey),
+		kind
+	};
+}
+/**
+* Applies a result to a range captured when the run started (see `captureRange`) — the apply entry point of the
+* selection AI menu and the AI sidebar's block generation. 'replace' does not write: it opens an in-document diff
+* review of the range (see `startAiReview`), and only accepted changes reach the document.
+*/
+function applyAiResult(editor, action, anchor, markdown) {
+	if (action === "replace") {
+		const review = startAiReview(editor, [{
+			id: "result",
+			range: anchor,
+			markdown
+		}]);
+		return review.hunks ? "ok" : review.skipped[0]?.reason ?? "unchanged";
+	}
+	const resolved = resolveRange(editor.state, anchor);
+	if (!resolved) return "missing";
+	return insertBlocksBelow(editor, resolved.to, markdown) ? "ok" : "empty";
+}
+/**
+* The inline content replacing [from, to] when both lie in one textblock and the result is a single paragraph or a
+* single block the segment stage made of one (e.g. a speaker line): inserted inline, since block content would split
+* the block. Null when the range needs a block replacement (`replaceRangeWithBlocks`). `parsed` is the result before
+* the segment stage (`parseBlocks`): such a block only keeps its own content inside a block of its own type (a speaker
+* line inside a segment keeps that segment's speaker, the model saw just the inline text, see `rangeMarkdown`); elsewhere
+* the label stays as the bold text the model wrote.
+*/
+function inlineReplacement($from, $to, { parsed, blocks }) {
+	const first = blocks[0];
+	if (!first || blocks.length !== 1 || !$from.sameParent($to) || !$from.parent.isTextblock) return null;
+	if (first.type === "paragraph") return first.content ?? [];
+	const original = parsed.content?.length === 1 ? parsed.content[0] : void 0;
+	if (original?.type !== "paragraph") return null;
+	return (first.type === $from.parent.type.name ? first.content : original.content) ?? [];
+}
+/**
+* Replaces exactly [from, to] in `tr` with `blocks`. The edge blocks merge into partially covered blocks, as a paste
+* would, so text outside the range survives; a defining textblock of another type (heading, speaker segment, code
+* block) is inserted whole instead and splits the block it lands in, and so is a host wrapper block (a callout in a
+* doc-level range, which would otherwise open up and only keep its body) unless the boundary already sits inside a
+* wrapper of that type (a callout's body), where it merges into that one instead of nesting a second.
+*/
+function replaceRangeWithBlocks(tr, from, to, blocks) {
+	const $from = tr.doc.resolve(from);
+	const $to = tr.doc.resolve(to);
+	const open = Slice.maxOpen(blocks);
+	const keepWhole = (node, $pos) => {
+		if (isWrapperBlock(node)) {
+			for (let d = 0; d <= $pos.depth; d++) if ($pos.node(d).type === node.type) return false;
+			return true;
+		}
+		return node.isTextblock && !!node.type.spec.defining && node.type !== $pos.parent.type;
+	};
+	const slice = new Slice(blocks, keepWhole(blocks.firstChild, $from) ? 0 : open.openStart, keepWhole(blocks.lastChild, $to) ? 0 : open.openEnd);
+	const steps = tr.steps.length;
+	tr.replace(from, to, slice);
+	if (tr.steps.length === steps) tr.replaceRange(from, to, slice);
+}
+/**
+* The result of a task as markdown the way it is shown and applied: a task with a heading gets it (in the language of
+* `t`) as `##` title (`withTaskHeading`), or as the single `formatAiResult` contributor formats it (composite AI wraps it in a section).
+*/
+function formatTaskResult(editor, task, markdown, t) {
+	if (!task.headingKey) return markdown;
+	const format = formatAiResultOf(editor);
+	return format ? format(markdown, t(task.headingKey)) : withTaskHeading(task, markdown, t);
+}
+/** Result blocks as they get inserted: parsed (`parseBlocks`) and brought into the preferred structure (`structureBlocks`). */
+function resultBlocks(editor, markdown) {
+	return structureBlocks(editor, parseBlocks(editor, markdown).blocks);
+}
+/** Inserts the result as blocks after the top-level block containing `pos`. */
+function insertBlocksBelow(editor, pos, markdown) {
+	const blocks = resultBlocks(editor, markdown);
+	if (!blocks.length) return false;
+	const $pos = editor.state.doc.resolve(pos);
+	return editor.chain().focus().insertContentAt($pos.depth === 0 ? pos : $pos.after(1), blocks).run();
+}
+/**
+* Inserts the result as blocks at an insertion target (`captureTarget`): after the captured block, or after the
+* document's last block. False when the anchor no longer exists or the result has no content.
+*/
+function insertBlocksAtTarget(editor, target, markdown) {
+	if (target.mode === "append-to-document") return insertBlocksBelow(editor, editor.state.doc.content.size, markdown);
+	const resolved = resolveRange(editor.state, target.anchor);
+	if (!resolved) return false;
+	return insertBlocksBelow(editor, resolved.from, markdown);
+}
+/**
+* Inserts a result at a caret captured when the run started (`captureRange` of a collapsed range): the result blocks
+* replace the caret's textblock while it is still empty (the line `/ai` was typed on), otherwise they go below its
+* top-level block. Not a rewrite, so no diff review. False when the caret no longer exists or the result has no content.
+*/
+function insertAtCaretLine(editor, anchor, markdown) {
+	const resolved = resolveRange(editor.state, anchor);
+	if (!resolved) return false;
+	const blocks = resultBlocks(editor, markdown);
+	if (!blocks.length) return false;
+	const $pos = editor.state.doc.resolve(resolved.from);
+	if ($pos.depth === 0) return editor.chain().focus().insertContentAt(resolved.from, blocks).run();
+	const line = $pos.parent.isTextblock && !$pos.parent.content.size ? {
+		from: $pos.before(),
+		to: $pos.after()
+	} : $pos.after(1);
+	return editor.chain().focus().insertContentAt(line, blocks).run();
+}
+//#endregion
+export { aiApplyFailure, applyAiResult, captureTarget, documentMarkdown, formatTaskResult, inlineReplacement, insertAtCaretLine, insertBlocksAtTarget, insertBlocksBelow, rangeMarkdown, replaceRangeWithBlocks, resultBlocks, selectionMarkdown };
+
+//# sourceMappingURL=ai-apply.js.map

package/dist/features/ai/ai-apply.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-apply.js","names":[],"sources":["../../../src/features/ai/ai-apply.ts"],"sourcesContent":["import type { Editor, JSONContent } from '@tiptap/core'\nimport { type Fragment, type Node as PMNode, type ResolvedPos, Slice } from '@tiptap/pm/model'\nimport type { EditorState, Transaction } from '@tiptap/pm/state'\nimport { captureRange, type DocAnchor, formatAiResultOf, isWrapperBlock, parseBlocks, resolveRange, selectionRange, structureBlocks } from '../../core'\nimport type { Notice } from '../../core/notify'\nimport type { MessageKey, Translate } from '../../i18n'\nimport { type AiReviewSkipReason, startAiReview } from './ai-review'\nimport { type AiApplyMode, AI_LIMITS, type AiTask, withTaskHeading } from './protocol'\n\nexport type AiTarget =\n  | { mode: 'replace-selection', anchor: DocAnchor }\n  /** Collapsed anchor after the caret's top-level block. */\n  | { mode: 'insert-after-block', anchor: DocAnchor }\n  /** After the document's last block at apply time. */\n  | { mode: 'append-to-document' }\n\n/**\n * Captures the apply target when the run starts as a DocAnchor, so it survives concurrent edits while the result\n * streams. Release the anchor (`releaseRanges`) when the run is applied or discarded.\n */\nexport function captureTarget(editor: Editor, mode: AiApplyMode): AiTarget {\n  if (mode === 'append-to-document') return { mode }\n  if (mode === 'replace-selection') return { mode, anchor: captureRange(editor, selectionRange(editor.state)) }\n  const { $to } = editor.state.selection\n  const pos = $to.depth ? $to.after(1) : $to.pos\n  return { mode, anchor: captureRange(editor, { from: pos, to: pos }) }\n}\n\n/** Markdown of [from, to] as the model gets it; `selectionMarkdown` for the current selection. */\nexport function rangeMarkdown(editor: Editor, { from, to }: { from: number, to: number }): string {\n  const { doc } = editor.state\n  const $from = doc.resolve(from)\n  const $to = doc.resolve(to)\n  // Single-textblock selections are replaced inline, so send only the inline content: node prefixes (speaker, `#`, list marker) would be echoed into the text.\n  if ($from.sameParent($to) && $from.parent.isTextblock) {\n    const content = $from.parent.slice($from.parentOffset, $to.parentOffset).content.toJSON()\n    return editor.markdown!.serialize({ type: 'doc', content: [{ type: 'paragraph', content: content ?? [] }] })\n  }\n  return editor.markdown!.serialize(doc.cut(from, to).toJSON())\n}\n\nexport function selectionMarkdown(editor: Editor): string {\n  return rangeMarkdown(editor, selectionRange(editor.state))\n}\n\n/** Document Markdown for the model, truncated to `limit` characters (whole-document tasks pass `AI_LIMITS.transcript`). */\nexport function documentMarkdown(editor: Editor, limit: number = AI_LIMITS.context): string {\n  return editor.getMarkdown().slice(0, limit)\n}\n\n/** How a selection result is applied: over the captured range, or as blocks below its last top-level block. */\nexport type AiResultAction = 'replace' | 'insert-below'\n\n/** 'ok': inserted ('insert-below') or opened as in-document review ('replace'); otherwise why nothing happened. */\nexport type AiApplyOutcome = 'ok' | AiReviewSkipReason\n\n/** Catalog keys and severity of the notice of an apply that did not happen. */\nconst AI_APPLY_FAILURES: Record<Exclude<AiApplyOutcome, 'ok'>, { titleKey: MessageKey, descriptionKey: MessageKey, kind: 'error' | 'info' }> = {\n  missing: { titleKey: 'ai.apply.missing.title', descriptionKey: 'ai.apply.missing.description', kind: 'error' },\n  empty: { titleKey: 'ai.apply.empty.title', descriptionKey: 'ai.apply.empty.description', kind: 'error' },\n  unchanged: { titleKey: 'ai.apply.unchanged.title', descriptionKey: 'ai.apply.unchanged.description', kind: 'info' },\n  overlap: { titleKey: 'ai.apply.overlap.title', descriptionKey: 'ai.apply.overlap.description', kind: 'error' },\n}\n\n/** Notice for an apply that did not happen, in the language of `t`. */\nexport function aiApplyFailure(outcome: Exclude<AiApplyOutcome, 'ok'>, t: Translate): Notice & { description: string, kind: 'error' | 'info' } {\n  const { titleKey, descriptionKey, kind } = AI_APPLY_FAILURES[outcome]\n  return { title: t(titleKey), description: t(descriptionKey), kind }\n}\n\n/**\n * Applies a result to a range captured when the run started (see `captureRange`) — the apply entry point of the\n * selection AI menu and the AI sidebar's block generation. 'replace' does not write: it opens an in-document diff\n * review of the range (see `startAiReview`), and only accepted changes reach the document.\n */\nexport function applyAiResult(editor: Editor, action: AiResultAction, anchor: DocAnchor, markdown: string): AiApplyOutcome {\n  if (action === 'replace') {\n    const review = startAiReview(editor, [{ id: 'result', range: anchor, markdown }])\n    return review.hunks ? 'ok' : review.skipped[0]?.reason ?? 'unchanged'\n  }\n  const resolved = resolveRange(editor.state, anchor)\n  if (!resolved) return 'missing'\n  return insertBlocksBelow(editor, resolved.to, markdown) ? 'ok' : 'empty'\n}\n\n/**\n * The inline content replacing [from, to] when both lie in one textblock and the result is a single paragraph or a\n * single block the segment stage made of one (e.g. a speaker line): inserted inline, since block content would split\n * the block. Null when the range needs a block replacement (`replaceRangeWithBlocks`). `parsed` is the result before\n * the segment stage (`parseBlocks`): such a block only keeps its own content inside a block of its own type (a speaker\n * line inside a segment keeps that segment's speaker, the model saw just the inline text, see `rangeMarkdown`); elsewhere\n * the label stays as the bold text the model wrote.\n */\nexport function inlineReplacement($from: ResolvedPos, $to: ResolvedPos, { parsed, blocks }: { parsed: JSONContent, blocks: JSONContent[] }): JSONContent[] | null {\n  const first = blocks[0]\n  if (!first || blocks.length !== 1 || !$from.sameParent($to) || !$from.parent.isTextblock) return null\n  if (first.type === 'paragraph') return first.content ?? []\n  const original = parsed.content?.length === 1 ? parsed.content[0] : undefined\n  if (original?.type !== 'paragraph') return null\n  return (first.type === $from.parent.type.name ? first.content : original.content) ?? []\n}\n\n/**\n * Replaces exactly [from, to] in `tr` with `blocks`. The edge blocks merge into partially covered blocks, as a paste\n * would, so text outside the range survives; a defining textblock of another type (heading, speaker segment, code\n * block) is inserted whole instead and splits the block it lands in, and so is a host wrapper block (a callout in a\n * doc-level range, which would otherwise open up and only keep its body) unless the boundary already sits inside a\n * wrapper of that type (a callout's body), where it merges into that one instead of nesting a second.\n */\nexport function replaceRangeWithBlocks(tr: Transaction, from: number, to: number, blocks: Fragment): void {\n  const $from = tr.doc.resolve(from)\n  const $to = tr.doc.resolve(to)\n  const open = Slice.maxOpen(blocks)\n  const keepWhole = (node: PMNode, $pos: ResolvedPos) => {\n    if (isWrapperBlock(node)) {\n      for (let d = 0; d <= $pos.depth; d++) if ($pos.node(d).type === node.type) return false\n      return true\n    }\n    return node.isTextblock && !!node.type.spec.defining && node.type !== $pos.parent.type\n  }\n  const slice = new Slice(\n    blocks,\n    keepWhole(blocks.firstChild!, $from) ? 0 : open.openStart,\n    keepWhole(blocks.lastChild!, $to) ? 0 : open.openEnd,\n  )\n  const steps = tr.steps.length\n  tr.replace(from, to, slice)\n  // replace() gives up when the slice does not fit the range's context; replaceRange() then finds a fitting depth.\n  if (tr.steps.length === steps) tr.replaceRange(from, to, slice)\n}\n\n/**\n * The result of a task as markdown the way it is shown and applied: a task with a heading gets it (in the language of\n * `t`) as `##` title (`withTaskHeading`), or as the single `formatAiResult` contributor formats it (composite AI wraps it in a section).\n */\nexport function formatTaskResult(editor: Editor, task: AiTask, markdown: string, t: Translate): string {\n  if (!task.headingKey) return markdown\n  const format = formatAiResultOf(editor)\n  return format ? format(markdown, t(task.headingKey)) : withTaskHeading(task, markdown, t)\n}\n\n/** Result blocks as they get inserted: parsed (`parseBlocks`) and brought into the preferred structure (`structureBlocks`). */\nexport function resultBlocks(editor: Editor, markdown: string): JSONContent[] {\n  return structureBlocks(editor, parseBlocks(editor, markdown).blocks)\n}\n\n/** Inserts the result as blocks after the top-level block containing `pos`. */\nexport function insertBlocksBelow(editor: Editor, pos: number, markdown: string): boolean {\n  const blocks = resultBlocks(editor, markdown)\n  if (!blocks.length) return false\n  const $pos = editor.state.doc.resolve(pos)\n  return editor.chain().focus().insertContentAt($pos.depth === 0 ? pos : $pos.after(1), blocks).run()\n}\n\n/**\n * Inserts the result as blocks at an insertion target (`captureTarget`): after the captured block, or after the\n * document's last block. False when the anchor no longer exists or the result has no content.\n */\nexport function insertBlocksAtTarget(editor: Editor, target: Exclude<AiTarget, { mode: 'replace-selection' }>, markdown: string): boolean {\n  if (target.mode === 'append-to-document') return insertBlocksBelow(editor, editor.state.doc.content.size, markdown)\n  const resolved = resolveRange(editor.state, target.anchor)\n  if (!resolved) return false\n  return insertBlocksBelow(editor, resolved.from, markdown)\n}\n\n/**\n * Inserts a result at a caret captured when the run started (`captureRange` of a collapsed range): the result blocks\n * replace the caret's textblock while it is still empty (the line `/ai` was typed on), otherwise they go below its\n * top-level block. Not a rewrite, so no diff review. False when the caret no longer exists or the result has no content.\n */\nexport function insertAtCaretLine(editor: Editor, anchor: DocAnchor, markdown: string): boolean {\n  const resolved = resolveRange(editor.state, anchor)\n  if (!resolved) return false\n  const blocks = resultBlocks(editor, markdown)\n  if (!blocks.length) return false\n  const $pos = editor.state.doc.resolve(resolved.from)\n  if ($pos.depth === 0) return editor.chain().focus().insertContentAt(resolved.from, blocks).run()\n  const line = $pos.parent.isTextblock && !$pos.parent.content.size\n    ? { from: $pos.before(), to: $pos.after() }\n    : $pos.after(1)\n  return editor.chain().focus().insertContentAt(line, blocks).run()\n}\n"],"mappings":"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"}

package/dist/features/ai/ai-menu.d.ts

@@ -0,0 +1,38 @@
+import { Editor } from "@tiptap/core";
+//#region src/features/ai/ai-menu.d.ts
+/** Transaction meta the AI menu (`AiSelectionMenu`) listens for: open anchored at the caret, without a selection. */
+export declare const AI_MENU_AT_CARET = "aiMenuAtCaret";
+export declare function openAiMenuAtCaret(editor: Editor): void;
+/** Transaction meta the AI menu (`AiSelectionMenu`) listens for: open on the current selection (e.g. a hover block action). */
+export declare const AI_MENU_FOR_SELECTION = "aiMenuForSelection";
+export declare function openAiMenuForSelection(editor: Editor): void;
+/**
+ * An extra row of the AI selection menu, contributed by any extension through its `aiMenuActions` field (the way
+ * `NodeFlags` reads `editorChrome`): integration features add their own AI operations on the selection this way.
+ */
+export interface AiMenuAction {
+  id: string;
+  label: string;
+  /** Iconify name, e.g. `i-lucide-eraser`. */
+  icon: string;
+  /** Offered while the selection `range` qualifies; always offered when unset. */
+  available?: (editor: Editor, range: {
+    from: number;
+    to: number;
+  }) => boolean;
+  /** Runs on the selection captured when the menu opened; `signal` aborts when the menu closes. The menu closes afterwards. */
+  run: (editor: Editor, range: {
+    from: number;
+    to: number;
+  }, signal: AbortSignal) => Promise<unknown> | void;
+}
+declare module '@tiptap/core' {
+  interface ExtensionConfig<Options, Storage> {
+    /** Extra actions of the AI selection menu (`AiMenuAction`). */
+    aiMenuActions?: readonly AiMenuAction[];
+  }
+}
+/** The AI menu actions of every extension of `editor`, in extension order. */
+export declare function aiMenuActionsOf(editor: Editor): AiMenuAction[];
+//#endregion
+//# sourceMappingURL=ai-menu.d.ts.map

package/dist/features/ai/ai-menu.js

@@ -0,0 +1,20 @@
+import { getExtensionField } from "@tiptap/core";
+//#region src/features/ai/ai-menu.ts
+/** Transaction meta the AI menu (`AiSelectionMenu`) listens for: open anchored at the caret, without a selection. */
+const AI_MENU_AT_CARET = "aiMenuAtCaret";
+function openAiMenuAtCaret(editor) {
+	editor.view.dispatch(editor.state.tr.setMeta(AI_MENU_AT_CARET, true).setMeta("addToHistory", false));
+}
+/** Transaction meta the AI menu (`AiSelectionMenu`) listens for: open on the current selection (e.g. a hover block action). */
+const AI_MENU_FOR_SELECTION = "aiMenuForSelection";
+function openAiMenuForSelection(editor) {
+	editor.view.dispatch(editor.state.tr.setMeta(AI_MENU_FOR_SELECTION, true).setMeta("addToHistory", false));
+}
+/** The AI menu actions of every extension of `editor`, in extension order. */
+function aiMenuActionsOf(editor) {
+	return editor.extensionManager.extensions.flatMap((extension) => getExtensionField(extension, "aiMenuActions") ?? []);
+}
+//#endregion
+export { AI_MENU_AT_CARET, AI_MENU_FOR_SELECTION, aiMenuActionsOf, openAiMenuAtCaret, openAiMenuForSelection };
+
+//# sourceMappingURL=ai-menu.js.map

package/dist/features/ai/ai-menu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-menu.js","names":[],"sources":["../../../src/features/ai/ai-menu.ts"],"sourcesContent":["import { type Editor, getExtensionField } from '@tiptap/core'\n\n/** Transaction meta the AI menu (`AiSelectionMenu`) listens for: open anchored at the caret, without a selection. */\nexport const AI_MENU_AT_CARET = 'aiMenuAtCaret'\n\nexport function openAiMenuAtCaret(editor: Editor): void {\n  editor.view.dispatch(editor.state.tr.setMeta(AI_MENU_AT_CARET, true).setMeta('addToHistory', false))\n}\n\n/** Transaction meta the AI menu (`AiSelectionMenu`) listens for: open on the current selection (e.g. a hover block action). */\nexport const AI_MENU_FOR_SELECTION = 'aiMenuForSelection'\n\nexport function openAiMenuForSelection(editor: Editor): void {\n  editor.view.dispatch(editor.state.tr.setMeta(AI_MENU_FOR_SELECTION, true).setMeta('addToHistory', false))\n}\n\n/**\n * An extra row of the AI selection menu, contributed by any extension through its `aiMenuActions` field (the way\n * `NodeFlags` reads `editorChrome`): integration features add their own AI operations on the selection this way.\n */\nexport interface AiMenuAction {\n  id: string\n  label: string\n  /** Iconify name, e.g. `i-lucide-eraser`. */\n  icon: string\n  /** Offered while the selection `range` qualifies; always offered when unset. */\n  available?: (editor: Editor, range: { from: number, to: number }) => boolean\n  /** Runs on the selection captured when the menu opened; `signal` aborts when the menu closes. The menu closes afterwards. */\n  run: (editor: Editor, range: { from: number, to: number }, signal: AbortSignal) => Promise<unknown> | void\n}\n\ndeclare module '@tiptap/core' {\n  interface ExtensionConfig<Options, Storage> {\n    /** Extra actions of the AI selection menu (`AiMenuAction`). */\n    aiMenuActions?: readonly AiMenuAction[]\n  }\n}\n\n/** The AI menu actions of every extension of `editor`, in extension order. */\nexport function aiMenuActionsOf(editor: Editor): AiMenuAction[] {\n  return editor.extensionManager.extensions.flatMap(extension => getExtensionField<readonly AiMenuAction[] | undefined>(extension, 'aiMenuActions') ?? [])\n}\n"],"mappings":";;;AAGA,MAAa,mBAAmB;AAEhC,SAAgB,kBAAkB,QAAsB;CACtD,OAAO,KAAK,SAAS,OAAO,MAAM,GAAG,QAAQ,kBAAkB,IAAI,CAAC,CAAC,QAAQ,gBAAgB,KAAK,CAAC;AACrG;;AAGA,MAAa,wBAAwB;AAErC,SAAgB,uBAAuB,QAAsB;CAC3D,OAAO,KAAK,SAAS,OAAO,MAAM,GAAG,QAAQ,uBAAuB,IAAI,CAAC,CAAC,QAAQ,gBAAgB,KAAK,CAAC;AAC1G;;AAyBA,SAAgB,gBAAgB,QAAgC;CAC9D,OAAO,OAAO,iBAAiB,WAAW,SAAQ,cAAa,kBAAuD,WAAW,eAAe,KAAK,CAAC,CAAC;AACzJ"}

package/dist/features/ai/ai-review.d.ts

@@ -0,0 +1,136 @@
+import { DocAnchor } from "../../core/doc-anchors.js";
+import "../../core/index.js";
+import { Editor, Extension } from "@tiptap/core";
+import { PluginKey } from "@tiptap/pm/state";
+import { Fragment, Node as Node$1 } from "@tiptap/pm/model";
+import { DecorationSet, EditorView } from "@tiptap/pm/view";
+//#region src/features/ai/ai-review.d.ts
+/**
+ * A proposed change; `id` is the caller's. 'replace' (default): `markdown` (the model's result) replaces the captured
+ * `range`. 'blocks': ready-made `blocks` (a block conversion) replace `range` as one block hunk. 'insert': `markdown`
+ * as blocks at `at`, a collapsed range between blocks (e.g. after a block). 'delete': `range` covers exactly one
+ * block, which is removed.
+ */
+export type AiReviewChange = {
+  id: string;
+  kind?: 'replace';
+  range: DocAnchor;
+  markdown: string;
+} | {
+  id: string;
+  kind: 'blocks';
+  range: DocAnchor;
+  blocks: Fragment;
+} | {
+  id: string;
+  kind: 'insert';
+  at: DocAnchor;
+  markdown: string;
+} | {
+  id: string;
+  kind: 'delete';
+  range: DocAnchor;
+};
+/** Why a change got no review: range gone, result identical, range overlaps a pending review, or empty result. */
+export type AiReviewSkipReason = 'missing' | 'unchanged' | 'overlap' | 'empty';
+export type AiReviewOutcome = 'accepted' | 'rejected' | 'invalid';
+/** One decided hunk; 'invalid': dropped because the original text changed underneath. */
+export interface AiReviewDecision {
+  reviewId: string;
+  changeId: string;
+  hunkId: string;
+  outcome: AiReviewOutcome;
+}
+/** Per change of a finished review: hunk counts, and 'partial' when its hunks were decided differently. */
+export interface AiReviewChangeSummary {
+  id: string;
+  outcome: AiReviewOutcome | 'partial';
+  accepted: number;
+  rejected: number;
+  invalid: number;
+}
+export interface AiReviewOptions {
+  /** Decisions as they happen, batched per transaction. */
+  onDecision?: (decisions: AiReviewDecision[]) => void;
+  /** Once every hunk of the review is decided. */
+  onDone?: (summary: AiReviewChangeSummary[]) => void;
+}
+/** `hunks === 0`: no review started (every change skipped). */
+export interface AiReviewHandle {
+  id: string;
+  hunks: number;
+  skipped: {
+    id: string;
+    reason: AiReviewSkipReason;
+  }[];
+  /** Rejects the review's pending hunks. */
+  cancel: () => void;
+}
+/**
+ * One reviewable difference: [from, to] of the document replaced by `insert` on accept.
+ * 'inline': a word-level change inside one textblock (`original` = its inline content);
+ * 'block': the whole range replaced by blocks, since the result's structure differs (`original` = its text);
+ * 'insert': blocks inserted at the collapsed position `from === to` between blocks;
+ * 'delete': the one block [from, to] removed (`original` = that block, `insert` empty).
+ */
+export type AiReviewHunk = {
+  id: string;
+  reviewId: string;
+  changeId: string;
+  from: number;
+  to: number;
+  insert: Fragment;
+  /**
+   * Edit-surviving [from, to] (DocAnchors), released when the hunk is decided. Bound to the range's own first and
+   * last characters, so text inserted at a boundary (here or remotely) stays outside.
+   */
+  anchor: DocAnchor;
+} & ({
+  kind: 'inline';
+  original: Fragment;
+} | {
+  kind: 'block';
+  original: string;
+} | {
+  kind: 'insert';
+} | {
+  kind: 'delete';
+  original: Node$1;
+});
+export interface AiReviewState {
+  /** Pending hunks, in document order. */
+  hunks: readonly AiReviewHunk[];
+  /** The clicked hunk, whose accept/reject controls are shown. */
+  active: string | null;
+  /** The latest decisions (oldest first); `logEnd` counts all decisions ever made. */
+  log: readonly AiReviewDecision[];
+  logEnd: number;
+  decorations: DecorationSet;
+}
+export declare const aiReviewKey: PluginKey<AiReviewState>;
+/**
+ * In-document review of AI rewrites: the difference between a range and its proposed replacement shows as local
+ * decorations only (red strike = deletion, green widget = insertion), so collaborators never see unaccepted text.
+ * Accepting writes the accepted hunks in one transaction (one undo step); rejecting only drops decorations.
+ * Client-only, not part of `schemaExtensions()`. Driven by `startAiReview`, `acceptAiReview`, `rejectAiReview`;
+ * AiReviewBar shows the controls.
+ */
+export declare const AiReview: Extension<any, any>;
+/**
+ * Opens a review of `changes` (independent, non-overlapping ranges; several reviews may be pending at once). A
+ * replacement becomes word-level hunks per textblock when the result has the range's block structure, otherwise one
+ * block-level hunk; an insertion or deletion is one hunk. Changes that cannot be reviewed are returned as `skipped`.
+ */
+export declare function startAiReview(editor: Editor, changes: readonly AiReviewChange[], options?: AiReviewOptions): AiReviewHandle;
+/**
+ * Writes the pending hunks `ids` (all when omitted) in one transaction — one undo step of its own: y-undo (collaborative)
+ * or prosemirror-history (standalone) would merge it with typing around it within their grouping delay, so the event is
+ * closed before and after.
+ */
+export declare function acceptAiReview(editor: Editor, ids?: readonly string[]): void;
+/** Drops the pending hunks `ids` (all when omitted); the document and undo history stay untouched. */
+export declare function rejectAiReview(editor: Editor, ids?: readonly string[]): void;
+/** Shows the controls of hunk `id` (null hides them). */
+export declare function setActiveAiReviewHunk(view: EditorView, id: string | null): void;
+//#endregion
+//# sourceMappingURL=ai-review.d.ts.map