drakongen 1.2.0 → 1.4.2

package/.vscode/launch.json

@@ -11,8 +11,8 @@
             "skipFiles": [
                 "<node_internals>/**"
             ],
-            "program": "${workspaceFolder}/src/index.js",
-            "args": ["examples/tmp.drakon"]
+            "program": "${workspaceFolder}/src/main.js",
+            "args": ["examples/Comments.drakon"]
         }
     ]
 }

package/README.md

@@ -1,8 +1,8 @@
 # drakongen
 
-**drakongen** generates pseudocode from drakon flowcharts built with [DrakonWidget](https://github.com/stepan-mitkin/drakonwidget) or [DrakonHub](https://github.com/stepan-mitkin/drakonhub_desktop).
+**drakongen** generates pseudocode from drakon flowcharts and mind-maps built with [DrakonWidget](https://github.com/stepan-mitkin/drakonwidget) or [DrakonHub](https://github.com/stepan-mitkin/drakonhub_desktop).
 
-One can use the output pseudocode as a prompt for AI applications like ChatGPT or CodePilot.
+One can use the output pseudocode as a prompt for AI applications like ChatGPT, Grok, or Gemini.
 
 **drakongen** can also generate a generic AST from drakon flowcharts to generate source code in programming languages, for example, JavaScript.
 **drakongen**  turns a drakon flowchart into a tree in the JSON format that one can trivially transform into code in any programming language.
@@ -15,17 +15,21 @@ Include the `drakongen.js` script on the web page.
 <script src="browser/drakongen.js"></script>
 ```
 
-Call `drakongen.toPseudocode` or `drakongen.toTree` functions.
+Call `drakongen.toPseudocode`, `drakongen.toMindTree`, or `drakongen.toTree` functions.
 
 ```html
 <script>
 var drakon = ... // Get the drakon chart from DrakonWidget
+var mindJson = ... // Graf mind-map as json
 var name = "Diagram one"
 var filename = "Diagram one.drakon"
 
 var pseudo = drakongen.toPseudocode(drakon, name, filename, "en")
 console.log(pseudo)
 
+var mind = drakongen.toMindTree(mindJson, name, filename)
+console.log(mind)
+
 var tree = drakongen.toTree(drakon, name, filename, "en")
 console.log(tree)
 
@@ -47,18 +51,22 @@ npm i drakongen
 ```
 
 - Require the **drakongen** module.
-- Call `toPseudocode` or `toTree` functions.
+- Call `toPseudocode`, `toMindTree`, or `toTree` functions.
 
 ```javascript
 const {toTree, toPseudocode} = require("drakongen")
 
 var drakon = ... // Get the drakon chart from DrakonWidget
+var mindJson = ... // Graf mind-map as json
 var name = "Diagram one"
 var filename = "Diagram one.drakon"
 
 var pseudo = toPseudocode(drakon, name, filename, "en")
 console.log(pseudo)
 
+var mind = toMindTree(mindJson, name, filename)
+console.log(mind)
+
 var tree = toTree(drakon, name, filename, "en")
 console.log(tree)
 ```
@@ -73,8 +81,76 @@ npm i --global drakongen
 
 Run the **drakongen** utility.
 
+### Generate from one file
+
+A .drakon flowchart will be converted to pseudocode.
+
+A .graf mind-map will be converted to tree-like text.
+
 In this example, the language is Norwegian, the path to the output folder is **out**, the input file is **Hello.drakon**:
 
 ```
 drakongen --language no --output out Hello.drakon
 ```
+
+## Project mode
+
+Drakongen in project mode generates a single prompt file by processing and concatenating multiple input files, including flowcharts, mind-maps, text files, and directories. It reads a project file specifying the input files, processes them in the defined order, and outputs a consolidated prompt file suitable for AI-driven code generation.
+
+### Features
+
+- **Processes multiple file types**:
+  - Plain text files (e.g., `.txt`) are included as-is.
+  - Mind-map files (e.g., `.graf`) are converted to indented text.
+  - Flowchart files (e.g., `.drakon`) are converted to pseudocode.
+  - Directories are recursively processed, including all files within.
+- **Preserves file order**: Files are processed and concatenated in the exact order specified in the project file, which is critical for AI tools relying on sequential context.
+- **Flexible project file format**: A simple text-based project file lists files and directories to process.
+
+
+### Usage
+
+Run the tool with the following command:
+
+```bash
+drakongen --project <project_file> --output <output_directory>
+```
+
+- `--project`: Path to the project file (e.g., `exampleproject/foo.proj`).
+- `--output`: Directory where the output prompt file will be saved (e.g., `exampleproject`).
+
+### Example
+
+Given a project file `exampleproject/foo.proj` with the following content:
+
+
+```
+start.txt
+math
+class Point.graf
+foo.drakon
+```
+
+Run:
+
+```bash
+drakongen --project exampleproject/foo.proj --output exampleproject
+```
+
+This will:
+
+1. Include `start.txt` as-is.
+2. Process all files in the `math` directory recursively.
+3. Convert `class Point.graf` (mind-map) to indented text.
+4. Convert `foo.drakon` (flowchart) to pseudocode.
+5. Concatenate all processed content into `exampleproject/foo.txt`.
+
+The output file `foo.txt` will contain the concatenated text in the exact order specified in `foo.proj`.
+
+### Project File Format
+
+The project file (e.g., `foo.proj`) is a plain text file where each line specifies:
+
+- A file path (relative to the project file) for a text, mind-map, or flowchart file.
+- A directory path to process all files within it recursively.
+

package/browser/drakongen.js

@@ -16,21 +16,17 @@ function htmlToString(html) {
         if (node.tagName === 'P') {
             output.push(node.textContent.trim());
         } else if (node.tagName === 'UL') {
-            output.push('');
             node.childNodes.forEach((item) => {
                 if (item.tagName === 'LI') {
                     output.push(`- ${item.textContent.trim()}`);
                 }
             });
-            output.push('');
         } else if (node.tagName === 'OL') {
-            output.push('');
             node.childNodes.forEach((item, index) => {
                 if (item.tagName === 'LI') {
                     output.push(`${index + 1}. ${item.textContent.trim()}`);
                 }
             });
-            output.push('');
         }
     });
 
@@ -40,18 +36,17 @@ function htmlToString(html) {
 module.exports = {htmlToString}
 },{}],2:[function(require,module,exports){
 const {drakonToStruct} = require("./drakonToStruct");
-const {printPseudo} = require('./printPseudo');
-const {addRange} = require("./tools")
+const {printPseudo, printWithIndent, makeIndent} = require('./printPseudo');
+const {addRange, sortByProperty} = require("./tools")
 
-function drakonToPseudocode(drakonJson, name, filename, htmlToString, translate) {
+function drakonToPseudocode(drakonJson, name, filename, htmlToString, translate) {    
     var diagram = drakonToStruct(drakonJson, name, filename, translate)
     var lines = []
+
+    lines.push("## " + translate("Procedure") + " \"" + diagram.name + "\"")
     if (diagram.params) {
         addRange(lines, htmlToString(diagram.params))
-        lines.push("")
-    }
-
-    lines.push(translate("Procedure") + " \"" + diagram.name + "\"")
+    }    
     lines.push("")
     lines.push(translate("Algorithm") + ":")    
     
@@ -70,6 +65,7 @@ function drakonToPseudocode(drakonJson, name, filename, htmlToString, translate)
             lines.push(translate("End of subroutine"))
         })
     }  
+    lines.push("")
     lines.push(translate("End of procedure"))
     if (diagram.description) {
         lines.push("")       
@@ -82,10 +78,83 @@ function drakonToPseudocode(drakonJson, name, filename, htmlToString, translate)
     return {text:text,json:str}
 }
 
-module.exports = { drakonToPseudocode };
+
+function mindToTree(drakonJson, name, filename, htmlToString) {
+    let drakonGraph;
+    try {
+        drakonJson = drakonJson || ""
+        drakonJson = drakonJson.trim()
+        drakonJson = drakonJson || "{}"
+        drakonGraph = JSON.parse(drakonJson);
+    } catch (error) {
+        var message = translate("Error parsing JSON") + ": " + error.message
+        throw createError(message, filename)
+    }
+
+    const nodes = drakonGraph.items || {};
+    var root = createMindNode("## " + name)
+    nodes["root"] = root
+    connectMindNodesToParent(nodes)
+    sortMindChildren(nodes)
+    var lines = []
+    printMindNode(root, 0, lines, htmlToString, true)
+    lines.push("")
+    var text = lines.join("\n")
+    return {text:text}
+}
+
+function connectMindNodesToParent(nodes) {
+    for (var id in nodes) {
+        var node = nodes[id]
+        if (node.parent) {
+            var parent = nodes[node.parent]
+            if (!parent.children) {
+                parent.children = []
+            }
+            parent.children.push(node)
+        }
+    }
+}
+
+function sortMindChildren(nodes) {
+    for (var id in nodes) {
+        var node = nodes[id]
+        if (node.children) {
+            sortByProperty(node.children, "ordinal")
+        }
+    }
+}
+
+function printMindNode(node, depth, lines, htmlToString, first) {
+    var printed = htmlToString(node.content)
+    const indent = makeIndent(depth)
+    printWithIndent(printed, indent, lines)
+    var childDepth = depth + 1
+    if (first) {
+        lines.push("")
+        childDepth = 0
+    }
+    if (node.children) {
+        for (var child of node.children) {
+            printMindNode(child, childDepth, lines, htmlToString, false)
+        }
+    }
+}
+
+function createMindNode(name) {
+    return {
+        "type": "idea",
+        "content": "<p>" + name + "</p>",
+        "parent": undefined,
+        "treeType": "treeview",
+        "ordinal": 0
+    }
+}
+
+module.exports = { drakonToPseudocode, mindToTree };
 },{"./drakonToStruct":3,"./printPseudo":5,"./tools":8}],3:[function(require,module,exports){
 const { structFlow, redirectNode } = require("./structFlow");
-const { createError } = require("./tools");
+const { createError, remove } = require("./tools");
 
 var translate
 
@@ -122,9 +191,7 @@ function drakonToStruct(drakonJson, name, filename, translateFunction) {
     branches.forEach(branch => checkBranchIsReferenced(branch, firstNodeId, filename))
     rewireShortcircuit(nodes, filename)
     branches.forEach(branch => cutOffBranch(nodes, branch))
-    
     var branchTrees = structFlow(nodes, branches, filename, translate)
-
     return {
         name: name,
         params: drakonGraph.params || "",
@@ -237,8 +304,11 @@ function addFakeEnd(nodes, prev, node, end, addresses) {
         nodes[address.id] = address
         end.prev.push(address.id)
         addresses.push(address)
+        node.prev.push(address.id)
     }
     redirectNode(nodes, prev, node.id, address.id)
+    address.prev.push(prev.id)
+    node.prev = remove(node.prev, prev.id)
 }
 
 function buildTwoWayConnections(nodes, firstNodeId) {
@@ -501,7 +571,7 @@ function markLoopBody(nodes, start, filename) {
 
 module.exports = { drakonToStruct, drakonToGraph };
 },{"./structFlow":6,"./tools":8}],4:[function(require,module,exports){
-const { drakonToPseudocode } = require('./drakonToPromptStruct');
+const { drakonToPseudocode, mindToTree } = require('./drakonToPromptStruct');
 const { htmlToString } = require("./browserTools")
 const { setUpLanguage, translate } = require("./translate")
 const { drakonToStruct } = require("./drakonToStruct");
@@ -513,6 +583,12 @@ window.drakongen = {
         return drakonToPseudocode(drakonJson, name, filename, htmlToString, translate).text
     },
 
+    toMindTree: function (mindJson, name, filename, language) {
+        setUpLanguage(language)    
+        var result = mindToTree(mindJson, name, filename, htmlToString)
+        return result.text
+    },    
+
     toTree: function (drakonJson, name, filename, language) {
         setUpLanguage(language)
         var result = drakonToStruct(drakonJson, name, filename, translate)
@@ -522,19 +598,20 @@ window.drakongen = {
 },{"./browserTools":1,"./drakonToPromptStruct":2,"./drakonToStruct":3,"./translate":9}],5:[function(require,module,exports){
 var {addRange} = require("./tools")
 
-function printPseudo(algorithm, translate, output, htmlToString) {
-
+function makeIndent(depth) {
+    return " ".repeat(depth * 4); 
+}
 
+function printWithIndent(lines, indent, output) {
+    lines.forEach(line => output.push(indent + line))
+}
 
+function printPseudo(algorithm, translate, output, htmlToString) {
     function printStructuredContent(content, indent, output) {
         var lines = printStructuredContentNoIdent(content)
         printWithIndent(lines, indent, output)
     }
 
-    function printWithIndent(lines, indent, output) {
-        lines.forEach(line => output.push(indent + line))
-    }
-
     function printStructuredContentNoIdent(content) {
         var lines = []
 
@@ -581,14 +658,10 @@ function printPseudo(algorithm, translate, output, htmlToString) {
         return lines
     }
 
-    function makeIndent(depth) {
-        return " ".repeat(depth * 4); 
-    }
-
     function printSteps(steps, depth, output) {
         const indent = makeIndent(depth)
         for (var step of steps) {
-            if (step.type === "end" || step.type === "branch" || step.type === "comment") { continue }
+            if (step.type === "end" || step.type === "branch") { continue }
             if (step.type === "question") {
                 printQuestion(step, depth, output)
             } else if (step.type === "loop") {
@@ -612,8 +685,7 @@ function printPseudo(algorithm, translate, output, htmlToString) {
         }
         if (step.content) {
             printStructuredContent(step.content, indent, output)
-        }        
-        output.push("")
+        }
     }
 
     function printAddress(step, indent, output) {
@@ -628,11 +700,12 @@ function printPseudo(algorithm, translate, output, htmlToString) {
 
     function printError(step, indent, output) {
         output.push(indent + translate("error") + ":")
-        output.push(indent + step.message)
+        var ind2 = indent + makeIndent(1)
+        output.push(ind2 + step.message)
         if (step.content) {
-            printStructuredContent(step.content, indent, output)
+            var ind3 = indent + makeIndent(2)
+            printStructuredContent(step.content, ind3, output)
         }        
-        output.push("")
     }    
 
     function empty(array) {
@@ -679,7 +752,7 @@ function printPseudo(algorithm, translate, output, htmlToString) {
     printSteps(algorithm.body, 0, output)
 }
 
-module.exports = {printPseudo}
+module.exports = {printPseudo, printWithIndent, makeIndent}
 },{"./tools":8}],6:[function(require,module,exports){
 var {buildTree} = require("./technicalTree")
 const { createError, sortByProperty } = require("./tools");
@@ -1160,6 +1233,10 @@ function createError(message, filename, nodeId) {
     return error
 }
 
+function remove(array, element) {
+    return array.filter(item => item != element)
+}
+
 function sortByProperty(array, property, order = "asc") {
     if (!Array.isArray(array)) {
         throw new Error("First argument must be an array");
@@ -1187,7 +1264,7 @@ function addRange(to, from) {
         to.push(item)
     }
 }
-module.exports = { createError, sortByProperty, addRange }
+module.exports = { createError, sortByProperty, addRange, remove }
 },{}],9:[function(require,module,exports){
 var translationsRu = {
     "error": "ОШИБКА",
@@ -1303,8 +1380,8 @@ function optimizeTree(steps) {
     var result = []
 
     for (var step of steps) {
-        if (step.type === "end" || step.type === "branch" || step.type === "comment" || step.type === "loopend") { continue }
-        if (step.type === "action" && !step.content) { continue }
+        if (step.type === "end" || step.type === "branch" || step.type === "loopend") { continue }
+        if ((step.type === "action" || step.type === "comment") && !step.content) { continue }
         var copy
         if (step.type === "question") {
             copy = optimizeQuestion(step)

package/browsertest.html

@@ -20,7 +20,6 @@
             width: 100%;
         }
     </style>
-    
     <title>Drakongen browser test</title>
 </head>
 <body>
@@ -29,13 +28,14 @@
         <textarea id="input" rows="30" autocorrect="false" placeholder="Enter drakon Json here" spellcheck="false"></textarea>
         <div><select id="format">
             <option value="pseudo">Pseudocode</option>
+            <option value="graf">Graf mind-map</option>
             <option value="tree">Tree</option>
         </select></div>
         <div><select id="language">
             <option value="en">English</option>
             <option value="no">Norsk</option>
             <option value="ru">Русский</option>
-        </select></div> 
+        </select></div>
         <button onclick="convert()">Convert to pseudocode</button>
         <div></div>
         <pre id="output"></pre>
@@ -67,6 +67,8 @@
                 var content
                 if (format.value === "pseudo") {
                     content = drakongen.toPseudocode(input.value, "Drakongen browser test", "Drakongen browser test.drakon", language.value)
+                } else if (format.value === "graf") {
+                    content = drakongen.toMindTree(input.value, "Drakongen browser test", "Drakongen browser test.graf")                    
                 } else {
                     content = drakongen.toTree(input.value, "Drakongen browser test", "Drakongen browser test.drakon", language.value)
                 }

package/buildexamples.js

@@ -38,7 +38,7 @@ async function processDrakonFiles() {
         const files = await fs.readdir(examplesFolder);
 
         // Filter for .drakon files
-        const drakonFiles = files.filter(file => file.endsWith('.drakon'));
+        const drakonFiles = files.filter(file => file.endsWith('.drakon') || file.endsWith('.graf'));
 
         // Process each .drakon file
         for (const file of drakonFiles) {

package/buildprojectexample

@@ -0,0 +1 @@
+node src/main.js --project exampleproject/foo.proj --output exampleproject

package/exampleproject/class Point.graf

@@ -0,0 +1,24 @@
+{
+    "items": {
+        "1": {
+            "type": "idea",
+            "content": "<p>x: number</p>",
+            "parent": "root",
+            "treeType": "treeview",
+            "ordinal": 0
+        },
+        "2": {
+            "type": "idea",
+            "content": "<p>y: number</p>",
+            "parent": "root",
+            "treeType": "treeview",
+            "ordinal": 1
+        },
+        "root": {
+            "treeType": "treeview",
+            "type": "header"
+        }
+    },
+    "type": "graf",
+    "id": "class Point.graf"
+}

package/exampleproject/foo.drakon

@@ -0,0 +1,51 @@
+{
+    "items": {
+        "1": {
+            "type": "end"
+        },
+        "2": {
+            "type": "branch",
+            "branchId": 0,
+            "one": "8"
+        },
+        "3": {
+            "type": "action",
+            "content": "<p>return sqrt(x * x + y * y)</p>",
+            "one": "1"
+        },
+        "4": {
+            "type": "question",
+            "content": "<p>x &gt; 0</p>",
+            "one": "5",
+            "two": "6",
+            "flag1": 1
+        },
+        "5": {
+            "type": "question",
+            "content": "<p>y &gt; 0</p>",
+            "one": "7",
+            "two": "6",
+            "flag1": 1
+        },
+        "6": {
+            "type": "action",
+            "content": "<p>return 0</p>",
+            "one": "1"
+        },
+        "7": {
+            "type": "question",
+            "content": "<p>x is approx. equal y</p>",
+            "one": "3",
+            "two": "6",
+            "flag1": 0
+        },
+        "8": {
+            "type": "action",
+            "content": "<p>x = point.x</p><p>y = point.y</p>",
+            "one": "4"
+        }
+    },
+    "type": "drakon",
+    "id": "foo.drakon",
+    "params": "<p>arguments:</p><ul><li>point: Point</li></ul><p><br /></p><p>returns: number</p>"
+}

package/exampleproject/foo.proj

@@ -0,0 +1,4 @@
+start.txt
+math
+class Point.graf
+foo.drakon

package/exampleproject/foo.txt

@@ -0,0 +1,45 @@
+Generate a JavaScript function "foo".
+Do not use "new", "class", and "this" keywords.
+Use "undefined" instead of "null".
+
+
+## Procedure "approximately equal"
+arguments:
+- left: number
+- right: number
+returns: boolean
+
+Algorithm:
+threshold = 0.00001
+delta = left - right
+If Math.abs(delta) > threshold
+    return true
+Else
+    return false
+
+End of procedure
+
+
+## class Point
+
+x: number
+y: number
+
+
+
+## Procedure "foo"
+arguments:
+- point: Point
+
+returns: number
+
+Algorithm:
+x = point.x
+y = point.y
+If (x > 0 and y > 0) and not (x is approx. equal y)
+    return sqrt(x * x + y * y)
+Else
+    return 0
+
+End of procedure
+

package/exampleproject/math/approximately equal.drakon

@@ -0,0 +1,42 @@
+{
+    "items": {
+        "1": {
+            "type": "end"
+        },
+        "2": {
+            "type": "branch",
+            "branchId": 0,
+            "one": "5"
+        },
+        "3": {
+            "type": "action",
+            "content": "<p>delta = left - right</p>",
+            "one": "4"
+        },
+        "4": {
+            "type": "question",
+            "content": "<p>Math.abs(delta) &gt; threshold</p>",
+            "one": "6",
+            "two": "7",
+            "flag1": 1
+        },
+        "5": {
+            "type": "action",
+            "content": "<p>threshold = 0.00001</p>",
+            "one": "3"
+        },
+        "6": {
+            "type": "action",
+            "content": "<p>return true</p>",
+            "one": "1"
+        },
+        "7": {
+            "type": "action",
+            "content": "<p>return false</p>",
+            "one": "1"
+        }
+    },
+    "params": "<p>arguments:</p><ul><li>left: number</li><li>right: number</li></ul><p>returns: boolean</p>",
+    "type": "drakon",
+    "id": "approximately equal.drakon"
+}

package/exampleproject/start.txt

@@ -0,0 +1,3 @@
+Generate a JavaScript function "foo".
+Do not use "new", "class", and "this" keywords.
+Use "undefined" instead of "null".

package/examples/00.Empty.txt

@@ -1,5 +1,6 @@
-Procedure "00.Empty"
+## Procedure "00.Empty"
 
 Algorithm:
 Empty
+
 End of procedure

package/examples/01. /320/221/320/265/320/273/321/213/320/271.txt"

@@ -1,4 +1,5 @@
-Procedure "01. Белый"
+## Procedure "01. Белый"
 
 Algorithm:
+
 End of procedure