bunki 0.5.3 → 0.6.1

package/dist/index.js

@@ -23766,9 +23766,9 @@ var require_fsevents_handler = __commonJS((exports, module) => {
       if (this.fsw.closed || this.checkIgnored(path4))
         return;
       if (event === EV_UNLINK) {
-        const isDirectory = info.type === FSEVENT_TYPE_DIRECTORY;
-        if (isDirectory || watchedDir.has(item)) {
-          this.fsw._remove(parent, item, isDirectory);
+        const isDirectory2 = info.type === FSEVENT_TYPE_DIRECTORY;
+        if (isDirectory2 || watchedDir.has(item)) {
+          this.fsw._remove(parent, item, isDirectory2);
         }
       } else {
         if (event === EV_ADD) {
@@ -24550,13 +24550,13 @@ var require_chokidar = __commonJS((exports) => {
       const it = Number.parseInt(st.toString(8)[0], 10);
       return Boolean(4 & it);
     }
-    _remove(directory, item, isDirectory) {
+    _remove(directory, item, isDirectory2) {
       const path4 = sysPath.join(directory, item);
       const fullPath = sysPath.resolve(path4);
-      isDirectory = isDirectory != null ? isDirectory : this._watched.has(path4) || this._watched.has(fullPath);
+      isDirectory2 = isDirectory2 != null ? isDirectory2 : this._watched.has(path4) || this._watched.has(fullPath);
       if (!this._throttle("remove", path4, 100))
         return;
-      if (!isDirectory && !this.options.useFsEvents && this._watched.size === 1) {
+      if (!isDirectory2 && !this.options.useFsEvents && this._watched.size === 1) {
         this.add(directory, item, true);
       }
       const wp = this._getWatchedDir(path4);
@@ -24578,7 +24578,7 @@ var require_chokidar = __commonJS((exports) => {
       }
       this._watched.delete(path4);
       this._watched.delete(fullPath);
-      const eventName = isDirectory ? EV_UNLINK_DIR : EV_UNLINK;
+      const eventName = isDirectory2 ? EV_UNLINK_DIR : EV_UNLINK;
       if (wasTracked && !this._isIgnored(path4))
         this._emit(eventName, path4);
       if (!this.options.useFsEvents) {
@@ -26000,6 +26000,7 @@ var require_slugify = __commonJS((exports, module) => {
 // src/utils/file-utils.ts
 var {Glob } = globalThis.Bun;
 import path from "path";
+import { mkdir } from "fs/promises";
 async function findFilesByPattern(pattern, directory, absolute = true) {
   const glob = new Glob(pattern);
   const files = [];
@@ -26012,8 +26013,20 @@ async function findFilesByPattern(pattern, directory, absolute = true) {
   return files;
 }
 async function fileExists(filePath) {
-  const file = Bun.file(filePath);
-  return await file.exists();
+  try {
+    const file = Bun.file(filePath);
+    return await file.exists();
+  } catch {
+    return false;
+  }
+}
+async function isDirectory(dirPath) {
+  try {
+    const stat = await Bun.file(dirPath).stat();
+    return stat?.isDirectory() ?? false;
+  } catch {
+    return false;
+  }
 }
 async function readFileAsText(filePath) {
   try {
@@ -26030,18 +26043,33 @@ async function readFileAsText(filePath) {
 function getBaseFilename(filePath, extension = ".md") {
   return path.basename(filePath, extension);
 }
-async function ensureDir(dirPath) {
+async function createDir(dirPath) {
   try {
-    await Bun.write(`${dirPath}/.gitkeep`, "");
-  } catch (error) {}
+    await mkdir(dirPath, { recursive: true });
+  } catch (error) {
+    if (await isDirectory(dirPath)) {
+      return;
+    }
+    if (await fileExists(dirPath)) {
+      throw new Error(`Path exists but is not a directory: ${dirPath}`);
+    }
+    console.error(`Error creating directory ${dirPath}:`, error);
+    throw error;
+  }
+}
+async function ensureDir(dirPath) {
+  return createDir(dirPath);
 }
 async function copyFile(sourcePath, targetPath) {
   try {
     const sourceFile = Bun.file(sourcePath);
-    const content = await sourceFile.arrayBuffer();
-    await Bun.write(targetPath, content);
+    if (!await sourceFile.exists()) {
+      throw new Error(`Source file does not exist: ${sourcePath}`);
+    }
+    await Bun.write(targetPath, sourceFile);
   } catch (error) {
     console.error(`Error copying file from ${sourcePath} to ${targetPath}:`, error);
+    throw error;
   }
 }
 
@@ -30576,7 +30604,7 @@ function getDefaultConfig() {
   return base;
 }
 async function createDefaultConfig(configPath = DEFAULT_CONFIG_FILE) {
-  if (await configExists()) {
+  if (await configExists(configPath)) {
     console.log(`Config file already exists`);
     return false;
   }
@@ -30775,15 +30803,6 @@ async function processCSS(options2) {
   } catch (error) {
     throw new Error(`CSS input file not found: ${inputPath}`);
   }
-  let postcssConfigExists = false;
-  try {
-    await fs2.promises.access(postcssConfigPath);
-    postcssConfigExists = true;
-  } catch (error) {
-    if (verbose) {
-      console.log(`PostCSS config not found at ${postcssConfigPath}, will fallback to simple copy`);
-    }
-  }
   const outputDirPath = path4.dirname(outputPath);
   await fs2.promises.mkdir(outputDirPath, { recursive: true });
   if (verbose) {
@@ -30792,71 +30811,33 @@ async function processCSS(options2) {
     console.log(`Output: ${outputPath}`);
     console.log(`Config: ${postcssConfigPath}`);
   }
-  if (!postcssConfigExists) {
-    await fs2.promises.copyFile(inputPath, outputPath);
-    if (verbose)
-      console.log("Copied CSS without PostCSS config");
-    return;
-  }
-  const runPostCSS = (configPathToUse) => {
-    return new Promise((resolve, reject) => {
-      const args = ["postcss", inputPath, "-o", outputPath];
-      if (configPathToUse && fs2.existsSync(configPathToUse)) {
-        args.push("--config", configPathToUse);
-      }
-      const postcss = spawn("bunx", args, {
-        stdio: verbose ? "inherit" : ["ignore", "pipe", "pipe"],
-        cwd: projectRoot
+  await runPostCSS(inputPath, outputPath, postcssConfigPath, projectRoot, verbose);
+}
+function runPostCSS(inputPath, outputPath, configPath, projectRoot, verbose) {
+  return new Promise((resolve, reject) => {
+    const args = ["postcss", inputPath, "-o", outputPath, "--config", configPath];
+    const postcss = spawn("bunx", args, {
+      stdio: verbose ? "inherit" : ["ignore", "pipe", "pipe"],
+      cwd: projectRoot
+    });
+    let errorOutput = "";
+    if (!verbose) {
+      postcss.stderr?.on("data", (data) => {
+        errorOutput += data.toString();
       });
-      let errorOutput = "";
-      if (!verbose) {
-        postcss.stderr?.on("data", (data) => {
-          errorOutput += data.toString();
-        });
+    }
+    postcss.on("close", (code) => {
+      if (code === 0) {
+        if (verbose)
+          console.log("\u2705 CSS build completed successfully!");
+        return resolve();
       }
-      postcss.on("close", async (code) => {
-        if (code === 0) {
-          if (verbose)
-            console.log("\u2705 CSS build completed successfully!");
-          return resolve();
-        }
-        if (/module is not defined in ES module scope/i.test(errorOutput) && configPathToUse.endsWith(".js")) {
-          const cjsPath = configPathToUse.replace(/\.js$/, ".cjs");
-          try {
-            if (!fs2.existsSync(cjsPath)) {
-              const original = await fs2.promises.readFile(configPathToUse, "utf-8");
-              await fs2.promises.writeFile(cjsPath, original, "utf-8");
-              if (verbose) {
-                console.log(`Retrying PostCSS with converted CommonJS config at ${cjsPath}`);
-              }
-            }
-            return resolve(runPostCSS(cjsPath));
-          } catch (e) {
-            if (verbose)
-              console.warn("CJS fallback failed, copying CSS.");
-            await fs2.promises.copyFile(inputPath, outputPath);
-            return resolve();
-          }
-        }
-        if (verbose) {
-          console.warn(`PostCSS failed (code ${code}). Falling back to simple copy. Error: ${errorOutput.trim()}`);
-        }
-        try {
-          await fs2.promises.copyFile(inputPath, outputPath);
-          resolve();
-        } catch (copyErr) {
-          reject(new Error(`CSS build failed with code ${code} and fallback copy also failed: ${copyErr.message}`));
-        }
-      });
-      postcss.on("error", (err) => {
-        if (verbose) {
-          console.warn(`Failed to start PostCSS process (${err.message}). Falling back to copy.`);
-        }
-        fs2.promises.copyFile(inputPath, outputPath).then(() => resolve()).catch((copyErr) => reject(new Error(`Failed to start PostCSS and fallback copy failed: ${copyErr.message}`)));
-      });
+      reject(new Error(`PostCSS failed with exit code ${code}: ${errorOutput.trim()}`));
     });
-  };
-  await runPostCSS(postcssConfigPath);
+    postcss.on("error", (err) => {
+      reject(new Error(`Failed to start PostCSS: ${err.message}`));
+    });
+  });
 }
 function getDefaultCSSConfig() {
   return {
@@ -31210,29 +31191,85 @@ class SiteGenerator {
       console.log("Copied public files to site (including extensionless & dotfiles)");
     }
   }
+  extractFirstImageUrl(html) {
+    const imgRegex = /<img[^>]+src=["']([^"']+)["']/;
+    const match = html.match(imgRegex);
+    return match ? match[1] : null;
+  }
+  escapeXml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  }
   async generateRSSFeed() {
     const posts = this.site.posts.slice(0, 15);
     const config = this.options.config;
+    const now = this.getPacificDate(new Date);
+    const latestPostDate = posts.length > 0 ? posts[0].date : now.toISOString();
+    const lastBuildDate = this.formatRSSDate(latestPostDate);
     const rssItems = posts.map((post) => {
       const postUrl = `${config.baseUrl}${post.url}`;
       const pubDate = this.formatRSSDate(post.date);
-      return `    <item>
+      const featuredImage = this.extractFirstImageUrl(post.html);
+      const categoryTags = post.tags.map((tag) => `      <category>${this.escapeXml(tag)}</category>`).join(`
+`);
+      let itemXml = `    <item>
       <title><![CDATA[${post.title}]]></title>
       <link>${postUrl}</link>
-      <guid>${postUrl}</guid>
-      <pubDate>${pubDate}</pubDate>
-      <description><![CDATA[${post.excerpt}]]></description>
+      <guid isPermaLink="true">${postUrl}</guid>
+      <pubDate>${pubDate}</pubDate>`;
+      if (config.authorEmail && config.authorName) {
+        itemXml += `
+      <author>${config.authorEmail} (${config.authorName})</author>`;
+      } else if (config.authorEmail) {
+        itemXml += `
+      <author>${config.authorEmail}</author>`;
+      }
+      itemXml += `
+      <description><![CDATA[${post.excerpt}]]></description>`;
+      if (post.tags.length > 0) {
+        itemXml += `
+${categoryTags}`;
+      }
+      itemXml += `
+      <content:encoded><![CDATA[${post.html}]]></content:encoded>`;
+      if (featuredImage) {
+        const absoluteImageUrl = featuredImage.startsWith("http") ? featuredImage : `${config.baseUrl}${featuredImage}`;
+        itemXml += `
+      <media:thumbnail url="${this.escapeXml(absoluteImageUrl)}" />`;
+      }
+      itemXml += `
     </item>`;
+      return itemXml;
     }).join(`
 `);
-    const rssContent = `<?xml version="1.0" encoding="UTF-8"?>
-<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
-  <channel>
+    let channelXml = `  <channel>
     <title><![CDATA[${config.title}]]></title>
-    <description><![CDATA[${config.description}]]></description>
     <link>${config.baseUrl}</link>
-    <atom:link href="${config.baseUrl}/feed.xml" rel="self" type="application/rss+xml" />
-    <lastBuildDate>${this.formatRSSDate(this.getPacificDate(new Date).toISOString())}</lastBuildDate>
+    <description><![CDATA[${config.description}]]></description>`;
+    const language = config.rssLanguage || "en-US";
+    channelXml += `
+    <language>${language}</language>`;
+    if (config.authorEmail && config.authorName) {
+      channelXml += `
+    <managingEditor>${config.authorEmail} (${config.authorName})</managingEditor>`;
+    } else if (config.authorEmail) {
+      channelXml += `
+    <managingEditor>${config.authorEmail}</managingEditor>`;
+    }
+    if (config.webMaster) {
+      channelXml += `
+    <webMaster>${config.webMaster}</webMaster>`;
+    }
+    if (config.copyright) {
+      channelXml += `
+    <copyright><![CDATA[${config.copyright}]]></copyright>`;
+    }
+    channelXml += `
+    <pubDate>${this.formatRSSDate(latestPostDate)}</pubDate>
+    <lastBuildDate>${lastBuildDate}</lastBuildDate>
+    <atom:link href="${config.baseUrl}/feed.xml" rel="self" type="application/rss+xml" />`;
+    const rssContent = `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:media="http://search.yahoo.com/mrss/">
+${channelXml}
 ${rssItems}
   </channel>
 </rss>`;

package/dist/site-generator.d.ts

@@ -16,6 +16,14 @@ export declare class SiteGenerator {
     private generateStylesheet;
     private fallbackCSSGeneration;
     private copyStaticAssets;
+    /**
+     * Extract the first image URL from HTML content
+     */
+    private extractFirstImageUrl;
+    /**
+     * Escape special characters in XML text to prevent CDATA issues
+     */
+    private escapeXml;
     private generateRSSFeed;
     private generateSitemap;
     private generateSitemapIndex;

package/dist/types.d.ts

@@ -58,6 +58,16 @@ export interface SiteConfig {
     maxTagsOnHomepage?: number;
     /** Optional list of domains to exclude from nofollow attribute. Links to these domains will have follow attribute. */
     noFollowExceptions?: string[];
+    /** RSS feed language code (default: en-US) */
+    rssLanguage?: string;
+    /** Author name for RSS feed (used in managingEditor field) */
+    authorName?: string;
+    /** Author email for RSS feed (used in managingEditor field) */
+    authorEmail?: string;
+    /** Web master email for RSS feed (optional) */
+    webMaster?: string;
+    /** Copyright statement for RSS feed (e.g., "Copyright © 2025 Your Site Name") */
+    copyright?: string;
     /** Additional custom configuration options */
     [key: string]: any;
 }

package/dist/utils/css-processor.d.ts

@@ -10,7 +10,8 @@ export interface CSSProcessorOptions {
     verbose?: boolean;
 }
 /**
- * Process CSS using PostCSS
+ * Process CSS using PostCSS directly
+ * Throws on error - no fallback
  */
 export declare function processCSS(options: CSSProcessorOptions): Promise<void>;
 /**

package/dist/utils/file-utils.d.ts

@@ -1,6 +1,146 @@
+/**
+ * Find files matching a glob pattern in a directory
+ * @param pattern - Glob pattern to match (e.g., "*.md", "**\/\*.ts")
+ * @param directory - Directory to search in
+ * @param absolute - Return absolute paths (default: true)
+ * @returns Array of matching file paths
+ */
 export declare function findFilesByPattern(pattern: string, directory: string, absolute?: boolean): Promise<string[]>;
+/**
+ * Check if a file exists using Bun's native API
+ *
+ * Note: BunFile.exists() only checks for files, not directories.
+ * Use isDirectory() to check if a path is a directory.
+ *
+ * @param filePath - Path to file
+ * @returns True if file exists, false if not or if path is a directory
+ *
+ * @see isDirectory - Use this to check if a path is a directory
+ */
 export declare function fileExists(filePath: string): Promise<boolean>;
+/**
+ * Check if a path is a file (not a directory)
+ * @param filePath - Path to check
+ * @returns True if path is a file
+ */
+export declare function isFile(filePath: string): Promise<boolean>;
+/**
+ * Check if a path is a directory
+ * @param dirPath - Path to check
+ * @returns True if path is a directory
+ */
+export declare function isDirectory(dirPath: string): Promise<boolean>;
+/**
+ * Read file as text using Bun's native API
+ * @param filePath - Path to file
+ * @returns File contents or null if file doesn't exist
+ */
 export declare function readFileAsText(filePath: string): Promise<string | null>;
+/**
+ * Read file as binary buffer using Bun's native API
+ * @param filePath - Path to file
+ * @returns File contents as Uint8Array or null if file doesn't exist
+ */
+export declare function readFileAsBuffer(filePath: string): Promise<Uint8Array | null>;
+/**
+ * Write text to a file
+ * @param filePath - Path to file
+ * @param content - Text content to write
+ */
+export declare function writeFile(filePath: string, content: string): Promise<void>;
+/**
+ * Write binary data to a file
+ * @param filePath - Path to file
+ * @param data - Binary data to write
+ */
+export declare function writeFileBuffer(filePath: string, data: Uint8Array | ArrayBuffer): Promise<void>;
+/**
+ * Get base filename without extension
+ * @param filePath - Path to file
+ * @param extension - Extension to remove (default: ".md")
+ * @returns Base filename
+ */
 export declare function getBaseFilename(filePath: string, extension?: string): string;
+/**
+ * Create a directory (creates parent directories if needed)
+ * @param dirPath - Path to create
+ */
+export declare function createDir(dirPath: string): Promise<void>;
+/**
+ * Ensure a directory exists (alias for createDir)
+ * @param dirPath - Path to ensure exists
+ */
 export declare function ensureDir(dirPath: string): Promise<void>;
+/**
+ * Copy a file from source to target using Bun's zero-copy file-to-file operation
+ *
+ * This uses Bun.write(target, BunFile) which performs a zero-copy operation at the kernel level.
+ * Similar to `cat source > target` but much faster than reading into memory and writing back.
+ *
+ * @param sourcePath - Source file path
+ * @param targetPath - Target file path
+ */
 export declare function copyFile(sourcePath: string, targetPath: string): Promise<void>;
+/**
+ * Delete a file using Bun's native API
+ * @param filePath - Path to file
+ */
+export declare function deleteFile(filePath: string): Promise<void>;
+/**
+ * Get file size in bytes
+ * @param filePath - Path to file
+ * @returns File size or null if file doesn't exist
+ */
+export declare function getFileSize(filePath: string): Promise<number | null>;
+/**
+ * Get file modification time
+ * @param filePath - Path to file
+ * @returns Modification time as number (ms since epoch) or null if file doesn't exist
+ */
+export declare function getFileMtime(filePath: string): Promise<number | null>;
+/**
+ * List files in a directory
+ * @param dirPath - Directory path
+ * @param recursive - Include subdirectories (default: false)
+ * @returns Array of file paths
+ */
+export declare function listDir(dirPath: string, recursive?: boolean): Promise<string[]>;
+/**
+ * Create a buffered file writer for incremental writes
+ *
+ * Useful for streaming writes or building large files incrementally without loading
+ * everything into memory. Uses a buffered sink with configurable watermark.
+ *
+ * Zero-copy streaming to disk with backpressure handling.
+ *
+ * @param filePath - Path to file
+ * @param highWaterMark - Buffer size in bytes (default: 1MB)
+ * @returns Bun file writer object with write(), flush(), and end() methods
+ *
+ * @example
+ * ```typescript
+ * const writer = createFileWriter("./output.txt");
+ * writer.write("Line 1\n");
+ * writer.write("Line 2\n");
+ * writer.write("Line 3\n");
+ * await writer.flush();
+ * await writer.end();
+ * ```
+ */
+export declare function createFileWriter(filePath: string, highWaterMark?: number): Bun.FileSink;
+/**
+ * Write a file to stdout using zero-copy streaming
+ *
+ * Similar to `cat file.txt` command. Uses Bun's zero-copy mechanism to stream
+ * the file content directly to stdout without loading into memory.
+ *
+ * @param filePath - Path to file to output
+ * @returns Promise that resolves when file is written to stdout
+ *
+ * @example
+ * ```typescript
+ * // CLI tool: output file contents
+ * await writeToStdout("./dist/index.html");
+ * ```
+ */
+export declare function writeToStdout(filePath: string): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunki",
-  "version": "0.5.3",
+  "version": "0.6.1",
   "description": "An opinionated static site generator built with Bun featuring PostCSS integration and modern web development workflows",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -84,7 +84,7 @@
     "README.md"
   ],
   "engines": {
-    "bun": ">=1.2.21",
+    "bun": ">=1.3.0",
     "node": ">=18.0.0"
   },
   "engineStrict": true,