beads-ui 0.1.1 → 0.2.0

package/server/cli/open.test.js

@@ -1,26 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { computeOpenCommand } from './open.js';
-
-describe('computeOpenCommand', () => {
-  test('returns macOS open command', () => {
-    const r = computeOpenCommand('http://127.0.0.1:3000', 'darwin');
-
-    expect(r.cmd).toBe('open');
-    expect(r.args).toEqual(['http://127.0.0.1:3000']);
-  });
-
-  test('returns Linux xdg-open command', () => {
-    const r = computeOpenCommand('http://127.0.0.1:3000', 'linux');
-
-    expect(r.cmd).toBe('xdg-open');
-    expect(r.args).toEqual(['http://127.0.0.1:3000']);
-  });
-
-  test('returns Windows start command via cmd', () => {
-    const r = computeOpenCommand('http://127.0.0.1:3000', 'win32');
-
-    expect(r.cmd).toBe('cmd');
-    expect(r.args.slice(0, 3)).toEqual(['/c', 'start', '']);
-    expect(r.args[r.args.length - 1]).toBe('http://127.0.0.1:3000');
-  });
-});

package/server/db.test.js

@@ -1,70 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
-import { findNearestBeadsDb, resolveDbPath } from './db.js';
-
-/** @type {string[]} */
-const tmps = [];
-
-function mkdtemp() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'beads-ui-test-'));
-  tmps.push(dir);
-  return dir;
-}
-
-beforeEach(() => {
-  vi.resetModules();
-});
-
-afterEach(() => {
-  for (const d of tmps.splice(0)) {
-    try {
-      fs.rmSync(d, { recursive: true, force: true });
-    } catch {
-      // ignore cleanup errors
-    }
-  }
-});
-
-describe('resolveDbPath', () => {
-  test('uses explicit_db when provided', () => {
-    const res = resolveDbPath({ cwd: '/x', explicit_db: './my.db', env: {} });
-    expect(res.path.endsWith('/x/my.db')).toBe(true);
-    expect(res.source).toBe('flag');
-  });
-
-  test('uses BEADS_DB from env when set', () => {
-    const res = resolveDbPath({ cwd: '/x', env: { BEADS_DB: '/abs/env.db' } });
-    expect(res.path).toBe('/abs/env.db');
-    expect(res.source).toBe('env');
-  });
-
-  test('finds nearest .beads/ui.db walking up', () => {
-    const root = mkdtemp();
-    const nested = path.join(root, 'a', 'b', 'c');
-    fs.mkdirSync(nested, { recursive: true });
-    const beads = path.join(root, '.beads');
-    fs.mkdirSync(beads);
-    const uiDb = path.join(beads, 'ui.db');
-    fs.writeFileSync(uiDb, '');
-
-    const found = findNearestBeadsDb(nested);
-    expect(found).toBe(uiDb);
-
-    const res = resolveDbPath({ cwd: nested, env: {} });
-    expect(res.path).toBe(uiDb);
-    expect(res.source).toBe('nearest');
-  });
-
-  test('falls back to ~/.beads/default.db when none found', async () => {
-    // Mock os.homedir to a deterministic location using spy
-    const home = mkdtemp();
-    const spy = vi.spyOn(os, 'homedir').mockReturnValue(home);
-    const mod = await import('./db.js');
-    const res = mod.resolveDbPath({ cwd: '/no/db/here', env: {} });
-    expect(res.path).toBe(path.join(home, '.beads', 'default.db'));
-    expect(res.source).toBe('home-default');
-    spy.mockRestore();
-  });
-});

package/server/protocol.test.js

@@ -1,87 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import {
-  MESSAGE_TYPES,
-  PROTOCOL_VERSION,
-  decodeReply,
-  decodeRequest,
-  isMessageType,
-  isReply,
-  isRequest,
-  makeError,
-  makeOk,
-  makeRequest
-} from './protocol.js';
-
-describe('server/protocol', () => {
-  test('isMessageType returns true for known type', () => {
-    // execution
-    const res = isMessageType('list-issues');
-
-    // assertion
-    expect(res).toBe(true);
-  });
-
-  test('isMessageType returns false for unknown type', () => {
-    // execution
-    const res = isMessageType('not-a-type');
-
-    // assertion
-    expect(res).toBe(false);
-  });
-
-  test('makeRequest and decodeRequest round-trip', () => {
-    // setup
-    const req = makeRequest('show-issue', { id: 'UI-9' }, 'r-9');
-
-    // execution
-    const decoded = decodeRequest(JSON.parse(JSON.stringify(req)));
-
-    // assertion
-    expect(isRequest(req)).toBe(true);
-    expect(decoded.id).toBe('r-9');
-    expect(decoded.type).toBe('show-issue');
-  });
-
-  test('makeOk and makeError create valid replies', () => {
-    // setup
-    const req = makeRequest('list-issues', undefined, 'r-10');
-
-    // execution
-    const ok = makeOk(req, [{ id: 'UI-1' }]);
-    const err = makeError(req, 'boom', 'Something went wrong');
-
-    // assertion
-    expect(isReply(ok)).toBe(true);
-    expect(isReply(err)).toBe(true);
-    expect(ok.ok).toBe(true);
-    expect(err.ok).toBe(false);
-  });
-
-  test('decodeReply accepts ok and error envelopes', () => {
-    // setup
-    const req = makeRequest('edit-text', { id: 'UI-1', text: 'x' }, 'r-11');
-    const ok = makeOk(req, { id: 'UI-1' });
-    const err = makeError(req, 'validation', 'Invalid');
-
-    // execution
-    const ok2 = decodeReply(JSON.parse(JSON.stringify(ok)));
-    const err2 = decodeReply(JSON.parse(JSON.stringify(err)));
-
-    // assertion
-    expect(ok2.ok).toBe(true);
-    expect(err2.ok).toBe(false);
-  });
-
-  test('invalid envelopes throw on decode', () => {
-    // execution + assertion
-    expect(() => decodeRequest({})).toThrow();
-    expect(() => decodeReply({ ok: true })).toThrow();
-  });
-
-  test('exports protocol constants', () => {
-    // assertion
-    expect(typeof PROTOCOL_VERSION).toBe('string');
-    expect(Array.isArray(MESSAGE_TYPES)).toBe(true);
-    expect(MESSAGE_TYPES.length).toBeGreaterThan(0);
-  });
-});

package/server/watcher.test.js

@@ -1,100 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
-import { watchDb } from './watcher.js';
-
-/** @type {{ dir: string, cb: (event: string, filename?: string) => void, w: { close: () => void } }[]} */
-const watchers = [];
-
-vi.mock('node:fs', () => {
-  const watch = vi.fn((dir, _opts, cb) => {
-    // Minimal event emitter interface for FSWatcher
-    const handlers = /** @type {{ close: Array<() => void> }} */ ({
-      close: []
-    });
-    const w = {
-      close: () => handlers.close.forEach((fn) => fn())
-    };
-    watchers.push({ dir, cb, w });
-    return /** @type {any} */ (w);
-  });
-  return { default: { watch }, watch };
-});
-
-beforeEach(() => {
-  watchers.length = 0;
-  vi.useFakeTimers();
-  vi.spyOn(console, 'warn').mockImplementation(() => {});
-});
-
-afterEach(() => {
-  vi.useRealTimers();
-  vi.restoreAllMocks();
-});
-
-describe('watchDb', () => {
-  test('debounces rapid change events', () => {
-    const calls = [];
-    const handle = watchDb('/repo', (p) => calls.push(p), {
-      debounce_ms: 100,
-      explicit_db: '/repo/.beads/ui.db'
-    });
-    expect(watchers.length).toBe(1);
-    const { cb } = watchers[0];
-
-    // Fire multiple changes in quick succession
-    cb('change', 'ui.db');
-    cb('change', 'ui.db');
-    cb('rename', 'ui.db');
-
-    // Nothing yet until debounce passes
-    expect(calls.length).toBe(0);
-    vi.advanceTimersByTime(99);
-    expect(calls.length).toBe(0);
-    vi.advanceTimersByTime(1);
-    expect(calls.length).toBe(1);
-
-    // Cleanup
-    handle.close();
-  });
-
-  test('ignores other filenames', () => {
-    const calls = [];
-    const handle = watchDb('/repo', (p) => calls.push(p), {
-      debounce_ms: 50,
-      explicit_db: '/repo/.beads/ui.db'
-    });
-    const { cb } = watchers[0];
-    cb('change', 'something-else.db');
-    vi.advanceTimersByTime(60);
-    expect(calls.length).toBe(0);
-    handle.close();
-  });
-
-  test('rebind attaches to new db path', () => {
-    const calls = [];
-    const handle = watchDb('/repo', (p) => calls.push(p), {
-      debounce_ms: 50,
-      explicit_db: '/repo/.beads/ui.db'
-    });
-    expect(watchers.length).toBe(1);
-    const first = watchers[0];
-
-    // Rebind to a different DB path
-    handle.rebind({ explicit_db: '/other/.beads/alt.db' });
-
-    // A new watcher is created
-    expect(watchers.length).toBe(2);
-    const second = watchers[1];
-
-    // Old watcher should ignore new file name
-    first.cb('change', 'ui.db');
-    vi.advanceTimersByTime(60);
-    expect(calls.length).toBe(0);
-
-    // New watcher reacts
-    second.cb('change', 'alt.db');
-    vi.advanceTimersByTime(60);
-    expect(calls.length).toBe(1);
-
-    handle.close();
-  });
-});

package/server/ws.handlers.test.js

@@ -1,174 +0,0 @@
-import { describe, expect, test, vi } from 'vitest';
-import { runBdJson } from './bd.js';
-import { handleMessage } from './ws.js';
-
-vi.mock('./bd.js', () => ({ runBdJson: vi.fn() }));
-
-function makeStubSocket() {
-  return {
-    sent: /** @type {string[]} */ ([]),
-    readyState: 1,
-    OPEN: 1,
-    /** @param {string} msg */
-    send(msg) {
-      this.sent.push(String(msg));
-    }
-  };
-}
-
-describe('ws handlers: list/show', () => {
-  test('list-issues forwards payload from bd', async () => {
-    const mocked = /** @type {import('vitest').Mock} */ (runBdJson);
-    mocked.mockResolvedValueOnce({ code: 0, stdoutJson: [{ id: 'UI-1' }] });
-    const ws = makeStubSocket();
-    const req = {
-      id: 'r1',
-      type: 'list-issues',
-      payload: { filters: { status: 'open' } }
-    };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(true);
-    expect(Array.isArray(obj.payload)).toBe(true);
-  });
-
-  test('list-issues with filters.ready uses bd "ready"', async () => {
-    const mocked = /** @type {import('vitest').Mock} */ (runBdJson);
-    mocked.mockResolvedValueOnce({ code: 0, stdoutJson: [{ id: 'UI-2' }] });
-    const ws = makeStubSocket();
-    const req = {
-      id: 'r1a',
-      type: 'list-issues',
-      payload: { filters: { ready: true } }
-    };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-    // Ensure we called the ready command
-    const call = mocked.mock.calls[mocked.mock.calls.length - 1];
-    expect(Array.isArray(call[0])).toBe(true);
-    expect(call[0][0]).toBe('ready');
-
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(true);
-    expect(Array.isArray(obj.payload)).toBe(true);
-  });
-
-  test('show-issue returns error on missing id', async () => {
-    const ws = makeStubSocket();
-    const req = { id: 'r2', type: 'show-issue', payload: {} };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(false);
-    expect(obj.error.code).toBe('bad_request');
-  });
-
-  test('show-issue forwards bd JSON on success', async () => {
-    const mocked = /** @type {import('vitest').Mock} */ (runBdJson);
-    mocked.mockResolvedValueOnce({
-      code: 0,
-      stdoutJson: { id: 'UI-9', title: 'X' }
-    });
-    const ws = makeStubSocket();
-    const req = { id: 'r3', type: 'show-issue', payload: { id: 'UI-9' } };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(true);
-    expect(obj.payload.id).toBe('UI-9');
-  });
-
-  test('show-issue unwraps single-element arrays from bd', async () => {
-    const mocked = /** @type {import('vitest').Mock} */ (runBdJson);
-    mocked.mockResolvedValueOnce({
-      code: 0,
-      stdoutJson: [{ id: 'UI-9', title: 'X' }]
-    });
-    const ws = makeStubSocket();
-    const req = { id: 'r3a', type: 'show-issue', payload: { id: 'UI-9' } };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(true);
-    expect(obj.payload && obj.payload.id).toBe('UI-9');
-  });
-
-  test('show-issue returns not_found when bd returns empty array', async () => {
-    const mocked = /** @type {import('vitest').Mock} */ (runBdJson);
-    mocked.mockResolvedValueOnce({ code: 0, stdoutJson: [] });
-    const ws = makeStubSocket();
-    const req = { id: 'r3b', type: 'show-issue', payload: { id: 'X' } };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(false);
-    expect(obj.error && obj.error.code).toBe('not_found');
-  });
-
-  test('epic-status forwards bd epic status', async () => {
-    const mocked = /** @type {import('vitest').Mock} */ (runBdJson);
-    mocked.mockResolvedValueOnce({ code: 0, stdoutJson: [] });
-    const ws = makeStubSocket();
-    const req = { id: 're', type: /** @type {any} */ ('epic-status') };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-    const call = mocked.mock.calls[mocked.mock.calls.length - 1];
-    expect(Array.isArray(call[0])).toBe(true);
-    expect(call[0][0]).toBe('epic');
-    expect(call[0][1]).toBe('status');
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(true);
-    expect(Array.isArray(obj.payload)).toBe(true);
-  });
-
-  test('list-issues supports limit passthrough', async () => {
-    const mocked = /** @type {import('vitest').Mock} */ (runBdJson);
-    mocked.mockResolvedValueOnce({ code: 0, stdoutJson: [] });
-    const ws = makeStubSocket();
-    const req = {
-      id: 'rlim',
-      type: 'list-issues',
-      payload: { filters: { status: 'closed', limit: 10 } }
-    };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-    const call = mocked.mock.calls[mocked.mock.calls.length - 1];
-    const args = /** @type {string[]} */ (call[0]);
-    expect(args.includes('--limit')).toBe(true);
-    expect(args.includes('10')).toBe(true);
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(true);
-    expect(Array.isArray(obj.payload)).toBe(true);
-  });
-
-  test('bd error propagates as bd_error reply', async () => {
-    const mocked = /** @type {import('vitest').Mock} */ (runBdJson);
-    mocked.mockResolvedValueOnce({ code: 1, stderr: 'boom' });
-    const ws = makeStubSocket();
-    const req = { id: 'r4', type: 'list-issues', payload: {} };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(false);
-    expect(obj.error.code).toBe('bd_error');
-  });
-});

package/server/ws.labels.test.js

@@ -1,95 +0,0 @@
-import { describe, expect, test, vi } from 'vitest';
-import { runBd, runBdJson } from './bd.js';
-import { handleMessage } from './ws.js';
-
-vi.mock('./bd.js', () => ({
-  runBd: vi.fn(),
-  runBdJson: vi.fn()
-}));
-
-function makeStubSocket() {
-  return {
-    sent: /** @type {string[]} */ ([]),
-    readyState: 1,
-    OPEN: 1,
-    /** @param {string} msg */
-    send(msg) {
-      this.sent.push(String(msg));
-    }
-  };
-}
-
-describe('ws labels handlers', () => {
-  test('label-add validates payload', async () => {
-    const ws = makeStubSocket();
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(
-        JSON.stringify({
-          id: 'x',
-          type: /** @type {any} */ ('label-add'),
-          payload: {}
-        })
-      )
-    );
-    const obj = JSON.parse(ws.sent[0]);
-    expect(obj.ok).toBe(false);
-    expect(obj.error.code).toBe('bad_request');
-  });
-
-  test('label-add runs bd and replies with show', async () => {
-    const rb = /** @type {import('vitest').Mock} */ (runBd);
-    const rj = /** @type {import('vitest').Mock} */ (runBdJson);
-    rb.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
-    rj.mockResolvedValueOnce({
-      code: 0,
-      stdoutJson: { id: 'UI-1', labels: ['frontend'] }
-    });
-
-    const ws = makeStubSocket();
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(
-        JSON.stringify({
-          id: 'a',
-          type: /** @type {any} */ ('label-add'),
-          payload: { id: 'UI-1', label: 'frontend' }
-        })
-      )
-    );
-
-    const call = rb.mock.calls[0][0];
-    expect(call.slice(0, 3)).toEqual(['label', 'add', 'UI-1']);
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(true);
-    expect(obj.payload && obj.payload.id).toBe('UI-1');
-  });
-
-  test('label-remove runs bd and replies with show', async () => {
-    const rb = /** @type {import('vitest').Mock} */ (runBd);
-    const rj = /** @type {import('vitest').Mock} */ (runBdJson);
-    rb.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
-    rj.mockResolvedValueOnce({
-      code: 0,
-      stdoutJson: { id: 'UI-1', labels: [] }
-    });
-
-    const ws = makeStubSocket();
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(
-        JSON.stringify({
-          id: 'b',
-          type: /** @type {any} */ ('label-remove'),
-          payload: { id: 'UI-1', label: 'frontend' }
-        })
-      )
-    );
-
-    const call = rb.mock.calls[rb.mock.calls.length - 1][0];
-    expect(call.slice(0, 3)).toEqual(['label', 'remove', 'UI-1']);
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(true);
-    expect(obj.payload && obj.payload.id).toBe('UI-1');
-  });
-});