vibe-coding-master 0.0.2 → 0.0.4

package/README.md

@@ -147,6 +147,8 @@ Important container notes:
 - Install Claude Code inside the container, or make the `claude` command available in the container PATH.
 - Make sure Claude Code authentication works inside the container.
 - Make sure the container has network access to Claude services.
+- Use the path as seen from inside the container, for example `/workspace`.
+- VCM accepts normal repositories by checking `/workspace/.git` directly; it does not require global Git `safe.directory` config to connect.
 - Keep the user project, `.vcm`, and `.ai/handoffs` on the same mounted workspace so paths are consistent.
 - Treat the container as the sandbox boundary, especially when using relaxed Claude Code permission modes.
 

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

@@ -1,12 +1,16 @@
+import fs from "node:fs/promises";
+import path from "node:path";
 import { VcmError } from "../errors.js";
 export function createGitAdapter(runner) {
     return {
+        async checkRepo(repoRoot) {
+            return checkGitMarker(repoRoot);
+        },
         async isRepo(repoRoot) {
-            const result = await runner.run("git", ["rev-parse", "--is-inside-work-tree"], { cwd: repoRoot });
-            return result.exitCode === 0 && result.stdout.trim() === "true";
+            return (await this.checkRepo(repoRoot)).isRepo;
         },
         async getCurrentBranch(repoRoot) {
-            const result = await runner.run("git", ["branch", "--show-current"], { cwd: repoRoot });
+            const result = await runGit(runner, repoRoot, ["branch", "--show-current"]);
             if (result.exitCode !== 0) {
                 throw new VcmError({
                     code: "GIT_ERROR",
@@ -18,7 +22,7 @@ export function createGitAdapter(runner) {
             return result.stdout.trim() || "detached";
         },
         async isDirty(repoRoot) {
-            const result = await runner.run("git", ["status", "--porcelain"], { cwd: repoRoot });
+            const result = await runGit(runner, repoRoot, ["status", "--porcelain"]);
             if (result.exitCode !== 0) {
                 throw new VcmError({
                     code: "GIT_ERROR",
@@ -31,3 +35,74 @@ export function createGitAdapter(runner) {
         }
     };
 }
+async function checkGitMarker(repoRoot) {
+    const markerPath = path.join(repoRoot, ".git");
+    try {
+        const markerStat = await fs.lstat(markerPath);
+        if (markerStat.isDirectory()) {
+            return checkGitDirectory(markerPath);
+        }
+        if (markerStat.isFile()) {
+            return checkGitFile(repoRoot, markerPath);
+        }
+        return {
+            isRepo: false,
+            hint: `.git exists but is neither a directory nor a gitdir file: ${markerPath}`
+        };
+    }
+    catch {
+        return {
+            isRepo: false,
+            hint: `.git not found under selected path: ${markerPath}`
+        };
+    }
+}
+async function checkGitDirectory(gitDir) {
+    if (await pathExists(path.join(gitDir, "HEAD"))) {
+        return { isRepo: true };
+    }
+    return {
+        isRepo: false,
+        hint: `.git directory exists but HEAD is missing: ${gitDir}`
+    };
+}
+async function checkGitFile(repoRoot, markerPath) {
+    const marker = await fs.readFile(markerPath, "utf8");
+    const match = marker.match(/^gitdir:\s*(.+)\s*$/m);
+    if (!match) {
+        return {
+            isRepo: false,
+            hint: `.git file does not contain a gitdir pointer: ${markerPath}`
+        };
+    }
+    const gitDir = path.resolve(repoRoot, match[1]);
+    if (await pathExists(path.join(gitDir, "HEAD"))) {
+        return { isRepo: true };
+    }
+    return {
+        isRepo: false,
+        hint: `.git file points to a gitdir without HEAD: ${gitDir}`
+    };
+}
+async function pathExists(targetPath) {
+    try {
+        await fs.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function runGit(runner, repoRoot, args) {
+    return runner.run("git", [...await buildSafeDirectoryArgs(repoRoot), ...args], { cwd: repoRoot });
+}
+async function buildSafeDirectoryArgs(repoRoot) {
+    const safeDirs = new Set([repoRoot]);
+    try {
+        safeDirs.add(await fs.realpath(repoRoot));
+    }
+    catch {
+        // The main Git command will return the actionable path error.
+    }
+    return [...safeDirs].flatMap((safeDir) => ["-c", `safe.directory=${safeDir}`]);
+}

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

@@ -5,11 +5,24 @@ export function createProjectService(deps) {
     let currentProject = null;
     return {
         async connectProject(input) {
-            const repoRoot = path.resolve(input.repoPath);
-            if (!(await deps.git.isRepo(repoRoot))) {
+            const requestedPath = input.repoPath.trim();
+            const repoRoot = path.resolve(requestedPath);
+            if (!requestedPath || !(await deps.fs.pathExists(repoRoot))) {
                 throw new VcmError({
                     code: "INVALID_REPO",
                     message: "Selected path is not a Git repository.",
+                    hint: requestedPath
+                        ? `Path does not exist inside the VCM runtime: ${repoRoot}`
+                        : "Repository path cannot be empty.",
+                    statusCode: 400
+                });
+            }
+            const repoCheck = await deps.git.checkRepo(repoRoot);
+            if (!repoCheck.isRepo) {
+                throw new VcmError({
+                    code: "INVALID_REPO",
+                    message: "Selected path is not a Git repository.",
+                    hint: repoCheck.hint,
                     statusCode: 400
                 });
             }
@@ -18,9 +31,21 @@ export function createProjectService(deps) {
             await deps.fs.ensureDir(path.join(repoRoot, config.stateRoot, "tasks"));
             await deps.fs.ensureDir(path.join(repoRoot, config.stateRoot, "sessions"));
             await this.saveConfig(config, true);
-            const branch = await deps.git.getCurrentBranch(repoRoot);
-            const isDirty = await deps.git.isDirty(repoRoot);
             const warnings = [];
+            let branch = "unknown";
+            let isDirty = false;
+            try {
+                branch = await deps.git.getCurrentBranch(repoRoot);
+            }
+            catch (caught) {
+                warnings.push(`Unable to read current Git branch. ${getErrorHint(caught)}`);
+            }
+            try {
+                isDirty = await deps.git.isDirty(repoRoot);
+            }
+            catch (caught) {
+                warnings.push(`Unable to read Git dirty status. ${getErrorHint(caught)}`);
+            }
             if (branch === "main" || branch === "master") {
                 warnings.push(`You are on ${branch}. Consider creating a task branch before coding.`);
             }
@@ -58,6 +83,15 @@ export function createProjectService(deps) {
         }
     };
 }
+function getErrorHint(caught) {
+    if (caught instanceof VcmError) {
+        return caught.hint?.trim() || caught.message;
+    }
+    if (caught instanceof Error) {
+        return caught.message;
+    }
+    return "Unknown Git metadata error.";
+}
 export function buildDefaultProjectConfig(repoRoot) {
     return {
         version: 1,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-coding-master",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Local GUI session cockpit for Claude Code role sessions.",
   "type": "module",
   "files": [