folderblog 0.0.1 → 0.0.2

package/README.md

@@ -1,87 +1,148 @@
 # folderblog
 
-TypeScript SDK for **[folder.blog](https://folder.blog)** — git-native blogging.
-
-Zero dependencies. Works in Node.js, Deno, Bun, and browsers.
+Official SDK for [folder.blog](https://folder.blog) — API client, server middleware, markdown processor, and CLI in one package.
 
 ## Install
 
 ```bash
-npm install folderblog
+npm i folderblog
 ```
 
-## Usage
+## API Client
+
+Read posts from any folder.blog site:
 
-```typescript
-import { folderBlog } from 'folderblog';
+```ts
+import { folderBlog } from "folderblog";
 
-const blog = folderBlog('yourname.folder.blog');
+const blog = folderBlog("yourname.folder.blog");
 
 const posts = await blog.posts.list();
-const post = await blog.posts.get('hello-world');
+const post = await blog.posts.get("hello-world");
 const site = await blog.site.get();
+const tags = await blog.tags.list();
+const rss = await blog.feed.rss();
 ```
 
-## API
+## Markdown Processor
 
-### `blog.posts.list()`
+Process a folder of markdown files into structured JSON:
 
-```typescript
-const posts = await blog.posts.list();
+```ts
+import { processFolder } from "folderblog";
+
+const result = await processFolder({
+  dir: { input: "./content", output: "./dist" },
+});
 
-posts[0].slug     // "hello-world"
-posts[0].title    // "Hello World"
-posts[0].date     // "2024-01-15"
-posts[0].tags     // ["intro"]
-posts[0].excerpt  // "My first post..."
-posts[0].url      // "/api/posts/hello-world"
+console.log(`${result.posts.length} posts processed`);
 ```
 
-### `blog.posts.get(slug)`
+Enable wiki-link resolution (Obsidian-style `[[links]]`):
+
+```ts
+const result = await processFolder({
+  dir: { input: "./vault", output: "./dist" },
+  pipeline: { wikiLinks: true },
+});
+```
+
+### Using the Processor class directly
+
+```ts
+import { Processor } from "folderblog";
 
-```typescript
-const post = await blog.posts.get('hello-world');
+const processor = new Processor({
+  config: {
+    dir: { input: "./content", output: "./dist" },
+    pipeline: { gfm: true, allowRawHtml: true },
+  },
+});
 
-post.content  // "<p>Full HTML here...</p>"
-post.raw      // "# Hello World\n\nFull markdown..."
-post.images   // ["/posts/images/photo.jpg"]
+await processor.initialize();
+const result = await processor.process();
+await processor.dispose();
 ```
 
-### `blog.site.get()`
+### Markdown utilities
 
-```typescript
-const site = await blog.site.get();
+```ts
+import { processMarkdown, parseFrontmatter, toSlug } from "folderblog";
 
-site.site        // "My Blog"
-site.variant     // "light" | "dark" | "serif" | "mono"
-site.postsCount  // 12
-site.url         // "https://yourname.folder.blog"
+const { html, frontmatter } = await processMarkdown("# Hello\n\nWorld");
+const slug = toSlug("My Blog Post"); // 'my-blog-post'
 ```
 
-## Error Handling
+## Server Middleware
 
-```typescript
-import { folderBlog, NotFoundError } from 'folderblog';
+Proxy a folder.blog into your app. Works with any Web Standard Request/Response framework:
 
-try {
-  await blog.posts.get('missing');
-} catch (error) {
-  if (error instanceof NotFoundError) {
-    // 404
-  }
-}
+```ts
+import { createHandler } from "folderblog/server";
+
+const handler = createHandler({
+  domain: "yourname.folder.blog",
+  basePath: "/blog",
+});
+
+// Hono
+app.get("/blog/*", (c) => handler(c.req.raw));
+
+// Node.js / any Web Standard server
+const response = await handler(request);
 ```
 
-## Types
+## CLI
 
-```typescript
-import type { Post, PostSummary, Site } from 'folderblog';
+```bash
+npx folderblog build                    # Auto-detect config
+npx folderblog build -i ./content       # Specify input dir
+npx folderblog build -o ./dist          # Specify output dir
+npx folderblog build -c my.config.js    # Custom config file
+```
+
+Config file (auto-detected as `folderblog.config.{js,mjs,ts}`):
+
+```js
+export default {
+  dir: { input: "./content", output: "./dist" },
+  pipeline: { gfm: true, wikiLinks: true },
+};
+```
+
+## Sub-path Imports
+
+For tree-shaking, import from specific sub-paths:
+
+```ts
+import { Processor } from "folderblog/processor";
+import { PluginManager } from "folderblog/processor/plugins";
+import type { ProcessConfig, ProcessedPost } from "folderblog/processor/types";
+import { createHandler } from "folderblog/server";
+import { build } from "folderblog/cli";
 ```
 
-## Links
+Everything is also available from the main `'folderblog'` entry point.
 
-- **Website:** [folder.blog](https://folder.blog)
-- **Docs:** [folder.blog/docs](https://folder.blog/docs)
+## Error Handling
+
+```ts
+import { folderBlog, NotFoundError, ApiError, NetworkError } from "folderblog";
+
+const blog = folderBlog("yourname.folder.blog");
+
+try {
+  const post = await blog.posts.get("missing");
+} catch (err) {
+  if (err instanceof NotFoundError) {
+    console.log("Post not found");
+  } else if (err instanceof ApiError) {
+    console.log(`API error: ${err.status}`);
+  } else if (err instanceof NetworkError) {
+    console.log("Network failure", err.cause);
+  }
+}
+```
 
 ## License
 

package/dist/chunk-24MKFHML.cjs

@@ -0,0 +1,143 @@
+'use strict';
+
+// ../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;
+}
+
+exports.DEFAULT_IMAGE_SIZES = DEFAULT_IMAGE_SIZES;
+exports.OUTPUT_FILES = OUTPUT_FILES;
+exports.buildEmbeddingCacheFromManifest = buildEmbeddingCacheFromManifest;
+exports.buildMediaCacheFromManifest = buildMediaCacheFromManifest;
+exports.createEmptyCacheStats = createEmptyCacheStats;
+exports.getMediaOutputDir = getMediaOutputDir;
+exports.getOutputDir = getOutputDir;
+exports.isBrokenLinkIssue = isBrokenLinkIssue;
+exports.isEmbeddingErrorIssue = isEmbeddingErrorIssue;
+exports.isMediaProcessingIssue = isMediaProcessingIssue;
+exports.isMermaidErrorIssue = isMermaidErrorIssue;
+exports.isMissingMediaIssue = isMissingMediaIssue;
+exports.isPluginErrorIssue = isPluginErrorIssue;
+exports.isSlugConflictIssue = isSlugConflictIssue;
+exports.withDefaults = withDefaults;

package/dist/chunk-3RG5ZIWI.js

@@ -0,0 +1,8 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export { __require };

package/dist/chunk-4ZJGUMHS.cjs

@@ -0,0 +1,78 @@
+'use strict';
+
+var chunkQA4KPPTA_cjs = require('./chunk-QA4KPPTA.cjs');
+var path = require('path');
+var url = require('url');
+var fs = require('fs');
+var child_process = require('child_process');
+
+async function loadConfig(configPath) {
+  const abs = path.resolve(configPath);
+  try {
+    const mod = await import(url.pathToFileURL(abs).href);
+    return mod.default ?? mod;
+  } catch {
+  }
+  if (abs.endsWith(".ts")) {
+    try {
+      const script = `import{pathToFileURL}from"url";const m=await import(pathToFileURL(${JSON.stringify(abs)}).href);process.stdout.write(JSON.stringify(m.default??m))`;
+      const json = child_process.execFileSync(
+        process.execPath,
+        ["--experimental-strip-types", "--input-type=module", "-e", script],
+        { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+      );
+      return JSON.parse(json);
+    } catch {
+    }
+  }
+  return null;
+}
+function resolveConfigPath(explicit) {
+  if (explicit) return explicit;
+  for (const ext of [".js", ".mjs", ".ts"]) {
+    const candidate = `./folderblog.config${ext}`;
+    if (fs.existsSync(path.resolve(candidate))) return candidate;
+  }
+  return "./folderblog.config.js";
+}
+async function build(options = {}) {
+  const configPath = resolveConfigPath(options.config);
+  let config = await loadConfig(configPath);
+  if (!config) {
+    config = {
+      dir: {
+        input: options.input ?? "./src",
+        output: options.output ?? "./dist"
+      }
+    };
+  } else {
+    if (options.input || options.output) {
+      config = {
+        ...config,
+        dir: {
+          ...config.dir,
+          ...options.input ? { input: options.input } : {},
+          ...options.output ? { output: options.output } : {}
+        }
+      };
+    }
+  }
+  console.log(`Processing: ${path.resolve(config.dir.input)}`);
+  const result = await chunkQA4KPPTA_cjs.processFolder(config);
+  const errorCount = result.issues.summary?.errorCount ?? 0;
+  const warningCount = result.issues.summary?.warningCount ?? 0;
+  console.log(`
+Done.`);
+  console.log(`  Posts:    ${result.posts.length}`);
+  console.log(`  Media:    ${result.media.length}`);
+  console.log(`  Output:   ${path.resolve(result.outputDir)}`);
+  if (errorCount > 0 || warningCount > 0) {
+    console.log(`  Errors:   ${errorCount}`);
+    console.log(`  Warnings: ${warningCount}`);
+  }
+  if (errorCount > 0) {
+    process.exit(1);
+  }
+}
+
+exports.build = build;