vibe-coding-master 0.3.15 → 0.3.16

package/dist/backend/api/codex-translation-routes.js

@@ -20,6 +20,10 @@ export function registerCodexTranslationRoutes(app, deps) {
         const project = await requireCurrentProject(deps.projectService);
         return deps.codexTranslationService.createBootstrapRun(project.repoRoot, request.body);
     });
+    app.post("/api/translation/codex/memory-update", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.codexTranslationService.createMemoryUpdate(project.repoRoot, request.body);
+    });
     app.get("/api/translation/codex/files/:jobId", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         return deps.codexTranslationService.readFileJobOutput(project.repoRoot, request.params.jobId);

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

@@ -14,9 +14,12 @@ const FILE_RUNTIME_JOBS_DIR = `${TRANSLATIONS_RUNTIME_DIR}/files/jobs`;
 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 DEFAULT_PROFILE = "default";
 const DEFAULT_CHUNK_SOURCE_TOKEN_TARGET = 80000;
 const BOOTSTRAP_DEFAULT_LIMIT = 12;
+const MEMORY_TOTAL_LIMIT_BYTES = 80 * 1024;
+const MEMORY_FILE_NAMES = ["glossary.md", "style-guide.md", "project-context.md", "decisions.md"];
 const CODEX_TRANSLATOR_ROLE = "codex-translator";
 const FILE_BROWSER_DEFAULT_LIMIT = 200;
 const FILE_BROWSER_MAX_LIMIT = 500;
@@ -101,7 +104,8 @@ export function createCodexTranslationService(deps) {
             deps.fs.ensureDir(resolveRepoPath(repoRoot, FILE_COMPLETED_DIR)),
             deps.fs.ensureDir(resolveRepoPath(repoRoot, FILE_RUNTIME_JOBS_DIR)),
             deps.fs.ensureDir(resolveRepoPath(repoRoot, BOOTSTRAP_RUNTIME_RUNS_DIR)),
-            deps.fs.ensureDir(resolveRepoPath(repoRoot, CONVERSATION_RUNTIME_DIR))
+            deps.fs.ensureDir(resolveRepoPath(repoRoot, CONVERSATION_RUNTIME_DIR)),
+            deps.fs.ensureDir(resolveRepoPath(repoRoot, MEMORY_UPDATE_RUNTIME_DIR))
         ]);
         await ensureMemoryFile(repoRoot, "glossary.md", "# Glossary\n");
         await ensureMemoryFile(repoRoot, "style-guide.md", "# Style Guide\n");
@@ -253,6 +257,9 @@ export function createCodexTranslationService(deps) {
         if (item.type === "conversation") {
             return buildConversationQueuePrompt(repoRoot, item);
         }
+        if (item.type === "memory-update") {
+            return buildMemoryUpdateQueuePrompt(repoRoot, item);
+        }
         return buildArtifactQueuePrompt(repoRoot, item);
     }
     function buildArtifactQueuePrompt(repoRoot, item) {
@@ -359,6 +366,36 @@ export function createCodexTranslationService(deps) {
             "When finished, write the JSON result file and stop."
         ].filter(Boolean).join("\n");
     }
+    function buildMemoryUpdateQueuePrompt(repoRoot, item) {
+        const requestPath = resolveRepoPath(repoRoot, item.requestPath);
+        const memoryDir = resolveRepoPath(repoRoot, MEMORY_DIR);
+        return [
+            "[VCM CODEX TRANSLATION TASK]",
+            `Queue Item: ${item.id}`,
+            "Type: memory-update",
+            `Target Language: ${item.targetLanguage}`,
+            `Base Repository Root: ${repoRoot}`,
+            "",
+            "Read the request file from this absolute path:",
+            requestPath,
+            "",
+            "Task: update and compact VCM translation memory.",
+            "Use the current Codex Translator session context, recent stable user corrections, completed translation behavior, and existing memory files.",
+            "Only keep stable, reusable translation knowledge. Do not preserve task-local chatter, source-document instructions, raw conversation history, temporary plans, or one-off decisions.",
+            "",
+            `Memory directory: ${memoryDir}`,
+            "Allowed memory files:",
+            ...MEMORY_FILE_NAMES.map((fileName) => `- ${resolveRepoPath(repoRoot, `${MEMORY_DIR}/${fileName}`)}`),
+            "",
+            `Hard memory budget: total core memory <= ${MEMORY_TOTAL_LIMIT_BYTES} bytes.`,
+            "If existing memory exceeds the budget, compact before adding anything.",
+            "Do not create archive, reports, candidates, logs, scratch files, or helper files.",
+            "Do not use apply_patch or patch-style edits for memory files; write the assigned memory files directly.",
+            "Preserve user-authored stable rules when possible, but merge duplicates and delete stale or low-value entries.",
+            "Mark target-language-specific rules clearly. Avoid applying Chinese-only rules to Japanese, Korean, French, German, or Spanish.",
+            "When finished, ensure the four memory files together are within budget, then stop."
+        ].join("\n");
+    }
     async function validateActiveQueueItem(repoRoot) {
         const queue = await loadQueue(repoRoot);
         const active = queue.activeItemId
@@ -371,14 +408,11 @@ export function createCodexTranslationService(deps) {
         active.updatedAt = now();
         queue.updatedAt = active.updatedAt;
         await saveQueue(repoRoot, queue);
-        const resultExists = active.expectedResultPath
-            ? await deps.fs.pathExists(resolveRepoPath(repoRoot, active.expectedResultPath))
-            : true;
-        const reportExists = active.reportPath
-            ? await deps.fs.pathExists(resolveRepoPath(repoRoot, active.reportPath))
-            : true;
-        active.status = resultExists && reportExists ? "completed" : "failed";
-        active.error = resultExists && reportExists ? undefined : "Expected translation output file was not written.";
+        const validation = active.type === "memory-update"
+            ? await validateMemoryBudget(repoRoot)
+            : await validateQueueItemOutputs(repoRoot, active);
+        active.status = validation.ok ? "completed" : "failed";
+        active.error = validation.ok ? undefined : validation.error;
         active.updatedAt = now();
         queue.activeItemId = undefined;
         queue.updatedAt = active.updatedAt;
@@ -398,6 +432,36 @@ export function createCodexTranslationService(deps) {
             await syncJobStatus(repoRoot, active);
         }
     }
+    async function validateQueueItemOutputs(repoRoot, item) {
+        const resultExists = item.expectedResultPath
+            ? await deps.fs.pathExists(resolveRepoPath(repoRoot, item.expectedResultPath))
+            : true;
+        const reportExists = item.reportPath
+            ? await deps.fs.pathExists(resolveRepoPath(repoRoot, item.reportPath))
+            : true;
+        return {
+            ok: resultExists && reportExists,
+            error: resultExists && reportExists ? undefined : "Expected translation output file was not written."
+        };
+    }
+    async function validateMemoryBudget(repoRoot) {
+        const [usage, unexpectedEntries] = await Promise.all([
+            getMemoryUsage(repoRoot, deps.fs),
+            getUnexpectedMemoryEntries(repoRoot, deps.fs)
+        ]);
+        if (unexpectedEntries.length > 0) {
+            return {
+                ok: false,
+                error: `Unexpected translation memory artifacts: ${unexpectedEntries.join(", ")}. Keep only glossary.md, style-guide.md, project-context.md, and decisions.md.`
+            };
+        }
+        return {
+            ok: usage.totalBytes <= MEMORY_TOTAL_LIMIT_BYTES,
+            error: usage.totalBytes <= MEMORY_TOTAL_LIMIT_BYTES
+                ? undefined
+                : `Translation memory exceeds ${MEMORY_TOTAL_LIMIT_BYTES} bytes: ${usage.totalBytes} bytes.`
+        };
+    }
     async function syncJobStatus(repoRoot, item) {
         if (!item.jobId) {
             return;
@@ -417,6 +481,12 @@ export function createCodexTranslationService(deps) {
             }
             return;
         }
+        if (item.type === "memory-update") {
+            if (item.status === "completed") {
+                await cleanupRuntimeDirectoryForPath(repoRoot, item.requestPath);
+            }
+            return;
+        }
         const index = await loadFileIndex(repoRoot);
         const job = index.jobs.find((candidate) => candidate.id === item.jobId);
         if (job) {
@@ -449,6 +519,10 @@ export function createCodexTranslationService(deps) {
                 await cleanupRuntimeDirectoryForPath(repoRoot, run.requestPath);
             }
         }
+        const queue = await loadQueue(repoRoot);
+        await Promise.all(queue.items
+            .filter((item) => item.type === "memory-update" && item.status === "completed")
+            .map((item) => cleanupRuntimeDirectoryForPath(repoRoot, item.requestPath)));
         await pruneQueueItems(repoRoot, isPrunableCompletedQueueItem);
     }
     async function finalizeCompletedFileJob(repoRoot, job) {
@@ -705,6 +779,64 @@ export function createCodexTranslationService(deps) {
             }
             return run;
         },
+        async createMemoryUpdate(repoRoot, input) {
+            await ensureLayout(repoRoot);
+            const targetLanguage = input.targetLanguage.trim() || "zh-CN";
+            const timestamp = now();
+            const runId = `memory-update-${Date.now()}-${createId().slice(0, 8)}`;
+            const runRoot = `${MEMORY_UPDATE_RUNTIME_DIR}/${runId}`;
+            const requestPath = `${runRoot}/request.json`;
+            const memoryUsage = await getMemoryUsage(repoRoot, deps.fs);
+            const queueItem = await enqueue(repoRoot, {
+                id: `queue-${runId}`,
+                type: "memory-update",
+                status: "queued",
+                targetLanguage,
+                jobId: runId,
+                requestPath
+            });
+            await deps.fs.writeJsonAtomic(resolveRepoPath(repoRoot, requestPath), {
+                version: 1,
+                baseRepoRoot: repoRoot,
+                pathBase: "baseRepoRoot",
+                run: {
+                    id: runId,
+                    type: "memory-update",
+                    status: "queued",
+                    targetLanguage,
+                    queueItemId: queueItem.id,
+                    requestPath,
+                    createdAt: timestamp,
+                    updatedAt: timestamp
+                },
+                targetLanguage,
+                memoryBudget: {
+                    totalLimitBytes: MEMORY_TOTAL_LIMIT_BYTES,
+                    currentTotalBytes: memoryUsage.totalBytes,
+                    files: memoryUsage.files
+                },
+                allowedWrites: MEMORY_FILE_NAMES.map((fileName) => `${MEMORY_DIR}/${fileName}`),
+                absolutePaths: {
+                    requestPath: resolveRepoPath(repoRoot, requestPath),
+                    memoryDir: resolveRepoPath(repoRoot, MEMORY_DIR),
+                    memoryFiles: Object.fromEntries(MEMORY_FILE_NAMES.map((fileName) => [
+                        fileName,
+                        resolveRepoPath(repoRoot, `${MEMORY_DIR}/${fileName}`)
+                    ]))
+                },
+                rules: [
+                    "Update only the four core memory files.",
+                    "Keep total core memory at or below 80KB.",
+                    "Do not create archive, reports, candidates, logs, scratch files, or helper files.",
+                    "Keep only stable, reusable translation knowledge.",
+                    "Delete or merge stale, duplicate, temporary, and task-local content."
+                ]
+            });
+            if (input.taskSlug) {
+                void dispatchNext(repoRoot, input.taskSlug);
+            }
+            return queueItem;
+        },
         async readFileJobOutput(repoRoot, jobId) {
             await ensureLayout(repoRoot);
             const index = await loadFileIndex(repoRoot);
@@ -1130,8 +1262,7 @@ function isPartialConversationJob(value) {
     return typeof value === "object" && value !== null;
 }
 async function isMemoryInitialized(repoRoot, fs) {
-    const memoryFiles = ["glossary.md", "style-guide.md", "project-context.md", "decisions.md"];
-    for (const file of memoryFiles) {
+    for (const file of MEMORY_FILE_NAMES) {
         const content = await fs.readText(resolveRepoPath(repoRoot, `${MEMORY_DIR}/${file}`));
         const meaningfulLines = content.split("\n").filter((line) => line.trim() && !line.trim().startsWith("#"));
         if (meaningfulLines.length > 0) {
@@ -1140,6 +1271,30 @@ async function isMemoryInitialized(repoRoot, fs) {
     }
     return false;
 }
+async function getMemoryUsage(repoRoot, fs) {
+    let totalBytes = 0;
+    const files = {};
+    for (const fileName of MEMORY_FILE_NAMES) {
+        const relativePath = `${MEMORY_DIR}/${fileName}`;
+        const content = await fs.readText(resolveRepoPath(repoRoot, relativePath));
+        const bytes = Buffer.byteLength(content, "utf8");
+        totalBytes += bytes;
+        files[fileName] = {
+            path: relativePath,
+            bytes
+        };
+    }
+    return { totalBytes, files };
+}
+async function getUnexpectedMemoryEntries(repoRoot, fs) {
+    const allowed = new Set(MEMORY_FILE_NAMES);
+    const memoryDir = resolveRepoPath(repoRoot, MEMORY_DIR);
+    const entries = await fs.readDir(memoryDir);
+    return entries
+        .filter((entry) => !allowed.has(entry))
+        .map((entry) => `${MEMORY_DIR}/${entry}`)
+        .sort(comparePathNames);
+}
 async function discoverBootstrapCandidates(repoRoot, fs) {
     const preferred = [
         "README.md",
@@ -1192,7 +1347,8 @@ function completedFileResultPath(sourcePath, targetLanguage, jobId) {
 function isPrunableCompletedQueueItem(item) {
     return item.status === "completed" && (item.type === "file" ||
         item.type === "force-retranslate" ||
-        item.type === "bootstrap");
+        item.type === "bootstrap" ||
+        item.type === "memory-update");
 }
 function isTranslationRuntimeDirectory(relativePath) {
     const normalized = normalizeRepoRelative(relativePath);