@portosaur/cli 0.6.3 → 0.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portosaur/cli",
-  "version": "0.6.3",
+  "version": "0.9.1",
   "description": "CLI for Portosaur - The static Personal portfolio site generator.",
   "license": "GPL-3.0-only",
   "author": "soymadip",
@@ -26,9 +26,9 @@
   },
   "types": "./src/index.d.ts",
   "dependencies": {
-    "@portosaur/core": "^0.6.3",
-    "@portosaur/logger": "^0.6.3",
-    "@portosaur/wizard": "^0.6.3",
+    "@portosaur/core": "^0.9.1",
+    "@portosaur/logger": "^0.9.1",
+    "@portosaur/wizard": "^0.9.1",
     "commander": "^13.1.0",
     "js-yaml": "^4.1.1"
   }

package/src/commands/schema.mjs

@@ -5,151 +5,198 @@ import { logger } from "@portosaur/logger";
 /**
  * Portosaur Discovery-Based Schema Generator
  *
- * This command "discovers" the configuration schema by parsing the actual
- * Docusaurus config building logic. Every key accessed via the `get()` helper
- * is recorded and mapped to a JSON schema.
+ * Discovers the configuration schema by parsing every key accessed via the
+ * `get()` and `rawGet()` helpers in docusaurusConfig.mjs.
+ *
+ * It parses all arguments in the call:
+ * `get("key1", "key2", "default")`
+ * - "key1" and "key2" are discovered as schema properties
+ * - "default" is recorded as the default value
  */
+
+// ------- Helpers -------
+
+function applyEntry(propertiesRoot, dotPath, leafSchema) {
+  const parts = dotPath.split(".");
+  let current = propertiesRoot;
+
+  parts.forEach((part, index) => {
+    const isLast = index === parts.length - 1;
+
+    if (!current[part]) {
+      current[part] = isLast
+        ? { ...leafSchema }
+        : { type: "object", additionalProperties: false, properties: {} };
+    } else if (!isLast && current[part].type !== "object") {
+      current[part] = {
+        type: "object",
+        additionalProperties: false,
+        properties: {},
+      };
+    }
+
+    if (!isLast) {
+      if (!current[part].properties) {
+        current[part].properties = {};
+      }
+      current = current[part].properties;
+    }
+  });
+}
+
+function isJsExpression(val) {
+  if (!val) return false;
+  return (
+    val.startsWith("`") ||
+    val.includes("${") ||
+    val.includes("()") ||
+    /^[a-zA-Z_$][a-zA-Z0-9_.]*$/.test(val) // bare identifier
+  );
+}
+
+// ------- Main -------
+
 export async function schemaCommand(options = {}) {
-  // Resolve paths for the monorepo structure
   const pkgDir = path.resolve(import.meta.dirname, "../");
   const coreDir = path.resolve(pkgDir, "../../core");
 
   const SOURCE_FILE =
     typeof options.config === "string"
       ? path.resolve(process.cwd(), options.config)
-      : path.resolve(coreDir, "src/index.mjs");
+      : path.resolve(coreDir, "src/generators/docusaurusConfig.mjs");
 
   const OUTPUT_FILE =
     typeof options.output === "string"
       ? path.resolve(process.cwd(), options.output)
-      : path.resolve(pkgDir, "../../../configSchema.json");
+      : path.resolve(coreDir, "configSchema.json");
 
   const discoveredSchema = {
     $schema: "http://json-schema.org/draft-07/schema#",
     title: "Portosaur Project Configuration",
+    description: "Schema for config.yml — validated at build time by porto.",
     type: "object",
     properties: {},
     required: [],
-    additionalProperties: true,
+    additionalProperties: false,
   };
 
-  // State for Balanced Parenthesis Walker
-  const getStartRegex = /get\(\s*["']([^"']+)["']\s*,\s*/g;
-  let match;
-
   try {
     if (!fs.existsSync(SOURCE_FILE)) {
       throw new Error(`Source file not found: ${SOURCE_FILE}`);
     }
 
-    logger.info(`Discovering keys from ${SOURCE_FILE}...`);
+    logger.info(`Discovering keys from: ${SOURCE_FILE}`);
     const sourceCode = fs.readFileSync(SOURCE_FILE, "utf8");
 
-    // Discovery Loop
+    // match the start of `get(` or `rawGet(`
+    const getStartRegex = /\b(?:get|rawGet)\s*\(/g;
+    let match;
+
     while ((match = getStartRegex.exec(sourceCode)) !== null) {
-      const keyPath = match[1];
       const startIdx = match.index + match[0].length;
 
-      let braceCount = 1;
+      let depth = 1;
       let currentIdx = startIdx;
-      let defaultValueRaw = "";
+      let argsRaw = [];
+      let currentArg = "";
       let inString = null;
       let inComment = null;
       let escaped = false;
 
-      // Extract raw default value using balanced parenthesis walker
-      while (braceCount > 0 && currentIdx < sourceCode.length) {
+      // Extract all arguments separated by commas
+      while (depth > 0 && currentIdx < sourceCode.length) {
         const char = sourceCode[currentIdx];
         const nextChar = sourceCode[currentIdx + 1];
 
         if (escaped) {
           escaped = false;
+          currentArg += char;
         } else if (char === "\\") {
           escaped = true;
+          currentArg += char;
         } else if (!inString && !inComment) {
-          if (char === "'" || char === '"' || char === "`") inString = char;
-          else if (char === "/" && nextChar === "/") inComment = "//";
-          else if (char === "/" && nextChar === "*") inComment = "/*";
-          else if (char === "(") braceCount++;
-          else if (char === ")") braceCount--;
+          if (char === "'" || char === '"' || char === "`") {
+            inString = char;
+            currentArg += char;
+          } else if (char === "/" && nextChar === "/") {
+            inComment = "//";
+          } else if (char === "/" && nextChar === "*") {
+            inComment = "/*";
+          } else if (char === "(" || char === "[" || char === "{") {
+            depth++;
+            currentArg += char;
+          } else if (char === ")" || char === "]" || char === "}") {
+            depth--;
+            if (depth > 0) currentArg += char;
+          } else if (char === "," && depth === 1) {
+            argsRaw.push(currentArg.trim());
+            currentArg = "";
+          } else {
+            currentArg += char;
+          }
         } else if (inString) {
           if (char === inString) inString = null;
+          currentArg += char;
         } else if (inComment === "//") {
           if (char === "\n") inComment = null;
         } else if (inComment === "/*") {
           if (char === "*" && nextChar === "/") {
             inComment = null;
-            defaultValueRaw += "*/";
-            currentIdx += 2;
-            continue;
+            currentIdx++;
           }
         }
-
-        if (braceCount > 0) defaultValueRaw += char;
         currentIdx++;
       }
 
-      // Extract Documentation Comments
+      if (currentArg.trim()) {
+        argsRaw.push(currentArg.trim());
+      }
+
+      if (argsRaw.length === 0) continue;
+
+      const defaultValueRaw = argsRaw.pop(); // Last argument is default
+
+      // All remaining arguments that are simple strings are key paths
+      const keys = [];
+      for (const arg of argsRaw) {
+        if (/^["'][^"']+["']$/.test(arg)) {
+          keys.push(arg.slice(1, -1));
+        }
+      }
+
+      if (keys.length === 0) continue;
+
+      // Extract comment
       const beforeMatch = sourceCode.slice(0, match.index);
-      const currentLineStart = beforeMatch.lastIndexOf("\n");
-      const linesBefore = sourceCode
-        .slice(0, currentLineStart === -1 ? 0 : currentLineStart)
-        .split("\n");
-
-      let i = linesBefore.length - 1;
-      let foundComment = [];
-      let inDocBlock = false;
-
-      while (i >= 0 && foundComment.length < 15) {
-        let line = linesBefore[i].trim();
-        if (!line && !inDocBlock) break;
-        if (line.endsWith("*/")) inDocBlock = true;
-
-        if (inDocBlock) {
-          const content = line.replace(/^\/\*\*?|\*\/|\*/g, "").trim();
-          if (content) foundComment.unshift(content);
-          if (line.startsWith("/*") || line.startsWith("/**"))
-            inDocBlock = false;
-        } else if (line.startsWith("//")) {
-          let content = line.replace(/^\/\/\s?/, "").trim();
+      const lines = beforeMatch.split("\n");
+
+      let description = "";
+      let i = lines.length - 1;
+      const commentLines = [];
+
+      while (i >= 0 && commentLines.length < 5) {
+        const line = lines[i].trim();
+        if (!line) break;
+        if (line.startsWith("//")) {
+          const content = line.replace(/^\/\/\s?/, "").trim();
           if (!content.match(/^(TODO|FIXME|NOTE|SECTION|---)/i)) {
-            foundComment.unshift(content);
+            commentLines.unshift(content);
           }
-        } else if (line && !line.startsWith("/") && !line.startsWith("*")) {
+          i--;
+        } else if (line.endsWith("*/") || line.startsWith("*")) {
+          break;
+        } else {
           break;
         }
-        i--;
       }
-      const description = foundComment.join("\n").trim();
+      description = commentLines.join(" ").trim();
+
+      // Type inference
+      const val = defaultValueRaw;
 
-      // Basic Type Inference and Argument Parsing
       let type = "string";
       let defaultValue = undefined;
-
-      let args = [];
-      let currentArg = "";
-      let depth = 0;
-      let argInString = null;
-
-      for (let i = 0; i < defaultValueRaw.length; i++) {
-        const c = defaultValueRaw[i];
-        if (!argInString) {
-          if (c === "'" || c === '"' || c === "`") argInString = c;
-          else if (c === "(" || c === "[" || c === "{") depth++;
-          else if (c === ")" || c === "]" || c === "}") depth--;
-          else if (c === "," && depth === 0) {
-            args.push(currentArg.trim());
-            currentArg = "";
-            continue;
-          }
-        } else if (c === argInString && defaultValueRaw[i - 1] !== "\\") {
-          argInString = null;
-        }
-        currentArg += c;
-      }
-      if (currentArg.trim()) args.push(currentArg.trim());
-
-      let val = (args[args.length - 1] || "").trim();
+      let isFreeform = false;
 
       if (val === "true" || val === "false") {
         type = "boolean";
@@ -164,45 +211,29 @@ export async function schemaCommand(options = {}) {
         val.includes(".slice(")
       ) {
         type = "array";
+      } else if (val === "{}") {
+        type = "object";
+        isFreeform = true;
       } else if (val.startsWith("{")) {
         type = "object";
-      } else if (val) {
-        defaultValue = val.replace(/^["'`](.*)["'`]$/s, "$1").trim();
+      } else if (val && !isJsExpression(val)) {
+        defaultValue = val.replace(/^["'`](.*?)["'`]$/s, "$1").trim();
       }
 
-      // Map to Discovered Schema Object
-      const parts = keyPath.split(".");
-      let current = discoveredSchema.properties;
-
-      parts.forEach((part, index) => {
-        const isLast = index === parts.length - 1;
+      const leafSchema = { type };
+      if (isFreeform) leafSchema.additionalProperties = true;
+      if (description) leafSchema.description = description;
+      if (defaultValue !== undefined) leafSchema.default = defaultValue;
 
-        if (!current[part]) {
-          if (isLast) {
-            current[part] = { type };
-            if (description) current[part].description = description;
-            if (defaultValue !== undefined)
-              current[part].default = defaultValue;
-          } else {
-            current[part] = { type: "object", properties: {} };
-          }
-        } else if (!isLast && current[part].type !== "object") {
-          current[part] = { type: "object", properties: {} };
-        }
-
-        if (!isLast) {
-          if (!current[part].properties) current[part].properties = {};
-          current = current[part].properties;
-        }
-      });
+      for (const keyPath of keys) {
+        applyEntry(discoveredSchema.properties, keyPath, leafSchema);
+      }
     }
 
     fs.writeFileSync(OUTPUT_FILE, JSON.stringify(discoveredSchema, null, 2));
-    logger.success(
-      `Successfully discovered and wrote schema to: ${OUTPUT_FILE}`,
-    );
+    logger.success(`Schema written to: ${OUTPUT_FILE}`);
   } catch (error) {
-    logger.error(`Discovery failed: ${error.message}`);
+    logger.error(`Schema generation failed: ${error.message}`);
     process.exit(1);
   }
 }

package/src/templates/config.yml

@@ -1,15 +1,11 @@
 # yaml-language-server: $schema=https://soymadip.github.io/portosaur/conf-schema.json
+#
 # Portosaur Project Configuration
-# This file is filled with example values
-# Check Config Docs: https://soymadip.is-a.dev/portosaur/guide/config
+# Check full Config Docs: https://soymadip.is-a.dev/portosaur/guide/config
 
 # Site Metadata & SEO
 site:
-  title: "{{fullName}}"
-  tagline: "Short description about you, your passion, your goals etc."
-
-  favicon: "{{portoRoot}}/assets/img/svg/icon.svg"
-  social_card: "{{portoRoot}}/assets/img/social-card.jpeg"
+  favicon: null # By default, generates from {{home_page.hero.profile_pic}}
 
   # Auto set if deploying in Github/GitLab Pages
   url: "auto"
@@ -17,21 +13,16 @@ site:
 
 # UI/UX & Theme Behavior
 theme:
-  appearance:
-    dark_mode: true
-    disable_switch: false
-
   navigation:
     collapsable_sidebar: true
-    hide_navbar_on_scroll: true
 
 # Page Content & Sections
 home_page:
   hero:
-    title: null # Fallback to {{site.title}}
+    title: "{{fullName}}"
     profession: "Your Profession"
-    desc: null # Fallback to {{site.tagline}}
-    profile_pic: null # Fallback to {{site.favicon}}
+    desc: "Short description about you, your passion, your goals etc."
+    profile_pic: "{{portoRoot}}/assets/img/svg/icon.svg"
 
     social:
       - name: "LinkedIn"
@@ -135,7 +126,7 @@ tasks:
       status: "done"
       desc: "Implementing the core framework."
 
-# Functional Tools
+# Functional Tools [TODO]
 tools:
   link_shortener:
     enable: false

package/src/utils/runner.mjs

@@ -2,7 +2,7 @@ import fs from "fs";
 import path from "path";
 import { spawn } from "child_process";
 import { createRequire } from "module";
-import { hasCommand } from "@portosaur/core";
+import { hasCommand, getPortoDotDir } from "@portosaur/core";
 
 /**
  * Generates a static Docusaurus config file by evaluating the Portosaur config
@@ -15,7 +15,7 @@ import { hasCommand } from "@portosaur/core";
  * @returns {string} The path to the generated config file.
  */
 export function writeConfigShim(UserRoot, portoPaths, context = {}) {
-  const dotDir = path.join(UserRoot, ".docusaurus", "portosaur");
+  const dotDir = getPortoDotDir(UserRoot);
 
   if (!fs.existsSync(dotDir)) {
     fs.mkdirSync(dotDir, { recursive: true });
@@ -174,6 +174,30 @@ export async function runDocusaurus(
 
   args.push(...extraArgs);
 
+  // Strip the hardcoded Docusaurus generator tag from its internal HTML templates
+  // so that only the Portosaur metadata tag is rendered in the final output.
+  try {
+    const coreLibDir = path.resolve(path.dirname(docusaurusBin), "../lib");
+    const templates = [
+      path.join(coreLibDir, "webpack/templates/dev.html.template.ejs"),
+      path.join(coreLibDir, "ssg/ssgTemplate.html.js"),
+    ];
+    for (const tpl of templates) {
+      if (fs.existsSync(tpl)) {
+        let content = fs.readFileSync(tpl, "utf8");
+        const newContent = content.replace(
+          /<meta name="generator" content="Docusaurus[^"]*">\n?/g,
+          "",
+        );
+        if (content !== newContent) {
+          fs.writeFileSync(tpl, newContent, "utf8");
+        }
+      }
+    }
+  } catch (err) {
+    // Ignore permissions or missing file errors
+  }
+
   // Use bun when available for faster builds, fall back to node.
   // If node isn't installed, fallback to bun gracefully.
   let runtime = "node";