@doxbrix/doxloop 0.1.5 → 0.2.0

package/vendor/doxbrix-import/dist/docs/manifest.d.ts

@@ -0,0 +1,163 @@
+/**
+ * Local mirror of the Doxbrix `docs.json` manifest model. Kept in sync with the
+ * server's `git-sync/manifest.ts` shape (the CLI can't import server-only code).
+ * The manifest is authoritative for navigation; pages live in files referenced
+ * by `file` (without extension).
+ */
+export type ManifestNavNode = {
+    type: 'page';
+    file: string;
+    title?: string;
+    icon?: string;
+    hidden?: boolean;
+} | {
+    type: 'group';
+    label: string;
+    icon?: string;
+    hidden?: boolean;
+    items: ManifestNavNode[];
+} | {
+    type: 'label';
+    text: string;
+} | {
+    type: 'divider';
+} | {
+    type: 'link';
+    title: string;
+    href: string;
+    icon?: string;
+} | {
+    type: 'api';
+    title: string;
+    spec: string;
+    icon?: string;
+};
+export interface ManifestSpace {
+    name: string;
+    slug?: string;
+    locale?: string;
+    parent?: string;
+    icon?: string;
+    tag?: string;
+    /** Doc-version slug from the manifest `versions` catalog; absent = default. */
+    version?: string;
+    nav: ManifestNavNode[];
+}
+/** Product-docs version entry. First entry is the default unless one sets
+ *  `default: true` (the Mintlify rule). `tag` renders as a badge. The SDK
+ *  importer emits `isDefault`; hand-authored docs.json may use `default`. */
+export interface ManifestDocVersion {
+    version: string;
+    label?: string;
+    tag?: string;
+    default?: boolean;
+    isDefault?: boolean;
+}
+export interface DocsManifest {
+    version: number;
+    name?: string;
+    description?: string;
+    openapiSources?: string[];
+    apiBaseUrl?: string;
+    /** Product-docs versions in switcher order; absent = unversioned project. */
+    versions?: ManifestDocVersion[];
+    spaces: ManifestSpace[];
+    /** Portable brand/layout settings produced by local migrations. */
+    theme?: {
+        source?: string;
+        preset?: string;
+        primaryColor?: string;
+        lightColor?: string;
+        darkColor?: string;
+        mode?: 'light' | 'dark' | 'system';
+        strictMode?: boolean;
+        font?: string;
+        headingFont?: string;
+        codeFont?: string;
+        typography?: {
+            titleWeight?: number;
+            titleSize?: number;
+            titleSizeMobile?: number;
+            titleLineHeight?: number;
+            titleLineHeightMobile?: number;
+            descriptionSize?: number;
+            descriptionLineHeight?: number;
+            bodyWeight?: number;
+            bodySize?: number;
+            bodyLineHeight?: number;
+            fontFeatures?: string[];
+            fontVariationSettings?: 'normal';
+            fontSmoothing?: 'auto' | 'antialiased';
+            headingWeight?: number;
+            h2Size?: number;
+            h2LineHeight?: number;
+            h2MarginTop?: number;
+            h2MarginBottom?: number;
+            h3Size?: number;
+            h3LineHeight?: number;
+            h3MarginTop?: number;
+            h3MarginBottom?: number;
+            h4Size?: number;
+            h4LineHeight?: number;
+            h4MarginTop?: number;
+            h4MarginBottom?: number;
+            strongWeight?: number;
+            apiFieldWeight?: number;
+        };
+        textColors?: {
+            light?: {
+                heading?: string;
+                body?: string;
+                muted?: string;
+            };
+            dark?: {
+                heading?: string;
+                body?: string;
+                muted?: string;
+            };
+        };
+        fontSources?: Array<{
+            family: string;
+            source: string;
+            format?: string;
+            weight?: number;
+            role: 'body' | 'heading' | 'code';
+        }>;
+        logoLight?: string;
+        logoDark?: string;
+        logoHref?: string;
+        favicon?: string;
+        faviconLight?: string;
+        faviconDark?: string;
+        backgroundColorLight?: string;
+        backgroundColorDark?: string;
+        backgroundImage?: string;
+        backgroundDecoration?: string;
+        codeTheme?: string;
+        codeThemeLight?: string;
+        codeThemeDark?: string;
+        eyebrow?: string;
+        layout?: {
+            headerHeight: number;
+            sidebarWidth: number;
+            tocWidth: number;
+            contentMaxWidth: number;
+            contentPadding: number;
+            navPadding: number;
+            tabsHeight?: number;
+            shellMaxWidth?: number;
+        };
+    };
+    site?: Record<string, unknown>;
+}
+export declare const PAGE_EXTENSIONS: string[];
+export declare function isPageFile(path: string): boolean;
+export declare function stripPageExtension(path: string): string;
+export declare function withPageExtension(file: string, ext?: string): string;
+/** Parse + lightly validate a `docs.json` string. Throws on malformed JSON. */
+export declare function parseManifest(jsonText: string): DocsManifest;
+export declare function stringifyManifest(manifest: DocsManifest): string;
+/** Every page `file` referenced in the manifest (without extension). */
+export declare function manifestPageFiles(manifest: DocsManifest): string[];
+/** Walk every nav node (for validation), depth-first. */
+export declare function walkNav(manifest: DocsManifest, visit: (node: ManifestNavNode, spaceIndex: number) => void): void;

package/vendor/doxbrix-import/dist/docs/manifest.js

@@ -0,0 +1,64 @@
+/**
+ * Local mirror of the Doxbrix `docs.json` manifest model. Kept in sync with the
+ * server's `git-sync/manifest.ts` shape (the CLI can't import server-only code).
+ * The manifest is authoritative for navigation; pages live in files referenced
+ * by `file` (without extension).
+ */
+export const PAGE_EXTENSIONS = ['.mdx', '.md', '.markdown'];
+export function isPageFile(path) {
+    const lower = path.toLowerCase();
+    return PAGE_EXTENSIONS.some((ext) => lower.endsWith(ext));
+}
+export function stripPageExtension(path) {
+    for (const ext of PAGE_EXTENSIONS) {
+        if (path.toLowerCase().endsWith(ext))
+            return path.slice(0, -ext.length);
+    }
+    return path;
+}
+export function withPageExtension(file, ext = '.mdx') {
+    return isPageFile(file) ? file : `${file}${ext}`;
+}
+/** Parse + lightly validate a `docs.json` string. Throws on malformed JSON. */
+export function parseManifest(jsonText) {
+    const raw = JSON.parse(jsonText);
+    if (!raw || typeof raw !== 'object')
+        throw new Error('docs.json must be a JSON object');
+    const spaces = Array.isArray(raw.spaces) ? raw.spaces : [];
+    return {
+        ...raw,
+        version: typeof raw.version === 'number' ? raw.version : 1,
+        spaces: spaces,
+    };
+}
+export function stringifyManifest(manifest) {
+    return `${JSON.stringify(manifest, null, 2)}\n`;
+}
+/** Every page `file` referenced in the manifest (without extension). */
+export function manifestPageFiles(manifest) {
+    const out = [];
+    const walk = (nodes) => {
+        for (const node of nodes) {
+            if (node.type === 'page')
+                out.push(node.file);
+            else if (node.type === 'group')
+                walk(node.items);
+        }
+    };
+    for (const space of manifest.spaces)
+        walk(space.nav);
+    return out;
+}
+/** Walk every nav node (for validation), depth-first. */
+export function walkNav(manifest, visit) {
+    manifest.spaces.forEach((space, i) => {
+        const walk = (nodes) => {
+            for (const node of nodes) {
+                visit(node, i);
+                if (node.type === 'group')
+                    walk(node.items);
+            }
+        };
+        walk(space.nav);
+    });
+}

package/vendor/doxbrix-import/dist/docs/project.d.ts

@@ -0,0 +1,25 @@
+import { type DocsManifest } from './manifest.js';
+export interface LocalPageFile {
+    /** Path relative to the docs dir, POSIX-separated, with extension. */
+    relPath: string;
+    absPath: string;
+    frontmatter: Record<string, unknown>;
+    body: string;
+    raw: string;
+}
+export interface LocalDocsProject {
+    /** Project root (folder containing `.doxbrix`). */
+    root: string;
+    /** Docs directory: `root/basePath`. */
+    docsDir: string;
+    basePath: string;
+    manifestPath: string | null;
+    manifest: DocsManifest;
+    pages: LocalPageFile[];
+    /** Media file paths relative to docsDir (POSIX). */
+    media: string[];
+}
+/** List all files under `dir` recursively, returned as POSIX paths relative to `dir`. */
+export declare function listFilesRecursive(dir: string): string[];
+/** Load and parse a local docs project rooted at `root` with `basePath`. */
+export declare function loadLocalProject(root: string, basePath: string): LocalDocsProject;

package/vendor/doxbrix-import/dist/docs/project.js

@@ -0,0 +1,77 @@
+import { readFileSync, readdirSync, existsSync, lstatSync } from 'node:fs';
+import { join, relative, sep, posix } from 'node:path';
+import { parseManifest, isPageFile } from './manifest.js';
+import { parseFrontmatter } from './frontmatter.js';
+const MEDIA_DIRS = ['images', 'assets', 'media', 'img', 'static'];
+const ASSET_RE = /\.(png|jpe?g|gif|svg|webp|avif|ico|bmp|woff2?|ttf|otf|eot|mp4|webm|mov|mp3|wav|ogg|pdf)$/i;
+const IGNORED_DIRS = new Set(['.doxbrix', '.agents', '.claude', '.gemini', 'node_modules']);
+/** List all files under `dir` recursively, returned as POSIX paths relative to `dir`. */
+export function listFilesRecursive(dir) {
+    const out = [];
+    const walk = (current) => {
+        let entries;
+        try {
+            entries = readdirSync(current);
+        }
+        catch {
+            return;
+        }
+        for (const name of entries) {
+            if (IGNORED_DIRS.has(name) || name.startsWith('.git'))
+                continue;
+            const abs = join(current, name);
+            let stat;
+            try {
+                stat = lstatSync(abs);
+            }
+            catch {
+                continue;
+            }
+            if (stat.isSymbolicLink())
+                continue;
+            if (stat.isDirectory())
+                walk(abs);
+            else
+                out.push(toPosix(relative(dir, abs)));
+        }
+    };
+    walk(dir);
+    return out;
+}
+function toPosix(p) {
+    return p.split(sep).join(posix.sep);
+}
+/** Load and parse a local docs project rooted at `root` with `basePath`. */
+export function loadLocalProject(root, basePath) {
+    const docsDir = basePath ? join(root, basePath) : root;
+    if (!existsSync(docsDir)) {
+        throw new Error(`Docs directory not found: ${docsDir}`);
+    }
+    const manifestPath = join(docsDir, 'docs.json');
+    let manifest;
+    let resolvedManifestPath = null;
+    if (existsSync(manifestPath)) {
+        manifest = parseManifest(readFileSync(manifestPath, 'utf8'));
+        resolvedManifestPath = manifestPath;
+    }
+    else {
+        manifest = { version: 1, spaces: [] };
+    }
+    const allFiles = listFilesRecursive(docsDir);
+    const pages = [];
+    const media = [];
+    for (const rel of allFiles) {
+        if (rel === 'docs.json')
+            continue;
+        if (isPageFile(rel)) {
+            const abs = join(docsDir, rel);
+            const raw = readFileSync(abs, 'utf8');
+            const { data, body } = parseFrontmatter(raw);
+            pages.push({ relPath: rel, absPath: abs, frontmatter: data, body, raw });
+        }
+        else if (ASSET_RE.test(rel) || MEDIA_DIRS.some((d) => rel.startsWith(`${d}/`))) {
+            media.push(rel);
+        }
+    }
+    return { root, docsDir, basePath, manifestPath: resolvedManifestPath, manifest, pages, media };
+}

package/vendor/doxbrix-import/dist/docs/starter.d.ts

@@ -0,0 +1,4 @@
+/** Invisible marker added to page scaffolds until researched content replaces them. */
+export declare const STARTER_PAGE_MARKER = "<!-- doxbrix:starter-page -->";
+/** Detect current marked scaffolds and legacy starter text created by older CLI builds. */
+export declare function hasStarterPageContent(body: string): boolean;

package/vendor/doxbrix-import/dist/docs/starter.js

@@ -0,0 +1,11 @@
+/** Invisible marker added to page scaffolds until researched content replaces them. */
+export const STARTER_PAGE_MARKER = '<!-- doxbrix:starter-page -->';
+/** Detect current marked scaffolds and legacy starter text created by older CLI builds. */
+export function hasStarterPageContent(body) {
+    const normalized = body.replace(/\r\n/g, '\n').trim();
+    if (normalized.includes(STARTER_PAGE_MARKER))
+        return true;
+    return (/^#\s+Introduction\s*\n+\s*Welcome to (?:\*\*)?.+?(?:\*\*)?\.\s*$/i.test(normalized) ||
+        /^#\s+Quickstart\s*\n+\s*Get started in a few minutes\.\s*$/i.test(normalized) ||
+        /^#\s+.+?\s*\n+\s*Start writing here\.\s*$/i.test(normalized));
+}

package/vendor/doxbrix-import/dist/importer.d.ts

@@ -0,0 +1,227 @@
+export type ImportDialect = 'native' | 'mintlify' | 'gitbook' | 'generic';
+export type ImportNavNode = {
+    type: 'page';
+    file: string;
+    title?: string;
+    icon?: string;
+    hidden?: boolean;
+} | {
+    type: 'group';
+    label: string;
+    icon?: string;
+    hidden?: boolean;
+    items: ImportNavNode[];
+} | {
+    type: 'label';
+    text: string;
+} | {
+    type: 'divider';
+} | {
+    type: 'link';
+    title: string;
+    href: string;
+    icon?: string;
+} | {
+    type: 'api';
+    title: string;
+    spec: string;
+    icon?: string;
+};
+export interface ImportSpace {
+    name: string;
+    slug?: string;
+    locale?: string;
+    parent?: string;
+    icon?: string;
+    tag?: string;
+    /** ImportVersion.version this space belongs to; absent = default/unversioned. */
+    version?: string;
+    nav: ImportNavNode[];
+}
+/** A product-docs version from the source config (Mintlify navigation.versions,
+ *  GitBook variants). The first entry is the default unless another entry sets
+ *  `default: true` — Mintlify's rule, adopted verbatim. */
+export interface ImportVersion {
+    version: string;
+    label: string;
+    tag?: string;
+    isDefault?: boolean;
+}
+export interface ImportedTheme {
+    /** Doxbrix-owned theme generated by a source-format conversion. The legacy
+     * provider-specific value remains readable in consumers for old projects. */
+    source: 'doxbrix-import';
+    preset?: string;
+    primaryColor?: string;
+    lightColor?: string;
+    darkColor?: string;
+    mode?: 'system' | 'light' | 'dark';
+    strictMode?: boolean;
+    font?: string;
+    headingFont?: string;
+    codeFont?: string;
+    typography?: {
+        titleWeight?: number;
+        titleSize?: number;
+        titleSizeMobile?: number;
+        titleLineHeight?: number;
+        titleLineHeightMobile?: number;
+        descriptionSize?: number;
+        descriptionLineHeight?: number;
+        bodyWeight?: number;
+        bodySize?: number;
+        bodyLineHeight?: number;
+        fontFeatures?: string[];
+        fontVariationSettings?: 'normal';
+        fontSmoothing?: 'auto' | 'antialiased';
+        headingWeight?: number;
+        h2Size?: number;
+        h2LineHeight?: number;
+        h2MarginTop?: number;
+        h2MarginBottom?: number;
+        h3Size?: number;
+        h3LineHeight?: number;
+        h3MarginTop?: number;
+        h3MarginBottom?: number;
+        h4Size?: number;
+        h4LineHeight?: number;
+        h4MarginTop?: number;
+        h4MarginBottom?: number;
+        strongWeight?: number;
+        apiFieldWeight?: number;
+    };
+    textColors?: {
+        light?: {
+            heading?: string;
+            body?: string;
+            muted?: string;
+        };
+        dark?: {
+            heading?: string;
+            body?: string;
+            muted?: string;
+        };
+    };
+    fontSources?: Array<{
+        family: string;
+        source: string;
+        format?: string;
+        weight?: number;
+        role: 'body' | 'heading' | 'code';
+    }>;
+    logoLight?: string;
+    logoDark?: string;
+    logoHref?: string;
+    favicon?: string;
+    faviconLight?: string;
+    faviconDark?: string;
+    backgroundColorLight?: string;
+    backgroundColorDark?: string;
+    backgroundImage?: string;
+    backgroundDecoration?: string;
+    codeTheme?: string;
+    codeThemeLight?: string;
+    codeThemeDark?: string;
+    eyebrow?: string;
+    layout?: {
+        headerHeight: number;
+        sidebarWidth: number;
+        tocWidth: number;
+        contentMaxWidth: number;
+        contentPadding: number;
+        navPadding: number;
+        tabsHeight?: number;
+        shellMaxWidth?: number;
+    };
+}
+export interface ImportedSiteChrome {
+    navbar?: {
+        links: Array<{
+            label: string;
+            href: string;
+            icon?: string;
+        }>;
+        primary?: {
+            label: string;
+            href: string;
+            type?: string;
+        };
+    };
+    footer?: {
+        groups: Array<{
+            title: string;
+            links: Array<{
+                label: string;
+                url: string;
+            }>;
+        }>;
+        socials: Array<{
+            platform: string;
+            label: string;
+            url: string;
+        }>;
+    };
+    banner?: {
+        content: string;
+        dismissible: boolean;
+        type: 'info' | 'warning' | 'critical';
+        colorLight?: string;
+        colorDark?: string;
+    };
+}
+export interface ImportedManifest {
+    version: number;
+    name?: string;
+    description?: string;
+    /** OpenAPI documents configured by the source site, in preference order. */
+    openapiSources?: string[];
+    /** Fallback server for page-level API operations when a spec omits servers. */
+    apiBaseUrl?: string;
+    spaces: ImportSpace[];
+    /** Product-docs versions in source order; absent when the source is unversioned. */
+    versions?: ImportVersion[];
+    theme?: ImportedTheme;
+    site?: ImportedSiteChrome;
+}
+export interface LocalImportFile {
+    path: string;
+    content: string;
+}
+export interface LocalConvertResult {
+    dialect: ImportDialect;
+    manifest: ImportedManifest;
+    pages: Array<{
+        path: string;
+        markdown: string;
+    }>;
+    redirects: Array<{
+        from: string;
+        to: string;
+    }>;
+    unmapped: string[];
+}
+/**
+ * Decode an SVG icon produced by the importer for safe inline rendering.
+ *
+ * SVGs that use `currentColor` must remain in the document tree to inherit the
+ * card or navigation color. Rendering the same data URL through `<img>` creates
+ * an isolated document and silently turns those icons black. Only the encoded
+ * SVG form emitted by this importer is accepted, and it is sanitized again at
+ * the rendering boundary before callers use it as markup.
+ */
+export declare function decodeImportedSvgIconDataUrl(value: string): string | null;
+/** Normalize current Mintlify components into Doxbrix's supported MDX vocabulary. */
+export declare function transformMintlifyMdx(input: string): string;
+export declare function convertSourceTree(inputFiles: LocalImportFile[]): LocalConvertResult;
+/** Materialize navigation-level OpenAPI markers into generated endpoint pages.
+ * Local documents are read from the source tree; callers may provide a guarded
+ * loader for public URL sources. Unavailable specs remain as API markers and
+ * are reported without dropping their navigation entry. */
+export declare function materializeMintlifyOpenApiNavigation(params: {
+    result: LocalConvertResult;
+    files: LocalImportFile[];
+    loadRemote?: (url: string) => Promise<string | null>;
+}): Promise<{
+    result: LocalConvertResult;
+    warnings: string[];
+}>;