opencode-agent-skills-md 1.0.0 → 1.1.0

package/dist/src/cli/config.d.ts

@@ -0,0 +1,144 @@
+/** npm package name for this plugin. */
+export declare const PLUGIN_NAME = "opencode-agent-skills-md";
+/** Maximum number of CLI-created backups retained in the config directory. */
+export declare const BACKUP_LIMIT = 3;
+/** Filename used for the OpenCode global config (preferred). */
+export declare const CONFIG_FILE_BASENAME = "opencode";
+/** Subdirectory under the user config root that holds `opencode.json`. */
+export declare const OPENCODE_CONFIG_SUBDIR = "opencode";
+/**
+ * Minimal synchronous filesystem surface that the `oas` CLI commands rely
+ * on. The CLI never imports `node:fs` directly — every disk operation
+ * goes through this boundary so tests can run fully in memory.
+ *
+ * The methods intentionally mirror only the operations the CLI needs:
+ * helpers that demand more (e.g. `rmSync` for recursive directory
+ * removal during uninstall purge) live outside this interface and call
+ * `node:fs` directly at the call site, where they belong.
+ */
+export interface CliFs {
+    readFileSync(path: string): string;
+    writeFileSync(path: string, content: string): void;
+    renameSync(from: string, to: string): void;
+    copyFileSync(from: string, to: string): void;
+    unlinkSync(path: string): void;
+    mkdirSync(path: string, opts?: {
+        recursive?: boolean;
+    }): void;
+    readdirSync(path: string): string[];
+    existsSync(path: string): boolean;
+}
+export interface ResolvedConfigPath {
+    /** Absolute path to use for reads/writes. `.json` by default. */
+    path: string;
+    /** "json" when the resolved file ends in `.json`, "jsonc" otherwise. */
+    format: "json" | "jsonc";
+    /** True when `path` already existed on disk before resolution. */
+    existed: boolean;
+}
+/**
+ * Resolve the parent directory that holds the global OpenCode config.
+ * `$OPENCODE_CONFIG_DIR` wins; otherwise we fall back to
+ * `$HOME/.config/opencode` (or `os.homedir()` as a last-resort).
+ *
+ * Exposed separately so tests and the rotation helper can reuse it
+ * without re-deriving the precedence rules.
+ */
+export declare const resolveConfigDir: (env?: NodeJS.ProcessEnv) => string;
+/**
+ * Resolve the global OpenCode config file path.
+ *
+ * Precedence:
+ *   1. If `$OPENCODE_CONFIG_DIR/opencode.json` exists, use it.
+ *   2. Else if `$OPENCODE_CONFIG_DIR/opencode.jsonc` exists, use it.
+ *   3. Else fall back to `$HOME/.config/opencode/opencode.json`, then `.jsonc`.
+ *   4. If nothing exists, return the preferred target `.json` in the
+ *      resolved directory so `install` knows where to create the file.
+ *
+ * `.json` always wins over `.jsonc` when both exist.
+ */
+export declare const resolveGlobalConfigPath: (fs: CliFs, env?: NodeJS.ProcessEnv) => ResolvedConfigPath;
+/**
+ * Strip JSONC-style comments and trailing commas, then parse with `JSON.parse`.
+ *
+ * Returns `{}` for empty input or whitespace-only input.
+ * **Throws** on malformed JSON — callers must handle the error to avoid
+ * silently overwriting a corrupt config with an empty one.
+ */
+export declare const parseJsonc: (text: string) => Record<string, unknown>;
+/**
+ * True when `entry` is a string that resolves to this plugin by base name.
+ * Matches `opencode-agent-skills-md` and any `opencode-agent-skills-md@<spec>`
+ * variant. Non-string entries (legacy object-form leftover) return false.
+ */
+export declare const matchesPlugin: (entry: unknown) => boolean;
+/**
+ * Coerce the raw value of `config.plugin` into a clean string array.
+ *
+ * Handles:
+ *   - `undefined` / `null`                 → `[]`
+ *   - array of strings (or mixed)          → only the string entries
+ *   - the broken object form `{ "<name>": ... }` → the keys (in declaration order)
+ *   - any other non-object, non-array shape → `[]` (doctor surfaces it)
+ */
+export declare const normalizePlugin: (raw: unknown) => string[];
+/**
+ * Dedupe the plugin list by base name (the part before the first `@`),
+ * keeping the LAST occurrence of each base. Any `opencode-agent-skills-md`
+ * entries are removed entirely so the install flow can append one fresh
+ * entry at the end without leaving stale versions behind.
+ *
+ * Order is preserved for the surviving entries (last-wins per base).
+ */
+export declare const dedupePlugins: (entries: readonly string[]) => string[];
+/**
+ * Build the npm specifier we will write into `plugin[]`:
+ * `"opencode-agent-skills-md"` when no version is supplied, otherwise
+ * `"opencode-agent-skills-md@<version>"`. Empty / whitespace-only versions
+ * are treated as "no version".
+ */
+export declare const buildSpecifier: (version?: string) => string;
+/**
+ * If `configPath` already exists, copy it next to itself as a timestamped
+ * sibling and prune older CLI-created backups so at most `BACKUP_LIMIT`
+ * survive (newest first). Returns the backup path, or `null` when no
+ * backup was needed (file missing or not writable).
+ */
+export declare const backupIfWritable: (configPath: string, fs: CliFs) => string | null;
+/**
+ * Prune CLI-created backups of `configPath`, keeping only the newest
+ * `limit` siblings (lexical order on the timestamp suffix is fine because
+ * the stamp is fixed-width and ISO-8601-derived).
+ */
+export declare const rotateBackups: (configPath: string, limit: number, fs: CliFs) => void;
+/**
+ * Write `content` to `targetPath` via a temp sibling + rename. The
+ * rename is atomic on POSIX (and best-effort on Windows), so a crashed
+ * CLI never leaves a half-written config behind. Any parent directories
+ * are created with `{ recursive: true }` so first-run installs Just Work.
+ */
+export declare const writeAtomically: (targetPath: string, content: string, fs: CliFs) => void;
+export interface LoadedConfig {
+    /** Absolute path the loader used (existing or newly-targeted). */
+    path: string;
+    /** Parsed config object — `{}` if the file was absent or unreadable. */
+    config: Record<string, unknown>;
+    /** Whether the file existed on disk before loading. */
+    existed: boolean;
+    /**
+     * If the existing config file is malformed JSON, this contains the
+     * error message. Commands must check this and abort rather than
+     * silently overwriting the corrupt file with an empty config.
+     */
+    parseError?: string;
+}
+/**
+ * Resolve the global config path, read it (if it exists), and parse it.
+ * Missing files yield `config = {}` and `existed = false` so the install
+ * flow can treat "fresh install" and "already installed" the same way.
+ *
+ * Malformed JSONC is surfaced via `LoadedConfig.parseError`. Commands MUST
+ * check this field and abort instead of silently overwriting the user's
+ * corrupt config with an empty one.
+ */
+export declare const loadGlobalConfig: (fs: CliFs, env?: NodeJS.ProcessEnv) => LoadedConfig;

package/dist/src/cli/install.d.ts

@@ -0,0 +1,33 @@
+import { type CliFs } from "./config";
+export interface InstallOptions {
+    /** Optional version pin (e.g. `"1.2.3"`, `"latest"`). Omit for bare specifier. */
+    version?: string;
+    /** Plan the change and print it without writing. */
+    dryRun?: boolean;
+    /** Reserved for future confirmation prompts; accepted but unused for now. */
+    yes?: boolean;
+}
+export interface InstallResult {
+    /** Outcome of the command. */
+    status: "wrote" | "planned" | "noop";
+    /** Resolved config path (existing or newly-targeted). */
+    path: string;
+    /** Specifier that was added (or would be added under `--dry-run`). */
+    specifier: string;
+    /** Backup path created before the write, or `null` when no backup was needed. */
+    backup: string | null;
+}
+/**
+ * Run `oas install` against the global OpenCode config.
+ *
+ * Steps: load → normalize → drop existing oas variants → dedupe surviving
+ * entries → append one requested specifier → backup → atomic write. The
+ * backup is a timestamped sibling of the config file; rotation to
+ * `BACKUP_LIMIT` is handled inside `backupIfWritable`.
+ *
+ * Idempotency: re-running with the same specifier resolves to a `noop`
+ * result without touching disk. A malformed config triggers an error so
+ * the user can fix the JSONC instead of silently losing it to an empty
+ * overwrite.
+ */
+export declare const runInstall: (opts?: InstallOptions, fs?: CliFs) => InstallResult;

package/dist/src/cli/main.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+export interface MainResult {
+    command: string | null;
+    exitCode: 0 | 1 | 2;
+}
+/**
+ * Pure(ish) dispatcher: takes argv, runs the matching command, sets
+ * `process.exitCode`, and returns a structured result so tests can assert
+ * without reading the exit code.
+ */
+export declare const runMain: (argv?: readonly string[]) => MainResult;

package/dist/src/cli/real-fs.d.ts

@@ -0,0 +1,6 @@
+import type { CliFs } from "./config";
+/**
+ * Build a `CliFs` that delegates to `node:fs`. All methods are sync; the
+ * CLI is short-lived and never benefits from async I/O.
+ */
+export declare const createRealFs: () => CliFs;

package/dist/src/cli/status.d.ts

@@ -0,0 +1,34 @@
+import { type CliFs } from "./config";
+export interface StatusResult {
+    /** Whether an `opencode-agent-skills-md` entry is present in `plugin`. */
+    installed: boolean;
+    /** Resolved config path the loader used. */
+    path: string;
+    /** Detected on-disk format. */
+    format: "json" | "jsonc";
+    /** The active specifier, or `null` when not installed. */
+    specifier: string | null;
+    /** Other plugin entries preserved alongside the oas one. */
+    extras: string[];
+}
+export interface DoctorResult {
+    /** True when there are zero blocking issues. */
+    ok: boolean;
+    /** Blocking problems — the install flow will not work until they are fixed. */
+    issues: string[];
+    /** Non-blocking advisories — install may still work. */
+    warnings: string[];
+    /** Informational notes about what was checked. */
+    info: string[];
+}
+/**
+ * Read-only status probe. Prints a human-readable report to stdout and
+ * returns the same data as a structured result so callers (including
+ * `main.ts` and tests) can consume it without parsing the message.
+ */
+export declare const runStatus: (fs?: CliFs) => StatusResult;
+/**
+ * Health checks. The function does not exit on its own — it returns a
+ * `DoctorResult` and `main.ts` maps `ok === false` to exit code 1.
+ */
+export declare const runDoctor: (fs?: CliFs, env?: NodeJS.ProcessEnv) => DoctorResult;

package/dist/src/cli/uninstall.d.ts

@@ -0,0 +1,22 @@
+import { type CliFs } from "./config";
+export interface UninstallOptions {
+    /** Also remove the runtime cache and the plugin's own config dir. */
+    purge?: boolean;
+    /** Plan the change and print it without writing. */
+    dryRun?: boolean;
+    /** Reserved for future confirmation prompts; accepted but unused for now. */
+    yes?: boolean;
+}
+export interface UninstallResult {
+    status: "wrote" | "planned" | "noop";
+    path: string;
+    /** Plugin entries that were (or would be) removed from the config. */
+    removed: string[];
+    /** Cache / config dirs removed under `--purge`. Empty when `--purge` was not set. */
+    purged: string[];
+}
+/** Bun/npm-style cache path where the plugin gets installed at runtime. */
+export declare const cachePath: (env?: NodeJS.ProcessEnv) => string;
+/** Plugin's own XDG config dir (separate from the OpenCode config it edits). */
+export declare const pluginConfigPath: (env?: NodeJS.ProcessEnv) => string;
+export declare const runUninstall: (opts?: UninstallOptions, fs?: CliFs) => UninstallResult;

package/dist/src/host.d.ts

@@ -0,0 +1,51 @@
+/**
+ * OpenCode host adapter.
+ *
+ * Wraps the OpenCode SDK client (`PluginInput["client"]`) and provides
+ * a bounded surface for content injection, session context, and filesystem
+ * access consumed by the plugin and skill tools.
+ *
+ * The boundary contracts (`SkillHostClient`, `SkillHostSession`,
+ * `SkillHostContext`) are declared in the `opencode-agent-skills-md-core`
+ * package per spec R2; this module IMPLEMENTS them over the OpenCode SDK
+ * client plus `node:fs/promises`. No other package may declare a concrete
+ * implementation — the plugin package owns exactly one.
+ */
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { SkillHostClient, SkillHostSession } from "opencode-agent-skills-md-core";
+/** Concrete OpenCode client (the SDK's generated client type). */
+export type OpencodeClient = PluginInput["client"];
+/**
+ * File access surface exposed alongside the host client. Tools
+ * consume these via the host instead of importing `node:fs/promises` so the
+ * boundary stays explicit and easy to stub in tests.
+ */
+export interface OpencodeHostFileAccess {
+    readFile(path: string): Promise<string>;
+    readdir(path: string): Promise<string[]>;
+}
+/**
+ * Concrete OpenCode client surface.
+ *
+ * Structurally identical to the core boundary contract `SkillHostClient`
+ * (it implements all four methods). The alias is preserved for backward
+ * compatibility with prior plugin-package consumers and to make the
+ * OpenCode-specific implementation obvious at use sites.
+ */
+export type OpencodeSkillHostClient = SkillHostClient;
+/**
+ * The full host surface: a bounded client plus a session factory. Each call
+ * to `session(id)` returns a `SkillHostSession` carrying only the id the core
+ * needs to thread through host calls.
+ */
+export interface OpencodeSkillHost {
+    client: OpencodeSkillHostClient;
+    session: (id: string) => SkillHostSession;
+}
+/**
+ * Build an `OpencodeSkillHost` over the supplied OpenCode SDK client.
+ *
+ * The host is the only place in the codebase that touches the SDK's
+ * `client.session.prompt` and `client.session.messages` methods.
+ */
+export declare const createOpencodeSkillHost: (client: OpencodeClient) => OpencodeSkillHost;

package/dist/src/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * OpenCode host adapter — root entrypoint.
+ *
+ * Re-exports the plugin factory as the package's default export so the
+ * `rolldown` build can target this file directly. The root `src/plugin.ts`
+ * shim forwards to this module to preserve the legacy import path while
+ * `package.json` still resolves `dist/plugin.mjs` to the package main.
+ *
+ * Public surface:
+ *   - default export: SkillsPlugin (the @opencode-ai/plugin Plugin factory)
+ *   - named exports: SkillsPlugin, createOpencodeSkillHost
+ */
+import { SkillsPlugin } from "./plugin";
+export { SkillsPlugin };
+export { createOpencodeSkillHost } from "./host";
+export type { OpencodeClient, OpencodeSkillHost, OpencodeSkillHostClient, OpencodeHostFileAccess, } from "./host";
+export default SkillsPlugin;

package/dist/src/plugin.d.ts

@@ -0,0 +1,35 @@
+/**
+ * OpenCode Agent Skills Plugin (host adapter).
+ *
+ * The plugin factory builds the host over the OpenCode SDK client, composes
+ * the four skill tools, and wires the chat.message and event hooks. The
+ * keyword matcher and session/loaded-skill bookkeeping are the only
+ * adapter-specific logic; everything else delegates to the portable core
+ * or the host.
+ */
+import type { Plugin } from "@opencode-ai/plugin";
+import { type SkillSummary } from "opencode-agent-skills-md-core";
+/**
+ * Render the matched-skill synthetic injection that asks the model to
+ * evaluate which of the matched skills (if any) it should activate.
+ *
+ * Each skill line carries a sub-line `trigger: <text>` whenever the
+ * skill has a non-empty `trigger`, so the model knows which user
+ * phrases should activate it. Skills with no trigger render exactly as
+ * before (`- name: description`).
+ */
+export declare const formatMatchedSkillsInjection: (matchedSkills: SkillSummary[]) => string;
+/**
+ * Lightweight keyword matching to replace ML embeddings.
+ *
+ * Per-token contribution:
+ *   - name hit    = 2x
+ *   - trigger hit = 1.5x
+ *   - desc hit    = 1x
+ *
+ * The trigger tier (1.5x) sits between name (2x) and description (1x)
+ * so a trigger-matched skill outranks a description-matched skill at
+ * the same query, but a name-matched skill still wins overall.
+ */
+export declare const matchSkillsByKeyword: (userMessage: string, availableSkills: SkillSummary[]) => SkillSummary[];
+export declare const SkillsPlugin: Plugin;

package/dist/src/sdk.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Local interfaces for the OpenCode hook payload shapes this plugin
+ * actually consumes.
+ *
+ * These intentionally mirror only the narrow slice of the SDK types
+ * the plugin reads — defining them locally (rather than importing the
+ * SDK's broad `UserMessage` / `Part` / `Event` types) keeps the
+ * adapter resilient to upstream shape changes and lets us narrow
+ * untyped runtime payloads safely.
+ *
+ * Internal only: this module is not re-exported from `src/index.ts`.
+ */
+/** A text-bearing chat part. `text` is optional because some parts carry metadata only. */
+export interface ChatTextPart {
+    type: "text";
+    text?: string;
+    synthetic?: boolean;
+}
+/** Minimal shape of the `chat.message` output payload the plugin reads. */
+export interface ChatMessageOutput {
+    message: {
+        sessionID: string;
+        model?: string;
+        agent?: string;
+    };
+    parts: unknown[];
+}
+/** `session.compacted` event payload. */
+export interface SessionCompactedEvent {
+    type: "session.compacted";
+    properties: {
+        sessionID: string;
+    };
+}
+/** `session.deleted` event payload. */
+export interface SessionDeletedEvent {
+    type: "session.deleted";
+    properties: {
+        info: {
+            id: string;
+        };
+    };
+}
+/** Discriminated union of the session lifecycle events this plugin handles. */
+export type SessionEvent = SessionCompactedEvent | SessionDeletedEvent;
+/** Type guard: narrows `unknown` to `ChatTextPart` when `part.type === "text"`. */
+export declare const isChatTextPart: (part: unknown) => part is ChatTextPart;
+/** Type guard: narrows `unknown` to `SessionCompactedEvent`. */
+export declare const isSessionCompactedEvent: (event: unknown) => event is SessionCompactedEvent;
+/** Type guard: narrows `unknown` to `SessionDeletedEvent`. */
+export declare const isSessionDeletedEvent: (event: unknown) => event is SessionDeletedEvent;

package/dist/src/tools.d.ts

@@ -0,0 +1,86 @@
+/**
+ * OpenCode tool factories.
+ *
+ * The four skill tools (get_available_skills, read_skill_file, run_skill_script,
+ * use_skill) compose the portable core engine with the OpenCode host. Tools
+ * consume the host's bounded client surface; they never reference the
+ * OpenCode SDK client or the `node:fs` module directly.
+ *
+ * `createSkillTools(host, $, directory)` returns the four tool factories
+ * pre-bound to the host, the shell runner, and the project directory. The
+ * plugin instantiates them at registration time.
+ */
+import type { PluginInput } from "@opencode-ai/plugin";
+import { tool } from "@opencode-ai/plugin";
+import type { OpencodeSkillHost } from "./host";
+/** @internal - exported for testing */
+export declare const _escapeXml: (s: string) => string;
+/** @internal - exported for testing */
+export declare const _escapeShellArg: (arg: string) => string;
+/**
+ * Portable return type for tool factory consts.
+ *
+ * The `tool()` helper captures the Zod shape of its `args` parameter in the
+ * generic parameter, so the inferred return type of each factory leaks Zod
+ * types. When TypeScript emits `.d.ts` files for the package, that generic
+ * instantiation cannot be named portably across zod versions. Annotating
+ * the return type as `ReturnType<typeof tool>` erases the per-call Zod
+ * shape and leaves a stable, portable declaration for downstream consumers.
+ */
+type SkillTool = ReturnType<typeof tool>;
+/**
+ * Tool translation guide for skills written for Claude Code.
+ * Injected into skill content to help the AI use OpenCode equivalents.
+ */
+export declare const toolTranslation = "<tool-translation>\nThis skill may reference Claude Code tools. Use OpenCode equivalents:\n- TodoWrite/TodoRead -> todowrite/todoread\n- Task (subagents) -> task tool with subagent_type parameter\n- Skill tool -> use_skill tool\n- Read/Write/Edit/Bash/Glob/Grep/WebFetch -> lowercase (read/write/edit/bash/glob/grep/webfetch)\n</tool-translation>";
+export interface SkillTools {
+    GetAvailableSkills: ReturnType<typeof GetAvailableSkills>;
+    ReadSkillFile: ReturnType<typeof ReadSkillFile>;
+    RunSkillScript: ReturnType<typeof RunSkillScript>;
+    UseSkill: ReturnType<typeof UseSkill>;
+}
+/**
+ * Callback fired by `UseSkill` after a successful load so the host can
+ * update its session-level bookkeeping (loaded-skill set, TUI icon, etc.).
+ * The core never assumes a callback is registered; missing it must not
+ * break the load.
+ */
+export type OnSkillLoaded = (sessionID: string, skillName: string) => void;
+/**
+ * Build the four skill tool factories bound to the host, shell, and
+ * project directory. The returned object is what the plugin registers
+ * under its `tool` hook.
+ *
+ * The optional `onSkillLoaded` callback is threaded through to `UseSkill`
+ * so a successful load can update host session state (e.g., the loaded-
+ * skill set used to suppress duplicate match injection in `chat.message`).
+ */
+export declare const createSkillTools: (host: OpencodeSkillHost, $: PluginInput["$"], directory: string, onSkillLoaded?: OnSkillLoaded) => SkillTools;
+/**
+ * Resolve a skill by name, or return a "not found" message with a
+ * close-match suggestion.
+ *
+ * Centralizes the duplicated resolve-then-suggest pattern that
+ * `use_skill`, `read_skill_file`, and `run_skill_script` all need.
+ * Returning a single `string` keeps the call site trivial:
+ *
+ *   - skill found              → returns `skill.name`
+ *   - skill missing, suggestion → `Skill "<name>" not found. Did you mean "<suggestion>"?`
+ *   - skill missing, no hint    → `Skill "<name>" not found. Use get_available_skills to list available skills.`
+ *
+ * Not-found messages always start with the literal `Skill "` so callers
+ * can detect them with `result.startsWith('Skill "')`. The skill-name
+ * regex (`/^[\p{Ll}\p{N}-]+$/u`) forbids uppercase initial characters,
+ * so a legitimate skill name can never collide with that prefix.
+ *
+ * The helper does its own discovery; callers that need the `Skill` object
+ * (rather than just its name) re-resolve via a second `discoverAllSkills`
+ * call. Discovery is cheap (file-listing only) and the OS-level metadata
+ * cache absorbs most of the cost.
+ */
+export declare const resolveSkillOrSuggest: (directory: string, skillName: string) => Promise<string>;
+declare const GetAvailableSkills: (directory: string) => SkillTool;
+declare const ReadSkillFile: (directory: string, host: OpencodeSkillHost) => SkillTool;
+declare const RunSkillScript: (directory: string, $: PluginInput["$"]) => SkillTool;
+declare const UseSkill: (directory: string, host: OpencodeSkillHost, onSkillLoaded?: (sessionID: string, skillName: string) => void) => SkillTool;
+export {};

package/package.json

@@ -1,14 +1,54 @@
 {
   "name": "opencode-agent-skills-md",
-  "version": "1.0.0",
-  "private": false,
-  "description": "pnpm workspace root for opencode-agent-skills-md. The user-facing OpenCode plugin lives at packages/opencode-agent-skills-md and the portable engine at packages/core. This manifest exists only to wire the workspace — it has no exports of its own; consumers install one of the workspace packages directly.",
-  "author": "Josh Thomas <josh@joshthomas.dev>",
+  "version": "1.1.0",
+  "description": "OpenCode adapter for the opencode-agent-skills-md workspace: plugin factory, host, and the four skill tools.",
+  "type": "module",
+  "main": "src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./src/index.ts",
+      "default": "./src/index.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "oas": "./dist/cli.mjs"
+  },
+  "dependencies": {
+    "yaml": "^2.9.0"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.1",
+    "rolldown": "^1.0.3",
+    "tsx": "^4.22.3",
+    "typescript": "^6.0.3",
+    "opencode-agent-skills-md-core": "0.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/MetalbolicX/opencode-agent-skills-md.git"
   },
+  "homepage": "https://github.com/MetalbolicX/opencode-agent-skills-md",
+  "bugs": {
+    "url": "https://github.com/MetalbolicX/opencode-agent-skills-md/issues"
+  },
+  "author": {
+    "name": "Josh Thomas",
+    "url": "https://github.com/joshjoshthomas"
+  },
   "keywords": [
     "opencode",
     "plugin",
@@ -16,20 +56,10 @@
     "agent",
     "ai"
   ],
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "devDependencies": {
-    "@types/node": "^25.9.1",
-    "tsx": "^4.22.3",
-    "typescript": "^6.0.3",
-    "opencode-agent-skills-md": "0.7.0",
-    "opencode-agent-skills-md-core": "0.0.0"
-  },
   "scripts": {
-    "build": "pnpm -r --workspace-concurrency=1 run build",
-    "test": "pnpm -r --no-bail --workspace-concurrency=1 test && node --import tsx --test tests/workspace.test.ts",
-    "test:workspace": "node --import tsx --test tests/workspace.test.ts",
-    "typecheck": "pnpm -r --workspace-concurrency=1 run typecheck"
+    "build": "rm -rf dist && rolldown -c && tsc -p tsconfig.build.json",
+    "pretest": "npm run build",
+    "test": "node --import tsx --test \"tests/**/*.test.ts\"",
+    "typecheck": "tsc --noEmit"
   }
 }

package/{packages/opencode-agent-skills-md/src → src}/cli/main.ts

@@ -16,6 +16,7 @@
 // ---------------------------------------------------------------------------
 
 import { pathToFileURL } from "node:url";
+import { realpathSync } from "node:fs";
 import { parseArgs } from "node:util";
 import { runInstall } from "./install";
 import { runDoctor, runStatus } from "./status";
@@ -186,15 +187,30 @@ export const runMain = (argv: readonly string[] = process.argv): MainResult => {
  * cli.mjs`), `false` when it was imported from a test harness. We avoid
  * `import.meta.main` because the package floor is Node 18 and that field
  * only landed in Node 22.
+ *
+ * Symlink-aware: when the script is invoked through a symlink (e.g. the
+ * pnpm global store, where `node_modules/<pkg>` is a symlink into a
+ * content-addressable store), `process.argv[1]` carries the symlink path
+ * while `import.meta.url` carries the real path after symlink resolution.
+ * Comparing the two verbatim would always be `false` under pnpm, causing
+ * the CLI to silently exit. We resolve both sides through `realpathSync`
+ * before comparing.
  */
-const invokedAsMain = ((): boolean => {
+const checkInvokedAsMain = (): boolean => {
   if (!process.argv[1]) return false;
   try {
-    return import.meta.url === pathToFileURL(process.argv[1]).href;
+    const realArgv = pathToFileURL(realpathSync(process.argv[1])).href;
+    return import.meta.url === realArgv;
   } catch {
-    return false;
+    try {
+      return import.meta.url === pathToFileURL(process.argv[1]).href;
+    } catch {
+      return false;
+    }
   }
-})();
+};
+
+const invokedAsMain = checkInvokedAsMain();
 
 if (invokedAsMain) {
   runMain(process.argv);

package/.beads/.local_version

@@ -1 +0,0 @@
-0.44.0