fossbook 0.0.2

package/lib/index.js

@@ -0,0 +1,79 @@
+const fs = require("fs");
+const path = require("path");
+
+const Page = require("./mod/page");
+const HomePagination = require("./home");
+const AllPostsPage = require("./all_posts");
+const Posts = require("./posts");
+const TagPages = require("./tag");
+
+function copyDirectoryRecursive(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDirectoryRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function build(config) {
+  // Remove the output directory
+  if (fs.existsSync(config.dev.outdir))
+    fs.rmSync(config.dev.outdir, { recursive: true });
+  fs.mkdirSync(config.dev.outdir);
+
+  // Create post pages in output directory
+  const posts = new Posts(config);
+  const postObjects = posts.createPostObjects();
+
+  postObjects.forEach((post) => {
+    post.generateContent("post.html");
+  });
+
+  // Create home page and pagination in output/page directory
+  const homePagination = new HomePagination(config);
+  homePagination.generateContent(postObjects);
+
+  // Create all posts page in output/all_posts directory
+  const allPostsPage = new AllPostsPage(config);
+  allPostsPage.generateContent(postObjects);
+
+  // Create tag pages in output/tags directory
+  const tagPages = new TagPages(config);
+  tagPages.generateContent(postObjects);
+
+  // Create about page in output/about directory
+  const aboutPath = config.dev.about;
+  if (fs.existsSync(aboutPath)) {
+    const aboutPage = new Page(config);
+    aboutPage.readSource(aboutPath);
+    aboutPage.generateContent("page.html", "about");
+  }
+
+  // Copy static directory to output directory
+  const staticImagesDir = path.join(config.dev.staticDir, "images");
+  if (fs.existsSync(staticImagesDir)) {
+    copyDirectoryRecursive(staticImagesDir, path.join(config.dev.outdir, "images"));
+  }
+
+  // Copy theme assets to output directory
+  const themeAssetsDir = path.join(config.themePath, "assets");
+  if (fs.existsSync(themeAssetsDir)) {
+    copyDirectoryRecursive(themeAssetsDir, config.dev.outdir);
+  }
+
+  // Create CNAME file for GitHub Pages
+  if (config.githubCNAME)
+    fs.writeFileSync(path.join(config.dev.outdir, "CNAME"), config.githubCNAME);
+
+  console.log("Build completed successfully");
+}
+
+module.exports = { build };

package/lib/init.js

@@ -0,0 +1,253 @@
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+const DEPLOY_WORKFLOW = `name: Deploy to GitHub Pages
+
+on:
+  push:
+    branches: [main]
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+jobs:
+  build-and-deploy:
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: \${{ steps.deployment.outputs.page_url }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build site
+        run: npx fossbook build
+
+      - name: Setup Pages
+        uses: actions/configure-pages@v4
+
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: './public'
+
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4
+`;
+
+function initProject(options = {}) {
+  const cwd = process.cwd();
+
+  // Create directories
+  const dirs = [
+    "content/posts",
+    "static/images",
+  ];
+
+  dirs.forEach((dir) => {
+    const dirPath = path.join(cwd, dir);
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+      console.log(`Created: ${dir}/`);
+    }
+  });
+
+  // Create .github/workflows/deploy.yml
+  const workflowDir = path.join(cwd, ".github", "workflows");
+  const workflowPath = path.join(workflowDir, "deploy.yml");
+  if (!fs.existsSync(workflowPath)) {
+    fs.mkdirSync(workflowDir, { recursive: true });
+    fs.writeFileSync(workflowPath, DEPLOY_WORKFLOW);
+    console.log("Created: .github/workflows/deploy.yml");
+  }
+
+  // Create .gitignore
+  const gitignorePath = path.join(cwd, ".gitignore");
+  if (!fs.existsSync(gitignorePath)) {
+    fs.writeFileSync(gitignorePath, "node_modules/\npublic/\n");
+    console.log("Created: .gitignore");
+  }
+
+  // Create fossbook.config.js
+  const configPath = path.join(cwd, "fossbook.config.js");
+  if (!fs.existsSync(configPath)) {
+    const configContent = `module.exports = {
+  blogName: "My Blog",
+  authorName: "",
+  authorDescription: "",
+  authorWebsite: "",
+  blogDescription: "A blog powered by fossbook",
+  blogsite: "http://localhost:3000",
+
+  // Optional
+  githubCNAME: "",
+  googleAnalyticsID: "",
+  authorTwitter: "",
+  siteTwitter: "",
+  githubRepository: "",
+  image: "",
+  theme: "archie",
+
+  // Comment system (optional)
+  // comments: { provider: "utterances", repo: "user/repo", issueTerm: "pathname", theme: "github-light" },
+
+  // Deployment
+  // deploy: { branch: "main", remote: "origin" },
+
+  // Directory overrides (defaults shown)
+  content: "./content",
+  postsDir: "./content/posts",
+  outputDir: "./public",
+  staticDir: "./static",
+  themesDir: "./themes",
+};
+`;
+    fs.writeFileSync(configPath, configContent);
+    console.log("Created: fossbook.config.js");
+  }
+
+  // Create content/about.md
+  const aboutPath = path.join(cwd, "content", "about.md");
+  if (!fs.existsSync(aboutPath)) {
+    const aboutContent = `---
+title: About
+---
+
+Welcome to my blog!
+`;
+    fs.writeFileSync(aboutPath, aboutContent);
+    console.log("Created: content/about.md");
+  }
+
+  // Create package.json if it doesn't exist
+  const pkgPath = path.join(cwd, "package.json");
+  const createdPkg = !fs.existsSync(pkgPath);
+  if (createdPkg) {
+    const pkg = {
+      name: path.basename(cwd),
+      version: "1.0.0",
+      private: true,
+      scripts: {
+        build: "fossbook build",
+        start: "fossbook serve",
+        deploy: "fossbook deploy",
+      },
+      dependencies: {
+        fossbook: "latest",
+      },
+    };
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+    console.log("Created: package.json");
+  }
+
+  // Generate package-lock.json (required by CI/CD npm ci + cache)
+  const lockPath = path.join(cwd, "package-lock.json");
+  if (!fs.existsSync(lockPath)) {
+    console.log("Running npm install to generate package-lock.json...");
+    try {
+      execSync("npm install", { cwd, stdio: "inherit" });
+      console.log("Created: package-lock.json");
+    } catch {
+      console.warn("Warning: npm install failed. You may need to run it manually.");
+    }
+  }
+
+  // Handle --github flag: create repo and push
+  if (options.github) {
+    initGitHub(cwd);
+  }
+
+  console.log("\nSite initialized! Next steps:");
+  if (!options.github) {
+    console.log('  1. Edit fossbook.config.js with your site settings');
+    console.log('  2. Run: fossbook new "My First Post"');
+    console.log("  3. Edit your post in content/posts/");
+    console.log("  4. Run: fossbook build");
+    console.log("  5. Run: fossbook serve");
+  } else {
+    console.log('  1. Edit fossbook.config.js with your site settings');
+    console.log('  2. Run: fossbook new "My First Post"');
+    console.log("  3. Edit your post in content/posts/");
+    console.log("  4. Run: fossbook deploy");
+  }
+}
+
+function initGitHub(cwd) {
+  // Check if gh CLI is available
+  try {
+    execSync("gh --version", { stdio: "ignore" });
+  } catch {
+    console.error(
+      "Error: GitHub CLI (gh) is not installed.\n" +
+      "Install it: https://cli.github.com/\n" +
+      "  Linux:   sudo apt install gh\n" +
+      "  macOS:   brew install gh\n" +
+      "  Windows: winget install GitHub.cli"
+    );
+    process.exit(1);
+  }
+
+  // Check if gh is authenticated
+  try {
+    execSync("gh auth status", { stdio: "ignore" });
+  } catch {
+    console.error("Error: GitHub CLI is not authenticated. Run: gh auth login");
+    process.exit(1);
+  }
+
+  // Initialize git repo if needed
+  if (!fs.existsSync(path.join(cwd, ".git"))) {
+    console.log("Initializing git repository...");
+    execSync("git init", { cwd, stdio: "inherit" });
+    execSync("git branch -M main", { cwd, stdio: "inherit" });
+  }
+
+  // Create GitHub repository
+  const repoName = path.basename(cwd);
+  console.log(`Creating GitHub repository: ${repoName}...`);
+  try {
+    execSync(`gh repo create ${repoName} --public --source=. --remote=origin`, {
+      cwd,
+      stdio: "inherit",
+    });
+  } catch {
+    // Repo may already exist or remote may already be set
+    console.warn("Note: GitHub repo creation skipped (may already exist).");
+  }
+
+  // Initial commit and push
+  console.log("Committing and pushing to GitHub...");
+  execSync("git add -A", { cwd, stdio: "inherit" });
+  try {
+    execSync('git commit -m "Initial fossbook site"', { cwd, stdio: "inherit" });
+  } catch {
+    // Nothing to commit
+  }
+  try {
+    execSync("git push -u origin main", { cwd, stdio: "inherit" });
+  } catch (e) {
+    console.warn("Warning: Could not push to origin. You may need to push manually.");
+  }
+
+  console.log("\nGitHub repository created and pushed!");
+  console.log("Enable GitHub Pages in your repo settings:");
+  console.log("  Settings → Pages → Source → GitHub Actions");
+}
+
+module.exports = { initProject };

package/lib/mod/config.js

@@ -0,0 +1,98 @@
+const path = require("path");
+const fs = require("fs");
+
+const defaults = {
+  blogName: "My Blog",
+  authorName: "",
+  authorDescription: "",
+  authorWebsite: "",
+  blogDescription: "",
+  blogsite: "http://localhost:3000",
+  githubCNAME: "",
+  googleAnalyticsID: "",
+  authorTwitter: "",
+  siteTwitter: "",
+  githubRepository: "",
+  image: "",
+  theme: "archie",
+  comments: null,  // { provider: "utterances", repo: "user/repo", issueTerm: "pathname", theme: "github-light" }
+  content: "./content",
+  postsDir: "./content/posts",
+  outputDir: "./public",
+  staticDir: "./static",
+  themesDir: "./themes",
+};
+
+/**
+ * Resolve the theme path, checking the user's themesDir first,
+ * then falling back to the built-in themes directory.
+ */
+function resolveThemePath(config) {
+  const themeName = config.theme || "archie";
+  const userThemePath = path.resolve(config.themesDir || "./themes", themeName);
+  const builtinThemePath = path.resolve(__dirname, "../../themes", themeName);
+
+  if (fs.existsSync(userThemePath)) {
+    return userThemePath;
+  }
+  if (fs.existsSync(builtinThemePath)) {
+    return builtinThemePath;
+  }
+  console.error(`Theme "${themeName}" not found in ${userThemePath} or ${builtinThemePath}`);
+  process.exit(1);
+}
+
+/**
+ * Load configuration from the user's fossbook.config.js (or a custom path),
+ * merge with defaults, and build the internal dev paths.
+ */
+function loadConfig(configPath) {
+  const resolvedConfigPath = path.resolve(configPath || "./fossbook.config.js");
+
+  let userConfig = {};
+  if (fs.existsSync(resolvedConfigPath)) {
+    userConfig = require(resolvedConfigPath);
+  } else if (configPath) {
+    // Only error if user explicitly specified a config path
+    console.error(`Config file not found: ${resolvedConfigPath}`);
+    process.exit(1);
+  } else {
+    console.warn("No fossbook.config.js found, using defaults.");
+  }
+
+  const merged = { ...defaults, ...userConfig };
+
+  // Build the internal dev paths object used by the generator modules
+  const themePath = resolveThemePath(merged);
+
+  merged.dev = {
+    postsdir: path.resolve(merged.postsDir),
+    content: path.resolve(merged.content),
+    about: path.resolve(merged.content, "about.md"),
+    outdir: path.resolve(merged.outputDir),
+    themePath: path.dirname(themePath), // e.g. /path/to/themes
+    staticDir: path.resolve(merged.staticDir),
+  };
+
+  merged.themePath = themePath; // full path to the active theme directory
+
+  // Inject version and build date
+  merged.version = require("../../package.json").version;
+  merged.date_time = formatDate(new Date());
+
+  return merged;
+}
+
+function formatDate(
+  date,
+  locale = "en-US",
+  options = {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+  },
+) {
+  return date.toLocaleDateString(locale, options);
+}
+
+module.exports = { loadConfig, resolveThemePath, formatDate };

package/lib/mod/marked.js

@@ -0,0 +1,95 @@
+const marked = require("marked");
+
+marked.setOptions({
+  renderer: new marked.Renderer(),
+  highlight: function (code, language) {
+    const hljs = require("highlight.js");
+    const validLanguage = hljs.getLanguage(language) ? language : "plaintext";
+    return hljs.highlight(validLanguage, code).value;
+  },
+  pedantic: false,
+  gfm: true,
+  breaks: false,
+  sanitize: false,
+  smartLists: true,
+  smartypants: false,
+  xhtml: false,
+});
+
+// Override function
+const renderer = {
+  image(href, title, text) {
+    let size = null;
+    // Check if the title contains a size specification
+    if (title && title.includes("size:")) {
+      const sizeMatch = title.match(/size:(\d+%)/);
+      if (sizeMatch && sizeMatch[1]) {
+        size = sizeMatch[1];
+        // Remove the size specification from the title
+        title = title.replace(/size:\d+%/g, "").trim();
+      }
+    }
+    let align = "center";
+    if (title && title.includes("align:")) {
+      // align: left, right, center
+      const alignMatch = title.match(/align:(left|right|center)/);
+      if (alignMatch && alignMatch[1]) {
+        align = alignMatch[1];
+        // Remove the alignment specification from the title
+        title = title.replace(/align:(left|right|center)/g, "").trim();
+      }
+    }
+
+    // Construct the image tag with optional size and title
+    let imageTag = `<img src="${href}" alt="${text}"`;
+    if (size) {
+      imageTag += ` style="width: ${size};"`;
+    }
+    imageTag += ">";
+
+    return `
+        <div style="text-align: ${align};">
+          <figure style="text-align: ${align};">
+            ${imageTag}
+            ${title ? `<figcaption>${title}</figcaption>` : ""}
+          </figure>
+        </div>
+      `;
+  },
+  link(href, title, text) {
+    let align = null;
+    if (title && title.includes("align:")) {
+      // align: left, right, center
+      const alignMatch = title.match(/align:(left|right|center)/);
+      if (alignMatch && alignMatch[1]) {
+        align = alignMatch[1];
+        // Remove the alignment specification from the title
+        title = title.replace(/align:(left|right|center)/g, "").trim();
+      }
+    }
+    // if align is not null, add div with text-align style
+    if (align) {
+      return `
+          <div style="text-align: ${align};">
+            <a href="${href} "${title ? `title="${title}"` : ""}>${text}</a>
+          </div>`;
+    } else {
+      return `<a href="${href} "${title ? `title="${title}"` : ""}>${text}</a>`;
+    }
+  },
+  blockquote(quote) {
+    return `<div class="blockquote-container"><blockquote>${quote}</blockquote></div>`;
+  },
+  paragraph(text) {
+    // remove <p> surrounding the image
+    if (text.includes('<figure style="text-align: center;">')) {
+      return text;
+    } else {
+      return `<p>${text}</p>`;
+    }
+  },
+};
+
+marked.use({ renderer });
+
+module.exports = marked;

package/lib/mod/page.js

@@ -0,0 +1,115 @@
+const fm = require("front-matter");
+const fs = require("fs");
+const path = require("path");
+const marked = require("./marked");
+const PageBase = require("./page_base");
+
+module.exports = class Page extends PageBase {
+  constructor(config) {
+    super(config);
+    this.srcFilePath = "";
+    this.markdownFilePath = ""; // markdown file path
+    this.contentPath = config.dev.content;
+  }
+
+  readSource(filePath) {
+    if (filePath.indexOf(".md") === -1)
+      this.srcFilePath = filePath + "/index.md";
+    else this.srcFilePath = filePath;
+
+    const mdContent = fs.readFileSync(this.srcFilePath, "utf8");
+
+    if (path.extname(filePath) === ".md") {
+      // If the file has a .md extension, extract the file name without the extension
+      this.path = path.basename(filePath, ".md");
+    } else {
+      // If there's no .md extension, just get the last part of the path
+      this.path = path.basename(filePath);
+    }
+    // parsed content by fields and body
+    const content = fm(mdContent);
+
+    this.title = `${content.attributes.title}`;
+    this.date = content.attributes.date;
+    this.url = `${this.config.blogsite}/${this.path}/`;
+    this.image = content.attributes.image;
+    this.description = content.attributes.description;
+    // default image if no imageURL is specified
+    this.imageURL = this.config.image;
+
+    if (content.attributes.tags && content.attributes.tags.length > 0) {
+      const tagArray = content.attributes.tags.split(",");
+      this.tags = tagArray
+        .map((tag) => tag.trim())
+        .sort((a, b) => a.localeCompare(b));
+    }
+
+    // generated HTML from markdown
+    this.body = marked.parse(content.body);
+    // remove <p></p> and <p> </p> from the beginning and end of the content.body
+    this.body = this.body.replace(/<p><\/p>/g, "").replace(/<p> <\/p>/g, "");
+
+    // for generating the navigation link in the post.html template
+    this.next = null;
+    this.previous = null;
+  }
+
+  // about/index.html or about/hello.html
+  generateContent(templateFile, outputPath) {
+    // For a series of posts
+    if (outputPath === undefined) outputPath = `${this.path}/index.html`;
+    // if file name is not included in the path
+    if (outputPath.indexOf(".htm") === -1) {
+      if (outputPath[outputPath.length - 1] !== "/") outputPath += "/";
+      outputPath += "index.html";
+    }
+
+    // if a directory path is included in the path
+    if (outputPath.indexOf("/") !== -1) {
+      if (this.path === "")
+        this.path = outputPath.split("/").slice(0, -1).join("/");
+
+      if (fs.existsSync(`${this.config.dev.outdir}/${this.path}`))
+        fs.rmSync(`${this.config.dev.outdir}/${this.path}`, {
+          recursive: true,
+        });
+
+      fs.mkdirSync(`${this.config.dev.outdir}/${this.path}`);
+    } else {
+      // remove the outputPath file if it exists
+      if (fs.existsSync(`${this.config.dev.outdir}/${this.path}`))
+        fs.unlinkSync(`${this.config.dev.outdir}/${this.path}`);
+    }
+
+    const layoutsPath = path.join(this.config.themePath, "layouts", templateFile);
+    const postHTML = this.generateHTML(layoutsPath);
+
+    fs.writeFileSync(
+      `${this.config.dev.outdir}/${outputPath}`,
+      postHTML,
+      (e) => {
+        if (e) throw e;
+        console.log(`${outputPath}/index.html was created successfully`);
+      },
+    );
+
+    // if there is the images folder in the output directory.
+    if (
+      fs.existsSync(`${this.config.dev.postsdir}/${this.path}/images`) &&
+      this.path !== ""
+    ) {
+      // Copy images folder from postsdir to outdir
+      if (!fs.existsSync(`${this.config.dev.outdir}/${this.path}/images`))
+        fs.mkdirSync(`${this.config.dev.outdir}/${this.path}/images`);
+
+      fs.readdirSync(`${this.config.dev.postsdir}/${this.path}/images`).forEach(
+        (image) => {
+          fs.copyFileSync(
+            `${this.config.dev.postsdir}/${this.path}/images/${image}`,
+            `${this.config.dev.outdir}/${this.path}/images/${image}`,
+          );
+        },
+      );
+    }
+  }
+};