vending-mocha 0.1.0

package/posts/hello-world.md

@@ -0,0 +1,20 @@
+---
+title: "Welcome to Vending Mocha ☕"
+date: "2026-02-17 00:00:00"
+summary: "Welcome to your new blogging framework! This is a sample post to get you started."
+---
+
+## Hello World!
+
+Welcome to **Vending Mocha**! This is a sample post. You can edit this file or add new Markdown files to the `/posts` directory to start blogging.
+
+### Features
+
+- **Simple and Clean UI**: Minimalist design that focuses on readability.
+- **Markdown Support**: write your posts in Markdown.
+- **Code Highlighting**: Syntax highlighting for code blocks.
+- **SSG**: Static Site Generation for optimal performance.
+- **Theme Support**: Customize your blog with different themes.
+- **Deployment**: Ready for GitHub Pages deployment.
+
+Enjoy building your new site! 🚀

package/posts/markdown-features.md

@@ -0,0 +1,57 @@
+---
+title: "Markdown Features Demo 📝"
+date: "2026-02-17 02:00:00"
+summary: "A demonstration of the Markdown features supported by Vending Mocha, including code blocks, lists, and formatting."
+---
+
+## Markdown Features
+
+**Vending Mocha** isn't just about text; it supports a wide range of Markdown features to help you write rich content.
+
+### Typography
+
+You can use **bold**, *italics*, and ~~strikethrough~~ text.
+
+> "Blockquotes are great for emphasizing important information or quoting sources."
+
+### Lists
+
+#### Unordered List
+- Item 1
+- Item 2
+  - Subitem 2.1
+  - Subitem 2.2
+
+#### Ordered List
+1. First step
+2. Second step
+3. Third step
+
+### Code Blocks
+
+You can write code blocks with syntax highlighting!
+
+```typescript
+interface User {
+  id: number;
+  name: string;
+  role: 'admin' | 'user';
+}
+
+const getUser = (id: number): User => {
+  return {
+    id,
+    name: 'Jane Doe',
+    role: 'admin'
+  };
+};
+```
+
+### Links and Images
+
+You can link to [Google](https://google.com) or internal pages.
+
+![Vending Mocha](/images/profile.png?vmw=300&vmh=300)
+
+
+Happy writing! ✍️

package/prerender.js

@@ -0,0 +1,221 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import prettier from 'prettier';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const toAbsolute = (p) => path.resolve(__dirname, p);
+
+
+
+async function prerender() {
+    // 1. Read the template (client build output)
+    const templatePath = toAbsolute('docs/index.html');
+    if (!fs.existsSync(templatePath)) {
+        console.error('docs/index.html not found. Run client build first.');
+        process.exit(1);
+    }
+    const template = fs.readFileSync(templatePath, 'utf-8');
+
+    // 2. Import the server entry (SSR build output)
+    const serverEntryPath = toAbsolute('dist/server/entry-server.js');
+    if (!fs.existsSync(serverEntryPath)) {
+        console.error('dist/server/entry-server.js not found. Run server build first.');
+        process.exit(1);
+    }
+    const { render, siteConfig } = await import(serverEntryPath);
+
+    let basePath = '/';
+    try {
+        if (siteConfig.url) {
+            const url = new URL(siteConfig.url);
+            basePath = url.pathname.endsWith('/') ? url.pathname : `${url.pathname}/`;
+        }
+    } catch (e) {
+        console.warn('Invalid siteConfig.url, defaulting to /');
+    }
+    const normalizedBasePath = basePath;
+
+    // 3. Determine routes to prerender
+    const routesToPrerender = ['/', '/projects/'];
+
+    // Add blog post routes and pagination
+    const postsPath = toAbsolute('src/posts.json');
+    if (fs.existsSync(postsPath)) {
+        const posts = JSON.parse(fs.readFileSync(postsPath, 'utf-8'));
+
+        // Add post routes
+        posts.forEach(post => {
+            routesToPrerender.push(`/post/${post.slug}/`);
+        });
+
+        // Add paginated routes
+        const POSTS_PER_PAGE = 50;
+        const totalPages = Math.ceil(posts.length / POSTS_PER_PAGE);
+        for (let i = 2; i <= totalPages; i++) {
+            routesToPrerender.push(`/page/${i}/`);
+        }
+    }
+
+    // Generate theme.js content once
+    const themeHash = Math.random().toString(36).substring(2, 10);
+    const themeFilename = `theme.${themeHash}.js`;
+    const themeJsContent = `
+(function() {
+    const themeConfig = ${JSON.stringify(siteConfig.theme)};
+    const STORAGE_KEY = 'theme';
+    const PREFERS_DARK = window.matchMedia('(prefers-color-scheme: dark)');
+
+    function getTheme() {
+        const savedTheme = localStorage.getItem(STORAGE_KEY);
+        if (savedTheme) return savedTheme;
+        return PREFERS_DARK.matches ? 'dark' : 'light';
+    }
+
+    function setTheme(theme) {
+        const root = document.documentElement;
+        const config = themeConfig[theme];
+        
+        for (const [key, value] of Object.entries(config)) {
+            // Check if key maps to CSS vars we use. 
+            // The config keys (primary, secondary, etc) map to --color-[key]
+            // Exception: linkColor -> --color-link, cardBackground -> --color-card-bg
+            
+            let cssVar = \`--color-\${key}\`;
+            if (key === 'linkColor') cssVar = '--color-link';
+            if (key === 'cardBackground') cssVar = '--color-card-bg';
+            
+            root.style.setProperty(cssVar, value);
+        }
+        root.style.setProperty('--font-family', themeConfig.fontFamily);
+        
+        localStorage.setItem(STORAGE_KEY, theme);
+        
+        // Update toggle button icon visibility if needed (could be CSS based)
+        document.documentElement.setAttribute('data-theme', theme);
+    }
+
+    // Initial setup
+    setTheme(getTheme());
+
+    // Listen for system changes
+    PREFERS_DARK.addEventListener('change', (e) => {
+        if (!localStorage.getItem(STORAGE_KEY)) {
+            setTheme(e.matches ? 'dark' : 'light');
+        }
+    });
+
+    // Setup toggle button listener when DOM is ready
+    document.addEventListener('DOMContentLoaded', () => {
+        const toggleBtn = document.querySelector('.theme-toggle');
+        if (toggleBtn) {
+            toggleBtn.addEventListener('click', () => {
+                const current = getTheme();
+                const next = current === 'light' ? 'dark' : 'light';
+                setTheme(next);
+            });
+        }
+
+        const hamburgerBtn = document.querySelector('.hamburger-menu');
+        const topNav = document.querySelector('.top-nav');
+        if (hamburgerBtn && topNav) {
+            hamburgerBtn.addEventListener('click', () => {
+                topNav.classList.toggle('active');
+            });
+            
+            // Close menu when clicking links
+             topNav.querySelectorAll('a').forEach(link => {
+                link.addEventListener('click', () => {
+                   topNav.classList.remove('active'); 
+                });
+            });
+        }
+    });
+})();
+`;
+    // Write theme.js
+    const themeJsPath = toAbsolute(`docs/assets/${themeFilename}`);
+    if (!fs.existsSync(path.dirname(themeJsPath))) {
+        fs.mkdirSync(path.dirname(themeJsPath), { recursive: true });
+    }
+    fs.writeFileSync(themeJsPath, themeJsContent);
+    console.log(`Generated ${themeFilename}`);
+
+    // 4. Render and save each route
+    for (const url of routesToPrerender) {
+        try {
+            const renderUrl = url === '/' ? normalizedBasePath : `${normalizedBasePath}${url.startsWith('/') ? url.slice(1) : url}`;
+            const { html: renderedHtml, helmet } = render(renderUrl);
+
+            let html = template.replace('<!--app-html-->', renderedHtml);
+
+
+
+            const helmetHead = `
+                ${helmet.title.toString()}
+                ${helmet.meta.toString()}
+                ${helmet.link.toString()}
+                ${helmet.script.toString()}
+                <link rel="alternate" type="application/rss+xml" title="RSS Feed for Krishna Thota" href="${normalizedBasePath}rss.xml" />
+                <script src="${normalizedBasePath}assets/${themeFilename}"></script>
+            `;
+
+            html = html.replace('<!--app-head-->', helmetHead);
+
+            // Strip out the client-side React bundle scripts and preloads
+            const escapedBase = normalizedBasePath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const scriptRegex = new RegExp(`<script type="module" crossorigin src="${escapedBase}assets\\/index-[^"]+\\.js"><\\/script>`, 'g');
+            const preloadRegex = new RegExp(`<link rel="modulepreload" crossorigin href="${escapedBase}assets\\/[^"]+">`, 'g');
+
+            html = html.replace(scriptRegex, '');
+            html = html.replace(preloadRegex, '');
+
+            const formattedHtml = await prettier.format(html, { parser: 'html' });
+
+            // Determine output file path
+            // For '/', it is docs/index.html
+            // For others, it is docs/subpath/index.html (to support clean URLs)
+            let filePath = `docs${url === '/' ? '/index.html' : `${url}/index.html`}`;
+            const absoluteFilePath = toAbsolute(filePath);
+            const dir = path.dirname(absoluteFilePath);
+
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+
+            fs.writeFileSync(absoluteFilePath, formattedHtml);
+            console.log(`Pre-rendered: ${url} -> ${filePath}`);
+        } catch (e) {
+            console.error(`Failed to render ${url}:`, e);
+        }
+    }
+
+    // 5. Generate Sitemap
+    // siteConfig is already imported above
+    const sitemap = `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+  ${routesToPrerender.map(url => `
+  <url>
+    <loc>${siteConfig.url.replace(/\/$/, '')}${url}</loc>
+    <lastmod>${new Date().toISOString().split('T')[0]}</lastmod>
+  </url>
+  `).join('')}
+</urlset>`;
+
+    fs.writeFileSync(toAbsolute('docs/sitemap.xml'), sitemap);
+    console.log('Generated sitemap.xml');
+
+    // 6. Cleanup unused assets
+    const assetsDir = toAbsolute('docs/assets');
+    if (fs.existsSync(assetsDir)) {
+        const files = fs.readdirSync(assetsDir);
+        for (const file of files) {
+            if (file.endsWith('.js') && file !== themeFilename) {
+                fs.unlinkSync(path.join(assetsDir, file));
+                console.log(`Deleted unused asset: ${file}`);
+            }
+        }
+    }
+}
+
+prerender();

package/projects/legacy-api.md

@@ -0,0 +1,7 @@
+---
+title: "Legacy API Wrapper"
+description: "An old library I wrote back in 2018. No longer maintained but good for reference."
+link: "https://example.com/legacy-api"
+status: "dead"
+weight: 1
+---

package/projects/task-master.md

@@ -0,0 +1,7 @@
+---
+title: "Task Master 3000"
+description: "A productivity application for managing daily tasks and goals efficiently."
+link: "https://example.com/task-master"
+status: "inactive"
+weight: 5
+---

package/projects/vending-mocha.md

@@ -0,0 +1,7 @@
+---
+title: "Vending Mocha"
+description: "A lightweight, blazing fast, personal blogging framework built with React."
+link: "https://github.com/kcthota/vending-mocha"
+status: "active"
+weight: 10
+---

package/scripts/generate-posts-data.js

@@ -0,0 +1,41 @@
+import fs from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const postsDir = path.join(__dirname, '../posts');
+const outputFile = path.join(__dirname, '../src/posts.json');
+
+function generatePostsData() {
+    if (!fs.existsSync(postsDir)) {
+        console.log('No posts directory found.');
+        return;
+    }
+
+    const files = fs.readdirSync(postsDir).filter(file => file.endsWith('.md'));
+    const posts = files.map(file => {
+        const filePath = path.join(postsDir, file);
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const { data } = matter(content);
+        const slug = file.replace('.md', '');
+
+        return {
+            slug,
+            title: data.title || 'Untitled',
+            date: data.date || 'Unknown Date',
+            summary: data.summary || '',
+            weight: data.weight || 0
+        };
+    });
+
+    // Sort by date descending
+    posts.sort((a, b) => new Date(b.date) - new Date(a.date));
+
+    fs.writeFileSync(outputFile, JSON.stringify(posts, null, 2));
+    console.log(`Generated ${posts.length} posts in ${outputFile}`);
+}
+
+generatePostsData();

package/scripts/generate-projects-data.js

@@ -0,0 +1,40 @@
+import fs from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const projectsDir = path.join(__dirname, '../projects');
+const outputFile = path.join(__dirname, '../src/projects.json');
+
+function generateProjectsData() {
+    if (!fs.existsSync(projectsDir)) {
+        console.log('No projects directory found.');
+        return;
+    }
+
+    const files = fs.readdirSync(projectsDir).filter(file => file.endsWith('.md'));
+    const projects = files.map(file => {
+        const filePath = path.join(projectsDir, file);
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const { data } = matter(content);
+
+        return {
+            name: data.title || 'Untitled Project',
+            description: data.description || '',
+            link: data.link || '#',
+            status: data.status || 'inactive',
+            weight: data.weight || 0
+        };
+    });
+
+    // Sort by weight descending
+    projects.sort((a, b) => b.weight - a.weight);
+
+    fs.writeFileSync(outputFile, JSON.stringify(projects, null, 2));
+    console.log(`Generated ${projects.length} projects in ${outputFile}`);
+}
+
+generateProjectsData();

package/scripts/generate-rss.js

@@ -0,0 +1,75 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const postsPath = path.join(__dirname, '../src/posts.json');
+const docsDir = path.join(__dirname, '../docs');
+const outputFile = path.join(docsDir, 'rss.xml');
+
+// Import site config
+const configPath = path.join(__dirname, '../src/site.config.ts');
+// Simple extraction of values from site.config.ts since it's TS and we are in JS environment
+const configContent = fs.readFileSync(configPath, 'utf-8');
+const siteTitle = configContent.match(/title:\s*"(.*?)"/)?.[1] || 'My Blog';
+const siteUrl = configContent.match(/url:\s*"(.*?)"/)?.[1] || 'http://localhost:3000';
+const siteDescription = configContent.match(/description:\s*`(.*?)`/s)?.[1].replace(/\*\*/g, '').replace(/👋/g, '').trim() || '';
+// Derive base path from URL
+let derivedBasePath = '/';
+try {
+    if (siteUrl) {
+        const urlObj = new URL(siteUrl);
+        derivedBasePath = urlObj.pathname.endsWith('/') ? urlObj.pathname : `${urlObj.pathname}/`;
+    }
+} catch (e) {
+    console.warn('Invalid siteUrl, defaulting to /');
+}
+
+const normalizedBasePath = derivedBasePath;
+
+function generateRSS() {
+    if (!fs.existsSync(postsPath)) {
+        console.error('posts.json not found. Run generate-posts-data.js first.');
+        return;
+    }
+
+    if (!fs.existsSync(docsDir)) {
+        fs.mkdirSync(docsDir, { recursive: true });
+    }
+
+    const posts = JSON.parse(fs.readFileSync(postsPath, 'utf-8')).slice(0, 25);
+
+    const items = posts.map(post => {
+        const url = `${siteUrl.replace(/\/$/, '')}/post/${post.slug}`;
+        const pubDate = new Date(post.date).toUTCString();
+
+        return `
+    <item>
+      <title><![CDATA[${post.title}]]></title>
+      <link>${url}</link>
+      <guid isPermaLink="true">${url}</guid>
+      <pubDate>${pubDate}</pubDate>
+      <description><![CDATA[${post.summary}]]></description>
+    </item>`;
+    }).join('');
+
+    const rss = `<?xml version="1.0" encoding="UTF-8" ?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
+<channel>
+  <title>${siteTitle}</title>
+  <link>${siteUrl}</link>
+  <description>${siteDescription}</description>
+  <language>en-us</language>
+  <lastBuildDate>${new Date().toUTCString()}</lastBuildDate>
+  <atom:link href="${siteUrl.replace(/\/$/, '')}/rss.xml" rel="self" type="application/rss+xml" />
+  ${items}
+</channel>
+</rss>`;
+
+    fs.writeFileSync(outputFile, rss);
+    console.log(`Generated RSS feed with ${posts.length} posts at ${outputFile}`);
+}
+
+generateRSS();