@agentplugins/adapter-kimi 0.1.0

package/README.md

@@ -0,0 +1,47 @@
+# @agentplugins/adapter-kimi
+
+> AgentPlugins platform adapter for [Kimi (Moonshot AI)](https://www.moonshot.cn/).
+
+Compiles a universal `PluginManifest` into Kimi's plugin layout: `kimi.plugin.json` manifest, hook wiring, and MCP server config. Inline handlers are wrapped as command scripts.
+
+## Installation
+
+```bash
+npm install @agentplugins/adapter-kimi
+```
+
+Typically installed transitively via [`@agentplugins/cli`](https://www.npmjs.com/package/@agentplugins/cli).
+
+## Usage
+
+```typescript
+import { createKimiAdapter } from '@agentplugins/adapter-kimi';
+
+const adapter = createKimiAdapter();
+const output = await adapter.compile(manifest);
+```
+
+Or via the CLI:
+
+```bash
+npx agentplugins build --target kimi
+```
+
+## Output shape
+
+A successful build writes to `dist/kimi/`:
+
+```
+dist/kimi/
+├── kimi.plugin.json
+├── hooks/
+│   └── hooks.json
+├── skills/
+└── .mcp.json
+```
+
+Install with: `cp -r dist/kimi ~/.kimi/plugins/`
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,172 @@
+import { PlatformAdapter, TargetPlatform, UniversalHookName, HandlerType, PluginManifest, ValidationIssue, AdapterOutput } from '@agentplugins/core';
+
+/**
+ * @agentplugins/adapter-kimi
+ *
+ * Platform adapter for Kimi (Moonshot AI) — AgentPlugins plugin system.
+ *
+ * Kimi plugins are installed via the `/plugins install <github-url|local-path>`
+ * command in the Kimi chat interface. They are **user-level only**; there is no
+ * project-level scope. Any change to a plugin requires a `/new` session restart
+ * to take effect.
+ *
+ * Architecture overview
+ * ---------------------
+ * - Manifest        : `kimi.plugin.json` (JSON)
+ * - Hooks           : Command-based (JSON over stdin / stdout), FAIL-OPEN
+ * - Skills          : Markdown files with YAML frontmatter (`SKILL.md`)
+ * - Registration    : `/plugins install <url>`
+ * - Security model  : Conservative loading + trust badges; hooks are *not* a
+ *                     sole security barrier (they fail open)
+ *
+ * Supported universal hooks
+ * -------------------------
+ * | Universal hook       | Kimi event        |
+ * |----------------------|-------------------|
+ * | preToolUse           | PreToolUse        |
+ * | userPromptSubmit     | UserPromptSubmit  |
+ * | sessionStart         | SessionStart      |
+ * | notification         | Notification      |
+ * | permissionRequest    | PermissionRequest |
+ *
+ * Unsupported hooks (explicitly rejected during validation):
+ *   sessionEnd, userPromptExpansion, postToolUse, postToolUseFailure,
+ *   permissionDenied, subagentStart, subagentStop, preCompact, postCompact,
+ *   stop, stopFailure, fileChanged, cwdChanged, setup
+ */
+
+/**
+ * Shape of the `kimi.plugin.json` manifest.
+ *
+ * @see https://platform.moonshot.cn/docs/plugins/kimi-plugin-json
+ */
+interface KimiPluginJson {
+    /** Plugin machine-name (kebab-case, unique within user scope). */
+    name: string;
+    /** Relative path to the skills directory containing `SKILL.md` files. */
+    skills: string;
+    /**
+     * Relative path to the session-start hook entry point.
+     * Executed once when a new chat session begins.
+     */
+    sessionStart?: string;
+    /**
+     * Relative path to an MCP (Model Context Protocol) server config JSON.
+     * Optional — only needed if the plugin exposes MCP-based tools.
+     */
+    mcpServers?: string;
+    /** Display metadata shown in the Kimi plugin store / `/plugins list`. */
+    interface: {
+        /** Human-readable plugin name. */
+        displayName: string;
+        /** Short description (≤ 120 chars recommended). */
+        description: string;
+        /** Optional icon URL or emoji. */
+        icon?: string;
+    };
+}
+/**
+ * Shape of the `kimi-hooks.json` configuration file.
+ *
+ * Each top-level key is a Kimi event name. Under each event lives a list of
+ * matcher rules; every matching rule runs its `hooks` array in order.
+ *
+ * Kimi hooks are **fail-open**: if a hook process exits non-zero or times out,
+ * Kimi logs the failure but continues execution. This is by design — hooks are
+ * *not* a security barrier on their own.
+ */
+interface KimiHooksJson {
+    hooks: Record<string, Array<{
+        /** Glob-style matcher (`*`, `read_file`, etc.). */
+        matcher: string;
+        /** Ordered list of hook invocations for this matcher. */
+        hooks: Array<{
+            type: "command";
+            command: string;
+            /** Message shown in the Kimi UI while the hook runs. */
+            statusMessage?: string;
+        }>;
+    }>>;
+}
+/**
+ * Shape of a single `SKILL.md` file’s YAML frontmatter.
+ */
+interface SkillFrontmatter {
+    name: string;
+    description: string;
+    version?: string;
+    author?: string;
+    tags?: string[];
+    tools?: string[];
+}
+/**
+ * Kimi (Moonshot AI) platform adapter for AgentPlugins.
+ *
+ * Transforms universal AgentPlugins plugins into the Kimi-native format:
+ * - `kimi.plugin.json` — main manifest
+ * - `kimi-hooks.json`  — command-based hook configuration
+ * - `skills/SKILL__*.md` — Markdown skill files with YAML frontmatter
+ *
+ * ### Hook model
+ * Kimi uses a **fail-open** command-based hook system. Hooks communicate with
+ * Kimi via JSON messages over stdin/stdout. If a hook fails (non-zero exit,
+ * timeout), Kimi logs the error but continues — hooks are not a security
+ * barrier on their own.
+ *
+ * ### Installation flow
+ * 1. User runs `/plugins install <url>` in Kimi chat
+ * 2. Kimi downloads and validates `kimi.plugin.json`
+ * 3. On session start (`/new`), `sessionStart` hook runs
+ * 4. Registered event hooks fire as their mapped events occur
+ *
+ * ### Session lifecycle
+ * - Plugins are **user-scoped** (no project-level isolation)
+ * - Any plugin change requires `/new` session restart
+ * - Hooks are re-evaluated on every session start
+ *
+ * @example
+ * ```typescript
+ * import { KimiAdapter } from "@agentplugins/adapter-kimi";
+ *
+ * const adapter = new KimiAdapter();
+ * const issues = adapter.validate(manifest);
+ * if (issues.every((i) => i.severity !== "error")) {
+ *   const output = adapter.compile(manifest);
+ *   // write output.files to disk...
+ * }
+ * ```
+ */
+declare class KimiAdapter implements PlatformAdapter {
+    /** @inheritDoc */
+    readonly name: TargetPlatform;
+    /** @inheritDoc */
+    readonly displayName: string;
+    /** @inheritDoc */
+    readonly supportedHooks: readonly UniversalHookName[];
+    /** @inheritDoc */
+    readonly supportedHandlers: readonly HandlerType[];
+    /** @inheritDoc */
+    readonly manifestPath: string;
+    /** @inheritDoc */
+    readonly manifestFormat: "json";
+    /**
+     * Validates a universal plugin manifest for Kimi compatibility.
+     *
+     * @param manifest — The plugin manifest to validate.
+     * @returns Array of validation issues (empty if fully valid).
+     */
+    validate(manifest: PluginManifest): ValidationIssue[];
+    /**
+     * Compiles a universal plugin manifest into Kimi-native artifacts.
+     *
+     * @param manifest — The plugin manifest to compile.
+     * @returns AdapterOutput containing all files to write.
+     */
+    compile(manifest: PluginManifest): AdapterOutput;
+}
+/** Default adapter instance for convenience imports. */
+declare const kimiAdapter: KimiAdapter;
+/** Factory function for creating a new Kimi adapter instance. */
+declare function createKimiAdapter(): PlatformAdapter;
+
+export { KimiAdapter, type KimiHooksJson, type KimiPluginJson, type SkillFrontmatter, createKimiAdapter, KimiAdapter as default, kimiAdapter };

package/dist/index.d.ts

@@ -0,0 +1,172 @@
+import { PlatformAdapter, TargetPlatform, UniversalHookName, HandlerType, PluginManifest, ValidationIssue, AdapterOutput } from '@agentplugins/core';
+
+/**
+ * @agentplugins/adapter-kimi
+ *
+ * Platform adapter for Kimi (Moonshot AI) — AgentPlugins plugin system.
+ *
+ * Kimi plugins are installed via the `/plugins install <github-url|local-path>`
+ * command in the Kimi chat interface. They are **user-level only**; there is no
+ * project-level scope. Any change to a plugin requires a `/new` session restart
+ * to take effect.
+ *
+ * Architecture overview
+ * ---------------------
+ * - Manifest        : `kimi.plugin.json` (JSON)
+ * - Hooks           : Command-based (JSON over stdin / stdout), FAIL-OPEN
+ * - Skills          : Markdown files with YAML frontmatter (`SKILL.md`)
+ * - Registration    : `/plugins install <url>`
+ * - Security model  : Conservative loading + trust badges; hooks are *not* a
+ *                     sole security barrier (they fail open)
+ *
+ * Supported universal hooks
+ * -------------------------
+ * | Universal hook       | Kimi event        |
+ * |----------------------|-------------------|
+ * | preToolUse           | PreToolUse        |
+ * | userPromptSubmit     | UserPromptSubmit  |
+ * | sessionStart         | SessionStart      |
+ * | notification         | Notification      |
+ * | permissionRequest    | PermissionRequest |
+ *
+ * Unsupported hooks (explicitly rejected during validation):
+ *   sessionEnd, userPromptExpansion, postToolUse, postToolUseFailure,
+ *   permissionDenied, subagentStart, subagentStop, preCompact, postCompact,
+ *   stop, stopFailure, fileChanged, cwdChanged, setup
+ */
+
+/**
+ * Shape of the `kimi.plugin.json` manifest.
+ *
+ * @see https://platform.moonshot.cn/docs/plugins/kimi-plugin-json
+ */
+interface KimiPluginJson {
+    /** Plugin machine-name (kebab-case, unique within user scope). */
+    name: string;
+    /** Relative path to the skills directory containing `SKILL.md` files. */
+    skills: string;
+    /**
+     * Relative path to the session-start hook entry point.
+     * Executed once when a new chat session begins.
+     */
+    sessionStart?: string;
+    /**
+     * Relative path to an MCP (Model Context Protocol) server config JSON.
+     * Optional — only needed if the plugin exposes MCP-based tools.
+     */
+    mcpServers?: string;
+    /** Display metadata shown in the Kimi plugin store / `/plugins list`. */
+    interface: {
+        /** Human-readable plugin name. */
+        displayName: string;
+        /** Short description (≤ 120 chars recommended). */
+        description: string;
+        /** Optional icon URL or emoji. */
+        icon?: string;
+    };
+}
+/**
+ * Shape of the `kimi-hooks.json` configuration file.
+ *
+ * Each top-level key is a Kimi event name. Under each event lives a list of
+ * matcher rules; every matching rule runs its `hooks` array in order.
+ *
+ * Kimi hooks are **fail-open**: if a hook process exits non-zero or times out,
+ * Kimi logs the failure but continues execution. This is by design — hooks are
+ * *not* a security barrier on their own.
+ */
+interface KimiHooksJson {
+    hooks: Record<string, Array<{
+        /** Glob-style matcher (`*`, `read_file`, etc.). */
+        matcher: string;
+        /** Ordered list of hook invocations for this matcher. */
+        hooks: Array<{
+            type: "command";
+            command: string;
+            /** Message shown in the Kimi UI while the hook runs. */
+            statusMessage?: string;
+        }>;
+    }>>;
+}
+/**
+ * Shape of a single `SKILL.md` file’s YAML frontmatter.
+ */
+interface SkillFrontmatter {
+    name: string;
+    description: string;
+    version?: string;
+    author?: string;
+    tags?: string[];
+    tools?: string[];
+}
+/**
+ * Kimi (Moonshot AI) platform adapter for AgentPlugins.
+ *
+ * Transforms universal AgentPlugins plugins into the Kimi-native format:
+ * - `kimi.plugin.json` — main manifest
+ * - `kimi-hooks.json`  — command-based hook configuration
+ * - `skills/SKILL__*.md` — Markdown skill files with YAML frontmatter
+ *
+ * ### Hook model
+ * Kimi uses a **fail-open** command-based hook system. Hooks communicate with
+ * Kimi via JSON messages over stdin/stdout. If a hook fails (non-zero exit,
+ * timeout), Kimi logs the error but continues — hooks are not a security
+ * barrier on their own.
+ *
+ * ### Installation flow
+ * 1. User runs `/plugins install <url>` in Kimi chat
+ * 2. Kimi downloads and validates `kimi.plugin.json`
+ * 3. On session start (`/new`), `sessionStart` hook runs
+ * 4. Registered event hooks fire as their mapped events occur
+ *
+ * ### Session lifecycle
+ * - Plugins are **user-scoped** (no project-level isolation)
+ * - Any plugin change requires `/new` session restart
+ * - Hooks are re-evaluated on every session start
+ *
+ * @example
+ * ```typescript
+ * import { KimiAdapter } from "@agentplugins/adapter-kimi";
+ *
+ * const adapter = new KimiAdapter();
+ * const issues = adapter.validate(manifest);
+ * if (issues.every((i) => i.severity !== "error")) {
+ *   const output = adapter.compile(manifest);
+ *   // write output.files to disk...
+ * }
+ * ```
+ */
+declare class KimiAdapter implements PlatformAdapter {
+    /** @inheritDoc */
+    readonly name: TargetPlatform;
+    /** @inheritDoc */
+    readonly displayName: string;
+    /** @inheritDoc */
+    readonly supportedHooks: readonly UniversalHookName[];
+    /** @inheritDoc */
+    readonly supportedHandlers: readonly HandlerType[];
+    /** @inheritDoc */
+    readonly manifestPath: string;
+    /** @inheritDoc */
+    readonly manifestFormat: "json";
+    /**
+     * Validates a universal plugin manifest for Kimi compatibility.
+     *
+     * @param manifest — The plugin manifest to validate.
+     * @returns Array of validation issues (empty if fully valid).
+     */
+    validate(manifest: PluginManifest): ValidationIssue[];
+    /**
+     * Compiles a universal plugin manifest into Kimi-native artifacts.
+     *
+     * @param manifest — The plugin manifest to compile.
+     * @returns AdapterOutput containing all files to write.
+     */
+    compile(manifest: PluginManifest): AdapterOutput;
+}
+/** Default adapter instance for convenience imports. */
+declare const kimiAdapter: KimiAdapter;
+/** Factory function for creating a new Kimi adapter instance. */
+declare function createKimiAdapter(): PlatformAdapter;
+
+export { KimiAdapter, type KimiHooksJson, type KimiPluginJson, type SkillFrontmatter, createKimiAdapter, KimiAdapter as default, kimiAdapter };

package/dist/index.js

@@ -0,0 +1,439 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  KimiAdapter: () => KimiAdapter,
+  createKimiAdapter: () => createKimiAdapter,
+  default: () => index_default,
+  kimiAdapter: () => kimiAdapter
+});
+module.exports = __toCommonJS(index_exports);
+var import_core = require("@agentplugins/core");
+var PLATFORM_NAME = "kimi";
+var PLATFORM_DISPLAY_NAME = "Kimi (Moonshot AI)";
+var MANIFEST_FILENAME = "kimi.plugin.json";
+var MANIFEST_FORMAT = "json";
+var SUPPORTED_HOOKS = [
+  "preToolUse",
+  "userPromptSubmit",
+  "sessionStart",
+  "notification",
+  "permissionRequest"
+];
+var SUPPORTED_HANDLERS = ["command"];
+var HOOK_NAME_MAP = {
+  preToolUse: "PreToolUse",
+  userPromptSubmit: "UserPromptSubmit",
+  sessionStart: "SessionStart",
+  notification: "Notification",
+  permissionRequest: "PermissionRequest",
+  // — unsupported mappings (not present in SUPPORTED_HOOKS) —
+  sessionEnd: "SessionEnd",
+  userPromptExpansion: "UserPromptExpansion",
+  postToolUse: "PostToolUse",
+  postToolUseFailure: "PostToolUseFailure",
+  permissionDenied: "PermissionDenied",
+  subagentStart: "SubagentStart",
+  subagentStop: "SubagentStop",
+  preCompact: "PreCompact",
+  postCompact: "PostCompact",
+  stop: "Stop",
+  stopFailure: "StopFailure",
+  fileChanged: "FileChanged",
+  cwdChanged: "CwdChanged",
+  setup: "Setup"
+};
+var UNSUPPORTED_HOOKS = [
+  "sessionEnd",
+  "userPromptExpansion",
+  "postToolUse",
+  "postToolUseFailure",
+  "permissionDenied",
+  "subagentStart",
+  "subagentStop",
+  "preCompact",
+  "postCompact",
+  "stop",
+  "stopFailure",
+  "fileChanged",
+  "cwdChanged",
+  "setup"
+];
+function validateForKimi(manifest) {
+  const issues = [];
+  if (!manifest.name || manifest.name.trim().length === 0) {
+    issues.push({
+      severity: import_core.Severity.ERROR,
+      field: "name",
+      message: "Plugin 'name' is required for kimi.plugin.json."
+    });
+  } else if (!/^[a-z0-9-]+$/.test(manifest.name)) {
+    issues.push({
+      severity: import_core.Severity.WARNING,
+      field: "name",
+      message: "Plugin name should be kebab-case (lowercase letters, numbers, hyphens) for best compatibility with Kimi."
+    });
+  }
+  if (!manifest.version || manifest.version.trim().length === 0) {
+    issues.push({
+      severity: import_core.Severity.ERROR,
+      field: "version",
+      message: "Plugin 'version' is required."
+    });
+  }
+  if (!manifest.description || manifest.description.trim().length === 0) {
+    issues.push({
+      severity: import_core.Severity.WARNING,
+      field: "description",
+      message: "Plugin 'description' is recommended for Kimi interface metadata."
+    });
+  }
+  if (manifest.hooks) {
+    for (const [hookName, hook] of Object.entries(manifest.hooks)) {
+      if (!hook) continue;
+      if (UNSUPPORTED_HOOKS.includes(hookName)) {
+        issues.push({
+          severity: import_core.Severity.ERROR,
+          field: `hooks.${hookName}`,
+          message: `Hook "${hookName}" is not supported by Kimi. Supported hooks: ${SUPPORTED_HOOKS.join(", ")}. Consider refactoring to use a supported hook or removing it.`
+        });
+        continue;
+      }
+      if (!SUPPORTED_HOOKS.includes(hookName)) {
+        issues.push({
+          severity: import_core.Severity.ERROR,
+          field: `hooks.${hookName}`,
+          message: `Unknown hook "${hookName}". Kimi supports: ${SUPPORTED_HOOKS.join(", ")}.`
+        });
+        continue;
+      }
+      if (hook.handler) {
+        if (hook.handler.type === "inline") {
+          issues.push({
+            severity: import_core.Severity.ERROR,
+            field: `hooks.${hookName}.handler`,
+            message: `Kimi does not support inline/function handlers for "${hookName}". Wrap the logic in a CLI command and set handler.type to "command" (e.g., "node ./hooks/${hookName}.js").`
+          });
+        } else if (hook.handler.type === "command") {
+          if (!hook.handler.command || hook.handler.command.trim().length === 0) {
+            issues.push({
+              severity: import_core.Severity.ERROR,
+              field: `hooks.${hookName}.handler.command`,
+              message: `Command handler for "${hookName}" has an empty command string.`
+            });
+          }
+          const securityKeywords = ["security", "block", "deny", "prevent", "guard"];
+          const lowerHookName = hookName.toLowerCase();
+          if (securityKeywords.some((k) => lowerHookName.includes(k))) {
+            issues.push({
+              severity: import_core.Severity.WARNING,
+              field: `hooks.${hookName}`,
+              message: `Hook "${hookName}" appears security-oriented. Kimi hooks are FAIL-OPEN (not a sole security barrier). Do not rely on this hook for access control.`
+            });
+          }
+        } else if (hook.handler.type !== "http") {
+          issues.push({
+            severity: import_core.Severity.ERROR,
+            field: `hooks.${hookName}.handler.type`,
+            message: `Kimi does not support handler type "${hook.handler.type}". Use "command" instead.`
+          });
+        }
+      }
+      if (hook.blocking && hookName !== "preToolUse") {
+        issues.push({
+          severity: import_core.Severity.WARNING,
+          field: `hooks.${hookName}.blocking`,
+          message: `Only "preToolUse" supports blocking semantics in Kimi. Hook "${hookName}" marked blocking=true but will run non-blocking.`
+        });
+      }
+    }
+  }
+  if (manifest.skills && manifest.skills.length > 0) {
+    for (let i = 0; i < manifest.skills.length; i++) {
+      const skill = manifest.skills[i];
+      if (!skill.name || skill.name.trim().length === 0) {
+        issues.push({
+          severity: import_core.Severity.ERROR,
+          field: `skills[${i}].name`,
+          message: `Skill at index ${i} is missing a name.`
+        });
+      }
+      if (!skill.description || skill.description.trim().length === 0) {
+        issues.push({
+          severity: import_core.Severity.WARNING,
+          field: `skills[${i}].description`,
+          message: `Skill "${skill.name || `#${i}`}" is missing a description.`
+        });
+      }
+    }
+  }
+  return issues;
+}
+function compileForKimi(manifest) {
+  const files = [];
+  const pluginJson = {
+    name: manifest.name,
+    skills: "./skills",
+    interface: {
+      displayName: manifest.displayName || manifest.name,
+      description: manifest.description || ""
+    }
+  };
+  const sessionStartHook = manifest.hooks?.sessionStart;
+  if (sessionStartHook?.handler?.type === "command") {
+    pluginJson.sessionStart = sessionStartHook.handler.command;
+  }
+  if (manifest.mcpServers && Object.keys(manifest.mcpServers).length > 0) {
+    pluginJson.mcpServers = "./mcp.json";
+  }
+  files.push({
+    path: MANIFEST_FILENAME,
+    content: JSON.stringify(pluginJson, null, 2)
+  });
+  const hooksJson = buildHooksJson(manifest.hooks || {});
+  if (Object.keys(hooksJson.hooks).length > 0) {
+    files.push({
+      path: "kimi-hooks.json",
+      content: JSON.stringify(hooksJson, null, 2)
+    });
+  }
+  if (manifest.skills && manifest.skills.length > 0) {
+    for (const skill of manifest.skills) {
+      const skillFile = compileSkillToMarkdown(skill);
+      files.push(skillFile);
+    }
+  }
+  files.push({
+    path: "KIMI_INSTALL.md",
+    content: generateInstallInstructions(manifest)
+  });
+  return {
+    files,
+    manifest: {},
+    warnings: [],
+    issues: []
+  };
+}
+function buildHooksJson(hooks) {
+  const hooksConfig = { hooks: {} };
+  for (const [hookName, hook] of Object.entries(hooks)) {
+    if (!hook) continue;
+    const universalName = hookName;
+    if (!SUPPORTED_HOOKS.includes(universalName)) {
+      continue;
+    }
+    if (universalName === "sessionStart") {
+      continue;
+    }
+    const kimiEventName = HOOK_NAME_MAP[universalName];
+    if (!kimiEventName) {
+      continue;
+    }
+    const command = extractCommand(hook, universalName);
+    if (!command) {
+      continue;
+    }
+    const statusMessage = buildStatusMessage(hook, universalName);
+    if (!hooksConfig.hooks[kimiEventName]) {
+      hooksConfig.hooks[kimiEventName] = [];
+    }
+    hooksConfig.hooks[kimiEventName].push({
+      matcher: hook.matcher || "*",
+      hooks: [
+        {
+          type: "command",
+          command,
+          statusMessage
+        }
+      ]
+    });
+  }
+  return hooksConfig;
+}
+function extractCommand(hook, hookName) {
+  if (!hook.handler) {
+    return null;
+  }
+  if (hook.handler.type === "command") {
+    return hook.handler.command || null;
+  }
+  if (hook.handler.type === "inline") {
+    return `node ./hooks/${hookName}.js`;
+  }
+  return null;
+}
+function buildStatusMessage(hook, universalName) {
+  if (hook.handler.type === "command" && hook.handler.statusMessage) {
+    return hook.handler.statusMessage;
+  }
+  const defaultMessages = {
+    preToolUse: "Running pre-tool check",
+    userPromptSubmit: "Processing user prompt",
+    sessionStart: "Initializing plugin session",
+    notification: "Handling notification",
+    permissionRequest: "Requesting permission",
+    sessionEnd: "Cleaning up session",
+    userPromptExpansion: "Expanding prompt context",
+    postToolUse: "Processing tool result",
+    postToolUseFailure: "Handling tool failure",
+    permissionDenied: "Processing permission denial",
+    subagentStart: "Subagent starting",
+    subagentStop: "Subagent stopping",
+    preCompact: "Pre-compacting session",
+    postCompact: "Post-compacting session",
+    stop: "Stopping",
+    stopFailure: "Handling stop failure",
+    fileChanged: "Processing file change",
+    cwdChanged: "Processing directory change",
+    setup: "Running setup"
+  };
+  return defaultMessages[universalName];
+}
+function compileSkillToMarkdown(skill) {
+  const frontmatter = {
+    name: skill.name,
+    description: skill.description
+  };
+  const frontmatterYaml = Object.entries(frontmatter).map(([key, value]) => {
+    if (Array.isArray(value)) {
+      return `${key}:
+${value.map((v) => `  - ${v}`).join("\n")}`;
+    }
+    return `${key}: ${value}`;
+  }).join("\n");
+  const body = skill.content || skill.description || "";
+  const content = `---
+${frontmatterYaml}
+---
+
+${body}
+`;
+  const safeName = skill.name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+  return {
+    path: `skills/SKILL__${safeName}.md`,
+    content
+  };
+}
+function generateInstallInstructions(manifest) {
+  const displayName = manifest.displayName || manifest.name;
+  return `# Installing ${displayName} for Kimi
+
+> Generated by AgentPlugins \u2014 Kimi Platform Adapter
+
+## Quick Install
+
+In any Kimi chat, run:
+
+\`\`\`
+/plugins install <github-url|local-path>
+\`\`\`
+
+Replace \`<github-url|local-path>\` with the repository URL or local directory
+path containing this plugin.
+
+## Post-Install
+
+Kimi plugins are **user-level** \u2014 they apply to all your sessions, not just the
+current project.
+
+After installing (or updating) this plugin, start a **new session** with:
+
+\`\`\`
+/new
+\`\`\`
+
+Plugin changes do **not** take effect in existing sessions.
+
+## Important Notes
+
+- **Fail-open hooks**: Kimi hooks are designed to fail open. If a hook process
+  crashes or times out, Kimi continues execution. Do not rely on hooks as a
+  sole security mechanism.
+
+- **Trust badges**: Kimi shows trust indicators for plugins installed from
+  GitHub. Install only plugins from sources you trust.
+
+- **No project scope**: Kimi does not support project-level plugin scoping.
+  All plugins are installed at the user level.
+
+## Supported Features
+
+This plugin uses the following Kimi features:
+
+  ${manifest.hooks && Object.keys(manifest.hooks).length > 0 ? `**Hooks**: ${Object.entries(manifest.hooks).filter(([name]) => SUPPORTED_HOOKS.includes(name)).map(([name]) => HOOK_NAME_MAP[name] || name).join(", ")}` : "**Hooks**: (none)"}
+
+${manifest.skills && manifest.skills.length > 0 ? `**Skills**: ${manifest.skills.map((s) => s.name).join(", ")}` : "**Skills**: (none)"}
+
+## Troubleshooting
+
+| Problem | Solution |
+|---------|----------|
+| Plugin not active | Run \`/new\` to start a fresh session |
+| Hook not firing | Check that the command in \`kimi-hooks.json\` is executable |
+| Skill not recognized | Verify \`kimi.plugin.json\` has correct \`skills\` path |
+| Changes not applied | Remember: **every change requires \`/new\`** |
+`;
+}
+var KimiAdapter = class {
+  constructor() {
+    /** @inheritDoc */
+    this.name = PLATFORM_NAME;
+    /** @inheritDoc */
+    this.displayName = PLATFORM_DISPLAY_NAME;
+    /** @inheritDoc */
+    this.supportedHooks = SUPPORTED_HOOKS;
+    /** @inheritDoc */
+    this.supportedHandlers = SUPPORTED_HANDLERS;
+    /** @inheritDoc */
+    this.manifestPath = MANIFEST_FILENAME;
+    /** @inheritDoc */
+    this.manifestFormat = MANIFEST_FORMAT;
+  }
+  /**
+   * Validates a universal plugin manifest for Kimi compatibility.
+   *
+   * @param manifest — The plugin manifest to validate.
+   * @returns Array of validation issues (empty if fully valid).
+   */
+  validate(manifest) {
+    return validateForKimi(manifest);
+  }
+  /**
+   * Compiles a universal plugin manifest into Kimi-native artifacts.
+   *
+   * @param manifest — The plugin manifest to compile.
+   * @returns AdapterOutput containing all files to write.
+   */
+  compile(manifest) {
+    return compileForKimi(manifest);
+  }
+};
+var kimiAdapter = new KimiAdapter();
+function createKimiAdapter() {
+  return new KimiAdapter();
+}
+var index_default = KimiAdapter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KimiAdapter,
+  createKimiAdapter,
+  kimiAdapter
+});

package/dist/index.mjs

@@ -0,0 +1,412 @@
+// src/index.ts
+import { Severity } from "@agentplugins/core";
+var PLATFORM_NAME = "kimi";
+var PLATFORM_DISPLAY_NAME = "Kimi (Moonshot AI)";
+var MANIFEST_FILENAME = "kimi.plugin.json";
+var MANIFEST_FORMAT = "json";
+var SUPPORTED_HOOKS = [
+  "preToolUse",
+  "userPromptSubmit",
+  "sessionStart",
+  "notification",
+  "permissionRequest"
+];
+var SUPPORTED_HANDLERS = ["command"];
+var HOOK_NAME_MAP = {
+  preToolUse: "PreToolUse",
+  userPromptSubmit: "UserPromptSubmit",
+  sessionStart: "SessionStart",
+  notification: "Notification",
+  permissionRequest: "PermissionRequest",
+  // — unsupported mappings (not present in SUPPORTED_HOOKS) —
+  sessionEnd: "SessionEnd",
+  userPromptExpansion: "UserPromptExpansion",
+  postToolUse: "PostToolUse",
+  postToolUseFailure: "PostToolUseFailure",
+  permissionDenied: "PermissionDenied",
+  subagentStart: "SubagentStart",
+  subagentStop: "SubagentStop",
+  preCompact: "PreCompact",
+  postCompact: "PostCompact",
+  stop: "Stop",
+  stopFailure: "StopFailure",
+  fileChanged: "FileChanged",
+  cwdChanged: "CwdChanged",
+  setup: "Setup"
+};
+var UNSUPPORTED_HOOKS = [
+  "sessionEnd",
+  "userPromptExpansion",
+  "postToolUse",
+  "postToolUseFailure",
+  "permissionDenied",
+  "subagentStart",
+  "subagentStop",
+  "preCompact",
+  "postCompact",
+  "stop",
+  "stopFailure",
+  "fileChanged",
+  "cwdChanged",
+  "setup"
+];
+function validateForKimi(manifest) {
+  const issues = [];
+  if (!manifest.name || manifest.name.trim().length === 0) {
+    issues.push({
+      severity: Severity.ERROR,
+      field: "name",
+      message: "Plugin 'name' is required for kimi.plugin.json."
+    });
+  } else if (!/^[a-z0-9-]+$/.test(manifest.name)) {
+    issues.push({
+      severity: Severity.WARNING,
+      field: "name",
+      message: "Plugin name should be kebab-case (lowercase letters, numbers, hyphens) for best compatibility with Kimi."
+    });
+  }
+  if (!manifest.version || manifest.version.trim().length === 0) {
+    issues.push({
+      severity: Severity.ERROR,
+      field: "version",
+      message: "Plugin 'version' is required."
+    });
+  }
+  if (!manifest.description || manifest.description.trim().length === 0) {
+    issues.push({
+      severity: Severity.WARNING,
+      field: "description",
+      message: "Plugin 'description' is recommended for Kimi interface metadata."
+    });
+  }
+  if (manifest.hooks) {
+    for (const [hookName, hook] of Object.entries(manifest.hooks)) {
+      if (!hook) continue;
+      if (UNSUPPORTED_HOOKS.includes(hookName)) {
+        issues.push({
+          severity: Severity.ERROR,
+          field: `hooks.${hookName}`,
+          message: `Hook "${hookName}" is not supported by Kimi. Supported hooks: ${SUPPORTED_HOOKS.join(", ")}. Consider refactoring to use a supported hook or removing it.`
+        });
+        continue;
+      }
+      if (!SUPPORTED_HOOKS.includes(hookName)) {
+        issues.push({
+          severity: Severity.ERROR,
+          field: `hooks.${hookName}`,
+          message: `Unknown hook "${hookName}". Kimi supports: ${SUPPORTED_HOOKS.join(", ")}.`
+        });
+        continue;
+      }
+      if (hook.handler) {
+        if (hook.handler.type === "inline") {
+          issues.push({
+            severity: Severity.ERROR,
+            field: `hooks.${hookName}.handler`,
+            message: `Kimi does not support inline/function handlers for "${hookName}". Wrap the logic in a CLI command and set handler.type to "command" (e.g., "node ./hooks/${hookName}.js").`
+          });
+        } else if (hook.handler.type === "command") {
+          if (!hook.handler.command || hook.handler.command.trim().length === 0) {
+            issues.push({
+              severity: Severity.ERROR,
+              field: `hooks.${hookName}.handler.command`,
+              message: `Command handler for "${hookName}" has an empty command string.`
+            });
+          }
+          const securityKeywords = ["security", "block", "deny", "prevent", "guard"];
+          const lowerHookName = hookName.toLowerCase();
+          if (securityKeywords.some((k) => lowerHookName.includes(k))) {
+            issues.push({
+              severity: Severity.WARNING,
+              field: `hooks.${hookName}`,
+              message: `Hook "${hookName}" appears security-oriented. Kimi hooks are FAIL-OPEN (not a sole security barrier). Do not rely on this hook for access control.`
+            });
+          }
+        } else if (hook.handler.type !== "http") {
+          issues.push({
+            severity: Severity.ERROR,
+            field: `hooks.${hookName}.handler.type`,
+            message: `Kimi does not support handler type "${hook.handler.type}". Use "command" instead.`
+          });
+        }
+      }
+      if (hook.blocking && hookName !== "preToolUse") {
+        issues.push({
+          severity: Severity.WARNING,
+          field: `hooks.${hookName}.blocking`,
+          message: `Only "preToolUse" supports blocking semantics in Kimi. Hook "${hookName}" marked blocking=true but will run non-blocking.`
+        });
+      }
+    }
+  }
+  if (manifest.skills && manifest.skills.length > 0) {
+    for (let i = 0; i < manifest.skills.length; i++) {
+      const skill = manifest.skills[i];
+      if (!skill.name || skill.name.trim().length === 0) {
+        issues.push({
+          severity: Severity.ERROR,
+          field: `skills[${i}].name`,
+          message: `Skill at index ${i} is missing a name.`
+        });
+      }
+      if (!skill.description || skill.description.trim().length === 0) {
+        issues.push({
+          severity: Severity.WARNING,
+          field: `skills[${i}].description`,
+          message: `Skill "${skill.name || `#${i}`}" is missing a description.`
+        });
+      }
+    }
+  }
+  return issues;
+}
+function compileForKimi(manifest) {
+  const files = [];
+  const pluginJson = {
+    name: manifest.name,
+    skills: "./skills",
+    interface: {
+      displayName: manifest.displayName || manifest.name,
+      description: manifest.description || ""
+    }
+  };
+  const sessionStartHook = manifest.hooks?.sessionStart;
+  if (sessionStartHook?.handler?.type === "command") {
+    pluginJson.sessionStart = sessionStartHook.handler.command;
+  }
+  if (manifest.mcpServers && Object.keys(manifest.mcpServers).length > 0) {
+    pluginJson.mcpServers = "./mcp.json";
+  }
+  files.push({
+    path: MANIFEST_FILENAME,
+    content: JSON.stringify(pluginJson, null, 2)
+  });
+  const hooksJson = buildHooksJson(manifest.hooks || {});
+  if (Object.keys(hooksJson.hooks).length > 0) {
+    files.push({
+      path: "kimi-hooks.json",
+      content: JSON.stringify(hooksJson, null, 2)
+    });
+  }
+  if (manifest.skills && manifest.skills.length > 0) {
+    for (const skill of manifest.skills) {
+      const skillFile = compileSkillToMarkdown(skill);
+      files.push(skillFile);
+    }
+  }
+  files.push({
+    path: "KIMI_INSTALL.md",
+    content: generateInstallInstructions(manifest)
+  });
+  return {
+    files,
+    manifest: {},
+    warnings: [],
+    issues: []
+  };
+}
+function buildHooksJson(hooks) {
+  const hooksConfig = { hooks: {} };
+  for (const [hookName, hook] of Object.entries(hooks)) {
+    if (!hook) continue;
+    const universalName = hookName;
+    if (!SUPPORTED_HOOKS.includes(universalName)) {
+      continue;
+    }
+    if (universalName === "sessionStart") {
+      continue;
+    }
+    const kimiEventName = HOOK_NAME_MAP[universalName];
+    if (!kimiEventName) {
+      continue;
+    }
+    const command = extractCommand(hook, universalName);
+    if (!command) {
+      continue;
+    }
+    const statusMessage = buildStatusMessage(hook, universalName);
+    if (!hooksConfig.hooks[kimiEventName]) {
+      hooksConfig.hooks[kimiEventName] = [];
+    }
+    hooksConfig.hooks[kimiEventName].push({
+      matcher: hook.matcher || "*",
+      hooks: [
+        {
+          type: "command",
+          command,
+          statusMessage
+        }
+      ]
+    });
+  }
+  return hooksConfig;
+}
+function extractCommand(hook, hookName) {
+  if (!hook.handler) {
+    return null;
+  }
+  if (hook.handler.type === "command") {
+    return hook.handler.command || null;
+  }
+  if (hook.handler.type === "inline") {
+    return `node ./hooks/${hookName}.js`;
+  }
+  return null;
+}
+function buildStatusMessage(hook, universalName) {
+  if (hook.handler.type === "command" && hook.handler.statusMessage) {
+    return hook.handler.statusMessage;
+  }
+  const defaultMessages = {
+    preToolUse: "Running pre-tool check",
+    userPromptSubmit: "Processing user prompt",
+    sessionStart: "Initializing plugin session",
+    notification: "Handling notification",
+    permissionRequest: "Requesting permission",
+    sessionEnd: "Cleaning up session",
+    userPromptExpansion: "Expanding prompt context",
+    postToolUse: "Processing tool result",
+    postToolUseFailure: "Handling tool failure",
+    permissionDenied: "Processing permission denial",
+    subagentStart: "Subagent starting",
+    subagentStop: "Subagent stopping",
+    preCompact: "Pre-compacting session",
+    postCompact: "Post-compacting session",
+    stop: "Stopping",
+    stopFailure: "Handling stop failure",
+    fileChanged: "Processing file change",
+    cwdChanged: "Processing directory change",
+    setup: "Running setup"
+  };
+  return defaultMessages[universalName];
+}
+function compileSkillToMarkdown(skill) {
+  const frontmatter = {
+    name: skill.name,
+    description: skill.description
+  };
+  const frontmatterYaml = Object.entries(frontmatter).map(([key, value]) => {
+    if (Array.isArray(value)) {
+      return `${key}:
+${value.map((v) => `  - ${v}`).join("\n")}`;
+    }
+    return `${key}: ${value}`;
+  }).join("\n");
+  const body = skill.content || skill.description || "";
+  const content = `---
+${frontmatterYaml}
+---
+
+${body}
+`;
+  const safeName = skill.name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+  return {
+    path: `skills/SKILL__${safeName}.md`,
+    content
+  };
+}
+function generateInstallInstructions(manifest) {
+  const displayName = manifest.displayName || manifest.name;
+  return `# Installing ${displayName} for Kimi
+
+> Generated by AgentPlugins \u2014 Kimi Platform Adapter
+
+## Quick Install
+
+In any Kimi chat, run:
+
+\`\`\`
+/plugins install <github-url|local-path>
+\`\`\`
+
+Replace \`<github-url|local-path>\` with the repository URL or local directory
+path containing this plugin.
+
+## Post-Install
+
+Kimi plugins are **user-level** \u2014 they apply to all your sessions, not just the
+current project.
+
+After installing (or updating) this plugin, start a **new session** with:
+
+\`\`\`
+/new
+\`\`\`
+
+Plugin changes do **not** take effect in existing sessions.
+
+## Important Notes
+
+- **Fail-open hooks**: Kimi hooks are designed to fail open. If a hook process
+  crashes or times out, Kimi continues execution. Do not rely on hooks as a
+  sole security mechanism.
+
+- **Trust badges**: Kimi shows trust indicators for plugins installed from
+  GitHub. Install only plugins from sources you trust.
+
+- **No project scope**: Kimi does not support project-level plugin scoping.
+  All plugins are installed at the user level.
+
+## Supported Features
+
+This plugin uses the following Kimi features:
+
+  ${manifest.hooks && Object.keys(manifest.hooks).length > 0 ? `**Hooks**: ${Object.entries(manifest.hooks).filter(([name]) => SUPPORTED_HOOKS.includes(name)).map(([name]) => HOOK_NAME_MAP[name] || name).join(", ")}` : "**Hooks**: (none)"}
+
+${manifest.skills && manifest.skills.length > 0 ? `**Skills**: ${manifest.skills.map((s) => s.name).join(", ")}` : "**Skills**: (none)"}
+
+## Troubleshooting
+
+| Problem | Solution |
+|---------|----------|
+| Plugin not active | Run \`/new\` to start a fresh session |
+| Hook not firing | Check that the command in \`kimi-hooks.json\` is executable |
+| Skill not recognized | Verify \`kimi.plugin.json\` has correct \`skills\` path |
+| Changes not applied | Remember: **every change requires \`/new\`** |
+`;
+}
+var KimiAdapter = class {
+  constructor() {
+    /** @inheritDoc */
+    this.name = PLATFORM_NAME;
+    /** @inheritDoc */
+    this.displayName = PLATFORM_DISPLAY_NAME;
+    /** @inheritDoc */
+    this.supportedHooks = SUPPORTED_HOOKS;
+    /** @inheritDoc */
+    this.supportedHandlers = SUPPORTED_HANDLERS;
+    /** @inheritDoc */
+    this.manifestPath = MANIFEST_FILENAME;
+    /** @inheritDoc */
+    this.manifestFormat = MANIFEST_FORMAT;
+  }
+  /**
+   * Validates a universal plugin manifest for Kimi compatibility.
+   *
+   * @param manifest — The plugin manifest to validate.
+   * @returns Array of validation issues (empty if fully valid).
+   */
+  validate(manifest) {
+    return validateForKimi(manifest);
+  }
+  /**
+   * Compiles a universal plugin manifest into Kimi-native artifacts.
+   *
+   * @param manifest — The plugin manifest to compile.
+   * @returns AdapterOutput containing all files to write.
+   */
+  compile(manifest) {
+    return compileForKimi(manifest);
+  }
+};
+var kimiAdapter = new KimiAdapter();
+function createKimiAdapter() {
+  return new KimiAdapter();
+}
+var index_default = KimiAdapter;
+export {
+  KimiAdapter,
+  createKimiAdapter,
+  index_default as default,
+  kimiAdapter
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@agentplugins/adapter-kimi",
+  "version": "0.1.0",
+  "description": "AgentPlugins platform adapter for Kimi (Moonshot AI)",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "lint": "eslint src/**/*.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@agentplugins/core": "workspace:*"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0"
+  },
+  "peerDependencies": {
+    "@agentplugins/core": "^0.1.0"
+  },
+  "keywords": [
+    "agentplugins",
+    "kimi",
+    "moonshot",
+    "plugin",
+    "adapter"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/espetro/agentplugins.git",
+    "directory": "packages/adapter-kimi"
+  }
+}