mdorigin 0.1.0 → 0.1.2

package/dist/core/api.js

@@ -0,0 +1,160 @@
+export async function handleApiRoute(pathname, searchParams, options) {
+    if (pathname === '/api/openapi.json') {
+        return json(200, buildOpenApiDocument(options));
+    }
+    if (pathname === '/api/search') {
+        if (!options.searchApi) {
+            return json(404, { error: 'search is not enabled for this site' });
+        }
+        const query = searchParams?.get('q')?.trim() ?? '';
+        if (query === '') {
+            return json(400, {
+                error: 'missing required query parameter: q',
+            });
+        }
+        const topK = normalizePositiveInteger(searchParams?.get('topK')) ?? 10;
+        const hits = await options.searchApi.search(query, { topK });
+        return json(200, {
+            query,
+            topK,
+            count: hits.length,
+            hits: hits.map(serializeSearchHit),
+        });
+    }
+    return null;
+}
+function buildOpenApiDocument(options) {
+    return {
+        openapi: '3.1.0',
+        info: {
+            title: `${options.siteConfig.siteTitle} API`,
+            version: '1.0.0',
+            description: 'Search API for a mdorigin site.',
+        },
+        servers: options.siteConfig.siteUrl
+            ? [{ url: options.siteConfig.siteUrl }]
+            : options.requestUrl
+                ? [{ url: new URL(options.requestUrl).origin }]
+                : undefined,
+        paths: {
+            '/api/search': {
+                get: {
+                    operationId: 'searchSite',
+                    summary: 'Search published site content',
+                    parameters: [
+                        {
+                            name: 'q',
+                            in: 'query',
+                            required: true,
+                            schema: { type: 'string' },
+                            description: 'Search query string.',
+                        },
+                        {
+                            name: 'topK',
+                            in: 'query',
+                            required: false,
+                            schema: { type: 'integer', minimum: 1, default: 10 },
+                            description: 'Maximum number of hits to return.',
+                        },
+                    ],
+                    responses: {
+                        '200': {
+                            description: 'Search results.',
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        type: 'object',
+                                        required: ['query', 'topK', 'count', 'hits'],
+                                        properties: {
+                                            query: { type: 'string' },
+                                            topK: { type: 'integer' },
+                                            count: { type: 'integer' },
+                                            hits: {
+                                                type: 'array',
+                                                items: {
+                                                    type: 'object',
+                                                    required: [
+                                                        'docId',
+                                                        'relativePath',
+                                                        'score',
+                                                        'metadata',
+                                                        'bestMatch',
+                                                    ],
+                                                    properties: {
+                                                        docId: { type: 'string' },
+                                                        relativePath: { type: 'string' },
+                                                        canonicalUrl: { type: 'string' },
+                                                        title: { type: 'string' },
+                                                        summary: { type: 'string' },
+                                                        score: { type: 'number' },
+                                                        metadata: { type: 'object', additionalProperties: true },
+                                                        bestMatch: {
+                                                            type: 'object',
+                                                            required: [
+                                                                'chunkId',
+                                                                'excerpt',
+                                                                'headingPath',
+                                                                'charStart',
+                                                                'charEnd',
+                                                                'score',
+                                                            ],
+                                                            properties: {
+                                                                chunkId: { type: 'number' },
+                                                                excerpt: { type: 'string' },
+                                                                headingPath: {
+                                                                    type: 'array',
+                                                                    items: { type: 'string' },
+                                                                },
+                                                                charStart: { type: 'integer' },
+                                                                charEnd: { type: 'integer' },
+                                                                score: { type: 'number' },
+                                                            },
+                                                        },
+                                                    },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                        '400': {
+                            description: 'Invalid request.',
+                        },
+                        '404': {
+                            description: 'Search API not enabled.',
+                        },
+                    },
+                },
+            },
+        },
+    };
+}
+function serializeSearchHit(hit) {
+    return {
+        docId: hit.docId,
+        relativePath: hit.relativePath,
+        canonicalUrl: hit.canonicalUrl,
+        title: hit.title,
+        summary: hit.summary,
+        metadata: hit.metadata,
+        score: hit.score,
+        bestMatch: hit.bestMatch,
+    };
+}
+function normalizePositiveInteger(value) {
+    if (!value) {
+        return null;
+    }
+    const parsed = Number.parseInt(value, 10);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
+function json(status, body) {
+    return {
+        status,
+        headers: {
+            'content-type': 'application/json; charset=utf-8',
+        },
+        body: JSON.stringify(body, null, 2),
+    };
+}

package/dist/core/content-store.js

@@ -54,10 +54,15 @@ const MEDIA_TYPES = new Map([
     ['.json', 'application/json; charset=utf-8'],
     ['.md', 'text/markdown; charset=utf-8'],
     ['.pdf', 'application/pdf'],
+    ['.py', 'text/plain; charset=utf-8'],
     ['.png', 'image/png'],
+    ['.sh', 'text/plain; charset=utf-8'],
     ['.svg', 'image/svg+xml'],
     ['.txt', 'text/plain; charset=utf-8'],
+    ['.toml', 'text/plain; charset=utf-8'],
     ['.webp', 'image/webp'],
+    ['.yaml', 'text/plain; charset=utf-8'],
+    ['.yml', 'text/plain; charset=utf-8'],
 ]);
 export function getMediaTypeForPath(contentPath) {
     const extension = path.posix.extname(contentPath).toLowerCase();

package/dist/core/content-type.d.ts

@@ -1,6 +1,7 @@
 import type { ParsedDocumentMeta } from './markdown.js';
 export type ContentType = 'page' | 'post';
 export interface DirectoryShape {
+    hasSkillIndex: boolean;
     hasChildDirectories: boolean;
     hasExtraMarkdownFiles: boolean;
     hasAssetFiles: boolean;

package/dist/core/content-type.js

@@ -9,6 +9,9 @@ export function inferDirectoryContentType(meta, shape) {
     if (typeof meta.date === 'string' && meta.date !== '') {
         return 'post';
     }
+    if (shape.hasSkillIndex) {
+        return 'post';
+    }
     if (shape.hasChildDirectories || shape.hasExtraMarkdownFiles) {
         return 'page';
     }

package/dist/core/directory-index.d.ts

@@ -1,2 +1,2 @@
-export declare const DIRECTORY_INDEX_FILENAMES: readonly ["index.md", "README.md"];
+export declare const DIRECTORY_INDEX_FILENAMES: readonly ["index.md", "README.md", "SKILL.md"];
 export declare function getDirectoryIndexCandidates(directoryPath: string): string[];

package/dist/core/directory-index.js

@@ -1,5 +1,9 @@
 import path from 'node:path';
-export const DIRECTORY_INDEX_FILENAMES = ['index.md', 'README.md'];
+export const DIRECTORY_INDEX_FILENAMES = [
+    'index.md',
+    'README.md',
+    'SKILL.md',
+];
 export function getDirectoryIndexCandidates(directoryPath) {
     return DIRECTORY_INDEX_FILENAMES.map((filename) => directoryPath === '' ? filename : path.posix.join(directoryPath, filename));
 }

package/dist/core/markdown.d.ts

@@ -1,10 +1,13 @@
 export interface ParsedDocumentMeta {
     title?: string;
+    name?: string;
     date?: string;
     summary?: string;
+    description?: string;
     draft?: boolean;
     type?: string;
     order?: number;
+    aliases?: string[];
     [key: string]: unknown;
 }
 export interface ParsedDocument {
@@ -13,8 +16,17 @@ export interface ParsedDocument {
     html: string;
     meta: ParsedDocumentMeta;
 }
+export interface ManagedIndexEntry {
+    kind: 'directory' | 'article';
+    title: string;
+    href: string;
+    detail?: string;
+}
+export declare function getDocumentTitle(meta: ParsedDocumentMeta, body: string, fallback: string): string;
+export declare function getDocumentSummary(meta: ParsedDocumentMeta, body: string): string | undefined;
 export declare function parseMarkdownDocument(sourcePath: string, markdown: string): Promise<ParsedDocument>;
 export declare function renderMarkdown(markdown: string): Promise<string>;
 export declare function rewriteMarkdownLinksInHtml(html: string): string;
 export declare function stripManagedIndexBlock(markdown: string): string;
 export declare function stripManagedIndexLinks(markdown: string, hrefs: ReadonlySet<string>): string;
+export declare function extractManagedIndexEntries(markdown: string): ManagedIndexEntry[];

package/dist/core/markdown.js

@@ -2,6 +2,15 @@ import matter from 'gray-matter';
 import { remark } from 'remark';
 import remarkGfm from 'remark-gfm';
 import remarkHtml from 'remark-html';
+export function getDocumentTitle(meta, body, fallback) {
+    return (firstNonEmptyString(meta.title, meta.name) ??
+        extractFirstHeading(body) ??
+        fallback);
+}
+export function getDocumentSummary(meta, body) {
+    return (firstNonEmptyString(meta.summary, meta.description) ??
+        extractFirstParagraph(body));
+}
 export async function parseMarkdownDocument(sourcePath, markdown) {
     const parsed = matter(markdown);
     const html = rewriteMarkdownLinksInHtml(await renderMarkdown(parsed.content));
@@ -49,11 +58,43 @@ export function stripManagedIndexLinks(markdown, hrefs) {
         return `${start}${keptBlocks.join('\n\n')}\n${end}`;
     });
 }
+export function extractManagedIndexEntries(markdown) {
+    const match = markdown.match(/<!-- INDEX:START -->\n?([\s\S]*?)\n?<!-- INDEX:END -->/);
+    if (!match) {
+        return [];
+    }
+    const blocks = match[1]
+        .trim()
+        .split(/\n\s*\n/g)
+        .map((block) => block.trim())
+        .filter((block) => block !== '');
+    const entries = [];
+    for (const block of blocks) {
+        const lines = block.split('\n');
+        const firstLine = lines[0]?.trim() ?? '';
+        const entryMatch = firstLine.match(/^- \[([^\]]+)\]\(([^)]+)\)$/);
+        if (!entryMatch) {
+            continue;
+        }
+        const rawHref = entryMatch[2];
+        const href = rewriteMarkdownHref(rawHref);
+        entries.push({
+            kind: href.endsWith('/') ? 'directory' : 'article',
+            title: entryMatch[1],
+            href,
+            detail: lines[1]?.trim() || undefined,
+        });
+    }
+    return entries;
+}
 function normalizeMeta(data) {
     const meta = { ...data };
     if (typeof data.title === 'string') {
         meta.title = data.title;
     }
+    if (typeof data.name === 'string') {
+        meta.name = data.name;
+    }
     if (typeof data.date === 'string') {
         meta.date = data.date;
     }
@@ -63,6 +104,9 @@ function normalizeMeta(data) {
     if (typeof data.summary === 'string') {
         meta.summary = data.summary;
     }
+    if (typeof data.description === 'string') {
+        meta.description = data.description;
+    }
     if (typeof data.draft === 'boolean') {
         meta.draft = data.draft;
     }
@@ -78,6 +122,12 @@ function normalizeMeta(data) {
             meta.order = order;
         }
     }
+    if (typeof data.aliases === 'string' && data.aliases !== '') {
+        meta.aliases = [data.aliases];
+    }
+    if (Array.isArray(data.aliases)) {
+        meta.aliases = data.aliases.filter((value) => typeof value === 'string' && value !== '');
+    }
     return meta;
 }
 function rewriteMarkdownHref(href) {
@@ -108,6 +158,12 @@ function rewriteMarkdownPath(pathname) {
     if (pathname.toLowerCase() === 'readme.md') {
         return './';
     }
+    if (pathname.toLowerCase().endsWith('/skill.md')) {
+        return pathname.slice(0, -'SKILL.md'.length);
+    }
+    if (pathname.toLowerCase() === 'skill.md') {
+        return './';
+    }
     return pathname.slice(0, -'.md'.length);
 }
 function shouldPreserveHref(href) {
@@ -133,3 +189,35 @@ function normalizeManagedIndexHref(href) {
     }
     return href;
 }
+function extractFirstHeading(markdown) {
+    for (const line of markdown.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('#')) {
+            continue;
+        }
+        const heading = trimmed.replace(/^#+\s*/, '').trim();
+        if (heading !== '') {
+            return heading;
+        }
+    }
+    return undefined;
+}
+function extractFirstParagraph(markdown) {
+    const paragraphs = markdown
+        .split(/\n\s*\n/g)
+        .map((paragraph) => paragraph.trim())
+        .filter((paragraph) => paragraph !== '');
+    for (const paragraph of paragraphs) {
+        if (paragraph.startsWith('#') ||
+            paragraph.startsWith('<!--') ||
+            paragraph.startsWith('- ') ||
+            paragraph.startsWith('* ')) {
+            continue;
+        }
+        return paragraph.replace(/\s+/g, ' ');
+    }
+    return undefined;
+}
+function firstNonEmptyString(...values) {
+    return values.find((value) => typeof value === 'string' && value !== '');
+}

package/dist/core/request-handler.d.ts

@@ -1,8 +1,13 @@
 import type { ContentStore } from './content-store.js';
 import type { ResolvedSiteConfig } from './site-config.js';
+import type { SearchApi } from '../search.js';
 export interface HandleSiteRequestOptions {
     draftMode: 'include' | 'exclude';
     siteConfig: ResolvedSiteConfig;
+    acceptHeader?: string;
+    searchParams?: URLSearchParams;
+    requestUrl?: string;
+    searchApi?: SearchApi;
 }
 export interface SiteResponse {
     status: number;