vibe-coding-master 0.0.6 → 0.0.8

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

@@ -1,23 +1,26 @@
 import { isDispatchableRole, isRoleName } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
+import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
 export function registerArtifactRoutes(app, deps) {
     app.get("/api/tasks/:taskSlug/artifacts", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
         return deps.artifactService.listArtifacts({
-            repoRoot: project.repoRoot,
+            repoRoot: taskRepoRoot,
             handoffDir: task.handoffDir
         });
     });
     app.get("/api/tasks/:taskSlug/artifacts/:artifactName", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
-        const paths = deps.artifactService.getHandoffPaths(project.repoRoot, task.handoffDir);
+        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+        const paths = deps.artifactService.getHandoffPaths(taskRepoRoot, task.handoffDir);
         const artifactPath = artifactNameToPath(paths, request.params.artifactName);
         return {
             path: artifactPath,
             content: await deps.artifactService.readArtifact({
-                repoRoot: project.repoRoot,
+                repoRoot: taskRepoRoot,
                 artifactPath
             })
         };
@@ -26,10 +29,11 @@ export function registerArtifactRoutes(app, deps) {
         const project = await requireCurrentProject(deps.projectService);
         const role = parseDispatchableRole(request.params.role);
         const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
         return {
             role,
             content: await deps.artifactService.readRoleCommand({
-                repoRoot: project.repoRoot,
+                repoRoot: taskRepoRoot,
                 handoffDir: task.handoffDir,
                 role
             })
@@ -39,8 +43,9 @@ export function registerArtifactRoutes(app, deps) {
         const project = await requireCurrentProject(deps.projectService);
         const role = parseDispatchableRole(request.params.role);
         const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
         await deps.artifactService.saveRoleCommand({
-            repoRoot: project.repoRoot,
+            repoRoot: taskRepoRoot,
             handoffDir: task.handoffDir,
             role,
             content: request.body.content
@@ -57,11 +62,12 @@ export function registerArtifactRoutes(app, deps) {
             });
         }
         const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
-        const paths = deps.artifactService.getHandoffPaths(project.repoRoot, task.handoffDir);
+        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+        const paths = deps.artifactService.getHandoffPaths(taskRepoRoot, task.handoffDir);
         return {
             role: request.params.role,
             content: await deps.artifactService.readArtifact({
-                repoRoot: project.repoRoot,
+                repoRoot: taskRepoRoot,
                 artifactPath: paths.roleLogPaths[request.params.role]
             })
         };
@@ -90,6 +96,9 @@ function artifactNameToPath(paths, artifactName) {
     if (artifactName === "review-report.md") {
         return paths.reviewReportPath;
     }
+    if (artifactName === "docs-sync-report.md") {
+        return paths.docsSyncReportPath;
+    }
     throw new VcmError({
         code: "ARTIFACT_UNKNOWN",
         message: `Unknown artifact: ${artifactName}`,

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

@@ -0,0 +1,22 @@
+import { VcmError } from "../errors.js";
+export function registerHarnessRoutes(app, deps) {
+    app.get("/api/projects/harness", async () => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.harnessService.getHarnessStatus(project.repoRoot);
+    });
+    app.post("/api/projects/harness/apply", async () => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.harnessService.applyHarness(project.repoRoot);
+    });
+}
+async function requireCurrentProject(projectService) {
+    const project = await projectService.getCurrentProject();
+    if (!project) {
+        throw new VcmError({
+            code: "PROJECT_NOT_CONNECTED",
+            message: "Connect a repository first.",
+            statusCode: 409
+        });
+    }
+    return project;
+}

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

@@ -1,4 +1,5 @@
 import { VcmError } from "../errors.js";
+import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
 export function registerMessageRoutes(app, deps) {
     app.get("/api/tasks/:taskSlug/messages", async (request) => {
         const context = await getRouteContext(deps, request.params.taskSlug);
@@ -72,6 +73,7 @@ async function getRouteContext(deps, taskSlug) {
     const task = await deps.taskService.loadTask(project.repoRoot, taskSlug);
     return {
         repoRoot: project.repoRoot,
+        taskRepoRoot: getTaskRuntimeRepoRoot(task),
         stateRoot: config.stateRoot,
         handoffDir: task.handoffDir,
         taskSlug

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

@@ -1,17 +1,12 @@
 export function registerProjectRoutes(app, deps) {
     app.get("/api/health", async () => ({ ok: true }));
+    app.get("/api/projects/recent", async () => {
+        return deps.projectService.getRecentRepositoryPaths();
+    });
     app.post("/api/projects/connect", async (request) => {
         return deps.projectService.connectProject(request.body);
     });
     app.get("/api/projects/current", async () => {
         return deps.projectService.getCurrentProject();
     });
-    app.get("/api/projects/harness", async () => ({
-        checks: [
-            {
-                name: "local-gui",
-                status: "ok"
-            }
-        ]
-    }));
 }

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

@@ -16,6 +16,20 @@ export function registerTaskRoutes(app, deps) {
         const project = await requireCurrentProject(deps.projectService);
         return deps.statusService.getTaskStatus(project.repoRoot, request.params.taskSlug);
     });
+    app.post("/api/tasks/:taskSlug/cleanup", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const sessions = await deps.sessionService.listRoleSessions(project.repoRoot, request.params.taskSlug);
+        const running = sessions.filter((session) => session.status === "running");
+        if (running.length > 0) {
+            throw new VcmError({
+                code: "TASK_SESSIONS_RUNNING",
+                message: "Stop all role sessions before cleaning up the task.",
+                statusCode: 409,
+                hint: running.map((session) => session.role).join(", ")
+            });
+        }
+        return deps.taskService.cleanupTask(project.repoRoot, request.params.taskSlug, request.body ?? {});
+    });
 }
 async function requireCurrentProject(projectService) {
     const project = await projectService.getCurrentProject();

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

@@ -0,0 +1,70 @@
+import { isRoleName } from "../../shared/constants.js";
+import { VcmError } from "../errors.js";
+export function registerTranslationRoutes(app, deps) {
+    app.get("/api/translation/settings", async () => {
+        return deps.translationService.getSettings();
+    });
+    app.put("/api/translation/settings", async (request) => {
+        const { apiKey, ...settings } = request.body ?? {};
+        return deps.translationService.updateSettings(settings, apiKey !== undefined ? { apiKey } : undefined);
+    });
+    app.get("/api/translation/prompts", async () => {
+        return deps.translationService.getPromptPreviews();
+    });
+    app.post("/api/translation/test", async () => {
+        return deps.translationService.testProvider();
+    });
+    app.post("/api/tasks/:taskSlug/sessions/:role/translation/input", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const role = parseRole(request.params.role);
+        await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        return deps.translationService.translateUserInput({
+            repoRoot: project.repoRoot,
+            taskSlug: request.params.taskSlug,
+            role,
+            ...(request.body ?? { text: "" })
+        });
+    });
+    app.post("/api/tasks/:taskSlug/sessions/:role/translation/send", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const role = parseRole(request.params.role);
+        await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        await deps.translationService.sendTranslatedInput({
+            repoRoot: project.repoRoot,
+            taskSlug: request.params.taskSlug,
+            role,
+            englishText: request.body?.englishText ?? ""
+        });
+        return { ok: true };
+    });
+    app.post("/api/translation/sessions/:sessionId/clear", async (request) => {
+        await requireCurrentProject(deps.projectService);
+        deps.translationService.clearSession(request.params.sessionId);
+        return { ok: true };
+    });
+    app.post("/api/translation/sessions/:sessionId/retry/:translationId", async (request) => {
+        await requireCurrentProject(deps.projectService);
+        return deps.translationService.retryTranslation(request.params.sessionId, request.params.translationId);
+    });
+}
+function parseRole(role) {
+    if (!isRoleName(role)) {
+        throw new VcmError({
+            code: "UNKNOWN_ROLE",
+            message: `Unknown role: ${role}`,
+            statusCode: 400
+        });
+    }
+    return role;
+}
+async function requireCurrentProject(projectService) {
+    const project = await projectService.getCurrentProject();
+    if (!project) {
+        throw new VcmError({
+            code: "PROJECT_NOT_CONNECTED",
+            message: "Connect a repository first.",
+            statusCode: 409
+        });
+    }
+    return project;
+}

package/dist/backend/runtime/node-pty-runtime.js

@@ -109,27 +109,29 @@ export function createNodePtyTerminalRuntime(deps) {
             entry.process.kill();
             return create(entry.input, sessionId);
         },
-        subscribe(sessionId, listener) {
+        subscribe(sessionId, listener, options = {}) {
             const entry = getEntry(entries, sessionId);
             entry.listeners.add(listener);
-            void deps.fs.readText(entry.input.logPath)
-                .then((data) => {
-                if (!data || !entry.listeners.has(listener)) {
-                    return;
-                }
-                listener({
-                    id: `evt_${Date.now()}_${Math.random().toString(16).slice(2)}`,
-                    sessionId,
-                    taskSlug: entry.session.taskSlug,
-                    role: entry.session.role,
-                    type: "output",
-                    timestamp: now(),
-                    data
+            if (options.replay !== false) {
+                void deps.fs.readText(entry.input.logPath)
+                    .then((data) => {
+                    if (!data || !entry.listeners.has(listener)) {
+                        return;
+                    }
+                    listener({
+                        id: `evt_${Date.now()}_${Math.random().toString(16).slice(2)}`,
+                        sessionId,
+                        taskSlug: entry.session.taskSlug,
+                        role: entry.session.role,
+                        type: "output",
+                        timestamp: now(),
+                        data
+                    });
+                })
+                    .catch(() => {
+                    // The log file may not exist yet for a brand-new session.
                 });
-            })
-                .catch(() => {
-                // The log file may not exist yet for a brand-new session.
-            });
+            }
             return () => {
                 entry.listeners.delete(listener);
             };

package/dist/backend/server.js

@@ -8,20 +8,28 @@ import { createClaudeAdapter } from "./adapters/claude-adapter.js";
 import { createCommandRunner } from "./adapters/command-runner.js";
 import { createCommandDispatcher } from "./services/command-dispatcher.js";
 import { createGitAdapter } from "./adapters/git-adapter.js";
+import { createAppSettingsService } from "./services/app-settings-service.js";
+import { createClaudeTranscriptService } from "./services/claude-transcript-service.js";
+import { createHarnessService } from "./services/harness-service.js";
 import { createNodeFileSystemAdapter } from "./adapters/filesystem.js";
 import { createNodePtyTerminalRuntime } from "./runtime/node-pty-runtime.js";
+import { createOpenAiCompatibleTranslationProvider } from "./adapters/translation-provider.js";
 import { createProjectService } from "./services/project-service.js";
 import { createSessionRegistry } from "./runtime/session-registry.js";
 import { createSessionService } from "./services/session-service.js";
 import { createMessageService } from "./services/message-service.js";
 import { createStatusService } from "./services/status-service.js";
 import { createTaskService } from "./services/task-service.js";
+import { createTranslationService } from "./services/translation-service.js";
 import { registerArtifactRoutes } from "./api/artifact-routes.js";
+import { registerHarnessRoutes } from "./api/harness-routes.js";
 import { registerMessageRoutes } from "./api/message-routes.js";
 import { registerProjectRoutes } from "./api/project-routes.js";
 import { registerSessionRoutes } from "./api/session-routes.js";
 import { registerTaskRoutes } from "./api/task-routes.js";
+import { registerTranslationRoutes } from "./api/translation-routes.js";
 import { registerTerminalWs } from "./ws/terminal-ws.js";
+import { registerTranslationWs } from "./ws/translation-ws.js";
 import { toVcmError } from "./errors.js";
 export async function createServer(deps, options = {}) {
     const app = Fastify({
@@ -38,10 +46,15 @@ export async function createServer(deps, options = {}) {
         });
     });
     registerProjectRoutes(app, { projectService: deps.projectService });
+    registerHarnessRoutes(app, {
+        projectService: deps.projectService,
+        harnessService: deps.harnessService
+    });
     registerTaskRoutes(app, {
         projectService: deps.projectService,
         taskService: deps.taskService,
-        statusService: deps.statusService
+        statusService: deps.statusService,
+        sessionService: deps.sessionService
     });
     registerSessionRoutes(app, {
         projectService: deps.projectService,
@@ -58,7 +71,13 @@ export async function createServer(deps, options = {}) {
         taskService: deps.taskService,
         messageService: deps.messageService
     });
+    registerTranslationRoutes(app, {
+        projectService: deps.projectService,
+        taskService: deps.taskService,
+        translationService: deps.translationService
+    });
     registerTerminalWs(app, { runtime: deps.runtime });
+    registerTranslationWs(app, { translationService: deps.translationService });
     if (options.staticDir) {
         await app.register(fastifyStatic, {
             root: options.staticDir,
@@ -90,10 +109,12 @@ export function createDefaultServerDeps(options = {}) {
     const runner = createCommandRunner();
     const git = createGitAdapter(runner);
     const claude = createClaudeAdapter(runner);
+    const appSettings = createAppSettingsService({ fs });
     const runtime = createNodePtyTerminalRuntime({ fs });
     const registry = createSessionRegistry();
     const artifactService = createArtifactService(fs);
-    const projectService = createProjectService({ fs, git, claude });
+    const harnessService = createHarnessService({ fs });
+    const projectService = createProjectService({ fs, git, claude, appSettings });
     const taskService = createTaskService({ fs, git, artifactService, projectService });
     const sessionService = createSessionService({
         fs,
@@ -123,14 +144,24 @@ export function createDefaultServerDeps(options = {}) {
         sessionService,
         taskService
     });
+    const translationService = createTranslationService({
+        runtime,
+        sessionRegistry: registry,
+        transcripts: createClaudeTranscriptService(),
+        sessionService,
+        appSettings,
+        provider: createOpenAiCompatibleTranslationProvider()
+    });
     return {
         projectService,
         taskService,
         sessionService,
         artifactService,
+        harnessService,
         commandDispatcher,
         messageService,
         statusService,
+        translationService,
         runtime
     };
 }

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

@@ -0,0 +1,128 @@
+import path from "node:path";
+import { homedir } from "node:os";
+const MAX_RECENT_REPOSITORIES = 5;
+export function createAppSettingsService(deps) {
+    const settingsPath = deps.settingsPath ?? path.join(homedir(), ".vcm", "settings.json");
+    const legacySettingsPath = deps.legacySettingsPath
+        ?? path.join(homedir(), ".vibe-coding-master", "settings.json");
+    const legacyTranslationPath = deps.legacyTranslationPath
+        ?? path.join(homedir(), ".vibe-coding-master", "translation.json");
+    let cachedSettings = null;
+    async function loadSettings() {
+        if (cachedSettings) {
+            return cachedSettings;
+        }
+        let raw = {};
+        let shouldSave = false;
+        if (await deps.fs.pathExists(settingsPath)) {
+            raw = await deps.fs.readJson(settingsPath);
+        }
+        else if (await deps.fs.pathExists(legacySettingsPath)) {
+            raw = await deps.fs.readJson(legacySettingsPath);
+            shouldSave = true;
+        }
+        else {
+            shouldSave = true;
+        }
+        if (!raw.translation && await deps.fs.pathExists(legacyTranslationPath)) {
+            raw = {
+                ...raw,
+                translation: normalizeTranslationConfig(await deps.fs.readJson(legacyTranslationPath))
+            };
+            shouldSave = true;
+        }
+        cachedSettings = normalizeSettingsFile(raw);
+        if (shouldSave) {
+            await saveSettings(cachedSettings);
+        }
+        return cachedSettings;
+    }
+    async function saveSettings(settings) {
+        cachedSettings = settings;
+        await deps.fs.writeJsonAtomic(settingsPath, settings);
+    }
+    return {
+        loadSettings,
+        async updateTranslationConfig(config) {
+            const current = await loadSettings();
+            const translation = normalizeTranslationConfig(config) ?? { settings: {}, secrets: {} };
+            await saveSettings({
+                ...current,
+                translation
+            });
+            return translation;
+        },
+        async getTranslationConfig() {
+            return (await loadSettings()).translation;
+        },
+        async getRecentRepositoryPaths() {
+            return (await loadSettings()).recentRepositoryPaths;
+        },
+        async recordRecentRepositoryPath(repoRoot) {
+            const normalizedPath = repoRoot.trim();
+            if (!normalizedPath) {
+                return (await loadSettings()).recentRepositoryPaths;
+            }
+            const current = await loadSettings();
+            const recentRepositoryPaths = normalizeRecentRepositoryPaths([
+                normalizedPath,
+                ...current.recentRepositoryPaths
+            ]);
+            await saveSettings({
+                ...current,
+                recentRepositoryPaths
+            });
+            return recentRepositoryPaths;
+        },
+        getSettingsPath() {
+            return settingsPath;
+        }
+    };
+}
+function normalizeSettingsFile(input) {
+    return {
+        version: 1,
+        translation: normalizeTranslationConfig(input.translation),
+        recentRepositoryPaths: normalizeRecentRepositoryPaths(input.recentRepositoryPaths)
+    };
+}
+function normalizeTranslationConfig(input) {
+    if (!input || typeof input !== "object") {
+        return undefined;
+    }
+    const candidate = input;
+    const rawSettings = isObject(candidate.settings) ? candidate.settings : {};
+    const rawSecrets = isObject(candidate.secrets) ? candidate.secrets : {};
+    const { apiKey: settingsApiKey, ...settings } = rawSettings;
+    const apiKey = rawSecrets.apiKey ?? settingsApiKey;
+    return {
+        settings,
+        secrets: {
+            ...rawSecrets,
+            ...(apiKey !== undefined ? { apiKey } : {})
+        }
+    };
+}
+function normalizeRecentRepositoryPaths(input) {
+    const paths = Array.isArray(input) ? input : [];
+    const seen = new Set();
+    const normalized = [];
+    for (const value of paths) {
+        if (typeof value !== "string") {
+            continue;
+        }
+        const repoPath = value.trim();
+        if (!repoPath || seen.has(repoPath)) {
+            continue;
+        }
+        seen.add(repoPath);
+        normalized.push(repoPath);
+        if (normalized.length >= MAX_RECENT_REPOSITORIES) {
+            break;
+        }
+    }
+    return normalized;
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

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

@@ -3,13 +3,14 @@ import { DISPATCHABLE_ROLES, ROLE_NAMES } from "../../shared/constants.js";
 import { checkMarkdownArtifact } from "../../shared/validation/artifact-check.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
-import { renderArchitecturePlanTemplate, renderImplementationLogTemplate, renderReviewReportTemplate, renderValidationLogTemplate } from "../templates/handoff.js";
+import { renderArchitecturePlanTemplate, renderDocsSyncReportTemplate, renderImplementationLogTemplate, renderReviewReportTemplate, renderValidationLogTemplate } from "../templates/handoff.js";
 import { renderRoleCommandTemplate } from "../templates/role-command.js";
 const ARTIFACT_PATH_KEYS = [
     ["architecture-plan", "architecturePlanPath"],
     ["implementation-log", "implementationLogPath"],
     ["validation-log", "validationLogPath"],
-    ["review-report", "reviewReportPath"]
+    ["review-report", "reviewReportPath"],
+    ["docs-sync-report", "docsSyncReportPath"]
 ];
 const ROLE_COMMAND_PLACEHOLDER_PATTERN = /(^|\n)\s*(TBD|status:\s*draft)\s*(\n|$)/i;
 export function createArtifactService(fs) {
@@ -35,7 +36,8 @@ export function createArtifactService(fs) {
                 architecturePlanPath: path.posix.join(handoffDir, "architecture-plan.md"),
                 implementationLogPath: path.posix.join(handoffDir, "implementation-log.md"),
                 validationLogPath: path.posix.join(handoffDir, "validation-log.md"),
-                reviewReportPath: path.posix.join(handoffDir, "review-report.md")
+                reviewReportPath: path.posix.join(handoffDir, "review-report.md"),
+                docsSyncReportPath: path.posix.join(handoffDir, "docs-sync-report.md")
             };
         },
         async ensureHandoffStructure(input) {
@@ -54,7 +56,8 @@ export function createArtifactService(fs) {
                 [paths.architecturePlanPath, renderArchitecturePlanTemplate(input.taskSlug)],
                 [paths.implementationLogPath, renderImplementationLogTemplate(input.taskSlug)],
                 [paths.validationLogPath, renderValidationLogTemplate(input.taskSlug)],
-                [paths.reviewReportPath, renderReviewReportTemplate(input.taskSlug)]
+                [paths.reviewReportPath, renderReviewReportTemplate(input.taskSlug)],
+                [paths.docsSyncReportPath, renderDocsSyncReportTemplate(input.taskSlug)]
             ];
             const created = [];
             for (const [artifactPath, content] of files) {