gitdone-agent 0.6.2 → 0.6.4

package/index.js

@@ -27,7 +27,7 @@ import { randomUUID } 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.6.2'
+const AGENT_VERSION = '0.6.4'
 
 const AGENT_DIR = join(homedir(), '.gitdone-agent')
 const CONFIG_PATH = join(AGENT_DIR, 'config.json')
@@ -521,19 +521,24 @@ async function postRunEvents(cfg, runId, events, status, result) {
 
 // Post transcript lines (and optional turn status / Claude session id) for an
 // interactive AiSession chat turn.
-async function postSessionEvents(cfg, sessionId, events, status, claudeSessionId) {
+async function postSessionEvents(cfg, sessionId, events, status, claudeSessionId, streamingText) {
   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 } : {}),
   }).catch((e) => log(`✗ ai-session events post failed: ${e.message}`))
 }
 
 // Turn one stream-json line from `claude -p` into console events. Phase 1 shows
 // what the model writes (TEXT) and which tools it calls (TOOL_CALL); raw tool
 // results (Bash stdout etc.) come in Phase 2 via a PostToolUse hook.
-function parseStreamLine(line, push, onInit) {
+// With `--include-partial-messages`, Claude also emits `stream_event` lines
+// carrying incremental text deltas — onDelta gets those so chat sessions can
+// show the reply being written live (gd-302).
+function parseStreamLine(line, push, onInit, onDelta) {
   let ev
   try { ev = JSON.parse(line) } catch { return }
   if (ev.type === 'system') {
@@ -544,6 +549,16 @@ function parseStreamLine(line, push, onInit) {
     }
     return
   }
+  // Partial-message stream: only the model's visible text deltas feed the live
+  // preview. Tool-input JSON deltas and thinking deltas are ignored here — the
+  // full block still arrives as a normal `assistant` event below.
+  if (ev.type === 'stream_event' && typeof onDelta === 'function') {
+    const e = ev.event
+    if (e?.type === 'content_block_delta' && e.delta?.type === 'text_delta' && e.delta.text) {
+      onDelta(e.delta.text)
+    }
+    return
+  }
   if (ev.type === 'assistant' && ev.message?.content) {
     for (const block of ev.message.content) {
       if (block.type === 'text' && block.text?.trim()) {
@@ -791,6 +806,24 @@ async function downloadSessionImages(sessionId, urls) {
   return { dir, paths }
 }
 
+// Live chat turns, keyed by sessionId → their spawned `claude` child. Lets an
+// `ai_chat_stop` command find and kill the turn a user asked to interrupt
+// (gd-303). A turn registers itself on spawn and removes itself on close.
+const chatChildren = new Map()
+
+// Kill a process AND its descendants. `claude` spawns its own children (bash,
+// node hooks), so killing just the top pid would orphan them. Windows needs
+// `taskkill /T`; POSIX kills the process group, falling back to a hard kill.
+function killTree(child) {
+  const pid = child?.pid
+  if (!pid) return
+  if (process.platform === 'win32') {
+    try { spawn('taskkill', ['/PID', String(pid), '/T', '/F'], { windowsHide: true }) } catch { /* best-effort */ }
+  } else {
+    try { process.kill(-pid, 'SIGKILL') } catch { try { child.kill('SIGKILL') } catch { /* gone */ } }
+  }
+}
+
 // Run one turn of an interactive chat session: `claude -p` (resuming the prior
 // Claude session when known) with the user's message on stdin, streaming the
 // reply back to the session console. Long-running + fire-and-forget like ai_run.
@@ -822,6 +855,9 @@ async function runAiChat(cfg, cmd, repoPath) {
     '-p',
     '--output-format', 'stream-json',
     '--verbose',
+    // Stream the reply token-by-token so the console can show it being written
+    // live, not only once each block is complete (gd-302).
+    '--include-partial-messages',
     '--permission-mode', 'acceptEdits',
     '--allowedTools', 'Read,Edit,Write,Bash,mcp__gitdone__*',
     // Block git commit/push unless this repo opted in (per-repo aiAutoCommit).
@@ -837,16 +873,35 @@ async function runAiChat(cfg, cmd, repoPath) {
   let pending = []
   let capturedSession = null // Claude's session id, sent (idempotently) for --resume
   let flushing = false
+  let liveText = '' // in-progress text of the current assistant block (live preview)
+  let sentLive = '' // last streamingText we posted — so we only push on change
+  let lastPostAt = 0 // Date.now() of the last post, for the keep-alive heartbeat
   const flush = async () => {
-    if (flushing || pending.length === 0) return
+    if (flushing) return
+    const hasEvents = pending.length > 0
+    const liveChanged = liveText !== sentLive
+    // Heartbeat: with nothing new for a while, still post (bumps lastActivityAt)
+    // so the console shows honest "still working" and can spot a real stall.
+    const heartbeat = !hasEvents && !liveChanged && Date.now() - lastPostAt > 2500
+    if (!hasEvents && !liveChanged && !heartbeat) return
     flushing = true
     const batch = pending.map((e) => ({ role: roleFor(e.kind), text: e.text })); pending = []
-    await postSessionEvents(cfg, sessionId, batch, 'running', capturedSession || undefined)
+    const streamingText = liveChanged ? liveText : undefined
+    sentLive = liveText
+    await postSessionEvents(cfg, sessionId, batch, 'running', capturedSession || undefined, streamingText)
+    lastPostAt = Date.now()
     flushing = false
   }
-  const push = (kind, text) => { if (text != null && String(text) !== '') pending.push({ kind, text: String(text) }) }
+  const push = (kind, text) => {
+    if (text == null || String(text) === '') return
+    // A completed text block becomes a real event — drop its live preview so the
+    // finalised bubble and the cleared preview swap in on the same flush.
+    if (kind === 'TEXT') liveText = ''
+    pending.push({ kind, text: String(text) })
+  }
   const onInit = (sid) => { if (sid && !claudeSessionId) capturedSession = sid }
-  const timer = setInterval(flush, 800)
+  const onDelta = (chunk) => { liveText += chunk }
+  const timer = setInterval(flush, 500)
 
   // Fetch any attached images locally and fold their paths into the prompt so
   // Claude reads them with its Read tool (URLs on stdin don't render).
@@ -875,6 +930,9 @@ async function runAiChat(cfg, cmd, repoPath) {
     return
   }
 
+  // Track this turn so an `ai_chat_stop` command can find and kill it (gd-303).
+  chatChildren.set(sessionId, child)
+
   if (child.stdin) {
     child.stdin.on('error', () => {})
     try { child.stdin.write(fullPrompt); child.stdin.end() }
@@ -888,28 +946,61 @@ async function runAiChat(cfg, cmd, repoPath) {
     while ((nl = buf.indexOf('\n')) >= 0) {
       const line = buf.slice(0, nl).trim()
       buf = buf.slice(nl + 1)
-      if (line) parseStreamLine(line, push, onInit)
+      if (line) parseStreamLine(line, push, onInit, onDelta)
     }
   })
   child.stderr.on('data', (d) => { const s = d.toString().trim(); if (s) push('SYSTEM', s) })
   child.on('error', (err) => push('SYSTEM', `Процесна грешка: ${err.message}`))
   child.on('close', async (code) => {
     clearInterval(timer)
+    chatChildren.delete(sessionId)
     if (imgDir) { try { rmSync(imgDir, { recursive: true, force: true }) } catch { /* best-effort */ } }
-    if (buf.trim()) parseStreamLine(buf.trim(), push, onInit)
+    if (buf.trim()) parseStreamLine(buf.trim(), push, onInit, onDelta)
+    liveText = '' // turn is over — drop any lingering live preview
     await flush()
+    // User-initiated stop (gd-303): land on idle with a friendly note, not an
+    // "exited with code N" error — the kill's non-zero code is expected here.
+    if (child.__stopped) {
+      await postSessionEvents(
+        cfg, sessionId,
+        [{ role: 'SYSTEM', text: '⏹ Спряно. Напиши още нещо, за да продължим разговора.' }],
+        'idle', capturedSession || undefined, '',
+      )
+      reportCommandResult(cfg, cmd.id, 'done', 'stopped by user')
+      log(`⏹ ai_chat ${sessionId} спряно от потребителя`)
+      return
+    }
     const ok = code === 0
     await postSessionEvents(
       cfg, sessionId,
       ok ? [] : [{ role: 'SYSTEM', text: `✗ Ходът приключи с код ${code}.` }],
       ok ? 'idle' : 'error',
       capturedSession || undefined,
+      '', // clear the live preview on the terminal post
     )
     reportCommandResult(cfg, cmd.id, ok ? 'done' : 'error', `exit ${code}`)
     log(`■ ai_chat ${sessionId} приключи (code ${code})`)
   })
 }
 
+// ai_chat_stop — interrupt a running chat turn the user asked to stop (gd-303).
+// Kills the tracked child (its `close` handler then posts the "⏹ Спряно" note and
+// flips the session to idle). If nothing is running, just idles the session so
+// the console unlocks.
+function stopAiChat(cfg, cmd) {
+  const sessionId = cmd.payload?.sessionId
+  const child = sessionId ? chatChildren.get(sessionId) : null
+  if (!child) {
+    if (sessionId) postSessionEvents(cfg, sessionId, [], 'idle', undefined, '')
+    reportCommandResult(cfg, cmd.id, 'done', 'no active turn')
+    return
+  }
+  child.__stopped = true
+  killTree(child)
+  log(`⏹ ai_chat_stop ${sessionId} — kill signalled`)
+  reportCommandResult(cfg, cmd.id, 'done', 'stop signalled')
+}
+
 // deploy — run the project's deploy script (scripts/deploy.sh) in the repo.
 // Long-running (git pull + npm build + service restart), so we spawn it detached
 // from the poll loop and report the result on exit. The agent is its OWN process
@@ -954,6 +1045,12 @@ async function executeCommand(cfg, cmd, repoPath) {
     runAiChat(cfg, cmd, repoPath)
     return
   }
+  // ai_chat_stop — interrupt the running turn for a session (gd-303). Handled
+  // inline (it just signals a kill) and reports its own result.
+  if (cmd.type === 'ai_chat_stop') {
+    stopAiChat(cfg, cmd)
+    return
+  }
   // deploy — run the repo's deploy script. Long-running (pull + build + service
   // restart), so it's launched in the background and reports its own result on
   // exit, same as ai_run.

package/package.json

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