@fyresmith/hive-server 2.4.0 → 3.1.0

package/lib/collabStore.js

@@ -1,448 +0,0 @@
-import { randomUUID } from 'crypto';
-import { dirname, join, resolve } from 'path';
-import { appendFile, mkdir, readFile, rename, writeFile } from 'fs/promises';
-
-const DEFAULT_ACTIVITY_LIMIT = 100;
-const MAX_ACTIVITY_LIMIT = 500;
-const MAX_ACTIVITY_RETENTION = 5000;
-
-function nowTs() {
-  return Date.now();
-}
-
-function isoDay(ts) {
-  return new Date(ts).toISOString().slice(0, 10);
-}
-
-function workspaceKeyForPath(filePath) {
-  if (typeof filePath !== 'string' || filePath.length === 0) return 'root';
-  const normalized = filePath.replace(/\\/g, '/');
-  const [head] = normalized.split('/');
-  return head || 'root';
-}
-
-function clampLimit(value) {
-  const num = Number(value);
-  if (!Number.isFinite(num)) return DEFAULT_ACTIVITY_LIMIT;
-  const int = Math.trunc(num);
-  if (int < 1) return 1;
-  if (int > MAX_ACTIVITY_LIMIT) return MAX_ACTIVITY_LIMIT;
-  return int;
-}
-
-async function readJson(path, fallback) {
-  try {
-    const raw = await readFile(path, 'utf-8');
-    return JSON.parse(raw);
-  } catch (err) {
-    if (err?.code === 'ENOENT') return fallback;
-    throw err;
-  }
-}
-
-async function writeJsonAtomic(path, value) {
-  const tmp = `${path}.tmp`;
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(tmp, JSON.stringify(value, null, 2), 'utf-8');
-  await rename(tmp, path);
-}
-
-function normalizeMode(mode) {
-  if (mode === 'mute' || mode === 'focus' || mode === 'digest' || mode === 'all') {
-    return mode;
-  }
-  return 'all';
-}
-
-export class CollabStore {
-  constructor(options = {}) {
-    const vaultRoot = process.env.VAULT_PATH ? resolve(process.env.VAULT_PATH) : process.cwd();
-    this.root = options.root ?? join(vaultRoot, '.hive-collab');
-    this.eventsDir = join(this.root, 'events');
-    this.indexDir = join(this.root, 'index');
-    this.threadsFile = join(this.indexDir, 'threads.json');
-    this.activityFile = join(this.indexDir, 'activity.json');
-    this.preferencesFile = join(this.indexDir, 'notify-preferences.json');
-    this.initPromise = null;
-  }
-
-  async ensureReady() {
-    if (!this.initPromise) {
-      this.initPromise = (async () => {
-        await mkdir(this.eventsDir, { recursive: true });
-        await mkdir(this.indexDir, { recursive: true });
-        const [threads, activity, preferences] = await Promise.all([
-          readJson(this.threadsFile, null),
-          readJson(this.activityFile, null),
-          readJson(this.preferencesFile, null),
-        ]);
-
-        if (!threads) {
-          await writeJsonAtomic(this.threadsFile, { threads: {} });
-        }
-        if (!activity) {
-          await writeJsonAtomic(this.activityFile, { events: [] });
-        }
-        if (!preferences) {
-          await writeJsonAtomic(this.preferencesFile, { users: {} });
-        }
-      })();
-    }
-
-    await this.initPromise;
-  }
-
-  async appendEvent(type, payload) {
-    await this.ensureReady();
-    const ts = nowTs();
-    const line = JSON.stringify({
-      eventId: randomUUID(),
-      type,
-      ts,
-      payload,
-    });
-    await appendFile(join(this.eventsDir, `${isoDay(ts)}.jsonl`), `${line}\n`, 'utf-8');
-  }
-
-  async listThreads(filter = {}) {
-    await this.ensureReady();
-    const store = await readJson(this.threadsFile, { threads: {} });
-    const threads = Object.values(store.threads ?? {})
-      .filter((thread) => {
-        if (filter.filePath && thread.filePath !== filter.filePath) return false;
-        if (filter.status && thread.status !== filter.status) return false;
-        return true;
-      })
-      .sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
-
-    return threads;
-  }
-
-  async getThread(threadId) {
-    await this.ensureReady();
-    const store = await readJson(this.threadsFile, { threads: {} });
-    return store.threads?.[threadId] ?? null;
-  }
-
-  async createThread({ filePath, anchor, author, body, mentions = [] }) {
-    await this.ensureReady();
-
-    const store = await readJson(this.threadsFile, { threads: {} });
-    const ts = nowTs();
-    const threadId = randomUUID();
-
-    const baseThread = {
-      threadId,
-      filePath,
-      anchor: anchor ?? null,
-      status: 'thread_open',
-      participants: author?.username ? [author.username] : [],
-      createdAt: ts,
-      updatedAt: ts,
-      comments: [],
-      task: null,
-    };
-
-    if (typeof body === 'string' && body.trim().length > 0) {
-      baseThread.comments.push({
-        commentId: randomUUID(),
-        threadId,
-        author,
-        body,
-        mentions,
-        createdAt: ts,
-        updatedAt: ts,
-      });
-    }
-
-    store.threads[threadId] = baseThread;
-    await writeJsonAtomic(this.threadsFile, store);
-    await this.appendEvent('thread.create', { thread: baseThread });
-
-    return baseThread;
-  }
-
-  async updateThread({ threadId, patch }) {
-    await this.ensureReady();
-
-    const store = await readJson(this.threadsFile, { threads: {} });
-    const thread = store.threads?.[threadId];
-    if (!thread) return null;
-
-    const ts = nowTs();
-    if (typeof patch?.status === 'string') {
-      thread.status = patch.status;
-    }
-    if (patch?.anchor !== undefined) {
-      thread.anchor = patch.anchor;
-    }
-    thread.updatedAt = ts;
-
-    store.threads[threadId] = thread;
-    await writeJsonAtomic(this.threadsFile, store);
-    await this.appendEvent('thread.update', { threadId, patch });
-
-    return thread;
-  }
-
-  async deleteThread(threadId) {
-    await this.ensureReady();
-
-    const store = await readJson(this.threadsFile, { threads: {} });
-    const thread = store.threads?.[threadId];
-    if (!thread) return null;
-
-    const ts = nowTs();
-    thread.status = 'thread_archived';
-    thread.archivedAt = ts;
-    thread.updatedAt = ts;
-    store.threads[threadId] = thread;
-
-    await writeJsonAtomic(this.threadsFile, store);
-    await this.appendEvent('thread.delete', { threadId });
-
-    return thread;
-  }
-
-  async createComment({ threadId, author, body, mentions = [] }) {
-    await this.ensureReady();
-
-    const store = await readJson(this.threadsFile, { threads: {} });
-    const thread = store.threads?.[threadId];
-    if (!thread) return null;
-
-    const ts = nowTs();
-    const comment = {
-      commentId: randomUUID(),
-      threadId,
-      author,
-      body,
-      mentions,
-      createdAt: ts,
-      updatedAt: ts,
-    };
-
-    thread.comments = Array.isArray(thread.comments) ? thread.comments : [];
-    thread.comments.push(comment);
-    if (author?.username) {
-      const next = new Set(thread.participants ?? []);
-      next.add(author.username);
-      thread.participants = [...next];
-    }
-    thread.updatedAt = ts;
-    store.threads[threadId] = thread;
-
-    await writeJsonAtomic(this.threadsFile, store);
-    await this.appendEvent('comment.create', { threadId, comment });
-
-    return { thread, comment };
-  }
-
-  async updateComment({ threadId, commentId, body }) {
-    await this.ensureReady();
-
-    const store = await readJson(this.threadsFile, { threads: {} });
-    const thread = store.threads?.[threadId];
-    if (!thread || !Array.isArray(thread.comments)) return null;
-
-    const comment = thread.comments.find((entry) => entry.commentId === commentId);
-    if (!comment) return null;
-
-    const ts = nowTs();
-    comment.body = body;
-    comment.updatedAt = ts;
-    thread.updatedAt = ts;
-    store.threads[threadId] = thread;
-
-    await writeJsonAtomic(this.threadsFile, store);
-    await this.appendEvent('comment.update', { threadId, commentId });
-
-    return { thread, comment };
-  }
-
-  async deleteComment({ threadId, commentId }) {
-    await this.ensureReady();
-
-    const store = await readJson(this.threadsFile, { threads: {} });
-    const thread = store.threads?.[threadId];
-    if (!thread || !Array.isArray(thread.comments)) return null;
-
-    const next = thread.comments.filter((entry) => entry.commentId !== commentId);
-    if (next.length === thread.comments.length) return null;
-
-    const ts = nowTs();
-    thread.comments = next;
-    thread.updatedAt = ts;
-    store.threads[threadId] = thread;
-
-    await writeJsonAtomic(this.threadsFile, store);
-    await this.appendEvent('comment.delete', { threadId, commentId });
-
-    return { thread, commentId };
-  }
-
-  async setTaskState({ threadId, status, assignee = null, dueAt = null }) {
-    await this.ensureReady();
-
-    const store = await readJson(this.threadsFile, { threads: {} });
-    const thread = store.threads?.[threadId];
-    if (!thread) return null;
-
-    const ts = nowTs();
-    const previous = thread.task;
-    thread.task = {
-      taskId: previous?.taskId ?? randomUUID(),
-      threadId,
-      status,
-      assignee,
-      dueAt,
-      updatedAt: ts,
-      createdAt: previous?.createdAt ?? ts,
-    };
-    thread.updatedAt = ts;
-    store.threads[threadId] = thread;
-
-    await writeJsonAtomic(this.threadsFile, store);
-    await this.appendEvent('task.set-state', { threadId, task: thread.task });
-
-    return { thread, task: thread.task };
-  }
-
-  async recordActivity({ type, filePath = null, actor = null, payload = null, groupKey = null }) {
-    await this.ensureReady();
-
-    const store = await readJson(this.activityFile, { events: [] });
-    const activity = {
-      eventId: randomUUID(),
-      type,
-      filePath,
-      actor,
-      payload,
-      groupKey,
-      ts: nowTs(),
-    };
-
-    store.events = Array.isArray(store.events) ? store.events : [];
-    store.events.unshift(activity);
-    if (store.events.length > MAX_ACTIVITY_RETENTION) {
-      store.events = store.events.slice(0, MAX_ACTIVITY_RETENTION);
-    }
-
-    await writeJsonAtomic(this.activityFile, store);
-    await this.appendEvent('activity.record', activity);
-
-    return activity;
-  }
-
-  async listActivity({ filePath = null, types = null, limit = DEFAULT_ACTIVITY_LIMIT, cursor = null } = {}) {
-    await this.ensureReady();
-
-    const store = await readJson(this.activityFile, { events: [] });
-    let events = Array.isArray(store.events) ? [...store.events] : [];
-
-    if (filePath) {
-      events = events.filter((entry) => entry.filePath === filePath);
-    }
-    if (Array.isArray(types) && types.length > 0) {
-      const set = new Set(types.map((entry) => String(entry)));
-      events = events.filter((entry) => set.has(entry.type));
-    }
-
-    if (cursor) {
-      const idx = events.findIndex((entry) => entry.eventId === cursor);
-      if (idx >= 0) {
-        events = events.slice(idx + 1);
-      }
-    }
-
-    const clamped = clampLimit(limit);
-    const page = events.slice(0, clamped);
-    const nextCursor = page.length > 0 ? page[page.length - 1].eventId : null;
-
-    return {
-      events: page,
-      nextCursor,
-    };
-  }
-
-  async getNotifyPreferences(userId) {
-    await this.ensureReady();
-    const store = await readJson(this.preferencesFile, { users: {} });
-
-    const current = store.users?.[userId] ?? {
-      global: 'all',
-      workspace: {},
-      file: {},
-    };
-
-    return {
-      global: normalizeMode(current.global),
-      workspace: current.workspace ?? {},
-      file: current.file ?? {},
-    };
-  }
-
-  async setNotifyPreference({ userId, scope, key = null, mode }) {
-    await this.ensureReady();
-
-    const store = await readJson(this.preferencesFile, { users: {} });
-    const current = store.users?.[userId] ?? {
-      global: 'all',
-      workspace: {},
-      file: {},
-    };
-
-    const normalizedMode = normalizeMode(mode);
-
-    if (scope === 'global') {
-      current.global = normalizedMode;
-    } else if (scope === 'workspace' && typeof key === 'string' && key.length > 0) {
-      current.workspace[key] = normalizedMode;
-    } else if (scope === 'file' && typeof key === 'string' && key.length > 0) {
-      current.file[key] = normalizedMode;
-    } else {
-      throw new Error('Invalid notification scope or key');
-    }
-
-    store.users[userId] = current;
-    await writeJsonAtomic(this.preferencesFile, store);
-    await this.appendEvent('notify.preference', { userId, scope, key, mode: normalizedMode });
-
-    return {
-      global: normalizeMode(current.global),
-      workspace: current.workspace,
-      file: current.file,
-    };
-  }
-
-  async resolveNotifyMode(userId, filePath) {
-    const preferences = await this.getNotifyPreferences(userId);
-    const workspace = workspaceKeyForPath(filePath);
-
-    if (filePath && preferences.file?.[filePath]) {
-      return normalizeMode(preferences.file[filePath]);
-    }
-    if (preferences.workspace?.[workspace]) {
-      return normalizeMode(preferences.workspace[workspace]);
-    }
-    return normalizeMode(preferences.global);
-  }
-
-  async shouldDeliverNotification(userId, filePath, kind) {
-    const mode = await this.resolveNotifyMode(userId, filePath);
-    if (mode === 'mute') {
-      return { deliver: false, mode };
-    }
-    if (mode === 'focus') {
-      return { deliver: kind === 'mention' || kind === 'task', mode };
-    }
-    if (mode === 'digest') {
-      return { deliver: false, mode };
-    }
-    return { deliver: true, mode };
-  }
-}
-
-export function createCollabStore(options) {
-  return new CollabStore(options);
-}

package/lib/discordWebhook.js

@@ -1,81 +0,0 @@
-function parseWebhookMap(raw) {
-  if (!raw) return [];
-  try {
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== 'object') return [];
-    return Object.entries(parsed)
-      .filter(([prefix, url]) => typeof prefix === 'string' && typeof url === 'string')
-      .map(([prefix, url]) => ({
-        prefix: prefix.replace(/\\/g, '/').replace(/^\//, ''),
-        url,
-      }))
-      .sort((a, b) => b.prefix.length - a.prefix.length);
-  } catch {
-    return [];
-  }
-}
-
-const mappedWebhooks = parseWebhookMap(process.env.HIVE_DISCORD_WEBHOOKS_JSON);
-
-function resolveWebhook(filePath) {
-  const normalized = typeof filePath === 'string' ? filePath.replace(/\\/g, '/') : '';
-
-  for (const entry of mappedWebhooks) {
-    if (!entry.prefix) continue;
-    if (normalized === entry.prefix || normalized.startsWith(`${entry.prefix}/`)) {
-      return entry.url;
-    }
-  }
-
-  const fallback = process.env.HIVE_DISCORD_WEBHOOK_URL;
-  return typeof fallback === 'string' && fallback.length > 0 ? fallback : null;
-}
-
-function buildMessage(payload) {
-  const kind = payload?.kind === 'task' ? 'Task' : 'Mention';
-  const actor = payload?.actor?.username ? `@${payload.actor.username}` : 'Someone';
-  const filePath = payload?.filePath ?? 'unknown file';
-  const threadId = payload?.threadId ?? 'n/a';
-  const target = payload?.targetUser?.username ? `@${payload.targetUser.username}` : 'a collaborator';
-
-  return {
-    username: 'Hive',
-    content: `**${kind}** for ${target} in \`${filePath}\` by ${actor}`,
-    embeds: [
-      {
-        title: `${kind} Notification`,
-        fields: [
-          { name: 'File', value: `\`${filePath}\``, inline: false },
-          { name: 'Thread', value: threadId, inline: true },
-          { name: 'Recipient', value: target, inline: true },
-        ],
-        description: typeof payload?.body === 'string' ? payload.body.slice(0, 500) : '',
-        timestamp: new Date(payload?.ts ?? Date.now()).toISOString(),
-      },
-    ],
-  };
-}
-
-export async function sendDiscordWebhook(payload) {
-  const webhook = resolveWebhook(payload?.filePath);
-  if (!webhook) return false;
-
-  try {
-    const res = await fetch(webhook, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify(buildMessage(payload)),
-    });
-
-    if (!res.ok) {
-      const body = await res.text();
-      console.warn(`[notify] Discord webhook failed (${res.status}): ${body}`);
-      return false;
-    }
-
-    return true;
-  } catch (err) {
-    console.warn('[notify] Discord webhook error:', err?.message ?? err);
-    return false;
-  }
-}

package/lib/mentionUtils.js

@@ -1,13 +0,0 @@
-const MENTION_RE = /(^|\s)@([a-zA-Z0-9](?:[a-zA-Z0-9_.-]{0,62}[a-zA-Z0-9])?)(?=$|\s|[.,!?;:])/g;
-
-export function parseMentions(text) {
-  if (typeof text !== 'string' || text.length === 0) return [];
-
-  const mentions = new Set();
-  let match;
-  while ((match = MENTION_RE.exec(text)) !== null) {
-    mentions.add(match[2].toLowerCase());
-  }
-
-  return [...mentions];
-}