@daniel156161/prism 0.2.60 → 0.2.78

package/src/prism-extensions/tools/builtin-tools.ts

@@ -1,164 +1,16 @@
-import { createHash, randomUUID } from "node:crypto"
-import { Type } from "typebox"
 import type { ToolboxToolDefinition } from "./toolbox.js"
 import { createDiagnosticToolboxTools } from "./diagnostic-tools.js"
+import { createPrismDiagnosticToolboxTools } from "./prism-diagnostic-tools.js"
 import { createSshConfigTool } from "./ssh-config-tool.js"
-import { clampInteger, normalizedAction, textToolResult, type ToolInput } from "./toolbox-utils.js"
-
-const MAX_RESULTS = 500
 
 export function defineToolboxTool(definition: ToolboxToolDefinition): ToolboxToolDefinition {
   return { source: "toolbox/builtin", ...definition }
 }
 
-function stableSort(value: any): any {
-  if (Array.isArray(value)) return value.map(stableSort)
-  if (!value || typeof value !== "object" || value.constructor !== Object) return value
-  return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stableSort(value[key])]))
-}
-
-function parseJsonInput(input: unknown): any {
-  if (typeof input === "string") return JSON.parse(input)
-  return input
-}
-
 export const builtinToolboxTools: ToolboxToolDefinition[] = [
-  defineToolboxTool({
-    name: "json_format",
-    label: "JSON Format",
-    description: "Format, minify, validate, and optionally sort JSON input.",
-    tags: ["json", "format", "validate", "minify"],
-    parameters: Type.Object({
-      input: Type.Any({ description: "JSON string or JSON-compatible value" }),
-      minify: Type.Optional(Type.Boolean({ description: "Return compact JSON instead of pretty JSON" })),
-      sortKeys: Type.Optional(Type.Boolean({ description: "Sort object keys recursively" })),
-    }),
-    async execute(_id: string, params: ToolInput) {
-      const parsed = parseJsonInput(params.input)
-      const normalized = params.sortKeys ? stableSort(parsed) : parsed
-      return textToolResult(JSON.stringify(normalized, null, params.minify ? 0 : 2), { valid: true })
-    },
-  }),
-
-  defineToolboxTool({
-    name: "base64_codec",
-    label: "Base64 Codec",
-    description: "Encode or decode UTF-8 text with Base64.",
-    tags: ["base64", "encode", "decode", "text"],
-    parameters: Type.Object({
-      action: Type.String({ description: "encode or decode" }),
-      text: Type.String({ description: "Input text" }),
-    }),
-    async execute(_id: string, params: ToolInput) {
-      const action = normalizedAction(params.action, "")
-      if (action === "encode") return textToolResult(Buffer.from(String(params.text ?? ""), "utf8").toString("base64"), { action })
-      if (action === "decode") return textToolResult(Buffer.from(String(params.text ?? ""), "base64").toString("utf8"), { action })
-      throw new Error("action must be encode or decode")
-    },
-  }),
-
-  defineToolboxTool({
-    name: "url_codec",
-    label: "URL Codec",
-    description: "Encode or decode URL components.",
-    tags: ["url", "encode", "decode", "uri"],
-    parameters: Type.Object({
-      action: Type.String({ description: "encode or decode" }),
-      text: Type.String({ description: "Input text" }),
-    }),
-    async execute(_id: string, params: ToolInput) {
-      const action = normalizedAction(params.action, "")
-      if (action === "encode") return textToolResult(encodeURIComponent(String(params.text ?? "")), { action })
-      if (action === "decode") return textToolResult(decodeURIComponent(String(params.text ?? "")), { action })
-      throw new Error("action must be encode or decode")
-    },
-  }),
-
-  defineToolboxTool({
-    name: "hash_text",
-    label: "Hash Text",
-    description: "Hash text using sha256, sha1, or md5.",
-    tags: ["hash", "sha256", "sha1", "md5", "checksum"],
-    parameters: Type.Object({
-      text: Type.String({ description: "Text to hash" }),
-      algorithm: Type.Optional(Type.String({ description: "sha256 (default), sha1, or md5" })),
-    }),
-    async execute(_id: string, params: ToolInput) {
-      const algorithm = normalizedAction(params.algorithm, "sha256")
-      if (!["sha256", "sha1", "md5"].includes(algorithm)) throw new Error("algorithm must be sha256, sha1, or md5")
-      return textToolResult(createHash(algorithm).update(String(params.text ?? ""), "utf8").digest("hex"), { algorithm })
-    },
-  }),
-
-  defineToolboxTool({
-    name: "regex_extract",
-    label: "Regex Extract",
-    description: "Extract regex matches from text, with optional capture group selection.",
-    tags: ["regex", "extract", "text", "match"],
-    parameters: Type.Object({
-      text: Type.String({ description: "Text to search" }),
-      pattern: Type.String({ description: "JavaScript regular expression pattern, without slashes" }),
-      flags: Type.Optional(Type.String({ description: "Regex flags. g is added automatically. Allowed: gimsyu" })),
-      group: Type.Optional(Type.Number({ description: "Capture group index, default 0 for whole match" })),
-      limit: Type.Optional(Type.Number({ description: "Maximum matches, default 100, max 500" })),
-    }),
-    async execute(_id: string, params: ToolInput) {
-      const rawFlags = String(params.flags ?? "")
-      if (!/^[gimsyu]*$/.test(rawFlags)) throw new Error("flags may only contain g, i, m, s, y, u")
-      const flags = rawFlags.includes("g") ? rawFlags : `${rawFlags}g`
-      const regex = new RegExp(String(params.pattern ?? ""), flags)
-      const group = Math.max(0, Math.trunc(Number(params.group ?? 0)))
-      const limit = clampInteger(params.limit, 100, 1, MAX_RESULTS)
-      const matches: string[] = []
-      for (const match of String(params.text ?? "").matchAll(regex)) {
-        matches.push(match[group] ?? "")
-        if (matches.length >= limit) break
-      }
-      return textToolResult(matches.join("\n") || "No matches", { count: matches.length, group, flags })
-    },
-  }),
-
-  defineToolboxTool({
-    name: "time_convert",
-    label: "Time Convert",
-    description: "Convert timestamps or date strings to ISO, Unix seconds, and Unix milliseconds. Uses current time when value is omitted.",
-    tags: ["time", "date", "timestamp", "unix", "iso"],
-    parameters: Type.Object({
-      value: Type.Optional(Type.Any({ description: "Date string, Unix seconds, Unix milliseconds, or empty for now" })),
-      unit: Type.Optional(Type.String({ description: "auto (default), seconds, milliseconds, or iso" })),
-    }),
-    async execute(_id: string, params: ToolInput) {
-      const unit = normalizedAction(params.unit, "auto")
-      const value = params.value
-      let date: Date
-      if (value === undefined || value === null || value === "") date = new Date()
-      else if (unit === "seconds") date = new Date(Number(value) * 1000)
-      else if (unit === "milliseconds") date = new Date(Number(value))
-      else if (unit === "iso") date = new Date(String(value))
-      else if (typeof value === "number" || /^\d+$/.test(String(value))) {
-        const numeric = Number(value)
-        date = new Date(numeric < 10_000_000_000 ? numeric * 1000 : numeric)
-      } else date = new Date(String(value))
-      if (!Number.isFinite(date.getTime())) throw new Error("Invalid date/time value")
-      const unixMs = date.getTime()
-      return textToolResult(JSON.stringify({ iso: date.toISOString(), unixSeconds: Math.floor(unixMs / 1000), unixMilliseconds: unixMs }, null, 2), { unixMs })
-    },
-  }),
-
-  defineToolboxTool({
-    name: "uuid_generate",
-    label: "UUID Generate",
-    description: "Generate one or more random UUID v4 values.",
-    tags: ["uuid", "random", "id"],
-    parameters: Type.Object({ count: Type.Optional(Type.Number({ description: "How many UUIDs to generate, default 1, max 100" })) }),
-    async execute(_id: string, params: ToolInput) {
-      const count = clampInteger(params.count, 1, 1, 100)
-      return textToolResult(Array.from({ length: count }, () => randomUUID()).join("\n"), { count })
-    },
-  }),
-
   createSshConfigTool(),
   ...createDiagnosticToolboxTools(),
+  ...createPrismDiagnosticToolboxTools(),
 ]
 
 export function createBuiltinToolboxTools(): ToolboxToolDefinition[] {

package/src/prism-extensions/tools/prism-diagnostic-tools.ts

@@ -0,0 +1,160 @@
+import * as fs from "node:fs"
+import * as path from "node:path"
+import { execFile } from "node:child_process"
+import { promisify } from "node:util"
+import { Type } from "typebox"
+import type { ToolboxToolDefinition } from "./toolbox.js"
+import { clampInteger, normalizedAction, requiredString, textToolResult, timeoutMs, MAX_TOOL_OUTPUT_CHARS, type ToolInput } from "./toolbox-utils.js"
+
+const execFileAsync = promisify(execFile)
+type ExecRunner = typeof execFileAsync
+
+async function run(command: string, args: string[], timeout: number, runner: ExecRunner = execFileAsync): Promise<string> {
+  try {
+    const { stdout, stderr } = await runner(command, args, { timeout, maxBuffer: MAX_TOOL_OUTPUT_CHARS * 2 })
+    return [stdout, stderr && `STDERR:\n${stderr}`].filter(Boolean).join("\n").trim()
+  } catch (error: any) {
+    const stdout = error?.stdout ? String(error.stdout) : ""
+    const stderr = error?.stderr ? String(error.stderr) : ""
+    const message = [stdout, stderr, error?.message ? `ERROR: ${error.message}` : ""].filter(Boolean).join("\n").trim()
+    return message || `ERROR: ${command} failed`
+  }
+}
+
+function jsonText(value: unknown): string {
+  return JSON.stringify(value, null, 2)
+}
+
+function prismHome(env: NodeJS.ProcessEnv = process.env): string {
+  return env.PRISM_CODING_AGENT_DIR || path.join(env.HOME || process.env.HOME || ".", ".prism")
+}
+
+function createPrismRuntimeStatusTool(): ToolboxToolDefinition {
+  return {
+    name: "prism_runtime_status",
+    label: "Prism Runtime Status",
+    description: "Inspect local Prism runtime/config paths, package version, pi dependency versions, sessions DB, and auth profile marker.",
+    tags: ["prism", "runtime", "version", "config", "sessions", "auth", "diagnostic"],
+    source: "toolbox/prism-diagnostics",
+    parameters: Type.Object({ cwd: Type.Optional(Type.String({ description: "Project directory to inspect. Defaults to current working directory." })) }),
+    async execute(_id: string, params: ToolInput, _signal, _onUpdate, ctx) {
+      const env = ctx?.env ?? process.env
+      const cwd = path.resolve(String(params.cwd || ctx?.cwd || process.cwd()))
+      const packagePath = path.join(cwd, "package.json")
+      const pkg = fs.existsSync(packagePath) ? JSON.parse(fs.readFileSync(packagePath, "utf-8")) : undefined
+      const home = prismHome(env)
+      const authProfilePath = path.join(home, "auth.profile")
+      const sessionsDb = path.join(home, "sessions.db")
+      const result = {
+        cwd,
+        package: pkg ? { name: pkg.name, version: pkg.version, piCodingAgent: pkg.dependencies?.["@earendil-works/pi-coding-agent"], piAi: pkg.dependencies?.["@earendil-works/pi-ai"] } : undefined,
+        prismHome: home,
+        settingsPath: path.join(home, "settings.json"),
+        settingsExists: fs.existsSync(path.join(home, "settings.json")),
+        sessionsDb,
+        sessionsDbExists: fs.existsSync(sessionsDb),
+        authProfile: fs.existsSync(authProfilePath) ? fs.readFileSync(authProfilePath, "utf-8").trim() : undefined,
+        env: {
+          PRISM_AI_MEMORY_BASE_URL: env.PRISM_AI_MEMORY_BASE_URL,
+          PRISM_OBSIDIAN_VAULT_NAME: env.PRISM_OBSIDIAN_VAULT_NAME,
+          PRISM_OBSIDIAN_VAULT: env.PRISM_OBSIDIAN_VAULT,
+          PRISM_CODING_AGENT_DIR: env.PRISM_CODING_AGENT_DIR,
+        },
+      }
+      return textToolResult(jsonText(result), result)
+    },
+  }
+}
+
+function createGiteaPackageVersionTool(): ToolboxToolDefinition {
+  return {
+    name: "gitea_package_version",
+    label: "Gitea Package Version",
+    description: "Check a Gitea/npm package metadata endpoint for the latest published version.",
+    tags: ["gitea", "package", "npm", "version", "registry", "prism", "deploy"],
+    source: "toolbox/prism-diagnostics",
+    parameters: Type.Object({
+      registry: Type.Optional(Type.String({ description: "Registry base URL. Default https://git.yiprawr.dev/api/packages/ai/npm" })),
+      packageName: Type.Optional(Type.String({ description: "Package name. Default @ai/prism" })),
+      timeoutMs: Type.Optional(Type.Number({ description: "Request timeout in milliseconds. Default 5000." })),
+    }),
+    async execute(_id: string, params: ToolInput) {
+      const registry = String(params.registry || "https://git.yiprawr.dev/api/packages/ai/npm").replace(/\/+$/, "")
+      const packageName = String(params.packageName || "@ai/prism")
+      const encodedName = packageName.startsWith("@") ? `@${encodeURIComponent(packageName.slice(1))}` : encodeURIComponent(packageName)
+      const url = `${registry}/${encodedName}`
+      const started = Date.now()
+      const response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs(params.timeoutMs, 5_000)), headers: { accept: "application/json" } })
+      const body = await response.text()
+      const ms = Date.now() - started
+      if (!response.ok) return textToolResult(`${response.status} ${response.statusText} (${ms}ms)\n${body.slice(0, 2000)}`, { ok: false, status: response.status, ms, url })
+      const data = JSON.parse(body)
+      const result = { ok: true, url, ms, name: data.name, latest: data?.["dist-tags"]?.latest, versions: Object.keys(data.versions ?? {}).slice(-10) }
+      return textToolResult(jsonText(result), result)
+    },
+  }
+}
+
+function createPortainerWebhookTool(): ToolboxToolDefinition {
+  return {
+    name: "portainer_webhook",
+    label: "Portainer Webhook",
+    description: "Inspect or trigger a Portainer webhook URL for stack redeploys. Defaults to dry-run.",
+    tags: ["portainer", "webhook", "redeploy", "docker", "stack", "deploy"],
+    source: "toolbox/prism-diagnostics",
+    parameters: Type.Object({
+      url: Type.String({ description: "Portainer webhook URL." }),
+      action: Type.Optional(Type.String({ description: "dry-run or trigger. Default dry-run." })),
+      timeoutMs: Type.Optional(Type.Number({ description: "Request timeout in milliseconds. Default 10000." })),
+    }),
+    async execute(_id: string, params: ToolInput) {
+      const url = requiredString(params.url, "url")
+      if (!/^https?:\/\//i.test(url)) throw new Error("url must start with http:// or https://")
+      const action = normalizedAction(params.action, "dry-run")
+      if (action === "dry-run") return textToolResult(`Dry-run only. Would POST Portainer webhook:\n${url}`, { action, url })
+      if (action !== "trigger") throw new Error("action must be dry-run or trigger")
+      const started = Date.now()
+      const response = await fetch(url, { method: "POST", signal: AbortSignal.timeout(timeoutMs(params.timeoutMs, 10_000)) })
+      const body = await response.text()
+      const result = { action, url, status: response.status, ok: response.ok, ms: Date.now() - started, body: body.slice(0, 2000) }
+      return textToolResult(jsonText(result), result)
+    },
+  }
+}
+
+function createPrismDeployCheckTool(): ToolboxToolDefinition {
+  return {
+    name: "prism_deploy_check",
+    label: "Prism Deploy Check",
+    description: "Run read-only checks for a deployed Prism SSH/tmux container over SSH: docker ps, image id, and recent logs.",
+    tags: ["prism", "deploy", "ssh", "docker", "container", "logs", "portainer", "zeus"],
+    source: "toolbox/prism-diagnostics",
+    parameters: Type.Object({
+      host: Type.String({ description: "SSH host alias." }),
+      container: Type.Optional(Type.String({ description: "Container name. Default prism-ssh." })),
+      lines: Type.Optional(Type.Number({ description: "Recent log lines. Default 80." })),
+      timeoutMs: Type.Optional(Type.Number({ description: "SSH timeout in milliseconds. Default 30000." })),
+    }),
+    async execute(_id: string, params: ToolInput, _signal, _onUpdate, ctx) {
+      const host = requiredString(params.host, "host")
+      const container = String(params.container || "prism-ssh")
+      const lines = clampInteger(params.lines, 80, 1, 500)
+      const remote = [
+        `echo '== container =='; docker ps --filter name=${JSON.stringify(container)} --format 'table {{.Names}}\t{{.Image}}\t{{.Status}}\t{{.Ports}}'`,
+        `echo; echo '== image =='; docker inspect ${JSON.stringify(container)} --format '{{.Image}} {{.Config.Image}}' 2>/dev/null || true`,
+        `echo; echo '== logs =='; docker logs --tail ${lines} ${JSON.stringify(container)} 2>&1 || true`,
+      ].join("; ")
+      const output = await run("ssh", ["-o", "BatchMode=yes", host, remote], timeoutMs(params.timeoutMs, 30_000), ctx?.execFileAsync ?? execFileAsync)
+      return textToolResult(output || `No Prism deploy output from ${host}.`, { host, container, lines })
+    },
+  }
+}
+
+export function createPrismDiagnosticToolboxTools(): ToolboxToolDefinition[] {
+  return [
+    createPrismRuntimeStatusTool(),
+    createGiteaPackageVersionTool(),
+    createPortainerWebhookTool(),
+    createPrismDeployCheckTool(),
+  ]
+}

package/src/prism-extensions/tools/toolbox.ts

@@ -29,7 +29,7 @@ export type ToolboxSearchResult = {
 
 import { Type } from "typebox"
 import { createBuiltinToolboxTools } from "./builtin-tools.js"
-import { fuzzyFilter } from "../core/fuzzy.js"
+import { fuzzyScore } from "../core/fuzzy.js"
 import { formatBracketedToolCall, renderSingleLineToolCall, type ThemeLike } from "../ui/tool-call-rendering.js"
 
 export function normalizeToolboxToolName(input: string): string | undefined {
@@ -42,11 +42,35 @@ function toolSearchText(tool: ToolboxToolDefinition): string {
   return [tool.name, tool.label, tool.description, ...(tool.tags ?? []), tool.source].filter(Boolean).join(" ").toLowerCase()
 }
 
+function toolboxSearchScore(tool: ToolboxToolDefinition, query: string): number {
+  const text = toolSearchText(tool)
+  const fullScore = fuzzyScore(text, query)
+  if (fullScore >= 0) return fullScore + 100_000
+
+  const terms = query.toLowerCase().trim().split(/\s+/).filter(Boolean)
+  if (terms.length === 0) return 1
+
+  let matchedTerms = 0
+  let score = 0
+  for (const term of terms) {
+    const termScore = fuzzyScore(text, term)
+    if (termScore >= 0) {
+      matchedTerms += 1
+      score += termScore
+    }
+  }
+
+  return matchedTerms > 0 ? matchedTerms * 10_000 + score : -1
+}
+
 export function searchToolboxTools(tools: ToolboxToolDefinition[], query: string, limit = 10): ToolboxSearchResult[] {
   const safeLimit = Math.max(1, Math.min(50, Math.trunc(Number(limit) || 10)))
-  return fuzzyFilter(tools, query, toolSearchText, (a, b) => a.name.localeCompare(b.name))
+  return tools
+    .map((tool) => ({ tool, score: toolboxSearchScore(tool, query) }))
+    .filter((entry) => entry.score >= 0)
+    .sort((a, b) => b.score - a.score || a.tool.name.localeCompare(b.tool.name))
     .slice(0, safeLimit)
-    .map((tool) => ({
+    .map(({ tool }) => ({
       name: tool.name,
       label: tool.label ?? tool.name,
       description: tool.description,
@@ -64,6 +88,53 @@ function formatResults(results: ToolboxSearchResult[]): string {
   }).join("\n")
 }
 
+const AUTO_SUGGEST_DOMAIN_TERMS = new Set([
+  "backup", "borg", "container", "deploy", "diagnostic", "docker", "gitea", "health", "http", "logs", "netbird", "npm", "opnsense", "package", "pfsense", "port", "portainer", "process", "prism", "registry", "redeploy", "router", "runtime", "service", "services", "ssh", "stack", "status", "systemd", "vpn", "webhook",
+])
+
+const AUTO_SUGGEST_STOPWORDS = new Set([
+  "about", "after", "again", "also", "and", "are", "can", "check", "could", "did", "does", "for", "from", "get", "had", "has", "have", "how", "into", "lets", "like", "need", "now", "please", "show", "that", "the", "then", "they", "this", "tool", "tools", "use", "was", "what", "when", "with", "would", "yes", "you",
+])
+
+function tokenizeForAutoSuggest(text: string): Set<string> {
+  return new Set((text.toLowerCase().match(/[a-z0-9][a-z0-9_-]{1,}/g) ?? []).filter((term) => !AUTO_SUGGEST_STOPWORDS.has(term)))
+}
+
+function hasAutoSuggestIntent(promptTerms: Set<string>): boolean {
+  for (const term of promptTerms) {
+    if (AUTO_SUGGEST_DOMAIN_TERMS.has(term)) return true
+  }
+  return false
+}
+
+function autoSuggestOverlap(tool: ToolboxSearchResult, promptTerms: Set<string>): number {
+  const toolTerms = tokenizeForAutoSuggest([tool.name, tool.label, tool.description, ...tool.tags, tool.source].filter(Boolean).join(" "))
+  let overlap = 0
+  for (const term of promptTerms) {
+    if (toolTerms.has(term)) overlap += AUTO_SUGGEST_DOMAIN_TERMS.has(term) ? 2 : 1
+  }
+  return overlap
+}
+
+export function suggestToolboxToolsForPrompt(tools: ToolboxToolDefinition[], prompt: string, limit = 3): ToolboxSearchResult[] {
+  const query = String(prompt ?? "").trim()
+  if (!query) return []
+  const promptTerms = tokenizeForAutoSuggest(query)
+  if (!hasAutoSuggestIntent(promptTerms)) return []
+
+  return searchToolboxTools(tools, query, Math.max(10, limit * 3))
+    .filter((tool) => autoSuggestOverlap(tool, promptTerms) >= 2)
+    .slice(0, Math.max(1, Math.min(5, Math.trunc(Number(limit) || 3))))
+}
+
+function formatAutoSuggestions(results: ToolboxSearchResult[]): string {
+  return [
+    "Relevant hidden toolbox tools for this request. These are suggestions only; use toolbox_search if you need schemas/details, then toolbox_execute if one is useful.",
+    "",
+    ...results.map((tool) => `- ${tool.name} — ${tool.description}`),
+  ].join("\n")
+}
+
 export function createToolboxRegistry() {
   const tools = new Map<string, ToolboxToolDefinition>()
 
@@ -140,6 +211,19 @@ export default function toolboxExtension(pi: ExtensionAPI): void {
     },
   })
 
+  pi.on?.("before_agent_start", (event: any) => {
+    const suggestions = suggestToolboxToolsForPrompt(registry.list(), String(event?.prompt ?? ""), 3)
+    if (suggestions.length === 0) return
+    return {
+      message: {
+        customType: "toolbox-suggestions",
+        display: false,
+        content: formatAutoSuggestions(suggestions),
+        details: { results: suggestions.map(({ name, source, tags }) => ({ name, source, tags })) },
+      },
+    }
+  })
+
   pi.on?.("session_start", (_event: any, ctx: any) => {
     ctx.ui.setStatus?.("toolbox", registry.size() > 0 ? `🧰 ${registry.size()}` : undefined)
   })

package/src/prism-extensions/ui/toolbar.ts

@@ -106,22 +106,40 @@ export function contextBarLabel(usage: any): string {
   return `[${"█".repeat(filled)}${"░".repeat(10 - filled)}] ${Math.round(used)}% used | ${Math.round(left)}% left`
 }
 
+function numeric(value: unknown): number {
+  const n = Number(value)
+  return Number.isFinite(n) ? n : 0
+}
+
+function usageCost(usage: any): number {
+  const cost = usage?.cost
+  if (cost && typeof cost === "object") return numeric(cost.total ?? numeric(cost.input) + numeric(cost.output) + numeric(cost.cacheRead) + numeric(cost.cacheWrite))
+  return numeric(cost)
+}
+
+function addUsage(stats: { input: number; output: number; cost: number }, usage: any): void {
+  stats.input += numeric(usage?.input ?? usage?.inputTokens)
+  stats.output += numeric(usage?.output ?? usage?.outputTokens)
+  stats.cost += usageCost(usage)
+}
+
 export function sessionStats(ctx: ExtensionContext): { toolCalls: number; input: number; output: number; cost: number } {
-  let toolCalls = 0
-  let input = 0
-  let output = 0
-  let cost = 0
+  const stats = { toolCalls: 0, input: 0, output: 0, cost: 0 }
   const entries = ctx?.sessionManager?.getEntries?.() ?? []
   for (const entry of entries) {
     const message = entry.message ?? entry.data?.message
-    if (entry.type !== "message" && entry.data?.type !== "message") continue
-    if (message?.role !== "assistant") continue
-    for (const block of message.content ?? []) if (block?.type === "toolCall") toolCalls += 1
-    input += Number(message.usage?.input ?? message.usage?.inputTokens ?? 0)
-    output += Number(message.usage?.output ?? message.usage?.outputTokens ?? 0)
-    cost += Number(message.usage?.cost?.total ?? message.usage?.cost ?? 0)
+    if (entry.type === "message" || entry.data?.type === "message") {
+      if (message?.role === "assistant") {
+        for (const block of message.content ?? []) if (block?.type === "toolCall") stats.toolCalls += 1
+        addUsage(stats, message.usage)
+      } else if (message?.role === "toolResult") {
+        addUsage(stats, message.usage)
+      }
+    } else if ((entry.type === "branch_summary" || entry.type === "compaction") && entry.usage) {
+      addUsage(stats, entry.usage)
+    }
   }
-  return { toolCalls, input, output, cost }
+  return stats
 }
 
 export function joinDistributed(parts: string[], width: number): string {
@@ -166,8 +184,9 @@ class ToolbarFooter {
     const caveman = cavemanLabel(statuses?.get("caveman-mode") ?? statuses?.get("caveman"))
     const obsidian = statuses?.get("obsidian-memory")
     const logseq = statuses?.get("logseq-memory")
+    const aiMemory = statuses?.get("ai-memory")
 
-    return [joinDistributed([mode ? fg(this.theme, "success", mode) : undefined, model, fg(this.theme, "accent", `🔧 ${toolCalls}`), fg(this.theme, "dim", `↑${formatTokens(input)}`), fg(this.theme, "dim", `↓${formatTokens(output)}`), fg(this.theme, "success", `$${cost.toFixed(4)}`), context, caveman, obsidian, logseq, thinking].filter(Boolean) as string[], Math.max(0, width))]
+    return [joinDistributed([mode ? fg(this.theme, "success", mode) : undefined, model, fg(this.theme, "accent", `🔧 ${toolCalls}`), fg(this.theme, "dim", `↑${formatTokens(input)}`), fg(this.theme, "dim", `↓${formatTokens(output)}`), fg(this.theme, "success", `$${cost.toFixed(4)}`), context, caveman, obsidian, logseq, aiMemory ? `AI Memory: ${aiMemory}` : undefined, thinking].filter(Boolean) as string[], Math.max(0, width))]
   }
 }
 

package/dist/prism-extensions/integrations/mcp-adapter.d.ts

@@ -1,3 +0,0 @@
-type ExtensionAPI = any;
-export default function prismMcpAdapter(pi: ExtensionAPI): Promise<unknown>;
-export {};

package/dist/prism-extensions/integrations/mcp-adapter.js

@@ -1,21 +0,0 @@
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import { createJiti } from "jiti";
-function localRequireResolve(id) {
-    return import.meta.resolve(id).startsWith("file:") ? fileURLToPath(import.meta.resolve(id)) : import.meta.resolve(id);
-}
-export default async function prismMcpAdapter(pi) {
-    const jiti = createJiti(import.meta.url, {
-        moduleCache: true,
-        alias: {
-            "@earendil-works/pi-ai": localRequireResolve("@earendil-works/pi-ai/compat"),
-            "@earendil-works/pi-ai/compat": localRequireResolve("@earendil-works/pi-ai/compat"),
-            "@earendil-works/pi-ai/oauth": localRequireResolve("@earendil-works/pi-ai/oauth"),
-            "@earendil-works/pi-ai/providers/all": localRequireResolve("@earendil-works/pi-ai/providers/all"),
-        },
-    });
-    const adapterPath = path.join(path.dirname(localRequireResolve("pi-mcp-adapter/package.json")), "index.ts");
-    const mcpAdapter = await jiti.import(adapterPath, { default: true });
-    return mcpAdapter(pi);
-}
-//# sourceMappingURL=mcp-adapter.js.map

package/dist/prism-extensions/integrations/mcp-adapter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mcp-adapter.js","sourceRoot":"","sources":["../../../src/prism-extensions/integrations/mcp-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAA;AAIjC,SAAS,mBAAmB,CAAC,EAAU;IACrC,OAAO,OAAO,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,OAAO,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;AACvH,CAAC;AAED,MAAM,CAAC,OAAO,CAAC,KAAK,UAAU,eAAe,CAAC,EAAgB;IAC5D,MAAM,IAAI,GAAG,UAAU,CAAC,OAAO,IAAI,CAAC,GAAG,EAAE;QACvC,WAAW,EAAE,IAAI;QACjB,KAAK,EAAE;YACL,uBAAuB,EAAE,mBAAmB,CAAC,8BAA8B,CAAC;YAC5E,8BAA8B,EAAE,mBAAmB,CAAC,8BAA8B,CAAC;YACnF,6BAA6B,EAAE,mBAAmB,CAAC,6BAA6B,CAAC;YACjF,qCAAqC,EAAE,mBAAmB,CAAC,qCAAqC,CAAC;SAClG;KACF,CAAC,CAAA;IACF,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,mBAAmB,CAAC,6BAA6B,CAAC,CAAC,EAAE,UAAU,CAAC,CAAA;IAC3G,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAkC,CAAA;IACrG,OAAO,UAAU,CAAC,EAAE,CAAC,CAAA;AACvB,CAAC"}

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"]}