@intentius/chant 0.124.12 → 0.124.14

package/dist/codegen/naming.js

@@ -0,0 +1,217 @@
+/**
+ * Collision-free naming strategy for TypeScript class names.
+ *
+ * 6-phase algorithm:
+ * 1. Priority names (backward compatibility)
+ * 1a. Reserved names — names this lexicon has already published (chant #1459)
+ * 2. Priority aliases (additional short names)
+ * 3. Short names (last segment of type)
+ * 4. Collision resolution (service-prefixed)
+ * 5. Property type aliases (globally unique defs)
+ *
+ * ## Why phase 1a exists
+ *
+ * Phases 3 and 4 assign a short name to whoever asks first and service-qualify
+ * everyone after. Membership of that contest is the whole input set, so a
+ * resource's name was a function of its NEIGHBOURS: removing
+ * `AWS::Athena::Session` upstream freed `Session`, and `AWS::Macie::Session`
+ * silently changed from `MacieSession` to `Session` — a breaking rename for a
+ * resource whose schema had not moved. Adding a resource does the same in
+ * reverse: `AWS::QuickSight::Space` appearing renamed `AWS::SageMaker::Space`
+ * from `Space` to `SageMakerSpace`.
+ *
+ * Worse, it is reversible. These are read-only registry types that come and go,
+ * so a name could flip back on the next upgrade and break consumers again.
+ *
+ * Reserved names invert the bias: a name that has already shipped belongs to
+ * the type that shipped it, and a newcomer colliding with it gets qualified
+ * instead. A published name then changes only when its own type disappears,
+ * which is a genuine breaking change rather than an incidental one.
+ */
+/**
+ * The names a lexicon has already published, read from a committed surface
+ * snapshot (chant #1459).
+ *
+ * The snapshot is keyed by TypeScript name with the spec type inside, which is
+ * exactly the mapping phase 1a needs, inverted. Only `resource` entries are
+ * reserved: property-type names are derived from their owning resource's name
+ * (phase 5), so pinning the resource pins them, and reserving them separately
+ * would freeze aliases that are meant to follow their parent.
+ */
+export function reservedNamesFromSnapshot(snapshot) {
+    var _a;
+    const reserved = {};
+    for (const [tsName, entry] of Object.entries(snapshot?.entries ?? {})) {
+        if (entry.kind !== "resource" || !entry.resourceType)
+            continue;
+        // First writer wins: a snapshot that somehow lists one spec type under two
+        // names keeps the earlier, rather than silently preferring iteration order.
+        reserved[_a = entry.resourceType] ?? (reserved[_a] = tsName);
+    }
+    return reserved;
+}
+export class NamingStrategy {
+    constructor(results, config) {
+        this.config = config;
+        this.assigned = new Map(); // typeName → primary TS name
+        this._aliases = new Map(); // typeName → additional TS names
+        this.usedNames = new Set();
+        this._propertyAliases = new Map(); // typeName → (defName → aliasName)
+        const typeNames = results.map((r) => r.typeName);
+        const abbreviateService = (service) => config.serviceAbbreviations[service] ?? service;
+        // Phase 1: assign priority names
+        for (const t of typeNames) {
+            const name = config.priorityNames[t];
+            if (name) {
+                this.assigned.set(t, name);
+                this.usedNames.add(name);
+            }
+        }
+        // Phase 1a: claim previously-published names (chant #1459).
+        //
+        // After priority names, which are explicit hand-pinned decisions and still
+        // win, and before any short name is contested. A reserved name whose type
+        // is gone from the input is simply never reached, so its name is released
+        // for whoever legitimately claims it next.
+        for (const t of typeNames) {
+            if (this.assigned.has(t))
+                continue;
+            const published = config.reservedNames?.[t];
+            // `usedNames` guards the case where a priority name already took it —
+            // an explicit pin outranks history.
+            if (published && !this.usedNames.has(published)) {
+                this.assigned.set(t, published);
+                this.usedNames.add(published);
+            }
+        }
+        // Phase 1b: assign priority aliases
+        for (const t of typeNames) {
+            const extras = config.priorityAliases[t];
+            if (extras) {
+                for (const alias of extras) {
+                    if (!this.usedNames.has(alias)) {
+                        const existing = this._aliases.get(t) ?? [];
+                        existing.push(alias);
+                        this._aliases.set(t, existing);
+                        this.usedNames.add(alias);
+                    }
+                }
+            }
+        }
+        // Phase 2: collect short names for non-priority types and detect collisions
+        const shortNameUsers = new Map(); // shortName → typeNames
+        const nonPriority = [];
+        for (const t of typeNames) {
+            if (this.assigned.has(t))
+                continue;
+            nonPriority.push(t);
+            const short = config.shortName(t);
+            const users = shortNameUsers.get(short) ?? [];
+            users.push(t);
+            shortNameUsers.set(short, users);
+        }
+        // Phase 3: assign non-colliding short names
+        for (const [short, users] of shortNameUsers) {
+            if (users.length === 1 && !this.usedNames.has(short)) {
+                this.assigned.set(users[0], short);
+                this.usedNames.add(short);
+            }
+        }
+        // Phase 4: resolve collisions with service prefix
+        for (const t of nonPriority) {
+            if (this.assigned.has(t))
+                continue;
+            const short = config.shortName(t);
+            const service = abbreviateService(config.serviceName(t));
+            const prefixed = service + short;
+            this.assigned.set(t, prefixed);
+            this.usedNames.add(prefixed);
+        }
+        // Phase 5: compute property type aliases
+        // First, force priority property aliases
+        for (const [typeName, aliases] of Object.entries(config.priorityPropertyAliases)) {
+            if (!this.assigned.has(typeName))
+                continue;
+            for (const [defName, aliasName] of Object.entries(aliases)) {
+                if (!this.usedNames.has(aliasName)) {
+                    let ptAliases = this._propertyAliases.get(typeName);
+                    if (!ptAliases) {
+                        ptAliases = new Map();
+                        this._propertyAliases.set(typeName, ptAliases);
+                    }
+                    ptAliases.set(defName, aliasName);
+                    this.usedNames.add(aliasName);
+                }
+            }
+        }
+        // Count how many resources define each property type defName
+        const defNameCount = new Map();
+        for (const r of results) {
+            const shortName = config.shortName(r.typeName);
+            for (const pt of r.propertyTypes) {
+                const defName = extractDefName(pt.name, shortName);
+                defNameCount.set(defName, (defNameCount.get(defName) ?? 0) + 1);
+            }
+        }
+        // For globally unique defNames, create an alias
+        for (const r of results) {
+            const typeName = r.typeName;
+            const tsName = this.assigned.get(typeName);
+            if (!tsName)
+                continue;
+            const shortName = config.shortName(typeName);
+            for (const pt of r.propertyTypes) {
+                const defName = extractDefName(pt.name, shortName);
+                if (defNameCount.get(defName) === 1 && !this.usedNames.has(defName)) {
+                    let ptAliases = this._propertyAliases.get(typeName);
+                    if (!ptAliases) {
+                        ptAliases = new Map();
+                        this._propertyAliases.set(typeName, ptAliases);
+                    }
+                    ptAliases.set(defName, defName);
+                    this.usedNames.add(defName);
+                }
+            }
+        }
+    }
+    /** Primary TypeScript class name for a type. */
+    resolve(typeName) {
+        return this.assigned.get(typeName);
+    }
+    /** Additional TypeScript names for a type. */
+    aliases(typeName) {
+        return this._aliases.get(typeName) ?? [];
+    }
+    /** All (typeName, tsName) pairs sorted by TS name. */
+    allAssignments() {
+        const pairs = [];
+        for (const [t, name] of this.assigned) {
+            pairs.push([t, name]);
+        }
+        for (const [t, extras] of this._aliases) {
+            for (const alias of extras) {
+                pairs.push([t, alias]);
+            }
+        }
+        pairs.sort((a, b) => a[1].localeCompare(b[1]));
+        return pairs;
+    }
+    /** Property type aliases for a given type. */
+    propertyTypeAliases(typeName) {
+        return this._propertyAliases.get(typeName);
+    }
+}
+/**
+ * Construct property type name: "Bucket_ServerSideEncryptionByDefault"
+ */
+export function propertyTypeName(parentTSName, defName) {
+    return `${parentTSName}_${defName}`;
+}
+/**
+ * Extract the raw definition name from a parser-generated name.
+ * "Bucket_ServerSideEncryptionByDefault" → "ServerSideEncryptionByDefault"
+ */
+export function extractDefName(parserName, shortName) {
+    const prefix = `${shortName}_`;
+    return parserName.startsWith(prefix) ? parserName.slice(prefix.length) : parserName;
+}

package/dist/codegen/okf-lexicon.js

@@ -0,0 +1,245 @@
+/**
+ * Lexicon OKF knowledge bundle (#1060, epic #1057) — projects a packaged
+ * lexicon's resource-type registry and lint rules into an Open Knowledge
+ * Format v0.2 bundle, emitted alongside the other build artifacts
+ * (`dist/meta.json`, `dist/types/`) as `dist/okf/`.
+ *
+ * Vocabulary, resolved against the project bundle (#1058, ../okf.ts): there a
+ * concept's `type` IS the entity's resource type; here `type` is the concept
+ * *category* — `resource-type`, `lint-rule`, `post-synth-check` — and the
+ * resource type string rides in `resource_type`. A consumer tells the two
+ * bundle kinds apart by exactly that.
+ *
+ * Cross-links run both directions: a resource concept lists the rules that
+ * govern it under "Governed by", a rule concept lists the types it applies to
+ * under "Applies to". The association is derived from the rule's source text
+ * (rules match on identifiers, not declared type lists), so it is a textual
+ * over-approximation — acceptable for knowledge, wrong for enforcement.
+ */
+import * as ts from "typescript";
+import { frontmatter, slug, OKF_VERSION } from "../okf.js";
+/** Collapse whitespace so a description fits a frontmatter scalar or a list line. */
+function oneLine(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+function truncate(text, max) {
+    return text.length <= max ? text : `${text.slice(0, max - 3).trimEnd()}...`;
+}
+/**
+ * Per-class constructor property docs, parsed out of the generated
+ * declarations. This is where CloudFormation- and OpenAPI-derived lexicons
+ * carry their spec-sourced property descriptions (the registry carries them
+ * only for hand-authored lexicons like docker).
+ */
+function parseDtsProperties(typesDTS) {
+    const out = new Map();
+    if (!typesDTS.includes("constructor"))
+        return out;
+    const sf = ts.createSourceFile("types.d.ts", typesDTS, ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
+    for (const stmt of sf.statements) {
+        if (!ts.isClassDeclaration(stmt) || !stmt.name)
+            continue;
+        const ctor = stmt.members.find(ts.isConstructorDeclaration);
+        const param = ctor?.parameters[0];
+        if (!param?.type || !ts.isTypeLiteralNode(param.type))
+            continue;
+        const props = [];
+        for (const member of param.type.members) {
+            if (!ts.isPropertySignature(member) || !member.name)
+                continue;
+            const name = ts.isIdentifier(member.name) || ts.isStringLiteral(member.name)
+                ? member.name.text
+                : member.name.getText(sf);
+            const raw = member.jsDoc?.[0]?.comment;
+            const doc = typeof raw === "string" ? raw : raw ? ts.getTextOfJSDocComment(raw) : undefined;
+            props.push({
+                name,
+                type: member.type?.getText(sf),
+                required: member.questionToken === undefined,
+                // Undo the `*\/` escaping generate-typescript applies inside JSDoc.
+                description: doc?.replace(/\*\\\//g, "*/"),
+            });
+        }
+        if (props.length > 0)
+            out.set(stmt.name.text, props);
+    }
+    return out;
+}
+/**
+ * The resource types a rule's source mentions — by class name as a whole
+ * word, or by the resource type string anywhere.
+ */
+function ruleAppliesTo(source, concepts) {
+    const words = new Set(source.match(/[A-Za-z0-9_$]+/g) ?? []);
+    return concepts.filter((c) => words.has(c.className) || source.includes(c.resourceType));
+}
+function propertyLine(prop) {
+    const facts = [];
+    if (prop.type)
+        facts.push(`\`${oneLine(prop.type)}\``);
+    if (prop.required === true)
+        facts.push("required");
+    if (prop.required === false)
+        facts.push("optional");
+    const head = facts.length > 0 ? `- \`${prop.name}\` (${facts.join(", ")})` : `- \`${prop.name}\``;
+    return prop.description ? `${head}: ${oneLine(prop.description)}` : head;
+}
+/**
+ * Build the OKF bundle for a packaged lexicon. Pure and deterministic: the
+ * same registry, declarations, and rules yield byte-identical files.
+ */
+export function buildLexiconOkfBundle(input) {
+    let registry;
+    try {
+        registry = JSON.parse(input.registry);
+    }
+    catch {
+        registry = {};
+    }
+    const dtsProps = parseDtsProperties(input.typesDTS);
+    // One concept per resource type: alias entries share a resourceType, the
+    // first class name in sorted order names the concept.
+    const byType = new Map();
+    for (const className of Object.keys(registry).sort((a, b) => a.localeCompare(b))) {
+        const entry = registry[className];
+        if (entry?.kind !== "resource" || typeof entry.resourceType !== "string")
+            continue;
+        if (!byType.has(entry.resourceType))
+            byType.set(entry.resourceType, { className, entry });
+    }
+    const concepts = [];
+    const takenPaths = new Set();
+    for (const { className, entry } of [...byType.values()].sort((a, b) => a.className.localeCompare(b.className))) {
+        const base = `types/${slug(className)}`;
+        let path = `${base}.md`;
+        for (let n = 2; takenPaths.has(path); n++)
+            path = `${base}-${n}.md`;
+        takenPaths.add(path);
+        // Registry-carried property docs (hand-authored lexicons) win; the
+        // generated declarations fill in for spec-derived lexicons.
+        let properties;
+        if (entry.properties && Object.keys(entry.properties).length > 0) {
+            properties = Object.entries(entry.properties).map(([name, p]) => ({
+                name,
+                type: p.type,
+                description: p.description,
+            }));
+        }
+        else {
+            properties = dtsProps.get(className) ?? [];
+        }
+        concepts.push({
+            className,
+            resourceType: entry.resourceType,
+            description: typeof entry.description === "string" ? entry.description : undefined,
+            properties,
+            attributes: entry.attrs ? Object.values(entry.attrs).sort((a, b) => a.localeCompare(b)) : [],
+            path,
+        });
+    }
+    // One concept per rule id, first scan wins.
+    const rulesById = new Map();
+    for (const rule of input.rules) {
+        if (!rulesById.has(rule.meta.id))
+            rulesById.set(rule.meta.id, rule);
+    }
+    const rules = [...rulesById.values()].sort((a, b) => a.meta.id.localeCompare(b.meta.id));
+    const rulePath = (id) => `rules/${slug(id)}.md`;
+    // Association, both directions.
+    const governedBy = new Map();
+    const appliesTo = new Map();
+    for (const rule of rules) {
+        const targets = ruleAppliesTo(rule.source, concepts);
+        appliesTo.set(rule.meta.id, targets);
+        for (const target of targets) {
+            if (!governedBy.has(target.resourceType))
+                governedBy.set(target.resourceType, []);
+            governedBy.get(target.resourceType).push(rule);
+        }
+    }
+    const docsUrl = `https://intentius.io/chant/lexicons/${input.name}/rules/`;
+    const files = [];
+    for (const concept of concepts) {
+        const head = frontmatter({
+            type: "resource-type",
+            title: concept.className,
+            description: truncate(oneLine(concept.description ?? `${input.name} resource type ${concept.resourceType}`), 200),
+            name: concept.className,
+            lexicon: input.name,
+            resource_type: concept.resourceType,
+        });
+        const body = [""];
+        body.push(concept.description
+            ? oneLine(concept.description)
+            : `\`${concept.resourceType}\`, a resource type of the ${input.name} lexicon.`);
+        if (concept.properties.length > 0) {
+            body.push("", "## Properties", "");
+            for (const prop of concept.properties)
+                body.push(propertyLine(prop));
+        }
+        if (concept.attributes.length > 0) {
+            body.push("", "## Attributes", "");
+            for (const attr of concept.attributes)
+                body.push(`- \`${attr}\``);
+        }
+        const governing = governedBy.get(concept.resourceType) ?? [];
+        if (governing.length > 0) {
+            body.push("", "## Governed by", "");
+            for (const rule of governing) {
+                body.push(`- [${rule.meta.id}](/${rulePath(rule.meta.id)}): ${oneLine(rule.meta.description)}`);
+            }
+        }
+        body.push("");
+        files.push({ path: concept.path, content: head + body.join("\n") });
+    }
+    for (const rule of rules) {
+        const head = frontmatter({
+            type: rule.meta.type === "post-synth" ? "post-synth-check" : "lint-rule",
+            title: rule.meta.id,
+            description: truncate(oneLine(rule.meta.description), 200),
+            id: rule.meta.id,
+            severity: rule.meta.severity,
+            category: rule.meta.category,
+            lexicon: input.name,
+            docs: docsUrl,
+        });
+        const body = ["", oneLine(rule.meta.description)];
+        const targets = appliesTo.get(rule.meta.id) ?? [];
+        if (targets.length > 0) {
+            body.push("", "## Applies to", "");
+            for (const target of targets) {
+                body.push(`- [${target.className}](/${target.path})`);
+            }
+        }
+        body.push("");
+        files.push({ path: rulePath(rule.meta.id), content: head + body.join("\n") });
+    }
+    files.push({ path: "index.md", content: buildIndex(input.name, concepts, rules, rulePath) });
+    files.sort((a, b) => a.path.localeCompare(b.path));
+    return files;
+}
+/**
+ * The bundle-root `index.md`: resource types and rules as sections of linked
+ * entries, `okf_version` its only frontmatter (spec §12).
+ */
+function buildIndex(name, concepts, rules, rulePath) {
+    const lines = ["---", `okf_version: '${OKF_VERSION}'`, "---", ""];
+    if (concepts.length > 0) {
+        lines.push("# Resource types", "");
+        for (const concept of concepts) {
+            lines.push(`* [${concept.className}](/${concept.path}) - ${concept.resourceType}`);
+        }
+        lines.push("");
+    }
+    if (rules.length > 0) {
+        lines.push("# Rules", "");
+        for (const rule of rules) {
+            lines.push(`* [${rule.meta.id}](/${rulePath(rule.meta.id)}) - ${truncate(oneLine(rule.meta.description), 160)}`);
+        }
+        lines.push("");
+    }
+    if (concepts.length === 0 && rules.length === 0) {
+        lines.push(`The ${name} lexicon declares no resource types or rules.`, "");
+    }
+    return lines.join("\n");
+}

package/dist/codegen/package.js

@@ -0,0 +1,150 @@
+/**
+ * Generic lexicon packaging pipeline.
+ *
+ * Orchestrates: generate → manifest → collect rules → collect skills →
+ * assemble BundleSpec → compute integrity → attach metadata.
+ */
+import { readFileSync, readdirSync, writeFileSync, mkdirSync, rmSync } from "fs";
+import { dirname, join } from "path";
+import { computeIntegrity } from "../lexicon-integrity.js";
+import { scanRulesWithSources } from "./docs-rule-scanning.js";
+import { buildLexiconOkfBundle } from "./okf-lexicon.js";
+// ── Pipeline ───────────────────────────────────────────────────────
+/**
+ * Run the packaging pipeline with the supplied config.
+ */
+export async function packagePipeline(config, opts = {}) {
+    const log = opts.verbose
+        ? (msg) => console.error(msg)
+        : (_msg) => { };
+    // Step 1: Run the generation pipeline
+    log("Running generation pipeline...");
+    const result = await config.generate({ verbose: opts.verbose, force: opts.force });
+    // Step 2: Build manifest
+    log("Building manifest...");
+    const manifest = config.buildManifest(result);
+    // Step 3: Collect rules
+    log("Collecting rules...");
+    const rules = collectRules(config.srcDir, config.ruleDirs);
+    // Step 4: Collect skills
+    log("Collecting skills...");
+    const skills = config.collectSkills();
+    // Step 5: Assemble BundleSpec, with the OKF knowledge bundle over the same
+    // artifacts (#1060) — derived here so it cannot drift from the registry and
+    // rules it describes.
+    log("Building OKF knowledge bundle...");
+    const okf = buildLexiconOkfBundle({
+        name: manifest.name,
+        registry: result.lexiconJSON,
+        typesDTS: result.typesDTS,
+        rules: scanRulesWithSources(config.srcDir),
+    });
+    const spec = {
+        manifest,
+        registry: result.lexiconJSON,
+        typesDTS: result.typesDTS,
+        rules,
+        skills,
+        okf,
+    };
+    // Step 6: Compute integrity
+    log("Computing integrity...");
+    spec.integrity = computeIntegrity(spec);
+    // Step 7: Populate metadata
+    spec.metadata = {
+        generatedAt: new Date().toISOString(),
+        chantVersion: "0.1.0",
+        generatorVersion: config.version ?? "0.0.0",
+        sourceSchemaCount: result.resources,
+    };
+    log(`Package assembled: ${rules.size} rules, ${skills.size} skills`);
+    return {
+        spec,
+        stats: {
+            resources: result.resources,
+            properties: result.properties,
+            enums: result.enums,
+            ruleCount: rules.size,
+            skillCount: skills.size,
+        },
+    };
+}
+// ── Utilities ──────────────────────────────────────────────────────
+/**
+ * Collect lint rule source files from a lexicon package.
+ * Auto-discovers .ts files in the specified directories,
+ * skipping test files, re-export files (index.ts), and non-.ts files.
+ */
+export function collectRules(srcDir, dirs = ["lint/rules", "lint/post-synth"]) {
+    const rules = new Map();
+    for (const dir of dirs) {
+        const fullDir = join(srcDir, dir);
+        let entries;
+        try {
+            entries = readdirSync(fullDir);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.endsWith(".ts"))
+                continue;
+            if (entry.endsWith(".test.ts"))
+                continue;
+            if (entry === "index.ts")
+                continue;
+            try {
+                const content = readFileSync(join(fullDir, entry), "utf-8");
+                rules.set(entry, content);
+            }
+            catch {
+                // Skip unreadable files
+            }
+        }
+    }
+    return rules;
+}
+/**
+ * Write a BundleSpec to the given dist directory.
+ *
+ * Creates the directory structure and writes all artifacts:
+ * manifest.json, meta.json, types/index.d.ts, rules/*, skills/*, okf/*,
+ * integrity.json.
+ */
+export function writeBundleSpec(spec, distDir) {
+    mkdirSync(join(distDir, "types"), { recursive: true });
+    mkdirSync(join(distDir, "rules"), { recursive: true });
+    mkdirSync(join(distDir, "skills"), { recursive: true });
+    writeFileSync(join(distDir, "manifest.json"), JSON.stringify(spec.manifest, null, 2));
+    writeFileSync(join(distDir, "meta.json"), spec.registry);
+    writeFileSync(join(distDir, "types", "index.d.ts"), spec.typesDTS);
+    for (const [name, content] of spec.rules) {
+        writeFileSync(join(distDir, "rules", name), content);
+    }
+    for (const [name, content] of spec.skills) {
+        writeFileSync(join(distDir, "skills", name), content);
+    }
+    if (spec.okf) {
+        // Replace rather than merge — a concept whose resource type was removed
+        // upstream must not survive as a stale file.
+        rmSync(join(distDir, "okf"), { recursive: true, force: true });
+        for (const file of spec.okf) {
+            const target = join(distDir, "okf", file.path);
+            mkdirSync(dirname(target), { recursive: true });
+            writeFileSync(target, file.content);
+        }
+    }
+    if (spec.integrity) {
+        writeFileSync(join(distDir, "integrity.json"), JSON.stringify(spec.integrity, null, 2));
+    }
+}
+/**
+ * Collect skills from a plugin's skill definitions.
+ */
+export function collectSkills(skillDefs) {
+    const skills = new Map();
+    for (const s of skillDefs) {
+        skills.set(`${s.name}.md`, s.content);
+    }
+    return skills;
+}

package/dist/codegen/pinned-upgrade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pinned-upgrade.d.ts","sourceRoot":"","sources":["../../src/codegen/pinned-upgrade.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"pinned-upgrade.d.ts","sourceRoot":"","sources":["../../src/codegen/pinned-upgrade.ts"],"names":[],"mappings":"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"}