117 lines
3.8 KiB
TypeScript
Executable File
117 lines
3.8 KiB
TypeScript
Executable File
#!/usr/bin/env bun
|
|
|
|
import { z } from "zod"
|
|
import { Config } from "@/config/config"
|
|
import { zodObject } from "@opencode-ai/core/effect-zod"
|
|
import { TuiJsonSchema } from "../src/cli/cmd/tui/config/tui-json-schema"
|
|
import { Schema } from "effect"
|
|
|
|
type JsonSchema = Record<string, unknown>
|
|
|
|
function generate(schema: z.ZodType) {
|
|
const result = z.toJSONSchema(schema, {
|
|
io: "input", // Generate input shape (treats optional().default() as not required)
|
|
/**
|
|
* We'll use the `default` values of the field as the only value in `examples`.
|
|
* This will ensure no docs are needed to be read, as the configuration is
|
|
* self-documenting.
|
|
*
|
|
* See https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-00#rfc.section.9.5
|
|
*/
|
|
override(ctx) {
|
|
const schema = ctx.jsonSchema
|
|
|
|
// Preserve strictness: set additionalProperties: false for objects
|
|
if (
|
|
schema &&
|
|
typeof schema === "object" &&
|
|
schema.type === "object" &&
|
|
schema.additionalProperties === undefined
|
|
) {
|
|
schema.additionalProperties = false
|
|
}
|
|
|
|
// Add examples and default descriptions for string fields with defaults
|
|
if (schema && typeof schema === "object" && "type" in schema && schema.type === "string" && schema?.default) {
|
|
if (!schema.examples) {
|
|
schema.examples = [schema.default]
|
|
}
|
|
|
|
schema.description = [schema.description || "", `default: \`${formatDefault(schema.default)}\``]
|
|
.filter(Boolean)
|
|
.join("\n\n")
|
|
.trim()
|
|
}
|
|
},
|
|
}) as Record<string, unknown> & {
|
|
allowComments?: boolean
|
|
allowTrailingCommas?: boolean
|
|
}
|
|
|
|
// used for json lsps since config supports jsonc
|
|
result.allowComments = true
|
|
result.allowTrailingCommas = true
|
|
|
|
return result
|
|
}
|
|
|
|
function formatDefault(value: unknown) {
|
|
if (typeof value !== "object" || value === null) return String(value)
|
|
return JSON.stringify(value)
|
|
}
|
|
|
|
function generateEffect(schema: Schema.Top) {
|
|
const document = Schema.toJsonSchemaDocument(schema)
|
|
const normalized = normalize({
|
|
$schema: "https://json-schema.org/draft/2020-12/schema",
|
|
...document.schema,
|
|
$defs: document.definitions,
|
|
})
|
|
if (!isRecord(normalized)) throw new Error("schema generator produced a non-object schema")
|
|
normalized.allowComments = true
|
|
normalized.allowTrailingCommas = true
|
|
return normalized
|
|
}
|
|
|
|
function normalize(value: unknown): unknown {
|
|
if (Array.isArray(value)) return value.map(normalize)
|
|
if (!isRecord(value)) return value
|
|
|
|
const schema = Object.fromEntries(Object.entries(value).map(([key, item]) => [key, normalize(item)]))
|
|
|
|
if (Array.isArray(schema.anyOf)) {
|
|
const anyOf = schema.anyOf.filter((item) => !isRecord(item) || item.type !== "null")
|
|
if (anyOf.length !== schema.anyOf.length) {
|
|
const { anyOf: _, ...rest } = schema
|
|
if (anyOf.length === 1 && isRecord(anyOf[0])) return normalize({ ...anyOf[0], ...rest })
|
|
return { ...rest, anyOf }
|
|
}
|
|
}
|
|
|
|
if (Array.isArray(schema.allOf) && schema.allOf.length === 1 && isRecord(schema.allOf[0])) {
|
|
const { allOf: _, ...rest } = schema
|
|
return normalize({ ...schema.allOf[0], ...rest })
|
|
}
|
|
|
|
if (schema.type === "integer" && schema.maximum === undefined) {
|
|
return { ...schema, maximum: Number.MAX_SAFE_INTEGER }
|
|
}
|
|
|
|
return schema
|
|
}
|
|
|
|
function isRecord(value: unknown): value is JsonSchema {
|
|
return typeof value === "object" && value !== null && !Array.isArray(value)
|
|
}
|
|
|
|
const configFile = process.argv[2]
|
|
const tuiFile = process.argv[3]
|
|
|
|
console.log(configFile)
|
|
await Bun.write(configFile, JSON.stringify(generate(zodObject(Config.Info).strict().meta({ ref: "Config" })), null, 2))
|
|
|
|
if (tuiFile) {
|
|
console.log(tuiFile)
|
|
await Bun.write(tuiFile, JSON.stringify(generateEffect(TuiJsonSchema.Info), null, 2))
|
|
}
|