producs 1.0.1

package/cli.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+const { Command } = require("commander");
+const fs = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+const { ProDucs } = require("./producs.js");
+
+const PAGES_DIR = "/usr/share/producs";
+const program = new Command();
+
+// ───────────────────────────────────────────────
+// Utility functions
+// ───────────────────────────────────────────────
+function listPages(showDesc = false) {
+  if (!fs.existsSync(PAGES_DIR)) {
+    console.log(chalk.red(`No pages directory found at ${PAGES_DIR}`));
+    return;
+  }
+
+  const files = fs.readdirSync(PAGES_DIR).filter(f => f.endsWith(".prd"));
+  if (files.length === 0) {
+    console.log(chalk.yellow("No .prd pages found in"), PAGES_DIR);
+    return;
+  }
+
+  console.log(chalk.bold.cyan("Available ProDucs pages:\n"));
+  for (const file of files) {
+    const name = file.replace(/\.prd$/, "");
+    let desc = "";
+    if (showDesc) {
+      try {
+        const firstLine = fs.readFileSync(path.join(PAGES_DIR, file), "utf8").split("\n")[0];
+        desc = " — " + firstLine.trim();
+      } catch {}
+    }
+    console.log(" • " + chalk.green(name) + chalk.gray(desc));
+  }
+}
+
+// ───────────────────────────────────────────────
+// Page runner
+// ───────────────────────────────────────────────
+function runPage(name) {
+  const filePath = path.join(PAGES_DIR, name.endsWith(".prd") ? name : name + ".prd");
+  if (!fs.existsSync(filePath)) {
+    console.error(chalk.red(`Page not found:`), filePath);
+    console.log();
+    listPages(true);
+    process.exit(1);
+  }
+
+  const src = fs.readFileSync(filePath, "utf8");
+  const engine = new ProDucs();
+
+  console.log(chalk.yellowBright(`\n── Running page: ${name} ──\n`));
+  try {
+    const ast = engine.astify(src);
+    engine.execute(ast);
+    console.log(chalk.greenBright("\n✔ Page completed successfully.\n"));
+  } catch (err) {
+    console.error(chalk.red.bold("\n✖ Execution error:"), err.message, "\n");
+    process.exit(1);
+  }
+}
+
+// ───────────────────────────────────────────────
+// CLI setup with commander
+// ───────────────────────────────────────────────
+program
+  .name("producs")
+  .description("Interactive documentation and tutorial runner")
+  .version("1.0.0");
+
+program
+  .command("list")
+  .description("List all available ProDucs pages")
+  .option("-d, --describe", "Show first-line descriptions for each page")
+  .action((options) => listPages(options.describe));
+
+program
+  .command("run <page>")
+  .description("Run a specific ProDucs documentation page")
+  .action(runPage);
+
+program
+  .argument("[page]", "Run a page directly (shortcut for 'run <page>')")
+  .action((page) => {
+    if (page) runPage(page);
+    else listPages(true);
+  });
+
+program.parse(process.argv);

package/index.js

@@ -0,0 +1,185 @@
+const { execSync } = require("child_process");
+const prompt = require("prompt-sync")({ sigint: true });
+
+class ProDucs {
+  constructor() {
+    this.commands = {
+      ">": (text, value, promptText = "") => {
+        const result = prompt(promptText || text || "");
+        return { VALUE: result, failed: result ? 0 : 1 };
+      },
+      Check_equals: (text, value, expected) => ({
+        VALUE: value.VALUE,
+        failed: value.VALUE === expected ? 0 : 1
+      }),
+      Check_failed_error: (text, value, msg) => {
+        if (value.failed) throw new Error(msg || "Check failed!");
+        return value;
+      },
+      Shell_run: (text, value) => {
+        execSync(value.VALUE, { stdio: "inherit" });
+        return { VALUE: value.VALUE, failed: 0 };
+      },
+      Text: (text, value, str) => ({ VALUE: str || text, failed: 0 })
+    };
+  }
+
+  // ──────────────────────────── TOKENIZER ────────────────────────────
+  tokenize(src) {
+    const tokens = [];
+    let i = 0;
+    const peek = () => src[i];
+    const next = () => src[i++];
+    const eof = () => i >= src.length;
+    const skipSpaces = () => { while (!eof() && /\s/.test(peek())) next(); };
+
+    const readIdent = () => {
+      let name = "";
+      while (!eof() && /[A-Za-z0-9_>]/.test(peek())) name += next();
+      return name;
+    };
+
+    const readArgs = () => {
+      const args = [];
+      let buf = "";
+      if (peek() === "[") {
+        next();
+        while (!eof()) {
+          const c = next();
+          if (c === "]") break;
+          if (c === ",") {
+            args.push(buf.trim().replace(/^'|'$/g, ""));
+            buf = "";
+          } else buf += c;
+        }
+        if (buf.trim()) args.push(buf.trim().replace(/^'|'$/g, ""));
+      }
+      return args;
+    };
+
+    while (!eof()) {
+      skipSpaces();
+
+      if (peek() === "#" && src[i + 1] === "$") {
+        i += 2;
+        if (src.startsWith("End_", i)) {
+          i += 4;
+          const name = readIdent();
+          tokens.push({ type: "COMMAND_END", name });
+        } else {
+          const name = readIdent();
+          const args = readArgs();
+          tokens.push({ type: "COMMAND_START", name, args });
+        }
+      } else {
+        let text = "";
+        while (!eof() && !(peek() === "#" && src[i + 1] === "$")) text += next();
+        if (text.trim()) tokens.push({ type: "TEXT", value: text.trim() });
+      }
+    }
+
+    return tokens;
+  }
+
+  // ──────────────────────────── PARSER ────────────────────────────
+  parse(tokens) {
+    const root = [];
+    const stack = [];
+
+    for (let i = 0; i < tokens.length; i++) {
+      const token = tokens[i];
+
+      if (token.type === "COMMAND_START") {
+        const node = {
+          type: token.name,
+          args: token.args,
+          children: [],
+          pipedCommands: []
+        };
+
+        // Inline (pipe) commands
+        if (stack.length && !token.name.startsWith("End_")) {
+          const parent = stack.at(-1);
+          if (parent.type === ">" || parent.pipedCommands.length) {
+            parent.pipedCommands.push(node);
+            continue;
+          }
+        }
+
+        // Block commands
+        stack.push(node);
+
+      } else if (token.type === "COMMAND_END") {
+        const last = stack.pop();
+        if (!last)
+          throw new Error(`Unexpected #$End_${token.name}`);
+        if (last.type !== token.name)
+          throw new Error(`Mismatched end: expected #$End_${last.type}, got #$End_${token.name}`);
+        if (stack.length) stack.at(-1).children.push(last);
+        else root.push(last);
+      } else if (token.type === "TEXT") {
+        const node = { type: "Text", value: token.value };
+        if (stack.length) stack.at(-1).children.push(node);
+        else root.push(node);
+      }
+    }
+
+    if (stack.length) throw new Error(`Unclosed command: ${stack.at(-1).type}`);
+    return root;
+  }
+
+  astify(text) {
+    return this.parse(this.tokenize(text));
+  }
+
+  // ──────────────────────────── EXECUTION ────────────────────────────
+  executeNode(node, input = { VALUE: "", failed: 0 }) {
+    // Handle text nodes directly
+    if (node.type === "Text")
+      return { VALUE: console.log(node.value), failed: 0 };
+
+    const cmd = this.commands[node.type];
+    if (!cmd) throw new Error(`Unknown command: ${node.type}`);
+
+    // Get the first text child as `text`
+    const textChild = node.children.find(c => c.type === "Text");
+    const text = textChild ? textChild.value : "";
+
+    // Base execution (text, value, ...args)
+    let current = cmd(text, input, ...node.args);
+
+    // Inline piped commands
+    for (const pipe of node.pipedCommands) {
+      const fn = this.commands[pipe.type];
+      if (!fn) throw new Error(`Unknown piped command: ${pipe.type}`);
+      const pipeText = pipe.children.find(c => c.type === "Text")?.value || "";
+      current = fn(pipeText, current, ...pipe.args);
+    }
+
+    // Block children
+    for (const child of node.children) {
+      if (child.type !== "Text") current = this.executeNode(child, current);
+    }
+
+    return current;
+  }
+
+  execute(ast) {
+    let result = { VALUE: "", failed: 0 };
+    for (const node of ast) {
+      result = this.executeNode(node, result);
+    }
+    return result;
+  }
+}
+
+// ──────────────────────────── Example ────────────────────────────
+const src = `
+Hi
+#$> Type your command: #$Check_equals['ls -la'] #$Check_failed_error['expected ls -la!'] #$Shell_run #$End_>
+`;
+
+const prod = new ProDucs();
+const ast = prod.astify(src);
+console.log("AST:", JSON.stringify(ast, null, 2));
+prod.execute(ast);

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "producs",
+  "version": "1.0.1",
+  "description": "simple documentation engine",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "bin": {
+    "prod": "./cli.js"
+  },
+  "keywords": [],
+  "author": "purcwix",
+  "license": "MIT",
+  "type": "commonjs",
+  "dependencies": {
+    "commander": "^14.0.1",
+    "prompt-sync": "^4.2.0"
+  }
+}