gitspace 0.2.0-rc.20 → 0.2.0-rc.21

package/src/lib/events/filters.ts

@@ -1,26 +0,0 @@
-/**
- * Saved events filter helpers
- */
-
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import type { EventsConfigFile, SavedEventFilter } from '../../types/events.js';
-
-export function getEventsConfigPath(workspacePath: string): string {
-  return join(workspacePath, '.gitspace', 'events.json');
-}
-
-export function loadSavedEventFilters(workspacePath: string): SavedEventFilter[] {
-  const path = getEventsConfigPath(workspacePath);
-  if (!existsSync(path)) {
-    return [];
-  }
-
-  try {
-    const raw = readFileSync(path, 'utf-8');
-    const parsed = JSON.parse(raw) as EventsConfigFile;
-    return Array.isArray(parsed.savedFilters) ? parsed.savedFilters : [];
-  } catch {
-    return [];
-  }
-}

package/src/lib/events/index.ts

@@ -1,11 +0,0 @@
-/**
- * Wide event module exports
- */
-
-export * from './collector.js';
-export * from './paths.js';
-
-export * from './reader.js';
-export * from './store.js';
-export * from './indexer.js';
-export * from './filters.js';

package/src/lib/events/indexer.ts

@@ -1,14 +0,0 @@
-/**
- * Wide event index maintenance helpers
- */
-
-import { writeFileSync } from 'fs';
-import type { WideEventIndex } from '../../types/events.js';
-
-export function writeIndexFile(path: string, index: WideEventIndex): void {
-  const data = {
-    ...index,
-    minTs: index.minTs === Number.POSITIVE_INFINITY ? index.maxTs : index.minTs,
-  };
-  writeFileSync(path, JSON.stringify(data, null, 2), 'utf-8');
-}

package/src/lib/events/paths.ts

@@ -1,69 +0,0 @@
-/**
- * Wide event path helpers
- */
-
-import { existsSync, readdirSync } from 'fs';
-import { join, relative, sep } from 'path';
-import { getGitspaceDir } from '../../core/config.js';
-import { encodeProcessNameForPath } from '../processes/names.js';
-
-const DEFAULT_INSTANCE = 1;
-
-export interface WorkspaceRef {
-  projectName: string;
-  workspaceId: string;
-  workspacePath: string;
-}
-
-/**
- * Resolve workspace/project info from a cwd path
- */
-export function resolveWorkspaceRef(cwd: string): WorkspaceRef | null {
-  const spacesDir = getGitspaceDir();
-  const rel = relative(spacesDir, cwd);
-  if (!rel || rel.startsWith('..')) {
-    return null;
-  }
-  const parts = rel.split(sep).filter(Boolean);
-  if (parts.length < 3) {
-    return null;
-  }
-  if (parts[1] !== 'workspaces') {
-    return null;
-  }
-  const projectName = parts[0];
-  const workspaceId = parts[2];
-  const workspacePath = join(spacesDir, projectName, 'workspaces', workspaceId);
-  return { projectName, workspaceId, workspacePath };
-}
-
-/**
- * Get events directory for a process
- */
-export function getProcessEventsDir(
-  workspacePath: string,
-  processName: string,
-  processInstance?: number
-): string {
-  const instance = processInstance ?? DEFAULT_INSTANCE;
-  return join(workspacePath, '.events', 'processes', `${encodeProcessNameForPath(processName)}-${instance}`);
-}
-
-export function getProcessSnapshotsPath(
-  workspacePath: string,
-  processName: string,
-  processInstance?: number
-): string {
-  return join(getProcessEventsDir(workspacePath, processName, processInstance), 'wide-snapshots.ndjson');
-}
-
-/**
- * Get all process events directories for a workspace
- */
-export function listProcessEventsDirs(workspacePath: string): string[] {
-  const base = join(workspacePath, '.events', 'processes');
-  if (!existsSync(base)) return [];
-  return readdirSync(base)
-    .filter((entry: string) => !entry.startsWith('.'))
-    .map((entry: string) => join(base, entry));
-}

package/src/lib/events/reader.ts

@@ -1,212 +0,0 @@
-/**
- * Wide event reader for CLI queries
- */
-
-import { join } from 'path';
-import { readFileSync } from 'fs';
-import type { WideEvent, WideEventFilter, WideSnapshot, WideSnapshotTimelineEntry } from '../../types/events.js';
-import { listEventIndexes, selectFilesForQuery, queryEvents } from './store.js';
-import { listProcessEventsDirs } from './paths.js';
-
-export interface WideEventQueryParams {
-  eventsDir: string;
-  filter: WideEventFilter;
-  limit?: number;
-  sinceMs?: number;
-  untilMs?: number;
-}
-
-export function readWideEvents(params: WideEventQueryParams): WideEvent[] {
-  const indexes = listEventIndexes(params.eventsDir);
-  const selected = selectFilesForQuery(indexes, {
-    filter: params.filter,
-    limit: params.limit,
-    sinceMs: params.sinceMs,
-    untilMs: params.untilMs,
-  });
-  const sorted = [...selected].sort((a, b) => b.maxTs - a.maxTs);
-  const results = queryEvents(
-    params.eventsDir,
-    sorted,
-    {
-      filter: params.filter,
-      limit: params.limit,
-      sinceMs: params.sinceMs,
-      untilMs: params.untilMs,
-    }
-  );
-  return results.reverse();
-
-}
-
-export function getEventsFilePath(eventsDir: string, indexFile: string): string {
-  return join(eventsDir, indexFile);
-}
-
-type SnapshotCacheEntry = {
-  snapshots: Map<string, WideSnapshot>;
-  bytes: number;
-  updatedAt: number;
-};
-
-const workspaceSnapshotCache = new Map<string, SnapshotCacheEntry>();
-const DEFAULT_CACHE_BYTES = 64 * 1024 * 1024;
-const DEFAULT_CACHE_TTL_MS = 1000;
-const DEFAULT_MAX_TIMELINE = 200;
-
-function estimateSnapshotSize(snapshot: WideSnapshot): number {
-  return Buffer.byteLength(JSON.stringify(snapshot));
-}
-
-function readSnapshotFile(filePath: string): WideSnapshot[] {
-  try {
-    const content = readFileSync(filePath, 'utf-8');
-    const snapshots: WideSnapshot[] = [];
-    for (const line of content.split('\n')) {
-      if (line.trim().length === 0) continue;
-      try {
-        const parsed = JSON.parse(line) as WideSnapshot;
-        if (!parsed || typeof parsed !== 'object') continue;
-        if (typeof parsed.correlationId !== 'string') continue;
-        if (typeof parsed.updatedAt !== 'number' || Number.isNaN(parsed.updatedAt)) continue;
-        if (typeof parsed.eventName !== 'string') continue;
-        if (typeof parsed.level !== 'string') continue;
-        if (typeof parsed.message !== 'string') continue;
-        if (typeof parsed.lastEventId !== 'string') continue;
-        if (!parsed.timelineMap || typeof parsed.timelineMap !== 'object') continue;
-        if (!Array.isArray(parsed.timelineOrder)) continue;
-        if (!parsed.timelineOrder.every((entry) => typeof entry === 'string')) continue;
-        snapshots.push(parsed);
-      } catch {
-        // Skip malformed snapshot entries
-      }
-    }
-    return snapshots;
-  } catch {
-    return [];
-  }
-}
-
-function mergeSnapshot(
-  existing: WideSnapshot | undefined,
-  incoming: WideSnapshot,
-  maxTimeline: number
-): WideSnapshot {
-  if (!existing) {
-    return incoming;
-  }
-
-  const orderedEntries: Array<{ entry: WideSnapshotTimelineEntry; seq: number }> = [];
-  existing.timelineOrder.forEach((key, index) => {
-    const entry = existing.timelineMap[key];
-    if (entry) {
-      orderedEntries.push({ entry, seq: index });
-    }
-  });
-  const incomingOffset = orderedEntries.length;
-  incoming.timelineOrder.forEach((key, index) => {
-    const entry = incoming.timelineMap[key];
-    if (entry) {
-      orderedEntries.push({ entry, seq: incomingOffset + index });
-    }
-  });
-
-  orderedEntries.sort((a, b) => {
-    if (a.entry.timestampMs !== b.entry.timestampMs) {
-      return a.entry.timestampMs - b.entry.timestampMs;
-    }
-    return a.seq - b.seq;
-  });
-
-  const maxEntries = Math.max(1, maxTimeline);
-  const trimmedEntries =
-    orderedEntries.length > maxEntries
-      ? orderedEntries.slice(orderedEntries.length - maxEntries)
-      : orderedEntries;
-
-  const timelineMap: Record<string, WideSnapshotTimelineEntry> = {};
-  const timelineOrder: string[] = [];
-  const keyCounts = new Map<string, number>();
-  for (const { entry } of trimmedEntries) {
-    const baseName = entry.eventName;
-    const count = keyCounts.get(baseName) ?? 0;
-    const next = count + 1;
-    keyCounts.set(baseName, next);
-    const key = next === 1 ? baseName : `${baseName}#${next}`;
-    timelineMap[key] = { ...entry, key };
-    timelineOrder.push(key);
-  }
-
-  const isIncomingLatest = incoming.updatedAt >= existing.updatedAt;
-
-  return {
-    correlationId: incoming.correlationId,
-    updatedAt: Math.max(existing.updatedAt, incoming.updatedAt),
-    processName: isIncomingLatest ? incoming.processName : existing.processName,
-    processInstance: isIncomingLatest ? incoming.processInstance : existing.processInstance,
-    level: isIncomingLatest ? incoming.level : existing.level,
-    message: isIncomingLatest ? incoming.message : existing.message,
-    eventName: isIncomingLatest ? incoming.eventName : existing.eventName,
-    lastEventId: isIncomingLatest ? incoming.lastEventId : existing.lastEventId,
-    timelineMap,
-    timelineOrder,
-    raw: isIncomingLatest ? incoming.raw : existing.raw,
-  };
-}
-
-function applyCacheLimit(entry: SnapshotCacheEntry, maxBytes: number): void {
-  if (entry.bytes <= maxBytes) return;
-  const sorted = Array.from(entry.snapshots.values()).sort((a, b) => a.updatedAt - b.updatedAt);
-  for (const snapshot of sorted) {
-    if (entry.bytes <= maxBytes) break;
-    entry.snapshots.delete(snapshot.correlationId);
-    entry.bytes = Math.max(0, entry.bytes - estimateSnapshotSize(snapshot));
-  }
-}
-
-export interface ReadWorkspaceSnapshotsOptions {
-  maxBytes?: number;
-  maxTimeline?: number;
-  refresh?: boolean;
-}
-
-export function readWorkspaceSnapshots(
-  workspacePath: string,
-  options: ReadWorkspaceSnapshotsOptions = {}
-): WideSnapshot[] {
-  const cached = workspaceSnapshotCache.get(workspacePath);
-  const isFresh = cached ? Date.now() - cached.updatedAt <= DEFAULT_CACHE_TTL_MS : false;
-  if (cached && !options.refresh && isFresh) {
-    return Array.from(cached.snapshots.values()).sort((a, b) => b.updatedAt - a.updatedAt);
-  }
-
-  const maxBytes = options.maxBytes ?? DEFAULT_CACHE_BYTES;
-  const maxTimeline = options.maxTimeline ?? DEFAULT_MAX_TIMELINE;
-
-  const entry: SnapshotCacheEntry = {
-    snapshots: new Map<string, WideSnapshot>(),
-    bytes: 0,
-    updatedAt: Date.now(),
-  };
-
-  const processDirs = listProcessEventsDirs(workspacePath);
-  for (const dir of processDirs) {
-    const filePath = join(dir, 'wide-snapshots.ndjson');
-    const snapshots = readSnapshotFile(filePath);
-    for (const snapshot of snapshots) {
-      const existing = entry.snapshots.get(snapshot.correlationId);
-      const merged = mergeSnapshot(existing, snapshot, maxTimeline);
-      if (!existing) {
-        entry.bytes += estimateSnapshotSize(merged);
-      } else {
-        entry.bytes = Math.max(0, entry.bytes - estimateSnapshotSize(existing));
-        entry.bytes += estimateSnapshotSize(merged);
-      }
-      entry.snapshots.set(merged.correlationId, merged);
-    }
-  }
-
-  applyCacheLimit(entry, maxBytes);
-  workspaceSnapshotCache.set(workspacePath, entry);
-  return Array.from(entry.snapshots.values()).sort((a, b) => b.updatedAt - a.updatedAt);
-}

package/src/lib/events/store.ts

@@ -1,141 +0,0 @@
-/**
- * Wide event storage and query helpers
- */
-
-import { existsSync, readFileSync, readdirSync } from 'fs';
-import { join } from 'path';
-import type { WideEvent, WideEventFilter, WideEventIndex } from '../../types/events.js';
-
-export interface WideEventQueryOptions {
-  filter: WideEventFilter;
-  limit?: number;
-  sinceMs?: number;
-  untilMs?: number;
-}
-
-export function listEventIndexes(eventsDir: string): WideEventIndex[] {
-  if (!existsSync(eventsDir)) {
-    return [];
-  }
-  return readdirSync(eventsDir)
-    .filter((file) => file.endsWith('.index.json'))
-    .map((file) => {
-      const path = join(eventsDir, file);
-      try {
-        const data = JSON.parse(readFileSync(path, 'utf-8')) as WideEventIndex;
-        return data;
-      } catch {
-        return null;
-      }
-    })
-    .filter((item): item is WideEventIndex => Boolean(item));
-}
-
-export function selectFilesForQuery(indexes: WideEventIndex[], options: WideEventQueryOptions): WideEventIndex[] {
-  return indexes.filter((index) => {
-    if (options.sinceMs !== undefined && index.maxTs < options.sinceMs) {
-      return false;
-    }
-    if (options.untilMs !== undefined && index.minTs > options.untilMs) {
-      return false;
-    }
-    if (options.filter.level && !index.levels.includes(options.filter.level)) {
-      return false;
-    }
-    if (options.filter.eventName && !index.eventNames.includes(options.filter.eventName)) {
-      return false;
-    }
-    return true;
-  });
-}
-
-export function queryEvents(
-  eventsDir: string,
-  indexes: WideEventIndex[],
-  options: WideEventQueryOptions
-): WideEvent[] {
-  const results: WideEvent[] = [];
-  const limit = options.limit ?? 100;
-
-  for (const index of indexes) {
-    const path = join(eventsDir, index.file);
-    if (!existsSync(path)) continue;
-
-    const lines = readFileSync(path, 'utf-8').split('\n');
-    for (let i = lines.length - 1; i >= 0; i -= 1) {
-      const line = lines[i];
-      if (!line || !line.trim()) continue;
-      try {
-        const raw = JSON.parse(line) as Record<string, unknown>;
-        const event = normalizeStoredEvent(raw);
-        if (!event) continue;
-        if (!matchesQuery(event, options)) continue;
-        results.push(event);
-        if (results.length >= limit) {
-          return results;
-        }
-      } catch {
-        // Ignore malformed lines
-      }
-    }
-  }
-
-  return results;
-}
-
-function normalizeStoredEvent(raw: Record<string, unknown>): WideEvent | null {
-  if (!raw || typeof raw !== 'object') return null;
-  const eventId = typeof raw.eventId === 'string' ? raw.eventId : null;
-  const eventName = typeof raw.eventName === 'string' ? raw.eventName : null;
-  const level = typeof raw.level === 'string' ? raw.level : null;
-  const timestamp = typeof raw.timestamp === 'string' ? raw.timestamp : null;
-  const message = typeof raw.message === 'string' ? raw.message : null;
-  const timestampMs = typeof raw.timestampMs === 'number' ? raw.timestampMs : Date.parse(timestamp ?? '');
-  const sessionId = typeof raw.sessionId === 'string' ? raw.sessionId : '';
-  const workspaceId = typeof raw.workspaceId === 'string' ? raw.workspaceId : '';
-  const projectName = typeof raw.projectName === 'string' ? raw.projectName : '';
-  const processName = typeof raw.processName === 'string' ? raw.processName : undefined;
-  const processInstance = typeof raw.processInstance === 'number' ? raw.processInstance : undefined;
-  const kind = raw.kind === 'wide' || raw.kind === 'source' ? raw.kind : undefined;
-  const correlationId = typeof raw.correlationId === 'string' ? raw.correlationId : undefined;
-  const timeline = Array.isArray(raw.timeline)
-    ? (raw.timeline as WideEvent['timeline'])
-    : undefined;
-
-  if (!eventId || !eventName || !level || !timestamp || !message || Number.isNaN(timestampMs)) {
-    return null;
-  }
-
-  return {
-    eventId,
-    eventName,
-    level,
-    timestamp,
-    timestampMs,
-    message,
-    sessionId,
-    workspaceId,
-    projectName,
-    processName,
-    processInstance,
-    raw,
-    kind,
-    correlationId,
-    timeline,
-  };
-
-}
-
-function matchesQuery(event: WideEvent, options: WideEventQueryOptions): boolean {
-  const { filter, sinceMs, untilMs } = options;
-  if (filter.eventName && event.eventName !== filter.eventName) return false;
-  if (filter.eventId && event.eventId !== filter.eventId) return false;
-  if (filter.level && event.level !== filter.level) return false;
-  if (filter.message && !event.message.includes(filter.message)) return false;
-  if (filter.processName && event.processName !== filter.processName) return false;
-  if (filter.kind && event.kind !== filter.kind) return false;
-  if (filter.correlationId && event.correlationId !== filter.correlationId) return false;
-  if (sinceMs !== undefined && event.timestampMs < sinceMs) return false;
-  if (untilMs !== undefined && event.timestampMs > untilMs) return false;
-  return true;
-}

package/src/lib/invite.web.ts

@@ -1,58 +0,0 @@
-/**
- * Invite token parsing
- */
-
-export interface ParsedInvite {
-  inviteToken: string;  // Full invite token for X3DH authorization
-  machineId: string;
-  inviteId: string;     // Short hash for relay lookup
-  relayUrl?: string;
-}
-
-/**
- * Parse invite from URL hash
- * Format: #invite=base64url(JSON)
- */
-export async function parseInviteFromHash(hash: string): Promise<ParsedInvite | null> {
-  try {
-    const prefix = "#invite=";
-    if (!hash.startsWith(prefix)) return null;
-
-    const encoded = hash.slice(prefix.length);
-
-    // Decode base64url
-    const base64 = encoded.replace(/-/g, "+").replace(/_/g, "/");
-    const padding = "=".repeat((4 - (base64.length % 4)) % 4);
-    const decoded = atob(base64 + padding);
-
-    const invite = JSON.parse(decoded);
-
-    // Generate invite ID from token (first 16 chars of hash)
-    const inviteId = await generateInviteId(encoded);
-
-    return {
-      inviteToken: encoded,  // Full token for X3DH auth
-      machineId: invite.machineId,
-      inviteId,              // Short hash for relay lookup
-      relayUrl: invite.relayUrl,
-    };
-  } catch (e) {
-    console.error("Failed to parse invite:", e);
-    return null;
-  }
-}
-
-/**
- * Generate invite ID from token (simple hash)
- */
-async function generateInviteId(token: string): Promise<string> {
-  const encoder = new TextEncoder();
-  const data = encoder.encode(token);
-  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
-  const hashArray = new Uint8Array(hashBuffer);
-  const hashBase64 = btoa(String.fromCharCode(...hashArray))
-    .replace(/\+/g, "-")
-    .replace(/\//g, "_")
-    .replace(/=/g, "");
-  return hashBase64.slice(0, 16);
-}

package/src/lib/preferences-service.web.ts

@@ -1,41 +0,0 @@
-import type { PreferencesService } from '../preferences/index.js';
-import type { NotificationConfig } from '../notifications/types.js';
-import { DEFAULT_NOTIFICATION_CONFIG } from '../notifications/types.js';
-
-const NOTIFICATION_CONFIG_STORAGE_KEY = 'gitspace:web:notification-config';
-
-/**
- * Browser preferences service backed by localStorage.
- */
-export const browserPreferencesService: PreferencesService = {
-  async getNotificationConfig(): Promise<NotificationConfig> {
-    try {
-      const raw = localStorage.getItem(NOTIFICATION_CONFIG_STORAGE_KEY);
-      if (!raw) {
-        return { ...DEFAULT_NOTIFICATION_CONFIG };
-      }
-
-      const parsed = JSON.parse(raw) as Partial<NotificationConfig>;
-      return {
-        enabled: parsed.enabled ?? DEFAULT_NOTIFICATION_CONFIG.enabled,
-        minCommandDurationMs:
-          parsed.minCommandDurationMs ?? DEFAULT_NOTIFICATION_CONFIG.minCommandDurationMs,
-        types: {
-          ...DEFAULT_NOTIFICATION_CONFIG.types,
-          ...(parsed.types || {}),
-        },
-        toast: {
-          ...DEFAULT_NOTIFICATION_CONFIG.toast,
-          ...(parsed.toast || {}),
-        },
-      };
-    } catch {
-      return { ...DEFAULT_NOTIFICATION_CONFIG };
-    }
-  },
-
-  async updateNotificationConfig(config: NotificationConfig): Promise<NotificationConfig> {
-    localStorage.setItem(NOTIFICATION_CONFIG_STORAGE_KEY, JSON.stringify(config));
-    return config;
-  },
-};

package/src/lib/processes/__tests__/config.test.ts

@@ -1,83 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import {
-  getProcessesConfigPath,
-  loadProcessesConfig,
-  loadProcessesConfigWithDiagnostics,
-} from '../config.js';
-
-function makeWorkspace(): string {
-  const dir = mkdtempSync(join(tmpdir(), 'gssh-process-config-'));
-  mkdirSync(join(dir, '.gitspace'), { recursive: true });
-  return dir;
-}
-
-function withWorkspace<T>(run: (workspace: string) => T): T {
-  const workspace = makeWorkspace();
-  try {
-    return run(workspace);
-  } finally {
-    rmSync(workspace, { recursive: true, force: true });
-  }
-}
-
-describe('loadProcessesConfigWithDiagnostics', () => {
-  it('parses JSONC comments and trailing commas', () => {
-    withWorkspace((workspace) => {
-      const path = getProcessesConfigPath(workspace);
-      writeFileSync(path, [
-        '{',
-        '  // One process',
-        '  "processes": [',
-        '    {',
-        '      "name": "web",',
-        '      "command": "bun",',
-        '      "args": ["run", "dev",],',
-        '    },',
-        '  ],',
-        '}',
-        '',
-      ].join('\n'));
-
-      const result = loadProcessesConfigWithDiagnostics(workspace);
-      expect(result.error).toBeNull();
-      expect(result.config.processes).toHaveLength(1);
-      expect(result.config.processes[0]?.name).toBe('web');
-    });
-  });
-
-  it('returns parse diagnostics for malformed JSONC', () => {
-    withWorkspace((workspace) => {
-      const path = getProcessesConfigPath(workspace);
-      writeFileSync(path, '{\n  "processes": [\n    {\n');
-
-      const result = loadProcessesConfigWithDiagnostics(workspace);
-      expect(result.config.processes).toEqual([]);
-      expect(result.error).toContain('Failed to parse .gitspace/processes.json');
-    });
-  });
-
-  it('returns validation diagnostics for invalid config', () => {
-    withWorkspace((workspace) => {
-      const path = getProcessesConfigPath(workspace);
-      writeFileSync(path, '{"processes":[{"name":"web"}]}');
-
-      const result = loadProcessesConfigWithDiagnostics(workspace);
-      expect(result.error).toContain('Invalid .gitspace/processes.json');
-      expect(result.error).toContain('missing command');
-    });
-  });
-
-  it('loadProcessesConfig stays backward-compatible', () => {
-    withWorkspace((workspace) => {
-      const path = getProcessesConfigPath(workspace);
-      writeFileSync(path, '{"processes":[{"name":"api","command":"bun"}]}');
-
-      const config = loadProcessesConfig(workspace);
-      expect(config.processes).toHaveLength(1);
-      expect(config.processes[0]?.name).toBe('api');
-    });
-  });
-});