svharness 0.15.14 → 0.15.15

package/README.md

@@ -553,6 +553,12 @@ svharness convert --verbose --yes
 | `--force` | flag，覆盖已存在同名 `.md`（默认自动追加 `-1`、`-2` 后缀） | `false` |
 | `--split-sheets-suffix <suffix>` | xlsx/xls 按 sheet 拆分的子目录后缀 | `_split` |
 | `--no-split-sheets` | flag，不将 xlsx/xls 合并 md 按 `##` 拆分为多文件 | `false`（默认拆分） |
+| `--no-split-headings` | flag，不对超大合并 md 按标题（默认 `##`）拆分 | `false`（默认拆分） |
+| `--split-heading-level <n>` | 标题切分锚点级别（1–6） | `2` |
+| `--split-min-lines <n>` | 触发标题切分的最小行数 | `800` |
+| `--split-min-bytes <n>` | 触发标题切分的最小字节数 | `100000` |
+| `--split-tables` | flag，将超大 GFM 表格按行切段（每段重复表头） | `false` |
+| `--split-table-max-rows <n>` | 表格切段时每段最大数据行数 | `80` |
 | `-y, --yes` | flag，跳过交互确认 | `false` |
 | `--verbose` | flag，显示详细日志（含每文件 `converter` / `fallback_used` / endpoint） | `false` |
 

package/dist/commands/convert.js

@@ -29,7 +29,7 @@ const markitdown_client_1 = require("../core/markitdown-client");
 const doc_intake_paths_1 = require("../core/doc-intake-paths");
 const structure_scan_1 = require("../lib/requirements/structure-scan");
 const markdown_table_cleanup_1 = require("../core/markdown-table-cleanup");
-const markdown_sheet_split_1 = require("../core/markdown-sheet-split");
+const markdown_post_split_1 = require("../core/markdown-post-split");
 /**
  * Extensions recognised by Microsoft MarkItDown (v0.x). Anything outside this
  * whitelist is skipped client-side to avoid a round-trip that is guaranteed to
@@ -98,6 +98,14 @@ async function runConvert(opts) {
         value: opts.splitSheets === false
             ? 'no'
             : `yes (${opts.splitSheetsSuffix ?? '_split'})`,
+    }, {
+        label: 'split headings',
+        value: opts.splitHeadings === false
+            ? 'no'
+            : `yes (##, min ${opts.splitMinLines ?? 800} lines / ${opts.splitMinBytes ?? 100_000}B)`,
+    }, {
+        label: 'split tables',
+        value: opts.splitTables ? `yes (max ${opts.splitTableMaxRows ?? 80} rows)` : 'no',
     });
     logger_1.logger.configBox('svharness convert', configRows);
     // 1. Collect candidate files.
@@ -203,7 +211,7 @@ async function runConvert(opts) {
             const item = queue.shift();
             if (!item)
                 break;
-            results.push(await uploadOne(item.source, outDir, used, v, opts, activeEndpoints));
+            results.push(await uploadOne(item.source, outDir, used, v, opts, activeEndpoints, v.harnessRoot));
         }
     };
     for (let i = 0; i < Math.min(v.concurrency, toUpload.length); i++) {
@@ -384,12 +392,10 @@ async function buildPlan(files, limitBytes) {
     }
     return out;
 }
-async function uploadOne(source, outDir, used, v, opts, activeEndpoints) {
+async function uploadOne(source, outDir, used, v, opts, activeEndpoints, harnessRoot) {
     const basename = node_path_1.default.basename(source, node_path_1.default.extname(source));
     const outPath = await resolveOutputPath(outDir, basename, used, !!opts.force);
     used.add(outPath);
-    const splitSheets = opts.splitSheets !== false;
-    const splitSuffix = opts.splitSheetsSuffix ?? '_split';
     logger_1.logger.debug(`upload ${source} -> ${outPath}`);
     try {
         const resp = await (0, markitdown_client_1.postConvertWithEndpointFailover)(activeEndpoints, source, v.timeoutSec * 1000);
@@ -413,33 +419,30 @@ async function uploadOne(source, outDir, used, v, opts, activeEndpoints) {
         }
         await fs_extra_1.default.writeFile(outPath, markdown, 'utf8');
         const bytes = Buffer.byteLength(markdown, 'utf8');
-        const outputs = [outPath];
-        if (splitSheets && markdown_sheet_split_1.XLSX_SPLIT_EXTS.has(ext)) {
-            const split = (0, markdown_sheet_split_1.splitSpreadsheetMarkdownBySheet)(markdown);
-            if (split.sections.length >= 2) {
-                const splitDir = node_path_1.default.join(outDir, `${basename}${splitSuffix}`);
-                const splitWritten = await (0, markdown_sheet_split_1.writeSheetSplitOutput)(split.sections, splitDir, node_path_1.default.basename(source), { writeIndex: true, force: !!opts.force });
-                outputs.push(...splitWritten);
-                logger_1.logger.debug(`sheet split ${node_path_1.default.basename(source)}: ${split.sections.length} sections -> ${splitDir}`);
-                logger_1.logger.success(`${node_path_1.default.basename(source)} -> ${node_path_1.default.basename(outPath)} + ${split.sections.length} sheets in ${node_path_1.default.basename(splitDir)}/ (${bytes}B)`);
-                return {
-                    source,
-                    output: outPath,
-                    outputs,
-                    status: 'ok',
-                    bytes,
-                    converter: resp.converter,
-                    fallbackUsed: resp.fallback_used,
-                    endpoint: resp.endpointUsed,
-                };
-            }
-        }
+        const splitResult = await (0, markdown_post_split_1.runPostConvertSplits)({
+            source,
+            outDir,
+            basename,
+            mergedMdPath: outPath,
+            markdown,
+            ext,
+            opts,
+            harnessRoot,
+        });
         const convNote = resp.fallback_used && resp.converter ? ` [${resp.converter}]` : '';
-        logger_1.logger.success(`${node_path_1.default.basename(source)} -> ${node_path_1.default.basename(outPath)} (${bytes}B)${convNote}`);
+        const splitNote = splitResult.sheetSplitDone
+            ? ` + sheet split`
+            : splitResult.headingSplitSections > 0
+                ? ` + ${splitResult.headingSplitSections} heading sections`
+                : '';
+        const tableNote = splitResult.tableSplitParts > 0
+            ? ` + ${splitResult.tableSplitParts} table parts`
+            : '';
+        logger_1.logger.success(`${node_path_1.default.basename(source)} -> ${node_path_1.default.basename(outPath)} (${bytes}B)${convNote}${splitNote}${tableNote}`);
         return {
             source,
             output: outPath,
-            outputs,
+            outputs: splitResult.outputs,
             status: 'ok',
             bytes,
             converter: resp.converter,

package/dist/config/merge-options.js

@@ -157,6 +157,14 @@ function mergeConvertOptions(cli, configSection, defaults, cmd) {
             ? false
             : pickBool('splitSheets', cli.splitSheets, cfg.splitSheets, undefined, cmd),
         splitSheetsSuffix: pickString('splitSheetsSuffix', cli.splitSheetsSuffix, cfg.splitSheetsSuffix, cmd),
+        splitHeadings: cli.noSplitHeadings
+            ? false
+            : pickBool('splitHeadings', cli.splitHeadings, cfg.splitHeadings, undefined, cmd),
+        splitHeadingLevel: pickNumber('splitHeadingLevel', cli.splitHeadingLevel, cfg.splitHeadingLevel, cmd),
+        splitMinLines: pickNumber('splitMinLines', cli.splitMinLines, cfg.splitMinLines, cmd),
+        splitMinBytes: pickNumber('splitMinBytes', cli.splitMinBytes, cfg.splitMinBytes, cmd),
+        splitTables: pickBool('splitTables', cli.splitTables, cfg.splitTables, undefined, cmd),
+        splitTableMaxRows: pickNumber('splitTableMaxRows', cli.splitTableMaxRows, cfg.splitTableMaxRows, cmd),
         noStructureScan: pickBool('noStructureScan', cli.noStructureScan, cfg.noStructureScan, undefined, cmd),
         yes: pickBool('yes', cli.yes, cfg.yes, defaults?.yes, cmd),
         verbose: pickBool('verbose', cli.verbose, cfg.verbose, defaults?.verbose, cmd),

package/dist/config/normalize.js

@@ -155,13 +155,17 @@ function pickConvertSection(raw) {
         if (raw[k] !== undefined)
             s[k] = Number(raw[k]);
     }
-    for (const k of ['force', 'yes', 'verbose', 'splitSheets']) {
+    for (const k of ['force', 'yes', 'verbose', 'splitSheets', 'splitHeadings', 'splitTables']) {
         if (raw[k] !== undefined)
             s[k] = Boolean(raw[k]);
     }
     if (raw.splitSheetsSuffix !== undefined && raw.splitSheetsSuffix !== null) {
         s.splitSheetsSuffix = String(raw.splitSheetsSuffix).trim();
     }
+    for (const k of ['splitHeadingLevel', 'splitMinLines', 'splitMinBytes', 'splitTableMaxRows']) {
+        if (raw[k] !== undefined)
+            s[k] = Number(raw[k]);
+    }
     return s;
 }
 function pickDefaults(raw) {

package/dist/core/doc-intake-paths.js

@@ -22,7 +22,9 @@ exports.RAW_SKIP_DIR_NAMES = new Set([
 function shouldSkipRawSubdir(name) {
     if (exports.RAW_SKIP_DIR_NAMES.has(name))
         return true;
-    // auto_pack_req：`--requirements .` 时勿把同级的 `.requirements-harness/` 当作源资料。
+    // auto_pack_req / md-pack：勿把 harness 工作目录当作源资料。
+    if (name.startsWith('.requirements-'))
+        return true;
     if (name.endsWith('-harness'))
         return true;
     return false;

package/dist/core/markdown-heading-split.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitMarkdownByHeadingLevel = splitMarkdownByHeadingLevel;
+/**
+ * Split large merged Markdown files by ATX heading level (default `##`).
+ */
+const markdown_split_common_1 = require("./markdown-split-common");
+const HEADING_RE = /^(#{1,6})\s+(.+)$/;
+function parseHeading(line) {
+    const m = HEADING_RE.exec(line);
+    if (!m)
+        return null;
+    return { level: m[1].length, title: m[2].trim() };
+}
+function headingPathAtLine(headings, line, splitLevel) {
+    const stack = [];
+    for (const h of headings) {
+        if (h.line >= line)
+            break;
+        while (stack.length > 0 && stack[stack.length - 1].level >= h.level) {
+            stack.pop();
+        }
+        stack.push({ level: h.level, title: h.title });
+    }
+    return stack.filter((h) => h.level < splitLevel).map((h) => h.title);
+}
+/**
+ * Split markdown at headings of the given level.
+ * Requires at least two sections to return a non-empty result.
+ */
+function splitMarkdownByHeadingLevel(markdown, opts) {
+    const splitLevel = opts.level ?? 2;
+    const minLines = opts.minLines ?? 800;
+    const minBytes = opts.minBytes ?? 100_000;
+    const charsBefore = Buffer.byteLength(markdown, 'utf8');
+    if (!(0, markdown_split_common_1.markdownExceedsSplitThreshold)(markdown, minLines, minBytes)) {
+        return {
+            sections: [],
+            stats: {
+                sectionsFound: 0,
+                charsBefore,
+                charsAfter: charsBefore,
+                skippedReason: 'below threshold',
+            },
+        };
+    }
+    const lines = markdown.split(/\r?\n/);
+    const allHeadings = [];
+    for (let i = 0; i < lines.length; i++) {
+        const h = parseHeading(lines[i]);
+        if (h)
+            allHeadings.push({ ...h, line: i });
+    }
+    const anchors = allHeadings.filter((h) => h.level === splitLevel);
+    if (anchors.length < 2) {
+        return {
+            sections: [],
+            stats: {
+                sectionsFound: 0,
+                charsBefore,
+                charsAfter: charsBefore,
+                skippedReason: `no level-${splitLevel} headings`,
+            },
+        };
+    }
+    const sections = [];
+    for (let i = 0; i < anchors.length; i++) {
+        const startLine = anchors[i].line;
+        let endLine = lines.length;
+        for (let j = startLine + 1; j < lines.length; j++) {
+            const h = parseHeading(lines[j]);
+            if (h && h.level <= splitLevel) {
+                endLine = j;
+                break;
+            }
+        }
+        const title = anchors[i].title;
+        const headingPath = [...headingPathAtLine(allHeadings, startLine, splitLevel), title];
+        const bodyLines = lines.slice(startLine, endLine);
+        const meta = {
+            mergedBasename: opts.mergedBasename,
+            rawSource: opts.rawSource,
+            heading: title,
+            headingPath,
+            originStartLine: startLine,
+            originEndLine: endLine,
+        };
+        const body = (0, markdown_split_common_1.buildSplitMetaComment)(meta) +
+            bodyLines.join('\n').trimEnd() +
+            '\n';
+        sections.push({
+            title,
+            body,
+            filename: (0, markdown_split_common_1.slugifySplitTitle)(title, i + 1),
+            originStartLine: startLine,
+            originEndLine: endLine,
+            headingPath,
+        });
+    }
+    const charsAfter = sections.reduce((sum, s) => sum + Buffer.byteLength(s.body, 'utf8'), 0);
+    return {
+        sections,
+        stats: {
+            sectionsFound: sections.length,
+            charsBefore,
+            charsAfter,
+        },
+    };
+}

package/dist/core/markdown-post-split.js

@@ -0,0 +1,153 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPostConvertSplits = runPostConvertSplits;
+/**
+ * Post-convert markdown splitting: heading split + optional table split.
+ */
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const logger_1 = require("../utils/logger");
+const markdown_heading_split_1 = require("./markdown-heading-split");
+const markdown_table_split_1 = require("./markdown-table-split");
+const markdown_split_common_1 = require("./markdown-split-common");
+const markdown_sheet_split_1 = require("./markdown-sheet-split");
+function relRawPath(source, harnessRoot) {
+    if (!harnessRoot)
+        return undefined;
+    const rel = node_path_1.default.relative(harnessRoot, source).replace(/\\/g, '/');
+    if (rel.startsWith('..'))
+        return node_path_1.default.basename(source);
+    return rel;
+}
+async function applyTableSplitToFile(filePath, opts, force) {
+    if (!opts.splitTables) {
+        return { outputs: [], parts: 0 };
+    }
+    const content = await fs_extra_1.default.readFile(filePath, 'utf8');
+    const dir = node_path_1.default.dirname(filePath);
+    const base = node_path_1.default.basename(filePath, '.md');
+    const tablesDir = node_path_1.default.join(dir, 'tables');
+    const result = (0, markdown_table_split_1.splitLargeTablesInMarkdown)(content, {
+        maxRows: opts.splitTableMaxRows ?? 80,
+        fileBasename: base,
+        tablesDir,
+    });
+    if (result.stats.partsWritten === 0) {
+        return { outputs: [], parts: 0 };
+    }
+    await fs_extra_1.default.writeFile(filePath, result.markdown, 'utf8');
+    const written = [filePath];
+    await fs_extra_1.default.ensureDir(tablesDir);
+    for (const part of result.parts) {
+        const abs = node_path_1.default.join(dir, part.relativePath);
+        if (!force && (await fs_extra_1.default.pathExists(abs))) {
+            throw new Error(`table split output exists (pass --force): ${abs}`);
+        }
+        await fs_extra_1.default.writeFile(abs, part.content, 'utf8');
+        written.push(abs);
+    }
+    return { outputs: written, parts: result.stats.partsWritten };
+}
+async function writeSectionsWithTableSplit(sections, outputDir, sourceName, opts) {
+    const force = !!opts.force;
+    const processed = [];
+    const extraOutputs = [];
+    for (const section of sections) {
+        if (opts.splitTables) {
+            const tablesDir = node_path_1.default.join(outputDir, 'tables');
+            const partBase = node_path_1.default.basename(section.filename, '.md');
+            const split = (0, markdown_table_split_1.splitLargeTablesInMarkdown)(section.body, {
+                maxRows: opts.splitTableMaxRows ?? 80,
+                fileBasename: partBase,
+                tablesDir,
+            });
+            processed.push({ ...section, body: split.markdown });
+            if (split.parts.length > 0) {
+                await fs_extra_1.default.ensureDir(tablesDir);
+                for (const part of split.parts) {
+                    const abs = node_path_1.default.join(outputDir, part.relativePath);
+                    if (!force && (await fs_extra_1.default.pathExists(abs))) {
+                        throw new Error(`table split output exists (pass --force): ${abs}`);
+                    }
+                    await fs_extra_1.default.writeFile(abs, part.content, 'utf8');
+                    extraOutputs.push(abs);
+                }
+            }
+        }
+        else {
+            processed.push(section);
+        }
+    }
+    const written = await (0, markdown_split_common_1.writeMarkdownSplitOutput)(processed, outputDir, sourceName, { writeIndex: true, force });
+    return [...written, ...extraOutputs];
+}
+/**
+ * Run sheet / heading / table splits after merged markdown is written.
+ */
+async function runPostConvertSplits(ctx) {
+    const { source, outDir, basename, mergedMdPath, markdown, ext, opts } = ctx;
+    const splitSheets = opts.splitSheets !== false;
+    const splitHeadings = opts.splitHeadings !== false;
+    const splitSuffix = opts.splitSheetsSuffix ?? '_split';
+    const outputs = [mergedMdPath];
+    let sheetSplitDone = false;
+    let headingSplitSections = 0;
+    let tableSplitParts = 0;
+    let splitSkippedReason;
+    if (splitSheets && markdown_sheet_split_1.XLSX_SPLIT_EXTS.has(ext)) {
+        const split = (0, markdown_sheet_split_1.splitSpreadsheetMarkdownBySheet)(markdown);
+        if (split.sections.length >= 2) {
+            const splitDir = node_path_1.default.join(outDir, `${basename}${splitSuffix}`);
+            const splitWritten = await writeSectionsWithTableSplit(split.sections, splitDir, node_path_1.default.basename(source), opts);
+            outputs.push(...splitWritten);
+            sheetSplitDone = true;
+            logger_1.logger.debug(`sheet split ${node_path_1.default.basename(source)}: ${split.sections.length} sections -> ${splitDir}`);
+            const tableCount = splitWritten.length - split.sections.length - 1;
+            if (tableCount > 0)
+                tableSplitParts += tableCount;
+            return {
+                outputs,
+                sheetSplitDone,
+                headingSplitSections: 0,
+                tableSplitParts,
+            };
+        }
+    }
+    if (splitHeadings && !sheetSplitDone) {
+        const heading = (0, markdown_heading_split_1.splitMarkdownByHeadingLevel)(markdown, {
+            level: opts.splitHeadingLevel ?? 2,
+            minLines: opts.splitMinLines ?? 800,
+            minBytes: opts.splitMinBytes ?? 100_000,
+            mergedBasename: basename,
+            rawSource: relRawPath(source, ctx.harnessRoot),
+        });
+        if (heading.stats.skippedReason) {
+            splitSkippedReason = heading.stats.skippedReason;
+            if (heading.stats.skippedReason.startsWith('no level-')) {
+                logger_1.logger.warn(`heading-split skipped for ${node_path_1.default.basename(source)}: ${heading.stats.skippedReason}`);
+            }
+        }
+        if (heading.sections.length >= 2) {
+            const splitDir = node_path_1.default.join(outDir, `${basename}${splitSuffix}`);
+            const splitWritten = await writeSectionsWithTableSplit(heading.sections, splitDir, `${basename}.md`, opts);
+            outputs.push(...splitWritten);
+            headingSplitSections = heading.sections.length;
+            logger_1.logger.debug(`heading split ${node_path_1.default.basename(source)}: ${heading.sections.length} sections -> ${splitDir}`);
+        }
+    }
+    if (opts.splitTables) {
+        const tableOnMerged = await applyTableSplitToFile(mergedMdPath, opts, !!opts.force);
+        outputs.push(...tableOnMerged.outputs.filter((p) => !outputs.includes(p)));
+        tableSplitParts += tableOnMerged.parts;
+    }
+    return {
+        outputs,
+        sheetSplitDone,
+        headingSplitSections,
+        tableSplitParts,
+        splitSkippedReason,
+    };
+}

package/dist/core/markdown-sheet-split.js

@@ -1,7 +1,4 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.XLSX_SPLIT_EXTS = void 0;
 exports.slugifySheetTitle = slugifySheetTitle;
@@ -13,23 +10,14 @@ exports.writeSheetSplitOutput = writeSheetSplitOutput;
  * MarkItDown emits one `## SheetName` block per Excel worksheet. This pass
  * writes each block to its own `.md` file under `<basename><suffix>/`.
  */
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const node_path_1 = __importDefault(require("node:path"));
+const markdown_split_common_1 = require("./markdown-split-common");
 /** Source extensions that trigger sheet split during `svharness convert`. */
 exports.XLSX_SPLIT_EXTS = new Set(['.xlsx', '.xls']);
-const INVALID_FILENAME_CHARS = /[<>:"/\\|?*\x00-\x1f]/g;
 /**
  * Turn a sheet title into a safe filename: `{index}_{slug}.md`.
  */
 function slugifySheetTitle(title, index) {
-    let name = title.trim();
-    name = name.replace(INVALID_FILENAME_CHARS, '_');
-    name = name.replace(/\s+/g, '_');
-    name = name.replace(/^[._]+|[._]+$/g, '');
-    if (!name) {
-        name = 'section';
-    }
-    return `${String(index).padStart(2, '0')}_${name}.md`;
+    return (0, markdown_split_common_1.slugifySplitTitle)(title, index);
 }
 /**
  * Split markdown at `##` headings (one section per sheet).
@@ -54,7 +42,7 @@ function splitSpreadsheetMarkdownBySheet(markdown) {
     for (let i = 0; i < anchors.length; i++) {
         const endLine = i + 1 < anchors.length ? anchors[i + 1].startLine : lines.length;
         const body = lines.slice(anchors[i].startLine, endLine).join('\n').trimEnd() + '\n';
-        const filename = slugifySheetTitle(anchors[i].title, i + 1);
+        const filename = (0, markdown_split_common_1.slugifySplitTitle)(anchors[i].title, i + 1);
         sections.push({
             title: anchors[i].title,
             body,
@@ -71,39 +59,9 @@ function splitSpreadsheetMarkdownBySheet(markdown) {
         },
     };
 }
-function buildSplitIndex(sourceName, sections) {
-    const lines = [
-        `# Split index: ${sourceName}\n`,
-        `\nTotal sections: ${sections.length}\n\n`,
-    ];
-    for (const section of sections) {
-        lines.push(`- [${section.title}](${section.filename})\n`);
-    }
-    return lines.join('');
-}
 /**
  * Persist split sections to `outputDir`. Returns absolute paths written.
  */
 async function writeSheetSplitOutput(sections, outputDir, sourceName, opts) {
-    const writeIndex = opts?.writeIndex !== false;
-    const force = !!opts?.force;
-    await fs_extra_1.default.ensureDir(outputDir);
-    const written = [];
-    for (const section of sections) {
-        const filePath = node_path_1.default.join(outputDir, section.filename);
-        if (!force && (await fs_extra_1.default.pathExists(filePath))) {
-            throw new Error(`sheet split output exists (pass --force): ${filePath}`);
-        }
-        await fs_extra_1.default.writeFile(filePath, section.body, 'utf8');
-        written.push(filePath);
-    }
-    if (writeIndex) {
-        const indexPath = node_path_1.default.join(outputDir, 'README.md');
-        if (!force && (await fs_extra_1.default.pathExists(indexPath))) {
-            throw new Error(`sheet split index exists (pass --force): ${indexPath}`);
-        }
-        await fs_extra_1.default.writeFile(indexPath, buildSplitIndex(sourceName, sections), 'utf8');
-        written.push(indexPath);
-    }
-    return written;
+    return (0, markdown_split_common_1.writeMarkdownSplitOutput)(sections, outputDir, sourceName, opts);
 }

package/dist/core/markdown-split-common.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slugifySplitTitle = slugifySplitTitle;
+exports.buildSplitMetaComment = buildSplitMetaComment;
+exports.buildSplitIndex = buildSplitIndex;
+exports.writeMarkdownSplitOutput = writeMarkdownSplitOutput;
+exports.markdownExceedsSplitThreshold = markdownExceedsSplitThreshold;
+/**
+ * Shared utilities for markdown split passes (sheet / heading / table).
+ */
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const INVALID_FILENAME_CHARS = /[<>:"/\\|?*\x00-\x1f]/g;
+/**
+ * Turn a section title into a safe filename: `{index}_{slug}.md`.
+ */
+function slugifySplitTitle(title, index) {
+    let name = title.trim();
+    name = name.replace(INVALID_FILENAME_CHARS, '_');
+    name = name.replace(/\s+/g, '_');
+    name = name.replace(/^[._]+|[._]+$/g, '');
+    if (!name) {
+        name = 'section';
+    }
+    return `${String(index).padStart(2, '0')}_${name}.md`;
+}
+function buildSplitMetaComment(meta) {
+    const lines = [
+        '<!-- split-meta',
+        `source: ${meta.mergedBasename}.md`,
+    ];
+    if (meta.rawSource) {
+        lines.push(`raw: ${meta.rawSource}`);
+    }
+    lines.push(`heading: ${meta.heading}`);
+    lines.push(`heading_path: ${JSON.stringify(meta.headingPath)}`);
+    lines.push(`origin_lines: ${meta.originStartLine + 1}-${meta.originEndLine}`);
+    lines.push('-->', '');
+    return lines.join('\n');
+}
+function buildSplitIndex(sourceName, sections) {
+    const lines = [
+        `# Split index: ${sourceName}\n`,
+        `\nTotal sections: ${sections.length}\n\n`,
+    ];
+    for (const section of sections) {
+        lines.push(`- [${section.title}](${section.filename})\n`);
+    }
+    return lines.join('');
+}
+/**
+ * Persist split sections to `outputDir`. Returns absolute paths written.
+ */
+async function writeMarkdownSplitOutput(sections, outputDir, sourceName, opts) {
+    const writeIndex = opts?.writeIndex !== false;
+    const force = !!opts?.force;
+    await fs_extra_1.default.ensureDir(outputDir);
+    const written = [];
+    for (const section of sections) {
+        const filePath = node_path_1.default.join(outputDir, section.filename);
+        if (!force && (await fs_extra_1.default.pathExists(filePath))) {
+            throw new Error(`split output exists (pass --force): ${filePath}`);
+        }
+        await fs_extra_1.default.writeFile(filePath, section.body, 'utf8');
+        written.push(filePath);
+    }
+    if (writeIndex) {
+        const indexPath = node_path_1.default.join(outputDir, 'README.md');
+        if (!force && (await fs_extra_1.default.pathExists(indexPath))) {
+            throw new Error(`split index exists (pass --force): ${indexPath}`);
+        }
+        await fs_extra_1.default.writeFile(indexPath, buildSplitIndex(sourceName, sections), 'utf8');
+        written.push(indexPath);
+    }
+    return written;
+}
+function markdownExceedsSplitThreshold(markdown, minLines, minBytes) {
+    const lines = markdown.split(/\r?\n/).length;
+    const bytes = Buffer.byteLength(markdown, 'utf8');
+    return lines >= minLines || bytes >= minBytes;
+}

package/dist/core/markdown-table-split.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitLargeTablesInMarkdown = splitLargeTablesInMarkdown;
+/**
+ * Split oversized GFM tables inside Markdown into parts with repeated headers.
+ */
+const node_path_1 = __importDefault(require("node:path"));
+function isTableRow(line) {
+    return /^\|.+\|$/.test(line.trim());
+}
+function isTableSeparator(line) {
+    return /^\|[\s:|-]+\|$/.test(line.trim());
+}
+function parseTables(lines) {
+    const tables = [];
+    let i = 0;
+    while (i < lines.length) {
+        if (!isTableRow(lines[i])) {
+            i++;
+            continue;
+        }
+        const start = i;
+        const headerLine = lines[i];
+        i++;
+        let separatorLine = null;
+        if (i < lines.length && isTableSeparator(lines[i])) {
+            separatorLine = lines[i];
+            i++;
+        }
+        const dataLines = [];
+        while (i < lines.length && isTableRow(lines[i])) {
+            if (isTableSeparator(lines[i])) {
+                i++;
+                continue;
+            }
+            dataLines.push(lines[i]);
+            i++;
+        }
+        tables.push({ start, end: i, headerLine, separatorLine, dataLines });
+    }
+    return tables;
+}
+function buildTablePartContent(headerLine, separatorLine, dataLines) {
+    const parts = [headerLine];
+    if (separatorLine)
+        parts.push(separatorLine);
+    parts.push(...dataLines);
+    return parts.join('\n') + '\n';
+}
+function stubLinks(parts) {
+    const links = parts
+        .map((p, idx) => `[p${String(idx + 1).padStart(2, '0')}](${p.relativePath.replace(/\\/g, '/')})`)
+        .join('/');
+    return `> [split-table] 原表过大，已拆为 ${parts.length} 段：见 ${links}\n`;
+}
+/**
+ * Split tables exceeding maxRows; replace each oversized table with a stub link.
+ */
+function splitLargeTablesInMarkdown(markdown, opts) {
+    const maxRows = opts.maxRows ?? 80;
+    const lines = markdown.split(/\r?\n/);
+    const tables = parseTables(lines);
+    const parts = [];
+    let tablesSplit = 0;
+    if (tables.every((t) => t.dataLines.length <= maxRows)) {
+        return {
+            markdown,
+            parts: [],
+            stats: { tablesSplit: 0, partsWritten: 0 },
+        };
+    }
+    const outLines = [...lines];
+    let lineOffset = 0;
+    for (let ti = 0; ti < tables.length; ti++) {
+        const table = tables[ti];
+        if (table.dataLines.length <= maxRows)
+            continue;
+        tablesSplit++;
+        const chunkCount = Math.ceil(table.dataLines.length / maxRows);
+        const tableParts = [];
+        for (let c = 0; c < chunkCount; c++) {
+            const slice = table.dataLines.slice(c * maxRows, (c + 1) * maxRows);
+            const partName = `${opts.fileBasename}_table_p${String(c + 1).padStart(2, '0')}_of_${String(chunkCount).padStart(2, '0')}.md`;
+            const relativePath = node_path_1.default.join('tables', partName).replace(/\\/g, '/');
+            const content = `<!-- split-table-part ${c + 1}/${chunkCount} -->\n\n` +
+                buildTablePartContent(table.headerLine, table.separatorLine, slice);
+            tableParts.push({ relativePath, content });
+            parts.push({ relativePath, content });
+        }
+        const stub = stubLinks(tableParts);
+        const adjStart = table.start + lineOffset;
+        const adjEnd = table.end + lineOffset;
+        const stubLines = stub.split('\n');
+        outLines.splice(adjStart, adjEnd - adjStart, ...stubLines);
+        lineOffset += stubLines.length - (adjEnd - adjStart);
+    }
+    return {
+        markdown: outLines.join('\n'),
+        parts,
+        stats: {
+            tablesSplit,
+            partsWritten: parts.length,
+        },
+    };
+}

package/dist/index.js

@@ -376,6 +376,12 @@ function main() {
         .option('--force', '覆盖已存在同名 .md')
         .option('--split-sheets-suffix <suffix>', 'xlsx/xls 按 sheet（##）拆分时的子目录后缀', '_split')
         .option('--no-split-sheets', '不将 xlsx/xls 合并 md 按 ## 拆分为多文件')
+        .option('--no-split-headings', '不对超大合并 md 按标题（默认 ##）拆分为多文件')
+        .option('--split-heading-level <n>', '标题切分锚点级别（1–6，默认 2）', (v) => Number(v))
+        .option('--split-min-lines <n>', '触发标题切分的最小行数（默认 800）', (v) => Number(v))
+        .option('--split-min-bytes <n>', '触发标题切分的最小字节数（默认 100000）', (v) => Number(v))
+        .option('--split-tables', '将超大 GFM 表格按行切段（默认关闭）')
+        .option('--split-table-max-rows <n>', '表格切段时每段最大数据行数（默认 80）', (v) => Number(v))
         .option('--no-structure-scan', 'convert 完成后不自动 structure-scan（仅 requirements）')
         .option('-y, --yes', '跳过交互确认')
         .option('--verbose', '显示详细日志')
@@ -394,6 +400,12 @@ function main() {
                 force: opts.force,
                 splitSheetsSuffix: opts.splitSheetsSuffix,
                 noSplitSheets: opts.noSplitSheets,
+                noSplitHeadings: opts.noSplitHeadings,
+                splitHeadingLevel: opts.splitHeadingLevel,
+                splitMinLines: opts.splitMinLines,
+                splitMinBytes: opts.splitMinBytes,
+                splitTables: opts.splitTables,
+                splitTableMaxRows: opts.splitTableMaxRows,
                 noStructureScan: opts.noStructureScan,
                 yes: opts.yes,
                 verbose: opts.verbose,
@@ -410,6 +422,12 @@ function main() {
                 force: !!merged.force,
                 splitSheets: merged.noSplitSheets ? false : merged.splitSheets,
                 splitSheetsSuffix: merged.splitSheetsSuffix,
+                splitHeadings: merged.noSplitHeadings ? false : merged.splitHeadings,
+                splitHeadingLevel: merged.splitHeadingLevel,
+                splitMinLines: merged.splitMinLines,
+                splitMinBytes: merged.splitMinBytes,
+                splitTables: merged.splitTables,
+                splitTableMaxRows: merged.splitTableMaxRows,
                 yes: !!merged.yes,
                 verbose: !!merged.verbose,
                 noStructureScan: !!merged.noStructureScan,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svharness",
-  "version": "0.15.14",
+  "version": "0.15.15",
   "description": "CLI scaffolder for SDD-Driven Agent-Agnostic Coding Framework (harness)",
   "bin": {
     "svharness": "./bin/cli.js",
@@ -26,7 +26,7 @@
     "build": "tsc && node -e \"require('fs').cpSync('src/dashboard/static','dist/dashboard/static',{recursive:true,force:true})\"",
     "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
     "rebuild": "npm run clean && npm run build",
-    "test:requirements": "npm run build && node scripts/test-parse-blocks.js",
+    "test:requirements": "npm run build && node scripts/test-parse-blocks.js && node scripts/test-markdown-split.js",
     "test:auto": "npm run build && node scripts/test-harness-name.js && node scripts/test-doc-intake-paths.js && node scripts/test-auto-score.js && node scripts/test-auto-prompt.js && node scripts/test-acp-agent-cli-resolver.js && node scripts/test-auto-pack-req-context.js",
     "test:cli-declarations": "npm run build && node scripts/test-cli-input-declarations.js",
     "test:agent-launcher": "npm run build && node scripts/test-agent-launcher.js",