@assistkick/create 1.0.0

package/templates/product-system/tests/kanban.test.ts

@@ -0,0 +1,529 @@
+/**
+ * Tests for kanban board server endpoints and data transformations.
+ * Uses node:test built-in runner.
+ */
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createServer } from 'node:http';
+import { randomUUID } from 'node:crypto';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Valid kanban columns — users can move cards between any columns (mirrors server logic)
+const VALID_COLUMNS = ['todo', 'in_progress', 'in_review', 'qa', 'done'];
+
+// In-memory kanban data used by the test server
+let kanbanData;
+
+const INITIAL_KANBAN = () => ({
+  feat_001: { column: 'done', rejection_count: 0, notes: [] },
+  feat_009: { column: 'todo', rejection_count: 0, notes: [] },
+  feat_010: { column: 'done', rejection_count: 0, notes: [] },
+});
+
+const startTestServer = async () => {
+  const sendJson = (res, code, data) => {
+    const body = JSON.stringify(data);
+    res.writeHead(code, { 'Content-Type': 'application/json' });
+    res.end(body);
+  };
+
+  const readBody = (req) => new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on('data', c => chunks.push(c));
+    req.on('end', () => {
+      try { resolve(JSON.parse(Buffer.concat(chunks).toString())); }
+      catch { reject(new Error('Invalid JSON')); }
+    });
+  });
+
+  const handler = async (req, res) => {
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const path = url.pathname;
+    const method = req.method;
+
+    if (method === 'GET' && path === '/api/kanban') {
+      return sendJson(res, 200, kanbanData);
+    }
+
+    const moveMatch = path.match(/^\/api\/kanban\/([a-z_]+\d+)\/move$/);
+    if (method === 'POST' && moveMatch) {
+      const featureId = moveMatch[1];
+      const body = await readBody(req);
+      const entry = kanbanData[featureId];
+      if (!entry) return sendJson(res, 404, { error: 'Not found' });
+      if (!VALID_COLUMNS.includes(body.column)) {
+        return sendJson(res, 400, { error: `Invalid column "${body.column}"` });
+      }
+      if (entry.column === body.column) {
+        return sendJson(res, 400, { error: `Card is already in "${body.column}"` });
+      }
+      const prev = entry.column;
+      entry.column = body.column;
+      if (prev === 'qa' && body.column === 'todo') {
+        entry.rejection_count = (entry.rejection_count || 0) + 1;
+      }
+      return sendJson(res, 200, { feature_id: featureId, previous_column: prev, new_column: body.column, rejection_count: entry.rejection_count || 0 });
+    }
+
+    const notesMatch = path.match(/^\/api\/kanban\/([a-z_]+\d+)\/notes$/);
+    if (method === 'POST' && notesMatch) {
+      const featureId = notesMatch[1];
+      const body = await readBody(req);
+      const entry = kanbanData[featureId];
+      if (!entry) return sendJson(res, 404, { error: 'Not found' });
+      const note = { id: randomUUID().slice(0, 8), text: body.text, created_at: new Date().toISOString(), updated_at: new Date().toISOString() };
+      if (!entry.notes) entry.notes = [];
+      entry.notes.push(note);
+      return sendJson(res, 201, note);
+    }
+
+    const noteMatch = path.match(/^\/api\/kanban\/([a-z_]+\d+)\/notes\/([a-z0-9]+)$/);
+    if (method === 'PUT' && noteMatch) {
+      const [, featureId, noteId] = noteMatch;
+      const body = await readBody(req);
+      const entry = kanbanData[featureId];
+      if (!entry) return sendJson(res, 404, { error: 'Not found' });
+      const note = (entry.notes || []).find(n => n.id === noteId);
+      if (!note) return sendJson(res, 404, { error: 'Note not found' });
+      note.text = body.text;
+      note.updated_at = new Date().toISOString();
+      return sendJson(res, 200, note);
+    }
+
+    if (method === 'DELETE' && noteMatch) {
+      const [, featureId, noteId] = noteMatch;
+      const entry = kanbanData[featureId];
+      if (!entry) return sendJson(res, 404, { error: 'Not found' });
+      const idx = (entry.notes || []).findIndex(n => n.id === noteId);
+      if (idx === -1) return sendJson(res, 404, { error: 'Note not found' });
+      entry.notes.splice(idx, 1);
+      return sendJson(res, 200, { deleted: true });
+    }
+
+    sendJson(res, 404, { error: 'Not found' });
+  };
+
+  const server = createServer(handler);
+  await new Promise(resolve => server.listen(0, resolve));
+  return { server, baseUrl: `http://localhost:${server.address().port}` };
+};
+
+describe('Kanban API', () => {
+  let server, baseUrl;
+
+  beforeEach(async () => {
+    kanbanData = INITIAL_KANBAN();
+    const s = await startTestServer();
+    server = s.server;
+    baseUrl = s.baseUrl;
+  });
+
+  afterEach(async () => {
+    server.close();
+  });
+
+  it('GET /api/kanban returns kanban data', async () => {
+    const resp = await fetch(`${baseUrl}/api/kanban`);
+    assert.equal(resp.status, 200);
+    const data = await resp.json();
+    assert.ok(typeof data === 'object');
+    assert.ok('feat_001' in data);
+  });
+
+  it('POST /api/kanban/:id/move — valid in_review→qa transition', async () => {
+    // Set feat_009 to in_review for this test
+    kanbanData.feat_009.column = 'in_review';
+
+    const resp = await fetch(`${baseUrl}/api/kanban/feat_009/move`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ column: 'qa' }),
+    });
+    assert.equal(resp.status, 200);
+    const data = await resp.json();
+    assert.equal(data.previous_column, 'in_review');
+    assert.equal(data.new_column, 'qa');
+  });
+
+  it('POST /api/kanban/:id/move — rejects move to same column', async () => {
+    // feat_010 is in 'done', moving to 'done' should be rejected
+    const resp = await fetch(`${baseUrl}/api/kanban/feat_010/move`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ column: 'done' }),
+    });
+    assert.equal(resp.status, 400);
+    const data = await resp.json();
+    assert.ok(data.error.includes('already in'));
+  });
+
+  it('POST /api/kanban/:id/move — rejects invalid column name', async () => {
+    const resp = await fetch(`${baseUrl}/api/kanban/feat_010/move`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ column: 'nonexistent' }),
+    });
+    assert.equal(resp.status, 400);
+    const data = await resp.json();
+    assert.ok(data.error.includes('Invalid column'));
+  });
+
+  it('POST /api/kanban/:id/move — allows free-form transitions (done→todo)', async () => {
+    const resp = await fetch(`${baseUrl}/api/kanban/feat_010/move`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ column: 'todo' }),
+    });
+    assert.equal(resp.status, 200);
+    const data = await resp.json();
+    assert.equal(data.previous_column, 'done');
+    assert.equal(data.new_column, 'todo');
+  });
+
+  it('POST /api/kanban/:id/move — qa→todo increments rejection_count', async () => {
+    // Set feat_009 to qa with rejection_count 2
+    kanbanData.feat_009.column = 'qa';
+    kanbanData.feat_009.rejection_count = 2;
+
+    const resp = await fetch(`${baseUrl}/api/kanban/feat_009/move`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ column: 'todo' }),
+    });
+    assert.equal(resp.status, 200);
+    const data = await resp.json();
+    assert.equal(data.rejection_count, 3);
+  });
+
+  it('POST /api/kanban/:id/notes — creates a rejection note', async () => {
+    const resp = await fetch(`${baseUrl}/api/kanban/feat_009/notes`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ text: 'Missing edge case handling' }),
+    });
+    assert.equal(resp.status, 201);
+    const note = await resp.json();
+    assert.ok(note.id);
+    assert.equal(note.text, 'Missing edge case handling');
+    assert.ok(note.created_at);
+
+    // Verify it persisted in memory
+    assert.equal(kanbanData.feat_009.notes.length, 1);
+    assert.equal(kanbanData.feat_009.notes[0].text, 'Missing edge case handling');
+  });
+
+  it('PUT /api/kanban/:id/notes/:nid — updates a note', async () => {
+    // Create a note first
+    const createResp = await fetch(`${baseUrl}/api/kanban/feat_009/notes`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ text: 'Original text' }),
+    });
+    const created = await createResp.json();
+
+    const resp = await fetch(`${baseUrl}/api/kanban/feat_009/notes/${created.id}`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ text: 'Updated text' }),
+    });
+    assert.equal(resp.status, 200);
+    const updated = await resp.json();
+    assert.equal(updated.text, 'Updated text');
+  });
+
+  it('DELETE /api/kanban/:id/notes/:nid — deletes a note', async () => {
+    // Create a note first
+    const createResp = await fetch(`${baseUrl}/api/kanban/feat_009/notes`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ text: 'To be deleted' }),
+    });
+    const created = await createResp.json();
+
+    const resp = await fetch(`${baseUrl}/api/kanban/feat_009/notes/${created.id}`, {
+      method: 'DELETE',
+    });
+    assert.equal(resp.status, 200);
+
+    // Verify deletion
+    assert.equal(kanbanData.feat_009.notes.length, 0);
+  });
+
+  it('returns 404 for non-existent feature', async () => {
+    const resp = await fetch(`${baseUrl}/api/kanban/feat_999/move`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ column: 'done' }),
+    });
+    assert.equal(resp.status, 404);
+  });
+});
+
+describe('Kanban data transformations', () => {
+  it('includes all feature nodes regardless of spec status', () => {
+    const nodes = [
+      { id: 'feat_001', type: 'feature', status: 'defined' },
+      { id: 'feat_002', type: 'feature', status: 'draft' },
+      { id: 'feat_003', type: 'feature', status: 'partially_defined' },
+      { id: 'comp_001', type: 'component', status: 'defined' },
+    ];
+    const features = nodes.filter(n => n.type === 'feature');
+    assert.equal(features.length, 3);
+    assert.deepEqual(features.map(f => f.id), ['feat_001', 'feat_002', 'feat_003']);
+  });
+
+  it('groups cards by column', () => {
+    const kanban = {
+      feat_001: { column: 'done' },
+      feat_002: { column: 'todo' },
+      feat_003: { column: 'todo' },
+      feat_004: { column: 'in_progress' },
+    };
+    const grouped = {};
+    Object.entries(kanban).forEach(([id, entry]) => {
+      if (!grouped[entry.column]) grouped[entry.column] = [];
+      grouped[entry.column].push(id);
+    });
+    assert.equal(grouped.todo.length, 2);
+    assert.equal(grouped.done.length, 1);
+    assert.equal(grouped.in_progress.length, 1);
+  });
+
+  it('validates user transitions — free-form between any different columns', () => {
+    const isValidUserTransition = (from, to) => {
+      return VALID_COLUMNS.includes(from) && VALID_COLUMNS.includes(to) && from !== to;
+    };
+
+    // All cross-column moves are valid for users
+    assert.ok(isValidUserTransition('in_review', 'qa'));
+    assert.ok(isValidUserTransition('qa', 'done'));
+    assert.ok(isValidUserTransition('qa', 'todo'));
+    assert.ok(isValidUserTransition('todo', 'in_progress'));
+    assert.ok(isValidUserTransition('todo', 'done'));
+    assert.ok(isValidUserTransition('done', 'todo'));
+    assert.ok(isValidUserTransition('in_progress', 'qa'));
+
+    // Same column is not valid
+    assert.ok(!isValidUserTransition('todo', 'todo'));
+    assert.ok(!isValidUserTransition('done', 'done'));
+
+    // Invalid column names are not valid
+    assert.ok(!isValidUserTransition('todo', 'nonexistent'));
+    assert.ok(!isValidUserTransition('nonexistent', 'todo'));
+  });
+
+  it('identifies problematic cards (3+ rejections)', () => {
+    const cards = [
+      { id: 'feat_001', rejectionCount: 0 },
+      { id: 'feat_002', rejectionCount: 2 },
+      { id: 'feat_003', rejectionCount: 3 },
+      { id: 'feat_004', rejectionCount: 5 },
+    ];
+    const problematic = cards.filter(c => c.rejectionCount >= 3);
+    assert.equal(problematic.length, 2);
+    assert.deepEqual(problematic.map(c => c.id), ['feat_003', 'feat_004']);
+  });
+});
+
+describe('Retry attempt label (feat_025)', () => {
+  const PIPELINE_STATUS_LABELS = {
+    creating_worktree: 'Setting up...',
+    developing: 'Developing',
+    reviewing: 'Reviewing',
+    fixing_review: 'Fixing review',
+    fixing_merge: 'Fixing merge',
+    merging: 'Merging',
+    completed: 'Completed',
+    failed: 'Failed',
+    blocked: 'Blocked',
+  };
+
+  // Mirror the helper from kanban_renderer.js
+  const getPipelineBadgeText = (pipelineStatus, rejectionCount) => {
+    const label = PIPELINE_STATUS_LABELS[pipelineStatus] || pipelineStatus;
+    if (rejectionCount >= 1) {
+      return `Retry ${rejectionCount + 1}`;
+    }
+    return label;
+  };
+
+  it('first attempt (rejection_count=0) shows status label only', () => {
+    assert.equal(getPipelineBadgeText('developing', 0), 'Developing');
+    assert.equal(getPipelineBadgeText('reviewing', 0), 'Reviewing');
+    assert.equal(getPipelineBadgeText('merging', 0), 'Merging');
+  });
+
+  it('second attempt (rejection_count=1) shows "Retry 2"', () => {
+    assert.equal(getPipelineBadgeText('developing', 1), 'Retry 2');
+    assert.equal(getPipelineBadgeText('reviewing', 1), 'Retry 2');
+  });
+
+  it('third attempt (rejection_count=2) shows "Retry 3"', () => {
+    assert.equal(getPipelineBadgeText('developing', 2), 'Retry 3');
+  });
+
+  it('higher rejection counts continue the pattern', () => {
+    assert.equal(getPipelineBadgeText('developing', 5), 'Retry 6');
+  });
+
+  it('does not include (N/M) format', () => {
+    const text = getPipelineBadgeText('developing', 0);
+    assert.ok(!text.includes('/'), 'Should not contain slash');
+    assert.ok(!text.includes('('), 'Should not contain parenthesis');
+
+    const retryText = getPipelineBadgeText('developing', 2);
+    assert.ok(!retryText.includes('/'), 'Retry text should not contain slash');
+    assert.ok(!retryText.includes('('), 'Retry text should not contain parenthesis');
+  });
+
+  it('handles unknown pipeline status gracefully', () => {
+    assert.equal(getPipelineBadgeText('some_new_status', 0), 'some_new_status');
+    assert.equal(getPipelineBadgeText('some_new_status', 1), 'Retry 2');
+  });
+});
+
+describe('Kanban Card Copy Button (feat_038)', () => {
+  // Mirror the copy text format from kanban_renderer.js
+  const getCopyText = (cardId, cardName) => `${cardId} ${cardName}`;
+
+  it('formats copy text as "feat_XXX Feature Name"', () => {
+    assert.equal(getCopyText('feat_001', 'Node CRUD Operations'), 'feat_001 Node CRUD Operations');
+    assert.equal(getCopyText('feat_021', 'Kanban Board View'), 'feat_021 Kanban Board View');
+  });
+
+  it('handles feature names with special characters', () => {
+    assert.equal(
+      getCopyText('feat_033', 'Test Bug'),
+      'feat_033 Test Bug'
+    );
+    assert.equal(
+      getCopyText('feat_037', 'Fix: Graph Settings Not Persisted and Labels Reset on Clear Selection'),
+      'feat_037 Fix: Graph Settings Not Persisted and Labels Reset on Clear Selection'
+    );
+  });
+
+  it('copy button element is created with correct attributes', () => {
+    // Simulate the card data structure used by buildCard
+    const card = {
+      id: 'feat_038',
+      name: 'Kanban Card Copy Button',
+      completeness: 0.8,
+      kind: 'new',
+      rejectionCount: 0,
+      notes: [],
+      column: 'in_progress',
+      devBlocked: false,
+    };
+
+    // Verify the copy text is correctly assembled from card properties
+    const copyText = `${card.id} ${card.name}`;
+    assert.equal(copyText, 'feat_038 Kanban Card Copy Button');
+    assert.ok(copyText.startsWith('feat_'));
+    assert.ok(copyText.includes(' '));
+    // The text should have exactly one space between id and name
+    const parts = copyText.split(' ');
+    assert.equal(parts[0], 'feat_038');
+    assert.equal(parts.slice(1).join(' '), 'Kanban Card Copy Button');
+  });
+});
+
+describe('All Features on Kanban Board (feat_036)', () => {
+  it('TODO column sorts by completeness descending', () => {
+    const cards = [
+      { id: 'feat_001', completeness: 0.3, column: 'todo' },
+      { id: 'feat_002', completeness: 0.9, column: 'todo' },
+      { id: 'feat_003', completeness: 0.5, column: 'todo' },
+    ];
+    cards.sort((a, b) => (b.completeness || 0) - (a.completeness || 0));
+    assert.deepEqual(cards.map(c => c.id), ['feat_002', 'feat_003', 'feat_001']);
+  });
+
+  it('Done column sorts by moved_at descending (newest first)', () => {
+    const cards = [
+      { id: 'feat_001', movedAt: '2026-02-27T10:00:00.000Z' },
+      { id: 'feat_003', movedAt: '2026-02-27T12:00:00.000Z' },
+      { id: 'feat_002', movedAt: '2026-02-27T11:00:00.000Z' },
+    ];
+    // Done column sort: descending by moved_at
+    cards.sort((a, b) => {
+      const aTime = a.movedAt || '';
+      const bTime = b.movedAt || '';
+      return bTime.localeCompare(aTime);
+    });
+    assert.deepEqual(cards.map(c => c.id), ['feat_003', 'feat_002', 'feat_001']);
+  });
+
+  it('non-TODO/non-Done columns sort by moved_at timestamp chronologically', () => {
+    const cards = [
+      { id: 'feat_003', movedAt: '2026-02-27T12:00:00.000Z' },
+      { id: 'feat_001', movedAt: '2026-02-27T10:00:00.000Z' },
+      { id: 'feat_002', movedAt: '2026-02-27T11:00:00.000Z' },
+    ];
+    cards.sort((a, b) => {
+      const aTime = a.movedAt || '';
+      const bTime = b.movedAt || '';
+      return aTime.localeCompare(bTime);
+    });
+    assert.deepEqual(cards.map(c => c.id), ['feat_001', 'feat_002', 'feat_003']);
+  });
+
+  it('cards without moved_at sort before cards with moved_at', () => {
+    const cards = [
+      { id: 'feat_002', movedAt: '2026-02-27T12:00:00.000Z' },
+      { id: 'feat_001', movedAt: null },
+      { id: 'feat_003', movedAt: '2026-02-27T10:00:00.000Z' },
+    ];
+    cards.sort((a, b) => {
+      const aTime = a.movedAt || '';
+      const bTime = b.movedAt || '';
+      return aTime.localeCompare(bTime);
+    });
+    assert.deepEqual(cards.map(c => c.id), ['feat_001', 'feat_003', 'feat_002']);
+  });
+
+  it('auto-adds missing features to TODO column with moved_at', () => {
+    const graphNodes = [
+      { id: 'feat_001', type: 'feature', created_at: '2026-01-01T00:00:00.000Z' },
+      { id: 'feat_002', type: 'feature', created_at: '2026-01-02T00:00:00.000Z' },
+      { id: 'feat_003', type: 'feature', created_at: '2026-01-03T00:00:00.000Z' },
+      { id: 'comp_001', type: 'component' },
+    ];
+    const kanban = {
+      feat_001: { column: 'done', rejection_count: 0, notes: [] },
+    };
+
+    // Simulate auto-add logic
+    const featureNodes = graphNodes.filter(n => n.type === 'feature');
+    for (const node of featureNodes) {
+      if (!kanban[node.id]) {
+        kanban[node.id] = {
+          column: 'todo',
+          rejection_count: 0,
+          notes: [],
+          moved_at: node.created_at || new Date().toISOString(),
+        };
+      }
+    }
+
+    assert.equal(Object.keys(kanban).length, 3);
+    assert.equal(kanban.feat_002.column, 'todo');
+    assert.equal(kanban.feat_002.moved_at, '2026-01-02T00:00:00.000Z');
+    assert.equal(kanban.feat_003.column, 'todo');
+    assert.ok(!kanban.comp_001); // components excluded
+  });
+
+  it('move card sets moved_at timestamp', () => {
+    const entry = { column: 'todo', rejection_count: 0, notes: [] };
+    const before = new Date().toISOString();
+    entry.column = 'in_progress';
+    entry.moved_at = new Date().toISOString();
+    const after = new Date().toISOString();
+
+    assert.equal(entry.column, 'in_progress');
+    assert.ok(entry.moved_at >= before);
+    assert.ok(entry.moved_at <= after);
+  });
+});

package/templates/product-system/tests/neighborhood_focus.test.ts

@@ -0,0 +1,132 @@
+/**
+ * Tests for Neighborhood Focus Mode (feat_012).
+ * Uses node:test built-in runner.
+ * Tests the neighbor identification logic that drives
+ * the focus mode highlighting behavior.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+const createRenderer = (links: any[] = []) => {
+  return {
+    links,
+    getNeighborIds(nodeId: string) {
+      const neighbors = new Set<string>();
+      if (!this.links) return neighbors;
+      for (const link of this.links) {
+        const sourceId = typeof link.source === 'object' ? link.source.id : link.source;
+        const targetId = typeof link.target === 'object' ? link.target.id : link.target;
+        if (sourceId === nodeId) neighbors.add(targetId);
+        if (targetId === nodeId) neighbors.add(sourceId);
+      }
+      return neighbors;
+    },
+  };
+};
+
+describe('Neighborhood Focus Mode', () => {
+
+  describe('getNeighborIds', () => {
+
+    it('returns direct neighbors from outgoing edges', () => {
+      const renderer = createRenderer([
+        { source: 'A', target: 'B', relation: 'contains' },
+        { source: 'A', target: 'C', relation: 'depends_on' },
+      ]);
+      const neighbors = renderer.getNeighborIds('A');
+      assert.deepEqual(neighbors, new Set(['B', 'C']));
+    });
+
+    it('returns direct neighbors from incoming edges', () => {
+      const renderer = createRenderer([
+        { source: 'B', target: 'A', relation: 'contains' },
+        { source: 'C', target: 'A', relation: 'depends_on' },
+      ]);
+      const neighbors = renderer.getNeighborIds('A');
+      assert.deepEqual(neighbors, new Set(['B', 'C']));
+    });
+
+    it('returns neighbors from both incoming and outgoing edges', () => {
+      const renderer = createRenderer([
+        { source: 'A', target: 'B', relation: 'contains' },
+        { source: 'C', target: 'A', relation: 'depends_on' },
+      ]);
+      const neighbors = renderer.getNeighborIds('A');
+      assert.deepEqual(neighbors, new Set(['B', 'C']));
+    });
+
+    it('does not include non-neighbor nodes', () => {
+      const renderer = createRenderer([
+        { source: 'A', target: 'B', relation: 'contains' },
+        { source: 'C', target: 'D', relation: 'depends_on' },
+      ]);
+      const neighbors = renderer.getNeighborIds('A');
+      assert.equal(neighbors.has('B'), true);
+      assert.equal(neighbors.has('C'), false);
+      assert.equal(neighbors.has('D'), false);
+    });
+
+    it('does not include the node itself', () => {
+      const renderer = createRenderer([
+        { source: 'A', target: 'B', relation: 'contains' },
+      ]);
+      const neighbors = renderer.getNeighborIds('A');
+      assert.equal(neighbors.has('A'), false);
+    });
+
+    it('returns empty set for isolated node with no edges', () => {
+      const renderer = createRenderer([
+        { source: 'B', target: 'C', relation: 'contains' },
+      ]);
+      const neighbors = renderer.getNeighborIds('A');
+      assert.equal(neighbors.size, 0);
+    });
+
+    it('returns empty set when links is null', () => {
+      const renderer = createRenderer(null);
+      const neighbors = renderer.getNeighborIds('A');
+      assert.equal(neighbors.size, 0);
+    });
+
+    it('handles D3 object-style link references', () => {
+      const renderer = createRenderer([
+        { source: { id: 'A' }, target: { id: 'B' }, relation: 'contains' },
+        { source: { id: 'C' }, target: { id: 'A' }, relation: 'depends_on' },
+      ]);
+      const neighbors = renderer.getNeighborIds('A');
+      assert.deepEqual(neighbors, new Set(['B', 'C']));
+    });
+
+    it('deduplicates when multiple edges connect same neighbor', () => {
+      const renderer = createRenderer([
+        { source: 'A', target: 'B', relation: 'contains' },
+        { source: 'A', target: 'B', relation: 'depends_on' },
+      ]);
+      const neighbors = renderer.getNeighborIds('A');
+      assert.equal(neighbors.size, 1);
+      assert.equal(neighbors.has('B'), true);
+    });
+
+    it('finds all neighbors in a hub topology', () => {
+      const renderer = createRenderer([
+        { source: 'hub', target: 'spoke1', relation: 'contains' },
+        { source: 'hub', target: 'spoke2', relation: 'contains' },
+        { source: 'hub', target: 'spoke3', relation: 'contains' },
+        { source: 'spoke4', target: 'hub', relation: 'depends_on' },
+      ]);
+      const neighbors = renderer.getNeighborIds('hub');
+      assert.deepEqual(neighbors, new Set(['spoke1', 'spoke2', 'spoke3', 'spoke4']));
+    });
+
+    it('does not include second-degree neighbors', () => {
+      const renderer = createRenderer([
+        { source: 'A', target: 'B', relation: 'contains' },
+        { source: 'B', target: 'C', relation: 'contains' },
+        { source: 'C', target: 'D', relation: 'contains' },
+      ]);
+      const neighbors = renderer.getNeighborIds('A');
+      assert.equal(neighbors.has('B'), true);
+      assert.equal(neighbors.has('C'), false, 'second-degree neighbor C should not be included');
+      assert.equal(neighbors.has('D'), false, 'third-degree neighbor D should not be included');
+    });
+  });
+});