mdx-artifacts 0.1.2 → 0.2.0

package/dist/lib/cli/commands/review.js

@@ -0,0 +1,171 @@
+import { addReviewThreadService, replyToReviewThreadsService, validateReviewStateService } from "../services/review.js";
+export async function reviewCommand(projectRoot, args) {
+    const [subcommand] = args;
+    if (subcommand === "add") {
+        const options = parseReviewAddArgs(args.slice(1));
+        const result = await addReviewThreadService(projectRoot, options.input, options);
+        console.log(formatReviewAddResult(result));
+        return;
+    }
+    if (subcommand === "reply") {
+        const options = parseReviewReplyArgs(args.slice(1));
+        const result = await replyToReviewThreadsService(projectRoot, options.input, options);
+        console.log(formatReviewReplyResult(result));
+        return;
+    }
+    if (subcommand === "validate") {
+        const input = parseReviewValidateArgs(args.slice(1));
+        const result = await validateReviewStateService(projectRoot, input);
+        console.log(formatReviewValidationResult(result));
+        if (result.missingThreads.length > 0) {
+            process.exitCode = 1;
+        }
+        return;
+    }
+    throw new Error("review requires a subcommand. Use `mdx-artifacts review add <file.mdx>`, `mdx-artifacts review reply <file.mdx>`, or `mdx-artifacts review validate <file.mdx>`.");
+}
+function parseReviewReplyArgs(args) {
+    const [input, ...rest] = args;
+    if (!input) {
+        throw new Error("review reply requires a .mdx file path.");
+    }
+    const { replies, status } = parseReviewReplyOptions(rest);
+    return {
+        input,
+        replies,
+        ...(status ? { status } : {})
+    };
+}
+function parseReviewValidateArgs(args) {
+    const [input, ...rest] = args;
+    if (!input) {
+        throw new Error("review validate requires a .mdx file path.");
+    }
+    if (rest.length > 0) {
+        throw new Error(`Unexpected review validate argument: ${rest[0]}`);
+    }
+    return input;
+}
+function parseReviewAddArgs(args) {
+    const [input, ...rest] = args;
+    if (!input) {
+        throw new Error("review add requires a .mdx file path.");
+    }
+    const options = parseKeyValueOptions(rest, ["anchor", "body", "title"]);
+    const anchorId = options.get("anchor");
+    const body = options.get("body");
+    const title = options.get("title");
+    if (!anchorId) {
+        throw new Error("review add requires --anchor <anchorId>.");
+    }
+    if (!body || !body.trim()) {
+        throw new Error("review add requires --body <message>.");
+    }
+    return {
+        input,
+        anchorId,
+        body: body.trim(),
+        ...(title ? { title } : {})
+    };
+}
+function parseKeyValueOptions(args, allowedKeys) {
+    const options = new Map();
+    for (let index = 0; index < args.length; index += 1) {
+        const name = args[index];
+        if (!name?.startsWith("--")) {
+            throw new Error(`Unexpected review argument: ${name}`);
+        }
+        const key = name.slice(2);
+        const value = args[index + 1];
+        if (!allowedKeys.includes(key)) {
+            throw new Error(`Unknown review option: --${key}.`);
+        }
+        if (!value || value.startsWith("--")) {
+            throw new Error(`Missing value for --${key}.`);
+        }
+        options.set(key, value);
+        index += 1;
+    }
+    return options;
+}
+function parseReviewReplyOptions(args) {
+    const replies = [];
+    let status;
+    let threadId;
+    for (let index = 0; index < args.length; index += 1) {
+        const name = args[index];
+        if (!name?.startsWith("--")) {
+            throw new Error(`Unexpected review reply argument: ${name}`);
+        }
+        const key = name.slice(2);
+        const value = args[index + 1];
+        if (!value || value.startsWith("--")) {
+            throw new Error(`Missing value for --${key}.`);
+        }
+        if (key === "thread") {
+            if (threadId) {
+                throw new Error(`Missing --body for --thread ${threadId}.`);
+            }
+            threadId = value;
+        }
+        else if (key === "body") {
+            if (!threadId) {
+                throw new Error("review reply requires --thread before --body.");
+            }
+            if (!value.trim()) {
+                throw new Error("review reply requires --body <message>.");
+            }
+            replies.push({ threadId, body: value.trim() });
+            threadId = undefined;
+        }
+        else if (key === "status") {
+            status = value;
+        }
+        else {
+            throw new Error(`Unknown review reply option: --${key}.`);
+        }
+        index += 1;
+    }
+    if (threadId) {
+        throw new Error(`Missing --body for --thread ${threadId}.`);
+    }
+    if (replies.length === 0) {
+        throw new Error("review reply requires at least one --thread <threadId> --body <message> pair.");
+    }
+    return { replies, status };
+}
+function formatReviewAddResult(result) {
+    return [`review add ok`, `state: ${result.statePath}`, `thread: ${result.threadId}`, `anchorId: ${result.anchorId}`].join("\n");
+}
+function formatReviewReplyResult(result) {
+    return [
+        `review reply ok`,
+        `state: ${result.statePath}`,
+        `messages: ${result.messageRecords.length}`,
+        ...result.messageRecords.map((record) => `- thread: ${record.threadId} message: ${record.messageId}`)
+    ].join("\n");
+}
+function formatReviewValidationResult(result) {
+    return result.missingThreads.length === 0
+        ? [
+            `review validate ok`,
+            `state: ${result.statePath}`,
+            `anchors: ${result.anchorCount}`,
+            `threads: ${result.threadCount}`
+        ].join("\n")
+        : [
+            `review validate failed`,
+            `state: ${result.statePath}`,
+            `anchors: ${result.anchorCount}`,
+            `threads: ${result.threadCount}`,
+            `missing: ${result.missingThreads.length}`,
+            ...result.missingThreads.map((thread) => [
+                `- thread: ${thread.threadId}`,
+                `anchorId: ${thread.anchorId}`,
+                thread.status ? `status: ${thread.status}` : undefined,
+                thread.title ? `title: ${thread.title}` : undefined
+            ]
+                .filter(Boolean)
+                .join(" "))
+        ].join("\n");
+}

package/dist/lib/cli/commands/scaffold.d.ts

@@ -0,0 +1,16 @@
+export type InitAgent = "generic" | "codex" | "claude-code" | "cursor" | "all";
+export type InitProjectOptions = {
+    agent?: InitAgent;
+    docsDir?: string;
+    componentsDir?: string;
+    yes?: boolean;
+};
+type InitPromptIo = {
+    input: NodeJS.ReadStream;
+    output: NodeJS.WriteStream;
+    question?: (query: string) => Promise<string>;
+};
+export declare function initProject(projectRoot: string, options?: InitProjectOptions): Promise<void>;
+export declare function parseInitOptions(args: string[], io?: InitPromptIo): Promise<InitProjectOptions>;
+export declare function parseInitAgent(value: string | undefined): InitAgent;
+export {};

package/dist/lib/cli/commands/scaffold.js

@@ -0,0 +1,440 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { stdin as defaultInput, stdout as defaultOutput } from "node:process";
+import { createInterface } from "node:readline/promises";
+const defaultDocsDir = "artifact-docs";
+const defaultComponentsDir = "artifact-components";
+function agentSnippetContent(options) {
+    return `# MDX Artifacts Agent Instructions
+
+Use MDX Artifacts when the user asks for an interactive report, option comparison, review handoff, temporary tool, or visual explanation page that should be authored as Markdown-native MDX.
+
+Do not use MDX Artifacts for ordinary README files, simple notes, raw HTML pages, full web apps, or cases where the user explicitly asks for plain Markdown.
+
+Authoring rules:
+
+1. Create .mdx files under ${options.docsDir}/.
+2. Keep prose in Markdown and use semantic React components as islands.
+3. Prefer high-level components from mdx-artifacts/react.
+4. Prefer MDX children for human-readable body content when a component supports it.
+5. Use props for stable ids, short labels, variants, layout controls, export values, and structured data.
+6. Do not inline bulky data in JSX props. Prefer adjacent local files when the project supports them.
+7. Local resource paths must stay inside the project root. Do not use remote URLs, ~ paths, or project-root escapes.
+8. Interactive artifacts must include ExportPanel or an equivalent export path.
+9. Run mdx-artifacts components <ComponentName> when component props are unclear.
+10. Run mdx-artifacts components --json when machine-readable component metadata is needed.
+11. Run mdx-artifacts validate <file.mdx> before build.
+12. Run mdx-artifacts validate <file.mdx> --json when structured diagnostics are useful for repairs.
+13. If validation reports diagnostics, fix errors first, review warnings, and validate again.
+14. Run mdx-artifacts build <file.mdx> to produce standalone HTML.
+
+${projectLocalComponentGuidance(options)}
+`;
+}
+function skillMarkdownContent(options) {
+    return `---
+name: mdx-artifacts
+description: Create, validate, and build Markdown-native MDX artifacts with MDX Artifacts semantic React components, structured diagnostics, and standalone HTML output.
+license: MIT
+---
+
+# MDX Artifacts Skill
+
+Use MDX Artifacts when the user asks for an interactive report, option comparison, review handoff, temporary tool, or visual explanation page that should remain readable as Markdown-native MDX.
+
+Do not use MDX Artifacts for ordinary README files, simple notes, raw HTML pages, full web apps, or cases where the user explicitly asks for plain Markdown.
+
+Authoring workflow:
+
+1. Create .mdx files under ${options.docsDir}/.
+2. Keep narrative prose in Markdown.
+3. Use semantic components from mdx-artifacts/react for workflow UI.
+4. Import only the components the artifact uses.
+5. Prefer MDX children for readable body content.
+6. Use stable id props on reviewable or stateful components.
+7. Include ExportPanel or an equivalent export path for interactive artifacts.
+8. Keep local resource paths inside the project root.
+9. Do not use remote URLs, ~ paths, or project-root escapes for local resources.
+
+Component discovery:
+
+- Run mdx-artifacts components to list available components.
+- Run mdx-artifacts components <ComponentName> when props are unclear.
+- Run mdx-artifacts components --json when machine-readable metadata is needed.
+- Do not copy component metadata into this skill. The CLI registry is the source of truth.
+
+Validation and repair loop:
+
+- Run mdx-artifacts validate <file.mdx> before build.
+- Run mdx-artifacts validate <file.mdx> --json when structured diagnostics are useful.
+- Use diagnostic code, suggestion, componentName, propName, and example fields to repair the MDX.
+- Re-run validation after each repair pass.
+- Treat errors as blockers. Review warnings before calling the artifact complete.
+
+Build:
+
+- Run mdx-artifacts build <file.mdx> to produce standalone HTML.
+- Do not call build until validation has been reviewed.
+
+Project-local components:
+
+${projectLocalComponentGuidance(options)}
+`;
+}
+function cursorRuleContent(options) {
+    return `---
+description: Use MDX Artifacts to create Markdown-native MDX artifacts with semantic React components and validation.
+alwaysApply: false
+---
+
+# MDX Artifacts Rule
+
+Use MDX Artifacts when the user asks for an interactive report, option comparison, review handoff, temporary tool, or visual explanation page that should be authored as Markdown-native MDX.
+
+Do not use MDX Artifacts for ordinary README files, simple notes, raw HTML pages, full web apps, or cases where the user explicitly asks for plain Markdown.
+
+Workflow:
+
+1. Create .mdx files under ${options.docsDir}/.
+2. Keep prose in Markdown and use semantic React components as islands.
+3. Query component metadata with mdx-artifacts components <ComponentName> instead of guessing props.
+4. Use mdx-artifacts components --json when machine-readable metadata is needed.
+5. Run mdx-artifacts validate <file.mdx> before build.
+6. Use mdx-artifacts validate <file.mdx> --json for structured repair diagnostics.
+7. Fix validation errors, review warnings, and validate again.
+8. Run mdx-artifacts build <file.mdx> only after validation has been reviewed.
+
+Local resource paths must stay inside the project root. Do not use remote URLs, ~ paths, or project-root escapes for local resources.
+
+${projectLocalComponentGuidance(options)}
+`;
+}
+export async function initProject(projectRoot, options = {}) {
+    const agent = options.agent ?? "generic";
+    const docsDir = validateProjectRelativePath(projectRoot, options.docsDir ?? defaultDocsDir, "docsDir");
+    const componentsDir = options.componentsDir
+        ? validateProjectRelativePath(projectRoot, options.componentsDir, "componentsDir")
+        : undefined;
+    const docsExamplesDir = path.join(projectRoot, docsDir, "examples");
+    const agentsDir = path.join(projectRoot, "agents");
+    const scaffoldOptions = { docsDir, componentsDir };
+    await mkdir(docsExamplesDir, { recursive: true });
+    await mkdir(agentsDir, { recursive: true });
+    if (componentsDir) {
+        await mkdir(path.join(projectRoot, componentsDir), { recursive: true });
+    }
+    await writeFile(path.join(projectRoot, "mdx-artifacts.config.mjs"), `/** @type {import("mdx-artifacts").MdxArtifactsConfig} */
+const config = {
+  docsDir: ${JSON.stringify(docsDir)},
+  outDir: "dist/artifacts",
+  includeDefaultStyles: true,
+  styles: [],
+  tailwindSources: ${formatTailwindSources(componentsDir)}
+};
+
+export default config;
+`, { flag: "wx" }).catch(ignoreExisting);
+    await writeFile(path.join(agentsDir, "AGENTS.snippet.md"), agentSnippetContent(scaffoldOptions), { flag: "wx" }).catch(ignoreExisting);
+    await writeFile(path.join(docsExamplesDir, "hello.mdx"), `import { ContentSet, ExportPanel } from "mdx-artifacts/react";
+
+# Hello Artifact
+
+<ContentSet
+  id="set.initialized"
+  title="Has MDX Artifacts been initialized?"
+  columns={2}
+>
+  <ContentSet.Item
+    id="initialized"
+    title="Initialized"
+    badge="Ready"
+    tone="positive"
+    emphasis="primary"
+    summary="Ready to continue generating artifacts."
+  >
+    - MDX source exists
+    - Export panel exists
+    - Real content still needs to be added
+  </ContentSet.Item>
+</ContentSet>
+
+<ExportPanel
+  value={{
+    recommendation: "Continue generating interactive HTML artifacts with MDX and high-level components"
+  }}
+/>
+`, { flag: "wx" }).catch(ignoreExisting);
+    await installAgentGuidance(projectRoot, agent, scaffoldOptions);
+    console.log(formatInitSummary({ agent, docsDir, componentsDir }));
+}
+export async function parseInitOptions(args, io = { input: defaultInput, output: defaultOutput }) {
+    const yes = args.includes("--yes");
+    const agentValue = readFlagValue(args, "--agent");
+    const options = {
+        yes,
+        agent: agentValue ? parseInitAgent(agentValue) : undefined,
+        docsDir: readFlagValue(args, "--docs-dir"),
+        componentsDir: readFlagValue(args, "--components-dir")
+    };
+    if (shouldPromptInitOptions(options, io)) {
+        return promptInitOptions(options, io);
+    }
+    return options;
+}
+export function parseInitAgent(value) {
+    if (!value) {
+        return "generic";
+    }
+    const agent = value.toLowerCase().trim().replace(/[\s_]+/g, "-");
+    if (agent === "generic" || agent === "codex" || agent === "claude-code" || agent === "cursor" || agent === "all") {
+        return agent;
+    }
+    throw new Error(`Unsupported init agent: ${value}. Use generic, codex, claude-code, cursor, or all.`);
+}
+async function installAgentGuidance(projectRoot, agent, options) {
+    const targets = agentGuidanceTargets(projectRoot, agent, options);
+    for (const target of targets) {
+        await mkdir(path.dirname(target.path), { recursive: true });
+        await writeFile(target.path, target.content, { flag: "wx" }).catch(ignoreExisting);
+    }
+}
+function agentGuidanceTargets(projectRoot, agent, options) {
+    const targets = [];
+    if (agent === "codex" || agent === "all") {
+        targets.push({
+            path: path.join(projectRoot, ".agents", "skills", "mdx-artifacts", "SKILL.md"),
+            content: skillMarkdownContent(options)
+        });
+    }
+    if (agent === "claude-code" || agent === "all") {
+        targets.push({
+            path: path.join(projectRoot, ".claude", "skills", "mdx-artifacts", "SKILL.md"),
+            content: skillMarkdownContent(options)
+        });
+    }
+    if (agent === "cursor" || agent === "all") {
+        targets.push({
+            path: path.join(projectRoot, ".cursor", "rules", "mdx-artifacts.mdc"),
+            content: cursorRuleContent(options)
+        });
+    }
+    return targets;
+}
+async function promptInitOptions(options, io) {
+    const rl = io.question ? undefined : createInterface({ input: io.input, output: io.output });
+    const question = io.question ?? ((query) => rl?.question(query) ?? Promise.resolve(""));
+    const style = createPromptStyle(io.output.isTTY === true && !io.question);
+    try {
+        const docsDir = options.docsDir ?? await askPathChoice(question, {
+            title: "Where should MDX artifact source files live?",
+            defaultPath: defaultDocsDir,
+            customQuestion: "Custom MDX artifact source directory:",
+            style
+        });
+        const useComponents = options.componentsDir
+            ? true
+            : await askChoice(question, {
+                title: "Use project-local React components?",
+                description: "Adds a Tailwind source directory; it does not auto-register components.",
+                defaultIndex: 0,
+                choices: [
+                    { value: "no", label: "No", aliases: ["n"] },
+                    { value: "yes", label: "Yes, choose a project-local component source directory", aliases: ["y"] }
+                ],
+                style
+            }) === "yes";
+        const componentsDir = options.componentsDir
+            ?? (useComponents
+                ? await askPathChoice(question, {
+                    title: "Where should project-local component source files live?",
+                    defaultPath: defaultComponentsDir,
+                    customQuestion: "Custom project-local component source directory:",
+                    style
+                })
+                : undefined);
+        const agent = options.agent
+            ?? parseInitAgent(await askChoice(question, {
+                title: "Install agent guidance for which tool?",
+                defaultIndex: 0,
+                choices: [
+                    { value: "generic", label: "generic" },
+                    { value: "codex", label: "codex" },
+                    { value: "claude-code", label: "claude-code", aliases: ["claude_code"] },
+                    { value: "cursor", label: "cursor" },
+                    { value: "all", label: "all" }
+                ],
+                style
+            }));
+        return { ...options, docsDir, componentsDir, agent };
+    }
+    finally {
+        rl?.close();
+    }
+}
+async function askPathChoice(question, options) {
+    const selected = await askChoice(question, {
+        title: options.title,
+        defaultIndex: 0,
+        choices: [
+            { value: "default", label: formatPromptPath(options.defaultPath) },
+            { value: "custom", label: "Enter a custom directory" }
+        ],
+        style: options.style
+    });
+    if (selected === "default") {
+        return options.defaultPath;
+    }
+    return askText(question, options.customQuestion, options.style);
+}
+async function askChoice(question, options) {
+    const prompt = formatChoicePrompt(options);
+    const answer = (await question(prompt)).trim();
+    if (!answer) {
+        return options.choices[options.defaultIndex]?.value ?? "";
+    }
+    const selectedIndex = Number.parseInt(answer, 10);
+    if (Number.isInteger(selectedIndex) && String(selectedIndex) === answer && selectedIndex >= 1 && selectedIndex <= options.choices.length) {
+        return options.choices[selectedIndex - 1].value;
+    }
+    const normalized = answer.toLowerCase();
+    const direct = options.choices.find((choice) => {
+        const aliases = choice.aliases ?? [];
+        return choice.value.toLowerCase() === normalized || choice.label.toLowerCase() === normalized || aliases.includes(normalized);
+    });
+    if (direct) {
+        return direct.value;
+    }
+    throw new Error(`Unsupported selection: ${answer}. Use 1-${options.choices.length}.`);
+}
+async function askText(question, title, style) {
+    const answer = (await question(`${style.heading(title)} `)).trim();
+    if (!answer) {
+        throw new Error(`${title} requires a value.`);
+    }
+    return answer;
+}
+function shouldPromptInitOptions(options, io) {
+    return !options.yes && io.input.isTTY === true && io.output.isTTY === true;
+}
+function readFlagValue(args, flag) {
+    const inline = args.find((arg) => arg.startsWith(`${flag}=`));
+    if (inline) {
+        return inline.slice(flag.length + 1);
+    }
+    const index = args.indexOf(flag);
+    if (index < 0) {
+        return undefined;
+    }
+    const value = args[index + 1];
+    if (!value || value.startsWith("--")) {
+        throw new Error(`mdx-artifacts init ${flag} requires a value.`);
+    }
+    return value;
+}
+function validateProjectRelativePath(projectRoot, value, fieldName) {
+    const normalized = value.trim().replace(/\\/g, "/").replace(/\/+$/g, "");
+    if (!normalized) {
+        throw new Error(`${fieldName} must not be empty.`);
+    }
+    if (path.isAbsolute(normalized) || normalized === "~" || normalized.startsWith("~/") || isUrlLike(normalized)) {
+        throw new Error(`${fieldName} must be a project-relative path.`);
+    }
+    const resolved = path.resolve(projectRoot, normalized);
+    const relative = path.relative(projectRoot, resolved);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error(`${fieldName} must stay inside the project root.`);
+    }
+    return normalized;
+}
+function isUrlLike(value) {
+    return /^[a-zA-Z][a-zA-Z\d+.-]*:\/\//.test(value) || /^(data|blob):/.test(value) || value.startsWith("//");
+}
+function formatTailwindSources(componentsDir) {
+    if (!componentsDir) {
+        return "[]";
+    }
+    return `[\n    ${JSON.stringify(`${componentsDir}/**/*.{ts,tsx}`)}\n  ]`;
+}
+function formatChoicePrompt(options) {
+    const lines = [
+        "",
+        options.style.heading(options.title),
+        options.description ? `  ${options.style.muted(options.description)}` : undefined,
+        ...options.choices.map((choice, index) => {
+            const defaultLabel = index === options.defaultIndex ? options.style.muted(" (default)") : "";
+            const description = choice.description ? options.style.muted(` - ${choice.description}`) : "";
+            return `  ${options.style.option(String(index + 1))}. ${choice.label}${defaultLabel}${description}`;
+        }),
+        `Select an option (${options.defaultIndex + 1}) `
+    ];
+    return lines.filter((line) => line !== undefined).join("\n");
+}
+function formatPromptPath(value) {
+    return `./${value.replace(/^\.?\//, "").replace(/\/+$/g, "")}/`;
+}
+function createPromptStyle(useColor) {
+    if (!useColor || process.env.NO_COLOR) {
+        return {
+            heading: identity,
+            muted: identity,
+            option: identity
+        };
+    }
+    return {
+        heading: (value) => `\x1b[1m${value}\x1b[22m`,
+        muted: (value) => `\x1b[2m${value}\x1b[22m`,
+        option: (value) => `\x1b[36m${value}\x1b[39m`
+    };
+}
+function identity(value) {
+    return value;
+}
+function formatInitSummary(options) {
+    const examplePath = `${options.docsDir}/examples/hello.mdx`;
+    const files = [
+        "  config: mdx-artifacts.config.mjs",
+        `  example: ${examplePath}`,
+        "  agent snippet: agents/AGENTS.snippet.md",
+        ...agentGuidanceSummaryFiles(options.agent),
+        ...(options.componentsDir ? [`  component source: ${options.componentsDir}/`] : [])
+    ];
+    return [
+        "MDX Artifacts initialized.",
+        "",
+        "Summary:",
+        `  docsDir: ${options.docsDir}`,
+        `  componentsDir: ${options.componentsDir ?? "none"}`,
+        `  agent: ${options.agent}`,
+        "",
+        "Files:",
+        ...files,
+        "",
+        "Next steps:",
+        `  mdx-artifacts validate ${examplePath}`,
+        `  mdx-artifacts build ${examplePath}`
+    ].join("\n");
+}
+function agentGuidanceSummaryFiles(agent) {
+    const files = [];
+    if (agent === "codex" || agent === "all") {
+        files.push("  Codex skill: .agents/skills/mdx-artifacts/SKILL.md");
+    }
+    if (agent === "claude-code" || agent === "all") {
+        files.push("  Claude Code skill: .claude/skills/mdx-artifacts/SKILL.md");
+    }
+    if (agent === "cursor" || agent === "all") {
+        files.push("  Cursor rule: .cursor/rules/mdx-artifacts.mdc");
+    }
+    return files;
+}
+function projectLocalComponentGuidance(options) {
+    if (!options.componentsDir) {
+        return "If this project later adds project-local components, choose a stable project-local component source directory and include it in tailwindSources when those files use Tailwind classes.";
+    }
+    return `Project-local component source may live under ${options.componentsDir}/. This is a source location for user-owned React components, not automatic component registration. If those files use Tailwind classes, keep ${options.componentsDir}/**/*.{ts,tsx} in tailwindSources.`;
+}
+function ignoreExisting(error) {
+    if (error.code !== "EEXIST") {
+        throw error;
+    }
+}

package/dist/lib/cli/commands/validate.d.ts

@@ -0,0 +1,18 @@
+import type { MdxArtifactsConfig } from "../config/types";
+import type { ArtifactDiagnostic } from "../diagnostics/diagnostics";
+export type { ArtifactDiagnostic } from "../diagnostics/diagnostics";
+export type ValidationResult = {
+    diagnostics: ArtifactDiagnostic[];
+    errors: string[];
+    warnings: string[];
+};
+export type ValidateMdxOptions = {
+    projectRoot?: string;
+    config?: Required<MdxArtifactsConfig>;
+};
+export declare function validateMdx(filePath: string, options?: ValidateMdxOptions): Promise<ValidationResult>;
+export declare function formatValidationJson(result: ValidationResult): {
+    ok: boolean;
+    diagnostics: ArtifactDiagnostic[];
+};
+export declare function printValidationResult(result: ValidationResult): void;