@kb-labs/commit-core 2.94.0 → 2.96.0

package/dist/index.js

@@ -17,20 +17,17 @@ async function getGitStatus(cwd) {
     untracked: status.not_added.filter((f) => !shouldIgnoreFile(f))
   };
 }
+var IGNORED_SEGMENTS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".turbo",
+  "coverage"
+]);
 function shouldIgnoreFile(file) {
-  const ignoredPaths = [
-    "node_modules/",
-    ".git/",
-    "dist/",
-    "build/",
-    ".next/",
-    ".turbo/",
-    "coverage/",
-    ".cache/",
-    ".temp/",
-    "tmp/"
-  ];
-  return ignoredPaths.some((path) => file.includes(path));
+  return file.split("/").some((segment) => IGNORED_SEGMENTS.has(segment));
 }
 function getAllChangedFiles(status) {
   const allFiles = [
@@ -2769,11 +2766,44 @@ function getErrorType(error) {
   const preview = error.message.substring(0, 50).replace(/\n/g, " ");
   return `error: ${preview}${error.message.length > 50 ? "..." : ""}`;
 }
+var GIT_HOOK_NAMES = [
+  "pre-commit",
+  "commit-msg",
+  "post-commit",
+  "prepare-commit-msg",
+  "pre-push"
+];
+function cleanGitError(message) {
+  return message.split("\n").filter((line) => !line.trimStart().startsWith("hint:")).join("\n").trim();
+}
+function formatCommitError(message) {
+  const cleaned = cleanGitError(message);
+  const isHookError = /hook\s+(failed|exited|returned)/i.test(cleaned) || /husky/i.test(cleaned) || /lint-staged/i.test(cleaned) || GIT_HOOK_NAMES.some((h) => cleaned.includes(h));
+  if (isHookError) {
+    const match = cleaned.match(
+      /(pre-commit|commit-msg|post-commit|prepare-commit-msg|pre-push)/i
+    );
+    const hookName = match?.[1] ?? "git hook";
+    return `${hookName} hook failed:
+${cleaned}`;
+  }
+  return cleaned;
+}
 async function applyCommitPlan(cwd, plan, options) {
   const appliedCommits = [];
   const errors = [];
+  const logger = useLogger();
+  const planFileCount = plan.commits.reduce((sum, c) => sum + c.files.length, 0);
+  await logger.info("apply: start", {
+    scope: options?.scope,
+    cwd,
+    commits: plan.commits.length,
+    planFiles: planFileCount,
+    force: !!options?.force
+  });
   const integrityErrors = validatePlanIntegrity(plan);
   if (integrityErrors.length > 0) {
+    await logger.warn("apply: plan integrity failed", { errors: integrityErrors });
     return {
       success: false,
       appliedCommits: [],
@@ -2799,8 +2829,8 @@ async function applyCommitPlan(cwd, plan, options) {
         message: formatCommitMessage(commit)
       });
     } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      errors.push(`Failed to apply commit ${commit.id}: ${message}`);
+      const raw = error instanceof Error ? error.message : String(error);
+      errors.push(`Failed to apply commit ${commit.id}: ${formatCommitError(raw)}`);
       break;
     }
   }
@@ -2818,6 +2848,10 @@ function validatePlanIntegrity(plan) {
       errors.push(`Commit ${commit.id} has no files`);
       continue;
     }
+    if (!commit.message.trim()) {
+      errors.push(`Commit ${commit.id} has empty message`);
+      continue;
+    }
     for (const file of commit.files) {
       const firstCommit = seenInCommit.get(file);
       if (firstCommit) {
@@ -2841,9 +2875,44 @@ async function applyCommit(cwd, commit) {
   }
   const [repoPath, fileInfos] = Array.from(filesByRepo.entries())[0];
   const git = simpleGit(repoPath);
-  await git.reset(["--"]);
+  const statusBefore = await git.status();
+  if (statusBefore.staged.length > 0) {
+    const restored = await git.raw(["restore", "--staged", "--", ...statusBefore.staged]).then(() => true).catch(() => false);
+    if (!restored) {
+      for (const f of statusBefore.staged) {
+        await git.raw(["rm", "--cached", "--", f]).catch(() => {
+        });
+      }
+    }
+  }
   for (const { relativePath } of fileInfos) {
-    await git.add(relativePath);
+    try {
+      await git.add(relativePath);
+    } catch (addErr) {
+      const msg = addErr instanceof Error ? addErr.message : String(addErr);
+      if (msg.includes("ignored by one of your .gitignore files")) {
+        const isTracked = await git.raw(["ls-files", "--error-unmatch", relativePath]).then(() => true).catch(() => false);
+        if (isTracked) {
+          await git.raw(["add", "-f", relativePath]);
+        } else {
+          throw new Error(
+            `File is gitignored and untracked, cannot stage: ${relativePath}`
+          );
+        }
+      } else {
+        throw new Error(cleanGitError(msg));
+      }
+    }
+  }
+  const statusAfterAdd = await git.status();
+  const stagedSet = new Set(statusAfterAdd.staged);
+  const anyStagedForCommit = fileInfos.some(
+    (fi) => stagedSet.has(fi.relativePath)
+  );
+  if (!anyStagedForCommit) {
+    throw new Error(
+      `Nothing staged for this commit \u2014 files may already be committed or have no changes`
+    );
   }
   const message = formatCommitMessage(commit);
   const result = await git.commit(message);
@@ -2893,8 +2962,14 @@ ${commit.body}`;
   }
   return message;
 }
-async function checkStaleness(cwd, plan, _scope) {
+async function checkStaleness(cwd, plan, scope) {
+  const logger = useLogger();
   const planFiles = new Set(plan.commits.flatMap((c) => c.files));
+  await logger.debug("checkStaleness: start", {
+    scope,
+    cwd,
+    planFiles: [...planFiles]
+  });
   if (planFiles.size === 0) {
     return { isStale: false, reason: "" };
   }
@@ -2902,8 +2977,22 @@ async function checkStaleness(cwd, plan, _scope) {
   for (const [repoPath, fileInfos] of filesByRepo) {
     const currentStatus = await getGitStatus(repoPath);
     const currentFiles = new Set(getAllChangedFiles(currentStatus));
+    await logger.debug("checkStaleness: repo status", {
+      repoPath,
+      staged: currentStatus.staged,
+      unstaged: currentStatus.unstaged,
+      untracked: currentStatus.untracked,
+      expected: fileInfos.map((f) => f.relativePath)
+    });
     for (const { relativePath, originalPath } of fileInfos) {
       if (!currentFiles.has(relativePath)) {
+        await logger.warn("checkStaleness: file not in current changes", {
+          scope,
+          repoPath,
+          originalPath,
+          relativePath,
+          currentFiles: [...currentFiles]
+        });
         return {
           isStale: true,
           reason: `File no longer has changes: ${originalPath}. Regenerate plan or use --force.`
@@ -2945,7 +3034,8 @@ async function pushCommits(cwd, options) {
       commitsPushed: commitsToPush
     };
   } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
+    const raw = error instanceof Error ? error.message : String(error);
+    const message = cleanGitError2(raw);
     const branch = await getCurrentBranch(cwd).catch(() => "unknown");
     return {
       success: false,
@@ -2956,6 +3046,9 @@ async function pushCommits(cwd, options) {
     };
   }
 }
+function cleanGitError2(message) {
+  return message.split("\n").filter((line) => !line.trimStart().startsWith("hint:")).join("\n").trim();
+}
 async function countCommitsToPush(git, remote, branch) {
   try {
     await git.fetch(remote, branch);
@@ -3021,12 +3114,21 @@ async function loadPlan(cwd, scope = "root") {
     const data = JSON.parse(content);
     const result = CommitPlanSchema.safeParse(data);
     if (!result.success) {
-      console.error(`[loadPlan] Zod validation failed for ${planPath}:`, JSON.stringify(result.error.issues));
-      return null;
+      throw new Error(
+        `Commit plan is corrupted and cannot be loaded. Run 'kb commit:generate' to create a new plan.
+` + result.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n")
+      );
     }
     return result.data;
   } catch (err) {
-    console.error(`[loadPlan] Failed to read ${planPath}:`, err instanceof Error ? err.message : err);
+    if (err instanceof SyntaxError) {
+      throw new Error(
+        `Commit plan file is not valid JSON. Run 'kb commit:generate' to create a new plan.`
+      );
+    }
+    if (err instanceof Error && err.message.startsWith("Commit plan is corrupted")) {
+      throw err;
+    }
     return null;
   }
 }