@pi-unipi/kanboard 2.20.4 → 3.0.0-alpha.0

package/src/settings.ts

@@ -0,0 +1,158 @@
+/**
+ * @pi-unipi/kanboard — settings (hub section "Kanboard").
+ */
+
+import { getSettings, registerCommandRunner, registerSettings, setSettings } from "@pi-unipi/core";
+
+export type ChainGate = "in_review" | "done";
+
+export interface KanboardSettings {
+  /** Which dependency status counts as "the chain reached this task". */
+  chainGate: ChainGate;
+  /** Passed to `serve --idle-min`. */
+  idleMin: number;
+  /** Passed to `serve --host` (127.0.0.1 = local only). */
+  host: string;
+  /** Passed to `serve --port` (0 = OS-assigned). */
+  port: number;
+  /** Auto-archive done/cancelled tasks after N days (0 = off). */
+  archiveAfterDays: number;
+  /** Move archived/cancelled tasks to cold storage after N days (0 = off). */
+  retentionDays: number;
+  /** Open the board in a browser on `open` (default off). */
+  openBrowser: boolean;
+  /** Token-gate loopback binds too (remote always needs it). */
+  requireAuth: boolean;
+  /** Reuse <home>/token so board links survive daemon restarts. */
+  keepToken: boolean;
+  /** Tasks one session may queue (0 = unlimited). */
+  queueMax: number;
+  /** Distinct sessions running tasks per project (min 1). */
+  maxSessions: number;
+  /** `add` calls allowed per -do/runner window (0 = unlimited). */
+  turnAddLimit: number;
+}
+
+export const DEFAULT_SETTINGS: KanboardSettings = {
+  chainGate: "in_review",
+  idleMin: 10,
+  host: "127.0.0.1",
+  port: 0,
+  archiveAfterDays: 0,
+  retentionDays: 90,
+  openBrowser: false,
+  requireAuth: false,
+  keepToken: false,
+  queueMax: 10,
+  maxSessions: 2,
+  turnAddLimit: 20,
+};
+
+export const KANBOARD_NAMESPACE = "kanboard";
+
+/** Runners the hub's action rows call (registered by index.ts). */
+export const ACTION_OPEN = "unipi:kanboard-open";
+export const ACTION_STOP_DAEMON = "unipi:kanboard-stop-daemon";
+export const ACTION_ROTATE_TOKEN = "unipi:kanboard-rotate-token";
+
+export function registerKanboardSettings(): void {
+  registerSettings({
+    namespace: KANBOARD_NAMESPACE,
+    label: "Kanboard",
+    defaults: DEFAULT_SETTINGS as unknown as Record<string, unknown>,
+    schema: [
+      {
+        title: "Kanboard",
+        description: "Deferred-work board: task runner, daemon and skill",
+        fields: [
+          {
+            key: "chainGate",
+            type: "enum",
+            label: "Chain gate",
+            options: [
+              { value: "in_review", label: "in_review (next task starts when this one is reviewed)" },
+              { value: "done", label: "done (next task waits for a completed dependency)" },
+            ],
+            description: "When a dependency counts as satisfied for the next task",
+          },
+          { key: "idleMin", type: "number", label: "Daemon idle minutes", min: 1, description: "Shut the daemon down after this long with no board open" },
+          {
+            key: "host",
+            type: "string",
+            label: "Bind address",
+            emptyLabel: "127.0.0.1 (local only)",
+            hint: "127.0.0.1 · 0.0.0.0 (LAN, token-gated) · tailscale (tailnet IP)",
+            description: "Anything but a loopback address requires an access token",
+          },
+          { key: "port", type: "number", label: "Daemon port", min: 0, max: 65535, zeroLabel: "auto", description: "0 lets the OS pick a free port" },
+          { key: "archiveAfterDays", type: "number", label: "Archive after (days)", min: 0, zeroLabel: "off", description: "Auto-archive done/cancelled tasks on session start" },
+          { key: "retentionDays", type: "number", label: "Cold storage after (days)", min: 0, zeroLabel: "off", description: "Move archived/cancelled tasks to cold storage — files stay readable, the board drops them" },
+          { key: "openBrowser", type: "boolean", label: "Open the browser", description: "Open the board in a browser when /unipi:kanboard opens it" },
+          {
+            key: "requireAuth",
+            type: "boolean",
+            label: "Require the access token on localhost too",
+            description: "Remote binds always need the token; this adds it for 127.0.0.1. Applies on the next daemon start.",
+          },
+          {
+            key: "keepToken",
+            type: "boolean",
+            label: "Keep the access token across restarts",
+            description: "Reuse one token so board links stay valid; rotate it below.",
+          },
+          { key: "queueMax", type: "number", label: "-do queue limit", min: 0, zeroLabel: "unlimited", description: "Tasks a session may queue for the runner" },
+          { key: "maxSessions", type: "number", label: "Sessions working at once (per project)", min: 1, description: "Distinct sessions holding in_progress tasks" },
+          { key: "turnAddLimit", type: "number", label: "New tasks per turn", min: 0, zeroLabel: "unlimited", description: "`add` calls allowed per -do turn or runner task" },
+          { key: "open", type: "action", label: "Open board…", description: "Start the daemon and print the URL", command: ACTION_OPEN },
+          { key: "stopDaemon", type: "action", label: "Stop daemon", description: "Terminate the running kanboard daemon", command: ACTION_STOP_DAEMON },
+          { key: "rotateToken", type: "action", label: "Rotate access token", description: "Drop the persistent token; a fresh one mints on the next daemon start", command: ACTION_ROTATE_TOKEN },
+        ],
+      },
+    ],
+  });
+}
+
+export function readKanboardSettings(cwd: string = process.cwd()): KanboardSettings {
+  const raw = getSettings(KANBOARD_NAMESPACE, cwd);
+  return {
+    chainGate: raw.chainGate === "done" ? "done" : "in_review",
+    idleMin: typeof raw.idleMin === "number" && raw.idleMin >= 1 ? raw.idleMin : DEFAULT_SETTINGS.idleMin,
+    host:
+      typeof raw.host === "string" && raw.host.trim().length > 0 ? raw.host.trim() : DEFAULT_SETTINGS.host,
+    port: typeof raw.port === "number" && raw.port >= 0 && raw.port <= 65535 ? raw.port : 0,
+    archiveAfterDays:
+      typeof raw.archiveAfterDays === "number" && raw.archiveAfterDays > 0 ? raw.archiveAfterDays : 0,
+    retentionDays:
+      typeof raw.retentionDays === "number" && raw.retentionDays >= 0 ? raw.retentionDays : DEFAULT_SETTINGS.retentionDays,
+    openBrowser: raw.openBrowser === true,
+    requireAuth: raw.requireAuth === true,
+    keepToken: raw.keepToken === true,
+    queueMax: typeof raw.queueMax === "number" && raw.queueMax >= 0 ? raw.queueMax : DEFAULT_SETTINGS.queueMax,
+    maxSessions: typeof raw.maxSessions === "number" && raw.maxSessions >= 1 ? raw.maxSessions : DEFAULT_SETTINGS.maxSessions,
+    turnAddLimit: typeof raw.turnAddLimit === "number" && raw.turnAddLimit >= 0 ? raw.turnAddLimit : DEFAULT_SETTINGS.turnAddLimit,
+  };
+}
+
+export function writeKanboardSettings(patch: Partial<KanboardSettings>, cwd: string): void {
+  setSettings(KANBOARD_NAMESPACE, patch as unknown as Record<string, unknown>, "global", cwd);
+}
+
+/** Re-exported so index.ts and tests share one registration path. */
+export function registerKanboardRunners(runners: {
+  open: (ctx: unknown) => void | Promise<void>;
+  stopDaemon: (ctx: unknown) => void | Promise<void>;
+  rotateToken?: (ctx: unknown) => void | Promise<void>;
+}): void {
+  registerCommandRunner(ACTION_OPEN, runners.open);
+  registerCommandRunner(ACTION_STOP_DAEMON, runners.stopDaemon);
+  if (runners.rotateToken) registerCommandRunner(ACTION_ROTATE_TOKEN, runners.rotateToken);
+}
+
+/**
+ * Limits reach the Rust CLI through the environment — refresh the process-wide
+ * values so the agent's bash calls and the runner's CLI calls both see them.
+ */
+export function applyLimitEnv(settings: KanboardSettings): void {
+  process.env.UNIPI_KANBOARD_QUEUE_MAX = String(settings.queueMax);
+  process.env.UNIPI_KANBOARD_MAX_SESSIONS = String(settings.maxSessions);
+}

package/src/shapes.ts

@@ -0,0 +1,220 @@
+/**
+ * @pi-unipi/kanboard — the CLI's JSON contract.
+ *
+ * Every shape the extension consumes is validated here instead of being cast,
+ * so a change on the Rust side fails loudly (and the contract test in
+ * `tests/contract.test.ts` feeds the real binary's output through these
+ * functions). K4 changed `list --json` from an array to `{tasks, problems}` and
+ * a stale cast silently broke the runner with "all.map is not a function".
+ */
+
+export class KanboardShapeError extends Error {
+  readonly command: string;
+
+  constructor(command: string, detail: string) {
+    super(`unexpected ${command} output: ${detail} — the extension and the binary disagree (version mismatch?)`);
+    this.name = "KanboardShapeError";
+    this.command = command;
+  }
+}
+
+export interface KanboardProblem {
+  file: string;
+  line: number;
+  error: string;
+  fixable?: boolean;
+}
+
+export interface KanboardRun {
+  session?: string;
+  pid?: number;
+  host?: string;
+  mode?: string;
+  goal?: string | null;
+  started?: string;
+}
+
+export interface KanboardActivity {
+  at: string;
+  actor: string;
+  text: string;
+}
+
+export interface KanboardTask {
+  id: string;
+  title: string;
+  body?: string;
+  status: string;
+  priority?: string;
+  order?: number;
+  deps?: string[];
+  labels?: string[];
+  run?: KanboardRun | null;
+  activity?: KanboardActivity[];
+  ready?: boolean;
+  waitingFor?: string[];
+  /** Deps still in Backlog (or missing): only a human can schedule them. */
+  lockedBy?: string[];
+  staleness?: string;
+  allowedMoves?: string[];
+  [key: string]: unknown;
+}
+
+export interface KanboardProject {
+  slug: string;
+  name: string;
+  root?: string;
+  prefix?: string;
+  nextId?: number;
+  createdAt?: string;
+  counts?: Record<string, number>;
+  total?: number;
+  problems?: KanboardProblem[];
+}
+
+export interface KanboardClaim {
+  task: KanboardTask | null;
+  waiting?: Array<{ id: string; waitingFor?: string[]; lockedBy?: string[] }>;
+}
+
+export interface KanboardStop {
+  stopped: boolean;
+  pid?: number;
+  reason?: string;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function requireRecord(command: string, value: unknown): Record<string, unknown> {
+  if (!isRecord(value)) {
+    throw new KanboardShapeError(command, `expected an object, got ${Array.isArray(value) ? "an array" : typeof value}`);
+  }
+  return value;
+}
+
+function requireString(command: string, record: Record<string, unknown>, key: string): string {
+  const value = record[key];
+  if (typeof value !== "string") {
+    throw new KanboardShapeError(command, `missing string "${key}"`);
+  }
+  return value;
+}
+
+function optionalArray<T>(value: unknown): T[] | undefined {
+  return Array.isArray(value) ? (value as T[]) : undefined;
+}
+
+/** `show …, add …, move …, note …, release …` → one task. */
+export function asTask(command: string, value: unknown): KanboardTask {
+  const record = requireRecord(command, value);
+  return {
+    ...record,
+    id: requireString(command, record, "id"),
+    title: requireString(command, record, "title"),
+    status: requireString(command, record, "status"),
+    deps: optionalArray<string>(record.deps) ?? [],
+    activity: optionalArray<KanboardActivity>(record.activity) ?? [],
+  } as KanboardTask;
+}
+
+export function asTaskList(value: unknown): { tasks: KanboardTask[]; problems: KanboardProblem[] } {
+  if (Array.isArray(value)) {
+    // Exactly the K4 regression: the runner cast the old array shape.
+    throw new KanboardShapeError("list", "an array here means the binary is older than the extension");
+  }
+  const record = requireRecord("list", value);
+  if (!Array.isArray(record.tasks)) {
+    throw new KanboardShapeError("list", 'expected {tasks: [...], problems: [...]}');
+  }
+  const tasks = record.tasks.map((entry) => asTask("list", entry));
+  const problems = (optionalArray<KanboardProblem>(record.problems) ?? []).map((problem) => ({
+    file: String(problem.file ?? ""),
+    line: Number(problem.line ?? 0),
+    error: String(problem.error ?? ""),
+    fixable: problem.fixable === true,
+  }));
+  return { tasks, problems };
+}
+
+/** `claim-next` → `{task: <task|null>, waiting: [...]}`. */
+export function asClaimResult(value: unknown): KanboardClaim {
+  const record = requireRecord("claim-next", value);
+  if (!("task" in record)) {
+    throw new KanboardShapeError("claim-next", 'missing "task"');
+  }
+  const waiting = (optionalArray<{ id: string; waitingFor?: unknown; lockedBy?: unknown }>(record.waiting) ?? []).map((entry) => ({
+    id: String(entry.id ?? ""),
+    waitingFor: optionalArray<string>(entry.waitingFor) ?? [],
+    lockedBy: optionalArray<string>(entry.lockedBy) ?? [],
+  }));
+  return {
+    task: record.task === null ? null : asTask("claim-next", record.task),
+    waiting,
+  };
+}
+
+export function asProject(command: string, value: unknown): KanboardProject {
+  const record = requireRecord(command, value);
+  return {
+    ...record,
+    slug: requireString(command, record, "slug"),
+    name: requireString(command, record, "name"),
+  } as KanboardProject;
+}
+
+export function asProjectList(value: unknown): KanboardProject[] {
+  if (!Array.isArray(value)) {
+    throw new KanboardShapeError("project list", `expected an array, got ${typeof value}`);
+  }
+  return value.map((entry) => asProject("project list", entry));
+}
+
+/** `project show` → `{project, counts, total, problems}`. */
+export function asProjectDetail(value: unknown): KanboardProject & { total: number } {
+  const record = requireRecord("project show", value);
+  const project = asProject("project show", record.project);
+  return {
+    ...project,
+    counts: isRecord(record.counts) ? (record.counts as Record<string, number>) : {},
+    total: typeof record.total === "number" ? record.total : 0,
+    problems: optionalArray<KanboardProblem>(record.problems) ?? [],
+  };
+}
+
+export function asStopResult(value: unknown): KanboardStop {
+  const record = requireRecord("stop", value);
+  if (typeof record.stopped !== "boolean") {
+    throw new KanboardShapeError("stop", 'missing boolean "stopped"');
+  }
+  return {
+    stopped: record.stopped,
+    pid: typeof record.pid === "number" ? record.pid : undefined,
+    reason: typeof record.reason === "string" ? record.reason : undefined,
+  };
+}
+
+/** `status` → `{daemon, alive, home}` (the extension reads daemon.json itself, but tests pin the shape). */
+export function asDaemonStatus(value: unknown): { daemon: Record<string, unknown> | null; alive: boolean; home?: string } {
+  const record = requireRecord("status", value);
+  const daemon = record.daemon;
+  if (daemon !== null && !isRecord(daemon)) {
+    throw new KanboardShapeError("status", '"daemon" must be an object or null');
+  }
+  return {
+    daemon: (daemon as Record<string, unknown> | null) ?? null,
+    alive: record.alive === true,
+    home: typeof record.home === "string" ? record.home : undefined,
+  };
+}
+
+/** `validate` → `{ok, problems, fixed}`. */
+export function asValidateResult(value: unknown): { ok: boolean; problems: KanboardProblem[]; fixed: string[] } {
+  const record = requireRecord("validate", value);
+  return {
+    ok: record.ok === true,
+    problems: optionalArray<KanboardProblem>(record.problems) ?? [],
+    fixed: optionalArray<string>(record.fixed) ?? [],
+  };
+}

package/commands.ts

@@ -1,83 +0,0 @@
-/**
- * @pi-unipi/kanboard — Command Registration
- *
- * Registers kanboard and kanboard-doctor commands.
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { UNIPI_PREFIX, KANBOARD_COMMANDS, KANBOARD_DIRS, UNIPI_EVENTS, emitEvent } from "@pi-unipi/core";
-import { startServer, KanboardServer } from "./server/index.js";
-
-/** Module-level reference to running server */
-let runningServer: KanboardServer | null = null;
-
-/** Check if a kanboard server is running via PID file */
-function isPidFileRunning(pidFile: string): boolean {
-  try {
-    if (!fs.existsSync(pidFile)) return false;
-    const pid = parseInt(fs.readFileSync(pidFile, "utf-8").trim(), 10);
-    if (isNaN(pid)) return false;
-    process.kill(pid, 0); // Check if process exists
-    return true;
-  } catch {
-    // Process doesn't exist or can't access PID file
-    try {
-       fs.unlinkSync(pidFile);
-    } catch {}
-    return false;
-  }
-}
-
-/** Register kanboard commands */
-export function registerCommands(pi: ExtensionAPI): void {
-  // kanboard — Toggle server start/stop
-  pi.registerCommand(
-    `${UNIPI_PREFIX}${KANBOARD_COMMANDS.KANBOARD}`,
-    {
-      description: "Toggle kanboard visualization server",
-      handler: async (_args: string, ctx: ExtensionCommandContext) => {
-        const pidFile = path.resolve(KANBOARD_DIRS.PID_FILE);
-
-        try {
-          // Case 1: We have a live reference in this process
-          if (runningServer) {
-            runningServer.stop();
-            runningServer = null;
-            ctx.ui.notify("Kanboard stopped", "info");
-            return;
-          }
-
-          // Case 2: PID file shows a running instance (from previous process)
-          if (isPidFileRunning(pidFile)) {
-            // PID file exists but we don't have a reference — stale or external.
-            // Remove stale PID file and let user know.
-            try { fs.unlinkSync(pidFile); } catch {}
-            ctx.ui.notify("Kanboard was running in a previous session. PID file cleaned. Run again to start fresh.", "info");
-            return;
-          }
-
-          // Case 3: No running instance — start fresh
-          const { server, url } = await startServer();
-          runningServer = server;
-          ctx.ui.notify(`Kanboard running at ${url}`, "info");
-        } catch (err: unknown) {
-          ctx.ui.notify(`Kanboard error: ${err instanceof Error ? err.message : String(err)}`, "error");
-        }
-      },
-    },
-  );
-
-  // kanboard-doctor — Load doctor skill
-  pi.registerCommand(
-    `${UNIPI_PREFIX}${KANBOARD_COMMANDS.KANBOARD_DOCTOR}`,
-    {
-      description: "Diagnose and fix kanboard parser issues",
-      handler: async (_args: string, ctx: ExtensionCommandContext) => {
-        ctx.ui.notify("Loading kanboard-doctor skill...", "info");
-        // The skill will be loaded by the skill system via resources_discover
-      },
-    },
-  );
-}

package/parser/checkbox-parser.ts

@@ -1,165 +0,0 @@
-/**
- * @pi-unipi/kanboard — Config-driven checkbox document parser
- *
- * Replaces 7 separate parser classes (Spec, QuickWork, Debug, Fix, Chore, Review,
- * and the checkbox-extraction half of Milestone) with one config-driven class.
- * Each doc type is just: path regex + type label + command string + checkbox pattern.
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { DocParser, ParsedDoc, ParsedItem, DocType } from "../types.js";
-import { parseFrontmatter } from "./frontmatter.js";
-
-/** Config for a checkbox-based document type. */
-interface CheckboxDocConfig {
-  /** Document type label */
-  type: DocType;
-  /** Path regex to match (e.g. /\/specs\//) */
-  pathRegex: RegExp;
-  /** Command string for parsed items */
-  command: string | ((fileName: string) => string);
-  /** Whether to also extract ## headers as items (default: false) */
-  extractHeaders?: boolean;
-  /** Status for header items (default: "todo") */
-  headerStatus?: "todo" | "done";
-  /** Extra metadata fields to include */
-  extraMetadata?: (metadata: Record<string, string>) => Record<string, string>;
-  /** Custom title extraction (default: metadata.title ?? fileName) */
-  titleExtractor?: (metadata: Record<string, string>, fileName: string) => string;
-}
-
-const CHECKBOX_PATTERN = /^\s*-\s*\[([ xX])\]\s*(.*)$/;
-const HEADER_PATTERN = /^##\s+(.+)$/;
-
-/** Config-driven parser for checkbox-style documents. */
-export class CheckboxParser implements DocParser {
-  constructor(private config: CheckboxDocConfig) {}
-
-  canParse(filePath: string): boolean {
-    return this.config.pathRegex.test(filePath) && filePath.endsWith(".md");
-  }
-
-  parse(filePath: string): ParsedDoc {
-    const warnings: string[] = [];
-    const items: ParsedItem[] = [];
-    let content: string;
-
-    try {
-      content = fs.readFileSync(filePath, "utf-8");
-    } catch (err: unknown) {
-      warnings.push(`Could not read file: ${err instanceof Error ? err.message : String(err)}`);
-      return this.emptyDoc(filePath, warnings);
-    }
-
-    const { metadata, bodyStart } = parseFrontmatter(content);
-    const lines = content.split("\n");
-    const fileName = path.basename(filePath);
-    const cmd = typeof this.config.command === "function"
-      ? this.config.command(fileName)
-      : this.config.command;
-
-    for (let i = bodyStart; i < lines.length; i++) {
-      const line = lines[i];
-      const lineNum = i + 1;
-
-      // Match ## headers if configured
-      if (this.config.extractHeaders) {
-        const headerMatch = line.match(HEADER_PATTERN);
-        if (headerMatch) {
-          items.push({
-            text: headerMatch[1].trim(),
-            status: this.config.headerStatus ?? "todo",
-            lineNumber: lineNum,
-            sourceFile: fileName,
-            command: cmd,
-          });
-        }
-      }
-
-      // Match checklist items
-      const checkboxMatch = line.match(CHECKBOX_PATTERN);
-      if (checkboxMatch) {
-        const checked = checkboxMatch[1].toLowerCase() === "x";
-        const text = checkboxMatch[2].trim();
-        if (text) {
-          items.push({
-            text,
-            status: checked ? "done" : "todo",
-            lineNumber: lineNum,
-            sourceFile: fileName,
-            command: cmd,
-          });
-        }
-      }
-    }
-
-    const title = this.config.titleExtractor
-      ? this.config.titleExtractor(metadata, fileName)
-      : (metadata.title ?? fileName.replace(/\.md$/, ""));
-
-    const finalMetadata = this.config.extraMetadata
-      ? this.config.extraMetadata(metadata)
-      : metadata;
-
-    return {
-      type: this.config.type,
-      title,
-      filePath,
-      items,
-      metadata: finalMetadata,
-      warnings,
-    };
-  }
-
-  private emptyDoc(filePath: string, warnings: string[]): ParsedDoc {
-    return {
-      type: this.config.type,
-      title: path.basename(filePath).replace(/\.md$/, ""),
-      filePath,
-      items: [],
-      metadata: {},
-      warnings,
-    };
-  }
-}
-
-/** All checkbox doc configs — drives the 6 simple parsers. */
-export const CHECKBOX_DOC_CONFIGS: CheckboxDocConfig[] = [
-  {
-    type: "spec",
-    pathRegex: /\/specs\//,
-    command: (f) => `/unipi:plan specs:${f}`,
-  },
-  {
-    type: "quick-work",
-    pathRegex: /\/quick-work\//,
-    command: "/unipi:quick-work",
-  },
-  {
-    type: "debug",
-    pathRegex: /\/debug\//,
-    command: (f) => `/unipi:fix debug:${f}`,
-    extractHeaders: true,
-    headerStatus: "todo",
-  },
-  {
-    type: "fix",
-    pathRegex: /\/fix\//,
-    command: "/unipi:fix",
-    extractHeaders: true,
-    headerStatus: "done",
-    extraMetadata: (m) => ({ ...m, related_debug: m.related_debug ?? m.debug ?? "" }),
-  },
-  {
-    type: "chore",
-    pathRegex: /\/chore\//,
-    command: (f) => `/unipi:chore-execute chore:${f}`,
-    titleExtractor: (m, f) => m.title ?? m.name ?? f.replace(/\.md$/, ""),
-  },
-  {
-    type: "review",
-    pathRegex: /\/reviews\//,
-    command: "/unipi:review-work",
-  },
-];

package/parser/frontmatter.ts

@@ -1,26 +0,0 @@
-/** Shared frontmatter parser for kanboard document parsers. */
-
-/** Parse frontmatter from markdown content.
- * Returns metadata key-value pairs and the line number where the body starts. */
-export function parseFrontmatter(content: string): {
-  metadata: Record<string, string>;
-  bodyStart: number;
-} {
-  const metadata: Record<string, string> = {};
-  const lines = content.split("\n");
-
-  if (lines[0]?.trim() !== "---") return { metadata, bodyStart: 0 };
-
-  for (let i = 1; i < lines.length; i++) {
-    const line = lines[i];
-    if (line.trim() === "---") {
-      return { metadata, bodyStart: i + 1 };
-    }
-    const match = line.match(/^(\w[\w-]*):\s*(.*)$/);
-    if (match) {
-      metadata[match[1]] = match[2].trim();
-    }
-  }
-
-  return { metadata, bodyStart: 0 };
-}