mdstitch 1.0.0

package/bin/cli.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+const { program } = require('commander');
+
+const { pretty } = require('../src/commands/pretty');
+const { compress } = require('../src/commands/compress');
+const { run } = require('../src/commands/run');
+
+const pkg = require('../package.json');
+
+//setup
+program
+  .name('agmod')
+  .description('A CLI tool for agmod')
+  .version(pkg.version); // enables: betterag --version
+
+//Commands
+program
+  .command('pretty')
+  .description('Format and prettify a agent.md file')
+  .argument('<file>', 'The file to prettify')
+  .action((file) => {
+    pretty(file);
+  });
+
+// betterag compress <file>
+program
+  .command('compress')
+  .description('Compress a file')
+  .argument('<file>', 'The file to compress')
+  .action((file) => {
+    compress(file);
+  });
+
+// betterag run <file>
+program
+  .command('run')
+  .description('Process @excel() references in a markdown file')
+  .argument('<file>', 'The markdown file to process')
+  .action((file) => {
+    run(file);
+  });
+
+// ─── Parse ──────────────────────────────────────────────────────────────────
+
+// Reads what the user typed in the terminal and runs the matching command
+// This must always be the last line
+program.parse();

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "mdstitch",
+  "version": "1.0.0",
+  "description": "A CLI tool for agmod",
+  "bin": {
+    "agmd": "bin/cli.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": ["cli", "agent", "markdown", "compress", "excel"],
+  "author": "tannergill",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "commander": "^14.0.3",
+    "xlsx": "^0.18.5"
+  }
+}

package/src/commands/compress.js

@@ -0,0 +1,22 @@
+const fs = require("fs");
+const path = require("path");
+const { compressFile } = require("./compress_helpers");
+
+function compress(file) {
+  const inputPath = path.resolve(file);
+  const outputPath = inputPath.replace(/\.md$/, ".compressed.md");
+
+  const content = fs.readFileSync(inputPath, "utf8");
+  const compressed = compressFile(content);
+
+  fs.writeFileSync(outputPath, compressed, "utf8");
+
+  const originalSize = Buffer.byteLength(content, "utf8");
+  const compressedSize = Buffer.byteLength(compressed, "utf8");
+  const reduction = (((originalSize - compressedSize) / originalSize) * 100).toFixed(1);
+
+  console.log(`Compressed: ${inputPath} → ${outputPath}`);
+  console.log(`Size: ${originalSize} bytes → ${compressedSize} bytes (${reduction}% reduction)`);
+}
+
+module.exports = { compress };

package/src/commands/compress_helpers.js

@@ -0,0 +1,127 @@
+function parseFile(file) {
+    let splitFile = file.split(/\r?\n/)
+    let mapedFile = splitFile.map((line, index) => ({
+        index,
+        raw: line,
+        text: line.trim(),
+    }));
+    return mapedFile
+}
+
+function normalizeStructure(lines) {
+    const relevantLines = lines.filter(line => line.text.length > 0);
+    const result = [];
+
+    for (const line of relevantLines) {
+        if (/^#{1,6}\s+/.test(line.text)) {
+            const level = line.text.match(/^#+/)[0].length;
+            result.push({ type: "heading", level, value: line.text.replace(/^#{1,6}\s+/, "") });
+            continue;
+        }
+        if (/^[-*]\s+/.test(line.text)) {
+            result.push({ type: "bullet", value: line.text.replace(/^[-*]\s+/, "") });
+            continue;
+        }
+
+        result.push({ type: "paragraph", value: line.text });
+    }
+
+    return result;
+}
+
+const fluffy = [
+    "so that",
+    "in order to",
+    "to ensure",
+    "to make sure",
+    "to allow",
+    "to avoid",
+    "to prevent",
+    "to help",
+    "to enable",
+    "make sure to",
+    "be sure to",
+    "don't forget to",
+    "always remember to",
+    "remember to",
+    "try to",
+    "feel free to",
+    "just",
+    "simply",
+    "easily",
+    "quickly",
+    "even if nobody asked",
+    "before you merge",
+    "and then",
+    "after that",
+    "from there",
+    "at that point",
+    "the",
+    "a",
+    "an",
+];
+
+function stripContent(text) {
+    let s = text
+        .replace(/\*\*([^*]+)\*\*/g, "$1")
+        .replace(/`([^`]+)`/g, "$1")
+        .replace(/\s*\([^)]{10,}\)/g, "");
+
+    for (const word of fluffy) {
+        const pattern = new RegExp(`\\b${word}\\b\\s*`, "gi");
+        s = s.replace(pattern, "");
+    }
+
+    return s.replace(/\s{2,}/g, " ").trim().replace(/[.,;]+$/, "");
+}
+
+function buildCompressed(nodes) {
+    let title = "";
+    const sections = [];
+    let currentSection = null;
+
+    let headingPath = [];
+
+    for (const node of nodes) {
+        if (node.type === "heading" && node.level === 1) {
+            title = `[${node.value}]`;
+            continue;
+        }
+
+        if (node.type === "heading") {
+            headingPath = headingPath.slice(0, node.level - 2);
+            headingPath.push(node.value.replace(/:$/, ""));
+
+            currentSection = { name: headingPath.join(">"), items: [] };
+            sections.push(currentSection);
+            continue;
+        }
+
+        if ((node.type === "bullet" || node.type === "numbered") && currentSection) {
+            currentSection.items.push(stripContent(node.value));
+            continue;
+        }
+
+        if (node.type === "paragraph" && currentSection) {
+            currentSection.items.push(stripContent(node.value));
+            continue;
+        }
+    }
+
+    const lines = sections
+        .filter(section => section.items.length > 0)
+        .map(section => {
+            const items = section.items.join(";");
+            return `|${section.name}:{${items}}`;
+        });
+
+    return [title, ...lines].join("\n");
+}
+
+function compressFile(fileContent) {
+    const lines = parseFile(fileContent);
+    const nodes = normalizeStructure(lines);
+    return buildCompressed(nodes);
+}
+
+module.exports = { compressFile };

package/src/commands/pretty.js

@@ -0,0 +1,18 @@
+const fs = require("fs");
+const path = require("path");
+const { parseCompressed, buildPretty } = require("./pretty_helpers");
+
+function pretty(file) {
+    const inputPath = path.resolve(file);
+    const outputPath = inputPath.replace(/\.compressed\.md$/, ".pretty.md")
+                                .replace(/(?<!\.pretty)\.md$/, ".pretty.md");
+
+    const content = fs.readFileSync(inputPath, "utf8");
+    const parsed = parseCompressed(content);
+    const result = buildPretty(parsed);
+
+    fs.writeFileSync(outputPath, result, "utf8");
+    console.log(`Prettified: ${inputPath} → ${outputPath}`);
+}
+
+module.exports = { pretty };

package/src/commands/pretty_helpers.js

@@ -0,0 +1,66 @@
+function parseCompressed(content) {
+    const result = { title: "", sections: [] };
+    const entries = content.split(/\n(?=\||\[)/);
+
+    for (const entry of entries) {
+        const trimmed = entry.trim();
+        if (!trimmed) continue;
+
+        if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+            result.title = trimmed.slice(1, -1);
+            continue;
+        }
+
+        if (!trimmed.startsWith("|")) continue;
+
+        const body = trimmed.slice(1);
+
+        const match = body.match(/^(.+?):\{(.+)\}$/s);
+        if (match) {
+            result.sections.push({
+                name: match[1].trim(),
+                items: match[2].split(";").map(i => i.trim()).filter(Boolean),
+            });
+            continue;
+        }
+
+        result.sections.push({ name: body.trim(), items: [] });
+    }
+
+    return result;
+}
+
+function buildPretty(parsed) {
+    const blocks = [];
+    let lastPath = [];
+
+    if (parsed.title) {
+        blocks.push(`# ${parsed.title}`);
+    }
+
+    for (const section of parsed.sections) {
+        const parts = section.name.split(">");
+
+        for (let i = 0; i < parts.length - 1; i++) {
+            if (parts[i] !== lastPath[i]) {
+                // Only h2 gets a blank line before it
+                const prefix = i === 0 ? "\n" : "";
+                blocks.push(`${prefix}${"#".repeat(i + 2)} ${parts[i]}`);
+            }
+        }
+
+        const depth = parts.length;
+        const prefix = depth === 1 ? "\n" : "";
+        blocks.push(`${prefix}${"#".repeat(depth + 1)} ${parts[parts.length - 1]}`);
+
+        lastPath = parts;
+
+        if (section.items.length > 0) {
+            blocks.push(section.items.map(item => `- ${item}`).join("\n"));
+        }
+    }
+
+    return blocks.join("\n");
+}
+
+module.exports = { parseCompressed, buildPretty };

package/src/commands/run.js

@@ -0,0 +1,38 @@
+const fs = require("fs");
+const path = require("path");
+const { resolveExcelPath, describeSheet } = require("./run_helpers");
+
+function run(file) {
+    const inputPath = path.resolve(file);
+    const outputPath = inputPath.replace(/\.md$/, ".processed.md");
+    const dir = path.dirname(inputPath);
+
+    let content = fs.readFileSync(inputPath, "utf8");
+
+    const pattern = /@excel\(([^)]+)\)/g;
+    let found = 0;
+
+    content = content.replace(pattern, (original, args) => {
+        const [fileRef, sheetName, range] = args.split(",").map(s => s.trim());
+
+        if (!fileRef || !sheetName || !range) {
+            console.warn(`  Warning: @excel() requires all 3 arguments — @excel(filename, sheet, range)`);
+            return original;
+        }
+
+        const excelPath = resolveExcelPath(dir, fileRef);
+        if (!excelPath) {
+            console.warn(`  Warning: Excel file not found — ${fileRef}`);
+            return `[Excel file not found: ${fileRef}]`;
+        }
+
+        found++;
+        console.log(`  Processing: ${fileRef} | sheet: ${sheetName} | range: ${range}`);
+        return describeSheet(excelPath, sheetName, range);
+    });
+
+    fs.writeFileSync(outputPath, content, "utf8");
+    console.log(`\nProcessed ${found} @excel() reference(s): ${inputPath} → ${outputPath}`);
+}
+
+module.exports = { run };

package/src/commands/run_helpers.js

@@ -0,0 +1,128 @@
+const fs = require("fs");
+const path = require("path");
+const XLSX = require("xlsx");
+
+function resolveExcelPath(dir, name) {
+    const candidates = [
+        path.resolve(dir, name),
+        path.resolve(dir, `${name}.xlsx`),
+        path.resolve(dir, `${name}.xls`),
+    ];
+    return candidates.find(fs.existsSync) || null;
+}
+
+function colToIndex(col) {
+    let index = 0;
+    for (let i = 0; i < col.length; i++) {
+        index = index * 26 + col.charCodeAt(i) - 64;
+    }
+    return index - 1;
+}
+
+function humanizeFormula(formula, headers, rangeColStart) {
+    return formula
+        .replace(/([A-Za-z0-9_]+)!([A-Z]+)(\d+)/g, (_, sheet, col) => {
+            const idx = colToIndex(col) - rangeColStart;
+            const header = headers[idx];
+            return header ? `[${sheet}:${header}]` : `[${sheet}:${col}]`;
+        })
+        .replace(/([A-Z]+)(\d+)/g, (match, col) => {
+            const idx = colToIndex(col) - rangeColStart;
+            const header = headers[idx];
+            return header ? `[${header}]` : match;
+        })
+        .replace(/\*/g, " × ")
+        .replace(/\//g, " ÷ ")
+        .replace(/\+/g, " + ")
+        .replace(/-/g, " - ");
+}
+
+function describeSheet(filePath, sheetName, range) {
+    const workbook = XLSX.readFile(filePath, { cellFormula: true });
+
+    const sheet = workbook.Sheets[sheetName];
+    if (!sheet) {
+        const available = workbook.SheetNames.join(", ");
+        return `[Sheet "${sheetName}" not found in ${path.basename(filePath)}. Available: ${available}]`;
+    }
+
+    const opts = { header: 1, defval: "" };
+    if (range) opts.range = range;
+
+    const rows = XLSX.utils.sheet_to_json(sheet, opts);
+    if (rows.length === 0) return `[No data found in ${sheetName}${range ? ` (${range})` : ""}]`;
+
+    const headers = rows[0];
+    const dataRows = rows.slice(1).filter(r => r.some(cell => cell !== ""));
+    const rowCount = dataRows.length;
+
+    const decodedRange = range ? XLSX.utils.decode_range(range) : XLSX.utils.decode_range(sheet["!ref"]);
+    const rangeColStart = decodedRange.s.c;
+    const rangeRowStart = decodedRange.s.r;
+
+    const formulaMap = {};
+    for (let R = decodedRange.s.r; R <= decodedRange.e.r; R++) {
+        for (let C = decodedRange.s.c; C <= decodedRange.e.c; C++) {
+            const cell = sheet[XLSX.utils.encode_cell({ r: R, c: C })];
+            if (cell && cell.f) {
+                const relRow = R - rangeRowStart;
+                const relCol = C - rangeColStart;
+                if (!formulaMap[relRow]) formulaMap[relRow] = {};
+                formulaMap[relRow][relCol] = cell.f;
+            }
+        }
+    }
+
+    const colFormulas = {};
+    Object.entries(formulaMap).forEach(([relRow, cols]) => {
+        if (Number(relRow) === 0) return;
+        Object.entries(cols).forEach(([relCol, formula]) => {
+            const humanised = humanizeFormula(formula, headers, rangeColStart);
+            const generalised = humanised.replace(/\b([A-Z]+)(\d+)\b/g, "$1n");
+            if (!colFormulas[relCol]) colFormulas[relCol] = new Set();
+            colFormulas[relCol].add(generalised);
+        });
+    });
+
+    const calcLogic = [];
+    Object.entries(colFormulas).forEach(([relCol, formulas]) => {
+        const header = headers[Number(relCol)] || `Col ${Number(relCol) + 1}`;
+        formulas.forEach(f => {
+            calcLogic.push(`  ${header} = ${f}`);
+        });
+    });
+
+    const columns = headers.map((header, colIndex) => {
+        const values = dataRows.map(row => row[colIndex]).filter(v => v !== "" && v != null);
+        const numeric = values.filter(v => typeof v === "number");
+        const isNumeric = numeric.length > 0 && numeric.length > values.length * 0.8;
+        if (isNumeric) {
+            const min = Math.min(...numeric);
+            const max = Math.max(...numeric);
+            return `${header} (number, ${min}–${max})`;
+        }
+        const unique = [...new Set(values.map(String))].slice(0, 3);
+        return `${header} (text, e.g. ${unique.join(", ")})`;
+    });
+
+    const allRows = dataRows.map(row =>
+        headers.map((_, i) => row[i] ?? "").join(" | ")
+    );
+
+    const lines = [
+        `[Excel: ${path.basename(filePath)} | Sheet: ${sheetName}${range ? ` | Range: ${range}` : ""} | ${rowCount} rows × ${headers.length} columns]`,
+        `Columns: ${columns.join("; ")}`,
+    ];
+
+    if (calcLogic.length > 0) {
+        lines.push(`Calculation logic:`);
+        lines.push(...calcLogic);
+    }
+
+    lines.push(`Rows:`);
+    lines.push(...allRows.map(r => `  ${r}`));
+
+    return lines.join("\n");
+}
+
+module.exports = { resolveExcelPath, describeSheet };