beads-ui 0.1.0

package/server/ws.labels.test.js

@@ -0,0 +1,95 @@
+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');
+  });
+});

package/server/ws.mutations.test.js

@@ -0,0 +1,261 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { runBd, runBdJson } from './bd.js';
+import { handleMessage } from './ws.js';
+
+vi.mock('./bd.js', () => ({ runBdJson: vi.fn(), runBd: vi.fn() }));
+
+// Ensure clean mock state for each test
+beforeEach(() => {
+  /** @type {import('vitest').Mock} */ (runBd).mockReset();
+  /** @type {import('vitest').Mock} */ (runBdJson).mockReset();
+});
+
+function makeStubSocket() {
+  return {
+    sent: /** @type {string[]} */ ([]),
+    readyState: 1,
+    OPEN: 1,
+    /** @param {string} msg */
+    send(msg) {
+      this.sent.push(String(msg));
+    }
+  };
+}
+
+describe('ws mutation handlers', () => {
+  test('update-status validates and returns updated issue', async () => {
+    const mRun = /** @type {import('vitest').Mock} */ (runBd);
+    const mJson = /** @type {import('vitest').Mock} */ (runBdJson);
+    mRun.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
+    mJson.mockResolvedValueOnce({
+      code: 0,
+      stdoutJson: { id: 'UI-7', status: 'in_progress' }
+    });
+    const ws = makeStubSocket();
+    const req = {
+      id: 'r1',
+      type: 'update-status',
+      payload: { id: 'UI-7', status: 'in_progress' }
+    };
+    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.status).toBe('in_progress');
+  });
+
+  test('update-status invalid payload yields bad_request', async () => {
+    const ws = makeStubSocket();
+    const req = {
+      id: 'r2',
+      type: 'update-status',
+      payload: { id: 'UI-7', status: 'bogus' }
+    };
+    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('update-priority success path', async () => {
+    const mRun = /** @type {import('vitest').Mock} */ (runBd);
+    const mJson = /** @type {import('vitest').Mock} */ (runBdJson);
+    mRun.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
+    mJson.mockResolvedValueOnce({
+      code: 0,
+      stdoutJson: { id: 'UI-7', priority: 1 }
+    });
+    const ws = makeStubSocket();
+    const req = {
+      id: 'r3',
+      type: 'update-priority',
+      payload: { id: 'UI-7', priority: 1 }
+    };
+    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.priority).toBe(1);
+  });
+
+  test('edit-text title success', async () => {
+    const mRun = /** @type {import('vitest').Mock} */ (runBd);
+    const mJson = /** @type {import('vitest').Mock} */ (runBdJson);
+    mRun.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
+    mJson.mockResolvedValueOnce({
+      code: 0,
+      stdoutJson: { id: 'UI-7', title: 'New' }
+    });
+    const ws = makeStubSocket();
+    const req = {
+      id: 'r4',
+      type: 'edit-text',
+      payload: { id: 'UI-7', field: 'title', value: 'New' }
+    };
+    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.title).toBe('New');
+  });
+
+  // update-type removed; no server handler remains
+
+  test('update-assignee validates and returns updated issue', async () => {
+    const mRun = /** @type {import('vitest').Mock} */ (runBd);
+    const mJson = /** @type {import('vitest').Mock} */ (runBdJson);
+    mRun.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
+    mJson.mockResolvedValueOnce({ code: 0, stdoutJson: { id: 'UI-2' } });
+    const ws = makeStubSocket();
+    const req = {
+      id: 'rua',
+      type: /** @type {any} */ ('update-assignee'),
+      payload: { id: 'UI-2', assignee: 'max' }
+    };
+    await handleMessage(
+      /** @type {any} */ (ws),
+      Buffer.from(JSON.stringify(req))
+    );
+    const call = mRun.mock.calls[mRun.mock.calls.length - 1];
+    expect(call[0][0]).toBe('update');
+    expect(call[0].includes('--assignee')).toBe(true);
+    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
+    expect(obj.ok).toBe(true);
+    expect(obj.payload.id).toBe('UI-2');
+  });
+
+  test('update-assignee allows clearing with empty string', async () => {
+    const mRun = /** @type {import('vitest').Mock} */ (runBd);
+    const mJson = /** @type {import('vitest').Mock} */ (runBdJson);
+    mRun.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
+    mJson.mockResolvedValueOnce({ code: 0, stdoutJson: { id: 'UI-31' } });
+    const ws = makeStubSocket();
+    const req = {
+      id: 'rua2',
+      type: /** @type {any} */ ('update-assignee'),
+      payload: { id: 'UI-31', assignee: '' }
+    };
+    await handleMessage(
+      /** @type {any} */ (ws),
+      Buffer.from(JSON.stringify(req))
+    );
+    const call = mRun.mock.calls[mRun.mock.calls.length - 1];
+    expect(call[0]).toEqual(['update', 'UI-31', '--assignee', '']);
+    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
+    expect(obj.ok).toBe(true);
+    expect(obj.payload.id).toBe('UI-31');
+  });
+
+  test('edit-text acceptance success', async () => {
+    const mRun = /** @type {import('vitest').Mock} */ (runBd);
+    const mJson = /** @type {import('vitest').Mock} */ (runBdJson);
+    mRun.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
+    mJson.mockResolvedValueOnce({
+      code: 0,
+      stdoutJson: { id: 'UI-7', acceptance: 'Done when...' }
+    });
+    const ws = makeStubSocket();
+    const req = {
+      id: 'r4a',
+      type: 'edit-text',
+      payload: { id: 'UI-7', field: 'acceptance', value: 'Done when...' }
+    };
+    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.acceptance).toBe('Done when...');
+    // Verify correct flag mapping for acceptance
+    expect(mRun.mock.calls[0][0]).toEqual([
+      'update',
+      'UI-7',
+      '--acceptance-criteria',
+      'Done when...'
+    ]);
+  });
+
+  test('edit-text description yields bd_error (unsupported)', async () => {
+    const ws = makeStubSocket();
+    const req = {
+      id: 'r4b',
+      type: 'edit-text',
+      payload: { id: 'UI-7', field: 'description', value: 'New desc' }
+    };
+    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');
+  });
+
+  test('dep-add returns updated issue (view_id)', async () => {
+    const mRun = /** @type {import('vitest').Mock} */ (runBd);
+    const mJson = /** @type {import('vitest').Mock} */ (runBdJson);
+    mRun.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
+    mJson.mockResolvedValueOnce({
+      code: 0,
+      stdoutJson: { id: 'UI-7', dependencies: [] }
+    });
+    const ws = makeStubSocket();
+    const req = {
+      id: 'r5',
+      type: 'dep-add',
+      payload: { a: 'UI-7', b: 'UI-1', view_id: 'UI-7' }
+    };
+    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-7');
+  });
+
+  test('dep-remove bad payload yields bad_request', async () => {
+    const ws = makeStubSocket();
+    const req = { id: 'r6', type: 'dep-remove', payload: { a: '' } };
+    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('create-issue acks on success', async () => {
+    const mRun = /** @type {import('vitest').Mock} */ (runBd);
+    mRun.mockResolvedValueOnce({ code: 0, stdout: 'UI-99', stderr: '' });
+    const ws = makeStubSocket();
+    const req = {
+      id: 'r7',
+      type: 'create-issue',
+      payload: {
+        title: 'New item',
+        type: 'task',
+        priority: 2,
+        description: '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(true);
+    expect(obj.payload && obj.payload.created).toBe(true);
+  });
+});

package/server/ws.subscriptions.test.js

@@ -0,0 +1,116 @@
+import { createServer } from 'node:http';
+import { describe, expect, test, vi } from 'vitest';
+import { runBdJson } from './bd.js';
+import { attachWsServer, handleMessage, notifyIssuesChanged } from './ws.js';
+
+vi.mock('./bd.js', () => ({ runBdJson: vi.fn(), runBd: vi.fn() }));
+
+describe('ws subscriptions + targeted fanout', () => {
+  test('subscribe-updates ack and targeted issues-changed by show id', async () => {
+    const mJson = /** @type {import('vitest').Mock} */ (runBdJson);
+    // show-issue → return object with id
+    mJson.mockImplementation(async (args) => {
+      if (Array.isArray(args) && args[0] === 'show') {
+        return { code: 0, stdoutJson: { id: String(args[1]), status: 'open' } };
+      }
+      return { code: 0, stdoutJson: [] };
+    });
+
+    // Create an http server object but do not listen; just to satisfy attachWsServer
+    const server = createServer();
+    const { wss } = attachWsServer(server, {
+      path: '/ws',
+      heartbeat_ms: 10000
+    });
+
+    // Create two stub sockets and register them as connected clients
+    const a = {
+      sent: /** @type {string[]} */ ([]),
+      readyState: 1,
+      OPEN: 1,
+      /** @param {string} msg */
+      send(msg) {
+        this.sent.push(String(msg));
+      }
+    };
+    const b = {
+      sent: /** @type {string[]} */ ([]),
+      readyState: 1,
+      OPEN: 1,
+      /** @param {string} msg */
+      send(msg) {
+        this.sent.push(String(msg));
+      }
+    };
+    wss.clients.add(/** @type {any} */ (a));
+    wss.clients.add(/** @type {any} */ (b));
+
+    // Subscribe both and set show-issue for A
+    await handleMessage(
+      /** @type {any} */ (a),
+      Buffer.from(JSON.stringify({ id: 's1', type: 'subscribe-updates' }))
+    );
+    await handleMessage(
+      /** @type {any} */ (b),
+      Buffer.from(JSON.stringify({ id: 's2', type: 'subscribe-updates' }))
+    );
+    await handleMessage(
+      /** @type {any} */ (a),
+      Buffer.from(
+        JSON.stringify({
+          id: 'q1',
+          type: 'show-issue',
+          payload: { id: 'UI-1' }
+        })
+      )
+    );
+
+    // Now emit a targeted change for UI-1
+    notifyIssuesChanged(
+      { hint: { ids: ['UI-1'] } },
+      { issue: { id: 'UI-1', status: 'open' } }
+    );
+
+    const aHas = a.sent.some((m) => {
+      try {
+        const o = JSON.parse(m);
+        return o && o.type === 'issues-changed';
+      } catch {
+        return false;
+      }
+    });
+    const bHas = b.sent.some((m) => {
+      try {
+        const o = JSON.parse(m);
+        return o && o.type === 'issues-changed';
+      } catch {
+        return false;
+      }
+    });
+
+    expect(aHas).toBe(true);
+    expect(bHas).toBe(false);
+  });
+
+  test('subscribe-updates handler replies ok for bare ws', async () => {
+    const ws = {
+      sent: /** @type {string[]} */ ([]),
+      readyState: 1,
+      OPEN: 1,
+      /** @param {string} msg */
+      send(msg) {
+        this.sent.push(String(msg));
+      }
+    };
+    const req = { id: 'sub1', type: 'subscribe-updates', payload: {} };
+    await handleMessage(
+      /** @type {any} */ (ws),
+      Buffer.from(JSON.stringify(req))
+    );
+    const last = ws.sent[ws.sent.length - 1];
+    const obj = JSON.parse(last);
+    expect(obj.ok).toBe(true);
+    expect(obj.type).toBe('subscribe-updates');
+    expect(obj.payload && obj.payload.subscribed).toBe(true);
+  });
+});

package/server/ws.test.js

@@ -0,0 +1,52 @@
+import { describe, expect, test, vi } from 'vitest';
+import { handleMessage } from './ws.js';
+
+/** @returns {any} */
+function makeStubSocket() {
+  return {
+    sent: /** @type {string[]} */ ([]),
+    readyState: 1,
+    OPEN: 1,
+    /** @param {string} msg */
+    send(msg) {
+      this.sent.push(String(msg));
+    },
+    ping: vi.fn(),
+    terminate: vi.fn()
+  };
+}
+
+describe('ws message handling', () => {
+  test('invalid JSON yields bad_json error', () => {
+    const ws = makeStubSocket();
+    handleMessage(/** @type {any} */ (ws), Buffer.from('{oops'));
+    expect(ws.sent.length).toBe(1);
+    const obj = JSON.parse(ws.sent[0]);
+    expect(obj.ok).toBe(false);
+    expect(obj.error.code).toBe('bad_json');
+  });
+
+  test('invalid envelope yields bad_request', () => {
+    const ws = makeStubSocket();
+    handleMessage(
+      /** @type {any} */ (ws),
+      Buffer.from(JSON.stringify({ not: 'a request' }))
+    );
+    const last = ws.sent[ws.sent.length - 1];
+    const obj = JSON.parse(last);
+    expect(obj.ok).toBe(false);
+    expect(obj.error.code).toBe('bad_request');
+  });
+
+  test('unknown message type returns unknown_type error', () => {
+    const ws = makeStubSocket();
+    const req = { id: '1', type: 'some-unknown', payload: {} };
+    handleMessage(/** @type {any} */ (ws), Buffer.from(JSON.stringify(req)));
+    const last = ws.sent[ws.sent.length - 1];
+    const obj = JSON.parse(last);
+    expect(obj.ok).toBe(false);
+    expect(obj.error.code).toBe('unknown_type');
+  });
+});
+
+// Note: broadcast behavior is integration-tested later when a full server can run.

package/test/setup-vitest.js

@@ -0,0 +1,12 @@
+/* global console */
+// Suppress Lit dev-mode warning in Vitest
+// Provided snippet: overrides console.warn but forwards all other messages
+const { warn } = console;
+console.warn = /** @type {function(...*): void} */ (
+  (...args) => {
+    // Filter out the noisy Lit dev-mode banner in tests
+    if (!args[0].startsWith('Lit is in dev mode.')) {
+      warn.call(console, ...args);
+    }
+  }
+);

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "allowJs": true,
+    "checkJs": true,
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "lib": ["ES2022", "DOM"],
+    "types": ["vitest/globals", "node"]
+  },
+  "include": [
+    "app/**/*.js",
+    "server/**/*.js",
+    "test/**/*.js",
+    "vitest.config.mjs"
+  ]
+}

package/vitest.config.mjs

@@ -0,0 +1,14 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    include: ['**/*.test.js'],
+    setupFiles: ['test/setup-vitest.js'],
+    environmentMatchGlobs: [['app/**/*.test.js', 'jsdom']],
+    reporters: 'default',
+    coverage: {
+      reporter: ['text', 'html']
+    }
+  }
+});