vibe-coding-master 0.0.1

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

@@ -0,0 +1,109 @@
+import { isDispatchableRole, isRoleName } from "../../shared/constants.js";
+import { VcmError } from "../errors.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);
+        return deps.artifactService.listArtifacts({
+            repoRoot: project.repoRoot,
+            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 artifactPath = artifactNameToPath(paths, request.params.artifactName);
+        return {
+            path: artifactPath,
+            content: await deps.artifactService.readArtifact({
+                repoRoot: project.repoRoot,
+                artifactPath
+            })
+        };
+    });
+    app.get("/api/tasks/:taskSlug/role-commands/:role", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const role = parseDispatchableRole(request.params.role);
+        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        return {
+            role,
+            content: await deps.artifactService.readRoleCommand({
+                repoRoot: project.repoRoot,
+                handoffDir: task.handoffDir,
+                role
+            })
+        };
+    });
+    app.put("/api/tasks/:taskSlug/role-commands/:role", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const role = parseDispatchableRole(request.params.role);
+        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        await deps.artifactService.saveRoleCommand({
+            repoRoot: project.repoRoot,
+            handoffDir: task.handoffDir,
+            role,
+            content: request.body.content
+        });
+        return { ok: true };
+    });
+    app.get("/api/tasks/:taskSlug/logs/:role", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        if (!isRoleName(request.params.role)) {
+            throw new VcmError({
+                code: "UNKNOWN_ROLE",
+                message: `Unknown role: ${request.params.role}`,
+                statusCode: 400
+            });
+        }
+        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        const paths = deps.artifactService.getHandoffPaths(project.repoRoot, task.handoffDir);
+        return {
+            role: request.params.role,
+            content: await deps.artifactService.readArtifact({
+                repoRoot: project.repoRoot,
+                artifactPath: paths.roleLogPaths[request.params.role]
+            })
+        };
+    });
+}
+function parseDispatchableRole(role) {
+    if (!isDispatchableRole(role)) {
+        throw new VcmError({
+            code: "ROLE_NOT_DISPATCHABLE",
+            message: `${role} cannot receive role commands.`,
+            statusCode: 400
+        });
+    }
+    return role;
+}
+function artifactNameToPath(paths, artifactName) {
+    if (artifactName === "architecture-plan.md") {
+        return paths.architecturePlanPath;
+    }
+    if (artifactName === "implementation-log.md") {
+        return paths.implementationLogPath;
+    }
+    if (artifactName === "validation-log.md") {
+        return paths.validationLogPath;
+    }
+    if (artifactName === "review-report.md") {
+        return paths.reviewReportPath;
+    }
+    throw new VcmError({
+        code: "ARTIFACT_UNKNOWN",
+        message: `Unknown artifact: ${artifactName}`,
+        statusCode: 404
+    });
+}
+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

@@ -0,0 +1,90 @@
+import { VcmError } from "../errors.js";
+export function registerMessageRoutes(app, deps) {
+    app.get("/api/tasks/:taskSlug/messages", async (request) => {
+        const context = await getRouteContext(deps, request.params.taskSlug);
+        return deps.messageService.listMessages(context);
+    });
+    app.post("/api/tasks/:taskSlug/messages", async (request) => {
+        const context = await getRouteContext(deps, request.params.taskSlug);
+        return deps.messageService.sendMessage({
+            ...context,
+            ...request.body
+        });
+    });
+    app.post("/api/tasks/:taskSlug/messages/:messageId/stage", async (request) => {
+        const context = await getRouteContext(deps, request.params.taskSlug);
+        return deps.messageService.stageMessage({
+            ...context,
+            messageId: request.params.messageId
+        });
+    });
+    app.post("/api/tasks/:taskSlug/messages/:messageId/approve", async (request) => {
+        const context = await getRouteContext(deps, request.params.taskSlug);
+        return deps.messageService.approveMessage({
+            ...context,
+            messageId: request.params.messageId
+        });
+    });
+    app.post("/api/tasks/:taskSlug/messages/:messageId/reject", async (request) => {
+        const context = await getRouteContext(deps, request.params.taskSlug);
+        return deps.messageService.rejectMessage({
+            ...context,
+            messageId: request.params.messageId
+        });
+    });
+    app.get("/api/tasks/:taskSlug/orchestration", async (request) => {
+        const context = await getRouteContext(deps, request.params.taskSlug);
+        return deps.messageService.getOrchestrationState(context);
+    });
+    app.put("/api/tasks/:taskSlug/orchestration", async (request) => {
+        const context = await getRouteContext(deps, request.params.taskSlug);
+        if (request.body.mode && request.body.mode !== "manual" && request.body.mode !== "auto") {
+            throw new VcmError({
+                code: "ORCHESTRATION_MODE_INVALID",
+                message: `Invalid orchestration mode: ${request.body.mode}`,
+                statusCode: 400
+            });
+        }
+        return deps.messageService.updateOrchestrationState({
+            ...context,
+            mode: request.body.mode,
+            paused: request.body.paused
+        });
+    });
+    app.post("/api/tasks/:taskSlug/orchestration/pause", async (request) => {
+        const context = await getRouteContext(deps, request.params.taskSlug);
+        return deps.messageService.updateOrchestrationState({
+            ...context,
+            paused: true
+        });
+    });
+    app.post("/api/tasks/:taskSlug/orchestration/resume", async (request) => {
+        const context = await getRouteContext(deps, request.params.taskSlug);
+        return deps.messageService.updateOrchestrationState({
+            ...context,
+            paused: false
+        });
+    });
+}
+async function getRouteContext(deps, taskSlug) {
+    const project = await requireCurrentProject(deps.projectService);
+    const config = await deps.projectService.loadConfig(project.repoRoot);
+    const task = await deps.taskService.loadTask(project.repoRoot, taskSlug);
+    return {
+        repoRoot: project.repoRoot,
+        stateRoot: config.stateRoot,
+        handoffDir: task.handoffDir,
+        taskSlug
+    };
+}
+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/project-routes.js

@@ -0,0 +1,17 @@
+export function registerProjectRoutes(app, deps) {
+    app.get("/api/health", async () => ({ ok: true }));
+    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/session-routes.js

@@ -0,0 +1,64 @@
+import { isDispatchableRole, isRoleName } from "../../shared/constants.js";
+import { VcmError } from "../errors.js";
+export function registerSessionRoutes(app, deps) {
+    app.get("/api/tasks/:taskSlug/sessions", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.sessionService.listRoleSessions(project.repoRoot, request.params.taskSlug);
+    });
+    app.post("/api/tasks/:taskSlug/sessions/:role/start", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const role = parseRole(request.params.role);
+        return deps.sessionService.startRoleSession(project.repoRoot, request.params.taskSlug, role, request.body);
+    });
+    app.post("/api/tasks/:taskSlug/sessions/:role/stop", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const role = parseRole(request.params.role);
+        return deps.sessionService.stopRoleSession(project.repoRoot, request.params.taskSlug, role);
+    });
+    app.post("/api/tasks/:taskSlug/sessions/:role/restart", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const role = parseRole(request.params.role);
+        return deps.sessionService.restartRoleSession(project.repoRoot, request.params.taskSlug, role, request.body);
+    });
+    app.post("/api/tasks/:taskSlug/sessions/:role/resume", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const role = parseRole(request.params.role);
+        return deps.sessionService.resumeRoleSession(project.repoRoot, request.params.taskSlug, role, request.body);
+    });
+    app.post("/api/tasks/:taskSlug/sessions/:role/dispatch", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        if (!isDispatchableRole(request.params.role)) {
+            throw new VcmError({
+                code: "ROLE_NOT_DISPATCHABLE",
+                message: `${request.params.role} cannot receive role commands.`,
+                statusCode: 400
+            });
+        }
+        return deps.commandDispatcher.dispatchRoleCommand({
+            repoRoot: project.repoRoot,
+            taskSlug: request.params.taskSlug,
+            role: request.params.role
+        });
+    });
+}
+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/api/task-routes.js

@@ -0,0 +1,30 @@
+import { VcmError } from "../errors.js";
+export function registerTaskRoutes(app, deps) {
+    app.get("/api/tasks", async () => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.taskService.listTasks(project.repoRoot);
+    });
+    app.post("/api/tasks", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.taskService.createTask(project.repoRoot, request.body);
+    });
+    app.get("/api/tasks/:taskSlug", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+    });
+    app.get("/api/tasks/:taskSlug/status", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.statusService.getTaskStatus(project.repoRoot, request.params.taskSlug);
+    });
+}
+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/errors.js

@@ -0,0 +1,29 @@
+export class VcmError extends Error {
+    code;
+    statusCode;
+    hint;
+    constructor(input) {
+        super(input.message);
+        this.name = "VcmError";
+        this.code = input.code;
+        this.statusCode = input.statusCode ?? 400;
+        this.hint = input.hint;
+    }
+}
+export function toVcmError(error) {
+    if (error instanceof VcmError) {
+        return error;
+    }
+    if (error instanceof Error) {
+        return new VcmError({
+            code: "INTERNAL_ERROR",
+            message: error.message,
+            statusCode: 500
+        });
+    }
+    return new VcmError({
+        code: "INTERNAL_ERROR",
+        message: "Unknown error",
+        statusCode: 500
+    });
+}

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

@@ -0,0 +1,162 @@
+import * as pty from "node-pty";
+import { VcmError } from "../errors.js";
+export function createNodePtyTerminalRuntime(deps) {
+    const entries = new Map();
+    const now = deps.now ?? (() => new Date().toISOString());
+    const id = deps.id ?? (() => `session_${Date.now()}_${Math.random().toString(16).slice(2)}`);
+    const emit = (entry, event) => {
+        const terminalEvent = {
+            id: `evt_${Date.now()}_${Math.random().toString(16).slice(2)}`,
+            timestamp: now(),
+            ...event
+        };
+        for (const listener of entry.listeners) {
+            listener(terminalEvent);
+        }
+    };
+    const create = async (input, sessionId = id()) => {
+        await deps.fs.ensureDir(input.logPath.replace(/[/\\][^/\\]+$/, ""));
+        const child = pty.spawn(input.command, input.args, {
+            cwd: input.cwd,
+            env: buildPtyEnvironment(process.env, input.env),
+            cols: input.cols ?? 100,
+            rows: input.rows ?? 28,
+            name: "xterm-256color"
+        });
+        const session = {
+            id: sessionId,
+            taskSlug: input.taskSlug,
+            role: input.role,
+            status: "running",
+            pid: child.pid,
+            startedAt: now(),
+            exitCode: null
+        };
+        const entry = {
+            input,
+            session,
+            process: child,
+            listeners: new Set()
+        };
+        entries.set(session.id, entry);
+        child.onData((data) => {
+            entry.session.lastOutputAt = now();
+            void deps.fs.appendText(input.logPath, data);
+            emit(entry, {
+                sessionId: session.id,
+                taskSlug: input.taskSlug,
+                role: input.role,
+                type: "output",
+                data
+            });
+        });
+        child.onExit(({ exitCode }) => {
+            entry.session.status = exitCode === 0 ? "exited" : "crashed";
+            entry.session.exitCode = exitCode;
+            emit(entry, {
+                sessionId: session.id,
+                taskSlug: input.taskSlug,
+                role: input.role,
+                type: "exit",
+                exitCode
+            });
+        });
+        return { ...session };
+    };
+    return {
+        createSession(input) {
+            return create(input);
+        },
+        getSession(sessionId) {
+            const entry = entries.get(sessionId);
+            return entry ? { ...entry.session } : undefined;
+        },
+        getSessionByRole(taskSlug, role) {
+            for (const entry of entries.values()) {
+                if (entry.session.taskSlug === taskSlug && entry.session.role === role) {
+                    return { ...entry.session };
+                }
+            }
+            return undefined;
+        },
+        listSessions(taskSlug) {
+            return [...entries.values()]
+                .filter((entry) => !taskSlug || entry.session.taskSlug === taskSlug)
+                .map((entry) => ({ ...entry.session }));
+        },
+        write(sessionId, data) {
+            const entry = getEntry(entries, sessionId);
+            entry.process.write(data);
+            emit(entry, {
+                sessionId,
+                taskSlug: entry.session.taskSlug,
+                role: entry.session.role,
+                type: "input",
+                data
+            });
+        },
+        resize(sessionId, cols, rows) {
+            const entry = getEntry(entries, sessionId);
+            entry.process.resize(cols, rows);
+        },
+        async stop(sessionId) {
+            const entry = getEntry(entries, sessionId);
+            entry.session.status = "exited";
+            entry.process.kill();
+        },
+        async restart(sessionId) {
+            const entry = getEntry(entries, sessionId);
+            entry.process.kill();
+            return create(entry.input, sessionId);
+        },
+        subscribe(sessionId, listener) {
+            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
+                });
+            })
+                .catch(() => {
+                // The log file may not exist yet for a brand-new session.
+            });
+            return () => {
+                entry.listeners.delete(listener);
+            };
+        }
+    };
+}
+export function buildPtyEnvironment(baseEnv, inputEnv = {}) {
+    const env = {
+        ...baseEnv,
+        ...inputEnv,
+        TERM: inputEnv.TERM ?? "xterm-256color",
+        COLORTERM: inputEnv.COLORTERM ?? baseEnv.COLORTERM ?? "truecolor",
+        FORCE_COLOR: inputEnv.FORCE_COLOR ?? baseEnv.FORCE_COLOR ?? "3",
+        CLICOLOR: inputEnv.CLICOLOR ?? baseEnv.CLICOLOR ?? "1",
+        TERM_PROGRAM: inputEnv.TERM_PROGRAM ?? "VibeCodingMaster"
+    };
+    delete env.NO_COLOR;
+    return env;
+}
+function getEntry(entries, sessionId) {
+    const entry = entries.get(sessionId);
+    if (!entry) {
+        throw new VcmError({
+            code: "SESSION_MISSING",
+            message: `Terminal session does not exist: ${sessionId}`,
+            statusCode: 404
+        });
+    }
+    return entry;
+}

package/dist/backend/runtime/session-registry.js

@@ -0,0 +1,36 @@
+export function createSessionRegistry() {
+    const sessions = new Map();
+    return {
+        upsert(session) {
+            sessions.set(session.id, session);
+        },
+        get(sessionId) {
+            const session = sessions.get(sessionId);
+            return session ? { ...session } : undefined;
+        },
+        getByRole(taskSlug, role) {
+            const session = [...sessions.values()].find((candidate) => (candidate.taskSlug === taskSlug && candidate.role === role));
+            return session ? { ...session } : undefined;
+        },
+        list(taskSlug) {
+            return [...sessions.values()]
+                .filter((session) => !taskSlug || session.taskSlug === taskSlug)
+                .map((session) => ({ ...session }));
+        },
+        updateStatus(sessionId, status, patch = {}) {
+            const current = sessions.get(sessionId);
+            if (!current) {
+                return;
+            }
+            sessions.set(sessionId, {
+                ...current,
+                ...patch,
+                status,
+                updatedAt: patch.updatedAt ?? new Date().toISOString()
+            });
+        },
+        remove(sessionId) {
+            sessions.delete(sessionId);
+        }
+    };
+}

package/dist/backend/runtime/terminal-runtime.js

@@ -0,0 +1 @@
+export {};