@bojackduy/opencode-learn 0.1.5 → 1.0.0

package/plugins/learn.ts

@@ -125,6 +125,15 @@ function resolveCorrect(correctAnswer: string | string[] | undefined, options: A
   return { indices: Array.from(new Set(indices)).sort((a, b) => a - b) as number[] }
 }
 
+function decodeQuizText(s: string | undefined): string | undefined {
+  if (!s || typeof s !== "string") return s
+  if (!s.includes("\\")) return s
+  let out = s.replace(/\\r\\n/g, "\n").replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "\t")
+  out = out.replace(/\\"/g, '"').replace(/\\'/g, "'")
+  out = out.replace(/\\\\/g, "\\")
+  return out
+}
+
 // ────────────────────────────────────────────────────────────────────────────
 // md-log helpers (ported from .pi/extensions/md-log.ts)
 // ────────────────────────────────────────────────────────────────────────────
@@ -454,11 +463,164 @@ const server: Plugin = async ({ client, directory }) => {
   const loggedToolCallIds = new Set<string>()
   const messageIdToRole = new Map<string, string>()
 
+  // ── Classify watcher: note → inferred options (learner-easy) — LLM-backed, not heuristic-only
+  function heuristicClassify(note: string, options: Array<{ label: string; value?: string }>): number[] {
+    const n = note.toLowerCase()
+    const out: number[] = []
+    for (let i = 0; i < options.length; i++) {
+      const o = options[i]
+      const label = (o.label || "").toLowerCase()
+      const value = (o.value || "").toLowerCase()
+      if (label && n.includes(label)) out.push(i + 1)
+      else if (value && n.includes(value)) out.push(i + 1)
+      else {
+        const tokens = label.split(/[^a-z0-9]+/).filter(t => t.length >= 3)
+        if (tokens.some(t => n.includes(t))) out.push(i + 1)
+      }
+    }
+    return [...new Set(out)]
+  }
+  async function llmClassify(client: any, directory: string, note: string, options: Array<{ label: string; value?: string }>, question?: string, parentSessionID?: string): Promise<{ inferred: number[]; semanticCorrect?: boolean; reason?: string; sessionID?: string }> {
+    const prompt = `Map learner's free-text note (may be Vietnamese or English) to closest option(s) and judge semantic correctness. Only pick from given Options, no new options.
+
+${question ? `Question: ${question}\n` : ""}Options:
+${options.map((o, i) => `${i + 1}. ${o.label} (value: ${o.value || o.label})`).join("\n")}
+
+Learner note: "${note}"
+
+Task: 1) inferred: which option(s) note best matches (Vietnamese translations/synonyms allowed). 2) semanticCorrect: true if note shows valid understanding or deeper nuance even when inferred != correct key (e.g., note about rotate array variant vs standard sorted is valid nuance). 3) reason: short English reason.
+
+Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"..."}  If vague/"I don't know", inferred:[], semanticCorrect:false. No markdown, just JSON.`
+    try {
+      const title = `classify: ${question ? question.slice(0, 30) : note.slice(0, 20)}`
+      const body: any = { title }
+      if (parentSessionID) body.parentID = parentSessionID
+      const created: any = await client.session.create({ body, query: { directory } })
+      const sid = created?.data?.id || created?.id || created?.data?.sessionID
+      if (!sid) throw new Error("no sid")
+      const createdSession = created?.data || created
+      slog("classify subagent created", sid, `requestedParent:${parentSessionID || "none"}`, `actualParent:${createdSession?.parentID || "none"}`, note.slice(0, 40))
+      if (parentSessionID && createdSession?.parentID !== parentSessionID) {
+        throw new Error(`classifier parent mismatch: expected ${parentSessionID}, got ${createdSession?.parentID || "none"}`)
+      }
+      await client.session.prompt({ path: { id: sid }, body: { parts: [{ type: "text", text: prompt }], agent: "classify" } })
+      // Poll for assistant response up to 12s
+      for (let i = 0; i < 24; i++) {
+        await new Promise(r => setTimeout(r, 500))
+        try {
+          const msgs: any = await client.session.messages({ path: { id: sid } })
+          const data = msgs?.data || msgs
+          const arr = Array.isArray(data) ? data : []
+          for (let j = arr.length - 1; j >= 0; j--) {
+            const entry = arr[j]
+            if (entry?.info?.role === "assistant") {
+              const text = (entry.parts || []).filter((p: any) => p.type === "text").map((p: any) => p.text).join(" ") || ""
+              // Try object JSON {"inferred":[2],"semanticCorrect":false}
+              const objMatch = text.match(/\{[^}]*"inferred"[^}]*\}/)
+              if (objMatch) {
+                try {
+                  const parsed = JSON.parse(objMatch[0])
+                  if (parsed && Array.isArray(parsed.inferred)) {
+                    const nums = parsed.inferred.filter((n: any) => typeof n === "number" && n >= 1 && n <= options.length)
+                    slog("llmClassify success object", note.slice(0, 40), nums.join(","), `semantic:${parsed.semanticCorrect} reason:${parsed.reason || ""} sid:${sid}`)
+                    return { inferred: nums, semanticCorrect: !!parsed.semanticCorrect, reason: parsed.reason, sessionID: sid }
+                  }
+                } catch {}
+              }
+              const m = text.match(/\[[\s\d,]*\]/)
+              if (m) {
+                try {
+                  const parsed = JSON.parse(m[0])
+                  if (Array.isArray(parsed)) {
+                    const nums = parsed.filter((n: any) => typeof n === "number" && n >= 1 && n <= options.length)
+                    if (nums.length) {
+                      slog("llmClassify success array", note.slice(0, 40), nums.join(","))
+                      return { inferred: nums, sessionID: sid }
+                    }
+                  }
+                } catch {}
+              }
+              if (text.includes("1") || text.includes("2")) {
+                const nums = [...text.matchAll(/\b([1-9])\b/g)].map(x => parseInt(x[1])).filter(n => n <= options.length)
+                if (nums.length) return { inferred: [...new Set(nums)], sessionID: sid }
+              }
+            }
+          }
+        } catch {}
+      }
+      slog("llmClassify timeout", note.slice(0, 40))
+    } catch (e) {
+      slog("llmClassify failed", String(e).slice(0, 200))
+    }
+    return { inferred: [] }
+  }
+  function startClassifyWatcher(client: any, directory: string) {
+    const dir = pendingDir(directory)
+    try { fs.mkdirSync(dir, { recursive: true }) } catch {}
+    const processClassify = async (filename: string) => {
+      if (!filename.startsWith("classify-") || filename.startsWith("classify-response-")) return
+      const fp = path.join(dir, filename)
+      if (!fs.existsSync(fp)) return
+      const respPath = path.join(dir, filename.replace("classify-", "classify-response-"))
+      if (fs.existsSync(respPath)) return
+      let data: any
+      try { data = JSON.parse(fs.readFileSync(fp, "utf8")) } catch { return }
+      if (data?.type !== "classify" || !data?.note || !Array.isArray(data?.options)) return
+      slog("classify watcher processing", data.id, data.note.slice(0, 80))
+      const byVal = new Map<string, number>(data.options.map((o: any, i: number) => [o.value, i + 1] as [string, number]))
+      const start = Date.now()
+      let inferred: number[] = []
+      let semanticCorrect: boolean | undefined
+      let reason: string | undefined
+      const llmRes = await llmClassify(client, directory, data.note, data.options, data.question, data.sessionID)
+      if (llmRes.inferred.length) {
+        inferred = llmRes.inferred
+        semanticCorrect = llmRes.semanticCorrect
+        reason = llmRes.reason
+        slog("classify llm hit", data.id, llmRes.inferred.join(","), `semantic:${semanticCorrect} sid:${llmRes.sessionID || ""}`)
+      } else {
+        inferred = heuristicClassify(data.note, data.options)
+        if (inferred.length) slog("classify heuristic hit", data.id, inferred.join(","))
+        else slog("classify no match", data.id, `"${data.note.slice(0, 40)}"`)
+      }
+      // Ensure minimal classify time so UI doesn't feel instant-wrong (at least 1200ms)
+      const elapsed = Date.now() - start
+      if (elapsed < 1200) await new Promise(r => setTimeout(r, 1200 - elapsed))
+      const inferredValues = inferred.map((i: number) => data.options[i - 1]?.value).filter(Boolean) as string[]
+      // Final fallback if still empty
+      if (!inferred.length && data.note) {
+        const n = data.note.toLowerCase()
+        for (const o of data.options) {
+          const v = o.value ? String(o.value).toLowerCase() : ""
+          if (v && n.includes(v) && !inferred.includes(byVal.get(o.value) as number)) {
+            const idx = byVal.get(o.value) as number | undefined
+            if (idx) inferred.push(idx)
+          }
+        }
+      }
+      slog("classify inferred", data.id, inferred.join(",") || "(none)", `semantic:${semanticCorrect} reason:${reason || ""} sid:${(llmRes as any)?.sessionID || ""} note:"${data.note.slice(0, 60)}"`)
+      const out = { id: data.id, inferredIndices: inferred, inferredValues, semanticCorrect, reason, classifySessionID: (llmRes as any)?.sessionID, note: data.note, at: Date.now() }
+      try { fs.writeFileSync(respPath, JSON.stringify(out), "utf8"); slog("classify response written", data.id, inferred.join(",")) } catch {}
+    }
+    // Initial sweep
+    try {
+      for (const f of fs.readdirSync(dir).filter(f => f.startsWith("classify-") && !f.startsWith("classify-response-"))) {
+        void processClassify(f)
+      }
+    } catch {}
+    try {
+      const w = fs.watch(dir, (_e, filename) => { if (filename) void processClassify(filename) })
+      w.on("error", () => {})
+      // Keep watcher alive; store to avoid GC? No need.
+    } catch {}
+  }
+  startClassifyWatcher(client, directory)
+
   // Durability: on (re)start, re-watch any pending quizzes left from a crash/exit
   try {
     const dir = pendingDir(directory)
     if (fs.existsSync(dir)) {
-      for (const f of fs.readdirSync(dir).filter(x => x.endsWith(".json") && !x.startsWith("response-") && !x.startsWith("."))) {
+      for (const f of fs.readdirSync(dir).filter(x => x.endsWith(".json") && !x.startsWith("response-") && !x.startsWith(".") && !x.startsWith("classify"))) {
         try {
           const j = JSON.parse(fs.readFileSync(path.join(dir, f), "utf8"))
           if (j?.id && j?.sessionID) {
@@ -511,7 +673,7 @@ const server: Plugin = async ({ client, directory }) => {
     config: async (output) => {
       const agents = (output as any).agent ?? {}
       let mutated = false
-      for (const name of ["researcher", "mermaid-maker", "svg-maker"]) {
+      for (const name of ["researcher", "mermaid-maker", "svg-maker", "classify"]) {
         if (!agents[name]) {
           // Minimal placeholder — real agent definitions live in .opencode/agents/*.md
           // We inject a lightweight config so `task` tool can discover them even if md file is missing.
@@ -635,8 +797,14 @@ const server: Plugin = async ({ client, directory }) => {
           shuffle: tool.schema.boolean().optional().describe("Default true: shuffle before display. False only if order matters."),
         },
         async execute(args, ctx) {
+          // Fix double-escaped \n coming from LLM JSON (e.g. "\\n" literal instead of newline)
+          const qFixed = (decodeQuizText(args.question) ?? args.question) as string
+          const dFixed = decodeQuizText(args.details) as string | undefined
+          const eFixed = (decodeQuizText(args.explanation) ?? args.explanation) as string
+          // Also decode option labels in case they contain code
+          const optsDecoded = (args.options as any[] | undefined)?.map((o: any) => ({ ...o, label: decodeQuizText(o.label) ?? o.label, description: o.description ? decodeQuizText(o.description) : o.description })) as any
           let options: Array<{ label: string; value: string; description?: string }>
-          try { options = normalizeQuizOptions(args.options as any) } catch (e) { return `quiz error: ${(e as Error).message}` }
+          try { options = normalizeQuizOptions(optsDecoded) } catch (e) { return `quiz error: ${(e as Error).message}` }
           if (args.shuffle !== false) options = shuffleOptions(options)
           const { indices: correctIndices, error: correctError } = resolveCorrect(args.correctAnswer as any, options)
           if (correctError) return `quiz error: ${correctError}`
@@ -655,17 +823,17 @@ const server: Plugin = async ({ client, directory }) => {
           const payload = {
             id,
             type: "quiz" as const,
-            question: args.question,
-            details: args.details,
+            question: qFixed,
+            details: dFixed,
             options: options.map((o, i) => ({ label: o.label, value: o.value, description: o.description, index: i + 1 })),
             correctIndices,
-            explanation: args.explanation,
+            explanation: eFixed,
             multiSelect: !!args.multiSelect,
             sessionID: (ctx as any).sessionID,
             timestamp: Date.now(),
           }
           try { fs.writeFileSync(pendingPath, JSON.stringify(payload), "utf8"); slog("quiz wrote durably", pendingPath, "alive", tuiAlive) } catch (e) { slog("quiz write failed", String(e)) }
-          try { await (ctx as any).metadata?.({ title: `Quiz: ${args.question.slice(0, 40)}`, metadata: { pendingId: id } }) } catch {}
+          try { await (ctx as any).metadata?.({ title: `Quiz: ${qFixed.slice(0, 40)}`, metadata: { pendingId: id } }) } catch {}
           watchAndInject(client, directory, id, (ctx as any).sessionID, (r: any) => {
               const dk = !!r?.dontKnow
               const sel = (r?.answers || []).map((a: any) => `${a.index}. ${a.label}`).join(", ") || "(none)"
@@ -679,19 +847,19 @@ const server: Plugin = async ({ client, directory }) => {
                   answers: r?.answers || [],
                   correct: ok,
                   correctIndices,
-                  explanation: args.explanation,
+                  explanation: eFixed,
                   dontKnow: dk,
                   note: r?.note,
                 }
                 void withMdLock(() => appendToMdLog(answerCalloutQuiz(details)))
               }
               return dk
-                ? `[quiz answered] "${args.question}" -> I don't know (genuine gap).\nCorrect: ${correctStr}\nExplanation: ${args.explanation}${note}`
-                : `[quiz answered] "${args.question}" -> ${sel} = ${ok ? "CORRECT" : "INCORRECT"}.\nCorrect: ${correctStr}\nExplanation: ${args.explanation}${note}`
+                ? `[quiz answered] "${qFixed}" -> I don't know (genuine gap).\nCorrect: ${correctStr}\nExplanation: ${eFixed}${note}`
+                : `[quiz answered] "${qFixed}" -> ${sel} = ${ok ? "CORRECT" : "INCORRECT"}.\nCorrect: ${correctStr}\nExplanation: ${eFixed}${note}`
             })
           // Always mirror question with TRUE shuffled order (pi: tool_execution_update)
           if (mdLogFile) {
-            try { await withMdLock(() => appendToMdLog(questionCallout("Quiz", args.question, args.details?.trim() || undefined, options.map((o) => ({ label: o.label }))))) } catch {}
+            try { await withMdLock(() => appendToMdLog(questionCallout("Quiz", qFixed, dFixed?.trim() || undefined, options.map((o) => ({ label: o.label }))))) } catch {}
           }
           if (tuiAlive) {
             return `[quiz displayed in TUI — waiting for your answer in the popup. I'll continue once you respond.]`
@@ -710,8 +878,8 @@ const server: Plugin = async ({ client, directory }) => {
             if (raw === null) return "User cancelled the quiz"
             const trimmed = (raw as string).trim()
             if (trimmed === "0" || trimmed.toLowerCase() === "i don't know") {
-              const msg = `User selected "I don't know" — genuine gap, not a guess.\nCorrect: ${correctStr}\nExplanation: ${args.explanation}`
-              if (mdLogFile) await withMdLock(() => appendToMdLog(callout("question", "Quiz — I don't know", [args.question, trimmed, `Correct: ${correctStr}`, args.explanation])))
+              const msg = `User selected "I don't know" — genuine gap, not a guess.\nCorrect: ${correctStr}\nExplanation: ${eFixed}`
+              if (mdLogFile) await withMdLock(() => appendToMdLog(callout("question", "Quiz — I don't know", [qFixed, trimmed, `Correct: ${correctStr}`, eFixed])))
               return msg
             }
             const nums = trimmed.split(/[,\s]+/).map(s => parseInt(s, 10)).filter(n => !isNaN(n) && n >= 1 && n <= options.length)
@@ -720,28 +888,28 @@ const server: Plugin = async ({ client, directory }) => {
             const correct = selectedSet.size === correctSet.size && [...selectedSet].every(n => correctSet.has(n))
             const selectedStr = nums.map(n => `${n}. ${options[n - 1].label}`).join(", ") || "(none)"
             const verdict = correct ? "correctly" : "incorrectly"
-            const result = `User answered ${verdict}.\nSelected: ${selectedStr}\nCorrect: ${correctStr}\nExplanation: ${args.explanation}`
-              ;(ctx as any).metadata?.({ title: correct ? "Quiz — correct ✓" : "Quiz — incorrect ✗", metadata: { correct, correctIndices, explanation: args.explanation } })
-            if (mdLogFile) await withMdLock(() => appendToMdLog(callout(correct ? "success" : "failure", correct ? "Quiz — correct ✓" : "Quiz — incorrect ✗", [`Q: ${args.question}`, `Selected: ${selectedStr}`, `Correct: ${correctStr}`, args.explanation])))
+            const result = `User answered ${verdict}.\nSelected: ${selectedStr}\nCorrect: ${correctStr}\nExplanation: ${eFixed}`
+              ;(ctx as any).metadata?.({ title: correct ? "Quiz — correct ✓" : "Quiz — incorrect ✗", metadata: { correct, correctIndices, explanation: eFixed } })
+            if (mdLogFile) await withMdLock(() => appendToMdLog(callout(correct ? "success" : "failure", correct ? "Quiz — correct ✓" : "Quiz — incorrect ✗", [`Q: ${qFixed}`, `Selected: ${selectedStr}`, `Correct: ${correctStr}`, eFixed])))
             return result
           }
           const instruction = [
             `[quiz ready — awaiting user answer via \`question\` tool]`,
-            `Question: ${args.question}`,
-            args.details ? `Details: ${args.details}` : null,
+            `Question: ${qFixed}`,
+            dFixed ? `Details: ${dFixed}` : null,
             `Options (display order, already shuffled):`,
             ...options.map((o, i) => `${i + 1}. ${o.label}${o.description ? ` — ${o.description}` : ""} (value="${o.value}")`),
             `Correct indices: ${correctIndices.join(", ")} (Correct values: ${correctStr})`,
-            `Explanation (reveal AFTER answer): ${args.explanation}`,
+            `Explanation (reveal AFTER answer): ${eFixed}`,
             `Mode: ${args.multiSelect ? "multi-select (exact set)" : "single-select"}`,
             ``,
             `INSTRUCTION FOR LLM: Call the built-in \`question\` tool with:`,
             `  header: "Quiz"`,
-            `  question: "${args.question.replace(/"/g, '\\"')}"`,
+            `  question: "${qFixed.replace(/"/g, '\\"')}"`,
             `  options: [${options.map(o => `{label:"${o.label.replace(/"/g, '\\"')}", description:"${(o.description ?? "").replace(/"/g, '\\"')}"}`).join(", ")}]`,
             `Then compare the user's selected labels to correct indices [${correctIndices.join(", ")}]. Grade as ${args.multiSelect ? "exact-set match" : "single match"}, show ✓/✗, reveal Correct: ${correctStr}, and Explanation. An 'I don't know' maps to dontKnow (genuine gap).`,
           ].filter(Boolean).join("\n")
-            ;(ctx as any).metadata?.({ title: `Quiz: ${args.question.slice(0, 40)}`, metadata: { correctIndices, explanation: args.explanation, options: options.map((o, i) => ({ index: i + 1, label: o.label })) } })
+            ;(ctx as any).metadata?.({ title: `Quiz: ${qFixed.slice(0, 40)}`, metadata: { correctIndices, explanation: eFixed, options: options.map((o, i) => ({ index: i + 1, label: o.label })) } })
           return instruction
         },
       }),
@@ -771,13 +939,17 @@ const server: Plugin = async ({ client, directory }) => {
           slog("quiz_batch isAlive", isAlive)
           const normalized: any[] = []
           for (const q of (args.quizzes as any[])) {
+            const qFixed = (decodeQuizText(q.question) ?? q.question) as string
+            const dFixed = decodeQuizText(q.details) as string | undefined
+            const eFixed = (decodeQuizText(q.explanation) ?? q.explanation) as string
+            const optsDecoded = (q.options as any[] | undefined)?.map((o: any) => ({ ...o, label: decodeQuizText(o.label) ?? o.label, description: o.description ? decodeQuizText(o.description) : o.description })) as any
             let opts: any
-            try { opts = normalizeQuizOptions(q.options) } catch (e) { slog("quiz_batch normalize error", (e as Error).message); return `quiz_batch error: ${(e as Error).message} in "${q.question}"` }
+            try { opts = normalizeQuizOptions(optsDecoded) } catch (e) { slog("quiz_batch normalize error", (e as Error).message); return `quiz_batch error: ${(e as Error).message} in "${qFixed}"` }
             if (q.shuffle !== false) opts = shuffleOptions(opts)
             const { indices, error } = resolveCorrect(q.correctAnswer as any, opts)
-            if (error) { slog("quiz_batch resolveCorrect error", error); return `quiz_batch error: ${error} in "${q.question}"` }
-            if (opts.length < 2) return `quiz_batch error: need 2+ options in "${q.question}"`
-            normalized.push({ question: q.question, details: q.details, options: opts, correctIndices: indices, explanation: q.explanation, multiSelect: !!q.multiSelect })
+            if (error) { slog("quiz_batch resolveCorrect error", error); return `quiz_batch error: ${error} in "${qFixed}"` }
+            if (opts.length < 2) return `quiz_batch error: need 2+ options in "${qFixed}"`
+            normalized.push({ question: qFixed, details: dFixed, options: opts, correctIndices: indices, explanation: eFixed, multiSelect: !!q.multiSelect })
           }
           slog("quiz_batch normalized", normalized.length)
           try { fs.mkdirSync(pendingDirPath, { recursive: true }) } catch {}

package/scripts/install.mjs

@@ -184,7 +184,7 @@ async function installOrUpdate() {
   const agentsSrc = join(root, "agents")
   const agentsDest = join(config, "agents")
   let agentsCount = 0
-  for (const f of ["researcher.md", "mermaid-maker.md", "svg-maker.md"]) {
+  for (const f of ["researcher.md", "mermaid-maker.md", "svg-maker.md", "classify.md"]) {
     try {
       await copyFile(join(agentsSrc, f), join(agentsDest, f))
       agentsCount++
@@ -216,7 +216,7 @@ async function installOrUpdate() {
 
   console.log(`Installed ${packageName}@${packageVersion} to ${config}`)
   if (changed) console.log(`Updated plugin registration in ${changed} config file(s)`)
-  console.log(`  Agents: ${agentsCount} (researcher, mermaid-maker, svg-maker)`)
+  console.log(`  Agents: ${agentsCount} (researcher, mermaid-maker, svg-maker, classify)`)
   console.log(`  Skills: ${skillsCount} (teach, visualize, marker-pdf-parser, notebooklm-lecture-notes)`)
   if (commandsCount) console.log(`  Commands: ${commandsCount}`)
   console.log(`  Plugin: ${packageName} (server) + ${packageName}/tui (TUI)`)
@@ -230,7 +230,7 @@ async function uninstall() {
   const changed = await configurePlugins(true)
 
   // Remove agents (only those we own)
-  for (const f of ["researcher.md", "mermaid-maker.md", "svg-maker.md"]) {
+  for (const f of ["researcher.md", "mermaid-maker.md", "svg-maker.md", "classify.md"]) {
     try { await rm(join(config, "agents", f), { force: true }) } catch {}
   }
   // Remove skills (including subdirectories like scripts/assets)