backstep 0.1.9 → 0.1.13

package/mod/hooks/register.test.tsx

@@ -13,9 +13,14 @@ const CLI = '/opt/backstep/cli.js'
 // `undo` answers with `undo`. Every argv the mod runs is recorded.
 function engine(on: On, undo: { exitCode: number; stdout: string; stderr?: string }, shell: object = { kind: 'read', undoable: false }) {
   const runs: string[][] = []
+  const logs: string[] = []
   const prompts: { text: string; context?: readonly string[] }[] = []
   on('session.cwd', () => ({ value: '/repo' }))
   on('session.id', () => ({ value: 's1' }))
+  on('ui.log', (_, e) => {
+    logs.push(e.text)
+    return { value: undefined }
+  })
   on('process.run', (_, e) => {
     runs.push([...e.argv])
     const r = e.argv.includes('undo') ? undo : e.argv.includes('shell') ? { exitCode: 0, stdout: JSON.stringify(shell) } : { exitCode: 0, stdout: '' }
@@ -30,7 +35,7 @@ function engine(on: On, undo: { exitCode: number; stdout: string; stderr?: strin
     const { Text } = $.ui.resolve(e)
     return <Text>engine</Text>
   })
-  return { runs, prompts }
+  return { runs, prompts, logs }
 }
 
 test('an edit is snapshotted and the band offers to undo the turn', { options: { cli: CLI } }, async ($, on) => {
@@ -74,15 +79,18 @@ test('pressing undo rewinds the turn and tells Claude on the next prompt', { opt
 
   await clock.advance(1000)
   await pressed
+  await clock.advance(500)
   expect((await ui.find({ type: 'Text', text: /Rewound/ }))?.text).toContain('Rewound 1 change from the last turn.')
   expect((await ui.find({ type: 'Text', text: /src\/a\.ts restored/ }))).toBeTruthy()
 
-  // The band folds away, and with the turn undone nothing is left to offer.
-  await clock.advance(5000)
-  expect(await ui.find({ type: 'Text', text: /nothing to undo yet/ })).toBeTruthy()
-  await ui.unmount()
+  // The list stays up, however long, until the next message.
+  await clock.advance(60_000)
+  expect((await ui.find({ type: 'Text', text: /Rewound/ }))).toBeTruthy()
 
   await $.prompt.submit({ text: 'try again', wait: false, origin: { kind: 'composer' } })
+  // Then the band goes back to the undo line; with the turn undone, nothing is left to offer.
+  expect(await ui.find({ type: 'Text', text: /Rewound/ })).toBeFalsy()
+  await ui.unmount()
   const note = prompts.at(-1)?.context?.at(-1) ?? ''
   expect(note).toContain('These changes were reverted:\n- src/a.ts restored')
 
@@ -110,14 +118,14 @@ test('a change that cannot be undone stops the rewind and says so', { options: {
   const pressed = ui.press({ key: 'undo' })
   await clock.advance(1000)
   await pressed
+  await clock.advance(500)
   expect((await ui.find({ type: 'Text', text: /Stopped/ }))?.text).toContain('Stopped after 1 change')
   expect((await ui.find({ type: 'Text', text: /row changed since/ }))).toBeTruthy()
 
-  // Still undoable once the band folds, since the turn was not fully rewound.
-  await clock.advance(10000)
+  // Still undoable after the next message, since the turn was not fully rewound.
+  await $.prompt.submit({ text: 'hmm', wait: false, origin: { kind: 'composer' } })
   expect(await ui.find({ type: 'Button', key: 'undo' })).toBeTruthy()
   await ui.unmount()
-  expect(prompts).toHaveLength(1)
 })
 
 test('with nothing to undo the band still holds the key, and a press says there is nothing to undo', async ($, on) => {
@@ -219,6 +227,7 @@ function connector(on: On, opts: { start: object; undoable: boolean; mcpFails?:
     toasts.push(e.text)
     return { value: undefined }
   })
+  on('ui.log', () => ({ value: undefined }))
   on('session.cwd', () => ({ value: '/repo' }))
   on('session.id', () => ({ value: 's1' }))
   on('process.run', (_, e) => {
@@ -531,6 +540,7 @@ test('one press only asks; it lets go after a few seconds, or on cancel, and und
 
   await ui.press({ key: 'undo' })
   expect((await ui.find({ type: 'Text', text: /Undo Claude's last turn\?/ }))).toBeTruthy()
+  expect((await ui.find({ type: 'Text', text: /"fix it" · 1 edit to 1 file/ }))).toBeTruthy()
   expect((await ui.find({ type: 'Button', key: 'undo' }))?.text).toBe('ctrl+u again to undo')
   await clock.advance(6000)
   expect((await ui.find({ type: 'Text', text: /Last turn/ }))).toBeTruthy()
@@ -606,3 +616,157 @@ test('about to change a Supabase project that is not connected, Backstep asks fi
   await $.tool.call({ tool: 'Bash', command })
   expect(asked).toHaveLength(1)
 })
+
+// An engine where each shell command's plan is given by a test, and undo answers as told.
+function shellEngine(on: On, plans: (command: string) => object, undo: object[]) {
+  const runs: string[][] = []
+  const logs: string[] = []
+  on('session.cwd', () => ({ value: '/repo' }))
+  on('session.id', () => ({ value: 's1' }))
+  on('ui.toast', () => ({ value: undefined }))
+  on('ui.log', (_, e) => {
+    logs.push(e.text)
+    return { value: undefined }
+  })
+  on('process.run', (_, e) => {
+    runs.push([...e.argv])
+    const command = e.argv.at(-1) ?? ''
+    const out = e.argv.includes('undo') ? undo : e.argv.includes('shell') ? plans(command) : e.argv.includes('db-check') ? { ask: null } : null
+    return { value: { exitCode: 0, stdout: out ? JSON.stringify(out) : '', stderr: '', isStdoutTruncated: false, isStderrTruncated: false } }
+  })
+  on('tool.call', { tool: 'AskUserQuestion' }, () => ({ result: { questions: [], answers: {} } }))
+  on('tool.call', () => ({ result: {} }))
+  on('prompt.submit', (_, e) => ({ text: e.text, context: e.context }))
+  on('ui.render', ($, e) => {
+    const { Text } = $.ui.resolve(e)
+    return <Text>engine</Text>
+  })
+  return { runs, logs }
+}
+
+test('when the last turn only committed and pushed, undo offers to take back the work it saved too', { options: { cli: CLI } }, async ($, on) => {
+  const clock = mock.clock(on, { now: 5000 })
+  const { runs } = shellEngine(on, () => ({ kind: 'outbound', reason: 'pushes to a remote', id: 'p1', undoable: true }), [])
+
+  await $.prompt.submit({ text: 'add the kanban board', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Edit', file_path: '/repo/src/board.tsx', old_string: 'a', new_string: 'b' })
+  await clock.advance(1000)
+  await $.prompt.submit({ text: 'commit and push it', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Bash', command: 'git add -A && git commit -m "board" && git push' })
+
+  const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  expect((await ui.find({ type: 'Text', text: /Last turn: "commit and push it"/ }))).toBeTruthy()
+  await ui.press({ key: 'undo' })
+  expect((await ui.find({ type: 'Text', text: /only saved and pushed to git/ }))).toBeTruthy()
+  expect((await ui.find({ type: 'Text', text: /Undo it and the turn before it "add the kanban board"\?/ }))).toBeTruthy()
+  expect((await ui.find({ type: 'Button', key: 'undo' }))?.text).toBe('ctrl+u again to undo both')
+  expect(await ui.find({ type: 'Button', key: 'just' })).toBeTruthy()
+
+  const pressed = ui.press({ key: 'undo' })
+  await clock.advance(1000)
+  await pressed
+  // Both turns: everything since the first one started.
+  expect(runs.find((r) => r.includes('undo'))?.slice(3)).toEqual(['undo', '--since', '5000', '--json', '--via-claude-code'])
+  await ui.unmount()
+})
+
+test('after an undo, everything undone and everything that was not is listed, in the band and the conversation', { options: { cli: CLI } }, async ($, on) => {
+  const clock = mock.clock(on, { now: 5000 })
+  const { logs } = shellEngine(
+    on,
+    (command) => (command.startsWith('curl') ? { kind: 'outbound', reason: 'sends a request', id: 'r1', undoable: true } : { kind: 'write', id: 'w1', undoable: true }),
+    [{ id: 'w1', tool: 'Bash', ok: true, detail: 'restored /repo/src/a.ts\nremoved /repo/src/b.ts' }],
+  )
+
+  await $.prompt.submit({ text: 'tidy and notify', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Bash', command: 'rm src/a.ts' })
+  await $.tool.call({ tool: 'Bash', command: 'curl -X POST https://hooks.example.com/notify -d done' })
+
+  const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  await ui.press({ key: 'undo' })
+  const pressed = ui.press({ key: 'undo' })
+  await clock.advance(1000)
+  await pressed
+  await clock.advance(500)
+  expect((await ui.find({ type: 'Text', text: /src\/a\.ts restored/ }))).toBeTruthy()
+  expect((await ui.find({ type: 'Text', text: /Not undone/ }))).toBeTruthy()
+  expect((await ui.find({ type: 'Text', text: /curl -X POST https:\/\/hooks\.example\.com\/notify -d done: sends a request/ }))).toBeTruthy()
+
+  const report = logs.find((l) => l.includes('Backstep undid'))!
+  expect(report).toContain('undid 2 changes from the last turn ("tidy and notify")')
+  expect(report).toContain('◀ src/b.ts removed')
+  expect(report).toContain('Not undone:\n  ✗ curl -X POST')
+  await ui.unmount()
+})
+
+test('a GitHub repository Claude created is offered for deletion after undo, and its push needs no undo of its own', { options: { cli: CLI } }, async ($, on) => {
+  const clock = mock.clock(on, { now: 5000 })
+  const repo = { kind: 'repo', repo: 'bzells11/taskflow', url: 'https://github.com/bzells11/taskflow' }
+  const runs: { argv: string[]; stdin?: string }[] = []
+  const asked: string[] = []
+  const logs: string[] = []
+  on('session.cwd', () => ({ value: '/repo' }))
+  on('session.id', () => ({ value: 's1' }))
+  on('ui.toast', () => ({ value: undefined }))
+  on('ui.log', (_, e) => {
+    logs.push(e.text)
+    return { value: undefined }
+  })
+  on('process.run', (_, e) => {
+    runs.push({ argv: [...e.argv], stdin: e.init?.stdin })
+    const out = e.argv.includes('shell')
+      ? { kind: 'outbound', reason: 'changes GitHub', id: 'g1', undoable: true }
+      : e.argv.includes('undo')
+        ? [{ id: 'g1', tool: 'Bash', ok: true, detail: 'restored main', github: [repo], pushed: { root: '/repo', pushes: [{ remote: 'origin', branch: 'main', before: null, after: 'b', commits: 1, host: 'GitHub' }] } }]
+        : e.argv.includes('gh-undo')
+          ? // The first try finds gh's sign-in can't delete repositories yet.
+            runs.filter((r) => r.argv.includes('gh-undo')).length === 1
+            ? { ok: false, needs: 'delete_repo', detail: 'GitHub needs your OK before bzells11/taskflow can be deleted' }
+            : { ok: true, detail: 'deleted the repository bzells11/taskflow' }
+          : e.argv.includes('gh-auth')
+            ? { ok: true, detail: 'GitHub approved it' }
+          : e.argv.includes('db-check')
+            ? { ask: null }
+            : null
+    return { value: { exitCode: 0, stdout: out ? JSON.stringify(out) : '', stderr: '', isStdoutTruncated: false, isStderrTruncated: false } }
+  })
+  on('tool.call', { tool: 'AskUserQuestion' }, (_, e) => {
+    const questions = (e as unknown as { questions: { question: string }[] }).questions
+    asked.push(questions[0].question)
+    return { result: { questions, answers: { [questions[0].question]: 'Delete it' } } }
+  })
+  on('tool.call', () => ({ result: {}, text: '✓ Created repository bzells11/taskflow on GitHub' }))
+  on('prompt.submit', (_, e) => ({ text: e.text, context: e.context }))
+  on('ui.render', ($, e) => {
+    const { Text } = $.ui.resolve(e)
+    return <Text>engine</Text>
+  })
+
+  await $.prompt.submit({ text: 'make a github repo', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Bash', command: 'gh repo create taskflow --public --source . --push' })
+  // What gh printed is noted once it has run.
+  const end = runs.find((r) => r.argv.includes('shell-end'))
+  expect(end?.stdin).toContain('Created repository bzells11/taskflow')
+
+  const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  await ui.press({ key: 'undo' })
+  const pressed = ui.press({ key: 'undo' })
+  await clock.advance(1000)
+  await pressed
+  await clock.settle()
+  expect(asked).toEqual(['Claude created the GitHub repository bzells11/taskflow. Delete it on GitHub too?'])
+  expect(JSON.parse(runs.find((r) => r.argv.includes('gh-undo'))?.stdin ?? '{}')).toEqual(repo)
+  // Missing permission: GitHub's OK is fetched by Backstep itself, then the delete is tried again.
+  expect(runs.filter((r) => r.argv.includes('gh-undo') || r.argv.includes('gh-auth')).map((r) => r.argv.slice(3).join(' '))).toEqual([
+    'gh-undo',
+    'gh-auth delete_repo',
+    'gh-undo',
+  ])
+  expect(logs.find((l) => l.includes('opened the approval page and copied the code'))).toBeTruthy()
+  expect(logs.find((l) => l.includes('On GitHub: deleted the repository'))).toBeTruthy()
+  // The repository is gone, so its push isn't asked about.
+  expect(runs.some((r) => r.argv.includes('revert-push'))).toBe(false)
+  // And "changes GitHub" isn't listed as not undone, since it was offered.
+  expect(logs.find((l) => l.includes('Backstep undid'))).not.toContain('changes GitHub')
+  await ui.unmount()
+})