create-yss-spec 2.1.4 → 2.1.6

package/template/.claude/skills/drawio/scripts/adapters/index.js

@@ -1,489 +0,0 @@
-/**
- * Input adapters that normalize Mermaid and CSV sources into the canonical
- * draw.io YAML-spec object shape used by the DSL compiler.
- */
-
-const SUPPORTED_MERMAID_TYPES = new Set([
-  'flowchart',
-  'graph',
-  'sequencediagram',
-  'classdiagram',
-  'statediagram-v2',
-  'statediagram',
-  'erdiagram',
-  'gantt'
-])
-
-function normalizeId(raw, fallback = 'node') {
-  const cleaned = String(raw || fallback)
-    .trim()
-    .replace(/^[^A-Za-z]+/, '')
-    .replace(/[^A-Za-z0-9_-]+/g, '_')
-  return cleaned || fallback
-}
-
-function inferNodeType(label, explicitType = null) {
-  if (explicitType) return explicitType
-  const lower = String(label || '').toLowerCase()
-  if (!lower) return 'service'
-  if (lower.includes('start') || lower.includes('end')) return 'terminal'
-  if (lower.includes('db') || lower.includes('database') || lower.includes('table')) return 'database'
-  if (lower.includes('decision') || lower.includes('approve') || lower.includes('reject')) return 'decision'
-  if (lower.includes('user') || lower.includes('actor') || lower.includes('client')) return 'user'
-  if (lower.includes('doc') || lower.includes('report') || lower.includes('paper')) return 'document'
-  if (lower.includes('queue') || lower.includes('buffer') || lower.includes('stream')) return 'queue'
-  if (lower.includes('cloud') || lower.includes('internet')) return 'cloud'
-  return 'service'
-}
-
-function parseMermaidNodeToken(token) {
-  const trimmed = token.trim()
-  const match = trimmed.match(/^([A-Za-z0-9_:-]+)\s*(\[[^\]]+\]|\([^)]+\)|\{[^}]+\}|>"[^"]+"|:"[^"]+")?$/)
-  if (!match) {
-    const id = normalizeId(trimmed)
-    return { id, label: trimmed, type: inferNodeType(trimmed) }
-  }
-
-  const [, rawId, decoration] = match
-  const id = normalizeId(rawId)
-  const label = decoration
-    ? decoration
-        .replace(/^[\[\(\{>:"]+/, '')
-        .replace(/[\]\)\}"]+$/, '')
-        .trim()
-    : rawId
-
-  let type = inferNodeType(label)
-  if (decoration?.startsWith('{')) type = 'decision'
-  if (decoration?.startsWith('(')) type = 'terminal'
-  if (decoration?.startsWith('[')) type = inferNodeType(label)
-  return { id, label, type }
-}
-
-function pushNode(nodeMap, nodes, node) {
-  if (!nodeMap.has(node.id)) {
-    nodeMap.set(node.id, node)
-    nodes.push(node)
-    return
-  }
-
-  const current = nodeMap.get(node.id)
-  if (current.label === current.id && node.label && node.label !== node.id) {
-    current.label = node.label
-  }
-  if (current.type === 'service' && node.type && node.type !== 'service') {
-    current.type = node.type
-  }
-  if (!current.module && node.module) {
-    current.module = node.module
-  }
-}
-
-/**
- * Arrow-type to connector-type mapping.
- * Order matters: longer/more-specific patterns must come first so the regex
- * engine matches them before shorter prefixes.
- */
-const ARROW_TYPE_MAP = [
-  { pattern: '-.->', type: 'data' },
-  { pattern: '===>', type: 'primary' },
-  { pattern: '==>', type: 'primary' },
-  { pattern: '-->>', type: 'primary' },
-  { pattern: '->>', type: 'primary' },
-  { pattern: '--x', type: 'optional' },
-  { pattern: '-->', type: 'primary' },
-  { pattern: '---', type: 'bidirectional' },
-  { pattern: '->', type: 'primary' }
-]
-
-function escapeRegex(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-}
-
-const ARROW_SPLIT_RE = new RegExp(ARROW_TYPE_MAP.map((a) => escapeRegex(a.pattern)).join('|'), 'g')
-
-function splitMermaidArrow(line) {
-  const cleaned = line.replace(/\|[^|]+\|/g, ' ')
-
-  // Collect arrows in order of appearance
-  const arrows = []
-  let m
-  const re = new RegExp(ARROW_SPLIT_RE.source, 'g')
-  while ((m = re.exec(cleaned)) !== null) {
-    const mapped = ARROW_TYPE_MAP.find((a) => a.pattern === m[0])
-    arrows.push(mapped ? mapped.type : 'primary')
-  }
-
-  const parts = cleaned
-    .split(ARROW_SPLIT_RE)
-    .map((part) => part.trim())
-    .filter(Boolean)
-  return { parts, arrows }
-}
-
-function parseFlowchart(text, profile = 'default') {
-  const nodes = []
-  const edges = []
-  const nodeMap = new Map()
-  const modules = []
-  const moduleMap = new Map()
-  const subgraphStack = [] // stack of subgraph ids for nesting
-
-  for (const rawLine of text.split(/\r?\n/)) {
-    const line = rawLine.trim()
-    if (!line || line.startsWith('%%') || /^(graph|flowchart)\b/i.test(line)) {
-      continue
-    }
-
-    // Handle subgraph opening
-    const subgraphMatch = line.match(/^subgraph\s+(\S+)(?:\s+\[(.+)\])?/i)
-    if (subgraphMatch) {
-      const rawId = subgraphMatch[1]
-      const id = normalizeId(rawId)
-      const label = subgraphMatch[2] || rawId
-      if (!moduleMap.has(id)) {
-        const mod = { id, label }
-        moduleMap.set(id, mod)
-        modules.push(mod)
-      }
-      subgraphStack.push(id)
-      continue
-    }
-
-    // Handle subgraph closing
-    if (/^end$/i.test(line)) {
-      subgraphStack.pop()
-      continue
-    }
-
-    if (!line.includes('-')) continue
-
-    const { parts, arrows } = splitMermaidArrow(line)
-    if (parts.length < 2) continue
-
-    const currentModule = subgraphStack.length > 0 ? subgraphStack[subgraphStack.length - 1] : undefined
-
-    for (let i = 0; i < parts.length - 1; i++) {
-      const source = parseMermaidNodeToken(parts[i])
-      const target = parseMermaidNodeToken(parts[i + 1])
-      if (currentModule) {
-        source.module = currentModule
-        target.module = currentModule
-      }
-      pushNode(nodeMap, nodes, source)
-      pushNode(nodeMap, nodes, target)
-      const connectorType = arrows[i] || 'primary'
-      edges.push({ from: source.id, to: target.id, type: connectorType })
-    }
-  }
-
-  return {
-    meta: { layout: 'horizontal', profile },
-    nodes,
-    edges,
-    modules
-  }
-}
-
-function parseSequenceDiagram(text, profile = 'default') {
-  const nodes = []
-  const edges = []
-  const nodeMap = new Map()
-
-  for (const rawLine of text.split(/\r?\n/)) {
-    const line = rawLine.trim()
-    if (!line || /^sequencediagram$/i.test(line)) continue
-    if (/^participant\s+/i.test(line)) {
-      const label = line.replace(/^participant\s+/i, '').trim()
-      const id = normalizeId(label)
-      pushNode(nodeMap, nodes, { id, label, type: 'user' })
-      continue
-    }
-
-    const message = line.match(/^([A-Za-z0-9_]+)\s*[-.]*>>?\s*([A-Za-z0-9_]+)\s*:\s*(.+)$/)
-    if (!message) continue
-    const [, rawFrom, rawTo, label] = message
-    const from = { id: normalizeId(rawFrom), label: rawFrom, type: 'user' }
-    const to = { id: normalizeId(rawTo), label: rawTo, type: 'user' }
-    pushNode(nodeMap, nodes, from)
-    pushNode(nodeMap, nodes, to)
-    edges.push({ from: from.id, to: to.id, type: 'primary', label: label.trim() })
-  }
-
-  return {
-    meta: { layout: 'horizontal', profile },
-    nodes,
-    edges,
-    modules: []
-  }
-}
-
-function parseClassDiagram(text, profile = 'default') {
-  const nodes = []
-  const edges = []
-  const nodeMap = new Map()
-
-  for (const rawLine of text.split(/\r?\n/)) {
-    const line = rawLine.trim()
-    if (!line || /^classdiagram$/i.test(line) || line === '}') continue
-    if (/^class\s+/i.test(line)) {
-      const name = line
-        .replace(/^class\s+/i, '')
-        .replace(/\s*\{.*/, '')
-        .trim()
-      const id = normalizeId(name)
-      pushNode(nodeMap, nodes, { id, label: name, type: 'service' })
-      continue
-    }
-
-    const rel = line.match(/^([A-Za-z0-9_]+)\s+([<|o*.\-]+--[<|o*.\-]+|<\|--|--\|>)\s+([A-Za-z0-9_]+)(?:\s*:\s*(.+))?$/)
-    if (!rel) continue
-    const [, rawFrom, , rawTo, label] = rel
-    const from = { id: normalizeId(rawFrom), label: rawFrom, type: 'service' }
-    const to = { id: normalizeId(rawTo), label: rawTo, type: 'service' }
-    pushNode(nodeMap, nodes, from)
-    pushNode(nodeMap, nodes, to)
-    edges.push({ from: from.id, to: to.id, type: 'dependency', label: label?.trim() })
-  }
-
-  return {
-    meta: { layout: 'horizontal', profile },
-    nodes,
-    edges,
-    modules: []
-  }
-}
-
-function parseStateDiagram(text, profile = 'default') {
-  const nodes = []
-  const edges = []
-  const nodeMap = new Map()
-
-  for (const rawLine of text.split(/\r?\n/)) {
-    const line = rawLine.trim()
-    if (!line || /^statediagram/i.test(line)) continue
-    const rel = line.match(/^(.+?)\s*-->\s*(.+?)(?:\s*:\s*(.+))?$/)
-    if (!rel) continue
-    const [, rawFrom, rawTo, label] = rel
-    const fromToken =
-      rawFrom === '[*]' ? { id: 'Start', label: 'Start', type: 'terminal' } : parseMermaidNodeToken(rawFrom)
-    const toToken = rawTo === '[*]' ? { id: 'End', label: 'End', type: 'terminal' } : parseMermaidNodeToken(rawTo)
-    pushNode(nodeMap, nodes, fromToken)
-    pushNode(nodeMap, nodes, toToken)
-    edges.push({ from: fromToken.id, to: toToken.id, type: 'primary', label: label?.trim() })
-  }
-
-  return {
-    meta: { layout: 'vertical', profile },
-    nodes,
-    edges,
-    modules: []
-  }
-}
-
-function parseErDiagram(text, profile = 'default') {
-  const nodes = []
-  const edges = []
-  const nodeMap = new Map()
-
-  for (const rawLine of text.split(/\r?\n/)) {
-    const line = rawLine.trim()
-    if (!line || /^erdiagram$/i.test(line) || line === '}') continue
-    if (/^[A-Z0-9_]+\s*\{$/.test(line)) {
-      const entity = line.replace('{', '').trim()
-      const id = normalizeId(entity)
-      pushNode(nodeMap, nodes, { id, label: entity, type: 'database' })
-      continue
-    }
-
-    const rel = line.match(/^([A-Z0-9_]+)\s+.+\s+([A-Z0-9_]+)\s*:\s*(.+)$/)
-    if (!rel) continue
-    const [, rawFrom, rawTo, label] = rel
-    const from = { id: normalizeId(rawFrom), label: rawFrom, type: 'database' }
-    const to = { id: normalizeId(rawTo), label: rawTo, type: 'database' }
-    pushNode(nodeMap, nodes, from)
-    pushNode(nodeMap, nodes, to)
-    edges.push({ from: from.id, to: to.id, type: 'dependency', label: label.trim() })
-  }
-
-  return {
-    meta: { layout: 'horizontal', profile },
-    nodes,
-    edges,
-    modules: []
-  }
-}
-
-function parseGantt(text, profile = 'default') {
-  const nodes = []
-  const edges = []
-  let section = null
-  let prevTaskId = null
-
-  for (const rawLine of text.split(/\r?\n/)) {
-    const line = rawLine.trim()
-    if (!line || /^gantt$/i.test(line) || /^title\s+/i.test(line) || /^dateFormat\s+/i.test(line)) continue
-    if (/^section\s+/i.test(line)) {
-      section = line.replace(/^section\s+/i, '').trim()
-      prevTaskId = null
-      continue
-    }
-
-    const taskName = line.split(':')[0]?.trim()
-    if (!taskName) continue
-    const id = normalizeId(taskName)
-    nodes.push({ id, label: section ? `${section}: ${taskName}` : taskName, type: 'process' })
-    if (prevTaskId) {
-      edges.push({ from: prevTaskId, to: id, type: 'primary' })
-    }
-    prevTaskId = id
-  }
-
-  return {
-    meta: { layout: 'vertical', profile },
-    nodes,
-    edges,
-    modules: []
-  }
-}
-
-export function parseMermaidToSpec(text, { profile = 'default' } = {}) {
-  const firstLine = text
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .find(Boolean)
-
-  if (!firstLine) {
-    throw new Error('Mermaid input is empty')
-  }
-
-  const type = firstLine.toLowerCase()
-  if (!SUPPORTED_MERMAID_TYPES.has(type.split(/\s+/)[0])) {
-    throw new Error(`Unsupported Mermaid diagram type "${firstLine}"`)
-  }
-
-  if (type.startsWith('flowchart') || type.startsWith('graph')) return parseFlowchart(text, profile)
-  if (type.startsWith('sequencediagram')) return parseSequenceDiagram(text, profile)
-  if (type.startsWith('classdiagram')) return parseClassDiagram(text, profile)
-  if (type.startsWith('statediagram')) return parseStateDiagram(text, profile)
-  if (type.startsWith('erdiagram')) return parseErDiagram(text, profile)
-  if (type.startsWith('gantt')) return parseGantt(text, profile)
-
-  throw new Error(`Unsupported Mermaid diagram type "${firstLine}"`)
-}
-
-function splitCsvLine(line) {
-  const cells = []
-  let current = ''
-  let inQuotes = false
-
-  for (let i = 0; i < line.length; i++) {
-    const ch = line[i]
-    if (ch === '"') {
-      if (inQuotes && line[i + 1] === '"') {
-        current += '"'
-        i++
-      } else {
-        inQuotes = !inQuotes
-      }
-      continue
-    }
-    if (ch === ',' && !inQuotes) {
-      cells.push(current.trim())
-      current = ''
-      continue
-    }
-    current += ch
-  }
-  cells.push(current.trim())
-  return cells
-}
-
-export function parseCsvToSpec(text, { profile = 'default' } = {}) {
-  const rows = text
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter((line) => line && !line.startsWith('#'))
-
-  if (rows.length < 2) {
-    throw new Error('CSV input must include a header row and at least one data row')
-  }
-
-  const headers = splitCsvLine(rows[0]).map((cell) => cell.trim())
-  if (!headers.includes('name') || !headers.includes('parent')) {
-    throw new Error('CSV input must include "name" and "parent" columns')
-  }
-
-  const nameIndex = headers.indexOf('name')
-  const parentIndex = headers.indexOf('parent')
-  const labelIndex = headers.indexOf('label')
-  const typeIndex = headers.indexOf('type')
-  const moduleIndex = headers.indexOf('module')
-
-  const nodes = []
-  const edges = []
-  const nodeMap = new Map()
-
-  for (const row of rows.slice(1)) {
-    const values = splitCsvLine(row)
-    const rawName = values[nameIndex]
-    if (!rawName) continue
-    const label = values[labelIndex] || rawName
-    const node = {
-      id: normalizeId(rawName),
-      label,
-      type: inferNodeType(label, values[typeIndex]),
-      module: values[moduleIndex] || undefined
-    }
-    pushNode(nodeMap, nodes, node)
-
-    const rawParent = values[parentIndex]
-    if (rawParent) {
-      edges.push({
-        from: normalizeId(rawParent),
-        to: node.id,
-        type: 'primary'
-      })
-      pushNode(nodeMap, nodes, {
-        id: normalizeId(rawParent),
-        label: rawParent,
-        type: 'service'
-      })
-    }
-  }
-
-  return {
-    meta: { layout: 'vertical', profile },
-    nodes,
-    edges,
-    modules: []
-  }
-}
-
-export * from './identity.js'
-export { finalizeGraphProjection } from './graph-projection.js'
-export { projectGraphToSpec } from './projection-to-spec.js'
-export { parseTerraformConfig, TERRAFORM_ATTRIBUTE_ALLOWLIST, buildTerraformIdentityInput } from './terraform-config.js'
-export { parseTerraformStateSnapshot } from './terraform-state.js'
-export {
-  parseKubernetesManifests,
-  parseKubernetesLiveSnapshot,
-  KUBERNETES_ATTRIBUTE_ALLOWLIST,
-  buildKubernetesIdentityInput
-} from './kubernetes.js'
-export { parseComposeConfig, COMPOSE_ATTRIBUTE_ALLOWLIST, buildComposeIdentityInput } from './compose.js'
-export { parseDockerInspectSnapshot } from './docker-inspect.js'
-export {
-  compareGraphProjections,
-  createDriftProjection,
-  projectDriftReportToSpec,
-  renderDriftGraph
-} from './graph-drift.js'
-export { parseSqlDdl, SQL_ATTRIBUTE_ALLOWLIST } from './sql-ddl.js'
-export { parseOpenApiDocument, OPENAPI_ATTRIBUTE_ALLOWLIST } from './openapi.js'
-export { parseCiWorkflow, CI_ATTRIBUTE_ALLOWLIST } from './ci.js'
-export { parsePythonImportsProject, parsePythonClassesProject } from './python-code.js'
-export { parseJavaScriptImportsProject } from './js-code.js'
-export { parseGoImportsProject } from './go-code.js'
-export { parseRustImportsProject } from './rust-code.js'
-export { parseRasterExtraction } from './raster-extraction.js'

package/template/.claude/skills/drawio/scripts/adapters/index.test.js

@@ -1,152 +0,0 @@
-/**
- * index.test.js
- * Unit tests for Mermaid and CSV input adapters
- * Uses Node.js built-in test runner
- */
-
-import { describe, it } from 'node:test'
-import assert from 'node:assert'
-import { parseMermaidToSpec, parseCsvToSpec } from './index.js'
-
-// ============================================================================
-// Mermaid Adapter Tests
-// ============================================================================
-
-describe('parseMermaidToSpec', () => {
-  describe('flowchart', () => {
-    it('should parse a simple flowchart LR with nodes and edges', () => {
-      const input = 'flowchart LR\n  A[Start] --> B[Process] --> C[End]'
-      const spec = parseMermaidToSpec(input)
-
-      assert.ok(spec.nodes.length >= 3, `Expected at least 3 nodes, got ${spec.nodes.length}`)
-      const ids = spec.nodes.map((n) => n.id)
-      assert.ok(ids.includes('A'), 'Should contain node A')
-      assert.ok(ids.includes('B'), 'Should contain node B')
-      assert.ok(ids.includes('C'), 'Should contain node C')
-
-      assert.ok(spec.edges.length >= 2, `Expected at least 2 edges, got ${spec.edges.length}`)
-      assert.strictEqual(spec.edges[0].from, 'A')
-      assert.strictEqual(spec.edges[0].to, 'B')
-      assert.strictEqual(spec.edges[1].from, 'B')
-      assert.strictEqual(spec.edges[1].to, 'C')
-
-      assert.strictEqual(spec.meta.layout, 'horizontal', 'Flowchart should have horizontal layout')
-    })
-  })
-
-  describe('sequence diagram', () => {
-    it('should parse participants as user type nodes', () => {
-      const input = 'sequenceDiagram\n  Alice->>Bob: Hello'
-      const spec = parseMermaidToSpec(input)
-
-      assert.ok(spec.nodes.length >= 2, `Expected at least 2 nodes, got ${spec.nodes.length}`)
-      for (const node of spec.nodes) {
-        assert.strictEqual(node.type, 'user', `Node "${node.label}" should be type "user"`)
-      }
-
-      assert.ok(spec.edges.length >= 1, 'Should have at least 1 edge')
-      assert.strictEqual(spec.edges[0].label, 'Hello')
-    })
-  })
-
-  describe('state diagram', () => {
-    it('should parse [*] as Start/End terminal types', () => {
-      const input = 'stateDiagram-v2\n  [*] --> Active\n  Active --> [*]'
-      const spec = parseMermaidToSpec(input)
-
-      const startNode = spec.nodes.find((n) => n.id === 'Start')
-      const endNode = spec.nodes.find((n) => n.id === 'End')
-      assert.ok(startNode, 'Should have a Start node')
-      assert.ok(endNode, 'Should have an End node')
-      assert.strictEqual(startNode.type, 'terminal', 'Start node should be terminal type')
-      assert.strictEqual(endNode.type, 'terminal', 'End node should be terminal type')
-
-      assert.ok(spec.edges.length >= 2, `Expected at least 2 edges, got ${spec.edges.length}`)
-    })
-  })
-
-  describe('ER diagram', () => {
-    it('should parse entities as database type nodes', () => {
-      const input = 'erDiagram\n  CUSTOMER ||--o{ ORDER : places'
-      const spec = parseMermaidToSpec(input)
-
-      assert.ok(spec.nodes.length >= 2, `Expected at least 2 nodes, got ${spec.nodes.length}`)
-      for (const node of spec.nodes) {
-        assert.strictEqual(node.type, 'database', `Node "${node.label}" should be type "database"`)
-      }
-
-      assert.ok(spec.edges.length >= 1, 'Should have at least 1 edge')
-      assert.strictEqual(spec.edges[0].label, 'places')
-    })
-  })
-
-  describe('class diagram', () => {
-    it('should parse classes as service type nodes', () => {
-      const input = 'classDiagram\n  Animal <|-- Dog'
-      const spec = parseMermaidToSpec(input)
-
-      assert.ok(spec.nodes.length >= 2, `Expected at least 2 nodes, got ${spec.nodes.length}`)
-      for (const node of spec.nodes) {
-        assert.strictEqual(node.type, 'service', `Node "${node.label}" should be type "service"`)
-      }
-
-      assert.ok(spec.edges.length >= 1, 'Should have at least 1 edge')
-    })
-  })
-
-  describe('error handling', () => {
-    it('should throw on empty input', () => {
-      assert.throws(() => parseMermaidToSpec(''), { message: 'Mermaid input is empty' })
-      assert.throws(() => parseMermaidToSpec('   \n  \n  '), { message: 'Mermaid input is empty' })
-    })
-
-    it('should throw on unsupported diagram type', () => {
-      assert.throws(() => parseMermaidToSpec('pie\n  "A": 50\n  "B": 50'), /Unsupported Mermaid diagram type/)
-    })
-  })
-})
-
-// ============================================================================
-// CSV Adapter Tests
-// ============================================================================
-
-describe('parseCsvToSpec', () => {
-  it('should parse CSV with name and parent columns into nodes and edges', () => {
-    const input = ['name,parent', 'Root,', 'Child1,Root', 'Child2,Root'].join('\n')
-
-    const spec = parseCsvToSpec(input)
-
-    assert.ok(spec.nodes.length >= 3, `Expected at least 3 nodes, got ${spec.nodes.length}`)
-    const ids = spec.nodes.map((n) => n.id)
-    assert.ok(ids.includes('Root'), 'Should contain Root node')
-    assert.ok(ids.includes('Child1'), 'Should contain Child1 node')
-    assert.ok(ids.includes('Child2'), 'Should contain Child2 node')
-
-    assert.ok(spec.edges.length >= 2, `Expected at least 2 edges, got ${spec.edges.length}`)
-    const edgePairs = spec.edges.map((e) => `${e.from}->${e.to}`)
-    assert.ok(edgePairs.includes('Root->Child1'), 'Should have edge Root->Child1')
-    assert.ok(edgePairs.includes('Root->Child2'), 'Should have edge Root->Child2')
-  })
-
-  it('should respect explicit type column', () => {
-    const input = ['name,parent,type', 'MyDB,,database', 'MyService,MyDB,queue'].join('\n')
-
-    const spec = parseCsvToSpec(input)
-
-    const dbNode = spec.nodes.find((n) => n.id === 'MyDB')
-    const svcNode = spec.nodes.find((n) => n.id === 'MyService')
-    assert.ok(dbNode, 'Should have MyDB node')
-    assert.ok(svcNode, 'Should have MyService node')
-    assert.strictEqual(dbNode.type, 'database', 'MyDB should have type "database"')
-    assert.strictEqual(svcNode.type, 'queue', 'MyService should have type "queue"')
-  })
-
-  it('should throw when name or parent columns are missing', () => {
-    assert.throws(() => parseCsvToSpec('label,description\nFoo,Bar'), {
-      message: 'CSV input must include "name" and "parent" columns'
-    })
-    assert.throws(() => parseCsvToSpec('name,description\nFoo,Bar'), {
-      message: 'CSV input must include "name" and "parent" columns'
-    })
-  })
-})

package/template/.claude/skills/drawio/scripts/adapters/js-code-adapter.test.js

@@ -1,42 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { parseJavaScriptImportsProject } from './js-code.js'
-
-test('JS/TS adapter resolves ESM static and string-literal dynamic imports', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'drawio-js-'))
-  try {
-    writeFileSync(join(root, 'a.ts'), "import './b.js'\nimport('./c.ts')\nimport 'react'\n")
-    writeFileSync(join(root, 'b.js'), 'export const b = 1\n')
-    writeFileSync(join(root, 'c.ts'), 'export const c = 1\n')
-    const projection = await parseJavaScriptImportsProject(root, {
-      parseModule: (source) => (source.includes('react') ? ['./b.js', './c.ts', 'react'] : [])
-    })
-
-    assert.deepEqual(projection.nodes.map((node) => node.identity.key), [
-      'javascript/b.js',
-      'typescript/a.ts',
-      'typescript/c.ts'
-    ])
-    assert.deepEqual(projection.edges.map((edge) => edge.to.key), ['javascript/b.js', 'typescript/c.ts'])
-    assert.ok(projection.diagnostics.some((entry) => entry.code === 'JS_NON_RELATIVE_IMPORTS_IGNORED'))
-  } finally {
-    rmSync(root, { recursive: true, force: true })
-  }
-})
-
-test('JS/TS unresolved relative imports fail instead of silently dropping an edge', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'drawio-js-'))
-  try {
-    writeFileSync(join(root, 'a.js'), "import './missing.js'\n")
-    await assert.rejects(
-      () => parseJavaScriptImportsProject(root, { parseModule: () => ['./missing.js'] }),
-      (error) => error.code === 'ADAPTER_UNSUPPORTED' && error.context.path === 'a.js'
-    )
-  } finally {
-    rmSync(root, { recursive: true, force: true })
-  }
-})