gtx-cli 2.5.17 → 2.5.19

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # gtx-cli
 
+## 2.5.19
+
+### Patch Changes
+
+- [#853](https://github.com/generaltranslation/gt/pull/853) [`02abd0a`](https://github.com/generaltranslation/gt/commit/02abd0a970a09c514744982f06169f385dfdd972) Thanks [@fernando-aviles](https://github.com/fernando-aviles)! - Including hash of post-processed files in `gt-lock.json` to avoid unnecessary saves when calling `save-local`
+
+## 2.5.18
+
+### Patch Changes
+
+- [#851](https://github.com/generaltranslation/gt/pull/851) [`cf5f0e3`](https://github.com/generaltranslation/gt/commit/cf5f0e3f1537c304b7ea5703714ffb4956a7f6f4) Thanks [@fernando-aviles](https://github.com/fernando-aviles)! - Skip anchor ID fallback in codeblocks to avoid adding anchors to comments
+
 ## 2.5.17
 
 ### Patch Changes

package/dist/api/collectUserEditDiffs.js

@@ -6,6 +6,7 @@ import { getGitUnifiedDiff } from '../utils/gitDiff.js';
 import { gt } from '../utils/gt.js';
 import os from 'node:os';
 import { randomUUID } from 'node:crypto';
+import { hashStringSync } from '../utils/hash.js';
 /**
  * Collects local user edits by diffing the latest downloaded server translation version
  * against the current local translation file, and submits the diffs upstream.
@@ -32,6 +33,19 @@ export async function collectAndSendUserEditDiffs(files, settings) {
             const downloadedVersion = downloadedVersions.entries?.[uploadedFile.branchId]?.[uploadedFile.fileId]?.[uploadedFile.versionId]?.[locale];
             if (!downloadedVersion)
                 continue;
+            // Skip if local file matches the last postprocessed content hash
+            if (downloadedVersion.postProcessHash) {
+                try {
+                    const localContent = await fs.promises.readFile(outputPath, 'utf8');
+                    const localHash = hashStringSync(localContent);
+                    if (localHash === downloadedVersion.postProcessHash) {
+                        continue;
+                    }
+                }
+                catch {
+                    // If hash check fails, fall through to diff
+                }
+            }
             candidates.push({
                 branchId: uploadedFile.branchId,
                 fileName: uploadedFile.fileName,

package/dist/api/downloadFileBatch.js

@@ -115,8 +115,14 @@ export async function downloadFileBatch(fileTracker, files, options, forceDownlo
                 }
                 // Write the file to disk
                 await fs.promises.writeFile(outputPath, data);
-                // Track as downloaded
-                recordDownloaded(outputPath);
+                // Track as downloaded with metadata for downstream postprocessing
+                recordDownloaded(outputPath, {
+                    branchId,
+                    fileId,
+                    versionId,
+                    locale,
+                    inputPath,
+                });
                 result.successful.push(requestedFile);
                 if (branchId && fileId && versionId && locale) {
                     ensureNestedObject(downloadedVersions.entries, [

package/dist/cli/commands/translate.js

@@ -9,6 +9,8 @@ import processOpenApi from '../../utils/processOpenApi.js';
 import { noFilesError, noVersionIdError } from '../../console/index.js';
 import localizeStaticImports from '../../utils/localizeStaticImports.js';
 import { logErrorAndExit } from '../../console/logging.js';
+import { getDownloadedMeta } from '../../state/recentDownloads.js';
+import { persistPostProcessHashes } from '../../utils/persistPostprocessHashes.js';
 // Downloads translations that were completed
 export async function handleTranslate(options, settings, fileVersionData, jobData, branchData) {
     if (fileVersionData) {
@@ -65,4 +67,6 @@ export async function postProcessTranslations(settings, includeFiles) {
     if (settings.options?.copyFiles) {
         await copyFile(settings);
     }
+    // Record postprocessed content hashes for newly downloaded files
+    persistPostProcessHashes(settings, includeFiles, getDownloadedMeta());
 }

package/dist/fs/config/downloadedVersions.d.ts

@@ -1,6 +1,7 @@
 export type DownloadedVersionEntry = {
     fileName?: string;
     updatedAt?: string;
+    postProcessHash?: string;
 };
 export type DownloadedVersions = {
     version: number;

package/dist/state/recentDownloads.d.ts

@@ -1,3 +1,12 @@
-export declare function recordDownloaded(filePath: string): void;
+type DownloadMeta = {
+    branchId: string;
+    fileId: string;
+    versionId: string;
+    locale: string;
+    inputPath?: string;
+};
+export declare function recordDownloaded(filePath: string, meta?: DownloadMeta): void;
 export declare function getDownloaded(): Set<string>;
+export declare function getDownloadedMeta(): Map<string, DownloadMeta>;
 export declare function clearDownloaded(): void;
+export {};

package/dist/state/recentDownloads.js

@@ -1,10 +1,18 @@
 const recent = new Set();
-export function recordDownloaded(filePath) {
+const recentMeta = new Map();
+export function recordDownloaded(filePath, meta) {
     recent.add(filePath);
+    if (meta) {
+        recentMeta.set(filePath, meta);
+    }
 }
 export function getDownloaded() {
     return recent;
 }
+export function getDownloadedMeta() {
+    return recentMeta;
+}
 export function clearDownloaded() {
     recent.clear();
+    recentMeta.clear();
 }

package/dist/utils/addExplicitAnchorIds.js

@@ -30,6 +30,53 @@ function extractHeadingText(heading) {
     });
     return text;
 }
+/**
+ * Simple line-by-line heading extractor that skips fenced code blocks.
+ * Used as a fallback when MDX parsing fails.
+ */
+function extractHeadingsWithFallback(mdxContent) {
+    const headings = [];
+    const lines = mdxContent.split('\n');
+    let position = 0;
+    let inFence = false;
+    let fenceChar = null;
+    for (const line of lines) {
+        const fenceMatch = line.match(/^(\s*)(`{3,}|~{3,})/);
+        if (fenceMatch) {
+            const fenceString = fenceMatch[2];
+            if (!inFence) {
+                inFence = true;
+                fenceChar = fenceString;
+            }
+            else if (fenceChar &&
+                fenceString[0] === fenceChar[0] &&
+                fenceString.length >= fenceChar.length) {
+                inFence = false;
+                fenceChar = null;
+            }
+            continue;
+        }
+        if (inFence) {
+            continue;
+        }
+        const headingMatch = line.match(/^(#{1,6})\s+(.*)$/);
+        if (!headingMatch) {
+            continue;
+        }
+        const hashes = headingMatch[1];
+        const rawText = headingMatch[2];
+        const { cleanedText, explicitId } = parseHeadingContent(rawText);
+        if (cleanedText || explicitId) {
+            headings.push({
+                text: cleanedText,
+                level: hashes.length,
+                slug: explicitId ?? generateSlug(cleanedText),
+                position: position++,
+            });
+        }
+    }
+    return headings;
+}
 function parseHeadingContent(text) {
     // Support both {#id} and escaped \{#id\} forms
     const anchorMatch = text.match(/(\\\{#([^}]+)\\\}|\{#([^}]+)\})\s*$/);
@@ -67,25 +114,8 @@ export function extractHeadingInfo(mdxContent) {
     }
     catch (error) {
         console.warn(`Failed to parse MDX content: ${error instanceof Error ? error.message : String(error)}`);
-        // Fallback: simple regex-based extraction to keep IDs usable
-        const fallbackHeadings = [];
-        const headingRegex = /^(#{1,6})\s+(.*)$/gm;
-        let position = 0;
-        let match;
-        while ((match = headingRegex.exec(mdxContent)) !== null) {
-            const hashes = match[1];
-            const rawText = match[2];
-            const { cleanedText, explicitId } = parseHeadingContent(rawText);
-            if (cleanedText || explicitId) {
-                fallbackHeadings.push({
-                    text: cleanedText,
-                    level: hashes.length,
-                    slug: explicitId ?? generateSlug(cleanedText),
-                    position: position++,
-                });
-            }
-        }
-        return fallbackHeadings;
+        // Fallback: line-by-line extraction skipping fenced code blocks
+        return extractHeadingsWithFallback(mdxContent);
     }
     let position = 0;
     visit(processedAst, 'heading', (heading) => {
@@ -270,25 +300,52 @@ function applyInlineIds(translatedContent, idMappings, escapeAnchors) {
  */
 function applyInlineIdsStringFallback(translatedContent, idMappings, escapeAnchors) {
     let headingIndex = 0;
-    return translatedContent.replace(/^(#{1,6}\s+)(.*)$/gm, (match, prefix, text) => {
+    let inFence = false;
+    let fenceChar = null;
+    const processedLines = translatedContent.split('\n').map((line) => {
+        const fenceMatch = line.match(/^(\s*)(`{3,}|~{3,})/);
+        if (fenceMatch) {
+            const fenceString = fenceMatch[2];
+            if (!inFence) {
+                inFence = true;
+                fenceChar = fenceString;
+            }
+            else if (fenceChar &&
+                fenceString[0] === fenceChar[0] &&
+                fenceString.length >= fenceChar.length) {
+                inFence = false;
+                fenceChar = null;
+            }
+            return line;
+        }
+        if (inFence) {
+            return line;
+        }
+        const headingMatch = line.match(/^(#{1,6}\s+)(.*)$/);
+        if (!headingMatch) {
+            return line;
+        }
+        const prefix = headingMatch[1];
+        const text = headingMatch[2];
         const id = idMappings.get(headingIndex++);
         if (!id) {
-            return match;
+            return line;
         }
         const hasEscaped = /\\\{#[^}]+\\\}\s*$/.test(text);
         const hasUnescaped = /\{#[^}]+\}\s*$/.test(text);
         if (hasEscaped) {
-            return match;
+            return line;
         }
         if (hasUnescaped) {
             if (!escapeAnchors) {
-                return match;
+                return line;
             }
             return `${prefix}${text.replace(/\{#([^}]+)\}\s*$/, '\\\\{#$1\\\\}')}`;
         }
         const suffix = escapeAnchors ? ` \\{#${id}\\}` : ` {#${id}}`;
         return `${prefix}${text}${suffix}`;
     });
+    return processedLines.join('\n');
 }
 /**
  * Wraps headings in divs with IDs (Mintlify approach)

package/dist/utils/persistPostprocessHashes.d.ts

@@ -0,0 +1,12 @@
+import type { Settings } from '../types/index.js';
+type DownloadMeta = {
+    branchId: string;
+    fileId: string;
+    versionId: string;
+    locale: string;
+};
+/**
+ * Persist postprocessed content hashes for recently downloaded files into gt-lock.json.
+ */
+export declare function persistPostProcessHashes(settings: Settings, includeFiles: Set<string> | undefined, downloadedMeta: Map<string, DownloadMeta>): void;
+export {};

package/dist/utils/persistPostprocessHashes.js

@@ -0,0 +1,39 @@
+import * as fs from 'node:fs';
+import { ensureNestedObject, getDownloadedVersions, saveDownloadedVersions, } from '../fs/config/downloadedVersions.js';
+import { hashStringSync } from './hash.js';
+/**
+ * Persist postprocessed content hashes for recently downloaded files into gt-lock.json.
+ */
+export function persistPostProcessHashes(settings, includeFiles, downloadedMeta) {
+    if (!includeFiles || includeFiles.size === 0 || downloadedMeta.size === 0) {
+        return;
+    }
+    const downloadedVersions = getDownloadedVersions(settings.configDirectory);
+    let lockUpdated = false;
+    for (const filePath of includeFiles) {
+        const meta = downloadedMeta.get(filePath);
+        if (!meta)
+            continue;
+        if (!fs.existsSync(filePath))
+            continue;
+        const content = fs.readFileSync(filePath, 'utf8');
+        const hash = hashStringSync(content);
+        ensureNestedObject(downloadedVersions.entries, [
+            meta.branchId,
+            meta.fileId,
+            meta.versionId,
+            meta.locale,
+        ]);
+        const existing = downloadedVersions.entries[meta.branchId][meta.fileId][meta.versionId][meta.locale] || {};
+        if (existing.postProcessHash !== hash) {
+            downloadedVersions.entries[meta.branchId][meta.fileId][meta.versionId][meta.locale] = {
+                ...existing,
+                postProcessHash: hash,
+            };
+            lockUpdated = true;
+        }
+    }
+    if (lockUpdated) {
+        saveDownloadedVersions(settings.configDirectory, downloadedVersions);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.5.17",
+  "version": "2.5.19",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [