vibe-coding-master 0.3.21 → 0.3.23

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

@@ -7,7 +7,6 @@ const TRANSLATIONS_ROOT = ".ai/vcm/translations";
 const TRANSLATIONS_RUNTIME_DIR = `${TRANSLATIONS_ROOT}/runtime`;
 const MEMORY_DIR = `${TRANSLATIONS_ROOT}/memory`;
 const QUEUE_PATH = `${TRANSLATIONS_RUNTIME_DIR}/queue.json`;
-const LEGACY_QUEUE_PATH = `${TRANSLATIONS_ROOT}/queue.json`;
 const FILE_INDEX_PATH = `${TRANSLATIONS_ROOT}/files/index.json`;
 const FILE_COMPLETED_DIR = `${TRANSLATIONS_ROOT}/files/completed`;
 const FILE_RUNTIME_JOBS_DIR = `${TRANSLATIONS_RUNTIME_DIR}/files/jobs`;
@@ -15,10 +14,6 @@ const BOOTSTRAP_INDEX_PATH = `${TRANSLATIONS_ROOT}/bootstrap/index.json`;
 const BOOTSTRAP_RUNTIME_RUNS_DIR = `${TRANSLATIONS_RUNTIME_DIR}/bootstrap/runs`;
 const CONVERSATION_RUNTIME_DIR = `${TRANSLATIONS_RUNTIME_DIR}/conversations`;
 const MEMORY_UPDATE_RUNTIME_DIR = `${TRANSLATIONS_RUNTIME_DIR}/memory-updates`;
-const TRANSLATOR_LOG_PATHS = [
-    `${TRANSLATIONS_RUNTIME_DIR}/codex-translator.log`,
-    `${TRANSLATIONS_ROOT}/codex-translator.log`
-];
 const DEFAULT_PROFILE = "default";
 const DEFAULT_CHUNK_SOURCE_TOKEN_TARGET = 80000;
 const BOOTSTRAP_DEFAULT_LIMIT = 12;
@@ -115,7 +110,6 @@ export function createCodexTranslationService(deps) {
         await ensureMemoryFile(repoRoot, "style-guide.md", "# Style Guide\n");
         await ensureMemoryFile(repoRoot, "project-context.md", "# Project Context\n");
         await ensureMemoryFile(repoRoot, "decisions.md", "# Decisions\n");
-        await cleanupTranslatorLogs(repoRoot);
     }
     async function ensureMemoryFile(repoRoot, fileName, content) {
         await deps.fs.ensureFile(resolveRepoPath(repoRoot, `${MEMORY_DIR}/${fileName}`), content);
@@ -129,19 +123,9 @@ export function createCodexTranslationService(deps) {
             force: true
         });
     }
-    async function cleanupTranslatorLogs(repoRoot) {
-        await Promise.all(TRANSLATOR_LOG_PATHS.map((relativePath) => removeRepoPath(repoRoot, relativePath)));
-    }
     async function loadQueue(repoRoot) {
         const queuePath = resolveRepoPath(repoRoot, QUEUE_PATH);
         if (!(await deps.fs.pathExists(queuePath))) {
-            const legacyQueuePath = resolveRepoPath(repoRoot, LEGACY_QUEUE_PATH);
-            if (await deps.fs.pathExists(legacyQueuePath)) {
-                const migrated = normalizeQueue(await deps.fs.readJson(legacyQueuePath));
-                await deps.fs.writeJsonAtomic(queuePath, migrated);
-                await removeRepoPath(repoRoot, LEGACY_QUEUE_PATH);
-                return migrated;
-            }
             return {
                 version: 1,
                 updatedAt: now(),
@@ -152,7 +136,6 @@ export function createCodexTranslationService(deps) {
     }
     async function saveQueue(repoRoot, queue) {
         await deps.fs.writeJsonAtomic(resolveRepoPath(repoRoot, QUEUE_PATH), queue);
-        await removeRepoPath(repoRoot, LEGACY_QUEUE_PATH);
     }
     async function loadFileIndex(repoRoot) {
         const indexPath = resolveRepoPath(repoRoot, FILE_INDEX_PATH);
@@ -195,7 +178,7 @@ export function createCodexTranslationService(deps) {
         await saveQueue(repoRoot, queue);
         return queued;
     }
-    async function dispatchNext(repoRoot, taskSlug) {
+    async function dispatchNext(repoRoot) {
         if (!deps.runtime || !deps.sessionService) {
             return;
         }
@@ -224,7 +207,7 @@ export function createCodexTranslationService(deps) {
                 queue.updatedAt = next.updatedAt;
                 await saveQueue(repoRoot, queue);
             }
-            const session = await ensureTranslatorSession(repoRoot, taskSlug, next.targetLanguage);
+            const session = await ensureTranslatorSession(repoRoot, next.targetLanguage);
             await submitTerminalInput(deps.runtime, session.id, batch?.prompt ?? await buildQueuePrompt(repoRoot, next));
             const dispatchedAt = now();
             for (const item of batch?.items ?? [next]) {
@@ -272,7 +255,7 @@ export function createCodexTranslationService(deps) {
         await saveQueue(repoRoot, queue);
         return { items: candidates, prompt };
     }
-    async function ensureTranslatorSession(repoRoot, taskSlug, targetLanguage) {
+    async function ensureTranslatorSession(repoRoot, targetLanguage) {
         void targetLanguage;
         if (!deps.sessionService) {
             throw new VcmError({
@@ -281,17 +264,7 @@ export function createCodexTranslationService(deps) {
                 statusCode: 500
             });
         }
-        const existing = await deps.sessionService.getRoleSession(repoRoot, taskSlug, CODEX_TRANSLATOR_ROLE);
-        if (existing?.status === "running") {
-            return existing;
-        }
-        if (existing?.claudeSessionId) {
-            return deps.sessionService.resumeRoleSession(repoRoot, taskSlug, CODEX_TRANSLATOR_ROLE, {
-                model: existing.model,
-                effort: existing.effort
-            });
-        }
-        return deps.sessionService.startRoleSession(repoRoot, taskSlug, CODEX_TRANSLATOR_ROLE, {
+        return deps.sessionService.ensureProjectTranslatorSession(repoRoot, {
             model: "gpt-5.5",
             effort: "medium"
         });
@@ -577,6 +550,7 @@ export function createCodexTranslationService(deps) {
         try {
             const request = await deps.fs.readJson(resolveRepoPath(repoRoot, requestPath));
             return {
+                job: isFileJob(request.job) ? request.job : undefined,
                 chunks: Array.isArray(request.chunks) ? request.chunks.filter(isFileTranslationChunk) : []
             };
         }
@@ -584,6 +558,37 @@ export function createCodexTranslationService(deps) {
             return {};
         }
     }
+    async function loadRuntimeFileJob(repoRoot, item) {
+        if (!isFileTranslationQueueItem(item)) {
+            return undefined;
+        }
+        const request = await loadFileTranslationRequest(repoRoot, item.requestPath);
+        if (!request.job) {
+            return undefined;
+        }
+        return {
+            ...request.job,
+            status: toFileJobStatus(item.status),
+            queueItemId: item.id,
+            updatedAt: item.updatedAt
+        };
+    }
+    async function loadRuntimeFileJobs(repoRoot, queue) {
+        const sourceQueue = queue ?? await loadQueue(repoRoot);
+        const jobs = await Promise.all(sourceQueue.items
+            .filter(isFileTranslationQueueItem)
+            .filter((item) => item.status !== "completed")
+            .map((item) => loadRuntimeFileJob(repoRoot, item)));
+        return jobs
+            .filter((job) => Boolean(job))
+            .sort(compareFileJobUpdatedAtDesc);
+    }
+    async function findRuntimeFileJobById(repoRoot, jobId) {
+        const queue = await loadQueue(repoRoot);
+        const item = queue.items.find((candidate) => isFileTranslationQueueItem(candidate) &&
+            candidate.jobId === jobId);
+        return item ? loadRuntimeFileJob(repoRoot, item) : undefined;
+    }
     async function validateMemoryBudget(repoRoot) {
         const [usage, unexpectedEntries] = await Promise.all([
             getMemoryUsage(repoRoot, deps.fs),
@@ -630,19 +635,29 @@ export function createCodexTranslationService(deps) {
         if (item.type === "conversation") {
             return;
         }
-        const index = await loadFileIndex(repoRoot);
-        const job = index.jobs.find((candidate) => candidate.id === item.jobId);
-        if (job) {
-            job.status = item.status === "needs_review" ? "needs_review" : item.status;
-            job.updatedAt = now();
-            if (item.status === "completed") {
-                await finalizeCompletedFileJob(repoRoot, job);
-                job.completedAt = job.updatedAt;
-                await cleanupSupersededCompletedFileJobs(repoRoot, index);
-            }
-            index.updatedAt = job.updatedAt;
-            await saveFileIndex(repoRoot, index);
+        if (!isFileTranslationQueueItem(item) || item.status !== "completed") {
+            return;
+        }
+        const runtimeJob = await loadRuntimeFileJob(repoRoot, item);
+        if (!runtimeJob) {
+            return;
         }
+        const completedAt = now();
+        const completedJob = {
+            ...runtimeJob,
+            status: "completed",
+            updatedAt: completedAt,
+            completedAt
+        };
+        await finalizeCompletedFileJob(repoRoot, completedJob);
+        const index = await loadFileIndex(repoRoot);
+        index.jobs = [
+            completedJob,
+            ...index.jobs.filter((job) => job.id !== completedJob.id)
+        ];
+        await cleanupSupersededCompletedFileJobs(repoRoot, index);
+        index.updatedAt = completedAt;
+        await saveFileIndex(repoRoot, index);
     }
     async function cleanupCompletedRuntime(repoRoot) {
         const fileIndex = await loadFileIndex(repoRoot);
@@ -674,6 +689,48 @@ export function createCodexTranslationService(deps) {
             .map((item) => cleanupRuntimeDirectoryForPath(repoRoot, item.requestPath)));
         await pruneQueueItems(repoRoot, isPrunableCompletedQueueItem);
     }
+    async function cleanupStartupFileIndex(repoRoot) {
+        const indexPath = resolveRepoPath(repoRoot, FILE_INDEX_PATH);
+        if (!(await deps.fs.pathExists(indexPath))) {
+            return;
+        }
+        const index = await loadFileIndex(repoRoot);
+        const seenKeys = new Set();
+        const jobs = [];
+        for (const job of index.jobs) {
+            if (job.status !== "completed" || !isCompletedFileResultPath(job.resultPath)) {
+                continue;
+            }
+            const key = fileTranslationReplacementKey(job);
+            if (seenKeys.has(key)) {
+                continue;
+            }
+            if (await deps.fs.pathExists(resolveRepoPath(repoRoot, job.resultPath))) {
+                seenKeys.add(key);
+                jobs.push(job);
+            }
+        }
+        if (jobs.length === index.jobs.length) {
+            return;
+        }
+        index.jobs = jobs;
+        index.updatedAt = now();
+        await saveFileIndex(repoRoot, index);
+    }
+    async function cleanupStartupBootstrapIndex(repoRoot) {
+        const indexPath = resolveRepoPath(repoRoot, BOOTSTRAP_INDEX_PATH);
+        if (!(await deps.fs.pathExists(indexPath))) {
+            return;
+        }
+        const index = await loadBootstrapIndex(repoRoot);
+        const runs = index.runs.filter((run) => run.status === "completed");
+        if (runs.length === index.runs.length) {
+            return;
+        }
+        index.runs = runs;
+        index.updatedAt = now();
+        await saveBootstrapIndex(repoRoot, index);
+    }
     async function finalizeCompletedFileJob(repoRoot, job) {
         const finalResultPath = completedFileResultPath(job.sourcePath, job.targetLanguage, job.translationProfile);
         const absoluteCurrentResultPath = resolveRepoPath(repoRoot, job.resultPath);
@@ -750,6 +807,11 @@ export function createCodexTranslationService(deps) {
         await saveQueue(repoRoot, queue);
     }
     return {
+        async cleanupStartupRuntime(repoRoot) {
+            await removeRepoPath(repoRoot, TRANSLATIONS_RUNTIME_DIR, true);
+            await cleanupStartupFileIndex(repoRoot);
+            await cleanupStartupBootstrapIndex(repoRoot);
+        },
         async getState(repoRoot) {
             await ensureLayout(repoRoot);
             await cleanupCompletedRuntime(repoRoot);
@@ -759,9 +821,13 @@ export function createCodexTranslationService(deps) {
                 loadBootstrapIndex(repoRoot),
                 isMemoryInitialized(repoRoot, deps.fs)
             ]);
+            const runtimeFileJobs = await loadRuntimeFileJobs(repoRoot, queue);
             return {
                 queue,
-                fileIndex,
+                fileIndex: visibleFileTranslationIndex({
+                    ...fileIndex,
+                    jobs: [...runtimeFileJobs, ...fileIndex.jobs]
+                }),
                 bootstrapIndex,
                 memoryInitialized
             };
@@ -822,7 +888,13 @@ export function createCodexTranslationService(deps) {
             const targetLanguage = input.targetLanguage.trim() || "zh-CN";
             const profile = input.translationProfile?.trim() || DEFAULT_PROFILE;
             const dedupeKey = sha256(`${sourceHash}|${targetLanguage}|${profile}`);
-            const index = await loadFileIndex(repoRoot);
+            const replacementKey = fileTranslationReplacementKeyFromParts(sourcePath, targetLanguage, profile);
+            const activeExisting = (await loadRuntimeFileJobs(repoRoot)).find((job) => fileTranslationReplacementKey(job) === replacementKey &&
+                isActiveFileTranslationJobStatus(job.status));
+            if (activeExisting) {
+                void dispatchNext(repoRoot);
+                return activeExisting;
+            }
             const timestamp = now();
             const jobId = `file-${safeId(path.basename(sourcePath, path.extname(sourcePath)))}-${Date.now()}-${createId().slice(0, 8)}`;
             const jobRoot = `${FILE_RUNTIME_JOBS_DIR}/${jobId}`;
@@ -919,12 +991,7 @@ export function createCodexTranslationService(deps) {
                 lastUpdatedAt: timestamp
             });
             await deps.fs.writeText(resolveRepoPath(repoRoot, job.reportPath), `# Translation Report\n\nStatus: queued\nJob: ${jobId}\n`);
-            index.jobs = [job, ...index.jobs];
-            index.updatedAt = timestamp;
-            await saveFileIndex(repoRoot, index);
-            if (input.taskSlug) {
-                void dispatchNext(repoRoot, input.taskSlug);
-            }
+            void dispatchNext(repoRoot);
             return job;
         },
         async createBootstrapRun(repoRoot, input) {
@@ -981,9 +1048,7 @@ export function createCodexTranslationService(deps) {
             index.runs = [run, ...index.runs];
             index.updatedAt = timestamp;
             await saveBootstrapIndex(repoRoot, index);
-            if (input.taskSlug) {
-                void dispatchNext(repoRoot, input.taskSlug);
-            }
+            void dispatchNext(repoRoot);
             return run;
         },
         async createMemoryUpdate(repoRoot, input) {
@@ -1039,15 +1104,14 @@ export function createCodexTranslationService(deps) {
                     "Delete or merge stale, duplicate, temporary, and task-local content."
                 ]
             });
-            if (input.taskSlug) {
-                void dispatchNext(repoRoot, input.taskSlug);
-            }
+            void dispatchNext(repoRoot);
             return queueItem;
         },
         async readFileJobOutput(repoRoot, jobId) {
             await ensureLayout(repoRoot);
             const index = await loadFileIndex(repoRoot);
-            const job = index.jobs.find((candidate) => candidate.id === jobId);
+            const job = index.jobs.find((candidate) => candidate.id === jobId)
+                ?? await findRuntimeFileJobById(repoRoot, jobId);
             if (!job) {
                 throw new VcmError({
                     code: "TRANSLATION_JOB_MISSING",
@@ -1074,14 +1138,12 @@ export function createCodexTranslationService(deps) {
                 });
             }
             const timestamp = now();
-            const jobId = `conversation-${safeId(input.role)}-${Date.now()}-${createId().slice(0, 8)}`;
-            const jobRoot = `${CONVERSATION_RUNTIME_DIR}/${safeId(input.taskSlug)}/${safeId(input.role)}/jobs/${jobId}`;
+            const jobId = `conversation-${Date.now()}-${createId().slice(0, 8)}`;
+            const jobRoot = `${CONVERSATION_RUNTIME_DIR}/jobs/${jobId}`;
             const sourceHash = `sha256:${sha256(sourceText)}`;
             const targetLanguage = input.targetLanguage.trim() || "zh-CN";
             const job = {
                 id: jobId,
-                taskSlug: input.taskSlug,
-                role: input.role,
                 direction: input.direction,
                 sourceHash,
                 sourceLanguage: input.sourceLanguage.trim() || "auto",
@@ -1105,15 +1167,10 @@ export function createCodexTranslationService(deps) {
                 version: 1,
                 baseRepoRoot: repoRoot,
                 pathBase: "baseRepoRoot",
-                job,
-                taskSlug: input.taskSlug,
-                role: input.role,
                 direction: input.direction,
-                sourceHash,
                 sourceLanguage: job.sourceLanguage,
                 targetLanguage,
                 translationProfile: input.translationProfile?.trim() || DEFAULT_PROFILE,
-                contextText: input.contextText,
                 sourceContentBoundary: "VCM_TEXT",
                 sourceText,
                 absolutePaths: {
@@ -1126,8 +1183,8 @@ export function createCodexTranslationService(deps) {
                     format: "plain-text"
                 }
             });
-            if (input.taskSlug && !input.deferDispatch) {
-                void dispatchNext(repoRoot, input.taskSlug);
+            if (!input.deferDispatch) {
+                void dispatchNext(repoRoot);
             }
             return job;
         },
@@ -1208,6 +1265,7 @@ export function createCodexTranslationService(deps) {
             return job;
         },
         async handleCodexHook(repoRoot, eventName, taskSlug) {
+            void taskSlug;
             if (eventName === "UserPromptSubmit") {
                 const queue = await loadQueue(repoRoot);
                 const active = queue.activeItemId
@@ -1224,10 +1282,11 @@ export function createCodexTranslationService(deps) {
             }
             if (eventName === "Stop") {
                 await validateActiveQueueItem(repoRoot);
-                if (taskSlug) {
-                    await dispatchNext(repoRoot, taskSlug);
-                }
+                await dispatchNext(repoRoot);
             }
+        },
+        ensureTranslatorSession(repoRoot) {
+            return ensureTranslatorSession(repoRoot, "zh-CN");
         }
     };
 }
@@ -1607,12 +1666,60 @@ function completedFileResultPath(sourcePath, targetLanguage, translationProfile)
     return `${FILE_COMPLETED_DIR}/${sourceBaseName}-${languagePart}-${profilePart}-${sourcePathHash}.md`;
 }
 function fileTranslationReplacementKey(job) {
+    return fileTranslationReplacementKeyFromParts(job.sourcePath, job.targetLanguage, job.translationProfile);
+}
+function fileTranslationReplacementKeyFromParts(sourcePath, targetLanguage, translationProfile) {
     return [
-        normalizeRepoRelative(job.sourcePath),
-        job.targetLanguage.trim(),
-        (job.translationProfile || DEFAULT_PROFILE).trim()
+        normalizeRepoRelative(sourcePath),
+        targetLanguage.trim(),
+        (translationProfile || DEFAULT_PROFILE).trim()
     ].join("\0");
 }
+function isActiveFileTranslationJobStatus(status) {
+    return status === "queued" || status === "running" || status === "validating";
+}
+function isFileTranslationQueueItem(item) {
+    return item.type === "file" || item.type === "force-retranslate";
+}
+function toFileJobStatus(status) {
+    if (status === "dispatching") {
+        return "running";
+    }
+    return status === "completed" ||
+        status === "queued" ||
+        status === "running" ||
+        status === "validating" ||
+        status === "needs_review" ||
+        status === "failed" ||
+        status === "interrupted" ||
+        status === "skipped" ||
+        status === "cancelled"
+        ? status
+        : "failed";
+}
+function compareFileJobUpdatedAtDesc(left, right) {
+    return (right.updatedAt ?? "").localeCompare(left.updatedAt ?? "");
+}
+function isCompletedFileResultPath(relativePath) {
+    const normalized = normalizeRepoRelative(relativePath);
+    return normalized.startsWith(`${FILE_COMPLETED_DIR}/`);
+}
+function visibleFileTranslationIndex(index) {
+    const seenKeys = new Set();
+    const jobs = [];
+    for (const job of index.jobs) {
+        const key = fileTranslationReplacementKey(job);
+        if (seenKeys.has(key)) {
+            continue;
+        }
+        seenKeys.add(key);
+        jobs.push(job);
+    }
+    return {
+        ...index,
+        jobs
+    };
+}
 function retainedCompletedFileJobIds(index) {
     const seenKeys = new Set();
     const retainedIds = new Set();
@@ -1637,10 +1744,7 @@ function isPrunableCompletedQueueItem(item) {
 }
 function isTranslationRuntimeDirectory(relativePath) {
     const normalized = normalizeRepoRelative(relativePath);
-    return normalized.startsWith(`${TRANSLATIONS_RUNTIME_DIR}/`) ||
-        normalized.startsWith(`${TRANSLATIONS_ROOT}/files/jobs/`) ||
-        normalized.startsWith(`${TRANSLATIONS_ROOT}/bootstrap/runs/`) ||
-        normalized.startsWith(`${TRANSLATIONS_ROOT}/conversations/`);
+    return normalized.startsWith(`${TRANSLATIONS_RUNTIME_DIR}/`);
 }
 async function readStandaloneConversationResult(repoRoot, resultRelativePath, fs) {
     const resultPath = resolveRepoPath(repoRoot, resultRelativePath);