@tiramisu-docs/kit 0.1.0

package/dist/lib/open-links.d.ts

@@ -0,0 +1,22 @@
+export interface OpenLinkOptions {
+    baseUrl: string;
+    slug: string;
+    locale?: string;
+    github?: {
+        repo: string;
+        branch?: string;
+        dir?: string;
+    };
+    mcp?: boolean | string;
+    title?: string;
+}
+export interface OpenLink {
+    label: string;
+    href?: string;
+    copy?: string;
+    icon: "chatgpt" | "claude" | "cursor" | "github" | "mcp" | "vscode";
+    type: "open" | "edit" | "mcp";
+}
+export declare function getPageUrl(opts: OpenLinkOptions): string;
+export declare function getGitHubEditUrl(opts: OpenLinkOptions): string | null;
+export declare function getOpenLinks(opts: OpenLinkOptions): OpenLink[];

package/dist/lib/open-links.js

@@ -0,0 +1,33 @@
+export function getPageUrl(opts) {
+    const localePart = opts.locale ? `${opts.locale}/` : "";
+    const slug = opts.slug === "index" ? "" : opts.slug.replace(/\/index$/, "");
+    return `${opts.baseUrl}/docs/${localePart}${slug}`;
+}
+export function getGitHubEditUrl(opts) {
+    if (!opts.github)
+        return null;
+    const branch = opts.github.branch ?? "main";
+    const dir = opts.github.dir ?? "src/docs";
+    const localePart = opts.locale ? `${opts.locale}/` : "";
+    return `https://github.com/${opts.github.repo}/edit/${branch}/${dir}/${localePart}${opts.slug}.tiramisu`;
+}
+export function getOpenLinks(opts) {
+    const pageUrl = getPageUrl(opts);
+    const prompt = encodeURIComponent(`Read ${pageUrl} and answer questions about the content.`);
+    const cursorPrompt = encodeURIComponent(`Read ${pageUrl}, I want to ask questions about it.`);
+    const links = [
+        { label: "Open in ChatGPT", href: `https://chat.openai.com/?q=${prompt}`, icon: "chatgpt", type: "open" },
+        { label: "Open in Claude", href: `https://claude.ai/new?q=${prompt}`, icon: "claude", type: "open" },
+        { label: "Open in Cursor", href: `https://cursor.com/link/prompt?text=${cursorPrompt}`, icon: "cursor", type: "open" },
+    ];
+    if (opts.mcp) {
+        const mcpUrl = typeof opts.mcp === "string" ? opts.mcp : `${opts.baseUrl}/mcp`;
+        links.push({ label: "Connect with MCP", copy: mcpUrl, icon: "mcp", type: "mcp" });
+        const mcpMeta = JSON.stringify({ name: opts.title ?? "Documentation", url: mcpUrl });
+        links.push({ label: "Connect to VSCode", href: `vscode:mcp/install?${encodeURIComponent(mcpMeta)}`, icon: "vscode", type: "mcp" });
+    }
+    const ghUrl = getGitHubEditUrl(opts);
+    if (ghUrl)
+        links.push({ label: "Edit on GitHub", href: ghUrl, icon: "github", type: "edit" });
+    return links;
+}

package/dist/lib/routes/docs/[...slug]/+page.d.ts

@@ -0,0 +1,25 @@
+import type { ResolvedSection, SidebarGroup } from "../../../../types.js";
+export declare function load({ params }: {
+    params: {
+        slug?: string;
+    };
+}): Promise<{
+    component: any;
+    meta: import("@tiramisu-docs/core").DocMeta;
+    headings: import("@tiramisu-docs/core").Heading[];
+    lastEdited: string | undefined;
+    slug: string;
+    locale: string;
+    locales: string[];
+    sections: ResolvedSection[] | undefined;
+    activeSidebar: SidebarGroup[];
+    showFallbackBanner: boolean;
+} | {
+    component: typeof import("svelte").SvelteComponent;
+    meta: import("@tiramisu-docs/core").DocMeta;
+    headings: import("@tiramisu-docs/core").Heading[];
+    lastEdited: string | undefined;
+    slug: string;
+    sections: ResolvedSection[] | undefined;
+    activeSidebar: SidebarGroup[];
+}>;

package/dist/lib/routes/docs/[...slug]/+page.js

@@ -0,0 +1,109 @@
+import { error, redirect } from "@sveltejs/kit";
+export async function load({ params }) {
+    const rawSlug = params.slug || "index";
+    const mod = await import("virtual:tiramisu-docs");
+    // If i18n is enabled, parse locale from slug
+    if (mod.locales && mod.defaultLocale) {
+        const segments = rawSlug.split("/");
+        const possibleLocale = segments[0];
+        const localeData = mod.locales[possibleLocale];
+        if (localeData) {
+            const locale = possibleLocale;
+            const slug = segments.slice(1).join("/") || "index";
+            return loadDoc(localeData, slug, locale, mod);
+        }
+        else {
+            // No locale prefix — redirect to default locale
+            throw redirect(302, `/docs/${mod.defaultLocale}/${rawSlug}`);
+        }
+    }
+    // No i18n — legacy behavior
+    return loadLegacy(mod, rawSlug);
+}
+function loadLegacy(mod, slug) {
+    let importFn = mod.docImports[slug] ?? mod.docImports[slug + "/index"];
+    // Root /docs with no page — redirect to first section
+    if (!importFn && slug === "index" && mod.sections) {
+        const firstSection = mod.sections.find((s) => s.path);
+        if (firstSection)
+            throw redirect(302, `/docs/${firstSection.path}`);
+    }
+    if (!importFn)
+        throw error(404, "Page not found");
+    if (!mod.docImports[slug])
+        slug = slug + "/index";
+    return importFn().then((c) => {
+        const doc = mod.docs.find((d) => d.slug === slug);
+        let activeSidebar = mod.sidebar;
+        if (mod.sections) {
+            activeSidebar = findActiveSectionSidebar(mod.sections, slug) ?? mod.sidebar;
+        }
+        return {
+            component: c.default ?? c,
+            meta: doc?.meta ?? {},
+            headings: doc?.headings ?? [],
+            lastEdited: doc?.lastEdited,
+            slug,
+            sections: mod.sections ?? undefined,
+            activeSidebar,
+        };
+    });
+}
+async function loadDoc(localeData, slug, locale, mod) {
+    let importFn = localeData.docImports[slug] ?? localeData.docImports[slug + "/index"];
+    if (!localeData.docImports[slug] && localeData.docImports[slug + "/index"])
+        slug = slug + "/index";
+    let showFallbackBanner = false;
+    if (!importFn) {
+        const defaultData = mod.locales?.[mod.defaultLocale];
+        importFn = defaultData?.docImports[slug] ?? defaultData?.docImports[slug + "/index"];
+        if (!defaultData?.docImports[slug] && defaultData?.docImports[slug + "/index"])
+            slug = slug + "/index";
+        if (!importFn) {
+            // Root /docs/<locale> with no index page — redirect to first section
+            if (slug === "index" && localeData.sections) {
+                const firstSection = localeData.sections.find((s) => s.path);
+                if (firstSection)
+                    throw redirect(302, `/docs/${locale}/${firstSection.path}`);
+            }
+            throw error(404, "Page not found");
+        }
+        showFallbackBanner = true;
+    }
+    const component = await importFn();
+    const doc = localeData.docs.find((d) => d.slug === slug)
+        ?? mod.locales?.[mod.defaultLocale]?.docs.find((d) => d.slug === slug);
+    const sections = localeData.sections;
+    let activeSidebar = localeData.sidebar;
+    if (sections) {
+        activeSidebar = findActiveSectionSidebar(sections, slug) ?? localeData.sidebar;
+    }
+    return {
+        component: component.default ?? component,
+        meta: doc?.meta ?? {},
+        headings: doc?.headings ?? [],
+        lastEdited: doc?.lastEdited,
+        slug,
+        locale,
+        locales: Object.keys(mod.locales),
+        sections,
+        activeSidebar,
+        showFallbackBanner,
+    };
+}
+function findActiveSectionSidebar(sections, slug) {
+    for (const section of sections) {
+        if (section.path && (slug === section.path || slug.startsWith(section.path + "/"))) {
+            return section.sidebar ?? null;
+        }
+        if (section.children) {
+            const found = findActiveSectionSidebar(section.children, slug);
+            if (found)
+                return found;
+        }
+    }
+    if (sections.length > 0 && sections[0].sidebar && !sections[0].path) {
+        return sections[0].sidebar;
+    }
+    return null;
+}

package/dist/lib/utils.d.ts

@@ -0,0 +1,5 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;
+export type WithElementRef<T, El extends HTMLElement = HTMLElement> = T & {
+    ref?: El | null;
+};

package/dist/lib/utils.js

@@ -0,0 +1,5 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}

package/dist/mcp.d.ts

@@ -0,0 +1,24 @@
+import type { VirtualDoc, SearchIndexEntry, SidebarGroup } from "./types.js";
+export interface McpData {
+    docs: VirtualDoc[];
+    searchIndex: SearchIndexEntry[];
+    sidebar: SidebarGroup[];
+}
+interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id?: string | number;
+    method: string;
+    params?: Record<string, unknown>;
+}
+interface JsonRpcResponse {
+    jsonrpc: "2.0";
+    id?: string | number | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export declare function handleMcpRequest(body: JsonRpcRequest, data: McpData): JsonRpcResponse;
+export {};

package/dist/mcp.js

@@ -0,0 +1,155 @@
+const TOOL_DEFINITIONS = [
+    {
+        name: "search_docs",
+        description: "Search documentation pages by keyword",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Search query" },
+                limit: { type: "number", description: "Max results (default 10)" },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "read_doc",
+        description: "Read a specific documentation page by slug",
+        inputSchema: {
+            type: "object",
+            properties: {
+                slug: { type: "string", description: "Page slug" },
+            },
+            required: ["slug"],
+        },
+    },
+    {
+        name: "list_pages",
+        description: "List documentation pages, optionally filtered by section",
+        inputSchema: {
+            type: "object",
+            properties: {
+                section: { type: "string", description: "Filter by section name" },
+            },
+        },
+    },
+    {
+        name: "list_sections",
+        description: "List all documentation sections with page counts",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "get_table_of_contents",
+        description: "Get headings for a documentation page",
+        inputSchema: {
+            type: "object",
+            properties: {
+                slug: { type: "string", description: "Page slug" },
+            },
+            required: ["slug"],
+        },
+    },
+];
+function toolResult(data) {
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function toolError(message) {
+    return { content: [{ type: "text", text: message }], isError: true };
+}
+function callTool(name, args, data) {
+    switch (name) {
+        case "search_docs": {
+            const query = String(args.query ?? "");
+            const limit = Number(args.limit ?? 10);
+            const terms = query.toLowerCase().split(/\s+/);
+            const scored = data.searchIndex
+                .map((entry) => {
+                const haystack = `${entry.title} ${entry.headings} ${entry.text}`.toLowerCase();
+                const score = terms.reduce((s, t) => s + (haystack.includes(t) ? 1 : 0), 0);
+                return { entry, score };
+            })
+                .filter((r) => r.score > 0)
+                .sort((a, b) => b.score - a.score)
+                .slice(0, limit);
+            return toolResult(scored.map((r) => ({
+                title: r.entry.title,
+                slug: r.entry.slug,
+                snippet: r.entry.text.slice(0, 200),
+            })));
+        }
+        case "read_doc": {
+            const slug = String(args.slug ?? "");
+            const doc = data.docs.find((d) => d.slug === slug);
+            const idx = data.searchIndex.find((e) => e.slug === slug);
+            if (!doc || !idx)
+                return toolError(`Page not found: ${slug}`);
+            return toolResult({
+                title: doc.meta.title ?? doc.slug,
+                description: doc.meta.description ?? "",
+                content: idx.text,
+                headings: doc.headings,
+            });
+        }
+        case "list_pages": {
+            const section = args.section ? String(args.section).toLowerCase() : "";
+            let filtered = data.searchIndex;
+            if (section) {
+                filtered = filtered.filter((e) => e.group.toLowerCase().includes(section));
+            }
+            return toolResult(filtered.map((e) => ({
+                title: e.title,
+                slug: e.slug,
+                description: data.docs.find((d) => d.slug === e.slug)?.meta.description ?? "",
+            })));
+        }
+        case "list_sections": {
+            const groups = new Map();
+            for (const entry of data.searchIndex) {
+                groups.set(entry.group, (groups.get(entry.group) ?? 0) + 1);
+            }
+            return toolResult(Array.from(groups.entries()).map(([label, pageCount]) => ({
+                label,
+                path: label.toLowerCase().replace(/ > /g, "/").replace(/ /g, "-"),
+                pageCount,
+            })));
+        }
+        case "get_table_of_contents": {
+            const slug = String(args.slug ?? "");
+            const doc = data.docs.find((d) => d.slug === slug);
+            if (!doc)
+                return toolError(`Page not found: ${slug}`);
+            return toolResult(doc.headings.map((h) => ({ level: h.level, text: h.text, id: h.id })));
+        }
+        default:
+            return toolError(`Unknown tool: ${name}`);
+    }
+}
+export function handleMcpRequest(body, data) {
+    const { method, id, params } = body;
+    switch (method) {
+        case "initialize":
+            return {
+                jsonrpc: "2.0",
+                id: id ?? null,
+                result: {
+                    protocolVersion: "2024-11-05",
+                    capabilities: { tools: {} },
+                    serverInfo: { name: "tiramisu-docs", version: "0.1.0" },
+                },
+            };
+        case "notifications/initialized":
+            return { jsonrpc: "2.0", id: id ?? null, result: {} };
+        case "tools/list":
+            return { jsonrpc: "2.0", id: id ?? null, result: { tools: TOOL_DEFINITIONS } };
+        case "tools/call": {
+            const name = String(params?.name ?? "");
+            const args = (params?.arguments ?? {});
+            return { jsonrpc: "2.0", id: id ?? null, result: callTool(name, args, data) };
+        }
+        default:
+            return {
+                jsonrpc: "2.0",
+                id: id ?? null,
+                error: { code: -32601, message: `Method not found: ${method}` },
+            };
+    }
+}

package/dist/scan.d.ts

@@ -0,0 +1,15 @@
+import type { DocMeta, Heading } from "@tiramisu-docs/core";
+export interface ScannedDoc {
+    slug: string;
+    meta: DocMeta;
+    headings: Heading[];
+}
+import type { SearchIndexEntry } from "./types.js";
+export type { SearchIndexEntry } from "./types.js";
+export declare function findTiramisuFiles(dir: string): string[];
+export declare function extractPlainText(html: string): string;
+export declare function titleCase(slug: string): string;
+export declare function scanDocs(docsDir: string): {
+    docs: ScannedDoc[];
+    searchIndex: SearchIndexEntry[];
+};

package/dist/scan.js

@@ -0,0 +1,72 @@
+import { compileTiramisu } from "@tiramisu-docs/core";
+import fs from "node:fs";
+import path from "node:path";
+export function findTiramisuFiles(dir) {
+    const results = [];
+    if (!fs.existsSync(dir))
+        return results;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...findTiramisuFiles(fullPath));
+        }
+        else if (entry.name.endsWith(".tiramisu")) {
+            results.push(fullPath);
+        }
+    }
+    return results;
+}
+export function extractPlainText(html) {
+    return html
+        .replace(/<script[\s\S]*?<\/script>/g, "")
+        .replace(/<[^>]+>/g, " ")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export function titleCase(slug) {
+    return slug
+        .split("-")
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join(" ");
+}
+function resolveSearchGroup(slug, meta) {
+    const segments = slug.split("/");
+    if (segments.length === 1)
+        return meta.group ?? "Docs";
+    return segments
+        .slice(0, -1)
+        .map(titleCase)
+        .join(" > ");
+}
+export function scanDocs(docsDir) {
+    const absDocsDir = path.resolve(docsDir);
+    const files = findTiramisuFiles(absDocsDir);
+    const docs = [];
+    for (const file of files) {
+        const source = fs.readFileSync(file, "utf-8");
+        const { meta, headings } = compileTiramisu(source);
+        const relativePath = path.relative(absDocsDir, file);
+        const slug = relativePath.replace(/\.tiramisu$/, "").replace(/\\/g, "/");
+        docs.push({ slug, meta, headings });
+    }
+    const searchIndex = docs.map((doc) => {
+        const file = path.resolve(absDocsDir, doc.slug + ".tiramisu");
+        const source = fs.readFileSync(file, "utf-8");
+        const { svelte } = compileTiramisu(source);
+        const text = extractPlainText(svelte);
+        return {
+            id: doc.slug,
+            title: doc.meta.title ?? doc.slug,
+            group: resolveSearchGroup(doc.slug, doc.meta),
+            slug: doc.slug,
+            headings: doc.headings.map((h) => h.text).join(" "),
+            text,
+        };
+    });
+    return { docs, searchIndex };
+}

package/dist/seo.d.ts

@@ -0,0 +1,63 @@
+export declare function generateSitemap(docs: {
+    slug: string;
+}[], options: {
+    baseUrl: string;
+    basePath?: string;
+    locales?: {
+        code: string;
+    }[];
+    defaultLocale?: string;
+}): string;
+export declare function generateLlmsTxt(docs: {
+    slug: string;
+    meta: {
+        title?: string;
+        description?: string;
+        group?: string;
+    };
+}[], options: {
+    title: string;
+    description: string;
+    baseUrl: string;
+    basePath?: string;
+}): string;
+export declare function generateLlmsFullTxt(searchIndex: {
+    slug: string;
+    title: string;
+    group: string;
+    text: string;
+}[], options: {
+    title: string;
+    description: string;
+    baseUrl: string;
+    basePath?: string;
+}): string;
+export declare function buildInstantOgUrl(pageUrl: string, options: {
+    siteId: string;
+    template?: string;
+    theme?: "light" | "dark";
+    accentColor?: string;
+    gradientBg?: boolean;
+}): string;
+export declare function buildCanonicalUrl(baseUrl: string, slug: string): string;
+export declare function buildPageJsonLd(options: {
+    title: string;
+    slug: string;
+    baseUrl: string;
+    description?: string;
+    lastEdited?: string;
+    siteName?: string;
+    image?: string;
+    author?: string;
+}): string;
+export declare function generateSkillMd(docs: {
+    slug: string;
+    meta: {
+        title?: string;
+        description?: string;
+        group?: string;
+    };
+}[], options: {
+    title: string;
+    description: string;
+}): string;