@nt-ai-lab/opencode-skillz 0.2.8 → 0.3.2

package/AGENTS.md

@@ -15,6 +15,7 @@ Purpose: package OpenCode workflow assets as a plugin.
 - Put voice and persona behavior in agent prompts.
 - Treat reusable skill content as command templates in `commands/`.
 - Commands should be manually invoked by default.
+- All plugin-provided commands must use the `nt-skillz:` prefix, including code-backed commands.
 - Prefer minimal additions; only add new commands when needed.
 - Do not add `agent:` in command frontmatter unless the command must force a specific agent.
 

package/dist/commands/dont-stop/hooks.d.ts

@@ -0,0 +1,2 @@
+import type { OpencodeClient, PluginHooks } from "../../types.js";
+export declare function createDontStopHooks(client: OpencodeClient): PluginHooks;

package/dist/commands/dont-stop/hooks.js

@@ -0,0 +1,217 @@
+import { CLEAR_DONT_STOP_COMMAND_NAME, DONT_STOP_COMMAND_NAME, } from "./register.js";
+import { createDontStopState } from "./state.js";
+function unwrapResponse(result) {
+    return typeof result === "object" && result !== null && "data" in result ? result.data : result;
+}
+function normalizeCriteria(value) {
+    return value
+        .split(/\n|;/)
+        .map((item) => item.replace(/^\s*[-*]\s*/, "").trim())
+        .filter(Boolean);
+}
+function buildSystemInstruction(criteria) {
+    return [
+        "# dont-stop",
+        "",
+        "Acceptance criteria:",
+        ...criteria.map((item, index) => `${index + 1}. ${item}`),
+        "",
+        "Rules:",
+        "- Continue working until every acceptance criterion is achieved or a concrete blocker exists.",
+        "- Do not stop at partial progress.",
+        "- Do not ask for confirmation between obvious non-destructive next steps.",
+        "- dont-stop stays active until the user explicitly runs /nt-skillz:clear-dont-stop.",
+        "- You must never declare the work complete or permanently blocked.",
+        "- You may only request completion or request blocked review with a strong and compelling reason.",
+        "- End every final response with exactly one machine-readable status block using this format:",
+        "",
+        "<dont-stop-status>",
+        "state: continue|completion-requested|blocked-requested",
+        ...criteria.map((item, index) => `criterion-${index + 1}: achieved|not-achieved|unknown - ${item}`),
+        "justification: concise evidence-based justification",
+        "reason: none|short compelling reason",
+        "next: short next action",
+        "</dont-stop-status>",
+        "",
+        "State rules:",
+        "- continue = more work should be done now",
+        "- completion-requested = you believe the criteria are met and request user approval to stop",
+        "- blocked-requested = you believe progress is blocked and request user review of the blocker",
+        "- A request does not stop dont-stop. Only the user can clear it.",
+    ].join("\n");
+}
+function parseAssistantStatus(text) {
+    const match = text.match(/<dont-stop-status>([\s\S]*?)<\/dont-stop-status>/i);
+    if (!match)
+        return null;
+    const body = match[1];
+    const stateMatch = body.match(/^\s*state\s*:\s*(continue|completion-requested|blocked-requested)\s*$/im);
+    const justificationMatch = body.match(/^\s*justification\s*:\s*(.+)\s*$/im);
+    const reasonMatch = body.match(/^\s*reason\s*:\s*(.+)\s*$/im);
+    return {
+        state: stateMatch?.[1] ?? "continue",
+        justification: justificationMatch?.[1]?.trim() ?? "",
+        reason: reasonMatch?.[1]?.trim() ?? "",
+    };
+}
+async function showToast(client, body) {
+    try {
+        await client.tui.showToast({ body });
+    }
+    catch { }
+}
+async function getLatestAssistantStatus(client, sessionID) {
+    const result = unwrapResponse(await client.session.messages({ path: { id: sessionID } }));
+    const messages = Array.isArray(result) ? result : [];
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const entry = messages[index];
+        if (entry.info?.role !== "assistant")
+            continue;
+        const text = (entry.parts ?? [])
+            .filter((part) => part.type === "text" && typeof part.text === "string")
+            .map((part) => part.text)
+            .join("\n");
+        return parseAssistantStatus(text);
+    }
+    return null;
+}
+function buildContinuationPrompt(criteria, status) {
+    const reportedState = status?.state ?? "missing";
+    const reason = status?.reason || "none";
+    return [
+        "dont-stop remains active.",
+        "",
+        "Acceptance criteria:",
+        ...criteria.map((item, index) => `${index + 1}. ${item}`),
+        "",
+        `Last reported state: ${reportedState}`,
+        `Last reported reason: ${reason}`,
+        "",
+        "If the work seems done, request completion with the required status block.",
+        "A completion request must include a clear justification that all acceptance criteria have been achieved.",
+        "If a concrete blocker exists, request blocked review with the required status block.",
+        "Otherwise continue working immediately on the unmet criteria and end with the required status block.",
+    ].join("\n");
+}
+function buildReviewRequestKey(status) {
+    return `${status.state}:${status.reason}`;
+}
+async function notifyReviewRequested(client, state, sessionID, status) {
+    const session = state.get(sessionID);
+    if (!session)
+        return;
+    const reviewKey = buildReviewRequestKey(status);
+    if (session.pendingReviewKey === reviewKey)
+        return;
+    session.pendingReviewKey = reviewKey;
+    const message = status.state === "completion-requested"
+        ? "dont-stop completion requested; run /nt-skillz:clear-dont-stop to accept or reply to continue"
+        : "dont-stop blocker review requested; run /nt-skillz:clear-dont-stop to accept or reply to continue";
+    await showToast(client, {
+        message,
+        variant: "info",
+    });
+}
+function getDeletedSessionID(event) {
+    if (event.type !== "session.deleted")
+        return undefined;
+    const properties = event.properties;
+    if (!properties || typeof properties !== "object")
+        return undefined;
+    const info = properties.info;
+    return typeof info?.id === "string" ? info.id : undefined;
+}
+function getIdleSessionID(event) {
+    if (event.type !== "session.idle")
+        return undefined;
+    const properties = event.properties;
+    if (!properties || typeof properties !== "object")
+        return undefined;
+    const sessionID = properties.sessionID;
+    return typeof sessionID === "string" ? sessionID : undefined;
+}
+async function handleCommand(client, state, input, output) {
+    if (input.command === CLEAR_DONT_STOP_COMMAND_NAME) {
+        state.clear(input.sessionID);
+        output.parts = [];
+        await showToast(client, {
+            message: "dont-stop cleared for this session",
+            variant: "success",
+        });
+        return;
+    }
+    if (input.command !== DONT_STOP_COMMAND_NAME)
+        return;
+    const criteria = normalizeCriteria(input.arguments);
+    output.parts = [];
+    if (!criteria.length) {
+        await showToast(client, {
+            message: "/nt-skillz:dont-stop requires acceptance criteria",
+            variant: "error",
+        });
+        return;
+    }
+    state.set(input.sessionID, { criteria });
+    await showToast(client, {
+        message: `dont-stop enabled for this session (${criteria.length} criteria)`,
+        variant: "success",
+    });
+}
+async function handleSystemTransform(state, input, output) {
+    if (!input.sessionID)
+        return;
+    const session = state.get(input.sessionID);
+    if (!session)
+        return;
+    output.system.push(buildSystemInstruction(session.criteria));
+}
+async function handleEvent(client, state, event) {
+    const deletedSessionID = getDeletedSessionID(event);
+    if (deletedSessionID) {
+        state.clear(deletedSessionID);
+        return;
+    }
+    const sessionID = getIdleSessionID(event);
+    if (!sessionID)
+        return;
+    const session = state.get(sessionID);
+    if (!session || state.isBusy(sessionID))
+        return;
+    state.startBusy(sessionID);
+    try {
+        const latestStatus = await getLatestAssistantStatus(client, sessionID);
+        if (latestStatus?.state === "completion-requested" || latestStatus?.state === "blocked-requested") {
+            await notifyReviewRequested(client, state, sessionID, latestStatus);
+            return;
+        }
+        session.pendingReviewKey = undefined;
+        await client.session.prompt({
+            path: { id: sessionID },
+            body: {
+                parts: [
+                    {
+                        type: "text",
+                        text: buildContinuationPrompt(session.criteria, latestStatus),
+                    },
+                ],
+            },
+        });
+    }
+    finally {
+        state.finishBusy(sessionID);
+    }
+}
+export function createDontStopHooks(client) {
+    const state = createDontStopState();
+    return {
+        "command.execute.before": async (input, output) => {
+            await handleCommand(client, state, input, output);
+        },
+        "experimental.chat.system.transform": async (input, output) => {
+            await handleSystemTransform(state, input, output);
+        },
+        event: async ({ event }) => {
+            await handleEvent(client, state, event);
+        },
+    };
+}

package/dist/commands/dont-stop/index.d.ts

@@ -0,0 +1 @@
+export { createDontStopHooks } from "./hooks.js";

package/dist/commands/dont-stop/index.js

@@ -0,0 +1 @@
+export { createDontStopHooks } from "./hooks.js";

package/dist/commands/dont-stop/register.d.ts

@@ -0,0 +1,4 @@
+import type { CommandDefinition } from "../../types.js";
+export declare const DONT_STOP_COMMAND_NAME: string;
+export declare const CLEAR_DONT_STOP_COMMAND_NAME: string;
+export declare function registerDontStopCommands(commandConfig: Record<string, CommandDefinition>): void;

package/dist/commands/dont-stop/register.js

@@ -0,0 +1,17 @@
+import { buildCommandName } from "../../plugin-registry/command-names.js";
+export const DONT_STOP_COMMAND_NAME = buildCommandName("dont-stop");
+export const CLEAR_DONT_STOP_COMMAND_NAME = buildCommandName("clear-dont-stop");
+export function registerDontStopCommands(commandConfig) {
+    if (!commandConfig[DONT_STOP_COMMAND_NAME]) {
+        commandConfig[DONT_STOP_COMMAND_NAME] = {
+            description: "Activate idle continuation for this session",
+            template: "",
+        };
+    }
+    if (!commandConfig[CLEAR_DONT_STOP_COMMAND_NAME]) {
+        commandConfig[CLEAR_DONT_STOP_COMMAND_NAME] = {
+            description: "Disable idle continuation for this session",
+            template: "",
+        };
+    }
+}

package/dist/commands/dont-stop/state.d.ts

@@ -0,0 +1,13 @@
+export interface DontStopSessionState {
+    criteria: string[];
+    pendingReviewKey?: string;
+}
+export interface DontStopState {
+    get(sessionID: string): DontStopSessionState | undefined;
+    set(sessionID: string, state: DontStopSessionState): void;
+    clear(sessionID: string): void;
+    isBusy(sessionID: string): boolean;
+    startBusy(sessionID: string): void;
+    finishBusy(sessionID: string): void;
+}
+export declare function createDontStopState(): DontStopState;

package/dist/commands/dont-stop/state.js

@@ -0,0 +1,25 @@
+export function createDontStopState() {
+    const sessions = new Map();
+    const busySessions = new Set();
+    return {
+        get(sessionID) {
+            return sessions.get(sessionID);
+        },
+        set(sessionID, state) {
+            sessions.set(sessionID, state);
+        },
+        clear(sessionID) {
+            sessions.delete(sessionID);
+            busySessions.delete(sessionID);
+        },
+        isBusy(sessionID) {
+            return busySessions.has(sessionID);
+        },
+        startBusy(sessionID) {
+            busySessions.add(sessionID);
+        },
+        finishBusy(sessionID) {
+            busySessions.delete(sessionID);
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { PluginInput } from "./types.js";
+export declare const OpencodeSkillzPlugin: (input: PluginInput) => Promise<import("./types.js").PluginHooks>;
+export default OpencodeSkillzPlugin;

package/dist/index.js

@@ -0,0 +1,7 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createPluginRegistry } from "./plugin-registry/index.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pluginRoot = path.resolve(__dirname, "..");
+export const OpencodeSkillzPlugin = async (input) => createPluginRegistry(input, pluginRoot);
+export default OpencodeSkillzPlugin;

package/dist/plugin-registry/agents.d.ts

@@ -0,0 +1,2 @@
+import type { AgentDefinition, CommandDefinition } from "../types.js";
+export declare function registerAgents(agentConfig: Record<string, AgentDefinition>, pluginRoot: string, commands: Record<string, CommandDefinition>): void;

package/dist/plugin-registry/agents.js

@@ -0,0 +1,61 @@
+import { readMarkdownEntries } from "./markdown.js";
+function parseCsvList(value) {
+    if (typeof value !== "string")
+        return [];
+    return value
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function materializePreloadedTemplate(template) {
+    return template.replace(/\$ARGUMENTS/g, "all relevant current work in this session");
+}
+export function registerAgents(agentConfig, pluginRoot, commands) {
+    const rawAgents = readMarkdownEntries(pluginRoot, "agents");
+    function collectPreloadedCommands(agentName, stack = new Set()) {
+        const rawAgent = rawAgents[agentName];
+        if (!rawAgent)
+            return [];
+        if (stack.has(agentName))
+            return parseCsvList(rawAgent.meta.preload_commands);
+        stack.add(agentName);
+        const merged = [];
+        const parentAgentName = typeof rawAgent.meta.extends === "string" ? rawAgent.meta.extends.trim() : "";
+        if (parentAgentName && rawAgents[parentAgentName]) {
+            merged.push(...collectPreloadedCommands(parentAgentName, stack));
+        }
+        merged.push(...parseCsvList(rawAgent.meta.preload_commands));
+        stack.delete(agentName);
+        return [...new Set(merged)];
+    }
+    for (const [name, rawAgent] of Object.entries(rawAgents)) {
+        if (agentConfig[name])
+            continue;
+        const promptParts = [];
+        const parentAgentName = typeof rawAgent.meta.extends === "string" ? rawAgent.meta.extends.trim() : "";
+        if (parentAgentName && rawAgents[parentAgentName]?.body) {
+            promptParts.push(rawAgents[parentAgentName].body);
+        }
+        if (rawAgent.body) {
+            promptParts.push(rawAgent.body);
+        }
+        for (const commandName of collectPreloadedCommands(name)) {
+            const command = commands[commandName];
+            if (!command?.template)
+                continue;
+            promptParts.push(`[Preloaded command /${commandName}]\n${materializePreloadedTemplate(command.template)}`);
+        }
+        const agent = {
+            prompt: promptParts.join("\n\n").trim(),
+        };
+        if (typeof rawAgent.meta.description === "string")
+            agent.description = rawAgent.meta.description;
+        if (typeof rawAgent.meta.mode === "string")
+            agent.mode = rawAgent.meta.mode;
+        if (typeof rawAgent.meta.model === "string")
+            agent.model = rawAgent.meta.model;
+        if (typeof rawAgent.meta.color === "string")
+            agent.color = rawAgent.meta.color;
+        agentConfig[name] = agent;
+    }
+}

package/dist/plugin-registry/command-names.d.ts

@@ -0,0 +1,2 @@
+export declare const COMMAND_NAMESPACE = "nt-skillz";
+export declare function buildCommandName(name: string): string;

package/dist/plugin-registry/command-names.js

@@ -0,0 +1,4 @@
+export const COMMAND_NAMESPACE = "nt-skillz";
+export function buildCommandName(name) {
+    return `${COMMAND_NAMESPACE}:${name}`;
+}

package/dist/plugin-registry/commands.d.ts

@@ -0,0 +1,2 @@
+import type { CommandDefinition } from "../types.js";
+export declare function registerCommands(commandConfig: Record<string, CommandDefinition>, pluginRoot: string): Record<string, CommandDefinition>;

package/dist/plugin-registry/commands.js

@@ -0,0 +1,59 @@
+import { registerDontStopCommands } from "../commands/dont-stop/register.js";
+import { buildCommandName } from "./command-names.js";
+import { readMarkdownEntries } from "./markdown.js";
+function normalizeCommandReference(value) {
+    if (typeof value !== "string")
+        return "";
+    return value.trim().replace(/_/g, "-");
+}
+function loadMarkdownCommands(pluginRoot) {
+    const rawCommands = readMarkdownEntries(pluginRoot, "commands");
+    const commands = {};
+    function buildComposedTemplate(name, stack = new Set()) {
+        const rawCommand = rawCommands[name];
+        if (!rawCommand)
+            return "";
+        if (stack.has(name))
+            return rawCommand.body;
+        stack.add(name);
+        let template = rawCommand.body;
+        const composeAfterName = normalizeCommandReference(rawCommand.meta.compose_after);
+        const composedCommand = rawCommands[composeAfterName];
+        if (composeAfterName && composedCommand) {
+            const composedTemplate = buildComposedTemplate(composeAfterName, stack);
+            if (composedTemplate) {
+                template = [template, `In addition you must adhere to the following:\n\n${composedTemplate}`]
+                    .filter(Boolean)
+                    .join("\n\n");
+            }
+        }
+        stack.delete(name);
+        return template.trim();
+    }
+    for (const [name, rawCommand] of Object.entries(rawCommands)) {
+        const description = typeof rawCommand.meta.description === "string" ? rawCommand.meta.description : `Run /${name}`;
+        const command = {
+            description,
+            template: buildComposedTemplate(name),
+        };
+        if (typeof rawCommand.meta.agent === "string")
+            command.agent = rawCommand.meta.agent;
+        if (typeof rawCommand.meta.model === "string")
+            command.model = rawCommand.meta.model;
+        if (typeof rawCommand.meta.subtask === "boolean")
+            command.subtask = rawCommand.meta.subtask;
+        commands[name] = command;
+    }
+    return commands;
+}
+export function registerCommands(commandConfig, pluginRoot) {
+    const markdownCommands = loadMarkdownCommands(pluginRoot);
+    for (const [name, command] of Object.entries(markdownCommands)) {
+        const commandName = buildCommandName(name);
+        if (!commandConfig[commandName]) {
+            commandConfig[commandName] = command;
+        }
+    }
+    registerDontStopCommands(commandConfig);
+    return markdownCommands;
+}

package/dist/plugin-registry/index.d.ts

@@ -0,0 +1,2 @@
+import type { PluginHooks, PluginInput } from "../types.js";
+export declare function createPluginRegistry(input: PluginInput, pluginRoot: string): PluginHooks;

package/dist/plugin-registry/index.js

@@ -0,0 +1,26 @@
+import { createDontStopHooks } from "../commands/dont-stop/index.js";
+import { registerAgents } from "./agents.js";
+import { registerCommands } from "./commands.js";
+export function createPluginRegistry(input, pluginRoot) {
+    const dontStopHooks = createDontStopHooks(input.client);
+    return {
+        ...dontStopHooks,
+        config: async (config) => {
+            config.command ??= {};
+            config.agent ??= {};
+            const commands = registerCommands(config.command, pluginRoot);
+            registerAgents(config.agent, pluginRoot, commands);
+            config.agent.build = {
+                ...(config.agent.build ?? {}),
+                disable: true,
+            };
+            config.agent.plan = {
+                ...(config.agent.plan ?? {}),
+                disable: true,
+            };
+            if (!config.default_agent && config.agent.default) {
+                config.default_agent = "default";
+            }
+        },
+    };
+}

package/dist/plugin-registry/markdown.d.ts

@@ -0,0 +1,7 @@
+type FrontmatterValue = string | boolean;
+export interface MarkdownEntry {
+    meta: Record<string, FrontmatterValue>;
+    body: string;
+}
+export declare function readMarkdownEntries(pluginRoot: string, directoryName: string): Record<string, MarkdownEntry>;
+export {};

package/dist/plugin-registry/markdown.js

@@ -0,0 +1,48 @@
+import fs from "node:fs";
+import path from "node:path";
+function extractFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+    if (!match)
+        return { meta: {}, body: content };
+    const meta = {};
+    for (const rawLine of match[1].split("\n")) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const separatorIndex = line.indexOf(":");
+        if (separatorIndex <= 0)
+            continue;
+        const key = line.slice(0, separatorIndex).trim();
+        let value = line.slice(separatorIndex + 1).trim().replace(/^['\"]|['\"]$/g, "");
+        if (value === "true")
+            value = true;
+        if (value === "false")
+            value = false;
+        meta[key] = value;
+    }
+    return { meta, body: match[2] };
+}
+function readMarkdownFiles(directoryPath) {
+    if (!fs.existsSync(directoryPath))
+        return [];
+    return fs
+        .readdirSync(directoryPath)
+        .filter((file) => file.endsWith(".md"))
+        .sort((left, right) => left.localeCompare(right));
+}
+export function readMarkdownEntries(pluginRoot, directoryName) {
+    const directoryPath = path.join(pluginRoot, directoryName);
+    const files = readMarkdownFiles(directoryPath);
+    const entries = {};
+    for (const file of files) {
+        const name = file.replace(/\.md$/, "");
+        const fullPath = path.join(directoryPath, file);
+        const content = fs.readFileSync(fullPath, "utf8");
+        const entry = extractFrontmatter(content);
+        entries[name] = {
+            meta: entry.meta,
+            body: entry.body.trim(),
+        };
+    }
+    return entries;
+}

package/dist/types.d.ts

@@ -0,0 +1,80 @@
+export interface CommandDefinition {
+    description?: string;
+    template: string;
+    agent?: string;
+    model?: string;
+    subtask?: boolean;
+}
+export interface AgentDefinition {
+    prompt: string;
+    description?: string;
+    mode?: string;
+    model?: string;
+    color?: string;
+    disable?: boolean;
+}
+export interface PluginConfig {
+    command?: Record<string, CommandDefinition>;
+    agent?: Record<string, AgentDefinition>;
+    default_agent?: string;
+}
+export interface CommandExecuteBeforeInput {
+    command: string;
+    sessionID: string;
+    arguments: string;
+}
+export interface CommandExecuteBeforeOutput {
+    parts: unknown[];
+}
+export interface ChatSystemTransformInput {
+    sessionID?: string;
+}
+export interface ChatSystemTransformOutput {
+    system: string[];
+}
+export interface SessionEvent {
+    type: string;
+    properties?: Record<string, unknown>;
+}
+export interface ToastBody {
+    title?: string;
+    message: string;
+    variant: "info" | "success" | "warning" | "error";
+    duration?: number;
+}
+export interface OpencodeClient {
+    tui: {
+        showToast(args: {
+            body: ToastBody;
+        }): Promise<unknown>;
+    };
+    session: {
+        messages(args: {
+            path: {
+                id: string;
+            };
+        }): Promise<unknown>;
+        prompt(args: {
+            path: {
+                id: string;
+            };
+            body: {
+                parts: Array<{
+                    type: "text";
+                    text: string;
+                }>;
+            };
+        }): Promise<unknown>;
+    };
+}
+export interface PluginHooks {
+    config?: (config: PluginConfig) => Promise<void>;
+    "command.execute.before"?: (input: CommandExecuteBeforeInput, output: CommandExecuteBeforeOutput) => Promise<void>;
+    "experimental.chat.system.transform"?: (input: ChatSystemTransformInput, output: ChatSystemTransformOutput) => Promise<void>;
+    event?: (input: {
+        event: SessionEvent;
+    }) => Promise<void>;
+}
+export interface PluginInput {
+    client: OpencodeClient;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,19 +1,31 @@
 {
   "name": "@nt-ai-lab/opencode-skillz",
-  "version": "0.2.8",
+  "version": "0.3.2",
   "description": "Bundled OpenCode commands and agents",
   "type": "module",
-  "main": "index.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
-    ".": "./index.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepack": "npm run build"
   },
   "files": [
-    "index.js",
+    "dist",
     "commands",
     "agents",
     "AGENTS.md",
     "README.md"
   ],
+  "devDependencies": {
+    "@types/node": "^24.7.2",
+    "typescript": "^5.9.3"
+  },
   "publishConfig": {
     "access": "public"
   }

package/index.js

@@ -1,237 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-import { fileURLToPath } from "node:url"
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-const pluginRoot = __dirname
-const commandNamespace = "nt-skillz"
-
-function buildCommandName(name) {
-  return `${commandNamespace}:${name}`
-}
-
-function extractFrontmatter(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/)
-  if (!match) return { meta: {}, body: content }
-
-  const meta = {}
-  for (const rawLine of match[1].split("\n")) {
-    const line = rawLine.trim()
-    if (!line || line.startsWith("#")) continue
-    const idx = line.indexOf(":")
-    if (idx <= 0) continue
-
-    const key = line.slice(0, idx).trim()
-    let value = line.slice(idx + 1).trim()
-    value = value.replace(/^['\"]|['\"]$/g, "")
-    if (value === "true") value = true
-    if (value === "false") value = false
-    meta[key] = value
-  }
-
-  return { meta, body: match[2] }
-}
-
-function readMarkdownFiles(dirPath) {
-  if (!fs.existsSync(dirPath)) return []
-  return fs
-    .readdirSync(dirPath)
-    .filter((file) => file.endsWith(".md"))
-    .sort((a, b) => a.localeCompare(b))
-}
-
-function normalizeCommandReference(value) {
-  if (!value || typeof value !== "string") return ""
-  return value.trim().replace(/_/g, "-")
-}
-
-function loadCommands() {
-  const commandsDir = path.join(pluginRoot, "commands")
-  const files = readMarkdownFiles(commandsDir)
-  const rawCommands = {}
-
-  for (const file of files) {
-    const name = file.replace(/\.md$/, "")
-    const fullPath = path.join(commandsDir, file)
-    const content = fs.readFileSync(fullPath, "utf8")
-    const { meta, body } = extractFrontmatter(content)
-
-    rawCommands[name] = {
-      meta,
-      body: body.trim(),
-    }
-  }
-
-  const commands = {}
-
-  function buildComposedTemplate(name, stack = new Set()) {
-    const rawCommand = rawCommands[name]
-    if (!rawCommand) return ""
-    if (stack.has(name)) return rawCommand.body
-
-    stack.add(name)
-
-    let template = rawCommand.body
-    const composeAfterName = normalizeCommandReference(rawCommand.meta.compose_after)
-    const composedCommand = rawCommands[composeAfterName]
-
-    if (composeAfterName && composedCommand) {
-      const composedTemplate = buildComposedTemplate(composeAfterName, stack)
-      if (composedTemplate) {
-        template = [
-          template,
-          `In addition you must adhere to the following:\n\n${composedTemplate}`,
-        ]
-          .filter(Boolean)
-          .join("\n\n")
-      }
-    }
-
-    stack.delete(name)
-
-    return template.trim()
-  }
-
-  for (const [name, rawCommand] of Object.entries(rawCommands)) {
-    const { meta } = rawCommand
-    const command = {
-      description: meta.description || `Run /${name}`,
-      template: buildComposedTemplate(name),
-    }
-
-    if (meta.agent) command.agent = meta.agent
-    if (meta.model) command.model = meta.model
-    if (typeof meta.subtask === "boolean") command.subtask = meta.subtask
-
-    commands[name] = command
-  }
-
-  return commands
-}
-
-function parseCsvList(value) {
-  if (!value || typeof value !== "string") return []
-  return value
-    .split(",")
-    .map((item) => item.trim())
-    .filter(Boolean)
-}
-
-function materializePreloadedTemplate(template) {
-  return template.replace(/\$ARGUMENTS/g, "all relevant current work in this session")
-}
-
-function loadAgents(commands) {
-  const agentsDir = path.join(pluginRoot, "agents")
-  const files = readMarkdownFiles(agentsDir)
-  const rawAgents = {}
-
-  for (const file of files) {
-    const name = file.replace(/\.md$/, "")
-    const fullPath = path.join(agentsDir, file)
-    const content = fs.readFileSync(fullPath, "utf8")
-    const { meta, body } = extractFrontmatter(content)
-
-    rawAgents[name] = {
-      meta,
-      body: body.trim(),
-    }
-  }
-
-  const agents = {}
-
-  function collectPreloadedCommands(agentName, stack = new Set()) {
-    const rawAgent = rawAgents[agentName]
-    if (!rawAgent) return []
-    if (stack.has(agentName)) return parseCsvList(rawAgent.meta.preload_commands)
-
-    stack.add(agentName)
-
-    const merged = []
-    const parentAgentName = typeof rawAgent.meta.extends === "string" ? rawAgent.meta.extends.trim() : ""
-    if (parentAgentName && rawAgents[parentAgentName]) {
-      merged.push(...collectPreloadedCommands(parentAgentName, stack))
-    }
-
-    merged.push(...parseCsvList(rawAgent.meta.preload_commands))
-    stack.delete(agentName)
-
-    return [...new Set(merged)]
-  }
-
-  for (const [name, raw] of Object.entries(rawAgents)) {
-    const { meta, body } = raw
-    const promptParts = []
-
-    const parentAgentName = typeof meta.extends === "string" ? meta.extends.trim() : ""
-    if (parentAgentName && rawAgents[parentAgentName]) {
-      const parentPrompt = rawAgents[parentAgentName].body
-      if (parentPrompt) promptParts.push(parentPrompt)
-    }
-
-    if (body) {
-      promptParts.push(body)
-    }
-
-    const preloadedCommands = collectPreloadedCommands(name)
-    for (const commandName of preloadedCommands) {
-      const command = commands[commandName]
-      if (!command || !command.template) continue
-      const rendered = materializePreloadedTemplate(command.template)
-      promptParts.push(`[Preloaded command /${commandName}]\n${rendered}`)
-    }
-
-    const agent = {
-      prompt: promptParts.join("\n\n").trim(),
-    }
-
-    if (meta.description) agent.description = meta.description
-    if (meta.mode) agent.mode = meta.mode
-    if (meta.model) agent.model = meta.model
-    if (meta.color) agent.color = meta.color
-
-    agents[name] = agent
-  }
-
-  return agents
-}
-
-export const OpencodeSkillzPlugin = async () => {
-  return {
-    config: async (config) => {
-      config.command = config.command || {}
-      config.agent = config.agent || {}
-
-      const commands = loadCommands()
-      for (const [name, command] of Object.entries(commands)) {
-        const commandName = buildCommandName(name)
-        if (!config.command[commandName]) {
-          config.command[commandName] = command
-        }
-      }
-
-      const agents = loadAgents(commands)
-      for (const [name, agent] of Object.entries(agents)) {
-        if (!config.agent[name]) {
-          config.agent[name] = agent
-        }
-      }
-
-      config.agent.build = {
-        ...(config.agent.build || {}),
-        disable: true,
-      }
-
-      config.agent.plan = {
-        ...(config.agent.plan || {}),
-        disable: true,
-      }
-
-      if (!config.default_agent && config.agent.default) {
-        config.default_agent = "default"
-      }
-    },
-  }
-}
-
-export default OpencodeSkillzPlugin