@fitlab-ai/agent-infra 0.7.7 → 0.8.0

package/lib/server/server.schema.json

@@ -0,0 +1,127 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://github.com/fitlab-ai/agent-infra/lib/server/server.schema.json",
+  "title": "agent-infra server configuration",
+  "description": "Schema for .agents/server.json. Secrets (appSecret, tokens, passwords) must NOT be committed here — put them in .agents/server.local.json or AGENT_INFRA_SERVER_* environment variables.",
+  "type": "object",
+  "additionalProperties": true,
+  "properties": {
+    "$schema": {
+      "type": "string"
+    },
+    "log": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "path": {
+          "type": "string",
+          "description": "Log file path. Defaults to ~/.agent-infra/logs/<project>/<repo-hash>/server.log (outside the repo; the repo-hash isolates checkouts that share a project). Relative paths resolve against the repo root; absolute paths are used as-is."
+        },
+        "rotateAtBytes": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Rotate the log to <path>.1 at startup if it already exceeds this size.",
+          "default": 52428800
+        }
+      }
+    },
+    "heartbeatMs": {
+      "type": "integer",
+      "minimum": 1,
+      "description": "Interval between daemon heartbeat log lines, in milliseconds.",
+      "default": 30000
+    },
+    "adapters": {
+      "type": "object",
+      "description": "Per-adapter configuration. Only adapters with enabled=true are loaded.",
+      "properties": {
+        "feishu": {
+          "type": "object",
+          "description": "Feishu (Lark) IM adapter. The appSecret must NOT be committed here — put it in .agents/server.local.json or AGENT_INFRA_SERVER_adapters__feishu__appSecret.",
+          "properties": {
+            "enabled": {
+              "type": "boolean",
+              "default": false
+            },
+            "appId": {
+              "type": "string",
+              "description": "Feishu self-built app App ID."
+            },
+            "domain": {
+              "type": "string",
+              "enum": ["feishu", "lark"],
+              "default": "feishu",
+              "description": "Open platform domain: feishu (default) or lark."
+            }
+          },
+          "required": ["enabled"]
+        }
+      },
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "enabled": {
+            "type": "boolean",
+            "default": false
+          }
+        },
+        "required": ["enabled"]
+      }
+    },
+    "command": {
+      "type": "object",
+      "description": "Command protocol defaults and skill allow-list.",
+      "additionalProperties": false,
+      "properties": {
+        "defaultTui": {
+          "type": "string",
+          "enum": ["claude", "codex", "gemini", "opencode"],
+          "default": "codex"
+        },
+        "skillTuiDefaults": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string",
+            "enum": ["claude", "codex", "gemini", "opencode"]
+          }
+        },
+        "allowedSkills": {
+          "type": "array",
+          "items": { "type": "string" }
+        }
+      }
+    },
+    "auth": {
+      "type": "object",
+      "description": "Adapter-qualified user roles. Keys look like feishu:ou_xxx.",
+      "additionalProperties": false,
+      "properties": {
+        "users": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "object",
+            "additionalProperties": true,
+            "properties": {
+              "role": {
+                "type": "string",
+                "enum": ["read", "write", "exec"]
+              },
+              "name": { "type": "string" }
+            },
+            "required": ["role"]
+          }
+        }
+      }
+    },
+    "stream": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "throttleMs": { "type": "integer", "minimum": 0, "default": 1500 },
+        "chunkChars": { "type": "integer", "minimum": 1, "default": 4000 },
+        "tailChars": { "type": "integer", "minimum": 1, "default": 8000 },
+        "timeoutMs": { "type": "integer", "minimum": 1, "default": 1800000 }
+      }
+    }
+  }
+}

package/lib/server/streamer.ts

@@ -0,0 +1,57 @@
+import { redactSecrets } from './redact.ts';
+import type { RunnerResult } from './runner.ts';
+
+export type StreamOptions = {
+  title: string;
+  chunkChars?: number;
+  throttleMs?: number;
+};
+
+function chunks(text: string, size: number): string[] {
+  if (text.length === 0) return [];
+  const out: string[] = [];
+  for (let i = 0; i < text.length; i += size) {
+    out.push(text.slice(i, i + size));
+  }
+  return out;
+}
+
+export async function streamCommand(
+  options: StreamOptions,
+  run: (emit?: (chunk: string) => Promise<void>) => Promise<RunnerResult>,
+  send: (text: string) => Promise<void>
+): Promise<RunnerResult> {
+  await send(`started ${options.title}`);
+  const size = options.chunkChars ?? 4000;
+  const throttleMs = options.throttleMs ?? 0;
+  let streamed = false;
+  let buffer = '';
+  let lastFlush = 0;
+
+  const flush = async (): Promise<void> => {
+    if (!buffer) return;
+    const text = redactSecrets(buffer);
+    buffer = '';
+    lastFlush = Date.now();
+    for (const chunk of chunks(text, size)) {
+      await send(chunk);
+    }
+  };
+
+  const emit = async (chunk: string): Promise<void> => {
+    streamed = true;
+    buffer += chunk;
+    const due = throttleMs === 0 || Date.now() - lastFlush >= throttleMs;
+    if (buffer.length >= size || due) {
+      await flush();
+    }
+  };
+
+  const result = await run(emit);
+  if (!streamed) {
+    buffer += [result.stdout, result.stderr].filter(Boolean).join('\n');
+  }
+  await flush();
+  await send(`finished ${options.title} exitCode=${result.exitCode} signal=${result.signal ?? 'null'}`);
+  return result;
+}

package/lib/task/commands/decisions.ts

@@ -0,0 +1,272 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { formatTable } from '../../table.ts';
+import { resolveTaskRef } from '../resolve-ref.ts';
+import { parseLedger, HUMAN_DECISION_STATUSES, type LedgerRow } from '../ledger.ts';
+import { extractSubSection } from '../sections.ts';
+
+const USAGE = `Usage: ai task decisions <N | #N | TASK-id> [selector] [options]
+
+Lists the human-decision (HD-) items recorded in a task's review disagreement
+ledger, or prints the full detail block for a single item. Read-only.
+
+  <ref>          Bare numeric / '#N' short id, or a full TASK-YYYYMMDD-HHMMSS id.
+  [selector]     Ordinal (1-based) or HD id (e.g. 'HD-3') to show one item's detail.
+
+Options:
+  --all              Include already-decided (human-decided) items, not just pending.
+  --stage <s>        Filter to one stage: analysis | plan | code.
+  --format <fmt>     Output format: text (default) | markdown.
+  -h, --help         Show this help.
+
+Aliased as 'ai task d'.
+`;
+
+const STAGES = new Set(['analysis', 'plan', 'code']);
+const FORMATS = new Set(['text', 'markdown']);
+const HD_ID_RE = /^HD-\d+$/;
+
+function fail(message: string): void {
+  process.stderr.write(`ai task decisions: ${message}\n`);
+  process.exitCode = 1;
+}
+
+type ParsedArgs = {
+  positionals: string[];
+  all: boolean;
+  stage?: string;
+  format: string;
+};
+
+// Returns null and sets the exit code when an option is malformed.
+function parseArgs(args: string[]): ParsedArgs | null {
+  const out: ParsedArgs = { positionals: [], all: false, format: 'text' };
+  for (let i = 0; i < args.length; i += 1) {
+    const a = args[i]!;
+    if (a === '--all') {
+      out.all = true;
+    } else if (a === '--stage') {
+      const v = args[i + 1];
+      if (v === undefined) {
+        fail('--stage requires a value (analysis|plan|code)');
+        return null;
+      }
+      out.stage = v;
+      i += 1;
+    } else if (a.startsWith('--stage=')) {
+      out.stage = a.slice('--stage='.length);
+    } else if (a === '--format') {
+      const v = args[i + 1];
+      if (v === undefined) {
+        fail('--format requires a value (text|markdown)');
+        return null;
+      }
+      out.format = v;
+      i += 1;
+    } else if (a.startsWith('--format=')) {
+      out.format = a.slice('--format='.length);
+    } else if (a.startsWith('-')) {
+      fail(`unknown option '${a}'`);
+      return null;
+    } else {
+      out.positionals.push(a);
+    }
+  }
+  return out;
+}
+
+// Parse `<file>.md#anchor` evidence into its filename, when present.
+function evidenceFile(evidence: string): string | null {
+  const m = /([\w.-]+\.md)#/.exec(evidence);
+  return m ? m[1]! : null;
+}
+
+function roundOf(file: string): number {
+  const m = /-r(\d+)\.md$/.exec(file);
+  return m ? Number.parseInt(m[1]!, 10) : 1;
+}
+
+// Locate the `### HD-N` detail block for a row. Prefer the artifact named by the
+// row's evidence anchor; otherwise scan analysis/plan/code artifacts and return
+// the block from the highest-round file that contains it. Returns '' when none
+// is found (caller degrades gracefully — plan B3).
+function findDetailBlock(row: LedgerRow, taskDir: string): string {
+  const hinted = evidenceFile(row.evidence);
+  if (hinted) {
+    const p = path.join(taskDir, hinted);
+    if (fs.existsSync(p)) {
+      const block = extractSubSection(fs.readFileSync(p, 'utf8'), row.id);
+      if (block) return block;
+    }
+  }
+  let best = '';
+  let bestRound = -1;
+  let entries: string[];
+  try {
+    entries = fs.readdirSync(taskDir);
+  } catch {
+    return '';
+  }
+  for (const file of entries) {
+    if (!/^(analysis|plan|code)(-r\d+)?\.md$/.test(file)) continue;
+    const block = extractSubSection(fs.readFileSync(path.join(taskDir, file), 'utf8'), row.id);
+    if (block && roundOf(file) > bestRound) {
+      best = block;
+      bestRound = roundOf(file);
+    }
+  }
+  return best;
+}
+
+// Pull the `## 人工裁决` record lines that mention this HD id, so a decided item
+// shows the human's recorded ruling alongside its detail block.
+function findDecisionRecord(id: string, content: string): string[] {
+  const lines = content.split('\n');
+  let i = 0;
+  while (i < lines.length && !/^##\s+(人工裁决|Human Decisions?)\s*$/.test(lines[i]!)) i += 1;
+  if (i >= lines.length) return [];
+  const idRe = new RegExp(`(^|[^\\w-])${id}(?![\\w-])`);
+  const out: string[] = [];
+  for (let j = i + 1; j < lines.length; j += 1) {
+    if (/^##\s/.test(lines[j]!)) break;
+    if (lines[j]!.trim().startsWith('-') && idRe.test(lines[j]!)) out.push(lines[j]!);
+  }
+  return out;
+}
+
+function titleOf(row: LedgerRow, taskDir: string): string {
+  const block = findDetailBlock(row, taskDir);
+  if (block) {
+    return block
+      .split('\n')[0]!
+      .replace(/^###\s+/, '')
+      .replace(/\s*\[needs-human-decision\]\s*$/, '')
+      .trim();
+  }
+  return row.evidence || '(无详情)';
+}
+
+function renderList(rows: LedgerRow[], format: string, taskDir: string): void {
+  if (rows.length === 0) {
+    process.stdout.write('无待裁决项。\n');
+    return;
+  }
+  const headers = ['#', 'ID', 'STAGE', 'SEVERITY', 'STATUS', 'EVIDENCE', 'TITLE'];
+  const data = rows.map((r, i) => [
+    String(i + 1),
+    r.id,
+    r.stage,
+    r.severity,
+    r.status,
+    r.evidence,
+    titleOf(r, taskDir)
+  ]);
+  if (format === 'markdown') {
+    const sep = headers.map(() => '---');
+    const md = [
+      `| ${headers.join(' | ')} |`,
+      `| ${sep.join(' | ')} |`,
+      ...data.map((row) => `| ${row.join(' | ')} |`)
+    ];
+    process.stdout.write(`${md.join('\n')}\n`);
+    return;
+  }
+  process.stdout.write(`${formatTable(headers, data).join('\n')}\n`);
+}
+
+function renderDetail(
+  rows: LedgerRow[],
+  selector: string,
+  format: string,
+  taskDir: string,
+  content: string
+): void {
+  let row: LedgerRow | undefined;
+  if (/^\d+$/.test(selector)) {
+    const idx = Number.parseInt(selector, 10) - 1;
+    if (idx < 0 || idx >= rows.length) {
+      fail(`ordinal '${selector}' out of range (1..${rows.length})`);
+      return;
+    }
+    row = rows[idx];
+  } else {
+    const want = selector.toUpperCase();
+    const matches = rows.filter((r) => r.id.toUpperCase() === want);
+    if (matches.length === 0) {
+      fail(`no decision item matches '${selector}'`);
+      return;
+    }
+    if (matches.length > 1) {
+      fail(`duplicate id '${selector}' in ledger; select by ordinal instead`);
+      return;
+    }
+    row = matches[0];
+  }
+
+  const r = row!;
+  const block = findDetailBlock(r, taskDir);
+  const lines: string[] = [];
+  if (format === 'markdown') {
+    lines.push(`**${r.id}** (${r.stage}/${r.severity}) · status=\`${r.status}\` · evidence: \`${r.evidence}\``, '');
+  } else {
+    lines.push(`${r.id} (${r.stage}/${r.severity}) status=${r.status}`, `evidence: ${r.evidence}`, '');
+  }
+  if (block) {
+    lines.push(block);
+  } else {
+    lines.push(
+      `（详情块未找到：未在任务产物中定位到 \`### ${r.id}\` 锚点，可能为历史产物或尚未写入；evidence 指向 ${r.evidence}）`
+    );
+  }
+  if (r.status === 'human-decided') {
+    const record = findDecisionRecord(r.id, content);
+    if (record.length) {
+      lines.push('', '人工裁定：', ...record);
+    }
+  }
+  process.stdout.write(`${lines.join('\n')}\n`);
+}
+
+function decisions(args: string[] = []): void {
+  if (args[0] === '--help' || args[0] === '-h') {
+    process.stdout.write(USAGE);
+    return;
+  }
+  const parsed = parseArgs(args);
+  if (!parsed) return;
+  if (parsed.positionals.length === 0) {
+    process.stdout.write(USAGE);
+    process.exitCode = 1;
+    return;
+  }
+  if (parsed.stage !== undefined && !STAGES.has(parsed.stage)) {
+    fail(`invalid --stage '${parsed.stage}' (expected analysis|plan|code)`);
+    return;
+  }
+  if (!FORMATS.has(parsed.format)) {
+    fail(`invalid --format '${parsed.format}' (expected text|markdown)`);
+    return;
+  }
+
+  const resolved = resolveTaskRef(parsed.positionals[0]!);
+  if (!resolved.ok) {
+    fail(resolved.message);
+    return;
+  }
+
+  const content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+  let rows = parseLedger(content).filter((r) => HD_ID_RE.test(r.id));
+  rows = rows.filter((r) =>
+    parsed.all ? HUMAN_DECISION_STATUSES.has(r.status) : r.status === 'needs-human-decision'
+  );
+  if (parsed.stage !== undefined) rows = rows.filter((r) => r.stage === parsed.stage);
+
+  const selector = parsed.positionals[1];
+  if (selector === undefined) {
+    renderList(rows, parsed.format, resolved.taskDir);
+  } else {
+    renderDetail(rows, selector, parsed.format, resolved.taskDir, content);
+  }
+}
+
+export { decisions };

package/lib/task/commands/log.ts

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import { formatTable } from '../../table.ts';
 import { resolveTaskRef } from '../resolve-ref.ts';
+import { parseLedger, HUMAN_DECISION_STATUSES, type LedgerRow } from '../ledger.ts';
 
 const USAGE = `Usage: ai task log <N | #N | TASK-id>
 
@@ -20,7 +21,6 @@ const TABLE_HEADERS = ['#', 'STEP', 'AGENT', 'STARTED', 'DONE', 'NOTE'] as const
 
 // The activity-log H2 heading is language-dependent (zh template / en template).
 const HEADING_RE = /^##\s+(活动日志|Activity Log)\s*$/;
-const LEDGER_HEADING_RE = /^##\s+(审查分歧账本|Review Disagreement Ledger)\s*$/;
 const NEXT_H2_RE = /^##\s/;
 // `- {time} — **{step}** by {agent} — {note}` ; the separator is an em-dash
 // (U+2014). STEP/AGENT are non-greedy so a note that itself contains ' — ' or
@@ -30,7 +30,6 @@ const ENTRY_RE =
 
 type LogEntry = { time: string; step: string; agent: string; note: string };
 type ReviewStage = 'analysis' | 'plan' | 'code';
-type LedgerRow = { stage: string; status: string };
 
 // One rendered row = one step instance. `started`/`done` are timestamps; an empty
 // `done` with a non-empty `started` means the step is still in flight, while an
@@ -47,7 +46,6 @@ const STARTED_SUFFIX_RE = /\s*\[started\]\s*$/;
 // note these differ from the `.airc.json` long names claude-code/gemini-cli).
 // Any other executor token (a human name, possibly CJK) is treated as human.
 const KNOWN_AI_AGENTS = new Set(['claude', 'codex', 'gemini', 'opencode', 'cursor']);
-const HUMAN_DECISION_STATUSES = new Set(['needs-human-decision', 'human-decided']);
 const ENV_BLOCKED_RE = /\(\+\s*(\d+)\s+env-blocked\)/i;
 // Same match plus any leading whitespace, so folding the count into the verdict
 // text drops the redundant `(+ n env-blocked)` fragment without leaving a gap.
@@ -111,27 +109,6 @@ function pairEntries(entries: LogEntry[]): StepRow[] {
   return rows;
 }
 
-function parseReviewLedger(content: string): LedgerRow[] {
-  const lines = content.split('\n');
-  let i = 0;
-  while (i < lines.length && !LEDGER_HEADING_RE.test(lines[i]!)) i += 1;
-  if (i >= lines.length) return [];
-
-  const rows: LedgerRow[] = [];
-  for (let j = i + 1; j < lines.length; j += 1) {
-    if (NEXT_H2_RE.test(lines[j]!)) break;
-    const line = lines[j]!.trim();
-    if (!line.startsWith('|')) continue;
-    const cells = line
-      .split('|')
-      .slice(1, -1)
-      .map((cell) => cell.trim());
-    if (cells.length < 6 || cells[0] === 'id' || /^-+$/.test(cells[0] ?? '')) continue;
-    rows.push({ stage: cells[1]!, status: cells[4]! });
-  }
-  return rows;
-}
-
 function countHumanDecisionsByStage(rows: LedgerRow[]): Map<ReviewStage, number> {
   const counts = new Map<ReviewStage, number>();
   for (const row of rows) {
@@ -200,7 +177,7 @@ function log(args: string[] = []): void {
     return;
   }
   const steps = pairEntries(entries);
-  const humanDecisionCounts = countHumanDecisionsByStage(parseReviewLedger(content));
+  const humanDecisionCounts = countHumanDecisionsByStage(parseLedger(content));
   const rows = steps.map((s, idx) => {
     const stage = reviewStageForStep(s.step);
     const note = stage

package/lib/task/index.ts

@@ -2,6 +2,7 @@ const USAGE = `Usage: ai task <command> [options]
 
 Commands:
   cat <ref> <artifact | N>               Print a task artifact (by name or number)
+  decisions, d <ref> [selector]          List human-decision (HD-) items, or show one's detail
   files <ref>                            List artifacts in a task dir (numbered)
   grep <pattern> [ref] [artifact | N]    Literal search across task artifacts (omit ref to scan all)
   issue-body <ref> [--template <path>]   Print a deterministic Issue body from task.md (描述 + 需求, or an Issue Form)
@@ -13,6 +14,8 @@ Commands:
 Examples:
   ai task cat 11 analysis
   ai task cat 11 3
+  ai task decisions 11
+  ai task d 11 HD-3 --format markdown
   ai task files 11
   ai task grep resolveArtifact
   ai task grep resolveArtifact 11
@@ -46,6 +49,12 @@ export async function runTask(args: string[]): Promise<void> {
       cat(rest);
       break;
     }
+    case 'decisions':
+    case 'd': {
+      const { decisions } = await import('./commands/decisions.ts');
+      decisions(rest);
+      break;
+    }
     case 'files': {
       const { files } = await import('./commands/files.ts');
       files(rest);

package/lib/task/ledger.ts

@@ -0,0 +1,73 @@
+// Shared parser for the task.md `## 审查分歧账本` (Review Disagreement Ledger).
+// Single source of truth for ledger row parsing across `ai task` commands
+// (log, decisions) — see the plan's D1 constraint "no third parser". The gate
+// parser in `.agents/scripts/validate-artifact.js` is a separate concern and
+// must be kept semantically in sync by hand (noted in review-handshake.md).
+
+// The ledger H2 heading is language-dependent (zh template / en template).
+const LEDGER_HEADING_RE = /^##\s+(审查分歧账本|Review Disagreement Ledger)\s*$/;
+const NEXT_H2_RE = /^##\s/;
+
+type LedgerRow = {
+  id: string;
+  stage: string;
+  round: string;
+  severity: string;
+  status: string;
+  evidence: string;
+};
+
+// Terminal statuses the completion gates treat as resolved.
+const LEDGER_TERMINAL = new Set(['confirmed', 'closed', 'human-decided']);
+// Statuses that represent an executor-raised human-decision row (pending or done).
+const HUMAN_DECISION_STATUSES = new Set(['needs-human-decision', 'human-decided']);
+
+// Parse all rows of the disagreement ledger table. Skips the heading, the
+// header row (`| id | ... |`) and the `|---|` separator; ignores non-`|` lines.
+// Rows with fewer than 6 columns are skipped (mirrors the JS gate parser).
+function parseLedger(content: string): LedgerRow[] {
+  const lines = content.split('\n');
+  let i = 0;
+  while (i < lines.length && !LEDGER_HEADING_RE.test(lines[i]!)) i += 1;
+  if (i >= lines.length) return [];
+
+  const rows: LedgerRow[] = [];
+  for (let j = i + 1; j < lines.length; j += 1) {
+    if (NEXT_H2_RE.test(lines[j]!)) break;
+    const line = lines[j]!.trim();
+    if (!line.startsWith('|')) continue;
+    const cells = line
+      .split('|')
+      .slice(1, -1)
+      .map((cell) => cell.trim());
+    if (cells.length < 6) continue;
+    if (cells[0] === 'id' || /^-+$/.test(cells[0] ?? '')) continue;
+    rows.push({
+      id: cells[0]!,
+      stage: cells[1]!,
+      round: cells[2]!,
+      severity: cells[3]!,
+      status: cells[4]!,
+      evidence: cells[5]!
+    });
+  }
+  return rows;
+}
+
+// Allocate the next globally-unique human-decision id. Scans every `HD-<n>`
+// already present in the ledger (across all stages) and returns `HD-{max+1}`,
+// or `HD-1` when none exist. Global monotonic allocation prevents id collisions
+// across the analysis / plan / code stages (plan PL-2).
+function nextHdId(rows: readonly LedgerRow[]): string {
+  let max = 0;
+  for (const row of rows) {
+    const m = /^HD-(\d+)$/.exec(row.id);
+    if (!m) continue;
+    const n = Number.parseInt(m[1]!, 10);
+    if (n > max) max = n;
+  }
+  return `HD-${max + 1}`;
+}
+
+export { parseLedger, nextHdId, LEDGER_TERMINAL, HUMAN_DECISION_STATUSES };
+export type { LedgerRow };

package/lib/task/sections.ts

@@ -41,4 +41,33 @@ function findSectionHeading(content: string, aliases: string[]): string {
   return aliases[0]!;
 }
 
-export { extractSection, findSectionHeading };
+/**
+ * Return the body of the first `### {headingPrefix}` sub-section, from the
+ * heading line (inclusive) to the next `### ` / `## ` heading or EOF. Used to
+ * pull a single `### HD-N` human-decision detail block out of an artifact. The
+ * prefix must be followed by a word boundary so `HD-1` does not match `HD-10`
+ * (e.g. `### HD-1`, `### HD-1：标题`, `### HD-1 [needs-human-decision]`). Leading
+ * and trailing blank lines are trimmed. Returns '' when no match is present.
+ */
+function extractSubSection(content: string, headingPrefix: string): string {
+  const lines = content.split('\n');
+  const headRe = new RegExp(`^###\\s+${escapeRegExp(headingPrefix)}(?![\\w-])`);
+  let start = -1;
+  for (let i = 0; i < lines.length; i += 1) {
+    if (headRe.test(lines[i]!.trim())) {
+      start = i;
+      break;
+    }
+  }
+  if (start === -1) return '';
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i += 1) {
+    if (/^###?\s+/.test(lines[i]!)) {
+      end = i;
+      break;
+    }
+  }
+  return lines.slice(start, end).join('\n').replace(/^\n+/, '').replace(/\n+$/, '');
+}
+
+export { extractSection, findSectionHeading, extractSubSection };