vibe-coding-master 0.2.1 → 0.2.2

package/dist/backend/services/translation-service.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { TRANSLATION_PROMPT_KEYS } from "../../shared/types/translation.js";
+import { TRANSLATION_ENTRY_RETENTION_LIMIT, TRANSLATION_PROMPT_KEYS } from "../../shared/types/translation.js";
 import { TranslationProviderError } from "../adapters/translation-provider.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
@@ -17,11 +17,11 @@ const DEFAULT_SETTINGS = {
     inputMode: "review-before-send",
     translateOutput: true,
     translateUserInput: true,
-    contextEnabled: true,
+    contextEnabled: false,
     preserveTechnicalTokens: true,
     skipCjkText: true,
     redactSecrets: true,
-    requestTimeoutMs: 15000,
+    requestTimeoutMs: 120000,
     temperature: 0.1
 };
 const TRANSCRIPT_REPLAY_GRACE_MS = 5000;
@@ -62,6 +62,7 @@ export function createTranslationService(deps) {
                 listeners: new Set(),
                 seenTranscriptIds: new Set(),
                 entries: [],
+                failures: new Map(),
                 status: "ready",
                 events: [],
                 nextSeq: 1
@@ -92,6 +93,11 @@ export function createTranslationService(deps) {
         appendEvent(sessionId, { type: "error", id, message });
         emit(sessionId, { type: "translation-error", id, message });
     }
+    function publishFailures(sessionId) {
+        const failures = getFailureItems(getState(sessionId));
+        appendEvent(sessionId, { type: "failures", failures });
+        emit(sessionId, { type: "translation-failures", failures });
+    }
     function appendEvent(sessionId, input) {
         const state = getState(sessionId);
         const event = {
@@ -117,6 +123,7 @@ export function createTranslationService(deps) {
         if (!state.cacheLoaded) {
             await loadCachedEvents(state);
             state.cacheLoaded = true;
+            pruneTranslationEntries(input.sessionId);
         }
         await deps.fs.ensureDir(path.dirname(cachePath));
         return state;
@@ -150,6 +157,9 @@ export function createTranslationService(deps) {
             else if (event.type === "error") {
                 state.status = "failed";
             }
+            else if (event.type === "failures") {
+                state.failures = new Map(event.failures.map((failure) => [failure.translationId, failure]));
+            }
         }
     }
     async function persistEvents(state) {
@@ -216,14 +226,20 @@ export function createTranslationService(deps) {
         }
     }
     function processClaudeOutputText(sessionId, rawText, config, entryId) {
+        return startClaudeOutputTranslation(sessionId, rawText, config, {
+            entryId,
+            replaceExisting: false
+        }) !== undefined;
+    }
+    function startClaudeOutputTranslation(sessionId, rawText, config, options) {
         const session = deps.runtime.getSession(sessionId);
         const roleSession = deps.sessionRegistry.get(sessionId);
         if (!session && !roleSession) {
-            return false;
+            return undefined;
         }
         const { settings, secrets } = config;
         if (!rawText.trim()) {
-            return false;
+            return undefined;
         }
         const text = rawText;
         const baseEntry = {
@@ -236,11 +252,16 @@ export function createTranslationService(deps) {
                 settings,
                 status: "translating",
                 contextUsed: false,
-                id: entryId
+                id: options.entryId
             }),
             translationStartedAt: now()
         };
-        pushEntry(sessionId, baseEntry);
+        if (options.replaceExisting) {
+            replaceEntry(sessionId, baseEntry);
+        }
+        else {
+            pushEntry(sessionId, baseEntry);
+        }
         const queue = queues.getQueue(sessionId);
         void queue.enqueue(async () => {
             publishStatus(sessionId, "translating");
@@ -265,6 +286,7 @@ export function createTranslationService(deps) {
                     tokenUsage: result.tokenUsage
                 };
                 replaceEntry(sessionId, completed);
+                clearFailure(sessionId, completed.id);
                 getState(sessionId).lastAssistantText = text;
                 publishStatus(sessionId, "ready");
             }
@@ -276,15 +298,23 @@ export function createTranslationService(deps) {
                     completedAt: now()
                 };
                 replaceEntry(sessionId, failed);
+                recordFailure(sessionId, failed);
                 publishStatus(sessionId, "failed");
             }
         }).catch((error) => {
             publishError(sessionId, error instanceof Error ? error.message : "Translation failed.");
         });
-        return true;
+        return baseEntry;
     }
     function pushEntry(sessionId, entry) {
         getState(sessionId).entries.push(entry);
+        pruneTranslationEntries(sessionId, new Set([entry.id]));
+        publishEntry(sessionId, entry);
+    }
+    function upsertAndPublishEntry(sessionId, entry) {
+        const state = getState(sessionId);
+        state.entries = upsertEntry(state.entries, entry);
+        pruneTranslationEntries(sessionId, new Set([entry.id]));
         publishEntry(sessionId, entry);
     }
     function pushPreservedTranscriptEntry(sessionId, entryId, sourceText, settings) {
@@ -311,9 +341,100 @@ export function createTranslationService(deps) {
     }
     function replaceEntry(sessionId, entry) {
         const state = getState(sessionId);
-        state.entries = state.entries.map((current) => current.id === entry.id ? entry : current);
+        state.entries = upsertEntry(state.entries, entry);
+        pruneTranslationEntries(sessionId, new Set([entry.id]));
         publishEntry(sessionId, entry);
     }
+    function recordFailure(sessionId, entry) {
+        if (!isRetryableFailedEntry(entry)) {
+            return;
+        }
+        const state = getState(sessionId);
+        const existing = state.failures.get(entry.id);
+        state.failures.set(entry.id, {
+            translationId: entry.id,
+            sessionId,
+            taskSlug: entry.taskSlug,
+            role: entry.role,
+            sourceText: entry.sourceText,
+            error: entry.error ?? "Translation failed.",
+            failedAt: entry.completedAt ?? now(),
+            retryCount: existing?.retryCount ?? 0,
+            lastRetryAt: existing?.lastRetryAt
+        });
+        publishFailures(sessionId);
+    }
+    function clearFailure(sessionId, translationId) {
+        const state = getState(sessionId);
+        if (state.failures.delete(translationId)) {
+            publishFailures(sessionId);
+        }
+    }
+    function pruneTranslationEntries(sessionId, protectedIds = new Set()) {
+        const state = getState(sessionId);
+        const overflow = state.entries.length - TRANSLATION_ENTRY_RETENTION_LIMIT;
+        if (overflow <= 0) {
+            return;
+        }
+        const removedIds = new Set();
+        for (const entry of state.entries) {
+            if (removedIds.size >= overflow) {
+                break;
+            }
+            if (protectedIds.has(entry.id) || isActiveTranslationEntry(entry)) {
+                continue;
+            }
+            removedIds.add(entry.id);
+        }
+        if (removedIds.size === 0) {
+            return;
+        }
+        state.entries = state.entries.filter((entry) => !removedIds.has(entry.id));
+        state.events = pruneTranslationEntryEvents(state.events, removedIds);
+        void persistEvents(state);
+        let failuresChanged = false;
+        for (const entryId of removedIds) {
+            failuresChanged = state.failures.delete(entryId) || failuresChanged;
+        }
+        if (failuresChanged) {
+            publishFailures(sessionId);
+        }
+    }
+    function markFailureRetrying(sessionId, failure) {
+        const retrying = {
+            ...failure,
+            retryCount: failure.retryCount + 1,
+            lastRetryAt: now()
+        };
+        getState(sessionId).failures.set(failure.translationId, retrying);
+        return retrying;
+    }
+    function retryOneTranslation(sessionId, original, config) {
+        const state = getState(sessionId);
+        const existingFailure = state.failures.get(original.id) ?? {
+            translationId: original.id,
+            sessionId,
+            taskSlug: original.taskSlug,
+            role: original.role,
+            sourceText: original.sourceText,
+            error: original.error ?? "Translation failed.",
+            failedAt: original.completedAt ?? now(),
+            retryCount: 0
+        };
+        markFailureRetrying(sessionId, existingFailure);
+        const retrying = startClaudeOutputTranslation(sessionId, original.sourceText, config, {
+            entryId: original.id,
+            replaceExisting: true
+        });
+        if (!retrying) {
+            throw new VcmError({
+                code: "TRANSLATION_RETRY_UNSUPPORTED",
+                message: "Translation entry cannot be retried.",
+                statusCode: 400
+            });
+        }
+        return retrying;
+    }
     function createEntry(input) {
         return {
             id: input.id ?? id(),
@@ -327,6 +448,9 @@ export function createTranslationService(deps) {
             translatedText: input.translatedText ?? "",
             status: input.status,
             contextUsed: input.contextUsed,
+            boundaryKind: input.boundaryKind,
+            conversationTurn: input.conversationTurn,
+            occurredAt: input.occurredAt,
             createdAt: now(),
             completedAt: input.completedAt,
             provider: input.settings.providerType,
@@ -413,6 +537,44 @@ export function createTranslationService(deps) {
                 events
             };
         },
+        async recordConversationBoundary(input) {
+            const { settings } = await loadConfig();
+            const state = await prepareCache({
+                repoRoot: input.taskRepoRoot ?? input.repoRoot,
+                taskSlug: input.taskSlug,
+                role: input.role,
+                sessionId: input.sessionId
+            });
+            const conversationTurn = resolveConversationBoundaryTurn(state, input.boundaryKind);
+            if (conversationTurn === undefined) {
+                return undefined;
+            }
+            const entryId = `boundary:${input.sessionId}:${conversationTurn}:${input.boundaryKind}`;
+            const existing = state.entries.find((entry) => entry.id === entryId);
+            if (existing) {
+                return existing;
+            }
+            const occurredAt = input.occurredAt ?? now();
+            const sourceText = formatConversationBoundaryText(input.boundaryKind, conversationTurn, occurredAt);
+            const entry = createEntry({
+                taskSlug: input.taskSlug,
+                role: input.role,
+                direction: "cc-output-to-user",
+                sourceKind: "conversation-boundary",
+                sourceText,
+                settings,
+                status: "preserved",
+                contextUsed: false,
+                id: entryId,
+                translatedText: sourceText,
+                completedAt: occurredAt,
+                boundaryKind: input.boundaryKind,
+                conversationTurn,
+                occurredAt
+            });
+            upsertAndPublishEntry(input.sessionId, entry);
+            return entry;
+        },
         async translateUserInput(input) {
             const { settings, secrets } = await loadConfig();
             if (!input.text.trim()) {
@@ -524,6 +686,7 @@ export function createTranslationService(deps) {
             for (const entry of state.entries) {
                 listener({ type: "translation-entry", entry });
             }
+            listener({ type: "translation-failures", failures: getFailureItems(state) });
             if (!state.unsubscribeTranscript) {
                 if (!roleSession) {
                     listener({
@@ -545,6 +708,7 @@ export function createTranslationService(deps) {
         async clearSession(sessionId) {
             const state = getState(sessionId);
             state.entries = [];
+            state.failures.clear();
             state.events = [];
             state.nextSeq = 1;
             queues.clearQueue(sessionId);
@@ -577,16 +741,45 @@ export function createTranslationService(deps) {
                     statusCode: 404
                 });
             }
-            if (original.direction !== "cc-output-to-user") {
+            if (!isRetryableFailedEntry(original)) {
                 throw new VcmError({
                     code: "TRANSLATION_RETRY_UNSUPPORTED",
-                    message: "Only Claude Code output translation entries can be retried.",
+                    message: "Only failed Claude Code output prose translation entries can be retried.",
                     statusCode: 400
                 });
             }
             const config = await loadConfig();
-            processClaudeOutputText(sessionId, original.sourceText, config);
-            return state.entries[state.entries.length - 1] ?? original;
+            const retrying = retryOneTranslation(sessionId, original, config);
+            publishFailures(sessionId);
+            return retrying;
+        },
+        async retryFailedTranslations(sessionId) {
+            const state = getState(sessionId);
+            const failures = getFailureItems(state);
+            const config = await loadConfig();
+            let changed = false;
+            for (const failure of failures) {
+                const original = state.entries.find((entry) => entry.id === failure.translationId);
+                if (!original || !isRetryableFailedEntry(original)) {
+                    state.failures.delete(failure.translationId);
+                    changed = true;
+                    continue;
+                }
+                retryOneTranslation(sessionId, original, config);
+                changed = true;
+            }
+            if (changed) {
+                publishFailures(sessionId);
+            }
+            return { failures: getFailureItems(state) };
+        },
+        async ignoreTranslationFailures(sessionId) {
+            const state = getState(sessionId);
+            if (state.failures.size > 0) {
+                state.failures.clear();
+                publishFailures(sessionId);
+            }
+            return { failures: [] };
         }
     };
     async function writeToCurrentRole(repoRoot, taskSlug, role, text) {
@@ -658,6 +851,80 @@ function formatUnknown(value) {
         return String(value);
     }
 }
+function resolveConversationBoundaryTurn(state, boundaryKind) {
+    const openTurn = getOpenConversationTurn(state);
+    if (boundaryKind === "start") {
+        return openTurn ?? getMaxConversationTurn(state) + 1;
+    }
+    return openTurn;
+}
+function getOpenConversationTurn(state) {
+    const startTurns = getBoundaryEntries(state)
+        .filter((entry) => entry.boundaryKind === "start")
+        .map((entry) => entry.conversationTurn)
+        .filter((turn) => typeof turn === "number" && Number.isFinite(turn))
+        .sort((left, right) => right - left);
+    return startTurns.find((turn) => !hasBoundaryEntry(state, turn, "end"));
+}
+function getMaxConversationTurn(state) {
+    return Math.max(0, ...getBoundaryEntries(state)
+        .map((entry) => entry.conversationTurn)
+        .filter((turn) => typeof turn === "number" && Number.isFinite(turn)));
+}
+function hasBoundaryEntry(state, conversationTurn, boundaryKind) {
+    return getBoundaryEntries(state).some((entry) => entry.boundaryKind === boundaryKind &&
+        entry.conversationTurn === conversationTurn);
+}
+function getBoundaryEntries(state) {
+    return state.entries.filter((entry) => entry.sourceKind === "conversation-boundary");
+}
+function getFailureItems(state) {
+    return Array.from(state.failures.values());
+}
+function isActiveTranslationEntry(entry) {
+    return entry.status === "queued" || entry.status === "translating";
+}
+function isRetryableFailedEntry(entry) {
+    return entry.status === "failed"
+        && entry.direction === "cc-output-to-user"
+        && entry.sourceKind === "prose";
+}
+function pruneTranslationEntryEvents(events, removedIds) {
+    const pruned = [];
+    for (const event of events) {
+        if (event.type === "entry") {
+            if (!removedIds.has(event.entry.id)) {
+                pruned.push(event);
+            }
+            continue;
+        }
+        if (event.type === "failures") {
+            pruned.push({
+                ...event,
+                failures: event.failures.filter((failure) => !removedIds.has(failure.translationId))
+            });
+            continue;
+        }
+        pruned.push(event);
+    }
+    return pruned;
+}
+function formatConversationBoundaryText(boundaryKind, conversationTurn, occurredAt) {
+    const label = boundaryKind === "start" ? "开始" : "结束";
+    return `-------${label}---第 ${conversationTurn} 轮----${formatBoundaryTime(occurredAt)}---------------`;
+}
+function formatBoundaryTime(value) {
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime())) {
+        return value;
+    }
+    return new Intl.DateTimeFormat(undefined, {
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: false
+    }).format(date);
+}
 function upsertEntry(entries, entry) {
     const index = entries.findIndex((current) => current.id === entry.id);
     if (index === -1) {

package/dist/backend/templates/harness/reviewer-agent.js

@@ -23,6 +23,8 @@ export function renderReviewerHarnessRules() {
 
 - Independently design the test coverage needed to prove the implemented behavior, including missing cases beyond coder's baseline tests.
 - Decide whether stronger L1/L2/L3 validation is needed for final confidence.
+- Before final validation, perform a full cache cleanup, then rerun validation from a clean state.
+- Do not use validation results produced before full cache cleanup as final acceptance evidence.
 - Add or modify tests needed for test adequacy.
 - Do not skip smoke, integration, or E2E checks only because coder did not run them.
 

package/dist/shared/types/translation.js

@@ -3,3 +3,4 @@ export const TRANSLATION_PROMPT_KEYS = [
     "zh-to-en-with-context",
     "en-to-zh"
 ];
+export const TRANSLATION_ENTRY_RETENTION_LIMIT = 500;