gitdone-agent 0.8.0 → 0.8.3

package/index.js

@@ -10,6 +10,7 @@
 // from ~/.gitdone-agent/config.json, so the autostart entry needs no args.
 
 import { execSync, execFileSync, spawn } from 'node:child_process'
+import readline from 'node:readline'
 import {
   existsSync, writeFileSync, readFileSync, unlinkSync, renameSync,
   mkdirSync, copyFileSync, appendFileSync, readdirSync, rmSync, statSync,
@@ -28,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.0'
+const AGENT_VERSION = '0.8.3'
 
 const AGENT_DIR = join(homedir(), '.gitdone-agent')
 const CONFIG_PATH = join(AGENT_DIR, 'config.json')
@@ -1470,6 +1471,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, после рестартирай агента.`
@@ -1494,7 +1506,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',
@@ -1517,6 +1529,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).
@@ -1550,6 +1565,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.
@@ -1585,7 +1601,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',
@@ -1599,6 +1615,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).
@@ -1893,7 +1911,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) {
@@ -1913,6 +1931,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).
@@ -2004,7 +2025,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) {
@@ -2015,7 +2036,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
@@ -2106,6 +2127,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)) {
@@ -2140,6 +2162,7 @@ async function runAiChat(cfg, cmd, repoPath) {
       imgDir: dl?.dir ?? null,
       resumeId: claudeSessionId,
       model,
+      effort,
       allowCommit,
     })
     return
@@ -2159,7 +2182,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)
@@ -2388,19 +2411,14 @@ async function readClaudeUsage() {
 }
 
 // ─── Codex (ChatGPT) plan usage (gd-492) ───────────────────────────────────
-// Codex knows its own rate limits but does NOT put them in the `codex exec
-// --json` stdout stream (upstream openai/codex#14728). It DOES write them to the
-// session rollout it keeps on disk:
-//   ~/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-<ts>-<thread>.jsonl
-// where `token_count` lines carry:
-//   payload.rate_limits = { primary: { used_percent, window_minutes, resets_at },
-//                           secondary: …|null, plan_type, credits, … }
-// So we read the newest rollout and take its LAST rate_limits record.
+// Ask Codex itself for the ChatGPT account rate limits, instead of guessing from
+// a previous run's transcript. The app-server API is the same local surface the
+// clients use for account/rateLimits/read; it returns primary/secondary windows
+// when the account has both a short and a weekly/general Codex bucket.
 //
-// Unlike the Claude numbers — fetched live from Anthropic on every tick — these
-// are only as fresh as the user's last Codex run, which is why we report the
-// rollout line's OWN timestamp as observedAt instead of "now". The console can
-// then say how old they are rather than implying they're live.
+// If that live read fails, fall back to the last rollout file so old Codex
+// installs still show something. Rollout values are telemetry only and may not
+// include every limit the CLI enforces.
 
 // Newest entry in a dir, by name (the sessions tree is zero-padded YYYY/MM/DD,
 // so the lexicographic max IS the newest) or by mtime for the files themselves.
@@ -2435,8 +2453,20 @@ function readTail(file, bytes) {
   return start > 0 ? text.slice(text.indexOf('\n') + 1) : text
 }
 
-// One window of a Codex rate limit → the shape the server stores.
-function codexWindow(w) {
+function codexAppWindow(w) {
+  if (!w || typeof w !== 'object') return null
+  const pct = Number(w.usedPercent)
+  if (!Number.isFinite(pct)) return null
+  const resets = Number(w.resetsAt)
+  return {
+    pct: Math.round(pct),
+    windowMin: Number.isFinite(Number(w.windowDurationMins)) ? Math.round(Number(w.windowDurationMins)) : null,
+    resetsAt: Number.isFinite(resets) && resets > 0 ? new Date(resets * 1000).toISOString() : null,
+  }
+}
+
+// One rollout window of a Codex rate limit → the shape the server stores.
+function codexRolloutWindow(w) {
   if (!w || typeof w !== 'object') return null
   const pct = Number(w.used_percent)
   if (!Number.isFinite(pct)) return null
@@ -2449,10 +2479,77 @@ function codexWindow(w) {
   }
 }
 
-let codexUsageCache = { at: 0, data: null }
-function readCodexUsage() {
-  const now = Date.now()
-  if (codexUsageCache.data && now - codexUsageCache.at < 60_000) return codexUsageCache.data
+function codexUsageFromSnapshot(snapshot) {
+  if (!snapshot || typeof snapshot !== 'object') return null
+  const primary = codexAppWindow(snapshot.primary)
+  const secondary = codexAppWindow(snapshot.secondary)
+  if (!primary && !secondary) return null
+  return {
+    primary,
+    secondary,
+    planType: typeof snapshot.planType === 'string' ? snapshot.planType : null,
+    observedAt: new Date().toISOString(),
+  }
+}
+
+function readCodexUsageFromAppServer() {
+  return new Promise((resolve) => {
+    const { path: codexPath, shell, found } = findCodex()
+    if (!found) return resolve(null)
+
+    let settled = false
+    let child
+    const finish = (value) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      try { child?.kill() } catch { /* best-effort */ }
+      resolve(value)
+    }
+    const timer = setTimeout(() => finish(null), 12_000)
+
+    try {
+      child = spawn(codexPath, ['app-server', '--stdio'], {
+        stdio: ['pipe', 'pipe', 'ignore'],
+        shell,
+        windowsHide: true,
+      })
+    } catch {
+      return finish(null)
+    }
+
+    child.on('error', () => finish(null))
+    child.on('exit', () => finish(null))
+
+    const rl = readline.createInterface({ input: child.stdout })
+    rl.on('line', (line) => {
+      let msg
+      try { msg = JSON.parse(line) } catch { return }
+      if (msg.id !== 2) return
+      if (msg.error) return finish(null)
+      const result = msg.result
+      const byId = result?.rateLimitsByLimitId
+      const snapshot = byId?.codex || result?.rateLimits
+      finish(codexUsageFromSnapshot(snapshot))
+    })
+
+    const send = (message) => {
+      try { child.stdin.write(`${JSON.stringify(message)}\n`) } catch { finish(null) }
+    }
+    send({
+      method: 'initialize',
+      id: 1,
+      params: {
+        clientInfo: { name: 'gitdone-agent', title: 'gitDone Agent', version: AGENT_VERSION },
+        capabilities: { experimentalApi: true },
+      },
+    })
+    send({ method: 'initialized', params: {} })
+    send({ method: 'account/rateLimits/read', id: 2 })
+  })
+}
+
+function readCodexUsageFromRollout() {
   try {
     const root = join(homedir(), '.codex', 'sessions')
     if (!existsSync(root)) return null
@@ -2477,18 +2574,16 @@ function readCodexUsage() {
           try { ev = JSON.parse(line) } catch { continue }
           const rl = ev?.payload?.rate_limits
           if (!rl || typeof rl !== 'object') continue
-          const primary = codexWindow(rl.primary)
-          const secondary = codexWindow(rl.secondary)
+          const primary = codexRolloutWindow(rl.primary)
+          const secondary = codexRolloutWindow(rl.secondary)
           if (!primary && !secondary) continue
-          const data = {
+          return {
             primary,
             secondary,
             planType: typeof rl.plan_type === 'string' ? rl.plan_type : null,
             // When these numbers were actually true — the run that produced them.
             observedAt: typeof ev.timestamp === 'string' ? ev.timestamp : new Date(statSync(file).mtimeMs).toISOString(),
           }
-          codexUsageCache = { at: now, data }
-          return data
         }
       }
     }
@@ -2498,6 +2593,15 @@ function readCodexUsage() {
   }
 }
 
+let codexUsageCache = { at: 0, data: null }
+async function readCodexUsage() {
+  const now = Date.now()
+  if (codexUsageCache.data && now - codexUsageCache.at < 60_000) return codexUsageCache.data
+  const data = await readCodexUsageFromAppServer() || readCodexUsageFromRollout()
+  if (data) codexUsageCache = { at: now, data }
+  return data
+}
+
 // The discovered repo list barely ever changes, but re-upserting every repo's
 // row on the server each tick is pure idle write load at scale. So we ship the
 // full `repos` list only when the discovered set actually changed, or every
@@ -2513,7 +2617,7 @@ async function sync(cfg, discovered) {
   const usage = await readClaudeUsage()
   // gd-492: the ChatGPT side's own limits, so a Codex console shows ITS numbers
   // instead of Claude's. Both ride along — one machine can run both engines.
-  const codexUsage = readCodexUsage()
+  const codexUsage = await readCodexUsage()
   const sig = createHash('sha1').update(JSON.stringify(discovered)).digest('hex')
   const full = sig !== syncRepoSig || syncFullCountdown <= 0
   const data = await api(cfg, '/api/v1/agent/sync', {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name":  "gitdone-agent",
-    "version":  "0.8.0",
+    "version":  "0.8.3",
     "description":  "Local git agent for gitdone — watches a local repo and sends snapshots to gitdone.eu",
     "type":  "module",
     "bin":  {