specrails-hub 0.1.0

package/server/proposal-manager.test.ts

@@ -0,0 +1,410 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest'
+import { EventEmitter } from 'events'
+import { Readable } from 'stream'
+
+vi.mock('child_process', () => ({
+  spawn: vi.fn(),
+  execSync: vi.fn(),
+}))
+
+vi.mock('tree-kill', () => ({
+  default: vi.fn(),
+}))
+
+// Mock command-resolver to return a resolved prompt (different from raw command)
+vi.mock('./command-resolver', () => ({
+  resolveCommand: vi.fn((command: string) => 'Resolved prompt for: ' + command),
+}))
+
+import { spawn as mockSpawn } from 'child_process'
+import treeKill from 'tree-kill'
+import { ProposalManager } from './proposal-manager'
+import { initDb, createProposal, getProposal } from './db'
+import type { DbInstance } from './db'
+
+// ─── Mock helpers ─────────────────────────────────────────────────────────────
+
+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> {
+  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_PROPOSAL_ID = 'proposal-test-001'
+const TEST_CWD = '/fake/project/path'
+
+// ─── Test suite ───────────────────────────────────────────────────────────────
+
+describe('ProposalManager', () => {
+  let db: DbInstance
+  let broadcast: ReturnType<typeof vi.fn>
+  let pm: ProposalManager
+
+  beforeEach(() => {
+    vi.resetAllMocks()
+    db = initDb(':memory:')
+    broadcast = vi.fn()
+    pm = new ProposalManager(broadcast, db, TEST_CWD)
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  function setupProposal(id = TEST_PROPOSAL_ID, idea = 'Add dark mode') {
+    createProposal(db, { id, idea })
+    return id
+  }
+
+  // ─── startExploration ──────────────────────────────────────────────────────
+
+  describe('startExploration', () => {
+    it('spawns claude with correct args', async () => {
+      const proposalId = setupProposal()
+      const child = createMockChildProcess()
+      vi.mocked(mockSpawn).mockReturnValue(child as any)
+
+      const explorePromise = pm.startExploration(proposalId, 'Add dark mode')
+      await finishProcess(child, 0)
+      await explorePromise
+
+      expect(vi.mocked(mockSpawn)).toHaveBeenCalledWith(
+        'claude',
+        expect.arrayContaining([
+          '--dangerously-skip-permissions',
+          '--output-format', 'stream-json',
+          '--verbose',
+          '-p',
+        ]),
+        expect.objectContaining({ cwd: TEST_CWD })
+      )
+    })
+
+    it('broadcasts proposal_stream deltas as text arrives', async () => {
+      const proposalId = setupProposal()
+      const child = createMockChildProcess()
+      vi.mocked(mockSpawn).mockReturnValue(child as any)
+
+      const explorePromise = pm.startExploration(proposalId, 'Add dark mode')
+
+      pushLine(child, assistantEvent('## Feature Title\n'))
+      pushLine(child, assistantEvent('Add Dark Mode'))
+      pushLine(child, resultEvent('sess-001'))
+      await finishProcess(child, 0)
+      await explorePromise
+
+      const streamMsgs = getBroadcastedByType(broadcast, 'proposal_stream')
+      expect(streamMsgs.length).toBeGreaterThan(0)
+      expect(streamMsgs[0].proposalId).toBe(proposalId)
+      expect(streamMsgs[0].delta).toBeTruthy()
+    })
+
+    it('captures session_id from result event', async () => {
+      const proposalId = setupProposal()
+      const child = createMockChildProcess()
+      vi.mocked(mockSpawn).mockReturnValue(child as any)
+
+      const explorePromise = pm.startExploration(proposalId, 'Add dark mode')
+      pushLine(child, assistantEvent('Some content'))
+      pushLine(child, resultEvent('sess-captured-001'))
+      await finishProcess(child, 0)
+      await explorePromise
+
+      const row = getProposal(db, proposalId)!
+      expect(row.session_id).toBe('sess-captured-001')
+    })
+
+    it('broadcasts proposal_ready with full markdown on close(0)', async () => {
+      const proposalId = setupProposal()
+      const child = createMockChildProcess()
+      vi.mocked(mockSpawn).mockReturnValue(child as any)
+
+      const explorePromise = pm.startExploration(proposalId, 'Add dark mode')
+      pushLine(child, assistantEvent('## Feature Title\nAdd Dark Mode'))
+      pushLine(child, resultEvent('sess-002'))
+      await finishProcess(child, 0)
+      await explorePromise
+
+      const readyMsgs = getBroadcastedByType(broadcast, 'proposal_ready')
+      expect(readyMsgs).toHaveLength(1)
+      expect(readyMsgs[0].proposalId).toBe(proposalId)
+      expect(readyMsgs[0].markdown).toContain('Add Dark Mode')
+    })
+
+    it('updates proposal status to review on success', async () => {
+      const proposalId = setupProposal()
+      const child = createMockChildProcess()
+      vi.mocked(mockSpawn).mockReturnValue(child as any)
+
+      const explorePromise = pm.startExploration(proposalId, 'Add dark mode')
+      pushLine(child, assistantEvent('Content'))
+      pushLine(child, resultEvent('sess-003'))
+      await finishProcess(child, 0)
+      await explorePromise
+
+      const row = getProposal(db, proposalId)!
+      expect(row.status).toBe('review')
+    })
+
+    it('broadcasts proposal_error and resets status to input on close(non-0)', async () => {
+      const proposalId = setupProposal()
+      const child = createMockChildProcess()
+      vi.mocked(mockSpawn).mockReturnValue(child as any)
+
+      const explorePromise = pm.startExploration(proposalId, 'Add dark mode')
+      await finishProcess(child, 1)
+      await explorePromise
+
+      const errorMsgs = getBroadcastedByType(broadcast, 'proposal_error')
+      expect(errorMsgs).toHaveLength(1)
+      expect(errorMsgs[0].proposalId).toBe(proposalId)
+
+      const row = getProposal(db, proposalId)!
+      expect(row.status).toBe('input')
+    })
+
+    it('does nothing if proposal not found in DB', async () => {
+      vi.mocked(mockSpawn)
+
+      await pm.startExploration('nonexistent-id', 'some idea')
+
+      const errorMsgs = getBroadcastedByType(broadcast, 'proposal_error')
+      expect(errorMsgs).toHaveLength(1)
+      expect(vi.mocked(mockSpawn)).not.toHaveBeenCalled()
+    })
+  })
+
+  // ─── sendRefinement ────────────────────────────────────────────────────────
+
+  describe('sendRefinement', () => {
+    it('spawns with --resume <session_id>', async () => {
+      const proposalId = setupProposal()
+      // Set up proposal in review state with session_id
+      const db2 = db
+      db2.prepare("UPDATE proposals SET status = 'review', session_id = ? WHERE id = ?")
+        .run('sess-existing', proposalId)
+
+      const child = createMockChildProcess()
+      vi.mocked(mockSpawn).mockReturnValue(child as any)
+
+      const refinePromise = pm.sendRefinement(proposalId, 'Make it simpler')
+      pushLine(child, assistantEvent('Simplified'))
+      pushLine(child, resultEvent('sess-refined'))
+      await finishProcess(child, 0)
+      await refinePromise
+
+      const spawnArgs = vi.mocked(mockSpawn).mock.calls[0][1] as string[]
+      expect(spawnArgs).toContain('--resume')
+      expect(spawnArgs).toContain('sess-existing')
+    })
+
+    it('broadcasts proposal_refined on success', async () => {
+      const proposalId = setupProposal()
+      db.prepare("UPDATE proposals SET status = 'review', session_id = 'sess-r1' WHERE id = ?").run(proposalId)
+
+      const child = createMockChildProcess()
+      vi.mocked(mockSpawn).mockReturnValue(child as any)
+
+      const refinePromise = pm.sendRefinement(proposalId, 'Refine this')
+      pushLine(child, assistantEvent('Refined content'))
+      pushLine(child, resultEvent('sess-r2'))
+      await finishProcess(child, 0)
+      await refinePromise
+
+      const refinedMsgs = getBroadcastedByType(broadcast, 'proposal_refined')
+      expect(refinedMsgs).toHaveLength(1)
+      expect(refinedMsgs[0].proposalId).toBe(proposalId)
+      expect(refinedMsgs[0].markdown).toContain('Refined content')
+    })
+
+    it('returns early and broadcasts error if session_id is null', async () => {
+      const proposalId = setupProposal()
+      // session_id is null by default
+
+      await pm.sendRefinement(proposalId, 'Some feedback')
+
+      const errorMsgs = getBroadcastedByType(broadcast, 'proposal_error')
+      expect(errorMsgs).toHaveLength(1)
+      expect(vi.mocked(mockSpawn)).not.toHaveBeenCalled()
+    })
+  })
+
+  // ─── createIssue ──────────────────────────────────────────────────────────
+
+  describe('createIssue', () => {
+    it('extracts GitHub URL from response and broadcasts proposal_issue_created', async () => {
+      const proposalId = setupProposal()
+      db.prepare("UPDATE proposals SET status = 'review', session_id = 'sess-ci1' WHERE id = ?").run(proposalId)
+
+      const child = createMockChildProcess()
+      vi.mocked(mockSpawn).mockReturnValue(child as any)
+
+      const issuePromise = pm.createIssue(proposalId)
+      pushLine(child, assistantEvent('I created the issue.\nhttps://github.com/owner/repo/issues/99'))
+      pushLine(child, resultEvent('sess-ci2'))
+      await finishProcess(child, 0)
+      await issuePromise
+
+      const issueMsgs = getBroadcastedByType(broadcast, 'proposal_issue_created')
+      expect(issueMsgs).toHaveLength(1)
+      expect(issueMsgs[0].proposalId).toBe(proposalId)
+      expect(issueMsgs[0].issueUrl).toBe('https://github.com/owner/repo/issues/99')
+    })
+
+    it('broadcasts proposal_error if no GitHub URL found in response', async () => {
+      const proposalId = setupProposal()
+      db.prepare("UPDATE proposals SET status = 'review', session_id = 'sess-ci3' WHERE id = ?").run(proposalId)
+
+      const child = createMockChildProcess()
+      vi.mocked(mockSpawn).mockReturnValue(child as any)
+
+      const issuePromise = pm.createIssue(proposalId)
+      pushLine(child, assistantEvent('I could not create the issue. GitHub CLI not found.'))
+      pushLine(child, resultEvent('sess-ci4'))
+      await finishProcess(child, 0)
+      await issuePromise
+
+      const errorMsgs = getBroadcastedByType(broadcast, 'proposal_error')
+      expect(errorMsgs).toHaveLength(1)
+      expect(errorMsgs[0].proposalId).toBe(proposalId)
+    })
+
+    it('updates proposal status to created when URL found', async () => {
+      const proposalId = setupProposal()
+      db.prepare("UPDATE proposals SET status = 'review', session_id = 'sess-ci5' WHERE id = ?").run(proposalId)
+
+      const child = createMockChildProcess()
+      vi.mocked(mockSpawn).mockReturnValue(child as any)
+
+      const issuePromise = pm.createIssue(proposalId)
+      pushLine(child, assistantEvent('Done. https://github.com/owner/repo/issues/123'))
+      pushLine(child, resultEvent('sess-ci6'))
+      await finishProcess(child, 0)
+      await issuePromise
+
+      const row = getProposal(db, proposalId)!
+      expect(row.status).toBe('created')
+      expect(row.issue_url).toBe('https://github.com/owner/repo/issues/123')
+    })
+  })
+
+  // ─── cancel ───────────────────────────────────────────────────────────────
+
+  describe('cancel', () => {
+    it('calls treeKill with SIGTERM on active process', async () => {
+      const proposalId = setupProposal()
+      const child = createMockChildProcess()
+      vi.mocked(mockSpawn).mockReturnValue(child as any)
+
+      // Start exploration to create an active process
+      const explorePromise = pm.startExploration(proposalId, 'Add dark mode')
+
+      pm.cancel(proposalId)
+
+      expect(vi.mocked(treeKill)).toHaveBeenCalledWith(child.pid, 'SIGTERM')
+
+      // Let the process close to avoid open handles
+      await finishProcess(child, 1)
+      await explorePromise
+    })
+
+    it('updates proposal status to cancelled', () => {
+      const proposalId = setupProposal()
+
+      pm.cancel(proposalId)
+
+      const row = getProposal(db, proposalId)!
+      expect(row.status).toBe('cancelled')
+    })
+
+    it('broadcasts proposal_error with error: cancelled', () => {
+      const proposalId = setupProposal()
+
+      pm.cancel(proposalId)
+
+      const errorMsgs = getBroadcastedByType(broadcast, 'proposal_error')
+      expect(errorMsgs).toHaveLength(1)
+      expect(errorMsgs[0].error).toBe('cancelled')
+    })
+
+    it('does nothing if no active process (cancel still updates DB)', () => {
+      const proposalId = setupProposal()
+
+      pm.cancel(proposalId)
+
+      expect(vi.mocked(treeKill)).not.toHaveBeenCalled()
+      // DB update and broadcast still happen
+      expect(getProposal(db, proposalId)!.status).toBe('cancelled')
+    })
+  })
+
+  // ─── isActive ─────────────────────────────────────────────────────────────
+
+  describe('isActive', () => {
+    it('returns false before exploration starts', () => {
+      const proposalId = setupProposal()
+      expect(pm.isActive(proposalId)).toBe(false)
+    })
+
+    it('returns true while exploration is running', () => {
+      const proposalId = setupProposal()
+      const child = createMockChildProcess()
+      vi.mocked(mockSpawn).mockReturnValue(child as any)
+
+      pm.startExploration(proposalId, 'Add dark mode')
+      expect(pm.isActive(proposalId)).toBe(true)
+
+      // Cleanup
+      child.stdout.push(null)
+      child.emit('close', 0)
+    })
+
+    it('returns false after exploration completes', async () => {
+      const proposalId = setupProposal()
+      const child = createMockChildProcess()
+      vi.mocked(mockSpawn).mockReturnValue(child as any)
+
+      const explorePromise = pm.startExploration(proposalId, 'Add dark mode')
+      pushLine(child, assistantEvent('Content'))
+      pushLine(child, resultEvent('sess-x'))
+      await finishProcess(child, 0)
+      await explorePromise
+
+      expect(pm.isActive(proposalId)).toBe(false)
+    })
+  })
+})

package/server/proposal-manager.ts

@@ -0,0 +1,285 @@
+import { spawn, ChildProcess } from 'child_process'
+import { createInterface } from 'readline'
+import treeKill from 'tree-kill'
+import type { WsMessage } from './types'
+import type { DbInstance } from './db'
+import {
+  getProposal,
+  updateProposal,
+} from './db'
+import { resolveCommand } from './command-resolver'
+
+// ─── ProposalManager ──────────────────────────────────────────────────────────
+
+export class ProposalManager {
+  private _broadcast: (msg: WsMessage) => void
+  private _db: DbInstance
+  private _cwd: string
+  private _activeProcesses: Map<string, ChildProcess>
+  private _buffers: Map<string, string>
+
+  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()
+  }
+
+  isActive(proposalId: string): boolean {
+    return this._activeProcesses.has(proposalId)
+  }
+
+  async startExploration(proposalId: string, idea: string): Promise<void> {
+    const proposal = getProposal(this._db, proposalId)
+    if (!proposal) {
+      this._broadcastError(proposalId, 'Proposal not found')
+      return
+    }
+
+    // Resolve the command file — error if not installed
+    const rawCommand = `/sr:propose-feature ${idea}`
+    const prompt = resolveCommand(rawCommand, this._cwd)
+    if (prompt === rawCommand) {
+      updateProposal(this._db, proposalId, { status: 'cancelled' })
+      this._broadcastError(proposalId, 'This project does not have the /sr:propose-feature command installed. Run "npx specrails" to update.')
+      return
+    }
+
+    updateProposal(this._db, proposalId, { status: 'exploring' })
+
+    const args = [
+      '--dangerously-skip-permissions',
+      '--output-format', 'stream-json',
+      '--verbose',
+      '-p', prompt,
+    ]
+
+    await this._runProcess(proposalId, args, (fullText, sessionId) => {
+      updateProposal(this._db, proposalId, {
+        status: 'review',
+        result_markdown: fullText,
+        ...(sessionId ? { session_id: sessionId } : {}),
+      })
+      this._broadcast({
+        type: 'proposal_ready',
+        projectId: '',
+        proposalId,
+        markdown: fullText,
+        timestamp: new Date().toISOString(),
+      })
+    }, () => {
+      updateProposal(this._db, proposalId, { status: 'input' })
+      this._broadcastError(proposalId, 'Exploration failed')
+    })
+  }
+
+  async sendRefinement(proposalId: string, feedback: string): Promise<void> {
+    const proposal = getProposal(this._db, proposalId)
+    if (!proposal) {
+      this._broadcastError(proposalId, 'Proposal not found')
+      return
+    }
+
+    if (!proposal.session_id) {
+      this._broadcastError(proposalId, 'No session available for refinement')
+      return
+    }
+
+    updateProposal(this._db, proposalId, { status: 'refining' })
+
+    const args = [
+      '--dangerously-skip-permissions',
+      '--output-format', 'stream-json',
+      '--verbose',
+      '--resume', proposal.session_id,
+      '-p', feedback,
+    ]
+
+    await this._runProcess(proposalId, args, (fullText, sessionId) => {
+      updateProposal(this._db, proposalId, {
+        status: 'review',
+        result_markdown: fullText,
+        ...(sessionId ? { session_id: sessionId } : {}),
+      })
+      this._broadcast({
+        type: 'proposal_refined',
+        projectId: '',
+        proposalId,
+        markdown: fullText,
+        timestamp: new Date().toISOString(),
+      })
+    }, () => {
+      updateProposal(this._db, proposalId, { status: 'review' })
+      this._broadcastError(proposalId, 'Refinement failed')
+    })
+  }
+
+  async createIssue(proposalId: string): Promise<void> {
+    const proposal = getProposal(this._db, proposalId)
+    if (!proposal) {
+      this._broadcastError(proposalId, 'Proposal not found')
+      return
+    }
+
+    if (!proposal.session_id) {
+      this._broadcastError(proposalId, 'No session available for issue creation')
+      return
+    }
+
+    updateProposal(this._db, proposalId, { status: 'refining' })
+
+    const prompt =
+      "Based on the proposal above, create a GitHub Issue with the label 'user-proposed'. " +
+      "Output only the URL of the created issue on the last line of your response."
+
+    const args = [
+      '--dangerously-skip-permissions',
+      '--output-format', 'stream-json',
+      '--verbose',
+      '--resume', proposal.session_id,
+      '-p', prompt,
+    ]
+
+    await this._runProcess(proposalId, args, (fullText, sessionId) => {
+      const match = fullText.match(/https:\/\/github\.com\/[^\s]+\/issues\/\d+/)
+      const issueUrl = match ? match[0] : null
+
+      if (issueUrl) {
+        updateProposal(this._db, proposalId, {
+          status: 'created',
+          issue_url: issueUrl,
+          ...(sessionId ? { session_id: sessionId } : {}),
+        })
+        this._broadcast({
+          type: 'proposal_issue_created',
+          projectId: '',
+          proposalId,
+          issueUrl,
+          timestamp: new Date().toISOString(),
+        })
+      } else {
+        updateProposal(this._db, proposalId, { status: 'review' })
+        this._broadcastError(
+          proposalId,
+          'Issue creation failed — GitHub CLI may not be available or not authenticated'
+        )
+      }
+    }, () => {
+      updateProposal(this._db, proposalId, { status: 'review' })
+      this._broadcastError(proposalId, 'Issue creation failed')
+    })
+  }
+
+  cancel(proposalId: string): void {
+    const child = this._activeProcesses.get(proposalId)
+    if (child?.pid) {
+      treeKill(child.pid, 'SIGTERM')
+    }
+    updateProposal(this._db, proposalId, { status: 'cancelled' })
+    this._broadcast({
+      type: 'proposal_error',
+      projectId: '',
+      proposalId,
+      error: 'cancelled',
+      timestamp: new Date().toISOString(),
+    })
+  }
+
+  // ─── Private helpers ───────────────────────────────────────────────────────
+
+  private async _runProcess(
+    proposalId: string,
+    args: string[],
+    onSuccess: (fullText: string, sessionId: string | null) => void,
+    onError: () => void
+  ): Promise<void> {
+    const child = spawn('claude', args, {
+      env: process.env,
+      shell: false,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      cwd: this._cwd,
+    })
+
+    this._activeProcesses.set(proposalId, child)
+    this._buffers.set(proposalId, '')
+
+    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
+      }
+
+      if (eventType === 'assistant') {
+        const msg = parsed.message as { content?: Array<{ type: string; text?: string; name?: string }> } | undefined
+        const blocks = msg?.content ?? []
+
+        // Extract text from text blocks (skip thinking blocks)
+        const texts = blocks
+          .filter((c) => c.type === 'text')
+          .map((c) => c.text ?? '')
+        const newText = texts.join('')
+        if (newText) {
+          const prev = this._buffers.get(proposalId) ?? ''
+          this._buffers.set(proposalId, prev + newText)
+          this._broadcast({
+            type: 'proposal_stream',
+            projectId: '',
+            proposalId,
+            delta: newText,
+            timestamp: new Date().toISOString(),
+          })
+        }
+
+        // Broadcast tool_use activity so the UI can show "reading codebase..."
+        for (const block of blocks) {
+          if (block.type === 'tool_use' && block.name) {
+            this._broadcast({
+              type: 'proposal_stream',
+              projectId: '',
+              proposalId,
+              delta: `<!--tool:${block.name}-->`,
+              timestamp: new Date().toISOString(),
+            })
+          }
+        }
+      }
+    })
+
+    return new Promise<void>((resolve) => {
+      child.on('close', (code) => {
+        const fullText = this._buffers.get(proposalId) ?? ''
+        this._activeProcesses.delete(proposalId)
+        this._buffers.delete(proposalId)
+
+        if (code === 0) {
+          onSuccess(fullText, capturedSessionId)
+        } else {
+          onError()
+        }
+
+        resolve()
+      })
+    })
+  }
+
+  private _broadcastError(proposalId: string, error: string): void {
+    this._broadcast({
+      type: 'proposal_error',
+      projectId: '',
+      proposalId,
+      error,
+      timestamp: new Date().toISOString(),
+    })
+  }
+}