create-yss-spec 2.1.4 → 2.1.6

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

@@ -1,207 +0,0 @@
-import { posix } from 'node:path'
-
-import {
-  aggregateDiagnostic,
-  codeAdapterError,
-  finalizeCodeProjection,
-  loadOptionalParser,
-  moduleNode,
-  scanDiagnostics,
-  scanCodeProject
-} from './code-common.js'
-import { ERROR_CODES, createCodeIdentity, serializeIdentity } from './identity.js'
-
-function pathParts(node) {
-  if (!node) return []
-  if (['crate', 'self', 'super', 'identifier'].includes(node.type)) return [node.text]
-  if (node.type === 'scoped_identifier') {
-    return [...pathParts(node.childForFieldName('path')), ...pathParts(node.childForFieldName('name'))]
-  }
-  if (node.type === 'use_as_clause') return pathParts(node.childForFieldName('path'))
-  if (node.type === 'use_wildcard') return pathParts(node.namedChildren[0])
-  return []
-}
-
-function expandUseNode(node, prefix = []) {
-  if (!node) return []
-  if (node.type === 'scoped_use_list') {
-    const nextPrefix = [...prefix, ...pathParts(node.childForFieldName('path'))]
-    return expandUseNode(node.childForFieldName('list'), nextPrefix)
-  }
-  if (node.type === 'use_list') {
-    return node.namedChildren.flatMap((child) => expandUseNode(child, prefix))
-  }
-  const parts = pathParts(node)
-  return parts.length > 0 ? [[...prefix, ...parts]] : []
-}
-
-async function createRustSourceParser() {
-  const [parserModule, grammarModule] = await Promise.all([
-    loadOptionalParser('tree-sitter', 'tree-sitter@0.21.1'),
-    loadOptionalParser('tree-sitter-rust', 'tree-sitter-rust@0.23.0')
-  ])
-  const Parser = parserModule.default || parserModule
-  const grammar = grammarModule.default || grammarModule
-  let parser
-  try {
-    parser = new Parser()
-    parser.setLanguage(grammar)
-  } catch (error) {
-    codeAdapterError(ERROR_CODES.ADAPTER_PARSE, 'Rust Tree-sitter parser could not be initialized', {}, error)
-  }
-  return (source, path) => {
-    let root
-    try {
-      root = parser.parse(source).rootNode
-    } catch (error) {
-      codeAdapterError(ERROR_CODES.ADAPTER_PARSE, 'Rust source could not be parsed', { path }, error)
-    }
-    if (root.hasError) {
-      const errorNode = root.descendantsOfType('ERROR')[0] || root
-      codeAdapterError(ERROR_CODES.ADAPTER_PARSE, 'Rust source contains invalid syntax', {
-        path,
-        line: errorNode.startPosition.row + 1,
-        column: errorNode.startPosition.column
-      })
-    }
-    const attributes = root.descendantsOfType('attribute_item')
-    const attributeNames = new Set(
-      attributes.map((node) => node.namedChildren[0]?.namedChildren[0]?.text).filter(Boolean)
-    )
-    const hasInlineModules = root
-      .descendantsOfType('mod_item')
-      .some((node) => node.childForFieldName('body') != null || node.namedChildren.some((child) => child.type === 'declaration_list'))
-    const uses = root
-      .descendantsOfType('use_declaration')
-      .flatMap((node) => expandUseNode(node.childForFieldName('argument')))
-      .map((parts) => parts.join('::'))
-    return {
-      uses,
-      hasCfg: attributeNames.has('cfg') || attributeNames.has('cfg_attr'),
-      hasPathAttributes: attributeNames.has('path'),
-      hasInlineModules
-    }
-  }
-}
-
-function moduleSegments(filePath) {
-  const parts = filePath.slice(0, -3).split('/')
-  if (parts[0] === 'src') parts.shift()
-  if (['lib', 'main', 'mod'].includes(parts.at(-1))) parts.pop()
-  return parts
-}
-
-function moduleKey(parts) {
-  return parts.join('::')
-}
-
-function targetSegments(usePath, current, path) {
-  const parts = usePath.split('::').filter(Boolean)
-  const root = parts.shift()
-  if (root === 'crate') return parts
-  if (root === 'self') return [...current, ...parts]
-  if (root !== 'super') return null
-  let levels = 1
-  while (parts[0] === 'super') {
-    parts.shift()
-    levels++
-  }
-  if (levels > current.length) {
-    codeAdapterError(ERROR_CODES.ADAPTER_UNSUPPORTED, 'Rust super path escapes the selected crate', { path })
-  }
-  return [...current.slice(0, current.length - levels), ...parts]
-}
-
-function resolveRustModule(parts, modules) {
-  const candidate = [...parts]
-  while (candidate.length >= 0) {
-    const path = modules.get(moduleKey(candidate))
-    if (path) return path
-    if (candidate.length === 0) break
-    candidate.pop()
-  }
-  return null
-}
-
-export async function parseRustImportsProject(projectRoot, { locator = 'project', parseFile } = {}) {
-  const scan = scanCodeProject(projectRoot, { extensions: ['.rs'] })
-  if (scan.files.length === 0) codeAdapterError(ERROR_CODES.ADAPTER_UNSUPPORTED, 'Rust project contains no source files')
-  const sourceParser = parseFile || await createRustSourceParser()
-  const modules = new Map()
-  for (const file of scan.files) {
-    const key = moduleKey(moduleSegments(file.path))
-    if (modules.has(key)) {
-      codeAdapterError(ERROR_CODES.ADAPTER_UNSUPPORTED, 'Rust module path is ambiguous in the selected project', {
-        path: file.path
-      })
-    }
-    modules.set(key, file.path)
-  }
-  const identities = new Map(
-    scan.files.map((file) => [file.path, createCodeIdentity({ language: 'rust', modulePath: file.path })])
-  )
-  const nodes = scan.files.map((file) => moduleNode('rust', file.path))
-  const edges = []
-  const seenEdges = new Set()
-  let ignored = 0
-
-  for (const file of scan.files) {
-    let parsed
-    try {
-      parsed = await sourceParser(file.source, file.path)
-    } catch (error) {
-      if (error?.code) throw error
-      codeAdapterError(ERROR_CODES.ADAPTER_PARSE, 'Rust source could not be parsed', { path: file.path }, error)
-    }
-    if (
-      !parsed ||
-      !Array.isArray(parsed.uses) ||
-      !parsed.uses.every((value) => typeof value === 'string') ||
-      typeof parsed.hasCfg !== 'boolean' ||
-      typeof parsed.hasInlineModules !== 'boolean'
-    ) {
-      codeAdapterError(ERROR_CODES.ADAPTER_PARSE, 'Rust parser returned an invalid result', { path: file.path })
-    }
-    if (parsed.hasCfg || parsed.hasInlineModules || parsed.hasPathAttributes === true) {
-      codeAdapterError(ERROR_CODES.ADAPTER_UNSUPPORTED, 'Rust cfg, path attributes, and inline modules are not supported', {
-        path: file.path
-      })
-    }
-    const current = moduleSegments(file.path)
-    for (const usePath of parsed.uses) {
-      const target = targetSegments(usePath, current, file.path)
-      if (target == null) {
-        ignored++
-        continue
-      }
-      const targetPath = resolveRustModule(target, modules)
-      if (!targetPath) {
-        codeAdapterError(ERROR_CODES.ADAPTER_UNSUPPORTED, 'Rust crate-local use does not resolve to a scanned module', {
-          path: file.path
-        })
-      }
-      const from = identities.get(file.path)
-      const to = identities.get(targetPath)
-      if (serializeIdentity(from) === serializeIdentity(to)) continue
-      const key = `${serializeIdentity(from)}\0uses\0${serializeIdentity(to)}`
-      if (seenEdges.has(key)) continue
-      seenEdges.add(key)
-      edges.push({ from, to, relation: 'uses', attributes: {} })
-    }
-  }
-
-  return finalizeCodeProjection({
-    adapter: 'rust-imports',
-    locator,
-    nodes,
-    edges,
-    diagnostics: [
-      ...aggregateDiagnostic(
-        'RUST_NON_CRATE_USES_IGNORED',
-        ignored,
-        'Non-crate-qualified uses were not resolved; external crates and edition-ambiguous paths were ignored.'
-      ),
-      ...scanDiagnostics(scan)
-    ]
-  })
-}

package/template/.claude/skills/drawio/scripts/adapters/sql-ddl.js

@@ -1,118 +0,0 @@
-import {
-  AdapterContractError,
-  ERROR_CODES,
-  createGroupIdentity,
-  createSqlIdentity
-} from './identity.js'
-import {
-  adapterError,
-  assertSourceText,
-  diagnostic,
-  finalizeConfigProjection,
-  isRecord,
-  pushUniqueEdge
-} from './config-common.js'
-import { runOptionalPythonParser } from './optional-python.js'
-
-const ADAPTER = 'sql-ddl'
-
-export const SQL_ATTRIBUTE_ALLOWLIST = Object.freeze({
-  node: ['columnCount', 'columns', 'dialect', 'schema'],
-  edge: ['columns', 'targetColumns'],
-  module: ['dialect', 'schema']
-})
-
-function validateWorkerResult(result) {
-  if (!isRecord(result) || !Array.isArray(result.tables) || !Array.isArray(result.diagnostics || [])) {
-    adapterError(ERROR_CODES.ADAPTER_PARSE, 'SQL parser returned an invalid record set', { adapter: ADAPTER })
-  }
-  return result
-}
-
-function columnSummary(column) {
-  if (!isRecord(column) || typeof column.name !== 'string' || typeof column.type !== 'string') {
-    adapterError(ERROR_CODES.ADAPTER_PARSE, 'SQL parser returned an invalid column record', { adapter: ADAPTER })
-  }
-  return [column.name, column.type, column.primaryKey ? 'pk' : 'column', column.nullable === false ? 'required' : 'nullable'].join(':')
-}
-
-export function parseSqlDdl(
-  source,
-  { dialect = 'postgres', defaultSchema = '_default', locator = 'schema.sql', runParser = runOptionalPythonParser } = {}
-) {
-  assertSourceText(source, ADAPTER)
-  let result
-  try {
-    result = validateWorkerResult(runParser({ adapter: 'sql', source, dialect, defaultSchema }))
-  } catch (error) {
-    if (error instanceof AdapterContractError || error?.code) throw error
-    adapterError(ERROR_CODES.ADAPTER_PARSE, 'SQL parser failed', { adapter: ADAPTER }, error)
-  }
-
-  const identities = new Map()
-  const moduleIdentities = new Map()
-  const nodes = result.tables.map((table) => {
-    if (!isRecord(table) || typeof table.schema !== 'string' || typeof table.name !== 'string' || !Array.isArray(table.columns)) {
-      adapterError(ERROR_CODES.ADAPTER_PARSE, 'SQL parser returned an invalid table record', { adapter: ADAPTER })
-    }
-    const identity = createSqlIdentity({ dialect, schema: table.schema, table: table.name })
-    identities.set(`${table.schema}\0${table.name}`, identity)
-    if (!moduleIdentities.has(table.schema)) {
-      moduleIdentities.set(table.schema, createGroupIdentity({ domain: 'sql-schema', key: `${dialect}/${table.schema}` }))
-    }
-    const columns = table.columns.map(columnSummary)
-    return {
-      identity,
-      label: `${table.schema}.${table.name}`,
-      semanticType: 'database',
-      moduleIdentity: moduleIdentities.get(table.schema),
-      attributes: { dialect, schema: table.schema, columnCount: columns.length, columns }
-    }
-  })
-  const modules = [...moduleIdentities].map(([schema, identity]) => ({
-    identity,
-    label: schema,
-    attributes: { dialect, schema }
-  }))
-  const edges = []
-  const edgeKeys = new Set()
-  const diagnostics = (result.diagnostics || []).map((entry) =>
-    diagnostic(
-      typeof entry?.code === 'string' ? entry.code : 'SQL_DIAGNOSTIC',
-      typeof entry?.message === 'string' ? entry.message : 'SQL parser emitted a diagnostic.'
-    )
-  )
-
-  for (const table of result.tables) {
-    const from = identities.get(`${table.schema}\0${table.name}`)
-    for (const foreignKey of Array.isArray(table.foreignKeys) ? table.foreignKeys : []) {
-      if (!isRecord(foreignKey) || typeof foreignKey.targetSchema !== 'string' || typeof foreignKey.targetTable !== 'string') {
-        adapterError(ERROR_CODES.ADAPTER_PARSE, 'SQL parser returned an invalid foreign-key record', { adapter: ADAPTER })
-      }
-      const to = identities.get(`${foreignKey.targetSchema}\0${foreignKey.targetTable}`)
-      if (!to) {
-        adapterError(
-          ERROR_CODES.ADAPTER_UNSUPPORTED,
-          `SQL foreign key target table ${foreignKey.targetSchema}.${foreignKey.targetTable} is not present`,
-          { adapter: ADAPTER }
-        )
-      }
-      const columns = Array.isArray(foreignKey.columns) ? foreignKey.columns.map(String) : []
-      const targetColumns = Array.isArray(foreignKey.targetColumns) ? foreignKey.targetColumns.map(String) : []
-      const sourceName = foreignKey.name || 'fk'
-      const discriminator = `${sourceName}:${columns.join(',')}->${targetColumns.join(',')}`
-      pushUniqueEdge(edges, edgeKeys, {
-        from,
-        to,
-        relation: 'foreign-key',
-        discriminator,
-        attributes: { columns, targetColumns }
-      })
-    }
-  }
-
-  return finalizeConfigProjection(
-    { adapter: ADAPTER, domain: 'sql', locator, nodes, edges, modules, diagnostics },
-    SQL_ATTRIBUTE_ALLOWLIST
-  )
-}

package/template/.claude/skills/drawio/scripts/adapters/sql-ddl.test.js

@@ -1,56 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-
-import { ERROR_CODES } from './identity.js'
-import { parseSqlDdl, SQL_ATTRIBUTE_ALLOWLIST } from './sql-ddl.js'
-
-const records = {
-  tables: [
-    {
-      schema: 'public',
-      name: 'users',
-      columns: [{ name: 'id', type: 'INT', primaryKey: true, nullable: false }],
-      foreignKeys: []
-    },
-    {
-      schema: 'sales',
-      name: 'orders',
-      columns: [
-        { name: 'id', type: 'INT', primaryKey: true, nullable: false },
-        { name: 'user_id', type: 'INT', primaryKey: false, nullable: false }
-      ],
-      foreignKeys: [
-        {
-          name: 'orders_user_fk',
-          columns: ['user_id'],
-          targetSchema: 'public',
-          targetTable: 'users',
-          targetColumns: ['id']
-        }
-      ]
-    }
-  ],
-  diagnostics: []
-}
-
-test('parseSqlDdl projects schema-qualified tables and stable foreign keys', () => {
-  const projection = parseSqlDdl('CREATE TABLE ...', {
-    dialect: 'postgres',
-    locator: 'db/schema.sql',
-    runParser: () => records
-  })
-
-  assert.deepEqual(projection.nodes.map((node) => node.identity.key), ['postgres/public/users', 'postgres/sales/orders'])
-  assert.equal(projection.edges[0].relation, 'foreign-key')
-  assert.equal(projection.edges[0].discriminator, 'orders_user_fk:user_id->id')
-  assert.equal(projection.nodes[1].attributes.columns[0], 'id:INT:pk:required')
-  assert.deepEqual(SQL_ATTRIBUTE_ALLOWLIST.node, ['columnCount', 'columns', 'dialect', 'schema'])
-})
-
-test('parseSqlDdl rejects foreign keys whose target table is absent', () => {
-  const incomplete = { ...records, tables: [records.tables[1]] }
-  assert.throws(
-    () => parseSqlDdl('x', { dialect: 'postgres', locator: 'db/schema.sql', runParser: () => incomplete }),
-    (error) => error.code === ERROR_CODES.ADAPTER_UNSUPPORTED && /target table/.test(error.message)
-  )
-})

package/template/.claude/skills/drawio/scripts/adapters/terraform-config.js

@@ -1,141 +0,0 @@
-import {
-  AdapterContractError,
-  ERROR_CODES,
-  createGroupIdentity,
-  createTerraformIdentity
-} from './identity.js'
-import {
-  adapterError,
-  assertSourceText,
-  diagnostic,
-  finalizeConfigProjection,
-  isRecord,
-  pushUniqueEdge
-} from './config-common.js'
-import { runOptionalPythonParser } from './optional-python.js'
-
-const ADAPTER = 'terraform-config'
-
-export const TERRAFORM_ATTRIBUTE_ALLOWLIST = Object.freeze({
-  node: ['module', 'provider', 'resourceType'],
-  edge: [],
-  module: ['path']
-})
-
-export function terraformModulePath(address) {
-  const parts = address.split('.')
-  return parts.length > 2 ? parts.slice(0, -2).join('.') : '_root'
-}
-
-export function terraformResourceLabel(address) {
-  return address.split('.').slice(-2).join('.')
-}
-
-function validateWorkerResult(result) {
-  if (!isRecord(result) || !Array.isArray(result.resources) || !Array.isArray(result.diagnostics || [])) {
-    adapterError(ERROR_CODES.ADAPTER_PARSE, 'Terraform parser returned an invalid record set', { adapter: ADAPTER })
-  }
-  return result
-}
-
-export function buildTerraformIdentityInput(resource) {
-  if (!isRecord(resource) || typeof resource.address !== 'string') {
-    adapterError(ERROR_CODES.ADAPTER_PARSE, 'Terraform resource record requires an address', { adapter: ADAPTER })
-  }
-  return resource.address
-}
-
-export function buildTerraformNodeAttributes(resource) {
-  if (
-    !isRecord(resource) ||
-    typeof resource.address !== 'string' ||
-    typeof resource.resourceType !== 'string' ||
-    typeof resource.provider !== 'string'
-  ) {
-    adapterError(ERROR_CODES.ADAPTER_PARSE, 'Terraform resource record requires address, resourceType, and provider', {
-      adapter: ADAPTER
-    })
-  }
-  return {
-    module: terraformModulePath(resource.address),
-    provider: resource.provider,
-    resourceType: resource.resourceType
-  }
-}
-
-export function parseTerraformConfig(
-  source,
-  { locator = 'main.tf', moduleAddress = '', runParser = runOptionalPythonParser } = {}
-) {
-  assertSourceText(source, ADAPTER)
-  let result
-  try {
-    result = validateWorkerResult(runParser({ adapter: 'terraform', source, moduleAddress }))
-  } catch (error) {
-    if (error instanceof AdapterContractError || error?.code) throw error
-    adapterError(ERROR_CODES.ADAPTER_PARSE, 'Terraform parser failed', { adapter: ADAPTER }, error)
-  }
-
-  const identities = new Map()
-  const moduleIdentities = new Map()
-  const nodes = result.resources.map((resource) => {
-    if (!isRecord(resource) || typeof resource.resourceType !== 'string' || typeof resource.provider !== 'string') {
-      adapterError(ERROR_CODES.ADAPTER_PARSE, 'Terraform parser returned an invalid resource record', { adapter: ADAPTER })
-    }
-    const identity = createTerraformIdentity(buildTerraformIdentityInput(resource))
-    identities.set(resource.address, identity)
-    const attributes = buildTerraformNodeAttributes(resource)
-    const module = attributes.module
-    if (!moduleIdentities.has(module)) {
-      moduleIdentities.set(module, createGroupIdentity({ domain: 'terraform', key: module }))
-    }
-    return {
-      identity,
-      label: terraformResourceLabel(resource.address),
-      semanticType: resource.resourceType.includes('database') || resource.resourceType.includes('db_') ? 'database' : 'service',
-      moduleIdentity: moduleIdentities.get(module),
-      attributes
-    }
-  })
-  const modules = [...moduleIdentities].map(([path, identity]) => ({
-    identity,
-    label: path === '_root' ? 'root' : path,
-    attributes: { path }
-  }))
-  const edges = []
-  const edgeKeys = new Set()
-  const diagnostics = (result.diagnostics || []).map((entry) =>
-    diagnostic(
-      typeof entry?.code === 'string' ? entry.code : 'TERRAFORM_DIAGNOSTIC',
-      typeof entry?.message === 'string' ? entry.message : 'Terraform parser emitted a diagnostic.'
-    )
-  )
-
-  for (const resource of result.resources) {
-    const from = identities.get(resource.address)
-    for (const [relation, references] of [
-      ['depends-on', resource.dependsOn],
-      ['references', resource.references]
-    ]) {
-      for (const targetAddress of Array.isArray(references) ? references : []) {
-        const to = identities.get(targetAddress)
-        if (!to) {
-          diagnostics.push(diagnostic('TERRAFORM_EXTERNAL_REF', `${resource.address} references external resource ${targetAddress}.`, from))
-          continue
-        }
-        pushUniqueEdge(edges, edgeKeys, {
-          from,
-          to,
-          relation,
-          discriminator: `${relation}:${targetAddress}`,
-          attributes: {}
-        })
-      }
-    }
-  }
-
-  return finalizeConfigProjection(
-    { adapter: ADAPTER, domain: 'terraform', locator, nodes, edges, modules, diagnostics },
-    TERRAFORM_ATTRIBUTE_ALLOWLIST
-  )
-}

package/template/.claude/skills/drawio/scripts/adapters/terraform-config.test.js

@@ -1,67 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-
-import { ERROR_CODES } from './identity.js'
-import { parseTerraformConfig, TERRAFORM_ATTRIBUTE_ALLOWLIST } from './terraform-config.js'
-
-const records = {
-  resources: [
-    {
-      address: 'module.api.aws_instance.web',
-      resourceType: 'aws_instance',
-      provider: 'aws',
-      references: ['module.net.aws_security_group.web'],
-      dependsOn: []
-    },
-    {
-      address: 'module.net.aws_security_group.web',
-      resourceType: 'aws_security_group',
-      provider: 'aws',
-      references: [],
-      dependsOn: []
-    }
-  ],
-  diagnostics: []
-}
-
-test('parseTerraformConfig uses worker records and shared Terraform identities', () => {
-  const projection = parseTerraformConfig('resource "aws_instance" "web" {}', {
-    locator: 'infra/main.tf',
-    runParser: () => records
-  })
-
-  assert.equal(projection.source.adapter, 'terraform-config')
-  assert.deepEqual(projection.nodes.map((node) => node.identity.key), [
-    'module.api.aws_instance.web',
-    'module.net.aws_security_group.web'
-  ])
-  assert.equal(projection.edges[0].relation, 'references')
-  assert.equal(projection.nodes[0].attributes.resourceType, 'aws_instance')
-  assert.deepEqual(TERRAFORM_ATTRIBUTE_ALLOWLIST.node, ['module', 'provider', 'resourceType'])
-})
-
-test('parseTerraformConfig keeps identity stable across labels and record order', () => {
-  const reversed = { ...records, resources: [...records.resources].reverse() }
-  const first = parseTerraformConfig('x', { locator: 'infra/main.tf', runParser: () => records })
-  const second = parseTerraformConfig('x', { locator: 'other/main.tf', runParser: () => reversed })
-
-  assert.deepEqual(
-    first.nodes.map((node) => node.identity),
-    second.nodes.map((node) => node.identity)
-  )
-})
-
-test('parseTerraformConfig preserves optional dependency errors', () => {
-  assert.throws(
-    () =>
-      parseTerraformConfig('x', {
-        locator: 'infra/main.tf',
-        runParser: () => {
-          const error = new Error('python-hcl2 is unavailable')
-          error.code = ERROR_CODES.OPTIONAL_DEPENDENCY_MISSING
-          throw error
-        }
-      }),
-    (error) => error.code === ERROR_CODES.OPTIONAL_DEPENDENCY_MISSING
-  )
-})