@ferrule-io/ok-fine 0.0.0-stage → 0.3.7

package/dist/okf/concept.js

@@ -0,0 +1,99 @@
+import { parseFrontmatter, splitFrontmatter } from "./frontmatter.js";
+import { extractLinks } from "./markdown.js";
+import { blobRevision } from "./paths.js";
+import { displayTitle, effectiveStatus, generatedAt, generatedBy, lastVerifiedAt, staleAfter, trustTier, } from "./semantics.js";
+export function parseConcept(project, id, file, buf) {
+    const text = buf.toString("utf8");
+    const revision = blobRevision(buf);
+    const split = splitFrontmatter(text);
+    if (!split) {
+        return {
+            project,
+            id,
+            file,
+            revision,
+            frontmatter: null,
+            body: text,
+            parseError: "missing_frontmatter",
+            title: displayTitle(null, id),
+            description: null,
+            type: null,
+            tags: [],
+            status: "stable",
+            trustTier: "unverified",
+            staleAfter: null,
+            generatedAt: null,
+            generatedBy: null,
+            lastVerifiedAt: null,
+            outbound: [],
+        };
+    }
+    const parsed = parseFrontmatter(split.yaml);
+    if ("error" in parsed) {
+        return {
+            project,
+            id,
+            file,
+            revision,
+            frontmatter: null,
+            body: split.body,
+            parseError: parsed.error,
+            title: displayTitle(null, id),
+            description: null,
+            type: null,
+            tags: [],
+            status: "stable",
+            trustTier: "unverified",
+            staleAfter: null,
+            generatedAt: null,
+            generatedBy: null,
+            lastVerifiedAt: null,
+            outbound: [],
+        };
+    }
+    const { data } = parsed;
+    if (typeof data.type !== "string" || data.type.trim().length === 0) {
+        return {
+            project,
+            id,
+            file,
+            revision,
+            frontmatter: null,
+            body: split.body,
+            parseError: "missing_type",
+            title: displayTitle(data, id),
+            description: typeof data.description === "string" ? data.description : null,
+            type: null,
+            tags: [],
+            status: effectiveStatus(data),
+            trustTier: trustTier(data),
+            staleAfter: staleAfter(data),
+            generatedAt: generatedAt(data),
+            generatedBy: generatedBy(data),
+            lastVerifiedAt: lastVerifiedAt(data),
+            outbound: extractLinks(split.body, id),
+        };
+    }
+    const tags = Array.isArray(data.tags) ? data.tags.filter((t) => typeof t === "string") : [];
+    return {
+        project,
+        id,
+        file,
+        revision,
+        frontmatter: data,
+        body: split.body,
+        parseError: null,
+        title: displayTitle(data, id),
+        description: typeof data.description === "string" ? data.description : null,
+        type: data.type,
+        tags,
+        status: effectiveStatus(data),
+        trustTier: trustTier(data),
+        staleAfter: staleAfter(data),
+        generatedAt: generatedAt(data),
+        generatedBy: generatedBy(data),
+        lastVerifiedAt: lastVerifiedAt(data),
+        outbound: extractLinks(split.body, id),
+    };
+}
+//# sourceMappingURL=concept.js.map

package/dist/okf/frontmatter.js

@@ -0,0 +1,180 @@
+import { isDeepStrictEqual } from "node:util";
+import { Document, isMap, parseDocument } from "yaml";
+export function splitFrontmatter(text) {
+    if (text.charCodeAt(0) === 0xfeff) {
+        text = text.slice(1);
+    }
+    const match = /^---\r?\n/.exec(text);
+    if (!match) {
+        return null;
+    }
+    const yamlStart = match[0].length;
+    const closingRegex = /\r?\n---\r?\n|\r?\n---$/g;
+    closingRegex.lastIndex = yamlStart;
+    const closeMatch = closingRegex.exec(text);
+    if (!closeMatch) {
+        return null;
+    }
+    const yamlEnd = closeMatch.index;
+    const bodyStart = closeMatch.index + closeMatch[0].length;
+    const yaml = text.slice(yamlStart, yamlEnd);
+    let body = text.slice(bodyStart);
+    body = body.replace(/^(\r?\n)+/, "");
+    return { yaml, body };
+}
+export function parseFrontmatter(yaml) {
+    const doc = parseDocument(yaml);
+    if (doc.errors.length > 0) {
+        return {
+            error: "invalid_yaml",
+            message: doc.errors.map((e) => e.message).join("; "),
+        };
+    }
+    if (!doc.contents || !isMap(doc.contents)) {
+        return {
+            error: "frontmatter_not_mapping",
+            message: "frontmatter must be a YAML mapping",
+        };
+    }
+    const data = (doc.toJS() ?? {});
+    return { doc, data };
+}
+export function serializeConcept(doc, body) {
+    const normalizedBody = body.replace(/\r\n/g, "\n").replace(/^\n+/, "").replace(/\s*$/, "");
+    return `---\n${doc.toString({ lineWidth: 0 })}---\n\n${normalizedBody}\n`;
+}
+function createFormattedNode(doc, key, val) {
+    if (key === "tags" && Array.isArray(val)) {
+        return doc.createNode(val, { flow: true });
+    }
+    if (key === "usage_window" && val && typeof val === "object" && !Array.isArray(val)) {
+        return doc.createNode(val, { flow: true });
+    }
+    if (key === "parameters" && Array.isArray(val)) {
+        return doc.createNode(val.map((item) => item && typeof item === "object" && !Array.isArray(item) ? doc.createNode(item, { flow: true }) : item));
+    }
+    if (key === "generated" && val && typeof val === "object") {
+        return doc.createNode(val, { flow: true });
+    }
+    return val;
+}
+export function applyFrontmatter(existing, input, server) {
+    const ignoredKeys = [];
+    if (existing !== null) {
+        const existingJs = (existing.toJS() ?? {});
+        if ("generated" in input && !isDeepStrictEqual(input.generated, existingJs.generated)) {
+            ignoredKeys.push("generated");
+        }
+        if ("verified" in input && !isDeepStrictEqual(input.verified, existingJs.verified)) {
+            ignoredKeys.push("verified");
+        }
+        const cleanInput = {};
+        for (const [k, v] of Object.entries(input)) {
+            if (k !== "generated" && k !== "verified") {
+                cleanInput[k] = v;
+            }
+        }
+        const keysToDelete = [];
+        if (isMap(existing.contents)) {
+            for (const item of existing.contents.items) {
+                if (!item || typeof item !== "object" || !("key" in item) || item.key == null) {
+                    continue;
+                }
+                let keyName = "";
+                const rawKey = item.key;
+                if (typeof rawKey === "string") {
+                    keyName = rawKey;
+                }
+                else if (typeof rawKey === "object" && "value" in rawKey && typeof rawKey.value === "string") {
+                    keyName = rawKey.value;
+                }
+                else {
+                    keyName = String(rawKey);
+                }
+                if (keyName && keyName !== "generated" && keyName !== "verified" && !(keyName in cleanInput)) {
+                    keysToDelete.push(keyName);
+                }
+            }
+        }
+        for (const k of keysToDelete) {
+            existing.delete(k);
+        }
+        for (const [k, v] of Object.entries(cleanInput)) {
+            if (existing.has(k)) {
+                if (!isDeepStrictEqual(existingJs[k], v)) {
+                    existing.set(k, createFormattedNode(existing, k, v));
+                }
+            }
+            else {
+                existing.set(k, createFormattedNode(existing, k, v));
+            }
+        }
+        existing.set("generated", existing.createNode(server.generated, { flow: true }));
+        return { doc: existing, ignoredKeys };
+    }
+    else {
+        if ("generated" in input) {
+            ignoredKeys.push("generated");
+        }
+        if ("verified" in input) {
+            ignoredKeys.push("verified");
+        }
+        const cleanInput = {};
+        for (const [k, v] of Object.entries(input)) {
+            if (k !== "generated" && k !== "verified") {
+                cleanInput[k] = v;
+            }
+        }
+        const doc = new Document();
+        const firstKeys = ["type", "title", "description", "resource", "tags", "status"];
+        const endKeys = ["stale_after", "sources", "usage_window"];
+        for (const k of firstKeys) {
+            if (k in cleanInput) {
+                doc.set(k, createFormattedNode(doc, k, cleanInput[k]));
+            }
+        }
+        for (const [k, v] of Object.entries(cleanInput)) {
+            if (!firstKeys.includes(k) && !endKeys.includes(k)) {
+                doc.set(k, createFormattedNode(doc, k, v));
+            }
+        }
+        doc.set("generated", doc.createNode(server.generated, { flow: true }));
+        for (const k of endKeys) {
+            if (k in cleanInput) {
+                doc.set(k, createFormattedNode(doc, k, cleanInput[k]));
+            }
+        }
+        return { doc, ignoredKeys };
+    }
+}
+export function appendVerification(doc, entry) {
+    const js = (doc.toJS() ?? {});
+    const raw = js.verified;
+    let list = [];
+    if (raw && typeof raw === "object") {
+        if (Array.isArray(raw)) {
+            list = raw.filter((item) => Boolean(item && typeof item === "object" && typeof item.by === "string" && item.by.length > 0));
+        }
+        else {
+            if ("by" in raw && typeof raw.by === "string" && raw.by.length > 0) {
+                const atVal = "at" in raw && typeof raw.at === "string" ? raw.at : undefined;
+                list = [{ by: raw.by, at: atVal }];
+            }
+        }
+    }
+    list.push(entry);
+    if (list.length === 1) {
+        doc.set("verified", doc.createNode(list[0], { flow: true }));
+    }
+    else {
+        doc.set("verified", doc.createNode(list.map((e) => doc.createNode(e, { flow: true }))));
+    }
+}
+export function nowIso() {
+    return new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+export function isoAfterDays(now, days) {
+    const d = new Date(now.getTime() + days * 86_400_000);
+    return d.toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+//# sourceMappingURL=frontmatter.js.map

package/dist/okf/index-file.js

@@ -0,0 +1,74 @@
+export function renderIndex(listing) {
+    const sections = [];
+    // Group concepts by type
+    const byType = new Map();
+    for (const c of listing.concepts) {
+        const typeKey = c.type && c.type.length > 0 ? c.type : "Other";
+        let list = byType.get(typeKey);
+        if (!list) {
+            list = [];
+            byType.set(typeKey, list);
+        }
+        list.push({ file: c.file, title: c.title, description: c.description });
+    }
+    const sortedTypes = Array.from(byType).sort(([a], [b]) => a.localeCompare(b, "en"));
+    for (const [type, items] of sortedTypes) {
+        items.sort((a, b) => {
+            const titleCmp = a.title.toLowerCase().localeCompare(b.title.toLowerCase(), "en");
+            if (titleCmp !== 0) {
+                return titleCmp;
+            }
+            return a.file.localeCompare(b.file, "en");
+        });
+        const lines = [`# ${type}`];
+        for (const item of items) {
+            const uri = encodeURI(item.file);
+            if (item.description != null) {
+                const collapsedDesc = item.description.replace(/\s+/g, " ").trim();
+                lines.push(`* [${item.title}](${uri}) - ${collapsedDesc}`);
+            }
+            else {
+                lines.push(`* [${item.title}](${uri})`);
+            }
+        }
+        sections.push(lines.join("\n"));
+    }
+    // Non-markdown files
+    if (listing.files.length > 0) {
+        const sortedFiles = listing.files.slice().sort((a, b) => a.localeCompare(b, "en"));
+        const lines = ["# Files"];
+        for (const f of sortedFiles) {
+            lines.push(`* [${f}](${encodeURI(f)})`);
+        }
+        sections.push(lines.join("\n"));
+    }
+    // Directories
+    if (listing.dirs.length > 0) {
+        const sortedDirs = listing.dirs.slice().sort((a, b) => a.name.localeCompare(b.name, "en"));
+        const lines = ["# Directories"];
+        for (const d of sortedDirs) {
+            const uri = `${encodeURI(d.name)}/`;
+            let countText;
+            if (d.conceptCount > 0) {
+                countText = d.conceptCount === 1 ? "1 concept" : `${d.conceptCount} concepts`;
+            }
+            else {
+                countText = d.fileCount === 1 ? "1 file" : `${d.fileCount} files`;
+            }
+            lines.push(`* [${d.name}](${uri}) - ${countText}`);
+        }
+        sections.push(lines.join("\n"));
+    }
+    let body;
+    if (sections.length === 0) {
+        body = "# Concepts\n";
+    }
+    else {
+        body = `${sections.join("\n\n")}\n`;
+    }
+    if (listing.isRoot) {
+        return `---\nokf_version: "0.2"\n---\n\n${body}`;
+    }
+    return body;
+}
+//# sourceMappingURL=index-file.js.map