370 lines
16 KiB
JavaScript
370 lines
16 KiB
JavaScript
import { createHash } from 'node:crypto'
|
||
import { readFile, readdir, writeFile } from 'node:fs/promises'
|
||
import path from 'node:path'
|
||
import process from 'node:process'
|
||
|
||
const args = new Map()
|
||
for (let index = 2; index < process.argv.length; index += 2) args.set(process.argv[index], process.argv[index + 1])
|
||
|
||
const explicitSourceRoot = args.get('--source-root')
|
||
const repoRoot = args.get('--repo-root') || (explicitSourceRoot ? path.dirname(explicitSourceRoot) : null)
|
||
const sourceRoot = explicitSourceRoot || (repoRoot ? path.join(repoRoot, 'gls') : null)
|
||
const sourceCommit = args.get('--source-commit')
|
||
const output = args.get('--output')
|
||
const projectionsPath = args.get('--projections')
|
||
|
||
if (!repoRoot || !sourceRoot || !sourceCommit || !output || !projectionsPath) {
|
||
throw new Error('usage: compile-gls-runtime-registry.mjs --repo-root <REPO-012> --source-commit <sha> --output <manifest.json> --projections <projections.json>')
|
||
}
|
||
if (!/^[a-f0-9]{40}$/.test(sourceCommit)) throw new Error('source commit must be a full SHA-1')
|
||
|
||
async function walk(directory, prefix = '') {
|
||
const entries = await readdir(directory, { withFileTypes: true })
|
||
const paths = []
|
||
for (const entry of entries) {
|
||
const relative = prefix ? `${prefix}/${entry.name}` : entry.name
|
||
if (entry.isDirectory()) paths.push(...await walk(path.join(directory, entry.name), relative))
|
||
else paths.push(relative)
|
||
}
|
||
return paths
|
||
}
|
||
|
||
async function readRequired(relative) {
|
||
return readFile(path.join(repoRoot, relative), 'utf8')
|
||
}
|
||
|
||
function sourceRank(relative) {
|
||
if (!relative.includes('/')) return 0
|
||
if (relative.startsWith('standards/')) return 1
|
||
if (relative.includes('/notion-export/')) return 3
|
||
return 2
|
||
}
|
||
|
||
function cleanHeading(line, id) {
|
||
return line.replace(/^#+\s*/, '').replaceAll('**', '').replace(new RegExp(`^${id}\\s*[·:：-]?\\s*`), '').trim() || id
|
||
}
|
||
|
||
function sourceStatus(raw) {
|
||
const line = raw.split(/\r?\n/, 100).find((item) => /^\s*(?:>|[-*]\s*)?(?:状态|Status)\s*[：:]/i.test(item))
|
||
if (!line) return 'UNSPECIFIED_SOURCE_STATUS'
|
||
return line.replace(/^\s*(?:>|[-*]\s*)?(?:状态|Status)\s*[：:]\s*/i, '').replaceAll('`', '').trim()
|
||
}
|
||
|
||
function sourceDependencies(raw) {
|
||
const match = raw.match(/^\s*depends:\s*\[([^\]]*)\]/m)
|
||
return [...new Set(match?.[1].match(/GLS-\d{4}/g) || [])].sort()
|
||
}
|
||
|
||
function contractKind(family, projectionKind) {
|
||
if (projectionKind) return projectionKind
|
||
const kinds = {
|
||
GLS_ENGINEERING: 'COMPILER_OR_INTERMEDIATE_REPRESENTATION',
|
||
GLP: 'MESSAGE_SCHEMA_OR_SYNC_CONTRACT',
|
||
GLP_CONTROL_PLANE: 'CONTROL_PLANE_STATE_MACHINE',
|
||
GLP_WITNESS: 'APPEND_ONLY_EVIDENCE_LEDGER',
|
||
HLDP: 'LANGUAGE_PROGRAM_PROFILE',
|
||
GLS_IMPLEMENTATION: 'ADAPTER_MODEL_OR_MODULE_CONTRACT',
|
||
AGE: 'EXECUTION_BODY_LIFECYCLE_STATE_MACHINE',
|
||
AGE_OS: 'RESOURCE_SCHEDULER',
|
||
AGE_AUTONOMOUS_RUNTIME: 'TIME_OR_CAPABILITY_EXTENSION_RUNTIME',
|
||
GUANGHU_WORLD: 'WORLD_BOOT_AND_RECOVERY_STATE_MACHINE',
|
||
GUANGHU_NATIVE_ENGINEERING: 'NATIVE_QUALITY_GATE',
|
||
GUANGHU_NATIVE_OS: 'NATIVE_NODE_RUNTIME_CONTRACT',
|
||
GUANGHU_NATIVE_STORAGE: 'NATIVE_STORAGE_CONTRACT',
|
||
GUANGHU_PERSONA_GESTATION: 'GESTATIONAL_INGRESS_OR_REVIEW_PIPELINE',
|
||
GUANGHU_LANGUAGE_WORLD: 'LANGUAGE_WORLD_BOUNDARY_GUARD',
|
||
}
|
||
return kinds[family] || 'UNCLASSIFIED_PROTOCOL_SOURCE'
|
||
}
|
||
|
||
function parseTableAuthorities(raw, authorityKind) {
|
||
const results = []
|
||
for (const line of raw.split(/\r?\n/)) {
|
||
const id = line.match(/^\|\s*(GLS-\d{4})\s*\|/)?.[1]
|
||
if (!id) continue
|
||
results.push({
|
||
id,
|
||
authority_kind: authorityKind,
|
||
declared_source_path: line.match(/`(gls\/[^`]+\.hdlp)`/)?.[1] || null,
|
||
})
|
||
}
|
||
return results
|
||
}
|
||
|
||
function parseSourceManifest(raw) {
|
||
const lines = raw.split(/\r?\n/)
|
||
const results = []
|
||
for (let index = 0; index < lines.length; index += 1) {
|
||
const match = lines[index].match(/^\s*-\s+id:\s*["']?(GLS-\d{4})["']?\s*$/)
|
||
if (!match) continue
|
||
let sourcePath = null
|
||
for (let cursor = index + 1; cursor < lines.length && cursor <= index + 12; cursor += 1) {
|
||
if (/^\s*-\s+id:/.test(lines[cursor])) break
|
||
sourcePath ||= lines[cursor].match(/^\s*source_path:\s*["']?(gls\/[^"']+\.hdlp)["']?\s*$/)?.[1] || null
|
||
}
|
||
results.push({ id: match[1], authority_kind: 'SOURCE_MANIFEST', declared_source_path: sourcePath })
|
||
}
|
||
return results
|
||
}
|
||
|
||
function stronglyConnectedComponents(graph) {
|
||
let nextIndex = 0
|
||
const indices = new Map()
|
||
const lowLinks = new Map()
|
||
const stack = []
|
||
const onStack = new Set()
|
||
const components = []
|
||
function visit(id) {
|
||
indices.set(id, nextIndex)
|
||
lowLinks.set(id, nextIndex)
|
||
nextIndex += 1
|
||
stack.push(id)
|
||
onStack.add(id)
|
||
for (const target of graph.get(id) || []) {
|
||
if (!graph.has(target)) continue
|
||
if (!indices.has(target)) {
|
||
visit(target)
|
||
lowLinks.set(id, Math.min(lowLinks.get(id), lowLinks.get(target)))
|
||
} else if (onStack.has(target)) lowLinks.set(id, Math.min(lowLinks.get(id), indices.get(target)))
|
||
}
|
||
if (lowLinks.get(id) !== indices.get(id)) return
|
||
const component = []
|
||
let current
|
||
do {
|
||
current = stack.pop()
|
||
onStack.delete(current)
|
||
component.push(current)
|
||
} while (current !== id)
|
||
if (component.length > 1 || (graph.get(id) || []).includes(id)) components.push(component.sort())
|
||
}
|
||
for (const id of [...graph.keys()].sort()) if (!indices.has(id)) visit(id)
|
||
return components.sort((left, right) => left[0].localeCompare(right[0]))
|
||
}
|
||
|
||
const projectionManifest = JSON.parse(await readFile(projectionsPath, 'utf8'))
|
||
if (projectionManifest.schema !== 'hololake.gls-executable-projections/v1' || projectionManifest.source_commit !== sourceCommit) {
|
||
throw new Error('projection manifest does not match the selected REPO-012 source commit')
|
||
}
|
||
|
||
const protocolRegistryPath = 'gls/GLS-PROTOCOL-REGISTRY.json'
|
||
const glsEntryPath = 'gls/GLS-ENTRY.hdlp'
|
||
const sourceManifestPath = 'gls/SOURCE-MANIFEST.yml'
|
||
const architectureCatalogPath = 'gls/GLS-ARCHITECTURE-CATALOG.hdlp'
|
||
const protocolRegistryRaw = await readRequired(protocolRegistryPath)
|
||
const glsEntryRaw = await readRequired(glsEntryPath)
|
||
const sourceManifestRaw = await readRequired(sourceManifestPath)
|
||
const architectureCatalogRaw = await readRequired(architectureCatalogPath)
|
||
const protocolRegistry = JSON.parse(protocolRegistryRaw)
|
||
|
||
const authorityFiles = [
|
||
[protocolRegistryPath, protocolRegistryRaw, 'PROTOCOL_REGISTRY'],
|
||
[glsEntryPath, glsEntryRaw, 'GLS_ENTRY'],
|
||
[sourceManifestPath, sourceManifestRaw, 'SOURCE_MANIFEST'],
|
||
[architectureCatalogPath, architectureCatalogRaw, 'ARCHITECTURE_CATALOG'],
|
||
].map(([source_path, raw, authority_kind]) => ({
|
||
authority_kind,
|
||
source_path,
|
||
source_sha256: createHash('sha256').update(raw).digest('hex'),
|
||
}))
|
||
|
||
const registryMetadata = new Map()
|
||
const authorityDeclarations = new Map()
|
||
function addAuthority(declaration) {
|
||
const declarations = authorityDeclarations.get(declaration.id) || []
|
||
if (!declarations.some((existing) => existing.authority_kind === declaration.authority_kind)) declarations.push(declaration)
|
||
authorityDeclarations.set(declaration.id, declarations)
|
||
}
|
||
|
||
for (const entry of protocolRegistry.existing_registered || []) {
|
||
registryMetadata.set(entry.id, { ...entry, registry_section: 'existing_registered' })
|
||
addAuthority({ id: entry.id, authority_kind: 'PROTOCOL_REGISTRY', declared_source_path: entry.source || null })
|
||
}
|
||
for (const entry of protocolRegistry.registered_draft_protocols || []) {
|
||
registryMetadata.set(entry.id, { ...entry, registry_section: 'registered_draft_protocols' })
|
||
addAuthority({ id: entry.id, authority_kind: 'PROTOCOL_REGISTRY', declared_source_path: entry.source || null })
|
||
}
|
||
for (const declaration of parseTableAuthorities(glsEntryRaw, 'GLS_ENTRY')) addAuthority(declaration)
|
||
for (const declaration of parseSourceManifest(sourceManifestRaw)) addAuthority(declaration)
|
||
for (const declaration of parseTableAuthorities(architectureCatalogRaw, 'ARCHITECTURE_CATALOG')) addAuthority(declaration)
|
||
|
||
const routingReferences = new Map()
|
||
const routingRoot = path.join(repoRoot, 'routing')
|
||
for (const relative of await walk(routingRoot)) {
|
||
if (!/\.(?:json|hdlp|md|yml|yaml)$/.test(relative)) continue
|
||
const raw = await readFile(path.join(routingRoot, relative), 'utf8')
|
||
for (const id of new Set(raw.match(/GLS-\d{4}/g) || [])) {
|
||
const refs = routingReferences.get(id) || []
|
||
refs.push(`routing/${relative}`)
|
||
routingReferences.set(id, refs)
|
||
}
|
||
}
|
||
|
||
const candidates = (await walk(sourceRoot))
|
||
.map((relative) => ({ relative, match: path.basename(relative).match(/^(GLS-\d{4}).*\.hdlp$/) }))
|
||
.filter((item) => item.match)
|
||
.map((item) => ({ id: item.match[1], relative: item.relative }))
|
||
const grouped = new Map()
|
||
for (const candidate of candidates) {
|
||
const group = grouped.get(candidate.id) || []
|
||
group.push(candidate.relative)
|
||
grouped.set(candidate.id, group)
|
||
}
|
||
|
||
const selectedSource = new Map()
|
||
for (const [id, sources] of grouped) {
|
||
sources.sort((left, right) => sourceRank(left) - sourceRank(right) || left.localeCompare(right))
|
||
const relative = sources[0]
|
||
selectedSource.set(id, {
|
||
relative,
|
||
raw: await readFile(path.join(sourceRoot, relative), 'utf8'),
|
||
alternate_source_count: sources.length - 1,
|
||
})
|
||
}
|
||
|
||
const knownSourceIds = new Set(selectedSource.keys())
|
||
const protocolRegistryIds = new Set(registryMetadata.keys())
|
||
const draftIds = new Set((protocolRegistry.registered_draft_protocols || []).map((entry) => entry.id))
|
||
const legacyDependencyTargets = new Set()
|
||
const draftGraph = new Map()
|
||
for (const id of draftIds) {
|
||
const dependencies = sourceDependencies(selectedSource.get(id)?.raw || '')
|
||
draftGraph.set(id, dependencies.filter((target) => draftIds.has(target)))
|
||
for (const target of dependencies) legacyDependencyTargets.add(target)
|
||
}
|
||
const legacyDependencyCycles = stronglyConnectedComponents(draftGraph)
|
||
|
||
const protocols = []
|
||
for (const [id, source] of [...selectedSource.entries()].sort(([left], [right]) => left.localeCompare(right))) {
|
||
const heading = source.raw.split(/\r?\n/).find((line) => line.startsWith('#') && line.includes(id))
|
||
const projection = projectionManifest.projections[id]
|
||
const metadata = registryMetadata.get(id) || null
|
||
const authorities = (authorityDeclarations.get(id) || []).sort((left, right) => left.authority_kind.localeCompare(right.authority_kind))
|
||
const declaredPaths = [...new Set(authorities.map((entry) => entry.declared_source_path).filter(Boolean))]
|
||
const authorityConflict = declaredPaths.length > 1
|
||
const registrationState = authorityConflict
|
||
? 'REGISTRATION_CONFLICT'
|
||
: authorities.some((entry) => entry.authority_kind === 'PROTOCOL_REGISTRY')
|
||
? 'REGISTERED_PROTOCOL_REGISTRY'
|
||
: authorities.length > 0
|
||
? 'REGISTERED_OTHER_CANONICAL_INDEX'
|
||
: 'DISCOVERED_UNRECONCILED'
|
||
const legacyDependencies = sourceDependencies(source.raw)
|
||
const dependencyEdges = [
|
||
...legacyDependencies.map((target) => ({
|
||
target,
|
||
edge_kind: 'LEGACY_UNTYPED_REFERENCE',
|
||
declared_by: `gls/${source.relative}`,
|
||
enters_runtime_graph: false,
|
||
target_registered: protocolRegistryIds.has(target),
|
||
target_numbered_source_available: knownSourceIds.has(target),
|
||
})),
|
||
...(projection?.dependencies || []).map((target) => ({
|
||
target,
|
||
edge_kind: 'RUNTIME_REQUIRES',
|
||
declared_by: 'contracts/gls-executable-projections.json',
|
||
enters_runtime_graph: true,
|
||
target_registered: protocolRegistryIds.has(target),
|
||
target_numbered_source_available: knownSourceIds.has(target),
|
||
})),
|
||
]
|
||
const activationBlockers = []
|
||
if (!projection) activationBlockers.push('NO_EXECUTABLE_ADAPTER')
|
||
if (registrationState === 'DISCOVERED_UNRECONCILED') activationBlockers.push('REGISTRATION_NOT_RECONCILED')
|
||
if (authorityConflict) activationBlockers.push('REGISTRATION_SOURCE_CONFLICT')
|
||
if (legacyDependencies.length > 0 && !projection) activationBlockers.push('LEGACY_DEPENDENCIES_REQUIRE_TYPED_REVIEW')
|
||
if (legacyDependencies.some((target) => !knownSourceIds.has(target)) && !projection) activationBlockers.push('DEPENDENCY_NUMBERED_SOURCE_MISSING')
|
||
protocols.push({
|
||
id,
|
||
title: cleanHeading(heading || id, id),
|
||
source_status: sourceStatus(source.raw),
|
||
source_path: `gls/${source.relative}`,
|
||
source_sha256: createHash('sha256').update(source.raw).digest('hex'),
|
||
alternate_source_count: source.alternate_source_count,
|
||
registration: {
|
||
state: registrationState,
|
||
authorities,
|
||
declared_source_paths: declaredPaths,
|
||
routing_reference_count: (routingReferences.get(id) || []).length,
|
||
},
|
||
maturity: {
|
||
registry_section: metadata?.registry_section || null,
|
||
registry_status: metadata?.status || null,
|
||
family: metadata?.family || null,
|
||
implementation_evidence: metadata?.implementation || null,
|
||
},
|
||
contract_kind: contractKind(metadata?.family, projection?.projection_kind),
|
||
projection_state: projection ? 'EXECUTABLE_PROJECTION' : 'INVENTORIED_NOT_EXECUTABLE',
|
||
projection_kind: projection?.projection_kind || null,
|
||
adapter: projection?.adapter || null,
|
||
event_kinds: projection?.event_kinds || [],
|
||
dependencies: projection?.dependencies || [],
|
||
dependency_edges: dependencyEdges,
|
||
activation_blockers: activationBlockers,
|
||
})
|
||
}
|
||
|
||
const known = new Set(protocols.map((protocol) => protocol.id))
|
||
for (const [id, projection] of Object.entries(projectionManifest.projections)) {
|
||
if (!known.has(id)) throw new Error(`projection references an unknown protocol: ${id}`)
|
||
for (const dependency of projection.dependencies) {
|
||
if (!projectionManifest.projections[dependency]) throw new Error(`${id} depends on a protocol without an executable projection: ${dependency}`)
|
||
}
|
||
}
|
||
const visiting = new Set()
|
||
const visited = new Set()
|
||
function visit(id) {
|
||
if (visiting.has(id)) throw new Error(`executable protocol dependency cycle at ${id}`)
|
||
if (visited.has(id)) return
|
||
visiting.add(id)
|
||
for (const dependency of projectionManifest.projections[id].dependencies) visit(dependency)
|
||
visiting.delete(id)
|
||
visited.add(id)
|
||
}
|
||
for (const id of Object.keys(projectionManifest.projections)) visit(id)
|
||
|
||
const executableCount = protocols.filter((protocol) => protocol.projection_state === 'EXECUTABLE_PROJECTION').length
|
||
const dependenciesNotInRegistry = [...legacyDependencyTargets].filter((id) => !protocolRegistryIds.has(id)).sort()
|
||
const dependenciesWithoutNumberedSource = [...legacyDependencyTargets].filter((id) => !knownSourceIds.has(id)).sort()
|
||
const numberedSourcesNotInProtocolRegistry = [...knownSourceIds].filter((id) => !protocolRegistryIds.has(id)).sort()
|
||
const registry = {
|
||
schema: 'hololake.gls-runtime-manifest/v2',
|
||
record_id: 'HLP-GLS-RUNTIME-MANIFEST-002',
|
||
source: {
|
||
repository: 'REPO-012',
|
||
commit: sourceCommit,
|
||
root: 'gls',
|
||
authority_files: authorityFiles,
|
||
},
|
||
compiler: {
|
||
source_protocol_is_human_and_machine_authority: true,
|
||
raw_protocol_text_executed: false,
|
||
arbitrary_protocol_code_allowed: false,
|
||
executable_projection_requires_explicit_adapter: true,
|
||
unprojected_protocol_behavior: 'INVENTORIED_NOT_EXECUTABLE',
|
||
legacy_untyped_dependency_behavior: 'AUDIT_ONLY_BLOCKS_NEW_ACTIVATION',
|
||
runtime_graph_source: 'EXPLICIT_EXECUTABLE_PROJECTIONS_ONLY',
|
||
runtime_dependency_cycles: 'REJECT',
|
||
unknown_protocol: 'FAIL_CLOSED',
|
||
},
|
||
reconciliation: {
|
||
numbered_protocol_count: protocols.length,
|
||
protocol_registry_id_count: protocolRegistryIds.size,
|
||
existing_registered_count: (protocolRegistry.existing_registered || []).length,
|
||
registered_draft_count: (protocolRegistry.registered_draft_protocols || []).length,
|
||
registered_draft_not_started_count: (protocolRegistry.registered_draft_protocols || []).filter((entry) => entry.implementation === 'NOT_STARTED').length,
|
||
legacy_dependency_target_count: legacyDependencyTargets.size,
|
||
dependencies_not_in_protocol_registry: dependenciesNotInRegistry,
|
||
dependencies_without_numbered_source: dependenciesWithoutNumberedSource,
|
||
numbered_sources_not_in_protocol_registry: numberedSourcesNotInProtocolRegistry,
|
||
legacy_dependency_cycles: legacyDependencyCycles,
|
||
discovered_unreconciled_count: protocols.filter((protocol) => protocol.registration.state === 'DISCOVERED_UNRECONCILED').length,
|
||
authority_conflict_count: protocols.filter((protocol) => protocol.registration.state === 'REGISTRATION_CONFLICT').length,
|
||
},
|
||
protocol_count: protocols.length,
|
||
executable_projection_count: executableCount,
|
||
inventoried_not_executable_count: protocols.length - executableCount,
|
||
protocols,
|
||
}
|
||
|
||
await writeFile(output, `${JSON.stringify(registry, null, 2)}\n`)
|
||
console.log(`GLS_RUNTIME_MANIFEST_COMPILED protocols=${protocols.length} registered=${protocolRegistryIds.size} executable=${executableCount} legacy_cycles=${legacyDependencyCycles.length} output=${output}`)
|