@rol1n/pi-kit 0.0.0-stage → 0.1.1

package/subagent/session.ts

@@ -0,0 +1,166 @@
+import { openSync, readFileSync, readSync, closeSync } from "node:fs";
+
+export interface SessionEntry {
+  type: string;
+  id: string;
+  parentId?: string | null;
+  [key: string]: unknown;
+}
+
+export interface AssistantMessage {
+  role: "assistant";
+  content?: unknown;
+  stopReason?: string;
+  errorMessage?: string;
+  model?: string;
+  usage?: Record<string, unknown>;
+}
+
+export interface SessionUsage {
+  model?: string;
+  toolCount: number;
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  contextTokens: number;
+  cost: number;
+}
+
+export function readEntries(sessionFile: string): SessionEntry[] {
+  let content: string;
+  try {
+    content = readFileSync(sessionFile, "utf8");
+  } catch {
+    return [];
+  }
+  const entries: SessionEntry[] = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+      // ignore malformed or mid-append lines
+    }
+  }
+  return entries;
+}
+
+export function getSessionId(sessionFile: string): string | null {
+  let fd: number | undefined;
+  try {
+    fd = openSync(sessionFile, "r");
+    const buf = Buffer.allocUnsafe(4096);
+    const bytes = readSync(fd, buf, 0, 4096, 0);
+    if (bytes <= 0) return null;
+    const nl = buf.indexOf(0x0a);
+    const end = nl === -1 || nl >= bytes ? bytes : nl;
+    const firstLine = buf.toString("utf8", 0, end).trim();
+    if (!firstLine) return null;
+    const parsed = JSON.parse(firstLine);
+    return parsed.type === "session" && typeof parsed.id === "string" ? parsed.id : null;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined) {
+      try {
+        closeSync(fd);
+      } catch {}
+    }
+  }
+}
+
+/**
+ * Extracts the last assistant response text from a session JSONL file.
+ * Handles auto-retry error messages as fallback.
+ */
+export function findLastAssistantMessage(sessionFile: string): string | null {
+  const entries = readEntries(sessionFile);
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i];
+    if (entry.type !== "message" || typeof entry.message !== "object" || entry.message === null) continue;
+    const msg = entry.message as AssistantMessage;
+    if (msg.role !== "assistant") continue;
+
+    if (Array.isArray(msg.content)) {
+      const texts: string[] = [];
+      for (const block of msg.content) {
+        if (typeof block === "object" && block !== null && (block as any).type === "text" && typeof (block as any).text === "string") {
+          texts.push((block as any).text);
+        }
+      }
+      const combined = texts.join("\n").trim();
+      if (combined) return combined;
+    }
+
+    if (msg.stopReason === "error" && typeof msg.errorMessage === "string" && msg.errorMessage.trim()) {
+      return `Worker error: ${msg.errorMessage.trim()}`;
+    }
+  }
+  return null;
+}
+
+/**
+ * Summarize token usage and cost across all assistant turns.
+ */
+export function readSessionUsage(sessionFile: string): SessionUsage | undefined {
+  let content: string;
+  try {
+    content = readFileSync(sessionFile, "utf8");
+  } catch {
+    return undefined;
+  }
+
+  const usage: SessionUsage = {
+    toolCount: 0,
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    contextTokens: 0,
+    cost: 0,
+  };
+
+  const num = (value: unknown): number =>
+    typeof value === "number" && Number.isFinite(value) ? value : 0;
+
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    let entry: Record<string, unknown>;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+
+    if (entry.type === "model_change" && typeof entry.modelId === "string" && entry.modelId) {
+      usage.model = entry.modelId;
+      continue;
+    }
+    if (entry.type !== "message") continue;
+    const message = entry.message as AssistantMessage | undefined;
+    if (!message || message.role !== "assistant") continue;
+
+    if (typeof message.model === "string" && message.model) usage.model = message.model;
+    if (Array.isArray(message.content)) {
+      for (const block of message.content) {
+        if (typeof block === "object" && block !== null && (block as any).type === "toolCall") {
+          usage.toolCount++;
+        }
+      }
+    }
+
+    const record = message.usage as Record<string, unknown> | undefined;
+    if (!record || typeof record !== "object") continue;
+    usage.input += num(record.input);
+    usage.output += num(record.output);
+    usage.cacheRead += num(record.cacheRead);
+    usage.cacheWrite += num(record.cacheWrite);
+    const total = num(record.totalTokens);
+    if (total > 0) usage.contextTokens = total;
+    const cost = record.cost as Record<string, unknown> | undefined;
+    if (cost && typeof cost === "object") usage.cost += num(cost.total);
+  }
+
+  return usage;
+}

package/subagent/ui.ts

@@ -0,0 +1,100 @@
+/**
+ * subagent/ui.ts — Status widget for active subagent workers above the editor.
+ *
+ * Compact, borderless, multi-worker friendly layout matching the SRP theme suite.
+ */
+
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { readSessionUsage, type SessionUsage } from "./session.ts";
+
+export type WorkerState = "running" | "waiting" | "done" | "error";
+
+export interface WorkerStatus {
+  name: string;
+  state: WorkerState;
+  startTime: number;
+  sessionFile: string;
+  question?: string;
+  error?: string;
+  backend?: string;
+}
+
+export function formatTokenCount(value: number): string {
+  if (value < 1000) return `${value}`;
+  if (value < 1_000_000) return `${(value / 1000).toFixed(1)}k`;
+  return `${(value / 1_000_000).toFixed(2)}M`;
+}
+
+export function formatElapsed(seconds: number): string {
+  const total = Math.max(0, Math.floor(seconds));
+  const m = Math.floor(total / 60);
+  const s = total % 60;
+  if (m > 0) return `${m}m${String(s).padStart(2, "0")}s`;
+  return `${s}s`;
+}
+
+function usageSegments(usage: SessionUsage): string[] {
+  const parts: string[] = [];
+  if (usage.toolCount > 0) parts.push(`${usage.toolCount} calls`);
+  if (usage.input > 0) parts.push(`↑${formatTokenCount(usage.input)}`);
+  if (usage.output > 0) parts.push(`↓${formatTokenCount(usage.output)}`);
+  if (usage.cost > 0) parts.push(`$${usage.cost < 0.1 ? usage.cost.toFixed(4) : usage.cost.toFixed(2)}`);
+  return parts;
+}
+
+function stateStyle(state: WorkerState, theme: Theme): { icon: string; label: string } {
+  switch (state) {
+    case "running":
+      return { icon: theme.fg("accent", "●"), label: theme.fg("accent", "running") };
+    case "waiting":
+      return { icon: theme.fg("warning", "◆"), label: theme.fg("warning", "waiting: ask") };
+    case "done":
+      return { icon: theme.fg("success", "✔"), label: theme.fg("success", "done") };
+    case "error":
+      return { icon: theme.fg("error", "✖"), label: theme.fg("error", "error") };
+  }
+}
+
+/**
+ * Render multi-worker status lines for ctx.ui.setWidget.
+ */
+export function renderWorkersWidget(workers: WorkerStatus[], theme: Theme, maxRows = 4): string[] {
+  if (workers.length === 0) return [];
+
+  const waitingCount = workers.filter((w) => w.state === "waiting").length;
+  const statusNote = waitingCount > 0 ? theme.fg("warning", ` · ${waitingCount} awaiting reply`) : "";
+  const header = `${theme.fg("accent", "◆")} ${theme.bold("Subagents")} ${theme.fg("dim", `· ${workers.length} active`)}${statusNote}`;
+
+  const visible = workers.slice(0, maxRows);
+  const overflow = workers.length - visible.length;
+
+  const rows = visible.map((worker) => {
+    const elapsed = formatElapsed((Date.now() - worker.startTime) / 1000);
+    const { icon, label } = stateStyle(worker.state, theme);
+
+    let detail = "";
+    if (worker.state === "waiting" && worker.question) {
+      const q = worker.question.length > 40 ? `${worker.question.slice(0, 37)}...` : worker.question;
+      detail = ` ${theme.fg("warning", `[Q: "${q}"]`)}`;
+    } else {
+      const usage = readSessionUsage(worker.sessionFile);
+      if (usage) {
+        const segments = usageSegments(usage).map((seg) => theme.fg("dim", seg));
+        if (segments.length > 0) detail = ` ${segments.join(theme.fg("dim", " · "))}`;
+      }
+    }
+
+    if (worker.state === "error" && worker.error) {
+      detail = ` ${theme.fg("error", worker.error.split("\n")[0])}`;
+    }
+
+    const backendTag = worker.backend === "process" ? theme.fg("dim", " [bg]") : "";
+    return `  ${icon} ${theme.bold(worker.name)}${backendTag} ${label} ${theme.fg("dim", elapsed)}${detail}`;
+  });
+
+  if (overflow > 0) {
+    rows.push(`  ${theme.fg("muted", `+${overflow} more workers running...`)}`);
+  }
+
+  return [header, ...rows];
+}

package/tui-asr/README.md

@@ -0,0 +1,21 @@
+# tui-asr
+
+Streaming voice dictation for Pi's terminal editor using Aliyun DashScope Paraformer.
+
+## Install
+
+```sh
+pi install npm:@rol1n/tui-asr
+```
+
+Also included in `@rol1n/pi-kit`. Installing this package automatically installs `@rol1n/custom-providers`.
+
+## Commands and shortcuts
+
+| Action | Trigger |
+|---|---|
+| Start / stop dictation | `/asr` or `Alt+M` |
+| Cancel dictation | `Alt+N` |
+| Switch ASR model | `/asr model [name]` |
+
+Requires `sox` (`rec` on POSIX, `sox -t waveaudio` on Windows) on `PATH` and DashScope credentials via `/login dashscope`, `DASHSCOPE_API_KEY`, or `ALIYUN_API_KEY`.

package/tui-asr/dictation.ts

@@ -0,0 +1,272 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { spawn, type ChildProcessByStdio } from "node:child_process";
+import type { Readable } from "node:stream";
+import {
+  ALL_ASR_MODELS,
+  createAsrProvider,
+  ensureCustomProviders,
+  type AsrModelDefinition,
+  type StreamingAsrProvider,
+} from "../custom-providers/index.ts";
+import { insertTranscript } from "./input.ts";
+import { createStatusDisplay } from "./status.ts";
+
+export { ALL_ASR_MODELS, createAsrProvider, ensureCustomProviders, type AsrModelDefinition, type StreamingAsrProvider };
+
+export async function resolveProviderApiKey(provider: string, ctx?: ExtensionContext | null): Promise<string> {
+  if (ctx?.modelRegistry) {
+    const candidates = provider === "dashscope" ? ["dashscope", "aliyun"] : [provider];
+    for (const id of candidates) {
+      try {
+        const key = await ctx.modelRegistry.getApiKeyForProvider(id);
+        if (key?.trim()) return key.trim();
+      } catch {}
+      try {
+        const auth = await ctx.modelRegistry.getProviderAuth(id);
+        if (auth?.auth?.apiKey?.trim()) return auth.auth.apiKey.trim();
+      } catch {}
+    }
+  }
+  const envKey = process.env[`${provider.toUpperCase()}_API_KEY`];
+  if (envKey?.trim()) return envKey.trim();
+  if (provider === "dashscope") {
+    return process.env.ALIYUN_API_KEY?.trim() || "";
+  }
+  return "";
+}
+
+export function rmsFromPcm16(buf: Buffer): number {
+  if (buf.length < 2) return 0;
+  const sampleCount = Math.floor(buf.length / 2);
+  let sumSquares = 0;
+  for (let i = 0; i < sampleCount; i++) {
+    const sample = buf.readInt16LE(i * 2);
+    sumSquares += sample * sample;
+  }
+  const meanSquare = sumSquares / sampleCount;
+  return Math.sqrt(meanSquare);
+}
+
+/** Spawn the existing 16 kHz mono PCM recorder for the current platform. */
+export function spawnRecorder(): ChildProcessByStdio<null, Readable, Readable> {
+  const commonAudioArgs = [
+    "-q",
+    "--buffer", "512",
+    "-r", "16000",
+    "-c", "1",
+    "-b", "16",
+    "-e", "signed-integer",
+    "-t", "raw",
+    "-",
+  ];
+
+  let proc: ChildProcessByStdio<null, Readable, Readable>;
+  if (process.platform === "win32") {
+    proc = spawn("sox", ["-t", "waveaudio", "default", ...commonAudioArgs], { stdio: ["ignore", "pipe", "pipe"] });
+  } else {
+    try {
+      proc = spawn("rec", commonAudioArgs, { stdio: ["ignore", "pipe", "pipe"] });
+    } catch {
+      proc = spawn("sox", ["-d", ...commonAudioArgs], { stdio: ["ignore", "pipe", "pipe"] });
+    }
+  }
+  return proc;
+}
+
+type State = "idle" | "recording" | "stopping";
+
+/** Keep recording state, cancellation guards, and cleanup in one session-local controller. */
+export function createDictationController(getActiveModel: () => string, getTuiHandle: () => any) {
+  let state: State = "idle";
+  let rec: ChildProcessByStdio<null, Readable, Readable> | null = null;
+  let activeProvider: StreamingAsrProvider | null = null;
+  let finals: string[] = [];
+  let activeCtx: ExtensionContext | null = null;
+  let flushed = false;
+  let cancelled = false;
+  let stopTimeout: NodeJS.Timeout | null = null;
+  let generation = 0;
+
+  const status = createStatusDisplay(() => activeCtx);
+  const { setStatus, startMeter, stopMeter, startSpinner, stopSpinner } = status;
+
+  /** Flush transcribed text into the focused component once per recording. */
+  const flush = () => {
+    if (flushed || !activeCtx) return;
+    flushed = true;
+    if (cancelled) return;
+
+    const text = finals.join(" ").replace(/\s+/g, " ").trim();
+    if (!text) return;
+    insertTranscript(activeCtx, getTuiHandle(), text);
+  };
+
+  const cleanup = () => {
+    generation++;
+    flush();
+    stopSpinner();
+    stopMeter();
+    if (stopTimeout) {
+      clearTimeout(stopTimeout);
+      stopTimeout = null;
+    }
+    if (rec) {
+      try {
+        rec.kill("SIGTERM");
+      } catch {}
+      rec = null;
+    }
+    if (activeProvider) {
+      try {
+        activeProvider.cancel();
+      } catch {}
+      activeProvider = null;
+    }
+    finals = [];
+    state = "idle";
+    setStatus(undefined);
+    activeCtx = null;
+    flushed = false;
+    cancelled = false;
+  };
+
+  const startDictation = async (ctx: ExtensionContext) => {
+    const modelDef = ALL_ASR_MODELS.find((m) => m.id === getActiveModel()) ?? ALL_ASR_MODELS[0];
+    const apiKey = await resolveProviderApiKey(modelDef.provider, ctx);
+    if (!apiKey) {
+      ctx.ui.notify(
+        `API Key not found for ${modelDef.provider}.\nPlease run /login ${modelDef.provider} in terminal or set ${modelDef.provider.toUpperCase()}_API_KEY.`,
+        "error",
+      );
+      return;
+    }
+
+    activeCtx = ctx;
+    finals = [];
+    flushed = false;
+    cancelled = false;
+    state = "recording";
+
+    const provider = createAsrProvider(modelDef.provider, modelDef.id, apiKey);
+    activeProvider = provider;
+    const myGeneration = ++generation;
+    startMeter();
+
+    // Spawn cross-platform audio recorder (sox / rec)
+    let proc: ChildProcessByStdio<null, Readable, Readable>;
+    let recorderStderr = "";
+    try {
+      proc = spawnRecorder();
+    } catch {
+      ctx.ui.notify("Failed to spawn audio recorder. Please ensure sox or rec is installed (e.g. sudo pacman -S sox).", "error");
+      cleanup();
+      return;
+    }
+    rec = proc;
+
+    proc.stderr?.on("data", (chunk: Buffer) => {
+      recorderStderr += chunk.toString();
+    });
+
+    proc.on("error", (err) => {
+      if (myGeneration !== generation) return;
+      ctx.ui.notify(`Audio recording error: ${err.message}`, "error");
+      cleanup();
+    });
+
+    proc.on("exit", (code) => {
+      if (myGeneration !== generation) return;
+      if (state === "recording" && code !== null && code !== 0) {
+        if (activeCtx) {
+          const detail = recorderStderr.trim() ? `: ${recorderStderr.trim()}` : "";
+          activeCtx.ui.notify(`Audio recorder exited unexpectedly (code ${code})${detail}`, "warning");
+        }
+        cleanup();
+      }
+    });
+
+    // Start provider streaming connection
+    try {
+      await provider.start({
+        onFinal: (t) => {
+          if (myGeneration !== generation || cancelled) return;
+          if (t) finals.push(t);
+        },
+        onError: (err) => {
+          if (myGeneration !== generation || cancelled) return;
+          if (activeCtx) activeCtx.ui.notify(`DashScope ASR error: ${err.message}`, "error");
+          cleanup();
+        },
+        onClose: () => {
+          if (myGeneration !== generation || cancelled) return;
+          if (state === "recording" || state === "stopping") {
+            cleanup();
+          }
+        },
+      });
+    } catch (err: any) {
+      if (myGeneration !== generation || cancelled) return;
+      ctx.ui.notify(`Failed to connect to DashScope: ${err.message}`, "error");
+      cleanup();
+      return;
+    }
+
+    if (myGeneration !== generation || !rec) return;
+
+    rec.stdout.on("data", (chunk: Buffer) => {
+      status.setLevel(rmsFromPcm16(chunk));
+      if (provider && state === "recording") {
+        provider.sendAudio(chunk);
+      }
+    });
+  };
+
+  const stopDictation = async () => {
+    if (state !== "recording") return;
+    state = "stopping";
+    stopMeter();
+    startSpinner("finalizing…");
+
+    if (rec) {
+      try {
+        rec.kill("SIGTERM");
+      } catch {}
+    }
+
+    if (activeProvider) {
+      try {
+        await activeProvider.stop();
+      } catch {
+        cleanup();
+        return;
+      }
+
+      stopTimeout = setTimeout(() => {
+        if (state === "stopping") cleanup();
+      }, 3000);
+    } else {
+      cleanup();
+    }
+  };
+
+  const cancelDictation = () => {
+    if (state !== "recording" && state !== "stopping") return;
+    cancelled = true;
+    finals = [];
+    cleanup();
+    if (activeCtx) activeCtx.ui.notify("Voice dictation cancelled", "info");
+  };
+
+  const toggleDictation = async (ctx: ExtensionContext) => {
+    if (state === "idle") {
+      await startDictation(ctx);
+    } else if (state === "recording") {
+      await stopDictation();
+    }
+  };
+
+  return {
+    get state() { return state; },
+    startDictation, stopDictation, cancelDictation, toggleDictation, cleanup,
+  };
+}