@hasna/microservices 0.0.2 → 0.0.4

package/microservices/microservice-transcriber/src/lib/config.ts

@@ -0,0 +1,77 @@
+/**
+ * Persistent config for microservice-transcriber.
+ * Stored as JSON alongside data.db in the .microservices directory.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+
+export interface TranscriberConfig {
+  defaultProvider: "elevenlabs" | "openai" | "deepgram";
+  defaultLanguage: string;
+  defaultFormat: "txt" | "srt" | "vtt" | "json";
+  diarize: boolean;
+  vocab: string[]; // custom vocabulary hints for transcription accuracy
+  feeds: Array<{ url: string; title: string | null; lastChecked: string | null }>;
+  webhook: string | null; // URL to POST when transcription completes
+}
+
+export const CONFIG_DEFAULTS: TranscriberConfig = {
+  defaultProvider: "elevenlabs",
+  defaultLanguage: "en",
+  defaultFormat: "txt",
+  diarize: false,
+  vocab: [],
+  feeds: [],
+  webhook: null,
+};
+
+function getConfigPath(): string {
+  if (process.env["MICROSERVICES_DIR"]) {
+    return join(process.env["MICROSERVICES_DIR"], "microservice-transcriber", "config.json");
+  }
+
+  let dir = resolve(process.cwd());
+  while (true) {
+    const msDir = join(dir, ".microservices");
+    if (existsSync(msDir)) return join(msDir, "microservice-transcriber", "config.json");
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+  return join(home, ".microservices", "microservice-transcriber", "config.json");
+}
+
+export function getConfig(): TranscriberConfig {
+  const path = getConfigPath();
+  if (!existsSync(path)) return { ...CONFIG_DEFAULTS };
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf8"));
+    return { ...CONFIG_DEFAULTS, ...raw };
+  } catch {
+    return { ...CONFIG_DEFAULTS };
+  }
+}
+
+export function setConfig(updates: Partial<TranscriberConfig>): TranscriberConfig {
+  const current = getConfig();
+  const next = { ...current, ...updates };
+  const path = getConfigPath();
+  const dir = dirname(path);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(path, JSON.stringify(next, null, 2), "utf8");
+  return next;
+}
+
+export function resetConfig(): TranscriberConfig {
+  const path = getConfigPath();
+  const dir = dirname(path);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(path, JSON.stringify(CONFIG_DEFAULTS, null, 2), "utf8");
+  return { ...CONFIG_DEFAULTS };
+}
+
+export const CONFIG_KEYS = ["defaultProvider", "defaultLanguage", "defaultFormat", "diarize", "vocab", "webhook"] as const;
+export type ConfigKey = (typeof CONFIG_KEYS)[number];

package/microservices/microservice-transcriber/src/lib/diff.ts

@@ -0,0 +1,91 @@
+/**
+ * Simple word-level diff for comparing two transcripts.
+ */
+
+export interface DiffEntry {
+  type: "equal" | "added" | "removed";
+  text: string;
+}
+
+/**
+ * Compute a word-level diff between two texts.
+ * Uses a simple longest common subsequence approach.
+ */
+export function wordDiff(textA: string, textB: string): DiffEntry[] {
+  const wordsA = textA.split(/\s+/).filter(Boolean);
+  const wordsB = textB.split(/\s+/).filter(Boolean);
+
+  // LCS table
+  const m = wordsA.length;
+  const n = wordsB.length;
+  const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (wordsA[i - 1] === wordsB[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1] + 1;
+      } else {
+        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+      }
+    }
+  }
+
+  // Backtrack to build diff
+  const result: DiffEntry[] = [];
+  let i = m, j = n;
+
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && wordsA[i - 1] === wordsB[j - 1]) {
+      result.unshift({ type: "equal", text: wordsA[i - 1] });
+      i--; j--;
+    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+      result.unshift({ type: "added", text: wordsB[j - 1] });
+      j--;
+    } else {
+      result.unshift({ type: "removed", text: wordsA[i - 1] });
+      i--;
+    }
+  }
+
+  // Merge consecutive entries of the same type
+  const merged: DiffEntry[] = [];
+  for (const entry of result) {
+    const last = merged[merged.length - 1];
+    if (last && last.type === entry.type) {
+      last.text += " " + entry.text;
+    } else {
+      merged.push({ ...entry });
+    }
+  }
+
+  return merged;
+}
+
+/**
+ * Format a diff for terminal display.
+ */
+export function formatDiff(entries: DiffEntry[]): string {
+  return entries
+    .map((e) => {
+      if (e.type === "equal") return e.text;
+      if (e.type === "added") return `[+${e.text}+]`;
+      return `[-${e.text}-]`;
+    })
+    .join(" ");
+}
+
+/**
+ * Compute diff stats.
+ */
+export function diffStats(entries: DiffEntry[]): { equal: number; added: number; removed: number; similarity: number } {
+  const equalWords = entries.filter((e) => e.type === "equal").reduce((n, e) => n + e.text.split(/\s+/).length, 0);
+  const addedWords = entries.filter((e) => e.type === "added").reduce((n, e) => n + e.text.split(/\s+/).length, 0);
+  const removedWords = entries.filter((e) => e.type === "removed").reduce((n, e) => n + e.text.split(/\s+/).length, 0);
+  const total = equalWords + addedWords + removedWords;
+  return {
+    equal: equalWords,
+    added: addedWords,
+    removed: removedWords,
+    similarity: total > 0 ? Math.round((equalWords / total) * 100) : 100,
+  };
+}