gitdone-agent 0.5.0 → 0.5.2

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.5.0'
+const AGENT_VERSION = '0.5.2'
 
 const AGENT_DIR = join(homedir(), '.gitdone-agent')
 const CONFIG_PATH = join(AGENT_DIR, 'config.json')
@@ -371,14 +371,29 @@ async function postRunEvents(cfg, runId, events, status, result) {
   }).catch((e) => log(`✗ ai-run events post failed: ${e.message}`))
 }
 
+// Post transcript lines (and optional turn status / Claude session id) for an
+// interactive AiSession chat turn.
+async function postSessionEvents(cfg, sessionId, events, status, claudeSessionId) {
+  await api(cfg, '/api/v1/agent/ai-session/events', {
+    sessionId,
+    events,
+    ...(status ? { status } : {}),
+    ...(claudeSessionId ? { claudeSessionId } : {}),
+  }).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) {
+function parseStreamLine(line, push, onInit) {
   let ev
   try { ev = JSON.parse(line) } catch { return }
   if (ev.type === 'system') {
-    if (ev.subtype === 'init') push('SYSTEM', `Сесия стартирана${ev.model ? ` (${ev.model})` : ''}.`)
+    if (ev.subtype === 'init') {
+      push('SYSTEM', `Сесия стартирана${ev.model ? ` (${ev.model})` : ''}.`)
+      // Surface Claude's own session id so chat sessions can --resume it.
+      if (ev.session_id && typeof onInit === 'function') onInit(ev.session_id)
+    }
     return
   }
   if (ev.type === 'assistant' && ev.message?.content) {
@@ -448,31 +463,86 @@ function ensureAiHookFiles() {
   return AI_SETTINGS_PATH
 }
 
+// Same PostToolUse hook, for interactive chat sessions: posts raw tool output to
+// the session endpoint, reading GITDONE_SESSION_ID from the per-turn env.
+const AI_SESSION_HOOK_SCRIPT = join(AGENT_DIR, 'ai-session-hook.mjs')
+const AI_SESSION_SETTINGS_PATH = join(AGENT_DIR, 'ai-session-settings.json')
+
+function ensureAiSessionHookFiles() {
+  ensureAgentDir()
+  const hookSrc = [
+    "import process from 'node:process'",
+    "let data = ''",
+    "process.stdin.setEncoding('utf8')",
+    "process.stdin.on('data', (c) => { data += c })",
+    'process.stdin.on(\'end\', async () => {',
+    '  try {',
+    "    const ev = JSON.parse(data || '{}')",
+    '    const url = process.env.GITDONE_URL, key = process.env.GITDONE_KEY, sessionId = process.env.GITDONE_SESSION_ID',
+    '    if (url && key && sessionId) {',
+    "      const name = ev.tool_name || 'tool'",
+    '      const o = ev.tool_output',
+    "      let out = ''",
+    "      if (typeof o === 'string') out = o",
+    "      else if (o && typeof o === 'object') out = o.text || o.stdout || o.content || JSON.stringify(o)",
+    "      out = String(out || '').slice(0, 2000)",
+    "      const inp = ev.tool_input ? JSON.stringify(ev.tool_input).slice(0, 300) : ''",
+    "      const text = name + (inp ? ' ' + inp : '') + (out ? '\\n' + out : ' ✓')",
+    "      await fetch(url + '/api/v1/agent/ai-session/events', {",
+    "        method: 'POST',",
+    "        headers: { Authorization: 'Bearer ' + key, 'Content-Type': 'application/json' },",
+    "        body: JSON.stringify({ sessionId, events: [{ role: 'TOOL_RESULT', text }] }),",
+    '      }).catch(() => {})',
+    '    }',
+    '  } catch {}',
+    '  process.exit(0)',
+    '})',
+  ].join('\n')
+  writeFileSync(AI_SESSION_HOOK_SCRIPT, hookSrc, 'utf8')
+
+  const nodePath = getNodePath()
+  const settings = {
+    hooks: {
+      PostToolUse: [
+        { matcher: '', hooks: [{ type: 'command', command: `"${nodePath}" "${AI_SESSION_HOOK_SCRIPT}"` }] },
+      ],
+    },
+  }
+  writeFileSync(AI_SESSION_SETTINGS_PATH, JSON.stringify(settings, null, 2), 'utf8')
+  return AI_SESSION_SETTINGS_PATH
+}
+
 // Run a headless Claude Code session for an `ai_run` command and stream its
 // output back. Long-running and fire-and-forget: it wires up async handlers and
 // returns immediately so the agent's snapshot loop is never blocked.
 function runAiCommand(cfg, cmd, repoPath) {
   const runId = cmd.payload?.runId
   const prompt = cmd.payload?.prompt ?? ''
+  const allowCommit = cmd.payload?.allowCommit === true
   if (!runId || !prompt) {
     reportCommandResult(cfg, cmd.id, 'error', 'invalid ai_run payload')
     return
   }
 
   const { path: claudePath, shell } = findClaude()
-  // shell:true (claude.cmd) can't carry raw newlines on the command line.
-  const promptArg = shell ? prompt.replace(/\r?\n/g, '  ') : prompt
 
   let settingsPath
   try { settingsPath = ensureAiHookFiles() } catch (e) { log(`✗ ai hook setup failed: ${e.message}`) }
 
+  // The prompt is delivered on STDIN, not as a `-p <arg>` command-line value.
+  // A multi-line, non-ASCII (Cyrillic) prompt passed as an argv element gets
+  // mangled under the claude.cmd npm shim (shell:true → cmd.exe splits/strips
+  // it), so Claude received no prompt and fell back to an empty stdin
+  // ("no stdin data received…"), then ran blind off whatever was in the repo.
+  // Piping it to stdin is robust for both the native exe and the shim.
   const args = [
-    '-p', promptArg,
+    '-p',
     '--output-format', 'stream-json',
     '--verbose',
     '--permission-mode', 'acceptEdits',
     '--allowedTools', 'Read,Edit,Write,Bash,mcp__gitdone__*',
-    '--disallowedTools', 'Bash(git commit *),Bash(git push *)',
+    // Block git commit/push unless this repo opted in (per-repo aiAutoCommit).
+    ...(allowCommit ? [] : ['--disallowedTools', 'Bash(git commit *),Bash(git push *)']),
     ...(settingsPath ? ['--settings', settingsPath] : []),
   ]
 
@@ -505,6 +575,14 @@ function runAiCommand(cfg, cmd, repoPath) {
     return
   }
 
+  // Write the prompt to stdin and close it so Claude reads it as the task.
+  // Swallow EPIPE in case the process exits before we finish writing.
+  if (child.stdin) {
+    child.stdin.on('error', () => {})
+    try { child.stdin.write(prompt); child.stdin.end() }
+    catch (e) { push('SYSTEM', `stdin write failed: ${e.message}`) }
+  }
+
   let buf = ''
   child.stdout.on('data', (d) => {
     buf += d.toString()
@@ -533,6 +611,100 @@ function runAiCommand(cfg, cmd, repoPath) {
   })
 }
 
+// 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.
+function runAiChat(cfg, cmd, repoPath) {
+  const sessionId = cmd.payload?.sessionId
+  const prompt = cmd.payload?.prompt ?? ''
+  const claudeSessionId = cmd.payload?.claudeSessionId || null
+  const allowCommit = cmd.payload?.allowCommit === true
+  if (!sessionId || !prompt) {
+    reportCommandResult(cfg, cmd.id, 'error', 'invalid ai_chat payload')
+    return
+  }
+
+  const { path: claudePath, shell } = findClaude()
+
+  let settingsPath
+  try { settingsPath = ensureAiSessionHookFiles() } catch (e) { log(`✗ ai session hook setup failed: ${e.message}`) }
+
+  const args = [
+    '-p',
+    '--output-format', 'stream-json',
+    '--verbose',
+    '--permission-mode', 'acceptEdits',
+    '--allowedTools', 'Read,Edit,Write,Bash,mcp__gitdone__*',
+    // Block git commit/push unless this repo opted in (per-repo aiAutoCommit).
+    ...(allowCommit ? [] : ['--disallowedTools', 'Bash(git commit *),Bash(git push *)']),
+    ...(claudeSessionId ? ['--resume', claudeSessionId] : []),
+    ...(settingsPath ? ['--settings', settingsPath] : []),
+  ]
+
+  const childEnv = { ...process.env, GITDONE_URL: cfg.url, GITDONE_KEY: cfg.key, GITDONE_SESSION_ID: sessionId }
+
+  // Map console kinds → session transcript roles (model text → ASSISTANT).
+  const roleFor = (kind) => (kind === 'TEXT' ? 'ASSISTANT' : kind)
+  let pending = []
+  let capturedSession = null // Claude's session id, sent (idempotently) for --resume
+  let flushing = false
+  const flush = async () => {
+    if (flushing || pending.length === 0) return
+    flushing = true
+    const batch = pending.map((e) => ({ role: roleFor(e.kind), text: e.text })); pending = []
+    await postSessionEvents(cfg, sessionId, batch, 'running', capturedSession || undefined)
+    flushing = false
+  }
+  const push = (kind, text) => { if (text != null && String(text) !== '') pending.push({ kind, text: String(text) }) }
+  const onInit = (sid) => { if (sid && !claudeSessionId) capturedSession = sid }
+  const timer = setInterval(flush, 800)
+
+  log(`▶ ai_chat ${sessionId} @ ${repoPath} (resume=${claudeSessionId ? 'yes' : 'no'}) via ${claudePath}`)
+
+  let child
+  try {
+    child = spawn(claudePath, args, { cwd: repoPath, shell, windowsHide: true, env: childEnv })
+  } catch (err) {
+    clearInterval(timer)
+    postSessionEvents(cfg, sessionId, [{ role: 'SYSTEM', text: `Грешка при стартиране: ${err.message}` }], 'error')
+    reportCommandResult(cfg, cmd.id, 'error', err.message)
+    return
+  }
+
+  if (child.stdin) {
+    child.stdin.on('error', () => {})
+    try { child.stdin.write(prompt); child.stdin.end() }
+    catch (e) { push('SYSTEM', `stdin write failed: ${e.message}`) }
+  }
+
+  let buf = ''
+  child.stdout.on('data', (d) => {
+    buf += d.toString()
+    let nl
+    while ((nl = buf.indexOf('\n')) >= 0) {
+      const line = buf.slice(0, nl).trim()
+      buf = buf.slice(nl + 1)
+      if (line) parseStreamLine(line, push, onInit)
+    }
+  })
+  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)
+    if (buf.trim()) parseStreamLine(buf.trim(), push, onInit)
+    await flush()
+    const ok = code === 0
+    await postSessionEvents(
+      cfg, sessionId,
+      ok ? [] : [{ role: 'SYSTEM', text: `✗ Ходът приключи с код ${code}.` }],
+      ok ? 'idle' : 'error',
+      capturedSession || undefined,
+    )
+    reportCommandResult(cfg, cmd.id, ok ? 'done' : 'error', `exit ${code}`)
+    log(`■ ai_chat ${sessionId} приключи (code ${code})`)
+  })
+}
+
 async function executeCommand(cfg, cmd, repoPath) {
   // ai_run is long-running + streaming — launch it in the background and return
   // so the snapshot loop keeps going. It reports its own result on exit.
@@ -540,6 +712,11 @@ async function executeCommand(cfg, cmd, repoPath) {
     runAiCommand(cfg, cmd, repoPath)
     return
   }
+  // ai_chat — one interactive turn, same fire-and-forget model.
+  if (cmd.type === 'ai_chat') {
+    runAiChat(cfg, cmd, repoPath)
+    return
+  }
 
   let result = 'ok'
   let status = 'done'

package/package.json

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