md-zh-translation-skill 1.2.0 → 1.2.2

package/dist/src/codex-exec.d.ts

@@ -1,3 +1,5 @@
+import { type ChildProcessByStdio } from "node:child_process";
+import type { Readable, Writable } from "node:stream";
 export type CodexUsage = {
     inputTokens: number;
     cachedInputTokens: number;
@@ -23,6 +25,14 @@ export type CodexExecOptions = {
 export interface CodexExecutor {
     execute(prompt: string, options: CodexExecOptions): Promise<CodexExecResult>;
 }
+type SpawnFn = (command: string, args: readonly string[], options: {
+    cwd: string;
+    stdio: ["pipe", "pipe", "pipe"];
+}) => ChildProcessByStdio<Writable, Readable, Readable>;
 export declare class DefaultCodexExecutor implements CodexExecutor {
+    private readonly spawnFn;
+    private readonly sleepFn;
+    constructor(spawnFn?: SpawnFn, sleepFn?: (milliseconds: number) => Promise<void>);
     execute(prompt: string, options: CodexExecOptions): Promise<CodexExecResult>;
 }
+export {};

package/dist/src/codex-exec.js

@@ -3,6 +3,8 @@ import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { CodexExecutionError } from "./errors.js";
+const MAX_RETRYABLE_EXEC_FAILURES = 2;
+const RETRYABLE_EXEC_FAILURE_DELAY_MS = 250;
 function parseUsage(jsonl) {
     let latestUsage = null;
     for (const line of jsonl.split("\n")) {
@@ -48,67 +50,105 @@ function parseThreadId(jsonl) {
     }
     return undefined;
 }
+function isRetryableCodexFailure(stderr) {
+    return (stderr.includes("codex_core::shell_snapshot") &&
+        stderr.includes("Failed to delete shell snapshot"));
+}
+function sleep(milliseconds) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, milliseconds);
+    });
+}
 export class DefaultCodexExecutor {
+    spawnFn;
+    sleepFn;
+    constructor(spawnFn = spawn, sleepFn = sleep) {
+        this.spawnFn = spawnFn;
+        this.sleepFn = sleepFn;
+    }
     async execute(prompt, options) {
         const workingDir = options.cwd ?? process.cwd();
-        const tempDir = await mkdtemp(path.join(tmpdir(), "md-zh-translate-"));
-        const outputPath = path.join(tempDir, "last-message.txt");
-        const schemaPath = options.outputSchema ? path.join(tempDir, "output-schema.json") : null;
-        if (schemaPath) {
-            await writeFile(schemaPath, `${JSON.stringify(options.outputSchema, null, 2)}\n`, "utf8");
-        }
-        const args = options.threadId
-            ? buildResumeArgs(options, outputPath)
-            : buildExecArgs(options, workingDir, outputPath);
-        if (schemaPath) {
-            args.push("--output-schema", schemaPath);
-        }
-        args.push("-");
-        const child = spawn("codex", args, {
-            cwd: workingDir,
-            stdio: ["pipe", "pipe", "pipe"]
-        });
-        let stdout = "";
-        let stderr = "";
-        child.stdout.on("data", (chunk) => {
-            stdout += String(chunk);
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr += String(chunk);
-        });
-        child.stdin.write(prompt);
-        child.stdin.end();
-        const exitCode = await new Promise((resolve, reject) => {
-            child.once("error", reject);
-            child.once("close", (code) => resolve(code ?? 1));
-        });
-        try {
-            if (exitCode !== 0) {
-                options.onStderr?.(stderr);
-                throw new CodexExecutionError(stderr.trim() || stdout.trim() || `codex exec exited with ${exitCode}`);
+        let attempt = 0;
+        let lastError = null;
+        while (attempt <= MAX_RETRYABLE_EXEC_FAILURES) {
+            const tempDir = await mkdtemp(path.join(tmpdir(), "md-zh-translate-"));
+            const outputPath = path.join(tempDir, "last-message.txt");
+            const schemaPath = options.outputSchema ? path.join(tempDir, "output-schema.json") : null;
+            let stdout = "";
+            let stderr = "";
+            try {
+                if (schemaPath) {
+                    await writeFile(schemaPath, `${JSON.stringify(options.outputSchema, null, 2)}\n`, "utf8");
+                }
+                const args = options.threadId
+                    ? buildResumeArgs(options, outputPath)
+                    : buildExecArgs(options, workingDir, outputPath);
+                if (schemaPath) {
+                    args.push("--output-schema", schemaPath);
+                }
+                args.push("-");
+                const child = this.spawnFn("codex", args, {
+                    cwd: workingDir,
+                    stdio: ["pipe", "pipe", "pipe"]
+                });
+                child.stdout.on("data", (chunk) => {
+                    stdout += String(chunk);
+                });
+                child.stderr.on("data", (chunk) => {
+                    stderr += String(chunk);
+                });
+                child.stdin.write(prompt);
+                child.stdin.end();
+                const exitCode = await new Promise((resolve, reject) => {
+                    child.once("error", reject);
+                    child.once("close", (code) => resolve(code ?? 1));
+                });
+                if (exitCode !== 0) {
+                    options.onStderr?.(stderr);
+                    const error = new CodexExecutionError(stderr.trim() || stdout.trim() || `codex exec exited with ${exitCode}`);
+                    if (isRetryableCodexFailure(stderr) && attempt < MAX_RETRYABLE_EXEC_FAILURES) {
+                        lastError = error;
+                        attempt += 1;
+                        await this.sleepFn(RETRYABLE_EXEC_FAILURE_DELAY_MS * attempt);
+                        continue;
+                    }
+                    throw error;
+                }
+                const text = (await readFile(outputPath, "utf8")).trim();
+                if (!text) {
+                    throw new CodexExecutionError("Codex returned an empty final message.");
+                }
+                const threadId = parseThreadId(stdout) ?? options.threadId;
+                return {
+                    text,
+                    stderr,
+                    jsonl: stdout,
+                    usage: parseUsage(stdout),
+                    ...(threadId ? { threadId } : {})
+                };
             }
-            const text = (await readFile(outputPath, "utf8")).trim();
-            if (!text) {
-                throw new CodexExecutionError("Codex returned an empty final message.");
+            catch (error) {
+                if (isRetryableCodexFailure(stderr) && attempt < MAX_RETRYABLE_EXEC_FAILURES) {
+                    const retryableError = error instanceof CodexExecutionError
+                        ? error
+                        : new CodexExecutionError(error instanceof Error ? error.message : String(error));
+                    lastError = retryableError;
+                    attempt += 1;
+                    await this.sleepFn(RETRYABLE_EXEC_FAILURE_DELAY_MS * attempt);
+                    continue;
+                }
+                if (error instanceof CodexExecutionError) {
+                    lastError = error;
+                    throw error;
+                }
+                lastError = new CodexExecutionError(error instanceof Error ? error.message : String(error));
+                throw lastError;
             }
-            const threadId = parseThreadId(stdout) ?? options.threadId;
-            return {
-                text,
-                stderr,
-                jsonl: stdout,
-                usage: parseUsage(stdout),
-                ...(threadId ? { threadId } : {})
-            };
-        }
-        catch (error) {
-            if (error instanceof CodexExecutionError) {
-                throw error;
+            finally {
+                await rm(tempDir, { recursive: true, force: true });
             }
-            throw new CodexExecutionError(error instanceof Error ? error.message : String(error));
-        }
-        finally {
-            await rm(tempDir, { recursive: true, force: true });
         }
+        throw lastError ?? new CodexExecutionError("codex exec failed after retry.");
     }
 }
 function buildExecArgs(options, workingDir, outputPath) {
@@ -116,6 +156,10 @@ function buildExecArgs(options, workingDir, outputPath) {
         "exec",
         "--skip-git-repo-check",
         "--json",
+        "--disable",
+        "plugins",
+        "--disable",
+        "shell_snapshot",
         "--sandbox",
         "read-only",
         "--color",
@@ -147,6 +191,10 @@ function buildResumeArgs(options, outputPath) {
         "resume",
         "--skip-git-repo-check",
         "--json",
+        "--disable",
+        "plugins",
+        "--disable",
+        "shell_snapshot",
         "-m",
         options.model,
         "-o",

package/dist/src/internal/prompts/scheme-h.js

@@ -4,6 +4,7 @@ Markdown 结构要求：
 2. 不要改写 fenced code blocks、indented code blocks、inline code、URL、链接目标、图片 URL 和原始 HTML 标签。
 3. 链接或图片的可见文字如果是正文，可以翻译；目标地址必须保持不变。
 4. 不要把代码块、命令行片段或配置键值误译成中文。
+5. 如果原文正文使用了可翻译的 Markdown 强调结构（如 **加粗**、*斜体*）或命令/flag 写法（如 --flag），译文应保持等价结构；不要丢掉强调，也不要把普通命令/flag 误改成代码块、标题或其他 Markdown 结构。
 `.trim();
 export const INITIAL_TRANSLATION_PROMPT = `
 你是一名科技与科普翻译编辑。请把下面的英文 Markdown 文章翻译成自然、准确、可读性高的中文 Markdown，但本次任务以“硬性项正确”为第一优先级。请严格遵守以下要求：

package/dist/src/markdown-protection.js

@@ -51,9 +51,7 @@ export function protectSegmentFormattingSpans(body, startIndex = 1) {
         spans.push({ id, kind, raw });
         return id;
     };
-    let protectedBody = mapOutsideInlineCode(body, (text) => protectInlineMarkdownLinks(text, register));
-    protectedBody = protectInlineCodeSegments(protectedBody, register);
-    protectedBody = protectInlineStrongEmphasis(protectedBody, register);
+    const protectedBody = mapOutsideInlineCode(body, (text) => protectInlineMarkdownLinks(text, register));
     return { protectedBody, spans };
 }
 function protectFencedCodeBlocks(input, register) {

package/dist/src/translate.js

@@ -1,4 +1,4 @@
-import { buildBundledGateAuditPrompt, buildInitialPrompt, buildRepairPrompt, buildStylePolishPrompt } from "./internal/prompts/scheme-h.js";
+import { buildBundledGateAuditPrompt, buildGateAuditPrompt, buildInitialPrompt, buildRepairPrompt, buildStylePolishPrompt } from "./internal/prompts/scheme-h.js";
 import { DefaultCodexExecutor } from "./codex-exec.js";
 import { FormattingError, HardGateError } from "./errors.js";
 import { formatTranslatedBody, reconstructMarkdown } from "./format.js";
@@ -279,9 +279,7 @@ async function translateProtectedChunk(chunk, plan, context) {
             ? `${chunkLabel}, segment ${segment.index + 1}/${segments.length}`
             : chunkLabel;
         const segmentResult = await translateProtectedSegment(segment, plan, context, segmentPromptContext, segmentLabel, nextLocalSpanIndex);
-        nextLocalSpanIndex += segmentResult.spans.filter((span) => span.kind === "inline_code" ||
-            span.kind === "strong_emphasis" ||
-            span.kind === "inline_markdown_link").length;
+        nextLocalSpanIndex += segmentResult.spans.filter((span) => span.kind === "inline_markdown_link").length;
         draftedSegments.push(segmentResult);
     }
     let bundledAudit = await runBundledGateAudit(draftedSegments, plan, context, chunkPromptContext, chunkLabel);
@@ -404,12 +402,45 @@ async function runBundledGateAudit(draftedSegments, plan, context, chunkPromptCo
         reuseSession: true,
         onStderr: (stderrChunk) => reportChunkProgress(context.options, "audit", chunkPromptContext.chunkIndex - 1, plan, chunkLabel, stderrChunk)
     });
-    const bundledAudit = parseBundledGateAudit(auditResult.text, segmentIndices);
+    let bundledAudit;
+    try {
+        bundledAudit = parseBundledGateAudit(auditResult.text, segmentIndices);
+    }
+    catch (error) {
+        if (!(error instanceof HardGateError) ||
+            !error.message.includes("Bundled gate audit segment_index set mismatch")) {
+            throw error;
+        }
+        report(context.options, "audit", `Chunk ${chunkPromptContext.chunkIndex}/${plan.chunks.length}${chunkLabel}: bundled audit returned incomplete segment results; falling back to per-segment audit.`);
+        bundledAudit = await runFallbackSegmentAudits(draftedSegments, plan, context, chunkPromptContext, chunkLabel);
+    }
     for (const segmentAudit of bundledAudit.segments) {
         validateStructuralGateChecks(segmentAudit);
     }
     return bundledAudit;
 }
+async function runFallbackSegmentAudits(draftedSegments, plan, context, chunkPromptContext, chunkLabel) {
+    const segments = [];
+    for (const draftedSegment of draftedSegments) {
+        const segmentLabel = draftedSegments.length > 1
+            ? `${chunkLabel}, segment ${draftedSegment.segment.index + 1}/${draftedSegments.length}`
+            : chunkLabel;
+        const auditResult = await context.executor.execute(withChunkContext(buildGateAuditPrompt(draftedSegment.protectedSource, draftedSegment.protectedBody), draftedSegment.promptContext), {
+            cwd: context.cwd,
+            model: context.model,
+            reasoningEffort: AUDIT_REASONING_EFFORT,
+            outputSchema: GATE_AUDIT_SCHEMA,
+            reuseSession: true,
+            onStderr: (stderrChunk) => reportChunkProgress(context.options, "audit", chunkPromptContext.chunkIndex - 1, plan, segmentLabel, stderrChunk)
+        });
+        const audit = parseGateAudit(auditResult.text);
+        segments.push({
+            segment_index: draftedSegment.segment.index + 1,
+            ...audit
+        });
+    }
+    return { segments };
+}
 function rebuildChunkFromSegmentStates(segments, draftedSegments, key) {
     return segments
         .map((segment) => {
@@ -612,6 +643,9 @@ function extractSegmentSpecialNotes(source) {
     if (containsToolNameExplanationBlock(source)) {
         notes.push("当前分段包含工具名、命令名、包名、CLI 名称或产品名的列表项说明。对这类以英文原名作为标签的说明条目，允许保留英文原名，并在后面直接接中文解释；不要为了满足首现双语而强行改写成“中文（英文）”主译格式。", "对于 `kubectl - Kubernetes cluster access`、`docker - ...`、`npm install -g ...` 这类工具/命令/产品说明，只要英文原名保留且中文解释清楚，就可视为合格的首现锚定；不要把“英文名（中文解释）”误判为必须修复。");
     }
+    if (containsTranslatableMarkdownStructure(source)) {
+        notes.push("当前分段包含可翻译的 Markdown 强调结构或命令/flag 写法。翻译时必须保留等价结构：原文中的 **加粗**、*斜体* 等强调，不得无故去掉；像 --dangerously-skip-permissions 这类命令参数或 flag，应保留原始写法，不要改成代码块、标题、列表标签或其他 Markdown 结构。", "如果强调结构里的正文需要翻译，请翻译内容本身，但保留强调标记；如果命令、flag、配置键名或 CLI 参数本身是英文原名，请保留原名，只翻译周围解释。");
+    }
     return notes;
 }
 function containsAttributionLikeBlock(source) {
@@ -645,6 +679,15 @@ function isToolNameExplanationLine(line) {
     }
     return /^(?:`[^`]+`|[@A-Za-z0-9._/+:-]+)\s*(?:-|—|:)\s+.+$/.test(body);
 }
+function containsTranslatableMarkdownStructure(source) {
+    return splitRawBlocks(source).some((block) => isTranslatableMarkdownStructureBlock(block.content));
+}
+function isTranslatableMarkdownStructureBlock(content) {
+    if (content.trim().length === 0) {
+        return false;
+    }
+    return /(\*\*[^*\n]+?\*\*|__[^_\n]+?__|\*[^*\n]+?\*|_[^_\n]+?_)/.test(content) || /\B--[A-Za-z0-9][A-Za-z0-9-]*/.test(content);
+}
 function buildChunkPromptContext(chunk, plan, sourcePathHint, establishedTerms) {
     return {
         documentTitle: plan.documentTitle,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "md-zh-translation-skill",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "CLI skill for translating English Markdown articles into polished Chinese Markdown with a hidden gated pipeline.",
   "type": "module",
   "bin": {