skill-usage-tracker.ts

import type { Plugin } from "@opencode-ai/plugin"
import { appendFile, mkdir } from "node:fs/promises"
import path from "node:path"
import os from "node:os"

const LOG_PATH = path.join(os.homedir(), ".local", "share", "opencode", "skill-usage-tracker.jsonl")
const BUILTIN_COMMANDS = new Set(["init", "review"])

export default {
  id: "skill-usage-tracker",
  server: () => {
    const logPath = LOG_PATH

    async function append(record: Record<string, unknown>) {
      await mkdir(path.dirname(logPath), { recursive: true })
      await appendFile(logPath, JSON.stringify(record) + "\n")
    }

    async function readAll(): Promise<Record<string, unknown>[]> {
      const file = Bun.file(logPath)
      if (!(await file.exists())) return []
      const text = await file.text()
      return text
        .trim()
        .split("\n")
        .filter(Boolean)
        .map((line) => JSON.parse(line))
    }

    return Promise.resolve({
      "command.execute.before": async (cmd: { command: string; sessionID: string; arguments: string }) => {
        if (BUILTIN_COMMANDS.has(cmd.command)) return
        await append({
          timestamp: new Date().toISOString(),
          sessionID: cmd.sessionID,
          skillName: cmd.command,
          source: "slash-command",
          arguments: cmd.arguments,
        })
      },
      "tool.execute.before": async (
        toolInput: { tool: string; sessionID: string; callID: string },
        output: { args: any },
      ) => {
        if (toolInput.tool !== "skill") return
        await append({
          timestamp: new Date().toISOString(),
          sessionID: toolInput.sessionID,
          skillName: output.args?.name,
          source: "tool-call",
        })
      },
      tool: {
        "skill-log": {
          description:
            "Query the skill invocation log. Returns tracked skill invocations with timestamps and session IDs.",
          args: {
            type: "object",
            properties: {
              limit: { type: "number", description: "Max entries to return (default: 50)" },
              session: { type: "string", description: "Filter by session ID" },
            },
          },
          async execute(args: { limit?: number; session?: string }) {
            let entries = await readAll()
            if (args.session) {
              entries = entries.filter((e) => e.sessionID === args.session)
            }
            const limit = args.limit ?? 50
            const sliced = entries.slice(-limit)
            return {
              title: `Skill invocation log (${sliced.length} entries)`,
              output: sliced
                .map(
                  (e: any) =>
                    `[${e.timestamp}] session=${e.sessionID} skill=${e.skillName} via=${e.source}`,
                )
                .join("\n"),
              metadata: { entries: sliced, count: sliced.length },
            }
          },
        },
      },
    })
  },
}