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

package/dist/main.js

@@ -0,0 +1,32 @@
+import { loadConfig } from "./config.js";
+import { startServer } from "./server.js";
+let config;
+try {
+    config = loadConfig();
+}
+catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+}
+let server;
+try {
+    server = await startServer(config);
+}
+catch (err) {
+    console.error("ok-fine failed to start:", err);
+    process.exit(1);
+}
+let shuttingDown = false;
+for (const signal of ["SIGTERM", "SIGINT"]) {
+    process.on(signal, () => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        server.app.log.info({ signal }, "shutting down");
+        server.close().then(() => process.exit(0), (err) => {
+            server.app.log.error({ err }, "shutdown failed");
+            process.exit(1);
+        });
+    });
+}
+//# sourceMappingURL=main.js.map

package/dist/mcp/server.js

@@ -0,0 +1,202 @@
+import { McpServer } from "@modelcontextprotocol/server";
+import { z } from "zod";
+import { OkfError } from "../errors.js";
+import { FEEDBACK_TYPES, feedbackLink } from "../service/feedback.js";
+import { VERSION } from "../version.js";
+export const INSTRUCTIONS = `ok-fine holds shared project knowledge outside the codebase, as OKF v0.2 markdown concepts grouped into projects. In a git repository, first run \`git remote get-url origin\` and call list_projects with that URL as \`repository\`; use the returned project(s) for every read and write. If none match, say the repository is not onboarded and offer to onboard it (ok-fine-onboard skill). Search before non-trivial work; record durable decisions, conventions, and runbooks afterwards.
+1. Discover: get_index (progressive disclosure) or search_concepts with \`project\`.
+2. Read: read_concept returns frontmatter, body, trust tier (unverified | machine-confirmed | human-reviewed), staleness, and links. Freshness comes first: a concept that is stale, or whose code sources changed since \`sources[].commit\`, is a lead to re-check whatever its tier; among fresh concepts prefer higher trust tiers. Deprecated concepts are history; when code contradicts a concept, trust the code and update the concept.
+3. Write: write_concept with frontmatter containing \`type\` (e.g. Decision, Convention, Architecture, Component, Playbook, Interface, Reference) plus \`title\`, \`description\`, \`tags\`, and \`stale_after\` (ISO 8601, e.g. 180 days ahead). Record provenance in \`sources\` (each with \`resource\` and a stable \`id\`; code sources carry \`commit\`) and cite claims with footnotes [^id]. Link concepts with bundle-absolute links such as [orders](/tables/orders.md). After re-checking a concept against the code, refresh \`sources[].commit\` and \`stale_after\` with write_concept, then call verify_concept.
+4. Pass \`actor\` as <harness>/<model> (e.g. claude-code/claude-opus-4-5, codex/gpt-5-codex, gemini-cli/gemini-2.5-pro). Use human:<email>, with the email from \`git config user.email\`, only when the user personally reviewed the concept; on forbidden_actor, report both identities instead of retrying as another. The server stamps \`generated\`; \`verified\` changes only through verify_concept.
+5. When updating, pass expectedRevision from read_concept (null to create only).
+6. Prefer \`status: deprecated\` over delete_concept. index.md and log.md are maintained by the server; do not write them. A project is bound to repositories through the \`repositories\` list in its overview frontmatter.
+7. If ok-fine itself misbehaves or lacks something you need, call submit_feedback and show the user the returned url; nothing is filed until they submit the prefilled GitHub issue.`;
+const project = z.string().describe("Project (bundle) name, e.g. payments-api");
+const id = z.string().describe("Concept ID = bundle-relative path without .md, e.g. tables/orders");
+const actor = z
+    .string()
+    .describe("Who is writing, per the OKF actor convention: <producer>/<version> for agents (e.g. claude-code/claude-opus-4-5), human:<email> (the user's `git config user.email`, matching their token identity) only for personal review, or process:<id>");
+const expectedRevision = z
+    .string()
+    .nullable()
+    .optional()
+    .describe("Revision from read_concept; null = must not exist yet; omit to overwrite unconditionally");
+const expectedExisting = z.string().optional().describe("Revision from read_concept; omit to act unconditionally");
+const limit = z.number().int().min(1).max(100).optional();
+function fail(code, message, details) {
+    return {
+        isError: true,
+        content: [{ type: "text", text: `${code}: ${message}` }],
+        structuredContent: { error: { code, message, details } },
+    };
+}
+export function createMcpServer(service, principal, log) {
+    const server = new McpServer({ name: "ok-fine", version: VERSION }, { instructions: INSTRUCTIONS });
+    const run = async (name, fn) => {
+        try {
+            const result = await fn();
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                structuredContent: result,
+            };
+        }
+        catch (err) {
+            if (err instanceof OkfError)
+                return fail(err.code, err.message, err.details);
+            log.error({ err, tool: name }, "tool failed");
+            return fail("internal", "internal error");
+        }
+    };
+    const tool = (name, need, config, fn) => {
+        const permitted = need === "admin" ? principal.canAdmin : need === "write" ? principal.canWrite : principal.canRead;
+        if (!permitted)
+            return;
+        // Widen to the concrete ZodObject so the SDK's overload resolves; the SDK has already validated `args`
+        // against this schema, so the cast only restores the inferred type.
+        const inputSchema = config.inputSchema;
+        server.registerTool(name, { ...config, inputSchema }, async (args) => run(name, () => fn(args)));
+    };
+    const readOnly = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+    tool("list_projects", "read", {
+        title: "List projects",
+        description: "List projects (OKF bundles) with concept and staleness counts and the git repositories bound to each; pass repository to find the projects that hold a codebase's knowledge.",
+        inputSchema: z.object({
+            repository: z
+                .string()
+                .optional()
+                .describe("Git remote URL of the current repository, e.g. the output of `git remote get-url origin`; returns only the projects bound to it"),
+        }),
+        annotations: readOnly,
+    }, (a) => service.listProjects({ repository: a.repository }));
+    tool("get_index", "read", {
+        title: "Get directory index",
+        description: "Progressive-disclosure listing of one bundle directory: its concepts grouped by type, files, and subdirectories.",
+        inputSchema: z.object({ project, path: z.string().optional().describe("directory, default bundle root") }),
+        annotations: readOnly,
+    }, (a) => service.getIndex(a.project, a.path ?? ""));
+    tool("read_concept", "read", {
+        title: "Read concept",
+        description: "Read one concept with frontmatter, body, derived trust/staleness, links, and lint issues; returns `revision` to pass back as expectedRevision when updating.",
+        inputSchema: z.object({ project, id }),
+        annotations: readOnly,
+    }, (a) => service.readConcept(a.project, a.id));
+    tool("search_concepts", "read", {
+        title: "Search concepts",
+        description: "Keyword full-text search over concepts, optionally filtered by project, type, tags, status, trust tier, and staleness.",
+        inputSchema: z.object({
+            query: z.string().optional(),
+            project: z.string().optional(),
+            type: z.string().optional(),
+            tags: z.array(z.string()).optional(),
+            status: z.enum(["draft", "stable", "deprecated"]).optional().describe("omitted hides deprecated"),
+            trustTier: z.enum(["unverified", "machine-confirmed", "human-reviewed"]).optional(),
+            stale: z.boolean().optional(),
+            limit,
+        }),
+        annotations: readOnly,
+    }, (a) => service.search(a));
+    tool("get_history", "read", {
+        title: "Get history",
+        description: "List git commits that changed a concept, or the whole project when id is omitted.",
+        inputSchema: z.object({ project, id: id.optional(), limit }),
+        annotations: readOnly,
+    }, (a) => service.history(a.project, a.id, a.limit));
+    tool("read_file", "read", {
+        title: "Read file",
+        description: "Read any text file in a bundle verbatim (including index.md, log.md, and non-markdown assets).",
+        inputSchema: z.object({ project, path: z.string().describe("bundle-relative file path") }),
+        annotations: readOnly,
+    }, (a) => service.readFile(a.project, a.path));
+    tool("lint_project", "read", {
+        title: "Lint project",
+        description: "Check a bundle for OKF v0.2 conformance and return errors, warnings, and info issues.",
+        inputSchema: z.object({ project }),
+        annotations: readOnly,
+    }, (a) => service.lint(a.project));
+    tool("submit_feedback", "read", {
+        title: "Submit feedback",
+        description: "Draft feedback about ok-fine itself (a bug, a confusing or missing tool, wrong results, or a feature gap) as a prefilled public GitHub issue on ferrule-io/ok-fine. This call files nothing: show the returned url to the user, who opens it, reviews it, and submits it with their own GitHub account. The issue is public: never include concept content, project names, repository URLs, credentials, or personal data. Not for problems in project knowledge; fix those with write_concept.",
+        inputSchema: z.object({
+            type: z.enum(FEEDBACK_TYPES).describe("bug | feature | general"),
+            title: z.string().min(5).max(160).describe("Short summary of the problem or request"),
+            body: z.string().min(20).max(6000).describe("What happened or what is needed, in detail"),
+            tool: z.string().max(100).optional().describe("ok-fine tool involved, e.g. write_concept"),
+            expected: z.string().max(2000).optional().describe("Expected behavior"),
+            actual: z.string().max(2000).optional().describe("Actual behavior, including any error code returned"),
+            reproduction: z
+                .string()
+                .max(2000)
+                .optional()
+                .describe("Minimal steps a maintainer can replay, with no private data"),
+        }),
+        annotations: readOnly,
+    }, (a) => feedbackLink(a));
+    tool("create_project", "write", {
+        title: "Create project",
+        description: "Create a new project bundle with an overview concept, log.md, and index.md.",
+        inputSchema: z.object({ project, title: z.string(), description: z.string().optional(), actor }),
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    }, (a) => service.createProject(principal, a));
+    tool("write_concept", "write", {
+        title: "Write concept",
+        description: "Create or replace a concept's whole frontmatter and body; the server stamps `generated` and ignores `verified` (use verify_concept).",
+        inputSchema: z.object({
+            project,
+            id,
+            frontmatter: z.record(z.string(), z.unknown()).describe("YAML frontmatter as an object; `type` is required"),
+            body: z.string().describe("Markdown body"),
+            actor,
+            expectedRevision,
+            message: z.string().optional().describe("Optional note recorded in log.md and the commit"),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    }, (a) => service.writeConcept(principal, a));
+    tool("verify_concept", "write", {
+        title: "Verify concept",
+        description: "Append a verification by `actor` to a concept's `verified` list, raising its trust tier.",
+        inputSchema: z.object({ project, id, actor, expectedRevision: expectedExisting }),
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    }, (a) => service.verifyConcept(principal, a));
+    tool("delete_concept", "write", {
+        title: "Delete concept",
+        description: "Permanently remove a concept; prefer write_concept with `status: deprecated` to keep history visible.",
+        inputSchema: z.object({ project, id, actor, expectedRevision: expectedExisting }),
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+    }, (a) => service.deleteConcept(principal, a));
+    tool("write_file", "write", {
+        title: "Write file",
+        description: "Create or replace a non-markdown asset file in a bundle (e.g. references/attesters/x.py).",
+        inputSchema: z.object({
+            project,
+            path: z.string().describe("bundle-relative path; must not end with .md"),
+            content: z.string(),
+            actor,
+            expectedRevision,
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    }, (a) => service.writeFile(principal, a));
+    tool("delete_file", "write", {
+        title: "Delete file",
+        description: "Remove a non-markdown asset file from a bundle.",
+        inputSchema: z.object({ project, path: z.string(), actor, expectedRevision: expectedExisting }),
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+    }, (a) => service.deleteFile(principal, a));
+    tool("delete_project", "admin", {
+        title: "Delete project",
+        description: "Delete an entire project bundle; `confirm` must repeat the project name.",
+        inputSchema: z.object({ project, actor, confirm: z.string().describe("must equal project") }),
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+    }, (a) => {
+        if (a.confirm !== a.project)
+            throw new OkfError("bad_request", 400, "confirm must equal project");
+        return service.deleteProject(principal, { project: a.project, actor: a.actor });
+    });
+    tool("sync_now", "admin", {
+        title: "Sync now",
+        description: "Fetch, rebase onto, and push to the configured git remote immediately and return sync status.",
+        inputSchema: z.object({}),
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, () => service.syncNow());
+    return server;
+}
+//# sourceMappingURL=server.js.map

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