create-yss-spec 2.1.4 → 2.1.6

package/template/.qoder/skills/drawio/scripts/adapters/optional-python.integration.test.js

@@ -1,32 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-
-import { parseSqlDdl } from './sql-ddl.js'
-import { parseTerraformConfig } from './terraform-config.js'
-import { runOptionalPythonParser } from './optional-python.js'
-
-const pythonCommand = process.env.DRAWIO_TEST_PYTHON
-const integrationTest = pythonCommand ? test : test.skip
-const runParser = (request) => runOptionalPythonParser(request, { pythonCommand })
-const fixture = (name) => readFileSync(new URL(`../../references/examples/importers/${name}`, import.meta.url), 'utf8')
-
-integrationTest('optional Python worker parses pinned HCL and SQL packages', () => {
-  const terraform = parseTerraformConfig(
-    fixture('terraform.tf'),
-    { locator: 'infra/main.tf', moduleAddress: 'module.app', runParser }
-  )
-  assert.deepEqual(terraform.nodes.map((node) => node.identity.key), [
-    'module.app.aws_instance.api',
-    'module.app.aws_security_group.web'
-  ])
-  assert.deepEqual(new Set(terraform.edges.map((edge) => edge.relation)), new Set(['depends-on', 'references']))
-  assert.equal(terraform.diagnostics.length, 0)
-
-  const sql = parseSqlDdl(
-    fixture('schema.sql'),
-    { dialect: 'postgres', defaultSchema: 'public', locator: 'db/schema.sql', runParser }
-  )
-  assert.equal(sql.edges.length, 1)
-  assert.equal(sql.edges[0].discriminator, 'orders_user_fk:user_id->id')
-})

package/template/.qoder/skills/drawio/scripts/adapters/optional-python.js

@@ -1,127 +0,0 @@
-import { spawnSync } from 'node:child_process'
-import { fileURLToPath } from 'node:url'
-
-import { AdapterContractError, ERROR_CODES } from './identity.js'
-import { MAX_SOURCE_BYTES } from './config-common.js'
-
-const WORKER_PATH = fileURLToPath(new URL('./python/config-parser-worker.py', import.meta.url))
-const DEFAULT_TIMEOUT_MS = 10000
-const DEFAULT_MAX_OUTPUT_BYTES = 1024 * 1024
-
-function protocolError(message, cause, context = {}) {
-  throw new AdapterContractError(ERROR_CODES.ADAPTER_PARSE, message, context, { cause })
-}
-
-function optionalDependencyError(message, cause) {
-  throw new AdapterContractError(ERROR_CODES.OPTIONAL_DEPENDENCY_MISSING, message, {}, { cause })
-}
-
-function workerEnvironment() {
-  const env = { PYTHONIOENCODING: 'utf-8', PYTHONUTF8: '1' }
-  for (const key of ['PATH', 'SYSTEMROOT', 'WINDIR', 'TEMP', 'TMP']) {
-    if (process.env[key]) env[key] = process.env[key]
-  }
-  return env
-}
-
-function safeWorkerContext(value) {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return {}
-  const context = {}
-  if (typeof value.path === 'string' && /^[^\\\u0000-\u001f\u007f]{1,512}$/.test(value.path)) {
-    const path = value.path.replaceAll('\\', '/')
-    if (!path.startsWith('/') && !/^[A-Za-z]:/.test(path) && !path.split('/').includes('..')) context.path = path
-  }
-  for (const key of ['line', 'column']) {
-    if (Number.isInteger(value[key]) && value[key] >= 0) context[key] = value[key]
-  }
-  return context
-}
-
-export function runFixedPythonWorker(
-  request,
-  {
-    allowedAdapters,
-    workerPath,
-    maxInputBytes,
-    pythonUnavailableMessage = 'Python 3.9+ is unavailable',
-    spawn = spawnSync,
-    pythonCommand = process.platform === 'win32' ? 'python' : 'python3',
-    timeoutMs = DEFAULT_TIMEOUT_MS,
-    maxOutputBytes = DEFAULT_MAX_OUTPUT_BYTES
-  }
-) {
-  if (
-    !request ||
-    typeof request !== 'object' ||
-    !Array.isArray(allowedAdapters) ||
-    !allowedAdapters.includes(request.adapter) ||
-    typeof workerPath !== 'string' ||
-    workerPath === ''
-  ) {
-    protocolError('optional parser request has an invalid adapter')
-  }
-  const input = JSON.stringify(request)
-  if (Buffer.byteLength(input, 'utf8') > maxInputBytes) protocolError('optional parser input exceeds the size limit')
-
-  const result = spawn(pythonCommand, ['-I', workerPath], {
-    input,
-    encoding: 'utf8',
-    timeout: timeoutMs,
-    maxBuffer: maxOutputBytes,
-    windowsHide: true,
-    shell: false,
-    cwd: fileURLToPath(new URL('.', import.meta.url)),
-    env: workerEnvironment()
-  })
-
-  if (result?.error?.code === 'ENOENT') optionalDependencyError(pythonUnavailableMessage, result.error)
-  if (result?.error?.code === 'ETIMEDOUT') protocolError(`optional parser timed out after ${timeoutMs}ms`, result.error)
-  if (result?.error?.code === 'ENOBUFS') protocolError('optional parser exceeded the output limit', result.error)
-  if (result?.error) protocolError('optional parser process failed', result.error)
-
-  const stdout = typeof result?.stdout === 'string' ? result.stdout : String(result?.stdout || '')
-  if (Buffer.byteLength(stdout, 'utf8') > maxOutputBytes) protocolError('optional parser exceeded the output limit')
-  if (result.status !== 0 && stdout.trim() === '') {
-    protocolError(`optional parser exited with status ${result.status}`)
-  }
-
-  let response
-  try {
-    response = JSON.parse(stdout)
-  } catch (error) {
-    protocolError('optional parser returned malformed JSON', error)
-  }
-  if (!response || typeof response !== 'object') protocolError('optional parser returned an invalid response')
-
-  if (response.ok === true && result.status === 0 && response.result && typeof response.result === 'object') {
-    return response.result
-  }
-  if (response.code === ERROR_CODES.OPTIONAL_DEPENDENCY_MISSING) {
-    optionalDependencyError(String(response.message || 'optional parser dependency is unavailable'))
-  }
-  protocolError(
-    String(response.message || `optional parser exited with status ${result.status}`),
-    undefined,
-    safeWorkerContext(response.context)
-  )
-}
-
-export function runOptionalPythonParser(
-  request,
-  {
-    spawn = spawnSync,
-    pythonCommand = process.platform === 'win32' ? 'python' : 'python3',
-    timeoutMs = DEFAULT_TIMEOUT_MS,
-    maxOutputBytes = DEFAULT_MAX_OUTPUT_BYTES
-  } = {}
-) {
-  return runFixedPythonWorker(request, {
-    allowedAdapters: ['terraform', 'sql'],
-    workerPath: WORKER_PATH,
-    maxInputBytes: MAX_SOURCE_BYTES,
-    spawn,
-    pythonCommand,
-    timeoutMs,
-    maxOutputBytes
-  })
-}

package/template/.qoder/skills/drawio/scripts/adapters/optional-python.test.js

@@ -1,55 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-
-import { ERROR_CODES } from './identity.js'
-import { runOptionalPythonParser } from './optional-python.js'
-
-const request = { adapter: 'terraform', source: 'resource "x" "y" {}' }
-
-test('runOptionalPythonParser decodes a bounded successful response', () => {
-  const result = runOptionalPythonParser(request, {
-    spawn: () => ({ status: 0, stdout: '{"ok":true,"result":{"resources":[]}}', stderr: '' })
-  })
-  assert.deepEqual(result, { resources: [] })
-})
-
-test('runOptionalPythonParser maps missing Python and parser packages', () => {
-  assert.throws(
-    () => runOptionalPythonParser(request, { spawn: () => ({ error: { code: 'ENOENT' }, stdout: '', stderr: '' }) }),
-    (error) => error.code === ERROR_CODES.OPTIONAL_DEPENDENCY_MISSING
-  )
-  assert.throws(
-    () =>
-      runOptionalPythonParser(request, {
-        spawn: () => ({
-          status: 3,
-          stdout: '{"ok":false,"code":"OPTIONAL_DEPENDENCY_MISSING","message":"python-hcl2 is unavailable"}',
-          stderr: ''
-        })
-      }),
-    (error) => error.code === ERROR_CODES.OPTIONAL_DEPENDENCY_MISSING && !('source' in error.context)
-  )
-})
-
-test('runOptionalPythonParser maps timeout, malformed output, and output overflow', () => {
-  assert.throws(
-    () => runOptionalPythonParser(request, { spawn: () => ({ error: { code: 'ENOBUFS' }, stdout: '', stderr: '' }) }),
-    (error) => error.code === ERROR_CODES.ADAPTER_PARSE && /output limit/.test(error.message)
-  )
-  assert.throws(
-    () => runOptionalPythonParser(request, { spawn: () => ({ error: { code: 'ETIMEDOUT' }, stdout: '', stderr: '' }) }),
-    (error) => error.code === ERROR_CODES.ADAPTER_PARSE && /timed out/.test(error.message)
-  )
-  assert.throws(
-    () => runOptionalPythonParser(request, { spawn: () => ({ status: 0, stdout: 'not-json', stderr: 'raw source' }) }),
-    (error) => error.code === ERROR_CODES.ADAPTER_PARSE && !error.message.includes('raw source')
-  )
-  assert.throws(
-    () =>
-      runOptionalPythonParser(request, {
-        maxOutputBytes: 10,
-        spawn: () => ({ status: 0, stdout: '{"ok":true,"result":{}}', stderr: '' })
-      }),
-    (error) => error.code === ERROR_CODES.ADAPTER_PARSE && /output limit/.test(error.message)
-  )
-})

package/template/.qoder/skills/drawio/scripts/adapters/projection-to-spec.js

@@ -1,116 +0,0 @@
-import {
-  AdapterContractError,
-  ERROR_CODES,
-  createRendererId,
-  normalizeIdentity,
-  serializeIdentity
-} from './identity.js'
-
-const RELATION_TYPES = new Map([
-  ['async', 'async'],
-  ['data', 'data'],
-  ['feedback', 'feedback'],
-  ['bidirectional', 'bidirectional']
-])
-
-function projectionError(message) {
-  throw new AdapterContractError(ERROR_CODES.PROJECTION_INVALID, message)
-}
-
-function buildIdMap(items, kind, hash) {
-  const identityToId = new Map()
-  const idToIdentity = new Map()
-  for (const item of items) {
-    const identity = normalizeIdentity(item.identity)
-    const serialized = serializeIdentity(identity)
-    const id = createRendererId(identity, { kind, hash })
-    const existing = idToIdentity.get(id)
-    if (existing && existing !== serialized) {
-      throw new AdapterContractError(
-        ERROR_CODES.IDENTITY_COLLISION,
-        `renderer id collision for "${id}" between two distinct identities`,
-        { identity }
-      )
-    }
-    identityToId.set(serialized, id)
-    idToIdentity.set(id, serialized)
-  }
-  return identityToId
-}
-
-function copyIdentity(identity) {
-  const normalized = normalizeIdentity(identity)
-  return { ...normalized }
-}
-
-export function projectGraphToSpec(projection, { hash } = {}) {
-  if (
-    projection?.version !== 1 ||
-    typeof projection.source !== 'object' ||
-    projection.source == null ||
-    !Array.isArray(projection.nodes) ||
-    !Array.isArray(projection.edges) ||
-    !Array.isArray(projection.modules) ||
-    !Array.isArray(projection.diagnostics)
-  ) {
-    projectionError('projectGraphToSpec requires a finalized CanonicalGraphProjection v1')
-  }
-
-  const nodeIds = buildIdMap(projection.nodes, 'node', hash)
-  const edgeIds = buildIdMap(projection.edges, 'edge', hash)
-  const moduleIds = buildIdMap(projection.modules || [], 'module', hash)
-
-  const modules = (projection.modules || []).map((module) => ({
-    id: moduleIds.get(serializeIdentity(module.identity)),
-    label: module.label,
-    identity: copyIdentity(module.identity)
-  }))
-
-  const nodes = projection.nodes.map((node) => {
-    const result = {
-      id: nodeIds.get(serializeIdentity(node.identity)),
-      label: node.label,
-      type: node.semanticType || 'service',
-      identity: copyIdentity(node.identity)
-    }
-    if (node.icon) result.icon = node.icon
-    if (node.moduleIdentity) {
-      const moduleId = moduleIds.get(serializeIdentity(node.moduleIdentity))
-      if (!moduleId) projectionError(`node "${node.label}" references a module not present in the projection`)
-      result.module = moduleId
-    }
-    return result
-  })
-
-  const edges = projection.edges.map((edge) => {
-    const from = nodeIds.get(serializeIdentity(edge.from))
-    const to = nodeIds.get(serializeIdentity(edge.to))
-    if (!from || !to) projectionError('edge references a node not present in the projection')
-    const result = {
-      id: edgeIds.get(serializeIdentity(edge.identity)),
-      from,
-      to,
-      type: edge.semanticType || RELATION_TYPES.get(edge.relation) || 'dependency',
-      identity: copyIdentity(edge.identity)
-    }
-    if (edge.label) result.label = edge.label
-    return result
-  })
-
-  return {
-    meta: {
-      source: 'generated',
-      layout: 'hierarchical',
-      adapter: {
-        projectionVersion: 1,
-        name: projection.source.adapter,
-        domain: projection.source.domain,
-        mode: projection.source.mode,
-        locator: projection.source.locator
-      }
-    },
-    nodes,
-    edges,
-    modules
-  }
-}

package/template/.qoder/skills/drawio/scripts/adapters/projection-to-spec.test.js

@@ -1,139 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-
-import { applyAutoLayout } from '../dsl/auto-layout.js'
-import { parseSpecYaml, specToDrawioXml, validateSpec, validateXml } from '../dsl/spec-to-drawio.js'
-import { buildArchMetadata, serializeSpecYaml } from '../runtime/artifacts.js'
-import { createCodeIdentity, createGroupIdentity } from './identity.js'
-import { finalizeGraphProjection } from './graph-projection.js'
-import { projectGraphToSpec } from './projection-to-spec.js'
-
-function finalizedFixture(label = 'API', { mode = 'code', locator = 'src', reverse = false } = {}) {
-  const moduleIdentity = createGroupIdentity({ domain: 'code', key: 'src' })
-  const api = createCodeIdentity({ language: 'typescript', modulePath: 'src/api.ts' })
-  const db = createCodeIdentity({ language: 'typescript', modulePath: 'src/db.ts' })
-  const nodes = [
-    { identity: api, label, semanticType: 'service', moduleIdentity, attributes: {} },
-    { identity: db, label: 'Database', semanticType: 'database', moduleIdentity, attributes: {} }
-  ]
-  if (reverse) nodes.reverse()
-  return finalizeGraphProjection({
-    version: 1,
-    source: { adapter: 'typescript-imports', domain: 'code', mode, locator },
-    nodes,
-    edges: [{ from: api, to: db, relation: 'imports', label: 'imports', attributes: {} }],
-    modules: [{ identity: moduleIdentity, label: 'src', attributes: {} }],
-    diagnostics: []
-  })
-}
-
-test('projectGraphToSpec emits stable renderer-safe ids and identity metadata', () => {
-  const first = projectGraphToSpec(finalizedFixture('API'))
-  const renamed = projectGraphToSpec(finalizedFixture('Gateway', { reverse: true }))
-
-  assert.equal(first.meta.layout, 'hierarchical')
-  assert.deepEqual(first.meta.adapter, {
-    projectionVersion: 1,
-    name: 'typescript-imports',
-    domain: 'code',
-    mode: 'code',
-    locator: 'src'
-  })
-  assert.match(first.nodes[0].id, /^n-[a-f0-9]{20}$/)
-  assert.equal(first.nodes[0].id, renamed.nodes[0].id)
-  assert.deepEqual(first.nodes[0].identity, renamed.nodes[0].identity)
-  assert.match(first.edges[0].id, /^e-[a-f0-9]{20}$/)
-  assert.match(first.modules[0].id, /^m-[a-f0-9]{20}$/)
-  assert.equal(first.nodes[0].module, first.modules[0].id)
-  assert.equal('attributes' in first.nodes[0], false)
-})
-
-test('declared and live projections reuse the same identity factory across source metadata changes', () => {
-  const declared = projectGraphToSpec(finalizedFixture('Declared API', { mode: 'declared', locator: 'src' }))
-  const live = projectGraphToSpec(
-    finalizedFixture('Running API', { mode: 'live', locator: 'snapshots/runtime', reverse: true })
-  )
-
-  assert.deepEqual(
-    declared.nodes.map(({ id, identity }) => ({ id, identity })),
-    live.nodes.map(({ id, identity }) => ({ id, identity }))
-  )
-  assert.deepEqual(
-    declared.edges.map(({ id, identity }) => ({ id, identity })),
-    live.edges.map(({ id, identity }) => ({ id, identity }))
-  )
-})
-
-test('projectGraphToSpec detects renderer hash collisions without traversal-order suffixes', () => {
-  assert.throws(
-    () => projectGraphToSpec(finalizedFixture(), { hash: () => 'a'.repeat(64) }),
-    (error) => error.code === 'IDENTITY_COLLISION' && /collision/.test(error.message)
-  )
-})
-
-test('projectGraphToSpec rejects candidates that did not cross the finalization boundary', () => {
-  assert.throws(
-    () => projectGraphToSpec({ version: 1, source: {}, nodes: [], edges: [] }),
-    (error) => error.code === 'PROJECTION_INVALID' && /finalized/.test(error.message)
-  )
-})
-
-test('projected specs round-trip through YAML, arch metadata, JS ELK, and XML validation', async () => {
-  const projected = projectGraphToSpec(finalizedFixture())
-  validateSpec(projected)
-
-  const roundTripped = parseSpecYaml(serializeSpecYaml(projected))
-  assert.deepEqual(roundTripped.nodes[0].identity, projected.nodes[0].identity)
-  assert.deepEqual(roundTripped.meta.adapter, projected.meta.adapter)
-
-  const arch = buildArchMetadata(projected, { outputFile: 'code-graph.drawio' })
-  assert.deepEqual(arch.adapter, projected.meta.adapter)
-  assert.deepEqual(arch.nodes[0].identity, projected.nodes[0].identity)
-  assert.deepEqual(arch.edges[0].identity, projected.edges[0].identity)
-  assert.deepEqual(arch.modules[0].identity, projected.modules[0].identity)
-
-  const layout = await applyAutoLayout(projected)
-  assert.equal(layout.applied, true)
-  assert.ok(layout.spec.nodes.every((node) => node.bounds))
-  assert.deepEqual(layout.spec.nodes[0].identity, projected.nodes[0].identity)
-
-  const xml = specToDrawioXml(layout.spec)
-  assert.deepEqual(validateXml(xml), { valid: true, errors: [], warnings: [] })
-})
-
-test('legacy specs without identity remain valid', () => {
-  assert.doesNotThrow(() =>
-    validateSpec({
-      meta: { layout: 'horizontal' },
-      nodes: [{ id: 'api', label: 'API', type: 'service' }],
-      edges: [],
-      modules: []
-    })
-  )
-})
-
-test('canonical schema and runtime validation enforce adapter identity metadata', () => {
-  const schema = JSON.parse(readFileSync(new URL('../../assets/schemas/spec.schema.json', import.meta.url), 'utf8'))
-  assert.equal(schema.properties.meta.properties.adapter.$ref, '#/$defs/adapter')
-  assert.equal(schema.properties.nodes.items.properties.identity.$ref, '#/$defs/identity')
-  assert.equal(schema.properties.edges.items.properties.identity.$ref, '#/$defs/identity')
-  assert.equal(schema.properties.modules.items.properties.identity.$ref, '#/$defs/identity')
-
-  const projected = projectGraphToSpec(finalizedFixture())
-  const missingIdentity = structuredClone(projected)
-  delete missingIdentity.nodes[0].identity
-  assert.throws(() => validateSpec(missingIdentity), /requires identity/)
-
-  const badAdapter = structuredClone(projected)
-  badAdapter.meta.adapter.locator = 'C:\\private\\source'
-  assert.throws(() => validateSpec(badAdapter), /safe relative path/)
-
-  const escapingAdapter = structuredClone(projected)
-  escapingAdapter.meta.adapter.locator = 'infra/../../private/source'
-  assert.throws(() => validateSpec(escapingAdapter), /safe relative path/)
-
-  const duplicateIdentity = structuredClone(projected)
-  duplicateIdentity.nodes[1].identity = duplicateIdentity.nodes[0].identity
-  assert.throws(() => validateSpec(duplicateIdentity), /Duplicate node identity/)
-})

package/template/.qoder/skills/drawio/scripts/adapters/python/code-parser-worker.py

@@ -1,93 +0,0 @@
-import ast
-import json
-import sys
-
-
-ADAPTERS = {'python-imports', 'python-classes'}
-
-
-def fail(code, message, context=None, status=2):
-    response = {'ok': False, 'code': code, 'message': message}
-    if context:
-        response['context'] = context
-    sys.stdout.write(json.dumps(response, separators=(',', ':')))
-    raise SystemExit(status)
-
-
-def base_name(node):
-    if isinstance(node, ast.Name):
-        return node.id
-    if isinstance(node, ast.Attribute):
-        return node.attr
-    return None
-
-
-def parse_file(file, adapter):
-    path = file.get('path')
-    source = file.get('source')
-    if not isinstance(path, str) or not isinstance(source, str):
-        fail('ADAPTER_PARSE', 'Python code worker received an invalid file record')
-    try:
-        tree = ast.parse(source, filename=path)
-    except SyntaxError as error:
-        fail(
-            'ADAPTER_PARSE',
-            'Python source contains invalid syntax',
-            {
-                'path': path,
-                'line': error.lineno or 0,
-                'column': error.offset or 0,
-            },
-        )
-
-    if adapter == 'python-imports':
-        imports = []
-        for node in ast.walk(tree):
-            if isinstance(node, ast.Import):
-                for alias in node.names:
-                    imports.append({
-                        'module': alias.name,
-                        'level': 0,
-                        'names': [],
-                        'line': node.lineno,
-                        'column': node.col_offset,
-                    })
-            elif isinstance(node, ast.ImportFrom):
-                imports.append({
-                    'module': node.module or '',
-                    'level': node.level,
-                    'names': [alias.name for alias in node.names],
-                    'line': node.lineno,
-                    'column': node.col_offset,
-                })
-        return {'path': path, 'imports': imports}
-
-    classes = []
-    for node in tree.body:
-        if isinstance(node, ast.ClassDef):
-            classes.append({
-                'qualifiedName': node.name,
-                'bases': [name for name in (base_name(base) for base in node.bases) if name],
-                'line': node.lineno,
-                'column': node.col_offset,
-            })
-    return {'path': path, 'classes': classes}
-
-
-def main():
-    if sys.version_info < (3, 11):
-        fail('OPTIONAL_DEPENDENCY_MISSING', 'Python 3.11+ is required', status=3)
-    try:
-        request = json.load(sys.stdin)
-    except Exception:
-        fail('ADAPTER_PARSE', 'Python code worker received malformed JSON')
-    adapter = request.get('adapter') if isinstance(request, dict) else None
-    files = request.get('files') if isinstance(request, dict) else None
-    if adapter not in ADAPTERS or not isinstance(files, list):
-        fail('ADAPTER_PARSE', 'Python code worker received an invalid request')
-    result = {'files': [parse_file(file, adapter) for file in files]}
-    sys.stdout.write(json.dumps({'ok': True, 'result': result}, separators=(',', ':')))
-
-
-if __name__ == '__main__':
-    main()