regent-code 3.0.0

package/mcp/install.js

@@ -0,0 +1,204 @@
+// One-command installer: patches an existing OpenCode config (opencode.json or
+// opencode.jsonc) to register the Regent MCP server AND the Regent plugin.
+//
+// Non-destructive and idempotent: only adds or updates regent entries, and
+// preserves comments, formatting, trailing commas, and every unrelated
+// setting. Handles both bare JSON and JSONC (comments, trailing commas)
+// through jsonc-parser's modify/applyEdits, which edit the text in place.
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { createRequire } from 'node:module';
+import {
+  parseTree,
+  findNodeAtLocation,
+  getNodeValue,
+  modify,
+  applyEdits,
+} from 'jsonc-parser';
+
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json');
+
+export const PLUGIN_SPEC = `regent-code@${version}`;
+export const SERVER_NAME = 'regent';
+export const SERVER_CONFIG = Object.freeze({
+  type: 'local',
+  command: ['npx', '-y', `regent-code@${version}`],
+  cwd: '.',
+});
+
+const CONFIG_NAMES = ['opencode.jsonc', 'opencode.json'];
+
+export class InstallError extends Error {}
+
+export function globalConfigDir() {
+  return process.env.XDG_CONFIG_HOME
+    ? join(process.env.XDG_CONFIG_HOME, 'opencode')
+    : join(homedir(), '.config', 'opencode');
+}
+
+export function projectCandidates(cwd) {
+  return [
+    join(cwd, '.opencode', 'opencode.jsonc'),
+    join(cwd, '.opencode', 'opencode.json'),
+    join(cwd, 'opencode.jsonc'),
+    join(cwd, 'opencode.json'),
+  ];
+}
+
+export function globalCandidates() {
+  return CONFIG_NAMES.map((name) => join(globalConfigDir(), name));
+}
+
+function findExisting(candidates) {
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+// Decide which file to patch. Never writes; the installer writes after
+// resolving. Explicit --file wins, then forced global, then: an existing
+// project config in cwd, else an existing global config, else the global
+// location (created on demand).
+export function resolveTarget({ cwd = process.cwd(), file, global = false } = {}) {
+  if (file) return { path: resolve(cwd, file), scope: 'explicit' };
+  if (global) {
+    const hit = findExisting(globalCandidates());
+    return { path: hit ?? join(globalConfigDir(), 'opencode.jsonc'), scope: 'global' };
+  }
+  const projectHit = findExisting(projectCandidates(cwd));
+  if (projectHit) return { path: projectHit, scope: 'project' };
+  const globalHit = findExisting(globalCandidates());
+  if (globalHit) return { path: globalHit, scope: 'global' };
+  return { path: join(globalConfigDir(), 'opencode.jsonc'), scope: 'global' };
+}
+
+export function detectEol(text) {
+  return text.includes('\r\n') ? '\r\n' : '\n';
+}
+
+function deepEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+// Pure text transform: returns { text, report } with report describing what
+// changed (mcp: added|updated|unchanged, plugin: added|updated|unchanged,
+// warnings: string[]).
+export function patchText(
+  text,
+  { pluginSpec = PLUGIN_SPEC, serverName = SERVER_NAME, serverConfig = SERVER_CONFIG } = {},
+) {
+  const errors = [];
+  const root = parseTree(text, errors);
+  if (!root || errors.length) {
+    throw new InstallError(`invalid JSONC: ${errors[0]?.error ?? 'could not parse'}`);
+  }
+  if (root.type !== 'object') {
+    throw new InstallError('config root must be an object');
+  }
+
+  const eol = detectEol(text);
+  const formattingOptions = { insertSpaces: true, tabSize: 2, eol };
+  const report = { mcp: 'unchanged', plugin: 'unchanged', warnings: [] };
+  let edits = [];
+
+  // ---- MCP server entry ----
+  const mcpNode = findNodeAtLocation(root, ['mcp']);
+  const serversNode = mcpNode ? findNodeAtLocation(mcpNode, ['servers']) : null;
+  const regentNode = serversNode ? findNodeAtLocation(serversNode, [serverName]) : null;
+
+  if (regentNode) {
+    const existing = getNodeValue(regentNode);
+    if (existing && typeof existing === 'object' && !Array.isArray(existing)) {
+      if (deepEqual(existing, serverConfig)) {
+        report.mcp = 'unchanged';
+      } else {
+        edits = edits.concat(
+          modify(text, ['mcp', 'servers', serverName], serverConfig, { formattingOptions }),
+        );
+        report.mcp = 'updated';
+      }
+    } else {
+      report.warnings.push(
+        `mcp.servers.${serverName} exists but is not an object; left untouched`,
+      );
+    }
+  } else if (mcpNode && mcpNode.type !== 'object') {
+    report.warnings.push('existing "mcp" key is not an object; left untouched');
+  } else if (serversNode && serversNode.type !== 'object') {
+    report.warnings.push('existing "mcp.servers" is not an object; left untouched');
+  } else {
+    edits = edits.concat(
+      modify(text, ['mcp', 'servers', serverName], serverConfig, { formattingOptions }),
+    );
+    report.mcp = 'added';
+  }
+
+  // ---- Plugin entry ----
+  const pluginsNode = findNodeAtLocation(root, ['plugins']);
+  if (pluginsNode) {
+    const existing = getNodeValue(pluginsNode);
+    if (!Array.isArray(existing)) {
+      report.warnings.push('existing "plugins" is not an array; left untouched');
+    } else {
+      const entries = existing.filter((entry) => typeof entry === 'string');
+      const nonString = existing.filter((entry) => typeof entry !== 'string');
+      const gitEntries = entries.filter((entry) => /^regent-code@(git\+|git )/.test(entry));
+      const filePin = entries.find(
+        (entry) => /^file:/.test(entry) && entry.toLowerCase().includes('regent'),
+      );
+      const hasNpmPin =
+        entries.some((entry) => entry.startsWith('regent-code@') && !/^regent-code@git/.test(entry)) ||
+        entries.includes('regent-code');
+
+      const next = entries
+        .filter((entry) => !gitEntries.includes(entry))
+        .concat(nonString);
+      let reportPlugin;
+      if (hasNpmPin && gitEntries.length === 0) {
+        reportPlugin = 'unchanged';
+      } else {
+        reportPlugin = gitEntries.length ? 'updated' : 'added';
+      }
+      if (!hasNpmPin) next.push(pluginSpec);
+      if (filePin) {
+        report.warnings.push(
+          'regent plugin pinned via file:// (dev loop); entry left untouched',
+        );
+      }
+      if (!deepEqual(next, existing)) {
+        edits = edits.concat(modify(text, ['plugins'], next, { formattingOptions }));
+        report.plugin = reportPlugin;
+      }
+    }
+  } else {
+    edits = edits.concat(modify(text, ['plugins'], [pluginSpec], { formattingOptions }));
+    report.plugin = 'added';
+  }
+
+  return { text: applyEdits(text, edits), report };
+}
+
+// Full install against the filesystem: resolves the target config, patches it
+// (creating the file with only the regent entries when none exists), and
+// returns the report plus target info.
+export function install(options = {}) {
+  const target = resolveTarget(options);
+  const existingText = existsSync(target.path) ? readFileSync(target.path, 'utf8') : null;
+  const base = existingText ?? `{\n}\n`;
+  const { text, report } = patchText(base, options);
+
+  if (text !== existingText) {
+    mkdirSync(dirname(target.path), { recursive: true });
+    writeFileSync(target.path, text);
+  }
+
+  return {
+    ...report,
+    path: target.path,
+    scope: target.scope,
+    created: existingText === null,
+  };
+}

package/mcp/prompts.js

@@ -0,0 +1,99 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const rootDir = path.resolve(__dirname, '..');
+
+/**
+ * Extract the body of a Markdown file after its YAML-ish frontmatter block.
+ * Mirrors the plugin's `extractContent` helper.
+ * @param {string} content
+ * @returns {string}
+ */
+const extractContent = (content) => {
+  const match = content.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?([\s\S]*)$/);
+  return match ? match[1] : content;
+};
+
+/** @param {string} content @param {string} key @returns {string} */
+function frontmatterValue(content, key) {
+  return content.match(new RegExp(`^${key}:\\s*(.+)$`, 'm'))?.[1]?.trim() || '';
+}
+
+/**
+ * Read a SKILL.md/command.md file into an MCP prompt definition.
+ * @param {string} name
+ * @param {string} description
+ * @param {string} location
+ * @returns {{ name: string, description: string, arguments: Array<{ name: string, description: string, required: boolean }>, template: string }}
+ */
+function toPrompt(name, description, location) {
+  let content = '';
+  let sourceDescription = description;
+  try {
+    if (fs.existsSync(location)) {
+      const raw = fs.readFileSync(location, 'utf8');
+      sourceDescription = frontmatterValue(raw, 'description') || description;
+      content = extractContent(raw).trim();
+    }
+  } catch {
+    /* non-fatal */
+  }
+  return {
+    name,
+    description: sourceDescription,
+    arguments: [
+      {
+        name: 'arguments',
+        description: 'Optional free-form arguments to append to the template',
+        required: false,
+      },
+    ],
+    template: content,
+  };
+}
+
+/** @returns {Array<{ name: string, description: string, arguments: Array<{ name: string, description: string, required: boolean }>, template: string }>} */
+export function readPackagePrompts() {
+  const prompts = [];
+
+  // Commands -> command.<name> prompts
+  const commandsDir = path.join(rootDir, '.opencode', 'commands');
+  if (fs.existsSync(commandsDir)) {
+    for (const entry of fs.readdirSync(commandsDir, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith('.md')) continue;
+      const name = entry.name.replace(/\.md$/, '');
+      prompts.push(
+        toPrompt(`command.${name}`, `Regent command: ${name}`, path.join(commandsDir, entry.name)),
+      );
+    }
+  }
+
+  // Skills -> skill.<id> prompts
+  const skillsDir = path.join(rootDir, '.opencode', 'skills');
+  if (fs.existsSync(skillsDir)) {
+    for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const location = path.join(skillsDir, entry.name, 'SKILL.md');
+      if (!fs.existsSync(location)) continue;
+      prompts.push(toPrompt(`skill.${entry.name}`, `Regent skill: ${entry.name}`, location));
+    }
+  }
+
+  return prompts;
+}
+
+/**
+ * Render a prompt template, substituting $ARGUMENTS with the provided value.
+ * @param {{ template: string }} prompt
+ * @param {Record<string, string> | undefined} args
+ * @returns {string}
+ */
+export function renderPrompt(prompt, args = {}) {
+  const argumentsText = typeof args?.arguments === 'string' ? args.arguments : '';
+  if (prompt.template.includes('$ARGUMENTS')) {
+    return prompt.template.replaceAll('$ARGUMENTS', () => argumentsText);
+  }
+  return argumentsText.trim() ? `${prompt.template}\n\n${argumentsText}` : prompt.template;
+}