@terrymooreii/sia 1.0.1 → 2.0.0

package/lib/new.js

@@ -1,46 +1,384 @@
-import fs from 'fs'
-import path from 'path'
-import config from './readconfig.js'
-import { mkdir } from './helpers.js'
-import slugify from 'slugify'
-
-const { app } = config
-
-export const create = (type, folder) => {
-  if (!type || !folder) {
-    console.log('Must specify a type and folder')
-    process.exit(1)
-  }
-
-  const slugified = slugify(folder, {
-    replacement: '-',
-    lower: true,
-    strict: true,
-    locale: 'en',
-    trim: true,
-  })
-
-  if (!['page', 'post'].includes(type)) {
-    console.log('Invalid type.  post or page')
-    process.exit(1)
-  }
-
-  const date = new Date()
-  const createdAt = date.toISOString()
-
-  const template = `---
-created_at: ${createdAt}
-title: ${slugified}
-description:
-image: 
-template: ${type}
+import prompts from 'prompts';
+import { writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { loadConfig } from './config.js';
+import { slugify } from './content.js';
+
+/**
+ * Get current date in YYYY-MM-DD format
+ */
+function getDateString() {
+  const now = new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, '0');
+  const day = String(now.getDate()).padStart(2, '0');
+  return `${year}-${month}-${day}`;
+}
+
+/**
+ * Get current ISO date string
+ */
+function getISODate() {
+  return new Date().toISOString();
+}
+
+/**
+ * Parse tags string into array
+ */
+function parseTags(tagsInput) {
+  if (!tagsInput || tagsInput.trim() === '') {
+    return [];
+  }
+  return tagsInput
+    .split(',')
+    .map(tag => tag.trim())
+    .filter(tag => tag.length > 0);
+}
+
+/**
+ * Format tags for YAML
+ */
+function formatTags(tags) {
+  if (!tags || tags.length === 0) {
+    return '[]';
+  }
+  return `[${tags.join(', ')}]`;
+}
+
+/**
+ * Create a new post
+ */
+function createPost(config, options) {
+  const slug = slugify(options.title);
+  const date = getDateString();
+  const filename = `${date}-${slug}.md`;
+  const postsDir = join(config.inputDir, config.collections.posts?.path || 'posts');
+  const filePath = join(postsDir, filename);
+  
+  // Ensure directory exists
+  if (!existsSync(postsDir)) {
+    mkdirSync(postsDir, { recursive: true });
+  }
+  
+  let frontMatter = `---
+title: "${options.title}"
+date: ${getISODate()}
+tags: ${formatTags(options.tags)}`;
+
+  if (options.excerpt) {
+    frontMatter += `\nexcerpt: "${options.excerpt}"`;
+  }
+
+  if (options.draft) {
+    frontMatter += `\ndraft: true`;
+  }
+
+  frontMatter += `\n---
+
+${options.content || 'Write your post content here...'}
+`;
+  
+  writeFileSync(filePath, frontMatter, 'utf-8');
+  return filePath;
+}
+
+/**
+ * Create a new page
+ */
+function createPage(config, options) {
+  const slug = slugify(options.title);
+  const filename = `${slug}.md`;
+  const pagesDir = join(config.inputDir, config.collections.pages?.path || 'pages');
+  const filePath = join(pagesDir, filename);
+  
+  // Ensure directory exists
+  if (!existsSync(pagesDir)) {
+    mkdirSync(pagesDir, { recursive: true });
+  }
+  
+  let frontMatter = `---
+title: "${options.title}"
+layout: page`;
+
+  if (options.permalink) {
+    frontMatter += `\npermalink: ${options.permalink}`;
+  }
+
+  frontMatter += `\n---
+
+${options.content || 'Write your page content here...'}
+`;
+  
+  writeFileSync(filePath, frontMatter, 'utf-8');
+  return filePath;
+}
+
+/**
+ * Create a new note (short post)
+ */
+function createNote(config, options) {
+  const slug = options.title ? slugify(options.title) : 'note';
+  const date = getDateString();
+  const timestamp = Date.now();
+  const filename = `${date}-${slug}-${timestamp}.md`;
+  const notesDir = join(config.inputDir, config.collections.notes?.path || 'notes');
+  const filePath = join(notesDir, filename);
+  
+  // Ensure directory exists
+  if (!existsSync(notesDir)) {
+    mkdirSync(notesDir, { recursive: true });
+  }
+  
+  const content = `---
+date: ${getISODate()}
+tags: ${formatTags(options.tags)}
 ---
 
-Add ${type} content here
+${options.content || options.title || 'Write your note here...'}
+`;
+  
+  writeFileSync(filePath, content, 'utf-8');
+  return filePath;
+}
+
+/**
+ * Prompt for post options
+ */
+async function promptForPost(initialTitle) {
+  const answers = await prompts([
+    {
+      type: 'text',
+      name: 'title',
+      message: 'Post title:',
+      initial: initialTitle || '',
+      validate: value => value.length > 0 ? true : 'Title is required'
+    },
+    {
+      type: 'text',
+      name: 'tags',
+      message: 'Tags (comma-separated):',
+      initial: ''
+    },
+    {
+      type: 'text',
+      name: 'excerpt',
+      message: 'Excerpt (optional):',
+      initial: ''
+    },
+    {
+      type: 'confirm',
+      name: 'draft',
+      message: 'Save as draft?',
+      initial: true
+    }
+  ]);
+
+  if (!answers.title) {
+    return null;
+  }
+
+  return {
+    title: answers.title,
+    tags: parseTags(answers.tags),
+    excerpt: answers.excerpt || null,
+    draft: answers.draft
+  };
+}
+
+/**
+ * Prompt for page options
+ */
+async function promptForPage(initialTitle) {
+  const answers = await prompts([
+    {
+      type: 'text',
+      name: 'title',
+      message: 'Page title:',
+      initial: initialTitle || '',
+      validate: value => value.length > 0 ? true : 'Title is required'
+    },
+    {
+      type: 'text',
+      name: 'permalink',
+      message: 'Custom permalink (optional, e.g., /about/):',
+      initial: ''
+    }
+  ]);
 
-`
+  if (!answers.title) {
+    return null;
+  }
 
-  const root = path.join(app.src, app.content, slugified)
-  mkdir(root)
-  fs.writeFileSync(path.join(root, `index.md`), template)
+  return {
+    title: answers.title,
+    permalink: answers.permalink || null
+  };
 }
+
+/**
+ * Prompt for note options
+ */
+async function promptForNote(initialContent) {
+  const answers = await prompts([
+    {
+      type: 'text',
+      name: 'content',
+      message: 'Note content:',
+      initial: initialContent || '',
+      validate: value => value.length > 0 ? true : 'Content is required'
+    },
+    {
+      type: 'text',
+      name: 'tags',
+      message: 'Tags (comma-separated):',
+      initial: ''
+    }
+  ]);
+
+  if (!answers.content) {
+    return null;
+  }
+
+  return {
+    title: answers.content.substring(0, 50),
+    content: answers.content,
+    tags: parseTags(answers.tags)
+  };
+}
+
+/**
+ * Prompt for content type
+ */
+async function promptForType() {
+  const answer = await prompts({
+    type: 'select',
+    name: 'type',
+    message: 'What would you like to create?',
+    choices: [
+      { title: 'Post', description: 'A blog post with title, date, and tags', value: 'post' },
+      { title: 'Page', description: 'A static page (e.g., About, Contact)', value: 'page' },
+      { title: 'Note', description: 'A short note or quick thought', value: 'note' }
+    ],
+    initial: 0
+  });
+
+  return answer.type;
+}
+
+/**
+ * New command handler for CLI
+ */
+export async function newCommand(type, title, cmdOptions = {}) {
+  const config = loadConfig(process.cwd());
+  
+  // Quick mode - skip prompts if type and title provided
+  const quickMode = cmdOptions.quick || false;
+  
+  // If quick mode with all required args, skip prompts
+  if (quickMode && type && title) {
+    let filePath;
+    const tags = cmdOptions.tags ? parseTags(cmdOptions.tags) : [];
+    
+    switch (type.toLowerCase()) {
+      case 'post':
+        filePath = createPost(config, {
+          title,
+          tags,
+          draft: cmdOptions.draft !== false,
+          excerpt: null
+        });
+        console.log(`\n✨ Created new post: ${filePath}`);
+        if (cmdOptions.draft !== false) {
+          console.log('   📋 Saved as draft - remove "draft: true" when ready to publish.');
+        }
+        break;
+        
+      case 'page':
+        filePath = createPage(config, { title, permalink: null });
+        console.log(`\n✨ Created new page: ${filePath}`);
+        break;
+        
+      case 'note':
+        filePath = createNote(config, { title, content: title, tags });
+        console.log(`\n✨ Created new note: ${filePath}`);
+        break;
+        
+      default:
+        console.error(`\n❌ Unknown content type: ${type}`);
+        console.log('   Available types: post, page, note\n');
+        process.exit(1);
+    }
+    console.log('');
+    return;
+  }
+
+  console.log('\n📝 Create new content\n');
+
+  // If no type provided, prompt for it
+  let contentType = type;
+  if (!contentType) {
+    contentType = await promptForType();
+    if (!contentType) {
+      console.log('\n❌ Cancelled.\n');
+      return;
+    }
+  }
+
+  let filePath;
+  let options;
+
+  switch (contentType.toLowerCase()) {
+    case 'post':
+      options = await promptForPost(title);
+      if (!options) {
+        console.log('\n❌ Cancelled.\n');
+        return;
+      }
+      // Apply command line options if provided
+      if (cmdOptions.tags) {
+        options.tags = [...options.tags, ...parseTags(cmdOptions.tags)];
+      }
+      if (cmdOptions.draft !== undefined) {
+        options.draft = cmdOptions.draft;
+      }
+      filePath = createPost(config, options);
+      console.log(`\n✨ Created new post: ${filePath}`);
+      if (options.draft) {
+        console.log('   📋 Saved as draft - remove "draft: true" when ready to publish.');
+      }
+      break;
+      
+    case 'page':
+      options = await promptForPage(title);
+      if (!options) {
+        console.log('\n❌ Cancelled.\n');
+        return;
+      }
+      filePath = createPage(config, options);
+      console.log(`\n✨ Created new page: ${filePath}`);
+      break;
+      
+    case 'note':
+      options = await promptForNote(title);
+      if (!options) {
+        console.log('\n❌ Cancelled.\n');
+        return;
+      }
+      // Apply command line options if provided
+      if (cmdOptions.tags) {
+        options.tags = [...(options.tags || []), ...parseTags(cmdOptions.tags)];
+      }
+      filePath = createNote(config, options);
+      console.log(`\n✨ Created new note: ${filePath}`);
+      break;
+      
+    default:
+      console.error(`\n❌ Unknown content type: ${contentType}`);
+      console.log('   Available types: post, page, note\n');
+      process.exit(1);
+  }
+
+  console.log('');
+}
+
+export default { newCommand };

package/lib/server.js

@@ -0,0 +1,257 @@
+import { createServer } from 'http';
+import { readFileSync, existsSync, statSync } from 'fs';
+import { join, extname } from 'path';
+import { WebSocketServer } from 'ws';
+import chokidar from 'chokidar';
+import { loadConfig } from './config.js';
+import { build } from './build.js';
+
+// MIME types for common file extensions
+const MIME_TYPES = {
+  '.html': 'text/html',
+  '.css': 'text/css',
+  '.js': 'application/javascript',
+  '.json': 'application/json',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.svg': 'image/svg+xml',
+  '.webp': 'image/webp',
+  '.ico': 'image/x-icon',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.ttf': 'font/ttf',
+  '.xml': 'application/xml',
+  '.txt': 'text/plain',
+  '.pdf': 'application/pdf'
+};
+
+// Live reload script to inject into HTML pages
+const LIVE_RELOAD_SCRIPT = `
+<script>
+(function() {
+  const ws = new WebSocket('ws://' + window.location.hostname + ':{{WS_PORT}}');
+  ws.onmessage = function(event) {
+    if (event.data === 'reload') {
+      console.log('[Sia] Reloading...');
+      window.location.reload();
+    }
+  };
+  ws.onopen = function() {
+    console.log('[Sia] Live reload connected');
+  };
+  ws.onclose = function() {
+    console.log('[Sia] Live reload disconnected');
+    // Try to reconnect
+    setTimeout(function() {
+      window.location.reload();
+    }, 1000);
+  };
+})();
+</script>
+`;
+
+/**
+ * Inject live reload script into HTML
+ */
+function injectLiveReload(html, wsPort) {
+  const script = LIVE_RELOAD_SCRIPT.replace('{{WS_PORT}}', wsPort);
+  return html.replace('</body>', script + '</body>');
+}
+
+/**
+ * Create the HTTP server
+ */
+function createHttpServer(config, wsPort) {
+  const server = createServer((req, res) => {
+    // Parse URL
+    let urlPath = req.url.split('?')[0];
+    
+    // Handle root and trailing slashes
+    if (urlPath.endsWith('/')) {
+      urlPath += 'index.html';
+    }
+    
+    // Build the file path
+    let filePath = join(config.outputDir, urlPath);
+    
+    // Check if file exists, try adding .html
+    if (!existsSync(filePath)) {
+      const htmlPath = filePath + '.html';
+      if (existsSync(htmlPath)) {
+        filePath = htmlPath;
+      } else {
+        // Try index.html in directory
+        const indexPath = join(filePath, 'index.html');
+        if (existsSync(indexPath)) {
+          filePath = indexPath;
+        }
+      }
+    }
+    
+    // 404 if file still doesn't exist
+    if (!existsSync(filePath) || !statSync(filePath).isFile()) {
+      res.writeHead(404, { 'Content-Type': 'text/html' });
+      res.end('<h1>404 - Not Found</h1>');
+      console.log(`  404 ${req.url}`);
+      return;
+    }
+    
+    // Get MIME type
+    const ext = extname(filePath).toLowerCase();
+    const mimeType = MIME_TYPES[ext] || 'application/octet-stream';
+    
+    // Read and serve file
+    try {
+      let content = readFileSync(filePath);
+      
+      // Inject live reload script into HTML files
+      if (ext === '.html') {
+        content = injectLiveReload(content.toString(), wsPort);
+      }
+      
+      res.writeHead(200, { 'Content-Type': mimeType });
+      res.end(content);
+      console.log(`  200 ${req.url}`);
+    } catch (err) {
+      res.writeHead(500, { 'Content-Type': 'text/html' });
+      res.end('<h1>500 - Internal Server Error</h1>');
+      console.error(`  500 ${req.url}: ${err.message}`);
+    }
+  });
+  
+  return server;
+}
+
+/**
+ * Create WebSocket server for live reload
+ */
+function createWsServer(port) {
+  const wss = new WebSocketServer({ port });
+  
+  wss.on('connection', (ws) => {
+    console.log('🔌 Live reload client connected');
+  });
+  
+  return wss;
+}
+
+/**
+ * Notify all connected clients to reload
+ */
+function notifyReload(wss) {
+  wss.clients.forEach((client) => {
+    if (client.readyState === 1) { // WebSocket.OPEN
+      client.send('reload');
+    }
+  });
+}
+
+/**
+ * Set up file watcher
+ */
+function setupWatcher(config, wss) {
+  // Watch source files and config
+  const watchPaths = [
+    config.inputDir,
+    config.layoutsDir,
+    config.includesDir,
+    join(config.rootDir, '_config.yml'),
+    join(config.rootDir, '_config.json'),
+    join(config.rootDir, 'styles')
+  ].filter(p => existsSync(p));
+  
+  const watcher = chokidar.watch(watchPaths, {
+    ignored: /(^|[\/\\])\../, // Ignore dot files
+    persistent: true,
+    ignoreInitial: true
+  });
+  
+  let rebuildTimeout = null;
+  
+  const triggerRebuild = async (event, path) => {
+    // Debounce rapid changes
+    if (rebuildTimeout) {
+      clearTimeout(rebuildTimeout);
+    }
+    
+    rebuildTimeout = setTimeout(async () => {
+      console.log(`\n📝 ${event}: ${path}`);
+      console.log('🔄 Rebuilding...\n');
+      
+      try {
+        await build({ clean: false, rootDir: config.rootDir });
+        notifyReload(wss);
+      } catch (err) {
+        console.error('❌ Rebuild failed:', err.message);
+      }
+    }, 100);
+  };
+  
+  watcher.on('change', (path) => triggerRebuild('Changed', path));
+  watcher.on('add', (path) => triggerRebuild('Added', path));
+  watcher.on('unlink', (path) => triggerRebuild('Removed', path));
+  
+  return watcher;
+}
+
+/**
+ * Start the development server
+ */
+export async function startServer(options = {}) {
+  const config = loadConfig(options.rootDir || process.cwd());
+  const httpPort = parseInt(options.port) || config.server.port || 3000;
+  const wsPort = httpPort + 1;
+  
+  console.log('\n⚡ Sia - Development Server\n');
+  
+  // Initial build
+  await build({ clean: true, rootDir: config.rootDir });
+  
+  // Create servers
+  const httpServer = createHttpServer(config, wsPort);
+  const wss = createWsServer(wsPort);
+  
+  // Start HTTP server
+  httpServer.listen(httpPort, () => {
+    console.log(`\n🚀 Server running at http://localhost:${httpPort}`);
+    console.log(`🔄 Live reload on ws://localhost:${wsPort}`);
+    console.log('\n👀 Watching for changes...\n');
+  });
+  
+  // Set up file watcher
+  const watcher = setupWatcher(config, wss);
+  
+  // Handle shutdown
+  const shutdown = () => {
+    console.log('\n\n👋 Shutting down...');
+    watcher.close();
+    wss.close();
+    httpServer.close();
+    process.exit(0);
+  };
+  
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+  
+  return { httpServer, wss, watcher };
+}
+
+/**
+ * Dev command handler for CLI
+ */
+export async function devCommand(options) {
+  try {
+    await startServer({
+      port: options.port,
+      rootDir: process.cwd()
+    });
+  } catch (err) {
+    console.error('❌ Server failed to start:', err.message);
+    process.exit(1);
+  }
+}
+
+export default { startServer, devCommand };
+