folderblog 0.0.1 → 0.0.3

package/dist/chunk-6TFXNIO6.cjs

@@ -0,0 +1,495 @@
+'use strict';
+
+var fs = require('fs/promises');
+var path = require('path');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var path__default = /*#__PURE__*/_interopDefault(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__default.default.extname(filePath).toLowerCase();
+    return [".jpg", ".jpeg", ".png", ".gif", ".webp", ".avif", ".svg"].includes(ext);
+  }
+  async getMetadata(filePath) {
+    const ext = path__default.default.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__default.default.stat(outputPath);
+    const ext = path__default.default.extname(inputPath).toLowerCase().slice(1);
+    return {
+      outputPath,
+      width: 0,
+      height: 0,
+      format: ext || "unknown",
+      size: stats.size
+    };
+  }
+  async copy(inputPath, outputPath) {
+    await fs__default.default.mkdir(path__default.default.dirname(outputPath), { recursive: true });
+    await fs__default.default.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()
+});
+
+// ../processor/src/plugins/similarity.ts
+var CosineSimilarityPlugin = class {
+  name = "similarity";
+  requires = ["textEmbedder"];
+  ready = false;
+  context = null;
+  topN;
+  threshold;
+  constructor(options = {}) {
+    this.topN = options.topN ?? 5;
+    this.threshold = options.threshold ?? 0;
+  }
+  async initialize(context) {
+    this.context = context;
+    this.ready = true;
+    context.log(
+      `CosineSimilarityPlugin initialized (topN=${this.topN}, threshold=${this.threshold})`,
+      "info"
+    );
+  }
+  isReady() {
+    return this.ready;
+  }
+  async dispose() {
+    this.ready = false;
+  }
+  computeSimilarity(a, b) {
+    return cosineSimilarity(a, b);
+  }
+  async generateSimilarityMap(posts) {
+    const postsWithEmbeddings = posts.filter(
+      (p) => p.embedding && p.embedding.length > 0
+    );
+    if (postsWithEmbeddings.length < 2) {
+      this.context?.log(
+        `Skipping similarity: only ${postsWithEmbeddings.length} posts with embeddings`,
+        "debug"
+      );
+      return {
+        pairwiseScores: /* @__PURE__ */ new Map(),
+        similarPosts: /* @__PURE__ */ new Map(),
+        metadata: {
+          computedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          postCount: postsWithEmbeddings.length,
+          pairCount: 0
+        }
+      };
+    }
+    const pairwiseScores = /* @__PURE__ */ new Map();
+    const similarPosts = /* @__PURE__ */ new Map();
+    let pairCount = 0;
+    for (const post of postsWithEmbeddings) {
+      const similarities = [];
+      for (const other of postsWithEmbeddings) {
+        if (other.hash === post.hash) continue;
+        const pairKey = post.hash < other.hash ? `${post.hash}-${other.hash}` : `${other.hash}-${post.hash}`;
+        let score;
+        if (pairwiseScores.has(pairKey)) {
+          score = pairwiseScores.get(pairKey);
+        } else {
+          score = cosineSimilarity(post.embedding, other.embedding);
+          pairwiseScores.set(pairKey, score);
+          pairCount++;
+        }
+        if (score >= this.threshold) {
+          similarities.push({ hash: other.hash, score });
+        }
+      }
+      similarities.sort((a, b) => b.score - a.score);
+      const topHashes = similarities.slice(0, this.topN).map((s) => s.hash);
+      similarPosts.set(post.hash, topHashes);
+    }
+    this.context?.log(
+      `Computed similarity: ${pairCount} pairs for ${postsWithEmbeddings.length} posts`,
+      "info"
+    );
+    return {
+      pairwiseScores,
+      similarPosts,
+      metadata: {
+        computedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        postCount: postsWithEmbeddings.length,
+        pairCount
+      }
+    };
+  }
+};
+function cosineSimilarity(a, b) {
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    const aVal = a[i] ?? 0;
+    const bVal = b[i] ?? 0;
+    dot += aVal * bVal;
+    normA += aVal * aVal;
+    normB += bVal * bVal;
+  }
+  const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+  return magnitude === 0 ? 0 : dot / magnitude;
+}
+var createSimilarityPlugin = (options) => {
+  return new CosineSimilarityPlugin(options);
+};
+
+exports.CopyOnlyImageProcessor = CopyOnlyImageProcessor;
+exports.CosineSimilarityPlugin = CosineSimilarityPlugin;
+exports.NoOpDatabase = NoOpDatabase;
+exports.NoOpImageEmbedder = NoOpImageEmbedder;
+exports.NoOpSimilarity = NoOpSimilarity;
+exports.NoOpTextEmbedder = NoOpTextEmbedder;
+exports.PassthroughMermaidRenderer = PassthroughMermaidRenderer;
+exports.PluginManager = PluginManager;
+exports.cosineSimilarity = cosineSimilarity;
+exports.createAllNoOpPlugins = createAllNoOpPlugins;
+exports.createDefaultPlugins = createDefaultPlugins;
+exports.createPluginManager = createPluginManager;
+exports.createSimilarityPlugin = createSimilarityPlugin;
+exports.topologicalSort = topologicalSort;