@davait/aipictury 1.9.2

package/ext/notebook.js

@@ -0,0 +1,82 @@
+'use strict'
+// Running a Jupyter cell for the agent, as Claude Code does: the user is asked first (Execute /
+// Cancel), then the cell runs through VS Code's own notebook execution — the kernel the user
+// chose for the notebook — and its outputs come back: text, results, errors. A notebook with
+// no kernel says so.
+const vscode = require('vscode')
+const { resolve } = require('./paths')
+
+const decode = (bytes) => new TextDecoder().decode(bytes)
+
+/** A cell's outputs as text for the model: stdout, results, errors (pictures are named, not sent). */
+function outputsText(cell) {
+  const parts = []
+  for (const out of cell.outputs || []) {
+    for (const item of out.items || []) {
+      if (item.mime === 'application/vnd.code.notebook.error') {
+        const e = JSON.parse(decode(item.data))
+        parts.push(`Error: ${e.name}: ${e.message}${e.stack ? `\n${e.stack}` : ''}`)
+      } else if (/^(text\/|application\/vnd\.code\.notebook\.std)/.test(item.mime) || item.mime === 'application/json') {
+        parts.push(decode(item.data))
+      } else {
+        parts.push(`[${item.mime} output]`)
+      }
+    }
+  }
+  return parts.join('\n').trim()
+}
+
+/** Which cell: by its notebook id, else by its position. */
+function findCell(doc, id) {
+  const all = doc.getCells()
+  const byId = all.findIndex((c) => String(c.metadata?.id ?? c.metadata?.metadata?.id ?? '') === String(id))
+  if (byId !== -1) return byId
+  const n = Number(id)
+  if (Number.isInteger(n) && n >= 0 && n < all.length) return n
+  throw new Error(`no cell ${id} in this notebook (it has ${all.length})`)
+}
+
+/**
+ * Runs one code cell. `ask(question, code)` says yes or no (not asked when `skipAsk`).
+ * Resolves to the text for the model.
+ */
+async function runCell(args, { ask, skipAsk = false, signal, timeoutMs } = {}) {
+  const uri = resolve(args.path)
+  if (!uri.fsPath.endsWith('.ipynb')) throw new Error('notebook_run_cell runs cells of .ipynb notebooks')
+  const doc = await vscode.workspace.openNotebookDocument(uri)
+  const index = findCell(doc, args.cell_id ?? 0)
+  const cell = doc.cellAt(index)
+  if (cell.kind !== vscode.NotebookCellKind.Code) throw new Error(`cell ${index} is Markdown, not code`)
+  const code = cell.document.getText()
+  if (!skipAsk && !(await ask(`Run cell ${index} of ${args.path}?`, code))) {
+    return 'The user chose not to run it. Ask what they want instead, or carry on without its result.'
+  }
+  await vscode.window.showNotebookDocument(doc, { preserveFocus: true, preview: false })
+  const limit = Math.max(5, Math.min(600, Number(args.timeout) || 120)) * 1000
+  const before = cell.executionSummary?.executionOrder
+  const finished = new Promise((done) => {
+    const sub = vscode.workspace.onDidChangeNotebookDocument((e) => {
+      if (e.notebook !== doc) return
+      for (const change of e.cellChanges) {
+        const s = change.cell.index === index && (change.executionSummary || change.cell.executionSummary)
+        if (s && s.success !== undefined && s.executionOrder !== before) { sub.dispose(); done(change.cell) }
+      }
+    })
+    signal?.addEventListener('abort', () => { sub.dispose(); done(null) }, { once: true })
+    setTimeout(() => { sub.dispose(); done(null) }, timeoutMs ?? limit)
+  })
+  // Not awaited: with no kernel chosen, VS Code opens its kernel picker and the command waits
+  // on it — the result (or the time limit) is what is waited for.
+  Promise.resolve(vscode.commands.executeCommand('notebook.cell.execute', { ranges: [{ start: index, end: index + 1 }], document: uri })).catch(() => {})
+  const ran = await finished
+  if (!ran) vscode.commands.executeCommand('workbench.action.closeQuickOpen').then(() => {}, () => {})
+  if (signal?.aborted) return 'stopped by the user'
+  if (!ran) {
+    return `Cell ${index} did not finish within ${Math.round((timeoutMs ?? limit) / 1000)} s — still running, or no kernel is selected for `
+      + 'this notebook (the user picks one at the top right of the notebook).'
+  }
+  const text = outputsText(ran)
+  return `Cell ${index} ran ${ran.executionSummary.success ? 'without errors' : 'with an error'}${text ? `:\n${text}` : ' (no output).'}`
+}
+
+module.exports = { runCell, outputsText, findCell }