akm-opencode 0.8.2 → 0.9.0

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.