bunki 0.2.2 → 0.2.5

package/README.md

@@ -16,11 +16,11 @@ Bunki is an opinionated static site generator built with Bun. It's designed for
 - Sitemap generation
 - Local development server
 - Simple CLI interface
-- Cloud image uploading via Cloudflare R2
+- Cloud image uploading (Cloudflare R2, S3)
 
 ## Installation
 
-> **IMPORTANT**: Bunki requires Bun v1.2.12 or later as its runtime. It is not compatible with Node.js and will not work with npm, yarn, or pnpm.
+> **IMPORTANT**: Bunki requires Bun v1.2.19 or later as its runtime. It is not compatible with Node.js.
 
 ### Prerequisites
 
@@ -28,11 +28,11 @@ Bunki is an opinionated static site generator built with Bun. It's designed for
 # Install Bun if you don't have it
 curl -fsSL https://bun.sh/install | bash
 
-# Verify Bun version (should be 1.2.12 or later)
+# Verify Bun version (should be 1.2.19 or later)
 bun --version
 ```
 
-### From bun
+### Installation Options
 
 ```bash
 # Install globally
@@ -40,22 +40,12 @@ bun install -g bunki
 
 # Or install locally in your project
 bun install bunki
-```
-
-### From GitHub
 
-```bash
-# Clone the repository
+# Or from GitHub
 git clone git@github.com:kahwee/bunki.git
 cd bunki
-
-# Install dependencies
 bun install
-
-# Build the project
 bun run build
-
-# Link for local development
 bun link
 ```
 
@@ -68,13 +58,6 @@ bun link
 bunki init
 ```
 
-This will:
-
-- Create a default configuration file (`bunki.config.ts`)
-- Set up the required directory structure
-- Create default templates
-- Add a sample blog post
-
 ### Add Content
 
 Create markdown files in the `content` directory with frontmatter:
@@ -82,7 +65,7 @@ Create markdown files in the `content` directory with frontmatter:
 ```markdown
 ---
 title: Your Post Title
-date: 2025-01-01T12:00:00Z
+date: 2025-01-01T09:00:00-07:00
 tags: [tag1, tag2]
 ---
 
@@ -109,8 +92,6 @@ bunki generate
 bunki serve
 ```
 
-Then visit http://localhost:3000 in your browser.
-
 ## Configuration
 
 The `bunki.config.ts` file contains the configuration for your site:
@@ -130,92 +111,51 @@ export default function (): SiteConfig {
     domain: "blog",
     // S3 upload configuration
     s3: {
-      accessKeyId: process.env.S3_ACCESS_KEY_ID || "",
-      secretAccessKey: process.env.S3_SECRET_ACCESS_KEY || "",
-      bucket: process.env.S3_BUCKET || "",
-      endpoint: process.env.S3_ENDPOINT,
-      region: process.env.S3_REGION || "auto",
+      accessKeyId: process.env.R2_ACCESS_KEY_ID || "",
+      secretAccessKey: process.env.R2_SECRET_ACCESS_KEY || "",
+      bucket: process.env.R2_BUCKET || "",
+      endpoint: process.env.R2_ENDPOINT,
+      region: process.env.R2_REGION || "auto",
+      publicUrl: process.env.R2_PUBLIC_URL || "",
     },
   };
 }
 ```
 
-### Image Upload Configuration
-
-Bunki supports uploading images to cloud storage with two implementation options:
+## Image Upload Configuration
 
-1. **AWS SDK-based uploader** (type: `r2`) - Uses the AWS SDK for S3-compatible services
-2. **Bun native S3 uploader** (type: `bun-s3` or `bun-r2`) - Uses Bun's built-in S3 API for better performance
+Bunki uses Bun's native S3 API for efficient image uploads to S3-compatible services like Cloudflare R2.
 
-To configure image uploading to Cloudflare R2 or any S3-compatible service, set the following environment variables:
+Configure image uploading by setting environment variables:
 
 ```
-R2_ACCOUNT_ID=your-cloudflare-account-id
-R2_ACCESS_KEY_ID=your-r2-access-key-id
-R2_SECRET_ACCESS_KEY=your-r2-secret-access-key
-R2_PUBLIC_URL=https://your-r2-public-url.com
+R2_ACCOUNT_ID=your-account-id
+R2_ACCESS_KEY_ID=your-access-key
+R2_SECRET_ACCESS_KEY=your-secret-key
+R2_BUCKET=your-bucket
+R2_PUBLIC_URL=https://your-public-url.com
 ```
 
-You can add these to a `.env` file in your project root. The bucket name will be automatically generated from your domain name (e.g., `example.com` becomes `example-com`).
-
-For domain-specific custom domains, you can optionally set:
+For domain-specific custom domains:
 
 ```
 R2_CUSTOM_DOMAIN_EXAMPLE_COM=cdn.example.com
 ```
 
-This will use `https://cdn.example.com/` as the base URL for all uploaded images.
-
-#### Selecting an Uploader Implementation
-
-When using the CLI, specify the type with the `--type` option:
+### Image Upload Commands
 
 ```bash
-# Use AWS SDK-based uploader (default)
-bunki images:push --type r2
-
-# Use Bun's native S3 API (faster performance)
-bunki images:push --type bun-s3
-# or
-bunki images:push --type bun-r2
-```
-
-The Bun native S3 uploader provides better performance and reduced memory usage, especially for large files.
-
-#### Large File Uploads
-
-For very large files, the Bun native S3 uploader (`bun-s3` or `bun-r2`) supports efficient chunked uploads using streaming. This is particularly useful for video files, high-resolution images, or other large assets.
-
-When using the Bun native implementation programmatically, you can leverage the multipart upload functionality:
+# Upload all images
+bunki images:push
 
-```javascript
-import { createUploader } from "bunki";
+# Specify a different images directory
+bunki images:push --images path/to/images
 
-// Create uploader instance
-const uploader = createUploader("bun-s3", uploaderConfig);
-
-// Option 1: Use the high-level large file upload method
-const fileUrl = await uploader.uploadLargeFile(
-  "/path/to/large-video.mp4",
-  "videos/large-video.mp4",
-);
-
-// Option 2: For more control, use the streaming writer
-const writer = uploader.getWriterForLargeFile(
-  "videos/large-video.mp4",
-  "video/mp4",
-);
-
-// Write data in chunks
-for (let i = 0; i < 100; i++) {
-  writer.write(chunk); // chunk can be Uint8Array, Buffer, string, etc.
-}
-
-// Finalize the upload
-await writer.end();
+# Output URL mapping to a JSON file
+bunki images:push --output-json image-urls.json
 ```
 
-The AWS SDK implementation (`r2`) also supports large file uploads through its own multipart upload mechanism, but doesn't provide the streaming writer interface.
+The image uploader supports JPG, PNG, GIF, WebP, and SVG formats.
 
 ## Directory Structure
 
@@ -223,8 +163,8 @@ The AWS SDK implementation (`r2`) also supports large file uploads through its o
 .
 ├── bunki.config.ts     # Configuration file
 ├── content/            # Markdown content
-│   ├── post1.md
-│   └── post2.md
+│   └── YYYY/           # Year-based organization
+│       └── post-slug.md
 ├── templates/          # Nunjucks templates
 │   ├── base.njk
 │   ├── index.njk
@@ -234,267 +174,37 @@ The AWS SDK implementation (`r2`) also supports large file uploads through its o
 │   ├── archive.njk
 │   └── styles/
 │       └── main.css
-├── public/             # Static files to copy to the site
-│   └── favicon.ico
-├── images/             # Image storage directory
+├── images/             # Local images directory
 └── dist/               # Generated site
-    ├── index.html
-    ├── css/
-    │   └── style.css
-    └── ...
 ```
 
-## Templates
-
-Bunki uses [Nunjucks](https://mozilla.github.io/nunjucks/) for templating. The templates should be placed in the `templates` directory. The default templates provide a solid starting point for most blogs.
-
-## Command Line Interface
+## CLI Commands
 
 ```
 Usage: bunki [options] [command]
 
-An opinionated static site generator built with Bun
-
-Options:
-  -V, --version         output the version number
-  -h, --help            display help for command
-
 Commands:
-  init [options]        Initialize a new site with default structure
+  init [options]        Initialize a new site
   new [options] <title> Create a new blog post
-  generate [options]    Generate static site from markdown content
-  serve [options]       Start a local development server
-  images:push [options] Upload images to remote storage (e.g., Cloudflare R2)
-  help [command]        display help for command
-```
-
-### Initialize Command
-
-```
-Usage: bunki init [options]
-
-Initialize a new site with default structure
-
-Options:
-  -c, --config <file>  Path to config file (default: "bunki.config.ts")
-  -h, --help           display help for command
-```
-
-### New Post Command
-
-```
-Usage: bunki new [options] <title>
-
-Create a new blog post
-
-Arguments:
-  title                Title of the post
-
-Options:
-  -t, --tags <tags>    Comma-separated list of tags (default: "")
-  -h, --help           display help for command
-```
-
-### Generate Command
-
-```
-Usage: bunki generate [options]
-
-Generate static site from markdown content
-
-Options:
-  -c, --config <file>    Config file path (default: "bunki.config.ts")
-  -c, --content <dir>    Content directory (default: "content")
-  -o, --output <dir>     Output directory (default: "dist")
-  -t, --templates <dir>  Templates directory (default: "templates")
-  -h, --help             display help for command
-```
-
-### Serve Command
-
+  generate [options]    Generate static site
+  serve [options]       Start development server
+  images:push [options] Upload images to storage
+  help [command]        Display help
 ```
-Usage: bunki serve [options]
-
-Start a local development server
-
-Options:
-  -o, --output <dir>   Output directory (default: "dist")
-  -p, --port <number>  Port number (default: "3000")
-  -h, --help           display help for command
-```
-
-### Image Upload Commands
-
-#### Upload Multiple Images
-
-```
-Usage: bunki images:push [options]
-
-Upload images to remote storage (e.g., Cloudflare R2)
-
-Options:
-  -d, --domain <domain>     Domain name (defaults to domain in bunki.config.ts)
-  -i, --images <dir>        Images directory path (default: "images")
-  -t, --type <type>         Upload storage type (r2, bun-s3, bun-r2) (default: "r2")
-  --output-json <file>      Output URL mapping to JSON file
-  -h, --help                display help for command
-```
-
-This command will find and upload all supported image files (JPG, PNG, GIF, WebP, SVG) in the specified directory.
-
-#### Quick Upload Script
-
-Bunki also includes a convenient shell script for quick image uploads:
-
-```bash
-# Upload a single image using the shell script
-./upload-image.sh path/to/your/image.jpg
-
-# Optionally specify the domain
-./upload-image.sh path/to/your/image.jpg example.com
-```
-
-After uploading, the tool will display the public URL of the uploaded image along with the markdown syntax to use it in your content:
-
-```
-Image uploaded successfully!
-Use this URL in your markdown: ![Alt text](https://your-r2-url.com/example-com/image.jpg)
-```
-
-## Programmatic Usage
-
-You can also use Bunki programmatically in your own Bun scripts:
-
-### Site Generation
-
-```javascript
-import { SiteGenerator, loadConfig } from "bunki";
-import path from "path";
-
-// Load configuration
-const config = loadConfig("bunki.config.ts");
-
-// Create a generator
-const generator = new SiteGenerator({
-  contentDir: path.join(process.cwd(), "content"),
-  outputDir: path.join(process.cwd(), "dist"),
-  templatesDir: path.join(process.cwd(), "templates"),
-  config,
-});
-
-// Generate site
-async function generate() {
-  await generator.initialize();
-  await generator.generate();
-  console.log("Site generation complete!");
-}
-
-generate().catch(console.error);
-```
-
-### Image Uploading
-
-```javascript
-import { uploadImages, DEFAULT_IMAGES_DIR, createUploader } from "bunki";
-import path from "path";
-
-// Upload all images in a directory
-async function uploadAllImages() {
-  // Upload all images in a directory
-  const imageUrlMap = await uploadImages({
-    images: DEFAULT_IMAGES_DIR,
-    type: "bun-r2", // Use Bun's native S3 API for better performance
-    outputJson: "image-urls.json",
-  });
-
-  console.log("Image URLs:", imageUrlMap);
-
-  // For large files, you can access the uploader directly
-  // Get configuration from bunki.config.json or bunki.config.ts
-  import { loadConfig } from "bunki";
-  const config = loadConfig();
-
-  // Create uploader instance
-  const uploader = createUploader(config.s3);
-
-  // Upload a large file
-  const largeFileStream = Bun.file(
-    path.join(process.cwd(), "videos/presentation.mp4"),
-  );
-  await uploader.upload(
-    "videos/presentation.mp4",
-    largeFileStream,
-    "video/mp4",
-  );
-
-  console.log("Large file uploaded successfully");
-}
-
-uploadAllImages().catch(console.error);
-```
-
-> **Note**: Bunki's programmatic API is designed specifically for Bun and utilizes Bun's native APIs for optimal performance. It will not work in Node.js environments.
 
 ## Development
 
-### Testing
-
-Bunki includes a comprehensive test suite to verify functionality:
-
 ```bash
-# Run all tests
+# Run tests
 bun test
 
-# Run specific test files
-bun test site-generator
-bun test utils/markdown
-
-# Run tests with watch mode
-bun test --watch
-
 # Run tests with coverage
 bun test:coverage
 
-# Run TypeScript type checking
+# Type checking
 bun run typecheck
 ```
 
-Code coverage reports are automatically generated during testing.
-
-Tests are written using Bun's native test runner and verify all core functionality of Bunki, including:
-
-- Site generation process
-- Markdown parsing and rendering
-- Configuration handling
-- File system utilities
-- Template rendering
-
-### Test Fixtures
-
-Bunki comes with a set of test fixtures that are used by the test suite and can also serve as examples:
-
-The fixture directory includes:
-
-```
-fixtures/
-├── bunki.config.json   # Test configuration file
-├── content/            # Sample markdown content
-│   └── 2025/
-│       ├── test-post-1.md
-│       ├── performance-optimization.md
-│       └── migrating-from-gatsby.md
-├── src/
-│   └── tags.toml       # Tag definitions
-└── templates/          # Test templates
-    ├── base.njk
-    ├── index.njk
-    ├── post.njk
-    └── styles/
-        └── main.css
-```
-
-You can use these fixtures as examples for your own Bunki projects.
-
 ## License
 
 MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunki",
-  "version": "0.2.2",
+  "version": "0.2.5",
   "description": "An opinionated static site generator built with Bun",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -12,6 +12,7 @@
     "test": "bun test",
     "test:coverage": "bun test --coverage --coverage-reporter=lcov",
     "format": "prettier --write .",
+    "format:check": "prettier --check .",
     "prepare": "husky",
     "lint-staged": "lint-staged",
     "typecheck": "bun tsc --noEmit"
@@ -37,23 +38,23 @@
   },
   "homepage": "https://github.com/kahwee/bunki#readme",
   "dependencies": {
-    "commander": "^13.1.0",
+    "commander": "^14.0.0",
     "gray-matter": "^4.0.3",
-    "highlight.js": "^11.9.0",
-    "marked": "^15.0.11",
-    "marked-highlight": "^2.0.7",
+    "highlight.js": "^11.11.1",
+    "marked": "^16.1.1",
+    "marked-highlight": "^2.2.2",
     "nunjucks": "^3.2.4",
-    "sanitize-html": "^2.11.0",
+    "sanitize-html": "2.17.0",
     "slugify": "^1.6.6"
   },
   "devDependencies": {
-    "@types/nunjucks": "^3.2.5",
-    "@types/sanitize-html": "^2.9.5",
-    "bun-types": "^1.2.12",
+    "@types/nunjucks": "^3.2.6",
+    "@types/sanitize-html": "^2.16.0",
+    "bun-types": "1.2.19",
     "husky": "^9.1.7",
-    "lint-staged": "^15.5.2",
-    "prettier": "^3.1.0",
-    "typescript": "^5.2.2"
+    "lint-staged": "16.1.2",
+    "prettier": "^3.6.2",
+    "typescript": "^5.8.3"
   },
   "files": [
     "dist",
@@ -61,7 +62,7 @@
     "README.md"
   ],
   "engines": {
-    "bun": ">=1.2.12"
+    "bun": ">=1.2.19"
   },
   "engineStrict": true,
   "lint-staged": {