folderblog 0.0.2 → 0.0.3

package/dist/{chunk-4ZJGUMHS.cjs → chunk-Q6EYTOTM.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkQA4KPPTA_cjs = require('./chunk-QA4KPPTA.cjs');
+var chunkJ3Y3HEBF_cjs = require('./chunk-J3Y3HEBF.cjs');
 var path = require('path');
 var url = require('url');
 var fs = require('fs');
@@ -58,7 +58,7 @@ async function build(options = {}) {
     }
   }
   console.log(`Processing: ${path.resolve(config.dir.input)}`);
-  const result = await chunkQA4KPPTA_cjs.processFolder(config);
+  const result = await chunkJ3Y3HEBF_cjs.processFolder(config);
   const errorCount = result.issues.summary?.errorCount ?? 0;
   const warningCount = result.issues.summary?.warningCount ?? 0;
   console.log(`

package/dist/chunk-UCXXH2MP.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var fs = require('fs');
+
+// src/utils.ts
+function loadJsonFile(path, fallback) {
+  if (!fs.existsSync(path)) return fallback;
+  return JSON.parse(fs.readFileSync(path, "utf-8"));
+}
+function normalizeBaseUrl(domain) {
+  let url = domain.trim();
+  if (url.endsWith("/")) url = url.slice(0, -1);
+  if (!url.startsWith("http://") && !url.startsWith("https://")) {
+    url = `https://${url}`;
+  }
+  return url;
+}
+
+exports.loadJsonFile = loadJsonFile;
+exports.normalizeBaseUrl = normalizeBaseUrl;

package/dist/chunk-XQD3UUL5.js

@@ -0,0 +1,34 @@
+// src/errors.ts
+var FolderBlogError = class extends Error {
+  /** HTTP status code if applicable */
+  status;
+  /** The URL that was requested */
+  url;
+  constructor(message, options) {
+    super(message);
+    this.name = "FolderBlogError";
+    this.status = options?.status;
+    this.url = options?.url;
+  }
+};
+var NotFoundError = class extends FolderBlogError {
+  constructor(resource, identifier, url) {
+    super(`${resource} not found: ${identifier}`, { status: 404, url });
+    this.name = "NotFoundError";
+  }
+};
+var ApiError = class extends FolderBlogError {
+  constructor(message, status, url) {
+    super(message, { status, url });
+    this.name = "ApiError";
+  }
+};
+var NetworkError = class extends FolderBlogError {
+  constructor(message, cause) {
+    super(message);
+    this.name = "NetworkError";
+    if (cause) this.cause = cause;
+  }
+};
+
+export { ApiError, FolderBlogError, NetworkError, NotFoundError };

package/dist/cli/bin.cjs

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 'use strict';
 
-var chunk4ZJGUMHS_cjs = require('../chunk-4ZJGUMHS.cjs');
-require('../chunk-QA4KPPTA.cjs');
-require('../chunk-HMQIQUPB.cjs');
-require('../chunk-24MKFHML.cjs');
+var chunkQ6EYTOTM_cjs = require('../chunk-Q6EYTOTM.cjs');
+require('../chunk-J3Y3HEBF.cjs');
+require('../chunk-2TZSVPNP.cjs');
+require('../chunk-6TFXNIO6.cjs');
 require('../chunk-OBGZSXTJ.cjs');
 var commander = require('commander');
 
@@ -12,7 +12,7 @@ var program = new commander.Command();
 program.name("folderblog").description("Folderblog CLI \u2014 process markdown content").version("0.0.1");
 program.command("build").description("Process markdown files into JSON output").option("-i, --input <dir>", "Input directory").option("-o, --output <dir>", "Output directory").option("-c, --config <path>", "Config file path (auto-detects folderblog.config.{js,mjs,ts})").action(async (opts) => {
   try {
-    await chunk4ZJGUMHS_cjs.build({
+    await chunkQ6EYTOTM_cjs.build({
       input: opts.input,
       output: opts.output,
       config: opts.config

package/dist/cli/bin.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { build } from '../chunk-PARGDJNY.js';
-import '../chunk-IXP35S24.js';
-import '../chunk-ZRUBI3GH.js';
-import '../chunk-XP5J4LFJ.js';
+import { build } from '../chunk-K76XLEC7.js';
+import '../chunk-LPPBVXJ7.js';
+import '../chunk-D26H5722.js';
+import '../chunk-B43UAOPC.js';
 import '../chunk-3RG5ZIWI.js';
 import { Command } from 'commander';
 

package/dist/cli/index.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
-var chunk4ZJGUMHS_cjs = require('../chunk-4ZJGUMHS.cjs');
-require('../chunk-QA4KPPTA.cjs');
-require('../chunk-HMQIQUPB.cjs');
-require('../chunk-24MKFHML.cjs');
+var chunkQ6EYTOTM_cjs = require('../chunk-Q6EYTOTM.cjs');
+require('../chunk-J3Y3HEBF.cjs');
+require('../chunk-2TZSVPNP.cjs');
+require('../chunk-6TFXNIO6.cjs');
 require('../chunk-OBGZSXTJ.cjs');
 
 // src/cli/index.ts
@@ -16,7 +16,7 @@ async function importWp(_options) {
 
 Object.defineProperty(exports, "build", {
   enumerable: true,
-  get: function () { return chunk4ZJGUMHS_cjs.build; }
+  get: function () { return chunkQ6EYTOTM_cjs.build; }
 });
 exports.importWp = importWp;
 exports.init = init;

package/dist/cli/index.js

@@ -1,7 +1,7 @@
-export { build } from '../chunk-PARGDJNY.js';
-import '../chunk-IXP35S24.js';
-import '../chunk-ZRUBI3GH.js';
-import '../chunk-XP5J4LFJ.js';
+export { build } from '../chunk-K76XLEC7.js';
+import '../chunk-LPPBVXJ7.js';
+import '../chunk-D26H5722.js';
+import '../chunk-B43UAOPC.js';
 import '../chunk-3RG5ZIWI.js';
 
 // src/cli/index.ts

package/dist/config-ADPY6IQS.d.cts

@@ -0,0 +1,473 @@
+import { P as ProcessingIssue, I as IssueFilterOptions, a as IssueSeverity, b as IssueReport, c as IssueSummary, d as ProcessedPost, e as ProcessedMedia, C as CacheContext } from './output-0P0br3Jc.cjs';
+
+/**
+ * Issue Collector Service
+ *
+ * Functional service for collecting and managing processing issues.
+ * Uses immutable patterns - returns new state rather than mutating.
+ */
+
+interface IssueCollectorState {
+    readonly issues: readonly ProcessingIssue[];
+    readonly startTime: string;
+}
+/**
+ * Service for collecting and managing processing issues.
+ * Provides both mutable (class-based) and functional interfaces.
+ */
+declare class IssueCollector {
+    private issues;
+    private readonly startTime;
+    constructor();
+    /**
+     * Add a generic issue
+     */
+    addIssue(issue: Omit<ProcessingIssue, 'timestamp'>): void;
+    /**
+     * Add a broken link issue
+     */
+    addBrokenLink(params: {
+        filePath: string;
+        lineNumber?: number;
+        linkText: string;
+        linkTarget: string;
+        linkType: 'wiki' | 'markdown' | 'frontmatter';
+        suggestions?: readonly string[];
+    }): void;
+    /**
+     * Add a missing media issue
+     */
+    addMissingMedia(params: {
+        filePath: string;
+        lineNumber?: number;
+        mediaPath: string;
+        referencedFrom: 'content' | 'frontmatter' | 'embed';
+        originalReference?: string;
+        module?: 'embed-media' | 'image-processor';
+    }): void;
+    /**
+     * Add a media processing error
+     */
+    addMediaProcessingError(params: {
+        filePath: string;
+        mediaPath: string;
+        operation: 'read' | 'optimize' | 'resize' | 'hash' | 'copy';
+        errorMessage: string;
+        errorCode?: string;
+    }): void;
+    /**
+     * Add a slug conflict warning
+     */
+    addSlugConflict(params: {
+        filePath: string;
+        originalSlug: string;
+        finalSlug: string;
+        conflictingFiles: readonly string[];
+    }): void;
+    /**
+     * Add a mermaid error
+     */
+    addMermaidError(params: {
+        filePath: string;
+        lineNumber?: number;
+        errorType: 'plugin-load' | 'render-fail' | 'missing-deps';
+        message: string;
+        diagramContent?: string;
+        fallback: string;
+    }): void;
+    /**
+     * Add an embedding error
+     */
+    addEmbeddingError(params: {
+        filePath?: string;
+        embeddingType: 'text' | 'image';
+        operation: 'initialize' | 'embed' | 'batch';
+        errorMessage: string;
+    }): void;
+    /**
+     * Add a plugin error
+     */
+    addPluginError(params: {
+        pluginName: string;
+        operation: 'initialize' | 'process' | 'dispose';
+        errorMessage: string;
+    }): void;
+    /**
+     * Get all issues
+     */
+    getIssues(): readonly ProcessingIssue[];
+    /**
+     * Filter issues
+     */
+    filterIssues(options: IssueFilterOptions): readonly ProcessingIssue[];
+    /**
+     * Get issue count by severity
+     */
+    getCountBySeverity(severity: IssueSeverity): number;
+    /**
+     * Check if there are any errors
+     */
+    hasErrors(): boolean;
+    /**
+     * Get summary string for console output
+     */
+    getSummaryString(): string;
+    /**
+     * Generate the final report
+     */
+    generateReport(): IssueReport;
+    /**
+     * Clear all issues (for testing)
+     */
+    clear(): void;
+}
+/**
+ * Filter issues based on criteria
+ */
+declare const filterIssues: (issues: readonly ProcessingIssue[], options: IssueFilterOptions) => readonly ProcessingIssue[];
+/**
+ * Calculate issue summary
+ */
+declare const calculateSummary: (issues: readonly ProcessingIssue[]) => IssueSummary;
+/**
+ * Generate issue report
+ */
+declare const generateIssueReport: (issues: readonly ProcessingIssue[], startTime: string, endTime: string) => IssueReport;
+
+/**
+ * Plugin system types for @repo-md/processor-core
+ *
+ * Plugins extend the processor with optional functionality like:
+ * - Image optimization (Sharp, Jimp, etc.)
+ * - Text embeddings (HuggingFace, OpenAI, Cloudflare)
+ * - Image embeddings (CLIP)
+ * - Database generation (SQLite)
+ * - Diagram rendering (Mermaid)
+ */
+
+/**
+ * Context provided to plugins during initialization
+ */
+interface PluginContext {
+    /** Output directory for generated files */
+    readonly outputDir: string;
+    /** Issue collector for reporting problems */
+    readonly issues: IssueCollector;
+    /** Logger function */
+    readonly log: (message: string, level?: LogLevel) => void;
+    /** Access to other initialized plugins */
+    readonly getPlugin: <T extends Plugin>(name: string) => T | undefined;
+    /** Current processor configuration */
+    readonly config: ProcessConfig;
+}
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+/**
+ * Base interface for all plugins
+ */
+interface Plugin {
+    /** Unique plugin identifier */
+    readonly name: string;
+    /**
+     * Names of plugins this plugin depends on.
+     * Dependencies are initialized before this plugin.
+     */
+    readonly requires?: readonly string[];
+    /** Initialize the plugin with context */
+    initialize(context: PluginContext): Promise<void>;
+    /** Check if plugin is ready to use */
+    isReady(): boolean;
+    /** Optional cleanup method */
+    dispose?(): Promise<void>;
+}
+interface ImageMetadata {
+    readonly width: number;
+    readonly height: number;
+    readonly format: string;
+}
+interface ImageProcessOptions {
+    readonly width?: number;
+    readonly height?: number;
+    readonly format: 'webp' | 'avif' | 'jpeg' | 'png';
+    readonly quality?: number;
+}
+interface ImageProcessResult {
+    readonly outputPath: string;
+    readonly width: number;
+    readonly height: number;
+    readonly format: string;
+    readonly size: number;
+}
+/**
+ * Plugin for processing and optimizing images
+ */
+interface ImageProcessorPlugin extends Plugin {
+    readonly name: 'imageProcessor';
+    /** Check if this processor can handle the file type */
+    canProcess(filePath: string): boolean;
+    /** Get image metadata without processing */
+    getMetadata(filePath: string): Promise<ImageMetadata>;
+    /** Process/optimize an image */
+    process(inputPath: string, outputPath: string, options: ImageProcessOptions): Promise<ImageProcessResult>;
+    /** Copy file without processing */
+    copy(inputPath: string, outputPath: string): Promise<void>;
+}
+/**
+ * Plugin for generating text embeddings
+ */
+interface TextEmbeddingPlugin extends Plugin {
+    readonly name: 'textEmbedder';
+    /** Model identifier (e.g., "Xenova/all-MiniLM-L6-v2") */
+    readonly model: string;
+    /** Embedding vector dimensions */
+    readonly dimensions: number;
+    /** Generate embedding for a single text */
+    embed(text: string): Promise<readonly number[]>;
+    /** Generate embeddings for multiple texts */
+    batchEmbed(texts: readonly string[]): Promise<readonly (readonly number[])[]>;
+}
+/**
+ * Plugin for generating image embeddings (e.g., CLIP)
+ */
+interface ImageEmbeddingPlugin extends Plugin {
+    readonly name: 'imageEmbedder';
+    /** Model identifier */
+    readonly model: string;
+    /** Embedding vector dimensions */
+    readonly dimensions: number;
+    /** Generate embedding from image file path */
+    embedFile(filePath: string): Promise<readonly number[]>;
+    /** Generate embedding from image buffer */
+    embedBuffer(buffer: Buffer, mimeType: string): Promise<readonly number[]>;
+}
+interface SimilarityResult {
+    /** Map of "hash1-hash2" -> similarity score */
+    readonly pairwiseScores: ReadonlyMap<string, number>;
+    /** Map of hash -> array of similar hashes (sorted by similarity) */
+    readonly similarPosts: ReadonlyMap<string, readonly string[]>;
+    /** Metadata about the computation */
+    readonly metadata: {
+        readonly computedAt: string;
+        readonly postCount: number;
+        readonly pairCount: number;
+    };
+}
+/**
+ * Plugin for computing post similarity
+ * Requires: textEmbedder
+ */
+interface SimilarityPlugin extends Plugin {
+    readonly name: 'similarity';
+    readonly requires: readonly ['textEmbedder'];
+    /** Compute cosine similarity between two embedding vectors */
+    computeSimilarity(a: readonly number[], b: readonly number[]): number;
+    /** Generate similarity data for all posts */
+    generateSimilarityMap(posts: readonly ProcessedPost[]): Promise<SimilarityResult>;
+}
+interface DatabaseBuildInput {
+    readonly posts: readonly ProcessedPost[];
+    readonly media: readonly ProcessedMedia[];
+    readonly embeddings?: ReadonlyMap<string, readonly number[]>;
+    readonly imageEmbeddings?: ReadonlyMap<string, readonly number[]>;
+}
+interface DatabaseResult {
+    readonly databasePath: string;
+    readonly tables: readonly string[];
+    readonly rowCounts: Readonly<Record<string, number>>;
+    readonly hasVectorSearch: boolean;
+}
+/**
+ * Plugin for building a database from processed content
+ */
+interface DatabasePlugin extends Plugin {
+    readonly name: 'database';
+    /** Build database from processed data */
+    build(input: DatabaseBuildInput): Promise<DatabaseResult>;
+}
+type MermaidStrategy = 'img-png' | 'img-svg' | 'inline-svg' | 'pre-mermaid';
+interface MermaidRenderOptions {
+    readonly strategy: MermaidStrategy;
+    readonly dark?: boolean;
+}
+interface MermaidResult {
+    /** Rendered output (SVG string, base64 PNG, or original code) */
+    readonly output: string;
+    /** Strategy that was actually used */
+    readonly strategy: MermaidStrategy;
+}
+/**
+ * Plugin for rendering Mermaid diagrams
+ */
+interface MermaidRendererPlugin extends Plugin {
+    readonly name: 'mermaidRenderer';
+    /** Render mermaid code to specified format */
+    render(code: string, options: MermaidRenderOptions): Promise<MermaidResult>;
+    /** Check if renderer is available (e.g., has browser) */
+    isAvailable(): Promise<boolean>;
+}
+/**
+ * Type-safe plugin configuration for ProcessConfig
+ */
+interface PluginConfig {
+    /** Image processor plugin */
+    imageProcessor?: ImageProcessorPlugin;
+    /** Text embedding plugin */
+    textEmbedder?: TextEmbeddingPlugin;
+    /** Image embedding plugin */
+    imageEmbedder?: ImageEmbeddingPlugin;
+    /** Similarity computation plugin */
+    similarity?: SimilarityPlugin;
+    /** Database generation plugin */
+    database?: DatabasePlugin;
+    /** Mermaid rendering plugin */
+    mermaidRenderer?: MermaidRendererPlugin;
+}
+/**
+ * Union type of all plugin names
+ */
+type PluginName = keyof PluginConfig;
+/**
+ * Get plugin type by name
+ */
+type PluginByName<N extends PluginName> = NonNullable<PluginConfig[N]>;
+
+/**
+ * Configuration types for @repo-md/processor-core
+ */
+
+interface ImageSizeConfig {
+    readonly width: number | null;
+    readonly height: number | null;
+    readonly suffix: string;
+}
+/** Default image sizes for responsive images */
+declare const DEFAULT_IMAGE_SIZES: readonly ImageSizeConfig[];
+interface DirectoryConfig {
+    /** Base directory for resolving relative paths (default: cwd) */
+    readonly base?: string;
+    /** Input directory */
+    readonly input: string;
+    /** Output directory for generated files (default: input + '/dist') */
+    readonly output?: string;
+    /** Media output subdirectory (default: '_media') */
+    readonly mediaOutput?: string;
+    /** Posts output subdirectory for individual post JSON files */
+    readonly postsOutput?: string;
+}
+interface MediaConfig {
+    /** Skip media processing entirely */
+    readonly skip?: boolean;
+    /** Whether to optimize images (default: true if imageProcessor plugin available) */
+    readonly optimize?: boolean;
+    /** Image sizes to generate */
+    readonly sizes?: readonly ImageSizeConfig[];
+    /** Output format for optimized images (default: 'webp') */
+    readonly format?: 'webp' | 'avif' | 'jpeg' | 'png';
+    /** Quality for lossy formats (default: 80) */
+    readonly quality?: number;
+    /** Whether to use content hash for filenames (default: true) */
+    readonly useHash?: boolean;
+    /** Whether to shard hashed files by first 2 chars (default: false) */
+    readonly useSharding?: boolean;
+    /** Domain for absolute URLs */
+    readonly domain?: string;
+    /** Asset path prefix (default: '/_media') */
+    readonly pathPrefix?: string;
+}
+interface ContentConfig {
+    /** URL prefix for notes (default: '/content') */
+    readonly notePathPrefix?: string;
+    /** Whether to process all files regardless of 'public' frontmatter */
+    readonly processAllFiles?: boolean;
+    /** Files to ignore during processing */
+    readonly ignoreFiles?: readonly string[];
+    /** Whether to export individual post JSON files */
+    readonly exportPosts?: boolean;
+    /** Whether to track relationships between posts */
+    readonly trackRelationships?: boolean;
+    /** Include slug tracking information in output */
+    readonly includeSlugTracking?: boolean;
+    /** Strategy for resolving slug conflicts */
+    readonly slugConflictStrategy?: 'number' | 'hash';
+    /** Scope for slug deduplication: 'global' (default) or 'top-folder' (per top-level directory) */
+    readonly slugScope?: 'global' | 'top-folder';
+}
+interface MermaidConfig {
+    /** Whether mermaid rendering is enabled (default: true) */
+    readonly enabled?: boolean;
+    /** Rendering strategy (default: 'inline-svg') */
+    readonly strategy?: 'img-png' | 'img-svg' | 'inline-svg' | 'pre-mermaid';
+    /** Enable dark mode support */
+    readonly dark?: boolean;
+    /** Custom mermaid configuration */
+    readonly mermaidConfig?: Readonly<Record<string, unknown>>;
+}
+interface PipelineConfig {
+    /** Enable GitHub Flavored Markdown (default: true) */
+    readonly gfm?: boolean;
+    /** Allow raw HTML in markdown (default: true) */
+    readonly allowRawHtml?: boolean;
+    /** Enable syntax highlighting for code blocks (default: true) */
+    readonly syntaxHighlighting?: boolean;
+    /** Enable LaTeX formula parsing (default: false) */
+    readonly parseFormulas?: boolean;
+    /** Remove broken/dead links instead of keeping them (default: false) */
+    readonly removeDeadLinks?: boolean;
+    /** Enable wiki-link resolution ([[Page Name]] → <a href="/slug">) (default: true) */
+    readonly wikiLinks?: boolean;
+}
+interface SimilarityConfig {
+    /** Number of similar posts to return per post (default: 5) */
+    readonly topN?: number;
+    /** Minimum similarity score threshold (default: 0) */
+    readonly threshold?: number;
+}
+interface DebugConfig {
+    /** Debug level (0=off, 1=basic, 2=verbose) */
+    readonly level?: number;
+    /** Log timing information */
+    readonly timing?: boolean;
+}
+interface ProcessConfig {
+    /** Directory configuration */
+    readonly dir: DirectoryConfig;
+    /** Plugin configuration */
+    readonly plugins?: PluginConfig;
+    /** Media processing configuration */
+    readonly media?: MediaConfig;
+    /** Content processing configuration */
+    readonly content?: ContentConfig;
+    /** Mermaid rendering configuration */
+    readonly mermaid?: MermaidConfig;
+    /** Markdown pipeline configuration */
+    readonly pipeline?: PipelineConfig;
+    /** Similarity computation configuration */
+    readonly similarity?: SimilarityConfig;
+    /** Debug configuration */
+    readonly debug?: DebugConfig;
+    /**
+     * Cache context for incremental builds.
+     * When provided, the processor will skip processing files
+     * whose content hash matches a cached entry and use cached metadata instead.
+     */
+    readonly cache?: CacheContext;
+}
+/**
+ * ProcessConfig with all fields required except cache (which remains optional)
+ */
+type ProcessConfigWithDefaults = Required<Omit<ProcessConfig, 'cache'>> & {
+    cache?: CacheContext;
+};
+/**
+ * Merge configuration with defaults
+ */
+declare const withDefaults: (config: ProcessConfig) => ProcessConfigWithDefaults;
+/**
+ * Get output directory from config
+ */
+declare const getOutputDir: (config: ProcessConfig) => string;
+/**
+ * Get media output directory from config
+ */
+declare const getMediaOutputDir: (config: ProcessConfig) => string;
+
+export { calculateSummary as A, filterIssues as B, type ContentConfig as C, DEFAULT_IMAGE_SIZES as D, generateIssueReport as E, getMediaOutputDir as F, getOutputDir as G, withDefaults as H, type ImageEmbeddingPlugin as I, type LogLevel as L, type MediaConfig as M, type PluginContext as P, type SimilarityConfig as S, type TextEmbeddingPlugin as T, type DatabaseBuildInput as a, type DatabasePlugin as b, type DatabaseResult as c, type DebugConfig as d, type DirectoryConfig as e, type ImageMetadata as f, type ImageProcessOptions as g, type ImageProcessResult as h, type ImageProcessorPlugin as i, type ImageSizeConfig as j, IssueCollector as k, type IssueCollectorState as l, type MermaidConfig as m, type MermaidRenderOptions as n, type MermaidRendererPlugin as o, type MermaidResult as p, type MermaidStrategy as q, type PipelineConfig as r, type Plugin as s, type PluginByName as t, type PluginConfig as u, type PluginName as v, type ProcessConfig as w, type ProcessConfigWithDefaults as x, type SimilarityPlugin as y, type SimilarityResult as z };