@bojackduy/opencode-learn 0.1.5 → 0.1.6

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

@@ -513,10 +513,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 +747,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;