create-yss-spec 2.1.4 → 2.1.6

package/template/.claude/skills/drawio/scripts/adapters/docker-inspect.js

@@ -1,127 +0,0 @@
-import { ERROR_CODES, createComposeIdentity, serializeIdentity } from './identity.js'
-import {
-  adapterError,
-  diagnostic,
-  finalizeConfigProjection,
-  isRecord,
-  parseJsonDocument,
-  pushUniqueEdge
-} from './config-common.js'
-import { COMPOSE_ATTRIBUTE_ALLOWLIST, buildComposeIdentityInput } from './compose.js'
-
-const ADAPTER = 'docker-inspect'
-const PROJECT_LABEL = 'com.docker.compose.project'
-const SERVICE_LABEL = 'com.docker.compose.service'
-const DEPENDS_ON_LABEL = 'com.docker.compose.depends_on'
-
-function composeLabels(container) {
-  const labels = isRecord(container.Config?.Labels) ? container.Config.Labels : {}
-  const project = labels[PROJECT_LABEL]
-  const service = labels[SERVICE_LABEL]
-  if (typeof project !== 'string' || typeof service !== 'string') return null
-  return { project, service, dependsOn: labels[DEPENDS_ON_LABEL] }
-}
-
-function dependencyServices(value) {
-  if (typeof value !== 'string') return []
-  return [...new Set(value.split(',').map((entry) => entry.trim().split(':', 1)[0]).filter(Boolean))].sort()
-}
-
-export function parseDockerInspectSnapshot(source, { locator = 'docker-inspect.json' } = {}) {
-  const document = parseJsonDocument(source, { adapter: ADAPTER })
-  if (!Array.isArray(document)) {
-    adapterError(ERROR_CODES.ADAPTER_PARSE, 'Docker inspect snapshot must be a JSON array', { adapter: ADAPTER })
-  }
-
-  const services = new Map()
-  let standalone = 0
-  for (const container of document) {
-    if (!isRecord(container)) {
-      adapterError(ERROR_CODES.ADAPTER_PARSE, 'Docker inspect container must be an object', { adapter: ADAPTER })
-    }
-    const labels = composeLabels(container)
-    if (!labels) {
-      standalone++
-      continue
-    }
-    const identity = createComposeIdentity(buildComposeIdentityInput(labels.service, { project: labels.project }))
-    const key = serializeIdentity(identity)
-    const image = typeof container.Config?.Image === 'string' ? container.Config.Image : null
-    const current = services.get(key)
-    if (current && current.image !== image) {
-      adapterError(ERROR_CODES.ADAPTER_PARSE, 'Docker inspect replicas have inconsistent image values', {
-        adapter: ADAPTER,
-        identity
-      })
-    }
-    const record = current || {
-      identity,
-      project: labels.project,
-      service: labels.service,
-      image,
-      replicas: 0,
-      dependsOn: new Set()
-    }
-    record.replicas++
-    for (const dependency of dependencyServices(labels.dependsOn)) record.dependsOn.add(dependency)
-    services.set(key, record)
-  }
-  if (services.size === 0) {
-    adapterError(ERROR_CODES.ADAPTER_UNSUPPORTED, 'Docker inspect snapshot contains no Compose-managed containers', {
-      adapter: ADAPTER
-    })
-  }
-
-  const nodes = [...services.values()].map((record) => ({
-    identity: record.identity,
-    label: record.service,
-    semanticType: 'service',
-    attributes: {
-      kind: 'service',
-      project: record.project,
-      replicas: record.replicas,
-      service: record.service,
-      ...(record.image ? { image: record.image } : {})
-    }
-  }))
-  const byProjectService = new Map(
-    [...services.values()].map((record) => [`${record.project}\0${record.service}`, record.identity])
-  )
-  const edges = []
-  const edgeKeys = new Set()
-  const diagnostics = []
-  for (const record of services.values()) {
-    for (const dependency of record.dependsOn) {
-      const target = byProjectService.get(`${record.project}\0${dependency}`)
-      if (!target) {
-        diagnostics.push(
-          diagnostic('DOCKER_EXTERNAL_DEPENDENCY', 'Compose service dependency is outside the inspect snapshot.', record.identity)
-        )
-        continue
-      }
-      pushUniqueEdge(edges, edgeKeys, {
-        from: record.identity,
-        to: target,
-        relation: 'depends-on',
-        discriminator: `depends_on:${dependency}`,
-        attributes: {}
-      })
-    }
-  }
-  if (standalone > 0) {
-    diagnostics.push(
-      diagnostic('DOCKER_STANDALONE_EXCLUDED', `Standalone containers were excluded. Count: ${standalone}.`)
-    )
-  }
-  diagnostics.push(
-    diagnostic(
-      'DOCKER_RESOURCE_PARITY_DEFERRED',
-      'Docker network and volume parity requires separately approved metadata and was not inferred.'
-    )
-  )
-
-  return finalizeConfigProjection(
-    { adapter: ADAPTER, domain: 'compose', mode: 'live', locator, nodes, edges, diagnostics },
-    COMPOSE_ATTRIBUTE_ALLOWLIST
-  )
-}

package/template/.claude/skills/drawio/scripts/adapters/docker-inspect.test.js

@@ -1,62 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-
-import { parseComposeConfig } from './compose.js'
-import { parseDockerInspectSnapshot } from './docker-inspect.js'
-
-const fixture = readFileSync(
-  new URL('../../references/examples/importers/live/docker-inspect.json', import.meta.url),
-  'utf8'
-)
-
-test('Docker inspect aggregates Compose replicas using declared identity and attributes', () => {
-  const live = parseDockerInspectSnapshot(fixture, { locator: 'snapshots/docker-inspect.json' })
-  const declared = parseComposeConfig(
-    'name: shop\nservices:\n  web:\n    image: example/web:1\n    deploy: { replicas: 2 }\n    depends_on: [db]\n  db:\n    image: postgres:16',
-    { locator: 'compose.yaml' }
-  )
-
-  assert.equal(live.source.mode, 'live')
-  assert.deepEqual(live.nodes.map((node) => node.identity), declared.nodes.map((node) => node.identity))
-  assert.deepEqual(live.nodes.map((node) => node.attributes), declared.nodes.map((node) => node.attributes))
-  assert.equal(live.edges.length, 1)
-  assert.ok(live.diagnostics.some((entry) => entry.code === 'DOCKER_STANDALONE_EXCLUDED'))
-
-  const serialized = JSON.stringify(live)
-  for (const secret of [
-    'docker-secret-must-not-cross',
-    'docker-label-secret-must-not-cross',
-    'host-path-must-not-cross',
-    'container-web-1-must-not-cross',
-    'standalone-container-must-not-cross'
-  ]) {
-    assert.equal(serialized.includes(secret), false, secret)
-  }
-})
-
-test('Docker inspect output is deterministic across container order and instance names', () => {
-  const containers = JSON.parse(fixture).reverse().map((container, index) => ({
-    ...container,
-    Id: `changed-${index}`,
-    Name: `/changed-${index}`
-  }))
-  const first = parseDockerInspectSnapshot(fixture, { locator: 'snapshots/first.json' })
-  const second = parseDockerInspectSnapshot(JSON.stringify(containers), { locator: 'snapshots/second.json' })
-
-  assert.deepEqual(first.nodes, second.nodes)
-  assert.deepEqual(first.edges, second.edges)
-})
-
-test('Docker inspect rejects ambiguous replicas and invalid top-level input', () => {
-  const containers = JSON.parse(fixture)
-  containers[1].Config.Image = 'example/web:2'
-  assert.throws(
-    () => parseDockerInspectSnapshot(JSON.stringify(containers), { locator: 'snapshot.json' }),
-    (error) => error.code === 'ADAPTER_PARSE' && /inconsistent image/.test(error.message)
-  )
-  assert.throws(
-    () => parseDockerInspectSnapshot('{}', { locator: 'snapshot.json' }),
-    (error) => error.code === 'ADAPTER_PARSE' && /array/.test(error.message)
-  )
-})

package/template/.claude/skills/drawio/scripts/adapters/fixtures/raster-extraction.json

@@ -1,31 +0,0 @@
-{
-  "schemaVersion": 1,
-  "canvas": {
-    "width": 960,
-    "height": 540,
-    "background": "#FFFFFF"
-  },
-  "nodes": [
-    {
-      "id": "source",
-      "label": "Source & ingress",
-      "shape": "rounded",
-      "fill": "#DAE8FC",
-      "stroke": "#6C8EBF"
-    },
-    {
-      "id": "sink",
-      "label": "Orders",
-      "shape": "cylinder"
-    }
-  ],
-  "edges": [
-    {
-      "id": "source-sink",
-      "source": "source",
-      "target": "sink",
-      "label": "writes",
-      "arrow": true
-    }
-  ]
-}

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

@@ -1,59 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { parseGoImportsProject } from './go-code.js'
-
-test('Go adapter projects intra-module package imports without a Go toolchain', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'drawio-go-'))
-  try {
-    writeFileSync(join(root, 'go.mod'), 'module example.com/m\n\ngo 1.21\n')
-    mkdirSync(join(root, 'a'))
-    mkdirSync(join(root, 'b'))
-    writeFileSync(join(root, 'a', 'a.go'), 'package a\nimport (\n  "example.com/m/b"\n  "fmt"\n)\n')
-    writeFileSync(join(root, 'b', 'b.go'), 'package b\n')
-    const projection = await parseGoImportsProject(root, {
-      parseFile: (source) => ({
-        imports: source.includes('example.com/m/b') ? ['example.com/m/b', 'fmt'] : [],
-        hasBuildConstraints: false
-      })
-    })
-
-    assert.deepEqual(projection.nodes.map((node) => node.identity.key), ['go/a', 'go/b'])
-    assert.equal(projection.edges[0].relation, 'imports')
-    assert.equal(projection.edges[0].to.key, 'go/b')
-    assert.ok(projection.diagnostics.some((entry) => entry.code === 'CODE_EXTERNAL_IMPORTS_IGNORED'))
-  } finally {
-    rmSync(root, { recursive: true, force: true })
-  }
-})
-
-test('Go adapter requires one explicit go.mod module directive', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'drawio-go-'))
-  try {
-    writeFileSync(join(root, 'main.go'), 'package main\n')
-    await assert.rejects(
-      () => parseGoImportsProject(root, { parseFile: () => ({ imports: [], hasBuildConstraints: false }) }),
-      (error) => error.code === 'ADAPTER_PARSE' && /go\.mod/.test(error.message)
-    )
-  } finally {
-    rmSync(root, { recursive: true, force: true })
-  }
-})
-
-test('Go adapter rejects workspace roots instead of treating them as one module', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'drawio-go-'))
-  try {
-    writeFileSync(join(root, 'go.mod'), 'module example.com/m\n')
-    writeFileSync(join(root, 'go.work'), 'go 1.21\nuse .\n')
-    writeFileSync(join(root, 'main.go'), 'package main\n')
-    await assert.rejects(
-      () => parseGoImportsProject(root, { parseFile: () => ({ imports: [], hasBuildConstraints: false }) }),
-      (error) => error.code === 'ADAPTER_UNSUPPORTED' && /workspace/.test(error.message)
-    )
-  } finally {
-    rmSync(root, { recursive: true, force: true })
-  }
-})

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

@@ -1,168 +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 parseGoModule(source) {
-  let modulePath = null
-  for (const rawLine of source.split(/\r?\n/)) {
-    const line = rawLine.trim()
-    if (line === '' || line.startsWith('//')) continue
-    if (line.startsWith('replace ') || line === 'replace (') {
-      codeAdapterError(ERROR_CODES.ADAPTER_UNSUPPORTED, 'go.mod replace directives are not supported')
-    }
-    const match = /^module\s+([^\s]+)(?:\s+\/\/.*)?$/.exec(line)
-    if (!match) continue
-    if (modulePath) codeAdapterError(ERROR_CODES.ADAPTER_PARSE, 'go.mod contains multiple module directives')
-    modulePath = match[1]
-  }
-  if (!modulePath || /[\\\u0000-\u0020\u007f]/.test(modulePath)) {
-    codeAdapterError(ERROR_CODES.ADAPTER_PARSE, 'go.mod requires one safe module directive')
-  }
-  return modulePath.replace(/\/$/, '')
-}
-
-function decodeImportPath(text, path, position) {
-  try {
-    if (text.startsWith('`') && text.endsWith('`')) return text.slice(1, -1)
-    if (text.startsWith('"') && text.endsWith('"')) return JSON.parse(text)
-  } catch (error) {
-    codeAdapterError(ERROR_CODES.ADAPTER_PARSE, 'Go import path could not be decoded', {
-      path,
-      line: position?.row == null ? undefined : position.row + 1,
-      column: position?.column
-    }, error)
-  }
-  codeAdapterError(ERROR_CODES.ADAPTER_UNSUPPORTED, 'Go import path uses unsupported syntax', { path })
-}
-
-async function createGoSourceParser() {
-  const [parserModule, grammarModule] = await Promise.all([
-    loadOptionalParser('tree-sitter', 'tree-sitter@0.21.1'),
-    loadOptionalParser('tree-sitter-go', 'tree-sitter-go@0.23.4')
-  ])
-  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, 'Go 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, 'Go source could not be parsed', { path }, error)
-    }
-    if (root.hasError) {
-      const errorNode = root.descendantsOfType('ERROR')[0] || root
-      codeAdapterError(ERROR_CODES.ADAPTER_PARSE, 'Go source contains invalid syntax', {
-        path,
-        line: errorNode.startPosition.row + 1,
-        column: errorNode.startPosition.column
-      })
-    }
-    const imports = root.descendantsOfType('import_spec').map((node) => {
-      const pathNode = node.childForFieldName('path')
-      if (!pathNode) codeAdapterError(ERROR_CODES.ADAPTER_PARSE, 'Go import is missing its path', { path })
-      return decodeImportPath(pathNode.text, path, pathNode.startPosition)
-    })
-    const hasBuildConstraints = root.descendantsOfType('comment').some((node) => {
-      const text = node.text.trimStart()
-      return text.startsWith('//go:build') || text.startsWith('// +build')
-    })
-    return { imports, hasBuildConstraints }
-  }
-}
-
-function packagePath(filePath) {
-  const directory = posix.dirname(filePath)
-  return directory === '.' ? '_root' : directory
-}
-
-export async function parseGoImportsProject(projectRoot, { locator = 'project', parseFile } = {}) {
-  const scan = scanCodeProject(projectRoot, { extensions: ['.go', '.mod', '.work'] })
-  const goFiles = scan.files.filter((file) => file.path.endsWith('.go'))
-  const moduleFiles = scan.files.filter((file) => file.path.endsWith('.mod'))
-  if (goFiles.length === 0) codeAdapterError(ERROR_CODES.ADAPTER_UNSUPPORTED, 'Go project contains no source files')
-  if (scan.files.some((file) => file.path === 'go.work')) {
-    codeAdapterError(ERROR_CODES.ADAPTER_UNSUPPORTED, 'Go workspace files are not supported')
-  }
-  if (moduleFiles.length !== 1 || moduleFiles[0].path !== 'go.mod') {
-    codeAdapterError(ERROR_CODES.ADAPTER_PARSE, 'Go project requires exactly one root go.mod file')
-  }
-  const modulePath = parseGoModule(moduleFiles[0].source)
-  const sourceParser = parseFile || await createGoSourceParser()
-  const packagePaths = [...new Set(goFiles.map((file) => packagePath(file.path)))]
-  const packageSet = new Set(packagePaths)
-  const identities = new Map(
-    packagePaths.map((path) => [path, createCodeIdentity({ language: 'go', modulePath: path })])
-  )
-  const nodes = packagePaths.map((path) => moduleNode('go', path, { label: path }))
-  const edges = []
-  const seenEdges = new Set()
-  let ignored = 0
-  let constrainedFiles = 0
-
-  for (const file of goFiles) {
-    let parsed
-    try {
-      parsed = await sourceParser(file.source, file.path)
-    } catch (error) {
-      if (error?.code) throw error
-      codeAdapterError(ERROR_CODES.ADAPTER_PARSE, 'Go source could not be parsed', { path: file.path }, error)
-    }
-    if (
-      !parsed ||
-      !Array.isArray(parsed.imports) ||
-      !parsed.imports.every((value) => typeof value === 'string') ||
-      typeof parsed.hasBuildConstraints !== 'boolean'
-    ) {
-      codeAdapterError(ERROR_CODES.ADAPTER_PARSE, 'Go parser returned an invalid result', { path: file.path })
-    }
-    if (parsed.hasBuildConstraints) constrainedFiles++
-    for (const imported of parsed.imports) {
-      let targetPath
-      if (imported === modulePath) targetPath = '_root'
-      else if (imported.startsWith(`${modulePath}/`)) targetPath = imported.slice(modulePath.length + 1)
-      else {
-        ignored++
-        continue
-      }
-      if (!packageSet.has(targetPath)) {
-        codeAdapterError(ERROR_CODES.ADAPTER_UNSUPPORTED, 'Go intra-module import does not resolve to a scanned package', {
-          path: file.path
-        })
-      }
-      const from = identities.get(packagePath(file.path))
-      const to = identities.get(targetPath)
-      if (serializeIdentity(from) === serializeIdentity(to)) continue
-      const key = `${serializeIdentity(from)}\0imports\0${serializeIdentity(to)}`
-      if (seenEdges.has(key)) continue
-      seenEdges.add(key)
-      edges.push({ from, to, relation: 'imports', attributes: {} })
-    }
-  }
-
-  const diagnostics = [
-    ...aggregateDiagnostic('CODE_EXTERNAL_IMPORTS_IGNORED', ignored, 'External or standard-library imports were ignored.'),
-    ...aggregateDiagnostic(
-      'GO_BUILD_CONSTRAINTS_INCLUDED',
-      constrainedFiles,
-      'Files with build constraints were included without evaluating the selected build.'
-    ),
-    ...scanDiagnostics(scan)
-  ]
-  return finalizeCodeProjection({ adapter: 'go-imports', locator, nodes, edges, diagnostics })
-}

package/template/.claude/skills/drawio/scripts/adapters/graph-drift.file.test.js

@@ -1,67 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import yaml from 'js-yaml'
-
-import {
-  compareGraphProjections,
-  parseComposeConfig,
-  parseDockerInspectSnapshot,
-  projectDriftReportToSpec,
-  renderDriftGraph
-} from './index.js'
-
-const fixtureUrl = new URL('../../references/examples/importers/live/', import.meta.url)
-
-function readText(name) {
-  return readFileSync(new URL(name, fixtureUrl), 'utf8')
-}
-
-test('file-backed declared/live drift case pins sanitized report, canonical spec, and C0 evidence', async () => {
-  const baseline = parseComposeConfig(readText('drift-declared-compose.yaml'), {
-    locator: 'fixtures/drift-declared-compose.yaml'
-  })
-  const observed = parseDockerInspectSnapshot(readText('docker-inspect.json'), {
-    locator: 'fixtures/docker-inspect.json'
-  })
-  const report = compareGraphProjections(baseline, observed, {
-    baselineContext: 'shop-production',
-    observedContext: 'shop-production'
-  })
-  const spec = projectDriftReportToSpec(report, baseline, observed, {
-    locator: 'fixtures/compose-drift-report.json'
-  })
-  const expectedReport = JSON.parse(readText('compose-drift-report.json'))
-  const expectedSpec = yaml.load(readText('compose-drift.spec.yaml'))
-  const evidence = JSON.parse(readText('compose-drift-evidence.json'))
-
-  assert.deepEqual(report, expectedReport)
-  assert.deepEqual(spec, expectedSpec)
-  assert.deepEqual(evidence.rendererIds, {
-    nodes: spec.nodes.map((node) => node.id),
-    edges: spec.edges.map((edge) => edge.id)
-  })
-  assert.equal(evidence.outputs.preview, null)
-  assert.equal(evidence.execution.providerCli, 'missing evidence')
-  assert.equal(evidence.execution.desktop, 'missing evidence')
-  assert.equal(evidence.execution.model, 'missing evidence')
-  assert.equal(evidence.stopping.autonomousRoundLimit, 2)
-  assert.equal(evidence.stopping.userRoundLimit, 5)
-
-  const rendered = await renderDriftGraph(report, baseline, observed, {
-    locator: 'fixtures/compose-drift-report.json'
-  })
-  assert.equal(rendered.layoutApplied, true)
-  assert.equal(rendered.xmlValidation.valid, true)
-
-  const serialized = JSON.stringify({ report, spec, evidence, xml: rendered.xml })
-  for (const forbidden of [
-    'docker-secret-must-not-cross',
-    'docker-label-secret-must-not-cross',
-    'host-path-must-not-cross',
-    'container-web-1-must-not-cross',
-    'standalone-container-must-not-cross'
-  ]) {
-    assert.equal(serialized.includes(forbidden), false, forbidden)
-  }
-})