@p4pilot/core 0.1.0

package/dist/browser.d.cts

@@ -0,0 +1,3 @@
+export { C as ChangelistSummary, D as DescribeResult, F as FileStat, O as OpenedFile, P as P4Action, a as P4PilotError, b as P4PilotErrorCode, c as P4Result, d as P4RunOptions, e as P4Runner } from './p4-runner-CmZD1E6u.cjs';
+export { A as AssetClassification, a as AssetGuardConfig, b as AssetKind, C as CheckoutResult, c as CheckoutStatus, D as DEFAULT_ASSET_GUARD_CONFIG, F as FilelogEntry, P as P4Client, Z as ZtagRecord, d as buildChangelistDescription, e as classifyAsset, f as ensureOpenForEdit, g as ensureOpenForEditMany, h as groupIndexed, p as parseZtag } from './changelist-D-VWhdnq.cjs';
+export { FakeDepotState, FakeFile, MockP4Runner } from './testing/mock-runner.cjs';

package/dist/browser.d.ts

@@ -0,0 +1,3 @@
+export { C as ChangelistSummary, D as DescribeResult, F as FileStat, O as OpenedFile, P as P4Action, a as P4PilotError, b as P4PilotErrorCode, c as P4Result, d as P4RunOptions, e as P4Runner } from './p4-runner-CmZD1E6u.js';
+export { A as AssetClassification, a as AssetGuardConfig, b as AssetKind, C as CheckoutResult, c as CheckoutStatus, D as DEFAULT_ASSET_GUARD_CONFIG, F as FilelogEntry, P as P4Client, Z as ZtagRecord, d as buildChangelistDescription, e as classifyAsset, f as ensureOpenForEdit, g as ensureOpenForEditMany, h as groupIndexed, p as parseZtag } from './changelist-BD8jDKA6.js';
+export { FakeDepotState, FakeFile, MockP4Runner } from './testing/mock-runner.js';

package/dist/browser.js

@@ -0,0 +1,26 @@
+import {
+  DEFAULT_ASSET_GUARD_CONFIG,
+  P4Client,
+  P4PilotError,
+  buildChangelistDescription,
+  classifyAsset,
+  ensureOpenForEdit,
+  ensureOpenForEditMany,
+  groupIndexed,
+  parseZtag
+} from "./chunk-QIZ2GXWH.js";
+import {
+  MockP4Runner
+} from "./chunk-HLG24B6W.js";
+export {
+  DEFAULT_ASSET_GUARD_CONFIG,
+  MockP4Runner,
+  P4Client,
+  P4PilotError,
+  buildChangelistDescription,
+  classifyAsset,
+  ensureOpenForEdit,
+  ensureOpenForEditMany,
+  groupIndexed,
+  parseZtag
+};

package/dist/changelist-BD8jDKA6.d.ts

@@ -0,0 +1,123 @@
+import { P as P4Action, e as P4Runner, O as OpenedFile, F as FileStat, C as ChangelistSummary, D as DescribeResult } from './p4-runner-CmZD1E6u.js';
+
+type ZtagRecord = Map<string, string>;
+declare function parseZtag(stdout: string): ZtagRecord[];
+declare function groupIndexed(record: ZtagRecord): Record<string, string | string[]>;
+
+/** A single revision entry returned by {@link P4Client.filelog}. */
+interface FilelogEntry {
+    rev: number;
+    change: string;
+    action: P4Action;
+    user: string;
+    description: string;
+}
+/**
+ * Typed wrapper over a {@link P4Runner}. Each method builds `p4` args, runs them,
+ * parses the `-ztag` output, and maps it to a domain type. Non-zero exits raise
+ * a {@link P4PilotError} with code `P4_COMMAND_FAILED`.
+ */
+declare class P4Client {
+    #private;
+    constructor(runner: P4Runner);
+    info(): Promise<Record<string, string>>;
+    opened(opts?: {
+        changelist?: string;
+    }): Promise<OpenedFile[]>;
+    fstat(files: string[]): Promise<FileStat[]>;
+    edit(files: string[], opts?: {
+        changelist?: string;
+    }): Promise<OpenedFile[]>;
+    add(files: string[], opts?: {
+        changelist?: string;
+    }): Promise<OpenedFile[]>;
+    deleteFiles(files: string[], opts?: {
+        changelist?: string;
+    }): Promise<OpenedFile[]>;
+    revert(files: string[]): Promise<string[]>;
+    sync(paths?: string[]): Promise<{
+        synced: number;
+    }>;
+    where(file: string): Promise<{
+        depotFile: string;
+        clientFile: string;
+        path: string;
+    }>;
+    changes(opts?: {
+        status?: "pending" | "submitted";
+        max?: number;
+        user?: string;
+    }): Promise<ChangelistSummary[]>;
+    describe(change: string, opts?: {
+        diff?: boolean;
+    }): Promise<DescribeResult>;
+    filelog(file: string, opts?: {
+        max?: number;
+    }): Promise<FilelogEntry[]>;
+    newChangelist(description: string): Promise<string>;
+    reopen(files: string[], changelist: string): Promise<OpenedFile[]>;
+}
+
+/** How p4pilot classifies a file for agent consumption. */
+type AssetKind = "text" | "binary" | "large-asset";
+interface AssetClassification {
+    path: string;
+    kind: AssetKind;
+    /** p4 filetype when known (e.g. "text", "binary+l"). */
+    filetype?: string;
+    sizeBytes?: number;
+    /** True only for text — agents should not read binary/large-asset bytes. */
+    shouldRead: boolean;
+    reason: string;
+}
+interface AssetGuardConfig {
+    binaryExtensions: string[];
+    largeAssetExtensions: string[];
+    maxTextBytes: number;
+}
+declare const DEFAULT_ASSET_GUARD_CONFIG: AssetGuardConfig;
+/**
+ * Classify a file so an agent knows whether to read its bytes. Decision order:
+ * large-asset extension → binary p4 filetype → binary extension → oversized → text.
+ */
+declare function classifyAsset(path: string, opts?: {
+    stat?: FileStat;
+    sizeBytes?: number;
+    config?: Partial<AssetGuardConfig>;
+}): AssetClassification;
+
+type CheckoutStatus = "already-open" | "opened" | "added" | "skipped-untracked-ignored";
+interface CheckoutResult {
+    path: string;
+    status: CheckoutStatus;
+    action?: P4Action;
+    changelist?: string;
+    asset?: AssetClassification;
+}
+/**
+ * Ensure `localPath` is open for edit before an agent modifies it.
+ *
+ * fstat the file, then: already open → "already-open"; tracked in depot →
+ * `p4 edit` → "opened"; otherwise (new file) → `p4 add` → "added". Attaches to
+ * `opts.changelist` when provided, and classifies the file so hosts can warn
+ * on binary edits.
+ */
+declare function ensureOpenForEdit(client: P4Client, localPath: string, opts?: {
+    changelist?: string;
+    assetConfig?: Partial<AssetGuardConfig>;
+}): Promise<CheckoutResult>;
+/**
+ * Batch variant. Preserves input order and never lets one bad file abort the
+ * rest — a failure yields a `skipped-untracked-ignored` result for that path.
+ */
+declare function ensureOpenForEditMany(client: P4Client, localPaths: string[], opts?: {
+    changelist?: string;
+}): Promise<CheckoutResult[]>;
+
+/**
+ * Build a changelist description from an agent's task intent, prefixing it so
+ * p4pilot-created changelists are recognizable. Never double-prefixes.
+ */
+declare function buildChangelistDescription(intent: string, prefix?: string): string;
+
+export { type AssetClassification as A, type CheckoutResult as C, DEFAULT_ASSET_GUARD_CONFIG as D, type FilelogEntry as F, P4Client as P, type ZtagRecord as Z, type AssetGuardConfig as a, type AssetKind as b, type CheckoutStatus as c, buildChangelistDescription as d, classifyAsset as e, ensureOpenForEdit as f, ensureOpenForEditMany as g, groupIndexed as h, parseZtag as p };

package/dist/changelist-D-VWhdnq.d.cts

@@ -0,0 +1,123 @@
+import { P as P4Action, e as P4Runner, O as OpenedFile, F as FileStat, C as ChangelistSummary, D as DescribeResult } from './p4-runner-CmZD1E6u.cjs';
+
+type ZtagRecord = Map<string, string>;
+declare function parseZtag(stdout: string): ZtagRecord[];
+declare function groupIndexed(record: ZtagRecord): Record<string, string | string[]>;
+
+/** A single revision entry returned by {@link P4Client.filelog}. */
+interface FilelogEntry {
+    rev: number;
+    change: string;
+    action: P4Action;
+    user: string;
+    description: string;
+}
+/**
+ * Typed wrapper over a {@link P4Runner}. Each method builds `p4` args, runs them,
+ * parses the `-ztag` output, and maps it to a domain type. Non-zero exits raise
+ * a {@link P4PilotError} with code `P4_COMMAND_FAILED`.
+ */
+declare class P4Client {
+    #private;
+    constructor(runner: P4Runner);
+    info(): Promise<Record<string, string>>;
+    opened(opts?: {
+        changelist?: string;
+    }): Promise<OpenedFile[]>;
+    fstat(files: string[]): Promise<FileStat[]>;
+    edit(files: string[], opts?: {
+        changelist?: string;
+    }): Promise<OpenedFile[]>;
+    add(files: string[], opts?: {
+        changelist?: string;
+    }): Promise<OpenedFile[]>;
+    deleteFiles(files: string[], opts?: {
+        changelist?: string;
+    }): Promise<OpenedFile[]>;
+    revert(files: string[]): Promise<string[]>;
+    sync(paths?: string[]): Promise<{
+        synced: number;
+    }>;
+    where(file: string): Promise<{
+        depotFile: string;
+        clientFile: string;
+        path: string;
+    }>;
+    changes(opts?: {
+        status?: "pending" | "submitted";
+        max?: number;
+        user?: string;
+    }): Promise<ChangelistSummary[]>;
+    describe(change: string, opts?: {
+        diff?: boolean;
+    }): Promise<DescribeResult>;
+    filelog(file: string, opts?: {
+        max?: number;
+    }): Promise<FilelogEntry[]>;
+    newChangelist(description: string): Promise<string>;
+    reopen(files: string[], changelist: string): Promise<OpenedFile[]>;
+}
+
+/** How p4pilot classifies a file for agent consumption. */
+type AssetKind = "text" | "binary" | "large-asset";
+interface AssetClassification {
+    path: string;
+    kind: AssetKind;
+    /** p4 filetype when known (e.g. "text", "binary+l"). */
+    filetype?: string;
+    sizeBytes?: number;
+    /** True only for text — agents should not read binary/large-asset bytes. */
+    shouldRead: boolean;
+    reason: string;
+}
+interface AssetGuardConfig {
+    binaryExtensions: string[];
+    largeAssetExtensions: string[];
+    maxTextBytes: number;
+}
+declare const DEFAULT_ASSET_GUARD_CONFIG: AssetGuardConfig;
+/**
+ * Classify a file so an agent knows whether to read its bytes. Decision order:
+ * large-asset extension → binary p4 filetype → binary extension → oversized → text.
+ */
+declare function classifyAsset(path: string, opts?: {
+    stat?: FileStat;
+    sizeBytes?: number;
+    config?: Partial<AssetGuardConfig>;
+}): AssetClassification;
+
+type CheckoutStatus = "already-open" | "opened" | "added" | "skipped-untracked-ignored";
+interface CheckoutResult {
+    path: string;
+    status: CheckoutStatus;
+    action?: P4Action;
+    changelist?: string;
+    asset?: AssetClassification;
+}
+/**
+ * Ensure `localPath` is open for edit before an agent modifies it.
+ *
+ * fstat the file, then: already open → "already-open"; tracked in depot →
+ * `p4 edit` → "opened"; otherwise (new file) → `p4 add` → "added". Attaches to
+ * `opts.changelist` when provided, and classifies the file so hosts can warn
+ * on binary edits.
+ */
+declare function ensureOpenForEdit(client: P4Client, localPath: string, opts?: {
+    changelist?: string;
+    assetConfig?: Partial<AssetGuardConfig>;
+}): Promise<CheckoutResult>;
+/**
+ * Batch variant. Preserves input order and never lets one bad file abort the
+ * rest — a failure yields a `skipped-untracked-ignored` result for that path.
+ */
+declare function ensureOpenForEditMany(client: P4Client, localPaths: string[], opts?: {
+    changelist?: string;
+}): Promise<CheckoutResult[]>;
+
+/**
+ * Build a changelist description from an agent's task intent, prefixing it so
+ * p4pilot-created changelists are recognizable. Never double-prefixes.
+ */
+declare function buildChangelistDescription(intent: string, prefix?: string): string;
+
+export { type AssetClassification as A, type CheckoutResult as C, DEFAULT_ASSET_GUARD_CONFIG as D, type FilelogEntry as F, P4Client as P, type ZtagRecord as Z, type AssetGuardConfig as a, type AssetKind as b, type CheckoutStatus as c, buildChangelistDescription as d, classifyAsset as e, ensureOpenForEdit as f, ensureOpenForEditMany as g, groupIndexed as h, parseZtag as p };

package/dist/chunk-HLG24B6W.js

@@ -0,0 +1,387 @@
+// src/testing/mock-runner.ts
+var success = (stdout = "") => ({
+  stdout,
+  stderr: "",
+  exitCode: 0
+});
+var failure = (stderr) => ({
+  stdout: "",
+  stderr,
+  exitCode: 1
+});
+function formatRecord(fields) {
+  return fields.filter(
+    (field) => field[1] !== void 0
+  ).map(([key, rawValue]) => {
+    const [firstLine = "", ...continuationLines] = String(rawValue).split("\n");
+    return [`... ${key} ${firstLine}`, ...continuationLines].join("\n");
+  }).join("\n");
+}
+function formatRecords(records) {
+  if (records.length === 0) {
+    return "";
+  }
+  return `${records.map(formatRecord).join("\n\n")}
+`;
+}
+function normalizePath(value) {
+  return value.replaceAll("\\", "/");
+}
+function relativePosix(from, to) {
+  const fromParts = from.replace(/\/+$/, "").split("/").filter(Boolean);
+  const toParts = to.split("/").filter(Boolean);
+  let i = 0;
+  while (i < fromParts.length && i < toParts.length && fromParts[i] === toParts[i])
+    i += 1;
+  const up = fromParts.slice(i).map(() => "..");
+  return [...up, ...toParts.slice(i)].join("/");
+}
+function parseCommandFiles(args) {
+  let change = "default";
+  const files = [];
+  for (let index = 1; index < args.length; index += 1) {
+    const argument = args[index];
+    if (argument === void 0) {
+      continue;
+    }
+    if (argument === "-c") {
+      change = args[index + 1] ?? "default";
+      index += 1;
+    } else if (!argument.startsWith("-")) {
+      files.push(argument);
+    }
+  }
+  return { change, files };
+}
+var MockP4Runner = class {
+  #state;
+  constructor(state) {
+    this.#state = state;
+  }
+  get state() {
+    return this.#state;
+  }
+  async run(args, opts) {
+    const commandArgs = args[0] === "-ztag" ? args.slice(1) : [...args];
+    const command = commandArgs[0];
+    switch (command) {
+      case "info":
+        return this.runInfo();
+      case "fstat":
+        return this.runFstat(commandArgs);
+      case "opened":
+        return this.runOpened(commandArgs);
+      case "edit":
+        return this.runEdit(commandArgs);
+      case "add":
+        return this.runAdd(commandArgs);
+      case "revert":
+        return this.runRevert(commandArgs);
+      case "where":
+        return this.runWhere(commandArgs);
+      case "changes":
+        return this.runChanges(commandArgs);
+      case "describe":
+        return this.runDescribe(commandArgs);
+      case "change":
+        return this.runChange(commandArgs, opts);
+      case "sync":
+        return this.runSync();
+      case "filelog":
+        return this.runFilelog(commandArgs);
+      default:
+        return failure(`Unsupported mock p4 command: ${command ?? ""}`);
+    }
+  }
+  runInfo() {
+    return success(
+      formatRecords([
+        [
+          ["userName", this.#state.user],
+          ["clientName", this.#state.client],
+          ["clientRoot", this.#state.root],
+          ["serverAddress", this.#state.port]
+        ]
+      ])
+    );
+  }
+  runFstat(args) {
+    const requested = args.slice(1).filter((argument) => !argument.startsWith("-"));
+    const files = requested.length === 0 ? this.#state.files : requested.flatMap((file) => this.findFiles(file));
+    return success(
+      formatRecords(files.map((file) => this.fileStatFields(file)))
+    );
+  }
+  runOpened(args) {
+    const { files } = parseCommandFiles(args);
+    const changeIndex = args.indexOf("-c");
+    const requestedChange = changeIndex === -1 ? void 0 : args[changeIndex + 1];
+    const openedFiles = this.#state.files.filter((file) => {
+      if (file.opened === void 0) {
+        return false;
+      }
+      if (requestedChange !== void 0 && file.opened.change !== requestedChange) {
+        return false;
+      }
+      return files.length === 0 || files.some((requested) => this.matches(file, requested));
+    });
+    return success(
+      formatRecords(openedFiles.map((file) => this.openedFields(file)))
+    );
+  }
+  runEdit(args) {
+    const { change, files } = parseCommandFiles(args);
+    const edited = [];
+    for (const requested of files) {
+      const file = this.findFile(requested);
+      if (file === void 0 || file.headRev === void 0) {
+        return failure(`${requested} - no such file(s).`);
+      }
+      file.opened = { action: "edit", change };
+      edited.push(file);
+    }
+    return success(
+      formatRecords(edited.map((file) => this.openedFields(file)))
+    );
+  }
+  runAdd(args) {
+    const { change, files } = parseCommandFiles(args);
+    const added = [];
+    for (const requested of files) {
+      let file = this.findFile(requested);
+      if (file === void 0) {
+        const clientFile = normalizePath(requested);
+        file = {
+          depotFile: this.toDepotFile(clientFile),
+          clientFile,
+          headType: "text"
+        };
+        this.#state.files.push(file);
+      }
+      file.opened = { action: "add", change };
+      added.push(file);
+    }
+    return success(formatRecords(added.map((file) => this.openedFields(file))));
+  }
+  runRevert(args) {
+    const { files } = parseCommandFiles(args);
+    const reverted = [];
+    for (const requested of files) {
+      const fileIndex = this.#state.files.findIndex(
+        (file2) => this.matches(file2, requested)
+      );
+      const file = this.#state.files[fileIndex];
+      if (file === void 0 || file.opened === void 0) {
+        continue;
+      }
+      reverted.push([["depotFile", file.depotFile]]);
+      if (file.opened.action === "add" && file.headRev === void 0) {
+        this.#state.files.splice(fileIndex, 1);
+      } else {
+        delete file.opened;
+      }
+    }
+    return success(formatRecords(reverted));
+  }
+  runWhere(args) {
+    const requested = args.find(
+      (argument, index) => index > 0 && !argument.startsWith("-")
+    );
+    const file = requested === void 0 ? void 0 : this.findFile(requested);
+    if (file === void 0) {
+      return failure(`${requested ?? ""} - file(s) not in client view.`);
+    }
+    return success(
+      formatRecords([
+        [
+          ["depotFile", file.depotFile],
+          ["clientFile", file.clientFile],
+          ["path", file.clientFile]
+        ]
+      ])
+    );
+  }
+  runChanges(args) {
+    let status;
+    let max;
+    for (let index = 1; index < args.length; index += 1) {
+      if (args[index] === "-s") {
+        status = args[index + 1];
+        index += 1;
+      } else if (args[index] === "-m") {
+        max = Number(args[index + 1]);
+        index += 1;
+      }
+    }
+    let changelists = [...this.#state.changelists ?? []];
+    if (status !== void 0) {
+      changelists = changelists.filter(
+        (changelist) => changelist.status === status
+      );
+    }
+    if (max !== void 0 && Number.isFinite(max)) {
+      changelists = changelists.slice(0, max);
+    }
+    return success(
+      formatRecords(
+        changelists.map((changelist) => [
+          ["change", changelist.change],
+          ["desc", changelist.description],
+          ["status", changelist.status],
+          ["user", changelist.user],
+          ["client", changelist.client]
+        ])
+      )
+    );
+  }
+  runDescribe(args) {
+    const change = [...args].reverse().find((argument) => !argument.startsWith("-"));
+    const changelist = this.#state.changelists?.find(
+      (item) => item.change === change
+    );
+    if (changelist === void 0) {
+      return failure(`Change ${change ?? ""} unknown.`);
+    }
+    const fields = [
+      ["change", changelist.change],
+      ["desc", changelist.description],
+      ["user", changelist.user],
+      ["status", changelist.status]
+    ];
+    for (const [index, depotFile] of (changelist.files ?? []).entries()) {
+      const file = this.findFile(depotFile);
+      fields.push([`depotFile${index}`, depotFile]);
+      fields.push([`action${index}`, file?.opened?.action ?? "edit"]);
+      fields.push([`rev${index}`, file?.headRev]);
+    }
+    return success(formatRecords([fields]));
+  }
+  runChange(args, opts) {
+    if (!args.includes("-i")) {
+      return failure("MockP4Runner only supports change -i.");
+    }
+    const changelists = this.#state.changelists ?? [];
+    this.#state.changelists = changelists;
+    const nextChange = String(
+      changelists.reduce((highest, changelist) => {
+        const value = Number(changelist.change);
+        return Number.isFinite(value) ? Math.max(highest, value) : highest;
+      }, 0) + 1
+    );
+    const description = this.parseDescription(opts?.input ?? "");
+    changelists.push({
+      change: nextChange,
+      description,
+      status: "pending",
+      user: this.#state.user,
+      client: this.#state.client,
+      files: []
+    });
+    return success(formatRecords([[["change", nextChange]]]));
+  }
+  runSync() {
+    const records = this.#state.files.filter((file) => file.headRev !== void 0).map((file) => [
+      ["depotFile", file.depotFile],
+      ["rev", file.headRev]
+    ]);
+    return success(formatRecords(records));
+  }
+  runFilelog(args) {
+    const files = [];
+    for (let index = 1; index < args.length; index += 1) {
+      const argument = args[index];
+      if (argument === "-m") {
+        index += 1;
+      } else if (argument !== void 0 && !argument.startsWith("-")) {
+        files.push(argument);
+      }
+    }
+    const requested = files[0];
+    const file = requested === void 0 ? void 0 : this.findFile(requested);
+    if (file === void 0 || file.headRev === void 0) {
+      return failure(`${requested ?? ""} - no such file(s).`);
+    }
+    const fields = [
+      ["depotFile", file.depotFile],
+      ["rev0", file.headRev],
+      ["change0", "1"],
+      ["action0", "add"],
+      ["user0", this.#state.user],
+      ["desc0", "initial revision"]
+    ];
+    return success(formatRecords([fields]));
+  }
+  fileStatFields(file) {
+    return [
+      ["depotFile", file.depotFile],
+      ["clientFile", file.clientFile],
+      ["headType", file.headType],
+      ["headRev", file.headRev],
+      ["fileSize", file.sizeBytes],
+      ["action", file.opened?.action],
+      ["change", file.opened?.change]
+    ];
+  }
+  openedFields(file) {
+    return [
+      ["depotFile", file.depotFile],
+      ["clientFile", file.clientFile],
+      ["rev", file.headRev],
+      ["action", file.opened?.action],
+      ["change", file.opened?.change],
+      ["type", file.headType ?? "text"]
+    ];
+  }
+  findFiles(requested) {
+    return this.#state.files.filter((file) => this.matches(file, requested));
+  }
+  findFile(requested) {
+    return this.#state.files.find((file) => this.matches(file, requested));
+  }
+  matches(file, requested) {
+    const normalized = normalizePath(requested);
+    if (normalized.endsWith("/...")) {
+      const prefix = normalized.slice(0, -3);
+      return normalizePath(file.clientFile).startsWith(prefix) || file.depotFile.startsWith(prefix);
+    }
+    return normalizePath(file.clientFile) === normalized || file.depotFile === normalized;
+  }
+  toDepotFile(clientFile) {
+    const normalizedRoot = normalizePath(this.#state.root).replace(/\/$/, "");
+    const relative = relativePosix(normalizedRoot, clientFile);
+    const trackedFile = this.#state.files.find(
+      (file) => file.headRev !== void 0
+    );
+    if (trackedFile !== void 0) {
+      const trackedRelative = relativePosix(
+        normalizedRoot,
+        normalizePath(trackedFile.clientFile)
+      );
+      const suffix = `/${trackedRelative}`;
+      const depotRoot = trackedFile.depotFile.endsWith(suffix) ? trackedFile.depotFile.slice(0, -suffix.length) : "//depot";
+      return `${depotRoot}/${relative}`;
+    }
+    return `//depot/${relative}`;
+  }
+  parseDescription(input) {
+    const lines = input.split(/\r?\n/);
+    const descriptionIndex = lines.findIndex(
+      (line) => line.startsWith("Description:")
+    );
+    if (descriptionIndex === -1) {
+      return "";
+    }
+    const descriptionLines = [];
+    for (const line of lines.slice(descriptionIndex + 1)) {
+      if (/^[A-Za-z][A-Za-z0-9-]*:/.test(line)) {
+        break;
+      }
+      descriptionLines.push(line.replace(/^\t/, ""));
+    }
+    return descriptionLines.join("\n").trim();
+  }
+};
+
+export {
+  MockP4Runner
+};