@rahuldshetty/inscribe 0.0.1

package/cli/index.ts

@@ -0,0 +1,127 @@
+#!/usr/bin/env bun
+import { Cli, defineCommand } from "clerc";
+import fs from "fs-extra";
+import path from "path";
+import { LocalServer } from "./api/server";
+import { build } from "./api/builder";
+
+const templateDir = path.resolve(__dirname, "../template")
+
+const cli = Cli({
+    name: "inscribe",
+    scriptName: "inscribe",
+    description: "A simple static website generator for blogs and portfolio.",
+    version: "0.0.1",
+});
+
+const initCommand = defineCommand(
+    {
+        name: "init",
+        description: "Create scaffold for blog/docs",
+    },
+    async (ctx) => {
+        const target = process.cwd();
+        // check whether target is empty
+        if (fs.readdirSync(target).length > 0) {
+            console.log("Target directory is not empty");
+            return;
+        }
+        await fs.copy(templateDir, target, {
+            overwrite: false,
+        });
+        console.log("Docs scaffold created");
+    }
+);
+
+const devCommand = defineCommand(
+    {
+        name: "dev",
+        description: "Run development server",
+        parameters: [
+            "[path]",
+        ],
+        flags: {
+            port: {
+                type: Number,
+                alias: "p",
+                default: 3000,
+                description: "Port to run development server on",
+            },
+        },
+    },
+    async (ctx) => {
+        const sourceDir = path.resolve(process.cwd(), ctx.parameters.path || ".");
+        const port = ctx.flags.port;
+
+        if (!fs.existsSync(sourceDir)) {
+            console.error(`Error: directory not found ${sourceDir}`);
+            return;
+        }
+
+        console.log(`Starting dev server for: ${sourceDir} on port ${port}`);
+
+        const server = Bun.serve(LocalServer(sourceDir, true, port));
+
+        // Watch for changes and notify clients via WebSocket
+        let debounceTimer: Timer | null = null;
+        fs.watch(sourceDir, { recursive: true }, (event, filename) => {
+            if (filename && (filename.endsWith(".md") || filename.endsWith(".yaml") || filename.endsWith(".yml") || filename.endsWith(".json"))) {
+                if (debounceTimer) clearTimeout(debounceTimer);
+                debounceTimer = setTimeout(() => {
+                    console.log(`File changed: ${filename}. Triggering reload...`);
+                    server.publish("reload", "reload");
+                }, 100);
+            }
+        });
+
+        console.log(`Server running at http://localhost:${server.port}`);
+    }
+);
+
+const buildCommand = defineCommand(
+    {
+        name: "build",
+        description: "Build static website",
+        parameters: ["[path]"],
+        flags: {
+            output: {
+                type: String,
+                alias: "o",
+                default: "./dist",
+                description: "Output directory",
+            },
+            env: {
+                type: String,
+                default: "release",
+                description: "Build environment (dev or release)",
+            },
+        },
+    },
+    async (ctx) => {
+        const sourceDir = path.resolve(process.cwd(), ctx.parameters.path || ".");
+        const outputDir = path.resolve(process.cwd(), ctx.flags.output);
+
+        console.log(`Building static site from: ${sourceDir}`);
+        console.log(`Output directory: ${outputDir}`);
+        console.log(`Environment: ${ctx.flags.env}`);
+
+        try {
+            await build({
+                sourceDir,
+                outputDir,
+                env: ctx.flags.env,
+            });
+            console.log("Build completed successfully!");
+        } catch (error: any) {
+            console.error(`Build failed: ${error.message}`);
+        }
+    }
+);
+
+
+cli.command(initCommand);
+cli.command(devCommand);
+cli.command(buildCommand);
+
+// Parse arguments and run!
+cli.parse(); 

package/cli/schemas/blog.ts

@@ -0,0 +1,23 @@
+import * as z from "zod";
+
+export const BlogMetadataSchema = z.object({
+    title: z.string(),
+    author: z.string(),
+    date: z.string(),
+    slug: z.string(),
+    draft: z.preprocess((val) => (typeof val === "string" ? val.toLowerCase() === "true" : val), z.boolean()).default(true),
+    description: z.string().default("").optional(),
+    cover: z.string().default("").optional(),
+    cover_alt: z.string().default("").optional(),
+    tags: z.string().transform(val => val.split(",").map(t => t.trim())).optional(),
+    showToc: z.preprocess((val) => (typeof val === "string" ? val.toLowerCase() === "true" : val), z.boolean()).default(false),
+    weight: z.number().default(0).optional(),
+});
+
+export const BlogScehma = z.object({
+    metadata: BlogMetadataSchema,
+    markdown: z.string(),
+    isMDX: z.boolean().default(false),
+})
+
+export type Blog = z.infer<typeof BlogScehma>;

package/cli/schemas/folder.ts

@@ -0,0 +1,8 @@
+import * as z from "zod";
+
+export const FolderMetadataSchema = z.object({
+    title: z.string().optional(),
+    weight: z.number().default(0).optional(),
+});
+
+export type FolderMetadata = z.infer<typeof FolderMetadataSchema>;

package/cli/schemas/inscribe.ts

@@ -0,0 +1,14 @@
+import * as z from "zod";
+
+export const InscribeSchema = z.object({
+    title: z.string().default('Inscribe').optional(),
+    tagline: z.string().default('Inscribe Blog').optional(),
+    favicon: z.string().default('favicon.ico').optional(),
+    theme: z.string().default('default'),
+    show_home: z.preprocess((val) => (typeof val === "string" ? val.toLowerCase() === "true" : val), z.boolean()).default(true),
+    blog_path: z.string().default('blog').optional(),
+    doc_path: z.string().default('docs').optional(),
+    show_doc_nav: z.preprocess((val) => (typeof val === "string" ? val.toLowerCase() === "true" : val), z.boolean()).default(true).optional(),
+})
+
+export type InscribeConfig = z.infer<typeof InscribeSchema>;

package/cli/utils/markdown.ts

@@ -0,0 +1,72 @@
+import { marked } from "marked";
+import { parse as yamlParse } from "yaml";
+import { compile, run } from "@mdx-js/mdx";
+import * as jsxRuntime from "preact/jsx-runtime"
+import render from "preact-render-to-string"
+import fs from "fs-extra";
+import path from "path";
+import { FolderMetadataSchema, FolderMetadata } from "../schemas/folder";
+
+export const parseFolderMetadata = (dirPath: string): FolderMetadata => {
+    const indexPath = path.join(dirPath, "index.md");
+    if (fs.existsSync(indexPath)) {
+        const content = fs.readFileSync(indexPath, "utf-8");
+        const { data } = parseFrontMatter(content);
+        const validated = FolderMetadataSchema.safeParse(data);
+        if (validated.success) {
+            return validated.data;
+        }
+    }
+    return { title: path.basename(dirPath), weight: 0 };
+};
+
+export function parseFrontMatter(content: string) {
+    const regex = /^---\s*\r?\n([\s\S]*?)\r?\n---\s*\r?\n?([\s\S]*)$/;
+    const match = content.match(regex);
+    if (!match) return { data: {}, body: content };
+
+    const yamlStr = match[1];
+    const body = match[2];
+    
+    try {
+        const data = yamlParse(yamlStr);
+        return { data: data || {}, body };
+    } catch (e) {
+        // Fallback to manual parsing for "invalid" YAML with nested quotes
+        const data: Record<string, any> = {};
+        yamlStr.split(/\r?\n/).forEach(line => {
+            const index = line.indexOf(":");
+            if (index !== -1) {
+                const key = line.slice(0, index).trim();
+                const value = line.slice(index + 1).trim().replace(/^["']|["']$/g, "");
+                if (key) data[key] = value;
+            }
+        });
+        return { data, body };
+    }
+}
+
+export const markdown2HTML = async (content: string, isMDX: boolean = false) => {
+    if (isMDX) {
+        try {
+            // compile MDX -> JS
+            const compiled = await compile(content, { 
+                outputFormat: "function-body",
+                development: false 
+            });
+
+            // execute compiled module
+            const { default: Content } = await run(compiled, jsxRuntime);
+            
+            // render html
+            const html = render(Content({}));
+
+            return html;
+        } catch (e) {
+            console.error("MDX compilation error:", e);
+            return await marked(content);
+        }
+    }
+    const html = await marked(content)
+    return html;
+}

package/cli/utils/minifier.ts

@@ -0,0 +1,20 @@
+import { minify } from "html-minifier-terser";
+
+/**
+ * Robust HTML minifier using html-minifier-terser.
+ * @param html The HTML string to minify.
+ * @returns The minified HTML string.
+ */
+export async function minifyHtml(html: string): Promise<string> {
+    return await minify(html, {
+        collapseWhitespace: true,
+        removeComments: true,
+        minifyJS: true,
+        minifyCSS: true,
+        caseSensitive: true,
+        removeRedundantAttributes: true,
+        removeScriptTypeAttributes: true,
+        removeStyleLinkTypeAttributes: true,
+        useShortDoctype: true,
+    });
+}