@terrymooreii/sia 1.0.2 → 2.0.0

package/lib/config.js

@@ -0,0 +1,114 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import yaml from 'js-yaml';
+
+// Default configuration
+const defaultConfig = {
+  site: {
+    title: 'My Site',
+    description: 'A static site built with Static Forge',
+    url: 'http://localhost:3000',
+    author: 'Anonymous'
+  },
+  input: 'src',
+  output: 'dist',
+  layouts: '_layouts',
+  includes: '_includes',
+  collections: {
+    posts: {
+      path: 'posts',
+      layout: 'post',
+      permalink: '/blog/:slug/',
+      sortBy: 'date',
+      sortOrder: 'desc'
+    },
+    pages: {
+      path: 'pages',
+      layout: 'page',
+      permalink: '/:slug/'
+    },
+    notes: {
+      path: 'notes',
+      layout: 'note',
+      permalink: '/notes/:slug/',
+      sortBy: 'date',
+      sortOrder: 'desc'
+    }
+  },
+  pagination: {
+    size: 10
+  },
+  server: {
+    port: 3000
+  }
+};
+
+/**
+ * Deep merge two objects
+ */
+function deepMerge(target, source) {
+  const result = { ...target };
+  
+  for (const key in source) {
+    if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+      result[key] = deepMerge(result[key] || {}, source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+  
+  return result;
+}
+
+/**
+ * Load configuration from YAML or JSON file
+ */
+export function loadConfig(rootDir = process.cwd()) {
+  let userConfig = {};
+  
+  // Try to load _config.yml first, then _config.json
+  const yamlPath = join(rootDir, '_config.yml');
+  const jsonPath = join(rootDir, '_config.json');
+  
+  if (existsSync(yamlPath)) {
+    try {
+      const content = readFileSync(yamlPath, 'utf-8');
+      userConfig = yaml.load(content) || {};
+      console.log('📄 Loaded configuration from _config.yml');
+    } catch (err) {
+      console.error('Error parsing _config.yml:', err.message);
+    }
+  } else if (existsSync(jsonPath)) {
+    try {
+      const content = readFileSync(jsonPath, 'utf-8');
+      userConfig = JSON.parse(content);
+      console.log('📄 Loaded configuration from _config.json');
+    } catch (err) {
+      console.error('Error parsing _config.json:', err.message);
+    }
+  } else {
+    console.log('⚠️  No config file found, using defaults');
+  }
+  
+  // Merge user config with defaults
+  const config = deepMerge(defaultConfig, userConfig);
+  
+  // Add computed paths
+  config.rootDir = rootDir;
+  config.inputDir = join(rootDir, config.input);
+  config.outputDir = join(rootDir, config.output);
+  config.layoutsDir = join(rootDir, config.layouts);
+  config.includesDir = join(rootDir, config.includes);
+  
+  return config;
+}
+
+/**
+ * Get the default configuration
+ */
+export function getDefaultConfig() {
+  return { ...defaultConfig };
+}
+
+export default { loadConfig, getDefaultConfig };
+

package/lib/content.js

@@ -0,0 +1,323 @@
+import { readFileSync, readdirSync, statSync, existsSync } from 'fs';
+import { join, basename, extname, relative } from 'path';
+import matter from 'gray-matter';
+import { Marked } from 'marked';
+import { markedHighlight } from 'marked-highlight';
+import { markedEmoji } from 'marked-emoji';
+import hljs from 'highlight.js';
+
+/**
+ * Default emoji map for shortcode support
+ * Common emojis - extend as needed
+ */
+const emojis = {
+  smile: '😄',
+  grinning: '😀',
+  joy: '😂',
+  heart: '❤️',
+  thumbsup: '👍',
+  thumbsdown: '👎',
+  clap: '👏',
+  fire: '🔥',
+  rocket: '🚀',
+  star: '⭐',
+  sparkles: '✨',
+  check: '✅',
+  x: '❌',
+  warning: '⚠️',
+  bulb: '💡',
+  memo: '📝',
+  book: '📖',
+  link: '🔗',
+  eyes: '👀',
+  thinking: '🤔',
+  wave: '👋',
+  pray: '🙏',
+  muscle: '💪',
+  tada: '🎉',
+  party: '🥳',
+  coffee: '☕',
+  bug: '🐛',
+  wrench: '🔧',
+  hammer: '🔨',
+  gear: '⚙️',
+  lock: '🔒',
+  key: '🔑',
+  zap: '⚡',
+  bomb: '💣',
+  gem: '💎',
+  trophy: '🏆',
+  medal: '🏅',
+  crown: '👑',
+  sun: '☀️',
+  moon: '🌙',
+  cloud: '☁️',
+  rain: '🌧️',
+  snow: '❄️',
+  earth: '🌍',
+  tree: '🌳',
+  flower: '🌸',
+  apple: '🍎',
+  pizza: '🍕',
+  beer: '🍺',
+  wine: '🍷',
+  cat: '🐱',
+  dog: '🐶',
+  bird: '🐦',
+  fish: '🐟',
+  whale: '🐳',
+  snake: '🐍',
+  turtle: '🐢',
+  octopus: '🐙',
+  crab: '🦀',
+  shrimp: '🦐',
+  100: '💯',
+  '+1': '👍',
+  '-1': '👎',
+};
+
+/**
+ * Configure marked with syntax highlighting and emoji support
+ */
+const marked = new Marked(
+  markedHighlight({
+    langPrefix: 'hljs language-',
+    highlight(code, lang) {
+      if (lang && hljs.getLanguage(lang)) {
+        try {
+          return hljs.highlight(code, { language: lang }).value;
+        } catch (err) {
+          console.warn(`Highlight.js error for language "${lang}":`, err.message);
+        }
+      }
+      // Auto-detect language if not specified
+      try {
+        return hljs.highlightAuto(code).value;
+      } catch (err) {
+        return code;
+      }
+    }
+  }),
+  markedEmoji({
+    emojis,
+    renderer: (token) => token.emoji
+  })
+);
+
+// Configure marked options
+marked.setOptions({
+  gfm: true,
+  breaks: false
+});
+
+/**
+ * Generate a URL-friendly slug from a string
+ */
+export function slugify(str) {
+  return str
+    .toLowerCase()
+    .replace(/[^\w\s-]/g, '')
+    .replace(/[\s_-]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+/**
+ * Extract slug from filename (removes date prefix if present)
+ */
+export function getSlugFromFilename(filename) {
+  // Remove extension
+  const name = basename(filename, extname(filename));
+  
+  // Check for date prefix pattern: YYYY-MM-DD-slug
+  const datePattern = /^\d{4}-\d{2}-\d{2}-(.+)$/;
+  const match = name.match(datePattern);
+  
+  if (match) {
+    return match[1];
+  }
+  
+  return slugify(name);
+}
+
+/**
+ * Extract date from filename if present
+ */
+export function getDateFromFilename(filename) {
+  const name = basename(filename, extname(filename));
+  const datePattern = /^(\d{4}-\d{2}-\d{2})/;
+  const match = name.match(datePattern);
+  
+  if (match) {
+    return new Date(match[1]);
+  }
+  
+  return null;
+}
+
+/**
+ * Parse a markdown file with front matter
+ */
+export function parseContent(filePath) {
+  const content = readFileSync(filePath, 'utf-8');
+  const { data: frontMatter, content: markdown } = matter(content);
+  
+  // Parse markdown to HTML
+  const html = marked.parse(markdown);
+  
+  // Get slug from front matter or filename
+  const slug = frontMatter.slug || getSlugFromFilename(filePath);
+  
+  // Get date from front matter or filename
+  let date = frontMatter.date;
+  if (date) {
+    date = new Date(date);
+  } else {
+    date = getDateFromFilename(filePath) || new Date();
+  }
+  
+  // Extract excerpt (first paragraph or custom excerpt)
+  let excerpt = frontMatter.excerpt;
+  if (!excerpt) {
+    const firstParagraph = markdown.split('\n\n')[0];
+    excerpt = firstParagraph.replace(/^#+\s+.+\n?/, '').trim();
+    // Limit excerpt length
+    if (excerpt.length > 200) {
+      excerpt = excerpt.substring(0, 197) + '...';
+    }
+  }
+  
+  // Normalize tags to array
+  let tags = frontMatter.tags || [];
+  if (typeof tags === 'string') {
+    tags = tags.split(',').map(t => t.trim());
+  }
+  
+  return {
+    ...frontMatter,
+    slug,
+    date,
+    excerpt,
+    tags,
+    content: html,
+    rawContent: markdown,
+    filePath,
+    draft: frontMatter.draft || false
+  };
+}
+
+/**
+ * Recursively get all markdown files in a directory
+ */
+export function getMarkdownFiles(dir) {
+  const files = [];
+  
+  if (!existsSync(dir)) {
+    return files;
+  }
+  
+  const items = readdirSync(dir);
+  
+  for (const item of items) {
+    const fullPath = join(dir, item);
+    const stat = statSync(fullPath);
+    
+    if (stat.isDirectory()) {
+      files.push(...getMarkdownFiles(fullPath));
+    } else if (item.endsWith('.md') || item.endsWith('.markdown')) {
+      files.push(fullPath);
+    }
+  }
+  
+  return files;
+}
+
+/**
+ * Load all content from a collection directory
+ */
+export function loadCollection(config, collectionName) {
+  const collectionConfig = config.collections[collectionName];
+  
+  if (!collectionConfig) {
+    console.warn(`Collection "${collectionName}" not found in config`);
+    return [];
+  }
+  
+  const collectionDir = join(config.inputDir, collectionConfig.path);
+  const files = getMarkdownFiles(collectionDir);
+  
+  const items = files
+    .map(filePath => {
+      try {
+        const item = parseContent(filePath);
+        
+        // Add collection-specific metadata
+        item.collection = collectionName;
+        item.layout = item.layout || collectionConfig.layout;
+        
+        // Generate permalink
+        let permalink = item.permalink || collectionConfig.permalink || '/:slug/';
+        permalink = permalink
+          .replace(':slug', item.slug)
+          .replace(':year', item.date.getFullYear())
+          .replace(':month', String(item.date.getMonth() + 1).padStart(2, '0'))
+          .replace(':day', String(item.date.getDate()).padStart(2, '0'));
+        
+        item.url = permalink;
+        item.outputPath = join(config.outputDir, permalink, 'index.html');
+        
+        return item;
+      } catch (err) {
+        console.error(`Error parsing ${filePath}:`, err.message);
+        return null;
+      }
+    })
+    .filter(item => item !== null && !item.draft);
+  
+  // Sort items
+  const sortBy = collectionConfig.sortBy || 'date';
+  const sortOrder = collectionConfig.sortOrder || 'desc';
+  
+  items.sort((a, b) => {
+    const aVal = a[sortBy];
+    const bVal = b[sortBy];
+    
+    if (aVal instanceof Date && bVal instanceof Date) {
+      return sortOrder === 'desc' ? bVal - aVal : aVal - bVal;
+    }
+    
+    if (typeof aVal === 'string' && typeof bVal === 'string') {
+      return sortOrder === 'desc' 
+        ? bVal.localeCompare(aVal) 
+        : aVal.localeCompare(bVal);
+    }
+    
+    return 0;
+  });
+  
+  return items;
+}
+
+/**
+ * Load all collections defined in config
+ */
+export function loadAllCollections(config) {
+  const collections = {};
+  
+  for (const name of Object.keys(config.collections)) {
+    collections[name] = loadCollection(config, name);
+    console.log(`📚 Loaded ${collections[name].length} items from "${name}" collection`);
+  }
+  
+  return collections;
+}
+
+export default {
+  parseContent,
+  slugify,
+  getSlugFromFilename,
+  getDateFromFilename,
+  getMarkdownFiles,
+  loadCollection,
+  loadAllCollections
+};
+

package/lib/index.js

@@ -1,22 +1,57 @@
-#!/usr/bin/env node
+/**
+ * Sia - A simple, powerful static site generator
+ */
 
-import { build } from './build.js'
-import { create } from './new.js'
-import { init } from './init.js'
+export { loadConfig, getDefaultConfig } from './config.js';
+export { 
+  parseContent, 
+  slugify, 
+  getSlugFromFilename, 
+  loadCollection, 
+  loadAllCollections 
+} from './content.js';
+export { 
+  buildTagCollections, 
+  getAllTags, 
+  paginate, 
+  buildSiteData, 
+  getRecentItems, 
+  getRelatedItems 
+} from './collections.js';
+export { 
+  createTemplateEngine, 
+  renderTemplate, 
+  renderString 
+} from './templates.js';
+export { 
+  copyImages, 
+  copyAssets, 
+  copyStaticAssets, 
+  writeFile, 
+  ensureDir 
+} from './assets.js';
+export { build, buildCommand } from './build.js';
+export { startServer, devCommand } from './server.js';
+export { newCommand } from './new.js';
+export { initSite, initCommand } from './init.js';
 
-const [, , cmd, type, folder] = process.argv
+// Default export with version
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
 
-switch (cmd) {
-  case init:
-    init()
-    break
-  case 'build':
-    build()
-    break
-  case 'new':
-    create(type, folder)
-    break
-  default:
-    console.log('Missing command')
-    break
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+let version = '1.0.0';
+try {
+  const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
+  version = pkg.version;
+} catch (e) {
+  // Ignore error
 }
+
+export default {
+  version
+};
+