akm-opencode 0.8.2 → 0.9.1

package/shared/vendor-semver.ts

@@ -0,0 +1,112 @@
+// Minimal vendored semver implementation. Covers exactly the subset used by
+// akm-hook.ts (`valid`, `satisfies` with caret ranges + `||` disjunction).
+//
+// Why vendored: the Claude plugin ships via `/plugin marketplace add` which
+// just clones the repo — `node_modules` is gitignored and no install runs on
+// the user's machine. Relying on Bun's auto-install for `semver` makes every
+// hook silently no-op when auto-install is disabled, offline, or rate-limited.
+// Vendoring this ~80 LOC removes the runtime dependency entirely.
+
+type Parsed = {
+  major: number
+  minor: number
+  patch: number
+  prerelease: Array<string | number>
+}
+
+const SEMVER_RE = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/
+
+function parse(input: string): Parsed | null {
+  const m = String(input).trim().replace(/^v/, "").match(SEMVER_RE)
+  if (!m) return null
+  const [, maj, min, pat, pre] = m
+  const prerelease = pre ? pre.split(".").map((p) => (/^\d+$/.test(p) ? Number(p) : p)) : []
+  return { major: Number(maj), minor: Number(min), patch: Number(pat), prerelease }
+}
+
+export function valid(input: string | null | undefined): string | null {
+  if (!input) return null
+  if (!parse(input)) return null
+  return String(input).trim().replace(/^v/, "")
+}
+
+function cmp(a: Parsed, b: Parsed): number {
+  if (a.major !== b.major) return a.major < b.major ? -1 : 1
+  if (a.minor !== b.minor) return a.minor < b.minor ? -1 : 1
+  if (a.patch !== b.patch) return a.patch < b.patch ? -1 : 1
+  if (a.prerelease.length === 0 && b.prerelease.length === 0) return 0
+  // A version without prerelease has HIGHER precedence than one with.
+  if (a.prerelease.length === 0) return 1
+  if (b.prerelease.length === 0) return -1
+  const n = Math.min(a.prerelease.length, b.prerelease.length)
+  for (let i = 0; i < n; i++) {
+    const ai = a.prerelease[i]
+    const bi = b.prerelease[i]
+    const aNum = typeof ai === "number"
+    const bNum = typeof bi === "number"
+    if (aNum && !bNum) return -1
+    if (!aNum && bNum) return 1
+    if (aNum && bNum) {
+      if (ai !== bi) return (ai as number) < (bi as number) ? -1 : 1
+    } else {
+      const s = String(ai)
+      const t = String(bi)
+      if (s !== t) return s < t ? -1 : 1
+    }
+  }
+  if (a.prerelease.length !== b.prerelease.length) return a.prerelease.length < b.prerelease.length ? -1 : 1
+  return 0
+}
+
+type CaretRange = { min: Parsed; maxExclusive: Parsed; allowPrereleases: boolean }
+
+function parseCaretRange(token: string): CaretRange | null {
+  const m = token.trim().match(/^\^(.+)$/)
+  if (!m) return null
+  const min = parse(m[1])
+  if (!min) return null
+  let maxExclusive: Parsed
+  if (min.major > 0) {
+    maxExclusive = { major: min.major + 1, minor: 0, patch: 0, prerelease: [] }
+  } else if (min.minor > 0) {
+    maxExclusive = { major: 0, minor: min.minor + 1, patch: 0, prerelease: [] }
+  } else {
+    maxExclusive = { major: 0, minor: 0, patch: min.patch + 1, prerelease: [] }
+  }
+  return { min, maxExclusive, allowPrereleases: min.prerelease.length > 0 }
+}
+
+export function satisfies(version: string, range: string): boolean {
+  const v = parse(version)
+  if (!v) return false
+  const branches = range.split("||").map((s) => s.trim())
+  for (const branch of branches) {
+    const tokens = branch.split(/\s+/).filter(Boolean)
+    let ok = true
+    for (const t of tokens) {
+      const r = parseCaretRange(t)
+      if (!r) {
+        ok = false
+        break
+      }
+      if (cmp(v, r.min) < 0 || cmp(v, r.maxExclusive) >= 0) {
+        ok = false
+        break
+      }
+      // node-semver default: prereleases only satisfy a range whose lower
+      // bound also has a prerelease AND shares the same major.minor.patch.
+      if (v.prerelease.length > 0) {
+        if (!r.allowPrereleases) {
+          ok = false
+          break
+        }
+        if (v.major !== r.min.major || v.minor !== r.min.minor || v.patch !== r.min.patch) {
+          ok = false
+          break
+        }
+      }
+    }
+    if (ok) return true
+  }
+  return false
+}

package/agent/akm-curator.md

@@ -1,66 +0,0 @@
----
-mode: subagent
-description: AKM stash curator. Reviews session activity and proposes stash improvements.
-permission:
-  task: deny
-tools:
-  akm_env: deny
-  write: deny
-  bash: deny
----
-
-You are the AKM curator — a compound-engineering agent that keeps the user's AKM stash improving every time the main agent finishes a task.
-
-Inputs you should inspect:
-1. OpenCode app logs that include the "akm-opencode" service (feedback, memory, tool invocations).
-2. Session-summary memories named memory:opencode-session-*.
-3. The live stash: call akm_search "" --limit 50 and akm_show <ref> to enumerate assets; use akm_help topic="list sources" when you need the configured-sources view.
-4. Parent-session context via akm_parent_messages when this session was dispatched as a child.
-
-Signals to act on:
-- Hot refs: assets repeatedly appearing in positive tool outcomes. Call akm_feedback <ref> positive --note "curator: consistently useful" to reinforce.
-- Cold refs: assets tied to failures or user complaints. Record akm_feedback <ref> negative --note "<excerpt>" and open the asset for review.
-- Lesson candidates: repeated memories or failures that should become a proposed lesson. Use akm_help topic="improve" to surface the v0.8.0 improve flow (which replaces the old reflect/distill split) and propose an akm_improve <ref> call.
-- Missing coverage: recurring user prompts with no matching asset. Draft a new skill, command, knowledge doc, wiki page, or workflow in the working stash and reindex via the akm CLI (see akm_help topic="reindex").
-- Pending proposals: list or diff them via akm_help topic="proposal" and recommend accept, reject, or revise. Never accept or reject without explicit user approval.
-- Duplicates / drift: near-identical descriptions or overlapping responsibilities. Propose a consolidation.
-- Stale memories: session summaries that never get recalled. Propose removal (see akm_help topic="remove") once distilled into a durable knowledge doc or wiki page.
-- Wiki hygiene: for each wiki returned by akm_wiki list, run akm_wiki lint <name> and report orphans, broken xrefs, uncited raws, and stale indexes as fix candidates.
-- Stuck workflows: run akm_workflow list --active and surface any runs in blocked or failed state with their step ids. Propose whether to resume or escalate.
-- Never touch env or secret values: do not call akm_env run or akm_secret path unless the user explicitly asks. Values must never appear in reports.
-
-Rules of engagement:
-- Never apply destructive changes without explicit user approval.
-- Report findings as a prioritized action list of concrete akm_* tool calls the user can run.
-- Prefer small, reversible edits: promote via positive feedback, draft a candidate skill, or clone and tweak.
-- When drafting new assets, write them into the working stash directory under skills/, commands/, agents/, knowledge/, or scripts/. Use akm_help (topic="config" / topic="reindex") to look up the right CLI invocation when you need the stash path or want to force a reindex.
-- When finished, persist your own summary with akm_remember (name: curator-run-<timestamp>) so the next curator run can build on yours.
-
-Output shape: end every run with a markdown report that has these sections:
-
-## Hot assets (promote)
-- <ref> — why it helped — command to run
-
-## Cold assets (investigate)
-- <ref> — failure signal — proposed fix
-
-## Lesson candidates
-- <theme> — evidence refs — `akm improve <ref>` or `akm propose <type> <name> --task "..."` command to run
-
-## Coverage gaps
-- <theme> — proposed asset (type, name, one-line description)
-
-## Pending proposals
-- <proposal id> — summary — accept/reject/revise recommendation
-
-## Duplicates / drift
-- <ref a> vs <ref b> — consolidation proposal
-
-## Wiki health
-- <wiki> — lint findings (orphan, broken-xref, uncited-raw, stale-index) with suggested fix
-
-## Workflow health
-- <workflow|runId> — blocked/failed state — resume or escalate
-
-## Housekeeping
-- stale memories, reindex needs, config tweaks

package/commands/akm-evolve-session.md

@@ -1,15 +0,0 @@
-Run a full AKM session evolution review.
-
-End with these sections:
-
-## Hot assets
-## Cold assets
-## Lesson candidates
-## Coverage gaps
-## Pending proposals
-## Duplicates / drift
-## Wiki health
-## Workflow health
-## Housekeeping
-
-Use `akm_help` before long-tail raw CLI commands, and never accept or reject proposals or run risky AKM commands without explicit user approval.

package/commands/akm-improve-asset.md

@@ -1,9 +0,0 @@
-Improve existing AKM assets or distill repeated evidence into proposals.
-
-1. Identify the strongest evidence refs or the asset type that needs work.
-2. Record negative feedback when justified.
-3. Call `akm_help` with `topic: "improve"`.
-4. Run `akm improve [<type>|<ref>] [--task "..."]`.
-5. List resulting pending proposals and do not accept or reject them without explicit user approval.
-
-Improve-profile config (`profiles.improve.<name>`) shapes the run: `processes.triage` is a triage PRE-pass that drains the pending backlog by a deterministic policy (`{ enabled, applyMode: queue|promote, policy, maxAcceptsPerRun, maxDiffLines, rejectEmpty, judgment }`, same engine as `akm proposal drain`); `sync` (`{ enabled, push, message }`, with `{timestamp}{date}{time}{scope}{refs}{accepted}` message tokens) commits/pushes a git-backed stash at end of run. Override sync with `akm improve --sync/--no-sync` and `--push/--no-push`. Triage + `akm proposal drain` is the built-in replacement for the old manual proposal-management agent session.

package/commands/akm-propose-asset.md

@@ -1,8 +0,0 @@
-Create a proposed AKM asset for a coverage gap.
-
-1. Search or curate first.
-2. Confirm the gap is real.
-3. Call `akm_help` with `topic: "propose"`.
-4. Choose the smallest suitable asset type.
-5. Run `akm propose <type> <name> --task "..."` or `akm propose <type> <name> --file ./prompt.md`.
-6. Show proposal review commands and remind the user that proposed assets are not curated until accepted.

package/commands/akm-review-proposals.md

@@ -1,8 +0,0 @@
-Review pending AKM proposals safely.
-
-1. Call `akm_help` with `topic: "proposal"`.
-2. Run `akm proposal list --status pending --format json`.
-3. For relevant proposals, run `akm proposal show <id>` and `akm proposal diff <id>` (positional id).
-4. Summarize the likely accept, reject, or revise outcome.
-5. Do not run `akm proposal accept` or `akm proposal reject` unless the user explicitly approves the exact command.
-6. For a large backlog, suggest the deterministic bulk path: `akm proposal drain --policy <personal-stash|conservative|manual> --dry-run` to preview, then `--promote --yes` only after explicit approval (mutating; commits to git, no batch revert). This — plus the automatic `processes.triage` pre-pass inside `akm improve` — is the built-in replacement for the old manual proposal-management agent session.

package/commands/akm-workflow-status.md

@@ -1,7 +0,0 @@
-Inspect the current AKM workflow state safely.
-
-1. List active workflow runs.
-2. Show blocked or failed steps.
-3. Identify the next evidence needed.
-4. Recommend only safe next actions.
-5. Do not bypass review, approval, or verification requirements.

package/shared/memory-candidates.ts

@@ -1,196 +0,0 @@
-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
-}