@geoql/mdr 0.0.1 → 1.0.0

package/src/daemon.ts

@@ -14,7 +14,7 @@
  *   MACRODATA_CHILD_TIMEOUT_MS=<ms>  (default: 10 minutes)
  */
 
-import { watch } from "chokidar";
+import { watch } from 'chokidar';
 import {
   existsSync,
   readFileSync,
@@ -23,29 +23,29 @@ import {
   mkdirSync,
   readdirSync,
   unlinkSync,
-} from "fs";
-import { join, basename } from "path";
-import { Cron } from "croner";
-import { spawn, execSync } from "child_process";
+} from 'fs';
+import { join, basename } from 'path';
+import { Cron } from 'croner';
+import { spawn, execSync } from 'child_process';
 import {
   getStateRoot,
   getEntitiesDir,
   getJournalDir,
   getIndexDir,
   getRemindersDir,
-} from "./config.js";
+} from './config.js';
 
 // The indexing modules pull in @huggingface/transformers + vectra (multi-second
 // import). Load them lazily so the daemon writes its PID file and starts
 // scheduling immediately instead of blocking on heavy imports.
 export async function loadIndexer() {
-  return import("./indexer.js");
+  return import('./indexer.js');
 }
 
 export async function loadConversationIndexers() {
   const [oc, cc] = await Promise.all([
-    import("../opencode/conversations.js"),
-    import("./conversations.js"),
+    import('../opencode/conversations.js'),
+    import('./conversations.js'),
   ]);
   return {
     updateOpenCodeConversations: oc.updateConversationIndex,
@@ -58,7 +58,7 @@ export async function loadConversationIndexers() {
  */
 export async function findExecutable(name: string): Promise<string | null> {
   try {
-    const result = execSync(`which ${name}`, { encoding: "utf-8" }).trim();
+    const result = execSync(`which ${name}`, { encoding: 'utf-8' }).trim();
     return result || null;
   } catch {
     return null;
@@ -72,19 +72,19 @@ export function getDaemonDir() {
 }
 
 export function getPidFile() {
-  return join(getDaemonDir(), ".daemon.pid");
+  return join(getDaemonDir(), '.daemon.pid');
 }
 
 export function getLogFile() {
-  return join(getDaemonDir(), ".daemon.log");
+  return join(getDaemonDir(), '.daemon.log');
 }
 
 export function getPendingContext() {
-  return join(getStateRoot(), ".pending-context");
+  return join(getStateRoot(), '.pending-context');
 }
 
 export function getHeartbeatFile() {
-  return join(getDaemonDir(), ".daemon.heartbeat");
+  return join(getDaemonDir(), '.daemon.heartbeat');
 }
 
 export const HEARTBEAT_INTERVAL_MS = 60_000;
@@ -101,11 +101,11 @@ export function getChildTimeoutMs(): number {
 
 export interface Schedule {
   id: string;
-  type: "cron" | "once";
+  type: 'cron' | 'once';
   expression: string; // cron expression or ISO datetime
   description: string;
   payload: string;
-  agent?: "opencode" | "claude"; // Which agent to trigger
+  agent?: 'opencode' | 'claude'; // Which agent to trigger
   model?: string; // Optional model override (e.g., "anthropic/claude-opus-4-6")
   createdAt: string;
 }
@@ -124,7 +124,7 @@ export function logError(message: string) {
 
 export function writePendingContext(message: string) {
   try {
-    appendFileSync(getPendingContext(), message + "\n");
+    appendFileSync(getPendingContext(), message + '\n');
   } catch (err) {
     logError(`Failed to write pending context: ${String(err)}`);
   }
@@ -134,17 +134,17 @@ export function writePendingContext(message: string) {
  * Trigger an agent with a message
  */
 export async function triggerAgent(
-  agent: "opencode" | "claude" | undefined,
+  agent: 'opencode' | 'claude' | undefined,
   message: string,
   options: { model?: string; description?: string } = {},
 ): Promise<boolean> {
   if (!agent) {
-    log("No agent specified in schedule, skipping trigger");
+    log('No agent specified in schedule, skipping trigger');
     return false;
   }
 
   const timestamp = new Date().toLocaleString();
-  const fullMessage = `[Scheduled reminder: ${options.description || "reminder"}]
+  const fullMessage = `[Scheduled reminder: ${options.description || 'reminder'}]
 Current time: ${timestamp}
 
 IMPORTANT: Use the macrodata_* tools (e.g., macrodata_log_journal, macrodata_search_memory) for memory operations. You are running in a non-interactive scheduled context.
@@ -152,29 +152,29 @@ IMPORTANT: Use the macrodata_* tools (e.g., macrodata_log_journal, macrodata_sea
 ${message}`;
 
   try {
-    if (agent === "opencode") {
+    if (agent === 'opencode') {
       // opencode run "message" --model provider/model
-      const args = ["run", fullMessage];
+      const args = ['run', fullMessage];
       if (options.model) {
-        args.push("--model", options.model);
+        args.push('--model', options.model);
       }
 
       // Find opencode in PATH or use npx as fallback
-      const opencodePath = (await findExecutable("opencode")) || "npx";
-      const finalArgs = opencodePath === "npx" ? ["opencode", ...args] : args;
+      const opencodePath = (await findExecutable('opencode')) || 'npx';
+      const finalArgs = opencodePath === 'npx' ? ['opencode', ...args] : args;
 
-      log(`Triggering OpenCode: ${opencodePath} ${finalArgs.join(" ").substring(0, 50)}...`);
+      log(`Triggering OpenCode: ${opencodePath} ${finalArgs.join(' ').substring(0, 50)}...`);
 
-      spawnSupervisedChild(opencodePath, finalArgs, "opencode");
+      spawnSupervisedChild(opencodePath, finalArgs, 'opencode');
 
       return true;
     } else {
       // claude --print "message" or claude -p "message"
-      const args = ["--print", fullMessage];
+      const args = ['--print', fullMessage];
 
       log(`Triggering Claude Code: claude --print "..."`);
 
-      spawnSupervisedChild("claude", args, "claude");
+      spawnSupervisedChild('claude', args, 'claude');
 
       return true;
     }
@@ -193,7 +193,7 @@ ${message}`;
 export function spawnSupervisedChild(command: string, args: string[], label: string) {
   const childTimeoutMs = getChildTimeoutMs();
   const proc = spawn(command, args, {
-    stdio: ["ignore", "pipe", "pipe"],
+    stdio: ['ignore', 'pipe', 'pipe'],
     detached: true,
     env: { ...process.env, PATH: process.env.PATH },
   });
@@ -204,10 +204,10 @@ export function spawnSupervisedChild(command: string, args: string[], label: str
     log(`[${label}] child exceeded ${childTimeoutMs}ms timeout, killing process group ${proc.pid}`);
     if (proc.pid) {
       try {
-        process.kill(-proc.pid, "SIGKILL");
+        process.kill(-proc.pid, 'SIGKILL');
       } catch {
         try {
-          proc.kill("SIGKILL");
+          proc.kill('SIGKILL');
         } catch {
           // Child already gone
         }
@@ -216,17 +216,17 @@ export function spawnSupervisedChild(command: string, args: string[], label: str
   }, childTimeoutMs);
   killTimer.unref();
 
-  proc.stdout?.on("data", (data) => {
+  proc.stdout?.on('data', (data) => {
     log(`[${label} stdout] ${data.toString().trim()}`);
   });
-  proc.stderr?.on("data", (data) => {
+  proc.stderr?.on('data', (data) => {
     log(`[${label} stderr] ${data.toString().trim()}`);
   });
-  proc.on("error", (err) => {
+  proc.on('error', (err) => {
     clearTimeout(killTimer);
     logError(`[${label}] child process error: ${String(err)}`);
   });
-  proc.on("exit", (code, signal) => {
+  proc.on('exit', (code, signal) => {
     clearTimeout(killTimer);
     log(`[${label}] child exited (code=${code}, signal=${signal})`);
   });
@@ -243,8 +243,8 @@ export function ensureDirectories() {
     entitiesDir,
     getJournalDir(),
     getRemindersDir(),
-    join(entitiesDir, "people"),
-    join(entitiesDir, "projects"),
+    join(entitiesDir, 'people'),
+    join(entitiesDir, 'projects'),
   ];
   for (const dir of dirs) {
     if (!existsSync(dir)) {
@@ -292,10 +292,10 @@ export function loadAllSchedules(): Schedule[] {
   try {
     if (!existsSync(remindersDir)) return schedules;
 
-    const files = readdirSync(remindersDir).filter((f) => f.endsWith(".json"));
+    const files = readdirSync(remindersDir).filter((f) => f.endsWith('.json'));
     for (const file of files) {
       try {
-        const content = readFileSync(join(remindersDir, file), "utf-8");
+        const content = readFileSync(join(remindersDir, file), 'utf-8');
         const schedule = JSON.parse(content) as Schedule;
         schedules.push(schedule);
       } catch (err) {
@@ -350,7 +350,7 @@ export async function defaultBackgroundIndexing(
   const updateAll = deps.updateAll ?? updateAllConversationIndexes;
   const indexer = await load();
   await indexer.preloadModel();
-  log("Embedding model preloaded");
+  log('Embedding model preloaded');
   await updateAll();
 }
 
@@ -369,14 +369,14 @@ export class MacrodataLocalDaemon {
   }
 
   async start() {
-    log("Starting macrodata local daemon");
+    log('Starting macrodata local daemon');
     log(`State root: ${getStateRoot()}`);
 
     // Check if already running
     ensureDirectories();
     const pidFile = getPidFile();
     if (existsSync(pidFile)) {
-      const existingPid = readFileSync(pidFile, "utf-8").trim();
+      const existingPid = readFileSync(pidFile, 'utf-8').trim();
       try {
         process.kill(parseInt(existingPid, 10), 0); // Check if process exists
         log(`Daemon already running (PID ${existingPid}), exiting`);
@@ -391,16 +391,16 @@ export class MacrodataLocalDaemon {
     writeFileSync(pidFile, process.pid.toString());
 
     // Set up signal handlers
-    process.on("SIGTERM", () => this.shutdown("SIGTERM"));
-    process.on("SIGINT", () => this.shutdown("SIGINT"));
-    process.on("SIGHUP", () => this.reload());
+    process.on('SIGTERM', () => this.shutdown('SIGTERM'));
+    process.on('SIGINT', () => this.shutdown('SIGINT'));
+    process.on('SIGHUP', () => this.reload());
 
     // The daemon must be hard to stop: a failed child, watcher error, or
     // rejected background promise should be logged, never fatal (#25).
-    process.on("unhandledRejection", (reason) => {
+    process.on('unhandledRejection', (reason) => {
       logError(`Unhandled rejection (daemon continues): ${String(reason)}`);
     });
-    process.on("uncaughtException", (err) => {
+    process.on('uncaughtException', (err) => {
       logError(`Uncaught exception (daemon continues): ${String(err?.stack || err)}`);
     });
 
@@ -420,7 +420,7 @@ export class MacrodataLocalDaemon {
     this.startHeartbeat();
 
     // Keep process alive
-    log("Daemon running");
+    log('Daemon running');
   }
 
   private startHeartbeat() {
@@ -444,12 +444,12 @@ export class MacrodataLocalDaemon {
       awaitWriteFinish: { stabilityThreshold: 100 },
     });
 
-    this.schedulesWatcher.on("add", (path) => {
-      if (!path.endsWith(".json")) return;
+    this.schedulesWatcher.on('add', (path) => {
+      if (!path.endsWith('.json')) return;
       log(`Reminder added: ${basename(path)}`);
       this.reloadSchedules();
       try {
-        const schedule = JSON.parse(readFileSync(path, "utf-8")) as Schedule;
+        const schedule = JSON.parse(readFileSync(path, 'utf-8')) as Schedule;
         writePendingContext(
           `<macrodata-update type="schedule-added" id="${schedule.id}">${schedule.description}</macrodata-update>`,
         );
@@ -458,16 +458,16 @@ export class MacrodataLocalDaemon {
       }
     });
 
-    this.schedulesWatcher.on("error", (err) => {
+    this.schedulesWatcher.on('error', (err) => {
       logError(`Reminders watcher error: ${String(err)}`);
     });
 
-    this.schedulesWatcher.on("change", (path) => {
-      if (!path.endsWith(".json")) return;
+    this.schedulesWatcher.on('change', (path) => {
+      if (!path.endsWith('.json')) return;
       log(`Reminder changed: ${basename(path)}`);
       this.reloadSchedules();
       try {
-        const schedule = JSON.parse(readFileSync(path, "utf-8")) as Schedule;
+        const schedule = JSON.parse(readFileSync(path, 'utf-8')) as Schedule;
         writePendingContext(
           `<macrodata-update type="schedule-updated" id="${schedule.id}">${schedule.description}</macrodata-update>`,
         );
@@ -476,12 +476,12 @@ export class MacrodataLocalDaemon {
       }
     });
 
-    this.schedulesWatcher.on("unlink", (path) => this.onReminderUnlinked(path));
+    this.schedulesWatcher.on('unlink', (path) => this.onReminderUnlinked(path));
   }
 
   private onReminderUnlinked(path: string) {
-    if (!path.endsWith(".json")) return;
-    const id = basename(path, ".json");
+    if (!path.endsWith('.json')) return;
+    const id = basename(path, '.json');
     log(`Reminder removed: ${id}`);
     writePendingContext(`<macrodata-update type="schedule-removed" id="${id}" />`);
     if (this.cronJobs.has(id)) {
@@ -491,11 +491,11 @@ export class MacrodataLocalDaemon {
   }
 
   private scheduleFor(schedule: Schedule) {
-    if (schedule.type === "cron") {
+    if (schedule.type === 'cron') {
       this.startCronJob(schedule);
       return;
     }
-    if (schedule.type === "once") {
+    if (schedule.type === 'once') {
       if (new Date(schedule.expression).getTime() > Date.now()) {
         this.startOnceJob(schedule);
       } else {
@@ -587,7 +587,7 @@ export class MacrodataLocalDaemon {
     saveSchedule(schedule);
 
     // Start the job
-    if (schedule.type === "cron") {
+    if (schedule.type === 'cron') {
       this.startCronJob(schedule);
     } else {
       this.startOnceJob(schedule);
@@ -603,7 +603,7 @@ export class MacrodataLocalDaemon {
   private startFileWatcher() {
     const stateRoot = getStateRoot();
     const entitiesDir = getEntitiesDir();
-    const stateDir = join(stateRoot, "state");
+    const stateDir = join(stateRoot, 'state');
 
     // Watch both state files and entities
     this.watcher = watch([stateDir, entitiesDir], {
@@ -611,18 +611,18 @@ export class MacrodataLocalDaemon {
       persistent: true,
     });
 
-    this.watcher.on("all", (event, path) => this.onWatchedFileEvent(event, path));
+    this.watcher.on('all', (event, path) => this.onWatchedFileEvent(event, path));
 
     log(`Watching for state/entity changes in: ${stateRoot}`);
   }
 
   onWatchedFileEvent(event: string, path: string) {
-    if (!path.endsWith(".md")) return;
-    if (event !== "add" && event !== "change") return;
+    if (!path.endsWith('.md')) return;
+    if (event !== 'add' && event !== 'change') return;
 
     log(`File ${event}: ${path}`);
 
-    const stateDir = join(getStateRoot(), "state");
+    const stateDir = join(getStateRoot(), 'state');
     const entitiesDir = getEntitiesDir();
 
     if (path.startsWith(stateDir)) {
@@ -636,7 +636,7 @@ export class MacrodataLocalDaemon {
 
   private injectStateFileDelta(path: string) {
     try {
-      const raw = readFileSync(path, "utf-8");
+      const raw = readFileSync(path, 'utf-8');
       const cap = 4000;
       // Cap the injected delta so a mid-session write can't blow the budget.
       const content =
@@ -685,7 +685,7 @@ export class MacrodataLocalDaemon {
   }
 
   reload() {
-    log("Reloading config (SIGHUP)");
+    log('Reloading config (SIGHUP)');
     log(`New state root: ${getStateRoot()}`);
 
     // Stop existing watchers
@@ -712,7 +712,7 @@ export class MacrodataLocalDaemon {
     this.watchRemindersDir();
     this.startFileWatcher();
 
-    log("Reload complete");
+    log('Reload complete');
   }
 
   shutdown(signal: string) {
@@ -744,7 +744,7 @@ export class MacrodataLocalDaemon {
     try {
       const pidFile = getPidFile();
       if (existsSync(pidFile)) {
-        const pid = readFileSync(pidFile, "utf-8").trim();
+        const pid = readFileSync(pidFile, 'utf-8').trim();
         if (pid === process.pid.toString()) {
           unlinkSync(pidFile);
         }

package/src/detect-user.ts

@@ -3,10 +3,10 @@
  * Returns JSON with system, git, github, and code directory info
  */
 
-import { execSync } from "child_process";
-import { existsSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
 
 interface GitInfo {
   name: string;
@@ -31,32 +31,32 @@ export interface UserInfo {
 
 function exec(cmd: string): string {
   try {
-    return execSync(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    return execSync(cmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
   } catch {
-    return "";
+    return '';
   }
 }
 
 export function detectUser(): UserInfo {
   // System info
-  const username = exec("whoami");
-  const fullName = exec("id -F") || exec(`getent passwd ${username} | cut -d: -f5 | cut -d, -f1`);
+  const username = exec('whoami');
+  const fullName = exec('id -F') || exec(`getent passwd ${username} | cut -d: -f5 | cut -d, -f1`);
 
   // Timezone
-  let timezone = "";
-  if (existsSync("/etc/timezone")) {
-    timezone = exec("cat /etc/timezone");
-  } else if (existsSync("/etc/localtime")) {
+  let timezone = '';
+  if (existsSync('/etc/timezone')) {
+    timezone = exec('cat /etc/timezone');
+  } else if (existsSync('/etc/localtime')) {
     timezone = exec("readlink /etc/localtime | sed 's|.*/zoneinfo/||'");
   }
 
   // Git config
-  const gitName = exec("git config --global user.name");
-  const gitEmail = exec("git config --global user.email");
+  const gitName = exec('git config --global user.name');
+  const gitEmail = exec('git config --global user.email');
 
   // GitHub CLI (if authenticated)
   let github: GitHubInfo = {};
-  const ghCheck = exec("command -v gh");
+  const ghCheck = exec('command -v gh');
   if (ghCheck) {
     const ghJson = exec("gh api user --jq '{login: .login, name: .name, blog: .blog, bio: .bio}'");
     if (ghJson) {
@@ -71,15 +71,15 @@ export function detectUser(): UserInfo {
   // Code directories that exist
   const home = homedir();
   const possibleDirs = [
-    "Repos",
-    "repos",
-    "Code",
-    "code",
-    "Projects",
-    "projects",
-    "Developer",
-    "dev",
-    "src",
+    'Repos',
+    'repos',
+    'Code',
+    'code',
+    'Projects',
+    'projects',
+    'Developer',
+    'dev',
+    'src',
   ];
   const codeDirs = possibleDirs.map((dir) => join(home, dir)).filter((dir) => existsSync(dir));
 

package/src/embeddings.ts

@@ -22,13 +22,13 @@
  *   }
  */
 
-import { existsSync, readFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-import type { FeatureExtractionPipeline } from "@huggingface/transformers";
+import { existsSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import type { FeatureExtractionPipeline } from '@huggingface/transformers';
 
 export interface RemoteEmbeddingConfig {
-  provider: "openai-compatible";
+  provider: 'openai-compatible';
   endpoint: string;
   api_key?: string;
   api_key_env?: string;
@@ -48,18 +48,18 @@ export function getRemoteEmbeddingConfig(): RemoteEmbeddingConfig | null {
   if (cachedRemoteConfig !== undefined) return cachedRemoteConfig;
 
   const configPath =
-    process.env.MACRODATA_CONFIG_PATH || join(homedir(), ".config", "macrodata", "config.json");
+    process.env.MACRODATA_CONFIG_PATH || join(homedir(), '.config', 'macrodata', 'config.json');
 
   cachedRemoteConfig = null;
   if (existsSync(configPath)) {
     try {
-      const config = JSON.parse(readFileSync(configPath, "utf-8"));
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
       const embedding = config.embedding;
       if (
         embedding &&
-        embedding.provider === "openai-compatible" &&
-        typeof embedding.endpoint === "string" &&
-        typeof embedding.model === "string"
+        embedding.provider === 'openai-compatible' &&
+        typeof embedding.endpoint === 'string' &&
+        typeof embedding.model === 'string'
       ) {
         cachedRemoteConfig = embedding as RemoteEmbeddingConfig;
       }
@@ -92,11 +92,11 @@ function resolveApiKey(config: RemoteEmbeddingConfig): string | undefined {
 async function embedRemote(
   texts: string[],
   config: RemoteEmbeddingConfig,
-  kind: "passage" | "query",
+  kind: 'passage' | 'query',
 ): Promise<number[][]> {
-  const url = `${config.endpoint.replace(/\/$/, "")}/embeddings`;
+  const url = `${config.endpoint.replace(/\/$/, '')}/embeddings`;
   const apiKey = resolveApiKey(config);
-  const inputType = kind === "query" ? config.query_input_type : config.input_type;
+  const inputType = kind === 'query' ? config.query_input_type : config.input_type;
 
   const body: Record<string, unknown> = {
     ...config.extra_body,
@@ -108,16 +108,16 @@ async function embedRemote(
   }
 
   const response = await fetch(url, {
-    method: "POST",
+    method: 'POST',
     headers: {
-      "Content-Type": "application/json",
+      'Content-Type': 'application/json',
       ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
     },
     body: JSON.stringify(body),
   });
 
   if (!response.ok) {
-    const errText = await response.text().catch(() => "");
+    const errText = await response.text().catch(() => '');
     throw new Error(
       `Remote embedding request failed: ${response.status} ${response.statusText} ${errText.slice(0, 300)}`,
     );
@@ -141,7 +141,7 @@ async function embedRemote(
 async function embedRemoteBatched(
   texts: string[],
   config: RemoteEmbeddingConfig,
-  kind: "passage" | "query",
+  kind: 'passage' | 'query',
 ): Promise<number[][]> {
   const batchSize = config.batch_size && config.batch_size > 0 ? config.batch_size : 64;
   const results: number[][] = [];
@@ -173,16 +173,16 @@ async function getEmbeddingPipeline(): Promise<FeatureExtractionPipeline> {
   }
 
   pipelineLoading = (async () => {
-    const { pipeline } = await import("@huggingface/transformers");
-    return pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2", {
+    const { pipeline } = await import('@huggingface/transformers');
+    return pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2', {
       // Use quantized model for faster loading
-      dtype: "q8",
+      dtype: 'q8',
     });
   })();
 
   try {
     embeddingPipeline = await pipelineLoading;
-    console.log("[Embeddings] Model loaded successfully");
+    console.log('[Embeddings] Model loaded successfully');
     return embeddingPipeline;
   } finally {
     pipelineLoading = null;
@@ -199,7 +199,7 @@ async function embedLocal(texts: string[]): Promise<number[][]> {
   for (let i = 0; i < texts.length; i += batchSize) {
     const batch = texts.slice(i, i + batchSize);
     const outputs = await pipe(batch, {
-      pooling: "mean",
+      pooling: 'mean',
       normalize: true,
     });
 
@@ -229,7 +229,7 @@ export async function embed(text: string): Promise<number[]> {
 export async function embedQuery(text: string): Promise<number[]> {
   const remote = getRemoteEmbeddingConfig();
   if (remote) {
-    const [vector] = await embedRemoteBatched([text], remote, "query");
+    const [vector] = await embedRemoteBatched([text], remote, 'query');
     return vector;
   }
   const [vector] = await embedLocal([text]);
@@ -244,7 +244,7 @@ export async function embedBatch(texts: string[]): Promise<number[][]> {
 
   const remote = getRemoteEmbeddingConfig();
   if (remote) {
-    return embedRemoteBatched(texts, remote, "passage");
+    return embedRemoteBatched(texts, remote, 'passage');
   }
   return embedLocal(texts);
 }
@@ -255,7 +255,7 @@ export async function embedBatch(texts: string[]): Promise<number[][]> {
  */
 export async function preloadModel(): Promise<void> {
   if (getRemoteEmbeddingConfig()) {
-    console.log("[Embeddings] Remote embedding provider configured, skipping local model load");
+    console.log('[Embeddings] Remote embedding provider configured, skipping local model load');
     return;
   }
   await getEmbeddingPipeline();