@nexrall/code-core 1.4.46 → 1.4.48

package/dist/tools/executor.js

@@ -442,6 +442,187 @@ async function writeFile(input, workDir) {
         return { error: err.message };
     }
 }
+// ─── Office document tools (write_docx / write_xlsx / write_pptx) ─────────────
+//
+// Mirrors how Claude Cowork actually does this (per Anthropic's own docs):
+// generate the real OOXML binary via code, not a chat "artifact" preview.
+// Word/Excel/PowerPoint files ARE zip archives of XML under the hood — these
+// tools just drive the `docx`/`exceljs`/`pptxgenjs` libraries that build that
+// XML correctly, so a real .docx/.xlsx/.pptx lands on disk that Word/Excel/
+// PowerPoint (or LibreOffice) opens normally. The model is given a simplified
+// JSON content shape (paragraphs / sheets+rows / slides) rather than being
+// asked to write library calls itself — smaller, more reliable tool calls,
+// and it keeps these tools usable by models with no library-specific training.
+//
+// atomicWrite() (temp+rename) is NOT reused here — these libraries write
+// binary buffers via their own `.save()`/`.writeFile()` APIs rather than a
+// string this module already has in memory, so each tool does its own
+// write-to-temp-then-rename to get the same crash-safety property.
+function atomicWriteBuffer(resolved, data) {
+    const dir = path.dirname(resolved);
+    fs.mkdirSync(dir, { recursive: true });
+    const tmp = path.join(dir, `.${path.basename(resolved)}.nexrall-tmp-${process.pid}-${Date.now()}`);
+    fs.writeFileSync(tmp, data);
+    fs.renameSync(tmp, resolved);
+}
+async function writeDocx(input, workDir) {
+    const filePath = typeof input.path === 'string' ? input.path : '';
+    if (!filePath)
+        return { error: 'Missing required parameter: path' };
+    const title = typeof input.title === 'string' ? input.title : undefined;
+    const paragraphsRaw = input.paragraphs;
+    if (!Array.isArray(paragraphsRaw) || paragraphsRaw.length === 0) {
+        return { error: 'Missing or empty required parameter: paragraphs (array of { text, heading?, bold?, italic?, bullet?, align? })' };
+    }
+    try {
+        // Loaded lazily so the (fairly large) docx/exceljs/pptxgenjs bundles only
+        // ever get pulled into memory for a session that actually uses them —
+        // most agent sessions never touch Office files at all.
+        const { Document, Packer, Paragraph, TextRun, HeadingLevel, AlignmentType, } = await Promise.resolve().then(() => __importStar(require('docx')));
+        const headingMap = {
+            1: HeadingLevel.HEADING_1, 2: HeadingLevel.HEADING_2,
+            3: HeadingLevel.HEADING_3, 4: HeadingLevel.HEADING_4,
+        };
+        const alignMap = {
+            left: AlignmentType.LEFT, center: AlignmentType.CENTER,
+            right: AlignmentType.RIGHT, justify: AlignmentType.JUSTIFIED,
+        };
+        const children = [];
+        if (title) {
+            children.push(new Paragraph({ text: title, heading: HeadingLevel.TITLE }));
+        }
+        for (const raw of paragraphsRaw) {
+            if (!raw || typeof raw.text !== 'string')
+                continue;
+            children.push(new Paragraph({
+                heading: raw.heading ? headingMap[raw.heading] : undefined,
+                bullet: raw.bullet ? { level: 0 } : undefined,
+                alignment: raw.align ? alignMap[raw.align] : undefined,
+                children: [new TextRun({ text: raw.text, bold: raw.bold, italics: raw.italic })],
+            }));
+        }
+        const doc = new Document({ sections: [{ children }] });
+        const buffer = await Packer.toBuffer(doc);
+        const resolved = resolvePath(filePath, workDir);
+        const isNew = !fs.existsSync(resolved);
+        atomicWriteBuffer(resolved, buffer);
+        return { output: `${isNew ? 'Created' : 'Overwrote'} ${resolved} (${paragraphsRaw.length} paragraph(s), ${buffer.length} bytes)` };
+    }
+    catch (err) {
+        return { error: `Failed to write .docx: ${err.message}` };
+    }
+}
+async function writeXlsx(input, workDir) {
+    const filePath = typeof input.path === 'string' ? input.path : '';
+    if (!filePath)
+        return { error: 'Missing required parameter: path' };
+    const sheetsRaw = input.sheets;
+    if (!Array.isArray(sheetsRaw) || sheetsRaw.length === 0) {
+        return { error: 'Missing or empty required parameter: sheets (array of { name?, columns?, rows })' };
+    }
+    // mode: 'edit' loads the EXISTING workbook first (so other sheets, styles,
+    // and formulas already in the file survive) instead of always starting
+    // from a blank workbook — this is what makes "sửa file Excel có sẵn" work
+    // rather than only ever creating brand-new files.
+    const mode = input.mode === 'edit' ? 'edit' : 'create';
+    try {
+        const ExcelJS = await Promise.resolve().then(() => __importStar(require('exceljs')));
+        const resolved = resolvePath(filePath, workDir);
+        const isNew = !fs.existsSync(resolved);
+        const workbook = new ExcelJS.Workbook();
+        if (mode === 'edit' && !isNew) {
+            try {
+                await workbook.xlsx.readFile(resolved);
+            }
+            catch (err) {
+                return { error: `mode: 'edit' but could not read existing workbook at ${resolved}: ${err.message}` };
+            }
+        }
+        else if (mode === 'edit' && isNew) {
+            return { error: `mode: 'edit' but ${resolved} does not exist yet — use mode: 'create' (or omit mode) for a new file.` };
+        }
+        let sheetsTouched = 0;
+        for (const raw of sheetsRaw) {
+            const name = raw?.name || `Sheet${sheetsTouched + 1}`;
+            let sheet = workbook.getWorksheet(name);
+            if (sheet && mode === 'edit') {
+                // Editing an existing sheet in place: remove and recreate it so
+                // re-running the same tool call REPLACES its data instead of
+                // appending duplicate rows below whatever was already there —
+                // matches write_file's "full replace" semantics for a sheet's data,
+                // while sibling sheets and workbook-level state readFile() already
+                // loaded are untouched. (sheet.spliceRows(1, rowCount) looks like the
+                // obvious way to clear a sheet in place, but empirically does NOT
+                // remove existing rows in exceljs 4.4.0 — verified with a minimal
+                // repro before choosing this remove+recreate approach instead.)
+                //
+                // Trade-off: the recreated sheet is appended at the end of the
+                // workbook's tab order rather than kept in its original position —
+                // acceptable since sheet DATA correctness matters far more than tab
+                // order for an agent-generated edit, and exceljs has no public API
+                // to reinsert a worksheet at an arbitrary index.
+                workbook.removeWorksheet(sheet.id);
+                sheet = workbook.addWorksheet(name);
+            }
+            else if (!sheet) {
+                sheet = workbook.addWorksheet(name);
+            }
+            if (Array.isArray(raw?.columns) && raw.columns.length) {
+                sheet.columns = raw.columns.map((c) => ({ header: c.header, key: c.key, width: c.width }));
+            }
+            if (Array.isArray(raw?.rows)) {
+                for (const row of raw.rows)
+                    sheet.addRow(row);
+            }
+            sheetsTouched++;
+        }
+        const buffer = await workbook.xlsx.writeBuffer();
+        atomicWriteBuffer(resolved, Buffer.from(buffer));
+        return {
+            output: `${isNew ? 'Created' : mode === 'edit' ? 'Updated' : 'Overwrote'} ${resolved} (${sheetsTouched} sheet(s), ${buffer.byteLength} bytes)`,
+        };
+    }
+    catch (err) {
+        return { error: `Failed to write .xlsx: ${err.message}` };
+    }
+}
+async function writePptx(input, workDir) {
+    const filePath = typeof input.path === 'string' ? input.path : '';
+    if (!filePath)
+        return { error: 'Missing required parameter: path' };
+    const slidesRaw = input.slides;
+    if (!Array.isArray(slidesRaw) || slidesRaw.length === 0) {
+        return { error: 'Missing or empty required parameter: slides (array of { title?, bullets?, notes? })' };
+    }
+    try {
+        const PptxGenJSModule = await Promise.resolve().then(() => __importStar(require('pptxgenjs')));
+        const PptxGenJS = PptxGenJSModule.default;
+        const pres = new PptxGenJS();
+        for (const raw of slidesRaw) {
+            const slide = pres.addSlide();
+            if (raw?.title) {
+                slide.addText(raw.title, { x: 0.5, y: 0.3, w: '90%', h: 1, fontSize: 28, bold: true });
+            }
+            if (Array.isArray(raw?.bullets) && raw.bullets.length) {
+                slide.addText(raw.bullets.map((b) => ({ text: b, options: { bullet: true, breakLine: true } })), { x: 0.5, y: 1.5, w: '90%', h: '70%', fontSize: 18 });
+            }
+            if (raw?.notes)
+                slide.addNotes(raw.notes);
+        }
+        const resolved = resolvePath(filePath, workDir);
+        const isNew = !fs.existsSync(resolved);
+        fs.mkdirSync(path.dirname(resolved), { recursive: true });
+        // pptxgenjs writes to disk itself (no in-memory buffer API for Node the
+        // way docx/exceljs offer) — 'nodebuffer' gets us the buffer instead so we
+        // can still go through the same atomic temp+rename write as the other two.
+        const buffer = (await pres.write({ outputType: 'nodebuffer' }));
+        atomicWriteBuffer(resolved, buffer);
+        return { output: `${isNew ? 'Created' : 'Overwrote'} ${resolved} (${slidesRaw.length} slide(s), ${buffer.length} bytes)` };
+    }
+    catch (err) {
+        return { error: `Failed to write .pptx: ${err.message}` };
+    }
+}
 async function listDirectory(input, workDir) {
     const dirPath = typeof input.path === 'string' ? input.path : '.';
     try {
@@ -2360,20 +2541,26 @@ async function memoryWrite(input, workDir) {
     if (!content)
         return { error: 'content is required' };
     const scope = memoryScopeOf(input);
-    const r = await (0, memory_1.writeMemory)(content, scope, workDir);
+    const supersedes = typeof input.supersedes === 'string' ? input.supersedes.trim() : undefined;
+    const source = typeof input.source === 'string' ? input.source.trim() : undefined;
+    const r = await (0, memory_1.writeMemory)(content, scope, workDir, { supersedes, source });
     if (!r.ok)
         return { error: 'failed to save memory' };
-    return { output: r.already ? `Memory already recorded (skipped duplicate): ${content}` : `Memory saved (${scope}): ${content}` };
+    if (r.already)
+        return { output: `Memory already recorded (skipped duplicate): ${content}` };
+    const supersedeNote = r.superseded ? ' (older fact moved to Superseded)' : '';
+    return { output: `Memory saved (${scope}): ${content}${supersedeNote}` };
 }
 async function memoryRead(input, workDir) {
     try {
+        const includeArchived = input?.include_archived === true;
         // No explicit scope requested → merge both (what the model actually needs
         // when re-orienting mid-conversation); an explicit scope narrows to just that file.
         if (input && (input.scope === 'project' || input.scope === 'global')) {
-            const mem = (0, memory_1.readMemory)(input.scope, workDir);
+            const mem = (0, memory_1.readMemory)(input.scope, workDir, { includeArchived });
             return { output: mem || 'No memories saved yet.' };
         }
-        const mem = (0, memory_1.readAllMemory)(workDir);
+        const mem = (0, memory_1.readAllMemory)(workDir, { includeArchived });
         return { output: mem || 'No memories saved yet.' };
     }
     catch (err) {
@@ -2445,6 +2632,9 @@ async function getHover(input, workDir) {
 const TOOL_MAP = {
     read_file: readFile,
     write_file: writeFile,
+    write_docx: writeDocx,
+    write_xlsx: writeXlsx,
+    write_pptx: writePptx,
     list_directory: listDirectory,
     bash: bash,
     search_files: searchFiles,
@@ -2484,7 +2674,8 @@ const TOOL_MAP = {
 // their own dedicated branch above (which passes abortSignal too) — kept out
 // of this set so there's exactly one dispatch path per tool, not two.
 const WORKDIR_TOOLS = new Set([
-    'read_file', 'write_file', 'list_directory', 'search_files', 'glob',
+    'read_file', 'write_file', 'write_docx', 'write_xlsx', 'write_pptx',
+    'list_directory', 'search_files', 'glob',
     'create_directory', 'edit_file', 'multi_edit', 'copy_file', 'move_file',
     'delete_file', 'notebook_read', 'notebook_edit',
     'get_symbols', 'get_workspace_symbols',

package/dist/util/frontmatter.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Shared YAML-ish frontmatter parser for the markdown-based config formats
+ * this project uses (slash commands, skills, agent definitions, plugin
+ * manifests). Extracted here so a fix only has to happen once and cannot
+ * silently drift between the formats that consume it.
+ *
+ *   ---
+ *   key: value
+ *   another-key: "quoted value"
+ *   description: >-
+ *     a long value that folds onto
+ *     the following indented lines
+ *   metadata:
+ *     author: example-org
+ *     version: "1.0"
+ *   ---
+ *   body text...
+ *
+ * Deliberately still not a full YAML parser (no lists, no multi-level
+ * nesting, no anchors) — but it now handles the three shapes real-world
+ * SKILL.md files (including the `agentskills.io` spec's own examples) use:
+ *
+ *  1. Plain multi-line values: a `key: value` line followed by indented
+ *     lines with no `sub: value` shape of their own are folded onto the
+ *     value with a single space, the same way a human reads wrapped prose.
+ *  2. Block scalars: `key: >`, `>-`, `|`, `|-` followed by indented lines.
+ *     `>` folds lines into a single space-joined string (YAML "folded"
+ *     style); `|` keeps them literal, newline-joined ("literal" style).
+ *     The `-` chomping indicator is accepted for compatibility but every
+ *     value returned here is trimmed regardless, since these are metadata
+ *     strings, not file content whose trailing newline matters.
+ *  3. One-level nested maps: `key:` with NOTHING after the colon, followed
+ *     by indented `sub: value` lines, becomes a nested map — returned
+ *     separately in `nested[key]`, NEVER merged into the flat `meta` object.
+ *
+ * That last rule is load-bearing, not cosmetic. The previous version of
+ * this parser treated every trimmed line as a flat top-level key regardless
+ * of indentation, so a block like
+ *
+ *   tools: read_file, search_files, glob
+ *   metadata:
+ *     tools: read_file, search_files, glob, bash, write_file, delete_file
+ *
+ * silently let the indented `tools:` inside `metadata:` OVERWRITE the real,
+ * innocent-looking top-level `tools:` a reviewer would actually read —
+ * because both lines matched the same regex and the second write won. That
+ * is a privilege-escalation bug in an agent-definition file, not a display
+ * quirk: `agentTypes.ts`'s tool allowlist reads `meta.tools` and would have
+ * granted `bash`/`write_file`/`delete_file` from a definition that visibly
+ * only requests three read-only tools. Every indented line now belongs to
+ * ITS OWN key's continuation/nested-map, never to the flat top-level
+ * namespace, which makes this class of collision structurally impossible
+ * rather than merely untested.
+ */
+export interface ParsedFrontmatter {
+    /** Flat top-level `key: value` pairs. Indented/nested content never leaks in here. */
+    meta: Record<string, string>;
+    /** Markdown body after the closing `---`. */
+    body: string;
+    /**
+     * One-level nested maps, keyed by their parent field name — e.g. a
+     * `metadata:` block with indented `author: ...` / `version: ...` lines
+     * becomes `nested.metadata = { author: '...', version: '...' }`.
+     * Absent (not an empty object) when no field had a nested map, so
+     * callers that don't care can ignore this without an extra check.
+     */
+    nested?: Record<string, Record<string, string>>;
+    /**
+     * True if a valid `---`-delimited frontmatter block was found at all. False
+     * means the whole file is `body` and `meta`/`nested` are empty — callers
+     * that treat "no parseable frontmatter" as a distinct, fail-closed case
+     * (e.g. agent definitions default to read-only rather than unrestricted
+     * when this is false) should check this instead of `Object.keys(meta).length`,
+     * which can't tell "no frontmatter" apart from "frontmatter with no fields".
+     */
+    ok: boolean;
+}
+export declare function parseFrontmatter(raw: string): ParsedFrontmatter;
+//# sourceMappingURL=frontmatter.d.ts.map

package/dist/util/frontmatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontmatter.d.ts","sourceRoot":"","sources":["../../src/util/frontmatter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAEH,MAAM,WAAW,iBAAiB;IAChC,sFAAsF;IACtF,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAChD;;;;;;;OAOG;IACH,EAAE,EAAE,OAAO,CAAC;CACb;AAcD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAqG/D"}

package/dist/util/frontmatter.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * Shared YAML-ish frontmatter parser for the markdown-based config formats
+ * this project uses (slash commands, skills, agent definitions, plugin
+ * manifests). Extracted here so a fix only has to happen once and cannot
+ * silently drift between the formats that consume it.
+ *
+ *   ---
+ *   key: value
+ *   another-key: "quoted value"
+ *   description: >-
+ *     a long value that folds onto
+ *     the following indented lines
+ *   metadata:
+ *     author: example-org
+ *     version: "1.0"
+ *   ---
+ *   body text...
+ *
+ * Deliberately still not a full YAML parser (no lists, no multi-level
+ * nesting, no anchors) — but it now handles the three shapes real-world
+ * SKILL.md files (including the `agentskills.io` spec's own examples) use:
+ *
+ *  1. Plain multi-line values: a `key: value` line followed by indented
+ *     lines with no `sub: value` shape of their own are folded onto the
+ *     value with a single space, the same way a human reads wrapped prose.
+ *  2. Block scalars: `key: >`, `>-`, `|`, `|-` followed by indented lines.
+ *     `>` folds lines into a single space-joined string (YAML "folded"
+ *     style); `|` keeps them literal, newline-joined ("literal" style).
+ *     The `-` chomping indicator is accepted for compatibility but every
+ *     value returned here is trimmed regardless, since these are metadata
+ *     strings, not file content whose trailing newline matters.
+ *  3. One-level nested maps: `key:` with NOTHING after the colon, followed
+ *     by indented `sub: value` lines, becomes a nested map — returned
+ *     separately in `nested[key]`, NEVER merged into the flat `meta` object.
+ *
+ * That last rule is load-bearing, not cosmetic. The previous version of
+ * this parser treated every trimmed line as a flat top-level key regardless
+ * of indentation, so a block like
+ *
+ *   tools: read_file, search_files, glob
+ *   metadata:
+ *     tools: read_file, search_files, glob, bash, write_file, delete_file
+ *
+ * silently let the indented `tools:` inside `metadata:` OVERWRITE the real,
+ * innocent-looking top-level `tools:` a reviewer would actually read —
+ * because both lines matched the same regex and the second write won. That
+ * is a privilege-escalation bug in an agent-definition file, not a display
+ * quirk: `agentTypes.ts`'s tool allowlist reads `meta.tools` and would have
+ * granted `bash`/`write_file`/`delete_file` from a definition that visibly
+ * only requests three read-only tools. Every indented line now belongs to
+ * ITS OWN key's continuation/nested-map, never to the flat top-level
+ * namespace, which makes this class of collision structurally impossible
+ * rather than merely untested.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFrontmatter = parseFrontmatter;
+const TOP_LEVEL_KEY = /^([A-Za-z0-9_-]+)\s*:\s*(.*)$/;
+const BLOCK_SCALAR = /^[|>][+-]?$/;
+function leadingIndent(line) {
+    const m = /^[ \t]*/.exec(line);
+    return m ? m[0].length : 0;
+}
+function unquote(v) {
+    return v.trim().replace(/^["']|["']$/g, '');
+}
+function parseFrontmatter(raw) {
+    const m = /^\s*---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(raw);
+    if (!m)
+        return { meta: {}, body: raw.trim(), ok: false };
+    const lines = m[1].split(/\r?\n/);
+    const meta = {};
+    let nested;
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        // Blank lines and stray indented lines with no top-level key before them
+        // (malformed input) are simply skipped — lenient parsing, same spirit as
+        // the rest of this file: warn elsewhere, don't throw here.
+        if (!line.trim() || leadingIndent(line) > 0) {
+            i++;
+            continue;
+        }
+        const kv = TOP_LEVEL_KEY.exec(line.trim());
+        if (!kv) {
+            i++;
+            continue;
+        }
+        const key = kv[1].toLowerCase();
+        const value = kv[2].trim();
+        // Collect every immediately-following indented line as this key's
+        // continuation block, whatever shape it turns out to be.
+        const continuation = [];
+        let j = i + 1;
+        while (j < lines.length && (leadingIndent(lines[j]) > 0 || !lines[j].trim())) {
+            continuation.push(lines[j]);
+            j++;
+        }
+        // Trim trailing blank continuation lines (keeps indent-detection below
+        // simple and doesn't affect folded/literal output).
+        while (continuation.length && !continuation[continuation.length - 1].trim())
+            continuation.pop();
+        if (BLOCK_SCALAR.test(value)) {
+            // `key: >`, `>-`, `|`, `|-` — content is EVERY continuation line.
+            // `>` = YAML "folded" style (join into one space-separated line);
+            // `|` = YAML "literal" style (keep the line breaks as-is).
+            const folded = value.startsWith('>');
+            const base = continuation.length ? leadingIndent(continuation.find((l) => l.trim()) ?? continuation[0]) : 0;
+            const dedented = continuation.map((l) => (l.trim() ? l.slice(Math.min(base, leadingIndent(l))) : ''));
+            meta[key] = folded
+                ? dedented.join(' ').replace(/\s+/g, ' ').trim() // folded (>) style
+                : dedented.join('\n').trim(); // literal (|) style
+        }
+        else if (value === '') {
+            // `key:` with nothing after it. Two possibilities:
+            //  - continuation lines look like `sub: value` → this is a nested map,
+            //    isolated in `nested[key]` and NEVER merged into flat `meta`.
+            //  - continuation lines are plain prose → fold them as the value.
+            const looksNested = continuation.length > 0 && continuation.every((l) => !l.trim() || TOP_LEVEL_KEY.test(l.trim()));
+            if (looksNested && continuation.some((l) => l.trim())) {
+                const map = {};
+                for (const l of continuation) {
+                    const sub = TOP_LEVEL_KEY.exec(l.trim());
+                    if (sub)
+                        map[sub[1].toLowerCase()] = unquote(sub[2]);
+                }
+                nested = nested ?? {};
+                nested[key] = map;
+                // Deliberately no `meta[key] = ...` here — an empty-header field with
+                // a nested map has no flat scalar value of its own.
+            }
+            else if (continuation.length) {
+                meta[key] = [value, ...continuation.map((l) => l.trim())].filter(Boolean).join(' ').trim();
+            }
+            else {
+                meta[key] = '';
+            }
+        }
+        else {
+            // Normal `key: value`. Fold any plain-prose continuation lines onto it
+            // (the common case: a long `description:` wrapped across lines) —
+            // but only if none of them look like their own `sub: value` pair,
+            // which would instead mean the author meant something structured and
+            // folding it into one string would corrupt it silently.
+            const looksNested = continuation.length > 0 && continuation.every((l) => !l.trim() || TOP_LEVEL_KEY.test(l.trim()));
+            if (continuation.length && !looksNested) {
+                meta[key] = unquote([value, ...continuation.map((l) => l.trim())].join(' '));
+            }
+            else if (continuation.length && looksNested) {
+                // `key: value` immediately followed by what looks like a nested map —
+                // ambiguous/malformed YAML. Keep the scalar value (least surprising:
+                // it's what a naive line-by-line reader sees first) and surface the
+                // rest as a nested map too, rather than silently dropping either.
+                meta[key] = unquote(value);
+                const map = {};
+                for (const l of continuation) {
+                    const sub = TOP_LEVEL_KEY.exec(l.trim());
+                    if (sub)
+                        map[sub[1].toLowerCase()] = unquote(sub[2]);
+                }
+                nested = nested ?? {};
+                nested[key] = map;
+            }
+            else {
+                meta[key] = unquote(value);
+            }
+        }
+        i = j;
+    }
+    return { meta, body: (m[2] ?? '').trim(), nested, ok: true };
+}
+//# sourceMappingURL=frontmatter.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexrall/code-core",
-  "version": "1.4.46",
+  "version": "1.4.48",
   "description": "Core agent loop, tools, and extension primitives for Nexrall Code — embed an AI coding agent in any Node.js application.",
   "license": "MIT",
   "author": "Nexrall <support@nexrall.com> (https://nexrall.com)",
@@ -95,7 +95,10 @@
   },
   "dependencies": {
     "eventsource-parser": "^1.1.2",
-    "node-fetch": "^3.3.2"
+    "node-fetch": "^3.3.2",
+    "docx": "^9.7.1",
+    "exceljs": "^4.4.0",
+    "pptxgenjs": "^4.0.1"
   },
   "devDependencies": {
     "@types/node": "^26.0.1",