clovie 0.1.0

package/lib/core/discover.js

@@ -0,0 +1,74 @@
+import fs from 'fs';
+import path from 'path';
+
+export function discoverProjectStructure(config) {
+  const cwd = process.cwd();
+  const discovered = { ...config };
+  
+  // Auto-detect views directory
+  if (!discovered.views) {
+    const viewDirs = ['views', 'templates', 'pages', 'src/views', 'src/templates'];
+    for (const dir of viewDirs) {
+      if (fs.existsSync(path.join(cwd, dir))) {
+        discovered.views = path.join('./', dir);
+        console.log(`🔍 Auto-detected views directory: ${dir}`);
+        break;
+      }
+    }
+  }
+  
+  // Auto-detect scripts directory
+  if (!discovered.scripts) {
+    const scriptDirs = ['scripts', 'js', 'src/scripts', 'src/js'];
+    for (const dir of scriptDirs) {
+      if (fs.existsSync(path.join(cwd, dir))) {
+        const mainFiles = ['main.js', 'index.js', 'app.js'];
+        for (const file of mainFiles) {
+          if (fs.existsSync(path.join(cwd, dir, file))) {
+            discovered.scripts = path.join('./', dir, file);
+            console.log(`🔍 Auto-detected scripts entry: ${dir}/${file}`);
+            break;
+          }
+        }
+        if (discovered.scripts) break;
+      }
+    }
+  }
+  
+  // Auto-detect styles directory
+  if (!discovered.styles) {
+    const styleDirs = ['styles', 'css', 'scss', 'src/styles', 'src/css'];
+    for (const dir of styleDirs) {
+      if (fs.existsSync(path.join(cwd, dir))) {
+        const mainFiles = ['main.scss', 'main.css', 'style.scss', 'style.css'];
+        for (const file of mainFiles) {
+          if (fs.existsSync(path.join(cwd, dir, file))) {
+            discovered.styles = path.join('./', dir, file);
+            console.log(`🔍 Auto-detected styles entry: ${dir}/${file}`);
+            break;
+          }
+        }
+        if (discovered.styles) break;
+      }
+    }
+  }
+  
+  // Auto-detect assets directory
+  if (!discovered.assets) {
+    const assetDirs = ['assets', 'public', 'static', 'src/assets', 'src/public'];
+    for (const dir of assetDirs) {
+      if (fs.existsSync(path.join(cwd, dir))) {
+        discovered.assets = path.join('./', dir);
+        console.log(`🔍 Auto-detected assets directory: ${dir}`);
+        break;
+      }
+    }
+  }
+  
+  // Validate required directories
+  if (!discovered.views) {
+    console.warn('⚠️  No views directory found. Create a views/ folder with your HTML templates.');
+  }
+  
+  return discovered;
+}

package/lib/core/getAssets.js

@@ -0,0 +1,38 @@
+import fs from 'fs';
+import path from 'path';
+import { readFilesToMap } from '../utils/readFilesToMap.js';
+
+export default function (src) {
+    try {
+        if (!src || !fs.existsSync(src)) {
+            console.warn(`Assets directory does not exist: ${src}`);
+            return {};
+        }
+        
+        let fileNames = getFileNames(src);
+        return fileNames ? readFilesToMap(fileNames, src) : {};
+    } catch (err) {
+        console.error(`Error processing assets from ${src}:`, err);
+        return {};
+    }
+}
+
+function getFileNames (PATH, files = fs.readdirSync(PATH, { withFileTypes: true }), accumulator = []) {
+    if (files.length === 0) return accumulator;
+    
+    let value = files.shift();
+    if (!value) return accumulator;
+    
+    let name = path.join(PATH, value.name);
+    let res = value.isDirectory() ? getFileNames(name) : name;
+  
+    if (Array.isArray(res)) {
+      accumulator = accumulator.concat(res)
+    } else {
+      accumulator.push(res)
+    }
+  
+    return files.length ? getFileNames(PATH, files, accumulator) : accumulator;
+  }
+
+

package/lib/core/getData.js

@@ -0,0 +1,19 @@
+import type from 'type-detect';
+
+export default function getData (data) {
+  return new Promise ((resolve, reject) => {
+    switch (type(data)) {
+      case 'Object':
+        resolve(data);
+      break;
+
+      case 'function':
+        resolve(data())
+      break;
+
+      case 'Promise':
+        data.then(resolve)
+      break;
+    }
+  })
+}

package/lib/core/getStyles.js

@@ -0,0 +1,16 @@
+import * as sass from 'sass';
+import path from 'path';
+
+export default function (file) {
+  let pathObj = path.parse(file);
+
+  try {
+    let res = sass.compile(file);
+    return {[`${pathObj.name}.css`]: res.css};
+  } catch (err) {
+    console.log('Sass Error in file: ' + err.file);
+    console.log('On line: ' + err.line);
+    console.log(err.formatted);
+    return {}
+  }
+}

package/lib/core/getViews.js

@@ -0,0 +1,187 @@
+import fs from 'fs';
+import path from 'path';
+import { readFilesToMap } from '../utils/readFilesToMap.js';
+
+export default function (src, models = {}, data) {
+  try {
+    if (!src || !fs.existsSync(src)) {
+      console.warn(`Views directory does not exist: ${src}`);
+      return {};
+    }
+    
+    let fileNames = getFileNames(src);
+    let templates = fileNames ? readFilesToMap(fileNames, src) : null;
+    let pages = templates ? getPages(templates, data) : {};
+    
+    // Process models if any exist
+    if (Object.keys(models).length > 0) {
+      return processModels(templates, data, models, pages);
+    }
+    
+    return pages;
+  } catch (err) {
+    console.error(`Error processing views from ${src}:`, err);
+    return {};
+  }
+}
+
+function getFileNames (PATH, files = fs.readdirSync(PATH, { withFileTypes: true }), accumulator = [], depth = 0) {
+  // Prevent infinite recursion and stack overflow
+  const MAX_DEPTH = 50;
+  if (depth > MAX_DEPTH) {
+    console.warn(`Maximum directory depth exceeded at: ${PATH}`);
+    return accumulator;
+  }
+
+  if (!files || files.length === 0) return accumulator;
+  
+  let value = files.shift();
+  if (!value) return accumulator;
+
+  try {
+    if (value && !value.name.startsWith('.')) {
+      let name = path.join(PATH, value.name);
+      let res = value.isDirectory() ? getFileNames(name, [], [], depth + 1) : name;
+    
+      if (Array.isArray(res)) {
+        accumulator = accumulator.concat(res)
+      } else {
+        accumulator.push(res)
+      }
+    }
+  } catch (err) {
+    console.error(`Error processing file/directory: ${PATH}/${value?.name}:`, err);
+  }
+
+  return files.length ? getFileNames(PATH, files, accumulator, depth) : accumulator;
+}
+
+
+
+function getPages (templates, data, keys = Object.keys(templates), accumulator = {}) {
+  if (!keys || keys.length === 0) return accumulator;
+  
+  let key = keys.shift();
+  if (!key) return accumulator;
+  
+  try {
+    if (!path.parse(key).name.startsWith('_')) {
+      let template = templates[key];
+      accumulator[key] = {
+        template,
+        data
+      };
+    }
+  } catch (err) {
+    console.error(`Error processing page: ${key}:`, err);
+  }
+  
+  return keys.length ? getPages(templates, data, keys, accumulator) : accumulator;
+}
+
+function processModels(templates, data, models, existingPages = {}) {
+  const results = { ...existingPages };
+  
+  for (const [modelName, config] of Object.entries(models)) {
+    try {
+      // Get the data array for this model
+      const dataKey = config.ref || modelName;
+      const items = data[dataKey];
+      
+      if (!items) {
+        console.warn(`⚠️  No data found for model '${modelName}'. Expected '${dataKey}' in your data.`);
+        continue;
+      }
+      
+      if (!Array.isArray(items)) {
+        console.error(`❌ Data for model '${modelName}' must be an array, got: ${typeof items}`);
+        continue;
+      }
+      
+      // Process each item
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const page = processModelItem(item, i, config, templates, data);
+        
+        if (page) {
+          results[page.filename] = page;
+        }
+      }
+      
+      console.log(`✅ Generated ${items.length} pages for model '${modelName}'`);
+      
+    } catch (err) {
+      console.error(`❌ Error processing model '${modelName}':`, err);
+    }
+  }
+  
+  return results;
+}
+
+function processModelItem(item, index, config, templates, globalData) {
+  try {
+    // Get template
+    const templateName = config.template;
+    if (!templateName) {
+      console.error(`❌ Model missing 'template' property`);
+      return null;
+    }
+    
+    const templatePath = path.normalize(`/${templateName}`);
+    const template = templates[templatePath];
+    
+    if (!template) {
+      console.error(`❌ Template '${templateName}' not found. Available templates: ${Object.keys(templates).join(', ')}`);
+      return null;
+    }
+    
+    // Transform data if function provided
+    let processedData = item;
+    if (typeof config.transform === 'function') {
+      try {
+        processedData = config.transform(item, index);
+      } catch (err) {
+        console.error(`❌ Error in transform function for item ${index}:`, err);
+        processedData = item;
+      }
+    }
+    
+    // Generate filename
+    let filename = `${index}.html`;
+    if (typeof config.output === 'function') {
+      try {
+        filename = config.output(item, index);
+      } catch (err) {
+        console.error(`❌ Error in output function for item ${index}:`, err);
+        filename = `${index}.html`;
+      }
+    } else if (typeof config.output === 'string') {
+      // Simple string template replacement
+      filename = config.output
+        .replace('{index}', index)
+        .replace('{slug}', item.slug || item.id || index)
+        .replace('{title}', item.title || item.name || index);
+    }
+    
+    // Ensure .html extension
+    if (!filename.endsWith('.html')) {
+      filename += '.html';
+    }
+    
+    return {
+      template,
+      data: {
+        local: processedData,
+        ...globalData,
+        index,
+        isFirst: index === 0,
+        isLast: index === (globalData[config.ref || 'items']?.length - 1)
+      },
+      filename
+    };
+    
+  } catch (err) {
+    console.error(`❌ Error processing model item ${index}:`, err);
+    return null;
+  }
+}

package/lib/core/render.js

@@ -0,0 +1,17 @@
+import type from 'type-detect';
+
+const render = async (views, compiler, fileNames = Object.keys(views), accumulator = {}) => {
+  if (!fileNames || fileNames.length === 0) return accumulator;
+  
+  for (const fileName of fileNames) {
+    const view = views[fileName];
+    if (!view || !view.template) continue;
+    
+    const res = compiler(view.template, {...view.data, fileName, fileNames});
+    accumulator[fileName] = type(res) === 'Promise' ? await res : res;
+  }
+  
+  return accumulator;
+}
+
+export default render;

package/lib/core/server.js

@@ -0,0 +1,104 @@
+import express from 'express';
+import path from 'path';
+import { createServer } from 'http';
+import { Server } from 'socket.io';
+
+export class DevServer {
+  constructor(clovieInstance, port = 3000) {
+    this.clovie = clovieInstance;
+    this.port = port;
+    this.app = express();
+    this.server = createServer(this.app);
+    this.io = new Server(this.server);
+    this.isRunning = false;
+  }
+  
+  start() {
+    if (this.isRunning) return;
+    
+    // Serve static files from output directory
+    this.app.use(express.static(this.clovie.config.outputDir));
+    
+    // Explicitly handle root path to serve index.html
+    this.app.get('/', (req, res) => {
+      res.sendFile(path.join(this.clovie.config.outputDir, 'index.html'));
+    });
+    
+    // Handle paths without trailing slash by redirecting
+    this.app.get('*', (req, res, next) => {
+      if (!req.path.endsWith('/') && !req.path.includes('.')) {
+        // Redirect paths without trailing slash to include it
+        res.redirect(req.path + '/');
+        return;
+      }
+      next();
+    });
+    
+    // Serve source files for debugging
+    if (this.clovie.config.views) {
+      this.app.use('/source/views', express.static(this.clovie.config.views));
+    }
+    if (this.clovie.config.scriptsDir) {
+      this.app.use('/source/scripts', express.static(this.clovie.config.scriptsDir));
+    }
+    if (this.clovie.config.stylesDir) {
+      this.app.use('/source/styles', express.static(this.clovie.config.stylesDir));
+    }
+    
+    // WebSocket for live reload
+    this.io.on('connection', (socket) => {
+      console.log('🔌 Client connected');
+      
+      socket.on('disconnect', () => {
+        console.log('🔌 Client disconnected');
+      });
+    });
+    
+    // Add cache-busting headers for development
+    this.app.use((req, res, next) => {
+      res.set('Cache-Control', 'no-cache, no-store, must-revalidate');
+      res.set('Pragma', 'no-cache');
+      res.set('Expires', '0');
+      next();
+    });
+    
+    // Start server
+    this.server.listen(this.port, () => {
+      this.isRunning = true;
+      console.log(`🌐 Development server running at http://localhost:${this.port}`);
+      console.log(`📁 Serving files from: ${this.clovie.config.outputDir}`);
+      console.log(`🔌 Live reload enabled`);
+    });
+    
+    // Handle server shutdown
+    process.on('SIGINT', () => {
+      this.stop();
+    });
+  }
+  
+  stop() {
+    if (!this.isRunning) return;
+    
+    this.server.close(() => {
+      this.isRunning = false;
+      console.log('🛑 Development server stopped');
+    });
+  }
+  
+  // Notify clients to reload
+  notifyReload() {
+    if (this.io) {
+      this.io.emit('reload');
+      console.log('🔄 Live reload triggered');
+    }
+  }
+  
+  // Get server info
+  getInfo() {
+    return {
+      port: this.port,
+      isRunning: this.isRunning,
+              outputDir: this.clovie.config.outputDir
+    };
+  }
+}

package/lib/core/watcher.js

@@ -0,0 +1,242 @@
+import chokidar from 'chokidar';
+import path from 'path';
+import fs from 'fs';
+import { BuildCache } from './cache.js';
+
+export class SmartWatcher {
+  constructor(clovieInstance) {
+    this.clovie = clovieInstance;
+    this.watcher = null;
+    this.cache = new BuildCache(clovieInstance.config.outputDir);
+    this.debounceTimer = null;
+    this.isWatching = false;
+  }
+  
+  start() {
+    if (this.isWatching) return;
+    
+    console.log('👀 Starting smart file watcher...');
+    this.isWatching = true;
+    
+    // Watch views directory
+    if (this.clovie.config.views) {
+      this.watcher = chokidar.watch(this.clovie.config.views, {
+        ignored: /(^|[\/\\])\../, // Ignore hidden files
+        persistent: true
+      });
+      
+      this.watcher.on('change', (filePath) => this.handleViewChange(filePath));
+      this.watcher.on('add', (filePath) => this.handleViewChange(filePath));
+      this.watcher.on('unlink', (filePath) => this.handleViewChange(filePath));
+    }
+    
+    // Watch scripts directory
+    if (this.clovie.config.scriptsDir) {
+      const scriptsWatcher = chokidar.watch(this.clovie.config.scriptsDir, {
+        ignored: /(^|[\/\\])\../,
+        persistent: true
+      });
+      
+      scriptsWatcher.on('change', (filePath) => this.handleScriptChange(filePath));
+      scriptsWatcher.on('add', (filePath) => this.handleScriptChange(filePath));
+      scriptsWatcher.on('unlink', (filePath) => this.handleScriptChange(filePath));
+    }
+    
+    // Watch styles directory
+    if (this.clovie.config.stylesDir) {
+      const stylesWatcher = chokidar.watch(this.clovie.config.stylesDir, {
+        ignored: /(^|[\/\\])\../,
+        persistent: true
+      });
+      
+      stylesWatcher.on('change', (filePath) => this.handleStyleChange(filePath));
+      stylesWatcher.on('add', (filePath) => this.handleStyleChange(filePath));
+      stylesWatcher.on('unlink', (filePath) => this.handleStyleChange(filePath));
+    }
+    
+    // Watch assets directory
+    if (this.clovie.config.assets) {
+      const assetsWatcher = chokidar.watch(this.clovie.config.assets, {
+        ignored: /(^|[\/\\])\../,
+        persistent: true
+      });
+      
+      assetsWatcher.on('change', (filePath) => this.handleAssetChange(filePath));
+      assetsWatcher.on('add', (filePath) => this.handleAssetChange(filePath));
+      assetsWatcher.on('unlink', (filePath) => this.handleAssetChange(filePath));
+    }
+    
+    console.log('✅ Smart watcher started');
+  }
+  
+  stop() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    this.isWatching = false;
+    console.log('🛑 Smart watcher stopped');
+  }
+  
+  // Debounced rebuild to avoid multiple rapid rebuilds
+  scheduleRebuild(type, filePath) {
+    clearTimeout(this.debounceTimer);
+    
+    this.debounceTimer = setTimeout(() => {
+      this.rebuild(type, filePath);
+    }, 100); // 100ms debounce
+  }
+  
+  async rebuild(type, filePath) {
+    const startTime = Date.now();
+    console.log(`🔄 Rebuilding due to ${type} change: ${path.basename(filePath)}`);
+    
+    try {
+      // Only rebuild what's necessary based on what changed
+      switch (type) {
+        case 'view':
+          await this.rebuildViews();
+          break;
+        case 'script':
+          await this.rebuildScripts();
+          break;
+        case 'style':
+          await this.rebuildStyles();
+          break;
+        case 'asset':
+          await this.rebuildAssets();
+          break;
+      }
+      
+      this.cache.markBuilt();
+      const buildTime = Date.now() - startTime;
+      console.log(`✅ Incremental rebuild completed in ${buildTime}ms`);
+      
+      // Trigger live reload if callback is set
+      if (this.onRebuild) {
+        this.onRebuild();
+      }
+      
+    } catch (err) {
+      console.error(`❌ Incremental rebuild failed:`, err);
+    }
+  }
+  
+  async rebuildViews() {
+    // For now, just trigger a full rebuild of views since incremental is complex
+    console.log('   Triggering full view rebuild...');
+    
+    try {
+      // Re-process all views
+      const getViews = await import('./getViews.js');
+      this.clovie.views = getViews.default(this.clovie.config.views, this.clovie.config.models, this.clovie.data);
+      
+      // Re-render all views using the render function
+      const render = await import('./render.js');
+      this.clovie.rendered = await render.default(this.clovie.views, this.clovie.config.compiler, Object.keys(this.clovie.views));
+      
+      // Write the updated views
+      const write = await import('./write.js');
+      write.default(this.clovie.rendered, this.clovie.config.outputDir);
+      
+      console.log('   Views rebuilt successfully');
+    } catch (err) {
+      console.error('   View rebuild failed:', err);
+      throw err;
+    }
+  }
+  
+  async rebuildScripts() {
+    if (!this.clovie.config.scripts) return;
+    console.log('   Rebuilding scripts...');
+    
+    try {
+      const bundler = await import('./bundler.js');
+      this.clovie.scripts = await bundler.default(this.clovie.config.scripts);
+      
+      const write = await import('./write.js');
+      write.default(this.clovie.scripts, this.clovie.config.outputDir);
+      
+      console.log('   Scripts rebuilt successfully');
+    } catch (err) {
+      console.error('   Script rebuild failed:', err);
+      throw err;
+    }
+  }
+  
+  async rebuildStyles() {
+    if (!this.clovie.config.styles) return;
+    console.log('   Rebuilding styles...');
+    
+    try {
+      const getStyles = await import('./getStyles.js');
+      this.clovie.styles = getStyles.default(this.clovie.config.styles);
+      
+      const write = await import('./write.js');
+      write.default(this.clovie.styles, this.clovie.config.outputDir);
+      
+      console.log('   Styles rebuilt successfully');
+    } catch (err) {
+      console.error('   Style rebuild failed:', err);
+      throw err;
+    }
+  }
+  
+  async rebuildAssets() {
+    if (!this.clovie.config.assets) return;
+    console.log('   Rebuilding assets...');
+    
+    try {
+      const getAssets = await import('./getAssets.js');
+      this.clovie.assets = getAssets.default(this.clovie.config.assets);
+      
+      const write = await import('./write.js');
+      write.default(this.clovie.assets, this.clovie.config.outputDir);
+      
+      console.log('   Assets rebuilt successfully');
+    } catch (err) {
+      console.error('   Asset rebuild failed:', err);
+      throw err;
+    }
+  }
+  
+  getViewFiles(viewsDir) {
+    // Get all view files recursively
+    const files = [];
+    const scanDir = (dir) => {
+      try {
+        const items = fs.readdirSync(dir);
+        for (const item of items) {
+          const fullPath = path.join(dir, item);
+          const stat = fs.statSync(fullPath);
+          if (stat.isDirectory()) {
+            scanDir(fullPath);
+          } else if (path.extname(item) === '.html') {
+            files.push(fullPath);
+          }
+        }
+      } catch (err) {
+        // Ignore errors
+      }
+    };
+    
+    scanDir(viewsDir);
+    return files;
+  }
+  
+  handleViewChange(filePath) {
+    this.scheduleRebuild('view', filePath);
+  }
+  
+  handleScriptChange(filePath) {
+    this.scheduleRebuild('script', filePath);
+  }
+  
+  handleStyleChange(filePath) {
+    this.scheduleRebuild('style', filePath);
+  }
+  
+  handleAssetChange(filePath) {
+    this.scheduleRebuild('asset', filePath);
+  }
+}