folderblog 0.0.1 → 0.0.3

package/dist/processor/index.d.ts

@@ -0,0 +1,495 @@
+import { w as ProcessConfig, L as LogLevel, k as IssueCollector } from '../config-Dctsdeo6.js';
+export { C as ContentConfig, D as DEFAULT_IMAGE_SIZES, a as DatabaseBuildInput, b as DatabasePlugin, c as DatabaseResult, d as DebugConfig, e as DirectoryConfig, I as ImageEmbeddingPlugin, f as ImageMetadata, g as ImageProcessOptions, h as ImageProcessResult, i as ImageProcessorPlugin, j as ImageSizeConfig, l as IssueCollectorState, M as MediaConfig, m as MermaidConfig, n as MermaidRenderOptions, o as MermaidRendererPlugin, p as MermaidResult, q as MermaidStrategy, r as PipelineConfig, s as Plugin, t as PluginByName, u as PluginConfig, P as PluginContext, v as PluginName, x as ProcessConfigWithDefaults, S as SimilarityConfig, y as SimilarityPlugin, z as SimilarityResult, T as TextEmbeddingPlugin, A as calculateSummary, B as filterIssues, E as generateIssueReport, F as getMediaOutputDir, G as getOutputDir, H as withDefaults } from '../config-Dctsdeo6.js';
+import { A as ProcessResult, d as ProcessedPost } from '../output-0P0br3Jc.js';
+export { B as BrokenLinkIssue, f as BuildReport, C as CacheContext, g as CacheStats, h as CachedMediaMetadata, i as CachedMediaSizeVariant, E as EmbeddingErrorIssue, j as EmbeddingMap, G as GraphData, k as GraphEdge, l as GraphNode, m as IssueCategory, I as IssueFilterOptions, n as IssueModule, b as IssueReport, a as IssueSeverity, c as IssueSummary, M as MediaMetadata, o as MediaPathMap, p as MediaProcessingIssue, q as MediaSizeVariant, r as MermaidErrorIssue, s as MissingMediaIssue, O as OUTPUT_FILES, t as OutputFiles, u as PathHashMap, v as PluginErrorIssue, w as PostCover, x as PostCoverError, y as PostCoverSize, z as PostMetadata, e as ProcessedMedia, P as ProcessingIssue, R as RelationshipType, S as SlugConflictIssue, D as SlugHashMap, T as TocItem, F as buildEmbeddingCacheFromManifest, H as buildMediaCacheFromManifest, J as createEmptyCacheStats, K as isBrokenLinkIssue, L as isEmbeddingErrorIssue, N as isMediaProcessingIssue, Q as isMermaidErrorIssue, U as isMissingMediaIssue, V as isPluginErrorIssue, W as isSlugConflictIssue } from '../output-0P0br3Jc.js';
+import { FileMap, LinkResolverOptions, ObsidianLink } from './types.js';
+export { BlockOnly, HeaderOnly, PageAndBlock, PageAndHeader, PageOnly } from './types.js';
+export { CopyOnlyImageProcessor, NoOpDatabase, NoOpImageEmbedder, NoOpSimilarity, NoOpTextEmbedder, PassthroughMermaidRenderer, PluginManager, PluginManagerConfig, createAllNoOpPlugins, createDefaultPlugins, createPluginManager, topologicalSort } from './plugins.js';
+export { CosineSimilarityPlugin, SimilarityPluginOptions, cosineSimilarity, createSimilarityPlugin } from '../plugins/similarity.js';
+import { Root } from 'mdast';
+import { Root as Root$1 } from 'hast';
+import { ToLink, WikiLink } from 'remark-obsidian-link';
+import { Plugin } from 'unified';
+
+/**
+ * Core Processor
+ *
+ * Main processor class that orchestrates markdown processing with plugins.
+ * This is the primary entry point for processing markdown folders.
+ */
+
+/**
+ * Options for creating a processor
+ */
+interface ProcessorOptions {
+    readonly config: ProcessConfig;
+    readonly log?: (message: string, level?: LogLevel) => void;
+}
+/**
+ * Core Processor for markdown folders
+ *
+ * Processes markdown files and media, generating structured JSON output.
+ * Uses a plugin architecture for extensibility.
+ */
+declare class Processor {
+    private readonly config;
+    private readonly pluginManager;
+    private readonly issues;
+    private readonly log;
+    private initialized;
+    constructor(options: ProcessorOptions);
+    /**
+     * Initialize the processor and plugins
+     */
+    initialize(): Promise<void>;
+    /**
+     * Dispose the processor and cleanup resources
+     */
+    dispose(): Promise<void>;
+    private resolveInputDir;
+    private resolveOutputDir;
+    /**
+     * Process the folder and generate output
+     */
+    process(): Promise<ProcessResult>;
+    private timed;
+    private processMedia;
+    private processMarkdownFiles;
+    /**
+     * Phase 1: Parse a markdown file — extract all metadata but use basic HTML.
+     * The markdown source is stored for Phase 2 re-rendering.
+     */
+    private parseMarkdownFile;
+    /**
+     * Phase 2: Build file maps from all parsed posts, then re-render each
+     * file's markdown through a pipeline that includes wiki-link resolution.
+     */
+    private renderPostsWithLinks;
+    /**
+     * Build absolute URL from relative path using domain config
+     * URL structure: {domain}/_shared/medias/{filename}
+     */
+    private buildAbsoluteUrl;
+    /**
+     * Resolve cover image from frontmatter
+     * Returns PostCover if found, PostCoverError if specified but not found, undefined if not specified
+     */
+    private resolveCover;
+    private generateEmbeddings;
+    private generateSimilarity;
+    private buildDatabase;
+    private writeOutput;
+}
+/**
+ * Create and initialize a processor
+ */
+declare const createProcessor: (config: ProcessConfig) => Promise<Processor>;
+/**
+ * Process a folder with the given configuration
+ * Convenience function that creates, processes, and disposes a processor
+ */
+declare const processFolder: (config: ProcessConfig) => Promise<ProcessResult>;
+/** @deprecated Use `processFolder` instead */
+declare const processVault: (config: ProcessConfig) => Promise<ProcessResult>;
+
+/**
+ * Markdown Processing Pipeline
+ *
+ * Core unified pipeline for converting markdown to HTML.
+ * Extensible through plugins and options.
+ */
+
+/**
+ * Options for the markdown pipeline
+ */
+interface PipelineOptions {
+    /** Enable GitHub Flavored Markdown */
+    readonly gfm?: boolean;
+    /** Allow raw HTML in markdown */
+    readonly allowRawHtml?: boolean;
+    /** Custom remark plugins to add */
+    readonly remarkPlugins?: readonly RemarkPlugin[];
+    /** Custom rehype plugins to add */
+    readonly rehypePlugins?: readonly RehypePlugin[];
+}
+/**
+ * A remark plugin with optional options
+ */
+interface RemarkPlugin {
+    readonly plugin: unknown;
+    readonly options?: unknown;
+}
+/**
+ * A rehype plugin with optional options
+ */
+interface RehypePlugin {
+    readonly plugin: unknown;
+    readonly options?: unknown;
+}
+/**
+ * Result of parsing frontmatter
+ */
+interface FrontmatterResult {
+    readonly content: string;
+    readonly data: Readonly<Record<string, unknown>>;
+}
+/**
+ * Result of processing markdown
+ */
+interface MarkdownResult {
+    /** Processed HTML content */
+    readonly html: string;
+    /** Original markdown (without frontmatter) */
+    readonly markdown: string;
+    /** Parsed frontmatter data */
+    readonly frontmatter: Readonly<Record<string, unknown>>;
+    /** MDAST root node */
+    readonly mdast: Root;
+    /** HAST root node */
+    readonly hast: Root$1;
+}
+/**
+ * Parse frontmatter from markdown content
+ */
+declare const parseFrontmatter: (content: string) => FrontmatterResult;
+/**
+ * Default pipeline options
+ */
+declare const DEFAULT_PIPELINE_OPTIONS: PipelineOptions;
+/**
+ * Create a basic markdown to HTML processor
+ * Uses 'any' for processor type to avoid complex unified generic constraints
+ */
+declare const createBasePipeline: (options?: PipelineOptions) => any;
+/**
+ * Parse markdown to MDAST
+ */
+declare const parseToMdast: (markdown: string) => Root;
+/**
+ * Convert MDAST to HAST
+ */
+declare const mdastToHast: (mdast: Root, options?: {
+    allowDangerousHtml?: boolean;
+}) => Promise<Root$1>;
+/**
+ * Convert HAST to HTML string
+ */
+declare const hastToHtml: (hast: Root$1) => string;
+/**
+ * Process markdown content to HTML with full metadata
+ */
+declare const processMarkdown: (content: string, options?: PipelineOptions) => Promise<MarkdownResult>;
+/**
+ * Extract text content from MDAST
+ */
+declare const mdastToText: (node: Root) => string;
+/**
+ * Extract first paragraph text from MDAST
+ */
+declare const extractFirstParagraph: (mdast: Root) => string;
+/**
+ * Extract headings from MDAST
+ */
+declare const extractHeadings: (mdast: Root) => readonly {
+    depth: number;
+    text: string;
+}[];
+/**
+ * Build table of contents from headings
+ */
+declare const buildToc: (headings: readonly {
+    depth: number;
+    text: string;
+}[]) => readonly {
+    depth: number;
+    text: string;
+    slug: string;
+}[];
+
+/**
+ * Word Count Utilities
+ *
+ * Functions for counting words in text content.
+ */
+/**
+ * Count words in a text string
+ * Handles multiple languages and common edge cases
+ */
+declare const countWords: (text: string) => number;
+/**
+ * Estimate reading time in minutes
+ * Uses average reading speed of 200 words per minute
+ */
+declare const estimateReadingTime: (wordCount: number, wordsPerMinute?: number) => number;
+/**
+ * Get word count and reading time for content
+ */
+declare const getContentStats: (text: string) => {
+    readonly wordCount: number;
+    readonly readingTimeMinutes: number;
+};
+
+/**
+ * Path resolution utilities for file lookups.
+ * Ported from @repo-md/repo-processor.
+ */
+interface FileItem {
+    originalPath: string;
+    fileName: string;
+}
+/**
+ * Find files by filename with case-insensitive matching
+ */
+declare function findByFileNameCaseInsensitive<T extends FileItem>(fileName: string, fileMap: Map<string, T[]>): T[];
+/**
+ * Resolve from multiple candidates, preferring files in the same directory
+ */
+declare function resolveFromCandidates<T extends FileItem>(candidates: T[], currentFilePath?: string): T | null;
+/**
+ * Create path variations for flexible matching
+ */
+declare function createPathVariations(targetPath: string, currentFilePath?: string): string[];
+/**
+ * Universal file resolver combining path and name lookups
+ */
+declare function resolveFile<T extends FileItem>(targetPath: string, options: {
+    byPath: Map<string, T>;
+    byName?: Map<string, T[]>;
+    currentFilePath?: string;
+    extensions?: string[];
+}): T | null;
+
+/**
+ * Link resolver — builds file maps and resolves wiki/markdown links.
+ * Ported from @repo-md/repo-processor, adapted for ProcessedPost.
+ */
+
+/**
+ * Build maps for efficient file lookups
+ */
+declare function buildFileMaps(posts: ProcessedPost[]): FileMap;
+/**
+ * Resolve a wikilink to a specific post
+ */
+declare function resolveWikilink(wikilink: string, fileMap: FileMap, currentFilePath: string): ProcessedPost | null;
+/**
+ * Convert a wikilink to a markdown link format
+ */
+declare function wikilinkToMarkdownLink(wikilink: string, alias: string | undefined, targetFile: ProcessedPost, options: LinkResolverOptions): {
+    url: string;
+    text: string;
+};
+/**
+ * Resolve markdown links to final URLs
+ */
+declare function resolveMarkdownLink(href: string, fileMap: FileMap, currentFilePath: string, options: LinkResolverOptions): string;
+
+/**
+ * Wiki-link remark plugin — parses [[wiki]] syntax and resolves to URLs.
+ * Combined from repo-processor's toLinkBuilder.ts + customToLink.ts.
+ */
+
+declare function wikiToObsidian(wikiLink: WikiLink): ObsidianLink;
+interface CustomToLinkOptions {
+    filesBySlug: Map<string, ProcessedPost>;
+    filesByName: Map<string, ProcessedPost>;
+    filesByPath: Map<string, ProcessedPost>;
+    filesByAlias: Map<string, ProcessedPost[]>;
+    urlPrefix: string;
+    currentFile?: ProcessedPost;
+    issueCollector?: IssueCollector;
+}
+declare function createCustomToLink(options: CustomToLinkOptions): ToLink;
+/**
+ * Resolve a markdown link path relative to the current file
+ */
+declare function resolveMarkdownLinkPath(linkPath: string, currentFilePath: string, filesByPath: Map<string, ProcessedPost>): ProcessedPost | null;
+
+/**
+ * Remark plugin to resolve markdown links with relative path resolution.
+ * Ported from @repo-md/repo-processor remarkMarkdownLinkResolver.
+ */
+
+interface RemarkMarkdownLinkResolverOptions {
+    filesByPath: Map<string, ProcessedPost>;
+    urlPrefix: string;
+    currentFilePath: string;
+}
+declare const remarkMarkdownLinkResolver: Plugin<[
+    RemarkMarkdownLinkResolverOptions
+], Root>;
+
+/**
+ * Slug Utilities
+ *
+ * Functions for generating and managing URL-friendly slugs.
+ */
+/**
+ * Convert a string to a URL-friendly slug
+ */
+declare const toSlug: (s: string) => string;
+/**
+ * Information about a generated slug
+ */
+interface SlugInfo {
+    readonly slug: string;
+    readonly originalSlug: string;
+    readonly source: 'frontmatter' | 'filename' | 'folder';
+    readonly wasModified: boolean;
+}
+/**
+ * Configuration for slug generation
+ */
+interface SlugConfig {
+    readonly conflictStrategy: 'number' | 'hash';
+}
+/**
+ * Result of slug assignment
+ */
+interface SlugAssignment {
+    readonly filePath: string;
+    readonly slug: string;
+    readonly info: SlugInfo;
+}
+/**
+ * Options for generating a base slug
+ */
+interface BaseSlugOptions {
+    readonly fileName: string;
+    readonly parentFolder?: string;
+    readonly siblingCount?: number;
+    readonly frontmatterSlug?: string;
+}
+/**
+ * Generate a base slug from file info
+ * Uses file name by default, parent folder for index.md without siblings
+ */
+declare const generateBaseSlug: (options: BaseSlugOptions) => {
+    slug: string;
+    source: SlugInfo["source"];
+};
+/**
+ * Resolve a slug conflict by adding a numeric suffix
+ */
+declare const resolveSlugConflict: (baseSlug: string, usedSlugs: ReadonlySet<string>, strategy?: "number" | "hash") => string;
+/**
+ * Immutable slug manager for tracking used slugs
+ */
+declare class SlugManager {
+    private readonly usedSlugs;
+    private readonly scopedSlugs;
+    private readonly fileSlugs;
+    private readonly strategy;
+    constructor(strategy?: 'number' | 'hash');
+    /**
+     * Check if a slug is already used
+     */
+    isUsed(slug: string): boolean;
+    /**
+     * Get slug info for a file path
+     */
+    getSlugInfo(filePath: string): SlugInfo | undefined;
+    /**
+     * Get the slug map for a given scope, creating it if needed
+     */
+    private getScopeMap;
+    /**
+     * Reserve a slug for a file
+     * @param scope - Optional scope for slug deduplication (e.g. top-level folder)
+     */
+    reserve(filePath: string, options: BaseSlugOptions, scope?: string): SlugInfo;
+    /**
+     * Get all assigned slugs
+     */
+    getAllSlugs(): ReadonlyMap<string, SlugInfo>;
+}
+
+/**
+ * Hash Utilities
+ *
+ * Functions for generating content hashes.
+ */
+/**
+ * Calculate SHA-256 hash of a content string
+ */
+declare const hashContent: (content: string) => string;
+/**
+ * Calculate SHA-256 hash of a buffer
+ */
+declare const hashBuffer: (buffer: Buffer) => string;
+/**
+ * Calculate a short hash (first N characters)
+ */
+declare const shortHash: (content: string, length?: number) => string;
+/**
+ * Create a deterministic hash from multiple values
+ */
+declare const combineHashes: (...values: readonly string[]) => string;
+
+/**
+ * File Utilities
+ *
+ * Functions for file system operations.
+ */
+/**
+ * Get file name without extension
+ */
+declare const getFileName: (filePath: string) => string;
+/**
+ * Get file extension without dot
+ */
+declare const getExtension: (filePath: string) => string;
+/**
+ * Check if a file exists
+ */
+declare const fileExists: (filePath: string) => Promise<boolean>;
+/**
+ * Ensure a directory exists
+ */
+declare const ensureDir: (dirPath: string) => Promise<void>;
+/**
+ * Write JSON to a file
+ */
+declare const writeJson: (filePath: string, data: unknown) => Promise<void>;
+/**
+ * Read JSON from a file
+ */
+declare const readJson: <T = unknown>(filePath: string) => Promise<T>;
+/**
+ * Write text to a file
+ */
+declare const writeText: (filePath: string, content: string) => Promise<void>;
+/**
+ * Read text from a file
+ */
+declare const readText: (filePath: string) => Promise<string>;
+/**
+ * Copy a file
+ */
+declare const copyFile: (src: string, dest: string) => Promise<void>;
+/**
+ * Get file stats
+ */
+declare const getStats: (filePath: string) => Promise<{
+    size: number;
+    created: Date;
+    modified: Date;
+}>;
+/**
+ * Find files matching a pattern in a directory
+ */
+declare const findFiles: (dir: string, predicate: (name: string) => boolean, recursive?: boolean) => Promise<readonly string[]>;
+/**
+ * Find markdown files in a directory
+ */
+declare const findMarkdownFiles: (dir: string, recursive?: boolean) => Promise<readonly string[]>;
+/**
+ * Get relative path from a base directory
+ */
+declare const relativePath: (from: string, to: string) => string;
+/**
+ * Normalize a path to use forward slashes
+ */
+declare const normalizePath: (p: string) => string;
+
+export { type BaseSlugOptions, type CustomToLinkOptions, DEFAULT_PIPELINE_OPTIONS, type FileItem, FileMap, type FrontmatterResult, IssueCollector, LinkResolverOptions, LogLevel, type MarkdownResult, ObsidianLink, type PipelineOptions, ProcessConfig, ProcessResult, ProcessedPost, Processor, type ProcessorOptions, type RehypePlugin, type RemarkPlugin, type SlugAssignment, type SlugConfig, SlugManager, buildFileMaps, buildToc, combineHashes, copyFile, countWords, createBasePipeline, createCustomToLink, createPathVariations, createProcessor, ensureDir, estimateReadingTime, extractFirstParagraph, extractHeadings, fileExists, findByFileNameCaseInsensitive, findFiles, findMarkdownFiles, generateBaseSlug, getContentStats, getExtension, getFileName, getStats, hashBuffer, hashContent, hastToHtml, mdastToHast, mdastToText, normalizePath, parseFrontmatter, parseToMdast, processFolder, processMarkdown, processVault, readJson, readText, relativePath, remarkMarkdownLinkResolver, resolveFile, resolveFromCandidates, resolveMarkdownLink, resolveMarkdownLinkPath, resolveSlugConflict, resolveWikilink, shortHash, toSlug, wikiToObsidian, wikilinkToMarkdownLink, writeJson, writeText };

package/dist/processor/index.js

@@ -0,0 +1,4 @@
+export { DEFAULT_PIPELINE_OPTIONS, IssueCollector, Processor, SlugManager, buildFileMaps, buildToc, calculateSummary, combineHashes, copyFile, countWords, createBasePipeline, createCustomToLink, createPathVariations, createProcessor, ensureDir, estimateReadingTime, extractFirstParagraph, extractHeadings, fileExists, filterIssues, findByFileNameCaseInsensitive, findFiles, findMarkdownFiles, generateBaseSlug, generateIssueReport, getContentStats, getExtension, getFileName, getStats, hashBuffer, hashContent, hastToHtml, mdastToHast, mdastToText, normalizePath, parseFrontmatter, parseToMdast, processFolder, processMarkdown, processVault, readJson, readText, relativePath, remarkMarkdownLinkResolver, resolveFile, resolveFromCandidates, resolveMarkdownLink, resolveMarkdownLinkPath, resolveSlugConflict, resolveWikilink, shortHash, toSlug, wikiToObsidian, wikilinkToMarkdownLink, writeJson, writeText } from '../chunk-LPPBVXJ7.js';
+export { DEFAULT_IMAGE_SIZES, OUTPUT_FILES, buildEmbeddingCacheFromManifest, buildMediaCacheFromManifest, createEmptyCacheStats, getMediaOutputDir, getOutputDir, isBrokenLinkIssue, isEmbeddingErrorIssue, isMediaProcessingIssue, isMermaidErrorIssue, isMissingMediaIssue, isPluginErrorIssue, isSlugConflictIssue, withDefaults } from '../chunk-D26H5722.js';
+export { CopyOnlyImageProcessor, CosineSimilarityPlugin, NoOpDatabase, NoOpImageEmbedder, NoOpSimilarity, NoOpTextEmbedder, PassthroughMermaidRenderer, PluginManager, cosineSimilarity, createAllNoOpPlugins, createDefaultPlugins, createPluginManager, createSimilarityPlugin, topologicalSort } from '../chunk-B43UAOPC.js';
+import '../chunk-3RG5ZIWI.js';

package/dist/processor/plugins.cjs

@@ -0,0 +1,63 @@
+'use strict';
+
+var chunk6TFXNIO6_cjs = require('../chunk-6TFXNIO6.cjs');
+require('../chunk-OBGZSXTJ.cjs');
+
+
+
+Object.defineProperty(exports, "CopyOnlyImageProcessor", {
+  enumerable: true,
+  get: function () { return chunk6TFXNIO6_cjs.CopyOnlyImageProcessor; }
+});
+Object.defineProperty(exports, "CosineSimilarityPlugin", {
+  enumerable: true,
+  get: function () { return chunk6TFXNIO6_cjs.CosineSimilarityPlugin; }
+});
+Object.defineProperty(exports, "NoOpDatabase", {
+  enumerable: true,
+  get: function () { return chunk6TFXNIO6_cjs.NoOpDatabase; }
+});
+Object.defineProperty(exports, "NoOpImageEmbedder", {
+  enumerable: true,
+  get: function () { return chunk6TFXNIO6_cjs.NoOpImageEmbedder; }
+});
+Object.defineProperty(exports, "NoOpSimilarity", {
+  enumerable: true,
+  get: function () { return chunk6TFXNIO6_cjs.NoOpSimilarity; }
+});
+Object.defineProperty(exports, "NoOpTextEmbedder", {
+  enumerable: true,
+  get: function () { return chunk6TFXNIO6_cjs.NoOpTextEmbedder; }
+});
+Object.defineProperty(exports, "PassthroughMermaidRenderer", {
+  enumerable: true,
+  get: function () { return chunk6TFXNIO6_cjs.PassthroughMermaidRenderer; }
+});
+Object.defineProperty(exports, "PluginManager", {
+  enumerable: true,
+  get: function () { return chunk6TFXNIO6_cjs.PluginManager; }
+});
+Object.defineProperty(exports, "cosineSimilarity", {
+  enumerable: true,
+  get: function () { return chunk6TFXNIO6_cjs.cosineSimilarity; }
+});
+Object.defineProperty(exports, "createAllNoOpPlugins", {
+  enumerable: true,
+  get: function () { return chunk6TFXNIO6_cjs.createAllNoOpPlugins; }
+});
+Object.defineProperty(exports, "createDefaultPlugins", {
+  enumerable: true,
+  get: function () { return chunk6TFXNIO6_cjs.createDefaultPlugins; }
+});
+Object.defineProperty(exports, "createPluginManager", {
+  enumerable: true,
+  get: function () { return chunk6TFXNIO6_cjs.createPluginManager; }
+});
+Object.defineProperty(exports, "createSimilarityPlugin", {
+  enumerable: true,
+  get: function () { return chunk6TFXNIO6_cjs.createSimilarityPlugin; }
+});
+Object.defineProperty(exports, "topologicalSort", {
+  enumerable: true,
+  get: function () { return chunk6TFXNIO6_cjs.topologicalSort; }
+});