@maheidem/pi-audio-transcribe 0.2.0 → 0.2.1

package/index.ts

@@ -29,6 +29,7 @@ import { extractAudioPaths, expandPath, tokenizeArgs } from "./paths.ts";
 import { expandInputs, formatSummary, resolveSttModel, transcribeOne, type FileResult, type PipelineCtx, type Setup } from "./pipeline.ts";
 import { AudioSettingsController, type AudioSettingKey } from "./settings.ts";
 import { buildAudioPanelSnapshot } from "./ui/audio-panel.ts";
+import { audioTranscribeVersion } from "./version.ts";
 import { SettingsPanel, type PanelResult } from "./ui/settings-panel.ts";
 
 const TAG = "[audio-transcribe]";
@@ -83,7 +84,7 @@ export default function (pi: ExtensionAPI) {
 	async function reportStatus(ctx: ExtensionContext): Promise<void> {
 		const cfg = resolveConfig();
 		const health = await serverHealth(cfg.baseUrl, cfg.apiKey, 8_000, ctx.signal);
-		const setup = await getSetup(true);
+		const setup = await getSetup(true).catch(() => null); // an unreachable server must never break --status
 		const models = health.reachable
 			? await listSttModels(cfg.baseUrl, cfg.apiKey, 8_000, ctx.signal).catch(() => [] as SttModel[])
 			: [];
@@ -91,10 +92,11 @@ export default function (pi: ExtensionAPI) {
 			ctx,
 			[
 				`${TAG} status`,
+				`  version:     v${audioTranscribeVersion()} (loaded at session start; /reload picks up newer installs)`,
 				`  server:      ${cfg.baseUrl}`,
 				`  status:      ${health.reachable ? `ok (oMLX ${health.version})` : `UNREACHABLE — ${health.error}`}`,
-				`  model:       ${setup.model ?? "none discovered"}`,
-				`  resident:    ${setup.modelInfo?.loaded ? "yes" : "no (cold load on first use)"}`,
+				`  model:       ${setup?.model ?? "none discovered"}`,
+				`  resident:    ${setup?.modelInfo?.loaded ? "yes" : "no (cold load on first use)"}`,
 				`  language:    ${cfg.language ?? "auto-detect (default)"}`,
 				`  cross-check: ${cfg.crossCheck ? "on" : "off"}`,
 				`  input hook:  ${cfg.autoDetect ? "on" : "off"}`,
@@ -298,25 +300,35 @@ export default function (pi: ExtensionAPI) {
 		const found = extractAudioPaths(event.text ?? "");
 		if (!found.length) return { action: "continue" as const };
 
-		const setup = await getSetup();
-		if (!setup.model) return { action: "continue" as const };
+		// Session safety: this hook must NEVER break a prompt. If the oMLX
+		// server is unreachable (getSetup -> listSttModels throws) or anything
+		// else in the setup/transcribe path fails, log one tagged line and
+		// pass the text through untranscribed.
+		try {
+			const setup = await getSetup();
+			if (!setup.model) return { action: "continue" as const };
 
-		const blocks: string[] = [];
-		for (const p of found) {
-			const abs = expandPath(p, ctx.cwd);
-			const st = await (await import("node:fs/promises")).stat(abs).catch(() => null);
-			if (!st || st.isDirectory() || !isAudioPath(abs)) continue; // ignore passing mentions of absent files
-			say(ctx, `${TAG} auto-transcribing ${abs.split("/").pop()}`, "info");
-			const r = await transcribeOne(abs, setup, hostCtx(ctx, (c, a, o) => pi.exec(c, a, o)));
-			if (r.error) blocks.push(`[audio-transcribe] ${abs}: FAILED — ${r.error}`);
-			else if (r.skipped) blocks.push(`[audio-transcribe] ${abs}: skipped — ${r.skipReason}`);
-			else {
-				const head = `[audio-transcribe] ${abs}\nverdict=${r.verdict} confidence=${((r.confidence ?? 0) * 100).toFixed(0)}% language=${r.language ?? "?"} duration=${r.durationSeconds?.toFixed(1) ?? "?"}s sidecar=${r.sidecarPath}`;
-				blocks.push(`${head}\ntranscript:\n${r.text}`);
-				if (r.recommendations?.length) blocks.push(`advice: ${r.recommendations.join(" | ")}`);
+			const blocks: string[] = [];
+			for (const p of found) {
+				const abs = expandPath(p, ctx.cwd);
+				const st = await (await import("node:fs/promises")).stat(abs).catch(() => null);
+				if (!st || st.isDirectory() || !isAudioPath(abs)) continue; // ignore passing mentions of absent files
+				say(ctx, `${TAG} auto-transcribing ${abs.split("/").pop()}`, "info");
+				const r = await transcribeOne(abs, setup, hostCtx(ctx, (c, a, o) => pi.exec(c, a, o)));
+				if (r.error) blocks.push(`[audio-transcribe] ${abs}: FAILED — ${r.error}`);
+				else if (r.skipped) blocks.push(`[audio-transcribe] ${abs}: skipped — ${r.skipReason}`);
+				else {
+					const head = `[audio-transcribe] ${abs}\nverdict=${r.verdict} confidence=${((r.confidence ?? 0) * 100).toFixed(0)}% language=${r.language ?? "?"} duration=${r.durationSeconds?.toFixed(1) ?? "?"}s sidecar=${r.sidecarPath}`;
+					blocks.push(`${head}\ntranscript:\n${r.text}`);
+					if (r.recommendations?.length) blocks.push(`advice: ${r.recommendations.join(" | ")}`);
+				}
 			}
+			if (!blocks.length) return { action: "continue" as const };
+			return { action: "transform" as const, text: `${event.text}\n\n${blocks.join("\n\n")}` };
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			console.log(`${TAG} input hook failed (${msg}); continuing without transcription`);
+			return { action: "continue" as const };
 		}
-		if (!blocks.length) return { action: "continue" as const };
-		return { action: "transform" as const, text: `${event.text}\n\n${blocks.join("\n\n")}` };
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maheidem/pi-audio-transcribe",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "type": "module",
   "description": "Pi extension: transcribe audio with oMLX STT (Qwen3-ASR), validate the speech, and persist a JSON transcript sidecar beside each audio file.",
   "keywords": [
@@ -23,8 +23,10 @@
     "settings.ts",
     "sidecar.ts",
     "validate.ts",
+    "version.ts",
     "lib/json-store.ts",
     "ui/audio-panel.ts",
+    "ui/version.ts",
     "ui/settings-panel.ts",
     "README.md",
     "LICENSE"
@@ -66,4 +68,4 @@
       "./index.ts"
     ]
   }
-}
+}

package/ui/version.ts

@@ -0,0 +1,69 @@
+/**
+ * ui/version.ts — canonical loaded-version provenance (S2, pi-panel-kit
+ * stage 1).
+ *
+ * WHY THIS EXISTS
+ * A running Pi session keeps whatever extension code it loaded at startup;
+ * newer installs (npm store or by-path) only apply after `/reload`. A stale
+ * in-process copy is indistinguishable from a fresh one unless every status
+ * line, panel summary, and tool card carries the version actually EXECUTING.
+ * This helper reads that version from the extension's own `package.json` —
+ * never hard-coded, never baked at build time.
+ *
+ * Vendored byte-identically into consumers (guard: `node
+ * skills/pi-extension-builder/scripts/check-vendored.mjs`); each extension
+ * keeps a thin wrapper (`version.ts` at its package root) that exports its
+ * original function name and passes the `package.json` path resolved from
+ * THE WRAPPER'S module URL — a vendored copy sits in `ui/` and cannot find
+ * the package root by itself, which is exactly why the path is a parameter.
+ *
+ * Pi-free by design: node built-ins only, no imports from sibling modules.
+ */
+
+import * as fs from "node:fs";
+
+export interface ExtensionVersionOptions {
+	/**
+	 * Absolute path to the extension's `package.json`. Resolve it from the
+	 * wrapper's own module URL (`path.join(dirname(fileURLToPath(import.meta.url)), "package.json")`)
+	 * so the string is anchored to the code actually executing, not the cwd.
+	 */
+	packageJsonPath: string;
+	/**
+	 * Short extension name for composed headers. When set, the result is
+	 * `label vX.Y.Z` (the `[delegate v0.3.2 …]` pattern used in result
+	 * headers). Default: no label, bare version (status lines and panel
+	 * summaries render their own prefixes).
+	 */
+	label?: string;
+	/**
+	 * Verbatim suffix appended after the version, e.g.
+	 * `" (loaded at session start; /reload picks up newer installs)"`.
+	 * Default: none. Call sites that interpolate the suffix themselves keep
+	 * passing nothing — identical output either way.
+	 */
+	suffix?: string;
+	/** Returned when `package.json` is unreadable/unparsable or lacks `version`. Default `"unknown"`. */
+	fallback?: string;
+}
+
+/** Raw versions keyed by resolved package.json path; read once per process. */
+const cache = new Map<string, string>();
+
+/** The `version` field of the extension's package.json (never a hardcoded string). */
+export function extensionVersion(options: ExtensionVersionOptions): string {
+	const fallback = options.fallback ?? "unknown";
+	let version = cache.get(options.packageJsonPath);
+	if (version === undefined) {
+		try {
+			const pkg = JSON.parse(fs.readFileSync(options.packageJsonPath, "utf8")) as {
+				version?: string;
+			};
+			version = pkg.version ?? fallback;
+		} catch {
+			version = fallback;
+		}
+		cache.set(options.packageJsonPath, version);
+	}
+	return `${options.label ? `${options.label} v` : ""}${version}${options.suffix ?? ""}`;
+}

package/version.ts

@@ -0,0 +1,23 @@
+/**
+ * audio-transcribe — loaded-version provenance.
+ *
+ * A running Pi session keeps whatever extension code it loaded at startup;
+ * newer npm-store installs only apply after /reload. The /transcribe
+ * --status output therefore carries the version actually executing, so a
+ * stale copy in this process is self-evident instead of mysterious.
+ *
+ * Thin wrapper over the canonical helper vendored at `ui/version.ts`
+ * (kit source: `skills/pi-extension-builder/assets/control-panel/…`); the
+ * package.json path is resolved from THIS module's URL.
+ */
+
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { extensionVersion } from "./ui/version.ts";
+
+export function audioTranscribeVersion(): string {
+	return extensionVersion({
+		packageJsonPath: path.join(path.dirname(fileURLToPath(import.meta.url)), "package.json"),
+	});
+}