gitdone-agent 0.8.8 → 0.8.10

package/index.js

@@ -31,7 +31,7 @@ import { randomUUID, createHash } from 'node:crypto'
 // Reported to the server on every sync so the web UI can flag outdated agents.
 // Keep in lockstep with packages/agent/package.json. The server's offline
 // fallback is bumped only after this release has actually reached npm.
-const AGENT_VERSION = '0.8.8'
+const AGENT_VERSION = '0.8.10'
 
 const AGENT_DIR = join(homedir(), '.gitdone-agent')
 const CONFIG_PATH = join(AGENT_DIR, 'config.json')
@@ -775,11 +775,12 @@ function gitTry(cmd, cwd) {
 // commit path swallowed that via git() + `|| 'committed'` and reported a fake
 // success while nothing was committed (gd-445). gitDiffUntracked() already uses
 // execFileSync for the same reason. Local calls get 2 min; pass net for 5.
-function gitArgs(args, cwd, { net = false } = {}) {
+function gitArgs(args, cwd, { net = false, input } = {}) {
   try {
     const out = execFileSync('git', args, {
       cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
       maxBuffer: GIT_MAX_BUFFER, timeout: net ? GIT_NET_TIMEOUT_MS : GIT_TIMEOUT_MS, env: GIT_ENV,
+      ...(input === undefined ? {} : { input }),
     }).trim()
     return { ok: true, out }
   } catch (err) {
@@ -789,6 +790,32 @@ function gitArgs(args, cwd, { net = false } = {}) {
   }
 }
 
+function nulPathList(paths) {
+  return Buffer.from(`${paths.join('\0')}\0`, 'utf8')
+}
+
+// A snapshot can become stale between rendering and Commit — most notably when
+// the selected change also updates .gitignore. Return the selected paths that
+// match the repo's ignore rules. Normally check-ignore omits tracked files;
+// --no-index includes them so callers can handle the two groups differently.
+function ignoredPaths(paths, cwd, { includeTracked = false } = {}) {
+  if (paths.length === 0) return new Set()
+  try {
+    const args = ['check-ignore', ...(includeTracked ? ['--no-index'] : []), '-z', '--stdin']
+    const out = execFileSync('git', args, {
+      cwd, encoding: 'buffer', stdio: ['pipe', 'pipe', 'pipe'], input: nulPathList(paths),
+      maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, env: GIT_ENV,
+    })
+    return new Set(out.toString('utf8').split('\0').filter(Boolean))
+  } catch (err) {
+    // Exit 1 is check-ignore's documented "none ignored" result, not a failure.
+    if (err?.status === 1) return new Set()
+    const stderr = err?.stderr?.toString().trim()
+    const stdout = err?.stdout?.toString().trim()
+    throw new Error(`git check-ignore се провали: ${stderr || stdout || err?.message || 'unknown error'}`)
+  }
+}
+
 // Never let a token reach the log file or the server's command-result.
 function redact(text, token) {
   if (!text || !token) return text
@@ -2665,17 +2692,41 @@ async function executeCommand(cfg, cmd, repoPath) {
       const files = Array.isArray(cmd.payload?.files)
         ? cmd.payload.files.filter((f) => typeof f === 'string' && f.trim())
         : []
-      const add = files.length
-        ? gitArgs(['add', '--', ...files], repoPath)
-        : gitArgs(['add', '-A'], repoPath)
+      const ignoredUntracked = ignoredPaths(files, repoPath)
+      const ignoredByRules = ignoredPaths(files, repoPath, { includeTracked: true })
+      const trackedIgnored = new Set([...ignoredByRules].filter((f) => !ignoredUntracked.has(f)))
+      const addFiles = ignoredByRules.size > 0 ? files.filter((f) => !ignoredByRules.has(f)) : files
+      if (ignoredUntracked.size > 0) log(`↷ commit @ ${repoPath}: пропускам ${ignoredUntracked.size} игнорирани untracked файла`)
+      // Do not put every selected path in argv: a large change set can exceed
+      // Windows' ~32K CreateProcess command-line limit before git even starts
+      // (`spawnSync git ENAMETOOLONG`). Git's NUL-delimited stdin pathspec mode
+      // has no such argv limit and also preserves spaces/newlines verbatim.
+      // `git add <path>` refuses tracked files when a newly added rule ignores
+      // their parent directory. update-index stages those exact tracked paths
+      // without force-adding anything untracked; the normal add below handles
+      // all remaining (including new files and embedded repositories).
+      const updateIgnoredTracked = trackedIgnored.size > 0
+        ? gitArgs(['update-index', '--add', '--remove', '-z', '--stdin'], repoPath, { input: nulPathList([...trackedIgnored]) })
+        : { ok: true, out: '' }
+      if (!updateIgnoredTracked.ok) throw new Error(`git update-index се провали: ${updateIgnoredTracked.out}`)
+      const add = addFiles.length
+        ? gitArgs(
+            ['--literal-pathspecs', 'add', '--pathspec-from-file=-', '--pathspec-file-nul'],
+            repoPath,
+            { input: nulPathList(addFiles) },
+          )
+        : files.length === 0
+          ? gitArgs(['add', '-A'], repoPath)
+          : { ok: true, out: '' }
       if (!add.ok) throw new Error(`git add се провали: ${add.out}`)
       const commit = gitArgs(['commit', '-m', msg], repoPath)
+      const ignoredNote = ignoredUntracked.size > 0 ? `\nпропуснати игнорирани файлове: ${ignoredUntracked.size}` : ''
       if (commit.ok) {
-        result = commit.out || 'committed'
+        result = `${commit.out || 'committed'}${ignoredNote}`
       } else if (/nothing to commit|no changes added|working tree clean/i.test(commit.out)) {
         // Benign: the checked files carried no staged change (already committed or
         // whitespace-only). Say so plainly instead of faking success.
-        result = 'няма промени за commit'
+        result = `няма промени за commit${ignoredNote}`
       } else {
         // Real failure (hook, identity, lock, corrupt path…) — surface it so the
         // console shows the reason instead of the old silent fake ✓.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name":  "gitdone-agent",
-    "version":  "0.8.8",
+    "version":  "0.8.10",
     "description":  "Local gitDone companion for repository and optional World of Warcraft progress sync",
     "type":  "module",
     "files":  [