vibe-coding-master 0.4.41 → 0.4.42

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

@@ -17,6 +17,17 @@ export function registerTranslationRoutes(app, deps) {
         const project = await requireCurrentProject(deps.projectService);
         return deps.translationService.pollSessionEvents(request.params.sessionId, Number(request.query.after ?? "1"), request.query.limit === undefined ? undefined : Number(request.query.limit), { repoRoot: project.repoRoot });
     });
+    app.get("/api/tasks/:taskSlug/translation/feed", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        return deps.translationService.pollTaskFeed({
+            repoRoot: project.repoRoot,
+            taskRepoRoot: getTaskRuntimeRepoRoot(task),
+            taskSlug: request.params.taskSlug,
+            after: Number(request.query.after ?? "1"),
+            limit: request.query.limit === undefined ? undefined : Number(request.query.limit)
+        });
+    });
     app.post("/api/tasks/:taskSlug/sessions/:role/translation/input", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const role = parseRole(request.params.role);

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

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { isVcmRoleName } from "../../shared/constants.js";
 import { TRANSLATION_ENTRY_RETENTION_LIMIT } from "../../shared/types/translation.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
@@ -11,12 +12,14 @@ const TRANSLATION_PROVIDER = "claude-code";
 const TRANSLATION_MODEL = "translator";
 const OUTPUT_TRANSLATION_BATCH_DELAY_MS = 10000;
 const TRANSCRIPT_REPLAY_GRACE_MS = 5000;
+const TRANSLATION_TASK_FEED_RETENTION_LIMIT = 2000;
 export function createTranslationService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     const id = deps.id ?? (() => `tr_${Date.now()}_${Math.random().toString(16).slice(2)}`);
     const outputBatchDelayMs = Math.max(0, deps.outputBatchDelayMs ?? OUTPUT_TRANSLATION_BATCH_DELAY_MS);
     const queues = createTranslationQueueRegistry();
     const sessionStates = new Map();
+    const taskFeeds = new Map();
     async function loadConfig() {
         const preferences = await deps.appSettings.getPreferences();
         return {
@@ -79,9 +82,49 @@ export function createTranslationService(deps) {
             createdAt: now()
         };
         state.events.push(event);
+        appendTaskFeedEvent(sessionId, state, event);
         void persistEvents(state);
         return event;
     }
+    function appendTaskFeedEvent(sessionId, state, event) {
+        if (!state.repoRoot || !state.taskSlug || !state.role) {
+            return;
+        }
+        const feed = getTaskFeed(state.repoRoot, state.taskSlug);
+        const sessionEventKey = getTaskFeedSessionEventKey(sessionId, event);
+        if (feed.seenSessionEvents.has(sessionEventKey)) {
+            return;
+        }
+        feed.seenSessionEvents.add(sessionEventKey);
+        feed.events.push({
+            seq: feed.nextSeq++,
+            sessionId,
+            role: state.role,
+            event
+        });
+        if (feed.events.length > TRANSLATION_TASK_FEED_RETENTION_LIMIT) {
+            feed.events = feed.events.slice(-TRANSLATION_TASK_FEED_RETENTION_LIMIT);
+        }
+    }
+    function syncTaskFeedFromSessionState(sessionId, state) {
+        for (const event of state.events) {
+            appendTaskFeedEvent(sessionId, state, event);
+        }
+    }
+    function getTaskFeed(repoRoot, taskSlug) {
+        const key = getTaskFeedKey(repoRoot, taskSlug);
+        const current = taskFeeds.get(key);
+        if (current) {
+            return current;
+        }
+        const created = {
+            events: [],
+            nextSeq: 1,
+            seenSessionEvents: new Set()
+        };
+        taskFeeds.set(key, created);
+        return created;
+    }
     async function prepareCache(input) {
         const state = getState(input.sessionId);
         state.repoRoot = input.repoRoot;
@@ -99,6 +142,7 @@ export function createTranslationService(deps) {
             state.cacheLoaded = true;
             pruneTranslationEntries(input.sessionId);
         }
+        syncTaskFeedFromSessionState(input.sessionId, state);
         await deps.fs.ensureDir(path.dirname(cachePath));
         return state;
     }
@@ -629,6 +673,43 @@ export function createTranslationService(deps) {
                 events
             };
         },
+        async pollTaskFeed(input) {
+            const cursor = Number.isFinite(input.after) ? Math.max(1, Math.floor(input.after)) : 1;
+            const maxEvents = Math.min(Math.max(1, Math.floor(input.limit ?? 500)), 1000);
+            const roleSessions = await deps.sessionService.listRoleSessions(input.repoRoot, input.taskSlug);
+            const feedSessions = [];
+            for (const roleSession of roleSessions) {
+                if (!isVcmRoleName(roleSession.role)) {
+                    continue;
+                }
+                const state = await prepareCache({
+                    repoRoot: input.taskRepoRoot,
+                    baseRepoRoot: input.repoRoot,
+                    taskSlug: input.taskSlug,
+                    role: roleSession.role,
+                    sessionId: roleSession.id
+                });
+                if (roleSession.status === "running") {
+                    startTranscriptTail(roleSession);
+                }
+                feedSessions.push({
+                    sessionId: roleSession.id,
+                    role: roleSession.role,
+                    status: state.status
+                });
+            }
+            const feed = getTaskFeed(input.taskRepoRoot, input.taskSlug);
+            const events = feed.events
+                .filter((event) => event.seq >= cursor)
+                .slice(0, maxEvents);
+            const nextCursor = events.length > 0 ? (events.at(-1)?.seq ?? cursor) + 1 : cursor;
+            return {
+                taskSlug: input.taskSlug,
+                nextCursor,
+                sessions: feedSessions,
+                events
+            };
+        },
         async recordConversationBoundary(input) {
             const config = await loadConfig();
             const state = await prepareCache({
@@ -1060,6 +1141,12 @@ function getTranscriptSessionKey(roleSession) {
         roleSession.transcriptPath
     ].join("\n");
 }
+function getTaskFeedKey(repoRoot, taskSlug) {
+    return `${repoRoot}\n${taskSlug}`;
+}
+function getTaskFeedSessionEventKey(sessionId, event) {
+    return `${sessionId}:${event.seq}`;
+}
 function formatStructuredTranscriptEvent(event) {
     if (event.kind === "question") {
         return event.question.questions.map((question, index) => {