akm-opencode 0.10.261106-beta → 0.10.261108-beta

package/dist/index.js

@@ -964,7 +964,8 @@ function shouldSubmitAutomaticFeedback(signal) {
 // ../claude/shared/ref-extraction.ts
 import { existsSync as existsSync3, statSync as statSync3 } from "fs";
 import path4 from "path";
-var AKM_REF_STRICT = /^(?:[A-Za-z0-9@._+-]+\/\/)?(?:agents|commands|env|facts|instructions|knowledge|lessons|memories|scripts|secrets|sessions|skills|tasks|workflows)\/[A-Za-z0-9._/-]+(?:#[A-Za-z0-9._~!$&'()*+,;=:@%/?-]+)?$/;
+var AKM_REF_STRICT = /^(?:[A-Za-z0-9@._+-]+\/\/)?[A-Za-z0-9@._+-]+(?:\/[A-Za-z0-9._+@-]+)*(?:#[A-Za-z0-9._~!$&'()*+,;=:@%/?-]+)?$/;
+var CONCEPT_ROOT_REF = /^(?:[A-Za-z0-9@._+-]+\/\/)?(?:agents|commands|env|facts|instructions|knowledge|lessons|memories|scripts|secrets|sessions|skills|tasks|workflows)\/[A-Za-z0-9._/-]+(?:#[A-Za-z0-9._~!$&'()*+,;=:@%/?-]+)?$/;
 var EDGE_PUNCTUATION = new Set([".", ",", ";", ":", "!", "?", "(", ")", "[", "]", "{", "}", "'", '"', "`"]);
 function normalizeToken(token) {
   let start = 0;
@@ -979,14 +980,39 @@ function extractAkmRefsFromString(text) {
   const refs = new Set;
   for (const token of text.split(/\s+/)) {
     const normalized = normalizeToken(token);
-    if (normalized && AKM_REF_STRICT.test(normalized))
+    if (normalized && CONCEPT_ROOT_REF.test(normalized))
       refs.add(normalized);
   }
   return [...refs];
 }
+function akmRefFromValue(value) {
+  if (typeof value !== "string")
+    return;
+  const ref = value.trim();
+  return AKM_REF_STRICT.test(ref) && !ref.split("#", 1)[0].split("//").pop().split("/").some((s) => s === "." || s === "..") ? ref : undefined;
+}
+function refsOfAkmResult(result) {
+  if (!result || typeof result !== "object")
+    return [];
+  const r = result;
+  const entries = [r, ...Array.isArray(r.hits) ? r.hits : [], ...Array.isArray(r.items) ? r.items : []];
+  const refs = entries.map((e) => e && typeof e === "object" ? akmRefFromValue(e.ref) : undefined);
+  return [...new Set(refs.filter((ref) => !!ref))];
+}
+function extractRefsFromAkmOutput(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    parsed = undefined;
+  }
+  const refLines = [...text.matchAll(/^\s*ref:\s*(\S+)\s*$/gm)].map((m) => akmRefFromValue(m[1]));
+  return [...new Set([...refsOfAkmResult(parsed), ...refLines.filter((r) => !!r), ...extractAkmRefsFromString(text)])];
+}
 function normalizeCandidate(candidate) {
   const canonical = normalizeToken(candidate);
-  if (!AKM_REF_STRICT.test(canonical))
+  const ref = akmRefFromValue(canonical);
+  if (!ref)
     return null;
   const withoutFragment = canonical.split("#", 1)[0] ?? "";
   const separator = withoutFragment.indexOf("//");
@@ -1022,37 +1048,41 @@ var SCRIPT_EXTENSIONS = new Set([
   ".kts"
 ]);
 function markdownFile(directPath) {
+  if (path4.basename(directPath).replace(/\.md$/, "") === "SKILL")
+    return false;
   return isFile(`${directPath}.md`) || directPath.endsWith(".md") && isFile(directPath);
 }
-function isAsset(type, directPath) {
-  if (type === "skills")
-    return isFile(path4.join(directPath, "SKILL.md"));
-  if (type === "scripts")
-    return SCRIPT_EXTENSIONS.has(path4.extname(directPath).toLowerCase()) && isFile(directPath);
-  if (type === "secrets")
-    return !/\.(lock|sensitive)$/.test(directPath) && isFile(directPath);
-  if (type === "tasks")
-    return isFile(`${directPath}.yml`);
-  if (type === "env") {
-    return isFile(`${directPath}.env`) || path4.basename(directPath) === "default" && isFile(path4.join(path4.dirname(directPath), ".env"));
-  }
-  return markdownFile(directPath);
-}
-var OUTSIDE_THEIR_DIRECTORY = new Set(["scripts", "agents", "commands", "facts", "instructions", "knowledge", "lessons", "memories", "sessions"]);
+function isAsset(directPath, ref) {
+  if (isFile(path4.join(directPath, "SKILL.md")) || markdownFile(directPath))
+    return true;
+  if (SCRIPT_EXTENSIONS.has(path4.extname(directPath).toLowerCase()) && isFile(directPath))
+    return true;
+  const folders = ref.split("/").slice(0, -1);
+  if (folders.includes("env")) {
+    if (isFile(`${directPath}.env`))
+      return true;
+    if (path4.basename(directPath) === "default" && isFile(path4.join(path4.dirname(directPath), ".env")))
+      return true;
+  }
+  if (folders.includes("tasks") && isFile(`${directPath}.yml`))
+    return true;
+  return folders.includes("secrets") && !/\.(lock|sensitive)$/.test(directPath) && isFile(directPath);
+}
+var LEGACY_PREFIXES = new Set(["scripts", "agents", "commands", "facts", "instructions", "knowledge", "lessons", "memories", "sessions"]);
 function conceptExistsInAnyBundle(conceptId, bundleRoots) {
-  const type = conceptId.split("/", 1)[0];
-  const rest = conceptId.slice(type.length + 1);
+  const head = conceptId.split("/", 1)[0];
+  const rest = conceptId.slice(head.length + 1);
   for (const root of bundleRoots) {
     if (!root)
       continue;
     const resolvedRoot = path4.resolve(root);
+    const inside = (file) => file !== resolvedRoot && file.startsWith(`${resolvedRoot}${path4.sep}`);
     const directPath = path4.resolve(resolvedRoot, conceptId);
-    if (directPath !== resolvedRoot && !directPath.startsWith(`${resolvedRoot}${path4.sep}`))
-      continue;
-    if (isAsset(type, directPath))
+    if (inside(directPath) && isAsset(directPath, conceptId))
       return true;
-    if (OUTSIDE_THEIR_DIRECTORY.has(type) && rest.includes("/") && !rest.startsWith(`${type}/`)) {
-      if (isAsset(type, path4.resolve(resolvedRoot, rest)))
+    if (LEGACY_PREFIXES.has(head) && rest.includes("/")) {
+      const legacyPath = path4.resolve(resolvedRoot, rest);
+      if (inside(legacyPath) && isAsset(legacyPath, rest))
         return true;
     }
   }
@@ -1101,35 +1131,9 @@ function classifyToolFeedback(value) {
     return "positive";
   return;
 }
-function extractToolRefs(toolName, args, output) {
-  const refs = new Set;
-  const addMatches = (value) => {
-    if (typeof value !== "string")
-      return;
-    for (const ref of extractAkmRefsFromString(value))
-      refs.add(ref);
-  };
-  for (const key of ["ref", "package_ref"])
-    addMatches(args[key]);
-  if (output && typeof output === "object") {
-    const o = output;
-    addMatches(o.ref);
-    if (Array.isArray(o.hits)) {
-      for (const hit of o.hits) {
-        if (hit && typeof hit === "object")
-          addMatches(hit.ref);
-      }
-    }
-    if (Array.isArray(o.items)) {
-      for (const item of o.items) {
-        if (item && typeof item === "object")
-          addMatches(item.ref);
-      }
-    }
-    if (toolName === "akm_remember" && typeof o.ref === "string")
-      addMatches(o.ref);
-  }
-  return [...refs];
+function extractToolRefs(args, output) {
+  const named = [args.ref, args.package_ref].map(akmRefFromValue).filter((ref) => !!ref);
+  return [...new Set([...named, ...refsOfAkmResult(output)])];
 }
 function extractAkmRefsFromAllArgs(args) {
   if (!args || typeof args !== "object")
@@ -1208,7 +1212,7 @@ function createFeedbackTracker(options) {
     const isAkmTool = input.tool.startsWith("akm_");
     const candidateRefs = [...new Set([...extractAkmRefsFromAllArgs(input.args), ...extractAkmRefsFromString(input.outputText)])];
     const parsed = isAkmTool ? parseToolOutput(input.outputText) : null;
-    const refs = isAkmTool && parsed ? extractToolRefs(input.tool, input.args, parsed) : validateRefCandidates(candidateRefs, [await input.getBundleDir() ?? ""]);
+    const refs = isAkmTool && parsed ? extractToolRefs(input.args, parsed) : validateRefCandidates(candidateRefs, [await input.getBundleDir() ?? ""]);
     const failedCall = classifyToolFeedback(parsed) === "negative";
     if (refs.length > 0) {
       input.writeEvent({
@@ -1228,7 +1232,7 @@ function createFeedbackTracker(options) {
   }
   function observeAkmToolResult(input) {
     const outcome = classifyToolFeedback(input.parsed);
-    const refs = extractToolRefs(input.tool, input.args, input.parsed);
+    const refs = extractToolRefs(input.args, input.parsed);
     const failedCall = outcome === "negative";
     if (!failedCall)
       noteRecentRefs(input.sessionID, refs);
@@ -3233,8 +3237,7 @@ async function runCli(client, args, meta) {
       stdout,
       stderr: ""
     });
-    const parsed = safeJsonParse(stdout);
-    const refs = args[0] === "search" || args[0] === "curate" ? [...new Set([...parsed?.hits?.flatMap((hit) => hit.ref ? [hit.ref] : []) ?? [], ...extractAkmRefsFromString(stdout)])] : extractAkmRefsFromString(stdout);
+    const refs = extractRefsFromAkmOutput(stdout);
     feedbackTracker.noteRecentRefs(meta.sessionID, refs);
     if (meta.toolName === "akm_search") {
       await emitWorkflowTelemetry(client, "info", "akm.search.invoked", {
@@ -3346,7 +3349,7 @@ async function runInProcess(client, operation, input, meta) {
       return result.output;
     }
     const output = result.output;
-    const refs = extractAkmRefsFromString(output);
+    const refs = extractRefsFromAkmOutput(output);
     feedbackTracker.noteRecentRefs(meta.sessionID, refs);
     await writePluginLog(client, "info", "AKM read call completed", {
       subsystem: "akm",
@@ -3617,7 +3620,7 @@ ${block}`;
             (async () => {
               try {
                 const curated = await runCurateForPrompt(logClient, decision.query, sessionID, directorySnapshot);
-                const refs = extractAkmRefsFromString(curated ?? "");
+                const refs = extractRefsFromAkmOutput(curated ?? "");
                 writeStructuredEvent({
                   event: "prompt_recall",
                   sessionId: sessionID,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akm-opencode",
-  "version": "0.10.261106-beta",
+  "version": "0.10.261108-beta",
   "type": "module",
   "description": "OpenCode plugin for AKM with discovery tools, feedback, memory, and automatic learning proposals from corrections and recurring workflows.",
   "keywords": [
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "@opencode-ai/plugin": "^1.18.14",
-    "akm-cli": "0.10.261106-beta"
+    "akm-cli": "0.10.261108-beta"
   },
   "devDependencies": {
     "@types/node": "^26.1.1",