gitdone-agent 0.8.1 → 0.8.4

package/index.js

@@ -29,7 +29,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 "version" AND
 // src/lib/agentVersion.ts LATEST_AGENT_VERSION.
-const AGENT_VERSION = '0.8.1'
+const AGENT_VERSION = '0.8.4'
 
 const AGENT_DIR = join(homedir(), '.gitdone-agent')
 const CONFIG_PATH = join(AGENT_DIR, 'config.json')
@@ -999,7 +999,7 @@ function scanRepos(roots, maxDepth = 5) {
 
 // ─── Server sync + commands ─────────────────────────────────────────────────────
 
-async function api(cfg, path, body) {
+async function apiOnce(cfg, path, body) {
   const res = await fetch(`${cfg.url}${path}`, {
     method: 'POST',
     headers: { Authorization: `Bearer ${cfg.key}`, 'Content-Type': 'application/json' },
@@ -1007,11 +1007,45 @@ async function api(cfg, path, body) {
   })
   if (!res.ok) {
     const text = await res.text().catch(() => '')
-    throw new Error(`HTTP ${res.status} ${path}: ${text}`)
+    const err = new Error(`HTTP ${res.status} ${path}: ${text}`)
+    err.status = res.status
+    throw err
   }
   return res.json().catch(() => ({}))
 }
 
+// gd-514: statuses where the app server demonstrably never processed the body,
+// so re-sending it can't double-apply anything. 502/503/504 is Caddy answering
+// while `systemctl restart gitdone` is mid-flight — i.e. EVERY deploy. A thrown
+// fetch (no status) is a connection that never completed, same story. 4xx and
+// 500 are NOT retried: they won't get better, and a 500 may have half-applied.
+function isRetriableApiError(err) {
+  return err?.status === undefined || [408, 429, 502, 503, 504].includes(err.status)
+}
+
+/**
+ * POST to the app, retrying the failures that are purely "the server wasn't
+ * there". Console events used to be strictly best-effort, which meant a single
+ * 502 during a deploy could swallow the terminal "turn finished" post and leave
+ * the session RUNNING forever, showing a half-written reply that never moved
+ * again (gd-514).
+ */
+async function api(cfg, path, body, attempts = 4) {
+  let lastErr
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await apiOnce(cfg, path, body)
+    } catch (err) {
+      lastErr = err
+      if (i === attempts - 1 || !isRetriableApiError(err)) break
+      // 1s, 2s, 4s — covers the restart window of a deploy without stalling the
+      // console noticeably when the server is merely slow.
+      await new Promise((r) => setTimeout(r, 1000 * 2 ** i))
+    }
+  }
+  throw lastErr
+}
+
 async function reportCommandResult(cfg, id, status, result) {
   await api(cfg, '/api/v1/agent/command-result', { id, status, result }).catch(() => {})
 }
@@ -1021,20 +1055,28 @@ async function reportCommandResult(cfg, id, status, result) {
 // how many tokens the run cost. `streamingText` / `activityText` (gd-419) carry
 // the live "being typed" preview and the latest thinking snippet — explicit ''
 // clears them; `undefined` leaves them untouched.
-async function postRunEvents(cfg, runId, events, status, result, usage, streamingText, activityText, extra) {
-  await api(cfg, '/api/v1/agent/ai-run/events', {
-    runId,
-    events,
-    ...(status ? { status } : {}),
-    ...(result !== undefined ? { result } : {}),
-    ...(usage ? { usage } : {}),
-    ...(streamingText !== undefined ? { streamingText } : {}),
-    ...(activityText !== undefined ? { activityText } : {}),
-    // gd-466: claude's own session id (for --resume) + precise stop cause.
-    ...(extra?.claudeSessionId ? { claudeSessionId: extra.claudeSessionId } : {}),
-    ...(extra?.stopReason ? { stopReason: extra.stopReason } : {}),
-    ...(typeof extra?.resetAt === 'number' ? { resetAt: extra.resetAt } : {}),
-  }).catch((e) => log(`✗ ai-run events post failed: ${e.message}`))
+// Same contract as postSessionEvents: true when it landed, false when the
+// caller must keep the batch and retry it (gd-514).
+async function postRunEvents(cfg, runId, events, status, result, usage, streamingText, activityText, extra, attempts) {
+  try {
+    await api(cfg, '/api/v1/agent/ai-run/events', {
+      runId,
+      events,
+      ...(status ? { status } : {}),
+      ...(result !== undefined ? { result } : {}),
+      ...(usage ? { usage } : {}),
+      ...(streamingText !== undefined ? { streamingText } : {}),
+      ...(activityText !== undefined ? { activityText } : {}),
+      // gd-466: claude's own session id (for --resume) + precise stop cause.
+      ...(extra?.claudeSessionId ? { claudeSessionId: extra.claudeSessionId } : {}),
+      ...(extra?.stopReason ? { stopReason: extra.stopReason } : {}),
+      ...(typeof extra?.resetAt === 'number' ? { resetAt: extra.resetAt } : {}),
+    }, attempts)
+    return true
+  } catch (e) {
+    log(`✗ ai-run events post failed: ${e.message}`)
+    return false
+  }
 }
 
 // gd-466: parse a hard usage-limit stop out of claude's headless output. On the
@@ -1058,17 +1100,26 @@ function detectUsageLimit(text) {
 
 // Post transcript lines (and optional turn status / Claude session id) for an
 // interactive AiSession chat turn.
-async function postSessionEvents(cfg, sessionId, events, status, claudeSessionId, streamingText, activityText) {
-  await api(cfg, '/api/v1/agent/ai-session/events', {
-    sessionId,
-    events,
-    ...(status ? { status } : {}),
-    ...(claudeSessionId ? { claudeSessionId } : {}),
-    // Explicit '' clears the live preview; `undefined` leaves it untouched.
-    ...(streamingText !== undefined ? { streamingText } : {}),
-    // Same semantics for the live thinking snippet (gd-419).
-    ...(activityText !== undefined ? { activityText } : {}),
-  }).catch((e) => log(`✗ ai-session events post failed: ${e.message}`))
+// Returns true when the post landed. A false is the caller's cue to put the
+// batch back and re-send it next tick, instead of dropping it on the floor
+// (gd-514) — that is how whole chunks of a reply used to go missing.
+async function postSessionEvents(cfg, sessionId, events, status, claudeSessionId, streamingText, activityText, attempts) {
+  try {
+    await api(cfg, '/api/v1/agent/ai-session/events', {
+      sessionId,
+      events,
+      ...(status ? { status } : {}),
+      ...(claudeSessionId ? { claudeSessionId } : {}),
+      // Explicit '' clears the live preview; `undefined` leaves it untouched.
+      ...(streamingText !== undefined ? { streamingText } : {}),
+      // Same semantics for the live thinking snippet (gd-419).
+      ...(activityText !== undefined ? { activityText } : {}),
+    }, attempts)
+    return true
+  } catch (e) {
+    log(`✗ ai-session events post failed: ${e.message}`)
+    return false
+  }
 }
 
 // Turn one stream-json line from `claude -p` into console events. Phase 1 shows
@@ -1471,6 +1522,17 @@ function aiProviderArg(raw) {
   return raw === 'codex' ? 'codex' : 'claude'
 }
 
+// Reasoning effort — how hard the model thinks per turn (gd-507). Both CLIs
+// take the same five levels, by different spellings (gd-510): Claude Code as
+// `--effort <level>`, Codex as a `model_reasoning_effort` config override.
+// Whitelisted rather than pattern-matched, since an unknown level makes either
+// CLI refuse to start. null (incl. a gitDone older than gd-507) → don't pass
+// it, and the machine's own setting decides.
+const AI_EFFORT_LEVELS = ['low', 'medium', 'high', 'xhigh', 'max']
+function aiEffortArg(raw) {
+  return typeof raw === 'string' && AI_EFFORT_LEVELS.includes(raw.trim()) ? raw.trim() : null
+}
+
 function cliNotFoundMessage(provider, hostname) {
   return provider === 'codex'
     ? `Codex CLI (ChatGPT) не е намерен на този компютър (${hostname}). Инсталирай го (npm i -g @openai/codex), влез с ChatGPT акаунт през „codex login", увери се, че „codex" е в PATH, после рестартирай агента.`
@@ -1495,7 +1557,7 @@ function cliNotFoundMessage(provider, hostname) {
 // The commit policy is NOT here: Codex has no tool-level deny list to mirror
 // Claude's --disallowedTools, so it rides along in the prompt (codexPrompt).
 function codexExecArgs(cfg, opts) {
-  const { model, resumeId } = opts
+  const { model, effort, resumeId } = opts
   const flags = [
     '--json',
     '--skip-git-repo-check',
@@ -1518,6 +1580,9 @@ function codexExecArgs(cfg, opts) {
     // it, which killed every resumed turn with "unexpected argument".)
     '--dangerously-bypass-approvals-and-sandbox',
     ...(model ? ['--model', model] : []),
+    // Reasoning effort chosen in gitDone (gd-507). There is no flag for it, so
+    // it goes in as a config override like the MCP settings below.
+    ...(effort ? ['-c', `model_reasoning_effort="${effort}"`] : []),
     '-c', `mcp_servers.gitdone.url="${cfg.url}/api/mcp"`,
     '-c', 'mcp_servers.gitdone.bearer_token_env_var="GITDONE_KEY"',
     // Tags the AI agents this run registers with THIS computer (gd-308).
@@ -1551,6 +1616,7 @@ function runAiCommand(cfg, cmd, repoPath) {
   const prompt = cmd.payload?.prompt ?? ''
   const allowCommit = cmd.payload?.allowCommit === true
   const model = aiModelArg(cmd.payload?.model)
+  const effort = aiEffortArg(cmd.payload?.effort)
   const provider = aiProviderArg(cmd.payload?.provider)
   const isCodex = provider === 'codex'
   // gd-466: a token-reset resume asks us to continue the CLI's own conversation.
@@ -1586,7 +1652,7 @@ function runAiCommand(cfg, cmd, repoPath) {
   // Piping it to stdin is robust for both the native exe and the shim; `codex
   // exec -` reads its prompt from stdin the same way.
   const args = isCodex
-    ? codexExecArgs(cfg, { model, resumeId })
+    ? codexExecArgs(cfg, { model, effort, resumeId })
     : [
         '-p',
         '--output-format', 'stream-json',
@@ -1600,6 +1666,8 @@ function runAiCommand(cfg, cmd, repoPath) {
         ...(resumeId ? ['--resume', resumeId] : []),
         // Model chosen in gitDone (project default / task); omitted → machine default (gd-354).
         ...(model ? ['--model', model] : []),
+        // Reasoning effort chosen in gitDone (gd-510); omitted → machine default.
+        ...(effort ? ['--effort', effort] : []),
         '--permission-mode', 'acceptEdits',
         '--allowedTools', 'Read,Edit,Write,Bash,mcp__gitdone__*',
         // Block git commit/push unless this repo opted in (per-repo aiAutoCommit).
@@ -1628,7 +1696,9 @@ function runAiCommand(cfg, cmd, repoPath) {
     const activityChanged = liveActivity !== sentActivity
     if (pending.length === 0 && !liveChanged && !activityChanged) return
     flushing = true
-    const batch = pending; pending = []
+    const taken = pending; pending = []
+    const prevSentLive = sentLive
+    const prevSentActivity = sentActivity
     const streamingText = liveChanged ? liveText : undefined
     const activityText = activityChanged ? liveActivity : undefined
     sentLive = liveText
@@ -1637,7 +1707,16 @@ function runAiCommand(cfg, cmd, repoPath) {
     // resume survives even if the agent dies before the clean close handler.
     const extra = (!sentSession && capturedSession) ? { claudeSessionId: capturedSession } : undefined
     if (extra) sentSession = true
-    await postRunEvents(cfg, runId, batch, undefined, undefined, undefined, streamingText, activityText, extra)
+    const ok = await postRunEvents(cfg, runId, taken, undefined, undefined, undefined, streamingText, activityText, extra)
+    if (!ok) {
+      // Keep everything for the next tick rather than losing console lines to
+      // one bad request (gd-514) — including the session id, so a resume still
+      // gets it.
+      pending = taken.concat(pending)
+      sentLive = prevSentLive
+      sentActivity = prevSentActivity
+      if (extra) sentSession = false
+    }
     flushing = false
   }
   const push = (kind, text) => {
@@ -1740,7 +1819,9 @@ function runAiCommand(cfg, cmd, repoPath) {
         : (ok ? '✓ Готово.' : `✗ Процесът приключи с код ${code}.`),
     }]
     if (usage) events.push({ kind: 'SYSTEM', text: `📊 Токени: ${fmtTokens(usage.inputTokens)} вход · ${fmtTokens(usage.outputTokens)} изход${usage.cacheReadTokens ? ` · ${fmtTokens(usage.cacheReadTokens)} кеш` : ''}${typeof usage.costUsd === 'number' ? ` · $${usage.costUsd.toFixed(4)}` : ''}` })
-    await postRunEvents(
+    // Terminal post — retried hard (gd-514): losing it leaves the run stuck on
+    // RUNNING, and with it the token-limit park/resume the server keys off.
+    const landed = await postRunEvents(
       cfg, runId,
       events,
       // A limit stop is not a clean finish — report it as 'error' so the run
@@ -1751,7 +1832,9 @@ function runAiCommand(cfg, cmd, repoPath) {
       undefined,
       undefined,
       extra,
+      7,
     )
+    if (!landed) log(`✗ ai_run ${runId}: терминалният пост не мина — сървърният watchdog поема`)
     reportCommandResult(cfg, cmd.id, ok && !limit.limited ? 'done' : 'error', limit.limited ? 'usage_limit' : `exit ${code}`)
     log(`■ ai_run ${runId} приключи (code ${code}${limit.limited ? ', usage_limit' : ''})`)
   })
@@ -1846,12 +1929,26 @@ async function flushChatTurn(cfg, entry) {
   const heartbeat = !hasEvents && !liveChanged && !activityChanged && Date.now() - t.lastPostAt > 2500
   if (!hasEvents && !liveChanged && !activityChanged && !heartbeat) return
   t.flushing = true
-  const batch = t.pending.map((e) => ({ role: chatRoleFor(e.kind), text: e.text })); t.pending = []
+  const taken = t.pending; t.pending = []
+  const prevSentLive = t.sentLive
+  const prevSentActivity = t.sentActivity
   const streamingText = liveChanged ? t.liveText : undefined
   const activityText = activityChanged ? t.liveActivity : undefined
   t.sentLive = t.liveText
   t.sentActivity = t.liveActivity
-  await postSessionEvents(cfg, entry.sessionId, batch, 'running', entry.capturedSession || undefined, streamingText, activityText)
+  const ok = await postSessionEvents(
+    cfg, entry.sessionId,
+    taken.map((e) => ({ role: chatRoleFor(e.kind), text: e.text })),
+    'running', entry.capturedSession || undefined, streamingText, activityText,
+  )
+  if (!ok) {
+    // Put it all back so the next tick re-sends it (gd-514). Dropping the batch
+    // is what used to tear holes in the transcript; rewinding sentLive makes the
+    // next post carry the current live text again (it's a replace, not a delta).
+    t.pending = taken.concat(t.pending)
+    t.sentLive = prevSentLive
+    t.sentActivity = prevSentActivity
+  }
   t.lastPostAt = Date.now()
   t.flushing = false
 }
@@ -1872,21 +1969,31 @@ async function finishChatTurn(cfg, entry, outcome) {
   for (let i = 0; i < 20 && t.flushing; i++) await new Promise((r) => setTimeout(r, 100))
   const batch = t.pending.map((e) => ({ role: chatRoleFor(e.kind), text: e.text }))
   t.pending = []
+  // The one post that MUST land: it carries the last of the reply and the
+  // terminal status. Lose it and the console shows "АИ пише…" over a
+  // half-written answer forever (gd-514) — so it gets ~1 minute of retries,
+  // enough to outlast an app restart. The server's stall watchdog is the net if
+  // even that fails.
+  const terminal = async (status, extra) => {
+    const ok = await postSessionEvents(
+      cfg, entry.sessionId, extra ? batch.concat(extra) : batch, status,
+      entry.capturedSession || undefined, '', '', 7,
+    )
+    if (!ok) log(`✗ ai_chat ${entry.sessionId}: терминалният пост не мина — сървърът ще помири сесията`)
+  }
   if (outcome.stopped) {
-    batch.push({ role: 'SYSTEM', text: '⏹ Спряно. Напиши още нещо, за да продължим разговора.' })
-    await postSessionEvents(cfg, entry.sessionId, batch, 'idle', entry.capturedSession || undefined, '', '')
+    await terminal('idle', { role: 'SYSTEM', text: '⏹ Спряно. Напиши още нещо, за да продължим разговора.' })
     reportCommandResult(cfg, t.cmdId, 'done', 'stopped by user')
     log(`⏹ ai_chat ${entry.sessionId} спряно от потребителя`)
     return
   }
   if (!outcome.ok) {
-    batch.push({ role: 'SYSTEM', text: `✗ Ходът приключи с код ${outcome.code}.` })
-    await postSessionEvents(cfg, entry.sessionId, batch, 'error', entry.capturedSession || undefined, '', '')
+    await terminal('error', { role: 'SYSTEM', text: `✗ Ходът приключи с код ${outcome.code}.` })
     reportCommandResult(cfg, t.cmdId, 'error', `exit ${outcome.code}`)
     log(`✗ ai_chat ход в ${entry.sessionId} падна (code ${outcome.code})`)
     return
   }
-  await postSessionEvents(cfg, entry.sessionId, batch, 'idle', entry.capturedSession || undefined, '', '')
+  await terminal('idle')
   reportCommandResult(cfg, t.cmdId, 'done', 'ok')
   log(`✓ ai_chat ход в ${entry.sessionId} приключи (процесът остава жив)`)
 }
@@ -1894,7 +2001,7 @@ async function finishChatTurn(cfg, entry, outcome) {
 // Spawn the persistent claude process for one session and wire its stream
 // handlers once. Turns come and go via entry.turn; the process stays.
 function spawnChatProc(cfg, opts) {
-  const { sessionId, repoPath, model, allowCommit, resumeId, claudePath, shell, settingsPath, mcpConfigPath } = opts
+  const { sessionId, repoPath, model, effort, allowCommit, resumeId, claudePath, shell, settingsPath, mcpConfigPath } = opts
 
   // Room in the pool: evict the least-recently-used idle process first.
   if (chatProcs.size >= CHAT_PROC_MAX) {
@@ -1914,6 +2021,9 @@ function spawnChatProc(cfg, opts) {
     // Model resolved for this session (picker / project default); omitted →
     // machine default (gd-354). Kept consistent across the session's turns.
     ...(model ? ['--model', model] : []),
+    // Same for the session's reasoning effort (gd-510) — frozen at spawn, so a
+    // change in gitDone reaches the pooled process on its next respawn.
+    ...(effort ? ['--effort', effort] : []),
     '--permission-mode', 'acceptEdits',
     '--allowedTools', 'Read,Edit,Write,Bash,mcp__gitdone__*',
     // Block git commit/push unless this repo opted in (per-repo aiAutoCommit).
@@ -2005,7 +2115,7 @@ function killTree(child) {
 // chatProcs under the same entry shape, so ai_chat_stop and the stuck-turn
 // sweeper keep working untouched.
 function runCodexChatTurn(cfg, cmd, repoPath, opts) {
-  const { sessionId, prompt, resumeId, model, allowCommit } = opts
+  const { sessionId, prompt, resumeId, model, effort, allowCommit } = opts
 
   const { path: codexPath, shell, found } = findCodex()
   if (!found) {
@@ -2016,7 +2126,7 @@ function runCodexChatTurn(cfg, cmd, repoPath, opts) {
     return
   }
 
-  const args = codexExecArgs(cfg, { model, resumeId })
+  const args = codexExecArgs(cfg, { model, effort, resumeId })
   const childEnv = { ...process.env, GITDONE_URL: cfg.url, GITDONE_KEY: cfg.key, GITDONE_SESSION_ID: sessionId }
 
   let child
@@ -2107,6 +2217,7 @@ async function runAiChat(cfg, cmd, repoPath) {
   const claudeSessionId = cmd.payload?.claudeSessionId || null
   const allowCommit = cmd.payload?.allowCommit === true
   const model = aiModelArg(cmd.payload?.model)
+  const effort = aiEffortArg(cmd.payload?.effort)
   const provider = aiProviderArg(cmd.payload?.provider)
   // A turn may be text-only, image-only, or both — but needs at least one.
   if (!sessionId || (!prompt && images.length === 0)) {
@@ -2141,6 +2252,7 @@ async function runAiChat(cfg, cmd, repoPath) {
       imgDir: dl?.dir ?? null,
       resumeId: claudeSessionId,
       model,
+      effort,
       allowCommit,
     })
     return
@@ -2160,7 +2272,7 @@ async function runAiChat(cfg, cmd, repoPath) {
     let mcpConfigPath
     try { mcpConfigPath = ensureAiMcpConfig(cfg) } catch (e) { log(`✗ ai mcp config setup failed: ${e.message}`) }
     try {
-      entry = spawnChatProc(cfg, { sessionId, repoPath, model, allowCommit, resumeId: claudeSessionId, claudePath, shell, settingsPath, mcpConfigPath })
+      entry = spawnChatProc(cfg, { sessionId, repoPath, model, effort, allowCommit, resumeId: claudeSessionId, claudePath, shell, settingsPath, mcpConfigPath })
     } catch (err) {
       postSessionEvents(cfg, sessionId, [{ role: 'SYSTEM', text: `Грешка при стартиране: ${err.message}` }], 'error')
       reportCommandResult(cfg, cmd.id, 'error', err.message)

package/package.json

@@ -1,7 +1,7 @@
 {
     "name":  "gitdone-agent",
-    "version":  "0.8.1",
-    "description":  "Local git agent for gitdone — watches a local repo and sends snapshots to gitdone.eu",
+    "version":  "0.8.4",
+    "description":  "Local git agent for gitdone — watches a local repo and sends snapshots to gitdone.eu",
     "type":  "module",
     "bin":  {
                 "gitdone-agent":  "index.js"