vibe-coding-master 0.4.2 → 0.4.4

package/dist/backend/adapters/git-adapter.js

@@ -81,12 +81,54 @@ export function createGitAdapter(runner) {
             }
             return result.stdout;
         },
-        async getStagedStatus(repoRoot) {
-            const result = await runGit(runner, repoRoot, ["diff", "--cached", "--name-status"]);
+        async getStatusPorcelainV1(repoRoot) {
+            const result = await runGit(runner, repoRoot, [
+                "status",
+                "--porcelain=v1",
+                "-z",
+                "--untracked-files=all"
+            ]);
             if (result.exitCode !== 0) {
                 throw new VcmError({
                     code: "GIT_ERROR",
-                    message: "Unable to read staged Git changes.",
+                    message: "Unable to read Git status.",
+                    statusCode: 400,
+                    hint: result.stderr
+                });
+            }
+            return result.stdout;
+        },
+        async getCommitInfo(repoRoot, ref = "HEAD") {
+            const result = await runGit(runner, repoRoot, ["show", "-s", "--format=%H%x00%s%x00%cI", ref]);
+            if (result.exitCode !== 0) {
+                throw new VcmError({
+                    code: "GIT_ERROR",
+                    message: "Unable to read Git commit.",
+                    statusCode: 400,
+                    hint: result.stderr
+                });
+            }
+            const [sha = "", subject = "", committedAt = ""] = result.stdout.split("\0");
+            return {
+                sha: sha.trim(),
+                subject: subject.trim(),
+                committedAt: committedAt.trim() || undefined
+            };
+        },
+        async getCommitDiff(repoRoot, ref = "HEAD") {
+            const result = await runGit(runner, repoRoot, [
+                "show",
+                "--format=",
+                "--no-ext-diff",
+                "--binary",
+                "--src-prefix=a/",
+                "--dst-prefix=b/",
+                ref
+            ]);
+            if (result.exitCode !== 0) {
+                throw new VcmError({
+                    code: "GIT_ERROR",
+                    message: "Unable to read Git commit diff.",
                     statusCode: 400,
                     hint: result.stderr
                 });
@@ -149,21 +191,6 @@ export function createGitAdapter(runner) {
             }
             return this.getHeadCommit(repoRoot);
         },
-        async rebase(repoRoot, upstream) {
-            const result = await runGit(runner, repoRoot, ["rebase", upstream]);
-            if (result.exitCode !== 0) {
-                throw new VcmError({
-                    code: "GIT_REBASE_FAILED",
-                    message: "Unable to rebase task branch onto the harness commit.",
-                    statusCode: 409,
-                    hint: result.stderr || result.stdout
-                });
-            }
-            return {
-                stdout: result.stdout,
-                stderr: result.stderr
-            };
-        },
         async createWorktree(input) {
             const result = await runGit(runner, input.repoRoot, [
                 "worktree",

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

@@ -1,9 +1,9 @@
 import { isOpenFileLimitError, VcmError } from "../errors.js";
 export function registerHarnessRoutes(app, deps) {
-    app.get("/api/projects/harness", async () => {
-        const project = await requireCurrentProject(deps.projectService);
+    app.get("/api/projects/harness", async (request) => {
+        const { task } = await requireHarnessTaskContext(deps, request.query.taskSlug);
         try {
-            return await deps.harnessService.getHarnessStatus(project.repoRoot);
+            return await deps.harnessService.getHarnessStatus(task.worktreePath);
         }
         catch (error) {
             if (isOpenFileLimitError(error)) {
@@ -12,16 +12,16 @@ export function registerHarnessRoutes(app, deps) {
             throw error;
         }
     });
-    app.post("/api/projects/harness/apply", async () => {
-        const project = await requireCurrentProject(deps.projectService);
-        return deps.harnessService.applyHarness(project.repoRoot);
+    app.post("/api/projects/harness/apply", async (request) => {
+        const { task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
+        return deps.harnessService.applyHarness(task.worktreePath);
     });
     app.get("/api/projects/harness/file", async (request) => {
-        const project = await requireCurrentProject(deps.projectService);
-        return deps.harnessService.getHarnessFileContent(project.repoRoot, request.query.path ?? "");
+        const { task } = await requireHarnessTaskContext(deps, request.query.taskSlug);
+        return deps.harnessService.getHarnessFileContent(task.worktreePath, request.query.path ?? "");
     });
     app.put("/api/projects/harness/file", async (request) => {
-        const project = await requireCurrentProject(deps.projectService);
+        const { task } = await requireHarnessTaskContext(deps, request.query.taskSlug ?? request.body?.taskSlug);
         if (typeof request.body?.content !== "string") {
             throw new VcmError({
                 code: "HARNESS_FILE_CONTENT_INVALID",
@@ -29,22 +29,17 @@ export function registerHarnessRoutes(app, deps) {
                 statusCode: 400
             });
         }
-        return deps.harnessService.updateHarnessFileContent(project.repoRoot, request.query.path ?? "", request.body.content);
+        return deps.harnessService.updateHarnessFileContent(task.worktreePath, request.query.path ?? "", request.body.content);
     });
-    app.post("/api/projects/harness/tasks/:taskSlug/commit-and-rebase", async (request) => {
-        const project = await requireCurrentProject(deps.projectService);
-        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
-        return deps.harnessService.commitAndRebaseTask(project.repoRoot, {
-            taskSlug: task.taskSlug,
-            branch: task.branch,
-            worktreePath: task.worktreePath,
-            changedFiles: request.body?.changedFiles ?? []
-        });
+    app.get("/api/projects/harness/repository-diff", async (request) => {
+        const { task } = await requireHarnessTaskContext(deps, request.query.taskSlug);
+        const scope = request.query.scope === "all" ? "all" : "harness";
+        return deps.harnessService.getRepositoryDiff(task.worktreePath, scope);
     });
-    app.get("/api/projects/harness/bootstrap", async () => {
-        const project = await requireCurrentProject(deps.projectService);
+    app.get("/api/projects/harness/bootstrap", async (request) => {
+        const { project, task } = await requireHarnessTaskContext(deps, request.query.taskSlug);
         try {
-            return await deps.harnessService.getBootstrapStatus(project.repoRoot);
+            return await deps.harnessService.getBootstrapStatus(project.repoRoot, task.worktreePath);
         }
         catch (error) {
             if (isOpenFileLimitError(error)) {
@@ -54,20 +49,20 @@ export function registerHarnessRoutes(app, deps) {
         }
     });
     app.post("/api/projects/harness/bootstrap/start", async (request) => {
-        const project = await requireCurrentProject(deps.projectService);
-        return deps.harnessService.startHarnessBootstrap(project.repoRoot, request.body ?? {});
+        const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
+        return deps.harnessService.startHarnessBootstrap(project.repoRoot, task.worktreePath, request.body ?? {});
     });
     app.post("/api/projects/harness/bootstrap/restart", async (request) => {
-        const project = await requireCurrentProject(deps.projectService);
-        return deps.harnessService.restartHarnessBootstrap(project.repoRoot, request.body ?? {});
+        const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
+        return deps.harnessService.restartHarnessBootstrap(project.repoRoot, task.worktreePath, request.body ?? {});
     });
     app.post("/api/projects/harness/bootstrap/stop", async () => {
         const project = await requireCurrentProject(deps.projectService);
         return deps.harnessService.stopHarnessBootstrap(project.repoRoot);
     });
-    app.post("/api/projects/harness/bootstrap/run", async () => {
-        const project = await requireCurrentProject(deps.projectService);
-        return deps.harnessService.runHarnessBootstrap(project.repoRoot);
+    app.post("/api/projects/harness/bootstrap/run", async (request) => {
+        const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
+        return deps.harnessService.runHarnessBootstrap(project.repoRoot, task.worktreePath);
     });
     app.get("/api/projects/harness/engineer/session", async () => {
         const project = await requireCurrentProject(deps.projectService);
@@ -140,3 +135,17 @@ async function requireCurrentProject(projectService) {
     }
     return project;
 }
+async function requireHarnessTaskContext(deps, taskSlug) {
+    const project = await requireCurrentProject(deps.projectService);
+    const normalizedTaskSlug = taskSlug?.trim();
+    if (!normalizedTaskSlug) {
+        throw new VcmError({
+            code: "HARNESS_TASK_REQUIRED",
+            message: "Select or create an active task before changing VCM Harness.",
+            statusCode: 409,
+            hint: "VCM writes harness changes only to the active task worktree."
+        });
+    }
+    const task = await deps.taskService.loadTask(project.repoRoot, normalizedTaskSlug);
+    return { project, task };
+}