create-yss-spec 2.1.5 → 2.1.6

package/template/.pi/skills/drawio/scripts/adapters/js-code.js

@@ -1,141 +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'
-
-const EXTENSIONS = ['.js', '.jsx', '.mjs', '.ts', '.tsx']
-const TYPESCRIPT_EXTENSIONS = new Set(['.ts', '.tsx'])
-
-function languageForPath(path) {
-  return TYPESCRIPT_EXTENSIONS.has(posix.extname(path).toLowerCase()) ? 'typescript' : 'javascript'
-}
-
-async function parseWithEsModuleLexer(source, path) {
-  const lexer = await loadOptionalParser('es-module-lexer/js', 'es-module-lexer@2.3.1')
-  let imports
-  let hasModuleSyntax
-  try {
-    ;[imports, , , hasModuleSyntax] = lexer.parse(source, path)
-  } catch (error) {
-    codeAdapterError(ERROR_CODES.ADAPTER_PARSE, 'JavaScript or TypeScript module syntax could not be parsed', {
-      path,
-      column: Number.isInteger(error?.idx) ? error.idx : undefined
-    }, error)
-  }
-  const specifiers = []
-  for (const entry of imports) {
-    if (entry.d === -2) continue
-    if (typeof entry.n !== 'string') {
-      codeAdapterError(ERROR_CODES.ADAPTER_UNSUPPORTED, 'Non-literal dynamic imports are not supported', { path })
-    }
-    specifiers.push(entry.n)
-  }
-  return { specifiers, hasModuleSyntax }
-}
-
-function resolveRelativeImport(fromPath, specifier, files) {
-  if (specifier.includes('?') || specifier.includes('#')) {
-    codeAdapterError(ERROR_CODES.ADAPTER_UNSUPPORTED, 'Import query strings and fragments are not supported', {
-      path: fromPath
-    })
-  }
-  const target = posix.normalize(posix.join(posix.dirname(fromPath), specifier))
-  if (target === '..' || target.startsWith('../') || posix.isAbsolute(target)) {
-    codeAdapterError(ERROR_CODES.ADAPTER_UNSUPPORTED, 'Relative import escapes the selected project', { path: fromPath })
-  }
-  const candidates = []
-  if (files.has(target)) candidates.push(target)
-  if (!posix.extname(target)) {
-    for (const extension of EXTENSIONS) {
-      if (files.has(`${target}${extension}`)) candidates.push(`${target}${extension}`)
-      if (files.has(`${target}/index${extension}`)) candidates.push(`${target}/index${extension}`)
-    }
-  }
-  const unique = [...new Set(candidates)]
-  if (unique.length !== 1) {
-    const reason = unique.length === 0 ? 'does not resolve' : 'resolves ambiguously'
-    codeAdapterError(ERROR_CODES.ADAPTER_UNSUPPORTED, `Relative import ${reason} inside the selected project`, {
-      path: fromPath
-    })
-  }
-  return unique[0]
-}
-
-export async function parseJavaScriptImportsProject(
-  projectRoot,
-  { locator = 'project', parseModule = parseWithEsModuleLexer } = {}
-) {
-  const scan = scanCodeProject(projectRoot, { extensions: EXTENSIONS })
-  if (scan.files.length === 0) {
-    codeAdapterError(ERROR_CODES.ADAPTER_UNSUPPORTED, 'JavaScript/TypeScript project contains no supported source files')
-  }
-  const filePaths = new Set(scan.files.map((file) => file.path))
-  const identities = new Map(
-    scan.files.map((file) => [file.path, createCodeIdentity({ language: languageForPath(file.path), modulePath: file.path })])
-  )
-  const nodes = scan.files.map((file) => moduleNode(languageForPath(file.path), file.path))
-  const edges = []
-  const seenEdges = new Set()
-  let ignored = 0
-  let nonEsmFiles = 0
-
-  for (const file of scan.files) {
-    let parsed
-    try {
-      parsed = await parseModule(file.source, file.path)
-    } catch (error) {
-      if (error?.code) throw error
-      codeAdapterError(ERROR_CODES.ADAPTER_PARSE, 'JavaScript or TypeScript module syntax could not be parsed', {
-        path: file.path
-      }, error)
-    }
-    const specifiers = Array.isArray(parsed) ? parsed : parsed?.specifiers
-    if (!Array.isArray(specifiers) || !specifiers.every((value) => typeof value === 'string')) {
-      codeAdapterError(ERROR_CODES.ADAPTER_PARSE, 'JavaScript parser returned an invalid import list', {
-        path: file.path
-      })
-    }
-    if (!Array.isArray(parsed) && parsed.hasModuleSyntax === false && specifiers.length === 0) nonEsmFiles++
-    for (const specifier of specifiers) {
-      if (!specifier.startsWith('./') && !specifier.startsWith('../')) {
-        ignored++
-        continue
-      }
-      const targetPath = resolveRelativeImport(file.path, specifier, filePaths)
-      const from = identities.get(file.path)
-      const to = identities.get(targetPath)
-      const key = `${serializeIdentity(from)}\0imports\0${serializeIdentity(to)}`
-      if (seenEdges.has(key)) continue
-      seenEdges.add(key)
-      edges.push({ from, to, relation: 'imports', attributes: {} })
-    }
-  }
-
-  return finalizeCodeProjection({
-    adapter: 'js-imports',
-    locator,
-    nodes,
-    edges,
-    diagnostics: [
-      ...aggregateDiagnostic(
-        'JS_NON_RELATIVE_IMPORTS_IGNORED',
-        ignored,
-        'Non-relative imports were not resolved; they may be external packages or unsupported path aliases.'
-      ),
-      ...aggregateDiagnostic(
-        'JS_NON_ESM_FILES_UNANALYZED',
-        nonEsmFiles,
-        'Files without supported ESM import syntax were retained as nodes; CommonJS dependencies were not analyzed.'
-      ),
-      ...scanDiagnostics(scan)
-    ]
-  })
-}

package/template/.pi/skills/drawio/scripts/adapters/kubernetes-live.test.js

@@ -1,46 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-
-import { parseKubernetesManifests, parseKubernetesLiveSnapshot } from './kubernetes.js'
-import { projectGraphToSpec } from './projection-to-spec.js'
-
-const fixture = readFileSync(
-  new URL('../../references/examples/importers/live/kubernetes-live.json', import.meta.url),
-  'utf8'
-)
-
-test('Kubernetes declared/live wrappers reuse identities while preserving live mode', () => {
-  const declared = parseKubernetesManifests(fixture, { scope: 'prod', locator: 'k8s/app.json' })
-  const live = parseKubernetesLiveSnapshot(fixture, { scope: 'prod', locator: 'snapshots/kubernetes.json' })
-
-  assert.equal(declared.source.mode, 'declared')
-  assert.equal(live.source.mode, 'live')
-  assert.deepEqual(live.nodes.map((node) => node.identity), declared.nodes.map((node) => node.identity))
-  assert.deepEqual(
-    projectGraphToSpec(live).nodes.map(({ id, identity }) => ({ id, identity })),
-    projectGraphToSpec(declared).nodes.map(({ id, identity }) => ({ id, identity }))
-  )
-
-  const serialized = JSON.stringify(live)
-  for (const secret of [
-    'annotation-secret-must-not-cross',
-    'private-manager-must-not-cross',
-    'literal-env-secret-must-not-cross',
-    'kubernetes-secret-must-not-cross',
-    'binary-secret-must-not-cross'
-  ]) {
-    assert.equal(serialized.includes(secret), false, secret)
-  }
-})
-
-test('Kubernetes live wrapper requires explicit scope and rejects malformed input', () => {
-  assert.throws(
-    () => parseKubernetesLiveSnapshot(fixture, { locator: 'snapshot.json' }),
-    (error) => error.code === 'IDENTITY_INVALID' && /scope/.test(error.message)
-  )
-  assert.throws(
-    () => parseKubernetesLiveSnapshot('{', { scope: 'prod', locator: 'snapshot.json' }),
-    (error) => error.code === 'ADAPTER_PARSE'
-  )
-})

package/template/.pi/skills/drawio/scripts/adapters/kubernetes.js

@@ -1,258 +0,0 @@
-import {
-  AdapterContractError,
-  ERROR_CODES,
-  createKubernetesIdentity,
-  serializeIdentity
-} from './identity.js'
-import {
-  adapterError,
-  diagnostic,
-  finalizeConfigProjection,
-  isRecord,
-  parseStructuredDocuments,
-  pushUniqueEdge,
-  requireRecord
-} from './config-common.js'
-
-const ADAPTER = 'kubernetes-config'
-const CLUSTER_SCOPED_KINDS = new Set([
-  'ClusterRole',
-  'ClusterRoleBinding',
-  'CustomResourceDefinition',
-  'Namespace',
-  'Node',
-  'PersistentVolume',
-  'StorageClass'
-])
-const NAMESPACED_KINDS = new Set([
-  'ConfigMap',
-  'CronJob',
-  'DaemonSet',
-  'Deployment',
-  'HorizontalPodAutoscaler',
-  'Ingress',
-  'Job',
-  'NetworkPolicy',
-  'PersistentVolumeClaim',
-  'Pod',
-  'Role',
-  'RoleBinding',
-  'Secret',
-  'Service',
-  'ServiceAccount',
-  'StatefulSet'
-])
-const WORKLOAD_KINDS = new Set(['CronJob', 'DaemonSet', 'Deployment', 'Job', 'Pod', 'StatefulSet'])
-
-export const KUBERNETES_ATTRIBUTE_ALLOWLIST = Object.freeze({
-  node: ['apiVersion', 'kind', 'namespace', 'replicas'],
-  edge: [],
-  module: []
-})
-
-function resolveNamespaced(kind, kindScopes) {
-  if (Object.hasOwn(kindScopes, kind)) {
-    if (typeof kindScopes[kind] !== 'boolean') {
-      adapterError(ERROR_CODES.ADAPTER_PARSE, `Kubernetes kindScopes.${kind} must be boolean`, { adapter: ADAPTER })
-    }
-    return kindScopes[kind]
-  }
-  if (CLUSTER_SCOPED_KINDS.has(kind)) return false
-  if (NAMESPACED_KINDS.has(kind)) return true
-  adapterError(
-    ERROR_CODES.ADAPTER_UNSUPPORTED,
-    `Kubernetes kind "${kind}" has unknown namespace scope; provide kindScopes.${kind}`,
-    { adapter: ADAPTER }
-  )
-}
-
-function flattenDocuments(documents) {
-  const objects = []
-  for (const document of documents) {
-    if (Array.isArray(document)) objects.push(...document)
-    else if (document?.kind === 'List' && Array.isArray(document.items)) objects.push(...document.items)
-    else objects.push(document)
-  }
-  return objects
-}
-
-function semanticType(kind) {
-  if (['ConfigMap', 'Secret'].includes(kind)) return 'document'
-  if (['PersistentVolume', 'PersistentVolumeClaim', 'StorageClass'].includes(kind)) return 'database'
-  if (kind === 'Ingress' || kind === 'Service') return 'gateway'
-  if (kind === 'Namespace') return 'subnet'
-  return 'service'
-}
-
-function workloadPodSpec(object) {
-  if (object.kind === 'Pod') return object.spec
-  if (object.kind === 'CronJob') return object.spec?.jobTemplate?.spec?.template?.spec
-  return object.spec?.template?.spec
-}
-
-function workloadLabels(object) {
-  if (object.kind === 'Pod') return object.metadata?.labels || {}
-  if (object.kind === 'CronJob') return object.spec?.jobTemplate?.spec?.template?.metadata?.labels || {}
-  return object.spec?.template?.metadata?.labels || {}
-}
-
-function collectWorkloadRefs(object) {
-  const refs = []
-  const podSpec = workloadPodSpec(object)
-  if (!isRecord(podSpec)) return refs
-  for (const volume of Array.isArray(podSpec.volumes) ? podSpec.volumes : []) {
-    if (volume?.configMap?.name) refs.push({ kind: 'ConfigMap', name: volume.configMap.name, source: `volume:${volume.name}` })
-    if (volume?.secret?.secretName) refs.push({ kind: 'Secret', name: volume.secret.secretName, source: `volume:${volume.name}` })
-    if (volume?.persistentVolumeClaim?.claimName) {
-      refs.push({ kind: 'PersistentVolumeClaim', name: volume.persistentVolumeClaim.claimName, source: `volume:${volume.name}` })
-    }
-  }
-  const containers = [...(podSpec.containers || []), ...(podSpec.initContainers || [])]
-  for (const container of containers) {
-    for (const envFrom of container?.envFrom || []) {
-      if (envFrom?.configMapRef?.name) refs.push({ kind: 'ConfigMap', name: envFrom.configMapRef.name, source: `envFrom:${container.name}` })
-      if (envFrom?.secretRef?.name) refs.push({ kind: 'Secret', name: envFrom.secretRef.name, source: `envFrom:${container.name}` })
-    }
-    for (const env of container?.env || []) {
-      if (env?.valueFrom?.configMapKeyRef?.name) refs.push({ kind: 'ConfigMap', name: env.valueFrom.configMapKeyRef.name, source: `env:${container.name}:${env.name}` })
-      if (env?.valueFrom?.secretKeyRef?.name) refs.push({ kind: 'Secret', name: env.valueFrom.secretKeyRef.name, source: `env:${container.name}:${env.name}` })
-    }
-  }
-  return refs
-}
-
-function selectorMatches(selector, labels) {
-  const entries = Object.entries(selector || {})
-  return entries.length > 0 && entries.every(([key, value]) => labels?.[key] === value)
-}
-
-export function buildKubernetesIdentityInput(object, { scope, kindScopes = {} } = {}) {
-  requireRecord(object, 'Kubernetes object', ADAPTER)
-  const kind = object.kind
-  const name = object.metadata?.name
-  if (typeof kind !== 'string' || typeof name !== 'string') {
-    adapterError(ERROR_CODES.ADAPTER_PARSE, 'Kubernetes object requires string kind and metadata.name', { adapter: ADAPTER })
-  }
-  const namespaced = resolveNamespaced(kind, kindScopes)
-  return { scope, namespace: object.metadata?.namespace, kind, name, namespaced }
-}
-
-function parseKubernetesProjection(
-  source,
-  { scope, locator, kindScopes = {}, mode = 'declared', adapter = ADAPTER }
-) {
-  const documents = parseStructuredDocuments(source, { adapter })
-  const objects = flattenDocuments(documents).map((object) => requireRecord(object, 'Kubernetes object', adapter))
-  const records = objects.map((object) => {
-    const input = buildKubernetesIdentityInput(object, { scope, kindScopes })
-    const identity = createKubernetesIdentity(input)
-    return { object, input, identity }
-  })
-  const byIdentity = new Map(records.map((record) => [serializeIdentity(record.identity), record]))
-  const find = (kind, name, namespace = 'default') => {
-    const namespaced = resolveNamespaced(kind, kindScopes)
-    const identity = createKubernetesIdentity({ scope, namespace, kind, name, namespaced })
-    return byIdentity.get(serializeIdentity(identity))
-  }
-
-  const nodes = records.map(({ object, input, identity }) => ({
-    identity,
-    label: object.metadata.name,
-    semanticType: semanticType(object.kind),
-    attributes: {
-      apiVersion: object.apiVersion || 'v1',
-      kind: object.kind,
-      namespace: input.namespaced ? input.namespace || 'default' : '_cluster',
-      ...(Number.isFinite(object.spec?.replicas) ? { replicas: object.spec.replicas } : {})
-    }
-  }))
-  const edges = []
-  const edgeKeys = new Set()
-  const diagnostics = []
-  const addRelation = (fromRecord, targetKind, targetName, relation, discriminator, namespace) => {
-    let target
-    try {
-      target = find(targetKind, targetName, namespace || fromRecord.input.namespace || 'default')
-    } catch (error) {
-      if (error instanceof AdapterContractError && error.code === ERROR_CODES.ADAPTER_UNSUPPORTED) throw error
-      throw error
-    }
-    if (!target) {
-      diagnostics.push(diagnostic('KUBERNETES_EXTERNAL_REF', `${fromRecord.object.kind}/${fromRecord.object.metadata.name} references external ${targetKind}/${targetName}.`, fromRecord.identity))
-      return
-    }
-    pushUniqueEdge(edges, edgeKeys, {
-      from: fromRecord.identity,
-      to: target.identity,
-      relation,
-      discriminator,
-      attributes: {}
-    })
-  }
-
-  for (const record of records) {
-    const { object } = record
-    const namespace = record.input.namespace || 'default'
-    if (object.kind === 'Service') {
-      for (const workload of records.filter((candidate) => WORKLOAD_KINDS.has(candidate.object.kind))) {
-        if ((workload.input.namespace || 'default') !== namespace) continue
-        if (selectorMatches(object.spec?.selector, workloadLabels(workload.object))) {
-          pushUniqueEdge(edges, edgeKeys, {
-            from: record.identity,
-            to: workload.identity,
-            relation: 'selects',
-            discriminator: `selector:${object.metadata.name}->${workload.object.kind}/${workload.object.metadata.name}`,
-            attributes: {}
-          })
-        }
-      }
-    }
-    if (WORKLOAD_KINDS.has(object.kind)) {
-      for (const ref of collectWorkloadRefs(object)) {
-        addRelation(record, ref.kind, ref.name, 'references', ref.source, namespace)
-      }
-    }
-    if (object.kind === 'Ingress') {
-      for (const rule of object.spec?.rules || []) {
-        for (const path of rule?.http?.paths || []) {
-          const serviceName = path?.backend?.service?.name
-          if (serviceName) addRelation(record, 'Service', serviceName, 'routes-to', `rule:${serviceName}`, namespace)
-        }
-      }
-      const defaultService = object.spec?.defaultBackend?.service?.name
-      if (defaultService) addRelation(record, 'Service', defaultService, 'routes-to', `default:${defaultService}`, namespace)
-    }
-    if (object.kind === 'HorizontalPodAutoscaler' && object.spec?.scaleTargetRef?.name) {
-      addRelation(
-        record,
-        object.spec.scaleTargetRef.kind,
-        object.spec.scaleTargetRef.name,
-        'scales',
-        `target:${object.spec.scaleTargetRef.kind}/${object.spec.scaleTargetRef.name}`,
-        namespace
-      )
-    }
-  }
-
-  return finalizeConfigProjection(
-    { adapter, domain: 'kubernetes', mode, locator, nodes, edges, diagnostics },
-    KUBERNETES_ATTRIBUTE_ALLOWLIST
-  )
-}
-
-export function parseKubernetesManifests(source, { scope, locator = 'kubernetes.yaml', kindScopes = {} } = {}) {
-  return parseKubernetesProjection(source, { scope, locator, kindScopes })
-}
-
-export function parseKubernetesLiveSnapshot(
-  source,
-  { scope, locator = 'kubernetes-live.json', kindScopes = {} } = {}
-) {
-  return parseKubernetesProjection(source, {
-    scope,
-    locator,
-    kindScopes,
-    mode: 'live',
-    adapter: 'kubernetes-live'
-  })
-}

package/template/.pi/skills/drawio/scripts/adapters/kubernetes.test.js

@@ -1,81 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-
-import { ERROR_CODES } from './identity.js'
-import { KUBERNETES_ATTRIBUTE_ALLOWLIST, parseKubernetesManifests } from './kubernetes.js'
-
-const manifests = `
-apiVersion: apps/v1
-kind: Deployment
-metadata: { name: api, namespace: shop }
-spec:
-  replicas: 2
-  selector: { matchLabels: { app: api } }
-  template:
-    metadata: { labels: { app: api } }
-    spec:
-      containers:
-        - name: api
-          envFrom:
-            - configMapRef: { name: api-config }
----
-apiVersion: v1
-kind: Service
-metadata: { name: api, namespace: shop }
-spec:
-  selector: { app: api }
----
-apiVersion: v1
-kind: ConfigMap
-metadata: { name: api-config, namespace: shop }
-data: { PASSWORD: should-not-cross }
----
-apiVersion: networking.k8s.io/v1
-kind: Ingress
-metadata: { name: public, namespace: shop }
-spec:
-  rules:
-    - http:
-        paths:
-          - backend: { service: { name: api, port: { number: 80 } } }
----
-apiVersion: autoscaling/v2
-kind: HorizontalPodAutoscaler
-metadata: { name: api, namespace: shop }
-spec:
-  scaleTargetRef: { apiVersion: apps/v1, kind: Deployment, name: api }
-`
-
-test('parseKubernetesManifests extracts stable objects and declared relations', () => {
-  const projection = parseKubernetesManifests(manifests, { scope: 'prod', locator: 'k8s/app.yaml' })
-
-  assert.equal(projection.nodes.length, 5)
-  assert.deepEqual(
-    new Set(projection.edges.map((edge) => edge.relation)),
-    new Set(['selects', 'references', 'routes-to', 'scales'])
-  )
-  assert.ok(projection.nodes.every((node) => node.identity.key.startsWith('prod/')))
-  const config = projection.nodes.find((node) => node.label === 'api-config')
-  assert.equal('data' in config.attributes, false)
-  assert.deepEqual(KUBERNETES_ATTRIBUTE_ALLOWLIST.node, ['apiVersion', 'kind', 'namespace', 'replicas'])
-})
-
-test('parseKubernetesManifests rejects unknown kind scope without an override', () => {
-  assert.throws(
-    () =>
-      parseKubernetesManifests('apiVersion: example/v1\nkind: Widget\nmetadata: { name: demo }', {
-        scope: 'prod',
-        locator: 'k8s/widget.yaml'
-      }),
-    (error) => error.code === ERROR_CODES.ADAPTER_UNSUPPORTED && /scope/.test(error.message)
-  )
-})
-
-test('parseKubernetesManifests supports explicit CRD scope overrides', () => {
-  const projection = parseKubernetesManifests('apiVersion: example/v1\nkind: Widget\nmetadata: { name: demo }', {
-    scope: 'prod',
-    locator: 'k8s/widget.yaml',
-    kindScopes: { Widget: true }
-  })
-  assert.equal(projection.nodes[0].identity.key, 'prod/default/Widget/demo')
-})

package/template/.pi/skills/drawio/scripts/adapters/openapi.js

@@ -1,98 +0,0 @@
-import { ERROR_CODES, createOpenApiIdentity, createOpenApiSchemaIdentity } from './identity.js'
-import {
-  adapterError,
-  diagnostic,
-  finalizeConfigProjection,
-  isRecord,
-  parseStructuredDocuments,
-  pushUniqueEdge,
-  requireRecord
-} from './config-common.js'
-
-const ADAPTER = 'openapi-config'
-const METHODS = new Set(['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace'])
-
-export const OPENAPI_ATTRIBUTE_ALLOWLIST = Object.freeze({
-  node: ['component', 'method', 'operationId', 'path', 'tags'],
-  edge: [],
-  module: []
-})
-
-function collectRefs(value, refs, state = { seen: new WeakSet() }) {
-  if (!value || typeof value !== 'object') return
-  if (state.seen.has(value)) return
-  state.seen.add(value)
-  if (typeof value.$ref === 'string') refs.add(value.$ref)
-  if (Array.isArray(value)) {
-    for (const entry of value) collectRefs(entry, refs, state)
-  } else {
-    for (const entry of Object.values(value)) collectRefs(entry, refs, state)
-  }
-}
-
-export function parseOpenApiDocument(source, { locator = 'openapi.yaml' } = {}) {
-  const documents = parseStructuredDocuments(source, { adapter: ADAPTER })
-  if (documents.length !== 1) adapterError(ERROR_CODES.ADAPTER_PARSE, 'OpenAPI input must contain one document', { adapter: ADAPTER })
-  const document = requireRecord(documents[0], 'OpenAPI document', ADAPTER)
-  if (typeof document.openapi !== 'string' || !document.openapi.startsWith('3.')) {
-    adapterError(ERROR_CODES.ADAPTER_UNSUPPORTED, 'Only OpenAPI 3.x documents are supported', { adapter: ADAPTER })
-  }
-
-  const nodes = []
-  const schemaIdentities = new Map()
-  const schemas = isRecord(document.components?.schemas) ? document.components.schemas : {}
-  for (const name of Object.keys(schemas)) {
-    const identity = createOpenApiSchemaIdentity(name)
-    schemaIdentities.set(name, identity)
-    nodes.push({ identity, label: name, semanticType: 'document', attributes: { component: true } })
-  }
-
-  const operations = []
-  const paths = isRecord(document.paths) ? document.paths : {}
-  for (const [path, pathItem] of Object.entries(paths)) {
-    if (!isRecord(pathItem)) continue
-    for (const [method, operation] of Object.entries(pathItem)) {
-      if (!METHODS.has(method.toLowerCase()) || !isRecord(operation)) continue
-      const identity = createOpenApiIdentity({ method, path })
-      const label = operation.summary || operation.operationId || `${method.toUpperCase()} ${path}`
-      const attributes = { method: method.toUpperCase(), path }
-      if (typeof operation.operationId === 'string') attributes.operationId = operation.operationId
-      if (Array.isArray(operation.tags)) attributes.tags = operation.tags.filter((tag) => typeof tag === 'string')
-      nodes.push({ identity, label, semanticType: 'service', attributes })
-      operations.push({ identity, operation })
-    }
-  }
-
-  const edges = []
-  const edgeKeys = new Set()
-  const diagnostics = []
-  for (const { identity, operation } of operations) {
-    const refs = new Set()
-    collectRefs(operation, refs)
-    for (const ref of refs) {
-      const match = ref.match(/^#\/components\/schemas\/([^/]+)$/)
-      if (!match) {
-        diagnostics.push(diagnostic('OPENAPI_EXTERNAL_REF', `OpenAPI reference "${ref}" is outside local component schemas.`, identity))
-        continue
-      }
-      const schemaName = match[1].replaceAll('~1', '/').replaceAll('~0', '~')
-      const target = schemaIdentities.get(schemaName)
-      if (!target) {
-        diagnostics.push(diagnostic('OPENAPI_MISSING_SCHEMA', `OpenAPI operation references missing schema "${schemaName}".`, identity))
-        continue
-      }
-      pushUniqueEdge(edges, edgeKeys, {
-        from: identity,
-        to: target,
-        relation: 'uses-schema',
-        discriminator: `schema:${schemaName}`,
-        attributes: {}
-      })
-    }
-  }
-
-  return finalizeConfigProjection(
-    { adapter: ADAPTER, domain: 'openapi', locator, nodes, edges, diagnostics },
-    OPENAPI_ATTRIBUTE_ALLOWLIST
-  )
-}

package/template/.pi/skills/drawio/scripts/adapters/openapi.test.js

@@ -1,46 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-
-import { parseOpenApiDocument } from './openapi.js'
-
-const document = `
-openapi: 3.1.0
-paths:
-  /Pets/{id}:
-    get:
-      operationId: getPet
-      summary: Fetch pet
-      responses:
-        '200':
-          content:
-            application/json:
-              schema: { $ref: '#/components/schemas/Pet' }
-  /external:
-    post:
-      responses:
-        '200': { $ref: 'common.yaml#/responses/Ok' }
-components:
-  schemas:
-    Pet:
-      type: object
-`
-
-test('parseOpenApiDocument preserves method/path identity and component refs', () => {
-  const projection = parseOpenApiDocument(document, { locator: 'api/openapi.yaml' })
-  const operation = projection.nodes.find((node) => node.identity.scheme === 'openapi-operation')
-
-  assert.equal(operation.identity.key, 'GET /Pets/{id}')
-  assert.equal(projection.edges[0].relation, 'uses-schema')
-  assert.ok(projection.diagnostics.some((diagnostic) => diagnostic.code === 'OPENAPI_EXTERNAL_REF'))
-})
-
-test('OpenAPI summary and operationId changes do not change operation identity', () => {
-  const first = parseOpenApiDocument(document, { locator: 'api/openapi.yaml' })
-  const changed = parseOpenApiDocument(document.replace('getPet', 'renamed').replace('Fetch pet', 'Changed label'), {
-    locator: 'api/openapi.yaml'
-  })
-  assert.deepEqual(
-    first.nodes.map((node) => node.identity),
-    changed.nodes.map((node) => node.identity)
-  )
-})

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

@@ -1,16 +0,0 @@
-import { fileURLToPath } from 'node:url'
-
-import { MAX_CODE_PROJECT_BYTES } from './code-common.js'
-import { runFixedPythonWorker } from './optional-python.js'
-
-const WORKER_PATH = fileURLToPath(new URL('./python/code-parser-worker.py', import.meta.url))
-
-export function runOptionalPythonCodeParser(request, options = {}) {
-  return runFixedPythonWorker(request, {
-    ...options,
-    allowedAdapters: ['python-imports', 'python-classes'],
-    workerPath: WORKER_PATH,
-    maxInputBytes: MAX_CODE_PROJECT_BYTES,
-    pythonUnavailableMessage: 'Python 3.11+ is unavailable'
-  })
-}