@p4pilot/core 0.1.0

package/dist/p4-runner-CmZD1E6u.d.cts

@@ -0,0 +1,69 @@
+type P4Action = "edit" | "add" | "delete" | "branch" | "integrate" | "move/add" | "move/delete";
+interface OpenedFile {
+    depotFile: string;
+    clientFile?: string;
+    rev?: number;
+    action: P4Action;
+    change: string;
+    type: string;
+}
+interface FileStat {
+    depotFile: string;
+    clientFile?: string;
+    headType?: string;
+    headRev?: number;
+    haveRev?: number;
+    action?: P4Action;
+    isOpened: boolean;
+    isTracked: boolean;
+}
+interface ChangelistSummary {
+    change: string;
+    description: string;
+    status: "pending" | "submitted" | "shelved";
+    user?: string;
+    client?: string;
+    files?: string[];
+}
+interface DescribeResult {
+    change: string;
+    description: string;
+    user?: string;
+    files: Array<{
+        depotFile: string;
+        action: P4Action;
+        rev?: number;
+    }>;
+    diff?: string;
+}
+declare class P4PilotError extends Error {
+    readonly code: P4PilotErrorCode;
+    readonly detail?: string | undefined;
+    constructor(message: string, code: P4PilotErrorCode, detail?: string | undefined);
+}
+type P4PilotErrorCode = "P4_NOT_FOUND" | "P4_COMMAND_FAILED" | "NOT_CONNECTED" | "FILE_NOT_IN_CLIENT" | "INVALID_INPUT";
+
+interface P4Result {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+interface P4RunOptions {
+    cwd?: string;
+    input?: string;
+    env?: Record<string, string>;
+}
+interface P4Runner {
+    run(args: string[], opts?: P4RunOptions): Promise<P4Result>;
+}
+interface ExecaP4RunnerOptions {
+    p4Path?: string;
+    env?: Record<string, string>;
+}
+declare class ExecaP4Runner implements P4Runner {
+    #private;
+    constructor(options?: ExecaP4RunnerOptions);
+    run(args: string[], opts?: P4RunOptions): Promise<P4Result>;
+}
+
+export { type ChangelistSummary as C, type DescribeResult as D, ExecaP4Runner as E, type FileStat as F, type OpenedFile as O, type P4Action as P, P4PilotError as a, type P4PilotErrorCode as b, type P4Result as c, type P4RunOptions as d, type P4Runner as e, type ExecaP4RunnerOptions as f };

package/dist/p4-runner-CmZD1E6u.d.ts

@@ -0,0 +1,69 @@
+type P4Action = "edit" | "add" | "delete" | "branch" | "integrate" | "move/add" | "move/delete";
+interface OpenedFile {
+    depotFile: string;
+    clientFile?: string;
+    rev?: number;
+    action: P4Action;
+    change: string;
+    type: string;
+}
+interface FileStat {
+    depotFile: string;
+    clientFile?: string;
+    headType?: string;
+    headRev?: number;
+    haveRev?: number;
+    action?: P4Action;
+    isOpened: boolean;
+    isTracked: boolean;
+}
+interface ChangelistSummary {
+    change: string;
+    description: string;
+    status: "pending" | "submitted" | "shelved";
+    user?: string;
+    client?: string;
+    files?: string[];
+}
+interface DescribeResult {
+    change: string;
+    description: string;
+    user?: string;
+    files: Array<{
+        depotFile: string;
+        action: P4Action;
+        rev?: number;
+    }>;
+    diff?: string;
+}
+declare class P4PilotError extends Error {
+    readonly code: P4PilotErrorCode;
+    readonly detail?: string | undefined;
+    constructor(message: string, code: P4PilotErrorCode, detail?: string | undefined);
+}
+type P4PilotErrorCode = "P4_NOT_FOUND" | "P4_COMMAND_FAILED" | "NOT_CONNECTED" | "FILE_NOT_IN_CLIENT" | "INVALID_INPUT";
+
+interface P4Result {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+interface P4RunOptions {
+    cwd?: string;
+    input?: string;
+    env?: Record<string, string>;
+}
+interface P4Runner {
+    run(args: string[], opts?: P4RunOptions): Promise<P4Result>;
+}
+interface ExecaP4RunnerOptions {
+    p4Path?: string;
+    env?: Record<string, string>;
+}
+declare class ExecaP4Runner implements P4Runner {
+    #private;
+    constructor(options?: ExecaP4RunnerOptions);
+    run(args: string[], opts?: P4RunOptions): Promise<P4Result>;
+}
+
+export { type ChangelistSummary as C, type DescribeResult as D, ExecaP4Runner as E, type FileStat as F, type OpenedFile as O, type P4Action as P, P4PilotError as a, type P4PilotErrorCode as b, type P4Result as c, type P4RunOptions as d, type P4Runner as e, type ExecaP4RunnerOptions as f };

package/dist/testing/mock-runner.cjs

@@ -0,0 +1,411 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/testing/mock-runner.ts
+var mock_runner_exports = {};
+__export(mock_runner_exports, {
+  MockP4Runner: () => MockP4Runner
+});
+module.exports = __toCommonJS(mock_runner_exports);
+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();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MockP4Runner
+});

package/dist/testing/mock-runner.d.cts

@@ -0,0 +1,48 @@
+import { P as P4Action, C as ChangelistSummary, e as P4Runner, d as P4RunOptions, c as P4Result } from '../p4-runner-CmZD1E6u.cjs';
+
+interface FakeFile {
+    depotFile: string;
+    clientFile: string;
+    headType?: string;
+    headRev?: number;
+    sizeBytes?: number;
+    opened?: {
+        action: P4Action;
+        change: string;
+    };
+}
+interface FakeDepotState {
+    root: string;
+    port?: string;
+    client?: string;
+    user?: string;
+    files: FakeFile[];
+    changelists?: ChangelistSummary[];
+}
+declare class MockP4Runner implements P4Runner {
+    #private;
+    constructor(state: FakeDepotState);
+    get state(): FakeDepotState;
+    run(args: string[], opts?: P4RunOptions): Promise<P4Result>;
+    private runInfo;
+    private runFstat;
+    private runOpened;
+    private runEdit;
+    private runAdd;
+    private runRevert;
+    private runWhere;
+    private runChanges;
+    private runDescribe;
+    private runChange;
+    private runSync;
+    private runFilelog;
+    private fileStatFields;
+    private openedFields;
+    private findFiles;
+    private findFile;
+    private matches;
+    private toDepotFile;
+    private parseDescription;
+}
+
+export { type FakeDepotState, type FakeFile, MockP4Runner };

package/dist/testing/mock-runner.d.ts

@@ -0,0 +1,48 @@
+import { P as P4Action, C as ChangelistSummary, e as P4Runner, d as P4RunOptions, c as P4Result } from '../p4-runner-CmZD1E6u.js';
+
+interface FakeFile {
+    depotFile: string;
+    clientFile: string;
+    headType?: string;
+    headRev?: number;
+    sizeBytes?: number;
+    opened?: {
+        action: P4Action;
+        change: string;
+    };
+}
+interface FakeDepotState {
+    root: string;
+    port?: string;
+    client?: string;
+    user?: string;
+    files: FakeFile[];
+    changelists?: ChangelistSummary[];
+}
+declare class MockP4Runner implements P4Runner {
+    #private;
+    constructor(state: FakeDepotState);
+    get state(): FakeDepotState;
+    run(args: string[], opts?: P4RunOptions): Promise<P4Result>;
+    private runInfo;
+    private runFstat;
+    private runOpened;
+    private runEdit;
+    private runAdd;
+    private runRevert;
+    private runWhere;
+    private runChanges;
+    private runDescribe;
+    private runChange;
+    private runSync;
+    private runFilelog;
+    private fileStatFields;
+    private openedFields;
+    private findFiles;
+    private findFile;
+    private matches;
+    private toDepotFile;
+    private parseDescription;
+}
+
+export { type FakeDepotState, type FakeFile, MockP4Runner };

package/dist/testing/mock-runner.js

@@ -0,0 +1,6 @@
+import {
+  MockP4Runner
+} from "../chunk-HLG24B6W.js";
+export {
+  MockP4Runner
+};