@daniel156161/prism 0.2.92 → 0.2.96

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

@@ -0,0 +1,93 @@
+import { Type } from "typebox"
+import {
+  buildCheckArgs,
+  buildGraphArgs,
+  buildTimelineArgs,
+  hasMexScaffold,
+  isMexCliInstalled,
+  MEX_LOG_TYPES,
+  runMex,
+  type MexRunOptions,
+} from "../core/mex-cli.js"
+import type { ToolboxToolDefinition } from "./toolbox.js"
+import { textToolResult, timeoutMs, type ToolInput } from "./toolbox-utils.js"
+
+const MEX_TAGS = ["mex", "codegraph", "graph", "wiki", "scaffold", "drift", "documentation", "memory"]
+
+function runOptions(params: ToolInput, fallbackTimeout: number): MexRunOptions {
+  return {
+    cwd: typeof params.cwd === "string" && params.cwd.trim() ? params.cwd.trim() : process.cwd(),
+    timeoutMs: timeoutMs(params.timeoutMs, fallbackTimeout),
+  }
+}
+
+function guardScaffold(cwd: string): void {
+  if (!isMexCliInstalled()) throw new Error("mex CLI not found. Install it with: npm install -g mex-agent")
+  if (!hasMexScaffold(cwd)) throw new Error(`No .mex scaffold in ${cwd}. Run 'npx mex-agent setup' first.`)
+}
+
+async function execute(action: string, args: string[], options: MexRunOptions) {
+  guardScaffold(options.cwd ?? process.cwd())
+  const result = await runMex(args, options)
+  return textToolResult(result.output || `mex ${action} produced no output.`, { action, ok: result.ok, exitCode: result.exitCode, cwd: options.cwd })
+}
+
+function createMexGraphBuildTool(): ToolboxToolDefinition {
+  return {
+    name: "mex_graph_build",
+    label: "Mex Graph Build",
+    description: "Rebuild the local mex code knowledge graph (.mex/graph.db) so scope/query/impact results are current.",
+    tags: [...MEX_TAGS, "build", "index", "rebuild"],
+    parameters: Type.Object({
+      cwd: Type.Optional(Type.String({ description: "Repository root. Defaults to the current working directory." })),
+      json: Type.Optional(Type.Boolean({ description: "Return the build summary as JSON." })),
+      timeoutMs: Type.Optional(Type.Number({ description: "Command timeout in milliseconds. Default 120000." })),
+    }),
+    async execute(_id: string, params: ToolInput) {
+      const options = runOptions(params, 120_000)
+      return execute("graph", buildGraphArgs({ json: params.json, root: params.cwd }), options)
+    },
+  }
+}
+
+function createMexCheckTool(): ToolboxToolDefinition {
+  return {
+    name: "mex_check",
+    label: "Mex Check",
+    description: "Run mex drift detection between the .mex wiki and the codebase (paths, commands, dependencies, links, grounded symbols).",
+    tags: [...MEX_TAGS, "check", "health", "stale", "validate"],
+    parameters: Type.Object({
+      cwd: Type.Optional(Type.String({ description: "Repository root. Defaults to the current working directory." })),
+      json: Type.Optional(Type.Boolean({ description: "Return the full drift report as JSON." })),
+      quiet: Type.Optional(Type.Boolean({ description: "Single-line summary only." })),
+      timeoutMs: Type.Optional(Type.Number({ description: "Command timeout in milliseconds. Default 120000." })),
+    }),
+    async execute(_id: string, params: ToolInput) {
+      return execute("check", buildCheckArgs({ json: params.json, quiet: params.quiet }), runOptions(params, 120_000))
+    },
+  }
+}
+
+function createMexTimelineTool(): ToolboxToolDefinition {
+  return {
+    name: "mex_timeline",
+    label: "Mex Timeline",
+    description: `Read recent entries from the mex event log (${MEX_LOG_TYPES.join("/")}) for repo history and past decisions.`,
+    tags: [...MEX_TAGS, "timeline", "events", "decisions", "history", "log"],
+    parameters: Type.Object({
+      cwd: Type.Optional(Type.String({ description: "Repository root. Defaults to the current working directory." })),
+      since: Type.Optional(Type.String({ description: "YYYY-MM-DD or relative like 30d." })),
+      type: Type.Optional(Type.String({ description: MEX_LOG_TYPES.join(" | ") })),
+      limit: Type.Optional(Type.Number({ description: "Maximum entries." })),
+      json: Type.Optional(Type.Boolean({ description: "Return events as JSON." })),
+      timeoutMs: Type.Optional(Type.Number({ description: "Command timeout in milliseconds. Default 30000." })),
+    }),
+    async execute(_id: string, params: ToolInput) {
+      return execute("timeline", buildTimelineArgs(params), runOptions(params, 30_000))
+    },
+  }
+}
+
+export function createMexToolboxTools(): ToolboxToolDefinition[] {
+  return [createMexGraphBuildTool(), createMexCheckTool(), createMexTimelineTool()]
+}

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

@@ -72,6 +72,13 @@ export function toolbarAccent(theme: ThemeLike, text: string): string {
   return fg(theme, "accent", text)
 }
 
+/** Role-play status is only worth a toolbar slot while a role-play is actually running. */
+export function rpLabel(status: string | undefined): string | undefined {
+  const value = status?.trim()
+  if (!value || /^RP:\s*off$/i.test(value)) return undefined
+  return value
+}
+
 export function cavemanColor(mode: string): number {
   const normalized = mode.toLowerCase()
   if (normalized === "lite") return 226
@@ -185,8 +192,10 @@ class ToolbarFooter {
     const obsidian = statuses?.get("obsidian-memory")
     const logseq = statuses?.get("logseq-memory")
     const aiMemory = statuses?.get("ai-memory")
+    const mex = statuses?.get("mex")
+    const rp = rpLabel(statuses?.get("rp"))
 
-    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))]
+    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, mex, rp, thinking].filter(Boolean) as string[], Math.max(0, width))]
   }
 }
 

package/src/prism-extensions/commands/voice-command.ts

@@ -1,49 +0,0 @@
-import { LocalVoiceRuntime, parseVoiceMode, voiceStatus, type VoiceMode } from "../core/voice-runtime.js"
-
-type ExtensionAPI = any
-
-export default function voiceCommandExtension(pi: ExtensionAPI): void {
-  let runtime: LocalVoiceRuntime | undefined
-  let mode: VoiceMode = "off"
-
-  function ensureRuntime(ctx: any): LocalVoiceRuntime {
-    runtime ??= new LocalVoiceRuntime({
-      sendUserMessage: (message) => pi.sendUserMessage(message),
-      notify: (message, level) => ctx?.ui?.notify?.(message, level),
-      setStatus: (value) => ctx?.ui?.setStatus?.("voice", value),
-    })
-    return runtime
-  }
-
-  pi.registerCommand("voice", {
-    description: "Local voice mode: /voice on | output | input | off",
-    handler: async (args: string, ctx: any) => {
-      const next = parseVoiceMode(args)
-      if (!next) {
-        ctx.ui.notify(`Voice mode: ${mode}. Use /voice on, /voice output, /voice input, or /voice off.`, "info")
-        return
-      }
-      mode = next
-      const voice = ensureRuntime(ctx)
-      voice.setMode(mode)
-      ctx.ui.setStatus("voice", voiceStatus(mode))
-      if (mode === "output" || mode === "on") {
-        const ok = await voice.ensureVoicebox()
-        if (voice.isVoiceboxEnabled() && !ok) {
-          ctx.ui.notify("Voicebox is not reachable and could not be started. Check voicebox settings/PRISM_VOICEBOX_URL.", "warning")
-        }
-      }
-      ctx.ui.notify(mode === "off" ? "Voice off" : `Voice ${mode}`, "info")
-    },
-  })
-
-  pi.on("session_start", (_event: any, ctx: any) => {
-    if (mode !== "off") ensureRuntime(ctx).setMode(mode)
-  })
-
-  pi.on("message_end", async (event: any, ctx: any) => {
-    if (mode === "on" || mode === "output") await ensureRuntime(ctx).speakAssistantMessage(event.message)
-  })
-
-  pi.on?.("session_shutdown", () => runtime?.shutdown())
-}

package/src/prism-extensions/core/voice-runtime.ts

@@ -1,322 +0,0 @@
-import * as fs from "node:fs"
-import * as os from "node:os"
-import * as path from "node:path"
-import { spawn, spawnSync, type ChildProcess } from "node:child_process"
-import { readSettings } from "./shared-config.js"
-import { ensureVoiceboxServiceRunning, stopVoiceboxService } from "./voicebox-service.js"
-import { isVoiceboxBackend, resolveVoiceboxConfig, streamSpeechWithVoicebox } from "./voicebox-client.js"
-
-export type VoiceMode = "off" | "on" | "input" | "output"
-
-export interface VoiceConfig {
-  wakeWord: string
-  sttCommand?: string
-  whisperModel?: string
-  ttsCommand?: string
-  piperModel?: string
-  audioPlayer?: string
-  loopCooldownMs: number
-}
-
-export interface VoiceRuntimeOptions {
-  env?: NodeJS.ProcessEnv
-  sendUserMessage: (message: string) => void | Promise<void>
-  notify?: (message: string, level?: string) => void
-  setStatus?: (value: string | undefined) => void
-  spawnProcess?: typeof spawn
-  spawnSyncProcess?: typeof spawnSync
-}
-
-export function parseVoiceMode(input: string): VoiceMode | undefined {
-  const value = String(input || "").trim().toLowerCase()
-  if (!value || value === "status") return undefined
-  if (["on", "full", "both", "all"].includes(value)) return "on"
-  if (["off", "disable", "disabled", "stop"].includes(value)) return "off"
-  if (["input", "in", "listen", "mic"].includes(value)) return "input"
-  if (["output", "out", "speak", "tts"].includes(value)) return "output"
-  return undefined
-}
-
-export function voiceStatus(mode: VoiceMode): string | undefined {
-  if (mode === "off") return undefined
-  if (mode === "on") return "🎙 voice:in+out"
-  return mode === "input" ? "🎙 voice:in" : "🔊 voice:out"
-}
-
-function nonEmpty(value: unknown): string | undefined {
-  return typeof value === "string" && value.trim() ? value.trim() : undefined
-}
-
-export function resolveVoiceConfig(env: NodeJS.ProcessEnv = process.env): VoiceConfig {
-  const settings = readSettings(undefined, env)?.voice ?? {}
-  return {
-    wakeWord: nonEmpty(env.PRISM_VOICE_WAKE_WORD) ?? nonEmpty(settings.wakeWord) ?? "prism",
-    sttCommand: nonEmpty(env.PRISM_VOICE_STT_COMMAND) ?? nonEmpty(settings.sttCommand),
-    whisperModel: nonEmpty(env.PRISM_VOICE_WHISPER_MODEL) ?? nonEmpty(settings.whisperModel),
-    ttsCommand: nonEmpty(env.PRISM_VOICE_TTS_COMMAND) ?? nonEmpty(settings.ttsCommand),
-    piperModel: nonEmpty(env.PRISM_VOICE_PIPER_MODEL) ?? nonEmpty(settings.piperModel),
-    audioPlayer: nonEmpty(env.PRISM_VOICE_AUDIO_PLAYER) ?? nonEmpty(settings.audioPlayer),
-    loopCooldownMs: Math.max(0, Number(env.PRISM_VOICE_LOOP_COOLDOWN_MS ?? settings.loopCooldownMs ?? 1500) || 1500),
-  }
-}
-
-export function stripWakeWord(transcript: string, wakeWord: string): string | undefined {
-  const text = transcript.replace(/\s+/g, " ").trim()
-  if (!text) return undefined
-  const escaped = wakeWord.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-  const match = text.match(new RegExp(`(?:^|\\b)(?:hey\\s+|ok\\s+|okay\\s+)?${escaped}\\b[:,;\\-]?\\s*(.*)$`, "iu"))
-  const command = match?.[1]?.trim()
-  return command || undefined
-}
-
-export function normalizeVoiceText(text: string): string {
-  return text.toLowerCase().replace(/[^\p{L}\p{N}]+/gu, " ").replace(/\s+/g, " ").trim()
-}
-
-export function shouldIgnoreTranscript(transcript: string, state: { isSpeaking: boolean; lastSpokenText?: string; lastSpokenAt?: number }, now = Date.now(), cooldownMs = 1500): boolean {
-  if (state.isSpeaking) return true
-  if (state.lastSpokenAt && now - state.lastSpokenAt < cooldownMs) return true
-  const heard = normalizeVoiceText(transcript)
-  const spoken = normalizeVoiceText(state.lastSpokenText ?? "")
-  if (!heard || !spoken) return false
-  return heard.length >= 12 && (spoken.includes(heard) || heard.includes(spoken.slice(0, Math.min(spoken.length, 160))))
-}
-
-function isThinkingTextBlock(block: any): boolean {
-  if (!block || typeof block !== "object") return false
-  const marker = String(block.type ?? block.kind ?? block.name ?? block.category ?? block.role ?? "").toLowerCase()
-  if (/thinking|reasoning|scratchpad|analysis/.test(marker)) return true
-  if (block.thinking || block.reasoning || block.isThinking || block.isReasoning) return true
-  const metadata = block.metadata ?? block.providerMetadata ?? block.experimental_providerMetadata
-  if (metadata && typeof metadata === "object") {
-    const metadataMarker = JSON.stringify(metadata).toLowerCase()
-    if (/thinking|reasoning|scratchpad|analysis/.test(metadataMarker)) return true
-  }
-  return false
-}
-
-function stripThinkingText(text: string): string {
-  return text
-    .replace(/<\s*(think|thinking|reasoning|analysis|scratchpad)\b[^>]*>[\s\S]*?<\s*\/\s*\1\s*>/giu, " ")
-    .replace(/^\s*(?:#{1,6}\s*)?(?:thinking|reasoning|analysis|scratchpad|internal notes?)\s*:?\s*$/gimu, " ")
-}
-
-export function messageToSpeechText(message: any, maxChars = 4000): string {
-  if (!message || message.role !== "assistant" || message.stopReason === "error") return ""
-  const content = message.content
-  if (Array.isArray(content) && content.some((block: any) => block?.type === "toolCall" || block?.type === "tool-call" || block?.toolCallId || block?.name && block?.arguments)) return ""
-  const text = Array.isArray(content)
-    ? content.filter((block: any) => block?.type === "text" && typeof block.text === "string" && !isThinkingTextBlock(block)).map((block: any) => block.text).join("\n")
-    : typeof content === "string" ? content : ""
-  return stripThinkingText(text)
-    .replace(/```[\s\S]*?```/g, "Code block omitted.")
-    .replace(/`([^`]+)`/g, "$1")
-    .replace(/\s+/g, " ")
-    .trim()
-    .slice(0, maxChars)
-}
-
-function commandExists(command: string, spawnSyncProcess: typeof spawnSync): boolean {
-  return spawnSyncProcess("sh", ["-lc", `command -v ${JSON.stringify(command)} >/dev/null 2>&1`], { stdio: "ignore" }).status === 0
-}
-
-function defaultSttCommand(config: VoiceConfig): string | undefined {
-  if (!config.whisperModel) return undefined
-  return `whisper-stream -m ${JSON.stringify(config.whisperModel)} --step 3000 --length 5000 --keep 500 -t 4`
-}
-
-function chooseAudioPlayer(config: VoiceConfig, spawnSyncProcess: typeof spawnSync): string | undefined {
-  if (config.audioPlayer) return config.audioPlayer
-  for (const candidate of ["paplay", "aplay", "ffplay"]) {
-    if (commandExists(candidate, spawnSyncProcess)) return candidate === "ffplay" ? "ffplay -nodisp -autoexit" : candidate
-  }
-  return undefined
-}
-
-export class LocalVoiceRuntime {
-  private mode: VoiceMode = "off"
-  private sttProcess?: ChildProcess
-  private isSpeaking = false
-  private lastSpokenText = ""
-  private lastSpokenAt = 0
-  private readonly env: NodeJS.ProcessEnv
-  private readonly spawnProcess: typeof spawn
-  private readonly spawnSyncProcess: typeof spawnSync
-
-  constructor(private readonly options: VoiceRuntimeOptions) {
-    this.env = options.env ?? process.env
-    this.spawnProcess = options.spawnProcess ?? spawn
-    this.spawnSyncProcess = options.spawnSyncProcess ?? spawnSync
-  }
-
-  getMode(): VoiceMode { return this.mode }
-
-  setMode(mode: VoiceMode): void {
-    this.mode = mode
-    this.options.setStatus?.(voiceStatus(mode))
-    if (mode === "on" || mode === "input") this.startInput()
-    else {
-      this.stopInput()
-      if (mode === "off") void this.stopVoicebox()
-    }
-  }
-
-  shutdown(): void {
-    this.stopInput()
-    void this.stopVoicebox()
-    this.options.setStatus?.(undefined)
-  }
-
-  async speakAssistantMessage(message: any): Promise<void> {
-    if (this.mode !== "on" && this.mode !== "output") return
-    const text = messageToSpeechText(message)
-    if (!text) return
-    await this.speak(text)
-  }
-
-  isVoiceboxEnabled(): boolean {
-    return isVoiceboxBackend(this.env)
-  }
-
-  async checkVoicebox(): Promise<boolean> {
-    if (!this.isVoiceboxEnabled()) return false
-    const { checkVoiceboxHealth } = await import("./voicebox-client.js")
-    return checkVoiceboxHealth(resolveVoiceboxConfig(this.env))
-  }
-
-  async ensureVoicebox(): Promise<boolean> {
-    if (!this.isVoiceboxEnabled()) return false
-    return ensureVoiceboxServiceRunning(this.env, this.spawnSyncProcess, this.options.notify)
-  }
-
-  async stopVoicebox(): Promise<boolean> {
-    if (!this.isVoiceboxEnabled()) return false
-    return stopVoiceboxService(this.env, this.spawnSyncProcess)
-  }
-
-  handleTranscript(rawTranscript: string): void {
-    if (this.mode !== "on" && this.mode !== "input") return
-    const config = resolveVoiceConfig(this.env)
-    if (shouldIgnoreTranscript(rawTranscript, { isSpeaking: this.isSpeaking, lastSpokenText: this.lastSpokenText, lastSpokenAt: this.lastSpokenAt }, Date.now(), config.loopCooldownMs)) return
-    const command = stripWakeWord(rawTranscript, config.wakeWord)
-    if (!command) return
-    void this.options.sendUserMessage(command)
-  }
-
-  private startInput(): void {
-    if (this.sttProcess) return
-    const config = resolveVoiceConfig(this.env)
-    const command = config.sttCommand ?? defaultSttCommand(config)
-    if (!command) {
-      this.options.notify?.("Voice input needs PRISM_VOICE_STT_COMMAND or PRISM_VOICE_WHISPER_MODEL (whisper.cpp whisper-stream).", "warning")
-      return
-    }
-
-    const child = this.spawnProcess(command, { shell: true, stdio: ["ignore", "pipe", "pipe"], env: this.env })
-    this.sttProcess = child
-    child.stdout?.setEncoding("utf-8")
-    child.stdout?.on("data", (chunk: string) => {
-      for (const line of String(chunk).split(/\r?\n/)) this.handleTranscript(line)
-    })
-    child.stderr?.setEncoding("utf-8")
-    child.stderr?.on("data", (chunk: string) => {
-      const line = String(chunk).split(/\r?\n/).find((value) => value.trim())
-      if (line && /error|failed|no such|cannot/i.test(line)) this.options.notify?.(`Voice input: ${line.trim()}`, "warning")
-    })
-    child.on("exit", () => {
-      if (this.sttProcess === child) this.sttProcess = undefined
-      if (this.mode === "on" || this.mode === "input") this.options.notify?.("Voice input stopped.", "warning")
-    })
-    this.options.notify?.(`Voice input listening for wake word “${config.wakeWord}”.`, "info")
-  }
-
-  private stopInput(): void {
-    const child = this.sttProcess
-    this.sttProcess = undefined
-    if (!child || child.killed) return
-    child.kill("SIGTERM")
-    setTimeout(() => { if (!child.killed) child.kill("SIGKILL") }, 1000).unref?.()
-  }
-
-  private async speak(text: string): Promise<void> {
-    const config = resolveVoiceConfig(this.env)
-    const command = config.ttsCommand
-    this.isSpeaking = true
-    this.lastSpokenText = text
-    try {
-      if (isVoiceboxBackend(this.env)) {
-        const ok = await this.ensureVoicebox()
-        if (!ok) {
-          this.options.notify?.("Voicebox is not reachable and could not be started.", "warning")
-          return
-        }
-        const player = chooseAudioPlayer(config, this.spawnSyncProcess)
-        if (!player) {
-          this.options.notify?.("Voicebox output needs an audio player: paplay, aplay, ffplay, or PRISM_VOICE_AUDIO_PLAYER.", "warning")
-          return
-        }
-        await this.streamVoiceboxToPlayer(text, player)
-        return
-      }
-      if (command) {
-        await this.runShell(command, text)
-        return
-      }
-      if (!config.piperModel) {
-        this.options.notify?.("Voice output needs PRISM_VOICE_TTS_COMMAND or PRISM_VOICE_PIPER_MODEL (Piper TTS).", "warning")
-        return
-      }
-      const player = chooseAudioPlayer(config, this.spawnSyncProcess)
-      if (!player) {
-        this.options.notify?.("Voice output needs an audio player: paplay, aplay, ffplay, or PRISM_VOICE_AUDIO_PLAYER.", "warning")
-        return
-      }
-      const wav = path.join(os.tmpdir(), `prism-voice-${process.pid}-${Date.now()}.wav`)
-      await this.runCommand("piper", ["--model", config.piperModel, "--output_file", wav], text)
-      await this.runShell(`${player} ${JSON.stringify(wav)}`, "")
-      fs.rmSync(wav, { force: true })
-    } finally {
-      this.lastSpokenAt = Date.now()
-      this.isSpeaking = false
-    }
-  }
-
-  private streamVoiceboxToPlayer(text: string, player: string): Promise<void> {
-    return new Promise((resolve) => {
-      const child = this.spawnProcess(player, { shell: true, stdio: ["pipe", "ignore", "pipe"], env: this.env })
-      let settled = false
-      const finish = () => {
-        if (settled) return
-        settled = true
-        resolve()
-      }
-      child.on("exit", finish)
-      child.on("error", finish)
-      streamSpeechWithVoicebox(text, (chunk) => {
-        if (!child.stdin?.writable) return
-        child.stdin.write(Buffer.from(chunk))
-      }, resolveVoiceboxConfig(this.env)).then(() => child.stdin?.end()).catch(() => {
-        child.stdin?.destroy()
-        finish()
-      })
-    })
-  }
-
-  private runShell(command: string, input: string): Promise<void> {
-    return new Promise((resolve) => {
-      const child = this.spawnProcess(command, { shell: true, stdio: ["pipe", "ignore", "pipe"], env: this.env })
-      child.stdin?.end(input)
-      child.on("exit", () => resolve())
-      child.on("error", () => resolve())
-    })
-  }
-
-  private runCommand(command: string, args: string[], input: string): Promise<void> {
-    return new Promise((resolve) => {
-      const child = this.spawnProcess(command, args, { stdio: ["pipe", "ignore", "pipe"], env: this.env })
-      child.stdin?.end(input)
-      child.on("exit", () => resolve())
-      child.on("error", () => resolve())
-    })
-  }
-}