@p4pilot/core 0.1.0

package/dist/chunk-QIZ2GXWH.js

@@ -0,0 +1,453 @@
+// src/types.ts
+var P4PilotError = class extends Error {
+  constructor(message, code, detail) {
+    super(message);
+    this.code = code;
+    this.detail = detail;
+    this.name = "P4PilotError";
+  }
+  code;
+  detail;
+};
+
+// src/ztag.ts
+function parseZtag(stdout) {
+  const records = [];
+  let record = /* @__PURE__ */ new Map();
+  let previousKey;
+  const finishRecord = () => {
+    if (record.size > 0) {
+      records.push(record);
+      record = /* @__PURE__ */ new Map();
+    }
+    previousKey = void 0;
+  };
+  for (const line of stdout.split(/\r?\n/)) {
+    if (line.length === 0) {
+      finishRecord();
+    } else if (line.startsWith("... ")) {
+      const field = line.slice(4);
+      const separatorIndex = field.indexOf(" ");
+      const key = separatorIndex === -1 ? field : field.slice(0, separatorIndex);
+      const value = separatorIndex === -1 ? "" : field.slice(separatorIndex + 1);
+      record.set(key, value);
+      previousKey = key;
+    } else if (previousKey !== void 0) {
+      const previousValue = record.get(previousKey) ?? "";
+      record.set(previousKey, `${previousValue}
+${line}`);
+    }
+  }
+  finishRecord();
+  return records;
+}
+function groupIndexed(record) {
+  const grouped = {};
+  const indexed = /* @__PURE__ */ new Map();
+  for (const [key, value] of record) {
+    const match = /^(.*?)(\d+)$/.exec(key);
+    const baseKey = match?.[1];
+    const indexText = match?.[2];
+    if (baseKey === void 0 || indexText === void 0) {
+      grouped[key] = value;
+      continue;
+    }
+    const values = indexed.get(baseKey) ?? [];
+    values.push({ index: Number(indexText), value });
+    indexed.set(baseKey, values);
+  }
+  for (const [key, values] of indexed) {
+    grouped[key] = values.sort((left, right) => left.index - right.index).map(({ value }) => value);
+  }
+  return grouped;
+}
+
+// src/p4-client.ts
+var CHANGE_CREATED = /Change (\d+) created/;
+function num(value) {
+  return value === void 0 ? void 0 : Number(value);
+}
+function str(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asArray(value) {
+  if (value === void 0) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function toOpenedFile(record) {
+  return {
+    depotFile: record.get("depotFile") ?? "",
+    clientFile: record.get("clientFile"),
+    rev: num(record.get("rev")),
+    action: record.get("action") ?? "edit",
+    change: record.get("change") ?? "default",
+    type: record.get("type") ?? "text"
+  };
+}
+function toFileStat(record) {
+  const headRev = num(record.get("headRev"));
+  const action = record.get("action");
+  return {
+    depotFile: record.get("depotFile") ?? "",
+    clientFile: record.get("clientFile"),
+    headType: record.get("headType"),
+    headRev,
+    haveRev: num(record.get("haveRev")),
+    action,
+    isOpened: action !== void 0,
+    isTracked: headRev !== void 0
+  };
+}
+function toChangelistSummary(record) {
+  const status = record.get("status");
+  return {
+    change: record.get("change") ?? "",
+    description: record.get("desc") ?? "",
+    status: status === "submitted" || status === "shelved" ? status : "pending",
+    user: record.get("user"),
+    client: record.get("client")
+  };
+}
+var P4Client = class {
+  #runner;
+  constructor(runner) {
+    this.#runner = runner;
+  }
+  async #run(args, opts) {
+    const result = await this.#runner.run(args, opts);
+    if (result.exitCode !== 0) {
+      throw new P4PilotError(
+        `p4 ${args.join(" ")} failed`,
+        "P4_COMMAND_FAILED",
+        result.stderr.trim() || result.stdout.trim()
+      );
+    }
+    return result;
+  }
+  async info() {
+    const { stdout } = await this.#run(["info"]);
+    const record = parseZtag(stdout)[0];
+    const info = {};
+    if (record) {
+      for (const [key, value] of record) {
+        info[key] = value;
+      }
+    }
+    return info;
+  }
+  async opened(opts) {
+    const args = ["opened"];
+    if (opts?.changelist) args.push("-c", opts.changelist);
+    const { stdout } = await this.#run(args);
+    return parseZtag(stdout).map(toOpenedFile);
+  }
+  async fstat(files) {
+    if (files.length === 0) return [];
+    const { stdout } = await this.#run(["fstat", ...files]);
+    return parseZtag(stdout).map(toFileStat);
+  }
+  async edit(files, opts) {
+    return this.#openOp("edit", files, opts);
+  }
+  async add(files, opts) {
+    return this.#openOp("add", files, opts);
+  }
+  async deleteFiles(files, opts) {
+    return this.#openOp("delete", files, opts);
+  }
+  async #openOp(command, files, opts) {
+    if (files.length === 0) return [];
+    const args = [command];
+    if (opts?.changelist) args.push("-c", opts.changelist);
+    args.push(...files);
+    const { stdout } = await this.#run(args);
+    return parseZtag(stdout).map(toOpenedFile);
+  }
+  async revert(files) {
+    if (files.length === 0) return [];
+    const { stdout } = await this.#run(["revert", ...files]);
+    return parseZtag(stdout).map((record) => record.get("depotFile") ?? "").filter((depotFile) => depotFile.length > 0);
+  }
+  async sync(paths) {
+    const args = ["sync"];
+    if (paths && paths.length > 0) args.push(...paths);
+    const { stdout } = await this.#run(args);
+    return { synced: parseZtag(stdout).length };
+  }
+  async where(file) {
+    const { stdout } = await this.#run(["where", file]);
+    const record = parseZtag(stdout)[0];
+    if (!record) {
+      throw new P4PilotError(
+        `p4 where returned no mapping for ${file}`,
+        "FILE_NOT_IN_CLIENT"
+      );
+    }
+    const clientFile = record.get("clientFile") ?? "";
+    return {
+      depotFile: record.get("depotFile") ?? "",
+      clientFile,
+      path: record.get("path") ?? clientFile
+    };
+  }
+  async changes(opts) {
+    const args = ["changes"];
+    if (opts?.status) args.push("-s", opts.status);
+    if (opts?.max !== void 0) args.push("-m", String(opts.max));
+    if (opts?.user) args.push("-u", opts.user);
+    const { stdout } = await this.#run(args);
+    return parseZtag(stdout).map(toChangelistSummary);
+  }
+  async describe(change, opts) {
+    const args = ["describe"];
+    if (opts?.diff) args.push("-du");
+    args.push(change);
+    const { stdout } = await this.#run(args);
+    const record = parseZtag(stdout)[0];
+    if (!record) {
+      throw new P4PilotError(
+        `p4 describe returned nothing for ${change}`,
+        "P4_COMMAND_FAILED"
+      );
+    }
+    const grouped = groupIndexed(record);
+    const depotFiles = asArray(grouped.depotFile);
+    const actions = asArray(grouped.action);
+    const revs = asArray(grouped.rev);
+    const files = depotFiles.map((depotFile, index) => ({
+      depotFile,
+      action: actions[index] ?? "edit",
+      rev: revs[index] === void 0 ? void 0 : Number(revs[index])
+    }));
+    return {
+      change: str(grouped.change) ?? change,
+      description: str(grouped.desc) ?? "",
+      user: str(grouped.user),
+      files,
+      diff: str(grouped.diff)
+    };
+  }
+  async filelog(file, opts) {
+    const args = ["filelog"];
+    if (opts?.max !== void 0) args.push("-m", String(opts.max));
+    args.push(file);
+    const { stdout } = await this.#run(args);
+    const record = parseZtag(stdout)[0];
+    if (!record) return [];
+    const grouped = groupIndexed(record);
+    const revs = asArray(grouped.rev);
+    const changes = asArray(grouped.change);
+    const actions = asArray(grouped.action);
+    const users = asArray(grouped.user);
+    const descriptions = asArray(grouped.desc);
+    return revs.map((rev, index) => ({
+      rev: Number(rev),
+      change: changes[index] ?? "",
+      action: actions[index] ?? "edit",
+      user: users[index] ?? "",
+      description: descriptions[index] ?? ""
+    }));
+  }
+  async newChangelist(description) {
+    const indented = description.replace(/\n/g, "\n	");
+    const spec = `Change:	new
+
+Description:
+	${indented}
+`;
+    const { stdout } = await this.#run(["change", "-i"], { input: spec });
+    const matched = CHANGE_CREATED.exec(stdout);
+    if (matched?.[1]) return matched[1];
+    const change = parseZtag(stdout)[0]?.get("change");
+    if (change) return change;
+    throw new P4PilotError(
+      "could not parse created changelist number",
+      "P4_COMMAND_FAILED",
+      stdout.trim()
+    );
+  }
+  async reopen(files, changelist) {
+    if (files.length === 0) return [];
+    const { stdout } = await this.#run(["reopen", "-c", changelist, ...files]);
+    return parseZtag(stdout).map(toOpenedFile);
+  }
+};
+
+// src/asset-guard.ts
+var DEFAULT_ASSET_GUARD_CONFIG = {
+  largeAssetExtensions: [
+    ".uasset",
+    ".umap",
+    ".fbx",
+    ".psd",
+    ".pak",
+    ".mp4",
+    ".mov",
+    ".blend",
+    ".exr"
+  ],
+  binaryExtensions: [
+    ".png",
+    ".tga",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".bmp",
+    ".dds",
+    ".ico",
+    ".wav",
+    ".mp3",
+    ".ogg",
+    ".flac",
+    ".bin",
+    ".dll",
+    ".exe",
+    ".so",
+    ".dylib",
+    ".lib",
+    ".a",
+    ".zip",
+    ".7z",
+    ".rar",
+    ".gz",
+    ".pdf"
+  ],
+  maxTextBytes: 1e6
+};
+function extname(path) {
+  const normalized = path.replace(/\\/g, "/");
+  const base = normalized.slice(normalized.lastIndexOf("/") + 1);
+  const dot = base.lastIndexOf(".");
+  return dot <= 0 ? "" : base.slice(dot).toLowerCase();
+}
+function isBinaryFiletype(filetype) {
+  if (filetype === void 0) return false;
+  return /(binary|ubinary|apple)/i.test(filetype);
+}
+function build(path, kind, filetype, sizeBytes, reason) {
+  return {
+    path,
+    kind,
+    filetype,
+    sizeBytes,
+    shouldRead: kind === "text",
+    reason
+  };
+}
+function classifyAsset(path, opts) {
+  const config = {
+    ...DEFAULT_ASSET_GUARD_CONFIG,
+    ...opts?.config
+  };
+  const ext = extname(path);
+  const filetype = opts?.stat?.headType;
+  const sizeBytes = opts?.sizeBytes;
+  if (config.largeAssetExtensions.includes(ext)) {
+    return build(
+      path,
+      "large-asset",
+      filetype,
+      sizeBytes,
+      `large-asset extension ${ext}`
+    );
+  }
+  if (isBinaryFiletype(filetype)) {
+    return build(
+      path,
+      "binary",
+      filetype,
+      sizeBytes,
+      `binary p4 filetype ${filetype ?? ""}`
+    );
+  }
+  if (config.binaryExtensions.includes(ext)) {
+    return build(
+      path,
+      "binary",
+      filetype,
+      sizeBytes,
+      `binary extension ${ext}`
+    );
+  }
+  if (sizeBytes !== void 0 && sizeBytes > config.maxTextBytes) {
+    return build(
+      path,
+      "binary",
+      filetype,
+      sizeBytes,
+      `size ${sizeBytes} exceeds maxTextBytes ${config.maxTextBytes}`
+    );
+  }
+  return build(
+    path,
+    "text",
+    filetype,
+    sizeBytes,
+    ext ? `text extension ${ext}` : "text file"
+  );
+}
+
+// src/auto-checkout.ts
+async function ensureOpenForEdit(client, localPath, opts) {
+  const [stat] = await client.fstat([localPath]);
+  const asset = classifyAsset(localPath, { stat, config: opts?.assetConfig });
+  const changelist = opts?.changelist;
+  const openOpts = changelist === void 0 ? void 0 : { changelist };
+  if (stat?.isOpened) {
+    return {
+      path: localPath,
+      status: "already-open",
+      action: stat.action,
+      changelist,
+      asset
+    };
+  }
+  if (stat?.isTracked) {
+    const [opened] = await client.edit([localPath], openOpts);
+    return {
+      path: localPath,
+      status: "opened",
+      action: opened?.action ?? "edit",
+      changelist: opened?.change ?? changelist,
+      asset
+    };
+  }
+  const [added] = await client.add([localPath], openOpts);
+  return {
+    path: localPath,
+    status: "added",
+    action: added?.action ?? "add",
+    changelist: added?.change ?? changelist,
+    asset
+  };
+}
+async function ensureOpenForEditMany(client, localPaths, opts) {
+  const results = [];
+  for (const path of localPaths) {
+    try {
+      results.push(await ensureOpenForEdit(client, path, opts));
+    } catch {
+      results.push({ path, status: "skipped-untracked-ignored" });
+    }
+  }
+  return results;
+}
+
+// src/changelist.ts
+function buildChangelistDescription(intent, prefix = "[p4pilot] ") {
+  const trimmed = intent.trim();
+  if (trimmed.length === 0) return prefix.trimEnd();
+  return trimmed.startsWith(prefix) ? trimmed : `${prefix}${trimmed}`;
+}
+
+export {
+  P4PilotError,
+  parseZtag,
+  groupIndexed,
+  P4Client,
+  DEFAULT_ASSET_GUARD_CONFIG,
+  classifyAsset,
+  ensureOpenForEdit,
+  ensureOpenForEditMany,
+  buildChangelistDescription
+};