@assistkick/create 1.0.0

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

@@ -0,0 +1,562 @@
+/**
+ * Tests for coherence review logic — prompt building, proposal parsing, sorting,
+ * conflict detection, dismissal matching, scope expansion, and UI renderer logic.
+ * Uses node:test built-in runner.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+// --- Test data ---
+
+const SAMPLE_GRAPH = {
+  version: '1.0',
+  project: { name: 'Test', description: '' },
+  nodes: [
+    { id: 'feat_001', type: 'feature', name: 'Node CRUD', status: 'defined', completeness: 1, created_at: '2025-01-01T00:00:00Z', updated_at: '2025-01-15T00:00:00Z' },
+    { id: 'feat_002', type: 'feature', name: 'Edge Management', status: 'defined', completeness: 1, created_at: '2025-01-01T00:00:00Z', updated_at: '2025-01-15T00:00:00Z' },
+    { id: 'comp_001', type: 'component', name: 'Graph Engine', status: 'defined', completeness: 1, created_at: '2025-01-01T00:00:00Z', updated_at: '2025-01-15T00:00:00Z' },
+    { id: 'feat_003', type: 'feature', name: 'New Feature', status: 'draft', completeness: 0.3, created_at: '2025-02-01T00:00:00Z', updated_at: '2025-02-10T00:00:00Z' },
+    { id: 'dec_001', type: 'decision', name: 'Use Turso', status: 'defined', completeness: 1, created_at: '2025-01-05T00:00:00Z', updated_at: '2025-01-05T00:00:00Z' },
+  ],
+  edges: [
+    { from: 'feat_001', relation: 'implemented_with', to: 'comp_001' },
+    { from: 'feat_002', relation: 'implemented_with', to: 'comp_001' },
+    { from: 'feat_003', relation: 'depends_on', to: 'feat_001' },
+  ],
+};
+
+const EMPTY_COHERENCE = {
+  last_review_timestamp: null,
+  review_status: 'idle',
+  partial_run: false,
+  proposals: [],
+};
+
+const COHERENCE_WITH_DISMISSED = {
+  last_review_timestamp: '2025-01-20T00:00:00Z',
+  review_status: 'idle',
+  partial_run: false,
+  proposals: [
+    {
+      id: 'abc123',
+      type: 'add_edge',
+      from_id: 'feat_001',
+      to_id: 'feat_002',
+      relation: 'depends_on',
+      reasoning: 'Both relate to graph ops',
+      confidence: 'medium',
+      status: 'dismissed',
+      created_at: '2025-01-20T00:00:00Z',
+      resolved_at: '2025-01-20T01:00:00Z',
+    },
+  ],
+};
+
+// --- Scope expansion tests ---
+
+const expandScope = (scopeNodeIds, graph) => {
+  const expanded = new Set(scopeNodeIds);
+  for (const nodeId of scopeNodeIds) {
+    for (const edge of graph.edges) {
+      if (edge.from === nodeId) expanded.add(edge.to);
+      if (edge.to === nodeId) expanded.add(edge.from);
+    }
+  }
+  return [...expanded];
+};
+
+describe('Scope Expansion', () => {
+  it('includes 1-hop neighbors of scope nodes', () => {
+    const result = expandScope(['feat_003'], SAMPLE_GRAPH);
+    // feat_003 depends_on feat_001, so feat_001 should be included
+    assert.ok(result.includes('feat_003'));
+    assert.ok(result.includes('feat_001'));
+    assert.equal(result.length, 2);
+  });
+
+  it('includes all neighbors in both edge directions', () => {
+    const result = expandScope(['comp_001'], SAMPLE_GRAPH);
+    // comp_001 is target of feat_001 and feat_002 implemented_with edges
+    assert.ok(result.includes('comp_001'));
+    assert.ok(result.includes('feat_001'));
+    assert.ok(result.includes('feat_002'));
+    assert.equal(result.length, 3);
+  });
+
+  it('returns the same nodes if no edges connect', () => {
+    const result = expandScope(['dec_001'], SAMPLE_GRAPH);
+    assert.deepEqual(result, ['dec_001']);
+  });
+
+  it('deduplicates nodes', () => {
+    const result = expandScope(['feat_001', 'feat_002'], SAMPLE_GRAPH);
+    // Both connect to comp_001, should appear once
+    const unique = new Set(result);
+    assert.equal(result.length, unique.size);
+  });
+});
+
+// --- Prompt building tests ---
+
+const buildCoherencePrompt = (graph, coherenceData) => {
+  const lastReview = coherenceData.last_review_timestamp;
+  const getDismissalKey = (p) => {
+    switch (p.type) {
+      case 'add_edge':
+      case 'remove_edge':
+        return `${p.type}:${p.from_id}:${p.relation}:${p.to_id}`;
+      case 'add_node':
+        return `${p.type}:${p.proposed_node_type}:${p.proposed_node_name}`;
+      case 'deprecate_node':
+        return `${p.type}:${p.target_node_id}`;
+      case 'update_description':
+        return `${p.type}:${p.target_node_id}`;
+      default:
+        return `${p.type}:${p.id}`;
+    }
+  };
+
+  const dismissedKeys = new Set(
+    coherenceData.proposals
+      .filter(p => p.status === 'dismissed')
+      .map(p => getDismissalKey(p))
+  );
+  const dismissedList = [...dismissedKeys];
+
+  const changedNodes = lastReview
+    ? graph.nodes.filter(n => n.updated_at > lastReview || n.created_at > lastReview)
+    : graph.nodes;
+  const changedIds = changedNodes.map(n => n.id);
+  const scopeNodeIds = lastReview ? expandScope(changedIds, graph) : changedIds;
+
+  const nodesSummary = graph.nodes.map(n =>
+    `  ${n.id} [${n.type}] "${n.name}" status=${n.status} completeness=${n.completeness}`
+  ).join('\n');
+
+  const edgesSummary = graph.edges.map(e =>
+    `  ${e.from} --${e.relation}--> ${e.to}`
+  ).join('\n');
+
+  let prompt = `You are a graph coherence reviewer`;
+  prompt += `\n\n## All Nodes\n${nodesSummary}\n\n`;
+  prompt += `## All Edges\n${edgesSummary}\n\n`;
+  prompt += `## Scope\n`;
+  prompt += scopeNodeIds.length > 0
+    ? `Focus on these nodes: ${scopeNodeIds.join(', ')}\n\n`
+    : `No previous review — analyze all nodes.\n\n`;
+
+  if (dismissedList.length > 0) {
+    prompt += `## Previously Dismissed\n`;
+    prompt += dismissedList.map(d => `  - ${d}`).join('\n') + '\n\n';
+  }
+
+  prompt += `## Five Proposal Types\n`;
+  prompt += `add_edge, add_node, remove_edge, deprecate_node, update_description\n`;
+
+  return prompt;
+};
+
+describe('Coherence Prompt Building', () => {
+  it('includes all nodes and edges in the prompt', () => {
+    const prompt = buildCoherencePrompt(SAMPLE_GRAPH, EMPTY_COHERENCE);
+    assert.ok(prompt.includes('feat_001'));
+    assert.ok(prompt.includes('feat_002'));
+    assert.ok(prompt.includes('comp_001'));
+    assert.ok(prompt.includes('feat_003'));
+    assert.ok(prompt.includes('feat_001 --implemented_with--> comp_001'));
+  });
+
+  it('scopes to all nodes when no last review timestamp', () => {
+    const prompt = buildCoherencePrompt(SAMPLE_GRAPH, EMPTY_COHERENCE);
+    assert.ok(prompt.includes('feat_001'));
+    assert.ok(prompt.includes('feat_002'));
+    assert.ok(prompt.includes('comp_001'));
+    assert.ok(prompt.includes('feat_003'));
+    assert.ok(prompt.includes('dec_001'));
+  });
+
+  it('scopes to recently modified nodes with 1-hop expansion', () => {
+    const prompt = buildCoherencePrompt(SAMPLE_GRAPH, COHERENCE_WITH_DISMISSED);
+    // feat_003 created after 2025-01-20, its 1-hop neighbor feat_001 should be in scope
+    assert.ok(prompt.includes('feat_003'));
+    assert.ok(prompt.includes('feat_001'));
+  });
+
+  it('includes dismissed proposals as exact-tuple keys', () => {
+    const prompt = buildCoherencePrompt(SAMPLE_GRAPH, COHERENCE_WITH_DISMISSED);
+    assert.ok(prompt.includes('Previously Dismissed'));
+    assert.ok(prompt.includes('add_edge:feat_001:depends_on:feat_002'));
+  });
+
+  it('omits dismissed section when no dismissed proposals exist', () => {
+    const prompt = buildCoherencePrompt(SAMPLE_GRAPH, EMPTY_COHERENCE);
+    assert.ok(!prompt.includes('Previously Dismissed'));
+  });
+
+  it('mentions all five proposal types', () => {
+    const prompt = buildCoherencePrompt(SAMPLE_GRAPH, EMPTY_COHERENCE);
+    assert.ok(prompt.includes('add_edge'));
+    assert.ok(prompt.includes('add_node'));
+    assert.ok(prompt.includes('remove_edge'));
+    assert.ok(prompt.includes('deprecate_node'));
+    assert.ok(prompt.includes('update_description'));
+  });
+});
+
+// --- JSON parsing tests ---
+
+const parseClaudeOutput = (output) => {
+  let jsonStr = output.trim();
+  const fenceMatch = jsonStr.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+  if (fenceMatch) {
+    jsonStr = fenceMatch[1].trim();
+  }
+  const arrayMatch = jsonStr.match(/\[[\s\S]*\]/);
+  if (arrayMatch) {
+    jsonStr = arrayMatch[0];
+  }
+  return JSON.parse(jsonStr);
+};
+
+describe('Claude Output Parsing', () => {
+  it('parses plain JSON array', () => {
+    const output = '[{"type":"add_edge","from_id":"feat_001","to_id":"feat_003","relation":"depends_on","confidence":"high","reasoning":"test"}]';
+    const result = parseClaudeOutput(output);
+    assert.equal(result.length, 1);
+    assert.equal(result[0].type, 'add_edge');
+    assert.equal(result[0].confidence, 'high');
+  });
+
+  it('parses JSON wrapped in markdown code fences', () => {
+    const output = '```json\n[{"type":"add_node","proposed_node_type":"design_pattern","proposed_node_name":"Test Pattern","confidence":"medium","reasoning":"shared"}]\n```';
+    const result = parseClaudeOutput(output);
+    assert.equal(result.length, 1);
+    assert.equal(result[0].type, 'add_node');
+  });
+
+  it('parses empty array', () => {
+    const result = parseClaudeOutput('[]');
+    assert.equal(result.length, 0);
+  });
+
+  it('parses JSON with surrounding text', () => {
+    const output = 'Here are my proposals:\n\n[{"type":"remove_edge","from_id":"a","to_id":"b","relation":"relates_to","confidence":"low","reasoning":"x"}]\n\nDone.';
+    const result = parseClaudeOutput(output);
+    assert.equal(result.length, 1);
+    assert.equal(result[0].type, 'remove_edge');
+  });
+
+  it('parses all five proposal types', () => {
+    const output = JSON.stringify([
+      { type: 'add_edge', from_id: 'a', to_id: 'b', relation: 'r', confidence: 'high', reasoning: 'x' },
+      { type: 'add_node', proposed_node_type: 't', proposed_node_name: 'n', confidence: 'medium', reasoning: 'y' },
+      { type: 'remove_edge', from_id: 'c', to_id: 'd', relation: 's', confidence: 'high', reasoning: 'z' },
+      { type: 'deprecate_node', target_node_id: 'e', confidence: 'low', reasoning: 'w' },
+      { type: 'update_description', target_node_id: 'f', proposed_description: 'new desc', confidence: 'medium', reasoning: 'v' },
+    ]);
+    const result = parseClaudeOutput(output);
+    assert.equal(result.length, 5);
+    assert.deepEqual(result.map(r => r.type), ['add_edge', 'add_node', 'remove_edge', 'deprecate_node', 'update_description']);
+  });
+});
+
+// --- Proposal type validation ---
+
+describe('Proposal Data Structure', () => {
+  it('EMPTY_COHERENCE has correct shape', () => {
+    assert.equal(EMPTY_COHERENCE.last_review_timestamp, null);
+    assert.equal(EMPTY_COHERENCE.review_status, 'idle');
+    assert.equal(EMPTY_COHERENCE.partial_run, false);
+    assert.ok(Array.isArray(EMPTY_COHERENCE.proposals));
+    assert.equal(EMPTY_COHERENCE.proposals.length, 0);
+  });
+
+  it('proposals have required fields', () => {
+    const proposal = COHERENCE_WITH_DISMISSED.proposals[0];
+    assert.ok(proposal.id);
+    assert.ok(proposal.type);
+    assert.ok(proposal.status);
+    assert.ok(proposal.created_at);
+    assert.ok(proposal.confidence);
+    assert.ok(['add_edge', 'add_node', 'remove_edge', 'deprecate_node', 'update_description'].includes(proposal.type));
+    assert.ok(['pending', 'approved', 'dismissed'].includes(proposal.status));
+  });
+
+  it('add_edge proposals have from_id, to_id, and relation', () => {
+    const proposal = COHERENCE_WITH_DISMISSED.proposals[0];
+    assert.equal(proposal.type, 'add_edge');
+    assert.ok(proposal.from_id);
+    assert.ok(proposal.to_id);
+    assert.ok(proposal.relation);
+  });
+});
+
+// --- Sorting tests ---
+
+const PROPOSAL_TYPE_ORDER = ['deprecate_node', 'remove_edge', 'update_description', 'add_edge', 'add_node'];
+
+const sortProposals = (proposals) => {
+  return [...proposals].sort((a, b) => {
+    const aIdx = PROPOSAL_TYPE_ORDER.indexOf(a.type);
+    const bIdx = PROPOSAL_TYPE_ORDER.indexOf(b.type);
+    if (aIdx !== bIdx) return aIdx - bIdx;
+    if (a.batch_id && b.batch_id && a.batch_id === b.batch_id) return 0;
+    if (a.batch_id && !b.batch_id) return -1;
+    if (!a.batch_id && b.batch_id) return 1;
+    return 0;
+  });
+};
+
+describe('Proposal Sorting', () => {
+  it('sorts by type priority: deprecate first, add last', () => {
+    const proposals = [
+      { type: 'add_edge', id: '1' },
+      { type: 'deprecate_node', id: '2' },
+      { type: 'remove_edge', id: '3' },
+      { type: 'update_description', id: '4' },
+      { type: 'add_node', id: '5' },
+    ];
+    const sorted = sortProposals(proposals);
+    assert.deepEqual(sorted.map(p => p.type), [
+      'deprecate_node', 'remove_edge', 'update_description', 'add_edge', 'add_node',
+    ]);
+  });
+
+  it('keeps batch members together within same type', () => {
+    const proposals = [
+      { type: 'add_edge', id: '1', batch_id: 'b1' },
+      { type: 'add_edge', id: '2' },
+      { type: 'add_edge', id: '3', batch_id: 'b1' },
+    ];
+    const sorted = sortProposals(proposals);
+    // Batched items come before unbatched
+    assert.equal(sorted[0].batch_id, 'b1');
+    assert.equal(sorted[1].batch_id, 'b1');
+    assert.equal(sorted[2].batch_id, undefined);
+  });
+});
+
+// --- Dismissal key tests ---
+
+const getDismissalKey = (proposal) => {
+  switch (proposal.type) {
+    case 'add_edge':
+    case 'remove_edge':
+      return `${proposal.type}:${proposal.from_id}:${proposal.relation}:${proposal.to_id}`;
+    case 'add_node':
+      return `${proposal.type}:${proposal.proposed_node_type}:${proposal.proposed_node_name}`;
+    case 'deprecate_node':
+      return `${proposal.type}:${proposal.target_node_id}`;
+    case 'update_description':
+      return `${proposal.type}:${proposal.target_node_id}`;
+    default:
+      return `${proposal.type}:${proposal.id}`;
+  }
+};
+
+describe('Dismissal Key Generation', () => {
+  it('generates correct key for add_edge', () => {
+    const key = getDismissalKey({ type: 'add_edge', from_id: 'a', relation: 'r', to_id: 'b' });
+    assert.equal(key, 'add_edge:a:r:b');
+  });
+
+  it('generates correct key for remove_edge', () => {
+    const key = getDismissalKey({ type: 'remove_edge', from_id: 'x', relation: 'y', to_id: 'z' });
+    assert.equal(key, 'remove_edge:x:y:z');
+  });
+
+  it('generates correct key for add_node', () => {
+    const key = getDismissalKey({ type: 'add_node', proposed_node_type: 'decision', proposed_node_name: 'Test' });
+    assert.equal(key, 'add_node:decision:Test');
+  });
+
+  it('generates correct key for deprecate_node', () => {
+    const key = getDismissalKey({ type: 'deprecate_node', target_node_id: 'feat_099' });
+    assert.equal(key, 'deprecate_node:feat_099');
+  });
+
+  it('generates correct key for update_description', () => {
+    const key = getDismissalKey({ type: 'update_description', target_node_id: 'comp_001' });
+    assert.equal(key, 'update_description:comp_001');
+  });
+});
+
+// --- Conflict detection tests ---
+
+const detectConflicts = (proposals) => {
+  const conflicts = new Map();
+  const pending = proposals.filter(p => p.status === 'pending');
+
+  const deprecatedNodeIds = new Set(
+    pending.filter(p => p.type === 'deprecate_node').map(p => p.target_node_id)
+  );
+
+  for (const p of pending) {
+    const pConflicts = new Set();
+
+    if (p.type === 'add_edge') {
+      if (deprecatedNodeIds.has(p.from_id) || deprecatedNodeIds.has(p.to_id)) {
+        const deprecator = pending.find(d =>
+          d.type === 'deprecate_node' &&
+          (d.target_node_id === p.from_id || d.target_node_id === p.to_id)
+        );
+        if (deprecator) pConflicts.add(deprecator.id);
+      }
+    }
+
+    if (p.type === 'remove_edge') {
+      const addDup = pending.find(a =>
+        a.type === 'add_edge' &&
+        a.from_id === p.from_id && a.relation === p.relation && a.to_id === p.to_id
+      );
+      if (addDup) pConflicts.add(addDup.id);
+    }
+
+    if (p.type === 'update_description' && deprecatedNodeIds.has(p.target_node_id)) {
+      const deprecator = pending.find(d =>
+        d.type === 'deprecate_node' && d.target_node_id === p.target_node_id
+      );
+      if (deprecator) pConflicts.add(deprecator.id);
+    }
+
+    if (pConflicts.size > 0) {
+      conflicts.set(p.id, pConflicts);
+      for (const cId of pConflicts) {
+        if (!conflicts.has(cId)) conflicts.set(cId, new Set());
+        conflicts.get(cId).add(p.id);
+      }
+    }
+  }
+
+  return conflicts;
+};
+
+describe('Conflict Detection', () => {
+  it('detects conflict between add_edge and deprecate_node', () => {
+    const proposals = [
+      { id: '1', type: 'add_edge', from_id: 'a', to_id: 'b', relation: 'r', status: 'pending' },
+      { id: '2', type: 'deprecate_node', target_node_id: 'b', status: 'pending' },
+    ];
+    const conflicts = detectConflicts(proposals);
+    assert.ok(conflicts.has('1'));
+    assert.ok(conflicts.get('1').has('2'));
+    assert.ok(conflicts.has('2'));
+    assert.ok(conflicts.get('2').has('1'));
+  });
+
+  it('detects conflict between remove_edge and add_edge for same tuple', () => {
+    const proposals = [
+      { id: '1', type: 'remove_edge', from_id: 'a', to_id: 'b', relation: 'r', status: 'pending' },
+      { id: '2', type: 'add_edge', from_id: 'a', to_id: 'b', relation: 'r', status: 'pending' },
+    ];
+    const conflicts = detectConflicts(proposals);
+    assert.ok(conflicts.has('1'));
+    assert.ok(conflicts.get('1').has('2'));
+  });
+
+  it('detects conflict between update_description and deprecate_node for same node', () => {
+    const proposals = [
+      { id: '1', type: 'update_description', target_node_id: 'x', status: 'pending' },
+      { id: '2', type: 'deprecate_node', target_node_id: 'x', status: 'pending' },
+    ];
+    const conflicts = detectConflicts(proposals);
+    assert.ok(conflicts.has('1'));
+    assert.ok(conflicts.get('1').has('2'));
+  });
+
+  it('returns empty map when no conflicts', () => {
+    const proposals = [
+      { id: '1', type: 'add_edge', from_id: 'a', to_id: 'b', relation: 'r', status: 'pending' },
+      { id: '2', type: 'add_edge', from_id: 'c', to_id: 'd', relation: 's', status: 'pending' },
+    ];
+    const conflicts = detectConflicts(proposals);
+    assert.equal(conflicts.size, 0);
+  });
+
+  it('ignores resolved proposals', () => {
+    const proposals = [
+      { id: '1', type: 'add_edge', from_id: 'a', to_id: 'b', relation: 'r', status: 'approved' },
+      { id: '2', type: 'deprecate_node', target_node_id: 'b', status: 'pending' },
+    ];
+    const conflicts = detectConflicts(proposals);
+    assert.equal(conflicts.size, 0);
+  });
+});
+
+// --- CoherenceRenderer logic tests ---
+
+describe('CoherenceRenderer logic', () => {
+  it('escapeHtml escapes special characters', () => {
+    const escapeHtml = (str) => {
+      if (!str) return '';
+      return str
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+    };
+
+    assert.equal(escapeHtml('<script>alert("xss")</script>'), '&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;');
+    assert.equal(escapeHtml(''), '');
+    assert.equal(escapeHtml(null), '');
+    assert.equal(escapeHtml('normal text'), 'normal text');
+    assert.equal(escapeHtml('a & b'), 'a &amp; b');
+  });
+
+  it('filters pending proposals correctly', () => {
+    const proposals = [
+      { id: '1', status: 'pending' },
+      { id: '2', status: 'approved' },
+      { id: '3', status: 'dismissed' },
+      { id: '4', status: 'pending' },
+    ];
+    const pending = proposals.filter(p => p.status === 'pending');
+    const resolved = proposals.filter(p => p.status !== 'pending');
+
+    assert.equal(pending.length, 2);
+    assert.equal(resolved.length, 2);
+    assert.deepEqual(pending.map(p => p.id), ['1', '4']);
+  });
+
+  it('finds nodes by id from graph data', () => {
+    const findNode = (nodeId) => SAMPLE_GRAPH.nodes.find(n => n.id === nodeId) || null;
+
+    assert.equal(findNode('feat_001').name, 'Node CRUD');
+    assert.equal(findNode('comp_001').name, 'Graph Engine');
+    assert.equal(findNode('nonexistent'), null);
+  });
+
+  it('groups proposals by batch correctly', () => {
+    const proposals = [
+      { id: '1', batch_id: 'b1', type: 'add_edge' },
+      { id: '2', batch_id: 'b1', type: 'add_edge' },
+      { id: '3', type: 'remove_edge' },
+      { id: '4', batch_id: 'b2', type: 'add_node' },
+    ];
+
+    const batched = new Map();
+    const unbatched = [];
+    for (const p of proposals) {
+      if (p.batch_id) {
+        if (!batched.has(p.batch_id)) batched.set(p.batch_id, []);
+        batched.get(p.batch_id).push(p);
+      } else {
+        unbatched.push(p);
+      }
+    }
+
+    // Only batches with 2+ items are real batches
+    const realBatches = new Map();
+    for (const [batchId, items] of batched) {
+      if (items.length >= 2) {
+        realBatches.set(batchId, items);
+      } else {
+        unbatched.push(...items);
+      }
+    }
+
+    assert.equal(realBatches.size, 1); // b1 has 2 items
+    assert.ok(realBatches.has('b1'));
+    assert.equal(unbatched.length, 2); // feat_003 and b2's single item
+  });
+});

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

@@ -0,0 +1,75 @@
+/**
+ * Tests for the local SQLite fallback in db.ts (feat_095).
+ * Verifies the URL construction logic and connection selection.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { join } from 'node:path';
+
+describe('Local SQLite URL format', () => {
+  it('builds a file: URL from a data directory path', () => {
+    const projectRoot = '/home/user/myproject/product-system';
+    const dataDir = join(projectRoot, 'data');
+    const connectionUrl = `file:${join(dataDir, 'local.db')}`;
+
+    assert.ok(connectionUrl.startsWith('file:'));
+    assert.ok(connectionUrl.includes('data'));
+    assert.ok(connectionUrl.endsWith('local.db'));
+  });
+
+  it('uses Turso when both credentials are present', () => {
+    const url = 'libsql://test.turso.io';
+    const authToken = 'tok-abc';
+    assert.equal(Boolean(url && authToken), true);
+  });
+
+  it('falls back to local SQLite when both credentials are absent', () => {
+    const url = undefined;
+    const authToken = undefined;
+    assert.equal(Boolean(url && authToken), false);
+  });
+
+  it('falls back when only URL is set', () => {
+    const url = 'libsql://test.turso.io';
+    const authToken = undefined;
+    assert.equal(Boolean(url && authToken), false);
+  });
+
+  it('falls back when only token is set', () => {
+    const url = undefined;
+    const authToken = 'tok-abc';
+    assert.equal(Boolean(url && authToken), false);
+  });
+});
+
+describe('Local SQLite connection config', () => {
+  it('authToken is undefined for local SQLite', () => {
+    const tursoUrl = undefined;
+    const tursoAuthToken = undefined;
+
+    let connectionAuthToken: string | undefined;
+
+    if (tursoUrl && tursoAuthToken) {
+      connectionAuthToken = tursoAuthToken;
+    } else {
+      connectionAuthToken = undefined;
+    }
+
+    assert.equal(connectionAuthToken, undefined);
+  });
+
+  it('authToken is set for Turso connection', () => {
+    const tursoUrl = 'libsql://test.turso.io';
+    const tursoAuthToken = 'tok-abc';
+
+    let connectionAuthToken: string | undefined;
+
+    if (tursoUrl && tursoAuthToken) {
+      connectionAuthToken = tursoAuthToken;
+    } else {
+      connectionAuthToken = undefined;
+    }
+
+    assert.equal(connectionAuthToken, 'tok-abc');
+  });
+});