@andespindola/brainlink 1.0.2 → 1.0.4

package/dist/application/memory-suggestions.js

@@ -0,0 +1,220 @@
+import { readFile } from 'node:fs/promises';
+import { basename, extname } from 'node:path';
+import { ensureVault } from '../infrastructure/file-system-vault.js';
+import { searchKnowledge } from './search-knowledge.js';
+import { getGraphSummary } from './get-graph-summary.js';
+import { getBrokenLinksReport } from './analyze-vault.js';
+const stopwords = new Set([
+    'about',
+    'after',
+    'agent',
+    'agents',
+    'antes',
+    'brainlink',
+    'com',
+    'como',
+    'das',
+    'dos',
+    'for',
+    'from',
+    'para',
+    'por',
+    'que',
+    'the',
+    'this',
+    'uma',
+    'with'
+]);
+const wordPattern = /[\p{L}\p{N}_-]+/gu;
+const tagPattern = /(^|\s)#([A-Za-z0-9][A-Za-z0-9_-]*)/g;
+const unique = (values) => Array.from(new Set(values));
+const normalizeText = (value) => value
+    .normalize('NFKD')
+    .replace(/\p{Diacritic}/gu, '')
+    .toLowerCase();
+const words = (value) => normalizeText(value)
+    .match(wordPattern)
+    ?.filter((word) => word.length > 2 && !stopwords.has(word)) ?? [];
+const titleCase = (value) => value
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((word) => `${word.slice(0, 1).toUpperCase()}${word.slice(1)}`)
+    .join(' ');
+const stripMarkdownNoise = (value) => value
+    .replace(/^---[\s\S]*?\n---\n?/, '')
+    .replace(/```[\s\S]*?```/g, ' ')
+    .replace(/[#>*_\-[\]()`]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+export const inferMemoryTitle = (content, fallback = 'Memory Note') => {
+    const heading = content.match(/^#{1,6}\s+(.+)$/m)?.[1]?.trim();
+    if (heading)
+        return heading.replace(/\s+#\w[\w-]*/g, '').trim();
+    const firstSentence = stripMarkdownNoise(content).split(/[.!?\n]/)[0]?.trim();
+    if (!firstSentence)
+        return fallback;
+    return titleCase(firstSentence.split(/\s+/).slice(0, 8).join(' '));
+};
+export const inferMemoryTags = (content, extraTags = []) => {
+    const explicit = Array.from(content.matchAll(tagPattern), (match) => match[2]);
+    const weighted = words(content).reduce((state, word) => {
+        state.set(word, (state.get(word) ?? 0) + 1);
+        return state;
+    }, new Map());
+    const inferred = Array.from(weighted.entries())
+        .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
+        .map(([word]) => word.replace(/[^a-z0-9_-]/g, '-'))
+        .filter((word) => word.length >= 3)
+        .slice(0, 4);
+    return unique([...extraTags, ...explicit, ...inferred])
+        .map((tag) => tag.replace(/^#/, '').trim())
+        .filter(Boolean)
+        .slice(0, 8);
+};
+const scoreTitleAgainstText = (title, content) => {
+    const textWords = new Set(words(content));
+    const titleWords = words(title);
+    if (titleWords.length === 0)
+        return 0;
+    const hits = titleWords.filter((word) => textWords.has(word)).length;
+    return Number((hits / titleWords.length).toFixed(4));
+};
+const editDistance = (left, right) => {
+    const previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+    const current = Array.from({ length: right.length + 1 }, () => 0);
+    for (let leftIndex = 1; leftIndex <= left.length; leftIndex += 1) {
+        current[0] = leftIndex;
+        for (let rightIndex = 1; rightIndex <= right.length; rightIndex += 1) {
+            const cost = left[leftIndex - 1] === right[rightIndex - 1] ? 0 : 1;
+            current[rightIndex] = Math.min(previous[rightIndex] + 1, current[rightIndex - 1] + 1, previous[rightIndex - 1] + cost);
+        }
+        for (let index = 0; index < previous.length; index += 1) {
+            previous[index] = current[index];
+        }
+    }
+    return previous[right.length] ?? 0;
+};
+const titleSimilarity = (left, right) => {
+    const normalizedLeft = normalizeText(left).replace(/\s+/g, ' ').trim();
+    const normalizedRight = normalizeText(right).replace(/\s+/g, ' ').trim();
+    if (!normalizedLeft || !normalizedRight)
+        return 0;
+    if (normalizedLeft === normalizedRight)
+        return 1;
+    const distance = editDistance(normalizedLeft, normalizedRight);
+    const maxLength = Math.max(normalizedLeft.length, normalizedRight.length);
+    return Number(Math.max(0, 1 - distance / maxLength).toFixed(4));
+};
+export const suggestContextLinks = async (vaultPath, content, agentId, limit) => {
+    await ensureVault(vaultPath);
+    const graph = await getGraphSummary(vaultPath, agentId);
+    const byTitle = new Map();
+    for (const node of graph.nodes) {
+        const score = scoreTitleAgainstText(node.title, content);
+        if (score > 0) {
+            byTitle.set(node.title.toLowerCase(), {
+                title: node.title,
+                path: node.path,
+                score,
+                reason: 'title words appear in the new memory'
+            });
+        }
+    }
+    const query = stripMarkdownNoise(content).slice(0, 500);
+    const searchResults = query.length > 0
+        ? await searchKnowledge(vaultPath, query, Math.max(limit * 2, 6), agentId, 'hybrid')
+        : [];
+    for (const result of searchResults) {
+        const key = result.title.toLowerCase();
+        const current = byTitle.get(key);
+        const score = Number(Math.min(1, Math.max(result.score / 20, result.semanticScore)).toFixed(4));
+        if (!current || score > current.score) {
+            byTitle.set(key, {
+                title: result.title,
+                path: result.path,
+                score,
+                reason: result.textScore > 0 ? 'search matched title, tags or content' : 'semantic search found related content'
+            });
+        }
+    }
+    return Array.from(byTitle.values())
+        .sort((left, right) => right.score - left.score || left.title.localeCompare(right.title))
+        .slice(0, Math.max(0, limit));
+};
+export const buildRememberSuggestion = async (input) => {
+    const title = input.title?.trim() || inferMemoryTitle(input.content);
+    const tags = inferMemoryTags(input.content, input.tags ?? []);
+    const suggestedLinks = await suggestContextLinks(input.vaultPath, input.content, input.agentId, input.linkLimit ?? 5);
+    const explicitLinks = (input.links ?? []).map((link) => ({
+        title: link,
+        path: '',
+        score: 1,
+        reason: 'provided explicitly'
+    }));
+    const links = unique([...explicitLinks, ...suggestedLinks].map((link) => link.title))
+        .map((linkTitle) => explicitLinks.find((link) => link.title === linkTitle) ?? suggestedLinks.find((link) => link.title === linkTitle))
+        .filter((link) => Boolean(link));
+    const tagLine = tags.length > 0 ? `\n\n${tags.map((tag) => `#${tag}`).join(' ')}` : '';
+    const linkSection = links.length > 0
+        ? `\n\n## Context Links\n\n${links.map((link) => `- [[${link.title}]]`).join('\n')}`
+        : '';
+    return {
+        title,
+        tags,
+        links,
+        content: `${input.content.trim()}${tagLine}${linkSection}`.trim()
+    };
+};
+export const suggestBrokenLinkFixes = async (vaultPath, agentId, limit) => {
+    const [brokenLinks, graph] = await Promise.all([
+        getBrokenLinksReport(vaultPath, agentId),
+        getGraphSummary(vaultPath, agentId)
+    ]);
+    return brokenLinks.map((link) => ({
+        ...link,
+        candidates: graph.nodes
+            .map((node) => ({
+            title: node.title,
+            path: node.path,
+            score: Math.max(scoreTitleAgainstText(link.toTitle, `${node.title} ${node.path}`), titleSimilarity(link.toTitle, node.title)),
+            reason: 'similar title/path'
+        }))
+            .filter((candidate) => candidate.score > 0)
+            .sort((left, right) => right.score - left.score || left.title.localeCompare(right.title))
+            .slice(0, Math.max(0, limit))
+    }));
+};
+export const explainSearchResults = async (vaultPath, query, limit, agentId, mode) => {
+    const queryWords = new Set(words(query));
+    const results = await searchKnowledge(vaultPath, query, limit, agentId, mode);
+    return results.map((result) => {
+        const titleWords = words(result.title).filter((word) => queryWords.has(word));
+        const tagWords = result.tags.filter((tag) => queryWords.has(normalizeText(tag)));
+        const contentWords = words(result.content).filter((word) => queryWords.has(word));
+        const reasons = [
+            ...(titleWords.length > 0 ? [`title matched: ${unique(titleWords).join(', ')}`] : []),
+            ...(tagWords.length > 0 ? [`tags matched: ${unique(tagWords).join(', ')}`] : []),
+            ...(contentWords.length > 0 ? [`content matched: ${unique(contentWords).slice(0, 8).join(', ')}`] : []),
+            ...(result.semanticScore > 0 ? [`semantic score: ${result.semanticScore.toFixed(3)}`] : []),
+            `text score: ${result.textScore.toFixed(3)}`,
+            `final score: ${result.score.toFixed(3)}`
+        ];
+        return {
+            ...result,
+            reasons
+        };
+    });
+};
+export const readMemoryContentInput = async (input) => {
+    if (input.content != null && input.content.trim().length > 0) {
+        return input.content;
+    }
+    if (input.contentFile != null && input.contentFile.trim().length > 0) {
+        return readFile(input.contentFile, 'utf8');
+    }
+    throw new Error('Use --content or --content-file to provide content.');
+};
+export const inferTitleFromFilePath = (filePath) => basename(filePath, extname(filePath))
+    .replace(/[-_]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();

package/dist/application/operational-workflows.js

@@ -0,0 +1,153 @@
+import { execFile } from 'node:child_process';
+import { access, readFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { promisify } from 'node:util';
+import { addNoteWithMetadata } from './add-note.js';
+import { doctorVault, getStats, validateVault } from './analyze-vault.js';
+import { indexVault } from './index-vault.js';
+import { buildRememberSuggestion } from './memory-suggestions.js';
+import { ensureVault } from '../infrastructure/file-system-vault.js';
+const execFileAsync = promisify(execFile);
+const readIfExists = async (path) => {
+    try {
+        await access(path);
+        return readFile(path, 'utf8');
+    }
+    catch {
+        return null;
+    }
+};
+const tryGitStatus = async (cwd) => {
+    try {
+        const { stdout } = await execFileAsync('git', ['status', '--short'], { cwd });
+        return stdout.trim();
+    }
+    catch {
+        return '';
+    }
+};
+export const buildActionableDoctor = async (vaultPath) => {
+    const [doctor, validation] = await Promise.all([
+        doctorVault(vaultPath),
+        validateVault(vaultPath)
+    ]);
+    const actions = [
+        ...(doctor.recommendations ?? []).map((recommendation) => ({
+            severity: 'warning',
+            command: recommendation.startsWith('Vault is empty') ? recommendation.replace(/^Vault is empty\. Add your first note: /, '') : recommendation,
+            reason: 'doctor recommendation'
+        })),
+        ...(validation.brokenLinks.length > 0
+            ? [{
+                    severity: 'warning',
+                    command: `blink repair-links --vault "${vaultPath}"`,
+                    reason: `${validation.brokenLinks.length} unresolved wiki links can be safely repaired or materialized as placeholder targets`
+                }]
+            : []),
+        ...(validation.orphans.length > 0
+            ? [{
+                    severity: 'info',
+                    command: `blink suggest-links --vault "${vaultPath}"`,
+                    reason: `${validation.orphans.length} notes have no incoming or outgoing links`
+                }]
+            : []),
+        {
+            severity: doctor.ok ? 'info' : 'critical',
+            command: `blink index --vault "${vaultPath}"`,
+            reason: 'keep derived index synchronized with Markdown source'
+        }
+    ];
+    return {
+        doctor,
+        validation,
+        actions
+    };
+};
+export const closeSession = async (input) => {
+    const [stats, validation, gitStatus] = await Promise.all([
+        getStats(input.vaultPath, input.agentId),
+        validateVault(input.vaultPath, input.agentId),
+        tryGitStatus(input.cwd)
+    ]);
+    const date = new Date().toISOString().slice(0, 10);
+    const title = `Session Close ${basename(input.cwd)} ${date}`;
+    const content = [
+        input.content?.trim() ? `## Notes\n\n${input.content.trim()}` : null,
+        '## Vault State',
+        `- Documents: ${stats.documentCount}`,
+        `- Links: ${stats.linkCount}`,
+        `- Broken links: ${stats.brokenLinkCount}`,
+        `- Orphans: ${stats.orphanCount}`,
+        gitStatus ? `\n## Git Status\n\n\`\`\`txt\n${gitStatus}\n\`\`\`` : null,
+        validation.brokenLinks.length > 0
+            ? `\n## Follow Up\n\n- Review unresolved links with \`blink suggest-links --broken\`.`
+            : null,
+        '\n#session #handoff'
+    ].filter((part) => Boolean(part)).join('\n');
+    const suggestion = await buildRememberSuggestion({
+        vaultPath: input.vaultPath,
+        content,
+        agentId: input.agentId,
+        title,
+        tags: ['session', 'handoff'],
+        linkLimit: 5
+    });
+    if (input.write === false) {
+        return {
+            title,
+            content: suggestion.content,
+            writtenPath: null,
+            index: null
+        };
+    }
+    const note = await addNoteWithMetadata(input.vaultPath, title, suggestion.content, input.agentId, {
+        autoContextLinks: false
+    });
+    const index = input.autoIndex === false ? null : await indexVault(input.vaultPath);
+    return {
+        title,
+        content: suggestion.content,
+        writtenPath: note.path,
+        index
+    };
+};
+export const initializeProjectMemory = async (input) => {
+    const vault = await ensureVault(input.vaultPath);
+    const candidates = ['AGENTS.md', 'README.md', 'docs/ARCHITECTURE.md', 'docs/QUICKSTART.md'];
+    const contents = await Promise.all(candidates.map(async (relativePath) => ({
+        relativePath,
+        content: await readIfExists(join(input.projectPath, relativePath))
+    })));
+    const available = contents.filter((item) => item.content !== null);
+    const fallback = available.length > 0
+        ? []
+        : [{
+                relativePath: 'Project Overview',
+                content: `Project path: ${input.projectPath}\n\n#project #memory`
+            }];
+    const notes = await Promise.all([...available, ...fallback].map(async (item) => {
+        const title = `Project ${basename(input.projectPath)} ${item.relativePath.replace(/\.md$/i, '').replace(/[\\/]/g, ' ')}`;
+        const suggestion = await buildRememberSuggestion({
+            vaultPath: input.vaultPath,
+            content: `${item.content.trim()}\n\n#project #memory`,
+            agentId: input.agentId,
+            title,
+            tags: ['project', 'memory'],
+            linkLimit: 5
+        });
+        const note = await addNoteWithMetadata(input.vaultPath, title, suggestion.content, input.agentId, {
+            autoContextLinks: false
+        });
+        return {
+            title,
+            path: note.path
+        };
+    }));
+    const index = await indexVault(input.vaultPath);
+    return {
+        projectPath: input.projectPath,
+        vault,
+        notes,
+        index
+    };
+};

package/dist/application/repair-broken-links.js

@@ -0,0 +1,157 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { sanitizeAgentId, sharedAgentId } from '../domain/agents.js';
+import { parseMarkdownDocument } from '../domain/markdown.js';
+import { ensureVault, readMarkdownFileSummaries, writeMarkdownFile } from '../infrastructure/file-system-vault.js';
+import { indexVault } from './index-vault.js';
+import { suggestBrokenLinkFixes } from './memory-suggestions.js';
+const slugify = (title) => title
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '') || 'untitled';
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const replaceWikiLinkTitle = (content, fromTitle, toTitle) => {
+    const pattern = new RegExp(`\\[\\[${escapeRegExp(fromTitle)}((?:#[^\\]|]+)?(?:\\|[^\\]]+)?)\\]\\]`, 'g');
+    return content.replace(pattern, `[[${toTitle}$1]]`);
+};
+const buildPlaceholderNote = (title, sources, agentId) => [
+    '---',
+    `title: "${title.replaceAll('"', '\\"')}"`,
+    `agent: "${sanitizeAgentId(agentId)}"`,
+    '---',
+    '',
+    `# ${title}`,
+    '',
+    'Auto-created target for unresolved Brainlink wiki links. Replace this placeholder with durable context when the concept is clarified. #triage',
+    '',
+    '## Referenced By',
+    '',
+    ...sources.map((source) => `- [[${source}]]`),
+    ''
+].join('\n');
+const readNotes = async (vaultPath) => {
+    const absoluteVaultPath = await ensureVault(vaultPath);
+    const summaries = await readMarkdownFileSummaries(absoluteVaultPath);
+    return Promise.all(summaries.map(async (summary) => {
+        const content = await readFile(summary.absolutePath, 'utf8');
+        const document = parseMarkdownDocument({
+            absolutePath: summary.absolutePath,
+            vaultPath: absoluteVaultPath,
+            content,
+            createdAt: summary.createdAt,
+            updatedAt: summary.updatedAt
+        });
+        return {
+            relativePath: summary.relativePath,
+            title: document.title,
+            agentId: document.agentId,
+            content
+        };
+    }));
+};
+const isConfident = (candidates, minScore, margin) => {
+    const [best, second] = candidates;
+    if (!best || best.score < minScore)
+        return false;
+    if (!second)
+        return true;
+    return best.score - second.score >= margin;
+};
+export const repairBrokenLinks = async (vaultPath, options = {}) => {
+    const minScore = options.minScore ?? 0.88;
+    const margin = options.margin ?? 0.12;
+    const createMissing = options.createMissing !== false;
+    const suggestions = await suggestBrokenLinkFixes(vaultPath, options.agentId, 5);
+    const notes = await readNotes(vaultPath);
+    const notesByPath = new Map(notes.map((note) => [note.relativePath, note]));
+    const nextContentByPath = new Map();
+    const placeholderSources = new Map();
+    const entries = [];
+    for (const brokenLink of suggestions) {
+        const candidates = brokenLink.candidates;
+        const best = candidates[0];
+        const source = notesByPath.get(brokenLink.fromPath);
+        if (best && isConfident(candidates, minScore, margin)) {
+            const currentContent = nextContentByPath.get(brokenLink.fromPath) ?? source?.content;
+            if (!source || currentContent == null) {
+                entries.push({
+                    ...brokenLink,
+                    action: 'skipped',
+                    targetTitle: null,
+                    targetPath: null,
+                    score: best.score,
+                    reason: 'source note was not found'
+                });
+                continue;
+            }
+            const nextContent = replaceWikiLinkTitle(currentContent, brokenLink.toTitle, best.title);
+            if (nextContent !== currentContent) {
+                nextContentByPath.set(brokenLink.fromPath, nextContent);
+            }
+            entries.push({
+                ...brokenLink,
+                action: 'retargeted',
+                targetTitle: best.title,
+                targetPath: best.path,
+                score: best.score,
+                reason: 'single high-confidence existing title match'
+            });
+            continue;
+        }
+        if (createMissing) {
+            const sourceTitles = placeholderSources.get(brokenLink.toTitle) ?? new Set();
+            sourceTitles.add(brokenLink.fromTitle);
+            placeholderSources.set(brokenLink.toTitle, sourceTitles);
+            entries.push({
+                ...brokenLink,
+                action: 'created-target',
+                targetTitle: brokenLink.toTitle,
+                targetPath: null,
+                score: best?.score ?? null,
+                reason: best ? 'no unambiguous existing target; placeholder target will be created' : 'no existing target candidate; placeholder target will be created'
+            });
+            continue;
+        }
+        entries.push({
+            ...brokenLink,
+            action: 'skipped',
+            targetTitle: null,
+            targetPath: null,
+            score: best?.score ?? null,
+            reason: best ? 'candidate score or margin was too low' : 'no candidate found'
+        });
+    }
+    if (!options.dryRun) {
+        await Promise.all(Array.from(nextContentByPath.entries()).map(([relativePath, content]) => writeMarkdownFile(vaultPath, relativePath, content)));
+        await Promise.all(Array.from(placeholderSources.entries()).map(([title, sources]) => {
+            const agentId = sanitizeAgentId(options.agentId ?? sharedAgentId);
+            const path = join('agents', agentId, 'unresolved-links', `${slugify(title)}.md`).replaceAll('\\', '/');
+            return writeMarkdownFile(vaultPath, path, buildPlaceholderNote(title, Array.from(sources), agentId));
+        }));
+    }
+    const changed = nextContentByPath.size;
+    const created = placeholderSources.size;
+    const index = !options.dryRun && options.autoIndex !== false && (changed > 0 || created > 0)
+        ? await indexVault(vaultPath)
+        : undefined;
+    return {
+        dryRun: options.dryRun === true,
+        scanned: suggestions.length,
+        changed,
+        created,
+        skipped: entries.filter((entry) => entry.action === 'skipped').length,
+        entries: entries.map((entry) => {
+            if (entry.action !== 'created-target' || entry.targetPath) {
+                return entry;
+            }
+            const agentId = sanitizeAgentId(options.agentId ?? sharedAgentId);
+            return {
+                ...entry,
+                targetPath: join('agents', agentId, 'unresolved-links', `${slugify(entry.toTitle)}.md`).replaceAll('\\', '/')
+            };
+        }),
+        ...(index ? { index } : {})
+    };
+};

package/dist/application/server/multipart.js

@@ -0,0 +1,80 @@
+const readRequestBuffer = async (request, limitBytes) => {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.byteLength;
+        if (size > limitBytes) {
+            throw Object.assign(new Error('Request body too large'), { statusCode: 413 });
+        }
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks);
+};
+const parseDisposition = (value) => value
+    .split(';')
+    .slice(1)
+    .reduce((params, entry) => {
+    const [rawKey, ...rawValue] = entry.trim().split('=');
+    const key = rawKey?.trim();
+    if (!key) {
+        return params;
+    }
+    params[key] = rawValue.join('=').trim().replace(/^"|"$/g, '');
+    return params;
+}, {});
+const parseHeaders = (value) => value.split('\r\n').reduce((headers, line) => {
+    const separator = line.indexOf(':');
+    if (separator < 0) {
+        return headers;
+    }
+    const key = line.slice(0, separator).trim().toLowerCase();
+    const headerValue = line.slice(separator + 1).trim();
+    if (key) {
+        headers[key] = headerValue;
+    }
+    return headers;
+}, {});
+const stripPartTerminator = (value) => value.endsWith('\r\n') ? value.slice(0, -2) : value;
+export const parseMultipartForm = async (request, limitBytes = 50 * 1024 * 1024) => {
+    const contentType = Array.isArray(request.headers['content-type'])
+        ? request.headers['content-type'][0]
+        : request.headers['content-type'];
+    const boundary = contentType?.match(/boundary=(?:"([^"]+)"|([^;]+))/)?.[1] ?? contentType?.match(/boundary=(?:"([^"]+)"|([^;]+))/)?.[2];
+    if (!boundary) {
+        throw Object.assign(new Error('Missing multipart boundary'), { statusCode: 400 });
+    }
+    const body = await readRequestBuffer(request, limitBytes);
+    const bodyText = body.toString('binary');
+    const parts = bodyText.split(`--${boundary}`);
+    const fields = {};
+    const files = [];
+    for (const rawPart of parts) {
+        if (!rawPart || rawPart === '--\r\n' || rawPart === '--') {
+            continue;
+        }
+        const part = rawPart.startsWith('\r\n') ? rawPart.slice(2) : rawPart;
+        const separator = part.indexOf('\r\n\r\n');
+        if (separator < 0) {
+            continue;
+        }
+        const headers = parseHeaders(part.slice(0, separator));
+        const content = stripPartTerminator(part.slice(separator + 4));
+        const disposition = parseDisposition(headers['content-disposition'] ?? '');
+        const fieldName = disposition.name ?? '';
+        if (!fieldName) {
+            continue;
+        }
+        if (disposition.filename != null && disposition.filename.length > 0) {
+            files.push({
+                fieldName,
+                filename: disposition.filename,
+                contentType: headers['content-type'] ?? 'application/octet-stream',
+                data: Buffer.from(content, 'binary')
+            });
+            continue;
+        }
+        fields[fieldName] = Buffer.from(content, 'binary').toString('utf8');
+    }
+    return { fields, files };
+};