Initial release

Author: bryan-ente

README.md

@@ -2,6 +2,13 @@
 
 ProtoML is a lightweight, declarative markup language designed for writing and structuring meeting protocols, notes and task lists in a human-readable and machine-parseable format.
 
+## Installing the Parser
+
+- Clone the repository: `git clone https://github.com/ente/protoml-parser.git`
+- Install the app: `npm install -g .`
+- Restart your terminal
+- Run `protoparser test.pml html` to convert a file named `test.pml` to HTML.
+
 ## Key Concepts
 
 - **Purely declarative** - no logic, no runtime, just the code
@@ -108,6 +115,7 @@ ProtoML is a lightweight, declarative markup language designed for writing and s
 ## protoparser (protoml-parser)
 
 `protoparser` is the command-line tool for parsing `.pml` files (ProtoML) and converting them into structured formats such as JSON, HTML, PDF and more.
+**The parser currently only support HTML rendering.** The other formats are planned for future releases.
 
 ### Basic Usage
 

bin/protoparser.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+const { log, setVerbosity } = require("../src/utils/logger.js")
+const { parseArgs } = require("../src/cli/options.js");
+const { parseFile } = require("../src/core/parser.js");
+const { saveToFile } = require("../src/utils/file.js");
+const renderers = require("../src/renders/index.js");
+
+const args = parseArgs()
+setVerbosity(args.verbosity)
+const ast = parseFile(args.filename, args)
+const output = renderers[args.format](ast, args)
+
+saveToFile(args.output, output, args.format)
+log("info", `File saved to ${args.output}.${args.format}`)	

package.json

@@ -0,0 +1,32 @@
+{
+  "name": "protoml-parser",
+  "version": "1.0.1",
+  "description": "ProtoML is a lightweight, declarative markup language designed for writing and structuring meeting protocols, notes and task lists in a human-readable and machine-parseable format.",
+  "keywords": [
+    "protoml",
+    "parser",
+    "meeting",
+    "protocol",
+    "notes",
+    "task",
+    "list"
+  ],
+  "main": "bin/protoparser.js",
+  "bin": {
+    "protoml-parser": "bin/protoparser.js",
+    "protoparser": "bin/protoparser.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Ente/protoml-parser.git"
+  },
+  "author": "Ente",
+  "license": "GPL-3.0-or-later",
+  "bugs": {
+    "url": "https://github.com/Ente/protoml-parser/issues"
+  },
+  "homepage": "https://github.com/Ente/protoml-parser#readme"
+}

src/cli/options.js

@@ -0,0 +1,84 @@
+function parseArgs(argv = process.argv.slice(2)) {
+  const options = {
+    filename: null,
+    format: null,
+    output: null,
+    verbosity: 0,
+    strict: false,
+    theme: null,
+  }
+
+  const positional = []
+
+  for (const arg of argv) {
+    if (arg.startsWith("-v")) {
+      options.verbosity = arg.length - 1 // -v, -vv, -vvv = 1–3
+    } else if (arg.startsWith("-output=")) {
+      options.output = arg.split("=")[1]
+    } else if (arg.startsWith("-theme=")) {
+      options.theme = arg.split("=")[1]
+    } else if (arg === "-strict") {
+      options.strict = true
+    } else if (arg === "--help") {
+      printHelp()
+      process.exit(0)
+    } else if (arg === "--version"){
+      // read from package.json as JSON
+      const fs = require("fs")
+      const path = require("path")
+      const packageJsonPath = path.join(__dirname, "..", "..", "package.json")
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"))
+      const version = packageJson.version
+      printVersion(version)
+      process.exit(0)
+    } else {
+      positional.push(arg)
+    }
+  }
+
+  if (positional.length >= 1) options.filename = positional[0]
+  if (positional.length >= 2) options.format = positional[1]
+
+  if (!options.filename || options.filename.startsWith("-")) {
+    console.error("[X] No valid input file provided.")
+    printHelp()
+    process.exit(1)
+  }
+
+  if (!options.format) {
+    options.format = "json"
+  }
+
+  if (!options.output) {
+    options.output = options.filename.replace(/\.[^/.]+$/, "")
+  }
+
+  return options
+}
+
+
+
+function printHelp() {
+  console.log(`
+Usage:
+  protoparser [options] <filename> <format>
+
+Options:
+  -v, -vv, -vvv          Set verbosity level (1–3)
+  -output=<filename>     Set output base name (without extension)
+  -theme=<name>          Apply export theme (HTML/PDF only)
+  -strict                Enable strict parsing
+  --help                 Show this help
+  --version              Show version information
+
+Examples:
+  protoparser Meeting.pml json
+  protoparser -vv -output=notes Meeting.pml html
+`)
+}
+
+function printVersion(version) {
+  console.log(`Protoparser version: ${version}`)
+}
+
+module.exports = { parseArgs }

src/core/blockParser.js

@@ -0,0 +1,87 @@
+function parseBlocks(tokens, options = {}) {
+  const result = {};
+  let currentBlock = null;
+
+  for (const token of tokens) {
+    if (token.type === "meta") {
+      result.meta = result.meta || {};
+      result.meta[token.key] = token.value;
+      continue;
+    }
+
+    if (token.type === "command") {
+      currentBlock = token.value.toLowerCase();
+      if (!result[currentBlock]) {
+        result[currentBlock] =
+          currentBlock === "meeting"
+            ? []
+            : currentBlock === "participants" || currentBlock === "tags"
+            ? {}
+            : [];
+      }
+    }
+
+    if (!currentBlock) continue;
+
+    switch (token.type) {
+      case "declaration":
+        if (currentBlock === "participants") {
+          const [name, alias, email] = token.value.split(",");
+          result[currentBlock][token.key] = {
+            name: name?.trim(),
+            alias: alias?.trim(),
+            email: email?.trim(),
+          };
+        } else if (currentBlock === "tags") {
+          result[currentBlock][token.key] = token.value;
+        } else {
+          // General key:value map
+          result[currentBlock][token.key] = token.value;
+        }
+        break;
+
+      case "entry":
+        if (currentBlock === "tasks") {
+          const done = token.value.startsWith("[x]");
+
+          const ptp = token.raw.match(/@ptp=([^\s]+)/)?.[1] || null;
+          const subject = token.raw.match(/=([^\s]+)/)?.[1] || null;
+          const tag = token.raw.match(/@tag=([^\s]+)/)?.[1] || null;
+
+          const cleanedText = token.value
+            .replace(/^\[(x| )\]/, "") 
+            .replace(/@ptp=[^\s]+/g, "")
+            .replace(/@tag=[^\s]+/g, "")
+            .replace(/=[^\s]+/g, "")
+            .replace(/\/\/.*/, "") // comments
+            .trim();
+
+          result[currentBlock].push({
+            raw: token.raw, // raw line (für referenceLinker)
+            text: cleanedText, // cleaned text for display
+            done,
+            meta: {
+              ptp,
+              subject,
+              tag,
+            },
+          });
+        } else {
+          result[currentBlock].push(token.value);
+        }
+        break;
+
+      case "heading":
+      case "inlineCommand":
+      case "text":
+        if (currentBlock === "meeting") {
+          result[currentBlock].push(token.raw);
+        }
+        break;
+    }
+  }
+
+  return result;
+}
+
+module.exports = {parseBlocks};

src/core/inlineParser.js

@@ -0,0 +1,58 @@
+function parseInline(ast, options = {}) {
+  const parseText = (text) => {
+    if (!text || typeof text !== "string") return text
+
+    // Links: -a=url text -a-
+    text = text.replace(/-a=([^\s]+)\s(.*?)-a-/g, (_, url, label) =>
+      `<a href="${url}" target="_blank">${label}</a>`)
+
+    // Bold: -b Text -b-
+    text = text.replace(/-b\s(.*?)-b-/g, (_, content) =>
+      `<b>${content}</b>`)
+
+    // Italic: -i Text -i-
+    text = text.replace(/-i\s(.*?)-i-/g, (_, content) =>
+      `<i>${content}</i>`)
+
+    return text
+  }
+
+  // Meeting
+  if (Array.isArray(ast.meeting)) {
+  ast.meeting = ast.meeting.map(line => {
+    // Optional: Kommentar entfernen
+    line = line.replace(/\/\/.*/, "").trim()
+
+    if (line.startsWith("### ")) return `<h3>${line.slice(4)}</h3>`
+    if (line.startsWith("## ")) return `<h2>${line.slice(3)}</h2>`
+    if (line.startsWith("# ")) return `<h1>${line.slice(2)}</h1>`
+
+    return parseText(line)
+  })
+}
+
+
+  // Notes
+  if (Array.isArray(ast.notes)) {
+    ast.notes = ast.notes.map(parseText)
+  }
+
+  // Tasks
+  if (Array.isArray(ast.tasks)) {
+    ast.tasks = ast.tasks.map(task => ({
+      ...task,
+      text: parseText(task.text)
+    }))
+  }
+
+  // Subjects
+  if (ast.subjects) {
+    for (const key in ast.subjects) {
+      ast.subjects[key] = parseText(ast.subjects[key])
+    }
+  }
+
+  return ast
+}
+
+module.exports = { parseInline }

src/core/loader.js

@@ -0,0 +1,46 @@
+const fs = require("fs")
+const path = require("path")
+const { tokenize } = require("./tokenizer")
+const { parseBlocks } = require("./blockParser")
+
+function loadAndMergeImports(mainAst, basePath, options = {}) {
+  if (!mainAst || typeof mainAst !== "object") return mainAst
+
+  const importLines = findTagImports(mainAst)
+
+  for (const importFile of importLines) {
+    const fullPath = path.resolve(basePath, importFile)
+
+    if (!fs.existsSync(fullPath)) {
+      if (options.strict) throw new Error(`Import file not found: ${fullPath}`)
+      else continue
+    }
+
+    const raw = fs.readFileSync(fullPath, "utf8")
+    const tokens = tokenize(raw)
+    const importedAst = parseBlocks(tokens, options)
+
+    // Merge relevant blocks (tags, participants, subjects…)
+    for (const key in importedAst) {
+      if (!mainAst[key]) mainAst[key] = {}
+      if (typeof importedAst[key] === "object" && !Array.isArray(importedAst[key])) {
+        mainAst[key] = { ...importedAst[key], ...mainAst[key] } // imported gets overridden by main
+      }
+    }
+  }
+
+  return mainAst
+}
+
+function findTagImports(ast) {
+  if (!ast || !ast.tags_import) return []
+
+  const lines = Array.isArray(ast.tags_import) ? ast.tags_import : [ast.tags_import]
+
+  return lines
+    .map(line => line.match(/@tags_import\s+"(.+?)"/))
+    .filter(Boolean)
+    .map(match => match[1])
+}
+
+module.exports = { loadAndMergeImports }

src/core/parser.js

@@ -0,0 +1,27 @@
+const fs = require("fs")
+const path = require("path")
+
+const { tokenize } = require("./tokenizer")
+const { parseBlocks } = require("./blockParser")
+const { resolveReferences } = require("./referenceLinker")
+const { parseInline } = require("./inlineParser")
+const { loadAndMergeImports } = require("./loader")
+
+function parseFile(filename, options = {}) {
+  if (!fs.existsSync(filename)) {
+    throw new Error(`File not found: ${filename}`)
+  }
+
+  const raw = fs.readFileSync(filename, "utf8")
+  const tokens = tokenize(raw)
+  let ast = parseBlocks(tokens, options)
+
+  ast = loadAndMergeImports(ast, path.dirname(filename), options)
+
+  ast = resolveReferences(ast, options)
+  ast = parseInline(ast, options)
+
+  return ast
+}
+
+module.exports = { parseFile }