ecoportal-api-graphql 1.3.13 → 1.3.16

data/.ai-assistance/scripts/setup-mcps.test.ts

@@ -1,188 +0,0 @@
-#!/usr/bin/env npx ts-node
-/**
- * setup-mcps.test.ts
- * Unit tests for the pure logic in setup-mcps.ts.
- * No external dependencies — uses Node's assert module.
- *
- * Usage:
- *   npx ts-node .ai-assistance/scripts/setup-mcps.test.ts
- *
- * Tests cover:
- *   - parseEnvFile: key=value parsing, comments, blank lines, edge cases
- *   - buildMcpEntries: correct shape for GitKraken + GitLab entries
- *   - mergeConfig: merges, preserves unrelated keys, overwrites same-named entries
- *   - getConfigPath: returns a string containing "Claude" on current platform
- */
-
-import assert from "assert";
-import { parseEnvFile, buildMcpEntries, mergeConfig, getConfigPath } from "./setup-mcps";
-
-// ---------------------------------------------------------------------------
-// Test runner
-// ---------------------------------------------------------------------------
-
-let passed = 0;
-let failed = 0;
-
-function test(name: string, fn: () => void) {
-  try {
-    fn();
-    console.log(`  ✓ ${name}`);
-    passed++;
-  } catch (err: unknown) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.log(`  ✗ ${name}`);
-    console.log(`      ${message}`);
-    failed++;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// parseEnvFile
-// ---------------------------------------------------------------------------
-
-console.log("\nparseEnvFile");
-
-test("parses simple key=value pairs", () => {
-  const result = parseEnvFile("FOO=bar\nBAZ=qux");
-  assert.strictEqual(result["FOO"], "bar");
-  assert.strictEqual(result["BAZ"], "qux");
-});
-
-test("ignores comment lines", () => {
-  const result = parseEnvFile("# this is a comment\nFOO=bar");
-  assert.strictEqual(Object.keys(result).length, 1);
-  assert.strictEqual(result["FOO"], "bar");
-});
-
-test("ignores blank lines", () => {
-  const result = parseEnvFile("\n\nFOO=bar\n\n");
-  assert.strictEqual(Object.keys(result).length, 1);
-});
-
-test("handles values containing = signs", () => {
-  const result = parseEnvFile("URL=https://example.com?foo=bar");
-  assert.strictEqual(result["URL"], "https://example.com?foo=bar");
-});
-
-test("returns empty object for empty input", () => {
-  const result = parseEnvFile("");
-  assert.deepStrictEqual(result, {});
-});
-
-test("returns empty object for comment-only input", () => {
-  const result = parseEnvFile("# just a comment\n# another");
-  assert.deepStrictEqual(result, {});
-});
-
-// ---------------------------------------------------------------------------
-// buildMcpEntries
-// ---------------------------------------------------------------------------
-
-console.log("\nbuildMcpEntries");
-
-test("includes gitkraken entry with correct command", () => {
-  const entries = buildMcpEntries("tok", "https://gitlab.example.com");
-  const gk = entries["gitkraken"] as Record<string, unknown>;
-  assert.strictEqual(gk.command, "gk");
-  assert.deepStrictEqual(gk.args, ["mcp"]);
-});
-
-test("includes gitlab-mr entry with correct command", () => {
-  const entries = buildMcpEntries("tok", "https://gitlab.example.com");
-  const gl = entries["gitlab-mr"] as Record<string, unknown>;
-  assert.strictEqual(gl.command, "npx");
-  assert.deepStrictEqual(gl.args, ["-y", "@kopfrechner/gitlab-mr-mcp"]);
-});
-
-test("injects GITLAB_TOKEN into gitlab-mr env", () => {
-  const entries = buildMcpEntries("my-token", "https://gitlab.example.com");
-  const gl = entries["gitlab-mr"] as { env: Record<string, string> };
-  assert.strictEqual(gl.env["GITLAB_TOKEN"], "my-token");
-});
-
-test("injects GITLAB_URL into gitlab-mr env", () => {
-  const entries = buildMcpEntries("tok", "https://gitlab.example.com");
-  const gl = entries["gitlab-mr"] as { env: Record<string, string> };
-  assert.strictEqual(gl.env["GITLAB_URL"], "https://gitlab.example.com");
-});
-
-test("returns exactly two top-level keys", () => {
-  const entries = buildMcpEntries("tok", "https://gitlab.example.com");
-  assert.strictEqual(Object.keys(entries).length, 2);
-});
-
-// ---------------------------------------------------------------------------
-// mergeConfig
-// ---------------------------------------------------------------------------
-
-console.log("\nmergeConfig");
-
-test("adds mcpServers to empty config", () => {
-  const result = mergeConfig({}, { foo: { command: "foo" } });
-  assert.ok(result.mcpServers);
-  assert.ok((result.mcpServers as Record<string, unknown>)["foo"]);
-});
-
-test("preserves existing top-level keys", () => {
-  const result = mergeConfig({ theme: "dark" }, { foo: {} });
-  assert.strictEqual(result.theme, "dark");
-});
-
-test("preserves existing mcpServers entries not in newEntries", () => {
-  const existing = { mcpServers: { existing: { command: "old" } } };
-  const result = mergeConfig(existing, { newone: { command: "new" } });
-  const servers = result.mcpServers as Record<string, unknown>;
-  assert.ok(servers["existing"]);
-  assert.ok(servers["newone"]);
-});
-
-test("overwrites same-named mcpServers entries", () => {
-  const existing = {
-    mcpServers: { "gitlab-mr": { command: "old", env: { GITLAB_TOKEN: "old-tok" } } },
-  };
-  const result = mergeConfig(existing, {
-    "gitlab-mr": { command: "npx", env: { GITLAB_TOKEN: "new-tok" } },
-  });
-  const gl = (result.mcpServers as Record<string, unknown>)["gitlab-mr"] as {
-    env: Record<string, string>;
-  };
-  assert.strictEqual(gl.env["GITLAB_TOKEN"], "new-tok");
-});
-
-test("handles existing config with no mcpServers key", () => {
-  const result = mergeConfig({ theme: "light" }, { foo: {} });
-  assert.ok((result.mcpServers as Record<string, unknown>)["foo"]);
-  assert.strictEqual(result.theme, "light");
-});
-
-// ---------------------------------------------------------------------------
-// getConfigPath
-// ---------------------------------------------------------------------------
-
-console.log("\ngetConfigPath");
-
-test("returns a non-empty string", () => {
-  const p = getConfigPath();
-  assert.ok(typeof p === "string" && p.length > 0);
-});
-
-test("path contains 'Claude'", () => {
-  const p = getConfigPath();
-  assert.ok(p.includes("Claude"), `Expected path to contain 'Claude', got: ${p}`);
-});
-
-test("path ends with claude_desktop_config.json", () => {
-  const p = getConfigPath();
-  assert.ok(
-    p.endsWith("claude_desktop_config.json"),
-    `Expected path to end with filename, got: ${p}`
-  );
-});
-
-// ---------------------------------------------------------------------------
-// Summary
-// ---------------------------------------------------------------------------
-
-console.log(`\n${passed + failed} tests: ${passed} passed, ${failed} failed\n`);
-if (failed > 0) process.exit(1);

data/.ai-assistance/scripts/setup-mcps.ts

@@ -1,234 +0,0 @@
-#!/usr/bin/env npx ts-node
-/**
- * setup-mcps.ts
- * One-time setup: writes GitKraken and GitLab MCP entries into Claude Desktop's
- * global config (claude_desktop_config.json). Safe to re-run — merges into any
- * existing config without overwriting unrelated entries.
- *
- * Usage:
- *   npx ts-node .ai-assistance/scripts/setup-mcps.ts
- *
- * What it does:
- *   1. Detects OS and locates claude_desktop_config.json
- *   2. Reads GitLab credentials from .env as defaults (no re-entry needed)
- *   3. Prompts to confirm or override each value
- *   4. Backs up the existing config before writing
- *   5. Merges GitKraken + GitLab MCP entries and writes the config
- *   6. Prints verification steps
- *
- * Requirements:
- *   - GitKraken CLI (gk) installed + authenticated:
- *       https://www.gitkraken.com/cli
- *       Run: gk auth login
- *   - GitLab PAT with scopes: read_api, read_repository, create_runner, ai_features
- *       https://gitlab.ecoportal.co.nz/-/user_settings/personal_access_tokens
- *   - Node.js + ts-node:
- *       npm install -g ts-node typescript
- *
- * Expiry note:
- *   Current PAT expires April 2027. Token has rotation enabled — rotate before
- *   expiry and re-run this script with the new token.
- */
-
-import {
-  readFileSync,
-  writeFileSync,
-  existsSync,
-  copyFileSync,
-  mkdirSync,
-} from "fs";
-import { join, dirname } from "path";
-import { createInterface } from "readline";
-import { homedir, platform } from "os";
-
-// ---------------------------------------------------------------------------
-// Pure logic (exported for testing)
-// ---------------------------------------------------------------------------
-
-/** Detect OS-appropriate path to claude_desktop_config.json */
-export function getConfigPath(): string {
-  const p = platform();
-  if (p === "win32") {
-    const appData =
-      process.env.APPDATA ?? join(homedir(), "AppData", "Roaming");
-    return join(appData, "Claude", "claude_desktop_config.json");
-  } else if (p === "darwin") {
-    return join(
-      homedir(),
-      "Library",
-      "Application Support",
-      "Claude",
-      "claude_desktop_config.json"
-    );
-  } else {
-    // Linux fallback
-    return join(homedir(), ".config", "Claude", "claude_desktop_config.json");
-  }
-}
-
-/** Parse KEY=VALUE lines from a .env file. Ignores comments and blank lines. */
-export function parseEnvFile(content: string): Record<string, string> {
-  const env: Record<string, string> = {};
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-    const eq = trimmed.indexOf("=");
-    if (eq === -1) continue;
-    const key = trimmed.slice(0, eq).trim();
-    const value = trimmed.slice(eq + 1).trim();
-    if (key) env[key] = value;
-  }
-  return env;
-}
-
-/** Build the mcpServers block for GitKraken + GitLab. */
-export function buildMcpEntries(
-  gitlabToken: string,
-  gitlabUrl: string
-): Record<string, unknown> {
-  return {
-    gitkraken: {
-      command: "gk",
-      args: ["mcp"],
-    },
-    "gitlab-mr": {
-      command: "npx",
-      args: ["-y", "@kopfrechner/gitlab-mr-mcp"],
-      env: {
-        GITLAB_TOKEN: gitlabToken,
-        GITLAB_URL: gitlabUrl,
-      },
-    },
-  };
-}
-
-/**
- * Merge new MCP entries into an existing config object.
- * Existing mcpServers entries not in newEntries are preserved.
- * Entries in newEntries overwrite same-named existing entries.
- */
-export function mergeConfig(
-  existing: Record<string, unknown>,
-  newEntries: Record<string, unknown>
-): Record<string, unknown> {
-  return {
-    ...existing,
-    mcpServers: {
-      ...((existing.mcpServers as Record<string, unknown>) ?? {}),
-      ...newEntries,
-    },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// I/O helpers
-// ---------------------------------------------------------------------------
-
-function ask(question: string): Promise<string> {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer.trim());
-    });
-  });
-}
-
-function loadEnvDefaults(repoRoot: string): Record<string, string> {
-  const envPath = join(repoRoot, ".env");
-  if (!existsSync(envPath)) return {};
-  return parseEnvFile(readFileSync(envPath, "utf8"));
-}
-
-// ---------------------------------------------------------------------------
-// Main
-// ---------------------------------------------------------------------------
-
-async function main() {
-  // Resolve repo root relative to this script's location
-  const scriptDir = dirname(
-    process.argv[1]
-  );
-  const repoRoot = join(scriptDir, "../..");
-  const configPath = getConfigPath();
-  const env = loadEnvDefaults(repoRoot);
-
-  console.log("\n🔧 Claude Desktop MCP Setup");
-  console.log("============================");
-  console.log(`Config: ${configPath}\n`);
-
-  // Load existing config
-  let existing: Record<string, unknown> = {};
-  if (existsSync(configPath)) {
-    existing = JSON.parse(readFileSync(configPath, "utf8"));
-    const count = Object.keys(
-      (existing.mcpServers as Record<string, unknown>) ?? {}
-    ).length;
-    console.log(`Found existing config with ${count} MCP server(s) — will merge.\n`);
-  } else {
-    console.log("No existing config — will create fresh.\n");
-    mkdirSync(dirname(configPath), { recursive: true });
-  }
-
-  // --- GitLab PAT ---
-  const defaultToken = env["GITLAB_TOKEN"] ?? "";
-  const tokenHint = defaultToken
-    ? `from .env, ends …${defaultToken.slice(-6)}`
-    : "required";
-  const tokenInput = await ask(
-    `GitLab PAT [${tokenHint}] (press Enter to keep): `
-  );
-  const gitlabToken = tokenInput || defaultToken;
-
-  if (!gitlabToken) {
-    console.error(
-      "\n❌ GitLab PAT is required.\n" +
-        "   Create one at: https://gitlab.ecoportal.co.nz/-/user_settings/personal_access_tokens\n" +
-        "   Required scopes: read_api, read_repository, create_runner, ai_features\n" +
-        "   Enable token rotation. Current expiry: April 2027.\n"
-    );
-    process.exit(1);
-  }
-
-  // --- GitLab URL ---
-  const defaultUrl =
-    env["GITLAB_URL"] ?? "https://gitlab.ecoportal.co.nz";
-  const urlInput = await ask(`GitLab URL [${defaultUrl}]: `);
-  const gitlabUrl = urlInput || defaultUrl;
-
-  // --- Build + merge ---
-  const newEntries = buildMcpEntries(gitlabToken, gitlabUrl);
-  const merged = mergeConfig(existing, newEntries);
-
-  // --- Backup ---
-  if (existsSync(configPath)) {
-    const backupPath = configPath + ".backup";
-    copyFileSync(configPath, backupPath);
-    console.log(`\n✓ Backed up to ${backupPath}`);
-  }
-
-  // --- Write ---
-  writeFileSync(configPath, JSON.stringify(merged, null, 2) + "\n", "utf8");
-  console.log(`✓ Written to ${configPath}`);
-
-  console.log(`
-✅ Done! Next steps:
-
-  1. Restart Claude Desktop (fully quit and reopen)
-
-  2. Verify GitKraken — ask Claude:
-       "What branch am I on in ecoportal-api-graphql?"
-     First use opens a browser for GitKraken OAuth — approve it.
-
-  3. Verify GitLab — ask Claude:
-       "List open merge requests in ecoportal-api-graphql"
-
-  Note: if GitKraken (gk) isn't installed yet:
-    https://www.gitkraken.com/cli  →  gk auth login
-`);
-}
-
-main().catch((err) => {
-  console.error("\n❌ Setup failed:", err.message);
-  process.exit(1);
-});

data/.ai-assistance/scripts/task-complete.ts

@@ -1,74 +0,0 @@
-#!/usr/bin/env npx ts-node
-/**
- * task-complete.ts
- * Writes an outbox file and archives the inbox+outbox pair.
- * Called by Code after finishing a bridge task.
- *
- * Usage:
- *   npx ts-node .ai-assistance/scripts/task-complete.ts \
- *     --task oscar-a3f2b1c-list-open-mrs.md \
- *     --status done \
- *     --result "Branch: feature/auth. Open MRs: 3 ..." \
- *     --notes "GitLab plugin authenticated OK"
- */
-
-import { writeFileSync, renameSync, readFileSync, mkdirSync, existsSync } from "fs";
-import { join, dirname } from "path";
-
-const args = process.argv.slice(2);
-const get = (flag: string, required = true): string | undefined => {
-  const i = args.indexOf(flag);
-  if (i === -1 || i + 1 >= args.length) {
-    if (required) { console.error(`Missing required argument: ${flag}`); process.exit(1); }
-    return undefined;
-  }
-  return args[i + 1];
-};
-
-const taskFile = get("--task")!;
-const status = (get("--status")! as string).toUpperCase(); // DONE or FAILED
-const result = get("--result")!;
-const notes = get("--notes", false) ?? "";
-
-const scriptDir = dirname(process.argv[1]);
-const bridgeDir = join(scriptDir, "../bridge");
-const inboxPath = join(bridgeDir, "inbox", taskFile);
-const outboxDir = join(bridgeDir, "outbox");
-const archiveDir = join(bridgeDir, "archive");
-
-if (!existsSync(inboxPath)) {
-  console.error(`Inbox task not found: ${inboxPath}`);
-  process.exit(1);
-}
-
-mkdirSync(outboxDir, { recursive: true });
-mkdirSync(archiveDir, { recursive: true });
-
-// Read title from inbox
-const inboxContent = readFileSync(inboxPath, "utf8");
-const titleMatch = inboxContent.match(/^# TASK: (.+)$/m);
-const title = titleMatch?.[1] ?? taskFile;
-
-// Write outbox
-const timestamp = new Date().toISOString();
-const outboxContent = `# TASK: ${title}
-STATUS: ${status}
-COMPLETED: ${timestamp}
-FROM: code
-TO: cowork
-
-## Result
-${result}
-
-## Notes
-${notes || "(none)"}
-`;
-
-const outboxPath = join(outboxDir, taskFile);
-writeFileSync(outboxPath, outboxContent, "utf8");
-
-// Archive both files
-renameSync(inboxPath, join(archiveDir, `inbox-${taskFile}`));
-renameSync(outboxPath, join(archiveDir, `outbox-${taskFile}`));
-
-console.log(JSON.stringify({ archived: taskFile, status, timestamp }));

data/.ai-assistance/scripts/task-create.ts

@@ -1,75 +0,0 @@
-#!/usr/bin/env npx ts-node
-/**
- * task-create.ts
- * Creates a new bridge inbox task file with correct naming and format.
- * Keeps token usage low — agents call this instead of composing files manually.
- *
- * Usage:
- *   npx ts-node .ai-assistance/scripts/task-create.ts \
- *     --title "List open MRs" \
- *     --request "Run git branch --show-current, then list open MRs via GitLab plugin" \
- *     --expected "Branch name + MR table" \
- *     --from cowork \
- *     --to code \
- *     --user oscar
- */
-
-import { writeFileSync, mkdirSync } from "fs";
-import { join, dirname } from "path";
-import { randomUUID } from "crypto";
-
-// --- Parse args ---
-const args = process.argv.slice(2);
-const get = (flag: string): string => {
-  const i = args.indexOf(flag);
-  if (i === -1 || i + 1 >= args.length) {
-    console.error(`Missing required argument: ${flag}`);
-    process.exit(1);
-  }
-  return args[i + 1];
-};
-
-const title = get("--title");
-const request = get("--request");
-const expected = get("--expected");
-const from = get("--from");
-const to = get("--to");
-const user = get("--user");
-const context = args.includes("--context") ? get("--context") : "";
-
-// --- Generate filename ---
-const uuid7 = randomUUID().replace(/-/g, "").slice(0, 7);
-const slug = title
-  .toLowerCase()
-  .replace(/[^a-z0-9\s-]/g, "")
-  .trim()
-  .replace(/\s+/g, "-")
-  .slice(0, 40);
-const filename = `${user}-${uuid7}-${slug}.md`;
-
-// --- Build file content ---
-const timestamp = new Date().toISOString();
-const content = `# TASK: ${title}
-STATUS: PENDING
-CREATED: ${timestamp}
-FROM: ${from}
-TO: ${to}
-
-## Context
-${context || "(none provided)"}
-
-## Request
-${request}
-
-## Expected output
-${expected}
-`;
-
-// --- Write file ---
-const scriptDir = dirname(process.argv[1]);
-const inboxDir = join(scriptDir, "../bridge/inbox");
-mkdirSync(inboxDir, { recursive: true });
-const filePath = join(inboxDir, filename);
-writeFileSync(filePath, content, "utf8");
-
-console.log(JSON.stringify({ created: filename, path: filePath }));

data/.ai-assistance/scripts/task-read.ts

@@ -1,125 +0,0 @@
-#!/usr/bin/env npx ts-node
-/**
- * task-read.ts
- * Parse a bridge task file (inbox, outbox, or archive) and output structured JSON.
- * Saves agents from reading raw Markdown — reduces token overhead for every task fetch.
- *
- * Usage:
- *   npx ts-node .ai-assistance/scripts/task-read.ts --task oscar-a3f2b1c-list-open-mrs.md
- *   npx ts-node .ai-assistance/scripts/task-read.ts --file /absolute/path/to/file.md
- *   npx ts-node .ai-assistance/scripts/task-read.ts --task oscar-abc.md --dir outbox
- *
- * Output (always to stdout):
- *   {
- *     "title":    "List open MRs",
- *     "status":   "DONE",
- *     "created":  "2026-06-07T10:00:00Z",
- *     "from":     "cowork",
- *     "to":       "code",
- *     "context":  "...",
- *     "request":  "...",
- *     "expected": "...",
- *     "result":   "...",
- *     "notes":    "...",
- *     "raw_path": "/absolute/path/to/file.md"
- *   }
- *
- * Missing sections are returned as empty strings, not null.
- * Exits 1 with {"error":"..."} if file not found or unreadable.
- */
-
-import { readFileSync, existsSync } from "fs";
-import { join, dirname, resolve } from "path";
-
-// ---------------------------------------------------------------------------
-// Argument parsing
-// ---------------------------------------------------------------------------
-const args = process.argv.slice(2);
-const get = (flag: string): string | undefined => {
-  const i = args.indexOf(flag);
-  return i !== -1 && i + 1 < args.length ? args[i + 1] : undefined;
-};
-
-const taskFile = get("--task");
-const filePath = get("--file");
-const dir      = get("--dir") ?? "inbox"; // inbox | outbox | archive
-
-const scriptDir  = dirname(process.argv[1]);
-const bridgeDir  = join(scriptDir, "../bridge");
-
-let resolvedPath: string;
-
-if (filePath) {
-  resolvedPath = resolve(filePath);
-} else if (taskFile) {
-  // Try the specified dir first, then inbox, outbox, and archive variants
-  const seen = new Set<string>();
-  const unique = (p: string) => { seen.add(p); return p; };
-  const candidates = [
-    unique(join(bridgeDir, dir,       taskFile)),
-    unique(join(bridgeDir, "inbox",   taskFile)),
-    unique(join(bridgeDir, "outbox",  taskFile)),
-    unique(join(bridgeDir, "archive", taskFile)),
-    unique(join(bridgeDir, "archive", `inbox-${taskFile}`)),
-    unique(join(bridgeDir, "archive", `outbox-${taskFile}`)),
-  ].filter((p, i, arr) => arr.indexOf(p) === i); // deduplicate
-
-  const found = candidates.find(p => existsSync(p));
-  if (!found) {
-    console.log(JSON.stringify({ error: `Task file not found: ${taskFile}`, searched: candidates }));
-    process.exit(1);
-  }
-  resolvedPath = found;
-} else {
-  console.log(JSON.stringify({ error: "Provide --task <filename> or --file <path>" }));
-  process.exit(1);
-}
-
-if (!existsSync(resolvedPath)) {
-  console.log(JSON.stringify({ error: `File not found: ${resolvedPath}` }));
-  process.exit(1);
-}
-
-// ---------------------------------------------------------------------------
-// Parse
-// ---------------------------------------------------------------------------
-const raw = readFileSync(resolvedPath, "utf8");
-
-/** Extract a header field like "STATUS: PENDING" → "PENDING" */
-function header(key: string): string {
-  const m = raw.match(new RegExp(`^${key}:\\s*(.+)$`, "m"));
-  return m ? m[1].trim() : "";
-}
-
-/** Extract a Markdown section body (between ## Heading and the next ## or EOF) */
-function section(heading: string): string {
-  const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  // Match the heading line (## Heading...\n) then capture everything until the next ## or EOF
-  const headingRe = new RegExp(`^##\\s+${escaped}[^\\n]*\\n`, "m");
-  const headingMatch = headingRe.exec(raw);
-  if (!headingMatch) return "";
-  const contentStart = headingMatch.index + headingMatch[0].length;
-  const rest = raw.slice(contentStart);
-  const nextSection = /^## /m.exec(rest);
-  return rest.slice(0, nextSection ? nextSection.index : rest.length).trim();
-}
-
-// Title: "# TASK: My title"
-const titleMatch = raw.match(/^#\s+TASK:\s+(.+)$/m);
-const title = titleMatch ? titleMatch[1].trim() : "";
-
-const result = {
-  title,
-  status:   header("STATUS"),
-  created:  header("CREATED"),
-  from:     header("FROM"),
-  to:       header("TO"),
-  context:  section("Context"),
-  request:  section("Request"),
-  expected: section("Expected output"),
-  result:   section("Result"),
-  notes:    section("Notes"),
-  raw_path: resolvedPath,
-};
-
-console.log(JSON.stringify(result, null, 2));