t44 0.4.0-rc.3

package/caps/JsonSchemas.ts

@@ -0,0 +1,220 @@
+
+import { join } from 'path'
+import { mkdir, readFile, writeFile } from 'fs/promises'
+import Ajv from 'ajv'
+import addFormats from 'ajv-formats'
+import chalk from 'chalk'
+
+function createAjvInstance(): Ajv {
+    const ajv = new Ajv({
+        allErrors: true,
+        strict: false,
+        validateFormats: true,
+        logger: false
+    })
+    addFormats(ajv)
+    return ajv
+}
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: {
+    encapsulate: any
+    CapsulePropertyTypes: any
+    makeImportStack: any
+}) {
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule': {},
+            '#': {
+                WorkspaceConfig: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/WorkspaceConfig'
+                },
+                schemas: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: {}
+                },
+                resolveDefinition: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, defName: string): Promise<any | null> {
+                        const defValue = this.schemas[defName]
+                        if (!defValue) return null
+                        if (typeof defValue === 'object') return defValue
+                        return null
+                    }
+                },
+                validate: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, definitionName: string, data: any): Promise<{ warnings: any[], errors: any[] }> {
+                        const warnings: any[] = []
+                        const errors: any[] = []
+
+                        const schema = this.schemas[definitionName]
+                        if (!schema) {
+                            errors.push({
+                                type: 'schema_not_found',
+                                message: `Definition "${definitionName}" not found in schema schemas`,
+                                definitionName
+                            })
+                            return { warnings, errors }
+                        }
+
+                        const ajv = createAjvInstance()
+
+                        let validate
+                        try {
+                            validate = ajv.compile(schema)
+                        } catch (error: any) {
+                            warnings.push({
+                                type: 'schema_compilation_failed',
+                                message: `Schema compilation failed for "${definitionName}": ${error.message}`,
+                                definitionName,
+                                error: error.message
+                            })
+                            return { warnings, errors }
+                        }
+
+                        if (!validate(data)) {
+                            const validationErrors = validate.errors?.map((err: any) => ({
+                                path: err.instancePath || '/',
+                                message: err.message,
+                                params: err.params,
+                                keyword: err.keyword,
+                                schemaPath: err.schemaPath
+                            })) || []
+
+                            errors.push({
+                                type: 'validation_failed',
+                                message: `Data does not conform to schema "${definitionName}"`,
+                                definitionName,
+                                validationErrors
+                            })
+                        }
+
+                        return { warnings, errors }
+                    }
+                },
+                registerSchema: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, capsuleName: string, schema: Record<string, any>, schemaMinorVersion?: string): Promise<string | undefined> {
+                        if (!schema || !capsuleName) {
+                            return undefined
+                        }
+
+                        this.schemas[capsuleName] = schema
+
+                        const workspaceRootDir = this.WorkspaceConfig?.workspaceRootDir
+                        if (!workspaceRootDir) {
+                            return undefined
+                        }
+
+                        const jsonSchemaDir = join(
+                            workspaceRootDir,
+                            '.~o',
+                            'workspace.foundation',
+                            capsule['#'].replace(/\//g, '~')
+                        )
+                        await mkdir(jsonSchemaDir, { recursive: true })
+
+                        const version = schemaMinorVersion || '0'
+                        const schemaFilename = capsuleName.replace(/\//g, '~') + '.json'
+                        const schemaFilePath = join(jsonSchemaDir, schemaFilename)
+
+                        const schemaOutput: Record<string, any> = {
+                            $schema: 'https://json-schema.org/draft/2020-12/schema',
+                            $id: capsuleName + '.v' + version,
+                            ...schema
+                        }
+
+                        const schemaJson = JSON.stringify(schemaOutput, null, 4)
+                        const existing = await readFile(schemaFilePath, 'utf-8').catch(() => null)
+                        if (existing !== schemaJson) {
+                            await writeFile(schemaFilePath, schemaJson)
+                        }
+                        return schemaFilePath
+                    }
+                },
+                formatValidationFeedback: {
+                    type: CapsulePropertyTypes.Function,
+                    value: function (this: any, feedback: { warnings: any[], errors: any[] }, context: { filePath?: string, schemaRef?: string }): string {
+                        const lines: string[] = [
+                            '',
+                            chalk.bold.red('✗ Schema Validation Failed'),
+                            ''
+                        ]
+
+                        if (context.filePath) {
+                            lines.push(
+                                chalk.gray('  File:'),
+                                chalk.yellow(`    ${context.filePath}`),
+                                ''
+                            )
+                        }
+
+                        if (context.schemaRef) {
+                            lines.push(
+                                chalk.gray('  Schema:'),
+                                chalk.cyan(`    ${context.schemaRef}`),
+                                ''
+                            )
+                        }
+
+                        if (feedback.errors.length > 0) {
+                            lines.push(
+                                chalk.gray('  Errors:'),
+                                ...feedback.errors.map((e: any) => chalk.red(`    • ${e.message || e}`)),
+                                ''
+                            )
+                        }
+
+                        if (feedback.warnings.length > 0) {
+                            lines.push(
+                                chalk.gray('  Warnings:'),
+                                ...feedback.warnings.map((w: any) => chalk.yellow(`    • ${w.message || w}`)),
+                                ''
+                            )
+                        }
+
+                        return lines.join('\n')
+                    }
+                },
+                resolveSchemaFilePath: {
+                    type: CapsulePropertyTypes.Function,
+                    value: function (this: any, capsuleName: string): string | undefined {
+                        const workspaceRootDir = this.WorkspaceConfig?.workspaceRootDir
+                        if (!workspaceRootDir) return undefined
+                        const jsonSchemaDir = join(
+                            workspaceRootDir,
+                            '.~o',
+                            'workspace.foundation',
+                            capsule['#'].replace(/\//g, '~')
+                        )
+                        const schemaFilename = capsuleName.replace(/\//g, '~') + '.json'
+                        return join(jsonSchemaDir, schemaFilename)
+                    }
+                },
+                wrapWithSchema: {
+                    type: CapsulePropertyTypes.Function,
+                    value: function (this: any, data: any, capsuleName: string, version?: string): Record<string, any> {
+                        const output: Record<string, any> = {}
+                        // Use standard JSON Schema URL for $schema
+                        output.$schema = 'https://json-schema.org/draft/2020-12/schema'
+                        // Use entity identifier with version for $id
+                        const versionSuffix = version ? `.v${version}` : '.v0'
+                        output.$id = `${capsuleName}${versionSuffix}`
+                        Object.assign(output, data)
+                        return output
+                    }
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = 't44/caps/JsonSchemas'

package/caps/OpenApiSchema.ts

@@ -0,0 +1,67 @@
+import { join } from 'node:path'
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: {
+    encapsulate: any
+    CapsulePropertyTypes: any
+    makeImportStack: any
+}) {
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule': {},
+            '#': {
+                WorkspaceConfig: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/WorkspaceConfig'
+                },
+                url: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: undefined,
+                },
+                schemas: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: {}
+                },
+                ensureCached: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any): Promise<any | null> {
+                        if (!this.url) return null
+
+                        const cacheDir = join(
+                            this.WorkspaceConfig.workspaceRootDir,
+                            '.~o',
+                            'workspace.foundation',
+                            'OpenApiSchemas',
+                        )
+
+                        await mkdir(cacheDir, { recursive: true })
+
+                        const schemaFile = join(cacheDir, this.url.replace(/\//g, '~'))
+
+                        try {
+                            const cached = await readFile(schemaFile, 'utf-8')
+                            return JSON.parse(cached)
+                        } catch (error) {
+                            const response = await fetch(this.url)
+                            if (!response.ok) {
+                                return null
+                            }
+                            const openApiSpec = await response.json()
+                            await writeFile(schemaFile, JSON.stringify(openApiSpec, null, 2))
+                            return openApiSpec
+                        }
+                    }
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = 't44/caps/OpenApiSchema'

package/caps/PackageDescriptor.ts

@@ -0,0 +1,88 @@
+
+import { join } from 'path'
+import { readFile, writeFile } from 'fs/promises'
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: {
+    encapsulate: any
+    CapsulePropertyTypes: any
+    makeImportStack: any
+}) {
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule': {},
+            '#': {
+                JsonSchema: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/JsonSchemas'
+                },
+                RegisterSchemas: {
+                    type: CapsulePropertyTypes.StructInit,
+                    value: async function (this: any): Promise<void> {
+                        if (this.schema?.schema) {
+                            const version = this.schemaMinorVersion || '0'
+                            await this.JsonSchema.registerSchema(this.capsuleName, this.schema.schema, version)
+                        }
+                    }
+                },
+                _readPackageJson: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, packageJsonPath: string): Promise<any> {
+                        const content = await readFile(packageJsonPath, 'utf-8')
+                        return JSON.parse(content)
+                    }
+                },
+                _writePackageJson: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, packageJsonPath: string, pkg: any): Promise<void> {
+                        await writeFile(packageJsonPath, JSON.stringify(pkg, null, 4) + '\n')
+                    }
+                },
+                _resolveConfigSection: {
+                    type: CapsulePropertyTypes.Function,
+                    value: function (this: any, pkg: any): any {
+                        const structKey = this.capsuleName
+                        if (!pkg.config) return undefined
+                        if (!pkg.config.o) return undefined
+                        if (!pkg.config.o['workspace.foundation']) return undefined
+                        return pkg.config.o['workspace.foundation'][structKey] || undefined
+                    }
+                },
+                get: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, packageJsonPath: string): Promise<any | null> {
+                        try {
+                            const pkg = await this._readPackageJson(packageJsonPath)
+                            return this._resolveConfigSection(pkg) || null
+                        } catch {
+                            return null
+                        }
+                    }
+                },
+                set: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, packageJsonPath: string, data: any): Promise<void> {
+                        const pkg = await this._readPackageJson(packageJsonPath)
+                        const structKey = this.capsuleName
+
+                        if (!pkg.config) pkg.config = {}
+                        if (!pkg.config.o) pkg.config.o = {}
+                        if (!pkg.config.o['workspace.foundation']) pkg.config.o['workspace.foundation'] = {}
+
+                        pkg.config.o['workspace.foundation'][structKey] = data
+
+                        await this._writePackageJson(packageJsonPath, pkg)
+                    }
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = 't44/caps/PackageDescriptor'

package/caps/ProjectCatalogs.ts

@@ -0,0 +1,153 @@
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: {
+    encapsulate: any
+    CapsulePropertyTypes: any
+    makeImportStack: any
+}) {
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule': {},
+            '#t44/structs/ProjectCatalogsConfig': {
+                as: '$ProjectCatalogsConfig',
+            },
+            '#': {
+                HomeRegistry: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/HomeRegistry'
+                },
+                list: {
+                    type: CapsulePropertyTypes.GetterFunction,
+                    value: async function (this: any): Promise<Record<string, any>> {
+                        const catalogsConfig = await this.$ProjectCatalogsConfig.config
+                        return catalogsConfig?.catalogs || {}
+                    }
+                },
+                validate: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any): Promise<boolean> {
+                        const catalogsConfig = await this.$ProjectCatalogsConfig.config
+                        const catalogs = catalogsConfig?.catalogs
+
+                        if (!catalogs || typeof catalogs !== 'object') {
+                            return true
+                        }
+
+                        const chalk = (await import('chalk')).default
+
+                        for (const [catalogName, catalogConfig] of Object.entries(catalogs)) {
+                            if (!catalogConfig || typeof catalogConfig !== 'object') {
+                                console.log(chalk.red(`\n✗ Invalid catalog '${catalogName}': must be an object.\n`))
+                                return false
+                            }
+
+                            const fileName = catalogName.replace(/\//g, '~')
+                            const typedConfig = catalogConfig as Record<string, any>
+
+                            const existing = await this.HomeRegistry.getCatalog(fileName) || {}
+                            const now = new Date().toISOString()
+
+                            // Deep merge: config keys into existing, preserving existing nested data
+                            let changed = false
+                            for (const [key, value] of Object.entries(typedConfig)) {
+                                if (key === 'repositories' && typeof value === 'object' && typeof existing[key] === 'object') {
+                                    // Merge repositories: add missing repos, keep existing repo data
+                                    for (const [repoName, repoConfig] of Object.entries(value as Record<string, any>)) {
+                                        if (!existing[key][repoName]) {
+                                            existing[key][repoName] = repoConfig || {}
+                                            changed = true
+                                        }
+                                    }
+                                } else if (JSON.stringify(existing[key]) !== JSON.stringify(value)) {
+                                    existing[key] = value
+                                    changed = true
+                                }
+                            }
+
+                            if (changed) {
+                                existing.updatedAt = now
+                            }
+                            if (!existing.createdAt) {
+                                existing.createdAt = now
+                            }
+
+                            const filePath = await this.HomeRegistry.setCatalog(fileName, existing)
+                            if (changed) {
+                                console.log(chalk.green(`   ✓ Catalog '${catalogName}' → ${filePath}`))
+                            }
+                        }
+
+                        return true
+                    }
+                },
+                updateCatalogRepository: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, {
+                        repoName,
+                        providerKey,
+                        providerData,
+                    }: {
+                        repoName: string
+                        providerKey: string
+                        providerData: Record<string, any>
+                    }): Promise<void> {
+                        const catalogsConfig = await this.$ProjectCatalogsConfig.config
+                        const catalogs = catalogsConfig?.catalogs
+
+                        if (!catalogs || typeof catalogs !== 'object') return
+
+                        for (const [catalogName, catalogConfig] of Object.entries(catalogs)) {
+                            const typedConfig = catalogConfig as Record<string, any>
+                            const repositories = typedConfig.repositories
+                            if (!repositories || typeof repositories !== 'object') continue
+                            if (!(repoName in repositories)) continue
+
+                            const fileName = catalogName.replace(/\//g, '~')
+                            const existing = await this.HomeRegistry.getCatalog(fileName)
+                            if (!existing) continue
+
+                            if (!existing.repositories) existing.repositories = {}
+                            if (!existing.repositories[repoName]) existing.repositories[repoName] = {}
+                            const repoEntry = existing.repositories[repoName]
+                            const now = new Date().toISOString()
+
+                            const existingEntity = repoEntry[providerKey]
+                            const entityCreatedAt = existingEntity?.createdAt || now
+
+                            // Check if data actually changed (compare without timestamps, order-independent)
+                            const { createdAt: _ec, updatedAt: _eu, ...existingData } = existingEntity || {}
+                            const stableStringify = (obj: any): string => JSON.stringify(obj, (_, v) =>
+                                v && typeof v === 'object' && !Array.isArray(v)
+                                    ? Object.keys(v).sort().reduce((o: any, k) => { o[k] = v[k]; return o }, {})
+                                    : v
+                            )
+                            const dataChanged = stableStringify(existingData) !== stableStringify(providerData)
+
+                            repoEntry[providerKey] = {
+                                ...providerData,
+                                createdAt: entityCreatedAt,
+                                updatedAt: dataChanged ? now : (existingEntity?.updatedAt || now),
+                            }
+
+                            if (!repoEntry.createdAt) repoEntry.createdAt = now
+                            if (dataChanged) {
+                                repoEntry.updatedAt = now
+                                existing.updatedAt = now
+                            }
+
+                            await this.HomeRegistry.setCatalog(fileName, existing)
+                        }
+                    }
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = 't44/caps/ProjectCatalogs'