@meistrari/minuta-nuxt 0.1.0

package/dist/runtime/components/MinutaIcon.vue

@@ -0,0 +1,53 @@
+<script setup lang="ts">
+import { computed } from 'vue'
+import {
+    PhArrowUUpLeft,
+    PhArrowUUpRight,
+    PhArrowsOutLineHorizontal,
+    PhArrowsOutLineVertical,
+    PhEraser,
+    PhHighlighter,
+    PhImage,
+    PhListBullets,
+    PhListNumbers,
+    PhTextAlignCenter,
+    PhTextAlignJustify,
+    PhTextAlignLeft,
+    PhTextAlignRight,
+    PhNote,
+    PhTextT,
+    PhRectangle,
+    PhTrash,
+    PhX,
+} from '@phosphor-icons/vue'
+
+const props = defineProps<{ name: string }>()
+
+/** Substituto local do TelaIcon (tela-build) — só os ícones que o editor usa. */
+const ICONS: Record<string, unknown> = {
+    'i-ph-arrow-u-up-left': PhArrowUUpLeft,
+    'i-ph-arrow-u-up-right': PhArrowUUpRight,
+    'i-ph-arrows-out-line-horizontal': PhArrowsOutLineHorizontal,
+    'i-ph-arrows-out-line-vertical': PhArrowsOutLineVertical,
+    'i-ph-eraser': PhEraser,
+    'i-ph-highlighter': PhHighlighter,
+    'i-ph-image': PhImage,
+    'i-ph-list-bullets': PhListBullets,
+    'i-ph-list-numbers': PhListNumbers,
+    'i-ph-text-align-center': PhTextAlignCenter,
+    'i-ph-text-align-justify': PhTextAlignJustify,
+    'i-ph-text-align-left': PhTextAlignLeft,
+    'i-ph-text-align-right': PhTextAlignRight,
+    'i-ph-note': PhNote,
+    'i-ph-text-t': PhTextT,
+    'i-ph-rectangle': PhRectangle,
+    'i-ph-trash': PhTrash,
+    'i-ph-x': PhX,
+}
+
+const icon = computed(() => ICONS[props.name] ?? null)
+</script>
+
+<template>
+    <component :is="icon" v-if="icon" :size="16" />
+</template>

package/dist/runtime/composables/annotationAnchors.d.ts

@@ -0,0 +1,73 @@
+import type { Editor } from '@tiptap/core';
+/**
+ * Âncoras das anotações da análise (comentários de margem estilo Google Docs):
+ * localiza no documento o trecho exato (ou o título da seção) de cada item,
+ * dá as coordenadas pro gutter posicionar os cards e faz o highlight/scroll
+ * quando um card é clicado.
+ */
+export interface AnnotationTarget {
+    /** trecho verbatim da minuta (preferido — vem do agente) */
+    trecho?: string | null;
+    /** título da seção onde o item aparece (fallback) */
+    onde?: string | null;
+}
+/** range PM de um recorte verbatim do documento (busca whitespace-tolerante) */
+export declare function findTextRange(editor: Editor, needle: string): {
+    from: number;
+    to: number;
+} | null;
+export interface LocatedAnnotation {
+    range: {
+        from: number;
+        to: number;
+    };
+    /** como o range foi encontrado: trecho verbatim ou título da seção */
+    matchedBy: 'trecho' | 'onde';
+}
+/** localiza o range do item, dizendo por qual caminho: trecho verbatim primeiro, título da seção depois */
+export declare function locateAnnotationDetailed(editor: Editor, target: AnnotationTarget): LocatedAnnotation | null;
+/** localiza o range do item: trecho verbatim primeiro, título da seção depois */
+export declare function locateAnnotation(editor: Editor, target: AnnotationTarget): {
+    from: number;
+    to: number;
+} | null;
+/** y do range relativo a um elemento-referência (para posicionar o card) */
+export declare function annotationY(editor: Editor, from: number, reference: HTMLElement): number | null;
+/** `manual` = trecho que o usuário editou — a âncora original não vale mais */
+export type AnnotationKind = 'tese' | 'jurisprudencia' | 'citacao' | 'fato' | 'manual';
+export interface AnnotationDecoration {
+    /** identidade estável do item (pra recuperar o range mapeado após edições) */
+    id: string;
+    from: number;
+    to: number;
+    kind: AnnotationKind;
+    /** card ativo na margem → highlight mais forte */
+    active?: boolean;
+}
+/** aplica (ou substitui) o conjunto de highlights da análise no documento */
+export declare function applyAnnotationDecorations(editor: Editor, items: AnnotationDecoration[] | null): void;
+/**
+ * Ranges atuais das decorações, MAPEADOS pelas edições desde a última
+ * aplicação — é assim que um trecho editado continua rastreável mesmo quando
+ * a busca verbatim já não o encontra.
+ */
+export declare function getAnnotationDecorationRanges(editor: Editor): Map<string, {
+    from: number;
+    to: number;
+}>;
+/** meta que marca transações programáticas (chat, restore, troca de versão) */
+export declare const PROGRAMMATIC_META = "minutaProgrammatic";
+/** liga o rastro de edições do usuário (idempotente) */
+export declare function trackUserEdits(editor: Editor): void;
+/** ranges atuais do texto adicionado pelo usuário */
+export declare function getUserEditRanges(editor: Editor): Array<{
+    from: number;
+    to: number;
+}>;
+/** substitui o rastro (rehydratação a partir da analysis persistida) */
+export declare function setUserEditRanges(editor: Editor, ranges: Array<{
+    from: number;
+    to: number;
+}>): void;
+/** rola o container até o range da anotação */
+export declare function scrollToAnnotation(editor: Editor, from: number, scrollContainer?: HTMLElement | null): void;

package/dist/runtime/composables/annotationAnchors.js

@@ -0,0 +1,243 @@
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+const norm = (text) => text.toLowerCase().replace(/\s+/g, " ").trim();
+function buildTextIndex(editor) {
+  const chunks = [];
+  const posAt = [];
+  editor.state.doc.descendants((node, pos) => {
+    if (node.isText && node.text) {
+      for (let i = 0; i < node.text.length; i++) {
+        chunks.push(node.text[i]);
+        posAt.push(pos + i);
+      }
+    } else if (node.isBlock && chunks.length && chunks[chunks.length - 1] !== " ") {
+      chunks.push(" ");
+      posAt.push(pos);
+    }
+    return true;
+  });
+  return { text: chunks.join(""), posAt };
+}
+function findRange(text, posAt, needle) {
+  const target = norm(needle);
+  if (!target)
+    return null;
+  const lower = text.toLowerCase();
+  const idx = lower.indexOf(target);
+  if (idx >= 0)
+    return { from: posAt[idx], to: posAt[idx + target.length - 1] + 1 };
+  const isWs = (c) => /\s/.test(c);
+  for (let start = 0; start < lower.length; start++) {
+    if (lower[start] !== target[0])
+      continue;
+    let i = start;
+    let j = 0;
+    while (i < lower.length && j < target.length) {
+      if (lower[i] === target[j]) {
+        i++;
+        j++;
+      } else if (isWs(lower[i]) && target[j] === " ") {
+        while (i < lower.length && isWs(lower[i])) i++;
+        j++;
+      } else if (isWs(lower[i])) {
+        i++;
+      } else {
+        break;
+      }
+    }
+    if (j === target.length)
+      return { from: posAt[start], to: posAt[i - 1] + 1 };
+  }
+  return null;
+}
+export function findTextRange(editor, needle) {
+  const { text, posAt } = buildTextIndex(editor);
+  if (!text.length)
+    return null;
+  return findRange(text, posAt, needle);
+}
+export function locateAnnotationDetailed(editor, target) {
+  const { text, posAt } = buildTextIndex(editor);
+  if (!text.length)
+    return null;
+  if (target.trecho) {
+    const range = findRange(text, posAt, target.trecho);
+    if (range)
+      return { range, matchedBy: "trecho" };
+  }
+  if (target.onde) {
+    const candidates = [target.onde, target.onde.replace(/^[IVXLCDM\d]+\s*[—\-–.)]\s*/i, "")];
+    for (const candidate of candidates) {
+      if (!candidate.trim())
+        continue;
+      const range = findRange(text, posAt, candidate);
+      if (range)
+        return { range, matchedBy: "onde" };
+    }
+  }
+  return null;
+}
+export function locateAnnotation(editor, target) {
+  return locateAnnotationDetailed(editor, target)?.range ?? null;
+}
+export function annotationY(editor, from, reference) {
+  try {
+    const coords = editor.view.coordsAtPos(Math.min(from, editor.state.doc.content.size));
+    const refRect = reference.getBoundingClientRect();
+    return coords.top - refRect.top;
+  } catch {
+    return null;
+  }
+}
+const highlightKey = new PluginKey("minutaAnnotationHighlight");
+const editorsWithPlugin = /* @__PURE__ */ new WeakSet();
+function ensurePlugin(editor) {
+  if (editorsWithPlugin.has(editor))
+    return;
+  editorsWithPlugin.add(editor);
+  editor.registerPlugin(new Plugin({
+    key: highlightKey,
+    state: {
+      init: () => DecorationSet.empty,
+      apply(tr, old) {
+        const meta = tr.getMeta(highlightKey);
+        if (meta === null)
+          return DecorationSet.empty;
+        if (meta) {
+          const max = tr.doc.content.size;
+          const decorations = meta.filter((item) => item.from < item.to && item.to <= max).map((item) => Decoration.inline(item.from, item.to, {
+            class: `minuta-anno minuta-anno--${item.kind}${item.active ? " minuta-anno--active" : ""}`
+          }, { annotationId: item.id }));
+          return DecorationSet.create(tr.doc, decorations);
+        }
+        return old.map(tr.mapping, tr.doc);
+      }
+    },
+    props: {
+      decorations(state) {
+        return highlightKey.getState(state);
+      }
+    }
+  }));
+}
+export function applyAnnotationDecorations(editor, items) {
+  if (editor.isDestroyed)
+    return;
+  ensurePlugin(editor);
+  editor.view.dispatch(editor.state.tr.setMeta(highlightKey, items ?? null));
+}
+export function getAnnotationDecorationRanges(editor) {
+  const out = /* @__PURE__ */ new Map();
+  if (editor.isDestroyed)
+    return out;
+  const set = highlightKey.getState(editor.state);
+  if (!set)
+    return out;
+  for (const deco of set.find()) {
+    const id = deco.spec.annotationId;
+    if (id && deco.from < deco.to)
+      out.set(id, { from: deco.from, to: deco.to });
+  }
+  return out;
+}
+export const PROGRAMMATIC_META = "minutaProgrammatic";
+const userEditsKey = new PluginKey("minutaUserEdits");
+const editorsWithUserEdits = /* @__PURE__ */ new WeakSet();
+function mergeRanges(ranges) {
+  const sorted = [...ranges].filter((r) => r.to > r.from).sort((a, b) => a.from - b.from);
+  const out = [];
+  for (const range of sorted) {
+    const last = out[out.length - 1];
+    if (last && range.from <= last.to)
+      last.to = Math.max(last.to, range.to);
+    else
+      out.push({ ...range });
+  }
+  return out;
+}
+function userEditDecorations(doc, ranges) {
+  const max = doc.content.size;
+  return DecorationSet.create(doc, mergeRanges(ranges).filter((r) => r.from < r.to && r.to <= max).map((r) => Decoration.inline(r.from, r.to, { class: "minuta-anno minuta-anno--manual" }, { userEdit: true })));
+}
+function ensureUserEditsPlugin(editor) {
+  if (editorsWithUserEdits.has(editor))
+    return;
+  editorsWithUserEdits.add(editor);
+  editor.registerPlugin(new Plugin({
+    key: userEditsKey,
+    state: {
+      init: () => DecorationSet.empty,
+      apply(tr, old) {
+        const meta = tr.getMeta(userEditsKey);
+        if (meta)
+          return userEditDecorations(tr.doc, meta.set);
+        if (!tr.docChanged)
+          return old;
+        if (tr.getMeta(PROGRAMMATIC_META))
+          return old.map(tr.mapping, tr.doc);
+        const beforeSize = tr.before.content.size;
+        let fullReplace = false;
+        const inserted = [];
+        tr.mapping.maps.forEach((stepMap, index) => {
+          stepMap.forEach((fromA, toA, fromB, toB) => {
+            if (fromA <= 1 && toA >= beforeSize - 1)
+              fullReplace = true;
+            if (toB > fromB) {
+              let from = fromB;
+              let to = toB;
+              for (let j = index + 1; j < tr.mapping.maps.length; j++) {
+                from = tr.mapping.maps[j].map(from, 1);
+                to = tr.mapping.maps[j].map(to, -1);
+              }
+              if (to > from)
+                inserted.push({ from, to });
+            }
+          });
+        });
+        if (fullReplace)
+          return DecorationSet.empty;
+        const carried = old.map(tr.mapping, tr.doc).find().map((deco) => ({ from: deco.from, to: deco.to }));
+        return userEditDecorations(tr.doc, [...carried, ...inserted]);
+      }
+    },
+    props: {
+      decorations(state) {
+        return userEditsKey.getState(state);
+      }
+    }
+  }));
+}
+export function trackUserEdits(editor) {
+  ensureUserEditsPlugin(editor);
+}
+export function getUserEditRanges(editor) {
+  if (editor.isDestroyed)
+    return [];
+  const set = userEditsKey.getState(editor.state);
+  if (!set)
+    return [];
+  return mergeRanges(set.find().map((deco) => ({ from: deco.from, to: deco.to })));
+}
+export function setUserEditRanges(editor, ranges) {
+  if (editor.isDestroyed)
+    return;
+  ensureUserEditsPlugin(editor);
+  editor.view.dispatch(editor.state.tr.setMeta(userEditsKey, { set: ranges }));
+}
+export function scrollToAnnotation(editor, from, scrollContainer) {
+  try {
+    const coords = editor.view.coordsAtPos(from);
+    if (scrollContainer) {
+      const rect = scrollContainer.getBoundingClientRect();
+      scrollContainer.scrollTo({
+        top: scrollContainer.scrollTop + (coords.top - rect.top) - rect.height * 0.3,
+        behavior: "smooth"
+      });
+    } else {
+      const dom = editor.view.domAtPos(from);
+      const el = dom.node instanceof HTMLElement ? dom.node : dom.node.parentElement;
+      el?.scrollIntoView({ behavior: "smooth", block: "center" });
+    }
+  } catch {
+  }
+}

package/dist/runtime/composables/chatEditOps.d.ts

@@ -0,0 +1,37 @@
+import type { Editor } from '@tiptap/core';
+import type { MinutaAnalysis } from './useMinutaApi.js';
+/**
+ * Aplicador das edições propostas pelo assistente de chat da minuta.
+ * O agente emite blocos minuta-edit com operações ancoradas em recortes
+ * verbatim do texto; aqui elas viram transações do editor (undoáveis).
+ */
+export interface MinutaChatOp {
+    op: 'substituir' | 'inserir_apos' | 'remover';
+    trecho: string;
+    novo?: string;
+}
+export interface MinutaChatAnnotation {
+    tipo: 'tese' | 'jurisprudencia' | 'citacao' | 'fato';
+    trecho?: string;
+    onde?: string;
+    titulo?: string;
+    fundamento?: string;
+    referencia?: string;
+    tese?: string;
+    como?: string;
+    dado?: string;
+    documento?: string;
+    pagina?: number;
+}
+export interface MinutaChatEdit {
+    descricao?: string;
+    ops?: MinutaChatOp[];
+    anotacoes?: MinutaChatAnnotation[];
+}
+export interface ApplyChatEditResult {
+    applied: number;
+    failures: string[];
+}
+export declare function applyChatEditOps(editor: Editor, ops: MinutaChatOp[]): ApplyChatEditResult;
+/** mescla as anotações propostas pelo agente na análise existente */
+export declare function mergeChatAnnotations(analysis: MinutaAnalysis | null | undefined, anotacoes: MinutaChatAnnotation[]): MinutaAnalysis;

package/dist/runtime/composables/chatEditOps.js

@@ -0,0 +1,61 @@
+import { findTextRange, PROGRAMMATIC_META } from "./annotationAnchors.js";
+function paragraphsFor(text) {
+  return text.split(/\n{2,}/).map((part) => part.trim()).filter(Boolean).map((part) => ({ type: "paragraph", content: [{ type: "text", text: part }] }));
+}
+export function applyChatEditOps(editor, ops) {
+  let applied = 0;
+  const failures = [];
+  for (const op of ops) {
+    const trecho = op.trecho?.trim();
+    if (!trecho) {
+      failures.push("Opera\xE7\xE3o sem trecho de refer\xEAncia");
+      continue;
+    }
+    const range = findTextRange(editor, trecho);
+    if (!range) {
+      failures.push(`Trecho n\xE3o encontrado: \u201C${trecho.slice(0, 60)}${trecho.length > 60 ? "\u2026" : ""}\u201D`);
+      continue;
+    }
+    try {
+      if (op.op === "substituir") {
+        editor.chain().focus(void 0, { scrollIntoView: false }).setMeta(PROGRAMMATIC_META, true).insertContentAt(range, op.novo ?? "").run();
+      } else if (op.op === "remover") {
+        editor.chain().focus(void 0, { scrollIntoView: false }).setMeta(PROGRAMMATIC_META, true).deleteRange(range).run();
+      } else if (op.op === "inserir_apos") {
+        const $to = editor.state.doc.resolve(Math.min(range.to, editor.state.doc.content.size));
+        const after = $to.after(Math.max(1, $to.depth));
+        editor.chain().focus(void 0, { scrollIntoView: false }).setMeta(PROGRAMMATIC_META, true).insertContentAt(after, paragraphsFor(op.novo ?? "")).run();
+      } else {
+        failures.push(`Opera\xE7\xE3o desconhecida: ${String(op.op)}`);
+        continue;
+      }
+      applied++;
+    } catch (error) {
+      console.error("minuta chat edit: falha ao aplicar op", op, error);
+      failures.push(`Falha ao aplicar em \u201C${trecho.slice(0, 40)}\u2026\u201D`);
+    }
+  }
+  return { applied, failures };
+}
+export function mergeChatAnnotations(analysis, anotacoes) {
+  const merged = {
+    ...analysis ?? {},
+    teses: [...analysis?.teses ?? []],
+    jurisprudencias: [...analysis?.jurisprudencias ?? []],
+    citacoes: [...analysis?.citacoes ?? []],
+    documentos: [...analysis?.documentos ?? []],
+    fatos: [...analysis?.fatos ?? []]
+  };
+  for (const anno of anotacoes) {
+    if (anno.tipo === "tese" && anno.titulo) {
+      merged.teses.push({ titulo: anno.titulo, fundamento: anno.fundamento ?? "", onde: anno.onde ?? "", trecho: anno.trecho });
+    } else if (anno.tipo === "jurisprudencia" && anno.referencia) {
+      merged.jurisprudencias.push({ referencia: anno.referencia, tese: anno.tese ?? "", onde: anno.onde ?? "", trecho: anno.trecho });
+    } else if (anno.tipo === "citacao" && anno.referencia) {
+      merged.citacoes.push({ referencia: anno.referencia, como: anno.como ?? "", onde: anno.onde ?? "", trecho: anno.trecho });
+    } else if (anno.tipo === "fato" && anno.dado) {
+      merged.fatos.push({ dado: anno.dado, trecho: anno.trecho, documento: anno.documento, pagina: anno.pagina, onde: anno.onde });
+    }
+  }
+  return merged;
+}

package/dist/runtime/composables/docxExport.d.ts

@@ -0,0 +1,24 @@
+import type { Editor } from '@tiptap/core';
+import type { PocPageBreak } from './paginationPlugin.js';
+export interface PocDocxChrome {
+    headerText?: string;
+    footerText?: string;
+    headerLogoUrl?: string | null;
+    headerPosition?: 'left' | 'center' | 'right';
+    /** cabeçalho em todas as páginas ou só na primeira */
+    headerScope?: 'all' | 'first';
+    /** conteúdo custom do rodapé (o nº de página aparece sempre) */
+    footerScope?: 'all' | 'first';
+    /** numeração "Página N de M" no rodapé (default: ligada) */
+    showPageNumber?: boolean;
+}
+export interface PocDocxExportOptions {
+    /** quebras calculadas pelo engine de paginação do preview → paginação 1:1 */
+    breaks?: PocPageBreak[];
+}
+export declare function pocExportDocx(editor: Editor, margins: {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}, chrome?: PocDocxChrome, options?: PocDocxExportOptions): Promise<Blob>;