fromsrc 0.0.0 → 0.0.2

package/dist/linkcheck.d.ts

@@ -0,0 +1,26 @@
+type LinkCheckResult = {
+    source: string;
+    href: string;
+    type: "internal" | "anchor" | "external";
+    status: "ok" | "broken" | "unknown";
+};
+type LinkCheckConfig = {
+    dir: string;
+    extensions?: string[];
+    baseUrl?: string;
+};
+type LinkCheckReport = {
+    total: number;
+    broken: number;
+    results: LinkCheckResult[];
+};
+declare function isInternalLink(href: string): boolean;
+declare function resolveLink(source: string, href: string): string;
+declare function extractLinks(content: string, source: string): {
+    href: string;
+    type: "internal" | "anchor" | "external";
+}[];
+declare function checkInternalLinks(config: LinkCheckConfig): Promise<LinkCheckReport>;
+declare function formatReport(report: LinkCheckReport): string;
+
+export { type LinkCheckConfig, type LinkCheckReport, type LinkCheckResult, checkInternalLinks, extractLinks, formatReport, isInternalLink, resolveLink };

package/dist/linkcheck.js

@@ -0,0 +1,113 @@
+import { readFile, readdir, access } from 'node:fs/promises';
+import { resolve, dirname, join } from 'node:path';
+
+function isInternalLink(href) {
+  if (href.startsWith("http://") || href.startsWith("https://") || href.startsWith("mailto:")) {
+    return false;
+  }
+  return href.startsWith("/") || href.startsWith("./") || href.startsWith("../") || href.startsWith("#");
+}
+function resolveLink(source, href) {
+  if (href.startsWith("/")) return href;
+  return resolve(dirname(source), href);
+}
+function extractLinks(content, source) {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  const inline = /\[([^\]]*)\]\(([^)]+)\)/g;
+  const reference = /\[([^\]]*)\]\[([^\]]+)\]/g;
+  for (const m of content.matchAll(inline)) {
+    const raw = m[2];
+    if (!raw) continue;
+    const href = raw.split(/\s/)[0];
+    if (!href) continue;
+    if (!seen.has(href)) {
+      seen.add(href);
+      results.push({ href, type: linktype(href) });
+    }
+  }
+  for (const m of content.matchAll(reference)) {
+    const ref = m[2];
+    if (!ref) continue;
+    const pattern = new RegExp(`\\[${ref.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\]:\\s*(.+)`);
+    const def = content.match(pattern);
+    if (def) {
+      const raw = def[1];
+      if (!raw) continue;
+      const href = raw.trim();
+      if (!seen.has(href)) {
+        seen.add(href);
+        results.push({ href, type: linktype(href) });
+      }
+    }
+  }
+  return results;
+}
+function linktype(href) {
+  if (href.startsWith("#")) return "anchor";
+  if (href.startsWith("http://") || href.startsWith("https://") || href.startsWith("mailto:")) {
+    return "external";
+  }
+  return "internal";
+}
+async function exists(filepath) {
+  try {
+    await access(filepath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function gather(dir, exts) {
+  const files = [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await gather(full, exts));
+    } else if (exts.some((e) => entry.name.endsWith(e))) {
+      files.push(full);
+    }
+  }
+  return files;
+}
+async function checkInternalLinks(config) {
+  const exts = config.extensions ?? [".md", ".mdx"];
+  const files = await gather(config.dir, exts);
+  const results = [];
+  for (const filepath of files) {
+    const content = await readFile(filepath, "utf-8");
+    const links = extractLinks(content);
+    for (const link of links) {
+      if (link.type === "external") {
+        results.push({ source: filepath, href: link.href, type: "external", status: "unknown" });
+        continue;
+      }
+      if (link.type === "anchor") {
+        const slug = link.href.slice(1);
+        const heading = new RegExp(`^#{1,6}\\s+.*${slug.replace(/-/g, "[\\s-]")}`, "im");
+        const status = heading.test(content) ? "ok" : "broken";
+        results.push({ source: filepath, href: link.href, type: "anchor", status });
+        continue;
+      }
+      const clean = link.href.split("#")[0]?.split("?")[0] ?? "";
+      if (!clean) {
+        results.push({ source: filepath, href: link.href, type: "internal", status: "broken" });
+        continue;
+      }
+      const resolved = resolveLink(filepath, clean);
+      const found = await exists(resolved) || await exists(`${resolved}.md`) || await exists(`${resolved}.mdx`) || await exists(join(resolved, "index.md")) || await exists(join(resolved, "index.mdx"));
+      results.push({ source: filepath, href: link.href, type: "internal", status: found ? "ok" : "broken" });
+    }
+  }
+  return { total: results.length, broken: results.filter((r) => r.status === "broken").length, results };
+}
+function formatReport(report) {
+  const lines = [`${report.total} links, ${report.broken} broken`];
+  for (const r of report.results.filter((r2) => r2.status === "broken")) {
+    lines.push(`  ${r.type} ${r.source}: ${r.href}`);
+  }
+  return lines.join("\n");
+}
+
+export { checkInternalLinks, extractLinks, formatReport, isInternalLink, resolveLink };

package/dist/llms.d.ts

@@ -0,0 +1,14 @@
+import { Doc, DocMeta } from './content.js';
+import 'zod';
+import './schema.js';
+
+interface LlmsConfig {
+    title: string;
+    description: string;
+    baseUrl: string;
+    docsPath?: string;
+}
+declare function generateLlmsIndex(config: LlmsConfig, docs: DocMeta[]): string;
+declare function generateLlmsFull(config: LlmsConfig, docs: Doc[]): string;
+
+export { type LlmsConfig, generateLlmsFull, generateLlmsIndex };

package/dist/llms.js

@@ -0,0 +1,39 @@
+function clean(path) {
+  if (!path.startsWith("/")) return `/${path}`;
+  return path;
+}
+function formatEntry(baseUrl, docsPath, doc) {
+  const path = doc.slug ? `${docsPath}/${doc.slug}` : docsPath;
+  const url = `${baseUrl}${path}`;
+  const desc = doc.description ? `: ${escapeMarkdown(doc.description)}` : "";
+  return `- [${escapeMarkdown(doc.title)}](${url})${desc}`;
+}
+function generateLlmsIndex(config, docs) {
+  const docsPath = clean(config.docsPath ?? "/docs");
+  const lines = [`# ${config.title}`, "", config.description, "", "## pages", ""];
+  for (const doc of docs) {
+    lines.push(formatEntry(config.baseUrl, docsPath, doc));
+  }
+  return lines.join("\n");
+}
+function generateLlmsFull(config, docs) {
+  const docsPath = clean(config.docsPath ?? "/docs");
+  const lines = [`# ${config.title}`, "", config.description, "", "## pages", ""];
+  for (const doc of docs) {
+    lines.push(formatEntry(config.baseUrl, docsPath, doc));
+  }
+  lines.push("", "## content");
+  for (const doc of docs) {
+    lines.push("", `### ${escapeMarkdown(doc.title)}`);
+    if (doc.description) {
+      lines.push("", escapeMarkdown(doc.description));
+    }
+    lines.push("", doc.content.trim());
+  }
+  return lines.join("\n");
+}
+function escapeMarkdown(text) {
+  return text.replace(/[[\]()\\]/g, "\\$&");
+}
+
+export { generateLlmsFull, generateLlmsIndex };

package/dist/manifest.d.ts

@@ -0,0 +1,24 @@
+import { Doc } from './content.js';
+import 'zod';
+import './schema.js';
+
+interface DocManifest {
+    version: number;
+    generated: string;
+    pages: ManifestPage[];
+}
+interface ManifestPage {
+    slug: string;
+    title: string;
+    description?: string;
+    headings: {
+        depth: number;
+        text: string;
+        id: string;
+    }[];
+    wordCount: number;
+}
+declare function generateManifest(docs: Doc[]): DocManifest;
+declare function generateManifestJson(docs: Doc[]): string;
+
+export { type DocManifest, type ManifestPage, generateManifest, generateManifestJson };

package/dist/manifest.js

@@ -0,0 +1,31 @@
+import { extractHeadings } from './content';
+
+function countWords(content) {
+  return content.replace(/```[\s\S]*?```/g, "").replace(/<[^>]+>/g, " ").replace(/import\s+.*?from\s+['"][^'"]+['"];?/g, "").replace(/\s+/g, " ").trim().split(" ").filter((w) => w.length > 0).length;
+}
+function toManifestPage(doc) {
+  const headings = extractHeadings(doc.content).map((h) => ({
+    depth: h.level,
+    text: h.text,
+    id: h.id
+  }));
+  return {
+    slug: doc.slug,
+    title: doc.title,
+    description: doc.description,
+    headings,
+    wordCount: countWords(doc.content)
+  };
+}
+function generateManifest(docs) {
+  return {
+    version: 1,
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    pages: docs.map(toManifestPage)
+  };
+}
+function generateManifestJson(docs) {
+  return JSON.stringify(generateManifest(docs), null, 2);
+}
+
+export { generateManifest, generateManifestJson };

package/dist/mcp.d.ts

@@ -0,0 +1,56 @@
+import { ContentSource } from './source.js';
+import './content.js';
+import 'zod';
+import './schema.js';
+
+interface McpConfig {
+    name: string;
+    version: string;
+    baseUrl: string;
+}
+interface McpTool {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties?: Record<string, {
+            type: string;
+            description: string;
+        }>;
+        required?: string[];
+    };
+}
+interface McpManifest {
+    server: {
+        name: string;
+        version: string;
+    };
+    capabilities: {
+        tools: {
+            listChanged: boolean;
+        };
+        resources: {
+            listChanged: boolean;
+        };
+    };
+    tools: McpTool[];
+}
+declare function generateMcpManifest(config: McpConfig): McpManifest;
+interface PageEntry {
+    slug: string;
+    title: string;
+    description?: string;
+}
+interface SearchEntry {
+    slug: string;
+    title: string;
+    snippet?: string;
+}
+interface McpHandler {
+    search(query: string): Promise<SearchEntry[]>;
+    getPage(slug: string): Promise<string | null>;
+    listPages(): Promise<PageEntry[]>;
+}
+declare function createMcpHandler(config: McpConfig, source: ContentSource): McpHandler;
+
+export { type McpConfig, createMcpHandler, generateMcpManifest };

package/dist/mcp.js

@@ -0,0 +1,74 @@
+import { localSearch } from './search';
+import { trimquery } from './searchpolicy';
+
+function generateMcpManifest(config) {
+  return {
+    server: { name: config.name, version: config.version },
+    capabilities: {
+      tools: {
+        listChanged: false
+      },
+      resources: {
+        listChanged: false
+      }
+    },
+    tools: [
+      {
+        name: "search_docs",
+        description: "Search documentation",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "Search query" }
+          },
+          required: ["query"]
+        }
+      },
+      {
+        name: "get_page",
+        description: "Get a specific documentation page",
+        inputSchema: {
+          type: "object",
+          properties: {
+            slug: { type: "string", description: "Page slug" }
+          },
+          required: ["slug"]
+        }
+      },
+      {
+        name: "list_pages",
+        description: "List all available documentation pages",
+        inputSchema: { type: "object" }
+      }
+    ]
+  };
+}
+function createMcpHandler(config, source) {
+  return {
+    async search(query) {
+      if (!source.search) return [];
+      const docs = await source.search();
+      const results = await Promise.resolve(localSearch.search(trimquery(query), docs, 10));
+      return results.map((item) => ({
+        slug: item.doc.slug,
+        title: item.doc.title,
+        snippet: item.snippet ?? item.doc.description ?? item.doc.content.slice(0, 120)
+      }));
+    },
+    async getPage(slug) {
+      const result = await source.get(slug.split("/"));
+      if (!result) return null;
+      return result.content;
+    },
+    async listPages() {
+      const docs = await source.list();
+      return docs.map((d) => ({
+        slug: d.slug,
+        title: d.title,
+        description: d.description
+      }));
+    }
+  };
+}
+
+export { createMcpHandler, generateMcpManifest };

package/dist/mdtoc.d.ts

@@ -0,0 +1,16 @@
+type TocItem = {
+    level: number;
+    text: string;
+    slug: string;
+};
+type TocOptions = {
+    minLevel?: number;
+    maxLevel?: number;
+    ordered?: boolean;
+};
+declare function extractToc(content: string): TocItem[];
+declare function generateTocMarkdown(items: TocItem[], options?: TocOptions): string;
+declare function removeToc(content: string): string;
+declare function injectToc(content: string, options?: TocOptions): string;
+
+export { type TocItem, type TocOptions, extractToc, generateTocMarkdown, injectToc, removeToc };

package/dist/mdtoc.js

@@ -0,0 +1,59 @@
+function slugify(text) {
+  return text.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9_-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function extractToc(content) {
+  const items = [];
+  const lines = content.split("\n");
+  let inCodeBlock = false;
+  for (const line of lines) {
+    if (line.trimStart().startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock) continue;
+    const match = line.match(/^(#{1,6})\s+(.+)$/);
+    if (!match) continue;
+    const hashes = match[1];
+    const heading = match[2];
+    if (!hashes || !heading) continue;
+    const level = hashes.length;
+    const text = heading.trim();
+    items.push({ level, text, slug: slugify(text) });
+  }
+  return items;
+}
+function generateTocMarkdown(items, options) {
+  const min = options?.minLevel ?? 2;
+  const max = options?.maxLevel ?? 4;
+  const ordered = options?.ordered ?? false;
+  const prefix = ordered ? "1." : "-";
+  return items.filter((item) => item.level >= min && item.level <= max).map((item) => {
+    const indent = "	".repeat(item.level - min);
+    return `${indent}${prefix} [${item.text}](#${item.slug})`;
+  }).join("\n");
+}
+function removeToc(content) {
+  return content.replace(/<!-- toc -->\n[\s\S]*?<!-- \/toc -->\n?/, "");
+}
+function injectToc(content, options) {
+  const items = extractToc(content);
+  const toc = `<!-- toc -->
+${generateTocMarkdown(items, options)}
+<!-- /toc -->`;
+  const cleaned = removeToc(content);
+  if (cleaned.includes("<!-- toc -->")) {
+    return cleaned.replace("<!-- toc -->", toc);
+  }
+  const fmMatch = cleaned.match(/^---\n[\s\S]*?\n---\n/);
+  if (fmMatch) {
+    return `${fmMatch[0]}
+${toc}
+
+${cleaned.slice(fmMatch[0].length)}`;
+  }
+  return `${toc}
+
+${cleaned}`;
+}
+
+export { extractToc, generateTocMarkdown, injectToc, removeToc };

package/dist/mdxscope.d.ts

@@ -0,0 +1,17 @@
+import { ComponentType } from 'react';
+
+type MdxComponent = ComponentType<unknown>;
+type MdxScope = Record<string, MdxComponent>;
+type MdxScopeConfig = {
+    defaults?: MdxScope;
+    overrides?: MdxScope;
+    aliases?: Record<string, string>;
+};
+declare function createScope(config?: MdxScopeConfig): MdxScope;
+declare function mergeScopes(...scopes: MdxScope[]): MdxScope;
+declare function withDefaults(scope: MdxScope, defaults: MdxScope): MdxScope;
+declare function filterScope(scope: MdxScope, allowed: string[]): MdxScope;
+declare function scopeFromImports(imports: Record<string, unknown>): MdxScope;
+declare function listComponents(scope: MdxScope): string[];
+
+export { type MdxComponent, type MdxScope, type MdxScopeConfig, createScope, filterScope, listComponents, mergeScopes, scopeFromImports, withDefaults };

package/dist/mdxscope.js

@@ -0,0 +1,58 @@
+function createScope(config) {
+  if (!config) return {};
+  const base = { ...config.defaults };
+  if (config.overrides) {
+    for (const [key, value] of Object.entries(config.overrides)) {
+      base[key] = value;
+    }
+  }
+  if (config.aliases) {
+    for (const [alias, target] of Object.entries(config.aliases)) {
+      const component = base[target];
+      if (component) {
+        base[alias] = component;
+      }
+    }
+  }
+  return base;
+}
+function mergeScopes(...scopes) {
+  const result = {};
+  for (const scope of scopes) {
+    for (const [key, value] of Object.entries(scope)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function withDefaults(scope, defaults) {
+  const result = { ...defaults };
+  for (const [key, value] of Object.entries(scope)) {
+    result[key] = value;
+  }
+  return result;
+}
+function filterScope(scope, allowed) {
+  const set = new Set(allowed);
+  const result = {};
+  for (const [key, value] of Object.entries(scope)) {
+    if (set.has(key)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function scopeFromImports(imports) {
+  const result = {};
+  for (const [key, value] of Object.entries(imports)) {
+    if (/^[A-Z]/.test(key) && typeof value === "function") {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function listComponents(scope) {
+  return Object.keys(scope).sort();
+}
+
+export { createScope, filterScope, listComponents, mergeScopes, scopeFromImports, withDefaults };

package/dist/meta.d.ts

@@ -0,0 +1,19 @@
+interface MetaFile {
+    title?: string;
+    icon?: string;
+    pages?: string[];
+}
+interface PageTreeItem {
+    type: "page" | "folder" | "separator";
+    slug?: string;
+    title: string;
+    icon?: string;
+    children?: PageTreeItem[];
+}
+declare function loadMeta(dir: string): Promise<MetaFile | null>;
+declare function sortByMeta<T extends {
+    slug: string;
+}>(items: T[], pages: string[] | undefined, prefix: string): T[];
+declare function clearMetaCache(): void;
+
+export { type MetaFile, type PageTreeItem, clearMetaCache, loadMeta, sortByMeta };

package/dist/meta.js

@@ -0,0 +1,71 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+const metaCache = /* @__PURE__ */ new Map();
+const isProduction = () => process.env.NODE_ENV === "production";
+function isrecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isMetaFile(data) {
+  if (!isrecord(data)) return false;
+  const obj = data;
+  if (obj.title !== void 0 && typeof obj.title !== "string") return false;
+  if (obj.icon !== void 0 && typeof obj.icon !== "string") return false;
+  if (obj.pages !== void 0 && !Array.isArray(obj.pages)) return false;
+  if (Array.isArray(obj.pages) && !obj.pages.every((p) => typeof p === "string")) return false;
+  return true;
+}
+async function loadMeta(dir) {
+  if (isProduction()) {
+    const cached = metaCache.get(dir);
+    if (cached !== void 0) return cached;
+  }
+  const filepath = join(dir, "_meta.json");
+  try {
+    const content = await readFile(filepath, "utf-8");
+    const data = JSON.parse(content);
+    if (!isMetaFile(data)) {
+      if (isProduction()) {
+        metaCache.set(dir, null);
+      }
+      return null;
+    }
+    if (isProduction()) {
+      metaCache.set(dir, data);
+    }
+    return data;
+  } catch {
+    if (isProduction()) {
+      metaCache.set(dir, null);
+    }
+    return null;
+  }
+}
+function sortByMeta(items, pages, prefix) {
+  if (!pages || pages.length === 0) {
+    return items;
+  }
+  const order = /* @__PURE__ */ new Map();
+  pages.forEach((page, i) => {
+    if (!page.startsWith("---")) {
+      order.set(page, i);
+    }
+  });
+  return [...items].sort((a, b) => {
+    const aName = getBasename(a.slug, prefix);
+    const bName = getBasename(b.slug, prefix);
+    const aOrder = order.get(aName) ?? 999;
+    const bOrder = order.get(bName) ?? 999;
+    return aOrder - bOrder;
+  });
+}
+function getBasename(slug, prefix) {
+  const relative = prefix ? slug.replace(prefix, "") : slug;
+  const parts = relative.split("/");
+  return parts[0] || "index";
+}
+function clearMetaCache() {
+  metaCache.clear();
+}
+
+export { clearMetaCache, loadMeta, sortByMeta };

package/dist/migrate.d.ts

@@ -0,0 +1,17 @@
+type MigrateSource = "docusaurus" | "nextra" | "mintlify";
+interface MigrateConfig {
+    source: MigrateSource;
+    inputDir: string;
+    outputDir: string;
+}
+interface MigrateResult {
+    files: number;
+    warnings: string[];
+}
+type MigrateTransform = (content: string, filepath: string) => string;
+declare const migrateDocusaurus: MigrateTransform;
+declare const migrateNextra: MigrateTransform;
+declare const migrateMintlify: MigrateTransform;
+declare function migrate(config: MigrateConfig): Promise<MigrateResult>;
+
+export { type MigrateConfig, type MigrateResult, type MigrateSource, type MigrateTransform, migrate, migrateDocusaurus, migrateMintlify, migrateNextra };