vibe-coding-master 0.0.1

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

@@ -0,0 +1,221 @@
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { ROLE_NAMES, isDispatchableRole } from "../../shared/constants.js";
+import { VcmError } from "../errors.js";
+import { resolveRepoPath } from "../adapters/filesystem.js";
+import { renderRoleMessagingContext } from "../templates/role-messaging-context.js";
+export function createSessionService(deps) {
+    const now = deps.now ?? (() => new Date().toISOString());
+    async function launchRoleSession(repoRoot, taskSlug, role, input, launchMode) {
+        const live = deps.registry.getByRole(taskSlug, role);
+        if (live && live.status === "running") {
+            return live;
+        }
+        const config = await deps.projectService.loadConfig(repoRoot);
+        const task = await deps.taskService.loadTask(repoRoot, taskSlug);
+        const paths = deps.artifactService.getHandoffPaths(repoRoot, task.handoffDir);
+        const persisted = await loadPersistedRoleRecord(deps.fs, repoRoot, config.stateRoot, taskSlug, role);
+        const permissionMode = input.permissionMode ?? persisted?.permissionMode ?? "default";
+        const claudeSessionId = launchMode === "resume"
+            ? persisted?.claudeSessionId
+            : randomUUID();
+        if (!claudeSessionId) {
+            throw new VcmError({
+                code: "CLAUDE_SESSION_MISSING",
+                message: `${role} does not have a Claude session id to resume.`,
+                statusCode: 409,
+                hint: "Start the role once before using Resume."
+            });
+        }
+        const startCommand = deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, claudeSessionId, launchMode === "resume");
+        const runtimeSession = await deps.runtime.createSession({
+            taskSlug,
+            role,
+            command: startCommand.command,
+            args: startCommand.args,
+            cwd: repoRoot,
+            env: {
+                VCM_API_URL: deps.apiUrl,
+                VCM_CTL_COMMAND: deps.vcmctlCommand,
+                VCM_TASK_SLUG: taskSlug,
+                VCM_ROLE: role
+            },
+            cols: input.cols,
+            rows: input.rows,
+            logPath: resolveRepoPath(repoRoot, paths.roleLogPaths[role])
+        });
+        const timestamp = now();
+        const record = {
+            id: runtimeSession.id,
+            claudeSessionId,
+            taskSlug,
+            role,
+            status: runtimeSession.status,
+            command: startCommand.display,
+            permissionMode,
+            cwd: repoRoot,
+            terminalBackend: "node-pty",
+            pid: runtimeSession.pid,
+            logPath: paths.roleLogPaths[role],
+            roleCommandPath: isDispatchableRole(role)
+                ? paths.roleCommandPaths[role]
+                : undefined,
+            handoffArtifactPath: getHandoffArtifactPath(paths, role),
+            startedAt: runtimeSession.startedAt,
+            updatedAt: timestamp,
+            lastOutputAt: runtimeSession.lastOutputAt,
+            exitCode: runtimeSession.exitCode
+        };
+        deps.registry.upsert(record);
+        await persistTaskSession(deps.fs, repoRoot, config.stateRoot, record);
+        await deps.taskService.updateTaskStatus(repoRoot, taskSlug, "running");
+        deps.runtime.write(runtimeSession.id, `${renderRoleMessagingContext(task, paths, role, deps.vcmctlCommand)}\r`);
+        return record;
+    }
+    return {
+        startRoleSession(repoRoot, taskSlug, role, input = {}) {
+            return launchRoleSession(repoRoot, taskSlug, role, input, "fresh");
+        },
+        resumeRoleSession(repoRoot, taskSlug, role, input = {}) {
+            return launchRoleSession(repoRoot, taskSlug, role, input, "resume");
+        },
+        async stopRoleSession(repoRoot, taskSlug, role) {
+            const existing = await this.getRoleSession(repoRoot, taskSlug, role);
+            if (!existing) {
+                throw new VcmError({
+                    code: "SESSION_MISSING",
+                    message: `${role} session has not been started.`,
+                    statusCode: 404
+                });
+            }
+            if (deps.runtime.getSession(existing.id)) {
+                await deps.runtime.stop(existing.id);
+            }
+            const updated = {
+                ...existing,
+                status: "exited",
+                updatedAt: now()
+            };
+            deps.registry.upsert(updated);
+            const config = await deps.projectService.loadConfig(repoRoot);
+            await persistTaskSession(deps.fs, repoRoot, config.stateRoot, updated);
+            return updated;
+        },
+        async restartRoleSession(repoRoot, taskSlug, role, input = {}) {
+            const existing = await this.getRoleSession(repoRoot, taskSlug, role);
+            if (!existing) {
+                return launchRoleSession(repoRoot, taskSlug, role, input, "fresh");
+            }
+            if (deps.runtime.getSession(existing.id)) {
+                await deps.runtime.stop(existing.id);
+            }
+            deps.registry.remove(existing.id);
+            return existing.claudeSessionId
+                ? launchRoleSession(repoRoot, taskSlug, role, input, "resume")
+                : launchRoleSession(repoRoot, taskSlug, role, input, "fresh");
+        },
+        async getRoleSession(repoRoot, taskSlug, role) {
+            const config = await deps.projectService.loadConfig(repoRoot);
+            const record = deps.registry.getByRole(taskSlug, role)
+                ?? await loadPersistedRoleRecord(deps.fs, repoRoot, config.stateRoot, taskSlug, role);
+            if (!record) {
+                return undefined;
+            }
+            const runtimeSession = deps.runtime.getSession(record.id);
+            if (!runtimeSession) {
+                return {
+                    ...record,
+                    status: getRecoverableStatus(record),
+                    pid: undefined,
+                    exitCode: record.exitCode ?? null
+                };
+            }
+            return {
+                ...record,
+                status: runtimeSession.status,
+                pid: runtimeSession.pid,
+                lastOutputAt: runtimeSession.lastOutputAt,
+                exitCode: runtimeSession.exitCode
+            };
+        },
+        async listRoleSessions(repoRoot, taskSlug) {
+            const sessions = [];
+            for (const role of ROLE_NAMES) {
+                const session = await this.getRoleSession(repoRoot, taskSlug, role);
+                if (session) {
+                    sessions.push(session);
+                }
+            }
+            return sessions;
+        }
+    };
+}
+function getRecoverableStatus(record) {
+    if (!record.claudeSessionId) {
+        return record.status === "running" ? "missing" : record.status;
+    }
+    if (record.status === "done") {
+        return "done";
+    }
+    return "resumable";
+}
+function getHandoffArtifactPath(paths, role) {
+    if (role === "architect") {
+        return paths.architecturePlanPath;
+    }
+    if (role === "coder") {
+        return paths.implementationLogPath;
+    }
+    if (role === "reviewer") {
+        return paths.reviewReportPath;
+    }
+    return undefined;
+}
+async function loadPersistedRoleRecord(fs, repoRoot, stateRoot, taskSlug, role) {
+    const sessionPath = getTaskSessionPath(repoRoot, stateRoot, taskSlug);
+    if (!(await fs.pathExists(sessionPath))) {
+        return undefined;
+    }
+    const current = await fs.readJson(sessionPath);
+    return current.roles[role]?.record;
+}
+async function persistTaskSession(fs, repoRoot, stateRoot, session) {
+    const sessionPath = getTaskSessionPath(repoRoot, stateRoot, session.taskSlug);
+    const empty = createEmptyTaskSessionRecord(session.taskSlug, session.updatedAt);
+    const current = await fs.pathExists(sessionPath)
+        ? await fs.readJson(sessionPath)
+        : empty;
+    const record = {
+        ...session,
+        updatedAt: session.updatedAt
+    };
+    await fs.writeJsonAtomic(sessionPath, {
+        ...current,
+        updatedAt: session.updatedAt,
+        roles: {
+            ...current.roles,
+            [session.role]: {
+                id: session.id,
+                claudeSessionId: session.claudeSessionId,
+                status: session.status,
+                record
+            }
+        }
+    });
+}
+function createEmptyTaskSessionRecord(taskSlug, updatedAt) {
+    return {
+        version: 1,
+        taskSlug,
+        updatedAt,
+        roles: {
+            "project-manager": { id: null, status: "not_started" },
+            architect: { id: null, status: "not_started" },
+            coder: { id: null, status: "not_started" },
+            reviewer: { id: null, status: "not_started" }
+        }
+    };
+}
+function getTaskSessionPath(repoRoot, stateRoot, taskSlug) {
+    return path.join(repoRoot, stateRoot, "sessions", `${taskSlug}.json`);
+}

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

@@ -0,0 +1,21 @@
+export function createStatusService(deps) {
+    return {
+        async getTaskStatus(repoRoot, taskSlug) {
+            const task = await deps.taskService.loadTask(repoRoot, taskSlug);
+            const artifacts = await deps.artifactService.listArtifacts({
+                repoRoot,
+                handoffDir: task.handoffDir
+            });
+            const sessions = await deps.sessionService.listRoleSessions(repoRoot, taskSlug);
+            const warnings = artifacts.checks
+                .filter((check) => check.status !== "ok")
+                .map((check) => `${check.path}: ${check.status}`);
+            return {
+                task,
+                sessions,
+                artifacts,
+                warnings
+            };
+        }
+    };
+}

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

@@ -0,0 +1,88 @@
+import path from "node:path";
+import { assertValidTaskSlug } from "../../shared/validation/slug-check.js";
+import { VcmError } from "../errors.js";
+export function createTaskService(deps) {
+    const now = deps.now ?? (() => new Date().toISOString());
+    return {
+        async createTask(repoRoot, input) {
+            assertValidTaskSlug(input.taskSlug);
+            const config = await deps.projectService.loadConfig(repoRoot);
+            const taskPath = getTaskPath(repoRoot, config.stateRoot, input.taskSlug);
+            if (await deps.fs.pathExists(taskPath)) {
+                throw new VcmError({
+                    code: "TASK_EXISTS",
+                    message: `Task already exists: ${input.taskSlug}`,
+                    statusCode: 409
+                });
+            }
+            const timestamp = now();
+            const task = {
+                version: 1,
+                taskSlug: input.taskSlug,
+                title: input.title,
+                createdAt: timestamp,
+                updatedAt: timestamp,
+                repoRoot,
+                branch: await deps.git.getCurrentBranch(repoRoot),
+                handoffDir: path.posix.join(config.handoffRoot, input.taskSlug),
+                status: "created",
+                specPath: input.specPath
+            };
+            await deps.artifactService.ensureHandoffStructure({
+                repoRoot,
+                taskSlug: input.taskSlug,
+                handoffDir: task.handoffDir
+            });
+            await deps.artifactService.createArtifactTemplates({
+                repoRoot,
+                taskSlug: input.taskSlug,
+                handoffDir: task.handoffDir
+            });
+            await this.saveTask(repoRoot, task);
+            return task;
+        },
+        async listTasks(repoRoot) {
+            const config = await deps.projectService.loadConfig(repoRoot);
+            const tasksDir = path.join(repoRoot, config.stateRoot, "tasks");
+            if (!(await deps.fs.pathExists(tasksDir))) {
+                return [];
+            }
+            const entries = await deps.fs.readDir(tasksDir);
+            const tasks = [];
+            for (const entry of entries.filter((candidate) => candidate.endsWith(".json"))) {
+                tasks.push(await deps.fs.readJson(path.join(tasksDir, entry)));
+            }
+            return tasks.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+        },
+        async loadTask(repoRoot, taskSlug) {
+            assertValidTaskSlug(taskSlug);
+            const config = await deps.projectService.loadConfig(repoRoot);
+            const taskPath = getTaskPath(repoRoot, config.stateRoot, taskSlug);
+            if (!(await deps.fs.pathExists(taskPath))) {
+                throw new VcmError({
+                    code: "TASK_MISSING",
+                    message: `Task does not exist: ${taskSlug}`,
+                    statusCode: 404
+                });
+            }
+            return deps.fs.readJson(taskPath);
+        },
+        async saveTask(repoRoot, task) {
+            const config = await deps.projectService.loadConfig(repoRoot);
+            await deps.fs.writeJsonAtomic(getTaskPath(repoRoot, config.stateRoot, task.taskSlug), task);
+        },
+        async updateTaskStatus(repoRoot, taskSlug, status) {
+            const task = await this.loadTask(repoRoot, taskSlug);
+            const updated = {
+                ...task,
+                status,
+                updatedAt: now()
+            };
+            await this.saveTask(repoRoot, updated);
+            return updated;
+        }
+    };
+}
+function getTaskPath(repoRoot, stateRoot, taskSlug) {
+    return path.join(repoRoot, stateRoot, "tasks", `${taskSlug}.json`);
+}

package/dist/backend/templates/handoff.js

@@ -0,0 +1,76 @@
+export function renderArchitecturePlanTemplate(taskSlug) {
+    return `# Architecture Plan: ${taskSlug}
+
+## Context
+
+TBD
+
+## Architecture Decision
+
+TBD
+
+## Implementation Plan
+
+TBD
+
+## Risks
+
+TBD
+
+## Stop Conditions
+
+TBD
+`;
+}
+export function renderImplementationLogTemplate(taskSlug) {
+    return `# Implementation Log: ${taskSlug}
+
+## Summary
+
+TBD
+
+## Files Changed
+
+TBD
+
+## Validation
+
+TBD
+
+## Deviations From Architecture Plan
+
+TBD
+
+## Follow-ups
+
+TBD
+`;
+}
+export function renderValidationLogTemplate(taskSlug) {
+    return `# Validation Log: ${taskSlug}
+
+## Validation
+
+Not run yet.
+`;
+}
+export function renderReviewReportTemplate(taskSlug) {
+    return `# Review Report: ${taskSlug}
+
+## Summary
+
+TBD
+
+## Findings
+
+TBD
+
+## Validation
+
+TBD
+
+## Decision
+
+TBD
+`;
+}

package/dist/backend/templates/message-envelope.js

@@ -0,0 +1,27 @@
+export function renderMessageEnvelope(message) {
+    const artifactRefs = message.artifactRefs.length > 0
+        ? message.artifactRefs.map((artifact) => `- ${artifact}`).join("\n")
+        : "- none";
+    return `
+[VCM MESSAGE]
+id: ${message.id}
+task: ${message.taskSlug}
+from: ${message.fromRole}
+to: ${message.toRole}
+type: ${message.type}
+
+${message.body}
+
+Artifact refs:
+${artifactRefs}
+
+Instructions:
+- Read the message and execute only within this VCM task.
+- Reply to project-manager with vcmctl reply when complete, blocked, or unclear.
+[/VCM MESSAGE]
+`;
+}
+export function renderManualStagePrompt(message) {
+    const target = message.bodyPath ?? `VCM message ${message.id}`;
+    return `Read and handle VCM message ${message.id} at ${target}`;
+}

package/dist/backend/templates/role-command.js

@@ -0,0 +1,21 @@
+export function renderRoleCommandTemplate(taskSlug, role) {
+    return `# ${role} command for ${taskSlug}
+
+## Objective
+
+TBD
+
+## Inputs
+
+- Task slug: ${taskSlug}
+
+## Expected Output Artifact
+
+TBD
+
+## Stop Conditions
+
+- Stop and ask the user if the task scope is unclear.
+- Stop before making high-risk changes without explicit user approval.
+`;
+}

package/dist/backend/templates/role-messaging-context.js

@@ -0,0 +1,44 @@
+export function renderRoleMessagingContext(task, paths, role, vcmctlCommand = "vcmctl") {
+    if (role === "project-manager") {
+        return `VCM messaging context
+
+Task slug: ${task.taskSlug}
+Canonical handoff directory: ${task.handoffDir}
+
+You are the orchestration hub for this task.
+
+Use VCM messaging instead of asking the user to copy commands:
+- Send work to architect/coder/reviewer with: ${vcmctlCommand} send --to <role> --type task --body-file <file>
+- Ask a question with: ${vcmctlCommand} send --to <role> --type question --body "..."
+- Check pending messages with: ${vcmctlCommand} inbox
+
+Canonical role command files still exist for durable handoff:
+- architect: ${paths.roleCommandPaths.architect}
+- coder: ${paths.roleCommandPaths.coder}
+- reviewer: ${paths.roleCommandPaths.reviewer}
+
+Hard rules:
+- Use only ${task.handoffDir} for this task.
+- Do not create or write .ai/handoffs/<other-task>/ for this task.
+- Non-trivial blockers or high-risk decisions must be escalated to the user.
+- In manual orchestration mode, sent messages wait for user approval before the target role executes them.
+`;
+    }
+    return `VCM messaging context
+
+Task slug: ${task.taskSlug}
+Canonical handoff directory: ${task.handoffDir}
+Current role: ${role}
+
+When complete, blocked, or unclear, reply to project-manager through VCM:
+- ${vcmctlCommand} reply --type result --body-file <file>
+- ${vcmctlCommand} reply --type blocked --body "..."
+- ${vcmctlCommand} reply --type question --body "..."
+
+Hard rules:
+- Only reply to project-manager. Do not message other roles directly.
+- Use only ${task.handoffDir} for this task.
+- Do not create or write .ai/handoffs/<other-task>/ for this task.
+- In manual orchestration mode, your replies wait for user approval before project-manager receives them.
+`;
+}

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

@@ -0,0 +1,60 @@
+import { WebSocketServer } from "ws";
+import { toVcmError } from "../errors.js";
+export function registerTerminalWs(app, deps) {
+    const wss = new WebSocketServer({ noServer: true });
+    app.server.on("upgrade", (request, socket, head) => {
+        const url = new URL(request.url ?? "/", "http://localhost");
+        const match = /^\/ws\/terminal\/([^/]+)$/.exec(url.pathname);
+        if (!match) {
+            return;
+        }
+        wss.handleUpgrade(request, socket, head, (ws) => {
+            bindTerminalSocket(ws, decodeURIComponent(match[1] ?? ""), deps.runtime);
+        });
+    });
+}
+function bindTerminalSocket(ws, sessionId, runtime) {
+    let unsubscribe = () => { };
+    try {
+        unsubscribe = runtime.subscribe(sessionId, (event) => {
+            if (event.type === "output") {
+                send(ws, { type: "output", data: event.data ?? "" });
+            }
+            else if (event.type === "exit") {
+                send(ws, { type: "exit", exitCode: event.exitCode ?? null });
+            }
+            else if (event.type === "status" && event.status) {
+                send(ws, { type: "status", status: event.status });
+            }
+        });
+    }
+    catch (error) {
+        const vcmError = toVcmError(error);
+        send(ws, { type: "error", message: vcmError.message });
+        ws.close();
+        return;
+    }
+    ws.on("message", (raw) => {
+        try {
+            const message = JSON.parse(raw.toString());
+            if (message.type === "input") {
+                runtime.write(sessionId, message.data);
+            }
+            else if (message.type === "resize") {
+                runtime.resize(sessionId, message.cols, message.rows);
+            }
+        }
+        catch (error) {
+            const vcmError = toVcmError(error);
+            send(ws, { type: "error", message: vcmError.message });
+        }
+    });
+    ws.on("close", () => {
+        unsubscribe();
+    });
+}
+function send(ws, message) {
+    if (ws.readyState === ws.OPEN) {
+        ws.send(JSON.stringify(message));
+    }
+}