folderblog 0.0.1 → 0.0.2

package/dist/chunk-XP5J4LFJ.js

@@ -0,0 +1,127 @@
+// ../processor/src/types/config.ts
+var DEFAULT_IMAGE_SIZES = [
+  { width: 320, height: null, suffix: "xs" },
+  { width: 640, height: null, suffix: "sm" },
+  { width: 1024, height: null, suffix: "md" },
+  { width: 1920, height: null, suffix: "lg" },
+  { width: 3840, height: null, suffix: "xl" }
+];
+var withDefaults = (config) => ({
+  dir: config.dir,
+  plugins: config.plugins ?? {},
+  media: {
+    optimize: true,
+    sizes: DEFAULT_IMAGE_SIZES,
+    format: "webp",
+    quality: 80,
+    useHash: true,
+    useSharding: false,
+    pathPrefix: "/_media",
+    ...config.media
+  },
+  content: {
+    notePathPrefix: "/content",
+    processAllFiles: false,
+    ignoreFiles: ["CONTRIBUTING.md", "README.md", "readme.md", "LICENSE.md"],
+    exportPosts: false,
+    trackRelationships: false,
+    includeSlugTracking: false,
+    slugConflictStrategy: "number",
+    slugScope: "global",
+    ...config.content
+  },
+  mermaid: {
+    enabled: true,
+    strategy: "inline-svg",
+    dark: false,
+    ...config.mermaid
+  },
+  pipeline: {
+    gfm: true,
+    allowRawHtml: true,
+    syntaxHighlighting: true,
+    parseFormulas: false,
+    removeDeadLinks: false,
+    ...config.pipeline
+  },
+  debug: {
+    level: 0,
+    timing: false,
+    ...config.debug
+  },
+  cache: config.cache
+});
+var getOutputDir = (config) => config.dir.output ?? `${config.dir.input}/dist`;
+var getMediaOutputDir = (config) => {
+  const outputDir = getOutputDir(config);
+  const mediaSubdir = config.dir.mediaOutput ?? "_media";
+  return `${outputDir}/${mediaSubdir}`;
+};
+
+// ../processor/src/types/output.ts
+var OUTPUT_FILES = {
+  POSTS: "posts.json",
+  POSTS_SLUG_MAP: "posts-slug-map.json",
+  POSTS_PATH_MAP: "posts-path-map.json",
+  MEDIAS: "media.json",
+  MEDIA_PATH_MAP: "media-path-map.json",
+  GRAPH: "graph.json",
+  TEXT_EMBEDDINGS: "posts-embedding-hash-map.json",
+  IMAGE_EMBEDDINGS: "media-embedding-hash-map.json",
+  SIMILARITY: "similarity.json",
+  DATABASE: "repo.db",
+  ISSUES: "processor-issues.json"
+};
+
+// ../processor/src/types/issues.ts
+var isBrokenLinkIssue = (issue) => issue.category === "broken-link";
+var isMissingMediaIssue = (issue) => issue.category === "missing-media";
+var isMediaProcessingIssue = (issue) => issue.category === "media-processing";
+var isSlugConflictIssue = (issue) => issue.category === "slug-conflict";
+var isMermaidErrorIssue = (issue) => issue.category === "mermaid-error";
+var isEmbeddingErrorIssue = (issue) => issue.category === "embedding-error";
+var isPluginErrorIssue = (issue) => issue.category === "plugin-error";
+
+// ../processor/src/types/cache.ts
+var createEmptyCacheStats = () => ({
+  mediaCacheHits: 0,
+  mediaCacheMisses: 0,
+  textEmbeddingCacheHits: 0,
+  textEmbeddingCacheMisses: 0,
+  imageEmbeddingCacheHits: 0,
+  imageEmbeddingCacheMisses: 0
+});
+function buildMediaCacheFromManifest(medias) {
+  const cache = /* @__PURE__ */ new Map();
+  for (const media of medias) {
+    const hash = media.metadata?.hash;
+    if (!hash || !media.metadata?.width || !media.metadata?.height) continue;
+    cache.set(hash, {
+      width: media.metadata.width,
+      height: media.metadata.height,
+      format: media.metadata.format ?? "webp",
+      size: media.metadata.size ?? 0,
+      originalSize: media.metadata.originalSize,
+      outputPath: media.outputPath,
+      sizes: (media.sizes ?? []).map((s) => ({
+        suffix: s.suffix,
+        outputPath: s.outputPath,
+        width: s.width,
+        height: s.height,
+        size: s.size
+      }))
+    });
+  }
+  return cache;
+}
+function buildEmbeddingCacheFromManifest(embeddingMap) {
+  const cache = /* @__PURE__ */ new Map();
+  for (const [hash, embedding] of Object.entries(embeddingMap)) {
+    if (Array.isArray(embedding) && embedding.length > 0) {
+      cache.set(hash, embedding);
+    }
+  }
+  return cache;
+}
+
+export { DEFAULT_IMAGE_SIZES, OUTPUT_FILES, buildEmbeddingCacheFromManifest, buildMediaCacheFromManifest, createEmptyCacheStats, getMediaOutputDir, getOutputDir, isBrokenLinkIssue, isEmbeddingErrorIssue, isMediaProcessingIssue, isMermaidErrorIssue, isMissingMediaIssue, isPluginErrorIssue, isSlugConflictIssue, withDefaults };

package/dist/chunk-ZRUBI3GH.js

@@ -0,0 +1,370 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+// ../processor/src/plugins/manager.ts
+var PluginManager = class {
+  plugins = /* @__PURE__ */ new Map();
+  config;
+  outputDir;
+  issues;
+  log;
+  initialized = false;
+  constructor(config) {
+    this.config = config.config;
+    this.outputDir = config.outputDir;
+    this.issues = config.issues;
+    this.log = config.log ?? defaultLogger;
+  }
+  // --------------------------------------------------------------------------
+  // Initialization
+  // --------------------------------------------------------------------------
+  /**
+   * Initialize all plugins in dependency order
+   */
+  async initialize() {
+    if (this.initialized) {
+      this.log("Plugin manager already initialized", "warn");
+      return;
+    }
+    const pluginConfigs = this.config.plugins ?? {};
+    const allPlugins = Object.values(pluginConfigs).filter(
+      (p) => p != null
+    );
+    if (allPlugins.length === 0) {
+      this.log("No plugins configured", "debug");
+      this.initialized = true;
+      return;
+    }
+    this.log(`Initializing ${allPlugins.length} plugin(s)...`, "info");
+    const sorted = topologicalSort(allPlugins);
+    const context = this.createContext();
+    for (const plugin of sorted) {
+      await this.initializePlugin(plugin, context);
+    }
+    this.initialized = true;
+    this.log(`All plugins initialized successfully`, "info");
+  }
+  /**
+   * Initialize a single plugin
+   */
+  async initializePlugin(plugin, context) {
+    const { name, requires } = plugin;
+    this.log(`Initializing plugin: ${name}`, "debug");
+    for (const dep of requires ?? []) {
+      if (!this.plugins.has(dep)) {
+        const error = `Plugin "${name}" requires "${dep}" which is not configured`;
+        this.issues.addPluginError({
+          pluginName: name,
+          operation: "initialize",
+          errorMessage: error
+        });
+        throw new Error(error);
+      }
+    }
+    try {
+      await plugin.initialize(context);
+      this.plugins.set(name, plugin);
+      this.log(`Plugin "${name}" initialized`, "debug");
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.issues.addPluginError({
+        pluginName: name,
+        operation: "initialize",
+        errorMessage
+      });
+      throw new Error(`Failed to initialize plugin "${name}": ${errorMessage}`);
+    }
+  }
+  /**
+   * Create plugin context
+   */
+  createContext() {
+    return {
+      outputDir: this.outputDir,
+      issues: this.issues,
+      log: this.log,
+      config: this.config,
+      getPlugin: (name) => this.getPlugin(name)
+    };
+  }
+  // --------------------------------------------------------------------------
+  // Plugin Access
+  // --------------------------------------------------------------------------
+  /**
+   * Get a plugin by name
+   */
+  getPlugin(name) {
+    return this.plugins.get(name);
+  }
+  /**
+   * Get a typed plugin by its config key
+   */
+  getPluginByKey(key) {
+    return this.plugins.get(key);
+  }
+  /**
+   * Check if a plugin is available
+   */
+  hasPlugin(name) {
+    return this.plugins.has(name);
+  }
+  /**
+   * Get all initialized plugin names
+   */
+  getPluginNames() {
+    return [...this.plugins.keys()];
+  }
+  // --------------------------------------------------------------------------
+  // Cleanup
+  // --------------------------------------------------------------------------
+  /**
+   * Dispose all plugins
+   */
+  async dispose() {
+    const plugins = [...this.plugins.values()].reverse();
+    for (const plugin of plugins) {
+      if (plugin.dispose) {
+        try {
+          await plugin.dispose();
+          this.log(`Plugin "${plugin.name}" disposed`, "debug");
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          this.issues.addPluginError({
+            pluginName: plugin.name,
+            operation: "dispose",
+            errorMessage
+          });
+        }
+      }
+    }
+    this.plugins.clear();
+    this.initialized = false;
+  }
+};
+var topologicalSort = (plugins) => {
+  const pluginMap = /* @__PURE__ */ new Map();
+  const adjacency = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const plugin of plugins) {
+    pluginMap.set(plugin.name, plugin);
+    adjacency.set(plugin.name, []);
+    inDegree.set(plugin.name, 0);
+  }
+  for (const plugin of plugins) {
+    for (const dep of plugin.requires ?? []) {
+      if (adjacency.has(dep)) {
+        adjacency.get(dep).push(plugin.name);
+        inDegree.set(plugin.name, (inDegree.get(plugin.name) ?? 0) + 1);
+      }
+    }
+  }
+  const queue = [];
+  const result = [];
+  for (const [name, degree] of inDegree) {
+    if (degree === 0) {
+      queue.push(name);
+    }
+  }
+  while (queue.length > 0) {
+    const name = queue.shift();
+    const plugin = pluginMap.get(name);
+    if (plugin) {
+      result.push(plugin);
+    }
+    for (const neighbor of adjacency.get(name) ?? []) {
+      const newDegree = (inDegree.get(neighbor) ?? 0) - 1;
+      inDegree.set(neighbor, newDegree);
+      if (newDegree === 0) {
+        queue.push(neighbor);
+      }
+    }
+  }
+  if (result.length !== plugins.length) {
+    const unresolved = plugins.filter((p) => !result.includes(p)).map((p) => p.name);
+    throw new Error(
+      `Circular plugin dependency detected involving: ${unresolved.join(", ")}`
+    );
+  }
+  return result;
+};
+var defaultLogger = (message, level = "info") => {
+  const prefix = `[processor-core]`;
+  switch (level) {
+    case "error":
+      console.error(`${prefix} ERROR: ${message}`);
+      break;
+    case "warn":
+      console.warn(`${prefix} WARN: ${message}`);
+      break;
+    case "debug":
+      if (process.env.NODE_ENV === "development" || process.env.DEBUG) {
+        console.log(`${prefix} DEBUG: ${message}`);
+      }
+      break;
+    default:
+      console.log(`${prefix} ${message}`);
+  }
+};
+var createPluginManager = async (config) => {
+  const manager = new PluginManager(config);
+  await manager.initialize();
+  return manager;
+};
+var CopyOnlyImageProcessor = class {
+  name = "imageProcessor";
+  ready = false;
+  context = null;
+  async initialize(context) {
+    this.context = context;
+    this.ready = true;
+    context.log("CopyOnlyImageProcessor initialized (no optimization)", "debug");
+  }
+  isReady() {
+    return this.ready;
+  }
+  canProcess(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return [".jpg", ".jpeg", ".png", ".gif", ".webp", ".avif", ".svg"].includes(ext);
+  }
+  async getMetadata(filePath) {
+    const ext = path.extname(filePath).toLowerCase().slice(1);
+    return {
+      width: 0,
+      height: 0,
+      format: ext || "unknown"
+    };
+  }
+  async process(inputPath, outputPath, _options) {
+    await this.copy(inputPath, outputPath);
+    const stats = await fs.stat(outputPath);
+    const ext = path.extname(inputPath).toLowerCase().slice(1);
+    return {
+      outputPath,
+      width: 0,
+      height: 0,
+      format: ext || "unknown",
+      size: stats.size
+    };
+  }
+  async copy(inputPath, outputPath) {
+    await fs.mkdir(path.dirname(outputPath), { recursive: true });
+    await fs.copyFile(inputPath, outputPath);
+  }
+};
+var PassthroughMermaidRenderer = class {
+  name = "mermaidRenderer";
+  ready = false;
+  async initialize(context) {
+    this.ready = true;
+    context.log("PassthroughMermaidRenderer initialized (client-side rendering)", "debug");
+  }
+  isReady() {
+    return this.ready;
+  }
+  async isAvailable() {
+    return true;
+  }
+  async render(code, _options) {
+    return {
+      output: code,
+      strategy: "pre-mermaid"
+    };
+  }
+};
+var NoOpTextEmbedder = class {
+  name = "textEmbedder";
+  model = "none";
+  dimensions = 0;
+  ready = false;
+  async initialize(context) {
+    this.ready = true;
+    context.log("NoOpTextEmbedder initialized (embeddings disabled)", "debug");
+  }
+  isReady() {
+    return this.ready;
+  }
+  async embed(_text) {
+    return [];
+  }
+  async batchEmbed(texts) {
+    return texts.map(() => []);
+  }
+};
+var NoOpImageEmbedder = class {
+  name = "imageEmbedder";
+  model = "none";
+  dimensions = 0;
+  ready = false;
+  async initialize(context) {
+    this.ready = true;
+    context.log("NoOpImageEmbedder initialized (image embeddings disabled)", "debug");
+  }
+  isReady() {
+    return this.ready;
+  }
+  async embedFile(_filePath) {
+    return [];
+  }
+  async embedBuffer(_buffer, _mimeType) {
+    return [];
+  }
+};
+var NoOpSimilarity = class {
+  name = "similarity";
+  requires = ["textEmbedder"];
+  ready = false;
+  async initialize(context) {
+    this.ready = true;
+    context.log("NoOpSimilarity initialized (similarity disabled)", "debug");
+  }
+  isReady() {
+    return this.ready;
+  }
+  computeSimilarity(_a, _b) {
+    return 0;
+  }
+  async generateSimilarityMap(posts) {
+    return {
+      pairwiseScores: /* @__PURE__ */ new Map(),
+      similarPosts: /* @__PURE__ */ new Map(),
+      metadata: {
+        computedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        postCount: posts.length,
+        pairCount: 0
+      }
+    };
+  }
+};
+var NoOpDatabase = class {
+  name = "database";
+  ready = false;
+  async initialize(context) {
+    this.ready = true;
+    context.log("NoOpDatabase initialized (database generation disabled)", "debug");
+  }
+  isReady() {
+    return this.ready;
+  }
+  async build(_input) {
+    return {
+      databasePath: "",
+      tables: [],
+      rowCounts: {},
+      hasVectorSearch: false
+    };
+  }
+};
+var createDefaultPlugins = () => ({
+  imageProcessor: new CopyOnlyImageProcessor(),
+  mermaidRenderer: new PassthroughMermaidRenderer()
+});
+var createAllNoOpPlugins = () => ({
+  imageProcessor: new CopyOnlyImageProcessor(),
+  mermaidRenderer: new PassthroughMermaidRenderer(),
+  textEmbedder: new NoOpTextEmbedder(),
+  imageEmbedder: new NoOpImageEmbedder(),
+  similarity: new NoOpSimilarity(),
+  database: new NoOpDatabase()
+});
+
+export { CopyOnlyImageProcessor, NoOpDatabase, NoOpImageEmbedder, NoOpSimilarity, NoOpTextEmbedder, PassthroughMermaidRenderer, PluginManager, createAllNoOpPlugins, createDefaultPlugins, createPluginManager, topologicalSort };

package/dist/cli/bin.cjs

@@ -0,0 +1,25 @@
+#!/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');
+require('../chunk-OBGZSXTJ.cjs');
+var commander = require('commander');
+
+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({
+      input: opts.input,
+      output: opts.output,
+      config: opts.config
+    });
+  } catch (err) {
+    console.error("Build failed:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.parse();

package/dist/cli/bin.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli/bin.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli/bin.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { build } from '../chunk-PARGDJNY.js';
+import '../chunk-IXP35S24.js';
+import '../chunk-ZRUBI3GH.js';
+import '../chunk-XP5J4LFJ.js';
+import '../chunk-3RG5ZIWI.js';
+import { Command } from 'commander';
+
+var program = new 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 build({
+      input: opts.input,
+      output: opts.output,
+      config: opts.config
+    });
+  } catch (err) {
+    console.error("Build failed:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.parse();

package/dist/cli/index.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var chunk4ZJGUMHS_cjs = require('../chunk-4ZJGUMHS.cjs');
+require('../chunk-QA4KPPTA.cjs');
+require('../chunk-HMQIQUPB.cjs');
+require('../chunk-24MKFHML.cjs');
+require('../chunk-OBGZSXTJ.cjs');
+
+// src/cli/index.ts
+async function init(_options = {}) {
+  throw new Error("folderblog CLI is not yet implemented. Coming soon.");
+}
+async function importWp(_options) {
+  throw new Error("folderblog import-wp is not yet implemented. Coming soon.");
+}
+
+Object.defineProperty(exports, "build", {
+  enumerable: true,
+  get: function () { return chunk4ZJGUMHS_cjs.build; }
+});
+exports.importWp = importWp;
+exports.init = init;

package/dist/cli/index.d.cts

@@ -0,0 +1,39 @@
+interface BuildOptions {
+    input?: string;
+    output?: string;
+    config?: string;
+}
+declare function build(options?: BuildOptions): Promise<void>;
+
+/**
+ * folderblog CLI
+ *
+ * @example
+ * ```bash
+ * npx folderblog init
+ * npx folderblog init --template blog
+ * npx folderblog init --app nextjs
+ * npx folderblog import-wp
+ * ```
+ *
+ * @packageDocumentation
+ */
+interface InitOptions {
+    /** Template to clone: 'blog' | 'portfolio' | 'docs' */
+    template?: string;
+    /** App starter to clone: 'nextjs' | 'astro' | 'remix' */
+    app?: string;
+    /** Target directory (defaults to current directory) */
+    dir?: string;
+}
+interface ImportWpOptions {
+    /** WordPress XML export file path */
+    file: string;
+    /** Output directory for markdown files */
+    outDir?: string;
+}
+
+declare function init(_options?: InitOptions): Promise<void>;
+declare function importWp(_options: ImportWpOptions): Promise<void>;
+
+export { type BuildOptions, type ImportWpOptions, type InitOptions, build, importWp, init };

package/dist/cli/index.d.ts

@@ -0,0 +1,39 @@
+interface BuildOptions {
+    input?: string;
+    output?: string;
+    config?: string;
+}
+declare function build(options?: BuildOptions): Promise<void>;
+
+/**
+ * folderblog CLI
+ *
+ * @example
+ * ```bash
+ * npx folderblog init
+ * npx folderblog init --template blog
+ * npx folderblog init --app nextjs
+ * npx folderblog import-wp
+ * ```
+ *
+ * @packageDocumentation
+ */
+interface InitOptions {
+    /** Template to clone: 'blog' | 'portfolio' | 'docs' */
+    template?: string;
+    /** App starter to clone: 'nextjs' | 'astro' | 'remix' */
+    app?: string;
+    /** Target directory (defaults to current directory) */
+    dir?: string;
+}
+interface ImportWpOptions {
+    /** WordPress XML export file path */
+    file: string;
+    /** Output directory for markdown files */
+    outDir?: string;
+}
+
+declare function init(_options?: InitOptions): Promise<void>;
+declare function importWp(_options: ImportWpOptions): Promise<void>;
+
+export { type BuildOptions, type ImportWpOptions, type InitOptions, build, importWp, init };

package/dist/cli/index.js

@@ -0,0 +1,15 @@
+export { build } from '../chunk-PARGDJNY.js';
+import '../chunk-IXP35S24.js';
+import '../chunk-ZRUBI3GH.js';
+import '../chunk-XP5J4LFJ.js';
+import '../chunk-3RG5ZIWI.js';
+
+// src/cli/index.ts
+async function init(_options = {}) {
+  throw new Error("folderblog CLI is not yet implemented. Coming soon.");
+}
+async function importWp(_options) {
+  throw new Error("folderblog import-wp is not yet implemented. Coming soon.");
+}
+
+export { importWp, init };