enya-agent 0.1.0

package/docs/themes/tanuki/examples/blog/content/blog/modern-javascript-features.md

@@ -0,0 +1,234 @@
++++
+title = "Modern JavaScript Features You Should Be Using"
+description = "ES2020+ brought powerful features that make JavaScript more expressive and less error-prone. Here are the ones worth adopting."
+date = 2024-12-20
+[taxonomies]
+tags = ["javascript", "es2020", "frontend"]
++++
+
+# Modern JavaScript Features You Should Be Using
+
+JavaScript evolves yearly. Here are features from recent versions that genuinely improve code quality.
+
+## Optional Chaining (?.)
+
+Stop writing defensive chains:
+
+```javascript
+// Before
+const city = user && user.address && user.address.city;
+
+// After
+const city = user?.address?.city;
+```
+
+Works with methods and arrays too:
+
+```javascript
+const result = obj.method?.();
+const first = arr?.[0];
+```
+
+## Nullish Coalescing (??)
+
+Default values that respect `0` and `''`:
+
+```javascript
+// Problem with ||
+const count = response.count || 10; // 0 becomes 10!
+
+// Solution with ??
+const count = response.count ?? 10; // 0 stays 0
+```
+
+## Logical Assignment Operators
+
+Combine logical operators with assignment:
+
+```javascript
+// ||= assigns if falsy
+options.timeout ||= 3000;
+
+// ??= assigns if nullish
+user.name ??= 'Anonymous';
+
+// &&= assigns if truthy
+config.debug &&= validateDebugMode();
+```
+
+## Array Methods
+
+### at() - Negative Indexing
+
+```javascript
+const arr = [1, 2, 3, 4, 5];
+
+// Before
+const last = arr[arr.length - 1];
+
+// After
+const last = arr.at(-1);
+const secondLast = arr.at(-2);
+```
+
+### findLast() and findLastIndex()
+
+```javascript
+const transactions = [
+    { type: 'credit', amount: 100 },
+    { type: 'debit', amount: 50 },
+    { type: 'credit', amount: 200 },
+];
+
+const lastCredit = transactions.findLast(t => t.type === 'credit');
+// { type: 'credit', amount: 200 }
+```
+
+### toSorted(), toReversed(), toSpliced()
+
+Non-mutating array operations:
+
+```javascript
+const original = [3, 1, 2];
+
+const sorted = original.toSorted();
+// sorted: [1, 2, 3]
+// original: [3, 1, 2] - unchanged!
+
+const reversed = original.toReversed();
+const removed = original.toSpliced(1, 1);
+```
+
+## Object.groupBy()
+
+Native grouping without lodash:
+
+```javascript
+const inventory = [
+    { name: 'apples', type: 'fruit' },
+    { name: 'bananas', type: 'fruit' },
+    { name: 'carrots', type: 'vegetable' },
+];
+
+const grouped = Object.groupBy(inventory, item => item.type);
+// {
+//   fruit: [{ name: 'apples', ... }, { name: 'bananas', ... }],
+//   vegetable: [{ name: 'carrots', ... }]
+// }
+```
+
+## Promise.allSettled()
+
+Wait for all promises regardless of rejection:
+
+```javascript
+const results = await Promise.allSettled([
+    fetch('/api/users'),
+    fetch('/api/posts'),
+    fetch('/api/comments'),
+]);
+
+results.forEach(result => {
+    if (result.status === 'fulfilled') {
+        console.log(result.value);
+    } else {
+        console.error(result.reason);
+    }
+});
+```
+
+## Private Class Fields
+
+True privacy with `#`:
+
+```javascript
+class Counter {
+    #count = 0;
+
+    increment() {
+        this.#count++;
+    }
+
+    get value() {
+        return this.#count;
+    }
+}
+
+const counter = new Counter();
+counter.increment();
+console.log(counter.value); // 1
+console.log(counter.#count); // SyntaxError!
+```
+
+## Static Blocks
+
+Complex static initialization:
+
+```javascript
+class Config {
+    static values;
+
+    static {
+        try {
+            this.values = JSON.parse(localStorage.getItem('config'));
+        } catch {
+            this.values = { theme: 'dark' };
+        }
+    }
+}
+```
+
+## Top-Level Await
+
+Use `await` outside async functions in modules:
+
+```javascript
+// config.js
+const response = await fetch('/api/config');
+export const config = await response.json();
+
+// main.js
+import { config } from './config.js';
+// config is already resolved
+```
+
+## Temporal API (Coming Soon)
+
+Finally, a sane date/time API:
+
+```javascript
+// Current (painful)
+const date = new Date();
+date.setDate(date.getDate() + 7);
+
+// Temporal (clear)
+const date = Temporal.Now.plainDateISO();
+const nextWeek = date.add({ days: 7 });
+```
+
+## Error Cause
+
+Chain errors with context:
+
+```javascript
+try {
+    await fetchUserData(userId);
+} catch (error) {
+    throw new Error('Failed to load user profile', {
+        cause: error
+    });
+}
+```
+
+## Quick Adoption Guide
+
+| Feature | Use When |
+|---------|----------|
+| `?.` | Accessing nested properties |
+| `??` | Providing defaults (especially for 0/'') |
+| `at(-1)` | Accessing from array end |
+| `toSorted()` | Sorting without mutation |
+| `Object.groupBy()` | Categorizing arrays |
+| `#private` | Encapsulating class data |
+
+Check [caniuse.com](https://caniuse.com) for browser support before using in production.

package/docs/themes/tanuki/examples/blog/content/blog/testing-strategies.md

@@ -0,0 +1,311 @@
++++
+title = "Testing Strategies That Actually Work"
+description = "Testing isn't about coverage percentages. It's about confidence. Here's how to test effectively."
+date = 2024-12-26
+[taxonomies]
+tags = ["testing", "quality", "development"]
++++
+
+# Testing Strategies That Actually Work
+
+The goal of testing isn't 100% coverage. It's confidence to ship.
+
+## The Testing Trophy
+
+Forget the pyramid. Think trophy:
+
+```
+        ╱╲
+       ╱  ╲      E2E (few)
+      ╱────╲
+     ╱      ╲    Integration (most)
+    ╱────────╲
+   ╱          ╲  Unit (some)
+  ╱────────────╲
+ │  Static Types │
+ └──────────────┘
+```
+
+**Static analysis** catches the most bugs with the least effort.
+
+## Unit Tests
+
+Test pure functions and isolated logic:
+
+```javascript
+// utils.test.js
+import { formatCurrency, calculateDiscount } from './utils';
+
+describe('formatCurrency', () => {
+    it('formats positive amounts', () => {
+        expect(formatCurrency(1234.5)).toBe('$1,234.50');
+    });
+
+    it('handles zero', () => {
+        expect(formatCurrency(0)).toBe('$0.00');
+    });
+
+    it('formats negative amounts', () => {
+        expect(formatCurrency(-50)).toBe('-$50.00');
+    });
+});
+
+describe('calculateDiscount', () => {
+    it('applies percentage discount', () => {
+        expect(calculateDiscount(100, 0.2)).toBe(80);
+    });
+
+    it('never goes below zero', () => {
+        expect(calculateDiscount(10, 2)).toBe(0);
+    });
+});
+```
+
+### When to Unit Test
+
+- Pure functions
+- Complex business logic
+- Utility functions
+- State reducers
+- Data transformations
+
+### When NOT to Unit Test
+
+- Simple getters/setters
+- Framework code
+- Implementation details
+- One-liner functions
+
+## Integration Tests
+
+Test how pieces work together:
+
+```javascript
+// api.test.js
+import { createServer } from '../server';
+import { db } from '../database';
+
+describe('POST /users', () => {
+    let server;
+
+    beforeAll(async () => {
+        server = await createServer();
+        await db.migrate();
+    });
+
+    afterAll(async () => {
+        await db.close();
+        await server.close();
+    });
+
+    beforeEach(async () => {
+        await db.truncate('users');
+    });
+
+    it('creates a user and returns 201', async () => {
+        const response = await server.inject({
+            method: 'POST',
+            url: '/users',
+            payload: {
+                email: 'test@example.com',
+                name: 'Test User',
+            },
+        });
+
+        expect(response.statusCode).toBe(201);
+        expect(response.json()).toMatchObject({
+            email: 'test@example.com',
+            name: 'Test User',
+        });
+
+        // Verify database
+        const user = await db.query('SELECT * FROM users WHERE email = $1', ['test@example.com']);
+        expect(user).toBeDefined();
+    });
+
+    it('returns 400 for invalid email', async () => {
+        const response = await server.inject({
+            method: 'POST',
+            url: '/users',
+            payload: {
+                email: 'not-an-email',
+                name: 'Test',
+            },
+        });
+
+        expect(response.statusCode).toBe(400);
+        expect(response.json().error.code).toBe('VALIDATION_ERROR');
+    });
+});
+```
+
+## Component Tests (Frontend)
+
+Test components with realistic interactions:
+
+```javascript
+// UserProfile.test.jsx
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { UserProfile } from './UserProfile';
+import { server } from '../mocks/server';
+import { rest } from 'msw';
+
+describe('UserProfile', () => {
+    it('displays user information', async () => {
+        render(<UserProfile userId="123" />);
+
+        await waitFor(() => {
+            expect(screen.getByRole('heading')).toHaveTextContent('Jane Doe');
+        });
+
+        expect(screen.getByText('jane@example.com')).toBeInTheDocument();
+    });
+
+    it('handles edit mode', async () => {
+        const user = userEvent.setup();
+        render(<UserProfile userId="123" />);
+
+        await user.click(screen.getByRole('button', { name: /edit/i }));
+
+        const input = screen.getByLabelText(/name/i);
+        await user.clear(input);
+        await user.type(input, 'Jane Smith');
+        await user.click(screen.getByRole('button', { name: /save/i }));
+
+        await waitFor(() => {
+            expect(screen.getByRole('heading')).toHaveTextContent('Jane Smith');
+        });
+    });
+
+    it('shows error state', async () => {
+        server.use(
+            rest.get('/api/users/:id', (req, res, ctx) => {
+                return res(ctx.status(500));
+            })
+        );
+
+        render(<UserProfile userId="123" />);
+
+        await waitFor(() => {
+            expect(screen.getByRole('alert')).toHaveTextContent(/failed to load/i);
+        });
+    });
+});
+```
+
+## E2E Tests
+
+Test critical user journeys:
+
+```javascript
+// checkout.spec.js (Playwright)
+import { test, expect } from '@playwright/test';
+
+test.describe('Checkout Flow', () => {
+    test('completes purchase successfully', async ({ page }) => {
+        // Add item to cart
+        await page.goto('/products/widget');
+        await page.click('button:has-text("Add to Cart")');
+
+        // Go to checkout
+        await page.click('a:has-text("Checkout")');
+
+        // Fill shipping
+        await page.fill('[name="email"]', 'test@example.com');
+        await page.fill('[name="address"]', '123 Main St');
+        await page.fill('[name="city"]', 'Portland');
+        await page.selectOption('[name="state"]', 'OR');
+        await page.fill('[name="zip"]', '97201');
+
+        // Fill payment (test card)
+        await page.fill('[name="cardNumber"]', '4242424242424242');
+        await page.fill('[name="expiry"]', '12/25');
+        await page.fill('[name="cvc"]', '123');
+
+        // Submit
+        await page.click('button:has-text("Place Order")');
+
+        // Verify success
+        await expect(page.locator('h1')).toHaveText('Order Confirmed');
+        await expect(page.locator('.order-number')).toBeVisible();
+    });
+});
+```
+
+### E2E Best Practices
+
+- Test happy paths thoroughly
+- Use realistic test data
+- Run in CI on every PR
+- Keep tests independent
+- Use test IDs for stability
+
+## What NOT to Test
+
+- Third-party libraries
+- Framework internals
+- Private implementation details
+- Simple pass-through code
+- Autogenerated code
+
+## Test Data Strategies
+
+### Factories
+
+```javascript
+// factories/user.js
+import { faker } from '@faker-js/faker';
+
+export function createUser(overrides = {}) {
+    return {
+        id: faker.string.uuid(),
+        email: faker.internet.email(),
+        name: faker.person.fullName(),
+        createdAt: faker.date.past(),
+        ...overrides,
+    };
+}
+
+// In tests
+const user = createUser({ email: 'specific@test.com' });
+```
+
+### Fixtures
+
+```javascript
+// fixtures/users.json
+{
+    "admin": {
+        "id": "admin-001",
+        "email": "admin@example.com",
+        "role": "admin"
+    },
+    "regular": {
+        "id": "user-001",
+        "email": "user@example.com",
+        "role": "user"
+    }
+}
+```
+
+## Measuring Test Quality
+
+Coverage is a **floor**, not a **ceiling**.
+
+Better metrics:
+- **Mutation score**: Do tests catch bugs?
+- **Flakiness rate**: Are tests reliable?
+- **Time to run**: Are tests fast enough?
+- **Maintenance cost**: Are tests easy to update?
+
+## Quick Guidelines
+
+| Test Type | Speed | Confidence | Quantity |
+|-----------|-------|------------|----------|
+| Static | Instant | Medium | All code |
+| Unit | Fast | Low-Medium | Some |
+| Integration | Medium | High | Most |
+| E2E | Slow | Highest | Few |
+
+Write tests that give you confidence to ship, not tests that give you coverage badges.

package/docs/themes/tanuki/examples/blog/content/blog/typography-for-developers.md

@@ -0,0 +1,104 @@
++++
+title = "Typography Fundamentals for Developers"
+description = "Good typography makes your content readable and your site professional. Here are the basics every developer should know."
+date = 2024-12-15
+[taxonomies]
+tags = ["design", "typography", "css"]
++++
+
+# Typography Fundamentals for Developers
+
+You don't need to be a designer to get typography right. These fundamentals will take you far.
+
+## Choose Readable Fonts
+
+For body text, prioritize readability:
+
+- **Sans-serif** for screens: Geist, Inter, system-ui
+- **Serif** for long-form: Georgia, Charter, Literata
+- **Monospace** for code: Geist Mono, JetBrains Mono, Fira Code
+
+Avoid decorative fonts for body text. Save them for headlines.
+
+## Set a Comfortable Line Length
+
+Lines that are too long or too short hurt readability. Aim for **45-75 characters** per line:
+
+```css
+.prose {
+    max-width: 65ch;
+}
+```
+
+The `ch` unit is based on the width of the "0" character, making it perfect for this.
+
+## Use a Type Scale
+
+Don't pick font sizes randomly. Use a scale:
+
+```css
+:root {
+    --text-xs: 0.75rem;   /* 12px */
+    --text-sm: 0.875rem;  /* 14px */
+    --text-base: 1rem;    /* 16px */
+    --text-lg: 1.125rem;  /* 18px */
+    --text-xl: 1.25rem;   /* 20px */
+    --text-2xl: 1.5rem;   /* 24px */
+    --text-3xl: 1.875rem; /* 30px */
+    --text-4xl: 2.25rem;  /* 36px */
+}
+```
+
+## Line Height Matters
+
+Tighter line height for headlines, looser for body text:
+
+```css
+h1, h2, h3 {
+    line-height: 1.2;
+}
+
+p {
+    line-height: 1.6;
+}
+```
+
+## Vertical Rhythm
+
+Consistent spacing creates visual harmony:
+
+```css
+.prose > * + * {
+    margin-top: 1.5rem;
+}
+
+.prose h2 {
+    margin-top: 3rem;
+}
+```
+
+## Font Loading
+
+Use `font-display: swap` to prevent invisible text:
+
+```css
+@font-face {
+    font-family: 'Geist';
+    src: url('/fonts/Geist-Variable.woff2') format('woff2');
+    font-display: swap;
+}
+```
+
+## Responsive Typography
+
+Scale fonts based on viewport:
+
+```css
+html {
+    font-size: clamp(16px, 1vw + 14px, 20px);
+}
+```
+
+This creates fluid typography that adapts to screen size.
+
+Good typography is invisible—readers don't notice it, they just enjoy the content.

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

@@ -0,0 +1,67 @@
++++
+title = "Welcome to Tanuki"
+description = "Introducing Tanuki, a whimsical Zola theme inspired by Nintendo's playful design philosophy."
+date = 2024-12-27
+[taxonomies]
+tags = ["announcement", "release"]
++++
+
+# Welcome to Tanuki
+
+We're excited to introduce Tanuki, a new Zola theme that brings joy and whimsy to your documentation, books, and blogs.
+
+## Why Tanuki?
+
+The tanuki (Japanese raccoon dog) is a beloved creature in Japanese folklore, known for being playful, mischievous, and a little magical. We chose this name because our theme embodies those same qualities—it's fun to use, delightful to look at, and just a bit magical in how it transforms your content.
+
+## Three Modes, One Theme
+
+Tanuki supports three distinct modes:
+
+1. **Documentation Mode** - Perfect for API docs and technical references
+2. **E-Book Mode** - Ideal for tutorials, courses, and long-form content
+3. **Blog Mode** - Great for personal sites, portfolios, and announcements
+
+Each mode is optimized for its purpose while maintaining a consistent, cohesive design language.
+
+## Features You'll Love
+
+### Catppuccin Colors
+
+We use the beautiful [Catppuccin](https://github.com/catppuccin/catppuccin) color palette, with Mocha for dark mode and Latte for light mode. The colors are warm, inviting, and easy on the eyes during long reading sessions.
+
+### Nintendo-Inspired UX
+
+Inspired by games like Animal Crossing and Super Mario Odyssey, we've added subtle animations and interactions that make using the theme feel delightful. Watch the theme toggle sparkle when you click it!
+
+### Full-Text Search
+
+Press `/` anywhere to search your entire site instantly. Powered by Elasticlunr, it's fast and works offline.
+
+## Getting Started
+
+Adding Tanuki to your project is simple:
+
+```bash
+git submodule add https://github.com/raskell-io/tanuki themes/tanuki
+```
+
+Then add to your `config.toml`:
+
+```toml
+theme = "tanuki"
+
+[extra]
+mode = "site"  # or "docs" or "book"
+```
+
+## What's Next?
+
+We're just getting started! Upcoming features include:
+
+- More theme color options
+- Additional page templates
+- Enhanced print stylesheets
+- Improved accessibility features
+
+Stay tuned for more updates, and happy building!