@opencoven/coven-code 0.0.1 → 0.0.3

package/src/plugins/api.mjs

@@ -0,0 +1,187 @@
+import { pathToFileURL } from 'node:url';
+import { createPluginConfigurationApi } from './configuration.mjs';
+import {
+  filePathFromURI,
+  filesModifiedByToolCall,
+  isPluginUINotAvailableError,
+  runPluginShell,
+  toolCallsInMessages,
+} from './helpers.mjs';
+import {
+  createPluginAI,
+  createPluginExperimentalApi,
+  createPluginLogger,
+  createPluginSystem,
+  createPluginThreadContext,
+  pluginEnvConfirm,
+  pluginEnvInput,
+  pluginEnvSelection,
+} from './subsystems.mjs';
+import { createSubscription } from './configuration.mjs';
+import {
+  removeFirst,
+  validateCommandAvailability,
+  validatePluginCommand,
+  validatePluginConfirmOptions,
+  validatePluginInputOptions,
+  validatePluginNotifyMessage,
+  validatePluginSelectOptions,
+  validatePluginToolDefinition,
+  validatePluginToolName,
+} from './validators.mjs';
+
+export function createPluginApi({ cwd, runtime }) {
+  return {
+    registerTool(tool) {
+      const summary = runtime.currentPlugin;
+      validatePluginToolName(tool?.name);
+      validatePluginToolDefinition(tool);
+      const registeredTool = { ...tool };
+      if (tool?.name) summary?.tools.push(tool.name);
+      runtime.tools.push(registeredTool);
+      return createSubscription(() => {
+        runtime.tools = runtime.tools.filter((entry) => entry !== registeredTool);
+        if (tool?.name && summary) removeFirst(summary.tools, tool.name);
+      });
+    },
+    registerCommand(name, metadata = {}, handler = async () => undefined) {
+      const summary = runtime.currentPlugin;
+      validatePluginCommand(name, metadata);
+      summary?.commands.push(name);
+      const commandMetadata = {
+        ...metadata,
+        category: metadata.category ?? summary?.name,
+      };
+      const command = {
+        name,
+        metadata: commandMetadata,
+        handler,
+        availability: validateCommandAvailability(name, commandMetadata.availability ?? { type: 'enabled' }),
+      };
+      runtime.commands.push(command);
+      return {
+        setAvailability(availability) {
+          command.availability = validateCommandAvailability(name, availability);
+        },
+        ...createSubscription(() => {
+          runtime.commands = runtime.commands.filter((entry) => entry !== command);
+          if (summary) removeFirst(summary.commands, name);
+        }),
+      };
+    },
+    on(eventName, handler) {
+      const summary = runtime.currentPlugin;
+      summary?.events.push(eventName);
+      if (!runtime.handlers[eventName]) runtime.handlers[eventName] = [];
+      runtime.handlers[eventName].push(handler);
+      return createSubscription(() => {
+        runtime.handlers[eventName] = (runtime.handlers[eventName] ?? []).filter((entry) => entry !== handler);
+        if (summary) removeFirst(summary.events, eventName);
+      });
+    },
+    configuration: createPluginConfigurationApi(cwd, runtime),
+    ai: createPluginAI(),
+    helpers: {
+      shellCommandFromToolCall(event = {}) {
+        if (event.tool !== 'Bash' && event.tool !== 'shell_command') return null;
+        const command = event.input?.command ?? event.input?.cmd;
+        if (typeof command !== 'string' || !command) return null;
+        const dir = typeof event.input?.dir === 'string' && event.input.dir ? event.input.dir : undefined;
+        return dir ? { command, dir } : { command };
+      },
+      toolCallsInMessages(messages = []) {
+        return toolCallsInMessages(messages);
+      },
+      filesModifiedByToolCall(event = {}) {
+        const files = filesModifiedByToolCall(event);
+        return files ? files.map((filePath) => pathToFileURL(filePath)) : null;
+      },
+      filePathFromURI(uri) {
+        return filePathFromURI(uri);
+      },
+      isPluginUINotAvailableError(error) {
+        return isPluginUINotAvailableError(error);
+      },
+    },
+    logger: createPluginLogger(),
+    system: createPluginSystem((target) => {
+      runtime.notifications.push(String(target));
+    }),
+    ui: {
+      async notify(message) {
+        runtime.notifications.push(validatePluginNotifyMessage(message));
+      },
+      confirm: async (options) => pluginEnvConfirm(options),
+      input: async (options) => pluginEnvInput(options),
+      select: async (options) => pluginEnvSelection(options),
+    },
+    $: (strings, ...values) => runPluginShell(cwd, strings, values),
+    experimental: createPluginExperimentalApi(runtime),
+  };
+}
+
+export function createPluginContext(event = {}) {
+  return {
+    logger: createPluginLogger(),
+    $: (strings, ...values) => runPluginShell(process.cwd(), strings, values),
+    ui: {
+      async notify(message) {
+        validatePluginNotifyMessage(message);
+      },
+      confirm: async (options) => {
+        validatePluginConfirmOptions(options);
+        return false;
+      },
+      input: async (options) => {
+        validatePluginInputOptions(options);
+        return undefined;
+      },
+      select: async (options) => {
+        validatePluginSelectOptions(options);
+        return undefined;
+      },
+    },
+    ai: createPluginAI(),
+    system: createPluginSystem(),
+    thread: createPluginThreadContext(event.thread?.id),
+  };
+}
+
+export function createPluginCommandContext(cwd = process.cwd()) {
+  const notifications = [];
+  const context = {
+    ui: {
+      async notify(message) {
+        notifications.push(validatePluginNotifyMessage(message));
+      },
+      confirm: async (options) => pluginEnvConfirm(options),
+      input: async (options) => pluginEnvInput(options),
+      select: async (options) => pluginEnvSelection(options),
+    },
+    system: createPluginSystem((target) => {
+      notifications.push(String(target));
+    }),
+    ai: createPluginAI(),
+    $: (strings, ...values) => runPluginShell(cwd, strings, values),
+    thread: createPluginThreadContext(),
+  };
+  Object.defineProperty(context, 'notifications', {
+    value: notifications,
+    enumerable: false,
+  });
+  return context;
+}
+
+export function createPluginToolContext() {
+  return {
+    ui: {
+      notify: async (message) => {
+        validatePluginNotifyMessage(message);
+      },
+      confirm: async (options) => pluginEnvConfirm(options),
+      input: async (options) => pluginEnvInput(options),
+      select: async (options) => pluginEnvSelection(options),
+    },
+    logger: createPluginLogger(),
+  };
+}

package/src/plugins/configuration.mjs

@@ -0,0 +1,124 @@
+import {
+  SETTINGS_PREFIX,
+  readEffectiveSettings,
+  readSettings,
+  readSettingsFile,
+  writeSettings,
+  writeSettingsFile,
+} from '../settings/load.mjs';
+import { findProjectRoot, workspaceSettingsFile } from '../settings/paths.mjs';
+
+export function createSubscription(dispose) {
+  return {
+    unsubscribe: dispose,
+  };
+}
+
+export function createPluginConfigurationApi(cwd, runtime) {
+  const observableSymbol = Symbol.observable ?? Symbol.for('observable');
+  const api = {
+    async get() {
+      return pluginConfiguration(readEffectiveSettings());
+    },
+    async update(patch = {}, scope = 'workspace') {
+      const normalizedPatch = normalizePluginConfigurationPatch(patch);
+      const target = normalizePluginConfigurationTarget(scope);
+      if (target === 'workspace') {
+        const filePath = workspaceSettingsFile(findProjectRoot(cwd));
+        await writeSettingsFile(filePath, { ...readSettingsFile(filePath), ...normalizedPatch });
+      } else {
+        await writeSettings({ ...readSettings(), ...normalizedPatch });
+      }
+      await notifyConfigurationSubscribers(runtime);
+    },
+    async delete(key, scope = 'workspace') {
+      const normalizedKey = normalizePluginConfigurationKey(key);
+      const target = normalizePluginConfigurationTarget(scope);
+      if (target === 'workspace') {
+        const filePath = workspaceSettingsFile(findProjectRoot(cwd));
+        const settings = readSettingsFile(filePath);
+        delete settings[normalizedKey];
+        await writeSettingsFile(filePath, settings);
+      } else {
+        const settings = readSettings();
+        delete settings[normalizedKey];
+        await writeSettings(settings);
+      }
+      await notifyConfigurationSubscribers(runtime);
+    },
+    subscribe(handler) {
+      validateObservableSubscriber(handler);
+      runtime.configurationSubscribers.push(handler);
+      return createSubscription(() => {
+        runtime.configurationSubscribers = runtime.configurationSubscribers.filter((entry) => entry !== handler);
+      });
+    },
+    pipe(op) {
+      return op(api);
+    },
+    [observableSymbol]() {
+      return api;
+    },
+  };
+  return api;
+}
+
+function pluginConfiguration(settings = {}) {
+  const config = { ...settings };
+  for (const [key, value] of Object.entries(settings)) {
+    if (key.startsWith(SETTINGS_PREFIX) && !Object.hasOwn(config, key.slice(SETTINGS_PREFIX.length))) {
+      config[key.slice(SETTINGS_PREFIX.length)] = value;
+    }
+  }
+  return config;
+}
+
+function normalizePluginConfigurationPatch(patch = {}) {
+  if (!patch || typeof patch !== 'object' || Array.isArray(patch)) {
+    throw new Error('plugin configuration update patch must be an object');
+  }
+  return Object.fromEntries(Object.entries(patch).map(([key, value]) => [
+    normalizePluginConfigurationKey(key),
+    value,
+  ]));
+}
+
+function normalizePluginConfigurationKey(key) {
+  if (typeof key !== 'string') {
+    throw new Error('plugin configuration key must be a string');
+  }
+  const text = String(key);
+  if (text.startsWith(SETTINGS_PREFIX)) return text;
+  return `${SETTINGS_PREFIX}${text}`;
+}
+
+function normalizePluginConfigurationTarget(target = 'workspace') {
+  if (target !== 'workspace' && target !== 'global') {
+    throw new Error(`plugin configuration target must be workspace or global: ${String(target)}`);
+  }
+  return target;
+}
+
+async function notifyConfigurationSubscribers(runtime) {
+  if (runtime.configurationSubscribers.length === 0) return;
+  const config = pluginConfiguration(readEffectiveSettings());
+  for (const subscriber of runtime.configurationSubscribers) {
+    await notifyObservableSubscriber(subscriber, config);
+  }
+}
+
+export async function notifyObservableSubscriber(subscriber, value) {
+  if (typeof subscriber === 'function') {
+    await subscriber(value);
+    return;
+  }
+  if (typeof subscriber?.next === 'function') {
+    await subscriber.next(value);
+  }
+}
+
+export function validateObservableSubscriber(subscriber) {
+  if (typeof subscriber === 'function') return;
+  if (subscriber && typeof subscriber === 'object' && !Array.isArray(subscriber)) return;
+  throw new Error('plugin observable subscriber must be a function or observer object');
+}