specrails-hub 0.1.0

package/server/chat-manager.test.ts

@@ -0,0 +1,216 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest'
+import { EventEmitter } from 'events'
+import { Readable } from 'stream'
+
+// Mock child_process before importing chat-manager
+vi.mock('child_process', () => ({
+  spawn: vi.fn(),
+  execSync: vi.fn(),
+}))
+
+vi.mock('tree-kill', () => ({
+  default: vi.fn(),
+}))
+
+import { spawn as mockSpawn, execSync as mockExecSync } from 'child_process'
+import treeKill from 'tree-kill'
+import { ChatManager } from './chat-manager'
+import { initDb, createConversation, getConversation } from './db'
+import type { DbInstance } from './db'
+
+function createMockChildProcess() {
+  const child = new EventEmitter() as any
+  child.stdout = new Readable({ read() {} })
+  child.stderr = new Readable({ read() {} })
+  child.pid = 42000
+  child.kill = vi.fn()
+  return child
+}
+
+function pushLine(child: any, line: string) {
+  child.stdout.push(line + '\n')
+}
+
+function finishProcess(child: any, code: number): Promise<void> {
+  // Push EOF on stdout, then wait for readline to drain before emitting close.
+  // readline processes data asynchronously; setImmediate ensures all buffered
+  // line events have fired before the close handler runs.
+  return new Promise((resolve) => {
+    child.stdout.push(null)
+    setImmediate(() => {
+      child.emit('close', code)
+      resolve()
+    })
+  })
+}
+
+function assistantEvent(text: string): string {
+  return JSON.stringify({
+    type: 'assistant',
+    message: { content: [{ type: 'text', text }] },
+  })
+}
+
+function resultEvent(sessionId: string): string {
+  return JSON.stringify({ type: 'result', session_id: sessionId })
+}
+
+function getBroadcastedByType(broadcast: ReturnType<typeof vi.fn>, type: string) {
+  return broadcast.mock.calls
+    .map((args) => args[0] as Record<string, unknown>)
+    .filter((msg) => msg.type === type)
+}
+
+const TEST_CONV_ID = 'conv-test-001'
+
+describe('ChatManager', () => {
+  let db: DbInstance
+  let broadcast: ReturnType<typeof vi.fn>
+  let cm: ChatManager
+
+  beforeEach(() => {
+    vi.resetAllMocks()
+    vi.mocked(mockExecSync).mockReturnValue(Buffer.from('/usr/bin/claude'))
+    db = initDb(':memory:')
+    broadcast = vi.fn()
+    cm = new ChatManager(broadcast, db)
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  function setupConversation(model = 'claude-sonnet-4-5'): string {
+    createConversation(db, { id: TEST_CONV_ID, model })
+    return TEST_CONV_ID
+  }
+
+  // ─── Test 1: sendMessage persists user message and triggers chat_stream + chat_done ─
+
+  it('sendMessage persists user message and triggers chat_stream + chat_done broadcasts', async () => {
+    const convId = setupConversation()
+    const child = createMockChildProcess()
+    vi.mocked(mockSpawn).mockReturnValue(child as any)
+
+    const sendPromise = cm.sendMessage(convId, 'Hello world')
+
+    pushLine(child, assistantEvent('Hello '))
+    pushLine(child, assistantEvent('back!'))
+    pushLine(child, resultEvent('sess-abc'))
+    await finishProcess(child, 0)
+
+    await sendPromise
+
+    const streamMsgs = getBroadcastedByType(broadcast, 'chat_stream')
+    expect(streamMsgs.length).toBeGreaterThan(0)
+    expect(streamMsgs[0].conversationId).toBe(convId)
+    expect(streamMsgs[0].delta).toBeTruthy()
+
+    const doneMsgs = getBroadcastedByType(broadcast, 'chat_done')
+    expect(doneMsgs).toHaveLength(1)
+    expect(doneMsgs[0].conversationId).toBe(convId)
+    expect(doneMsgs[0].fullText).toBe('Hello back!')
+  })
+
+  // ─── Test 2: abort triggers chat_error { error: 'aborted' } ───────────────
+
+  it('abort triggers chat_error with aborted reason', async () => {
+    const convId = setupConversation()
+    const child = createMockChildProcess()
+    vi.mocked(mockSpawn).mockReturnValue(child as any)
+
+    const sendPromise = cm.sendMessage(convId, 'Do something')
+
+    expect(cm.isActive(convId)).toBe(true)
+    cm.abort(convId)
+
+    await finishProcess(child, 1)
+    await sendPromise
+
+    const errorMsgs = getBroadcastedByType(broadcast, 'chat_error')
+    expect(errorMsgs.length).toBeGreaterThan(0)
+    expect(errorMsgs[0].conversationId).toBe(convId)
+    expect(errorMsgs[0].error).toBe('aborted')
+    expect(vi.mocked(treeKill)).toHaveBeenCalledWith(child.pid, 'SIGTERM')
+  })
+
+  // ─── Test 3: :::command block triggers chat_command_proposal ──────────────
+
+  it(':::command block in response triggers chat_command_proposal broadcast', async () => {
+    const convId = setupConversation()
+    const child = createMockChildProcess()
+    vi.mocked(mockSpawn).mockReturnValue(child as any)
+
+    const sendPromise = cm.sendMessage(convId, 'What should I do?')
+
+    const responseWithCommand = 'You should run:\n:::command\n/sr:implement #5\n:::\nThis will help.'
+    pushLine(child, assistantEvent(responseWithCommand))
+    pushLine(child, resultEvent('sess-xyz'))
+    await finishProcess(child, 0)
+
+    await sendPromise
+
+    const proposalMsgs = getBroadcastedByType(broadcast, 'chat_command_proposal')
+    expect(proposalMsgs).toHaveLength(1)
+    expect(proposalMsgs[0].conversationId).toBe(convId)
+    expect(proposalMsgs[0].command).toBe('/sr:implement #5')
+  })
+
+  // ─── Test 4: duplicate :::command blocks not emitted twice ────────────────
+
+  it('duplicate :::command blocks in same response are not emitted twice', async () => {
+    const convId = setupConversation()
+    const child = createMockChildProcess()
+    vi.mocked(mockSpawn).mockReturnValue(child as any)
+
+    const sendPromise = cm.sendMessage(convId, 'Suggest something')
+
+    // Emit the same command twice across two chunks (buffer accumulates)
+    pushLine(child, assistantEvent(':::command\n/sr:implement #1\n:::'))
+    pushLine(child, assistantEvent(' and again :::command\n/sr:implement #1\n:::'))
+    pushLine(child, resultEvent('sess-dup'))
+    await finishProcess(child, 0)
+
+    await sendPromise
+
+    const proposalMsgs = getBroadcastedByType(broadcast, 'chat_command_proposal')
+    expect(proposalMsgs).toHaveLength(1)
+  })
+
+  // ─── Test 5: session_id stored in DB after first turn ────────────────────
+
+  it('session_id is stored in DB after first turn completes', async () => {
+    const convId = setupConversation()
+    const child = createMockChildProcess()
+    vi.mocked(mockSpawn).mockReturnValue(child as any)
+
+    const sendPromise = cm.sendMessage(convId, 'Hello')
+
+    pushLine(child, assistantEvent('Hi there'))
+    pushLine(child, resultEvent('sess-stored'))
+    await finishProcess(child, 0)
+
+    await sendPromise
+
+    const conv = getConversation(db, convId)
+    expect(conv?.session_id).toBe('sess-stored')
+  })
+
+  // ─── Test 6: isActive returns true while running, false after close ───────
+
+  it('isActive returns true while process is running and false after close', async () => {
+    const convId = setupConversation()
+    const child = createMockChildProcess()
+    vi.mocked(mockSpawn).mockReturnValue(child as any)
+
+    const sendPromise = cm.sendMessage(convId, 'Are you active?')
+    expect(cm.isActive(convId)).toBe(true)
+
+    pushLine(child, assistantEvent('Yes'))
+    pushLine(child, resultEvent('sess-active'))
+    await finishProcess(child, 0)
+
+    await sendPromise
+    expect(cm.isActive(convId)).toBe(false)
+  })
+})

package/server/chat-manager.ts

@@ -0,0 +1,289 @@
+import { spawn, execSync, ChildProcess } from 'child_process'
+import { createInterface } from 'readline'
+import treeKill from 'tree-kill'
+import type { WsMessage } from './types'
+import type { DbInstance } from './db'
+import { getConversation, addMessage, updateConversation } from './db'
+
+const SYSTEM_PROMPT =
+  'You are a project assistant with full access to this repository via Claude Code. ' +
+  'You can help answer questions about the codebase, explain SpecRails concepts, and suggest commands to run. ' +
+  'When you want to suggest a SpecRails command for the user to execute, wrap it in a command block like this: ' +
+  ':::command\n/sr:implement #42\n::: ' +
+  'The user will be prompted to confirm before the command runs.'
+
+function claudeOnPath(): boolean {
+  try {
+    execSync('which claude', { stdio: 'ignore' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+function extractTextFromEvent(event: Record<string, unknown>): string | null {
+  const type = event.type as string
+  if (type === 'assistant') {
+    const content = event.message as { content?: Array<{ type: string; text?: string }> } | undefined
+    const texts = (content?.content ?? [])
+      .filter((c) => c.type === 'text')
+      .map((c) => c.text ?? '')
+    return texts.join('') || null
+  }
+  return null
+}
+
+function extractCommandProposals(text: string): string[] {
+  const regex = /:::command\s*\n([\s\S]*?):::/g
+  const results: string[] = []
+  let match: RegExpExecArray | null
+  while ((match = regex.exec(text)) !== null) {
+    results.push(match[1].trim())
+  }
+  return results
+}
+
+// ─── ChatManager ──────────────────────────────────────────────────────────────
+
+export class ChatManager {
+  private _broadcast: (msg: WsMessage) => void
+  private _db: DbInstance
+  private _activeProcesses: Map<string, ChildProcess>
+  private _buffers: Map<string, string>
+  private _emittedProposals: Map<string, Set<string>>
+  private _abortingConversations: Set<string>
+
+  private _cwd: string | undefined
+
+  constructor(broadcast: (msg: WsMessage) => void, db: DbInstance, cwd?: string) {
+    this._broadcast = broadcast
+    this._db = db
+    this._cwd = cwd
+    this._activeProcesses = new Map()
+    this._buffers = new Map()
+    this._emittedProposals = new Map()
+    this._abortingConversations = new Set()
+  }
+
+  isActive(conversationId: string): boolean {
+    return this._activeProcesses.has(conversationId)
+  }
+
+  async sendMessage(conversationId: string, userText: string): Promise<void> {
+    if (this._activeProcesses.has(conversationId)) {
+      console.warn(`[ChatManager] conversation ${conversationId} already has an active stream`)
+      return
+    }
+
+    if (!claudeOnPath()) {
+      this._broadcast({
+        type: 'chat_error',
+        conversationId,
+        error: 'CLAUDE_NOT_FOUND',
+        timestamp: new Date().toISOString(),
+      })
+      return
+    }
+
+    const conversation = getConversation(this._db, conversationId)
+    if (!conversation) {
+      console.warn(`[ChatManager] conversation ${conversationId} not found`)
+      return
+    }
+
+    // Check if this is turn 1 (session_id was null before this message)
+    const isFirstTurn = conversation.session_id === null
+
+    // Persist user message
+    addMessage(this._db, { conversation_id: conversationId, role: 'user', content: userText })
+
+    // Build spawn args
+    const args: string[] = [
+      '--model', conversation.model,
+      '--dangerously-skip-permissions',
+      '--output-format', 'stream-json',
+      '--verbose',
+      '--system-prompt', SYSTEM_PROMPT,
+      '-p', userText,
+    ]
+
+    if (conversation.session_id) {
+      args.push('--resume', conversation.session_id)
+    }
+
+    const child = spawn('claude', args, {
+      env: process.env,
+      shell: false,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      cwd: this._cwd,
+    })
+
+    this._activeProcesses.set(conversationId, child)
+    this._buffers.set(conversationId, '')
+    this._emittedProposals.set(conversationId, new Set())
+
+    let capturedSessionId: string | null = null
+
+    const stdoutReader = createInterface({ input: child.stdout!, crlfDelay: Infinity })
+
+    stdoutReader.on('line', (line) => {
+      let parsed: Record<string, unknown> | null = null
+      try { parsed = JSON.parse(line) } catch { /* skip non-JSON */ }
+      if (!parsed) return
+
+      const eventType = parsed.type as string
+
+      if (eventType === 'result') {
+        const sid = parsed.session_id as string | undefined
+        if (sid) capturedSessionId = sid
+      }
+
+      const newText = extractTextFromEvent(parsed)
+      if (newText) {
+        const prev = this._buffers.get(conversationId) ?? ''
+        const updated = prev + newText
+        this._buffers.set(conversationId, updated)
+
+        this._broadcast({
+          type: 'chat_stream',
+          conversationId,
+          delta: newText,
+          timestamp: new Date().toISOString(),
+        })
+
+        // Check for new command proposals
+        const proposals = extractCommandProposals(updated)
+        const emitted = this._emittedProposals.get(conversationId)
+        if (emitted) {
+          for (const proposal of proposals) {
+            if (!emitted.has(proposal)) {
+              emitted.add(proposal)
+              this._broadcast({
+                type: 'chat_command_proposal',
+                conversationId,
+                command: proposal,
+                timestamp: new Date().toISOString(),
+              })
+            }
+          }
+        }
+      }
+    })
+
+    return new Promise<void>((resolve) => {
+      child.on('close', (code) => {
+        const fullText = this._buffers.get(conversationId) ?? ''
+        const wasAborting = this._abortingConversations.has(conversationId)
+
+        // Clean up tracking state
+        this._activeProcesses.delete(conversationId)
+        this._buffers.delete(conversationId)
+        this._emittedProposals.delete(conversationId)
+        this._abortingConversations.delete(conversationId)
+
+        if (wasAborting) {
+          // abort already emitted chat_error
+          resolve()
+          return
+        }
+
+        if (code === 0) {
+          // Persist assistant message
+          if (fullText) {
+            addMessage(this._db, { conversation_id: conversationId, role: 'assistant', content: fullText })
+          }
+
+          // Update session_id
+          if (capturedSessionId) {
+            updateConversation(this._db, conversationId, { session_id: capturedSessionId })
+          }
+
+          this._broadcast({
+            type: 'chat_done',
+            conversationId,
+            fullText,
+            timestamp: new Date().toISOString(),
+          })
+
+          // Auto-title on first turn
+          if (isFirstTurn && fullText) {
+            this._autoTitle(conversationId, userText, fullText)
+          }
+        } else {
+          this._broadcast({
+            type: 'chat_error',
+            conversationId,
+            error: `Process exited with code ${code ?? 'unknown'}`,
+            timestamp: new Date().toISOString(),
+          })
+        }
+
+        resolve()
+      })
+    })
+  }
+
+  abort(conversationId: string): void {
+    const child = this._activeProcesses.get(conversationId)
+    if (!child || !child.pid) return
+
+    this._abortingConversations.add(conversationId)
+    treeKill(child.pid, 'SIGTERM')
+
+    this._broadcast({
+      type: 'chat_error',
+      conversationId,
+      error: 'aborted',
+      timestamp: new Date().toISOString(),
+    })
+  }
+
+  private _autoTitle(conversationId: string, firstUserMsg: string, firstResponse: string): void {
+    try {
+      const titlePrompt =
+        `Generate a 4-6 word title for this conversation. Output ONLY the title text, no quotes or punctuation.\n\n` +
+        `User: ${firstUserMsg.slice(0, 200)}\nAssistant: ${firstResponse.slice(0, 300)}`
+
+      const child = spawn('claude', [
+        '--dangerously-skip-permissions',
+        '--output-format', 'stream-json',
+        '--verbose',
+        '-p', titlePrompt,
+      ], {
+        env: process.env,
+        shell: false,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        cwd: this._cwd,
+      })
+
+      let titleText = ''
+      const reader = createInterface({ input: child.stdout!, crlfDelay: Infinity })
+
+      reader.on('line', (line) => {
+        let parsed: Record<string, unknown> | null = null
+        try { parsed = JSON.parse(line) } catch { return }
+        if (!parsed) return
+
+        // Take only the first assistant event's text
+        if (!titleText) {
+          const text = extractTextFromEvent(parsed)
+          if (text) titleText = text.trim()
+        }
+      })
+
+      child.on('close', (code) => {
+        if (code === 0 && titleText) {
+          updateConversation(this._db, conversationId, { title: titleText })
+          this._broadcast({
+            type: 'chat_title_update',
+            conversationId,
+            title: titleText,
+            timestamp: new Date().toISOString(),
+          })
+        }
+      })
+    } catch {
+      // auto-title is fire-and-forget; failure is silent
+    }
+  }
+}