label-studio-converter 1.1.0 → 1.3.0

package/dist/bash-complete.cjs

@@ -38,12 +38,11 @@ var init_cjs_shims = __esm({
 });
 
 // src/constants.ts
-var OUTPUT_BASE_DIR, DEFAULT_LABEL_NAME, DEFAULT_LABEL_STUDIO_FULL_JSON, DEFAULT_CREATE_FILE_PER_IMAGE, DEFAULT_CREATE_FILE_LIST_FOR_SERVING, DEFAULT_FILE_LIST_NAME, DEFAULT_BASE_SERVER_URL, DEFAULT_PPOCR_FILE_NAME, SORT_VERTICAL_NONE, SORT_VERTICAL_TOP_BOTTOM, SORT_VERTICAL_BOTTOM_TOP, DEFAULT_SORT_VERTICAL, SORT_HORIZONTAL_NONE, SORT_HORIZONTAL_LTR, SORT_HORIZONTAL_RTL, DEFAULT_SORT_HORIZONTAL, SHAPE_NORMALIZE_NONE, SHAPE_NORMALIZE_RECTANGLE, DEFAULT_SHAPE_NORMALIZE, DEFAULT_WIDTH_INCREMENT, DEFAULT_HEIGHT_INCREMENT, DEFAULT_LABEL_STUDIO_PRECISION, DEFAULT_PPOCR_PRECISION;
+var DEFAULT_LABEL_NAME, DEFAULT_LABEL_STUDIO_FULL_JSON, DEFAULT_CREATE_FILE_PER_IMAGE, DEFAULT_CREATE_FILE_LIST_FOR_SERVING, DEFAULT_FILE_LIST_NAME, DEFAULT_BASE_SERVER_URL, DEFAULT_PPOCR_FILE_NAME, SORT_VERTICAL_NONE, SORT_VERTICAL_TOP_BOTTOM, SORT_VERTICAL_BOTTOM_TOP, DEFAULT_SORT_VERTICAL, SORT_HORIZONTAL_NONE, SORT_HORIZONTAL_LTR, SORT_HORIZONTAL_RTL, DEFAULT_SORT_HORIZONTAL, SHAPE_NORMALIZE_NONE, SHAPE_NORMALIZE_RECTANGLE, DEFAULT_SHAPE_NORMALIZE, DEFAULT_WIDTH_INCREMENT, DEFAULT_HEIGHT_INCREMENT, DEFAULT_LABEL_STUDIO_PRECISION, DEFAULT_PPOCR_PRECISION, DEFAULT_RECURSIVE, DEFAULT_PPOCR_FILE_PATTERN, DEFAULT_LABEL_STUDIO_FILE_PATTERN, OUTPUT_MODE_ANNOTATIONS, OUTPUT_MODE_PREDICTIONS, DEFAULT_OUTPUT_MODE, DEFAULT_BACKUP, BACKUP_SUFFIX_PREFIX;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
     init_cjs_shims();
-    OUTPUT_BASE_DIR = "./output";
     DEFAULT_LABEL_NAME = "Text";
     DEFAULT_LABEL_STUDIO_FULL_JSON = true;
     DEFAULT_CREATE_FILE_PER_IMAGE = false;
@@ -66,6 +65,86 @@ var init_constants = __esm({
     DEFAULT_HEIGHT_INCREMENT = 0;
     DEFAULT_LABEL_STUDIO_PRECISION = -1;
     DEFAULT_PPOCR_PRECISION = 0;
+    DEFAULT_RECURSIVE = false;
+    DEFAULT_PPOCR_FILE_PATTERN = ".*\\.txt$";
+    DEFAULT_LABEL_STUDIO_FILE_PATTERN = ".*\\.json$";
+    OUTPUT_MODE_ANNOTATIONS = "annotations";
+    OUTPUT_MODE_PREDICTIONS = "predictions";
+    DEFAULT_OUTPUT_MODE = OUTPUT_MODE_ANNOTATIONS;
+    DEFAULT_BACKUP = false;
+    BACKUP_SUFFIX_PREFIX = "backup-";
+  }
+});
+
+// src/lib/backup-utils.ts
+async function backupFileIfExists(filePath) {
+  if (!(0, import_fs.existsSync)(filePath)) {
+    return null;
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-").split(".")[0];
+  const backupPath = `${filePath}.${BACKUP_SUFFIX_PREFIX}${timestamp}`;
+  await copyFileAsync(filePath, backupPath);
+  return backupPath;
+}
+var import_fs, import_util, copyFileAsync;
+var init_backup_utils = __esm({
+  "src/lib/backup-utils.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_fs = require("fs");
+    import_util = require("util");
+    init_constants();
+    copyFileAsync = (0, import_util.promisify)(import_fs.copyFile);
+  }
+});
+
+// src/lib/file-utils.ts
+async function findFiles(dirs, pattern, recursive) {
+  const allFiles = [];
+  const regex = new RegExp(pattern);
+  async function scanDirectory(dirPath) {
+    const entries = await (0, import_promises.readdir)(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = (0, import_path.join)(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        if (recursive) {
+          await scanDirectory(fullPath);
+        }
+      } else if (entry.isFile()) {
+        if (regex.test(entry.name)) {
+          allFiles.push(fullPath);
+        }
+      }
+    }
+  }
+  for (const dir of dirs) {
+    const dirStat = await (0, import_promises.stat)(dir);
+    if (dirStat.isDirectory()) {
+      await scanDirectory(dir);
+    } else if (dirStat.isFile()) {
+      if (regex.test(dir)) {
+        allFiles.push(dir);
+      }
+    }
+  }
+  return allFiles;
+}
+function getRelativePathFromInputs(filePath, inputDirs) {
+  for (const inputDir of inputDirs) {
+    const rel = (0, import_path.relative)(inputDir, filePath);
+    if (!rel.startsWith("..") && !rel.startsWith("/")) {
+      return rel;
+    }
+  }
+  return (0, import_path.relative)(process.cwd(), filePath);
+}
+var import_promises, import_path;
+var init_file_utils = __esm({
+  "src/lib/file-utils.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_promises = require("fs/promises");
+    import_path = require("path");
   }
 });
 
@@ -155,273 +234,533 @@ var init_geometry = __esm({
   }
 });
 
-// src/lib/ppocr-label.ts
-var import_node_crypto, import_node_fs, import_node_path, import_image_size, ppocrToLabelStudio, ppocrToFullLabelStudio, ppocrToMinLabelStudio;
-var init_ppocr_label = __esm({
-  "src/lib/ppocr-label.ts"() {
+// src/lib/sort.ts
+function getBoundingBoxCenter(points) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const [x, y] of points) {
+    if (x !== void 0 && y !== void 0) {
+      minX = Math.min(minX, x);
+      minY = Math.min(minY, y);
+      maxX = Math.max(maxX, x);
+      maxY = Math.max(maxY, y);
+    }
+  }
+  return {
+    x: (minX + maxX) / 2,
+    y: (minY + maxY) / 2,
+    width: maxX - minX,
+    height: maxY - minY
+  };
+}
+function sortBoundingBoxes(annotations, verticalSort, horizontalSort) {
+  if (verticalSort === SORT_VERTICAL_NONE && horizontalSort === SORT_HORIZONTAL_NONE) {
+    return annotations;
+  }
+  const sorted = [...annotations];
+  const isVerticalText = sorted.length > 0 && (() => {
+    const verticalCount = sorted.filter((ann) => {
+      const center = getBoundingBoxCenter(ann.points);
+      return center.height > center.width * 1.5;
+    }).length;
+    return verticalCount > sorted.length / 2;
+  })();
+  if (horizontalSort === SORT_HORIZONTAL_RTL && verticalSort !== SORT_VERTICAL_NONE && isVerticalText) {
+    const annotationsWithCenters = sorted.map((ann) => ({
+      annotation: ann,
+      center: getBoundingBoxCenter(ann.points)
+    }));
+    const columns = [];
+    for (const item of annotationsWithCenters) {
+      let addedToColumn = false;
+      for (const column of columns) {
+        const avgX = column.reduce((sum, c) => sum + c.center.x, 0) / column.length;
+        if (Math.abs(item.center.x - avgX) < GROUPING_TOLERANCE) {
+          column.push(item);
+          addedToColumn = true;
+          break;
+        }
+      }
+      if (!addedToColumn) {
+        columns.push([item]);
+      }
+    }
+    columns.sort((colA, colB) => {
+      const avgXA = colA.reduce((sum, c) => sum + c.center.x, 0) / colA.length;
+      const avgXB = colB.reduce((sum, c) => sum + c.center.x, 0) / colB.length;
+      return avgXB - avgXA;
+    });
+    for (const column of columns) {
+      column.sort((a, b) => {
+        return verticalSort === SORT_VERTICAL_TOP_BOTTOM ? a.center.y - b.center.y : b.center.y - a.center.y;
+      });
+    }
+    return columns.flat().map((item) => item.annotation);
+  }
+  sorted.sort((a, b) => {
+    const centerA = getBoundingBoxCenter(a.points);
+    const centerB = getBoundingBoxCenter(b.points);
+    if (verticalSort !== SORT_VERTICAL_NONE) {
+      const yDiff = verticalSort === SORT_VERTICAL_TOP_BOTTOM ? centerA.y - centerB.y : centerB.y - centerA.y;
+      if (Math.abs(yDiff) > GROUPING_TOLERANCE) {
+        return yDiff;
+      }
+    }
+    if (horizontalSort !== SORT_HORIZONTAL_NONE) {
+      return horizontalSort === SORT_HORIZONTAL_LTR ? centerA.x - centerB.x : centerB.x - centerA.x;
+    }
+    return 0;
+  });
+  return sorted;
+}
+var GROUPING_TOLERANCE;
+var init_sort = __esm({
+  "src/lib/sort.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_crypto = require("crypto");
-    import_node_fs = require("fs");
-    import_node_path = require("path");
-    import_image_size = __toESM(require("image-size"), 1);
     init_constants();
+    GROUPING_TOLERANCE = 50;
+  }
+});
+
+// src/lib/enhance.ts
+function enhancePPOCRLabel(data, options) {
+  const {
+    sortVertical,
+    sortHorizontal,
+    normalizeShape: normalizeShape2,
+    widthIncrement = 0,
+    heightIncrement = 0,
+    precision = 0
+  } = options;
+  let enhanced = data;
+  if (sortVertical && sortHorizontal) {
+    enhanced = sortBoundingBoxes(enhanced, sortVertical, sortHorizontal);
+  }
+  if (normalizeShape2 || widthIncrement !== 0 || heightIncrement !== 0) {
+    enhanced = enhanced.map((annotation) => {
+      let points = transformPoints(annotation.points, {
+        normalizeShape: normalizeShape2,
+        widthIncrement,
+        heightIncrement
+      });
+      points = roundPoints(points, precision);
+      return {
+        ...annotation,
+        points
+      };
+    });
+  }
+  return enhanced;
+}
+var init_enhance = __esm({
+  "src/lib/enhance.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_geometry();
+    init_sort();
+  }
+});
+
+// src/lib/label-studio.ts
+var turf, labelStudioToPPOCR, minLabelStudioToPPOCR, processAnnotationOrPrediction, enhanceLabelStudioData;
+var init_label_studio = __esm({
+  "src/lib/label-studio.ts"() {
+    "use strict";
+    init_cjs_shims();
+    turf = __toESM(require("@turf/turf"), 1);
+    init_constants();
+    init_enhance();
     init_geometry();
-    ppocrToLabelStudio = async (data, options) => {
+    labelStudioToPPOCR = async (data, options) => {
       const {
-        imagePath,
-        baseServerUrl,
-        inputDir,
-        toFullJson = true,
-        taskId = 1,
-        labelName = DEFAULT_LABEL_NAME,
+        baseImageDir,
         normalizeShape: normalizeShape2,
         widthIncrement = 0,
         heightIncrement = 0,
-        precision = DEFAULT_LABEL_STUDIO_PRECISION
+        precision = 0
       } = options || {};
-      if (toFullJson) {
-        return ppocrToFullLabelStudio(
-          data,
-          imagePath,
-          baseServerUrl,
-          inputDir,
-          taskId,
-          labelName,
-          normalizeShape2,
-          widthIncrement,
-          heightIncrement,
-          precision
-        );
-      } else {
-        return ppocrToMinLabelStudio(
-          data,
-          imagePath,
-          baseServerUrl,
-          inputDir,
-          labelName,
-          normalizeShape2,
-          widthIncrement,
-          heightIncrement,
-          precision
-        );
-      }
-    };
-    ppocrToFullLabelStudio = (data, imagePath, baseServerUrl, inputDir, taskId = 1, labelName = DEFAULT_LABEL_NAME, normalizeShape2, widthIncrement = 0, heightIncrement = 0, precision = DEFAULT_LABEL_STUDIO_PRECISION) => {
-      const newBaseServerUrl = baseServerUrl.replace(/\/+$/, "") + (baseServerUrl === "" ? "" : "/");
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      let original_width = 1920;
-      let original_height = 1080;
-      const resolvedImagePath = inputDir ? (0, import_node_path.join)(inputDir, imagePath) : imagePath;
-      if (!(0, import_node_fs.existsSync)(resolvedImagePath)) {
-        throw new Error(`Image file not found: ${resolvedImagePath}`);
-      }
-      const buffer = (0, import_node_fs.readFileSync)(resolvedImagePath);
-      const dimensions = (0, import_image_size.default)(buffer);
-      if (!dimensions.width || !dimensions.height) {
-        throw new Error(
-          `Failed to read image dimensions from: ${resolvedImagePath}`
-        );
-      }
-      original_width = dimensions.width;
-      original_height = dimensions.height;
-      const fileName = imagePath.split("/").pop() || imagePath;
-      const result = [
-        {
-          id: taskId,
-          annotations: [
-            {
-              id: taskId,
-              completed_by: 1,
-              result: data.map((item) => {
-                let { points } = item;
-                points = transformPoints(points, {
-                  normalizeShape: normalizeShape2,
-                  widthIncrement,
-                  heightIncrement
-                });
-                const annotationId = (0, import_node_crypto.randomUUID)().slice(0, 10);
-                const polygonPoints = points.map(([x, y]) => [
-                  roundToPrecision((x ?? 0) / original_width * 100, precision),
-                  roundToPrecision((y ?? 0) / original_height * 100, precision)
+      const resultMap = /* @__PURE__ */ new Map();
+      for (const task of data) {
+        let imagePath = task.file_upload || "";
+        if (task.data.ocr) {
+          const urlPath = task.data.ocr.replace(/^https?:\/\/[^/]+\//, "");
+          imagePath = decodeURIComponent(urlPath);
+        }
+        if (baseImageDir) {
+          imagePath = `${baseImageDir}/${task.file_upload || imagePath.split("/").pop() || imagePath}`;
+        }
+        const imageAnnotations = [];
+        for (const annotation of task.annotations) {
+          const groupedById = /* @__PURE__ */ new Map();
+          for (const resultItem of annotation.result) {
+            const { id } = resultItem;
+            if (!groupedById.has(id)) {
+              groupedById.set(id, []);
+            }
+            groupedById.get(id).push(resultItem);
+          }
+          for (const [_, resultItems] of groupedById) {
+            let points;
+            let transcription = "";
+            for (const resultItem of resultItems) {
+              if ("points" in resultItem.value && resultItem.value.points) {
+                const { points: valuePoints } = resultItem.value;
+                const { original_width, original_height } = resultItem;
+                points = valuePoints.map(([x, y]) => [
+                  (x ?? 0) * original_width / 100,
+                  (y ?? 0) * original_height / 100
                 ]);
-                return [
-                  // 1. Polygon geometry only
-                  {
-                    original_width,
-                    original_height,
-                    image_rotation: 0,
-                    value: {
-                      points: polygonPoints,
-                      closed: true
-                    },
-                    id: annotationId,
-                    from_name: "poly",
-                    to_name: "image",
-                    type: "polygon",
-                    origin: "manual"
-                  },
-                  // 2. Labels with polygon geometry
-                  {
-                    original_width,
-                    original_height,
-                    image_rotation: 0,
-                    value: {
-                      points: polygonPoints,
-                      closed: true,
-                      labels: [labelName]
-                    },
-                    id: annotationId,
-                    from_name: "label",
-                    to_name: "image",
-                    type: "labels",
-                    origin: "manual"
-                  },
-                  // 3. Textarea with polygon geometry and text
-                  {
-                    original_width,
-                    original_height,
-                    image_rotation: 0,
-                    value: {
-                      points: polygonPoints,
-                      closed: true,
-                      text: [item.transcription]
-                    },
-                    id: annotationId,
-                    from_name: "transcription",
-                    to_name: "image",
-                    type: "textarea",
-                    origin: "manual"
-                  }
+              } else if ("x" in resultItem.value && "y" in resultItem.value && "width" in resultItem.value && "height" in resultItem.value) {
+                const { x, y, width, height } = resultItem.value;
+                const { original_width, original_height } = resultItem;
+                const absX = x * original_width / 100;
+                const absY = y * original_height / 100;
+                const absWidth = width * original_width / 100;
+                const absHeight = height * original_height / 100;
+                points = [
+                  [absX, absY],
+                  [absX + absWidth, absY],
+                  [absX + absWidth, absY + absHeight],
+                  [absX, absY + absHeight]
                 ];
-              }).flat(),
-              was_cancelled: false,
-              ground_truth: false,
-              created_at: now,
-              updated_at: now,
-              draft_created_at: now,
-              lead_time: 0,
-              prediction: {},
-              result_count: data.length * 3,
-              unique_id: (0, import_node_crypto.randomUUID)(),
-              import_id: null,
-              last_action: null,
-              bulk_created: false,
-              task: taskId,
-              project: 1,
-              updated_by: 1,
-              parent_prediction: null,
-              parent_annotation: null,
-              last_created_by: null
+              }
+              if ("text" in resultItem.value && Array.isArray(resultItem.value.text)) {
+                transcription = resultItem.value.text[0] || "";
+              }
             }
-          ],
-          file_upload: fileName,
-          drafts: [],
-          predictions: [],
-          data: { ocr: `${newBaseServerUrl}${imagePath}` },
-          meta: {},
-          created_at: now,
-          updated_at: now,
-          allow_skip: false,
-          inner_id: taskId,
-          total_annotations: 1,
-          cancelled_annotations: 0,
-          total_predictions: 0,
-          comment_count: 0,
-          unresolved_comment_count: 0,
-          last_comment_updated_at: null,
-          project: 1,
-          updated_by: 1,
-          comment_authors: []
+            if (points && points.length > 0) {
+              points = transformPoints(points, {
+                normalizeShape: normalizeShape2,
+                widthIncrement,
+                heightIncrement
+              });
+              points = roundPoints(points, precision);
+              let dt_score = 1;
+              try {
+                const firstPoint = points[0];
+                if (firstPoint) {
+                  const polygon2 = turf.polygon([points.concat([firstPoint])]);
+                  const area2 = turf.area(polygon2);
+                  dt_score = Math.min(1, Math.max(0.5, area2 / 1e4));
+                }
+              } catch {
+                dt_score = 0.8;
+              }
+              imageAnnotations.push({
+                transcription,
+                points,
+                dt_score
+              });
+            }
+          }
+        }
+        if (imageAnnotations.length > 0) {
+          resultMap.set(imagePath, imageAnnotations);
         }
-      ];
-      return result;
-    };
-    ppocrToMinLabelStudio = (data, imagePath, baseServerUrl, inputDir, labelName = "text", normalizeShape2, widthIncrement = 0, heightIncrement = 0, precision = DEFAULT_LABEL_STUDIO_PRECISION) => {
-      const newBaseServerUrl = baseServerUrl.replace(/\/+$/, "") + (baseServerUrl === "" ? "" : "/");
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      let original_width = 1920;
-      let original_height = 1080;
-      const resolvedImagePath = inputDir ? (0, import_node_path.join)(inputDir, imagePath) : imagePath;
-      if (!(0, import_node_fs.existsSync)(resolvedImagePath)) {
-        throw new Error(`Image file not found: ${resolvedImagePath}`);
       }
-      const buffer = (0, import_node_fs.readFileSync)(resolvedImagePath);
-      const dimensions = (0, import_image_size.default)(buffer);
-      if (!dimensions.width || !dimensions.height) {
-        throw new Error(
-          `Failed to read image dimensions from: ${resolvedImagePath}`
+      return resultMap;
+    };
+    minLabelStudioToPPOCR = async (data, options) => {
+      const {
+        baseImageDir,
+        normalizeShape: normalizeShape2,
+        widthIncrement = 0,
+        heightIncrement = 0,
+        precision = 0
+      } = options || {};
+      const resultMap = /* @__PURE__ */ new Map();
+      for (const item of data) {
+        let imagePath = item.ocr || "";
+        if (imagePath) {
+          imagePath = decodeURIComponent(
+            imagePath.replace(/^https?:\/\/[^/]+\//, "")
+          );
+        }
+        if (baseImageDir) {
+          imagePath = `${baseImageDir}/${imagePath.split("/").pop() || imagePath}`;
+        }
+        const numAnnotations = Math.max(
+          item.poly?.length || 0,
+          item.bbox?.length || 0,
+          item.transcription?.length || 0
         );
+        for (let i = 0; i < numAnnotations; i++) {
+          let points;
+          if (item.poly && item.poly.length > i && item.poly[i]) {
+            const poly = item.poly[i];
+            if (poly) {
+              const { points: polyPoints } = poly;
+              points = polyPoints;
+            }
+          } else if (item.bbox && item.bbox.length > i && item.bbox[i]) {
+            const bbox = item.bbox[i];
+            if (bbox) {
+              const { x, y, width, height } = bbox;
+              points = [
+                [x, y],
+                [x + width, y],
+                [x + width, y + height],
+                [x, y + height]
+              ];
+            }
+          }
+          if (!points) {
+            continue;
+          }
+          points = transformPoints(points, {
+            normalizeShape: normalizeShape2,
+            widthIncrement,
+            heightIncrement
+          });
+          points = roundPoints(points, precision);
+          const transcription = item.transcription && item.transcription.length > i ? item.transcription[i] : "";
+          let dt_score = 1;
+          try {
+            const firstPoint = points[0];
+            if (firstPoint) {
+              const polygon2 = turf.polygon([points.concat([firstPoint])]);
+              const area2 = turf.area(polygon2);
+              dt_score = Math.min(1, Math.max(0.5, area2 / 1e4));
+            }
+          } catch {
+            dt_score = 0.8;
+          }
+          const annotation = {
+            transcription: transcription ?? "",
+            points,
+            dt_score
+          };
+          if (!resultMap.has(imagePath)) {
+            resultMap.set(imagePath, []);
+          }
+          resultMap.get(imagePath).push(annotation);
+        }
       }
-      original_width = dimensions.width;
-      original_height = dimensions.height;
-      return data.map((item, index) => {
-        let { points } = item;
-        points = transformPoints(points, {
-          normalizeShape: normalizeShape2,
-          widthIncrement,
-          heightIncrement
-        });
-        const roundedPoints = points.map(
-          ([x, y]) => [
-            roundToPrecision(x ?? 0, precision),
-            roundToPrecision(y ?? 0, precision)
-          ]
-        );
-        let minX = Infinity;
-        let minY = Infinity;
-        let maxX = -Infinity;
-        let maxY = -Infinity;
-        for (const point of roundedPoints) {
-          const [x, y] = point;
-          if (x !== void 0 && y !== void 0) {
-            minX = Math.min(minX, x);
-            minY = Math.min(minY, y);
-            maxX = Math.max(maxX, x);
-            maxY = Math.max(maxY, y);
+      return resultMap;
+    };
+    processAnnotationOrPrediction = (annotation, options) => {
+      const {
+        sortVertical,
+        sortHorizontal,
+        normalizeShape: normalizeShape2,
+        widthIncrement,
+        heightIncrement,
+        precision
+      } = options;
+      const groupedById = /* @__PURE__ */ new Map();
+      for (const resultItem of annotation.result) {
+        const { id } = resultItem;
+        if (!groupedById.has(id)) {
+          groupedById.set(id, []);
+        }
+        groupedById.get(id).push(resultItem);
+      }
+      const enhancedResult = [];
+      for (const [, resultItems] of groupedById) {
+        let ppocrAnnotations = [];
+        for (const resultItem of resultItems) {
+          let points;
+          if ("points" in resultItem.value && resultItem.value.points) {
+            const { points: valuePoints } = resultItem.value;
+            const { original_width, original_height } = resultItem;
+            points = valuePoints.map(([x, y]) => [
+              (x ?? 0) * original_width / 100,
+              (y ?? 0) * original_height / 100
+            ]);
+          } else if ("x" in resultItem.value && "y" in resultItem.value && "width" in resultItem.value && "height" in resultItem.value) {
+            const { x, y, width, height } = resultItem.value;
+            const { original_width, original_height } = resultItem;
+            const absX = x * original_width / 100;
+            const absY = y * original_height / 100;
+            const absWidth = width * original_width / 100;
+            const absHeight = height * original_height / 100;
+            points = [
+              [absX, absY],
+              [absX + absWidth, absY],
+              [absX + absWidth, absY + absHeight],
+              [absX, absY + absHeight]
+            ];
+          }
+          if (points) {
+            ppocrAnnotations.push({
+              transcription: "",
+              points,
+              dt_score: 1
+            });
           }
         }
-        const width = maxX - minX;
-        const height = maxY - minY;
-        return {
-          ocr: encodeURI(`${newBaseServerUrl}${imagePath}`),
-          id: index + 1,
-          bbox: [
-            {
-              x: minX,
-              y: minY,
-              width,
-              height,
-              rotation: 0,
-              original_width,
-              original_height
+        if (ppocrAnnotations.length > 0) {
+          ppocrAnnotations = enhancePPOCRLabel(ppocrAnnotations, {
+            sortVertical,
+            sortHorizontal,
+            normalizeShape: normalizeShape2,
+            widthIncrement,
+            heightIncrement,
+            precision
+          });
+          for (let i = 0; i < resultItems.length; i++) {
+            const resultItem = resultItems[i];
+            const enhanced = ppocrAnnotations[i];
+            if (!enhanced) {
+              enhancedResult.push(resultItem);
+              continue;
             }
-          ],
-          label: [
-            {
-              points: roundedPoints,
-              closed: true,
-              labels: [labelName],
-              original_width,
-              original_height
+            if ("points" in resultItem.value && resultItem.value.points) {
+              const { original_width, original_height } = resultItem;
+              enhancedResult.push({
+                ...resultItem,
+                value: {
+                  ...resultItem.value,
+                  points: enhanced.points.map(
+                    ([x, y]) => [
+                      (x ?? 0) / original_width * 100,
+                      (y ?? 0) / original_height * 100
+                    ]
+                  )
+                }
+              });
+            } else if ("x" in resultItem.value && "y" in resultItem.value && "width" in resultItem.value && "height" in resultItem.value) {
+              const { original_width, original_height } = resultItem;
+              const xs = enhanced.points.map(([x]) => x ?? 0);
+              const ys = enhanced.points.map(([, y]) => y ?? 0);
+              const minX = Math.min(...xs);
+              const maxX = Math.max(...xs);
+              const minY = Math.min(...ys);
+              const maxY = Math.max(...ys);
+              enhancedResult.push({
+                ...resultItem,
+                value: {
+                  ...resultItem.value,
+                  x: minX / original_width * 100,
+                  y: minY / original_height * 100,
+                  width: (maxX - minX) / original_width * 100,
+                  height: (maxY - minY) / original_height * 100
+                }
+              });
+            } else {
+              enhancedResult.push(resultItem);
             }
-          ],
-          transcription: [item.transcription],
-          poly: [
-            {
-              points: roundedPoints,
-              closed: true,
-              original_width,
-              original_height
+          }
+        } else {
+          enhancedResult.push(...resultItems);
+        }
+      }
+      return {
+        ...annotation,
+        result: enhancedResult
+      };
+    };
+    enhanceLabelStudioData = async (data, isFull, options) => {
+      const {
+        sortVertical,
+        sortHorizontal,
+        normalizeShape: normalizeShape2,
+        widthIncrement = 0,
+        heightIncrement = 0,
+        precision = 0,
+        outputMode
+      } = options;
+      if (isFull) {
+        const fullData = data;
+        const isPredictions = outputMode === OUTPUT_MODE_PREDICTIONS;
+        return fullData.map((task) => {
+          const processOptions = {
+            sortVertical,
+            sortHorizontal,
+            normalizeShape: normalizeShape2,
+            widthIncrement,
+            heightIncrement,
+            precision
+          };
+          const allItems = [
+            ...task.annotations.map((a) => ({
+              item: a,
+              source: "annotations"
+            })),
+            ...(task.predictions || []).map((p) => ({
+              item: p,
+              source: "predictions"
+            }))
+          ];
+          const processedItems = allItems.map(
+            ({ item }) => (
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              processAnnotationOrPrediction(item, processOptions)
+            )
+          );
+          if (isPredictions) {
+            return {
+              ...task,
+              annotations: [],
+              predictions: processedItems,
+              total_annotations: 0,
+              total_predictions: processedItems.length
+            };
+          } else {
+            return {
+              ...task,
+              annotations: processedItems,
+              predictions: [],
+              total_annotations: processedItems.length,
+              total_predictions: 0
+            };
+          }
+        });
+      } else {
+        const minData = data;
+        return minData.map((item) => {
+          let ppocrAnnotations = [];
+          const numAnnotations = Math.max(
+            item.poly?.length || 0,
+            item.bbox?.length || 0,
+            item.transcription?.length || 0
+          );
+          for (let i = 0; i < numAnnotations; i++) {
+            let points;
+            if (item.poly && item.poly.length > i && item.poly[i]) {
+              const { points: polyPoints } = item.poly[i];
+              points = polyPoints;
+            } else if (item.bbox && item.bbox.length > i && item.bbox[i]) {
+              const { x, y, width, height } = item.bbox[i];
+              points = [
+                [x, y],
+                [x + width, y],
+                [x + width, y + height],
+                [x, y + height]
+              ];
             }
-          ],
-          annotator: 1,
-          annotation_id: index + 1,
-          created_at: now,
-          updated_at: now,
-          lead_time: 0
-        };
-      });
+            if (points) {
+              ppocrAnnotations.push({
+                transcription: item.transcription && item.transcription.length > i ? item.transcription[i] ?? "" : "",
+                points,
+                dt_score: 1
+              });
+            }
+          }
+          if (ppocrAnnotations.length > 0) {
+            ppocrAnnotations = enhancePPOCRLabel(ppocrAnnotations, {
+              sortVertical,
+              sortHorizontal,
+              normalizeShape: normalizeShape2,
+              widthIncrement,
+              heightIncrement,
+              precision
+            });
+            const newPoly = ppocrAnnotations.map((ann) => ({
+              points: ann.points
+            }));
+            const { bbox: _, ...itemWithoutBbox } = item;
+            return {
+              ...itemWithoutBbox,
+              poly: newPoly
+            };
+          }
+          return item;
+        });
+      }
     };
   }
 });
@@ -763,507 +1102,860 @@ var init_schema = __esm({
       import_zod.default.object({
         transcription: import_zod.default.string(),
         points: import_zod.default.array(import_zod.default.array(import_zod.default.number())),
-        dt_score: import_zod.default.number()
+        dt_score: import_zod.default.number().optional(),
+        // Detection score (from PaddleOCR)
+        difficult: import_zod.default.boolean().optional()
+        // Difficult flag (from PPOCRLabel tool)
       })
     );
   }
 });
 
-// src/lib/sort.ts
-function getBoundingBoxCenter(points) {
-  let minX = Infinity;
-  let minY = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  for (const [x, y] of points) {
-    if (x !== void 0 && y !== void 0) {
-      minX = Math.min(minX, x);
-      minY = Math.min(minY, y);
-      maxX = Math.max(maxX, x);
-      maxY = Math.max(maxY, y);
-    }
-  }
-  return {
-    x: (minX + maxX) / 2,
-    y: (minY + maxY) / 2,
-    width: maxX - minX,
-    height: maxY - minY
-  };
-}
-function sortBoundingBoxes(annotations, verticalSort, horizontalSort) {
-  if (verticalSort === SORT_VERTICAL_NONE && horizontalSort === SORT_HORIZONTAL_NONE) {
-    return annotations;
+// src/commands/enhance-labelstudio/impl.ts
+var impl_exports = {};
+__export(impl_exports, {
+  enhanceLabelStudio: () => enhanceLabelStudio
+});
+async function enhanceLabelStudio(flags, ...inputDirs) {
+  const {
+    outDir,
+    fileName,
+    backup = false,
+    sortVertical = DEFAULT_SORT_VERTICAL,
+    sortHorizontal = DEFAULT_SORT_HORIZONTAL,
+    normalizeShape: normalizeShape2 = DEFAULT_SHAPE_NORMALIZE,
+    widthIncrement = DEFAULT_WIDTH_INCREMENT,
+    heightIncrement = DEFAULT_HEIGHT_INCREMENT,
+    precision = DEFAULT_LABEL_STUDIO_PRECISION,
+    recursive = DEFAULT_RECURSIVE,
+    filePattern = DEFAULT_LABEL_STUDIO_FILE_PATTERN,
+    outputMode = DEFAULT_OUTPUT_MODE
+  } = flags;
+  console.log(import_chalk.default.blue("Finding files..."));
+  const filePaths = await findFiles(inputDirs, filePattern, recursive);
+  if (filePaths.length === 0) {
+    console.log(import_chalk.default.yellow("No files found matching the pattern."));
+    return;
   }
-  const sorted = [...annotations];
-  const isVerticalText = sorted.length > 0 && (() => {
-    const verticalCount = sorted.filter((ann) => {
-      const center = getBoundingBoxCenter(ann.points);
-      return center.height > center.width * 1.5;
-    }).length;
-    return verticalCount > sorted.length / 2;
-  })();
-  if (horizontalSort === SORT_HORIZONTAL_RTL && verticalSort !== SORT_VERTICAL_NONE && isVerticalText) {
-    const annotationsWithCenters = sorted.map((ann) => ({
-      annotation: ann,
-      center: getBoundingBoxCenter(ann.points)
-    }));
-    const columns = [];
-    for (const item of annotationsWithCenters) {
-      let addedToColumn = false;
-      for (const column of columns) {
-        const avgX = column.reduce((sum, c) => sum + c.center.x, 0) / column.length;
-        if (Math.abs(item.center.x - avgX) < GROUPING_TOLERANCE) {
-          column.push(item);
-          addedToColumn = true;
-          break;
-        }
-      }
-      if (!addedToColumn) {
-        columns.push([item]);
+  console.log(import_chalk.default.blue(`Found ${filePaths.length} files to process
+`));
+  for (const filePath of filePaths) {
+    const file = (0, import_path2.basename)(filePath);
+    console.log(import_chalk.default.gray(`Processing file: ${filePath}`));
+    try {
+      const fileData = await (0, import_promises2.readFile)(filePath, "utf-8");
+      const labelStudioData = JSON.parse(fileData);
+      const { data, isFull } = isLabelStudioFullJSON(labelStudioData);
+      if (outputMode !== DEFAULT_OUTPUT_MODE && !isFull) {
+        console.log(
+          import_chalk.default.red(
+            `  Skipping file: ${filePath}
+  Error: --outputMode can only be used with Full JSON format. This file is in Min JSON format which does not support annotations/predictions distinction.`
+          )
+        );
+        continue;
       }
-    }
-    columns.sort((colA, colB) => {
-      const avgXA = colA.reduce((sum, c) => sum + c.center.x, 0) / colA.length;
-      const avgXB = colB.reduce((sum, c) => sum + c.center.x, 0) / colB.length;
-      return avgXB - avgXA;
-    });
-    for (const column of columns) {
-      column.sort((a, b) => {
-        return verticalSort === SORT_VERTICAL_TOP_BOTTOM ? a.center.y - b.center.y : b.center.y - a.center.y;
+      const enhanced = await enhanceLabelStudioData(data, isFull, {
+        sortVertical,
+        sortHorizontal,
+        normalizeShape: normalizeShape2 !== SHAPE_NORMALIZE_NONE ? normalizeShape2 : void 0,
+        widthIncrement,
+        heightIncrement,
+        precision,
+        outputMode
       });
-    }
-    return columns.flat().map((item) => item.annotation);
-  }
-  sorted.sort((a, b) => {
-    const centerA = getBoundingBoxCenter(a.points);
-    const centerB = getBoundingBoxCenter(b.points);
-    if (verticalSort !== SORT_VERTICAL_NONE) {
-      const yDiff = verticalSort === SORT_VERTICAL_TOP_BOTTOM ? centerA.y - centerB.y : centerB.y - centerA.y;
-      if (Math.abs(yDiff) > GROUPING_TOLERANCE) {
-        return yDiff;
+      const outputSubDir = outDir ? (() => {
+        const relativePath = getRelativePathFromInputs(filePath, inputDirs);
+        const relativeDir = (0, import_path2.dirname)(relativePath);
+        return (0, import_path2.join)(outDir, relativeDir);
+      })() : (0, import_path2.dirname)(filePath);
+      await (0, import_promises2.mkdir)(outputSubDir, { recursive: true });
+      const outputFileName = fileName || file;
+      const outputFilePath = (0, import_path2.join)(outputSubDir, outputFileName);
+      if (backup) {
+        const backupPath = await backupFileIfExists(outputFilePath);
+        if (backupPath) {
+          console.log(import_chalk.default.gray(`  Backed up to: ${backupPath}`));
+        }
       }
+      await (0, import_promises2.writeFile)(
+        outputFilePath,
+        JSON.stringify(enhanced, null, 2),
+        "utf-8"
+      );
+      console.log(import_chalk.default.green(`\u2713 Enhanced file saved: ${outputFilePath}`));
+    } catch (error) {
+      console.error(
+        import_chalk.default.red(`Error processing file ${file}:`),
+        error instanceof Error ? error.message : String(error)
+      );
     }
-    if (horizontalSort !== SORT_HORIZONTAL_NONE) {
-      return horizontalSort === SORT_HORIZONTAL_LTR ? centerA.x - centerB.x : centerB.x - centerA.x;
-    }
-    return 0;
-  });
-  return sorted;
+  }
+  console.log(import_chalk.default.green("\n\u2713 Enhancement complete!"));
 }
-var GROUPING_TOLERANCE;
-var init_sort = __esm({
-  "src/lib/sort.ts"() {
+var import_promises2, import_path2, import_chalk, isLabelStudioFullJSON;
+var init_impl = __esm({
+  "src/commands/enhance-labelstudio/impl.ts"() {
     "use strict";
     init_cjs_shims();
+    import_promises2 = require("fs/promises");
+    import_path2 = require("path");
+    import_chalk = __toESM(require("chalk"), 1);
     init_constants();
-    GROUPING_TOLERANCE = 50;
+    init_backup_utils();
+    init_file_utils();
+    init_label_studio();
+    init_schema();
+    isLabelStudioFullJSON = (data) => {
+      const parsedFull = FullOCRLabelStudioSchema.safeParse(data);
+      if (parsedFull.success) {
+        return { isFull: true, data: parsedFull.data };
+      }
+      if (!Array.isArray(data) && typeof data === "object" && data !== null) {
+        const parsedSingleFull = FullOCRLabelStudioSchema.safeParse([data]);
+        if (parsedSingleFull.success) {
+          return { isFull: true, data: parsedSingleFull.data };
+        }
+      }
+      const parsedMin = MinOCRLabelStudioSchema.safeParse(data);
+      if (parsedMin.success) {
+        return { isFull: false, data: parsedMin.data };
+      }
+      throw new Error("Input data is not valid Label Studio JSON format.");
+    };
   }
 });
 
-// src/commands/toLabelStudio/impl.ts
-var impl_exports = {};
-__export(impl_exports, {
-  convertToLabelStudio: () => convertToLabelStudio
+// src/commands/enhance-ppocr/impl.ts
+var impl_exports2 = {};
+__export(impl_exports2, {
+  enhancePPOCR: () => enhancePPOCR
 });
-async function convertToLabelStudio(flags, ...inputDirs) {
+async function enhancePPOCR(flags, ...inputDirs) {
   const {
-    outDir = OUTPUT_BASE_DIR,
-    defaultLabelName = DEFAULT_LABEL_NAME,
-    toFullJson = DEFAULT_LABEL_STUDIO_FULL_JSON,
-    createFilePerImage = DEFAULT_CREATE_FILE_PER_IMAGE,
-    createFileListForServing = DEFAULT_CREATE_FILE_LIST_FOR_SERVING,
-    fileListName = DEFAULT_FILE_LIST_NAME,
-    baseServerUrl = DEFAULT_BASE_SERVER_URL,
+    outDir,
+    fileName,
+    backup = false,
     sortVertical = DEFAULT_SORT_VERTICAL,
     sortHorizontal = DEFAULT_SORT_HORIZONTAL,
     normalizeShape: normalizeShape2 = DEFAULT_SHAPE_NORMALIZE,
     widthIncrement = DEFAULT_WIDTH_INCREMENT,
     heightIncrement = DEFAULT_HEIGHT_INCREMENT,
-    precision = DEFAULT_LABEL_STUDIO_PRECISION
+    precision = DEFAULT_PPOCR_PRECISION,
+    recursive = DEFAULT_RECURSIVE,
+    filePattern = DEFAULT_PPOCR_FILE_PATTERN
   } = flags;
-  const newBaseServerUrl = baseServerUrl.replace(/\/+$/, "") + (baseServerUrl === "" ? "" : "/");
-  await (0, import_promises.mkdir)(outDir, { recursive: true });
-  for (const inputDir of inputDirs) {
-    console.log(import_chalk.default.blue(`Processing input directory: ${inputDir}`));
-    const files = await (0, import_promises.readdir)(inputDir);
-    for (const file of files) {
-      if (!file.endsWith(".txt")) {
-        continue;
-      }
-      const filePath = (0, import_path.join)(inputDir, file);
-      console.log(import_chalk.default.gray(`Processing file: ${file}`));
-      try {
-        const fileData = await (0, import_promises.readFile)(filePath, "utf-8");
-        const lines = fileData.trim().split("\n");
-        const imageDataMap = /* @__PURE__ */ new Map();
-        for (const line of lines) {
-          const parts = line.split("	");
-          if (parts.length !== 2) {
-            throw new Error(`Invalid PPOCRLabelV2 format in line: ${line}`);
-          }
-          const [imagePath, annotationsStr] = parts;
-          const annotations = JSON.parse(annotationsStr);
-          PPOCRLabelSchema.parse(annotations);
-          imageDataMap.set(imagePath, annotations);
-        }
-        const allLabelStudioData = [];
-        const fileList = [];
-        let taskId = 1;
-        for (const [imagePath, ppocrData] of imageDataMap.entries()) {
-          const sortedPpocrData = sortBoundingBoxes(
-            ppocrData,
-            sortVertical,
-            sortHorizontal
-          );
-          const finalImagePath = createFileListForServing ? encodeURI(`${newBaseServerUrl}${imagePath}`) : imagePath;
-          const labelStudioData = await ppocrToLabelStudio(sortedPpocrData, {
-            toFullJson,
-            imagePath,
-            baseServerUrl: newBaseServerUrl,
-            inputDir,
-            taskId,
-            labelName: defaultLabelName,
-            normalizeShape: normalizeShape2 !== SHAPE_NORMALIZE_NONE ? normalizeShape2 : void 0,
-            widthIncrement,
-            heightIncrement,
-            precision
-          });
-          if (toFullJson) {
-            allLabelStudioData.push(labelStudioData[0]);
-          } else {
-            allLabelStudioData.push(...labelStudioData);
-          }
-          if (createFilePerImage) {
-            const imageBaseName = imagePath.replace(/\//g, "_").replace(/\.[^.]+$/, "");
-            const individualOutputPath = (0, import_path.join)(
-              outDir,
-              `${imageBaseName}_${toFullJson ? "full" : "min"}.json`
-            );
-            await (0, import_promises.writeFile)(
-              individualOutputPath,
-              JSON.stringify(
-                toFullJson ? labelStudioData[0] : labelStudioData,
-                null,
-                2
-              ),
-              "utf-8"
-            );
-            console.log(
-              import_chalk.default.gray(
-                `  \u2713 Created individual file: ${individualOutputPath}`
-              )
-            );
-          }
-          if (createFileListForServing) {
-            fileList.push(finalImagePath);
-          }
-          taskId++;
+  console.log(import_chalk2.default.blue("Finding files..."));
+  const filePaths = await findFiles(inputDirs, filePattern, recursive);
+  if (filePaths.length === 0) {
+    console.log(import_chalk2.default.yellow("No files found matching the pattern."));
+    return;
+  }
+  console.log(import_chalk2.default.blue(`Found ${filePaths.length} files to process
+`));
+  for (const filePath of filePaths) {
+    const file = (0, import_path3.basename)(filePath);
+    console.log(import_chalk2.default.gray(`Processing file: ${filePath}`));
+    try {
+      const fileData = await (0, import_promises3.readFile)(filePath, "utf-8");
+      const lines = fileData.trim().split("\n");
+      const enhancedLines = [];
+      for (const line of lines) {
+        const parts = line.split("	");
+        if (parts.length !== 2) {
+          throw new Error(`Invalid PPOCRLabelV2 format in line: ${line}`);
         }
-        const baseName = file.replace(".txt", "");
-        const outputPath = (0, import_path.join)(
-          outDir,
-          `${baseName}_${toFullJson ? "full" : "min"}.json`
-        );
-        await (0, import_promises.writeFile)(
-          outputPath,
-          JSON.stringify(allLabelStudioData, null, 2),
-          "utf-8"
-        );
-        console.log(import_chalk.default.green(`\u2713 Converted ${file} -> ${outputPath}`));
-        if (createFileListForServing && fileList.length > 0) {
-          const fileListPath = (0, import_path.join)(outDir, fileListName);
-          await (0, import_promises.writeFile)(fileListPath, fileList.join("\n"), "utf-8");
-          console.log(
-            import_chalk.default.green(
-              `\u2713 Created file list: ${fileListPath} (${fileList.length} files)`
-            )
-          );
+        const [imagePath, annotationsStr] = parts;
+        const annotations = JSON.parse(annotationsStr);
+        PPOCRLabelSchema.parse(annotations);
+        const enhanced = enhancePPOCRLabel(annotations, {
+          sortVertical,
+          sortHorizontal,
+          normalizeShape: normalizeShape2 !== SHAPE_NORMALIZE_NONE ? normalizeShape2 : void 0,
+          widthIncrement,
+          heightIncrement,
+          precision
+        });
+        PPOCRLabelSchema.parse(enhanced);
+        const jsonArray = JSON.stringify(enhanced);
+        enhancedLines.push(`${imagePath}	${jsonArray}`);
+      }
+      const outputSubDir = outDir ? (() => {
+        const relativePath = getRelativePathFromInputs(filePath, inputDirs);
+        const relativeDir = (0, import_path3.dirname)(relativePath);
+        return (0, import_path3.join)(outDir, relativeDir);
+      })() : (0, import_path3.dirname)(filePath);
+      await (0, import_promises3.mkdir)(outputSubDir, { recursive: true });
+      const outputFileName = fileName || file;
+      const outputFilePath = (0, import_path3.join)(outputSubDir, outputFileName);
+      if (backup) {
+        const backupPath = await backupFileIfExists(outputFilePath);
+        if (backupPath) {
+          console.log(import_chalk2.default.gray(`  Backed up to: ${backupPath}`));
         }
-      } catch (error) {
-        console.error(
-          import_chalk.default.red(`\u2717 Failed to process ${file}:`),
-          error instanceof Error ? error.message : error
-        );
       }
+      await (0, import_promises3.writeFile)(outputFilePath, enhancedLines.join("\n"), "utf-8");
+      console.log(import_chalk2.default.green(`\u2713 Enhanced file saved: ${outputFilePath}`));
+    } catch (error) {
+      console.error(
+        import_chalk2.default.red(`Error processing file ${file}:`),
+        error instanceof Error ? error.message : String(error)
+      );
     }
   }
-  console.log(import_chalk.default.green("\n\u2713 Conversion completed!"));
+  console.log(import_chalk2.default.green("\n\u2713 Enhancement complete!"));
 }
-var import_promises, import_path, import_chalk;
-var init_impl = __esm({
-  "src/commands/toLabelStudio/impl.ts"() {
+var import_promises3, import_path3, import_chalk2;
+var init_impl2 = __esm({
+  "src/commands/enhance-ppocr/impl.ts"() {
     "use strict";
     init_cjs_shims();
-    import_promises = require("fs/promises");
-    import_path = require("path");
-    import_chalk = __toESM(require("chalk"), 1);
+    import_promises3 = require("fs/promises");
+    import_path3 = require("path");
+    import_chalk2 = __toESM(require("chalk"), 1);
     init_constants();
-    init_ppocr_label();
+    init_backup_utils();
+    init_enhance();
+    init_file_utils();
     init_schema();
-    init_sort();
   }
 });
 
-// src/lib/label-studio.ts
-var turf, labelStudioToPPOCR, minLabelStudioToPPOCR;
-var init_label_studio = __esm({
-  "src/lib/label-studio.ts"() {
+// src/lib/ppocr-label.ts
+var import_node_crypto, import_node_fs, import_node_path, import_image_size, ppocrToLabelStudio, ppocrToFullLabelStudio, ppocrToMinLabelStudio;
+var init_ppocr_label = __esm({
+  "src/lib/ppocr-label.ts"() {
     "use strict";
     init_cjs_shims();
-    turf = __toESM(require("@turf/turf"), 1);
+    import_node_crypto = require("crypto");
+    import_node_fs = require("fs");
+    import_node_path = require("path");
+    import_image_size = __toESM(require("image-size"), 1);
+    init_constants();
     init_geometry();
-    labelStudioToPPOCR = async (data, options) => {
+    ppocrToLabelStudio = async (data, options) => {
       const {
-        baseImageDir,
+        imagePath,
+        baseServerUrl,
+        inputDir,
+        relativeDir,
+        toFullJson = true,
+        taskId = 1,
+        labelName = DEFAULT_LABEL_NAME,
         normalizeShape: normalizeShape2,
         widthIncrement = 0,
         heightIncrement = 0,
-        precision = 0
+        precision = DEFAULT_LABEL_STUDIO_PRECISION,
+        outputMode = DEFAULT_OUTPUT_MODE
       } = options || {};
-      const resultMap = /* @__PURE__ */ new Map();
-      for (const task of data) {
-        let imagePath = task.file_upload || "";
-        if (task.data.ocr) {
-          const urlPath = task.data.ocr.replace(/^https?:\/\/[^/]+\//, "");
-          imagePath = decodeURIComponent(urlPath);
+      if (toFullJson) {
+        return ppocrToFullLabelStudio(
+          data,
+          imagePath,
+          baseServerUrl,
+          inputDir,
+          taskId,
+          labelName,
+          normalizeShape2,
+          widthIncrement,
+          heightIncrement,
+          precision,
+          relativeDir,
+          outputMode
+        );
+      } else {
+        return ppocrToMinLabelStudio(
+          data,
+          imagePath,
+          baseServerUrl,
+          inputDir,
+          labelName,
+          normalizeShape2,
+          widthIncrement,
+          heightIncrement,
+          precision,
+          relativeDir
+        );
+      }
+    };
+    ppocrToFullLabelStudio = (data, imagePath, baseServerUrl, inputDir, taskId = 1, labelName = DEFAULT_LABEL_NAME, normalizeShape2, widthIncrement = 0, heightIncrement = 0, precision = DEFAULT_LABEL_STUDIO_PRECISION, relativeDir, outputMode = DEFAULT_OUTPUT_MODE) => {
+      const newBaseServerUrl = baseServerUrl.replace(/\/+$/, "") + (baseServerUrl === "" ? "" : "/");
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      let original_width = 1920;
+      let original_height = 1080;
+      let resolvedImagePath;
+      if (inputDir) {
+        const lastDirComponent = (0, import_node_path.basename)(inputDir);
+        const imagePathParts = imagePath.split("/");
+        if (imagePathParts[0] === lastDirComponent && imagePathParts.length > 1) {
+          resolvedImagePath = (0, import_node_path.join)(inputDir, imagePathParts.slice(1).join("/"));
+        } else {
+          resolvedImagePath = (0, import_node_path.join)(inputDir, imagePath);
         }
-        if (baseImageDir) {
-          imagePath = `${baseImageDir}/${task.file_upload || imagePath.split("/").pop() || imagePath}`;
+      } else {
+        resolvedImagePath = imagePath;
+      }
+      if ((0, import_node_fs.existsSync)(resolvedImagePath)) {
+        try {
+          const buffer = (0, import_node_fs.readFileSync)(resolvedImagePath);
+          const dimensions = (0, import_image_size.default)(buffer);
+          if (dimensions.width && dimensions.height) {
+            original_width = dimensions.width;
+            original_height = dimensions.height;
+          } else {
+            console.warn(
+              `Warning: Failed to read dimensions from ${resolvedImagePath}, using defaults`
+            );
+          }
+        } catch (error) {
+          console.warn(
+            `Warning: Error reading image ${resolvedImagePath}, using defaults:`,
+            error instanceof Error ? error.message : error
+          );
         }
-        const imageAnnotations = [];
-        for (const annotation of task.annotations) {
-          const groupedById = /* @__PURE__ */ new Map();
-          for (const resultItem of annotation.result) {
-            const { id } = resultItem;
-            if (!groupedById.has(id)) {
-              groupedById.set(id, []);
-            }
-            groupedById.get(id).push(resultItem);
+      } else {
+        console.warn(
+          `Warning: Image file not found: ${resolvedImagePath}, using default dimensions`
+        );
+      }
+      const fileName = imagePath.split("/").pop() || imagePath;
+      let normalizedImagePath = imagePath;
+      if (inputDir && relativeDir) {
+        const lastDirComponent = (0, import_node_path.basename)(inputDir);
+        const imagePathParts = imagePath.split("/");
+        if (imagePathParts[0] === lastDirComponent && imagePathParts.length > 1) {
+          normalizedImagePath = imagePathParts.slice(1).join("/");
+        }
+      }
+      const isPredictions = outputMode === OUTPUT_MODE_PREDICTIONS;
+      const resultItems = data.map((item) => {
+        let { points } = item;
+        points = transformPoints(points, {
+          normalizeShape: normalizeShape2,
+          widthIncrement,
+          heightIncrement
+        });
+        const annotationId = (0, import_node_crypto.randomUUID)().slice(0, 10);
+        const polygonPoints = points.map(([x, y]) => [
+          roundToPrecision((x ?? 0) / original_width * 100, precision),
+          roundToPrecision((y ?? 0) / original_height * 100, precision)
+        ]);
+        const scoreField = isPredictions && item.dt_score !== void 0 ? { score: item.dt_score } : {};
+        return [
+          // 1. Polygon geometry only
+          {
+            original_width,
+            original_height,
+            image_rotation: 0,
+            value: {
+              points: polygonPoints,
+              closed: true
+            },
+            id: annotationId,
+            from_name: "poly",
+            to_name: "image",
+            type: "polygon",
+            origin: "manual",
+            ...scoreField
+          },
+          // 2. Labels with polygon geometry
+          {
+            original_width,
+            original_height,
+            image_rotation: 0,
+            value: {
+              points: polygonPoints,
+              closed: true,
+              labels: [labelName]
+            },
+            id: annotationId,
+            from_name: "label",
+            to_name: "image",
+            type: "labels",
+            origin: "manual",
+            ...scoreField
+          },
+          // 3. Textarea with polygon geometry and text
+          {
+            original_width,
+            original_height,
+            image_rotation: 0,
+            value: {
+              points: polygonPoints,
+              closed: true,
+              text: [item.transcription]
+            },
+            id: annotationId,
+            from_name: "transcription",
+            to_name: "image",
+            type: "textarea",
+            origin: "manual",
+            ...scoreField
           }
-          for (const [_, resultItems] of groupedById) {
-            let points;
-            let transcription = "";
-            for (const resultItem of resultItems) {
-              if ("points" in resultItem.value && resultItem.value.points) {
-                const { points: valuePoints } = resultItem.value;
-                const { original_width, original_height } = resultItem;
-                points = valuePoints.map(([x, y]) => [
-                  (x ?? 0) * original_width / 100,
-                  (y ?? 0) * original_height / 100
-                ]);
-              } else if ("x" in resultItem.value && "y" in resultItem.value && "width" in resultItem.value && "height" in resultItem.value) {
-                const { x, y, width, height } = resultItem.value;
-                const { original_width, original_height } = resultItem;
-                const absX = x * original_width / 100;
-                const absY = y * original_height / 100;
-                const absWidth = width * original_width / 100;
-                const absHeight = height * original_height / 100;
-                points = [
-                  [absX, absY],
-                  [absX + absWidth, absY],
-                  [absX + absWidth, absY + absHeight],
-                  [absX, absY + absHeight]
-                ];
-              }
-              if ("text" in resultItem.value && Array.isArray(resultItem.value.text)) {
-                transcription = resultItem.value.text[0] || "";
-              }
+        ];
+      }).flat();
+      const result = [
+        {
+          id: taskId,
+          annotations: isPredictions ? [] : [
+            {
+              id: taskId,
+              completed_by: 1,
+              result: resultItems,
+              was_cancelled: false,
+              ground_truth: false,
+              created_at: now,
+              updated_at: now,
+              draft_created_at: now,
+              lead_time: 0,
+              prediction: {},
+              result_count: data.length * 3,
+              unique_id: (0, import_node_crypto.randomUUID)(),
+              import_id: null,
+              last_action: null,
+              bulk_created: false,
+              task: taskId,
+              project: 1,
+              updated_by: 1,
+              parent_prediction: null,
+              parent_annotation: null,
+              last_created_by: null
             }
-            if (points && points.length > 0) {
-              points = transformPoints(points, {
-                normalizeShape: normalizeShape2,
-                widthIncrement,
-                heightIncrement
-              });
-              points = roundPoints(points, precision);
-              let dt_score = 1;
-              try {
-                const firstPoint = points[0];
-                if (firstPoint) {
-                  const polygon2 = turf.polygon([points.concat([firstPoint])]);
-                  const area2 = turf.area(polygon2);
-                  dt_score = Math.min(1, Math.max(0.5, area2 / 1e4));
-                }
-              } catch {
-                dt_score = 0.8;
-              }
-              imageAnnotations.push({
-                transcription,
-                points,
-                dt_score
-              });
+          ],
+          file_upload: fileName,
+          drafts: [],
+          predictions: isPredictions ? [
+            {
+              model_version: "ppocr-v1",
+              result: resultItems,
+              created_at: now,
+              task: taskId,
+              project: 1
             }
-          }
+          ] : [],
+          data: {
+            ocr: relativeDir ? `${newBaseServerUrl}${relativeDir}/${normalizedImagePath}` : `${newBaseServerUrl}${normalizedImagePath}`
+          },
+          meta: {},
+          created_at: now,
+          updated_at: now,
+          allow_skip: false,
+          inner_id: taskId,
+          total_annotations: isPredictions ? 0 : 1,
+          cancelled_annotations: 0,
+          total_predictions: isPredictions ? 1 : 0,
+          comment_count: 0,
+          unresolved_comment_count: 0,
+          last_comment_updated_at: null,
+          project: 1,
+          updated_by: 1,
+          comment_authors: []
         }
-        if (imageAnnotations.length > 0) {
-          resultMap.set(imagePath, imageAnnotations);
+      ];
+      return result;
+    };
+    ppocrToMinLabelStudio = (data, imagePath, baseServerUrl, inputDir, labelName = "text", normalizeShape2, widthIncrement = 0, heightIncrement = 0, precision = DEFAULT_LABEL_STUDIO_PRECISION, relativeDir) => {
+      const newBaseServerUrl = baseServerUrl.replace(/\/+$/, "") + (baseServerUrl === "" ? "" : "/");
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      let original_width = 1920;
+      let original_height = 1080;
+      let resolvedImagePath;
+      if (inputDir) {
+        const lastDirComponent = (0, import_node_path.basename)(inputDir);
+        const imagePathParts = imagePath.split("/");
+        if (imagePathParts[0] === lastDirComponent && imagePathParts.length > 1) {
+          resolvedImagePath = (0, import_node_path.join)(inputDir, imagePathParts.slice(1).join("/"));
+        } else {
+          resolvedImagePath = (0, import_node_path.join)(inputDir, imagePath);
         }
+      } else {
+        resolvedImagePath = imagePath;
       }
-      return resultMap;
-    };
-    minLabelStudioToPPOCR = async (data, options) => {
-      const {
-        baseImageDir,
-        normalizeShape: normalizeShape2,
-        widthIncrement = 0,
-        heightIncrement = 0,
-        precision = 0
-      } = options || {};
-      const resultMap = /* @__PURE__ */ new Map();
-      for (const item of data) {
-        let imagePath = item.ocr || "";
-        if (imagePath) {
-          imagePath = decodeURIComponent(
-            imagePath.replace(/^https?:\/\/[^/]+\//, "")
+      if ((0, import_node_fs.existsSync)(resolvedImagePath)) {
+        try {
+          const buffer = (0, import_node_fs.readFileSync)(resolvedImagePath);
+          const dimensions = (0, import_image_size.default)(buffer);
+          if (dimensions.width && dimensions.height) {
+            original_width = dimensions.width;
+            original_height = dimensions.height;
+          } else {
+            console.warn(
+              `Warning: Failed to read dimensions from ${resolvedImagePath}, using defaults`
+            );
+          }
+        } catch (error) {
+          console.warn(
+            `Warning: Error reading image ${resolvedImagePath}, using defaults:`,
+            error instanceof Error ? error.message : error
           );
         }
-        if (baseImageDir) {
-          imagePath = `${baseImageDir}/${imagePath.split("/").pop() || imagePath}`;
+      } else {
+        console.warn(
+          `Warning: Image file not found: ${resolvedImagePath}, using default dimensions`
+        );
+      }
+      let normalizedImagePath = imagePath;
+      if (inputDir && relativeDir) {
+        const lastDirComponent = (0, import_node_path.basename)(inputDir);
+        const imagePathParts = imagePath.split("/");
+        if (imagePathParts[0] === lastDirComponent && imagePathParts.length > 1) {
+          normalizedImagePath = imagePathParts.slice(1).join("/");
         }
-        const numAnnotations = Math.max(
-          item.poly?.length || 0,
-          item.bbox?.length || 0,
-          item.transcription?.length || 0
+      }
+      return data.map((item, index) => {
+        let { points } = item;
+        points = transformPoints(points, {
+          normalizeShape: normalizeShape2,
+          widthIncrement,
+          heightIncrement
+        });
+        const roundedPoints = points.map(
+          ([x, y]) => [
+            roundToPrecision(x ?? 0, precision),
+            roundToPrecision(y ?? 0, precision)
+          ]
         );
-        for (let i = 0; i < numAnnotations; i++) {
-          let points;
-          if (item.poly && item.poly.length > i && item.poly[i]) {
-            const poly = item.poly[i];
-            if (poly) {
-              const { points: polyPoints } = poly;
-              points = polyPoints;
+        let minX = Infinity;
+        let minY = Infinity;
+        let maxX = -Infinity;
+        let maxY = -Infinity;
+        for (const point of roundedPoints) {
+          const [x, y] = point;
+          if (x !== void 0 && y !== void 0) {
+            minX = Math.min(minX, x);
+            minY = Math.min(minY, y);
+            maxX = Math.max(maxX, x);
+            maxY = Math.max(maxY, y);
+          }
+        }
+        const width = maxX - minX;
+        const height = maxY - minY;
+        return {
+          ocr: relativeDir ? encodeURI(`${newBaseServerUrl}${relativeDir}/${normalizedImagePath}`) : encodeURI(`${newBaseServerUrl}${normalizedImagePath}`),
+          id: index + 1,
+          bbox: [
+            {
+              x: minX,
+              y: minY,
+              width,
+              height,
+              rotation: 0,
+              original_width,
+              original_height
             }
-          } else if (item.bbox && item.bbox.length > i && item.bbox[i]) {
-            const bbox = item.bbox[i];
-            if (bbox) {
-              const { x, y, width, height } = bbox;
-              points = [
-                [x, y],
-                [x + width, y],
-                [x + width, y + height],
-                [x, y + height]
-              ];
+          ],
+          label: [
+            {
+              points: roundedPoints,
+              closed: true,
+              labels: [labelName],
+              original_width,
+              original_height
             }
-          }
-          if (!points) {
-            continue;
-          }
-          points = transformPoints(points, {
-            normalizeShape: normalizeShape2,
-            widthIncrement,
-            heightIncrement
+          ],
+          transcription: [item.transcription],
+          poly: [
+            {
+              points: roundedPoints,
+              closed: true,
+              original_width,
+              original_height
+            }
+          ],
+          annotator: 1,
+          annotation_id: index + 1,
+          created_at: now,
+          updated_at: now,
+          lead_time: 0
+        };
+      });
+    };
+  }
+});
+
+// src/commands/toLabelStudio/impl.ts
+var impl_exports3 = {};
+__export(impl_exports3, {
+  convertToLabelStudio: () => convertToLabelStudio
+});
+async function convertToLabelStudio(flags, ...inputDirs) {
+  const {
+    outDir,
+    fileName,
+    backup = false,
+    defaultLabelName = DEFAULT_LABEL_NAME,
+    toFullJson = DEFAULT_LABEL_STUDIO_FULL_JSON,
+    createFilePerImage = DEFAULT_CREATE_FILE_PER_IMAGE,
+    createFileListForServing = DEFAULT_CREATE_FILE_LIST_FOR_SERVING,
+    fileListName = DEFAULT_FILE_LIST_NAME,
+    baseServerUrl = DEFAULT_BASE_SERVER_URL,
+    sortVertical = DEFAULT_SORT_VERTICAL,
+    sortHorizontal = DEFAULT_SORT_HORIZONTAL,
+    normalizeShape: normalizeShape2 = DEFAULT_SHAPE_NORMALIZE,
+    widthIncrement = DEFAULT_WIDTH_INCREMENT,
+    heightIncrement = DEFAULT_HEIGHT_INCREMENT,
+    precision = DEFAULT_LABEL_STUDIO_PRECISION,
+    recursive = DEFAULT_RECURSIVE,
+    filePattern = DEFAULT_PPOCR_FILE_PATTERN,
+    outputMode = DEFAULT_OUTPUT_MODE
+  } = flags;
+  if (outputMode !== DEFAULT_OUTPUT_MODE && !toFullJson) {
+    console.log(
+      import_chalk3.default.red(
+        "Error: --outputMode can only be used with --toFullJson (Full JSON format). Min JSON format does not support annotations/predictions distinction."
+      )
+    );
+    return;
+  }
+  const newBaseServerUrl = baseServerUrl.replace(/\/+$/, "") + (baseServerUrl === "" ? "" : "");
+  console.log(import_chalk3.default.blue("Finding files..."));
+  const filePaths = await findFiles(inputDirs, filePattern, recursive);
+  if (filePaths.length === 0) {
+    console.log(import_chalk3.default.yellow("No files found matching the pattern."));
+    return;
+  }
+  console.log(import_chalk3.default.blue(`Found ${filePaths.length} files to process
+`));
+  let fileListPath = null;
+  if (createFileListForServing && outDir) {
+    fileListPath = (0, import_path4.join)(outDir, fileListName);
+    await (0, import_promises4.mkdir)(outDir, { recursive: true });
+    await (0, import_promises4.writeFile)(fileListPath, "", "utf-8");
+  }
+  for (const filePath of filePaths) {
+    const file = (0, import_path4.basename)(filePath);
+    const baseImageDir = (0, import_path4.dirname)(filePath);
+    const relativePath = getRelativePathFromInputs(filePath, inputDirs);
+    const relativeDir = (0, import_path4.dirname)(relativePath);
+    console.log(import_chalk3.default.gray(`Processing file: ${filePath}`));
+    try {
+      const fileData = await (0, import_promises4.readFile)(filePath, "utf-8");
+      const trimmedData = fileData.trim();
+      if (trimmedData === "") {
+        console.log(import_chalk3.default.yellow(`  Skipping empty file: ${filePath}`));
+        continue;
+      }
+      const lines = trimmedData.split("\n");
+      const imageDataMap = /* @__PURE__ */ new Map();
+      for (const line of lines) {
+        if (line.trim() === "") {
+          continue;
+        }
+        const parts = line.split("	");
+        if (parts.length !== 2) {
+          throw new Error(`Invalid PPOCRLabelV2 format in line: ${line}`);
+        }
+        const [imagePath, annotationsStr] = parts;
+        const annotations = JSON.parse(annotationsStr);
+        PPOCRLabelSchema.parse(annotations);
+        imageDataMap.set(imagePath, annotations);
+      }
+      if (imageDataMap.size === 0) {
+        console.log(
+          import_chalk3.default.yellow(`  Skipping file with no valid data: ${filePath}`)
+        );
+        continue;
+      }
+      const allLabelStudioData = [];
+      let taskId = 1;
+      for (const [imagePath, ppocrData] of imageDataMap.entries()) {
+        const sortedPpocrData = sortBoundingBoxes(
+          ppocrData,
+          sortVertical,
+          sortHorizontal
+        );
+        const finalImagePath = createFileListForServing ? encodeURI(`${newBaseServerUrl}${relativeDir}/${imagePath}`) : imagePath;
+        const labelStudioData = await ppocrToLabelStudio(sortedPpocrData, {
+          toFullJson,
+          imagePath,
+          baseServerUrl: newBaseServerUrl,
+          inputDir: baseImageDir,
+          relativeDir,
+          taskId,
+          labelName: defaultLabelName,
+          normalizeShape: normalizeShape2 !== SHAPE_NORMALIZE_NONE ? normalizeShape2 : void 0,
+          widthIncrement,
+          heightIncrement,
+          precision,
+          outputMode
+        });
+        if (toFullJson) {
+          allLabelStudioData.push(labelStudioData[0]);
+        } else {
+          allLabelStudioData.push(...labelStudioData);
+        }
+        if (createFilePerImage) {
+          const imageBaseName = imagePath.replace(/\//g, "_").replace(/\.[^.]+$/, "");
+          const outputSubDir2 = outDir ? (0, import_path4.join)(outDir, relativeDir) : (0, import_path4.dirname)(filePath);
+          await (0, import_promises4.mkdir)(outputSubDir2, { recursive: true });
+          const individualOutputPath = (0, import_path4.join)(
+            outputSubDir2,
+            `${imageBaseName}_${toFullJson ? "full" : "min"}.json`
+          );
+          await (0, import_promises4.writeFile)(
+            individualOutputPath,
+            JSON.stringify(
+              toFullJson ? labelStudioData[0] : labelStudioData,
+              null,
+              2
+            ),
+            "utf-8"
+          );
+          console.log(
+            import_chalk3.default.gray(`  \u2713 Created individual file: ${individualOutputPath}`)
+          );
+        }
+        if (fileListPath) {
+          await (0, import_promises4.writeFile)(fileListPath, `${finalImagePath}
+`, {
+            encoding: "utf-8",
+            flag: "a"
           });
-          points = roundPoints(points, precision);
-          const transcription = item.transcription && item.transcription.length > i ? item.transcription[i] : "";
-          let dt_score = 1;
-          try {
-            const firstPoint = points[0];
-            if (firstPoint) {
-              const polygon2 = turf.polygon([points.concat([firstPoint])]);
-              const area2 = turf.area(polygon2);
-              dt_score = Math.min(1, Math.max(0.5, area2 / 1e4));
-            }
-          } catch {
-            dt_score = 0.8;
-          }
-          const annotation = {
-            transcription: transcription ?? "",
-            points,
-            dt_score
-          };
-          if (!resultMap.has(imagePath)) {
-            resultMap.set(imagePath, []);
-          }
-          resultMap.get(imagePath).push(annotation);
         }
+        taskId++;
       }
-      return resultMap;
-    };
+      const baseName = fileName || file.replace(".txt", "");
+      const outputSubDir = outDir ? (0, import_path4.join)(outDir, relativeDir) : (0, import_path4.dirname)(filePath);
+      await (0, import_promises4.mkdir)(outputSubDir, { recursive: true });
+      const outputPath = (0, import_path4.join)(
+        outputSubDir,
+        fileName ? `${fileName}.json` : `${baseName}_${toFullJson ? "full" : "min"}.json`
+      );
+      if (backup) {
+        const backupPath = await backupFileIfExists(outputPath);
+        if (backupPath) {
+          console.log(import_chalk3.default.gray(`  \u2713 Created backup: ${backupPath}`));
+        }
+      }
+      await (0, import_promises4.writeFile)(
+        outputPath,
+        JSON.stringify(allLabelStudioData, null, 2),
+        "utf-8"
+      );
+      console.log(import_chalk3.default.green(`\u2713 Converted ${file} -> ${outputPath}`));
+    } catch (error) {
+      console.error(
+        import_chalk3.default.red(`\u2717 Failed to process ${file}:`),
+        error instanceof Error ? error.message : error
+      );
+    }
+  }
+  console.log(import_chalk3.default.green("\n\u2713 Conversion completed!"));
+}
+var import_promises4, import_path4, import_chalk3;
+var init_impl3 = __esm({
+  "src/commands/toLabelStudio/impl.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_promises4 = require("fs/promises");
+    import_path4 = require("path");
+    import_chalk3 = __toESM(require("chalk"), 1);
+    init_constants();
+    init_backup_utils();
+    init_file_utils();
+    init_ppocr_label();
+    init_schema();
+    init_sort();
   }
 });
 
 // src/commands/toPPOCR/impl.ts
-var impl_exports2 = {};
-__export(impl_exports2, {
+var impl_exports4 = {};
+__export(impl_exports4, {
   convertToPPOCR: () => convertToPPOCR
 });
 async function convertToPPOCR(flags, ...inputDirs) {
   const {
-    outDir = `${OUTPUT_BASE_DIR}`,
+    outDir,
     fileName = DEFAULT_PPOCR_FILE_NAME,
+    backup = false,
     baseImageDir,
     sortVertical = DEFAULT_SORT_VERTICAL,
     sortHorizontal = DEFAULT_SORT_HORIZONTAL,
     normalizeShape: normalizeShape2 = DEFAULT_SHAPE_NORMALIZE,
     widthIncrement = DEFAULT_WIDTH_INCREMENT,
     heightIncrement = DEFAULT_HEIGHT_INCREMENT,
-    precision = DEFAULT_PPOCR_PRECISION
+    precision = DEFAULT_PPOCR_PRECISION,
+    recursive = DEFAULT_RECURSIVE,
+    filePattern = DEFAULT_LABEL_STUDIO_FILE_PATTERN
   } = flags;
-  await (0, import_promises2.mkdir)(outDir, { recursive: true });
-  for (const inputDir of inputDirs) {
-    console.log(import_chalk2.default.blue(`Processing input directory: ${inputDir}`));
-    const files = await (0, import_promises2.readdir)(inputDir);
-    for (const file of files) {
-      if (!file.endsWith(".json")) {
-        continue;
+  console.log(import_chalk4.default.blue("Finding files..."));
+  const filePaths = await findFiles(inputDirs, filePattern, recursive);
+  if (filePaths.length === 0) {
+    console.log(import_chalk4.default.yellow("No files found matching the pattern."));
+    return;
+  }
+  console.log(import_chalk4.default.blue(`Found ${filePaths.length} files to process
+`));
+  for (const filePath of filePaths) {
+    const file = (0, import_path5.basename)(filePath);
+    const relativePath = getRelativePathFromInputs(filePath, inputDirs);
+    const relativeDir = (0, import_path5.dirname)(relativePath);
+    console.log(import_chalk4.default.gray(`Processing file: ${filePath}`));
+    try {
+      const fileData = await (0, import_promises5.readFile)(filePath, "utf-8");
+      const labelStudioData = JSON.parse(fileData);
+      const { data, isFull } = isLabelStudioFullJSON2(labelStudioData);
+      const ppocrDataMap = isFull ? await labelStudioToPPOCR(data, {
+        baseImageDir,
+        normalizeShape: normalizeShape2 !== SHAPE_NORMALIZE_NONE ? normalizeShape2 : void 0,
+        widthIncrement,
+        heightIncrement,
+        precision
+      }) : await minLabelStudioToPPOCR(data, {
+        baseImageDir,
+        normalizeShape: normalizeShape2 !== SHAPE_NORMALIZE_NONE ? normalizeShape2 : void 0,
+        widthIncrement,
+        heightIncrement,
+        precision
+      });
+      const outputLines = [];
+      for (const [imagePath, annotations] of ppocrDataMap.entries()) {
+        const sortedAnnotations = sortBoundingBoxes(
+          annotations,
+          sortVertical,
+          sortHorizontal
+        );
+        PPOCRLabelSchema.parse(sortedAnnotations);
+        const jsonArray = JSON.stringify(sortedAnnotations);
+        outputLines.push(`${imagePath}	${jsonArray}`);
       }
-      const filePath = (0, import_path2.join)(inputDir, file);
-      console.log(import_chalk2.default.gray(`Processing file: ${file}`));
-      try {
-        const fileData = await (0, import_promises2.readFile)(filePath, "utf-8");
-        const labelStudioData = JSON.parse(fileData);
-        const { data, isFull } = isLabelStudioFullJSON(labelStudioData);
-        const ppocrDataMap = isFull ? await labelStudioToPPOCR(data, {
-          baseImageDir,
-          normalizeShape: normalizeShape2 !== SHAPE_NORMALIZE_NONE ? normalizeShape2 : void 0,
-          widthIncrement,
-          heightIncrement,
-          precision
-        }) : await minLabelStudioToPPOCR(data, {
-          baseImageDir,
-          normalizeShape: normalizeShape2 !== SHAPE_NORMALIZE_NONE ? normalizeShape2 : void 0,
-          widthIncrement,
-          heightIncrement,
-          precision
-        });
-        const outputLines = [];
-        for (const [imagePath, annotations] of ppocrDataMap.entries()) {
-          const sortedAnnotations = sortBoundingBoxes(
-            annotations,
-            sortVertical,
-            sortHorizontal
-          );
-          PPOCRLabelSchema.parse(sortedAnnotations);
-          const jsonArray = JSON.stringify(sortedAnnotations);
-          outputLines.push(`${imagePath}	${jsonArray}`);
+      const baseName = file.replace(".json", "");
+      const outputSubDir = outDir ? (0, import_path5.join)(outDir, relativeDir) : (0, import_path5.dirname)(filePath);
+      await (0, import_promises5.mkdir)(outputSubDir, { recursive: true });
+      const outputPath = (0, import_path5.join)(outputSubDir, `${baseName}_${fileName}`);
+      if (backup) {
+        const backupPath = await backupFileIfExists(outputPath);
+        if (backupPath) {
+          console.log(import_chalk4.default.gray(`  Backed up to: ${backupPath}`));
         }
-        const baseName = file.replace(".json", "");
-        const outputPath = (0, import_path2.join)(outDir, `${baseName}_${fileName}`);
-        await (0, import_promises2.writeFile)(outputPath, outputLines.join("\n"), "utf-8");
-        console.log(import_chalk2.default.green(`\u2713 Converted ${file} -> ${outputPath}`));
-      } catch (error) {
-        console.error(
-          import_chalk2.default.red(`\u2717 Failed to process ${file}:`),
-          error instanceof Error ? error.message : error
-        );
       }
+      await (0, import_promises5.writeFile)(outputPath, outputLines.join("\n"), "utf-8");
+      console.log(import_chalk4.default.green(`\u2713 Converted ${file} -> ${outputPath}`));
+    } catch (error) {
+      console.error(
+        import_chalk4.default.red(`\u2717 Failed to process ${file}:`),
+        error instanceof Error ? error.message : error
+      );
     }
   }
-  console.log(import_chalk2.default.green("\n\u2713 Conversion completed!"));
+  console.log(import_chalk4.default.green("\n\u2713 Conversion completed!"));
 }
-var import_promises2, import_path2, import_chalk2, isLabelStudioFullJSON;
-var init_impl2 = __esm({
+var import_promises5, import_path5, import_chalk4, isLabelStudioFullJSON2;
+var init_impl4 = __esm({
   "src/commands/toPPOCR/impl.ts"() {
     "use strict";
     init_cjs_shims();
-    import_promises2 = require("fs/promises");
-    import_path2 = require("path");
-    import_chalk2 = __toESM(require("chalk"), 1);
+    import_promises5 = require("fs/promises");
+    import_path5 = require("path");
+    import_chalk4 = __toESM(require("chalk"), 1);
     init_constants();
+    init_backup_utils();
+    init_file_utils();
     init_label_studio();
     init_schema();
     init_sort();
-    isLabelStudioFullJSON = (data) => {
+    isLabelStudioFullJSON2 = (data) => {
       const parsedFull = FullOCRLabelStudioSchema.safeParse(data);
       if (parsedFull.success) {
         return { isFull: true, data: parsedFull.data };
@@ -1285,24 +1977,210 @@ var init_impl2 = __esm({
 
 // src/bin/bash-complete.ts
 init_cjs_shims();
-var import_core4 = require("@stricli/core");
+var import_core6 = require("@stricli/core");
 
 // src/app.ts
 init_cjs_shims();
 var import_auto_complete = require("@stricli/auto-complete");
-var import_core3 = require("@stricli/core");
+var import_core5 = require("@stricli/core");
 
 // package.json
-var version = "1.1.0";
+var version = "1.3.0";
 var description = "Convert between Label Studio OCR format and PPOCRLabelv2 format";
 
-// src/commands/toLabelStudio/command.ts
+// src/commands/enhance-labelstudio/command.ts
 init_cjs_shims();
 var import_core = require("@stricli/core");
 init_constants();
-var toLabelStudioCommand = (0, import_core.buildCommand)({
+var enhanceLabelStudioCommand = (0, import_core.buildCommand)({
+  loader: async () => {
+    const { enhanceLabelStudio: enhanceLabelStudio2 } = await Promise.resolve().then(() => (init_impl(), impl_exports));
+    return enhanceLabelStudio2;
+  },
+  parameters: {
+    positional: {
+      kind: "array",
+      parameter: {
+        brief: "Input directories containing Label Studio JSON files",
+        parse: String
+      },
+      minimum: 1
+    },
+    flags: {
+      outDir: {
+        kind: "parsed",
+        brief: "Output directory. If not specified, files are saved in the same directory as the source files",
+        parse: String,
+        optional: true
+      },
+      fileName: {
+        kind: "parsed",
+        brief: "Custom output filename. If not specified, uses the same name as the source file",
+        parse: String,
+        optional: true
+      },
+      backup: {
+        kind: "boolean",
+        brief: `Create backup of existing files before overwriting. Default: ${DEFAULT_BACKUP}`,
+        optional: true
+      },
+      sortVertical: {
+        kind: "parsed",
+        brief: `Sort bounding boxes vertically. Options: "${SORT_VERTICAL_NONE}", "${SORT_VERTICAL_TOP_BOTTOM}", "${SORT_VERTICAL_BOTTOM_TOP}". Default: "${DEFAULT_SORT_VERTICAL}"`,
+        parse: String,
+        optional: true
+      },
+      sortHorizontal: {
+        kind: "parsed",
+        brief: `Sort bounding boxes horizontally. Options: "${SORT_HORIZONTAL_NONE}", "${SORT_HORIZONTAL_LTR}", "${SORT_HORIZONTAL_RTL}". Default: "${DEFAULT_SORT_HORIZONTAL}"`,
+        parse: String,
+        optional: true
+      },
+      normalizeShape: {
+        kind: "parsed",
+        brief: `Normalize diamond-like shapes to axis-aligned rectangles. Options: "${SHAPE_NORMALIZE_NONE}", "${SHAPE_NORMALIZE_RECTANGLE}". Default: "${DEFAULT_SHAPE_NORMALIZE}"`,
+        parse: String,
+        optional: true
+      },
+      widthIncrement: {
+        kind: "parsed",
+        brief: `Increase bounding box width by this amount (in pixels). Can be negative to decrease. Default: ${DEFAULT_WIDTH_INCREMENT}`,
+        parse: Number,
+        optional: true
+      },
+      heightIncrement: {
+        kind: "parsed",
+        brief: `Increase bounding box height by this amount (in pixels). Can be negative to decrease. Default: ${DEFAULT_HEIGHT_INCREMENT}`,
+        parse: Number,
+        optional: true
+      },
+      precision: {
+        kind: "parsed",
+        brief: `Number of decimal places for coordinates. Use -1 for full precision (no rounding). Default: ${DEFAULT_LABEL_STUDIO_PRECISION}`,
+        parse: Number,
+        optional: true
+      },
+      recursive: {
+        kind: "boolean",
+        brief: `Recursively search directories for files. Default: ${DEFAULT_RECURSIVE}`,
+        optional: true
+      },
+      filePattern: {
+        kind: "parsed",
+        brief: `Regex pattern to match Label Studio files (should match .json files). Default: "${DEFAULT_LABEL_STUDIO_FILE_PATTERN}"`,
+        parse: String,
+        optional: true
+      },
+      outputMode: {
+        kind: "parsed",
+        brief: `Output mode: "${OUTPUT_MODE_ANNOTATIONS}" for editable annotations (ground truth) or "${OUTPUT_MODE_PREDICTIONS}" for read-only predictions (pre-annotations). Default: "${DEFAULT_OUTPUT_MODE}"`,
+        parse: String,
+        optional: true
+      }
+    }
+  },
+  docs: {
+    brief: "Enhance Label Studio files with sorting, normalization, and resizing"
+  }
+});
+
+// src/commands/enhance-ppocr/command.ts
+init_cjs_shims();
+var import_core2 = require("@stricli/core");
+init_constants();
+var enhancePPOCRCommand = (0, import_core2.buildCommand)({
+  loader: async () => {
+    const { enhancePPOCR: enhancePPOCR2 } = await Promise.resolve().then(() => (init_impl2(), impl_exports2));
+    return enhancePPOCR2;
+  },
+  parameters: {
+    positional: {
+      kind: "array",
+      parameter: {
+        brief: "Input directories containing PPOCRLabel files",
+        parse: String
+      },
+      minimum: 1
+    },
+    flags: {
+      outDir: {
+        kind: "parsed",
+        brief: "Output directory. If not specified, files are saved in the same directory as the source files",
+        parse: String,
+        optional: true
+      },
+      fileName: {
+        kind: "parsed",
+        brief: "Custom output filename. If not specified, uses the same name as the source file",
+        parse: String,
+        optional: true
+      },
+      backup: {
+        kind: "boolean",
+        brief: `Create backup of existing files before overwriting. Default: ${DEFAULT_BACKUP}`,
+        optional: true
+      },
+      sortVertical: {
+        kind: "parsed",
+        brief: `Sort bounding boxes vertically. Options: "${SORT_VERTICAL_NONE}", "${SORT_VERTICAL_TOP_BOTTOM}", "${SORT_VERTICAL_BOTTOM_TOP}". Default: "${DEFAULT_SORT_VERTICAL}"`,
+        parse: String,
+        optional: true
+      },
+      sortHorizontal: {
+        kind: "parsed",
+        brief: `Sort bounding boxes horizontally. Options: "${SORT_HORIZONTAL_NONE}", "${SORT_HORIZONTAL_LTR}", "${SORT_HORIZONTAL_RTL}". Default: "${DEFAULT_SORT_HORIZONTAL}"`,
+        parse: String,
+        optional: true
+      },
+      normalizeShape: {
+        kind: "parsed",
+        brief: `Normalize diamond-like shapes to axis-aligned rectangles. Options: "${SHAPE_NORMALIZE_NONE}", "${SHAPE_NORMALIZE_RECTANGLE}". Default: "${DEFAULT_SHAPE_NORMALIZE}"`,
+        parse: String,
+        optional: true
+      },
+      widthIncrement: {
+        kind: "parsed",
+        brief: `Increase bounding box width by this amount (in pixels). Can be negative to decrease. Default: ${DEFAULT_WIDTH_INCREMENT}`,
+        parse: Number,
+        optional: true
+      },
+      heightIncrement: {
+        kind: "parsed",
+        brief: `Increase bounding box height by this amount (in pixels). Can be negative to decrease. Default: ${DEFAULT_HEIGHT_INCREMENT}`,
+        parse: Number,
+        optional: true
+      },
+      precision: {
+        kind: "parsed",
+        brief: `Number of decimal places for coordinates. Use -1 for full precision (no rounding). Default: ${DEFAULT_PPOCR_PRECISION} (integers)`,
+        parse: Number,
+        optional: true
+      },
+      recursive: {
+        kind: "boolean",
+        brief: `Recursively search directories for files. Default: ${DEFAULT_RECURSIVE}`,
+        optional: true
+      },
+      filePattern: {
+        kind: "parsed",
+        brief: `Regex pattern to match PPOCRLabel files (should match .txt files). Default: "${DEFAULT_PPOCR_FILE_PATTERN}"`,
+        parse: String,
+        optional: true
+      }
+    }
+  },
+  docs: {
+    brief: "Enhance PPOCRLabel files with sorting, normalization, and resizing"
+  }
+});
+
+// src/commands/toLabelStudio/command.ts
+init_cjs_shims();
+var import_core3 = require("@stricli/core");
+init_constants();
+var toLabelStudioCommand = (0, import_core3.buildCommand)({
   loader: async () => {
-    const { convertToLabelStudio: convertToLabelStudio2 } = await Promise.resolve().then(() => (init_impl(), impl_exports));
+    const { convertToLabelStudio: convertToLabelStudio2 } = await Promise.resolve().then(() => (init_impl3(), impl_exports3));
     return convertToLabelStudio2;
   },
   parameters: {
@@ -1317,58 +2195,69 @@ var toLabelStudioCommand = (0, import_core.buildCommand)({
     flags: {
       outDir: {
         kind: "parsed",
-        brief: `Output directory. Default to "${OUTPUT_BASE_DIR}"`,
+        brief: "Output directory. If not specified, files are saved in the same directory as the source files",
+        parse: String,
+        optional: true
+      },
+      fileName: {
+        kind: "parsed",
+        brief: "Custom output filename (without extension). If not specified, uses source filename with format suffix",
         parse: String,
         optional: true
       },
+      backup: {
+        kind: "boolean",
+        brief: `Create backup of existing files before overwriting. Default: ${DEFAULT_BACKUP}`,
+        optional: true
+      },
       defaultLabelName: {
         kind: "parsed",
-        brief: `Default label name for text annotations. Default to "${DEFAULT_LABEL_NAME}"`,
+        brief: `Default label name for text annotations. Default: "${DEFAULT_LABEL_NAME}"`,
         parse: String,
         optional: true
       },
       toFullJson: {
         kind: "boolean",
-        brief: `Convert to Full OCR Label Studio format. Default to "${DEFAULT_LABEL_STUDIO_FULL_JSON}"`,
+        brief: `Convert to Full OCR Label Studio format. Default: "${DEFAULT_LABEL_STUDIO_FULL_JSON}"`,
         optional: true
       },
       createFilePerImage: {
         kind: "boolean",
-        brief: `Create a separate Label Studio JSON file for each image. Default to "${DEFAULT_CREATE_FILE_PER_IMAGE}"`,
+        brief: `Create a separate Label Studio JSON file for each image. Default: "${DEFAULT_CREATE_FILE_PER_IMAGE}"`,
         optional: true
       },
       createFileListForServing: {
         kind: "boolean",
-        brief: `Create a file list for serving in Label Studio. Default to "${DEFAULT_CREATE_FILE_LIST_FOR_SERVING}"`,
+        brief: `Create a file list for serving in Label Studio. Default: "${DEFAULT_CREATE_FILE_LIST_FOR_SERVING}"`,
         optional: true
       },
       fileListName: {
         kind: "parsed",
-        brief: `Name of the file list for serving. Default to "${DEFAULT_FILE_LIST_NAME}"`,
+        brief: `Name of the file list for serving. Default: "${DEFAULT_FILE_LIST_NAME}"`,
         parse: String,
         optional: true
       },
       baseServerUrl: {
         kind: "parsed",
-        brief: `Base server URL for constructing image URLs in the file list. Default to "${DEFAULT_BASE_SERVER_URL}"`,
+        brief: `Base server URL for constructing image URLs in the file list. Default: "${DEFAULT_BASE_SERVER_URL}"`,
         parse: String,
         optional: true
       },
       sortVertical: {
         kind: "parsed",
-        brief: `Sort bounding boxes vertically. Options: "${SORT_VERTICAL_NONE}" (default), "${SORT_VERTICAL_TOP_BOTTOM}", "${SORT_VERTICAL_BOTTOM_TOP}"`,
+        brief: `Sort bounding boxes vertically. Options: "${SORT_VERTICAL_NONE}", "${SORT_VERTICAL_TOP_BOTTOM}", "${SORT_VERTICAL_BOTTOM_TOP}". Default: "${DEFAULT_SORT_VERTICAL}"`,
         parse: String,
         optional: true
       },
       sortHorizontal: {
         kind: "parsed",
-        brief: `Sort bounding boxes horizontally. Options: "${SORT_HORIZONTAL_NONE}" (default), "${SORT_HORIZONTAL_LTR}", "${SORT_HORIZONTAL_RTL}"`,
+        brief: `Sort bounding boxes horizontally. Options: "${SORT_HORIZONTAL_NONE}", "${SORT_HORIZONTAL_LTR}", "${SORT_HORIZONTAL_RTL}". Default: "${DEFAULT_SORT_HORIZONTAL}"`,
         parse: String,
         optional: true
       },
       normalizeShape: {
         kind: "parsed",
-        brief: `Normalize diamond-like shapes to axis-aligned rectangles. Options: "${SHAPE_NORMALIZE_NONE}" (default), "${SHAPE_NORMALIZE_RECTANGLE}"`,
+        brief: `Normalize diamond-like shapes to axis-aligned rectangles. Options: "${SHAPE_NORMALIZE_NONE}", "${SHAPE_NORMALIZE_RECTANGLE}". Default: "${DEFAULT_SHAPE_NORMALIZE}"`,
         parse: String,
         optional: true
       },
@@ -1389,6 +2278,23 @@ var toLabelStudioCommand = (0, import_core.buildCommand)({
         brief: `Number of decimal places for coordinates. Use -1 for full precision (no rounding). Default: ${DEFAULT_LABEL_STUDIO_PRECISION}`,
         parse: Number,
         optional: true
+      },
+      recursive: {
+        kind: "boolean",
+        brief: `Recursively search directories for files. Default: ${DEFAULT_RECURSIVE}`,
+        optional: true
+      },
+      filePattern: {
+        kind: "parsed",
+        brief: `Regex pattern to match PPOCRLabel files (should match .txt files). Default: "${DEFAULT_PPOCR_FILE_PATTERN}"`,
+        parse: String,
+        optional: true
+      },
+      outputMode: {
+        kind: "parsed",
+        brief: `Output mode: "${OUTPUT_MODE_ANNOTATIONS}" for editable annotations (ground truth) or "${OUTPUT_MODE_PREDICTIONS}" for read-only predictions (pre-annotations). Default: "${DEFAULT_OUTPUT_MODE}"`,
+        parse: String,
+        optional: true
       }
     }
   },
@@ -1399,11 +2305,11 @@ var toLabelStudioCommand = (0, import_core.buildCommand)({
 
 // src/commands/toPPOCR/commands.ts
 init_cjs_shims();
-var import_core2 = require("@stricli/core");
+var import_core4 = require("@stricli/core");
 init_constants();
-var toPPOCRCommand = (0, import_core2.buildCommand)({
+var toPPOCRCommand = (0, import_core4.buildCommand)({
   loader: async () => {
-    const { convertToPPOCR: convertToPPOCR2 } = await Promise.resolve().then(() => (init_impl2(), impl_exports2));
+    const { convertToPPOCR: convertToPPOCR2 } = await Promise.resolve().then(() => (init_impl4(), impl_exports4));
     return convertToPPOCR2;
   },
   parameters: {
@@ -1418,16 +2324,21 @@ var toPPOCRCommand = (0, import_core2.buildCommand)({
     flags: {
       outDir: {
         kind: "parsed",
-        brief: `Output directory. Default to "${OUTPUT_BASE_DIR}"`,
+        brief: "Output directory. If not specified, files are saved in the same directory as the source files",
         parse: String,
         optional: true
       },
       fileName: {
         kind: "parsed",
-        brief: `Output PPOCR file name. Default to "${DEFAULT_PPOCR_FILE_NAME}"`,
+        brief: `Output PPOCR file name. Default: "${DEFAULT_PPOCR_FILE_NAME}"`,
         parse: String,
         optional: true
       },
+      backup: {
+        kind: "boolean",
+        brief: `Create backup of existing files before overwriting. Default: ${DEFAULT_BACKUP}`,
+        optional: true
+      },
       baseImageDir: {
         kind: "parsed",
         brief: 'Base directory path to prepend to image filenames in output (e.g., "ch" or "images/ch")',
@@ -1436,19 +2347,19 @@ var toPPOCRCommand = (0, import_core2.buildCommand)({
       },
       sortVertical: {
         kind: "parsed",
-        brief: `Sort bounding boxes vertically. Options: "${SORT_VERTICAL_NONE}" (default), "${SORT_VERTICAL_TOP_BOTTOM}", "${SORT_VERTICAL_BOTTOM_TOP}"`,
+        brief: `Sort bounding boxes vertically. Options: "${SORT_VERTICAL_NONE}", "${SORT_VERTICAL_TOP_BOTTOM}", "${SORT_VERTICAL_BOTTOM_TOP}". Default: "${DEFAULT_SORT_VERTICAL}"`,
         parse: String,
         optional: true
       },
       sortHorizontal: {
         kind: "parsed",
-        brief: `Sort bounding boxes horizontally. Options: "${SORT_HORIZONTAL_NONE}" (default), "${SORT_HORIZONTAL_LTR}", "${SORT_HORIZONTAL_RTL}"`,
+        brief: `Sort bounding boxes horizontally. Options: "${SORT_HORIZONTAL_NONE}", "${SORT_HORIZONTAL_LTR}", "${SORT_HORIZONTAL_RTL}". Default: "${DEFAULT_SORT_HORIZONTAL}"`,
         parse: String,
         optional: true
       },
       normalizeShape: {
         kind: "parsed",
-        brief: `Normalize diamond-like shapes to axis-aligned rectangles. Options: "${SHAPE_NORMALIZE_NONE}" (default), "${SHAPE_NORMALIZE_RECTANGLE}"`,
+        brief: `Normalize diamond-like shapes to axis-aligned rectangles. Options: "${SHAPE_NORMALIZE_NONE}", "${SHAPE_NORMALIZE_RECTANGLE}". Default: "${DEFAULT_SHAPE_NORMALIZE}"`,
         parse: String,
         optional: true
       },
@@ -1469,6 +2380,17 @@ var toPPOCRCommand = (0, import_core2.buildCommand)({
         brief: `Number of decimal places for coordinates. Use -1 for full precision (no rounding). Default: ${DEFAULT_PPOCR_PRECISION} (integers)`,
         parse: Number,
         optional: true
+      },
+      recursive: {
+        kind: "boolean",
+        brief: `Recursively search directories for files. Default: ${DEFAULT_RECURSIVE}`,
+        optional: true
+      },
+      filePattern: {
+        kind: "parsed",
+        brief: `Regex pattern to match Label Studio files (should match .json files). Default: "${DEFAULT_LABEL_STUDIO_FILE_PATTERN}"`,
+        parse: String,
+        optional: true
       }
     }
   },
@@ -1478,10 +2400,12 @@ var toPPOCRCommand = (0, import_core2.buildCommand)({
 });
 
 // src/app.ts
-var routes = (0, import_core3.buildRouteMap)({
+var routes = (0, import_core5.buildRouteMap)({
   routes: {
     toLabelStudio: toLabelStudioCommand,
     toPPOCR: toPPOCRCommand,
+    "enhance-labelstudio": enhanceLabelStudioCommand,
+    "enhance-ppocr": enhancePPOCRCommand,
     install: (0, import_auto_complete.buildInstallCommand)("label-studio-converter", {
       bash: "__label-studio-converter_bash_complete"
     }),
@@ -1495,7 +2419,7 @@ var routes = (0, import_core3.buildRouteMap)({
     }
   }
 });
-var app = (0, import_core3.buildApplication)(routes, {
+var app = (0, import_core5.buildApplication)(routes, {
   name: "label-studio-converter",
   versionInfo: {
     currentVersion: version
@@ -1522,9 +2446,9 @@ function buildContext(process2) {
   if (process.env.COMP_LINE?.endsWith(" ")) {
     inputs.push("");
   }
-  await (0, import_core4.proposeCompletions)(app, inputs, buildContext(process));
+  await (0, import_core6.proposeCompletions)(app, inputs, buildContext(process));
   try {
-    for (const { completion } of await (0, import_core4.proposeCompletions)(
+    for (const { completion } of await (0, import_core6.proposeCompletions)(
       app,
       inputs,
       buildContext(process)