@goodtek/vibeops 3.1.0 → 3.1.1

package/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to VibeOps are documented here.
 
 ## Unreleased
 
+## 3.1.1 - 2026-10-15
+
+### Fixed
+
+- **`task ship` with deletions / renames:** a staged deletion (`D `, e.g. `git rm --cached <path>` + file removed) or a staged rename made ship fail with `fatal: pathspec '<path>' did not match any files`, because every dirty path was passed to `git add`. Ship now parses `git status --porcelain=v1 -z` and runs `git add -A -- :(literal)<path>` only for untracked / unstaged paths; staged changes are committed as they are. Unstaged deletions of tracked files are staged as deletions. Names with spaces or non-ASCII characters (previously quoted by porcelain output) are staged correctly (TASK-022).
+
 ## 3.1.0 - 2026-10-03
 
 ### Added

package/dist/lib/git.js

@@ -160,7 +160,7 @@ export async function stashGovernanceIfBlocking(cwd) {
     const gov = await gitGovernanceOnlyDirty(cwd);
     if (!gov.onlyGovernance || gov.allPaths.length === 0)
         return null;
-    const tracked = parsePorcelain(await gitStatusPorcelain(cwd))
+    const tracked = (await gitStatusEntries(cwd))
         .filter((e) => !e.untracked && isGovernanceDocumentationPath(e.path))
         .map((e) => e.path);
     if (tracked.length === 0)
@@ -256,52 +256,51 @@ export async function gitStatusPorcelain(cwd) {
         return [];
     return res.stdout.split("\n").filter((line) => line.length > 0);
 }
-function parsePorcelainLine(line) {
-    if (line.length < 3)
-        return null;
-    const code = line.slice(0, 2);
-    const rest = line.slice(3);
-    if (code === "??") {
-        return { code, staged: false, unstaged: false, untracked: true, path: rest };
-    }
-    if (code === "!!") {
-        return null;
-    }
-    const x = code.charAt(0);
-    const y = code.charAt(1);
-    // Rename / copy: `R  old -> new` or `C  old -> new`
-    if (x === "R" || x === "C") {
-        const arrow = rest.indexOf(" -> ");
-        if (arrow >= 0) {
-            const origPath = rest.slice(0, arrow);
-            const path = rest.slice(arrow + 4);
-            return {
-                code,
-                staged: true,
-                unstaged: y !== " " && y !== "?",
-                untracked: false,
-                path,
-                origPath,
-            };
-        }
-    }
-    return {
-        code,
-        staged: x !== " " && x !== "?",
-        unstaged: y !== " " && y !== "?",
-        untracked: false,
-        path: rest,
-    };
-}
-function parsePorcelain(lines) {
+/**
+ * Parse `git status --porcelain=v1 -z`: records are NUL-terminated, paths are
+ * never quoted, and a rename / copy record is followed by its source path as a
+ * separate NUL-terminated field (`XY new\0old\0`).
+ */
+export function parsePorcelainZ(stdout) {
+    const fields = stdout.split("\0");
     const out = [];
-    for (const line of lines) {
-        const entry = parsePorcelainLine(line);
-        if (entry !== null)
-            out.push(entry);
+    for (let i = 0; i < fields.length; i++) {
+        const record = fields[i];
+        if (record.length < 4)
+            continue;
+        const code = record.slice(0, 2);
+        const path = record.slice(3);
+        if (code === "!!")
+            continue;
+        if (code === "??") {
+            out.push({ code, staged: false, unstaged: false, untracked: true, path });
+            continue;
+        }
+        const x = code.charAt(0);
+        const y = code.charAt(1);
+        let origPath;
+        if (x === "R" || x === "C" || y === "R" || y === "C") {
+            origPath = fields[i + 1];
+            i += 1;
+        }
+        out.push({
+            code,
+            staged: x !== " ",
+            unstaged: y !== " ",
+            untracked: false,
+            path,
+            ...(typeof origPath === "string" && origPath.length > 0 ? { origPath } : {}),
+        });
     }
     return out;
 }
+/** Parsed `git status --porcelain=v1 -z`; empty when the repo is unreadable. */
+async function gitStatusEntries(cwd) {
+    const res = await tryGit(cwd, ["status", "--porcelain=v1", "-z"]);
+    if (!res)
+        return [];
+    return parsePorcelainZ(res.stdout);
+}
 /** Paths under these prefixes may stay uncommitted across `start` / `done` / doc updates. */
 const GOVERNANCE_DOC_REL_PREFIXES = [
     "docs/tasks/",
@@ -389,7 +388,7 @@ export async function tryResolveGovernanceUnmerged(cwd) {
     return resolved;
 }
 export async function listWorkingTreeRelPaths(cwd) {
-    const entries = parsePorcelain(await gitStatusPorcelain(cwd));
+    const entries = await gitStatusEntries(cwd);
     const all = new Set();
     for (const e of entries) {
         all.add(e.path);
@@ -416,13 +415,29 @@ export function partitionPathsForAutoCommit(paths, opts = {}) {
     }
     return { committable, excluded, unmerged };
 }
+/**
+ * Paths whose working-tree state is not yet in the index: untracked files and
+ * entries with a Y-column change (modified, deleted, type-changed, unmerged).
+ * Index-only changes — a staged deletion (`D `), the source of a staged rename
+ * (`R  old -> new`) — are already recorded and exist in neither the index nor
+ * the working tree, so `git add` must not be given them (it fails with
+ * `pathspec … did not match any files`).
+ */
+export async function listUnstagedRelPaths(cwd) {
+    const entries = await gitStatusEntries(cwd);
+    return entries.filter((e) => e.untracked || e.unstaged).map((e) => e.path);
+}
+/**
+ * Stage `paths` with git's own semantics: `-A` records modifications, new files
+ * and deletions alike; `:(literal)` keeps names with glob characters exact.
+ */
 export async function gitAddPaths(cwd, paths) {
     if (paths.length === 0)
         return;
     const chunkSize = 80;
     for (let i = 0; i < paths.length; i += chunkSize) {
-        const slice = paths.slice(i, i + chunkSize);
-        await runGit(cwd, ["add", "--", ...slice]);
+        const slice = paths.slice(i, i + chunkSize).map((p) => `:(literal)${p}`);
+        await runGit(cwd, ["add", "-A", "--", ...slice]);
     }
 }
 /**
@@ -432,8 +447,7 @@ export async function gitAddPaths(cwd, paths) {
  * block the next TASK unless application code is also dirty.
  */
 export async function gitGovernanceOnlyDirty(cwd) {
-    const lines = await gitStatusPorcelain(cwd);
-    const entries = parsePorcelain(lines);
+    const entries = await gitStatusEntries(cwd);
     const all = new Set();
     for (const e of entries) {
         all.add(e.path);
@@ -450,15 +464,15 @@ export async function gitGovernanceOnlyDirty(cwd) {
     };
 }
 export async function gitWorkingTreeChangedFiles(cwd) {
-    const entries = parsePorcelain(await gitStatusPorcelain(cwd));
+    const entries = await gitStatusEntries(cwd);
     return entries.filter((e) => e.unstaged).map((e) => e.path);
 }
 export async function gitStagedChangedFiles(cwd) {
-    const entries = parsePorcelain(await gitStatusPorcelain(cwd));
+    const entries = await gitStatusEntries(cwd);
     return entries.filter((e) => e.staged).map((e) => e.path);
 }
 export async function gitUntrackedFiles(cwd) {
-    const entries = parsePorcelain(await gitStatusPorcelain(cwd));
+    const entries = await gitStatusEntries(cwd);
     return entries.filter((e) => e.untracked).map((e) => e.path);
 }
 export async function gitCommittedChangedFilesSince(baseCommit, cwd) {
@@ -467,7 +481,7 @@ export async function gitCommittedChangedFilesSince(baseCommit, cwd) {
     return gitDiffNameOnly(cwd, `${baseCommit}..HEAD`);
 }
 export async function gitAllChangedFilesSinceTaskStart(baseCommit, cwd) {
-    const entries = parsePorcelain(await gitStatusPorcelain(cwd));
+    const entries = await gitStatusEntries(cwd);
     const working = entries.filter((e) => e.unstaged).map((e) => e.path);
     const staged = entries.filter((e) => e.staged).map((e) => e.path);
     const untracked = entries.filter((e) => e.untracked).map((e) => e.path);

package/dist/lib/task-git-commit.js

@@ -1,5 +1,5 @@
 import { dim, log } from "./logger.js";
-import { gitAddPaths, gitPush, listWorkingTreeRelPaths, partitionPathsForAutoCommit, readGitInfo, runGit, } from "./git.js";
+import { gitAddPaths, gitPush, listUnstagedRelPaths, listWorkingTreeRelPaths, partitionPathsForAutoCommit, readGitInfo, runGit, } from "./git.js";
 export function featCommitMessageFor(taskId, title) {
     const slug = title.replace(/^TASK-\d+\s*[:\-]\s*/i, "").trim() || taskId;
     return `feat(${taskId.toLowerCase()}): ${slug}`;
@@ -31,7 +31,12 @@ export function taskScopedCommitMessage(taskId, rawMessage, defaultType = "feat"
     }
     return `${defaultType}(${scope}): ${msg}`;
 }
-/** Commit all committable dirty paths; returns whether a commit was created. */
+/**
+ * Commit all committable dirty paths (staged and unstaged, including deletions
+ * and renames); returns whether a commit was created. Only paths whose
+ * working-tree state is not yet in the index are passed to `git add`; staged
+ * changes are already part of the commit.
+ */
 export async function commitDirtyWorkingTree(cwd, message, dryRun) {
     const git = await readGitInfo(cwd);
     if (!git.isRepo || git.dirty !== true)
@@ -46,7 +51,8 @@ export async function commitDirtyWorkingTree(cwd, message, dryRun) {
         log.info(dim(`  would commit ${committable.length} path(s): ${message}`));
         return true;
     }
-    await gitAddPaths(cwd, committable);
+    const committableSet = new Set(committable);
+    await gitAddPaths(cwd, (await listUnstagedRelPaths(cwd)).filter((p) => committableSet.has(p)));
     await runGit(cwd, ["commit", "-q", "-m", message]);
     log.ok(`Committed: ${message}`);
     return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodtek/vibeops",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "description": "Minimal CLI rails for Cursor-based TASK-driven vibe coding.",
   "type": "module",
   "packageManager": "pnpm@9.15.9",