vibe-coding-master 0.3.14 → 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/gateway/gateway-service.js

@@ -438,7 +438,7 @@ export function createGatewayService(deps) {
                     ...settings,
                     currentProjectId: project.repoRoot,
                     currentTaskSlug: task.taskSlug,
-                    translationEnabled: template.translationEnabled,
+                    translationEnabled: preferences.translationEnabled,
                     updatedAt: now()
                 });
                 throw new VcmError({
@@ -454,7 +454,7 @@ export function createGatewayService(deps) {
             ...settings,
             currentProjectId: project.repoRoot,
             currentTaskSlug: task.taskSlug,
-            translationEnabled: template.translationEnabled,
+            translationEnabled: preferences.translationEnabled,
             updatedAt: now()
         });
         return [
@@ -462,7 +462,7 @@ export function createGatewayService(deps) {
             `branch: ${task.branch}`,
             `worktree: ${task.worktreePath ?? task.repoRoot}`,
             `orchestration: ${template.autoOrchestration ? "auto" : "manual"}`,
-            `translation: ${template.translationEnabled ? "on" : "off"}`,
+            `translation: ${preferences.translationEnabled ? "on" : "off"}`,
             `sessions: ${startedRoles.join(", ")}`
         ].join("\n");
     }

package/dist/backend/services/app-settings-service.js

@@ -2,7 +2,7 @@ import path from "node:path";
 import { createHash } from "node:crypto";
 import { VCM_ROLE_NAMES } from "../../shared/constants.js";
 import { CODEX_REVIEW_GATES } from "../../shared/types/codex-review.js";
-import { createDefaultLaunchTemplate } from "../../shared/types/app-settings.js";
+import { createDefaultLaunchTemplate, DEFAULT_TRANSLATION_TARGET_LANGUAGE, TRANSLATION_TARGET_LANGUAGE_OPTIONS } from "../../shared/types/app-settings.js";
 import { CLAUDE_MODEL_OPTIONS, SESSION_EFFORT_OPTIONS } from "../../shared/types/session.js";
 import { resolveVcmDataDir } from "../vcm-data-dir.js";
 const MAX_RECENT_REPOSITORIES = 5;
@@ -244,6 +244,9 @@ function normalizePreferences(input) {
         themeMode: normalizeThemeMode(candidate.themeMode),
         flowPauseAlerts: rawFlowPauseAlerts !== false,
         permissionRequestMode: normalizePermissionRequestMode(candidate.permissionRequestMode),
+        translationEnabled: candidate.translationEnabled === true,
+        translationAutoSendEnabled: candidate.translationAutoSendEnabled === true,
+        translationTargetLanguage: normalizeTranslationTargetLanguage(candidate.translationTargetLanguage),
         launchTemplate: normalizeLaunchTemplate(candidate.launchTemplate)
     };
 }
@@ -259,6 +262,10 @@ function normalizePermissionRequestMode(input) {
     }
     return "off";
 }
+function normalizeTranslationTargetLanguage(input) {
+    const option = TRANSLATION_TARGET_LANGUAGE_OPTIONS.find((current) => current.value === input);
+    return option?.value ?? DEFAULT_TRANSLATION_TARGET_LANGUAGE;
+}
 function normalizeLaunchTemplate(input) {
     const defaults = createDefaultLaunchTemplate();
     if (!isObject(input)) {
@@ -272,8 +279,7 @@ function normalizeLaunchTemplate(input) {
     return {
         version: 1,
         roles,
-        autoOrchestration: input.autoOrchestration !== false,
-        translationEnabled: input.translationEnabled !== false
+        autoOrchestration: input.autoOrchestration !== false
     };
 }
 function normalizeRoleLaunchTemplateEntry(input, fallback) {

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);

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

@@ -33,15 +33,19 @@ export function createTranslationService(deps) {
     let cachedConfig = null;
     async function loadConfig() {
         if (cachedConfig) {
+            const preferences = await deps.appSettings.getPreferences();
+            cachedConfig = withTargetLanguagePreference(cachedConfig, preferences.translationTargetLanguage);
             return cachedConfig;
         }
         const storedConfig = await deps.appSettings.getTranslationConfig();
         if (!storedConfig) {
-            cachedConfig = { settings: DEFAULT_SETTINGS, secrets: {} };
+            const preferences = await deps.appSettings.getPreferences();
+            cachedConfig = withTargetLanguagePreference({ settings: DEFAULT_SETTINGS, secrets: {} }, preferences.translationTargetLanguage);
             return cachedConfig;
         }
         const rawSettings = storedConfig.settings ?? {};
         const apiKey = storedConfig.secrets?.apiKey ?? rawSettings.apiKey;
+        const preferences = await deps.appSettings.getPreferences();
         cachedConfig = {
             settings: normalizeSettings(rawSettings),
             secrets: {
@@ -49,11 +53,14 @@ export function createTranslationService(deps) {
                 ...(apiKey !== undefined ? { apiKey } : {})
             }
         };
+        cachedConfig = withTargetLanguagePreference(cachedConfig, preferences.translationTargetLanguage);
         return cachedConfig;
     }
     async function saveConfig(config) {
-        cachedConfig = config;
-        await deps.appSettings.updateTranslationConfig(config);
+        const preferences = await deps.appSettings.getPreferences();
+        cachedConfig = withTargetLanguagePreference(config, preferences.translationTargetLanguage);
+        await deps.appSettings.updateTranslationConfig(cachedConfig);
+        return cachedConfig;
     }
     function getState(sessionId) {
         let state = sessionStates.get(sessionId);
@@ -489,8 +496,8 @@ export function createTranslationService(deps) {
                     ...(secrets?.apiKey !== undefined ? { apiKey: secrets.apiKey } : {})
                 }
             };
-            await saveConfig(next);
-            return exposeSettings(next.settings, next.secrets);
+            const saved = await saveConfig(next);
+            return exposeSettings(saved.settings, saved.secrets);
         },
         async getPromptPreviews() {
             const { settings } = await loadConfig();
@@ -1074,6 +1081,15 @@ function normalizeSettings(input) {
         prompts: normalizePromptMap(input.prompts)
     };
 }
+function withTargetLanguagePreference(config, targetLanguage) {
+    return {
+        ...config,
+        settings: {
+            ...config.settings,
+            targetLanguage
+        }
+    };
+}
 function exposeSettings(settings, secrets) {
     return {
         ...settings,

package/dist/shared/types/app-settings.js

@@ -1,6 +1,15 @@
 import { VCM_ROLE_NAMES } from "../constants.js";
 export const THEME_MODES = ["system", "light", "dark"];
 export const PERMISSION_REQUEST_MODES = ["off", "allowAll"];
+export const DEFAULT_TRANSLATION_TARGET_LANGUAGE = "zh-CN";
+export const TRANSLATION_TARGET_LANGUAGE_OPTIONS = [
+    { value: "zh-CN", label: "Chinese" },
+    { value: "ja", label: "Japanese" },
+    { value: "ko", label: "Korean" },
+    { value: "fr", label: "French" },
+    { value: "de", label: "German" },
+    { value: "es", label: "Spanish" }
+];
 export function createDefaultLaunchTemplate() {
     const roles = {};
     for (const role of VCM_ROLE_NAMES) {
@@ -13,7 +22,6 @@ export function createDefaultLaunchTemplate() {
     return {
         version: 1,
         roles,
-        autoOrchestration: true,
-        translationEnabled: true
+        autoOrchestration: true
     };
 }