slidev-addon-agent 0.0.1

package/lib/bridge.ts

@@ -0,0 +1,212 @@
+import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises"
+import path from "node:path"
+
+import { env } from "./env.js"
+
+const GENERATED_ROOT = ".slidev-agent/generated"
+const MANIFEST_PATH = ".slidev-agent/manifest.json"
+
+type BridgeConfig = {
+  apiUrl?: string
+  deckId?: string
+  namespace?: string
+  entry: string
+  routePrefix: string
+  cwd: string
+}
+
+type DeckFile = {
+  path: string
+  content: string
+}
+
+type NormalizedPayload = {
+  entry: string
+  files: DeckFile[]
+}
+
+type BridgeManifest = {
+  entry: string
+  generatedRoot: string
+  files: string[]
+}
+
+function resolveBridgeConfig(cwd: string): BridgeConfig {
+  return {
+    entry: env(process.env, "SLIDEV_AGENT_ENTRY", "slides.md"),
+    routePrefix: env(process.env, "SLIDEV_AGENT_ROUTE_PREFIX", "/slidev-agent"),
+    cwd,
+  }
+}
+
+function isRemoteBridgeEnabled(config: BridgeConfig) {
+  return Boolean(config.apiUrl && config.deckId)
+}
+
+function normalizeRoutePrefix(routePrefix: string) {
+  if (!routePrefix.startsWith("/"))
+    return `/${routePrefix}`
+
+  return routePrefix.replace(/\/$/, "")
+}
+
+function createDeckUrl(config: BridgeConfig) {
+  if (!config.apiUrl || !config.deckId)
+    return undefined
+
+  const prefix = normalizeRoutePrefix(config.routePrefix)
+  const url = new URL(`${prefix}/decks/${encodeURIComponent(config.deckId)}`, config.apiUrl)
+
+  if (config.namespace)
+    url.searchParams.set("namespace", config.namespace)
+
+  return url
+}
+
+function normalizePayload(payload: any, fallbackEntry: string): NormalizedPayload {
+  const entry = typeof payload.entry === "string" && payload.entry
+    ? payload.entry
+    : fallbackEntry
+
+  if (Array.isArray(payload.files)) {
+    return {
+      entry,
+      files: payload.files.map((file: any) => ({
+        path: file.path,
+        content: file.content,
+      })),
+    }
+  }
+
+  if (payload.slides && typeof payload.slides === "object") {
+    return {
+      entry,
+      files: Object.entries(payload.slides).map(([filePath, content]) => ({
+        path: filePath,
+        content: String(content),
+      })),
+    }
+  }
+
+  throw new Error("Unsupported response shape. Expected `files` or `slides` in the bridge response.")
+}
+
+async function ensureParentDirectory(targetFile: string) {
+  await mkdir(path.dirname(targetFile), { recursive: true })
+}
+
+async function writeManifest(cwd: string, manifest: BridgeManifest) {
+  const manifestFile = path.join(cwd, MANIFEST_PATH)
+  await ensureParentDirectory(manifestFile)
+  await writeFile(manifestFile, `${JSON.stringify(manifest, null, 2)}\n`, "utf8")
+}
+
+async function readManifest(cwd: string): Promise<BridgeManifest> {
+  const manifestFile = path.join(cwd, MANIFEST_PATH)
+  const content = await readFile(manifestFile, "utf8")
+  return JSON.parse(content) as BridgeManifest
+}
+
+export async function pullRemoteSlides(cwd = process.cwd()) {
+  const config = resolveBridgeConfig(cwd)
+  if (!isRemoteBridgeEnabled(config)) {
+    return {
+      mode: "local" as const,
+      entry: path.join(cwd, config.entry),
+      manifest: null,
+    }
+  }
+
+  const deckUrl = createDeckUrl(config)
+  if (!deckUrl) {
+    throw new Error("Remote sync is not configured. Set SLIDEV_AGENT_API_URL and SLIDEV_AGENT_DECK_ID.")
+  }
+
+  const response = await fetch(deckUrl, {
+    headers: {
+      accept: "application/json",
+    },
+  })
+
+  if (!response.ok)
+    throw new Error(`Bridge pull failed with ${response.status} ${response.statusText}`)
+
+  const payload = normalizePayload(await response.json(), config.entry)
+  const generatedRoot = path.join(cwd, GENERATED_ROOT)
+
+  await rm(generatedRoot, { recursive: true, force: true })
+  await mkdir(generatedRoot, { recursive: true })
+
+  for (const file of payload.files) {
+    const outputFile = path.join(generatedRoot, file.path)
+    await ensureParentDirectory(outputFile)
+    await writeFile(outputFile, file.content, "utf8")
+  }
+
+  const manifest: BridgeManifest = {
+    entry: payload.entry,
+    generatedRoot: GENERATED_ROOT,
+    files: payload.files.map(file => file.path),
+  }
+
+  await writeManifest(cwd, manifest)
+
+  return {
+    mode: "remote" as const,
+    entry: path.join(generatedRoot, payload.entry),
+    manifest,
+  }
+}
+
+export async function pushRemoteSlides(cwd = process.cwd()) {
+  const config = resolveBridgeConfig(cwd)
+  if (!isRemoteBridgeEnabled(config))
+    throw new Error("Remote sync is not configured. Set SLIDEV_AGENT_API_URL and SLIDEV_AGENT_DECK_ID.")
+
+  const manifest = await readManifest(cwd)
+  const generatedRoot = path.join(cwd, manifest.generatedRoot)
+
+  const files: DeckFile[] = []
+  for (const filePath of manifest.files) {
+    const absoluteFile = path.join(generatedRoot, filePath)
+    files.push({
+      path: filePath,
+      content: await readFile(absoluteFile, "utf8"),
+    })
+  }
+
+  const deckUrl = createDeckUrl(config)
+  if (!deckUrl) {
+    throw new Error("Remote sync is not configured. Set SLIDEV_AGENT_API_URL and SLIDEV_AGENT_DECK_ID.")
+  }
+
+  const response = await fetch(deckUrl, {
+    method: "PUT",
+    headers: {
+      "content-type": "application/json",
+      accept: "application/json",
+    },
+    body: JSON.stringify({
+      entry: manifest.entry,
+      files,
+    }),
+  })
+
+  if (!response.ok)
+    throw new Error(`Bridge push failed with ${response.status} ${response.statusText}`)
+}
+
+export async function resolveSlideEntry(cwd = process.cwd()) {
+  const config = resolveBridgeConfig(cwd)
+  if (isRemoteBridgeEnabled(config))
+    return pullRemoteSlides(cwd)
+
+  const entryFile = path.join(cwd, config.entry)
+  await stat(entryFile)
+
+  return {
+    mode: "local" as const,
+    entry: entryFile,
+    manifest: null,
+  }
+}

package/lib/config.ts

@@ -0,0 +1,79 @@
+export interface SlidevAgentRuntimeConfig {
+  apiUrl: string
+  assistantId: string
+  deckId: string
+  threadId: string | null
+  inputPlaceholder: string
+  enabled: boolean
+}
+
+import { env } from "./env"
+
+interface SlidevAgentInjectedConfig {
+  apiUrl?: string
+  assistantId?: string
+}
+
+function readInjectedConfig(): SlidevAgentInjectedConfig {
+  if (typeof window === "undefined")
+    return {}
+
+  const injectedConfig = Reflect.get(window, "__SLIDEV_AGENT_CONFIG__")
+  if (!injectedConfig || typeof injectedConfig !== "object")
+    return {}
+
+  return injectedConfig as SlidevAgentInjectedConfig
+}
+
+function getThreadStorageKey(assistantId: string, deckId: string) {
+  return `slidev-agent:thread:${assistantId || "default"}:${deckId || "default"}`
+}
+
+function readStoredThreadId(assistantId: string, deckId: string) {
+  if (typeof window === "undefined")
+    return null
+
+  const storageKey = getThreadStorageKey(assistantId, deckId)
+  const current = window.sessionStorage.getItem(storageKey)
+  const legacyCurrent = window.localStorage.getItem(storageKey)
+
+  if (legacyCurrent) {
+    window.localStorage.removeItem(storageKey)
+  }
+
+  return current?.trim() || null
+}
+
+export function persistSlidevAgentThreadId(assistantId: string, deckId: string, threadId: string) {
+  if (typeof window === "undefined" || !threadId.trim())
+    return
+
+  window.sessionStorage.setItem(getThreadStorageKey(assistantId, deckId), threadId)
+}
+
+export function clearSlidevAgentThreadId(assistantId: string, deckId: string) {
+  if (typeof window === "undefined")
+    return
+
+  const storageKey = getThreadStorageKey(assistantId, deckId)
+  window.sessionStorage.removeItem(storageKey)
+  window.localStorage.removeItem(storageKey)
+}
+
+export function resolveSlidevAgentRuntimeConfig(): SlidevAgentRuntimeConfig {
+  const injectedConfig = readInjectedConfig()
+  const apiUrl = env(import.meta.env, "VITE_LANGGRAPH_API_URL") || injectedConfig.apiUrl || "http://localhost:2024"
+  const assistantId = env(import.meta.env, "VITE_LANGGRAPH_ASSISTANT_ID") || injectedConfig.assistantId || ""
+  const deckId = env(import.meta.env, "VITE_SLIDEV_AGENT_DECK_ID") || "default-deck"
+  const inputPlaceholder = env(import.meta.env, "VITE_SLIDEV_AGENT_PLACEHOLDER") || "Ask the agent to create or revise slides..."
+  const threadId = env(import.meta.env, "VITE_LANGGRAPH_THREAD_ID") || readStoredThreadId(assistantId, deckId)
+
+  return {
+    apiUrl,
+    assistantId,
+    deckId,
+    threadId,
+    inputPlaceholder,
+    enabled: Boolean(apiUrl && assistantId),
+  }
+}

package/lib/env.ts

@@ -0,0 +1,38 @@
+export function env(
+  source: Record<string, unknown>,
+  name: string,
+): string | undefined
+export function env<Fallback extends string>(
+  source: Record<string, unknown>,
+  name: string,
+  fallback: Fallback,
+): string | Fallback
+export function env(
+  source: Record<string, unknown>,
+  name: string,
+  fallback?: string,
+): string | undefined {
+  const value = source[name]
+  return typeof value === "string" && value.trim() ? value.trim() : fallback
+}
+
+type ImportMetaEnv = ImportMeta & {
+  env?: Record<string, string | undefined>
+}
+
+const globalEnv = "process" in globalThis
+  ? globalThis.process.env
+  : (import.meta as ImportMetaEnv).env ?? {}
+const anthropicEnv = env(globalEnv, "ANTHROPIC_API_KEY")
+const googleEnv = env(globalEnv, "GOOGLE_API_KEY")
+const openaiEnv = env(globalEnv, "OPENAI_API_KEY")
+
+export const model = env(globalEnv, "SLIDEV_AGENT_MODEL") ?? (
+  anthropicEnv
+    ? "anthropic:claude-sonnet-4-6"
+    : googleEnv
+      ? "google:gemini-2.5-flash"
+      : openaiEnv
+        ? "openai:gpt-5.4"
+        : undefined
+)

package/lib/headless-tool-impl.ts

@@ -0,0 +1,26 @@
+import { nextTick, unref } from "vue"
+
+import { slidevGoToSlide as slidevGoToSlideDefinition } from "./headless-tools"
+
+type SlidevNavAdapter = {
+  go: (page: number) => void | Promise<void>
+  currentPage: unknown
+}
+
+export function createSlidevHeadlessTools(nav: SlidevNavAdapter) {
+  const slidevGoToSlide = slidevGoToSlideDefinition.implement(async ({ page, reason }) => {
+    await Promise.resolve(nav.go(page))
+    await nextTick()
+
+    const currentPage = Number(unref(nav.currentPage)) || page
+
+    return {
+      success: currentPage === page,
+      page,
+      currentPage,
+      reason: reason || undefined,
+    }
+  })
+
+  return [slidevGoToSlide]
+}

package/lib/headless-tools.ts

@@ -0,0 +1,11 @@
+import { tool } from "langchain"
+import { z } from "zod"
+
+export const slidevGoToSlide = tool({
+  name: "slidev_go_to_slide",
+  description: "Navigate the active Slidev presentation in the user's browser to a specific 1-based slide number. Use this after creating a new slide when you know its final index.",
+  schema: z.object({
+    page: z.number().int().positive().describe("The 1-based Slidev page number to open."),
+    reason: z.string().optional().describe("Optional short explanation for the navigation."),
+  }),
+})

package/lib/langgraph-init.ts

@@ -0,0 +1,79 @@
+import { existsSync } from "node:fs"
+import { writeFileSync } from "node:fs"
+import { createRequire } from "node:module"
+import path from "node:path"
+
+export interface LanggraphJsonShape {
+  node_version: string
+  dependencies: string[]
+  graphs: Record<string, string>
+  http: { app: string }
+  env: string
+}
+
+function posixRelativeToCwd(cwd: string, absoluteFile: string): string {
+  const rel = path.relative(cwd, absoluteFile).replace(/\\/g, "/")
+  if (!rel)
+    return "."
+  return rel.startsWith(".") ? rel : `./${rel}`
+}
+
+/**
+ * Resolves installed `slidev-addon-agent` entry files and returns graph spec strings
+ * for langgraph.json (path + export name).
+ */
+export function resolveSlidevAddonGraphSpecs(cwd: string): { agent: string; app: string } {
+  const packageJsonPath = path.join(cwd, "package.json")
+  if (!existsSync(packageJsonPath)) {
+    throw new Error(
+      `No package.json in ${cwd}. Run slidev-agent dev from your Slidev project root (where package.json lives).`,
+    )
+  }
+
+  const require = createRequire(packageJsonPath)
+  let pkgRoot: string
+  try {
+    pkgRoot = path.dirname(require.resolve("slidev-addon-agent"))
+  }
+  catch {
+    throw new Error(
+      "Could not resolve \"slidev-addon-agent\". Install it in this project, e.g. pnpm add slidev-addon-agent",
+    )
+  }
+
+  const agentFile = path.join(pkgRoot, "agent", "index.ts")
+  const appFile = path.join(pkgRoot, "app", "index.ts")
+
+  return {
+    agent: `${posixRelativeToCwd(cwd, agentFile)}:agent`,
+    app: `${posixRelativeToCwd(cwd, appFile)}:app`,
+  }
+}
+
+export function buildLanggraphJson(cwd: string): LanggraphJsonShape {
+  const { agent, app } = resolveSlidevAddonGraphSpecs(cwd)
+  return {
+    node_version: "20",
+    dependencies: ["."],
+    graphs: {
+      agent,
+    },
+    http: {
+      app,
+    },
+    env: ".env",
+  }
+}
+
+/**
+ * Writes `langgraph.json` when it is missing (first `slidev-agent dev`).
+ * Does not overwrite an existing file.
+ */
+export function writeLanggraphJsonIfMissing(cwd: string): void {
+  const outPath = path.join(cwd, "langgraph.json")
+  if (existsSync(outPath))
+    return
+
+  const config = buildLanggraphJson(cwd)
+  writeFileSync(outPath, `${JSON.stringify(config, null, 2)}\n`, "utf8")
+}

package/lib/messages.ts

@@ -0,0 +1,169 @@
+function stringifyContentPart(part: unknown): string {
+  if (typeof part === "string")
+    return part
+
+  if (part && typeof part === "object") {
+    const maybeText = Reflect.get(part, "text")
+    if (typeof maybeText === "string")
+      return maybeText
+
+    const maybeType = Reflect.get(part, "type")
+    if (maybeType === "tool_call" || maybeType === "tool_result")
+      return ""
+  }
+
+  return ""
+}
+
+type MessageToolCall = {
+  id: string
+  name: string
+  args?: unknown
+}
+
+function parseToolCallLike(value: unknown): MessageToolCall | null {
+  if (!value || typeof value !== "object")
+    return null
+
+  const directId = Reflect.get(value, "id")
+  const nestedFunction = Reflect.get(value, "function")
+  const nestedId = Reflect.get(value, "tool_call_id")
+  const directName = Reflect.get(value, "name")
+  const nestedName = nestedFunction && typeof nestedFunction === "object"
+    ? Reflect.get(nestedFunction, "name")
+    : undefined
+  const directArgs = Reflect.get(value, "args")
+  const nestedArgs = nestedFunction && typeof nestedFunction === "object"
+    ? Reflect.get(nestedFunction, "arguments")
+    : undefined
+
+  const id = typeof directId === "string"
+    ? directId
+    : typeof nestedId === "string"
+      ? nestedId
+      : ""
+  const name = typeof directName === "string"
+    ? directName
+    : typeof nestedName === "string"
+      ? nestedName
+      : ""
+  const args = directArgs ?? nestedArgs
+
+  if (!id && !name)
+    return null
+
+  return { id, name, args }
+}
+
+export function getMessageRole(message: unknown): string {
+  if (message && typeof message === "object") {
+    const getType = Reflect.get(message, "getType")
+    if (typeof getType === "function")
+      return String(getType.call(message))
+
+    const type = Reflect.get(message, "type")
+    if (typeof type === "string")
+      return type
+  }
+
+  return "assistant"
+}
+
+export function getMessageContent(message: unknown): string {
+  if (!message || typeof message !== "object")
+    return ""
+
+  const content = Reflect.get(message, "content")
+  if (typeof content === "string")
+    return content
+
+  if (Array.isArray(content))
+    return content.map(stringifyContentPart).filter(Boolean).join("\n\n")
+
+  return ""
+}
+
+export function getMessageToolCalls(message: unknown): MessageToolCall[] {
+  if (!message || typeof message !== "object")
+    return []
+
+  const toolCalls: MessageToolCall[] = []
+  const seen = new Set<string>()
+  const content = Reflect.get(message, "content")
+
+  if (Array.isArray(content)) {
+    content.forEach((part) => {
+      if (!part || typeof part !== "object" || Reflect.get(part, "type") !== "tool_call")
+        return
+
+      const toolCall = parseToolCallLike(part)
+      if (!toolCall)
+        return
+
+      const key = toolCall.id || `${toolCall.name}:${JSON.stringify(toolCall.args ?? "")}`
+      if (seen.has(key))
+        return
+
+      seen.add(key)
+      toolCalls.push(toolCall)
+    })
+  }
+
+  const kwargs = Reflect.get(message, "additional_kwargs")
+  const nestedToolCalls = kwargs && typeof kwargs === "object"
+    ? Reflect.get(kwargs, "tool_calls")
+    : undefined
+
+  if (Array.isArray(nestedToolCalls)) {
+    nestedToolCalls.forEach((entry) => {
+      const toolCall = parseToolCallLike(entry)
+      if (!toolCall)
+        return
+
+      const key = toolCall.id || `${toolCall.name}:${JSON.stringify(toolCall.args ?? "")}`
+      if (seen.has(key))
+        return
+
+      seen.add(key)
+      toolCalls.push(toolCall)
+    })
+  }
+
+  return toolCalls
+}
+
+export function getMessageToolName(message: unknown): string {
+  if (!message || typeof message !== "object")
+    return ""
+
+  const directName = Reflect.get(message, "name")
+  if (typeof directName === "string")
+    return directName
+
+  const kwargs = Reflect.get(message, "additional_kwargs")
+  if (kwargs && typeof kwargs === "object") {
+    const nestedName = Reflect.get(kwargs, "name")
+    if (typeof nestedName === "string")
+      return nestedName
+  }
+
+  return ""
+}
+
+export function getMessageToolCallId(message: unknown): string {
+  if (!message || typeof message !== "object")
+    return ""
+
+  const directId = Reflect.get(message, "tool_call_id")
+  if (typeof directId === "string")
+    return directId
+
+  const kwargs = Reflect.get(message, "additional_kwargs")
+  if (kwargs && typeof kwargs === "object") {
+    const nestedId = Reflect.get(kwargs, "tool_call_id")
+    if (typeof nestedId === "string")
+      return nestedId
+  }
+
+  return ""
+}

package/lib/render-chat-markdown.ts

@@ -0,0 +1,19 @@
+import DOMPurify from "dompurify"
+import { marked } from "marked"
+
+marked.setOptions({
+  gfm: true,
+  breaks: true,
+})
+
+DOMPurify.addHook("afterSanitizeAttributes", (node) => {
+  if (node.tagName === "A") {
+    node.setAttribute("target", "_blank")
+    node.setAttribute("rel", "noopener noreferrer")
+  }
+})
+
+export function renderChatMarkdown(source: string): string {
+  const html = marked.parse(source, { async: false }) as string
+  return DOMPurify.sanitize(html)
+}