pi-docparser 1.0.0

package/extensions/docparser/deps.ts

@@ -0,0 +1,522 @@
+import { truncateTail } from "@mariozechner/pi-coding-agent";
+import { spawn } from "node:child_process";
+import { constants as fsConstants } from "node:fs";
+import { access } from "node:fs/promises";
+
+import {
+  DOCTOR_COMMAND,
+  GHOSTSCRIPT_MISSING_MESSAGE,
+  GHOSTSCRIPT_REQUIRED_EXTENSIONS,
+  IMAGEMAGICK_MISSING_MESSAGE,
+  INSTALL_COMMAND_TIMEOUT_MS,
+  LIBREOFFICE_MISSING_MESSAGE,
+} from "./constants.ts";
+import type {
+  DependencyDiagnosis,
+  DependencyName,
+  InputCategory,
+  InputInspection,
+  InstallCommandSpec,
+  InstallStrategy,
+  PackageManagerId,
+  UnixPrivilegeContext,
+} from "./types.ts";
+
+const DEPENDENCY_NAMES = ["libreoffice", "imagemagick", "ghostscript"] as const;
+const PLATFORM_LABELS = {
+  darwin: "macOS",
+  linux: "Linux",
+  win32: "Windows",
+} as const;
+const INPUT_CATEGORY_LABELS: Record<InputCategory, string> = {
+  pdf: "PDF",
+  office: "Office document",
+  spreadsheet: "Spreadsheet / tabular document",
+  image: "Image",
+  other: "Other / unknown",
+};
+const PACKAGE_NAMES: Record<PackageManagerId, Record<DependencyName, string>> = {
+  brew: {
+    libreoffice: "libreoffice",
+    imagemagick: "imagemagick",
+    ghostscript: "ghostscript",
+  },
+  "apt-get": {
+    libreoffice: "libreoffice",
+    imagemagick: "imagemagick",
+    ghostscript: "ghostscript",
+  },
+  dnf: {
+    libreoffice: "libreoffice",
+    imagemagick: "ImageMagick",
+    ghostscript: "ghostscript",
+  },
+  yum: {
+    libreoffice: "libreoffice",
+    imagemagick: "ImageMagick",
+    ghostscript: "ghostscript",
+  },
+  pacman: {
+    libreoffice: "libreoffice-fresh",
+    imagemagick: "imagemagick",
+    ghostscript: "ghostscript",
+  },
+  zypper: {
+    libreoffice: "libreoffice",
+    imagemagick: "ImageMagick",
+    ghostscript: "ghostscript",
+  },
+  apk: {
+    libreoffice: "libreoffice",
+    imagemagick: "imagemagick",
+    ghostscript: "ghostscript",
+  },
+  winget: {
+    libreoffice: "TheDocumentFoundation.LibreOffice",
+    imagemagick: "ImageMagick.Q16",
+    ghostscript: "ArtifexSoftware.GhostScript",
+  },
+  choco: {
+    libreoffice: "libreoffice-fresh",
+    imagemagick: "imagemagick.app",
+    ghostscript: "ghostscript",
+  },
+};
+const LINUX_MANAGERS: Array<{ id: PackageManagerId; label: string }> = [
+  { id: "apt-get", label: "APT" },
+  { id: "dnf", label: "DNF" },
+  { id: "yum", label: "YUM" },
+  { id: "pacman", label: "pacman" },
+  { id: "zypper", label: "zypper" },
+  { id: "apk", label: "apk" },
+];
+const DEPENDENCY_SETUP_PATTERNS = [
+  "LibreOffice is not installed",
+  "ImageMagick is not installed",
+  "Ghostscript is required",
+];
+
+async function spawnSucceeded(command: string, args: string[]): Promise<boolean> {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, {
+      stdio: "ignore",
+      windowsHide: true,
+    });
+
+    child.on("error", () => resolve(false));
+    child.on("close", (code) => resolve(code === 0));
+  });
+}
+
+async function runBinaryLookup(binary: string): Promise<boolean> {
+  return spawnSucceeded(process.platform === "win32" ? "where" : "which", [binary]);
+}
+
+async function isExecutablePathAvailable(filePath: string): Promise<boolean> {
+  try {
+    await access(filePath, process.platform === "win32" ? fsConstants.F_OK : fsConstants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function findFirstAvailableCommand(
+  commandNames: string[],
+  candidatePaths: string[] = [],
+): Promise<string | undefined> {
+  for (const commandName of commandNames) {
+    if (await runBinaryLookup(commandName)) {
+      return commandName;
+    }
+  }
+
+  for (const candidatePath of candidatePaths) {
+    if (await isExecutablePathAvailable(candidatePath)) {
+      return candidatePath;
+    }
+  }
+
+  return undefined;
+}
+
+function formatGhostscriptMissingMessage(extension: string): string {
+  const fileTypeLabel = (extension || "vector").replace(/^\./, "").toUpperCase();
+  return GHOSTSCRIPT_MISSING_MESSAGE.replace("%s", fileTypeLabel);
+}
+
+const DEPENDENCY_METADATA: Record<
+  DependencyName,
+  {
+    label: string;
+    summary: string;
+    findCommand: () => Promise<string | undefined>;
+    getMissingMessage: (inspection?: InputInspection) => string;
+  }
+> = {
+  libreoffice: {
+    label: "LibreOffice",
+    summary:
+      "Needed for Office documents and spreadsheets such as DOCX, PPTX, XLSX, CSV, and similar formats.",
+    findCommand: () =>
+      findFirstAvailableCommand(
+        ["libreoffice", "soffice"],
+        process.platform === "darwin"
+          ? [
+              "/Applications/LibreOffice.app/Contents/MacOS/soffice",
+              "/Applications/LibreOffice.app/Contents/MacOS/libreoffice",
+            ]
+          : process.platform === "win32"
+            ? [
+                "C:\\Program Files\\LibreOffice\\program\\soffice.exe",
+                "C:\\Program Files\\LibreOffice\\program\\libreoffice.exe",
+                "C:\\Program Files (x86)\\LibreOffice\\program\\soffice.exe",
+                "C:\\Program Files (x86)\\LibreOffice\\program\\libreoffice.exe",
+              ]
+            : [],
+      ),
+    getMissingMessage: () => LIBREOFFICE_MISSING_MESSAGE,
+  },
+  imagemagick: {
+    label: "ImageMagick",
+    summary:
+      "Needed for image inputs such as PNG, JPG, TIFF, WebP, SVG, and similar formats that must be converted before parsing.",
+    findCommand: () =>
+      findFirstAvailableCommand(process.platform === "win32" ? ["magick"] : ["magick", "convert"]),
+    getMissingMessage: () => IMAGEMAGICK_MISSING_MESSAGE,
+  },
+  ghostscript: {
+    label: "Ghostscript",
+    summary:
+      "Needed for vector image conversion paths such as SVG, EPS, PS, and AI when ImageMagick delegates rendering.",
+    findCommand: () => findFirstAvailableCommand(["gs", "gswin64c", "gswin32c"]),
+    getMissingMessage: (inspection) =>
+      formatGhostscriptMissingMessage(inspection?.extension || ".svg"),
+  },
+};
+
+function getPackageNames(manager: PackageManagerId, dependencyNames: DependencyName[]): string[] {
+  return dependencyNames.map((dependencyName) => PACKAGE_NAMES[manager][dependencyName]);
+}
+
+function getLinuxInstallArgs(managerId: PackageManagerId, packageNames: string[]): string[] {
+  if (managerId === "pacman") {
+    return ["-Sy", "--noconfirm", ...packageNames];
+  }
+
+  if (managerId === "apk") {
+    return ["add", ...packageNames];
+  }
+
+  return ["install", "-y", ...packageNames];
+}
+
+function buildCommandDisplay(command: string, args: string[], displayPrefix = ""): string {
+  return `${displayPrefix}${command}${args.length > 0 ? ` ${args.join(" ")}` : ""}`;
+}
+
+function createCommandSpec(
+  description: string,
+  command: string,
+  args: string[],
+  options: { prefix?: string[]; displayPrefix?: string; timeoutMs?: number } = {},
+): InstallCommandSpec {
+  const prefix = options.prefix ?? [];
+  const displayPrefix = options.displayPrefix ?? "";
+
+  if (prefix.length === 0) {
+    return {
+      description,
+      command,
+      args,
+      display: buildCommandDisplay(command, args),
+      timeoutMs: options.timeoutMs,
+    };
+  }
+
+  return {
+    description,
+    command: prefix[0],
+    args: [...prefix.slice(1), command, ...args],
+    display: buildCommandDisplay(command, args, displayPrefix),
+    timeoutMs: options.timeoutMs,
+  };
+}
+
+async function getUnixPrivilegeContext(): Promise<UnixPrivilegeContext> {
+  if (typeof process.getuid === "function" && process.getuid() === 0) {
+    return {
+      prefix: [],
+      displayPrefix: "",
+      autoRunnable: true,
+    };
+  }
+
+  if ((await runBinaryLookup("sudo")) && (await spawnSucceeded("sudo", ["-n", "true"]))) {
+    return {
+      prefix: ["sudo", "-n"],
+      displayPrefix: "sudo ",
+      autoRunnable: true,
+    };
+  }
+
+  return {
+    prefix: ["sudo", "-n"],
+    displayPrefix: "sudo ",
+    autoRunnable: false,
+    blockedReason: "Automatic install on Linux requires root privileges or passwordless sudo.",
+  };
+}
+
+function buildLinuxInstallCommands(
+  manager: { id: PackageManagerId; label: string },
+  dependencyNames: DependencyName[],
+  privilegeContext: UnixPrivilegeContext,
+): InstallCommandSpec[] {
+  const packageNames = getPackageNames(manager.id, dependencyNames);
+  const commands: InstallCommandSpec[] = [];
+
+  if (manager.id === "apt-get") {
+    commands.push(
+      createCommandSpec("Refresh apt package metadata", "apt-get", ["update"], {
+        prefix: privilegeContext.prefix,
+        displayPrefix: privilegeContext.displayPrefix,
+        timeoutMs: INSTALL_COMMAND_TIMEOUT_MS,
+      }),
+    );
+  }
+
+  commands.push(
+    createCommandSpec(
+      `Install missing document parser dependencies via ${manager.label}`,
+      manager.id,
+      getLinuxInstallArgs(manager.id, packageNames),
+      {
+        prefix: privilegeContext.prefix,
+        displayPrefix: privilegeContext.displayPrefix,
+        timeoutMs: INSTALL_COMMAND_TIMEOUT_MS,
+      },
+    ),
+  );
+
+  return commands;
+}
+
+function buildWingetCommands(dependencyNames: DependencyName[]): InstallCommandSpec[] {
+  return dependencyNames.map((dependencyName) =>
+    createCommandSpec(
+      `Install ${DEPENDENCY_METADATA[dependencyName].label} via winget`,
+      "winget",
+      [
+        "install",
+        "-e",
+        "--id",
+        PACKAGE_NAMES.winget[dependencyName],
+        "--accept-package-agreements",
+        "--accept-source-agreements",
+      ],
+      { timeoutMs: INSTALL_COMMAND_TIMEOUT_MS },
+    ),
+  );
+}
+
+export function getRelevantDependencyNames(inspection?: InputInspection): Set<DependencyName> {
+  if (!inspection) {
+    return new Set(DEPENDENCY_NAMES);
+  }
+
+  const relevantDependencies =
+    inspection.category === "office" || inspection.category === "spreadsheet"
+      ? new Set<DependencyName>(["libreoffice"])
+      : inspection.category === "image"
+        ? new Set<DependencyName>(["imagemagick"])
+        : new Set<DependencyName>();
+
+  if (
+    inspection.category === "image" &&
+    GHOSTSCRIPT_REQUIRED_EXTENSIONS.has(inspection.extension)
+  ) {
+    relevantDependencies.add("ghostscript");
+  }
+
+  return relevantDependencies;
+}
+
+export async function diagnoseDependencies(
+  inspection?: InputInspection,
+): Promise<DependencyDiagnosis[]> {
+  const relevantDependencies = getRelevantDependencyNames(inspection);
+  const detectedCommands = await Promise.all(
+    DEPENDENCY_NAMES.map((dependencyName) => DEPENDENCY_METADATA[dependencyName].findCommand()),
+  );
+
+  return DEPENDENCY_NAMES.map((dependencyName, index) => ({
+    name: dependencyName,
+    label: DEPENDENCY_METADATA[dependencyName].label,
+    installed: Boolean(detectedCommands[index]),
+    detectedCommand: detectedCommands[index],
+    relevant: relevantDependencies.has(dependencyName),
+    summary: DEPENDENCY_METADATA[dependencyName].summary,
+    missingMessage: DEPENDENCY_METADATA[dependencyName].getMissingMessage(inspection),
+  }));
+}
+
+export async function getMissingHostDependencyMessage(
+  inspection: InputInspection,
+): Promise<string | undefined> {
+  const diagnoses = await diagnoseDependencies(inspection);
+  return diagnoses.find((diagnosis) => diagnosis.relevant && !diagnosis.installed)?.missingMessage;
+}
+
+export function isDependencySetupMessage(message: string): boolean {
+  return DEPENDENCY_SETUP_PATTERNS.some((pattern) => message.includes(pattern));
+}
+
+export function appendDoctorHint(message: string): string {
+  return message.includes(DOCTOR_COMMAND)
+    ? message
+    : `${message} Run ${DOCTOR_COMMAND} for guided setup.`;
+}
+
+export function getPlatformLabel(): string {
+  return PLATFORM_LABELS[process.platform as keyof typeof PLATFORM_LABELS] ?? process.platform;
+}
+
+export function getInputCategoryLabel(category: InputCategory): string {
+  return INPUT_CATEGORY_LABELS[category];
+}
+
+export async function buildInstallStrategies(
+  missingDependencies: DependencyDiagnosis[],
+): Promise<InstallStrategy[]> {
+  const missingNames = Array.from(
+    new Set(
+      missingDependencies
+        .filter((dependency) => !dependency.installed)
+        .map((dependency) => dependency.name),
+    ),
+  );
+  if (missingNames.length === 0) {
+    return [];
+  }
+
+  if (process.platform === "darwin") {
+    const brewAvailable = await runBinaryLookup("brew");
+
+    return [
+      {
+        id: "brew",
+        label: "Homebrew",
+        autoRunnable: brewAvailable,
+        autoRunBlockedReason: brewAvailable ? undefined : "Homebrew was not detected on PATH.",
+        commands: [
+          createCommandSpec(
+            "Install missing document parser dependencies via Homebrew",
+            "brew",
+            ["install", ...getPackageNames("brew", missingNames)],
+            { timeoutMs: INSTALL_COMMAND_TIMEOUT_MS },
+          ),
+        ],
+      },
+    ];
+  }
+
+  if (process.platform === "linux") {
+    const privilegeContext = await getUnixPrivilegeContext();
+    const strategies: InstallStrategy[] = [];
+
+    for (const manager of LINUX_MANAGERS) {
+      if (!(await runBinaryLookup(manager.id))) {
+        continue;
+      }
+
+      strategies.push({
+        id: manager.id,
+        label: manager.label,
+        autoRunnable: privilegeContext.autoRunnable,
+        autoRunBlockedReason: privilegeContext.autoRunnable
+          ? undefined
+          : privilegeContext.blockedReason,
+        commands: buildLinuxInstallCommands(manager, missingNames, privilegeContext),
+      });
+    }
+
+    return strategies;
+  }
+
+  if (process.platform === "win32") {
+    const wingetAvailable = await runBinaryLookup("winget");
+    const chocoAvailable = await runBinaryLookup("choco");
+    const strategies: InstallStrategy[] = [];
+
+    if (wingetAvailable) {
+      strategies.push({
+        id: "winget",
+        label: "winget",
+        autoRunnable: true,
+        commands: buildWingetCommands(missingNames),
+      });
+    }
+
+    if (chocoAvailable) {
+      strategies.push({
+        id: "choco",
+        label: "Chocolatey",
+        autoRunnable: true,
+        commands: [
+          createCommandSpec(
+            "Install missing document parser dependencies via Chocolatey",
+            "choco",
+            ["install", "-y", ...getPackageNames("choco", missingNames)],
+            { timeoutMs: INSTALL_COMMAND_TIMEOUT_MS },
+          ),
+        ],
+      });
+    }
+
+    if (wingetAvailable || chocoAvailable) {
+      return strategies;
+    }
+
+    return [
+      {
+        id: "winget",
+        label: "winget",
+        autoRunnable: false,
+        autoRunBlockedReason: "Neither winget nor Chocolatey was detected on PATH.",
+        commands: buildWingetCommands(missingNames),
+      },
+    ];
+  }
+
+  return [];
+}
+
+export function getPreferredStrategies(strategies: InstallStrategy[]): InstallStrategy[] {
+  const order =
+    process.platform === "darwin"
+      ? ["brew"]
+      : process.platform === "linux"
+        ? ["apt-get", "dnf", "yum", "pacman", "zypper", "apk"]
+        : ["winget", "choco"];
+  const getOrderIndex = (id: PackageManagerId) => {
+    const index = order.indexOf(id);
+    return index === -1 ? Number.MAX_SAFE_INTEGER : index;
+  };
+
+  return [...strategies].sort((a, b) => getOrderIndex(a.id) - getOrderIndex(b.id));
+}
+
+export function summarizeInstallOutput(stdout: string, stderr: string): string | undefined {
+  const combined = [stdout.trim(), stderr.trim()].filter(Boolean).join("\n\n");
+  if (!combined) {
+    return undefined;
+  }
+
+  const truncation = truncateTail(combined, {
+    maxLines: 20,
+    maxBytes: 2 * 1024,
+  });
+
+  return truncation.content.trim();
+}