vibe-coding-master 0.0.5 → 0.0.7

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,6 +46,10 @@ 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,
@@ -58,7 +70,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 +108,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 +143,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) {