dictawhisper 0.0.13 → 0.0.14

package/src/lib/healthLib.ts

@@ -0,0 +1,377 @@
+import { spawnSync } from 'child_process';
+import fs from 'fs';
+import net from 'net';
+import { ollamaBaseUrl, ollamaTags, resolveTarget } from 'ollanet';
+import { configPath, type DictaConfig } from '../config.ts';
+import { apiListenHost, discoverTailscale, inboxUrls } from './tailscaleLib.ts';
+import { getWhisperWorkerStatus, resolveWhisperModel } from './whisperLib.ts';
+import { getJournalIndex, openJournalIndex } from './journalIndexLib.ts';
+
+export type HealthLevel = 'ok' | 'warn' | 'fail';
+
+export type HealthCheck = {
+  id: string;
+  level: HealthLevel;
+  message: string;
+};
+
+export type HealthMode = 'doctor' | 'startup' | 'live';
+
+export type HealthReport = {
+  ok: boolean;
+  degraded: boolean;
+  node: string;
+  configPath: string;
+  whisper: {
+    model: string;
+    device: string;
+    computeType: string;
+    python: string;
+    worker: ReturnType<typeof getWhisperWorkerStatus>;
+  };
+  ollanet: {
+    machine: string;
+    model: string;
+    reachable: boolean;
+  };
+  http: { host: string; port: number };
+  checks: HealthCheck[];
+};
+
+const LIVE_CACHE_MS = 30_000;
+const PYTHON_PROBE_MS = 45_000;
+const OLLANET_RESOLVE_MS = 12_000;
+const OLLANET_TAGS_MS = 8_000;
+
+let liveCache: { at: number; report: HealthReport } | null = null;
+
+function add(checks: HealthCheck[], id: string, level: HealthLevel, message: string): void {
+  checks.push({ id, level, message });
+}
+
+function pythonOnPath(name: string): boolean {
+  return name === 'python' || name === 'python3' || name === 'py';
+}
+
+function spawnPython(
+  python: string,
+  args: string[],
+  timeout = PYTHON_PROBE_MS
+): { status: number | null; stdout: string; stderr: string; error?: string } {
+  const result = spawnSync(python, args, {
+    encoding: 'utf8',
+    timeout,
+    windowsHide: true,
+    env: { ...process.env, PYTHONUNBUFFERED: '1' },
+  });
+  if (result.error) {
+    return { status: result.status, stdout: result.stdout || '', stderr: result.stderr || '', error: result.error.message };
+  }
+  return {
+    status: result.status,
+    stdout: (result.stdout || '').trim(),
+    stderr: (result.stderr || '').trim(),
+  };
+}
+
+function probePort(host: string, port: number): Promise<'free' | 'in-use' | 'error'> {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.unref();
+    server.once('error', (error: NodeJS.ErrnoException) => {
+      resolve(error.code === 'EADDRINUSE' ? 'in-use' : 'error');
+    });
+    server.listen(port, host, () => {
+      server.close(() => resolve('free'));
+    });
+  });
+}
+
+function withTimeout<T>(promise: Promise<T>, ms: number, message: string): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  return Promise.race([
+    promise,
+    new Promise<T>((_, reject) => {
+      timer = setTimeout(() => reject(new Error(message)), ms);
+    }),
+  ]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+}
+
+function modelListed(tags: { name: string }[], model: string): boolean {
+  const want = model.trim().toLowerCase();
+  return tags.some((tag) => {
+    const name = tag.name.toLowerCase();
+    return name === want || name.startsWith(`${want}:`) || name.startsWith(`${want}-`);
+  });
+}
+
+async function probeOllanet(
+  machine: string,
+  model: string
+): Promise<{ reachable: boolean; message: string; level: HealthLevel }> {
+  try {
+    const host = await withTimeout(
+      resolveTarget(machine),
+      OLLANET_RESOLVE_MS,
+      `timed out resolving ${machine}`
+    );
+    const baseUrl = ollamaBaseUrl(host);
+    const tags = await ollamaTags(baseUrl, OLLANET_TAGS_MS);
+    if (model && !modelListed(tags, model)) {
+      return {
+        reachable: true,
+        level: 'warn',
+        message: `ollanet ${machine} is up; model ${model} not in /api/tags`,
+      };
+    }
+    return {
+      reachable: true,
+      level: 'ok',
+      message: `ollanet ${machine} / ${model} (${tags.length} models)`,
+    };
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return {
+      reachable: false,
+      level: 'warn',
+      message: `ollanet ${machine} unreachable (${detail}) — cleanup degraded; raw transcripts still work`,
+    };
+  }
+}
+
+export async function collectHealth(
+  config: DictaConfig,
+  options: { mode: HealthMode } = { mode: 'startup' }
+): Promise<HealthReport> {
+  const checks: HealthCheck[] = [];
+  const nodeMajor = Number(process.versions.node.split('.')[0]);
+  if (!Number.isFinite(nodeMajor) || nodeMajor < 20) {
+    add(checks, 'node', 'fail', `node ${process.version} (need >= 20)`);
+  } else {
+    add(checks, 'node', 'ok', `node ${process.version}`);
+  }
+
+  add(checks, 'config', 'ok', `config ${configPath}`);
+
+  if (!config.watch.roots.length) {
+    add(checks, 'watch-roots', 'ok', 'no extra watch roots (browser record/drop only)');
+  }
+  for (const root of config.watch.roots) {
+    if (fs.existsSync(root)) {
+      add(checks, 'watch-root', 'ok', `watch root ${root}`);
+      continue;
+    }
+    if (config.watch.createMissingRoots) {
+      fs.mkdirSync(root, { recursive: true });
+      add(checks, 'watch-root', 'ok', `watch root ${root} (created)`);
+      continue;
+    }
+    add(checks, 'watch-root', 'fail', `watch root missing ${root}`);
+  }
+
+  const drop = config.watch.browserDropFolder;
+  if (!fs.existsSync(drop)) {
+    fs.mkdirSync(drop, { recursive: true });
+    add(checks, 'browser-drop', 'ok', `browser drop ${drop} (created)`);
+  } else {
+    add(checks, 'browser-drop', 'ok', `browser drop ${drop}`);
+  }
+
+  const python = config.whisper.python;
+  const pythonExists = pythonOnPath(python) || fs.existsSync(python);
+  if (!pythonExists) {
+    add(checks, 'python', 'fail', `python not found: ${python}`);
+  } else {
+    const version = spawnPython(python, ['--version'], 15_000);
+    if (version.status !== 0) {
+      add(checks, 'python', 'fail', `python failed (${version.error || version.stderr || `exit ${version.status}`}): ${python}`);
+    } else {
+      const fw = spawnPython(python, [
+        '-c',
+        'import faster_whisper; print(getattr(faster_whisper, "__version__", "ok"))',
+      ]);
+      if (fw.status !== 0) {
+        add(
+          checks,
+          'faster-whisper',
+          'fail',
+          `faster-whisper import failed (${fw.error || fw.stderr || `exit ${fw.status}`})`
+        );
+      } else {
+        add(checks, 'faster-whisper', 'ok', `python ${python} (faster-whisper ${fw.stdout || 'ok'})`);
+      }
+
+      const cuda = spawnPython(python, ['-c', 'import ctranslate2; print(ctranslate2.get_cuda_device_count())']);
+      const device = (config.whisper.device || 'cuda').toLowerCase();
+      if (cuda.status !== 0) {
+        add(
+          checks,
+          'device',
+          'warn',
+          `could not probe CUDA (${cuda.error || cuda.stderr || `exit ${cuda.status}`}); device=${device}`
+        );
+      } else {
+        const count = Number(cuda.stdout);
+        if (device === 'cpu') {
+          add(checks, 'device', 'warn', 'whisper device=cpu (slow; raw mode still works)');
+        } else if (!Number.isFinite(count) || count <= 0) {
+          add(
+            checks,
+            'device',
+            'warn',
+            `whisper device=${device} but 0 CUDA devices — set whisper.device=cpu or fix the GPU driver`
+          );
+        } else {
+          add(checks, 'device', 'ok', `whisper device=${device} (${count} CUDA device${count === 1 ? '' : 's'})`);
+        }
+      }
+    }
+  }
+
+  const ffmpeg = spawnSync('ffmpeg', ['-version'], { encoding: 'utf8', timeout: 15_000, windowsHide: true });
+  if (ffmpeg.status === 0) {
+    const version = (ffmpeg.stdout || '').match(/ffmpeg version (\S+)/i)?.[1];
+    add(checks, 'ffmpeg', 'ok', version ? `ffmpeg ${version}` : 'ffmpeg on PATH');
+  } else if (config.audio.preprocess) {
+    add(checks, 'ffmpeg', 'fail', 'ffmpeg not on PATH (denoise will fail)');
+  } else {
+    add(checks, 'ffmpeg', 'warn', 'ffmpeg not on PATH (preprocess is off)');
+  }
+
+  const machine = config.ollanet.machine.trim();
+  const model = config.ollanet.cleanModel.trim();
+  const configured =
+    machine.length > 0 && !machine.startsWith('YOUR-') && model.length > 0 && !model.startsWith('YOUR-');
+  let ollanetReachable = false;
+  if (!configured) {
+    add(checks, 'ollanet', 'warn', 'ollanet machine/model not configured — cleanup skipped; raw transcripts still work');
+  } else {
+    const ping = await probeOllanet(machine, model);
+    ollanetReachable = ping.reachable;
+    add(checks, 'ollanet', ping.level, ping.message);
+  }
+
+  const journalPath = config.journal.index;
+  if (!fs.existsSync(journalPath)) {
+    add(checks, 'journal-index', 'warn', `journal index missing (${journalPath}); run pnpm journal:index`);
+  } else {
+    let opened = getJournalIndex();
+    let closeAfter = false;
+    try {
+      if (!opened) {
+        opened = openJournalIndex(journalPath);
+        closeAfter = true;
+      }
+      const stats = opened.stats();
+      const vec = opened.hasVec()
+        ? `, ${stats.embedded} embedded${stats.embedModel ? ` (${stats.embedModel})` : ''}`
+        : ', FTS only';
+      add(
+        checks,
+        'journal-index',
+        stats.notes > 0 ? 'ok' : 'warn',
+        stats.notes > 0
+          ? `${stats.notes} notes in SQLite${vec}`
+          : `journal index empty (${journalPath})`,
+      );
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      add(checks, 'journal-index', 'fail', `journal index unreadable (${detail})`);
+    } finally {
+      if (closeAfter) opened?.close();
+    }
+  }
+
+  if (config.http.tailscale) {
+    const self = discoverTailscale();
+    if (self) {
+      const remote = inboxUrls(config, self).filter((url) => !/localhost|127\.0\.0\.1/.test(url));
+      add(checks, 'tailscale', 'ok', `inbox ${remote.join(' ')}; API stays ${apiListenHost(config)}:${config.http.port}`);
+    } else {
+      add(checks, 'tailscale', 'warn', 'http.tailscale is on but the tailscale CLI did not return an IP; inbox stays on 127.0.0.1');
+    }
+  }
+
+  const bindHost = apiListenHost(config);
+  if (options.mode === 'doctor') {
+    const bind = await probePort(bindHost === '0.0.0.0' ? '127.0.0.1' : bindHost, config.http.port);
+    if (bind === 'free') {
+      add(checks, 'port', 'ok', `port ${bindHost}:${config.http.port} free`);
+    } else if (bind === 'in-use') {
+      add(checks, 'port', 'warn', `port ${bindHost}:${config.http.port} in use (API may already be running)`);
+    } else {
+      add(checks, 'port', 'warn', `could not probe port ${bindHost}:${config.http.port}`);
+    }
+  } else if (options.mode === 'live') {
+    add(checks, 'port', 'ok', `listening on ${bindHost}:${config.http.port}`);
+    const worker = getWhisperWorkerStatus();
+    add(
+      checks,
+      'whisper-worker',
+      worker === 'ready' || worker === 'starting' ? 'ok' : 'warn',
+      `whisper worker ${worker}`
+    );
+  }
+
+  const failed = checks.some((check) => check.level === 'fail');
+  const degraded = checks.some((check) => check.level === 'warn');
+
+  return {
+    ok: !failed,
+    degraded,
+    node: process.version,
+    configPath,
+    whisper: {
+      model: resolveWhisperModel(),
+      device: config.whisper.device,
+      computeType: config.whisper.computeType,
+      python,
+      worker: getWhisperWorkerStatus(),
+    },
+    ollanet: {
+      machine,
+      model,
+      reachable: ollanetReachable,
+    },
+    http: { host: config.http.host, port: config.http.port },
+    checks,
+  };
+}
+
+export async function getHealthReport(
+  config: DictaConfig,
+  options: { mode: HealthMode; fresh?: boolean } = { mode: 'live' }
+): Promise<HealthReport> {
+  if (
+    options.mode === 'live' &&
+    !options.fresh &&
+    liveCache &&
+    Date.now() - liveCache.at < LIVE_CACHE_MS
+  ) {
+    return {
+      ...liveCache.report,
+      whisper: { ...liveCache.report.whisper, worker: getWhisperWorkerStatus() },
+    };
+  }
+  const report = await collectHealth(config, { mode: options.mode });
+  if (options.mode === 'live') liveCache = { at: Date.now(), report };
+  return report;
+}
+
+export function printHealthReport(report: HealthReport, prefix = 'health'): void {
+  for (const check of report.checks) {
+    const tag = check.level === 'ok' ? 'ok  ' : check.level === 'warn' ? 'WARN' : 'FAIL';
+    console.log(`[${prefix}] ${tag}  ${check.message}`);
+  }
+  if (!report.ok) {
+    console.error(`[${prefix}] fix the failing items above, then retry`);
+    return;
+  }
+  if (report.degraded) {
+    console.log(`[${prefix}] ready (degraded — raw mode still works)`);
+    return;
+  }
+  console.log(`[${prefix}] ready`);
+}

package/src/lib/inboxUrl.ts

@@ -0,0 +1,123 @@
+export type InboxSort = 'recent' | 'oldest' | 'relevance' | '';
+export type InboxMode = 'lex' | 'hybrid' | '';
+
+export type InboxUrlState = {
+  q: string;
+  tags: string[];
+  year: string;
+  month: string;
+  since: string;
+  until: string;
+  sort: InboxSort;
+  mode: InboxMode;
+  unreadable: boolean;
+  starred: boolean;
+  file: string;
+  cue: number | null;
+};
+
+const SORTS = new Set(['recent', 'oldest', 'relevance']);
+const MODES = new Set(['lex', 'hybrid']);
+
+export function emptyInboxUrl(): InboxUrlState {
+  return {
+    q: '',
+    tags: [],
+    year: '',
+    month: '',
+    since: '',
+    until: '',
+    sort: '',
+    mode: '',
+    unreadable: false,
+    starred: false,
+    file: '',
+    cue: null,
+  };
+}
+
+export function parseInboxUrl(search: string | URLSearchParams): InboxUrlState {
+  const params =
+    typeof search === 'string' ? new URLSearchParams(search.startsWith('?') ? search.slice(1) : search) : search;
+  const sortRaw = params.get('sort') || '';
+  const modeRaw = params.get('mode') || '';
+  const year = (params.get('year') || '').trim();
+  const monthRaw = (params.get('month') || '').trim();
+  const month = /^\d{1,2}$/.test(monthRaw) ? monthRaw.padStart(2, '0') : '';
+  return {
+    q: params.get('q') || '',
+    tags: params.getAll('tag').map((tag) => tag.trim()).filter(Boolean),
+    year: /^\d{4}$/.test(year) ? year : '',
+    month: year && month && Number(month) >= 1 && Number(month) <= 12 ? month : '',
+    since: (params.get('since') || '').trim(),
+    until: (params.get('until') || '').trim(),
+    sort: SORTS.has(sortRaw) ? (sortRaw as InboxSort) : '',
+    mode: MODES.has(modeRaw) ? (modeRaw as InboxMode) : '',
+    unreadable: params.get('unreadable') === '1',
+    starred: params.get('starred') === '1',
+    file: params.get('file') || '',
+    cue: null,
+  };
+}
+
+export function parseCueHash(hash: string): number | null {
+  const match = String(hash || '').match(/^#?cue-(\d+)$/);
+  if (!match) return null;
+  const cue = Number(match[1]);
+  return Number.isInteger(cue) && cue >= 0 ? cue : null;
+}
+
+export function buildInboxSearch(state: InboxUrlState): string {
+  const params = new URLSearchParams();
+  if (state.q.trim()) params.set('q', state.q.trim());
+  for (const tag of state.tags) {
+    if (tag.trim()) params.append('tag', tag.trim());
+  }
+  if (state.year) params.set('year', state.year);
+  if (state.year && state.month) params.set('month', state.month);
+  if (state.since) params.set('since', state.since);
+  if (state.until) params.set('until', state.until);
+  if (state.sort) params.set('sort', state.sort);
+  if (state.mode) params.set('mode', state.mode);
+  if (state.unreadable) params.set('unreadable', '1');
+  if (state.starred) params.set('starred', '1');
+  if (state.file) params.set('file', state.file);
+  return params.toString();
+}
+
+export function inboxPath(state: InboxUrlState): string {
+  const qs = buildInboxSearch(state);
+  const path = qs ? `/?${qs}` : '/';
+  if (state.file && state.cue != null && Number.isInteger(state.cue) && state.cue >= 0) {
+    return `${path}#cue-${state.cue}`;
+  }
+  return path;
+}
+
+export function isFilenameQuery(query: string): boolean {
+  const raw = String(query || '').replace(/^filename:\s*/i, '').trim();
+  if (!raw) return false;
+  if (/^filename:/i.test(query)) return true;
+  return /\d{4}[-_.]\d{2}[-_.]\d{2}/.test(raw) || /\.(mp3|m4a|wav|webm|ogg|json)$/i.test(raw);
+}
+
+export function filenameNeedle(query: string): string {
+  return String(query || '')
+    .replace(/^filename:\s*/i, '')
+    .trim()
+    .replace(/\.(mp3|m4a|wav|webm|ogg|json)$/i, '');
+}
+
+export function tightenFilenameHits<T extends { basename?: string; jsonFile?: string }>(
+  query: string,
+  hits: T[],
+): T[] {
+  if (!isFilenameQuery(query) || !hits.length) return hits;
+  const needle = filenameNeedle(query);
+  if (!needle) return hits;
+  const matched = hits.filter((hit) => {
+    const name = `${hit.basename || ''} ${hit.jsonFile || ''}`.replace(/\\/g, '/');
+    return name.includes(needle);
+  });
+  return matched.length ? matched : hits;
+}

package/src/lib/journalEmbedLib.ts

@@ -0,0 +1,127 @@
+import { listTargets, ollamaBaseUrl, ollamaTags } from 'ollanet';
+import { config } from '../config.ts';
+
+const EMBED_NAME = /embed|nomic|mxbai|bge|e5|minilm|arctic/i;
+
+export type EmbedClient = {
+  model: string;
+  baseUrl: string;
+  host: string;
+  embed(text: string): Promise<number[]>;
+};
+
+export type EmbedCandidate = {
+  host: string;
+  baseUrl: string;
+  names: string[];
+  local: boolean;
+};
+
+export function modelMatchesPreferred(name: string, preferred: string): boolean {
+  const want = preferred.trim();
+  if (!want) return false;
+  return name === want || name.startsWith(`${want}:`) || name.startsWith(`${want}-`);
+}
+
+export function pickEmbedName(names: string[], preferred = ''): string | null {
+  const want = preferred.trim();
+  if (want) {
+    const hit = names.find((name) => modelMatchesPreferred(name, want));
+    if (hit) return hit;
+  }
+  return names.find((name) => EMBED_NAME.test(name)) || null;
+}
+
+/** Prefer a local box, then any ollanet host that has an embed-class model. */
+export function pickEmbedTarget(candidates: EmbedCandidate[], preferred = ''): EmbedCandidate & { model: string } | null {
+  const ranked = [...candidates].sort((a, b) => Number(b.local) - Number(a.local));
+  if (preferred.trim()) {
+    for (const row of ranked) {
+      const model = pickEmbedName(row.names, preferred);
+      if (model && modelMatchesPreferred(model, preferred)) return { ...row, model };
+    }
+  }
+  for (const row of ranked) {
+    const model = pickEmbedName(row.names, preferred);
+    if (model) return { ...row, model };
+  }
+  return null;
+}
+
+export async function createEmbedClient(preferredModel = config.journal.embedModel): Promise<EmbedClient | null> {
+  let targets: Awaited<ReturnType<typeof listTargets>> = [];
+  try {
+    targets = await listTargets();
+  } catch {
+    return null;
+  }
+  const ordered = [...targets].sort(
+    (a, b) => Number(b.isSelf || b.source === 'localhost') - Number(a.isSelf || a.source === 'localhost'),
+  );
+  const candidates: EmbedCandidate[] = [];
+  const want = preferredModel.trim();
+  for (const host of ordered) {
+    const baseUrl = ollamaBaseUrl(host);
+    try {
+      const tags = await ollamaTags(baseUrl, 8_000);
+      candidates.push({
+        host: host.hostname || host.dnsName || host.ip,
+        baseUrl,
+        names: tags.map((tag: { name: string }) => tag.name),
+        local: Boolean(host.isSelf || host.source === 'localhost'),
+      });
+      const pickedSoFar = pickEmbedTarget(candidates, preferredModel);
+      if (!pickedSoFar) continue;
+      if (want && !modelMatchesPreferred(pickedSoFar.model, want)) continue;
+      if (pickedSoFar.local || !want) {
+        return {
+          model: pickedSoFar.model,
+          baseUrl: pickedSoFar.baseUrl,
+          host: pickedSoFar.host,
+          async embed(text: string) {
+            return embedWithOllama(pickedSoFar.baseUrl, pickedSoFar.model, text);
+          },
+        };
+      }
+    } catch {
+      // host offline or not serving Ollama
+    }
+  }
+  const picked = pickEmbedTarget(candidates, preferredModel);
+  if (!picked) return null;
+  return {
+    model: picked.model,
+    baseUrl: picked.baseUrl,
+    host: picked.host,
+    async embed(text: string) {
+      return embedWithOllama(picked.baseUrl, picked.model, text);
+    },
+  };
+}
+
+export async function embedWithOllama(baseUrl: string, model: string, text: string): Promise<number[]> {
+  const clipped = text.slice(0, 8000);
+  const modern = await fetch(`${baseUrl.replace(/\/$/, '')}/api/embed`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ model, input: clipped }),
+  });
+  if (modern.ok) {
+    const json = (await modern.json()) as { embeddings?: number[][]; embedding?: number[] };
+    const vector = json.embeddings?.[0] || json.embedding;
+    if (Array.isArray(vector) && vector.length) return vector;
+  }
+  const legacy = await fetch(`${baseUrl.replace(/\/$/, '')}/api/embeddings`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ model, prompt: clipped }),
+  });
+  if (!legacy.ok) {
+    throw new Error(`ollama embed ${legacy.status} ${await legacy.text().catch(() => '')}`);
+  }
+  const json = (await legacy.json()) as { embedding?: number[] };
+  if (!Array.isArray(json.embedding) || !json.embedding.length) {
+    throw new Error('ollama embed returned no vector');
+  }
+  return json.embedding;
+}