@24klynx/plugins 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,353 @@
+//#region src/types.d.ts
+/**
+ * Plugin system core types.
+ *
+ * Every plugin ships a manifest.json with static metadata and an
+ * entry point. The loader reads the manifest first, validates it,
+ * then lazily imports the entry module.
+ */
+/** Static metadata declared in a plugin's manifest.json. */
+interface PluginManifest {
+  name: string;
+  version: string;
+  description: string;
+  author?: string;
+  /** Relative path to the entry module, e.g. "./index.js". */
+  entry: string;
+  /** Lynx‑specific constraints and capabilities. */
+  lynx: {
+    minVersion: string; /** Which contract types this plugin fulfills. */
+    contracts: string[]; /** Declared capabilities. */
+    capabilities: {
+      tools?: string[];
+      hooks?: string[];
+      channels?: string[];
+      models?: string[];
+    }; /** Feature flags that must be enabled for this plugin. */
+    dangerousFlags?: string[]; /** Required permissions. */
+    permissions?: {
+      filesystem?: string;
+      network?: string;
+      exec?: string;
+    };
+  };
+}
+/** The live plugin instance returned by the loader. */
+interface PluginContract {
+  /** Same id as in the manifest. */
+  id: string;
+  manifest: PluginManifest;
+  /** Tools registered by this plugin. */
+  tools: PluginTool[];
+  /** Hooks registered by this plugin. */
+  hooks: PluginHook[];
+  /** Cleanup function called on unload. */
+  onUnload?: () => void | Promise<void>;
+}
+/** A tool contributed by a plugin. */
+interface PluginTool {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+  handler: (input: Record<string, unknown>) => Promise<{
+    success: boolean;
+    content: string;
+  }>;
+}
+/** A hook contributed by a plugin. */
+interface PluginHook {
+  type: string;
+  /** Priority — lower numbers run first. */
+  priority: number;
+  handler: (event: unknown) => Promise<void>;
+}
+/**
+ * Runtime context passed to every plugin during initialisation.
+ *
+ * This is the INTERNAL contract between the plugin loader and plugin modules.
+ * Plugin authors use the SDK's `PluginContext` (from `@lynx/plugin-sdk`),
+ * which wraps this with additional registration helpers.
+ */
+interface PluginRuntimeContext {
+  /** Unique plugin id assigned by the loader. */
+  pluginId: string;
+  /** Scoped logger for this plugin. */
+  logger: {
+    info(msg: string): void;
+    warn(msg: string): void;
+    error(msg: string): void;
+  };
+  /** Per‑plugin configuration from settings. */
+  config: Record<string, unknown>;
+  /** Per‑plugin persistent key‑value store. */
+  storage: {
+    get<T>(key: string): T | undefined;
+    set<T>(key: string, value: T): void;
+    delete(key: string): void;
+    clear(): void;
+  };
+}
+/** The default export of a plugin entry module. */
+type PluginEntryFunction = (ctx: PluginRuntimeContext) => PluginContract | Promise<PluginContract>;
+/** All hook event names that plugins can subscribe to. */
+type HookType = "before_tool_call" | "after_tool_call" | "before_llm_call" | "after_llm_call" | "on_session_start" | "on_session_end" | "on_message_received" | "on_message_sent" | "on_permission_decision";
+interface HookSink {
+  type: HookType;
+  /** The owning plugin id. */
+  pluginId: string;
+  priority: number;
+  handler: (event: unknown) => Promise<void>;
+}
+//#endregion
+//#region src/discovery.d.ts
+interface ManifestEntry {
+  /** Absolute path to the plugin directory. */
+  dir: string;
+  /** Parsed manifest content. */
+  manifest: PluginManifest;
+}
+interface ManifestRegistry {
+  /** Scan one or more directories for plugin manifests. */
+  scan(directories: string[]): ManifestEntry[];
+  /** Get a plugin by id (fast lookup). */
+  getById(id: string): ManifestEntry | undefined;
+  /** List all discovered plugins. */
+  listAll(): ManifestEntry[];
+  /** How many plugins are registered. */
+  count(): number;
+}
+/**
+ * Create a manifest registry.
+ *
+ * Call `scan()` during Phase 2 startup to populate it,
+ * then use `getById()` / `listAll()` for fast lookups.
+ */
+declare function createManifestRegistry(): ManifestRegistry;
+//#endregion
+//#region src/loader.d.ts
+interface PluginLoader {
+  /** Load a plugin from its manifest entry. */
+  load(entry: ManifestEntry, ctx: PluginRuntimeContext): Promise<PluginContract>;
+  /** Unload a previously loaded plugin. */
+  unload(pluginName: string): void;
+  /** Get a loaded plugin. */
+  getLoaded(pluginName: string): PluginContract | undefined;
+  /** List all loaded plugin names. */
+  listLoaded(): string[];
+  /** Destroy all loaded plugins. */
+  destroy(): Promise<void>;
+}
+/**
+ * Create a plugin loader with lazy import and caching.
+ */
+declare function createPluginLoader(): PluginLoader;
+//#endregion
+//#region src/hooks.d.ts
+type FailureStrategy = "fail-open" | "fail-closed";
+interface HookRegistry {
+  /** Register a sink. Lower priority runs first. */
+  register(sink: HookSink): void;
+  /** Remove all sinks for a plugin. */
+  unregisterPlugin(pluginId: string): void;
+  /** Dispatch an event to all registered hooks of this type. */
+  dispatch(type: HookType, event: unknown, strategy?: FailureStrategy): Promise<void>;
+  /** How many sinks are registered. */
+  count(): number;
+}
+/**
+ * Create a hook registry.
+ *
+ * Hooks are stored in priority‑ordered arrays per hook type.
+ * Dispatch iterates them in order and short‑circuits on fail‑closed.
+ */
+declare function createHookRegistry(): HookRegistry;
+//#endregion
+//#region src/predictive-loader.d.ts
+/**
+ * Predictive loader — pre‑warms plugins before they are needed.
+ *
+ * Priority‑based warmup queue that loads plugins during idle time
+ * (Phase 2 startup background tasks) and reactively based on input
+ * prefix heuristics.
+ *
+ * Reference: §17 PredictiveLoader design
+ */
+/** A plugin module after lazy import(). */
+type PluginModule = unknown;
+declare class PredictiveLoader {
+  /** Map of already loaded plugins. */
+  private _loaded;
+  /** Set of plugin ids currently being imported. */
+  private _warming;
+  /** Priority queue (higher number = more important). */
+  private _queue;
+  /** Abort controller for cancelling in‑flight warmups. */
+  private _abort;
+  /** Dynamic import function (injectable for testing). */
+  private _importFn;
+  constructor(importFn: (id: string) => Promise<PluginModule>);
+  /** Whether the plugin has already been loaded. */
+  isLoaded(pluginId: string): boolean;
+  /** Whether the plugin is currently being warmed. */
+  isWarming(pluginId: string): boolean;
+  /**
+   * Enqueue a plugin for warming at the given priority.
+   * Higher priority plugins are processed first.
+   */
+  enqueue(pluginId: string, priority: number): void;
+  /** Process the entire warmup queue (non‑blocking — yields between imports). */
+  processQueue(): Promise<void>;
+  /** Stop all in‑flight warmups and clear the queue. */
+  abort(): void;
+  /** Number of plugins currently queued for warming. */
+  get pendingCount(): number;
+  /** Number of plugins that have been successfully loaded. */
+  get loadedCount(): number;
+  /**
+   * Predict which plugins to warm based on input prefix.
+   *
+   * Heuristics (200 ms window after prefix character):
+   *   "/" → skill plugins
+   *   "@" → model/provider plugins
+   */
+  onInputPrefix(prefix: string): void;
+  /**
+   * Predict which plugins to warm based on a pending action.
+   *   "file_read"  → file operations plugin
+   *   "code_edit"  → editor tool plugin
+   */
+  onActionPending(action: string): void;
+}
+//#endregion
+//#region src/sdk/types.d.ts
+/**
+ * Plugin SDK types — the context object passed to every plugin's
+ * register callback.
+ */
+/** Simple scoped logger for plugins. */
+interface PluginLogger {
+  info(msg: string): void;
+  warn(msg: string): void;
+  error(msg: string): void;
+}
+/**
+ * The API surface available to a plugin during registration.
+ *
+ * Pattern: the plugin's `register(ctx)` callback receives this
+ * object and uses it to declare tools, hooks, and interact with
+ * the Lynx runtime.
+ */
+interface PluginContext {
+  /** Unique id assigned to this plugin instance. */
+  readonly pluginId: string;
+  /** Logger bound to this plugin's namespace. */
+  readonly logger: PluginLogger;
+  /** Plugin‑scoped key‑value store (persisted to disk). */
+  readonly storage: PluginStorage;
+  /** Emit an event that other plugins can subscribe to. */
+  emit(event: string, payload: unknown): void;
+}
+/** Simple key‑value store scoped to a single plugin. */
+interface PluginStorage {
+  get<T = unknown>(key: string): T | undefined;
+  set<T = unknown>(key: string, value: T): void;
+  delete(key: string): void;
+  clear(): void;
+}
+//#endregion
+//#region src/sdk/define-plugin.d.ts
+/** What a plugin's register function returns. */
+interface PluginDefinition {
+  /** Display name. */
+  name: string;
+  /** Semver version string. */
+  version?: string;
+  /** Human‑readable description. */
+  description?: string;
+  /** Hook declarations (executed by the hook engine). */
+  hooks?: HookDeclaration[];
+}
+/** A hook declaration — static metadata, handler runs at runtime. */
+interface HookDeclaration {
+  /** Hook event name (e.g. "before_agent_reply"). */
+  type: string;
+  /** "fail-open": hook failure doesn't block; "fail-closed": hook failure rejects. */
+  policy: "fail-open" | "fail-closed";
+  /** The handler function. */
+  handler: (event: unknown) => Promise<void>;
+}
+/** The register callback signature. */
+type PluginRegisterFn = (ctx: PluginContext) => PluginDefinition | Promise<PluginDefinition>;
+/** The shape returned by `definePlugin`. */
+interface DefinedPlugin {
+  /** Unique plugin id (from manifest.json). */
+  id: string;
+  manifest: PluginManifest;
+  register: PluginRegisterFn;
+}
+/**
+ * Declare a Lynx plugin.
+ *
+ * `register` is called once at startup with a {@link PluginContext}
+ * that provides logging, storage, and event emission.
+ */
+declare function definePlugin(manifest: PluginManifest, register: PluginRegisterFn): DefinedPlugin;
+//#endregion
+//#region src/sdk/define-tool.d.ts
+/**
+ * `defineTool` — declare a tool that a plugin contributes to the agent.
+ *
+ * Pattern (inspired by FengMing's `api.registerTool`):
+ *   const myTool = defineTool({
+ *     name: "my_tool",
+ *     description: "Does something useful",
+ *     inputSchema: { type: "object", properties: {...} },
+ *     handler: async (input) => ({ success: true, content: "done" }),
+ *   });
+ */
+/**
+ * Lightweight tool descriptor — the subset of internal `ToolDescriptor`
+ * that plugin authors need to provide. Extra fields (kind, safety, executor,
+ * owner) are filled in by the registration layer.
+ */
+interface SdkToolDescriptor {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+}
+/** The shape a plugin author provides to define a tool. */
+interface ToolBlueprint {
+  /** Unique tool name (e.g. "web_search"). */
+  name: string;
+  /** Human‑readable description for the LLM. */
+  description: string;
+  /** JSON Schema for the input parameters. */
+  inputSchema: Record<string, unknown>;
+  /** The tool implementation. */
+  handler: (input: Record<string, unknown>) => Promise<{
+    success: boolean;
+    content: string;
+  }>;
+}
+/** A defined tool — ready for registration. */
+interface DefinedTool {
+  /** Unique tool name. */
+  name: string;
+  /** The tool descriptor that the registration layer consumes. */
+  descriptor: SdkToolDescriptor;
+  /** The tool implementation. */
+  handler: (input: Record<string, unknown>) => Promise<{
+    success: boolean;
+    content: string;
+  }>;
+}
+/**
+ * Declare a tool that can be registered by a plugin.
+ *
+ * The returned `DefinedTool` is passed to the plugin's register
+ * function or returned from `definePlugin`.
+ */
+declare function defineTool(blueprint: ToolBlueprint): DefinedTool;
+//#endregion
+export { type DefinedPlugin, type DefinedTool, type FailureStrategy, type HookDeclaration, type HookRegistry, type HookSink, type HookType, type ManifestEntry, type ManifestRegistry, type PluginContext, type PluginContract, type PluginDefinition, type PluginEntryFunction, type PluginHook, type PluginLoader, type PluginLogger, type PluginManifest, type PluginRegisterFn, type PluginRuntimeContext, type PluginStorage, type PluginTool, PredictiveLoader, type SdkToolDescriptor, type ToolBlueprint, createHookRegistry, createManifestRegistry, createPluginLoader, definePlugin, defineTool };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/discovery.ts","../src/loader.ts","../src/hooks.ts","../src/predictive-loader.ts","../src/sdk/types.ts","../src/sdk/define-plugin.ts","../src/sdk/define-tool.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -0,0 +1,299 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { PluginError, PluginLoadError } from "@lynx/core";
+//#region src/discovery.ts
+/**
+* Plugin discovery — scan directories for manifest.json files.
+*
+* The discovery layer only reads manifest metadata; it never imports
+* plugin code. This keeps the registry fast and allows filtering
+* before loading.
+*/
+const MANIFEST_FILE = "manifest.json";
+/**
+* Create a manifest registry.
+*
+* Call `scan()` during Phase 2 startup to populate it,
+* then use `getById()` / `listAll()` for fast lookups.
+*/
+function createManifestRegistry() {
+	const entries = /* @__PURE__ */ new Map();
+	return {
+		scan(directories) {
+			const discovered = [];
+			for (const dir of directories) {
+				const manifestPath = join(dir, MANIFEST_FILE);
+				if (!existsSync(manifestPath)) continue;
+				let raw;
+				try {
+					raw = readFileSync(manifestPath, "utf-8");
+				} catch (err) {
+					throw new PluginLoadError$1(`Cannot read manifest at ${manifestPath}: ${String(err)}`);
+				}
+				let manifest;
+				try {
+					manifest = JSON.parse(raw);
+				} catch {
+					throw new PluginError(`Invalid JSON in manifest: ${manifestPath}`, {
+						category: "plugin",
+						userVisible: true
+					});
+				}
+				if (!manifest.name || !manifest.version || !manifest.entry) throw new PluginError(`manifest.json at ${dir} is missing required fields (name, version, entry)`, {
+					category: "plugin",
+					userVisible: true
+				});
+				const entry = {
+					dir,
+					manifest
+				};
+				entries.set(manifest.name, entry);
+				discovered.push(entry);
+			}
+			return discovered;
+		},
+		getById(id) {
+			return entries.get(id);
+		},
+		listAll() {
+			return [...entries.values()];
+		},
+		count() {
+			return entries.size;
+		}
+	};
+}
+var PluginLoadError$1 = class extends PluginError {
+	constructor(message) {
+		super(message, { userVisible: true });
+	}
+};
+//#endregion
+//#region src/loader.ts
+/**
+* Create a plugin loader with lazy import and caching.
+*/
+function createPluginLoader() {
+	const loaded = /* @__PURE__ */ new Map();
+	return {
+		async load(entry, ctx) {
+			const existing = loaded.get(entry.manifest.name);
+			if (existing) return existing;
+			let mod;
+			try {
+				mod = await import(`${entry.dir}/${entry.manifest.entry}`);
+			} catch (err) {
+				throw new PluginLoadError(`Failed to import plugin "${entry.manifest.name}" from ${entry.manifest.entry}: ${String(err)}`);
+			}
+			if (!mod.default || typeof mod.default !== "function") throw new PluginError(`Plugin "${entry.manifest.name}" does not have a default export function`, {
+				category: "plugin",
+				userVisible: true
+			});
+			let contract;
+			try {
+				contract = await mod.default(ctx);
+			} catch (err) {
+				throw new PluginError(`Plugin "${entry.manifest.name}" initialisation threw: ${String(err)}`, {
+					category: "plugin",
+					userVisible: true
+				});
+			}
+			loaded.set(entry.manifest.name, contract);
+			return contract;
+		},
+		unload(pluginName) {
+			const contract = loaded.get(pluginName);
+			if (contract?.onUnload) contract.onUnload();
+			loaded.delete(pluginName);
+		},
+		getLoaded(pluginName) {
+			return loaded.get(pluginName);
+		},
+		listLoaded() {
+			return [...loaded.keys()];
+		},
+		async destroy() {
+			for (const [, contract] of loaded) if (contract.onUnload) try {
+				await contract.onUnload();
+			} catch {}
+			loaded.clear();
+		}
+	};
+}
+//#endregion
+//#region src/hooks.ts
+/**
+* Create a hook registry.
+*
+* Hooks are stored in priority‑ordered arrays per hook type.
+* Dispatch iterates them in order and short‑circuits on fail‑closed.
+*/
+function createHookRegistry() {
+	const sinks = /* @__PURE__ */ new Map();
+	function ensureList(type) {
+		let list = sinks.get(type);
+		if (!list) {
+			list = [];
+			sinks.set(type, list);
+		}
+		return list;
+	}
+	return {
+		register(sink) {
+			const list = ensureList(sink.type);
+			list.push(sink);
+			list.sort((a, b) => a.priority - b.priority);
+		},
+		unregisterPlugin(pluginId) {
+			for (const [type, list] of sinks) {
+				const filtered = list.filter((s) => s.pluginId !== pluginId);
+				if (filtered.length === 0) sinks.delete(type);
+				else sinks.set(type, filtered);
+			}
+		},
+		async dispatch(type, event, strategy = "fail-open") {
+			const list = sinks.get(type);
+			if (!list || list.length === 0) return;
+			for (const sink of list) try {
+				await sink.handler(event);
+			} catch (err) {
+				if (strategy === "fail-closed") throw err;
+			}
+		},
+		count() {
+			let total = 0;
+			for (const list of sinks.values()) total += list.length;
+			return total;
+		}
+	};
+}
+//#endregion
+//#region src/predictive-loader.ts
+var PredictiveLoader = class {
+	/** Map of already loaded plugins. */
+	_loaded = /* @__PURE__ */ new Map();
+	/** Set of plugin ids currently being imported. */
+	_warming = /* @__PURE__ */ new Set();
+	/** Priority queue (higher number = more important). */
+	_queue = [];
+	/** Abort controller for cancelling in‑flight warmups. */
+	_abort = new AbortController();
+	/** Dynamic import function (injectable for testing). */
+	_importFn;
+	constructor(importFn) {
+		this._importFn = importFn;
+	}
+	/** Whether the plugin has already been loaded. */
+	isLoaded(pluginId) {
+		return this._loaded.has(pluginId);
+	}
+	/** Whether the plugin is currently being warmed. */
+	isWarming(pluginId) {
+		return this._warming.has(pluginId);
+	}
+	/**
+	* Enqueue a plugin for warming at the given priority.
+	* Higher priority plugins are processed first.
+	*/
+	enqueue(pluginId, priority) {
+		if (this.isLoaded(pluginId) || this.isWarming(pluginId)) return;
+		const idx = this._queue.findIndex((e) => e.priority < priority);
+		if (idx < 0) this._queue.push({
+			pluginId,
+			priority
+		});
+		else this._queue.splice(idx, 0, {
+			pluginId,
+			priority
+		});
+	}
+	/** Process the entire warmup queue (non‑blocking — yields between imports). */
+	async processQueue() {
+		while (this._queue.length > 0) {
+			if (this._abort.signal.aborted) return;
+			const entry = this._queue.shift();
+			if (this.isLoaded(entry.pluginId)) continue;
+			this._warming.add(entry.pluginId);
+			try {
+				const mod = await this._importFn(entry.pluginId);
+				this._loaded.set(entry.pluginId, mod);
+			} catch {} finally {
+				this._warming.delete(entry.pluginId);
+			}
+			await new Promise((resolve) => setImmediate(resolve));
+		}
+	}
+	/** Stop all in‑flight warmups and clear the queue. */
+	abort() {
+		this._abort.abort();
+		this._queue.length = 0;
+		this._warming.clear();
+	}
+	/** Number of plugins currently queued for warming. */
+	get pendingCount() {
+		return this._queue.length;
+	}
+	/** Number of plugins that have been successfully loaded. */
+	get loadedCount() {
+		return this._loaded.size;
+	}
+	/**
+	* Predict which plugins to warm based on input prefix.
+	*
+	* Heuristics (200 ms window after prefix character):
+	*   "/" → skill plugins
+	*   "@" → model/provider plugins
+	*/
+	onInputPrefix(prefix) {
+		if (prefix === "/") this.enqueue("@lynx/skills", 100);
+		else if (prefix === "@") this.enqueue("@lynx/model-picker", 90);
+	}
+	/**
+	* Predict which plugins to warm based on a pending action.
+	*   "file_read"  → file operations plugin
+	*   "code_edit"  → editor tool plugin
+	*/
+	onActionPending(action) {
+		if (action.startsWith("file_")) this.enqueue("@lynx/tool-file-ops", 80);
+		else if (action === "code_edit") this.enqueue("@lynx/tool-edit", 80);
+		else if (action === "web_search") this.enqueue("@lynx/tool-web", 70);
+	}
+};
+//#endregion
+//#region src/sdk/define-plugin.ts
+/**
+* Declare a Lynx plugin.
+*
+* `register` is called once at startup with a {@link PluginContext}
+* that provides logging, storage, and event emission.
+*/
+function definePlugin(manifest, register) {
+	return {
+		id: manifest.name,
+		manifest,
+		register
+	};
+}
+//#endregion
+//#region src/sdk/define-tool.ts
+/**
+* Declare a tool that can be registered by a plugin.
+*
+* The returned `DefinedTool` is passed to the plugin's register
+* function or returned from `definePlugin`.
+*/
+function defineTool(blueprint) {
+	return {
+		name: blueprint.name,
+		descriptor: {
+			name: blueprint.name,
+			description: blueprint.description,
+			inputSchema: blueprint.inputSchema
+		},
+		handler: blueprint.handler
+	};
+}
+//#endregion
+export { PredictiveLoader, createHookRegistry, createManifestRegistry, createPluginLoader, definePlugin, defineTool };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["PluginLoadError"],"sources":["../src/discovery.ts","../src/loader.ts","../src/hooks.ts","../src/predictive-loader.ts","../src/sdk/define-plugin.ts","../src/sdk/define-tool.ts"],"sourcesContent":["/**\n * Plugin discovery — scan directories for manifest.json files.\n *\n * The discovery layer only reads manifest metadata; it never imports\n * plugin code. This keeps the registry fast and allows filtering\n * before loading.\n */\n\nimport { readFileSync, existsSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport type { PluginManifest } from \"./types.js\";\nimport { PluginError } from \"@lynx/core\";\n\n// ── Types ──────────────────────────────────────────\n\nexport interface ManifestEntry {\n  /** Absolute path to the plugin directory. */\n  dir: string;\n  /** Parsed manifest content. */\n  manifest: PluginManifest;\n}\n\nexport interface ManifestRegistry {\n  /** Scan one or more directories for plugin manifests. */\n  scan(directories: string[]): ManifestEntry[];\n  /** Get a plugin by id (fast lookup). */\n  getById(id: string): ManifestEntry | undefined;\n  /** List all discovered plugins. */\n  listAll(): ManifestEntry[];\n  /** How many plugins are registered. */\n  count(): number;\n}\n\n// ── Constants ──────────────────────────────────────\n\nconst MANIFEST_FILE = \"manifest.json\";\n\n// ── Public API ─────────────────────────────────────\n\n/**\n * Create a manifest registry.\n *\n * Call `scan()` during Phase 2 startup to populate it,\n * then use `getById()` / `listAll()` for fast lookups.\n */\nexport function createManifestRegistry(): ManifestRegistry {\n  const entries = new Map<string, ManifestEntry>();\n\n  const registry: ManifestRegistry = {\n    scan(directories: string[]): ManifestEntry[] {\n      const discovered: ManifestEntry[] = [];\n\n      for (const dir of directories) {\n        const manifestPath = join(dir, MANIFEST_FILE);\n\n        if (!existsSync(manifestPath)) continue;\n\n        let raw: string;\n        try {\n          raw = readFileSync(manifestPath, \"utf-8\");\n        } catch (err) {\n          throw new PluginLoadError(`Cannot read manifest at ${manifestPath}: ${String(err)}`);\n        }\n\n        let manifest: PluginManifest;\n        try {\n          manifest = JSON.parse(raw) as PluginManifest;\n        } catch {\n          throw new PluginError(`Invalid JSON in manifest: ${manifestPath}`, {\n            category: \"plugin\",\n            userVisible: true,\n          });\n        }\n\n        // Validate required fields\n        if (!manifest.name || !manifest.version || !manifest.entry) {\n          throw new PluginError(\n            `manifest.json at ${dir} is missing required fields (name, version, entry)`,\n            { category: \"plugin\", userVisible: true },\n          );\n        }\n\n        const entry: ManifestEntry = { dir, manifest };\n        entries.set(manifest.name, entry);\n        discovered.push(entry);\n      }\n\n      return discovered;\n    },\n\n    getById(id: string): ManifestEntry | undefined {\n      return entries.get(id);\n    },\n\n    listAll(): ManifestEntry[] {\n      return [...entries.values()];\n    },\n\n    count(): number {\n      return entries.size;\n    },\n  };\n\n  return registry;\n}\n\n// ── Error helper ───────────────────────────────────\n\nclass PluginLoadError extends PluginError {\n  constructor(message: string) {\n    super(message, { userVisible: true });\n  }\n}\n","/**\n * Plugin loader — lazy import() with caching.\n *\n * Plugins are loaded once and cached. If a plugin fails to load,\n * the error is isolated — other plugins continue working.\n *\n * Fail‑open: a plugin that throws during init is unloaded but\n *            the app continues without it.\n * Fail‑closed: for security‑critical hooks, a failing plugin\n *              blocks the operation (see hooks.ts).\n */\n\nimport type { PluginContract, PluginRuntimeContext, PluginEntryFunction } from \"./types.js\";\nimport type { ManifestEntry } from \"./discovery.js\";\nimport { PluginError, PluginLoadError } from \"@lynx/core\";\n\n// ── Types ──────────────────────────────────────────\n\nexport interface PluginLoader {\n  /** Load a plugin from its manifest entry. */\n  load(entry: ManifestEntry, ctx: PluginRuntimeContext): Promise<PluginContract>;\n  /** Unload a previously loaded plugin. */\n  unload(pluginName: string): void;\n  /** Get a loaded plugin. */\n  getLoaded(pluginName: string): PluginContract | undefined;\n  /** List all loaded plugin names. */\n  listLoaded(): string[];\n  /** Destroy all loaded plugins. */\n  destroy(): Promise<void>;\n}\n\n// ── Public API ─────────────────────────────────────\n\n/**\n * Create a plugin loader with lazy import and caching.\n */\nexport function createPluginLoader(): PluginLoader {\n  const loaded = new Map<string, PluginContract>();\n\n  const loader: PluginLoader = {\n    async load(entry: ManifestEntry, ctx: PluginRuntimeContext): Promise<PluginContract> {\n      // Return cached if already loaded\n      const existing = loaded.get(entry.manifest.name);\n      if (existing) return existing;\n\n      let mod: { default?: PluginEntryFunction };\n      try {\n        // Dynamic import — the entry path is relative to the plugin directory\n        const entryPath = `${entry.dir}/${entry.manifest.entry}`;\n        mod = await import(entryPath);\n      } catch (err) {\n        throw new PluginLoadError(\n          `Failed to import plugin \"${entry.manifest.name}\" from ${entry.manifest.entry}: ${String(err)}`,\n        );\n      }\n\n      if (!mod.default || typeof mod.default !== \"function\") {\n        throw new PluginError(\n          `Plugin \"${entry.manifest.name}\" does not have a default export function`,\n          { category: \"plugin\", userVisible: true },\n        );\n      }\n\n      let contract: PluginContract;\n      try {\n        contract = await mod.default(ctx);\n      } catch (err) {\n        throw new PluginError(\n          `Plugin \"${entry.manifest.name}\" initialisation threw: ${String(err)}`,\n          { category: \"plugin\", userVisible: true },\n        );\n      }\n\n      loaded.set(entry.manifest.name, contract);\n      return contract;\n    },\n\n    unload(pluginName: string): void {\n      const contract = loaded.get(pluginName);\n      if (contract?.onUnload) {\n        void contract.onUnload();\n      }\n      loaded.delete(pluginName);\n    },\n\n    getLoaded(pluginName: string): PluginContract | undefined {\n      return loaded.get(pluginName);\n    },\n\n    listLoaded(): string[] {\n      return [...loaded.keys()];\n    },\n\n    async destroy(): Promise<void> {\n      for (const [, contract] of loaded) {\n        if (contract.onUnload) {\n          try {\n            await contract.onUnload();\n          } catch {\n            // Best effort cleanup\n          }\n        }\n      }\n      loaded.clear();\n    },\n  };\n\n  return loader;\n}\n","/**\n * Hook engine — dispatch events to registered plugin hooks.\n *\n * Supports two failure strategies:\n *   fail‑open  — hook failure does not block the operation (default)\n *   fail‑closed — hook failure blocks the operation (security‑critical)\n */\n\nimport type { HookType, HookSink } from \"./types.js\";\n\n// ── Types ──────────────────────────────────────────\n\nexport type FailureStrategy = \"fail-open\" | \"fail-closed\";\n\nexport interface HookRegistry {\n  /** Register a sink. Lower priority runs first. */\n  register(sink: HookSink): void;\n  /** Remove all sinks for a plugin. */\n  unregisterPlugin(pluginId: string): void;\n  /** Dispatch an event to all registered hooks of this type. */\n  dispatch(type: HookType, event: unknown, strategy?: FailureStrategy): Promise<void>;\n  /** How many sinks are registered. */\n  count(): number;\n}\n\n// ── Public API ─────────────────────────────────────\n\n/**\n * Create a hook registry.\n *\n * Hooks are stored in priority‑ordered arrays per hook type.\n * Dispatch iterates them in order and short‑circuits on fail‑closed.\n */\nexport function createHookRegistry(): HookRegistry {\n  const sinks = new Map<HookType, HookSink[]>();\n\n  function ensureList(type: HookType): HookSink[] {\n    let list = sinks.get(type);\n    if (!list) {\n      list = [];\n      sinks.set(type, list);\n    }\n    return list;\n  }\n\n  const registry: HookRegistry = {\n    register(sink: HookSink): void {\n      const list = ensureList(sink.type);\n      list.push(sink);\n      // Keep sorted by priority (ascending)\n      list.sort((a, b) => a.priority - b.priority);\n    },\n\n    unregisterPlugin(pluginId: string): void {\n      for (const [type, list] of sinks) {\n        const filtered = list.filter((s) => s.pluginId !== pluginId);\n        if (filtered.length === 0) {\n          sinks.delete(type);\n        } else {\n          sinks.set(type, filtered);\n        }\n      }\n    },\n\n    async dispatch(\n      type: HookType,\n      event: unknown,\n      strategy: FailureStrategy = \"fail-open\",\n    ): Promise<void> {\n      const list = sinks.get(type);\n      if (!list || list.length === 0) return;\n\n      for (const sink of list) {\n        try {\n          await sink.handler(event);\n        } catch (err) {\n          if (strategy === \"fail-closed\") {\n            throw err;\n          }\n          // fail‑open: continue to next hook\n        }\n      }\n    },\n\n    count(): number {\n      let total = 0;\n      for (const list of sinks.values()) {\n        total += list.length;\n      }\n      return total;\n    },\n  };\n\n  return registry;\n}\n","/**\n * Predictive loader — pre‑warms plugins before they are needed.\n *\n * Priority‑based warmup queue that loads plugins during idle time\n * (Phase 2 startup background tasks) and reactively based on input\n * prefix heuristics.\n *\n * Reference: §17 PredictiveLoader design\n */\n\n// ── Types ────────────────────────────────────────────\n\n/** A plugin module after lazy import(). */\ntype PluginModule = unknown;\n\ninterface QueueEntry {\n  pluginId: string;\n  priority: number;\n}\n\n// ── PredictiveLoader ─────────────────────────────────\n\nexport class PredictiveLoader {\n  /** Map of already loaded plugins. */\n  private _loaded = new Map<string, PluginModule>();\n\n  /** Set of plugin ids currently being imported. */\n  private _warming = new Set<string>();\n\n  /** Priority queue (higher number = more important). */\n  private _queue: QueueEntry[] = [];\n\n  /** Abort controller for cancelling in‑flight warmups. */\n  private _abort = new AbortController();\n\n  /** Dynamic import function (injectable for testing). */\n  private _importFn: (id: string) => Promise<PluginModule>;\n\n  constructor(importFn: (id: string) => Promise<PluginModule>) {\n    this._importFn = importFn;\n  }\n\n  // ── Public API ─────────────────────────────────────\n\n  /** Whether the plugin has already been loaded. */\n  isLoaded(pluginId: string): boolean {\n    return this._loaded.has(pluginId);\n  }\n\n  /** Whether the plugin is currently being warmed. */\n  isWarming(pluginId: string): boolean {\n    return this._warming.has(pluginId);\n  }\n\n  /**\n   * Enqueue a plugin for warming at the given priority.\n   * Higher priority plugins are processed first.\n   */\n  enqueue(pluginId: string, priority: number): void {\n    if (this.isLoaded(pluginId) || this.isWarming(pluginId)) {\n      return; // Already done or in progress — idempotent\n    }\n\n    // Insert sorted by priority (descending)\n    const idx = this._queue.findIndex((e) => e.priority < priority);\n    if (idx < 0) {\n      this._queue.push({ pluginId, priority });\n    } else {\n      this._queue.splice(idx, 0, { pluginId, priority });\n    }\n  }\n\n  /** Process the entire warmup queue (non‑blocking — yields between imports). */\n  async processQueue(): Promise<void> {\n    while (this._queue.length > 0) {\n      if (this._abort.signal.aborted) return;\n\n      const entry = this._queue.shift()!;\n      if (this.isLoaded(entry.pluginId)) continue;\n\n      this._warming.add(entry.pluginId);\n\n      try {\n        const mod = await this._importFn(entry.pluginId);\n        this._loaded.set(entry.pluginId, mod);\n      } catch {\n        // Silently skip plugins that fail to warm — they'll be\n        // retried (with an error report) when actually requested.\n      } finally {\n        this._warming.delete(entry.pluginId);\n      }\n\n      // Yield to the event loop so the main thread stays responsive.\n      await new Promise((resolve) => setImmediate(resolve));\n    }\n  }\n\n  /** Stop all in‑flight warmups and clear the queue. */\n  abort(): void {\n    this._abort.abort();\n    this._queue.length = 0;\n    this._warming.clear();\n  }\n\n  /** Number of plugins currently queued for warming. */\n  get pendingCount(): number {\n    return this._queue.length;\n  }\n\n  /** Number of plugins that have been successfully loaded. */\n  get loadedCount(): number {\n    return this._loaded.size;\n  }\n\n  // ── Input prediction ───────────────────────────────\n\n  /**\n   * Predict which plugins to warm based on input prefix.\n   *\n   * Heuristics (200 ms window after prefix character):\n   *   \"/\" → skill plugins\n   *   \"@\" → model/provider plugins\n   */\n  onInputPrefix(prefix: string): void {\n    if (prefix === \"/\") {\n      this.enqueue(\"@lynx/skills\", 100);\n    } else if (prefix === \"@\") {\n      this.enqueue(\"@lynx/model-picker\", 90);\n    }\n  }\n\n  /**\n   * Predict which plugins to warm based on a pending action.\n   *   \"file_read\"  → file operations plugin\n   *   \"code_edit\"  → editor tool plugin\n   */\n  onActionPending(action: string): void {\n    if (action.startsWith(\"file_\")) {\n      this.enqueue(\"@lynx/tool-file-ops\", 80);\n    } else if (action === \"code_edit\") {\n      this.enqueue(\"@lynx/tool-edit\", 80);\n    } else if (action === \"web_search\") {\n      this.enqueue(\"@lynx/tool-web\", 70);\n    }\n  }\n}\n","/**\n * `definePlugin` — the entry point for every Lynx plugin.\n *\n * Pattern (inspired by FengMing's `definePluginEntry`):\n *   export default definePlugin((ctx) => {\n *     ctx.logger.info(\"loaded\");\n *     return { name: \"my-plugin\", tools: [...] };\n *   });\n */\n\nimport type { PluginContext } from \"./types.js\";\nimport type { PluginManifest } from \"../types.js\";\n\n// ── Types ────────────────────────────────────────────\n\n/** What a plugin's register function returns. */\nexport interface PluginDefinition {\n  /** Display name. */\n  name: string;\n  /** Semver version string. */\n  version?: string;\n  /** Human‑readable description. */\n  description?: string;\n  /** Hook declarations (executed by the hook engine). */\n  hooks?: HookDeclaration[];\n}\n\n/** A hook declaration — static metadata, handler runs at runtime. */\nexport interface HookDeclaration {\n  /** Hook event name (e.g. \"before_agent_reply\"). */\n  type: string;\n  /** \"fail-open\": hook failure doesn't block; \"fail-closed\": hook failure rejects. */\n  policy: \"fail-open\" | \"fail-closed\";\n  /** The handler function. */\n  handler: (event: unknown) => Promise<void>;\n}\n\n/** The register callback signature. */\nexport type PluginRegisterFn = (ctx: PluginContext) => PluginDefinition | Promise<PluginDefinition>;\n\n/** The shape returned by `definePlugin`. */\nexport interface DefinedPlugin {\n  /** Unique plugin id (from manifest.json). */\n  id: string;\n  manifest: PluginManifest;\n  register: PluginRegisterFn;\n}\n\n// ── Public API ───────────────────────────────────────\n\n/**\n * Declare a Lynx plugin.\n *\n * `register` is called once at startup with a {@link PluginContext}\n * that provides logging, storage, and event emission.\n */\nexport function definePlugin(manifest: PluginManifest, register: PluginRegisterFn): DefinedPlugin {\n  return {\n    id: manifest.name,\n    manifest,\n    register,\n  };\n}\n","/**\n * `defineTool` — declare a tool that a plugin contributes to the agent.\n *\n * Pattern (inspired by FengMing's `api.registerTool`):\n *   const myTool = defineTool({\n *     name: \"my_tool\",\n *     description: \"Does something useful\",\n *     inputSchema: { type: \"object\", properties: {...} },\n *     handler: async (input) => ({ success: true, content: \"done\" }),\n *   });\n */\n\n// ── Types ────────────────────────────────────────────\n\n/**\n * Lightweight tool descriptor — the subset of internal `ToolDescriptor`\n * that plugin authors need to provide. Extra fields (kind, safety, executor,\n * owner) are filled in by the registration layer.\n */\nexport interface SdkToolDescriptor {\n  name: string;\n  description: string;\n  inputSchema: Record<string, unknown>;\n}\n\n/** The shape a plugin author provides to define a tool. */\nexport interface ToolBlueprint {\n  /** Unique tool name (e.g. \"web_search\"). */\n  name: string;\n  /** Human‑readable description for the LLM. */\n  description: string;\n  /** JSON Schema for the input parameters. */\n  inputSchema: Record<string, unknown>;\n  /** The tool implementation. */\n  handler: (input: Record<string, unknown>) => Promise<{ success: boolean; content: string }>;\n}\n\n/** A defined tool — ready for registration. */\nexport interface DefinedTool {\n  /** Unique tool name. */\n  name: string;\n  /** The tool descriptor that the registration layer consumes. */\n  descriptor: SdkToolDescriptor;\n  /** The tool implementation. */\n  handler: (input: Record<string, unknown>) => Promise<{ success: boolean; content: string }>;\n}\n\n// ── Public API ───────────────────────────────────────\n\n/**\n * Declare a tool that can be registered by a plugin.\n *\n * The returned `DefinedTool` is passed to the plugin's register\n * function or returned from `definePlugin`.\n */\nexport function defineTool(blueprint: ToolBlueprint): DefinedTool {\n  return {\n    name: blueprint.name,\n    descriptor: {\n      name: blueprint.name,\n      description: blueprint.description,\n      inputSchema: blueprint.inputSchema,\n    },\n    handler: blueprint.handler,\n  };\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@24klynx/plugins",
+  "version": "0.1.0",
+  "description": "Plugin system — discovery, loading, hook engine, SDK",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.mts"
+    }
+  },
+  "dependencies": {
+    "@24klynx/core": "0.1.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown --config-loader tsx",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsgo --noEmit"
+  }
+}