@daniel156161/prism 0.2.76 → 0.2.78

package/src/prism-extensions/integrations/ai-memory-system.ts

@@ -13,8 +13,10 @@ const DEFAULT_REQUEST_TIMEOUT_MS = 30_000
 const DEFAULT_STATUS_TIMEOUT_MS = 1_500
 const DEFAULT_INJECT_TIMEOUT_MS = 1_200
 const DEFAULT_INJECT_CACHE_TTL_MS = 60_000
+const DEFAULT_ALWAYS_CONTEXT_CACHE_TTL_MS = 60_000
 
 const injectCache = new Map<string, { expiresAt: number; results: any[] }>()
+const alwaysContextCache = { expiresAt: 0, content: "" }
 
 function aiMemoryBaseUrl(env: NodeJS.ProcessEnv = process.env): string {
   return (env.PRISM_AI_MEMORY_BASE_URL || env.AI_MEMORY_BASE_URL || DEFAULT_BASE_URL).replace(/\/+$/, "")
@@ -110,6 +112,50 @@ async function postJson<T>(path: string, body: unknown, timeoutMs = aiMemoryRequ
   return JSON.parse(text) as T
 }
 
+async function putJson<T>(path: string, body: unknown, timeoutMs = aiMemoryRequestTimeoutMs()): Promise<T> {
+  const baseUrl = aiMemoryBaseUrl()
+  const response = await fetch(`${baseUrl}${path}`, {
+    method: "PUT",
+    headers: { "content-type": "application/json; charset=utf-8", accept: "application/json" },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(timeoutMs),
+  })
+  const text = await response.text()
+  if (!response.ok) throw new Error(`AI Memory request failed: HTTP ${response.status} ${text.slice(0, 500)}`)
+  return JSON.parse(text) as T
+}
+
+async function deleteJson<T>(path: string, body: unknown, timeoutMs = aiMemoryRequestTimeoutMs()): Promise<T> {
+  const baseUrl = aiMemoryBaseUrl()
+  const response = await fetch(`${baseUrl}${path}`, {
+    method: "DELETE",
+    headers: { "content-type": "application/json; charset=utf-8", accept: "application/json" },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(timeoutMs),
+  })
+  const text = await response.text()
+  if (!response.ok) throw new Error(`AI Memory request failed: HTTP ${response.status} ${text.slice(0, 500)}`)
+  return JSON.parse(text) as T
+}
+
+async function methodJson<T>(
+  method: string,
+  path: string,
+  timeoutMs = aiMemoryRequestTimeoutMs(),
+  body?: unknown,
+): Promise<T> {
+  const baseUrl = aiMemoryBaseUrl()
+  const response = await fetch(`${baseUrl}${path}`, {
+    method,
+    headers: { accept: "application/json", ...(body === undefined ? {} : { "content-type": "application/json; charset=utf-8" }) },
+    body: body === undefined ? undefined : JSON.stringify(body),
+    signal: AbortSignal.timeout(timeoutMs),
+  })
+  const text = await response.text()
+  if (!response.ok) throw new Error(`AI Memory request failed: HTTP ${response.status} ${text.slice(0, 500)}`)
+  return JSON.parse(text) as T
+}
+
 async function getJson<T>(path: string, timeoutMs = aiMemoryStatusTimeoutMs()): Promise<T> {
   const baseUrl = aiMemoryBaseUrl()
   const response = await fetch(`${baseUrl}${path}`, {
@@ -175,6 +221,22 @@ async function loadAiMemoryInjectResults(query: string): Promise<any[]> {
   return results
 }
 
+async function loadAlwaysContext(): Promise<string> {
+  const now = Date.now()
+  if (alwaysContextCache.expiresAt > now) return alwaysContextCache.content
+
+  const data = await methodJson<{ content: string }>(
+    "CONTEXT",
+    `/vault`,
+    aiMemoryInjectTimeoutMs(),
+    {},
+  )
+  const content = String(data?.content ?? "")
+  alwaysContextCache.expiresAt = now + DEFAULT_ALWAYS_CONTEXT_CACHE_TTL_MS
+  alwaysContextCache.content = content
+  return content
+}
+
 export function buildAiMemoryContextMessage(results: any[]): any | undefined {
   const filtered = Array.isArray(results) ? results : []
   if (filtered.length === 0) return undefined
@@ -191,6 +253,21 @@ export function buildAiMemoryContextMessage(results: any[]): any | undefined {
   }
 }
 
+function buildAlwaysContextMessage(content: string): any | undefined {
+  const trimmed = String(content ?? "").trim()
+  if (!trimmed) return undefined
+  return {
+    customType: "ai-memory-always-context",
+    display: false,
+    content: [
+      "# Always-loaded context from 00 Kontext",
+      "Durable background from the user's Obsidian vault. Use it as context; do not mention it unless useful.",
+      "",
+      trimmed,
+    ].join("\n"),
+  }
+}
+
 function renderAiMemoryResult(result: any, options: { expanded?: boolean; isPartial?: boolean } = {}, theme: ThemeLike): { render(width: number): string[] } {
   return renderCollapsibleTextResult(result, options, theme, {
     partialLabel: "Searching AI Memory...",
@@ -292,6 +369,96 @@ export default function aiMemorySystemExtension(pi: ExtensionAPI): void {
     },
   })
 
+  // ── File-backed vault ops (write/edit/list/delete) ──
+
+  pi.registerTool({
+    name: "ai_memory_vault_list",
+    label: "AI Memory Vault List",
+    description: "List Markdown files inside the configured Obsidian vault (codebase-local workspace by default).",
+    promptSnippet: "List vault Markdown notes [paths only]",
+    parameters: Type.Object({
+      subdir: Type.Optional(Type.String({ description: "Vault-relative directory to search (default: root)" })),
+      limit: Type.Optional(Type.Number({ description: "Maximum paths to return (default 100)" })),
+    }),
+    async execute(_id: string, params: any) {
+      const subdir = typeof params.subdir === "string" ? params.subdir : ""
+      const limit = params.limit === undefined ? 100 : Math.max(1, Math.min(500, Math.trunc(params.limit)))
+      const data = await methodJson<any>("LIST", `/vault`, aiMemoryInjectTimeoutMs(), { subdir, limit })
+      const files = Array.isArray(data.files) ? data.files : []
+      return { content: [{ type: "text", text: files.join("\n") || "No Markdown notes found." }], details: { files, count: files.length } }
+    },
+    renderCall(args: any, theme: ThemeLike, context: any) {
+      return renderSingleLineToolCall(formatAiMemoryToolCall("ai_memory_vault_list", args, theme), context)
+    },
+  })
+
+  pi.registerTool({
+    name: "ai_memory_vault_write",
+    label: "AI Memory Vault Write",
+    description: "Create/overwrite a Markdown file in the configured Obsidian vault.",
+    promptSnippet: "Write vault file [path + body/frontmatter]",
+    parameters: Type.Object({
+      path: Type.String({ description: "Vault-relative path, e.g. 02 Projekte/Test.md" }),
+      frontmatter: Type.Optional(Type.String({ description: "Optional YAML frontmatter including leading/trailing --- lines" })),
+      body: Type.String({ description: "Markdown body (without YAML frontmatter unless you include it in frontmatter)" }),
+    }),
+    async execute(_id: string, params: any) {
+      const data = await postJson<any>("/vault", {
+        path: String(params.path ?? ""),
+        frontmatter: params.frontmatter !== undefined ? String(params.frontmatter) : null,
+        body: String(params.body ?? ""),
+      })
+      return { content: [{ type: "text", text: `Wrote: ${data.path ?? params.path}` }], details: data }
+    },
+    renderCall(args: any, theme: ThemeLike, context: any) {
+      return renderSingleLineToolCall(formatAiMemoryToolCall("ai_memory_vault_write", args, theme), context)
+    },
+  })
+
+  pi.registerTool({
+    name: "ai_memory_vault_edit",
+    label: "AI Memory Vault Edit",
+    description: "Replace the content block under a given heading in a Markdown file (or append if missing).",
+    promptSnippet: "Edit vault file section by heading",
+    parameters: Type.Object({
+      path: Type.String({ description: "Vault-relative path" }),
+      heading: Type.String({ description: "Heading text without leading #, e.g. 'Update 2026-01-01 — Thema'" }),
+      frontmatter: Type.Optional(Type.String({ description: "Optional YAML frontmatter including leading/trailing --- lines" })),
+      body: Type.String({ description: "Markdown body for that heading section (without '# Heading' line)" }),
+    }),
+    async execute(_id: string, params: any) {
+      const data = await putJson<any>("/vault", {
+        path: String(params.path ?? ""),
+        heading: String(params.heading ?? ""),
+        frontmatter: params.frontmatter !== undefined ? String(params.frontmatter) : null,
+        body: String(params.body ?? ""),
+      })
+      return { content: [{ type: "text", text: `Edited: ${data.path ?? params.path}` }], details: data }
+    },
+    renderCall(args: any, theme: ThemeLike, context: any) {
+      return renderSingleLineToolCall(formatAiMemoryToolCall("ai_memory_vault_edit", args, theme), context)
+    },
+  })
+
+  pi.registerTool({
+    name: "ai_memory_vault_delete",
+    label: "AI Memory Vault Delete",
+    description: "Delete a Markdown file from the configured Obsidian vault.",
+    promptSnippet: "Delete vault file [path]",
+    parameters: Type.Object({
+      path: Type.String({ description: "Vault-relative path" }),
+    }),
+    async execute(_id: string, params: any) {
+      const data = await deleteJson<any>("/vault", {
+        path: String(params.path ?? ""),
+      })
+      return { content: [{ type: "text", text: `Deleted: ${data.path ?? params.path}` }], details: data }
+    },
+    renderCall(args: any, theme: ThemeLike, context: any) {
+      return renderSingleLineToolCall(formatAiMemoryToolCall("ai_memory_vault_delete", args, theme), context)
+    },
+  })
+
   pi.registerCommand("ai-memory", {
     description: "Search local AI Memory System: /ai-memory <query>",
     handler: async (args: string, ctx: any) => {
@@ -316,6 +483,24 @@ export default function aiMemorySystemExtension(pi: ExtensionAPI): void {
   })
 
   pi.on?.("before_agent_start", async (event: any) => {
+    // Always-loaded durable context (mapped from 00 Kontext) is injected as a
+    // system-prompt chunk so it remains in the cached prefix.
+    let alwaysBlock: string | undefined
+    try {
+      const alwaysContent = await loadAlwaysContext()
+      const alwaysMessage = buildAlwaysContextMessage(alwaysContent)
+      alwaysBlock = alwaysMessage?.content
+    } catch {
+      // Ignore — always-context is best-effort.
+    }
+
+    const prev = String(event?.systemPrompt ?? "")
+    if (alwaysBlock && alwaysBlock.trim()) {
+      const block = alwaysBlock.trim()
+      return { systemPrompt: `${prev}${prev ? "\n\n" : ""}${block}` }
+    }
+
+    // Query-specific candidates
     if (!shouldInjectAiMemoryCandidates()) return
     const query = String(event?.prompt ?? "").trim()
     if (!query) return

package/src/prism-extensions/integrations/research-tools.ts

@@ -5,6 +5,7 @@ import { fuzzyFilter } from "../core/fuzzy.js"
 import { clearPrismManifestRoutingTier, setPrismManifestRoutingTier } from "../core/manifest-routing.js"
 import { renderCollapsibleTextResult } from "../ui/collapsed-text-rendering.js"
 import { formatBracketedToolCall, renderSingleLineToolCall, type ThemeLike } from "../ui/tool-call-rendering.js"
+import { fetchYouTubeContent, isYouTubeUrl } from "./youtube.js"
 
 export function formatResearchToolCall(toolName: "web_search" | "web_fetch", args: any, theme: ThemeLike): string {
   const displayName = toolName === "web_search" ? "web search" : "web fetch"
@@ -331,6 +332,7 @@ export async function webSearch(query: string, limit = 10): Promise<string> {
 export async function webFetch(url: string, maxChars = 20_000): Promise<string> {
   const safeUrl = validateHttpUrl(url)
   const safeMaxChars = clampLimit(maxChars, 20_000, 1_000, 100_000)
+  if (isYouTubeUrl(safeUrl)) return fetchYouTubeContent(safeUrl, safeMaxChars)
   const response = await fetch(safeUrl, { headers: { "User-Agent": "Mozilla/5.0 (compatible; prism-research/1.0)" }, signal: AbortSignal.timeout(15_000) })
   const text = await response.text()
   if (!response.ok) throw new Error(`Fetch failed for ${safeUrl}: HTTP ${response.status}`)
@@ -390,8 +392,8 @@ export default function researchToolsExtension(pi: ExtensionAPI): void {
   pi.registerTool({
     name: "web_fetch",
     label: "web fetch",
-    description: "Fetch readable text from a web page for citation-backed research.",
-    promptSnippet: "Fetch readable text from a web page.",
+    description: "Fetch readable text from a web page for citation-backed research. For YouTube URLs, extracts structured video metadata (title, channel, description, duration, views, publish date) and transcript when available.",
+    promptSnippet: "Fetch readable text from a web page. For YouTube URLs, extracts structured video metadata (title, channel, description, duration, views, publish date) and transcript when available.",
     parameters: Type.Object({ url: Type.String(), maxChars: Type.Optional(Type.Number()) }),
     async execute(_id: string, params: any) {
       return { content: [{ type: "text", text: await webFetch(params.url, params.maxChars || 20_000) }], details: { url: params.url } }

package/src/prism-extensions/integrations/youtube.ts

@@ -0,0 +1,292 @@
+import { decodeHtml } from "./research-tools.js"
+
+// ---------------------------------------------------------------------------
+// YouTube URL detection & video ID extraction
+// ---------------------------------------------------------------------------
+
+const YT_HOSTS = /^(?:www\.)?(?:youtube\.com|youtu\.be|m\.youtube\.com|music\.youtube\.com)$/i
+const YT_SHORT_HOST = /^(?:www\.)?youtu\.be$/i
+
+export function isYouTubeUrl(url: string): boolean {
+  try {
+    const parsed = new URL(url)
+    return YT_HOSTS.test(parsed.hostname) && (YT_SHORT_HOST.test(parsed.hostname) || /^\/(?:watch|shorts|embed|v)(?:[/?]|$)/.test(parsed.pathname) || parsed.pathname.startsWith("/live/"))
+  } catch {
+    return false
+  }
+}
+
+export function extractVideoId(url: string): string | undefined {
+  try {
+    const parsed = new URL(url)
+    if (YT_SHORT_HOST.test(parsed.hostname)) return parsed.pathname.slice(1).split(/[/?#]/)[0] || undefined
+    const v = parsed.searchParams.get("v")
+    if (v) return v
+    const pathMatch = parsed.pathname.match(/^\/(?:embed|v|shorts|live)\/([a-zA-Z0-9_-]{11})/)
+    return pathMatch?.[1]
+  } catch {
+    return undefined
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Metadata extraction from page HTML
+// ---------------------------------------------------------------------------
+
+export interface YouTubeMetadata {
+  videoId: string
+  title: string
+  channel: string
+  channelUrl?: string
+  description: string
+  duration: number // seconds
+  viewCount?: number
+  publishDate?: string
+  category?: string
+  keywords?: string[]
+  isLive?: boolean
+  thumbnail?: string
+}
+
+export function parsePlayerResponse(html: string): any | undefined {
+  const match = html.match(/var ytInitialPlayerResponse\s*=\s*(\{.*?\});\s*(?:var |<\/script>)/)
+  if (!match) return undefined
+  try {
+    return JSON.parse(match[1])
+  } catch {
+    return undefined
+  }
+}
+
+export function extractMetadata(player: any): YouTubeMetadata | undefined {
+  const details = player?.videoDetails
+  if (!details?.videoId) return undefined
+
+  const micro = player.microformat?.playerMicroformatRenderer
+
+  return {
+    videoId: details.videoId,
+    title: details.title ?? "Unknown",
+    channel: micro?.ownerChannelName ?? details.author ?? "Unknown",
+    channelUrl: details.channelId ? `https://www.youtube.com/channel/${details.channelId}` : undefined,
+    description: details.shortDescription ?? "",
+    duration: Number(details.lengthSeconds) || 0,
+    viewCount: details.viewCount ? Number(details.viewCount) : undefined,
+    publishDate: micro?.publishDate ?? micro?.uploadDate,
+    category: micro?.category,
+    keywords: details.keywords,
+    isLive: details.isLiveContent === true,
+    thumbnail: details.thumbnail?.thumbnails?.at(-1)?.url,
+  }
+}
+
+export function extractMetadataFromHtml(html: string): YouTubeMetadata | undefined {
+  const player = parsePlayerResponse(html)
+  return player ? extractMetadata(player) : undefined
+}
+
+// ---------------------------------------------------------------------------
+// Caption track extraction from page HTML
+// ---------------------------------------------------------------------------
+
+export interface CaptionTrack {
+  url: string
+  language: string
+  languageCode: string
+  kind?: string // "asr" = auto-generated
+}
+
+export function extractCaptionTracks(player: any): CaptionTrack[] {
+  const tracks = player?.captions?.playerCaptionsTracklistRenderer?.captionTracks
+  if (!Array.isArray(tracks)) return []
+  return tracks.map((t: any) => ({
+    url: (t.baseUrl ?? "").replace(/\\u0026/g, "&"),
+    language: t.name?.simpleText ?? t.languageCode ?? "unknown",
+    languageCode: t.languageCode ?? "",
+    kind: t.kind,
+  })).filter((t: CaptionTrack) => t.url)
+}
+
+// ---------------------------------------------------------------------------
+// Transcript parsing (XML srv1 format → plain text)
+// ---------------------------------------------------------------------------
+
+export function parseTranscriptXml(xml: string): string {
+  const segments: string[] = []
+  for (const match of xml.matchAll(/<text[^>]*start="([^"]*)"[^>]*>([\s\S]*?)<\/text>/g)) {
+    const startSec = parseFloat(match[1])
+    const text = decodeHtml(match[2]).replace(/<[^>]+>/g, "").trim()
+    if (!text) continue
+    const minutes = Math.floor(startSec / 60)
+    const seconds = Math.floor(startSec % 60)
+    const timestamp = `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`
+    segments.push(`[${timestamp}] ${text}`)
+  }
+  return segments.join("\n")
+}
+
+// ---------------------------------------------------------------------------
+// Transcript fetching via yt-dlp (best-effort)
+// ---------------------------------------------------------------------------
+
+async function ytDlpAvailable(): Promise<boolean> {
+  try {
+    const { execFile } = await import("node:child_process")
+    const { promisify } = await import("node:util")
+    const execFileAsync = promisify(execFile)
+    await execFileAsync("yt-dlp", ["--version"], { timeout: 5_000 })
+    return true
+  } catch {
+    return false
+  }
+}
+
+export async function fetchTranscriptYtDlp(videoId: string, lang = "en"): Promise<string> {
+  const { execFile } = await import("node:child_process")
+  const { promisify } = await import("node:util")
+  const { mkdtemp, readFile, rm } = await import("node:fs/promises")
+  const { join } = await import("node:path")
+  const { tmpdir } = await import("node:os")
+  const execFileAsync = promisify(execFile)
+
+  const tmpDir = await mkdtemp(join(tmpdir(), "yt-transcript-"))
+  const outTemplate = join(tmpDir, "sub")
+
+  try {
+    await execFileAsync("yt-dlp", [
+      "--write-auto-sub",
+      "--write-sub",
+      "--sub-lang", lang,
+      "--sub-format", "srv1",
+      "--skip-download",
+      "--no-warnings",
+      "--no-check-certificates",
+      "-o", outTemplate,
+      `https://www.youtube.com/watch?v=${videoId}`,
+    ], { timeout: 30_000 })
+
+    // Try manual subs first, then auto subs
+    const { readdir } = await import("node:fs/promises")
+    const files = await readdir(tmpDir)
+    const subFile = files.find((f) => f.endsWith(".srv1"))
+    if (!subFile) return ""
+
+    const xml = await readFile(join(tmpDir, subFile), "utf-8")
+    return parseTranscriptXml(xml)
+  } catch {
+    return ""
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true }).catch(() => {})
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Direct caption fetch (fallback when yt-dlp not available)
+// ---------------------------------------------------------------------------
+
+export async function fetchTranscriptDirect(captionUrl: string): Promise<string> {
+  try {
+    const response = await fetch(captionUrl, {
+      headers: { "User-Agent": "Mozilla/5.0 (compatible; prism-research/1.0)" },
+      signal: AbortSignal.timeout(10_000),
+    })
+    const text = await response.text()
+    if (!text || !response.ok) return ""
+    return parseTranscriptXml(text)
+  } catch {
+    return ""
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Duration formatting
+// ---------------------------------------------------------------------------
+
+export function formatDuration(seconds: number): string {
+  if (seconds <= 0) return "unknown"
+  const h = Math.floor(seconds / 3600)
+  const m = Math.floor((seconds % 3600) / 60)
+  const s = seconds % 60
+  if (h > 0) return `${h}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`
+  return `${m}:${String(s).padStart(2, "0")}`
+}
+
+// ---------------------------------------------------------------------------
+// Format the final YouTube result
+// ---------------------------------------------------------------------------
+
+export function formatYouTubeResult(meta: YouTubeMetadata, transcript: string, maxChars: number): string {
+  const lines: string[] = []
+
+  lines.push(`# ${meta.title}`)
+  lines.push("")
+  lines.push(`**Channel:** ${meta.channel}`)
+  if (meta.publishDate) lines.push(`**Published:** ${meta.publishDate}`)
+  lines.push(`**Duration:** ${formatDuration(meta.duration)}`)
+  if (meta.viewCount != null) lines.push(`**Views:** ${meta.viewCount.toLocaleString("en-US")}`)
+  if (meta.category) lines.push(`**Category:** ${meta.category}`)
+  if (meta.isLive) lines.push(`**Live:** yes`)
+  lines.push(`**URL:** https://www.youtube.com/watch?v=${meta.videoId}`)
+
+  if (meta.description) {
+    lines.push("")
+    lines.push("## Description")
+    lines.push(meta.description)
+  }
+
+  if (transcript) {
+    lines.push("")
+    lines.push("## Transcript")
+    lines.push(transcript)
+  }
+
+  let result = lines.join("\n")
+  if (result.length > maxChars) result = `${result.slice(0, maxChars - 20)}\n\n[truncated]`
+  return result
+}
+
+// ---------------------------------------------------------------------------
+// Main entry point for web_fetch YouTube handling
+// ---------------------------------------------------------------------------
+
+export async function fetchYouTubeContent(url: string, maxChars = 20_000): Promise<string> {
+  const videoId = extractVideoId(url)
+  if (!videoId) throw new Error(`Could not extract video ID from URL: ${url}`)
+
+  // Fetch the page for metadata
+  const response = await fetch(`https://www.youtube.com/watch?v=${videoId}`, {
+    headers: {
+      "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:125.0) Gecko/20100101 Firefox/125.0",
+      "Accept-Language": "en-US,en;q=0.5",
+      "Cookie": "CONSENT=YES+cb",
+    },
+    signal: AbortSignal.timeout(15_000),
+  })
+  if (!response.ok) throw new Error(`YouTube fetch failed: HTTP ${response.status}`)
+  const html = await response.text()
+
+  const player = parsePlayerResponse(html)
+  const meta = player ? extractMetadata(player) : undefined
+  if (!meta) throw new Error(`Could not extract video metadata from YouTube page for ${videoId}`)
+
+  // Try to get transcript
+  let transcript = ""
+
+  // 1. Try direct caption fetch from page (fast, works when YouTube allows it)
+  const captionTracks = player ? extractCaptionTracks(player) : []
+  if (captionTracks.length > 0) {
+    // Prefer manual English, then any manual, then auto English, then first available
+    const preferred = captionTracks.find((t) => t.languageCode === "en" && t.kind !== "asr")
+      ?? captionTracks.find((t) => t.kind !== "asr")
+      ?? captionTracks.find((t) => t.languageCode === "en")
+      ?? captionTracks[0]
+    transcript = await fetchTranscriptDirect(preferred.url)
+  }
+
+  // 2. Fall back to yt-dlp if direct fetch returned nothing
+  if (!transcript && await ytDlpAvailable()) {
+    transcript = await fetchTranscriptYtDlp(videoId, "en")
+  }
+
+  return formatYouTubeResult(meta, transcript, maxChars)
+}

package/node_modules/@earendil-works/pi-agent-core/dist/harness/session/jsonl-repo.d.ts

@@ -1,26 +0,0 @@
-import type { FileSystem, JsonlSessionCreateOptions, JsonlSessionListOptions, JsonlSessionMetadata, JsonlSessionRepoApi, Session } from "../types.ts";
-type JsonlSessionRepoFileSystem = Pick<FileSystem, "cwd" | "absolutePath" | "joinPath" | "readTextFile" | "readTextLines" | "writeFile" | "appendFile" | "listDir" | "exists" | "createDir" | "remove">;
-export declare class JsonlSessionRepo implements JsonlSessionRepoApi {
-    private readonly fs;
-    private readonly sessionsRootInput;
-    private sessionsRoot;
-    constructor(options: {
-        fs: JsonlSessionRepoFileSystem;
-        sessionsRoot: string;
-    });
-    private getSessionsRoot;
-    private getSessionDir;
-    private createSessionFilePath;
-    create(options: JsonlSessionCreateOptions): Promise<Session<JsonlSessionMetadata>>;
-    open(metadata: JsonlSessionMetadata): Promise<Session<JsonlSessionMetadata>>;
-    list(options?: JsonlSessionListOptions): Promise<JsonlSessionMetadata[]>;
-    delete(metadata: JsonlSessionMetadata): Promise<void>;
-    fork(sourceMetadata: JsonlSessionMetadata, options: JsonlSessionCreateOptions & {
-        entryId?: string;
-        position?: "before" | "at";
-        id?: string;
-    }): Promise<Session<JsonlSessionMetadata>>;
-    private listSessionDirs;
-}
-export {};
-//# sourceMappingURL=jsonl-repo.d.ts.map

package/node_modules/@earendil-works/pi-agent-core/dist/harness/session/jsonl-repo.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsonl-repo.d.ts","sourceRoot":"","sources":["../../../src/harness/session/jsonl-repo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,UAAU,EACV,yBAAyB,EACzB,uBAAuB,EACvB,oBAAoB,EACpB,mBAAmB,EACnB,OAAO,EACP,MAAM,aAAa,CAAC;AAWrB,KAAK,0BAA0B,GAAG,IAAI,CACrC,UAAU,EACR,KAAK,GACL,cAAc,GACd,UAAU,GACV,cAAc,GACd,eAAe,GACf,WAAW,GACX,YAAY,GACZ,SAAS,GACT,QAAQ,GACR,WAAW,GACX,QAAQ,CACV,CAAC;AAMF,qBAAa,gBAAiB,YAAW,mBAAmB;IAC3D,OAAO,CAAC,QAAQ,CAAC,EAAE,CAA6B;IAChD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAS;IAC3C,OAAO,CAAC,YAAY,CAAqB;IAEzC,YAAY,OAAO,EAAE;QAAE,EAAE,EAAE,0BAA0B,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,EAG5E;YAEa,eAAe;YAUf,aAAa;YAOb,qBAAqB;IAU7B,MAAM,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAgBvF;IAEK,IAAI,CAAC,QAAQ,EAAE,oBAAoB,GAAG,OAAO,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAQjF;IAEK,IAAI,CAAC,OAAO,GAAE,uBAA4B,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAsBjF;IAEK,MAAM,CAAC,QAAQ,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAK1D;IAEK,IAAI,CACT,cAAc,EAAE,oBAAoB,EACpC,OAAO,EAAE,yBAAyB,GAAG;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,GAChG,OAAO,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAwBxC;YAEa,eAAe;CAgB7B","sourcesContent":["import type {\n\tFileSystem,\n\tJsonlSessionCreateOptions,\n\tJsonlSessionListOptions,\n\tJsonlSessionMetadata,\n\tJsonlSessionRepoApi,\n\tSession,\n} from \"../types.ts\";\nimport { SessionError, toError } from \"../types.ts\";\nimport { JsonlSessionStorage, loadJsonlSessionMetadata } from \"./jsonl-storage.ts\";\nimport {\n\tcreateSessionId,\n\tcreateTimestamp,\n\tgetEntriesToFork,\n\tgetFileSystemResultOrThrow,\n\ttoSession,\n} from \"./repo-utils.ts\";\n\ntype JsonlSessionRepoFileSystem = Pick<\n\tFileSystem,\n\t| \"cwd\"\n\t| \"absolutePath\"\n\t| \"joinPath\"\n\t| \"readTextFile\"\n\t| \"readTextLines\"\n\t| \"writeFile\"\n\t| \"appendFile\"\n\t| \"listDir\"\n\t| \"exists\"\n\t| \"createDir\"\n\t| \"remove\"\n>;\n\nfunction encodeCwd(cwd: string): string {\n\treturn `--${cwd.replace(/^[/\\\\]/, \"\").replace(/[/\\\\:]/g, \"-\")}--`;\n}\n\nexport class JsonlSessionRepo implements JsonlSessionRepoApi {\n\tprivate readonly fs: JsonlSessionRepoFileSystem;\n\tprivate readonly sessionsRootInput: string;\n\tprivate sessionsRoot: string | undefined;\n\n\tconstructor(options: { fs: JsonlSessionRepoFileSystem; sessionsRoot: string }) {\n\t\tthis.fs = options.fs;\n\t\tthis.sessionsRootInput = options.sessionsRoot;\n\t}\n\n\tprivate async getSessionsRoot(): Promise<string> {\n\t\tif (!this.sessionsRoot) {\n\t\t\tthis.sessionsRoot = getFileSystemResultOrThrow(\n\t\t\t\tawait this.fs.absolutePath(this.sessionsRootInput),\n\t\t\t\t`Failed to resolve sessions root ${this.sessionsRootInput}`,\n\t\t\t);\n\t\t}\n\t\treturn this.sessionsRoot;\n\t}\n\n\tprivate async getSessionDir(cwd: string): Promise<string> {\n\t\treturn getFileSystemResultOrThrow(\n\t\t\tawait this.fs.joinPath([await this.getSessionsRoot(), encodeCwd(cwd)]),\n\t\t\t`Failed to resolve session directory for ${cwd}`,\n\t\t);\n\t}\n\n\tprivate async createSessionFilePath(cwd: string, sessionId: string, timestamp: string): Promise<string> {\n\t\treturn getFileSystemResultOrThrow(\n\t\t\tawait this.fs.joinPath([\n\t\t\t\tawait this.getSessionDir(cwd),\n\t\t\t\t`${timestamp.replace(/[:.]/g, \"-\")}_${sessionId}.jsonl`,\n\t\t\t]),\n\t\t\t`Failed to resolve session file path for ${sessionId}`,\n\t\t);\n\t}\n\n\tasync create(options: JsonlSessionCreateOptions): Promise<Session<JsonlSessionMetadata>> {\n\t\tconst id = options.id ?? createSessionId();\n\t\tconst createdAt = createTimestamp();\n\t\tconst sessionDir = await this.getSessionDir(options.cwd);\n\t\tgetFileSystemResultOrThrow(\n\t\t\tawait this.fs.createDir(sessionDir, { recursive: true }),\n\t\t\t`Failed to create session directory ${sessionDir}`,\n\t\t);\n\t\tconst filePath = await this.createSessionFilePath(options.cwd, id, createdAt);\n\t\tconst storage = await JsonlSessionStorage.create(this.fs, filePath, {\n\t\t\tcwd: options.cwd,\n\t\t\tsessionId: id,\n\t\t\tparentSessionPath: options.parentSessionPath,\n\t\t\tmetadata: options.metadata,\n\t\t});\n\t\treturn toSession(storage);\n\t}\n\n\tasync open(metadata: JsonlSessionMetadata): Promise<Session<JsonlSessionMetadata>> {\n\t\tif (\n\t\t\t!getFileSystemResultOrThrow(await this.fs.exists(metadata.path), `Failed to check session ${metadata.path}`)\n\t\t) {\n\t\t\tthrow new SessionError(\"not_found\", `Session not found: ${metadata.path}`);\n\t\t}\n\t\tconst storage = await JsonlSessionStorage.open(this.fs, metadata.path);\n\t\treturn toSession(storage);\n\t}\n\n\tasync list(options: JsonlSessionListOptions = {}): Promise<JsonlSessionMetadata[]> {\n\t\tconst dirs = options.cwd ? [await this.getSessionDir(options.cwd)] : await this.listSessionDirs();\n\t\tconst sessions: JsonlSessionMetadata[] = [];\n\t\tfor (const dir of dirs) {\n\t\t\tif (!getFileSystemResultOrThrow(await this.fs.exists(dir), `Failed to check session directory ${dir}`)) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst files = getFileSystemResultOrThrow(\n\t\t\t\tawait this.fs.listDir(dir),\n\t\t\t\t`Failed to list sessions in ${dir}`,\n\t\t\t).filter((file) => file.kind !== \"directory\" && file.name.endsWith(\".jsonl\"));\n\t\t\tfor (const file of files) {\n\t\t\t\ttry {\n\t\t\t\t\tsessions.push(await loadJsonlSessionMetadata(this.fs, file.path));\n\t\t\t\t} catch (error) {\n\t\t\t\t\tconst cause = toError(error);\n\t\t\t\t\tif (!(cause instanceof SessionError) || cause.code !== \"invalid_session\") throw cause;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tsessions.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());\n\t\treturn sessions;\n\t}\n\n\tasync delete(metadata: JsonlSessionMetadata): Promise<void> {\n\t\tgetFileSystemResultOrThrow(\n\t\t\tawait this.fs.remove(metadata.path, { force: true }),\n\t\t\t`Failed to delete session ${metadata.path}`,\n\t\t);\n\t}\n\n\tasync fork(\n\t\tsourceMetadata: JsonlSessionMetadata,\n\t\toptions: JsonlSessionCreateOptions & { entryId?: string; position?: \"before\" | \"at\"; id?: string },\n\t): Promise<Session<JsonlSessionMetadata>> {\n\t\tconst source = await this.open(sourceMetadata);\n\t\tconst forkedEntries = await getEntriesToFork(source.getStorage(), options);\n\t\tconst id = options.id ?? createSessionId();\n\t\tconst createdAt = createTimestamp();\n\t\tconst sessionDir = await this.getSessionDir(options.cwd);\n\t\tgetFileSystemResultOrThrow(\n\t\t\tawait this.fs.createDir(sessionDir, { recursive: true }),\n\t\t\t`Failed to create session directory ${sessionDir}`,\n\t\t);\n\t\tconst storage = await JsonlSessionStorage.create(\n\t\t\tthis.fs,\n\t\t\tawait this.createSessionFilePath(options.cwd, id, createdAt),\n\t\t\t{\n\t\t\t\tcwd: options.cwd,\n\t\t\t\tsessionId: id,\n\t\t\t\tparentSessionPath: options.parentSessionPath ?? sourceMetadata.path,\n\t\t\t\tmetadata: options.metadata ?? sourceMetadata.metadata,\n\t\t\t},\n\t\t);\n\t\tfor (const entry of forkedEntries) {\n\t\t\tawait storage.appendEntry(entry);\n\t\t}\n\t\treturn toSession(storage);\n\t}\n\n\tprivate async listSessionDirs(): Promise<string[]> {\n\t\tconst sessionsRoot = await this.getSessionsRoot();\n\t\tif (\n\t\t\t!getFileSystemResultOrThrow(\n\t\t\t\tawait this.fs.exists(sessionsRoot),\n\t\t\t\t`Failed to check sessions root ${sessionsRoot}`,\n\t\t\t)\n\t\t) {\n\t\t\treturn [];\n\t\t}\n\t\tconst entries = getFileSystemResultOrThrow(\n\t\t\tawait this.fs.listDir(sessionsRoot),\n\t\t\t`Failed to list sessions root ${sessionsRoot}`,\n\t\t);\n\t\treturn entries.filter((entry) => entry.kind === \"directory\").map((entry) => entry.path);\n\t}\n}\n"]}