@bojackduy/opencode-learn 0.1.5 → 1.0.0

package/agents/classify.md

@@ -0,0 +1,17 @@
+---
+name: classify
+description: Map learner free-text note (Vietnamese or English) to closest quiz option(s) and judge semantic correctness. Returns strict JSON only.
+thinking: low
+system-prompt: append
+auto-exit: true
+mode: subagent
+---
+
+You map a learner's free-text note to quiz options. You are lenient for learner-easy but auditable.
+
+Rules:
+
+- Only pick from given Options 1..N, no new options. Return inferred as indices that note best matches. Consider Vietnamese translations, synonyms, and "not fully" hedges.
+- Also judge semanticCorrect: true if note demonstrates valid understanding or deeper nuance, even when inferred != correct key. For standard facts (e.g., binary search requires sorted for vanilla), a note about rotate/mountain variant is valid nuance but the standard True still stands — in that case inferred is [2] but semanticCorrect may be true if note shows insight; the popup will show both.
+- Return ONLY JSON: {"inferred":[2],"semanticCorrect":false,"reason":"short reason in English"} — no extra text, no markdown.
+- If note is vague, empty, or "I don't know", inferred=[], semanticCorrect=false.

package/dist/server.js

@@ -147,6 +147,18 @@ function resolveCorrect(correctAnswer, options) {
   }
   return { indices: Array.from(new Set(indices)).sort((a, b) => a - b) };
 }
+function decodeQuizText(s) {
+  if (!s || typeof s !== "string")
+    return s;
+  if (!s.includes("\\"))
+    return s;
+  let out = s.replace(/\\r\\n/g, `
+`).replace(/\\n/g, `
+`).replace(/\\r/g, "\r").replace(/\\t/g, "\t");
+  out = out.replace(/\\"/g, '"').replace(/\\'/g, "'");
+  out = out.replace(/\\\\/g, "\\");
+  return out;
+}
 var mdLogFile = null;
 var mdLogWriteLock = Promise.resolve();
 function withMdLock(fn) {
@@ -513,10 +525,183 @@ var server = async ({ client, directory }) => {
   const loggedTextPartIds = new Set;
   const loggedToolCallIds = new Set;
   const messageIdToRole = new Map;
+  function heuristicClassify(note, options) {
+    const n = note.toLowerCase();
+    const out = [];
+    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(client2, directory2, note, options, question, parentSessionID) {
+    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}
+` : ""}Options:
+${options.map((o, i) => `${i + 1}. ${o.label} (value: ${o.value || o.label})`).join(`
+`)}
+
+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 = { title };
+      if (parentSessionID)
+        body.parentID = parentSessionID;
+      const created = await client2.session.create({ body, query: { directory: directory2 } });
+      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 client2.session.prompt({ path: { id: sid }, body: { parts: [{ type: "text", text: prompt }], agent: "classify" } });
+      for (let i = 0;i < 24; i++) {
+        await new Promise((r) => setTimeout(r, 500));
+        try {
+          const msgs = await client2.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) => p.type === "text").map((p) => p.text).join(" ") || "";
+              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) => 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) => 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(client2, directory2) {
+    const dir = pendingDir(directory2);
+    try {
+      fs.mkdirSync(dir, { recursive: true });
+    } catch {}
+    const processClassify = async (filename) => {
+      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;
+      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(data.options.map((o, i) => [o.value, i + 1]));
+      const start = Date.now();
+      let inferred = [];
+      let semanticCorrect;
+      let reason;
+      const llmRes = await llmClassify(client2, directory2, 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)}"`);
+      }
+      const elapsed = Date.now() - start;
+      if (elapsed < 1200)
+        await new Promise((r) => setTimeout(r, 1200 - elapsed));
+      const inferredValues = inferred.map((i) => data.options[i - 1]?.value).filter(Boolean);
+      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))) {
+            const idx = byVal.get(o.value);
+            if (idx)
+              inferred.push(idx);
+          }
+        }
+      }
+      slog("classify inferred", data.id, inferred.join(",") || "(none)", `semantic:${semanticCorrect} reason:${reason || ""} sid:${llmRes?.sessionID || ""} note:"${data.note.slice(0, 60)}"`);
+      const out = { id: data.id, inferredIndices: inferred, inferredValues, semanticCorrect, reason, classifySessionID: llmRes?.sessionID, note: data.note, at: Date.now() };
+      try {
+        fs.writeFileSync(respPath, JSON.stringify(out), "utf8");
+        slog("classify response written", data.id, inferred.join(","));
+      } catch {}
+    };
+    try {
+      for (const f of fs.readdirSync(dir).filter((f2) => f2.startsWith("classify-") && !f2.startsWith("classify-response-"))) {
+        processClassify(f);
+      }
+    } catch {}
+    try {
+      const w = fs.watch(dir, (_e, filename) => {
+        if (filename)
+          processClassify(filename);
+      });
+      w.on("error", () => {});
+    } catch {}
+  }
+  startClassifyWatcher(client, directory);
   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) {
@@ -574,7 +759,7 @@ Explanation: ${j.explanation}${note}`;
     config: async (output) => {
       const agents = output.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]) {
           agents[name] = { mode: "subagent", description: `${name} subagent (from learn plugin)`, permission: { "*": "allow" } };
           mutated = true;
@@ -718,9 +903,13 @@ Explanation: ${j.explanation}${note}`;
           shuffle: tool.schema.boolean().optional().describe("Default true: shuffle before display. False only if order matters.")
         },
         async execute(args, ctx) {
+          const qFixed = decodeQuizText(args.question) ?? args.question;
+          const dFixed = decodeQuizText(args.details);
+          const eFixed = decodeQuizText(args.explanation) ?? args.explanation;
+          const optsDecoded = args.options?.map((o) => ({ ...o, label: decodeQuizText(o.label) ?? o.label, description: o.description ? decodeQuizText(o.description) : o.description }));
           let options;
           try {
-            options = normalizeQuizOptions(args.options);
+            options = normalizeQuizOptions(optsDecoded);
           } catch (e) {
             return `quiz error: ${e.message}`;
           }
@@ -744,11 +933,11 @@ Explanation: ${j.explanation}${note}`;
           const payload = {
             id,
             type: "quiz",
-            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.sessionID,
             timestamp: Date.now()
@@ -760,7 +949,7 @@ Explanation: ${j.explanation}${note}`;
             slog("quiz write failed", String(e));
           }
           try {
-            await ctx.metadata?.({ title: `Quiz: ${args.question.slice(0, 40)}`, metadata: { pendingId: id } });
+            await ctx.metadata?.({ title: `Quiz: ${qFixed.slice(0, 40)}`, metadata: { pendingId: id } });
           } catch {}
           watchAndInject(client, directory, id, ctx.sessionID, (r) => {
             const dk = !!r?.dontKnow;
@@ -776,21 +965,21 @@ Note: ${r.note}` : "";
                 answers: r?.answers || [],
                 correct: ok,
                 correctIndices,
-                explanation: args.explanation,
+                explanation: eFixed,
                 dontKnow: dk,
                 note: r?.note
               };
               withMdLock(() => appendToMdLog(answerCalloutQuiz(details)));
             }
-            return dk ? `[quiz answered] "${args.question}" -> I don't know (genuine gap).
+            return dk ? `[quiz answered] "${qFixed}" -> I don't know (genuine gap).
 Correct: ${correctStr}
-Explanation: ${args.explanation}${note}` : `[quiz answered] "${args.question}" -> ${sel} = ${ok ? "CORRECT" : "INCORRECT"}.
+Explanation: ${eFixed}${note}` : `[quiz answered] "${qFixed}" -> ${sel} = ${ok ? "CORRECT" : "INCORRECT"}.
 Correct: ${correctStr}
-Explanation: ${args.explanation}${note}`;
+Explanation: ${eFixed}${note}`;
           });
           if (mdLogFile) {
             try {
-              await withMdLock(() => appendToMdLog(questionCallout("Quiz", args.question, args.details?.trim() || undefined, options.map((o) => ({ label: o.label })))));
+              await withMdLock(() => appendToMdLog(questionCallout("Quiz", qFixed, dFixed?.trim() || undefined, options.map((o) => ({ label: o.label })))));
             } catch {}
           }
           if (tuiAlive) {
@@ -825,9 +1014,9 @@ ${args.multiSelect ? "Select all correct (comma-separated numbers, e.g. 1,3) or
             if (trimmed === "0" || trimmed.toLowerCase() === "i don't know") {
               const msg = `User selected "I don't know" \u2014 genuine gap, not a guess.
 Correct: ${correctStr}
-Explanation: ${args.explanation}`;
+Explanation: ${eFixed}`;
               if (mdLogFile)
-                await withMdLock(() => appendToMdLog(callout("question", "Quiz \u2014 I don't know", [args.question, trimmed, `Correct: ${correctStr}`, args.explanation])));
+                await withMdLock(() => appendToMdLog(callout("question", "Quiz \u2014 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);
@@ -839,30 +1028,30 @@ Explanation: ${args.explanation}`;
             const result = `User answered ${verdict}.
 Selected: ${selectedStr}
 Correct: ${correctStr}
-Explanation: ${args.explanation}`;
-            ctx.metadata?.({ title: correct ? "Quiz \u2014 correct \u2713" : "Quiz \u2014 incorrect \u2717", metadata: { correct, correctIndices, explanation: args.explanation } });
+Explanation: ${eFixed}`;
+            ctx.metadata?.({ title: correct ? "Quiz \u2014 correct \u2713" : "Quiz \u2014 incorrect \u2717", metadata: { correct, correctIndices, explanation: eFixed } });
             if (mdLogFile)
-              await withMdLock(() => appendToMdLog(callout(correct ? "success" : "failure", correct ? "Quiz \u2014 correct \u2713" : "Quiz \u2014 incorrect \u2717", [`Q: ${args.question}`, `Selected: ${selectedStr}`, `Correct: ${correctStr}`, args.explanation])));
+              await withMdLock(() => appendToMdLog(callout(correct ? "success" : "failure", correct ? "Quiz \u2014 correct \u2713" : "Quiz \u2014 incorrect \u2717", [`Q: ${qFixed}`, `Selected: ${selectedStr}`, `Correct: ${correctStr}`, eFixed])));
             return result;
           }
           const instruction = [
             `[quiz ready \u2014 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 ? ` \u2014 ${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 \u2713/\u2717, reveal Correct: ${correctStr}, and Explanation. An 'I don't know' maps to dontKnow (genuine gap).`
           ].filter(Boolean).join(`
 `);
-          ctx.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.metadata?.({ title: `Quiz: ${qFixed.slice(0, 40)}`, metadata: { correctIndices, explanation: eFixed, options: options.map((o, i) => ({ index: i + 1, label: o.label })) } });
           return instruction;
         }
       }),
@@ -890,23 +1079,27 @@ Explanation: ${args.explanation}`;
           slog("quiz_batch isAlive", isAlive);
           const normalized = [];
           for (const q of args.quizzes) {
+            const qFixed = decodeQuizText(q.question) ?? q.question;
+            const dFixed = decodeQuizText(q.details);
+            const eFixed = decodeQuizText(q.explanation) ?? q.explanation;
+            const optsDecoded = q.options?.map((o) => ({ ...o, label: decodeQuizText(o.label) ?? o.label, description: o.description ? decodeQuizText(o.description) : o.description }));
             let opts;
             try {
-              opts = normalizeQuizOptions(q.options);
+              opts = normalizeQuizOptions(optsDecoded);
             } catch (e) {
               slog("quiz_batch normalize error", e.message);
-              return `quiz_batch error: ${e.message} in "${q.question}"`;
+              return `quiz_batch error: ${e.message} in "${qFixed}"`;
             }
             if (q.shuffle !== false)
               opts = shuffleOptions(opts);
             const { indices, error } = resolveCorrect(q.correctAnswer, opts);
             if (error) {
               slog("quiz_batch resolveCorrect error", error);
-              return `quiz_batch error: ${error} in "${q.question}"`;
+              return `quiz_batch error: ${error} in "${qFixed}"`;
             }
             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 });
+              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 {