@rubytech/taskmaster 1.2.1 → 1.4.0

package/dist/media-understanding/runner.js

@@ -5,7 +5,7 @@ import path from "node:path";
 import { findModelInCatalog, loadModelCatalog, modelSupportsVision, } from "../agents/model-catalog.js";
 import { applyTemplate } from "../auto-reply/templating.js";
 import { requireApiKey, resolveApiKeyForProvider } from "../agents/model-auth.js";
-import { logVerbose, shouldLogVerbose } from "../globals.js";
+import { createSubsystemLogger } from "../logging/subsystem.js";
 import { runExec } from "../process/exec.js";
 import { MediaAttachmentCache, normalizeAttachments, selectAttachments } from "./attachments.js";
 import { CLI_OUTPUT_MAX_BUFFER, DEFAULT_AUDIO_MODELS, DEFAULT_TIMEOUT_SECONDS, } from "./defaults.js";
@@ -23,6 +23,7 @@ const DEFAULT_IMAGE_MODELS = {
     google: "gemini-3-flash-preview",
     minimax: "MiniMax-VL-01",
 };
+const log = createSubsystemLogger("gateway/media");
 export function buildProviderRegistry(overrides) {
     return buildMediaUnderstandingRegistry(overrides);
 }
@@ -33,7 +34,6 @@ export function createMediaAttachmentCache(attachments) {
     return new MediaAttachmentCache(attachments);
 }
 const binaryCache = new Map();
-const geminiProbeCache = new Map();
 function expandHomeDir(value) {
     if (!value.startsWith("~"))
         return value;
@@ -181,26 +181,6 @@ function extractSherpaOnnxText(raw) {
     }
     return null;
 }
-async function probeGeminiCli() {
-    const cached = geminiProbeCache.get("gemini");
-    if (cached)
-        return cached;
-    const resolved = (async () => {
-        if (!(await hasBinary("gemini")))
-            return false;
-        try {
-            const { stdout } = await runExec("gemini", ["--output-format", "json", "ok"], {
-                timeoutMs: 8000,
-            });
-            return Boolean(extractGeminiResponse(stdout) ?? stdout.toLowerCase().includes("ok"));
-        }
-        catch {
-            return false;
-        }
-    })();
-    geminiProbeCache.set("gemini", resolved);
-    return resolved;
-}
 async function resolveLocalWhisperCppEntry() {
     if (!(await hasBinary("whisper-cli")))
         return null;
@@ -234,7 +214,34 @@ async function resolveLocalWhisperEntry() {
         ],
     };
 }
-async function resolveSherpaOnnxEntry() {
+/**
+ * Check if sherpa-onnx-node (npm package) is available with model + ffmpeg.
+ * Returns a provider entry so the pipeline uses the Node.js API directly
+ * (no CLI binary or SHERPA_ONNX_MODEL_DIR env var required).
+ */
+async function resolveSherpaOnnxNodeEntry() {
+    try {
+        const { isReady } = await import("./sherpa-onnx-local.js");
+        if (await isReady()) {
+            return { type: "provider", provider: "sherpa-onnx" };
+        }
+        // Package + ffmpeg available but model not yet downloaded — still viable
+        // (the provider will trigger a lazy download on first use)
+        const { isAvailable } = await import("./sherpa-onnx-local.js");
+        if (await isAvailable()) {
+            return { type: "provider", provider: "sherpa-onnx" };
+        }
+    }
+    catch {
+        // sherpa-onnx-node not installed — skip
+    }
+    return null;
+}
+/**
+ * Fallback: check for sherpa-onnx-offline CLI binary + SHERPA_ONNX_MODEL_DIR env var.
+ * This is the legacy detection path for users who installed the binary manually.
+ */
+async function resolveSherpaOnnxCliEntry() {
     if (!(await hasBinary("sherpa-onnx-offline")))
         return null;
     const modelDir = process.env.SHERPA_ONNX_MODEL_DIR?.trim();
@@ -265,32 +272,19 @@ async function resolveSherpaOnnxEntry() {
     };
 }
 async function resolveLocalAudioEntry() {
-    const sherpa = await resolveSherpaOnnxEntry();
-    if (sherpa)
-        return sherpa;
+    // Prefer sherpa-onnx-node (npm, no PATH issues, automatic model management)
+    const sherpaNode = await resolveSherpaOnnxNodeEntry();
+    if (sherpaNode)
+        return sherpaNode;
+    // Fallback: CLI binary (legacy/manual installs)
+    const sherpaCli = await resolveSherpaOnnxCliEntry();
+    if (sherpaCli)
+        return sherpaCli;
     const whisperCpp = await resolveLocalWhisperCppEntry();
     if (whisperCpp)
         return whisperCpp;
     return await resolveLocalWhisperEntry();
 }
-async function resolveGeminiCliEntry(_capability) {
-    if (!(await probeGeminiCli()))
-        return null;
-    return {
-        type: "cli",
-        command: "gemini",
-        args: [
-            "--output-format",
-            "json",
-            "--allowed-tools",
-            "read_many_files",
-            "--include-directories",
-            "{{MediaDir}}",
-            "{{Prompt}}",
-            "Use read_many_files to read {{MediaPath}} and respond with only the text output.",
-        ],
-    };
-}
 async function resolveKeyEntry(params) {
     const { cfg, agentDir, providerRegistry, capability } = params;
     const checkProvider = async (providerId, model) => {
@@ -362,9 +356,6 @@ async function resolveAutoEntries(params) {
         if (localAudio)
             return [localAudio];
     }
-    const gemini = await resolveGeminiCliEntry(params.capability);
-    if (gemini)
-        return [gemini];
     const keys = await resolveKeyEntry(params);
     if (keys)
         return [keys];
@@ -635,14 +626,18 @@ async function runProviderEntry(params) {
             maxBytes,
             timeoutMs,
         });
-        const auth = await resolveApiKeyForProvider({
-            provider: providerId,
-            cfg,
-            profileId: entry.profile,
-            preferredProfile: entry.preferredProfile,
-            agentDir: params.agentDir,
-        });
-        const apiKey = requireApiKey(auth, providerId);
+        // Local providers (e.g. sherpa-onnx) do not require an API key.
+        let apiKey;
+        if (!provider.isLocal) {
+            const auth = await resolveApiKeyForProvider({
+                provider: providerId,
+                cfg,
+                profileId: entry.profile,
+                preferredProfile: entry.preferredProfile,
+                agentDir: params.agentDir,
+            });
+            apiKey = requireApiKey(auth, providerId);
+        }
         const providerConfig = cfg.models?.providers?.[providerId];
         const baseUrl = entry.baseUrl ?? params.config?.baseUrl ?? providerConfig?.baseUrl;
         const mergedHeaders = {
@@ -751,9 +746,7 @@ async function runCliEntry(params) {
     };
     const argv = [command, ...args].map((part, index) => index === 0 ? part : applyTemplate(part, templCtx));
     try {
-        if (shouldLogVerbose()) {
-            logVerbose(`Media understanding via CLI: ${argv.join(" ")}`);
-        }
+        log.debug(`CLI: ${argv.join(" ")}`);
         const { stdout } = await runExec(argv[0], argv.slice(1), {
             timeoutMs,
             maxBuffer: CLI_OUTPUT_MAX_BUFFER,
@@ -825,9 +818,7 @@ async function runAttachmentEntries(params) {
                     outcome: "skipped",
                     reason: `${err.reason}: ${err.message}`,
                 }));
-                if (shouldLogVerbose()) {
-                    logVerbose(`Skipping ${capability} model due to ${err.reason}: ${err.message}`);
-                }
+                log.debug(`Skipping ${capability} model: ${err.reason}: ${err.message}`);
                 continue;
             }
             attempts.push(buildModelDecision({
@@ -836,9 +827,7 @@ async function runAttachmentEntries(params) {
                 outcome: "failed",
                 reason: String(err),
             }));
-            if (shouldLogVerbose()) {
-                logVerbose(`${capability} understanding failed: ${String(err)}`);
-            }
+            log.error(`${capability} failed: ${String(err)}`);
         }
     }
     return { output: null, attempts };
@@ -866,9 +855,7 @@ export async function runCapability(params) {
     }
     const scopeDecision = resolveScopeDecision({ scope: config?.scope, ctx });
     if (scopeDecision === "deny") {
-        if (shouldLogVerbose()) {
-            logVerbose(`${capability} understanding disabled by scope policy.`);
-        }
+        log.debug(`${capability} disabled by scope policy`);
         return {
             outputs: [],
             decision: {
@@ -885,9 +872,7 @@ export async function runCapability(params) {
         const catalog = await loadModelCatalog({ config: cfg });
         const entry = findModelInCatalog(catalog, activeProvider, params.activeModel?.model ?? "");
         if (modelSupportsVision(entry)) {
-            if (shouldLogVerbose()) {
-                logVerbose("Skipping image understanding: primary model supports vision natively");
-            }
+            log.debug("Skipping image understanding: primary model supports vision natively");
             const model = params.activeModel?.model?.trim();
             const reason = "primary model supports vision natively";
             return {
@@ -966,8 +951,12 @@ export async function runCapability(params) {
         outcome: outputs.length > 0 ? "success" : "skipped",
         attachments: attachmentDecisions,
     };
-    if (shouldLogVerbose()) {
-        logVerbose(`Media understanding ${formatDecisionSummary(decision)}`);
+    const summary = formatDecisionSummary(decision);
+    if (decision.outcome === "success") {
+        log.info(summary);
+    }
+    else {
+        log.debug(summary);
     }
     return {
         outputs,

package/dist/media-understanding/sherpa-onnx-local.js

@@ -0,0 +1,223 @@
+/**
+ * Local speech-to-text using sherpa-onnx-node (optional dependency).
+ *
+ * Model: NeMo CTC English Conformer Small (int8)
+ * Storage: ~/.taskmaster/lib/sherpa-onnx/nemo-ctc-en-conformer-small/
+ *
+ * Requires: sherpa-onnx-node (optional dep), ffmpeg (for OGG→WAV conversion)
+ */
+import { execFile as execFileCb, spawnSync } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+const execFile = promisify(execFileCb);
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const LIB_DIR = path.join(os.homedir(), ".taskmaster", "lib", "sherpa-onnx");
+const MODEL_DIR_NAME = "nemo-ctc-en-conformer-small";
+const MODEL_DIR = path.join(LIB_DIR, MODEL_DIR_NAME);
+const MODEL_FILE = "model.int8.onnx";
+const TOKENS_FILE = "tokens.txt";
+const MODEL_ARCHIVE_URL = "https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-nemo-ctc-en-conformer-small.tar.bz2";
+const ARCHIVE_INNER_DIR = "sherpa-onnx-nemo-ctc-en-conformer-small";
+export const MODEL_LABEL = "sherpa-onnx/nemo-ctc-en-conformer-small-int8";
+let sherpaModule = null;
+let sherpaModuleError = null;
+async function importSherpaOnnx() {
+    if (sherpaModule)
+        return sherpaModule;
+    if (sherpaModuleError)
+        throw sherpaModuleError;
+    try {
+        const mod = await import("sherpa-onnx-node");
+        // ESM dynamic import puts named exports under .default
+        sherpaModule = (mod.default ?? mod);
+        return sherpaModule;
+    }
+    catch (err) {
+        sherpaModuleError = err instanceof Error ? err : new Error(String(err));
+        throw sherpaModuleError;
+    }
+}
+// ---------------------------------------------------------------------------
+// Availability checks
+// ---------------------------------------------------------------------------
+let ffmpegAvailable = null;
+function checkFfmpeg() {
+    if (ffmpegAvailable !== null)
+        return ffmpegAvailable;
+    const result = spawnSync("ffmpeg", ["-version"], { stdio: "ignore", timeout: 5_000 });
+    ffmpegAvailable = result.status === 0;
+    return ffmpegAvailable;
+}
+async function fileExists(filePath) {
+    try {
+        await fs.stat(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function isModelDownloaded() {
+    return ((await fileExists(path.join(MODEL_DIR, MODEL_FILE))) &&
+        (await fileExists(path.join(MODEL_DIR, TOKENS_FILE))));
+}
+/**
+ * Returns true when both the npm package and ffmpeg are available.
+ * Does NOT check whether the model is downloaded (use isReady for that).
+ */
+export async function isAvailable() {
+    try {
+        await importSherpaOnnx();
+    }
+    catch {
+        return false;
+    }
+    return checkFfmpeg();
+}
+/**
+ * Returns true when everything is ready for immediate transcription:
+ * npm package + ffmpeg + model files on disk.
+ */
+export async function isReady() {
+    return (await isAvailable()) && (await isModelDownloaded());
+}
+// ---------------------------------------------------------------------------
+// Model download
+// ---------------------------------------------------------------------------
+let downloadInFlight = null;
+/**
+ * Download and extract the model if not already present.
+ * Deduplicates concurrent calls.
+ */
+export async function ensureModel() {
+    if (await isModelDownloaded())
+        return MODEL_DIR;
+    if (!downloadInFlight) {
+        downloadInFlight = downloadModelOnce().finally(() => {
+            downloadInFlight = null;
+        });
+    }
+    await downloadInFlight;
+    return MODEL_DIR;
+}
+async function downloadModelOnce() {
+    console.log("[sherpa-onnx] Downloading speech recognition model…");
+    await fs.mkdir(LIB_DIR, { recursive: true });
+    const archivePath = path.join(LIB_DIR, `${MODEL_DIR_NAME}.tar.bz2`);
+    try {
+        // Download archive using curl (available on macOS and Linux)
+        await execFile("curl", ["-fsSL", "-o", archivePath, MODEL_ARCHIVE_URL], {
+            timeout: 300_000,
+        });
+        // Extract — archive contains sherpa-onnx-nemo-ctc-en-conformer-small/{files}
+        await execFile("tar", ["-xjf", archivePath, "-C", LIB_DIR], {
+            timeout: 120_000,
+        });
+        // Rename extracted directory to our standard name (remove sherpa-onnx- prefix)
+        const extractedDir = path.join(LIB_DIR, ARCHIVE_INNER_DIR);
+        if ((await fileExists(extractedDir)) && extractedDir !== MODEL_DIR) {
+            // If target already exists (partial state), remove it first
+            if (await fileExists(MODEL_DIR)) {
+                await fs.rm(MODEL_DIR, { recursive: true });
+            }
+            await fs.rename(extractedDir, MODEL_DIR);
+        }
+        // Clean up: remove archive and unnecessary files to save disk space
+        await fs.unlink(archivePath).catch(() => { });
+        // Remove full-precision model (keep only int8 — saves ~37MB)
+        await fs.unlink(path.join(MODEL_DIR, "model.onnx")).catch(() => { });
+        // Remove test wav files
+        await fs
+            .rm(path.join(MODEL_DIR, "test_wavs"), { recursive: true, force: true })
+            .catch(() => { });
+        console.log("[sherpa-onnx] Model installed");
+    }
+    catch (err) {
+        // Clean up partial download
+        await fs.unlink(archivePath).catch(() => { });
+        await fs.rm(MODEL_DIR, { recursive: true, force: true }).catch(() => { });
+        throw new Error(`sherpa-onnx model download failed: ${String(err)}`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Audio conversion (OGG/Opus → WAV 16kHz mono)
+// ---------------------------------------------------------------------------
+async function convertToWav(inputPath, outputPath) {
+    await execFile("ffmpeg", [
+        "-i",
+        inputPath,
+        "-ar",
+        "16000",
+        "-ac",
+        "1",
+        "-sample_fmt",
+        "s16",
+        "-f",
+        "wav",
+        "-y",
+        outputPath,
+    ], { timeout: 30_000 });
+}
+// ---------------------------------------------------------------------------
+// Recognizer (cached singleton)
+// ---------------------------------------------------------------------------
+let recognizer = null;
+async function getRecognizer() {
+    if (recognizer)
+        return recognizer;
+    const sherpa = await importSherpaOnnx();
+    const modelDir = await ensureModel();
+    const config = {
+        featConfig: { sampleRate: 16000, featureDim: 80 },
+        modelConfig: {
+            nemoCtc: {
+                model: path.join(modelDir, MODEL_FILE),
+            },
+            tokens: path.join(modelDir, TOKENS_FILE),
+            numThreads: 2,
+            provider: "cpu",
+            debug: 0,
+        },
+    };
+    recognizer = new sherpa.OfflineRecognizer(config);
+    return recognizer;
+}
+// ---------------------------------------------------------------------------
+// Public transcription API
+// ---------------------------------------------------------------------------
+/**
+ * Transcribe an audio buffer (any format ffmpeg can read) to text.
+ * Returns the transcription text, or throws on failure.
+ */
+export async function transcribeLocal(buffer, fileName) {
+    const sherpa = await importSherpaOnnx();
+    const rec = await getRecognizer();
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "sherpa-stt-"));
+    try {
+        const inputPath = path.join(tmpDir, fileName || "audio.ogg");
+        await fs.writeFile(inputPath, buffer);
+        const wavPath = path.join(tmpDir, "audio.wav");
+        await convertToWav(inputPath, wavPath);
+        const wave = sherpa.readWave(wavPath);
+        const stream = rec.createStream();
+        stream.acceptWaveform({ sampleRate: wave.sampleRate, samples: wave.samples });
+        rec.decode(stream);
+        const result = rec.getResult(stream);
+        const text = result?.text?.trim() ?? "";
+        if (!text) {
+            throw new Error("sherpa-onnx returned empty transcription");
+        }
+        return { text, model: MODEL_LABEL };
+    }
+    finally {
+        await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => { });
+    }
+}
+// ---------------------------------------------------------------------------
+// Exported paths (for postinstall and diagnostics)
+// ---------------------------------------------------------------------------
+export { LIB_DIR, MODEL_DIR, MODEL_DIR_NAME, MODEL_FILE, TOKENS_FILE, MODEL_ARCHIVE_URL, ARCHIVE_INNER_DIR, };

package/dist/memory/audit.js

@@ -55,11 +55,20 @@ function writeAuditFile(workspaceDir, data) {
         // Audit is best-effort — don't fail writes over audit persistence
     }
 }
+/** Deduplicate window: ignore a second write to the same path by the same agent within this period. */
+const DEDUP_WINDOW_MS = 60_000;
 /**
  * Record an audit entry for a memory write.
+ * Skips the entry if an identical path+agent combination was recorded within the dedup window.
  */
 export function recordAuditEntry(workspaceDir, entry) {
     const audit = readAuditFile(workspaceDir);
+    // Deduplicate: skip if same path + agent recorded within the last DEDUP_WINDOW_MS
+    const dominated = audit.entries.some((e) => e.path === entry.path &&
+        e.agentId === entry.agentId &&
+        entry.timestamp - e.timestamp < DEDUP_WINDOW_MS);
+    if (dominated)
+        return;
     audit.entries.push(entry);
     // Cap at 500 entries to prevent unbounded growth.
     if (audit.entries.length > 500) {

package/dist/memory/manager.js

@@ -1245,7 +1245,7 @@ export class MemoryIndexManager {
             }
             const action = record ? "updated" : "added";
             log.info(`file ${action} (${this.agentId}): ${entry.path}`);
-            if (isAuditablePath(entry.path)) {
+            if (isAuditablePath(entry.path) && record?.hash !== entry.hash) {
                 recordAuditEntry(this.workspaceDir, {
                     path: entry.path,
                     timestamp: Date.now(),

package/dist/records/records-manager.js

@@ -90,3 +90,13 @@ export function deleteRecordField(id, key) {
     writeFile(data);
     return record;
 }
+export function setRecordName(id, name) {
+    const data = readFile();
+    const record = data.records[id];
+    if (!record)
+        return null;
+    record.name = name;
+    record.updatedAt = new Date().toISOString();
+    writeFile(data);
+    return record;
+}