@friehub/blueprint 0.1.0

package/dist/cli/commands.js

@@ -0,0 +1,362 @@
+import { resolve, detectCycles } from "../core/resolve.js";
+import { buildGraph, renderAscii, renderMermaid } from "../core/graph.js";
+import { searchModules } from "../core/search.js";
+import { verifyImplementation } from "../core/verify.js";
+import { generateImplementPrompts } from "../core/implement.js";
+import { loadAdapters, loadSelection, addAdapter, removeAdapter, resolveAdapters, listAdaptersByModule } from "../core/adapters/index.js";
+import { generateAndWrite } from "../generators/engine.js";
+import { generatePrototype } from "../generators/prototype/index.js";
+import { renderList, renderAdapterList, minimalCatalog, generateJsonSchema } from "./render.js";
+import { writeFile, stat, mkdir } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import * as readline from "node:readline";
+async function readStdin() {
+    if (process.stdin.destroyed || process.stdin.readableEnded)
+        return "";
+    return new Promise((resolve) => {
+        const chunks = [];
+        process.stdin.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+        process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+        process.stdin.on("error", () => resolve(""));
+        process.stdin.resume();
+    });
+}
+function parseStdinModules(input) {
+    return input.split(/[\n,]/).map((s) => s.trim()).filter(Boolean);
+}
+async function interactivePicker(query, results) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const question = (prompt) => new Promise((resolve) => rl.question(prompt, resolve));
+    console.log(`\nFound ${results.length} modules matching "${query}":\n`);
+    for (let i = 0; i < results.length; i++) {
+        const r = results[i];
+        console.log(`  ${i + 1}. ${r.module.name}${r.module.summary ? ` - ${r.module.summary}` : ""}`);
+    }
+    console.log("\nEnter numbers (e.g., 1,3,5), or 'all':");
+    const answer = await question("> ");
+    rl.close();
+    const trimmed = answer.trim().toLowerCase();
+    if (trimmed === "all")
+        return results.map((r) => r.module.name);
+    return trimmed.split(",").map((s) => parseInt(s.trim(), 10) - 1)
+        .filter((i) => i >= 0 && i < results.length)
+        .map((i) => results[i].module.name);
+}
+async function writeOutput(outputData, outputPath) {
+    if (!outputPath) {
+        console.log(outputData);
+        return;
+    }
+    try {
+        await stat(dirname(outputPath));
+    }
+    catch {
+        console.error(`Error: output directory does not exist: ${dirname(outputPath)}`);
+        process.exit(1);
+    }
+    try {
+        await writeFile(outputPath, outputData, "utf8");
+    }
+    catch (error) {
+        console.error(`Error: could not write to ${outputPath}: ${error instanceof Error ? error.message : error}`);
+        process.exit(1);
+    }
+}
+export function checkErrors(result, strict, quiet) {
+    if (result.issues.length === 0)
+        return;
+    const errors = result.issues.filter((i) => i.severity === "error");
+    const warnings = result.issues.filter((i) => i.severity === "warning");
+    if (errors.length > 0) {
+        console.error("Errors:");
+        errors.forEach((e) => console.error(`  - ${e.message}`));
+        if (strict)
+            process.exit(1);
+        else
+            process.exitCode = 1;
+    }
+    if (warnings.length > 0 && !quiet) {
+        console.warn("Warnings:");
+        warnings.forEach((w) => console.warn(`  - ${w.message}`));
+    }
+}
+export async function handleList(result, config, root) {
+    const outputData = renderList(result.value);
+    await writeOutput(outputData, config.output);
+}
+export async function handleInspect(result, config, root) {
+    if (!config.target) {
+        console.error("Error: module name is required. Example: blueprint inspect billing");
+        process.exit(1);
+    }
+    const mod = result.value.modules.find((m) => m.name === config.target);
+    if (!mod) {
+        console.error(`Module not found: ${config.target}`);
+        process.exit(1);
+    }
+    const outputData = JSON.stringify(mod, null, config.compact ? undefined : 2);
+    await writeOutput(outputData, config.output);
+}
+export async function handleGraph(result, config, root) {
+    if (!config.target) {
+        console.error("Error: module name is required. Example: blueprint graph billing");
+        process.exit(1);
+    }
+    const graph = buildGraph(result.value, config.target);
+    if (graph.nodes.length === 0) {
+        console.error(`Module not found: ${config.target}`);
+        process.exit(1);
+    }
+    const outputData = config.format === "mermaid" ? renderMermaid(graph, config.target) : renderAscii(graph, config.target);
+    await writeOutput(outputData, config.output);
+}
+export async function handleSearch(result, config, root) {
+    let query = config.query;
+    if (!query && !process.stdin.isTTY) {
+        const input = await readStdin();
+        query = input.trim().split("\n")[0]?.trim();
+    }
+    if (!query) {
+        console.error("Error: search query is required. Example: blueprint search billing");
+        process.exit(1);
+    }
+    const results = searchModules(result.value, query);
+    if (results.length === 0) {
+        console.error(`No modules found matching "${query}"`);
+        process.exit(1);
+    }
+    if (process.stdin.isTTY) {
+        const selected = await interactivePicker(query, results);
+        if (selected.length === 0) {
+            console.error("No modules selected.");
+            process.exit(1);
+        }
+        const cycles = detectCycles(result.value);
+        if (cycles.length > 0) {
+            console.error("Cycle detected:");
+            cycles.forEach((c) => console.error(`  ${c.join(" → ")}`));
+            process.exit(1);
+        }
+        const resolved = resolve(result.value, selected);
+        if (resolved.errors.length > 0) {
+            console.error("Resolve errors:");
+            resolved.errors.forEach((e) => console.error(`  - ${e}`));
+            process.exit(1);
+        }
+        await writeOutput(JSON.stringify(resolved, null, config.compact ? undefined : 2), config.output);
+    }
+    else {
+        const names = results.map((r) => r.module.name);
+        await writeOutput(JSON.stringify(names, null, config.compact ? undefined : 2), config.output);
+    }
+}
+export async function handleResolve(result, config, root) {
+    let modules = config.modules;
+    if (modules.length === 0 && !process.stdin.isTTY) {
+        modules = parseStdinModules(await readStdin());
+    }
+    if (modules.length === 0) {
+        console.error("Error: --modules is required. Example: blueprint resolve --modules billing,payments,users");
+        process.exit(1);
+    }
+    const cycles = detectCycles(result.value);
+    if (cycles.length > 0) {
+        console.error("Cycle detected:");
+        cycles.forEach((c) => console.error(`  ${c.join(" → ")}`));
+        process.exit(1);
+    }
+    const resolved = resolve(result.value, modules);
+    if (resolved.errors.length > 0) {
+        console.error("Resolve errors:");
+        resolved.errors.forEach((e) => console.error(`  - ${e}`));
+        process.exit(1);
+    }
+    if (resolved.warnings.length > 0 && !config.quiet) {
+        resolved.warnings.forEach((w) => console.warn(`  - ${w}`));
+    }
+    await writeOutput(JSON.stringify(resolved, null, config.compact ? undefined : 2), config.output);
+}
+export async function handleAdapters(result, config, root) {
+    const adaptersDir = join(root, "adapters");
+    const { adapters, errors: loadErrors } = await loadAdapters(adaptersDir);
+    if (loadErrors.length > 0 && !config.quiet)
+        loadErrors.forEach((e) => console.warn(`  - ${e}`));
+    if (config.adapterSubcommand === "list") {
+        const byModule = listAdaptersByModule(adapters);
+        await writeOutput(renderAdapterList(byModule, config.query), config.output);
+    }
+    else if (config.adapterSubcommand === "add") {
+        if (!config.provider || !config.module) {
+            console.error("Error: provider and module required. Example: blueprint adapters add stripe payments");
+            process.exit(1);
+        }
+        const { selection, error } = await addAdapter(root, config.module, config.provider);
+        if (error) {
+            console.error(`Error: ${error}`);
+            process.exit(1);
+        }
+        console.log(`Added ${config.provider} as adapter for ${config.module}`);
+        await writeOutput(JSON.stringify(selection, null, config.compact ? undefined : 2), config.output);
+    }
+    else if (config.adapterSubcommand === "remove") {
+        if (!config.module) {
+            console.error("Error: module is required. Example: blueprint adapters remove payments");
+            process.exit(1);
+        }
+        const { selection, error } = await removeAdapter(root, config.module);
+        if (error) {
+            console.error(`Error: ${error}`);
+            process.exit(1);
+        }
+        console.log(`Removed adapter for ${config.module}`);
+        await writeOutput(JSON.stringify(selection, null, config.compact ? undefined : 2), config.output);
+    }
+    else if (config.adapterSubcommand === "show") {
+        const { selection } = await loadSelection(root);
+        await writeOutput(JSON.stringify(selection, null, config.compact ? undefined : 2), config.output);
+    }
+    else if (config.adapterSubcommand === "verify") {
+        const { selection } = await loadSelection(root);
+        const resolution = resolveAdapters(selection, adapters, result.value);
+        if (resolution.issues.length > 0) {
+            resolution.issues.forEach((issue) => {
+                const msg = `${issue.adapter ? `${issue.adapter} → ` : ""}${issue.module}: ${issue.message}`;
+                if (issue.severity === "error")
+                    console.error(`  ERROR: ${msg}`);
+                else if (!config.quiet)
+                    console.warn(`  WARN: ${msg}`);
+            });
+            if (resolution.issues.some((i) => i.severity === "error"))
+                process.exit(1);
+        }
+        else {
+            console.log("All adapters verified successfully.");
+        }
+        await writeOutput(JSON.stringify(resolution, null, config.compact ? undefined : 2), config.output);
+    }
+    else if (config.adapterSubcommand === "search") {
+        const query = config.query ?? "";
+        const results = adapters.filter((a) => a.name.includes(query) || a.module.includes(query) || a.description?.includes(query));
+        await writeOutput(JSON.stringify(results, null, config.compact ? undefined : 2), config.output);
+    }
+    else {
+        console.error("Error: adapter subcommand required. Available: list, add, remove, show, verify, search");
+        process.exit(1);
+    }
+}
+export async function handleGenerate(result, config, root) {
+    const language = config.language ?? "typescript";
+    const type = config.generateSubcommand ?? "all";
+    const outputDir = config.output ?? join(root, "generated");
+    const adaptersDir = join(root, "adapters");
+    const { adapters } = await loadAdapters(adaptersDir);
+    const { written, errors } = await generateAndWrite(result.value, adapters, { language, type, module: config.module, provider: config.provider, outputDir });
+    if (errors.length > 0) {
+        console.error("Generation errors:");
+        errors.forEach((e) => console.error(`  - ${e}`));
+    }
+    console.log(`Generated ${written} files to ${outputDir}`);
+}
+export async function handlePrototype(result, config, root) {
+    const { selection } = await loadSelection(root);
+    const adaptersDir = join(root, "adapters");
+    const { adapters } = await loadAdapters(adaptersDir);
+    const selectedAdapters = {};
+    for (const [module, adapterRef] of Object.entries(selection.adapters)) {
+        selectedAdapters[module] = typeof adapterRef === "string" ? adapterRef : adapterRef.primary;
+    }
+    if (Object.keys(selectedAdapters).length === 0) {
+        console.error("Error: No adapters selected. Use 'blueprint adapters add' first.");
+        process.exit(1);
+    }
+    const moduleName = config.target ?? "my-project";
+    const outputDir = config.output ?? join(root, moduleName);
+    const { files, errors } = generatePrototype(result.value, adapters, {
+        name: moduleName, modules: Object.keys(selectedAdapters), adapters: selectedAdapters, outputDir,
+    });
+    if (errors.length > 0) {
+        console.error("Prototype generation errors:");
+        errors.forEach((e) => console.error(`  - ${e}`));
+    }
+    for (const file of files) {
+        try {
+            const fullPath = join(outputDir, file.path);
+            await mkdir(dirname(fullPath), { recursive: true });
+            await writeFile(fullPath, file.content, "utf8");
+        }
+        catch (error) {
+            console.error(`Failed to write ${file.path}: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    console.log(`Generated prototype with ${files.length} files to ${outputDir}`);
+}
+export async function handleSchema(result, config, root) {
+    const outputData = JSON.stringify(generateJsonSchema(result.value), null, config.compact ? undefined : 2);
+    await writeOutput(outputData, config.output);
+}
+export async function handleBuild(result, config, root) {
+    if (process.exitCode) {
+        console.error("Catalog has errors. Use --strict to fail on errors, or fix the issues above.");
+        process.exit(1);
+    }
+    const outputData = config.minimal
+        ? JSON.stringify(minimalCatalog(result.value), null, config.compact ? undefined : 2)
+        : JSON.stringify(result.value, null, config.compact ? undefined : 2);
+    await writeOutput(outputData, config.output);
+}
+export async function handleImplement(result, config, root) {
+    if (!config.module) {
+        console.error("Error: --module is required. Example: blueprint implement payments --adapter stripe --prompts");
+        process.exit(1);
+    }
+    if (!config.provider) {
+        console.error("Error: --adapter is required. Example: blueprint implement payments --adapter stripe --prompts");
+        process.exit(1);
+    }
+    const adaptersDir = join(root, "adapters");
+    const { adapters } = await loadAdapters(adaptersDir);
+    const prompts = generateImplementPrompts(result.value, adapters, config.module, config.provider);
+    if (prompts.length === 0) {
+        console.error(`No functions to implement for ${config.provider}/${config.module}`);
+        process.exit(1);
+    }
+    if (config.prompts) {
+        console.log(`# Implementation prompts for ${config.provider} → ${config.module}`);
+        console.log(`# ${prompts.length} functions need implementation\n`);
+        for (const p of prompts) {
+            console.log(`--- ${p.function} ---`);
+            console.log(p.prompt);
+            console.log("");
+        }
+    }
+    else {
+        console.log(`${prompts.length} functions ready to implement for ${config.provider}/${config.module}`);
+        console.log("Use --prompts to generate AI prompts.");
+        for (const p of prompts) {
+            console.log(`  - ${p.function}`);
+        }
+    }
+}
+export async function handleVerify(result, config, root) {
+    if (!config.target) {
+        console.error("Error: implementation file is required. Example: blueprint verify ./src/adapters/stripe.ts --module payments");
+        process.exit(1);
+    }
+    if (!config.module) {
+        console.error("Error: --module is required. Example: blueprint verify ./src/adapters/stripe.ts --module payments");
+        process.exit(1);
+    }
+    const verification = await verifyImplementation(config.target, config.module, result.value);
+    if (verification.issues.length > 0) {
+        console.error(`Verification issues for ${config.module}:`);
+        for (const issue of verification.issues) {
+            if (issue.kind === "missing") {
+                console.error(`  MISSING: ${issue.message}`);
+            }
+        }
+    }
+    if (verification.valid) {
+        console.log(`\n${config.module}: All ${result.value.modules.find((m) => m.name === config.module).functions.length} functions implemented. ✓`);
+    }
+    await writeOutput(JSON.stringify(verification, null, config.compact ? undefined : 2), config.output);
+}

package/dist/cli/help.js

@@ -0,0 +1,211 @@
+export function printHelp(command) {
+    if (command === "resolve") {
+        console.log(`
+Usage: blueprint resolve [options]
+
+Options:
+  --modules <list>   Comma-separated module names to resolve
+  --root <path>      Project root directory (default: current directory)
+  --output <file>    Write the resolved set to this file instead of stdout
+  --compact          Output compact JSON (no indentation)
+  --quiet            Suppress warnings
+
+Reads module names from stdin if --modules is not provided.
+Examples:
+  blueprint resolve --modules billing,payments,users
+  echo billing,payments | blueprint resolve
+  cat modules.txt | blueprint resolve --output resolved.json
+`);
+        return;
+    }
+    if (command === "inspect") {
+        console.log(`
+Usage: blueprint inspect <module> [options]
+
+Options:
+  --root <path>      Project root directory (default: current directory)
+  --output <file>    Write the contract to this file instead of stdout
+  --compact          Output compact JSON (no indentation)
+
+Shows the full contract for a single module.
+`);
+        return;
+    }
+    if (command === "graph") {
+        console.log(`
+Usage: blueprint graph <module> [options]
+
+Options:
+  --format <fmt>     Output format: ascii (default) or mermaid
+  --root <path>      Project root directory (default: current directory)
+  --output <file>    Write the graph to this file instead of stdout
+
+Shows the dependency graph for a module.
+`);
+        return;
+    }
+    if (command === "search") {
+        console.log(`
+Usage: blueprint search <query> [options]
+
+Options:
+  --root <path>      Project root directory (default: current directory)
+  --output <file>    Write the resolved set to this file instead of stdout
+  --compact          Output compact JSON (no indentation)
+
+Searches for modules matching the query and interactively picks which to resolve.
+In non-interactive mode (piped input), outputs matching module names as JSON.
+Examples:
+  blueprint search billing
+  blueprint search "user management"
+  echo "payment" | blueprint search
+`);
+        return;
+    }
+    if (command === "adapters") {
+        console.log(`
+Usage: blueprint adapters <subcommand> [options]
+
+Subcommands:
+  list [module]         List available adapters
+  add <provider> <module>  Select an adapter for a module
+  remove <module>       Remove adapter selection
+  show                  Show current adapter selections
+  verify [module]       Verify adapters against contracts
+  search <query>        Search for adapters
+
+Options:
+  --root <path>         Project root directory (default: current directory)
+  --compact             Output compact JSON (no indentation)
+  --quiet               Suppress warnings
+
+Examples:
+  blueprint adapters list
+  blueprint adapters list payments
+  blueprint adapters add stripe payments
+  blueprint adapters remove payments
+  blueprint adapters show
+  blueprint adapters verify
+  blueprint adapters search stripe
+`);
+        return;
+    }
+    if (command === "generate") {
+        console.log(`
+Usage: blueprint generate [subcommand] [options]
+
+Subcommands:
+  interfaces            Generate language interfaces from contracts
+  adapters              Generate adapter skeletons
+  tests                 Generate conformance tests
+  all                   Generate all (default)
+
+Options:
+  --lang <language>     Target language: typescript (default), rust, python, go
+  --module <module>     Generate for specific module only
+  --output <dir>        Output directory (default: ./generated)
+  --root <path>         Project root directory (default: current directory)
+
+Examples:
+  blueprint generate
+  blueprint generate --lang typescript
+  blueprint generate interfaces --lang typescript
+  blueprint generate adapter stripe payments --lang typescript
+  blueprint generate tests --lang typescript
+  blueprint generate --module billing --lang typescript
+`);
+        return;
+    }
+    if (command === "verify") {
+        console.log(`
+Usage: blueprint verify <file> --module <module> [options]
+
+Options:
+  --module <module>  Module name to verify against (required)
+  --root <path>      Project root directory (default: current directory)
+  --compact          Output compact JSON (no indentation)
+
+Checks that an implementation file covers all contract functions.
+
+Examples:
+  blueprint verify ./src/adapters/payments/stripe.ts --module payments
+  blueprint verify ./src/adapters/payments/stripe.ts --module payments --compact
+`);
+        return;
+    }
+    if (command === "schema") {
+        console.log(`
+Usage: blueprint schema [options]
+
+Options:
+  --output <file>    Write schema to file instead of stdout
+  --compact          Output compact JSON (no indentation)
+  --root <path>      Project root directory (default: current directory)
+
+Exports the catalog as a JSON Schema for programmatic validation.
+
+Examples:
+  blueprint schema
+  blueprint schema --output catalog.schema.json
+  blueprint schema --compact
+`);
+        return;
+    }
+    if (command === "prototype") {
+        console.log(`
+Usage: blueprint prototype [options]
+
+Options:
+  --name <name>         Project name (default: my-project)
+  --output <dir>        Output directory (default: ./<name>)
+  --root <path>         Project root directory (default: current directory)
+
+Generates a project scaffold based on selected adapters.
+Requires adapters to be selected first with 'blueprint adapters add'.
+
+Examples:
+  blueprint prototype
+  blueprint prototype --name my-saas
+  blueprint prototype --output ./my-project
+`);
+        return;
+    }
+    console.log(`
+Usage: blueprint [command] [options]
+
+Commands:
+  build (default)    Load all contracts and output catalog.json
+  list               List all modules with dependencies
+  search <query>     Search for modules and interactively pick to resolve
+  inspect <module>   Show full contract for a module
+  graph <module>     Show dependency graph for a module
+  resolve            Resolve specific modules with dependencies
+  adapters           Manage adapter selections
+  generate           Generate code from contracts
+  prototype          Generate project scaffold
+  schema             Export catalog as JSON Schema
+  verify <file>      Verify an implementation against its contract
+
+Options:
+  --root <path>      Project root directory (default: current directory)
+  --strict           Exit with code 1 if there are any errors (warnings do not affect exit code)
+  --output <file>    Write output to this file instead of stdout
+  --modules <list>   Comma-separated module names (resolve command only)
+  --format <fmt>     Output format for graph: ascii (default) or mermaid
+  --compact          Output compact JSON (no indentation)
+  --quiet            Suppress warnings
+  --minimal          Output minimal JSON without raw sections
+  --help, -h         Show this help message
+  --version, -v      Show version number
+
+Examples:
+  blueprint list
+  blueprint inspect billing
+  blueprint graph billing
+  blueprint graph billing --format mermaid
+  blueprint resolve --modules billing,payments,users
+  blueprint resolve --modules billing,payments,users --output resolved.json
+  echo billing,payments | blueprint resolve --compact
+  blueprint schema --output catalog.schema.json
+`);
+}

package/dist/cli/render.js

@@ -0,0 +1,109 @@
+export function renderList(catalog) {
+    const lines = [];
+    lines.push("Modules:");
+    for (const mod of catalog.modules.sort((a, b) => a.name.localeCompare(b.name))) {
+        const deps = mod.hardDeps.length > 0 ? mod.hardDeps.join(", ") : "(none)";
+        const soft = mod.softDeps.length > 0 ? mod.softDeps.join(", ") : "(none)";
+        const coreInherits = mod.coreInherits.length > 0 ? mod.coreInherits.join(", ") : "(none)";
+        const summary = mod.functions.length > 0 ? ` (${mod.functions.length} functions)` : "";
+        lines.push(`  ${mod.name}${summary}`);
+        lines.push(`    deps: ${deps}`);
+        lines.push(`    recommends: ${soft}`);
+        lines.push(`    inherits: ${coreInherits}`);
+    }
+    lines.push("");
+    lines.push("Core contracts:");
+    for (const c of catalog.core.sort((a, b) => a.name.localeCompare(b.name))) {
+        lines.push(`  ${c.name}${c.implicit ? " (implicit)" : ""}`);
+    }
+    return lines.join("\n");
+}
+export function renderAdapterList(byModule, filter) {
+    const lines = [];
+    const modules = Object.keys(byModule).sort();
+    lines.push("Available adapters:");
+    lines.push("");
+    for (const module of modules) {
+        if (filter && !module.includes(filter)) {
+            continue;
+        }
+        const adapters = byModule[module];
+        lines.push(`  ${module}`);
+        for (const adapter of adapters) {
+            lines.push(`    - ${adapter}`);
+        }
+    }
+    return lines.join("\n");
+}
+export function minimalCatalog(catalog) {
+    return {
+        modules: catalog.modules.map((mod) => ({
+            name: mod.name,
+            version: mod.version,
+            functions: mod.functions.map((fn) => ({
+                name: fn.name,
+                params: fn.params.map((p) => `${p.name}${p.optional ? "?" : ""}: ${p.type ?? "unknown"}`),
+                returns: fn.returns,
+            })),
+            hardDeps: mod.hardDeps,
+            softDeps: mod.softDeps,
+            coreInherits: mod.coreInherits,
+        })),
+        core: catalog.core.map((c) => ({
+            name: c.name,
+            implicit: c.implicit,
+        })),
+    };
+}
+export function generateJsonSchema(catalog) {
+    return {
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        title: "Engineering Blueprinter Catalog",
+        type: "object",
+        properties: {
+            modules: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string" },
+                        functions: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    name: { type: "string" },
+                                    params: {
+                                        type: "array",
+                                        items: {
+                                            type: "object",
+                                            properties: {
+                                                name: { type: "string" },
+                                                type: { type: ["string", "null"] },
+                                                optional: { type: "boolean" },
+                                            },
+                                        },
+                                    },
+                                    returns: { type: "string" },
+                                },
+                            },
+                        },
+                        hardDeps: { type: "array", items: { type: "string" } },
+                        softDeps: { type: "array", items: { type: "string" } },
+                        coreInherits: { type: "array", items: { type: "string" } },
+                    },
+                },
+            },
+            core: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string" },
+                        implicit: { type: "boolean" },
+                    },
+                },
+            },
+        },
+    };
+}