enya-agent 0.1.0

package/docs/themes/tanuki/examples/blog/content/blog/docker-essentials.md

@@ -0,0 +1,301 @@
++++
+title = "Docker Essentials for Developers"
+description = "Containers changed how we deploy software. Here's what every developer needs to know about Docker."
+date = 2024-12-25
+[taxonomies]
+tags = ["docker", "devops", "containers"]
++++
+
+# Docker Essentials for Developers
+
+"Works on my machine" used to be a punchline. Docker makes it a guarantee.
+
+## Core Concepts
+
+**Image**: A read-only template with your application and dependencies.
+
+**Container**: A running instance of an image.
+
+**Dockerfile**: Instructions to build an image.
+
+**Registry**: Storage for images (Docker Hub, GitHub Container Registry).
+
+## Your First Dockerfile
+
+For a Node.js application:
+
+```dockerfile
+# Start from a base image
+FROM node:20-alpine
+
+# Set working directory
+WORKDIR /app
+
+# Copy package files first (for caching)
+COPY package*.json ./
+
+# Install dependencies
+RUN npm ci --only=production
+
+# Copy application code
+COPY . .
+
+# Expose the port
+EXPOSE 3000
+
+# Run the application
+CMD ["node", "server.js"]
+```
+
+Build and run:
+
+```bash
+docker build -t myapp .
+docker run -p 3000:3000 myapp
+```
+
+## Layer Caching
+
+Docker caches layers. Order matters:
+
+```dockerfile
+# Bad: reinstalls deps on any code change
+COPY . .
+RUN npm install
+
+# Good: deps only reinstall when package.json changes
+COPY package*.json ./
+RUN npm install
+COPY . .
+```
+
+## Multi-Stage Builds
+
+Keep production images small:
+
+```dockerfile
+# Build stage
+FROM node:20 AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN npm run build
+
+# Production stage
+FROM node:20-alpine
+WORKDIR /app
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/node_modules ./node_modules
+EXPOSE 3000
+CMD ["node", "dist/server.js"]
+```
+
+Result: A fraction of the size.
+
+## Docker Compose
+
+Define multi-container applications:
+
+```yaml
+# docker-compose.yml
+services:
+  web:
+    build: .
+    ports:
+      - "3000:3000"
+    environment:
+      - DATABASE_URL=postgres://db:5432/myapp
+    depends_on:
+      - db
+
+  db:
+    image: postgres:16-alpine
+    environment:
+      - POSTGRES_DB=myapp
+      - POSTGRES_PASSWORD=secret
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+
+volumes:
+  postgres_data:
+```
+
+Run everything:
+
+```bash
+docker compose up -d
+```
+
+## Essential Commands
+
+```bash
+# Images
+docker build -t name:tag .
+docker images
+docker rmi image_name
+
+# Containers
+docker run -d -p 8080:80 nginx
+docker ps                    # Running containers
+docker ps -a                 # All containers
+docker stop container_id
+docker rm container_id
+
+# Logs and debugging
+docker logs container_id
+docker logs -f container_id  # Follow logs
+docker exec -it container_id sh
+
+# Cleanup
+docker system prune          # Remove unused data
+docker system prune -a       # Remove everything unused
+```
+
+## Volumes: Persistent Data
+
+Data inside containers is ephemeral. Use volumes:
+
+```bash
+# Named volume
+docker run -v mydata:/app/data myapp
+
+# Bind mount (development)
+docker run -v $(pwd):/app myapp
+```
+
+In Compose:
+
+```yaml
+services:
+  app:
+    volumes:
+      - ./src:/app/src        # Bind mount for hot reload
+      - node_modules:/app/node_modules  # Named volume
+
+volumes:
+  node_modules:
+```
+
+## Environment Variables
+
+```dockerfile
+# Default value in Dockerfile
+ENV NODE_ENV=production
+```
+
+Override at runtime:
+
+```bash
+docker run -e NODE_ENV=development myapp
+```
+
+Or use `.env` files with Compose:
+
+```yaml
+services:
+  app:
+    env_file:
+      - .env
+```
+
+## Health Checks
+
+Let Docker know if your app is healthy:
+
+```dockerfile
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s \
+    CMD curl -f http://localhost:3000/health || exit 1
+```
+
+## Security Best Practices
+
+### Don't run as root
+
+```dockerfile
+RUN addgroup -S appgroup && adduser -S appuser -G appgroup
+USER appuser
+```
+
+### Use specific image tags
+
+```dockerfile
+# Bad: unpredictable
+FROM node:latest
+
+# Good: reproducible
+FROM node:20.10-alpine3.18
+```
+
+### Don't store secrets in images
+
+```bash
+# Bad
+ENV API_KEY=secret123
+
+# Good: pass at runtime
+docker run -e API_KEY=$API_KEY myapp
+```
+
+## .dockerignore
+
+Keep images lean:
+
+```
+node_modules
+.git
+.env
+*.md
+Dockerfile
+docker-compose.yml
+.dockerignore
+coverage
+.nyc_output
+```
+
+## Development Workflow
+
+```yaml
+# docker-compose.dev.yml
+services:
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile.dev
+    volumes:
+      - .:/app
+      - /app/node_modules
+    environment:
+      - NODE_ENV=development
+    command: npm run dev
+```
+
+```bash
+docker compose -f docker-compose.dev.yml up
+```
+
+## Debugging Containers
+
+```bash
+# Shell into running container
+docker exec -it container_id sh
+
+# Inspect container details
+docker inspect container_id
+
+# View resource usage
+docker stats
+```
+
+## Quick Reference
+
+| Task | Command |
+|------|---------|
+| Build image | `docker build -t name .` |
+| Run container | `docker run -d -p 8080:80 name` |
+| View logs | `docker logs -f container` |
+| Shell access | `docker exec -it container sh` |
+| Stop all | `docker stop $(docker ps -q)` |
+| Clean up | `docker system prune -a` |
+
+Docker transforms "it works on my machine" into "it works everywhere."

package/docs/themes/tanuki/examples/blog/content/blog/getting-started-with-zola.md

@@ -0,0 +1,129 @@
++++
+title = "Getting Started with Zola"
+description = "A quick introduction to Zola, the fast static site generator that powers Tanuki."
+date = 2024-12-26
+[taxonomies]
+tags = ["tutorial", "zola"]
++++
+
+# Getting Started with Zola
+
+Zola is a fast static site generator written in Rust. It's what powers the Tanuki theme, and it's a joy to work with.
+
+## Why Zola?
+
+There are many static site generators out there—Jekyll, Hugo, Eleventy, Next.js—so why choose Zola?
+
+### Speed
+
+Zola is incredibly fast. A typical site builds in milliseconds, not seconds. This makes development pleasant and deployments quick.
+
+### Single Binary
+
+Unlike Jekyll (Ruby) or Eleventy (Node.js), Zola is a single binary with no dependencies. Download it, run it, done.
+
+### Built-in Features
+
+Zola includes everything you need out of the box:
+
+- Sass compilation
+- Syntax highlighting
+- Search index generation
+- Image processing
+- Shortcodes
+- Taxonomies (tags, categories)
+- Multilingual support
+
+No plugins to install, no configuration rabbit holes.
+
+## Installation
+
+### macOS (Homebrew)
+
+```bash
+brew install zola
+```
+
+### Linux
+
+```bash
+# Snap
+snap install zola --edge
+
+# Or download from GitHub releases
+wget https://github.com/getzola/zola/releases/download/v0.19.2/zola-v0.19.2-x86_64-unknown-linux-gnu.tar.gz
+tar xzf zola-*.tar.gz
+sudo mv zola /usr/local/bin/
+```
+
+### Windows
+
+```powershell
+# Scoop
+scoop install zola
+
+# Or Chocolatey
+choco install zola
+```
+
+## Creating a New Site
+
+```bash
+zola init my-site
+cd my-site
+```
+
+Zola will ask a few questions about your site configuration. Answer them, and you'll have a basic structure:
+
+```
+my-site/
+├── config.toml
+├── content/
+├── sass/
+├── static/
+├── templates/
+└── themes/
+```
+
+## Adding Content
+
+Content goes in the `content/` directory as Markdown files:
+
+```markdown
++++
+title = "My First Post"
+date = 2024-12-27
++++
+
+# Hello, World!
+
+This is my first post using Zola.
+```
+
+The `+++` section is called front matter—it's TOML by default and contains metadata about your page.
+
+## Development Server
+
+Run the development server:
+
+```bash
+zola serve
+```
+
+Open http://127.0.0.1:1111 and you'll see your site. Changes trigger automatic rebuilds and browser refresh.
+
+## Building for Production
+
+```bash
+zola build
+```
+
+Your complete site will be in the `public/` directory, ready to deploy anywhere.
+
+## Next Steps
+
+- Read the [Zola documentation](https://www.getzola.org/documentation/)
+- Explore the [Tanuki theme documentation](/docs/)
+- Join the [Zola Discord](https://discord.gg/WN8n6xqp)
+
+Happy building!

package/docs/themes/tanuki/examples/blog/content/blog/git-workflow-for-content.md

@@ -0,0 +1,112 @@
++++
+title = "Git Workflow for Content Teams"
+description = "How to use Git and pull requests to manage content on static sites, even if you're not a developer."
+date = 2024-12-08
+[taxonomies]
+tags = ["git", "workflow", "static-sites"]
++++
+
+# Git Workflow for Content Teams
+
+Static sites store content as files in a Git repository. This unlocks powerful workflows for content teams.
+
+## Why Git for Content?
+
+Traditional CMS platforms have their own versioning, but Git offers:
+
+- **Complete history**: Every change is tracked forever
+- **Branching**: Work on drafts without affecting the live site
+- **Review process**: Pull requests for editorial review
+- **Rollback**: Instantly revert any change
+- **Collaboration**: Multiple people can work simultaneously
+
+## The Basic Workflow
+
+### 1. Create a Branch
+
+Never work directly on `main`. Create a branch for your changes:
+
+```bash
+git checkout -b post/new-article-title
+```
+
+### 2. Make Your Changes
+
+Edit or create Markdown files in the `content/` directory:
+
+```markdown
++++
+title = "My New Article"
+date = 2024-12-08
++++
+
+Article content goes here...
+```
+
+### 3. Commit Your Work
+
+Save your changes with a descriptive message:
+
+```bash
+git add content/my-new-article.md
+git commit -m "Add article about Git workflows"
+```
+
+### 4. Push and Create a Pull Request
+
+```bash
+git push origin post/new-article-title
+```
+
+Then create a pull request on GitHub for review.
+
+### 5. Review and Merge
+
+Team members can:
+- Comment on specific lines
+- Suggest edits
+- Preview the changes (with deploy previews)
+- Approve and merge
+
+## Deploy Previews
+
+Services like Netlify and Vercel create preview URLs for every pull request. This lets editors see exactly how their changes will look before merging.
+
+## Branch Naming Conventions
+
+Use consistent prefixes:
+
+- `post/` - New blog posts
+- `docs/` - Documentation updates
+- `fix/` - Corrections and typos
+- `feature/` - New site features
+
+## Handling Conflicts
+
+If two people edit the same file:
+
+```bash
+git pull origin main
+# Resolve conflicts in your editor
+git add .
+git commit -m "Resolve merge conflict"
+```
+
+## Tips for Non-Developers
+
+1. **Use GitHub's web editor** for simple changes
+2. **Use a desktop app** like GitHub Desktop or VS Code
+3. **Write good commit messages** describing what and why
+4. **Don't fear branches** - they're cheap and easy to delete
+5. **Ask for help** - Git has a learning curve
+
+## Automating Quality Checks
+
+Add CI checks to catch issues before merge:
+
+- Spell checking
+- Link validation
+- Build verification
+- Image optimization
+
+Git transforms content management from a black box into a transparent, collaborative process.

package/docs/themes/tanuki/examples/blog/content/blog/introduction-to-webassembly.md

@@ -0,0 +1,183 @@
++++
+title = "Introduction to WebAssembly"
+description = "WebAssembly brings near-native performance to the browser. Here's what you need to know to get started."
+date = 2024-12-18
+[taxonomies]
+tags = ["webassembly", "rust", "performance"]
++++
+
+# Introduction to WebAssembly
+
+WebAssembly (Wasm) is a binary instruction format that runs in browsers at near-native speed. It's not here to replace JavaScript—it's here to complement it.
+
+## Why WebAssembly?
+
+JavaScript is incredibly versatile, but some tasks need more performance:
+
+- **Image/video processing**
+- **Games and 3D graphics**
+- **Compression/encryption**
+- **Scientific computing**
+- **CAD applications**
+
+WebAssembly handles these without plugins or browser extensions.
+
+## How It Works
+
+```
+Source Code → Compiler → .wasm binary → Browser Runtime
+(Rust, C++)              (portable)      (sandboxed)
+```
+
+The browser downloads the `.wasm` file and executes it in a secure sandbox alongside JavaScript.
+
+## Your First WebAssembly (with Rust)
+
+### 1. Set Up
+
+```bash
+# Install the Wasm target
+rustup target add wasm32-unknown-unknown
+
+# Install wasm-pack
+cargo install wasm-pack
+```
+
+### 2. Create a Project
+
+```bash
+cargo new --lib hello-wasm
+cd hello-wasm
+```
+
+### 3. Configure Cargo.toml
+
+```toml
+[package]
+name = "hello-wasm"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+wasm-bindgen = "0.2"
+```
+
+### 4. Write Rust Code
+
+```rust
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub fn greet(name: &str) -> String {
+    format!("Hello, {}!", name)
+}
+
+#[wasm_bindgen]
+pub fn fibonacci(n: u32) -> u32 {
+    match n {
+        0 => 0,
+        1 => 1,
+        _ => fibonacci(n - 1) + fibonacci(n - 2),
+    }
+}
+```
+
+### 5. Build
+
+```bash
+wasm-pack build --target web
+```
+
+### 6. Use in JavaScript
+
+```html
+<script type="module">
+    import init, { greet, fibonacci } from './pkg/hello_wasm.js';
+
+    async function main() {
+        await init();
+        console.log(greet("World"));
+        console.log(fibonacci(40)); // Much faster than JS
+    }
+
+    main();
+</script>
+```
+
+## Performance Comparison
+
+Computing Fibonacci(45):
+
+| Language | Time |
+|----------|------|
+| JavaScript | ~8 seconds |
+| WebAssembly (Rust) | ~4 seconds |
+| Native Rust | ~3 seconds |
+
+For compute-heavy tasks, Wasm can be 2-10x faster than JavaScript.
+
+## Real-World Use Cases
+
+### Figma
+The design tool uses WebAssembly for its rendering engine, enabling smooth performance with complex designs.
+
+### Photoshop Web
+Adobe ported significant portions of Photoshop to Wasm for the web version.
+
+### Google Earth
+Complex 3D rendering runs smoothly thanks to WebAssembly.
+
+### SQLite in the Browser
+The entire SQLite database engine compiled to Wasm.
+
+## Interacting with the DOM
+
+WebAssembly can't directly access the DOM—it must go through JavaScript:
+
+```rust
+use wasm_bindgen::prelude::*;
+use web_sys::console;
+
+#[wasm_bindgen(start)]
+pub fn main() {
+    console::log_1(&"Hello from Wasm!".into());
+}
+```
+
+```toml
+# Add to Cargo.toml
+[dependencies.web-sys]
+version = "0.3"
+features = ["console"]
+```
+
+## Memory Management
+
+Wasm has its own linear memory that JavaScript can read:
+
+```rust
+#[wasm_bindgen]
+pub fn process_image(data: &[u8]) -> Vec<u8> {
+    // Process and return new data
+    data.iter().map(|&x| 255 - x).collect()
+}
+```
+
+## When NOT to Use WebAssembly
+
+- **Simple DOM manipulation**: JavaScript is faster to develop
+- **Small utilities**: The Wasm overhead isn't worth it
+- **I/O-bound tasks**: Network/file operations are limited by the browser
+- **When bundle size matters**: Wasm adds payload
+
+## The Future
+
+- **WASI**: WebAssembly System Interface for running outside browsers
+- **Component Model**: Better interoperability between Wasm modules
+- **Garbage Collection**: Native GC support coming soon
+- **Threads**: Shared memory and threading support
+
+WebAssembly isn't just for browsers anymore—it's becoming a universal runtime.