@cyber-dash-tech/revela 0.16.2 → 0.16.4

package/lib/refine/visual-targets.ts

@@ -0,0 +1,295 @@
+import { readFileSync, statSync, writeFileSync } from "fs"
+
+export type VisualEditKind = "image" | "text-width" | "box"
+
+export interface VisualEditTarget {
+  editId: string
+  kind: VisualEditKind
+  tagName: "img" | "h1" | "h2" | "h3" | "h4" | "p" | "div" | "figure"
+  startOffset: number
+  openEndOffset: number
+  originalOpenTag: string
+  originalStyle: string
+}
+
+export interface VisualTargetResizeChange {
+  type: "resize"
+  editId: string
+  kind?: VisualEditKind
+  after: {
+    stylePatch?: Record<string, unknown>
+    width?: number
+    height?: number
+  }
+}
+
+export interface VisualTargetMoveChange {
+  type: "move"
+  editId: string
+  kind?: VisualEditKind
+  after: {
+    stylePatch?: Record<string, unknown>
+    dx?: number
+    dy?: number
+  }
+}
+
+export type VisualTargetChange = VisualTargetResizeChange | VisualTargetMoveChange
+
+export interface ApplyVisualTargetChangesInput {
+  file: string
+  deckVersion?: string
+  targetDeckVersion?: string
+  targets: Map<string, VisualEditTarget>
+  changes: VisualTargetChange[]
+}
+
+export interface ApplyVisualTargetChangesResult {
+  ok: true
+  deckVersion: string
+  changeCount: number
+}
+
+const TEXT_TAGS = new Set(["h1", "h2", "h3", "h4", "p"])
+const BOX_TAGS = new Set(["div", "figure"])
+const EDIT_TAGS = new Set(["img", ...TEXT_TAGS, ...BOX_TAGS])
+const MAX_DIMENSION_PX = 3840
+const MIN_IMAGE_DIMENSION_PX = 24
+const MIN_TEXT_WIDTH_PX = 80
+const MIN_BOX_WIDTH_PX = 40
+const MIN_BOX_HEIGHT_PX = 24
+
+export function annotateVisualEditTargets(html: string): { html: string; targets: Map<string, VisualEditTarget> } {
+  const targets = new Map<string, VisualEditTarget>()
+  const insertions: Array<{ offset: number; text: string }> = []
+  let nextId = 1
+
+  for (const tag of scanOpeningTags(html)) {
+    if (!EDIT_TAGS.has(tag.tagName)) continue
+    if (BOX_TAGS.has(tag.tagName) && !isSafeBoxTarget(tag.openTag)) continue
+    const editId = `rve-${nextId++}`
+    const kind: VisualEditKind = tag.tagName === "img" ? "image" : BOX_TAGS.has(tag.tagName) ? "box" : "text-width"
+    targets.set(editId, {
+      editId,
+      kind,
+      tagName: tag.tagName as VisualEditTarget["tagName"],
+      startOffset: tag.startOffset,
+      openEndOffset: tag.openEndOffset,
+      originalOpenTag: tag.openTag,
+      originalStyle: attrValue(tag.openTag, "style") || "",
+    })
+    insertions.push({ offset: tag.openEndOffset - (tag.openTag.endsWith("/>") ? 2 : 1), text: ` data-revela-edit-id="${editId}" data-revela-edit-kind="${kind}"` })
+  }
+
+  let annotated = html
+  for (const insertion of insertions.reverse()) {
+    annotated = annotated.slice(0, insertion.offset) + insertion.text + annotated.slice(insertion.offset)
+  }
+  return { html: annotated, targets }
+}
+
+export function applyVisualTargetChanges(input: ApplyVisualTargetChangesInput): ApplyVisualTargetChangesResult {
+  const currentVersion = readDeckVersion(input.file).version
+  if (input.deckVersion && input.deckVersion !== currentVersion) throw new Error("Deck changed outside Review. Refresh Review before saving visual edits.")
+  if (input.targetDeckVersion && input.targetDeckVersion !== currentVersion) throw new Error("Review visual targets are stale. Refresh Review before saving visual edits.")
+  if (!input.changes.length) throw new Error("No visual changes to save.")
+
+  let html = readFileSync(input.file, "utf-8")
+  const resolved = new Map<string, { target: VisualEditTarget; patch: Record<string, string> }>()
+  for (const change of input.changes) {
+    const target = input.targets.get(change.editId)
+    if (!target) throw new Error("Target is no longer editable. Refresh Review and try again.")
+    if (change.kind && change.kind !== target.kind) throw new Error("Visual edit target kind changed. Refresh Review and try again.")
+    const currentOpenTag = html.slice(target.startOffset, target.openEndOffset)
+    if (currentOpenTag !== target.originalOpenTag) throw new Error("Target is no longer editable. Refresh Review and try again.")
+    const patch = normalizeStylePatch(target, change)
+    if (!Object.keys(patch).length) throw new Error("Visual change does not contain valid style updates.")
+    const existing = resolved.get(target.editId)
+    resolved.set(target.editId, { target, patch: { ...(existing?.patch ?? {}), ...patch } })
+  }
+
+  for (const { target, patch } of Array.from(resolved.values()).sort((a, b) => b.target.startOffset - a.target.startOffset)) {
+    const updatedOpenTag = patchOpenTagStyle(target.originalOpenTag, patch)
+    html = html.slice(0, target.startOffset) + updatedOpenTag + html.slice(target.openEndOffset)
+  }
+
+  writeFileSync(input.file, html, "utf-8")
+  return { ok: true, deckVersion: readDeckVersion(input.file).version, changeCount: input.changes.length }
+}
+
+export function readDeckVersion(file: string): { mtimeMs: number; size: number; version: string } {
+  const stat = statSync(file)
+  return { mtimeMs: stat.mtimeMs, size: stat.size, version: `${stat.mtimeMs}:${stat.size}` }
+}
+
+function normalizeStylePatch(target: VisualEditTarget, change: VisualTargetChange): Record<string, string> {
+  const input = change.after.stylePatch ?? {}
+  if (change.type === "move") return normalizeMovePatch(target, input)
+  if (change.type !== "resize") throw new Error(`Unsupported visual change type: ${(change as any).type}`)
+  return normalizeResizePatch(target.kind, input)
+}
+
+function normalizeResizePatch(kind: VisualEditKind, input: Record<string, unknown>): Record<string, string> {
+  const patch: Record<string, string> = {}
+  const width = typeof input.width === "string" ? normalizePxValue(input.width, kind === "image" ? MIN_IMAGE_DIMENSION_PX : kind === "box" ? MIN_BOX_WIDTH_PX : MIN_TEXT_WIDTH_PX) : null
+  if (width) patch.width = width
+  if (kind === "image" || kind === "box") {
+    const height = typeof input.height === "string" ? normalizePxValue(input.height, kind === "image" ? MIN_IMAGE_DIMENSION_PX : MIN_BOX_HEIGHT_PX) : null
+    if (height) patch.height = height
+  } else {
+    const maxWidth = typeof input["max-width"] === "string" ? normalizePxValue(input["max-width"], MIN_TEXT_WIDTH_PX) : null
+    if (maxWidth) patch["max-width"] = maxWidth
+  }
+  return patch
+}
+
+function normalizeMovePatch(target: VisualEditTarget, input: Record<string, unknown>): Record<string, string> {
+  const translate = typeof input.translate === "string" ? normalizeTranslateValue(input.translate) : null
+  if (translate) return { translate }
+  const transform = typeof input.transform === "string" ? normalizeLegacyTransformValue(input.transform) : null
+  return transform ? { translate: transform } : {}
+}
+
+function normalizeTranslateValue(value: string): string | null {
+  const direct = parseTranslateProperty(value)
+  if (direct) return normalizeTranslatePoint(direct)
+  return normalizeLegacyTransformValue(value)
+}
+
+function normalizeLegacyTransformValue(value: string): string | null {
+  const parsed = parseSimpleTranslate(value)
+  if (!parsed) return null
+  return normalizeTranslatePoint(parsed)
+}
+
+function normalizeTranslatePoint(parsed: { x: number; y: number }): string | null {
+  const { x, y } = parsed
+  if (Math.abs(x) > MAX_DIMENSION_PX || Math.abs(y) > MAX_DIMENSION_PX) return null
+  return `${Math.round(x)}px ${Math.round(y)}px`
+}
+
+function parseTranslateProperty(value: string): { x: number; y: number } | null {
+  const normalized = value.trim()
+  const match = /^(-?\d+(?:\.\d+)?)px(?:\s+|\s*,\s*)(-?\d+(?:\.\d+)?)px$/.exec(normalized)
+  return match ? finitePoint(Number(match[1]), Number(match[2])) : null
+}
+
+function parseSimpleTranslate(value: string): { x: number; y: number } | null {
+  const normalized = value.trim()
+  if (!normalized || normalized === "none") return { x: 0, y: 0 }
+  const translate = /^translate\(\s*(-?\d+(?:\.\d+)?)px(?:\s*,\s*|\s+)(-?\d+(?:\.\d+)?)px\s*\)$/.exec(normalized)
+  if (translate) return finitePoint(Number(translate[1]), Number(translate[2]))
+  const matrix = /^matrix\(\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*\)$/.exec(normalized)
+  if (!matrix) return null
+  const a = Number(matrix[1])
+  const b = Number(matrix[2])
+  const c = Number(matrix[3])
+  const d = Number(matrix[4])
+  if (a !== 1 || b !== 0 || c !== 0 || d !== 1) return null
+  return finitePoint(Number(matrix[5]), Number(matrix[6]))
+}
+
+function finitePoint(x: number, y: number): { x: number; y: number } | null {
+  return Number.isFinite(x) && Number.isFinite(y) ? { x, y } : null
+}
+
+function normalizePxValue(value: string, min: number): string | null {
+  const match = /^(\d+(?:\.\d+)?)px$/.exec(value.trim())
+  if (!match) return null
+  const number = Number(match[1])
+  if (!Number.isFinite(number) || number < min || number > MAX_DIMENSION_PX) return null
+  return `${Math.round(number)}px`
+}
+
+function patchOpenTagStyle(openTag: string, patch: Record<string, string>): string {
+  const styleMatch = /\sstyle=("([^"]*)"|'([^']*)')/i.exec(openTag)
+  const current = styleMatch ? parseStyle(styleMatch[2] ?? styleMatch[3] ?? "") : {}
+  const next = serializeStyle({ ...current, ...patch })
+  if (styleMatch) return openTag.slice(0, styleMatch.index) + ` style="${escapeAttr(next)}"` + openTag.slice(styleMatch.index + styleMatch[0].length)
+  return openTag.replace(/\s*\/?>$/, (ending) => ` style="${escapeAttr(next)}"${ending}`)
+}
+
+function parseStyle(style: string): Record<string, string> {
+  const result: Record<string, string> = {}
+  for (const part of style.split(";")) {
+    const index = part.indexOf(":")
+    if (index < 0) continue
+    const key = part.slice(0, index).trim().toLowerCase()
+    const value = part.slice(index + 1).trim()
+    if (key && value) result[key] = value
+  }
+  return result
+}
+
+function serializeStyle(style: Record<string, string>): string {
+  return Object.entries(style).map(([key, value]) => `${key}: ${value}`).join("; ")
+}
+
+function escapeAttr(value: string): string {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;")
+}
+
+interface OpenTagRegion {
+  tagName: string
+  startOffset: number
+  openEndOffset: number
+  openTag: string
+}
+
+function scanOpeningTags(html: string): OpenTagRegion[] {
+  const tags: OpenTagRegion[] = []
+  let index = 0
+  while (index < html.length) {
+    const open = html.indexOf("<", index)
+    if (open < 0) break
+    if (html.startsWith("<!--", open)) {
+      const close = html.indexOf("-->", open + 4)
+      index = close < 0 ? html.length : close + 3
+      continue
+    }
+    const close = html.indexOf(">", open + 1)
+    if (close < 0) break
+    const raw = html.slice(open, close + 1)
+    const tagName = normalizeName(/^<\s*([a-zA-Z0-9-]+)/.exec(raw)?.[1] || "")
+    if (!tagName || /^<\s*[!/]/.test(raw) || /^<\s*\//.test(raw)) {
+      index = close + 1
+      continue
+    }
+    tags.push({ tagName, startOffset: open, openEndOffset: close + 1, openTag: raw })
+    if (tagName === "script" || tagName === "style") {
+      const closeTag = new RegExp(`</\\s*${tagName}\\s*>`, "ig")
+      closeTag.lastIndex = close + 1
+      const match = closeTag.exec(html)
+      index = match ? match.index + match[0].length : close + 1
+    } else {
+      index = close + 1
+    }
+  }
+  return tags
+}
+
+function attrValue(openTag: string, name: string): string | undefined {
+  const escaped = escapeRegExp(name)
+  const match = new RegExp(`\\s${escaped}=("([^"]*)"|'([^']*)')`, "i").exec(openTag)
+  return match ? match[2] ?? match[3] : undefined
+}
+
+function isSafeBoxTarget(openTag: string): boolean {
+  const tagName = normalizeName(/^<\s*([a-zA-Z0-9-]+)/.exec(openTag)?.[1] || "")
+  const className = attrValue(openTag, "class") || ""
+  const classes = className.split(/\s+/).map((item) => item.trim().toLowerCase()).filter(Boolean)
+  if (tagName === "div" && classes.length === 0) return false
+  if (/\s(?:data-chart|data-echarts|_echarts_instance_)\b/i.test(openTag)) return false
+  if (classes.some((name) => name === "slide" || name === "slide-canvas" || name === "deck" || name === "page")) return false
+  if (classes.some((name) => name.startsWith("revela-") || name.startsWith("echarts-") || name === "echart-container" || name === "echart-panel")) return false
+  if (classes.some((name) => /(^|-)echart($|-)/.test(name) || name === "chart-container" || name === "chart-panel")) return false
+  return true
+}
+
+function normalizeName(value: string | undefined): string {
+  return (value || "").trim().toLowerCase()
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyber-dash-tech/revela",
-  "version": "0.16.2",
+  "version": "0.16.4",
   "description": "OpenCode plugin that turns AI into an HTML slide deck generator",
   "type": "module",
   "main": "./index.ts",

package/plugin.ts

@@ -243,6 +243,9 @@ const server: Plugin = (async (pluginCtx) => {
         description: "Revela research agent — searches and collects raw materials for presentations",
         mode: "subagent",
         prompt: RESEARCH_PROMPT,
+        tools: {
+          "revela-decks": false,
+        },
         permission: {
           edit: "deny",
           bash: {

package/tools/narrative-view.ts

@@ -34,16 +34,6 @@ export default tool({
         risks: tool.schema.string().optional(),
         researchGaps: tool.schema.string().optional(),
         coveredSlides: tool.schema.string().optional(),
-        storyWorkbench: tool.schema.string().optional(),
-        workbenchNote: tool.schema.string().optional(),
-        artifactCoverage: tool.schema.string().optional(),
-        noRenderTargets: tool.schema.string().optional(),
-        nextActions: tool.schema.string().optional(),
-        missingClaims: tool.schema.string().optional(),
-        affectedClaims: tool.schema.string().optional(),
-        affectedSlides: tool.schema.string().optional(),
-        notes: tool.schema.string().optional(),
-        recommendedNextCommand: tool.schema.string().optional(),
         noClaims: tool.schema.string().optional(),
         none: tool.schema.string().optional(),
       }).optional(),
@@ -53,7 +43,13 @@ export default tool({
         roleLabel: tool.schema.string().optional(),
         narrativeJob: tool.schema.string().optional(),
         evidenceSummary: tool.schema.string().optional(),
+        supportRationale: tool.schema.string().optional().describe("Display-only localized explanation of why the evidence supports this claim. Do not add new causal logic beyond canonical evidence, supported scope, and relation rationale."),
+        supportedScope: tool.schema.string().optional().describe("Display-only localized version of the canonical supported scope."),
+        unsupportedScope: tool.schema.string().optional().describe("Display-only localized version of the canonical unsupported scope or evidence boundary."),
+        objectionsSummary: tool.schema.string().optional().describe("Display-only localized summary of objections tied to this claim."),
+        risksSummary: tool.schema.string().optional().describe("Display-only localized summary of risks tied to this claim."),
         riskOrGapSummary: tool.schema.string().optional(),
+        researchGapsSummary: tool.schema.string().optional().describe("Display-only localized summary of research gaps tied to this claim."),
       })).optional(),
       relations: tool.schema.array(tool.schema.object({
         fromClaimId: tool.schema.string(),