enya-agent 0.1.0

package/docs/themes/tanuki/examples/blog/content/blog/why-static-sites.md

@@ -0,0 +1,85 @@
++++
+title = "Why Static Sites Are Making a Comeback"
+description = "Static site generators are more popular than ever. Here's why developers are choosing them over traditional CMS platforms."
+date = 2024-12-18
+[taxonomies]
+tags = ["static-sites", "performance", "security"]
++++
+
+# Why Static Sites Are Making a Comeback
+
+In an era of complex web applications, static sites are experiencing a renaissance. Here's why.
+
+## Performance
+
+Static sites are *fast*. There's no database to query, no server-side rendering to wait for. Your HTML, CSS, and JavaScript are served directly from a CDN, often in under 100ms.
+
+Compare this to a typical WordPress site that might take 2-3 seconds to generate a page.
+
+## Security
+
+With no database and no server-side code, the attack surface shrinks dramatically:
+
+- No SQL injection
+- No server-side vulnerabilities
+- No CMS to keep patched
+
+Your site is essentially a folder of files. There's nothing to hack.
+
+## Cost
+
+Static hosting is cheap—often free:
+
+- **GitHub Pages**: Free
+- **Cloudflare Pages**: Free
+- **Netlify**: Free tier available
+- **Vercel**: Free tier available
+
+No server to maintain. No database to pay for. No DevOps headaches.
+
+## Developer Experience
+
+Modern static site generators like Zola, Hugo, and Eleventy offer:
+
+- **Hot reload** during development
+- **Markdown** for content
+- **Git-based workflows** for versioning
+- **Build previews** for pull requests
+
+## When Static Doesn't Work
+
+Static sites aren't for everything. You'll still need a server for:
+
+- User authentication
+- Real-time features
+- Dynamic content that changes per-user
+
+But for blogs, documentation, marketing sites, and portfolios? Static is hard to beat.
+
+## The JAMstack Approach
+
+The JAMstack (JavaScript, APIs, Markup) architecture extends static sites with:
+
+- Client-side JavaScript for interactivity
+- Third-party APIs for dynamic features
+- Pre-rendered markup for speed
+
+This gives you the best of both worlds: static performance with dynamic capabilities.
+
+## Getting Started
+
+Ready to try static? Zola is a great starting point:
+
+```bash
+# Install Zola
+brew install zola
+
+# Create a new site
+zola init my-site
+cd my-site
+
+# Start the dev server
+zola serve
+```
+
+The future is static—and it's faster than ever.

package/docs/themes/tanuki/examples/blog/content/projects.md

@@ -0,0 +1,64 @@
++++
+title = "Projects"
+description = "Things I've built and contributed to."
+template = "page.html"
+path = "projects"
++++
+
+# Projects
+
+A selection of projects I've worked on—both personal experiments and contributions to open source.
+
+---
+
+## Tanuki Theme
+
+A modern, flexible theme for Zola with support for documentation, e-books, and blogs.
+
+- **Stack**: Zola, Sass, JavaScript
+- **Features**: Dark/light themes, search, responsive design
+- [View on GitHub](https://github.com/raskell-io/tanuki)
+
+---
+
+## CLI Task Runner
+
+A fast, parallel task runner written in Rust for managing development workflows.
+
+- **Stack**: Rust, TOML
+- **Features**: Parallel execution, file watching, task dependencies
+- [View on GitHub](https://github.com/example/taskrunner)
+
+---
+
+## React Component Library
+
+A collection of accessible, themeable React components for building consistent UIs.
+
+- **Stack**: React, TypeScript, Storybook
+- **Features**: WAI-ARIA compliant, customizable themes, tree-shakeable
+- [View on GitHub](https://github.com/example/components)
+
+---
+
+## Markdown Note App
+
+A minimalist note-taking app with Markdown support and local-first storage.
+
+- **Stack**: Electron, React, SQLite
+- **Features**: Offline-first, full-text search, sync optional
+- [View on GitHub](https://github.com/example/notes)
+
+---
+
+## Open Source Contributions
+
+I also contribute to projects I use and care about:
+
+- **Zola** - Static site generator (documentation, bug fixes)
+- **Catppuccin** - Color palette (theme ports)
+- **Various Rust crates** - Bug fixes and features
+
+---
+
+*Interested in collaborating? [Get in touch](/about).*

package/docs/themes/tanuki/examples/book/config.toml

@@ -0,0 +1,17 @@
+# Tanuki Theme - Book Mode Example
+base_url = "/tanuki/book"
+title = "The Tanuki Guide"
+description = "E-book example for the Tanuki theme"
+theme = "tanuki"
+compile_sass = true
+build_search_index = true
+generate_feeds = false
+
+[markdown]
+highlight_code = true
+highlight_theme = "base16-ocean-dark"
+
+[extra]
+mode = "book"
+github = "https://github.com/raskell-io/tanuki"
+show_theme_toggle = true

package/docs/themes/tanuki/examples/book/content/_index.md

@@ -0,0 +1,12 @@
++++
+title = "The Art of Web Development"
+description = "A comprehensive guide to building modern web applications."
+sort_by = "weight"
+template = "section.html"
++++
+
+# The Art of Web Development
+
+A comprehensive guide to building modern, accessible, and performant web applications.
+
+This book takes you from the fundamentals of HTML, CSS, and JavaScript through to advanced topics like performance optimization, accessibility, and deployment strategies.

package/docs/themes/tanuki/examples/book/content/chapter-1.md

@@ -0,0 +1,90 @@
++++
+title = "Chapter 1: The Foundation"
+description = "Understanding the core technologies of the web."
+weight = 1
++++
+
+# Chapter 1: The Foundation
+
+Before we build castles in the sky, we must first understand the ground beneath our feet. The web is built on three fundamental technologies: HTML, CSS, and JavaScript. Each plays a crucial role in creating the experiences we use every day.
+
+## The Triad of Web Technologies
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris.
+
+### HTML: The Structure
+
+HTML (HyperText Markup Language) provides the semantic structure of web pages. Think of it as the skeleton of your website—the bones that give it shape and meaning.
+
+```html
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>My First Page</title>
+</head>
+<body>
+    <header>
+        <h1>Welcome</h1>
+    </header>
+    <main>
+        <p>Hello, World!</p>
+    </main>
+</body>
+</html>
+```
+
+Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident.
+
+### CSS: The Style
+
+CSS (Cascading Style Sheets) controls the visual presentation. It's the skin, the clothes, the paint on the walls—everything that makes your site visually appealing.
+
+```css
+body {
+    font-family: system-ui, sans-serif;
+    line-height: 1.6;
+    color: #333;
+}
+
+h1 {
+    color: #1e40af;
+    font-size: 2.5rem;
+}
+```
+
+Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam.
+
+### JavaScript: The Behavior
+
+JavaScript brings interactivity to the web. It's the muscles and nervous system—the parts that let your site respond and react.
+
+```javascript
+document.querySelector('button').addEventListener('click', () => {
+    console.log('Button clicked!');
+    alert('Hello, interactive web!');
+});
+```
+
+## The Document Object Model
+
+The DOM is the bridge between your HTML and JavaScript. It represents your page as a tree of objects that can be manipulated programmatically.
+
+| Concept | Description |
+|---------|-------------|
+| Node | Any point in the DOM tree |
+| Element | An HTML element node |
+| Attribute | Properties of elements |
+| Text | Text content within elements |
+
+## Summary
+
+In this chapter, we explored:
+
+- The three core technologies: HTML, CSS, and JavaScript
+- How each technology contributes to the web experience
+- The basics of the Document Object Model
+
+> **Key Insight**: Understanding these fundamentals deeply will make you a better developer. Don't rush past the basics—they're the foundation everything else is built upon.
+
+In the next chapter, we'll dive deeper into modern CSS and explore the powerful layout systems available to us today.

package/docs/themes/tanuki/examples/book/content/chapter-2.md

@@ -0,0 +1,143 @@
++++
+title = "Chapter 2: Modern CSS"
+description = "Exploring Flexbox, Grid, and modern CSS features."
+weight = 2
++++
+
+# Chapter 2: Modern CSS
+
+CSS has evolved dramatically over the past decade. Gone are the days of float-based layouts and clearfix hacks. Today, we have powerful tools like Flexbox and Grid that make complex layouts straightforward.
+
+## The Flexbox Revolution
+
+Flexbox (Flexible Box Layout) is designed for one-dimensional layouts—either rows or columns. It excels at distributing space and aligning items.
+
+```css
+.container {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    gap: 1rem;
+}
+
+.item {
+    flex: 1;
+}
+```
+
+### Flex Direction and Wrapping
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. The `flex-direction` property controls the main axis:
+
+```css
+.row { flex-direction: row; }        /* Default: left to right */
+.column { flex-direction: column; }  /* Top to bottom */
+.row-reverse { flex-direction: row-reverse; }
+.column-reverse { flex-direction: column-reverse; }
+```
+
+Nulla facilisi. Sed euismod, nisl nec ultricies lacinia, nisl nisl aliquam nisl, eget aliquam nisl nisl sit amet nisl.
+
+## CSS Grid: Two-Dimensional Layouts
+
+Grid Layout is the answer to two-dimensional layouts. It handles both rows and columns simultaneously.
+
+```css
+.grid-container {
+    display: grid;
+    grid-template-columns: repeat(3, 1fr);
+    grid-template-rows: auto 1fr auto;
+    gap: 2rem;
+}
+
+.header { grid-column: 1 / -1; }
+.sidebar { grid-row: 2 / 3; }
+.main { grid-column: 2 / 4; }
+```
+
+### Grid Template Areas
+
+For complex layouts, named grid areas provide clarity:
+
+```css
+.layout {
+    display: grid;
+    grid-template-areas:
+        "header header header"
+        "sidebar main main"
+        "footer footer footer";
+    grid-template-columns: 200px 1fr 1fr;
+}
+
+.header { grid-area: header; }
+.sidebar { grid-area: sidebar; }
+.main { grid-area: main; }
+.footer { grid-area: footer; }
+```
+
+## Custom Properties (CSS Variables)
+
+CSS Custom Properties bring the power of variables to stylesheets:
+
+```css
+:root {
+    --color-primary: #3b82f6;
+    --color-secondary: #10b981;
+    --spacing-unit: 8px;
+    --border-radius: 4px;
+}
+
+.button {
+    background: var(--color-primary);
+    padding: calc(var(--spacing-unit) * 2);
+    border-radius: var(--border-radius);
+}
+```
+
+### Dynamic Theming
+
+Variables can be changed at runtime with JavaScript:
+
+```javascript
+document.documentElement.style.setProperty('--color-primary', '#8b5cf6');
+```
+
+Or scoped to specific elements:
+
+```css
+.dark-theme {
+    --color-background: #1a1a2e;
+    --color-text: #eaeaea;
+}
+```
+
+## Container Queries
+
+The newest addition to responsive design—container queries let you style based on parent size, not viewport:
+
+```css
+.card-container {
+    container-type: inline-size;
+    container-name: card;
+}
+
+@container card (min-width: 400px) {
+    .card {
+        display: flex;
+        flex-direction: row;
+    }
+}
+```
+
+## Summary
+
+Modern CSS provides powerful tools for layout and styling:
+
+- **Flexbox** for one-dimensional layouts
+- **Grid** for two-dimensional layouts
+- **Custom Properties** for maintainable, themeable CSS
+- **Container Queries** for component-based responsive design
+
+> **Pro Tip**: Don't choose between Flexbox and Grid—use both! Grid for page layouts, Flexbox for component internals.
+
+Next, we'll explore JavaScript in depth and learn how to make our pages interactive.

package/docs/themes/tanuki/examples/book/content/chapter-3.md

@@ -0,0 +1,217 @@
++++
+title = "Chapter 3: JavaScript Essentials"
+description = "Core JavaScript concepts every developer should know."
+weight = 3
++++
+
+# Chapter 3: JavaScript Essentials
+
+JavaScript is the programming language of the web. From simple interactions to complex single-page applications, JavaScript powers the dynamic experiences users expect.
+
+## Variables and Data Types
+
+JavaScript has three ways to declare variables:
+
+```javascript
+var legacy = "Avoid this in modern code";
+let mutable = "Can be reassigned";
+const immutable = "Cannot be reassigned";
+```
+
+### Primitive Types
+
+```javascript
+// String
+const name = "Tanuki";
+
+// Number (integers and floats)
+const count = 42;
+const price = 19.99;
+
+// Boolean
+const isActive = true;
+
+// Null and Undefined
+const empty = null;
+let notAssigned; // undefined
+
+// Symbol (unique identifiers)
+const id = Symbol('id');
+
+// BigInt (large integers)
+const huge = 9007199254740991n;
+```
+
+## Functions
+
+Functions are first-class citizens in JavaScript:
+
+```javascript
+// Function declaration
+function greet(name) {
+    return `Hello, ${name}!`;
+}
+
+// Function expression
+const greet = function(name) {
+    return `Hello, ${name}!`;
+};
+
+// Arrow function
+const greet = (name) => `Hello, ${name}!`;
+
+// Arrow function with body
+const greet = (name) => {
+    const greeting = `Hello, ${name}!`;
+    console.log(greeting);
+    return greeting;
+};
+```
+
+### Higher-Order Functions
+
+Functions that take or return other functions:
+
+```javascript
+const numbers = [1, 2, 3, 4, 5];
+
+// map: transform each element
+const doubled = numbers.map(n => n * 2);
+// [2, 4, 6, 8, 10]
+
+// filter: keep elements that pass a test
+const evens = numbers.filter(n => n % 2 === 0);
+// [2, 4]
+
+// reduce: combine elements into a single value
+const sum = numbers.reduce((acc, n) => acc + n, 0);
+// 15
+```
+
+## Asynchronous JavaScript
+
+The web is inherently asynchronous. JavaScript provides several patterns for handling async operations.
+
+### Promises
+
+```javascript
+function fetchUser(id) {
+    return new Promise((resolve, reject) => {
+        setTimeout(() => {
+            if (id > 0) {
+                resolve({ id, name: 'Tanuki' });
+            } else {
+                reject(new Error('Invalid ID'));
+            }
+        }, 1000);
+    });
+}
+
+fetchUser(1)
+    .then(user => console.log(user.name))
+    .catch(error => console.error(error));
+```
+
+### Async/Await
+
+A cleaner syntax for working with Promises:
+
+```javascript
+async function displayUser(id) {
+    try {
+        const user = await fetchUser(id);
+        console.log(user.name);
+    } catch (error) {
+        console.error('Failed to fetch user:', error);
+    }
+}
+```
+
+## Modules
+
+Modern JavaScript uses ES Modules for code organization:
+
+```javascript
+// math.js
+export const PI = 3.14159;
+
+export function add(a, b) {
+    return a + b;
+}
+
+export default function multiply(a, b) {
+    return a * b;
+}
+```
+
+```javascript
+// main.js
+import multiply, { PI, add } from './math.js';
+
+console.log(PI);           // 3.14159
+console.log(add(2, 3));    // 5
+console.log(multiply(4, 5)); // 20
+```
+
+## The DOM API
+
+Interacting with the Document Object Model:
+
+```javascript
+// Selecting elements
+const button = document.querySelector('.submit-btn');
+const items = document.querySelectorAll('.item');
+
+// Creating elements
+const div = document.createElement('div');
+div.className = 'card';
+div.textContent = 'Hello!';
+
+// Modifying elements
+button.classList.add('active');
+button.setAttribute('disabled', true);
+button.style.backgroundColor = 'blue';
+
+// Event handling
+button.addEventListener('click', (event) => {
+    event.preventDefault();
+    console.log('Clicked!');
+});
+
+// Appending to DOM
+document.body.appendChild(div);
+```
+
+## Error Handling
+
+Robust error handling is crucial:
+
+```javascript
+try {
+    const data = JSON.parse(invalidJson);
+    processData(data);
+} catch (error) {
+    if (error instanceof SyntaxError) {
+        console.error('Invalid JSON:', error.message);
+    } else {
+        throw error; // Re-throw unexpected errors
+    }
+} finally {
+    cleanup();
+}
+```
+
+## Summary
+
+This chapter covered JavaScript fundamentals:
+
+- Variables and data types
+- Functions and higher-order functions
+- Asynchronous programming with Promises and async/await
+- ES Modules for code organization
+- DOM manipulation
+- Error handling
+
+> **Remember**: JavaScript is a multi-paradigm language. You can write imperative, functional, or object-oriented code. Choose the style that best fits your problem.
+
+In the next chapter, we'll explore performance optimization techniques.