akm-opencode 0.8.0-rc1 → 0.8.0

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "akm-opencode",
-  "version": "0.8.0-rc1",
+  "version": "0.8.0",
   "type": "module",
-  "description": "OpenCode plugin for AKM v0.7.0 - search, show, and manage extension assets via the akm CLI, including vaults, wikis, workflows, the proposal queue, lesson assets, and reflect/propose/distill commands, with agentic hooks that auto-load relevant stash assets, record feedback, and harvest session memories so the stash improves every session.",
+  "description": "OpenCode plugin for AKM v0.8.0 - search, show, and manage extension assets via the akm CLI, including vaults, wikis, workflows, the proposal queue, lesson assets, and improve/propose commands, with agentic hooks that auto-load relevant stash assets, record feedback, and harvest session memories so the stash improves every session.",
   "keywords": [
     "opencode",
     "opencode-ai",
@@ -27,13 +27,20 @@
     "index.ts",
     "agent/",
     "commands/",
+    "shared/",
     "README.md"
   ],
   "main": "./index.ts",
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "prepack": "node ./scripts/vendor-shared.mjs",
+    "postpack": "node ./scripts/unvendor-shared.mjs"
+  },
   "dependencies": {
-    "@opencode-ai/plugin": "^1.2.20"
+    "@opencode-ai/plugin": "^1.2.20",
+    "akm-cli": "^0.8.0",
+    "semver": "^7.7.2"
   }
 }

package/shared/feedback-signals.ts

@@ -0,0 +1,74 @@
+export type AkmFeedbackSignal = {
+  ref: string
+  polarity: "positive" | "negative"
+  confidence: number
+  source:
+    | "explicit_user_feedback"
+    | "tool_success"
+    | "tool_failure"
+    | "retrospective_positive"
+    | "retrospective_negative"
+    | "workflow_completion"
+    | "proposal_acceptance"
+    | "proposal_rejection"
+    | "curator_assessment"
+  note: string
+  sessionId?: string
+  harness: "claude-code" | "opencode"
+}
+
+export function getAutoFeedbackMinConfidence(): number {
+  const raw = Number(process.env.AKM_AUTO_FEEDBACK_MIN_CONFIDENCE ?? "0.6")
+  return Number.isFinite(raw) ? raw : 0.6
+}
+
+export function classifyFeedbackSignal(input: {
+  ref: string
+  polarity: "positive" | "negative"
+  harness: "claude-code" | "opencode"
+  sessionId?: string
+  directInput?: boolean
+  explicitUser?: boolean
+  retrospective?: boolean
+  workflowCompletion?: boolean
+  proposalAction?: "accept" | "reject"
+  curatorAssessment?: boolean
+  note?: string
+}): AkmFeedbackSignal {
+  let source: AkmFeedbackSignal["source"] = input.polarity === "positive" ? "tool_success" : "tool_failure"
+  let confidence = input.directInput ? 0.65 : 0.25
+
+  if (input.explicitUser) {
+    source = "explicit_user_feedback"
+    confidence = 0.95
+  } else if (input.retrospective) {
+    source = input.polarity === "positive" ? "retrospective_positive" : "retrospective_negative"
+    confidence = input.polarity === "positive" ? 0.7 : 0.8
+  } else if (input.workflowCompletion) {
+    source = "workflow_completion"
+    confidence = 0.85
+  } else if (input.proposalAction === "accept") {
+    source = "proposal_acceptance"
+    confidence = 0.95
+  } else if (input.proposalAction === "reject") {
+    source = "proposal_rejection"
+    confidence = 0.85
+  } else if (input.curatorAssessment) {
+    source = "curator_assessment"
+    confidence = 0.75
+  }
+
+  return {
+    ref: input.ref,
+    polarity: input.polarity,
+    confidence,
+    source,
+    note: input.note ?? `${input.harness} auto: source=${source}; confidence=${confidence.toFixed(2)}`,
+    sessionId: input.sessionId,
+    harness: input.harness,
+  }
+}
+
+export function shouldSubmitAutomaticFeedback(signal: AkmFeedbackSignal): boolean {
+  return signal.confidence >= getAutoFeedbackMinConfidence()
+}

package/shared/memory-candidates.ts

@@ -0,0 +1,196 @@
+import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
+import path from "node:path"
+import { redactObject } from "./redaction"
+
+// Memory candidates can contain prompt fragments, ref names, and (despite
+// redaction) potentially sensitive contextual data harvested from session
+// activity. Lock the on-disk file down to user-only read/write so multi-user
+// hosts (CI runners, shared VMs, dev sandboxes) cannot side-read another
+// user's stash signals.
+function chmodSafe(filePath: string, mode: number): void {
+  try {
+    chmodSync(filePath, mode)
+  } catch {
+    // Best-effort: filesystems without POSIX mode (FAT, some FUSE mounts) or
+    // platforms where chmod is a no-op (Windows) silently skip. Don't crash
+    // the hook over a hardening attempt.
+  }
+}
+
+export type AkmMemoryCandidate = {
+  id: string
+  createdAt: string
+  harness: "claude-code" | "opencode"
+  sessionId?: string
+  sourceEventIds?: string[]
+  sourcePaths?: string[]
+  type:
+    | "preference"
+    | "constraint"
+    | "decision"
+    | "lesson"
+    | "workflow_state"
+    | "asset_feedback"
+    | "coverage_gap"
+    | "stale_memory"
+    | "unknown"
+  scope: "user" | "project" | "repo" | "branch" | "session" | "agent" | "workflow"
+  content: string
+  evidence: string[]
+  confidence: number
+  recommendedAction: "remember" | "distill" | "propose" | "feedback" | "ignore"
+  targetRef?: string
+  status: "pending" | "promoted" | "rejected"
+  reason?: string
+}
+
+const AKM_REF_RE = /(?:[A-Za-z0-9@._+/-]+\/\/)?(?:skill|command|agent|knowledge|memory|script|workflow|env|secret|wiki|lesson):[A-Za-z0-9._/-]+/g
+
+function uniq(values: string[]): string[] {
+  return [...new Set(values)]
+}
+
+function pickTargetRef(refs: string[]): string | undefined {
+  return refs.find((ref) => !ref.startsWith("memory:") && !ref.startsWith("env:") && !ref.startsWith("secret:")) ?? refs[0]
+}
+
+function extractRefs(value: string): string[] {
+  return uniq(value.match(AKM_REF_RE) ?? [])
+}
+
+export function getCandidateLogPath(harness: "claude-code" | "opencode"): string {
+  const root = process.env.XDG_STATE_HOME ?? path.join(process.env.HOME ?? ".", ".local", "state")
+  const dir = path.join(root, harness === "claude-code" ? "akm-claude" : "akm-opencode")
+  return path.join(dir, "memory-candidates.jsonl")
+}
+
+function makeCandidateId(harness: string, sessionId: string | undefined, index: number): string {
+  const stamp = new Date().toISOString().replace(/[-:.TZ]/g, "").slice(0, 14)
+  const sid = (sessionId ?? "session").replace(/[^A-Za-z0-9._-]/g, "").slice(0, 12) || "session"
+  return `${harness}-${sid}-${stamp}-${index}`
+}
+
+function classifyCandidate(
+  content: string,
+  refs: string[],
+): Pick<AkmMemoryCandidate, "type" | "scope" | "confidence" | "recommendedAction" | "targetRef"> {
+  const text = content.toLowerCase()
+  const targetRef = pickTargetRef(refs)
+  if (targetRef && /\b(worked|helped|useful|failed|broken|wrong|didn't work|did not work)\b/.test(text)) {
+    return { type: "asset_feedback", scope: "project", confidence: 0.72, recommendedAction: "feedback", targetRef }
+  }
+  if (/\b(always|never|must|should not|cannot|can't|do not|required)\b/.test(text)) {
+    return { type: "constraint", scope: "project", confidence: 0.8, recommendedAction: "remember" }
+  }
+  if (/\b(prefer|likes|dislikes|wants|remember)\b/.test(text)) {
+    return { type: "preference", scope: "user", confidence: 0.8, recommendedAction: "remember" }
+  }
+  if (/\b(decided|decision|use |chosen|architecture|approach)\b/.test(text)) {
+    return { type: "decision", scope: "project", confidence: 0.75, recommendedAction: "remember" }
+  }
+  if (/\b(blocked|failed|workflow|next step|resume)\b/.test(text)) {
+    return { type: "workflow_state", scope: "workflow", confidence: 0.7, recommendedAction: "remember" }
+  }
+  if (/\b(missing|coverage gap|todo|follow-up|followup)\b/.test(text)) {
+    return { type: "coverage_gap", scope: "project", confidence: 0.65, recommendedAction: "propose" }
+  }
+  if (/\b(lesson|fix|worked|resolved|solution)\b/.test(text)) {
+    return { type: "lesson", scope: "project", confidence: 0.7, recommendedAction: "distill", targetRef }
+  }
+  return { type: "unknown", scope: "session", confidence: 0.4, recommendedAction: "ignore" }
+}
+
+export function extractCandidatesFromText(input: {
+  harness: "claude-code" | "opencode"
+  sessionId?: string
+  text: string
+  evidence?: string[]
+  sourceEventIds?: string[]
+  sourcePaths?: string[]
+  targetRefHints?: string[]
+}): AkmMemoryCandidate[] {
+  const lines = input.text
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.length >= 20)
+    .filter((line) => !line.startsWith("#") && !line.startsWith("## "))
+
+  const selected = lines.filter((line) => /\b(always|never|must|should|prefer|remember|decision|decided|workflow|blocked|failed|worked|fix|missing|follow-up|followup)\b/i.test(line))
+  return selected.slice(0, 12).map((content, index) => {
+    const contentRefs = extractRefs(content)
+    const evidenceRefs = (input.evidence ?? []).flatMap(extractRefs)
+    const hintedRefs = input.targetRefHints ?? []
+    const refs = uniq([
+      ...contentRefs,
+      ...hintedRefs,
+      ...evidenceRefs,
+    ])
+    const details = classifyCandidate(content, refs)
+    const targetRef = details.targetRef ?? pickTargetRef([...contentRefs, ...hintedRefs, ...evidenceRefs])
+    return {
+      id: makeCandidateId(input.harness, input.sessionId, index + 1),
+      createdAt: new Date().toISOString(),
+      harness: input.harness,
+      sessionId: input.sessionId,
+      sourceEventIds: input.sourceEventIds,
+      sourcePaths: input.sourcePaths ? uniq(input.sourcePaths) : undefined,
+      type: details.type,
+      scope: details.scope,
+      content,
+      evidence: uniq([...(input.evidence ?? []), content]),
+      confidence: details.confidence,
+      recommendedAction: details.recommendedAction,
+      targetRef,
+      status: "pending",
+    }
+  })
+}
+
+export function appendCandidates(filePath: string, candidates: AkmMemoryCandidate[]): { ok: true; count: number; categories: string[] } | { ok: false; error: string } {
+  try {
+    mkdirSync(path.dirname(filePath), { recursive: true })
+    chmodSafe(path.dirname(filePath), 0o700)
+    const categories: string[] = []
+    const created = !existsSync(filePath)
+    for (const candidate of candidates) {
+      const redacted = redactObject(candidate)
+      categories.push(...redacted.categories)
+      appendFileSync(filePath, `${JSON.stringify(redacted.value)}\n`)
+    }
+    if (created) chmodSafe(filePath, 0o600)
+    return { ok: true, count: candidates.length, categories: [...new Set(categories)] }
+  } catch (error: unknown) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) }
+  }
+}
+
+export function readCandidates(filePath: string): AkmMemoryCandidate[] {
+  if (!existsSync(filePath)) return []
+  return readFileSync(filePath, "utf8")
+    .split("\n")
+    .filter(Boolean)
+    .flatMap((line) => {
+      try {
+        return [JSON.parse(line) as AkmMemoryCandidate]
+      } catch {
+        return []
+      }
+    })
+}
+
+export function replaceCandidates(filePath: string, candidates: AkmMemoryCandidate[]): void {
+  mkdirSync(path.dirname(filePath), { recursive: true })
+  chmodSafe(path.dirname(filePath), 0o700)
+  writeFileSync(filePath, candidates.map((candidate) => `${JSON.stringify(candidate)}\n`).join(""))
+  chmodSafe(filePath, 0o600)
+}
+
+export function updateCandidateStatus(filePath: string, id: string, status: "promoted" | "rejected", reason?: string): AkmMemoryCandidate | undefined {
+  const candidates = readCandidates(filePath)
+  const index = candidates.findIndex((candidate) => candidate.id === id)
+  if (index === -1) return undefined
+  const updated = { ...candidates[index], status, reason }
+  candidates[index] = updated
+  replaceCandidates(filePath, candidates)
+  return updated
+}

package/shared/memory-events.ts

@@ -0,0 +1,122 @@
+import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync } from "node:fs"
+import path from "node:path"
+import { redactObject } from "./redaction"
+
+// Memory events log session activity (refs touched, outcomes, scope). Even
+// post-redaction this is a privileged record; lock the directory + file down
+// to owner-only access. Mirrors memory-candidates' chmodSafe helper.
+function chmodSafe(target: string, mode: number): void {
+  try {
+    chmodSync(target, mode)
+  } catch {
+    // Best-effort; see memory-candidates.ts for rationale.
+  }
+}
+
+export type AkmMemoryEventType =
+  | "session_started"
+  | "prompt_recall"
+  | "tool_observation"
+  | "tool_batch_observation"
+  | "tool_ref_observed"
+  | "workflow_step"
+  | "workflow_started"
+  | "workflow_next_loaded"
+  | "workflow_step_completed"
+  | "workflow_step_blocked"
+  | "workflow_step_failed"
+  | "workflow_step_skipped"
+  | "workflow_evidence_attached"
+  | "workflow_drift_detected"
+  | "workflow_resumed"
+  | "workflow_abandoned"
+  | "task_created"
+  | "task_completed"
+  | "subagent_started"
+  | "subagent_completed"
+  | "pre_compact_checkpoint"
+  | "post_compact_summary"
+  | "session_ended"
+  | "candidate_extracted"
+  | "candidate_promoted"
+  | "candidate_rejected"
+  | "durable_memory_written"
+  | "feedback_recorded"
+  | "safety_blocked"
+
+export type AkmMemoryEvent = {
+  version: 1
+  timestamp: string
+  harness: "claude-code" | "opencode"
+  event: AkmMemoryEventType
+  eventId?: string
+  sessionId?: string
+  project?: string
+  agent?: string
+  workflowRunId?: string
+  scope?: {
+    user?: string
+    agent?: string
+    run?: string
+    channel?: string
+    project?: string
+    repo?: string
+    branch?: string
+  }
+  input?: Record<string, unknown>
+  memory?: Record<string, unknown>
+  refs?: string[]
+  outcome?: {
+    status: "ok" | "skipped" | "blocked" | "failed"
+    warnings?: string[]
+    error?: string
+  }
+  redaction?: {
+    redacted: boolean
+    categories: string[]
+  }
+}
+
+export function getHarnessStateDir(harness: "claude-code" | "opencode"): string {
+  const root = process.env.XDG_STATE_HOME ?? path.join(process.env.HOME ?? ".", ".local", "state")
+  return path.join(root, harness === "claude-code" ? "akm-claude" : "akm-opencode")
+}
+
+export function getEventLogPath(harness: "claude-code" | "opencode"): string {
+  return path.join(getHarnessStateDir(harness), "events.jsonl")
+}
+
+export function appendMemoryEvent(filePath: string, event: AkmMemoryEvent): { ok: true; redacted: boolean; categories: string[] } | { ok: false; error: string } {
+  try {
+    mkdirSync(path.dirname(filePath), { recursive: true })
+    chmodSafe(path.dirname(filePath), 0o700)
+    const redacted = redactObject(event)
+    const enriched = {
+      ...redacted.value,
+      redaction: {
+        redacted: redacted.redacted,
+        categories: redacted.categories,
+      },
+    }
+    const created = !existsSync(filePath)
+    appendFileSync(filePath, `${JSON.stringify(enriched)}\n`)
+    if (created) chmodSafe(filePath, 0o600)
+    return { ok: true, redacted: redacted.redacted, categories: redacted.categories }
+  } catch (error: unknown) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) }
+  }
+}
+
+export function readJsonl<T>(filePath: string): T[] {
+  if (!existsSync(filePath)) return []
+  return readFileSync(filePath, "utf8")
+    .split("\n")
+    .filter(Boolean)
+    .flatMap((line) => {
+      try {
+        return [JSON.parse(line) as T]
+      } catch {
+        return []
+      }
+    })
+}

package/shared/recall-policy.ts

@@ -0,0 +1,70 @@
+export type RecallDecision = {
+  shouldRecall: boolean
+  reason:
+    | "explicit-akm"
+    | "long-prompt"
+    | "memory-intent"
+    | "workflow-intent"
+    | "agent-dispatch"
+    | "command-dispatch"
+    | "wiki-intent"
+    | "proposal-intent"
+    | "release-intent"
+    | "coding-task"
+    | "active-workflow"
+    | "recent-asset-failure"
+    | "skip-short"
+    | "skip-chitchat"
+    | "skip-low-signal"
+  query: string
+  scopeHints?: string[]
+}
+
+const REF_RE = /(?:skill|command|agent|knowledge|workflow|lesson|wiki|memory|env|secret):[A-Za-z0-9._/-]+/i
+
+export function shouldRecall(prompt: string, options?: { activeWorkflow?: boolean; recentAssetFailure?: boolean }): RecallDecision {
+  const text = prompt.trim()
+  const lower = text.toLowerCase()
+  const scopeHints: string[] = []
+  if (!text) return { shouldRecall: false, reason: "skip-low-signal", query: "", scopeHints }
+  if (options?.activeWorkflow) return { shouldRecall: true, reason: "active-workflow", query: text, scopeHints: ["workflow"] }
+  if (options?.recentAssetFailure) return { shouldRecall: true, reason: "recent-asset-failure", query: text, scopeHints }
+  if (text.length < 4 || /^(ok|thanks|thank you|yes|no|continue|go ahead|sure|cool)$/i.test(lower)) {
+    return { shouldRecall: false, reason: "skip-short", query: text, scopeHints }
+  }
+  if (/\b(hi|hello|how are you|good morning|good night)\b/i.test(lower) && text.length < 40) {
+    return { shouldRecall: false, reason: "skip-chitchat", query: text, scopeHints }
+  }
+  if (/\bakm\b|\bstash\b/.test(lower) || REF_RE.test(text)) {
+    return { shouldRecall: true, reason: "explicit-akm", query: text, scopeHints: ["akm"] }
+  }
+  if (/\b(remember|memory|prior session|previous decision)\b/.test(lower)) {
+    return { shouldRecall: true, reason: "memory-intent", query: text, scopeHints: ["memory"] }
+  }
+  if (/\b(workflow|resume|complete step|next step|blocked step)\b/.test(lower)) {
+    return { shouldRecall: true, reason: "workflow-intent", query: text, scopeHints: ["workflow"] }
+  }
+  if (/\b(dispatch|agent|subagent|reviewer|planner|curator)\b/.test(lower)) {
+    return { shouldRecall: true, reason: "agent-dispatch", query: text, scopeHints: ["agent"] }
+  }
+  if (/\b(command|slash command|run the stash command)\b/.test(lower)) {
+    return { shouldRecall: true, reason: "command-dispatch", query: text, scopeHints: ["command"] }
+  }
+  if (/\b(wiki|docs|knowledge base|ingest|lint)\b/.test(lower)) {
+    return { shouldRecall: true, reason: "wiki-intent", query: text, scopeHints: ["wiki"] }
+  }
+  if (/\b(proposal|accept|reject|diff proposal|review proposals)\b/.test(lower)) {
+    return { shouldRecall: true, reason: "proposal-intent", query: text, scopeHints: ["proposal"] }
+  }
+  if (/\b(release|publish|semver|version bump|bump version|tag the release|cut a release)\b/.test(lower)) {
+    return { shouldRecall: true, reason: "release-intent", query: text, scopeHints: ["workflow", "command"] }
+  }
+  if (
+    text.length >= 16
+    && /\b(review|pull request|\bpr\b|diff|refactor|type hints|typing|readability|readable|debug|diagnose|traceback|exception|exceptions|scaffold|unit test|tests|test|changelog|release notes|deployment|deploy|rollback|runbook|error code|healthcheck|linters|lint|format|formatting|naming conventions|convention|style guide|onboarding|new hire|new engineer|api keys|secrets|plan|design|architecture|tradeoffs|build|implement|fix|update)\b/.test(lower)
+  ) {
+    return { shouldRecall: true, reason: "coding-task", query: text, scopeHints: ["code"] }
+  }
+  if (text.length >= 120) return { shouldRecall: true, reason: "long-prompt", query: text, scopeHints }
+  return { shouldRecall: false, reason: "skip-low-signal", query: text, scopeHints }
+}