yt-briefing 1.1.1 → 1.2.1

package/README.md

@@ -137,6 +137,9 @@ The **Comment** field takes anything else. Type what you think in your own words
 shows, skip those") and press Enter: Claude turns it into a standing rule for that channel and
 infers the rating. `? your question` starts research with that question, `stop` closes the pane.
 Claude Code on a phone has no text fields, so there the pane shows the four keys only.
+Where no pane can be seen (`/yt` sent from claude.ai/code over Remote Control, or a surface that
+places no panes), the same loop runs in Claude Code's question dialog: the summary as plain text,
+OK / Weak / Research / Stop as choices, and a typed **Other** answer works as the Comment field.
 
 Each step is the engine, not a chat turn: rating a video takes no turn and no context of your
 session, and the next summary is usually ready before you have finished reading the current one.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yt-briefing",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "description": "A self-learning YouTube briefing for Claude Code: it sweeps the channels you follow, filters noise in two stages (title, then transcript), gives you a short briefing of the rest in your language in a pane, and adapts to your ratings — one video at a time.",
   "type": "module",
   "bin": {

package/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "yt-briefing",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "description": "The /yt briefing loop as a Claude Code pane: summary, one-key rating, research hand-off.",
   "author": {
     "name": "Michal Ryzio"

package/plugin/hooks/register.tsx

@@ -7,6 +7,8 @@ import { engine } from './engine.ts'
 // The /yt rating loop as a pane. Every step runs the engine as a subprocess and reads its one-line
 // JSON; the model is not involved unless the person asks for research, which hands the video to
 // the session as a prompt. Ratings and comments are written by the engine, never by this module.
+// Where no pane can be seen (a Remote Control web client, a surface that places none) the same
+// loop runs in the engine's own question dialog instead.
 
 const PANE = 'yt-briefing'
 const view = atom({ plugin: 'yt-briefing', key: 'view' } as const, { phase: 'idle' } as View)
@@ -50,13 +52,25 @@ function skipLine(out: SweepOut): string | undefined {
   return `Skipped ${out.skipped}: ${list}`
 }
 
+/** One engine sweep: the next ratable video, or the end state. Throws when the engine does not answer. */
+async function runSweep($: EngineInterface, reset: boolean): Promise<SweepOut> {
+  const run = await $.process.run([...engine('yt-sweep'), ...(reset ? ['--reset'] : [])], { timeoutMs: SWEEP_MS })
+  return parseOut(run.stdout)
+}
+
+/** What a sweep that found nothing to rate says, skips included. */
+function endText(out: SweepOut): string {
+  const text = out.status === 'done' ? STATUS_TEXT.done : out.error ?? STATUS_TEXT[out.status] ?? `Engine status: ${out.status}`
+  const skipped = skipLine(out)
+  return skipped ? `${text}\n${skipped}` : text
+}
+
 /** Advance to the next ratable video and put it (or the end state) in the view. */
 async function sweep($: EngineInterface, reset: boolean) {
   await setView($, { phase: 'loading' })
   let out: SweepOut
   try {
-    const run = await $.process.run([...engine('yt-sweep'), ...(reset ? ['--reset'] : [])], { timeoutMs: SWEEP_MS })
-    out = parseOut(run.stdout)
+    out = await runSweep($, reset)
   } catch (err) {
     await setView($, { phase: 'error', message: `The engine did not answer: ${String(err)}` })
     return
@@ -76,17 +90,26 @@ async function rate($: EngineInterface, args: string[], thenNext = true): Promis
   const v = await read($, view)
   if (v.phase !== 'rating' || v.busy) return null
   await update($, view, cur => ({ ...cur, busy: args[0] === '--raw-comment' ? 'Turning the comment into a rule…' : 'Saving…' }))
+  const result = await record($, args)
+  if (!result) {
+    await update($, view, cur => ({ ...cur, busy: undefined }))
+    return null
+  }
+  if (thenNext) void sweep($, false)
+  return result
+}
+
+/** Run the rating engine; on failure toast why and resolve null. */
+async function record($: EngineInterface, args: string[]): Promise<{ rule?: string } | null> {
   const run = await $.process.run([...engine('yt-rating'), ...args], { timeoutMs: RATE_MS }).catch(err => ({
     exitCode: 1, stdout: '', stderr: String(err),
   }))
   if (run.exitCode !== 0) {
-    await update($, view, cur => ({ ...cur, busy: undefined }))
     $.ui.toast(`Rating not saved: ${run.stderr.trim().slice(0, 200) || 'engine error'}`)
     return null
   }
   let result: { rule?: string } = {}
   try { result = JSON.parse(run.stdout.trim().split('\n').pop() ?? '{}') } catch { /* rating is on disk */ }
-  if (thenNext) void sweep($, false)
   return result
 }
 
@@ -96,7 +119,11 @@ async function research($: EngineInterface, question?: string) {
   if (!v.pending || !v.summary) return
   if (!(await rate($, ['--rating', '1'], false))) return
   await $.ui.close({ id: PANE })
-  const p = v.pending
+  await handOff($, v.pending, v.summary, v.lang, question)
+}
+
+/** Give the video to the session as the person's prompt, to research it together. */
+async function handOff($: EngineInterface, p: Pending, summary: string, lang: string | undefined, question?: string) {
   const transcript = [...engine('yt-transcript'), p.videoId, '--lang', 'auto'].join(' ')
   const ask = question
     ? `My question: ${question}`
@@ -107,9 +134,9 @@ async function research($: EngineInterface, question?: string) {
       `Let's research this video together: ${p.channel} — "${p.title}" (${p.videoId}, ${p.type}).`,
       '',
       'Its briefing:',
-      v.summary,
+      summary,
       '',
-      `For anything beyond the briefing, pull the full transcript with \`${transcript}\` and work from the tool result; never paste the transcript into the chat, quote only short passages. Keep what the video claims separate from what you verify yourself, and use whatever the question needs (my project, the web). Answer in ${v.lang ?? 'English'}.`,
+      `For anything beyond the briefing, pull the full transcript with \`${transcript}\` and work from the tool result; never paste the transcript into the chat, quote only short passages. Keep what the video claims separate from what you verify yourself, and use whatever the question needs (my project, the web). Answer in ${lang ?? 'English'}.`,
       ask,
       '',
       'If it turns out to be hype, record it with `' + [...engine('yt-rating'), '--rating', '0'].join(' ') + '`; a lasting preference about this channel goes in with `' + [...engine('yt-rating'), '--raw-comment', '"<what to remember>"'].join(' ') + '`.',
@@ -126,6 +153,57 @@ async function comment($: EngineInterface, raw: string) {
   if (saved?.rule) $.ui.toast(`Rule saved: ${saved.rule}`)
 }
 
+/** The dialog's choices; anything else is text typed under "Other". */
+const CHOICES = ['OK', 'Weak', 'Research', 'Stop'] as const
+
+/** The dialog draws plain text: drop the briefing's Markdown marks so no `**` or `###` shows. */
+function plain(md: string): string {
+  return md
+    .replace(/^#{1,6}\s+/gm, '')
+    .replace(/\*\*(.+?)\*\*/g, '$1')
+    .replace(/^_(.+)_$/gm, '$1')
+    .replace(/^(\d+\.)\s+/gm, '$1 ')
+    .replace(/(\d{4}-\d{2}-\d{2})T[\d:.]+Z/g, '$1')
+}
+
+/** True when the person typed /yt through Remote Control and nothing attached can show a pane. */
+async function paneUnseen($: EngineInterface, origin: { kind: string } | undefined): Promise<boolean> {
+  if (origin?.kind !== 'bridge') return false
+  return !(await $.session.surfaces()).some(s => s !== 'terminal')
+}
+
+/** The rating loop in the engine's question dialog, from a sweep already run, for a session where no pane can be seen. */
+async function dialogLoop($: EngineInterface, first: SweepOut) {
+  let out = first
+  for (;;) {
+    if (out.status !== 'rating_needed' || !out.summary || !out.pending) return void $.ui.log(endText(out))
+
+    const filtered = out.skipped ? `(${out.skipped} filtered out)` : undefined
+    const question = [plain(out.summary), filtered, '', 'Rating?'].filter(line => line !== undefined).join('\n')
+    let answer: string
+    try {
+      answer = (await $.ui.ask(question, { header: 'yt-briefing', options: CHOICES })).trim()
+    } catch {
+      return
+    }
+
+    if (answer === 'Stop' || answer.toLowerCase() === 'stop' || !answer) return
+    if (answer === 'Research' || answer.startsWith('?')) {
+      if (!(await record($, ['--rating', '1']))) return
+      const q = answer.startsWith('?') ? answer.slice(1).trim() || undefined : undefined
+      return handOff($, out.pending, out.summary, out.lang, q)
+    }
+    const args = answer === 'OK' ? ['--rating', '1'] : answer === 'Weak' ? ['--rating', '0'] : ['--raw-comment', answer]
+    const saved = await record($, args)
+    if (!saved) return
+    $.ui.log(saved.rule ? `Rule saved: ${saved.rule}. Looking for the next video…` : 'Saved. Looking for the next video…')
+    try {
+      out = await runSweep($, false)
+    } catch (err) {
+      return void $.ui.log(`The engine did not answer: ${String(err)}`)
+    }
+  }
+}
 
 export const register: Register = on => {
   on('session.start', async ($, e, next) => {
@@ -137,11 +215,27 @@ export const register: Register = on => {
     return next(e)
   })
 
-  on('command.run', { command: 'yt' }, async $ => {
-    await $.ui.open({ id: PANE, title: 'yt-briefing', focus: true, closeOnEscape: true })
-    void sweep($, true)
+  on('command.run', { command: 'yt' }, async ($, e) => {
+    if (!(await paneUnseen($, e.origin))) {
+      const opened = await $.ui.open({ id: PANE, title: 'yt-briefing', focus: true, closeOnEscape: true })
+      if (opened.isPlaced) {
+        void sweep($, true)
+        return { text: 'Briefing opened in a pane.' }
+      }
+      await $.ui.close({ id: PANE })
+    }
+    // No pane to show progress in: the command itself runs while the first sweep does, so the
+    // session shows it working, and only then hands over to the dialogs.
+    let first: SweepOut
+    try {
+      first = await runSweep($, true)
+    } catch (err) {
+      return { text: `The engine did not answer: ${String(err)}` }
+    }
+    if (first.status !== 'rating_needed') return { text: endText(first) }
+    void dialogLoop($, first)
 
-    return { text: 'Briefing opened in a pane.' }
+    return { text: 'Briefing ready: rate it in the question dialog.' }
   })
 
   on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {