@shirokuma-library/shirokuma-docs 0.1.0-alpha.10

package/dist/md/plugins/remove-internal-links.d.ts

@@ -0,0 +1,38 @@
+import type { Root } from 'mdast';
+/**
+ * Remark plugin to remove internal markdown links
+ *
+ * Removes internal links (redundant in combined output):
+ * [See documentation](./docs/guide.md) → See documentation
+ * [Previous section](../intro.md) → Previous section
+ *
+ * Preserves external links:
+ * [GitHub](https://github.com) → kept as is
+ *
+ * Token savings: ~10-30 tokens per internal link
+ *
+ * @example
+ * ```typescript
+ * import { unified } from 'unified';
+ * import remarkParse from 'remark-parse';
+ * import remarkStringify from 'remark-stringify';
+ * import { remarkRemoveInternalLinks } from './plugins/remove-internal-links.js';
+ *
+ * const processor = unified()
+ *   .use(remarkParse)
+ *   .use(remarkRemoveInternalLinks)
+ *   .use(remarkStringify);
+ *
+ * const result = await processor.process(markdown);
+ * ```
+ */
+export declare function remarkRemoveInternalLinks(): (tree: Root) => void;
+/**
+ * Count internal markdown links without removing them
+ * Useful for analysis and reporting
+ *
+ * @param tree - Markdown AST
+ * @returns Number of internal links found
+ */
+export declare function countInternalLinks(tree: Root): number;
+//# sourceMappingURL=remove-internal-links.d.ts.map

package/dist/md/plugins/remove-internal-links.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-internal-links.d.ts","sourceRoot":"","sources":["../../../src/md/plugins/remove-internal-links.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAQ,MAAM,OAAO,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,yBAAyB,KAC/B,MAAM,IAAI,UAoBnB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAerD"}

package/dist/md/plugins/remove-internal-links.js

@@ -0,0 +1,66 @@
+import { visit, SKIP } from 'unist-util-visit';
+/**
+ * Remark plugin to remove internal markdown links
+ *
+ * Removes internal links (redundant in combined output):
+ * [See documentation](./docs/guide.md) → See documentation
+ * [Previous section](../intro.md) → Previous section
+ *
+ * Preserves external links:
+ * [GitHub](https://github.com) → kept as is
+ *
+ * Token savings: ~10-30 tokens per internal link
+ *
+ * @example
+ * ```typescript
+ * import { unified } from 'unified';
+ * import remarkParse from 'remark-parse';
+ * import remarkStringify from 'remark-stringify';
+ * import { remarkRemoveInternalLinks } from './plugins/remove-internal-links.js';
+ *
+ * const processor = unified()
+ *   .use(remarkParse)
+ *   .use(remarkRemoveInternalLinks)
+ *   .use(remarkStringify);
+ *
+ * const result = await processor.process(markdown);
+ * ```
+ */
+export function remarkRemoveInternalLinks() {
+    return (tree) => {
+        visit(tree, 'link', (node, index, parent) => {
+            const url = node.url;
+            // Check if this is an internal markdown link
+            // Patterns: ./file.md, ../path/file.md
+            const isInternalMdLink = url.match(/^\.\/[^\)]+\.md/) ||
+                url.match(/^(?:\.\.\/)+[^\)]+\.md/);
+            if (isInternalMdLink && parent && typeof index === 'number') {
+                // Replace link node with just its text children
+                // This preserves the link text but removes the link itself
+                parent.children.splice(index, 1, ...node.children);
+                // Return index to reprocess the replaced nodes
+                return [SKIP, index];
+            }
+        });
+    };
+}
+/**
+ * Count internal markdown links without removing them
+ * Useful for analysis and reporting
+ *
+ * @param tree - Markdown AST
+ * @returns Number of internal links found
+ */
+export function countInternalLinks(tree) {
+    let count = 0;
+    visit(tree, 'link', (node) => {
+        const url = node.url;
+        const isInternalMdLink = url.match(/^\.\/[^\)]+\.md/) ||
+            url.match(/^(?:\.\.\/)+[^\)]+\.md/);
+        if (isInternalMdLink) {
+            count++;
+        }
+    });
+    return count;
+}
+//# sourceMappingURL=remove-internal-links.js.map

package/dist/md/plugins/remove-internal-links.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-internal-links.js","sourceRoot":"","sources":["../../../src/md/plugins/remove-internal-links.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAG/C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,yBAAyB;IACvC,OAAO,CAAC,IAAU,EAAE,EAAE;QACpB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,IAAU,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;YAChD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC;YAErB,6CAA6C;YAC7C,uCAAuC;YACvC,MAAM,gBAAgB,GACpB,GAAG,CAAC,KAAK,CAAC,iBAAiB,CAAC;gBAC5B,GAAG,CAAC,KAAK,CAAC,wBAAwB,CAAC,CAAC;YAEtC,IAAI,gBAAgB,IAAI,MAAM,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;gBAC5D,gDAAgD;gBAChD,2DAA2D;gBAC3D,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC;gBAEnD,+CAA+C;gBAC/C,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YACvB,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAU;IAC3C,IAAI,KAAK,GAAG,CAAC,CAAC;IAEd,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,IAAU,EAAE,EAAE;QACjC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC;QACrB,MAAM,gBAAgB,GACpB,GAAG,CAAC,KAAK,CAAC,iBAAiB,CAAC;YAC5B,GAAG,CAAC,KAAK,CAAC,wBAAwB,CAAC,CAAC;QAEtC,IAAI,gBAAgB,EAAE,CAAC;YACrB,KAAK,EAAE,CAAC;QACV,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/md/plugins/strip-heading-numbers.d.ts

@@ -0,0 +1,35 @@
+import type { Root } from 'mdast';
+/**
+ * Remark plugin to strip numbering from markdown headings
+ *
+ * Removes numbers from headings for better flexibility and token efficiency:
+ * ## 1. Introduction → ## Introduction
+ * ### 2.1. Getting Started → ### Getting Started
+ *
+ * This plugin uses AST-based processing, never touching code blocks.
+ *
+ * @example
+ * ```typescript
+ * import { unified } from 'unified';
+ * import remarkParse from 'remark-parse';
+ * import remarkStringify from 'remark-stringify';
+ * import { remarkStripHeadingNumbers } from './plugins/strip-heading-numbers.js';
+ *
+ * const processor = unified()
+ *   .use(remarkParse)
+ *   .use(remarkStripHeadingNumbers)
+ *   .use(remarkStringify);
+ *
+ * const result = await processor.process(markdown);
+ * ```
+ */
+export declare function remarkStripHeadingNumbers(): (tree: Root) => void;
+/**
+ * Check if markdown contains numbered headings
+ * Useful for validation and detection
+ *
+ * @param tree - Markdown AST
+ * @returns True if numbered headings are found
+ */
+export declare function hasNumberedHeadings(tree: Root): boolean;
+//# sourceMappingURL=strip-heading-numbers.d.ts.map

package/dist/md/plugins/strip-heading-numbers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strip-heading-numbers.d.ts","sourceRoot":"","sources":["../../../src/md/plugins/strip-heading-numbers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAW,IAAI,EAAE,MAAM,OAAO,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,yBAAyB,KAC/B,MAAM,IAAI,UAcnB;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAYvD"}

package/dist/md/plugins/strip-heading-numbers.js

@@ -0,0 +1,59 @@
+import { visit } from 'unist-util-visit';
+import { toString } from 'mdast-util-to-string';
+/**
+ * Remark plugin to strip numbering from markdown headings
+ *
+ * Removes numbers from headings for better flexibility and token efficiency:
+ * ## 1. Introduction → ## Introduction
+ * ### 2.1. Getting Started → ### Getting Started
+ *
+ * This plugin uses AST-based processing, never touching code blocks.
+ *
+ * @example
+ * ```typescript
+ * import { unified } from 'unified';
+ * import remarkParse from 'remark-parse';
+ * import remarkStringify from 'remark-stringify';
+ * import { remarkStripHeadingNumbers } from './plugins/strip-heading-numbers.js';
+ *
+ * const processor = unified()
+ *   .use(remarkParse)
+ *   .use(remarkStripHeadingNumbers)
+ *   .use(remarkStringify);
+ *
+ * const result = await processor.process(markdown);
+ * ```
+ */
+export function remarkStripHeadingNumbers() {
+    return (tree) => {
+        visit(tree, 'heading', (node) => {
+            const text = toString(node);
+            // Match patterns like "1. ", "2.1. ", "3.2.1. " at the beginning
+            const match = text.match(/^(\d+(?:\.\d+)*\.)\s+(.+)$/);
+            if (match && match[2]) {
+                // Replace heading text with version without numbers
+                const cleanText = match[2];
+                node.children = [{ type: 'text', value: cleanText }];
+            }
+        });
+    };
+}
+/**
+ * Check if markdown contains numbered headings
+ * Useful for validation and detection
+ *
+ * @param tree - Markdown AST
+ * @returns True if numbered headings are found
+ */
+export function hasNumberedHeadings(tree) {
+    let found = false;
+    visit(tree, 'heading', (node) => {
+        const text = toString(node);
+        if (text.match(/^\d+(?:\.\d+)*\.\s/)) {
+            found = true;
+            return false; // Stop visiting
+        }
+    });
+    return found;
+}
+//# sourceMappingURL=strip-heading-numbers.js.map

package/dist/md/plugins/strip-heading-numbers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strip-heading-numbers.js","sourceRoot":"","sources":["../../../src/md/plugins/strip-heading-numbers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,yBAAyB;IACvC,OAAO,CAAC,IAAU,EAAE,EAAE;QACpB,KAAK,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,IAAa,EAAE,EAAE;YACvC,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;YAE5B,iEAAiE;YACjE,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,4BAA4B,CAAC,CAAC;YAEvD,IAAI,KAAK,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;gBACtB,oDAAoD;gBACpD,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;gBAC3B,IAAI,CAAC,QAAQ,GAAG,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;YACvD,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAU;IAC5C,IAAI,KAAK,GAAG,KAAK,CAAC;IAElB,KAAK,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,IAAa,EAAE,EAAE;QACvC,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;QAC5B,IAAI,IAAI,CAAC,KAAK,CAAC,oBAAoB,CAAC,EAAE,CAAC;YACrC,KAAK,GAAG,IAAI,CAAC;YACb,OAAO,KAAK,CAAC,CAAC,gBAAgB;QAChC,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/md/plugins/strip-section-meta.d.ts

@@ -0,0 +1,37 @@
+import type { Root } from 'mdast';
+/**
+ * Remark plugin to strip section-meta HTML comments from markdown
+ *
+ * Removes section-meta blocks used for development/build metadata:
+ * <!-- section-meta
+ * priority: high
+ * tokens: 450
+ * -->
+ *
+ * This plugin uses AST-based processing for safe removal.
+ *
+ * @example
+ * ```typescript
+ * import { unified } from 'unified';
+ * import remarkParse from 'remark-parse';
+ * import remarkStringify from 'remark-stringify';
+ * import { remarkStripSectionMeta } from './plugins/strip-section-meta.js';
+ *
+ * const processor = unified()
+ *   .use(remarkParse)
+ *   .use(remarkStripSectionMeta)
+ *   .use(remarkStringify);
+ *
+ * const result = await processor.process(markdown);
+ * ```
+ */
+export declare function remarkStripSectionMeta(): (tree: Root) => void;
+/**
+ * Check if markdown contains section-meta comments
+ * Useful for validation and detection
+ *
+ * @param tree - Markdown AST
+ * @returns True if section-meta comments are found
+ */
+export declare function hasSectionMeta(tree: Root): boolean;
+//# sourceMappingURL=strip-section-meta.d.ts.map

package/dist/md/plugins/strip-section-meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strip-section-meta.d.ts","sourceRoot":"","sources":["../../../src/md/plugins/strip-section-meta.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAQ,MAAM,OAAO,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,sBAAsB,KAC5B,MAAM,IAAI,UAiBnB;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAWlD"}

package/dist/md/plugins/strip-section-meta.js

@@ -0,0 +1,62 @@
+import { visit, SKIP } from 'unist-util-visit';
+/**
+ * Remark plugin to strip section-meta HTML comments from markdown
+ *
+ * Removes section-meta blocks used for development/build metadata:
+ * <!-- section-meta
+ * priority: high
+ * tokens: 450
+ * -->
+ *
+ * This plugin uses AST-based processing for safe removal.
+ *
+ * @example
+ * ```typescript
+ * import { unified } from 'unified';
+ * import remarkParse from 'remark-parse';
+ * import remarkStringify from 'remark-stringify';
+ * import { remarkStripSectionMeta } from './plugins/strip-section-meta.js';
+ *
+ * const processor = unified()
+ *   .use(remarkParse)
+ *   .use(remarkStripSectionMeta)
+ *   .use(remarkStringify);
+ *
+ * const result = await processor.process(markdown);
+ * ```
+ */
+export function remarkStripSectionMeta() {
+    return (tree) => {
+        visit(tree, 'html', (node, index, parent) => {
+            // Check if this is a section-meta comment
+            // Match both single-line and multi-line variants
+            if (node.value.match(/^<!--\s*section-meta[\s\S]*?-->$/) ||
+                node.value.trim() === '<!-- section-meta' ||
+                node.value.trim() === '-->') {
+                // Remove section-meta comment
+                if (parent && typeof index === 'number') {
+                    parent.children.splice(index, 1);
+                    return [SKIP, index];
+                }
+            }
+        });
+    };
+}
+/**
+ * Check if markdown contains section-meta comments
+ * Useful for validation and detection
+ *
+ * @param tree - Markdown AST
+ * @returns True if section-meta comments are found
+ */
+export function hasSectionMeta(tree) {
+    let found = false;
+    visit(tree, 'html', (node) => {
+        if (node.value.match(/<!--\s*section-meta/)) {
+            found = true;
+            return false; // Stop visiting
+        }
+    });
+    return found;
+}
+//# sourceMappingURL=strip-section-meta.js.map

package/dist/md/plugins/strip-section-meta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strip-section-meta.js","sourceRoot":"","sources":["../../../src/md/plugins/strip-section-meta.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAG/C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,sBAAsB;IACpC,OAAO,CAAC,IAAU,EAAE,EAAE;QACpB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,IAAU,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;YAChD,0CAA0C;YAC1C,iDAAiD;YACjD,IACE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,kCAAkC,CAAC;gBACpD,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,mBAAmB;gBACzC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,KAAK,EAC3B,CAAC;gBACD,8BAA8B;gBAC9B,IAAI,MAAM,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;oBACxC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;oBACjC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;gBACvB,CAAC;YACH,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,IAAU;IACvC,IAAI,KAAK,GAAG,KAAK,CAAC;IAElB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,IAAU,EAAE,EAAE;QACjC,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,qBAAqB,CAAC,EAAE,CAAC;YAC5C,KAAK,GAAG,IAAI,CAAC;YACb,OAAO,KAAK,CAAC,CAAC,gBAAgB;QAChC,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/md/types/config.d.ts

@@ -0,0 +1,260 @@
+import { z } from 'zod';
+/**
+ * Configuration schema for shirokuma-md.config.yaml
+ */
+export declare const ConfigSchema: z.ZodObject<{
+    project: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    directories: z.ZodObject<{
+        source: z.ZodDefault<z.ZodString>;
+        output: z.ZodDefault<z.ZodString>;
+        config: z.ZodDefault<z.ZodString>;
+        templates: z.ZodOptional<z.ZodString>;
+        schemas: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    build: z.ZodObject<{
+        default_output: z.ZodString;
+        include: z.ZodArray<z.ZodString>;
+        exclude: z.ZodArray<z.ZodString>;
+        frontmatter: z.ZodObject<{
+            strip: z.ZodDefault<z.ZodBoolean>;
+            preserve_fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+        toc: z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            depth: z.ZodDefault<z.ZodNumber>;
+            title: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>;
+        file_separator: z.ZodDefault<z.ZodString>;
+        sort: z.ZodDefault<z.ZodEnum<{
+            path: "path";
+            custom: "custom";
+        }>>;
+        strip_section_meta: z.ZodDefault<z.ZodBoolean>;
+        strip_heading_numbers: z.ZodDefault<z.ZodBoolean>;
+        optimizations: z.ZodOptional<z.ZodObject<{
+            remove_internal_links: z.ZodDefault<z.ZodBoolean>;
+            normalize_whitespace: z.ZodDefault<z.ZodBoolean>;
+            normalize_headings: z.ZodDefault<z.ZodBoolean>;
+            heading_separator: z.ZodDefault<z.ZodString>;
+            remove_comments: z.ZodDefault<z.ZodBoolean>;
+            remove_badges: z.ZodDefault<z.ZodBoolean>;
+            remove_duplicates: z.ZodDefault<z.ZodBoolean>;
+            remove_blockquotes: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    sort_order: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        pattern: z.ZodString;
+    }, z.core.$strip>>>;
+    validation: z.ZodObject<{
+        required_frontmatter: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        custom_types: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodString>]>>>;
+        forbidden_patterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            pattern: z.ZodString;
+            message: z.ZodString;
+            apply_to: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        no_internal_links: z.ZodDefault<z.ZodBoolean>;
+        template_compliance: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            check_required_sections: z.ZodDefault<z.ZodBoolean>;
+            check_variable_substitution: z.ZodDefault<z.ZodBoolean>;
+            severity: z.ZodDefault<z.ZodEnum<{
+                error: "error";
+                warning: "warning";
+                info: "info";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    lint: z.ZodObject<{
+        builtin_rules: z.ZodRecord<z.ZodString, z.ZodBoolean>;
+        file_naming: z.ZodOptional<z.ZodObject<{
+            pattern: z.ZodString;
+            message: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        rules: z.ZodOptional<z.ZodObject<{
+            consistent_structure: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                overview_location: z.ZodDefault<z.ZodEnum<{
+                    inside: "inside";
+                    outside: "outside";
+                }>>;
+                directory_threshold: z.ZodDefault<z.ZodNumber>;
+                overview_naming: z.ZodDefault<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    analyze: z.ZodOptional<z.ZodObject<{
+        dependency_detection: z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                frontmatter: "frontmatter";
+                "wiki-link": "wiki-link";
+                "markdown-link": "markdown-link";
+            }>;
+            pattern: z.ZodOptional<z.ZodString>;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        module: z.ZodString;
+        validators: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    extraction: z.ZodOptional<z.ZodObject<{
+        patterns: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+            pattern: z.ZodString;
+            group: z.ZodNumber;
+            type: z.ZodEnum<{
+                string: "string";
+                boolean: "boolean";
+                integer: "integer";
+                array: "array";
+            }>;
+            mapping: z.ZodOptional<z.ZodString>;
+            output_field: z.ZodOptional<z.ZodString>;
+            required: z.ZodDefault<z.ZodBoolean>;
+            split: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        mappings: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>;
+        templates: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>>;
+    list: z.ZodPipe<z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        default_format: z.ZodDefault<z.ZodEnum<{
+            json: "json";
+            markdown: "markdown";
+            simple: "simple";
+            tree: "tree";
+            detailed: "detailed";
+        }>>;
+        include_frontmatter: z.ZodDefault<z.ZodBoolean>;
+        include_dependencies: z.ZodDefault<z.ZodBoolean>;
+        include_stats: z.ZodDefault<z.ZodBoolean>;
+        group_by: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            layer: "layer";
+            category: "category";
+            type: "type";
+        }>>;
+        sort_by: z.ZodDefault<z.ZodEnum<{
+            title: "title";
+            path: "path";
+            layer: "layer";
+        }>>;
+    }, z.core.$strip>>>, z.ZodTransform<{
+        default_format: string;
+        include_frontmatter: boolean;
+        include_dependencies: boolean;
+        include_stats: boolean;
+        group_by: string;
+        sort_by: string;
+    }, {
+        default_format: "json" | "markdown" | "simple" | "tree" | "detailed";
+        include_frontmatter: boolean;
+        include_dependencies: boolean;
+        include_stats: boolean;
+        group_by: "none" | "layer" | "category" | "type";
+        sort_by: "title" | "path" | "layer";
+    } | null>>;
+    layer_rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    output_paths: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type Config = z.infer<typeof ConfigSchema>;
+/**
+ * Build configuration
+ */
+export interface BuildConfig {
+    output: string;
+    exclude: string[];
+    include: string[];
+    stripFrontmatter: boolean;
+    generateTOC: boolean;
+    tocDepth: number;
+    fileSeparator: string;
+    sortBy: 'path' | 'custom';
+}
+/**
+ * Build result
+ */
+export interface BuildResult {
+    fileCount: number;
+    totalSize: number;
+    buildTime: number;
+    outputPath: string;
+    tokenCount?: number;
+    stats: {
+        files: string[];
+        layers?: Record<string, number>;
+    };
+}
+/**
+ * Extraction result
+ */
+export interface ExtractionResult {
+    success: boolean;
+    inputPath: string;
+    outputPath?: string;
+    extractedFields: Record<string, any>;
+    frontmatter: Record<string, any>;
+    warnings: string[];
+    errors: string[];
+    stats: {
+        fieldsExtracted: number;
+        fieldsTotal: number;
+        extractionRate: number;
+        mappingsApplied: number;
+    };
+}
+/**
+ * Batch extraction result
+ */
+export interface BatchExtractionResult {
+    totalFiles: number;
+    successCount: number;
+    failureCount: number;
+    warningCount: number;
+    results: ExtractionResult[];
+    unmappedValues: Array<{
+        field: string;
+        value: string;
+        count: number;
+        suggestion?: string;
+    }>;
+    fieldStats: Record<string, {
+        extracted: number;
+        total: number;
+        rate: number;
+    }>;
+}
+/**
+ * File information for list command
+ */
+export interface FileInfo {
+    path: string;
+    relativePath: string;
+    title?: string;
+    description?: string;
+    layer?: number;
+    type?: string;
+    category?: string;
+    depends_on?: string[];
+    tags?: string[];
+    size: number;
+    modified?: Date;
+}
+/**
+ * List result
+ */
+export interface ListResult {
+    files: FileInfo[];
+    stats: {
+        totalFiles: number;
+        layers?: Record<string, number>;
+        types?: Record<string, number>;
+        categories?: Record<string, number>;
+    };
+}
+//# sourceMappingURL=config.d.ts.map

package/dist/md/types/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/md/types/config.ts"],"names":[],"mappings":"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"}