@moderniser/plugin 0.1.0

package/dist/auth.d.ts

@@ -0,0 +1,24 @@
+export declare function moderniserAuth(): {
+    provider: string;
+    methods: {
+        type: "oauth";
+        label: string;
+        authorize(): Promise<{
+            url: string;
+            instructions: string;
+            method: "auto";
+            callback(): Promise<{
+                type: "failed";
+                key?: undefined;
+            } | {
+                type: "success";
+                key: string;
+            }>;
+        }>;
+    }[];
+    loader(auth: () => Promise<any>): Promise<{
+        apiKey: any;
+    } | {
+        apiKey?: undefined;
+    }>;
+};

package/dist/client.d.ts

@@ -0,0 +1,13 @@
+export declare const API: () => string;
+export declare class ApiError extends Error {
+    status: number;
+    constructor(status: number, message: string);
+}
+export declare function setStoredKey(key: string): void;
+export declare function storedKey(): string | undefined;
+export declare function api<T>(path: string, init?: RequestInit): Promise<T>;
+export declare const get: <T>(path: string) => Promise<T>;
+export declare const post: <T>(path: string, body: unknown) => Promise<T>;
+export declare const patch: <T>(path: string, body: unknown) => Promise<T>;
+export declare const del: <T>(path: string) => Promise<T>;
+export declare const json: (value: unknown) => string;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const ModerniserPlugin: Plugin;
+export default ModerniserPlugin;

package/dist/index.js

@@ -0,0 +1,468 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// packages/plugin/src/client.ts
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var API = () => (process.env.MODERNISER_API_URL ?? "https://v2.moderniser.ai/api").replace(/\/+$/, "");
+var BASE = API;
+
+class ApiError extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+}
+var stored;
+function setStoredKey(key) {
+  stored = key;
+}
+function storedKey() {
+  return stored;
+}
+function authFilePath() {
+  const data = process.env.XDG_DATA_HOME || join(homedir(), ".local", "share");
+  return join(data, "moderniser", "auth.json");
+}
+var fileKey;
+function fromAuthFile() {
+  if (fileKey !== undefined)
+    return fileKey ?? undefined;
+  fileKey = null;
+  let raw;
+  try {
+    raw = readFileSync(authFilePath(), "utf8");
+  } catch {
+    return;
+  }
+  try {
+    const entry = JSON.parse(raw)["moderniser"];
+    if (!entry || typeof entry !== "object")
+      return;
+    const { type, key } = entry;
+    if (type !== "api" || typeof key !== "string" || key.length === 0)
+      return;
+    fileKey = key;
+    return key;
+  } catch {
+    return;
+  }
+}
+function token() {
+  const value = process.env.MODERNISER_API_KEY ?? stored ?? fromAuthFile();
+  if (!value) {
+    throw new Error(`Not signed in to Moderniser. Run: moderniser providers login
+` + "(or set MODERNISER_API_KEY to a token from Settings in the web app).");
+  }
+  return value;
+}
+async function api(path, init = {}) {
+  const bearer = token();
+  let res;
+  try {
+    res = await fetch(`${BASE()}${path}`, {
+      ...init,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${bearer}`,
+        ...init.headers
+      },
+      signal: AbortSignal.timeout(30000)
+    });
+  } catch (error) {
+    throw new ApiError(0, `Could not reach Moderniser at ${BASE()}: ${error.message}`);
+  }
+  if (res.status === 204)
+    return;
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new ApiError(res.status, body.error ?? `Request failed with ${res.status}`);
+  }
+  return body;
+}
+var get = (path) => api(path);
+var post = (path, body) => api(path, { method: "POST", body: JSON.stringify(body) });
+var patch = (path, body) => api(path, { method: "PATCH", body: JSON.stringify(body) });
+var json = (value) => JSON.stringify(value, null, 2);
+
+// packages/plugin/src/auth.ts
+async function start() {
+  const label = [process.env.USER, __require("node:os").hostname()].filter(Boolean).join("@");
+  const res = await fetch(`${API()}/auth/device`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ label }),
+    signal: AbortSignal.timeout(15000)
+  });
+  if (!res.ok) {
+    throw new Error(`Could not reach Moderniser at ${API()} (${res.status}). Check MODERNISER_API_URL.`);
+  }
+  return await res.json();
+}
+async function poll(deviceCode, expiresIn, intervalSeconds) {
+  const deadline = Date.now() + expiresIn * 1000;
+  let interval = Math.max(intervalSeconds, 1) * 1000;
+  while (Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, interval));
+    let body;
+    try {
+      const res = await fetch(`${API()}/auth/device/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ deviceCode }),
+        signal: AbortSignal.timeout(15000)
+      });
+      body = await res.json();
+    } catch {
+      continue;
+    }
+    if (body.token)
+      return body.token;
+    if (body.error === "authorization_pending")
+      continue;
+    if (body.error === "slow_down") {
+      interval += 2000;
+      continue;
+    }
+    return null;
+  }
+  return null;
+}
+function moderniserAuth() {
+  return {
+    provider: "moderniser",
+    methods: [
+      {
+        type: "oauth",
+        label: "Sign in with Moderniser",
+        async authorize() {
+          const started = await start();
+          return {
+            url: started.verificationUrl,
+            instructions: `Check that your browser shows this code: ${started.userCode}`,
+            method: "auto",
+            async callback() {
+              const token2 = await poll(started.deviceCode, started.expiresIn, started.interval);
+              if (!token2)
+                return { type: "failed" };
+              setStoredKey(token2);
+              return { type: "success", key: token2 };
+            }
+          };
+        }
+      }
+    ],
+    async loader(auth) {
+      const stored2 = await auth().catch(() => {
+        return;
+      });
+      const key = stored2?.type === "api" ? stored2.key : undefined;
+      if (key)
+        setStoredKey(key);
+      return key ? { apiKey: key } : {};
+    }
+  };
+}
+
+// packages/plugin/src/tools-boards.ts
+import { tool } from "@opencode-ai/plugin";
+var z = tool.schema;
+var STATUS = ["todo", "in_progress", "in_review", "blocked", "done"];
+var TYPE = ["feature", "bug", "improvement", "chore"];
+var FILES_TO_MODIFY = "Paths you have actually opened, written exactly as you reached them from the folder this session started in — 'orders/src/Order.java', not an absolute path and not a path you have rewritten. When a task spans two codebases the leading folder is the only thing telling a reader which one a change is in. Leave this empty rather than guessing.";
+function commentPath(taskId, subtaskId) {
+  if (Boolean(taskId) === Boolean(subtaskId)) {
+    throw new Error("Pass exactly one of taskId or subtaskId");
+  }
+  return taskId ? `/projects/tasks/${taskId}/comments` : `/projects/subtasks/${subtaskId}/comments`;
+}
+var boardTools = {
+  list_projects: tool({
+    description: "List the projects belonging to the caller's company. Call this first — every task belongs to a project, and you need a project id before you can create one.",
+    args: {},
+    async execute() {
+      return json((await get("/projects")).projects);
+    }
+  }),
+  create_project: tool({
+    description: "Create a project. A project is an area of work, and it may span several codebases — a checkout modernisation touches the storefront and the system that receives the order. Check list_projects first, since a duplicate fragments the board.",
+    args: {
+      name: z.string().describe("Short name, e.g. 'Checkout modernisation'"),
+      description: z.string().describe("What this covers and why it is being worked on").optional(),
+      keyPrefix: z.string().regex(/^[A-Z]{3}$/).describe("Three uppercase letters used to key tasks, e.g. 'CAD' gives CAD-1. Omit it and one is derived from the name.").optional()
+    },
+    async execute(args) {
+      return json((await post("/projects", args)).project);
+    }
+  }),
+  list_tasks: tool({
+    description: "List the tasks in a project with their status. Use this to see what already exists before creating more.",
+    args: {
+      projectId: z.string().describe("Project id from list_projects"),
+      status: z.enum(STATUS).describe("Only tasks in this status").optional()
+    },
+    async execute({ projectId, status }) {
+      const query = status ? `?status=${status}` : "";
+      return json((await get(`/projects/${projectId}/tasks${query}`)).tasks);
+    }
+  }),
+  get_task: tool({
+    description: "Fetch one task with all of its subtasks. Use this before updating anything, so you are editing against the current state rather than what you remember.",
+    args: { taskId: z.string().describe("Task id") },
+    async execute(args) {
+      return json((await get(`/projects/tasks/${args.taskId}`)).task);
+    }
+  }),
+  create_task: tool({
+    description: "Create a task: one unit of work a team would plan together, such as 'Upgrade to SAP Commerce 2211'. Read the relevant code before writing the description — a task that describes the actual state of the code is worth keeping, one written from assumption is not. Break it into subtasks afterwards with create_subtask.",
+    args: {
+      projectId: z.string().describe("Project id from list_projects"),
+      title: z.string().max(300).describe("Imperative and specific: 'Replace deprecated FlexibleSearch calls'"),
+      description: z.string().describe("What needs doing and why, including what you found in the code — current version, affected modules, known blockers"),
+      type: z.enum(TYPE).describe("Defaults to feature").optional()
+    },
+    async execute({ projectId, ...body }) {
+      return json((await post(`/projects/${projectId}/tasks`, body)).task);
+    }
+  }),
+  update_task: tool({
+    description: "Update a task's title, description, type or status. Move it to in_progress when work starts. Prefer in_review over done when you have finished but a person has not checked it — done is a human's word. Use blocked when you cannot proceed, and say why in a comment.",
+    args: {
+      taskId: z.string().describe("Task id"),
+      title: z.string().max(300).describe("New title").optional(),
+      description: z.string().describe("New description").optional(),
+      type: z.enum(TYPE).describe("New type").optional(),
+      status: z.enum(STATUS).describe("New status").optional()
+    },
+    async execute({ taskId, ...body }) {
+      return json((await patch(`/projects/tasks/${taskId}`, body)).task);
+    }
+  }),
+  list_subtasks: tool({
+    description: "List the subtasks of a task, in order.",
+    args: { taskId: z.string().describe("Task id") },
+    async execute(args) {
+      return json((await get(`/projects/tasks/${args.taskId}/subtasks`)).subtasks);
+    }
+  }),
+  create_subtask: tool({
+    description: "Add a subtask: one concrete change a developer could pick up and finish, in one codebase. Populate filesToModify with paths you have actually opened; leave it empty rather than filling it with guesses. Work that genuinely spans two codebases is two subtasks, which is also what keeps 'done' honest.",
+    args: {
+      taskId: z.string().describe("Task id"),
+      title: z.string().max(300).describe("One specific change"),
+      description: z.string().describe("What to change and how you know it needs changing"),
+      filesToModify: z.array(z.string()).describe(FILES_TO_MODIFY).optional(),
+      implementationNotes: z.string().describe("Anything that saves the next person a search: the symbol to grep for, the call sites, the order to do things in").optional(),
+      order: z.number().int().describe("Position in the list. Lower runs first.").optional()
+    },
+    async execute({ taskId, ...body }) {
+      return json((await post(`/projects/tasks/${taskId}/subtasks`, body)).subtask);
+    }
+  }),
+  update_subtask: tool({
+    description: "Update a subtask. Use this to mark one done as you finish it, so the board reflects reality while the work is happening rather than after.",
+    args: {
+      subtaskId: z.string().describe("Subtask id"),
+      title: z.string().max(300).describe("New title").optional(),
+      description: z.string().describe("New description").optional(),
+      status: z.enum(STATUS).describe("New status").optional(),
+      filesToModify: z.array(z.string()).describe(FILES_TO_MODIFY).optional(),
+      implementationNotes: z.string().describe("Notes for whoever picks this up").optional(),
+      order: z.number().int().describe("Position in the list").optional()
+    },
+    async execute({ subtaskId, ...body }) {
+      return json((await patch(`/projects/subtasks/${subtaskId}`, body)).subtask);
+    }
+  }),
+  list_comments: tool({
+    description: "Read the comment thread on a task or a subtask. Do this before acting on work someone else planned — a correction from a human usually lives here rather than in the description. Pass exactly one of taskId or subtaskId.",
+    args: {
+      taskId: z.string().describe("Task id").optional(),
+      subtaskId: z.string().describe("Subtask id").optional()
+    },
+    async execute(args) {
+      const path = commentPath(args.taskId, args.subtaskId);
+      return json((await get(path)).comments);
+    }
+  }),
+  add_comment: tool({
+    description: "Leave a comment on a task or subtask. Use it to record what you found, what you changed, or why you departed from the plan — not to restate the description. Comments you write are labelled as coming from the agent. Pass exactly one of taskId or subtaskId.",
+    args: {
+      body: z.string().max(1e4).describe("The comment"),
+      taskId: z.string().describe("Task id").optional(),
+      subtaskId: z.string().describe("Subtask id").optional()
+    },
+    async execute(args) {
+      const path = commentPath(args.taskId, args.subtaskId);
+      return json((await post(path, { body: args.body, source: "agent" })).comment);
+    }
+  })
+};
+
+// packages/plugin/src/tools-context-hub.ts
+import { tool as tool2 } from "@opencode-ai/plugin";
+var z2 = tool2.schema;
+var contextHubTools = {
+  search_context_hub: tool2({
+    description: "Search the company's internal documentation. Run this before answering a question about how something works here — the wiki usually explains the intent that the code only implies, and it is where conventions, past decisions and known traps are written down. Searches by meaning as well as by keyword, so a question phrased differently to the page still finds it. Results carry a score and a staleness flag; a stale page is past its review date and may be wrong. Follow up with read_context_hub_page for the full text.",
+    args: {
+      query: z2.string().describe("What you want to know. A phrase or question works better than a single word."),
+      mode: z2.enum(["hybrid", "keyword", "semantic"]).describe("hybrid (default) searches by meaning and by keyword. Use keyword when looking for an exact identifier, class name or error string.").optional(),
+      spaceId: z2.string().describe("Optional: restrict to one space, from list_context_hub_spaces").optional(),
+      tag: z2.string().describe("Optional: restrict to pages carrying this tag").optional(),
+      limit: z2.number().int().describe("Maximum results, default 20, maximum 50").optional()
+    },
+    async execute(args) {
+      const params = new URLSearchParams({ q: args.query });
+      if (args.mode)
+        params.set("mode", args.mode);
+      if (args.spaceId)
+        params.set("spaceId", args.spaceId);
+      if (args.tag)
+        params.set("tag", args.tag);
+      if (args.limit)
+        params.set("limit", String(args.limit));
+      return json((await get(`/context-hub/search?${params}`)).results);
+    }
+  }),
+  list_context_hub_spaces: tool2({
+    description: "List the spaces in the Context Hub. A space groups related pages — typically one per system, team or imported wiki. Use it to narrow a search when a keyword is too common.",
+    args: {},
+    async execute() {
+      return json((await get("/context-hub/spaces")).spaces);
+    }
+  }),
+  list_context_hub_pages: tool2({
+    description: "List the pages in a space, with titles and when they were last updated. Bodies are not included — read_context_hub_page fetches those.",
+    args: { spaceId: z2.string().describe("Space id from list_context_hub_spaces") },
+    async execute(args) {
+      return json((await get(`/context-hub/spaces/${args.spaceId}/pages`)).pages);
+    }
+  }),
+  read_context_hub_page: tool2({
+    description: "Read one page in full. Cite what you found from it when it changes your answer, so the person can check the source — the wiki can be out of date, and saying where a claim came from is what lets them notice.",
+    args: { pageId: z2.string().describe("Page id from search or list") },
+    async execute(args) {
+      return json((await get(`/context-hub/pages/${args.pageId}`)).page);
+    }
+  }),
+  create_context_hub_page: tool2({
+    description: "Write a new page. Use this when you have worked something out that the next person would otherwise have to rediscover — a migration procedure, why an approach was rejected, how two systems actually talk to each other. Search first: adding a second page on a subject that already has one makes both less trustworthy.",
+    args: {
+      spaceId: z2.string().describe("Space to create the page in"),
+      title: z2.string().max(300).describe("Specific and searchable: 'Upgrading SAP Commerce 1905 to 2211'"),
+      content: z2.string().describe("Markdown body")
+    },
+    async execute({ spaceId, ...body }) {
+      return json((await post(`/context-hub/spaces/${spaceId}/pages`, body)).page);
+    }
+  }),
+  update_context_hub_page: tool2({
+    description: "Replace a page's title or body. The content you send replaces what is there — read the page first and return the whole document with your changes folded in, or you will delete the parts you did not mention.",
+    args: {
+      pageId: z2.string().describe("Page id"),
+      title: z2.string().max(300).describe("New title").optional(),
+      content: z2.string().describe("The complete new markdown body, not a fragment").optional()
+    },
+    async execute({ pageId, ...body }) {
+      return json((await patch(`/context-hub/pages/${pageId}`, body)).page);
+    }
+  })
+};
+
+// packages/plugin/src/index.ts
+var API2 = () => (process.env.MODERNISER_API_URL ?? "https://v2.moderniser.ai/api").replace(/\/+$/, "");
+var KEY = () => process.env.MODERNISER_API_KEY;
+var GATEWAY = () => {
+  const raw = (process.env.MODERNISER_GATEWAY_URL ?? "https://gateway.moderniser.ai").replace(/\/+$/, "");
+  return raw.endsWith("/v1") ? raw : `${raw}/v1`;
+};
+var PROVIDER_ID = "moderniser";
+var DEFAULT_MODEL = `${PROVIDER_ID}/emm`;
+async function call(path, body) {
+  const key = KEY() ?? storedKey();
+  if (!key)
+    return null;
+  try {
+    return await fetch(`${API2()}${path}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${key}` },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(1e4)
+    });
+  } catch {
+    return null;
+  }
+}
+var registered = new Set;
+var reported = new Map;
+var ModerniserPlugin = async () => {
+  return {
+    config: async (config) => {
+      const models = {
+        emm: { name: "Enterprise Modernisation Model", tool_call: true, reasoning: true },
+        "emm-high": {
+          name: "Enterprise Modernisation Model (deep reasoning)",
+          tool_call: true,
+          reasoning: true
+        }
+      };
+      const key = KEY();
+      config.provider ??= {};
+      config.provider[PROVIDER_ID] ??= {
+        name: "Moderniser",
+        npm: "@ai-sdk/openai-compatible",
+        options: { baseURL: GATEWAY(), ...key ? { apiKey: key } : {} },
+        models
+      };
+      const requested = process.env.MODERNISER_MODEL;
+      if (requested !== "off") {
+        config.model ??= requested || DEFAULT_MODEL;
+        config.small_model ??= config.model;
+      }
+    },
+    tool: { ...boardTools, ...contextHubTools },
+    auth: moderniserAuth(),
+    event: async ({ event }) => {
+      const type = event?.type;
+      if (type === "session.updated" || type === "session.status") {
+        const sessionId = event.properties?.info?.id ?? event.properties?.sessionID;
+        if (typeof sessionId === "string" && !registered.has(sessionId)) {
+          registered.add(sessionId);
+          await call("/billing/sessions", { sessionId });
+        }
+        return;
+      }
+      if (type !== "message.updated")
+        return;
+      const info = event.properties?.info;
+      if (!info || info.role !== "assistant")
+        return;
+      const tokens = info.tokens;
+      if (!tokens)
+        return;
+      const total = (tokens.input ?? 0) + (tokens.output ?? 0) + (tokens.reasoning ?? 0) + (tokens.cache?.read ?? 0) + (tokens.cache?.write ?? 0);
+      if (total === 0)
+        return;
+      if (reported.get(info.id) === total)
+        return;
+      reported.set(info.id, total);
+      await call("/billing/usage", {
+        sessionId: info.sessionID,
+        inputTokens: tokens.input ?? 0,
+        outputTokens: tokens.output ?? 0,
+        reasoningTokens: tokens.reasoning ?? 0,
+        cacheReadTokens: tokens.cache?.read ?? 0,
+        cacheWriteTokens: tokens.cache?.write ?? 0,
+        model: info.modelID
+      });
+    }
+  };
+};
+var src_default = ModerniserPlugin;
+export {
+  src_default as default,
+  ModerniserPlugin
+};

package/dist/tools-boards.d.ts

@@ -0,0 +1,2 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+export declare const boardTools: Record<string, ToolDefinition>;

package/dist/tools-context-hub.d.ts

@@ -0,0 +1,2 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+export declare const contextHubTools: Record<string, ToolDefinition>;

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@moderniser/plugin",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Moderniser plugin for opencode: points inference at the gateway, carries the board and Context Hub tools, and reports session telemetry",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moderniser-ai/cloud.git",
+    "directory": "packages/plugin"
+  },
+  "homepage": "https://v2.moderniser.ai",
+  "main": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": "*"
+  },
+  "types": "./dist/index.d.ts"
+}