@assistkick/create 1.0.0

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

@@ -0,0 +1,147 @@
+/**
+ * Tests for Edge Type Color Coding (feat_016).
+ * Uses node:test built-in runner.
+ * Tests that each relation type has a distinct color, edge labels
+ * map correctly, and the toggle controls label visibility.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { EDGE_COLORS, EDGE_LABELS } from '../packages/frontend/src/constants/graph.js';
+
+const ALL_RELATION_TYPES = [
+  'contains', 'depends_on', 'governed_by', 'constrained_by',
+  'implemented_with', 'reads_writes', 'exposes', 'consumes',
+  'performed_by', 'escalates_to', 'relates_to',
+];
+
+const createRenderer = () => {
+  const renderer = {
+    edgeLabelsVisible: true,
+    toggleEdgeLabels() {
+      this.edgeLabelsVisible = !this.edgeLabelsVisible;
+      return this.edgeLabelsVisible;
+    },
+    buildNodes(graphData: any) {
+      const edgeCounts = new Map();
+      graphData.edges.forEach((e: any) => {
+        edgeCounts.set(e.from, (edgeCounts.get(e.from) || 0) + 1);
+        edgeCounts.set(e.to, (edgeCounts.get(e.to) || 0) + 1);
+      });
+      return graphData.nodes.map((n: any) => ({
+        ...n,
+        edgeCount: edgeCounts.get(n.id) || 0,
+      }));
+    },
+    buildLinks(graphData: any, nodes: any[]) {
+      const nodeIds = new Set(nodes.map((n: any) => n.id));
+      return graphData.edges
+        .filter((e: any) => nodeIds.has(e.from) && nodeIds.has(e.to))
+        .map((e: any) => ({ source: e.from, target: e.to, relation: e.relation }));
+    },
+  };
+  return renderer;
+};
+
+describe('Edge Type Color Coding', () => {
+  describe('EDGE_COLORS mapping', () => {
+    it('has a color entry for every relation type', () => {
+      for (const rel of ALL_RELATION_TYPES) {
+        assert.ok(EDGE_COLORS[rel], `missing color for relation: ${rel}`);
+      }
+    });
+
+    it('has all distinct colors (no two relations share a color)', () => {
+      const colors = Object.values(EDGE_COLORS);
+      const unique = new Set(colors);
+      assert.equal(unique.size, colors.length, 'all edge colors should be unique');
+    });
+
+    it('uses valid hex color strings', () => {
+      const hexPattern = /^#[0-9a-fA-F]{6}$/;
+      for (const [rel, color] of Object.entries(EDGE_COLORS)) {
+        assert.ok(hexPattern.test(color), `${rel} color "${color}" is not valid hex`);
+      }
+    });
+  });
+
+  describe('EDGE_LABELS mapping', () => {
+    it('has a label entry for every relation type', () => {
+      for (const rel of ALL_RELATION_TYPES) {
+        assert.ok(EDGE_LABELS[rel], `missing label for relation: ${rel}`);
+      }
+    });
+
+    it('produces human-readable labels (no underscores)', () => {
+      for (const [rel, label] of Object.entries(EDGE_LABELS)) {
+        assert.ok(!label.includes('_'), `label for ${rel} should not contain underscores: "${label}"`);
+      }
+    });
+  });
+
+  describe('toggleEdgeLabels', () => {
+    it('starts with edge labels visible by default', () => {
+      const renderer = createRenderer();
+      assert.equal(renderer.edgeLabelsVisible, true);
+    });
+
+    it('toggles visibility off and returns false', () => {
+      const renderer = createRenderer();
+      const result = renderer.toggleEdgeLabels();
+      assert.equal(result, false);
+      assert.equal(renderer.edgeLabelsVisible, false);
+    });
+
+    it('toggles back on and returns true', () => {
+      const renderer = createRenderer();
+      renderer.toggleEdgeLabels(); // off
+      const result = renderer.toggleEdgeLabels(); // on
+      assert.equal(result, true);
+      assert.equal(renderer.edgeLabelsVisible, true);
+    });
+  });
+
+  describe('buildLinks preserves relation type', () => {
+    it('includes relation field in built links', () => {
+      const renderer = createRenderer();
+      const graphData = {
+        nodes: [
+          { id: 'a', type: 'feature', name: 'A', completeness: 1, open_questions_count: 0 },
+          { id: 'b', type: 'component', name: 'B', completeness: 1, open_questions_count: 0 },
+        ],
+        edges: [
+          { from: 'a', to: 'b', relation: 'contains' },
+        ],
+      };
+
+      const nodes = renderer.buildNodes(graphData);
+      const links = renderer.buildLinks(graphData, nodes);
+
+      assert.equal(links.length, 1);
+      assert.equal(links[0].relation, 'contains');
+      assert.equal(links[0].source, 'a');
+      assert.equal(links[0].target, 'b');
+    });
+
+    it('preserves different relation types across multiple edges', () => {
+      const renderer = createRenderer();
+      const graphData = {
+        nodes: [
+          { id: 'a', type: 'feature', name: 'A', completeness: 1, open_questions_count: 0 },
+          { id: 'b', type: 'component', name: 'B', completeness: 1, open_questions_count: 0 },
+          { id: 'c', type: 'decision', name: 'C', completeness: 1, open_questions_count: 0 },
+        ],
+        edges: [
+          { from: 'a', to: 'b', relation: 'contains' },
+          { from: 'a', to: 'c', relation: 'governed_by' },
+          { from: 'b', to: 'c', relation: 'depends_on' },
+        ],
+      };
+
+      const nodes = renderer.buildNodes(graphData);
+      const links = renderer.buildLinks(graphData, nodes);
+
+      const relations = links.map(l => l.relation);
+      assert.deepEqual(relations.sort(), ['contains', 'depends_on', 'governed_by']);
+    });
+  });
+});

package/templates/product-system/tests/emit-tool-use-events.test.ts

@@ -0,0 +1,85 @@
+/**
+ * Unit tests for emitToolUseEvents in claude-service.js.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { emitToolUseEvents } from '../packages/shared/lib/claude-service.js';
+
+describe('emitToolUseEvents', () => {
+  it('invokes callback for TodoWrite tool_use events', () => {
+    const calls = [];
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        content: [{
+          type: 'tool_use',
+          name: 'TodoWrite',
+          input: {
+            todos: [
+              { content: 'Parse events', status: 'completed', activeForm: 'Parsing events' },
+              { content: 'Write tests', status: 'in_progress', activeForm: 'Writing tests' },
+              { content: 'Run tests', status: 'pending', activeForm: 'Running tests' },
+            ],
+          },
+        }],
+      },
+    });
+
+    emitToolUseEvents(line, (name, input) => calls.push({ name, input }));
+
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0].name, 'TodoWrite');
+    assert.equal(calls[0].input.todos.length, 3);
+    assert.equal(calls[0].input.todos[0].status, 'completed');
+  });
+
+  it('invokes callback for multiple tool_use blocks in one event', () => {
+    const calls = [];
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        content: [
+          { type: 'text', text: 'Some text' },
+          { type: 'tool_use', name: 'Read', input: { file_path: '/a.js' } },
+          { type: 'tool_use', name: 'TodoWrite', input: { todos: [{ content: 'X', status: 'pending', activeForm: 'X' }] } },
+        ],
+      },
+    });
+
+    emitToolUseEvents(line, (name, input) => calls.push({ name, input }));
+
+    assert.equal(calls.length, 2);
+    assert.equal(calls[0].name, 'Read');
+    assert.equal(calls[1].name, 'TodoWrite');
+  });
+
+  it('does nothing for non-assistant events', () => {
+    const calls = [];
+    const line = JSON.stringify({ type: 'result', result: 'done' });
+
+    emitToolUseEvents(line, (name, input) => calls.push({ name, input }));
+
+    assert.equal(calls.length, 0);
+  });
+
+  it('does nothing for invalid JSON', () => {
+    const calls = [];
+    emitToolUseEvents('not valid json', (name, input) => calls.push({ name, input }));
+    assert.equal(calls.length, 0);
+  });
+
+  it('handles missing name gracefully', () => {
+    const calls = [];
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        content: [{ type: 'tool_use', input: { todos: [] } }],
+      },
+    });
+
+    emitToolUseEvents(line, (name, input) => calls.push({ name, input }));
+
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0].name, 'unknown');
+  });
+});

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

@@ -0,0 +1,139 @@
+/**
+ * Tests for feature kind field support (feat_027).
+ * Uses node:test built-in runner.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { VALID_FEATURE_KINDS } from '../packages/shared/lib/constants.js';
+
+describe('Feature kind constants', () => {
+  it('defines exactly three valid kinds', () => {
+    assert.deepEqual(VALID_FEATURE_KINDS, ['new', 'improvement', 'bugfix']);
+  });
+});
+
+describe('Feature kind data transformations', () => {
+  it('defaults missing kind to "new" for backward compatibility', () => {
+    const nodes = [
+      { id: 'feat_001', type: 'feature', status: 'defined', name: 'Old Feature' },
+      { id: 'feat_002', type: 'feature', status: 'defined', name: 'New Feature', kind: 'new' },
+      { id: 'feat_003', type: 'feature', status: 'defined', name: 'Bug Fix', kind: 'bugfix' },
+    ];
+
+    const withKinds = nodes.map(n => ({
+      ...n,
+      kind: n.kind || 'new',
+    }));
+
+    assert.equal(withKinds[0].kind, 'new');
+    assert.equal(withKinds[1].kind, 'new');
+    assert.equal(withKinds[2].kind, 'bugfix');
+  });
+
+  it('validates kind values against allowed list', () => {
+    const isValidKind = (kind) => VALID_FEATURE_KINDS.includes(kind);
+
+    assert.ok(isValidKind('new'));
+    assert.ok(isValidKind('improvement'));
+    assert.ok(isValidKind('bugfix'));
+    assert.ok(!isValidKind('enhancement'));
+    assert.ok(!isValidKind(''));
+    assert.ok(!isValidKind(undefined));
+  });
+
+  it('only applies kind to feature nodes', () => {
+    const nodes = [
+      { id: 'feat_001', type: 'feature', name: 'A Feature' },
+      { id: 'comp_001', type: 'component', name: 'A Component' },
+      { id: 'dec_001', type: 'decision', name: 'A Decision' },
+    ];
+
+    const withKinds = nodes.map(n => ({
+      ...n,
+      ...(n.type === 'feature' ? { kind: n.kind || 'new' } : {}),
+    }));
+
+    assert.equal(withKinds[0].kind, 'new');
+    assert.equal(withKinds[1].kind, undefined);
+    assert.equal(withKinds[2].kind, undefined);
+  });
+});
+
+describe('Kanban card kind display logic', () => {
+  it('includes kind in card data from graph nodes', () => {
+    const graphNodes = [
+      { id: 'feat_001', type: 'feature', status: 'defined', name: 'Feature A', completeness: 1 },
+      { id: 'feat_002', type: 'feature', status: 'defined', name: 'Feature B', completeness: 0.8, kind: 'bugfix' },
+      { id: 'feat_003', type: 'feature', status: 'defined', name: 'Feature C', completeness: 0.5, kind: 'improvement' },
+    ];
+
+    const kanbanData = {
+      feat_001: { column: 'todo', rejection_count: 0, notes: [] },
+      feat_002: { column: 'todo', rejection_count: 1, notes: [] },
+      feat_003: { column: 'in_progress', rejection_count: 0, notes: [] },
+    };
+
+    const featureNodes = new Map();
+    graphNodes
+      .filter(n => n.type === 'feature' && n.status === 'defined')
+      .forEach(n => featureNodes.set(n.id, n));
+
+    const cards = Object.entries(kanbanData)
+      .filter(([id, entry]) => entry.column === 'todo' && featureNodes.has(id))
+      .map(([id, entry]) => ({
+        id,
+        name: featureNodes.get(id).name,
+        kind: featureNodes.get(id).kind || 'new',
+        rejectionCount: entry.rejection_count || 0,
+      }));
+
+    assert.equal(cards.length, 2);
+    assert.equal(cards[0].kind, 'new');
+    assert.equal(cards[1].kind, 'bugfix');
+  });
+
+  it('only shows kind badge for non-default kinds', () => {
+    const shouldShowBadge = (kind) => kind && kind !== 'new';
+
+    assert.ok(!shouldShowBadge('new'));
+    assert.ok(!shouldShowBadge(undefined));
+    assert.ok(shouldShowBadge('improvement'));
+    assert.ok(shouldShowBadge('bugfix'));
+  });
+});
+
+describe('Feature kind in frontmatter', () => {
+  it('builds correct frontmatter for feature with kind', () => {
+    const type = 'feature';
+    const kind = 'bugfix';
+    const frontmatter = {
+      id: 'feat_001',
+      type,
+      name: 'Fix login bug',
+      status: 'draft',
+      priority: 'high',
+      ...(type === 'feature' ? { kind } : {}),
+      created_at: '2026-01-01T00:00:00.000Z',
+      updated_at: '2026-01-01T00:00:00.000Z',
+    };
+
+    assert.equal(frontmatter.kind, 'bugfix');
+  });
+
+  it('does not add kind to non-feature frontmatter', () => {
+    const type = 'component';
+    const kind = 'new';
+    const frontmatter = {
+      id: 'comp_001',
+      type,
+      name: 'A Component',
+      status: 'draft',
+      priority: 'medium',
+      ...(type === 'feature' ? { kind } : {}),
+      created_at: '2026-01-01T00:00:00.000Z',
+      updated_at: '2026-01-01T00:00:00.000Z',
+    };
+
+    assert.equal(frontmatter.kind, undefined);
+  });
+});

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

@@ -0,0 +1,199 @@
+/**
+ * Tests for Visual Gap Indicators (feat_013).
+ * Uses node:test built-in runner.
+ * Tests the data transformation and classification logic that drives
+ * pulsing rings and warning icons on nodes with open questions.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+const createRenderer = () => ({
+  nodeRadius(d: any) {
+    const base = 8;
+    const scale = Math.min(d.edgeCount * 1.5, 20);
+    return base + scale;
+  },
+  nodeStroke(d: any) {
+    if (d.completeness < 1 && d.open_questions_count > 0) return '#ff6b6b';
+    if (d.completeness < 1) return '#ffd43b';
+    return 'transparent';
+  },
+  nodeStrokeWidth(d: any) {
+    if (d.completeness < 1) return 3;
+    return 0;
+  },
+  hasGapIndicator(d: any) {
+    return d.open_questions_count > 0;
+  },
+  buildNodes(graphData: any) {
+    const edgeCounts = new Map();
+    graphData.edges.forEach((e: any) => {
+      edgeCounts.set(e.from, (edgeCounts.get(e.from) || 0) + 1);
+      edgeCounts.set(e.to, (edgeCounts.get(e.to) || 0) + 1);
+    });
+    return graphData.nodes.map((n: any) => ({
+      ...n,
+      edgeCount: edgeCounts.get(n.id) || 0,
+    }));
+  },
+});
+
+// Test node fixtures
+const makeNode = (overrides = {}) => ({
+  id: 'feat_001',
+  type: 'feature',
+  name: 'Test Feature',
+  completeness: 1.0,
+  open_questions_count: 0,
+  edgeCount: 2,
+  ...overrides,
+});
+
+describe('Visual Gap Indicators', () => {
+
+  describe('hasGapIndicator', () => {
+    const renderer = createRenderer();
+
+    it('returns true for nodes with open questions', () => {
+      const node = makeNode({ open_questions_count: 3 });
+      assert.equal(renderer.hasGapIndicator(node), true);
+    });
+
+    it('returns true for nodes with 1 open question', () => {
+      const node = makeNode({ open_questions_count: 1 });
+      assert.equal(renderer.hasGapIndicator(node), true);
+    });
+
+    it('returns false for nodes with zero open questions', () => {
+      const node = makeNode({ open_questions_count: 0 });
+      assert.equal(renderer.hasGapIndicator(node), false);
+    });
+
+    it('returns false for complete nodes without open questions', () => {
+      const node = makeNode({ completeness: 1.0, open_questions_count: 0 });
+      assert.equal(renderer.hasGapIndicator(node), false);
+    });
+
+    it('returns true for complete nodes with open questions', () => {
+      const node = makeNode({ completeness: 1.0, open_questions_count: 2 });
+      assert.equal(renderer.hasGapIndicator(node), true);
+    });
+
+    it('returns false for incomplete nodes without open questions', () => {
+      const node = makeNode({ completeness: 0.5, open_questions_count: 0 });
+      assert.equal(renderer.hasGapIndicator(node), false);
+    });
+  });
+
+  describe('nodeStroke distinguishes gap types', () => {
+    const renderer = createRenderer();
+
+    it('returns red for incomplete nodes with open questions', () => {
+      const node = makeNode({ completeness: 0.5, open_questions_count: 2 });
+      assert.equal(renderer.nodeStroke(node), '#ff6b6b');
+    });
+
+    it('returns yellow for incomplete nodes without open questions', () => {
+      const node = makeNode({ completeness: 0.5, open_questions_count: 0 });
+      assert.equal(renderer.nodeStroke(node), '#ffd43b');
+    });
+
+    it('returns transparent for complete nodes', () => {
+      const node = makeNode({ completeness: 1.0, open_questions_count: 0 });
+      assert.equal(renderer.nodeStroke(node), 'transparent');
+    });
+  });
+
+  describe('nodeStrokeWidth', () => {
+    const renderer = createRenderer();
+
+    it('returns 3 for incomplete nodes', () => {
+      const node = makeNode({ completeness: 0.7 });
+      assert.equal(renderer.nodeStrokeWidth(node), 3);
+    });
+
+    it('returns 0 for complete nodes', () => {
+      const node = makeNode({ completeness: 1.0 });
+      assert.equal(renderer.nodeStrokeWidth(node), 0);
+    });
+  });
+
+  describe('gap node filtering from graph data', () => {
+    const renderer = createRenderer();
+
+    it('filters nodes with open questions for gap indicators', () => {
+      const graphData = {
+        nodes: [
+          { id: 'feat_001', type: 'feature', name: 'A', completeness: 1.0, open_questions_count: 0 },
+          { id: 'feat_002', type: 'feature', name: 'B', completeness: 0.5, open_questions_count: 2 },
+          { id: 'comp_001', type: 'component', name: 'C', completeness: 0.8, open_questions_count: 0 },
+          { id: 'dec_001', type: 'decision', name: 'D', completeness: 0.3, open_questions_count: 1 },
+        ],
+        edges: [],
+      };
+
+      const nodes = renderer.buildNodes(graphData);
+      const gapNodes = nodes.filter(d => renderer.hasGapIndicator(d));
+
+      assert.equal(gapNodes.length, 2);
+      assert.deepEqual(
+        gapNodes.map(n => n.id).sort(),
+        ['dec_001', 'feat_002']
+      );
+    });
+
+    it('returns empty array when no nodes have open questions', () => {
+      const graphData = {
+        nodes: [
+          { id: 'feat_001', type: 'feature', name: 'A', completeness: 0.5, open_questions_count: 0 },
+          { id: 'feat_002', type: 'feature', name: 'B', completeness: 1.0, open_questions_count: 0 },
+        ],
+        edges: [],
+      };
+
+      const nodes = renderer.buildNodes(graphData);
+      const gapNodes = nodes.filter(d => renderer.hasGapIndicator(d));
+
+      assert.equal(gapNodes.length, 0);
+    });
+
+    it('includes all nodes when all have open questions', () => {
+      const graphData = {
+        nodes: [
+          { id: 'feat_001', type: 'feature', name: 'A', completeness: 0.5, open_questions_count: 1 },
+          { id: 'feat_002', type: 'feature', name: 'B', completeness: 0.8, open_questions_count: 3 },
+        ],
+        edges: [],
+      };
+
+      const nodes = renderer.buildNodes(graphData);
+      const gapNodes = nodes.filter(d => renderer.hasGapIndicator(d));
+
+      assert.equal(gapNodes.length, 2);
+    });
+  });
+
+  describe('visual distinction between gap types', () => {
+    const renderer = createRenderer();
+
+    it('incomplete-only nodes get yellow border but no gap indicator', () => {
+      const node = makeNode({ completeness: 0.6, open_questions_count: 0 });
+      assert.equal(renderer.nodeStroke(node), '#ffd43b');
+      assert.equal(renderer.nodeStrokeWidth(node), 3);
+      assert.equal(renderer.hasGapIndicator(node), false);
+    });
+
+    it('incomplete nodes with open questions get red border AND gap indicator', () => {
+      const node = makeNode({ completeness: 0.6, open_questions_count: 2 });
+      assert.equal(renderer.nodeStroke(node), '#ff6b6b');
+      assert.equal(renderer.nodeStrokeWidth(node), 3);
+      assert.equal(renderer.hasGapIndicator(node), true);
+    });
+
+    it('complete nodes with open questions get gap indicator but transparent border', () => {
+      const node = makeNode({ completeness: 1.0, open_questions_count: 1 });
+      assert.equal(renderer.nodeStroke(node), 'transparent');
+      assert.equal(renderer.nodeStrokeWidth(node), 0);
+      assert.equal(renderer.hasGapIndicator(node), true);
+    });
+  });
+});