obelisk/app/src/main/indexer-service.js

import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import chokidarModule from 'chokidar';

const DEFAULT_PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
const DEFAULT_DEBOUNCE_MS = 2000;
const DEFAULT_STABILITY_MS = 500;
const DEFAULT_HEARTBEAT_MS = 30000;
const DEFAULT_WATCH_RETRY_MS = 5000;

function createIndexerService({
  projectsDir = DEFAULT_PROJECTS_DIR,
  watchDirs = [projectsDir],
  debounceMs = DEFAULT_DEBOUNCE_MS,
  stabilityMs = DEFAULT_STABILITY_MS,
  heartbeatMs = DEFAULT_HEARTBEAT_MS,
  watchRetryMs = DEFAULT_WATCH_RETRY_MS,
  buildIndex,
  writeHeartbeat = () => {},
  watchProjects,
  chokidar,
  timers = {
    setTimeout,
    clearTimeout,
    setInterval,
    clearInterval,
  },
  logger = console,
} = {}) {
  if (typeof buildIndex !== 'function') throw new Error('createIndexerService() requires buildIndex');
  const watch = watchProjects || ((onChange) => {
    const roots = [...new Set((Array.isArray(watchDirs) ? watchDirs : [watchDirs]).filter(Boolean))];
    const existingRoots = roots.filter(root => fs.existsSync(root));
    if (!existingRoots.length) return null;
    const watchers = [];
    const onFileChange = (filename) => {
      const name = filename ? String(filename) : '';
      if (!name || name.endsWith('.jsonl') || name.endsWith('.json')) onChange(name);
    };
    for (const root of existingRoots) {
      const watcher = (chokidar || chokidarModule).watch(root, {
        cwd: root,
        ignoreInitial: true,
        awaitWriteFinish: {
          stabilityThreshold: Math.max(stabilityMs, 500),
          pollInterval: 100,
        },
        ignored: (targetPath, stats) => {
          if (stats?.isDirectory()) return false;
          if (!stats) return false;
          return !String(targetPath).endsWith('.jsonl') && !String(targetPath).endsWith('.json');
        },
      });
      watcher
        .on('add', onFileChange)
        .on('change', onFileChange)
        .on('unlink', onFileChange)
        .on('error', (error) => {
          logger.warn?.(`Obelisk watcher failed: ${error.message}`);
        });
      watchers.push(watcher);
    }
    return {
      close() {
        return Promise.all(watchers.map(w => Promise.resolve(w.close?.())));
      },
    };
  });

  let buildTimer = null;
  let stabilityTimer = null;
  let heartbeatTimer = null;
  let watchRetryTimer = null;
  let watcher = null;
  let stopped = false;
  let running = false;
  let pending = false;
  let lastReason = null;
  let changedPaths = new Set();
  let idlePromise = Promise.resolve();

  const addChangedPath = (changedPath) => {
    if (Array.isArray(changedPath)) {
      for (const p of changedPath) addChangedPath(p);
      return;
    }
    const name = changedPath ? String(changedPath) : '';
    if (name) changedPaths.add(name);
  };

  const takeChangedPaths = () => {
    if (!changedPaths.size) return undefined;
    const paths = [...changedPaths];
    changedPaths = new Set();
    return paths;
  };

  const runBuildNow = (reason = 'manual', paths = undefined) => {
    addChangedPath(paths);
    if (stopped) return idlePromise;
    if (running) {
      pending = true;
      return idlePromise;
    }
    running = true;
    pending = false;
    const buildChangedPaths = takeChangedPaths();
    idlePromise = (async () => {
      await buildIndex({ reason, changedPaths: buildChangedPaths });
      writeHeartbeat();
    })()
      .catch((error) => {
        // A build in flight when the service is stopped (e.g. a manual rebuild
        // tears down the worker) is a deliberate cancellation, not a failure.
        if (!stopped) logger.warn?.(`Obelisk index build failed: ${error.message}`);
      })
      .finally(() => {
        running = false;
        if (pending && !stopped) {
          pending = false;
          runBuildNow('pending');
        }
      });
    return idlePromise;
  };

  const scheduleBuild = (reason = 'change', changedPath = undefined) => {
    if (stopped) return;
    addChangedPath(changedPath);
    lastReason = reason;
    if (running) pending = true;
    if (buildTimer) timers.clearTimeout(buildTimer);
    if (stabilityTimer) timers.clearTimeout(stabilityTimer);
    buildTimer = timers.setTimeout(() => {
      buildTimer = null;
      if (stabilityMs <= 0) {
        runBuildNow(lastReason || reason);
        return;
      }
      stabilityTimer = timers.setTimeout(() => {
        stabilityTimer = null;
        runBuildNow(lastReason || reason);
      }, stabilityMs);
    }, debounceMs);
  };

  const startWatching = () => {
    if (stopped || watcher) return;
    watcher = watch((changedPath) => scheduleBuild('watch', changedPath));
    if (!watcher) {
      watchRetryTimer = timers.setTimeout(() => {
        watchRetryTimer = null;
        startWatching();
      }, watchRetryMs);
    }
  };

  const start = ({ buildOnStart = true } = {}) => {
    stopped = false;
    if (buildOnStart) scheduleBuild('startup');
    startWatching();
    if (typeof timers.setInterval === 'function') {
      heartbeatTimer = timers.setInterval(() => {
        try {
          writeHeartbeat();
        } catch (error) {
          logger.warn?.(`Obelisk heartbeat failed: ${error.message}`);
        }
      }, heartbeatMs);
    }
  };

  const stop = () => {
    stopped = true;
    pending = false;
    if (buildTimer) timers.clearTimeout(buildTimer);
    buildTimer = null;
    if (stabilityTimer) timers.clearTimeout(stabilityTimer);
    stabilityTimer = null;
    if (watchRetryTimer) timers.clearTimeout(watchRetryTimer);
    watchRetryTimer = null;
    if (heartbeatTimer && typeof timers.clearInterval === 'function') timers.clearInterval(heartbeatTimer);
    heartbeatTimer = null;
    if (watcher?.close) watcher.close();
    watcher = null;
  };

  return {
    start,
    stop,
    scheduleBuild,
    runBuildNow,
    idle: () => idlePromise,
  };
}

export { createIndexerService };