@cyber-dash-tech/revela 0.6.1 → 0.7.0

package/lib/edit/deck-state.ts

@@ -0,0 +1,125 @@
+import { readFileSync } from "fs"
+import { activeDesign } from "../design/designs"
+import { activeDomain } from "../domain/domains"
+import {
+  defaultRequiredInputs,
+  readOrCreateDecksState,
+  reviewDeckState,
+  upsertDeck,
+  upsertSlides,
+  writeDecksState,
+  type DeckStateReadinessResult,
+  type SlideSpec,
+} from "../decks-state"
+import type { EditableDeck } from "./resolve-deck"
+
+export interface EditDeckStatePreflightResult {
+  changed: boolean
+  readiness: DeckStateReadinessResult
+}
+
+export function ensureEditableDeckState(workspaceRoot: string, deck: EditableDeck): EditDeckStatePreflightResult {
+  let state = readOrCreateDecksState(workspaceRoot)
+  const existing = state.decks[deck.slug]
+  const existingReady = existing?.writeReadiness?.status === "ready" && existing.writeReadiness.blockers.length === 0
+  let changed = !existing || existing.outputPath !== deck.file
+
+  state = upsertDeck(state, {
+    ...existing,
+    slug: deck.slug,
+    goal: existing?.goal || `Edit existing Revela deck ${deck.slug}.`,
+    audience: existing?.audience || "Existing deck viewers",
+    language: existing?.language || "en",
+    slideCount: existing?.slideCount || inferSlideCount(deck.absoluteFile),
+    outputPath: deck.file,
+    theme: {
+      design: existing?.theme?.design || safeActiveDesign(),
+      domain: existing?.theme?.domain || safeActiveDomain(),
+    },
+    requiredInputs: defaultRequiredInputs({
+      ...existing?.requiredInputs,
+      topicClarified: true,
+      audienceClarified: true,
+      slideCountDecided: true,
+      languageDecided: true,
+      visualStyleSelected: true,
+      sourceMaterialsIdentified: true,
+      researchNeedAssessed: true,
+      researchFindingsRead: true,
+      slidePlanConfirmed: true,
+      designLayoutsFetched: true,
+    }),
+    researchPlan: existing?.researchPlan || [],
+  })
+
+  const current = state.decks[deck.slug]
+  if (current.slides.length === 0) {
+    state = upsertSlides(state, deck.slug, inferSlides(deck.absoluteFile))
+    changed = true
+  }
+
+  const reviewed = reviewDeckState(state, deck.slug)
+  writeDecksState(workspaceRoot, reviewed.state)
+
+  return {
+    changed: changed || !existingReady,
+    readiness: reviewed.result,
+  }
+}
+
+function inferSlideCount(filePath: string): number {
+  return inferSlides(filePath).length
+}
+
+function inferSlides(filePath: string): SlideSpec[] {
+  const html = readFileSync(filePath, "utf-8")
+  const chunks = html.match(/<section\b[\s\S]*?<\/section>/gi) || [html]
+  return chunks.map((chunk, index) => {
+    const title = extractTitle(chunk) || `Slide ${index + 1}`
+    return {
+      index: index + 1,
+      title,
+      purpose: "Existing HTML slide prepared for targeted visual edits.",
+      layout: "existing-html",
+      qa: /slide-qa=["']true["']/i.test(chunk),
+      components: ["existing-html"],
+      content: {
+        headline: title,
+        body: [extractText(chunk) || "Existing HTML slide content."],
+      },
+      evidence: [],
+      visuals: [],
+      status: "ready",
+      notes: "Inferred automatically by /revela edit preflight.",
+    }
+  })
+}
+
+function extractTitle(html: string): string {
+  const match = /<(?:h1|h2|h3|title)\b[^>]*>([\s\S]*?)<\/(?:h1|h2|h3|title)>/i.exec(html)
+  return normalizeText(match?.[1] || "").slice(0, 160)
+}
+
+function extractText(html: string): string {
+  return normalizeText(html.replace(/<script\b[\s\S]*?<\/script>/gi, " ").replace(/<style\b[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " ")).slice(0, 600)
+}
+
+function normalizeText(value: string): string {
+  return value.replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/\s+/g, " ").trim()
+}
+
+function safeActiveDesign(): string {
+  try {
+    return activeDesign()
+  } catch {
+    return "aurora"
+  }
+}
+
+function safeActiveDomain(): string {
+  try {
+    return activeDomain()
+  } catch {
+    return "general"
+  }
+}

package/lib/edit/prompt.ts

@@ -0,0 +1,81 @@
+export interface EditSelectedElementPayload {
+  slideIndex?: number
+  slideTitle?: string
+  selector?: string
+  domPath?: string
+  tagName?: string
+  id?: string
+  classList?: string[]
+  text?: string
+  outerHTMLExcerpt?: string
+  nearbyText?: string
+  boundingBox?: Record<string, unknown>
+  viewport?: Record<string, unknown>
+}
+
+export interface EditCommentDraftPayload {
+  comment: string
+  elements: EditSelectedElementPayload[]
+}
+
+export interface EditCommentPayload extends EditSelectedElementPayload {
+  deck: string
+  file: string
+  comment: string
+  elements?: EditSelectedElementPayload[]
+  comments?: EditCommentDraftPayload[]
+}
+
+export function buildEditPrompt(payload: EditCommentPayload): string {
+  const elements = payload.elements?.length
+    ? payload.elements
+    : [{
+        slideIndex: payload.slideIndex,
+        slideTitle: payload.slideTitle,
+        selector: payload.selector,
+        domPath: payload.domPath,
+        tagName: payload.tagName,
+        id: payload.id,
+        classList: payload.classList ?? [],
+        text: payload.text,
+        outerHTMLExcerpt: payload.outerHTMLExcerpt,
+        nearbyText: payload.nearbyText,
+        boundingBox: payload.boundingBox,
+        viewport: payload.viewport,
+      }]
+  const comments = payload.comments?.length
+    ? payload.comments
+    : [{
+        comment: payload.comment,
+        elements,
+      }]
+
+  const compact = {
+    deck: payload.deck,
+    file: payload.file,
+    comments,
+  }
+
+  return `The user left a visual edit comment on a Revela slide deck.
+
+Target deck: ${payload.deck}
+Target file: ${payload.file}
+
+Structured selection payload:
+
+\`\`\`json
+${JSON.stringify(compact, null, 2)}
+\`\`\`
+
+Instructions:
+- Make the smallest targeted change that satisfies the user's comment.
+- If there are multiple comments, apply them as one coherent edit pass and avoid changes from one comment overwriting another.
+- Each comment may reference one or more selected elements. Treat the elements in a single comment as a group.
+- Preserve the existing deck structure, active design language, typography, spacing system, animations, and slide count unless the comment explicitly asks otherwise.
+- Do not rewrite unrelated slides or broad sections of the deck.
+- Locate each target primarily with slideIndex, slideTitle, selected text, nearbyText, and outerHTMLExcerpt. Use selector/domPath as hints; they may be approximate.
+- Before patching or writing ${"`decks/*.html`"}, ensure ${"`DECKS.json`"} contains this deck and call ${"`revela-decks`"} with action ${"`review`"}. If ${"`DECKS.json`"} or the deck entry is missing, initialize/upsert the deck state with ${"`revela-decks`"} first. If readiness remains blocked, explain the blockers instead of forcing the edit.
+- Apply the edit to ${payload.file} only after readiness allows deck HTML changes.
+- After editing, run ${"`revela-qa`"} on ${payload.file} and fix any relevant regressions caused by the edit.
+- If the comment is ambiguous, ask one concise clarification question instead of guessing.`
+}

package/lib/edit/resolve-deck.ts

@@ -0,0 +1,99 @@
+import { existsSync } from "fs"
+import { basename, relative, resolve, sep } from "path"
+import { DECKS_STATE_FILE, hasDecksState, isDeckHtmlPath, readDecksState } from "../decks-state"
+
+export interface EditableDeck {
+  slug: string
+  file: string
+  absoluteFile: string
+  source: "decks-state" | "fallback" | "file-path"
+}
+
+export function resolveEditableDeck(workspaceRoot: string, input: string): EditableDeck {
+  const requested = input.trim()
+  if (!requested) throw new Error("Usage: /revela edit <deck-slug|decks/file.html>")
+
+  const slug = normalizeSlug(requested)
+
+  if (hasDecksState(workspaceRoot)) {
+    const state = readDecksState(workspaceRoot)
+    const deck = state.decks[requested] ?? (slug ? state.decks[slug] : undefined)
+    if (deck) {
+      return resolveDeckFile(workspaceRoot, deck.slug, deck.outputPath, "decks-state")
+    }
+  }
+
+  if (looksLikePath(requested)) {
+    return resolvePathTarget(workspaceRoot, requested)
+  }
+
+  if (!slug) throw new Error("Deck target must be a deck slug or decks/*.html path.")
+
+  return resolveDeckFile(workspaceRoot, slug, `decks/${slug}.html`, "fallback")
+}
+
+function resolvePathTarget(workspaceRoot: string, requested: string): EditableDeck {
+  if (isAbsoluteLike(requested)) {
+    throw new Error("/revela edit only accepts workspace-relative decks/*.html paths.")
+  }
+
+  const normalized = normalizePath(requested).replace(/^\.\//, "")
+  if (!isDeckHtmlPath(normalized)) {
+    throw new Error("/revela edit file paths must point to decks/*.html.")
+  }
+
+  const slug = normalizeSlug(basename(normalized, ".html"))
+  if (!slug) throw new Error("Deck target must be a deck slug or decks/*.html path.")
+  return resolveDeckFile(workspaceRoot, slug, normalized, "file-path")
+}
+
+function resolveDeckFile(
+  workspaceRoot: string,
+  slug: string,
+  file: string,
+  source: EditableDeck["source"],
+): EditableDeck {
+  if (!isDeckHtmlPath(file)) {
+    throw new Error(`${DECKS_STATE_FILE} deck outputPath must be decks/*.html, got ${file || "missing"}.`)
+  }
+
+  const root = resolve(workspaceRoot)
+  const absoluteFile = resolve(root, file)
+  if (!isInside(root, absoluteFile)) {
+    throw new Error(`Resolved deck file is outside the workspace: ${file}`)
+  }
+  if (!existsSync(absoluteFile)) {
+    throw new Error(`Deck HTML not found: ${workspaceRelative(root, absoluteFile)}`)
+  }
+
+  return {
+    slug: normalizeSlug(slug),
+    file: workspaceRelative(root, absoluteFile),
+    absoluteFile,
+    source,
+  }
+}
+
+function isInside(root: string, target: string): boolean {
+  return target === root || target.startsWith(root.endsWith(sep) ? root : root + sep)
+}
+
+function workspaceRelative(root: string, target: string): string {
+  return relative(root, target).split(sep).join("/")
+}
+
+function looksLikePath(value: string): boolean {
+  return value.includes("/") || value.includes("\\") || value.endsWith(".html")
+}
+
+function isAbsoluteLike(value: string): boolean {
+  return value.startsWith("/") || /^[a-zA-Z]:[\\/]/.test(value)
+}
+
+function normalizePath(value: string): string {
+  return value.replace(/\\/g, "/")
+}
+
+function normalizeSlug(value: string): string {
+  return value.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "")
+}