mm_module 1.0.2 → 1.0.4

package/README.md

@@ -0,0 +1,171 @@
+# mm_module
+
+内核模块管理框架件：基于 npm 实现模块的搜索、安装、卸载与清单编排，并按模块 package.json 声明的 `group` 层级分层装载与声明体检（不注册能力）。对外只暴露一个门面类 `ModuleManager`，宿主用它即可完成"检索远端 → 安装 → 按层级加载 → 更新 → 卸载"的完整模块生命周期管理；模块的自动发现以 npm 关键词 `mm_mod` 为唯一判定依据。
+
+## 项目信息
+
+- **当前版本**: 1.0.2
+- **更新日期**: 2026-10-04
+- **Gitee地址**: https://gitee.com/qiuwenwu91/mm_module（package.json 中 repository 指向 github.com/mm-modules，为复制遗留的错误地址）
+- **依赖**: `mm_corejs`（file 依赖，提供 `Manager` 基类与 `Store`）；运行环境要求 Node.js >= 18；npm 命令经子进程调用，需宿主可执行 `npm`
+
+## 特点
+
+- 单一门面：`index.js` 仅导出 `ModuleManager`，清单规范（lib/spec）与 npm 通道（lib/npm_channel）为内部实现
+- 声明式发现：只把 package.json 带 `mm_mod` 关键词、名称命中前缀（默认 `mm_`）的包纳入清单
+- 分层装载：按 `tool → infra → in_port → in_adapter → channel → service → domain → database → out_adapter → out_port → unknown` 的层级序加载，层内保持传入顺序
+- 生命周期实体自动驱动：模块导出同时具备 `init` 与 `start` 函数时自动补全 init/start，卸载时自动 stop/dispose 并清 require 缓存
+- 失败可回滚：`load` 默认 fail_fast，任一模块失败即逆序回滚本次新加载的模块并抛错
+- 测试友好：npm 执行可经 `config.runner` 注入假执行器，全程离线可演示（见 example/demo.js）
+
+## 安装
+
+```bash
+npm install mm_module
+```
+
+## 基本使用
+
+```javascript
+const { ModuleManager } = require('mm_module');
+
+async function main() {
+  const manager = new ModuleManager({ cwd: process.cwd() });
+  await manager.init();   // 构建本地清单（读宿主 package.json 依赖声明）
+  await manager.start();
+
+  const specs = await manager.search('pay'); // 远端检索，实际检索词 mm_pay
+  console.log(manager.names());              // 本地已装模块名（按层级序）
+
+  await manager.install('mm_pay_wechat');    // 安装并自动加载
+  await manager.load(manager.names());       // 按层级排序批量加载
+  await manager.unload('mm_pay_wechat');     // 卸载加载（stop/dispose + 清缓存）
+  await manager.uninstall('mm_pay_wechat');  // npm 卸载并移出清单
+
+  await manager.dispose(); // 释放时自动逆序卸载全部剩余模块
+}
+```
+
+## API 说明
+
+### 构造与配置
+
+`new ModuleManager(config = {}, server)`：`config` 覆盖静态默认配置，`server` 为框架引用（满足 mm_corejs Base 最小契约即可，可为空对象）。
+
+| 配置项 | 默认值 | 说明 |
+| --- | --- | --- |
+| `cwd` | `process.cwd()` | 宿主目录（读依赖声明、执行 npm 命令的工作目录） |
+| `prefix` | `'mm_'` | 模块名前缀，检索与查询只命中该前缀开头的模块；空串时不过滤 |
+| `keyword` | `'mm_mod'` | 发现关键词，模块声明合法性的唯一判定 |
+| `limit` | `250` | 远端检索条数上限 |
+| `registry` | `''` | 指定 npm registry，非空时追加 `--registry=` 参数 |
+| `runner` | `null` | 注入的 npm 执行函数 `(args, options) => { stdout }`，用于测试与定制 |
+| `include_untagged` | `false` | 本地清单是否纳入未声明关键词的依赖 |
+| `fail_fast` | `true` | `load` 失败时是否回滚并抛错 |
+
+### 模块清单项（spec）
+
+所有查询方法返回的条目由包描述归一化而来，字段固定为：
+
+| 字段 | 类型 | 说明 |
+| --- | --- | --- |
+| `name` / `version` / `description` | `string\|null` | 包名 / 版本 / 描述 |
+| `group` | `string` | 层级；未声明或非法时为 `'unknown'` |
+| `isolation` | `string\|null` | 隔离声明（透传 package.json 的 `isolation` 字段） |
+| `keywords` | `Array` | 关键词列表 |
+| `homepage` | `string\|null` | 主页，缺失时回退 repository 地址 |
+| `installed` | `boolean` | 是否本地已装 |
+| `path` | `string\|null` | 本地包根目录（远端项为 null） |
+| `source` | `'local'\|'remote'` | 清单项来源 |
+
+### 查找
+
+| 方法 | 签名 | 返回值 | 说明 |
+| --- | --- | --- | --- |
+| `search` | `async search(keyword = '', options = {})` | `Promise<Array>` | 远端检索（`npm search`），只命中前缀开头且带关键词的模块，标记本地已装项；`options.limit` 覆盖条数上限；结果按层级序排序 |
+| `inspect` | `async inspect(name)` | `Promise<object\|null>` | 查询单个模块，本地清单优先，未装时查远端（`npm view`）；非前缀名直接返回 `null` |
+| `list` | `list(filter = {})` | `Array` | 本地已装清单；`filter` 支持 `group / installed / isolation / keyword / text`（text 命中名称、描述、关键词） |
+| `names` | `names(filter = {})` | `Array` | 本地模块名列表，可直接交给 `load` |
+| `summary` | `summary(filter = {})` | `object` | 按层级汇总：`{ total, groups }`，groups 为层级 → 模块名数组 |
+
+### 安装与卸载
+
+| 方法 | 签名 | 返回值 | 说明 |
+| --- | --- | --- | --- |
+| `install` | `async install(name, options = {})` | `Promise<object>` | 校验发现关键词后 `npm install --save`，成功后重建本地清单并默认自动加载；`options.force` 跳过关键词校验、`options.version` 指定版本、`options.load: false` 跳过自动加载；已安装时幂等（仅补自动加载） |
+| `uninstall` | `async uninstall(name)` | `Promise<object>` | 已加载先自动卸载，再 `npm uninstall` 并移出本地清单；返回 `{ name, removed }`，未装时 `removed: false` 幂等返回 |
+
+### 更新版本
+
+| 方法 | 签名 | 返回值 | 说明 |
+| --- | --- | --- | --- |
+| `update` | `async update(name, options = {})` | `Promise<object\|null>` | 远端版本高于本地时重装并（若原本已加载）重载；无新版返回 `null`；`options.load: false` 更新后不重载。未安装或远端不可用抛 `Error` |
+| `updateAll` | `async updateAll(options = {})` | `Promise<Array>` | 逐个检查本地模块，返回更新过的清单项数组（无远端信息与无新版的跳过） |
+
+### 加载与卸载
+
+| 方法 | 签名 | 返回值 | 说明 |
+| --- | --- | --- | --- |
+| `load` | `async load(names, options = {})` | `Promise<object>` | 按层级排序后逐个装载；返回 `{ loaded, order, failed }`；`options.fail_fast` 覆盖实例配置——为真时任一失败即逆序回滚本次新加载模块并抛错，为假时失败记入 `failed` 继续 |
+| `unload` | `async unload(name)` | `Promise<boolean>` | 从受管集合移除并触发 disposer（实体 stop/dispose、清 require 缓存） |
+| `doctor` | `doctor()` | `object` | 静态体检已加载模块：`{ untagged, ungrouped }`（未带关键词 / 未声明合法层级） |
+
+装载约定：入口经 `require.resolve` 定位；导出对象同时具备 `init` 与 `start` 函数时视为生命周期实体，自动驱动至运行态（具备 `getState/isRunning` 的按状态补调用）；已装载模块幂等跳过。
+
+### 继承自 mm_corejs Manager 的能力
+
+`init()` / `start()` / `stop()` / `dispose()`（dispose 时逆序触发各模块 disposer，即自动全部卸载）、`has(name)`、`get/del/set/keys/size`、`log(level, msg)`、`state`。
+
+## 使用示例
+
+### 场景一：宿主启动时按层级批量装载
+
+```javascript
+const { ModuleManager } = require('mm_module');
+
+async function bootstrap() {
+  const manager = new ModuleManager({ cwd: __dirname });
+  await manager.init();
+  await manager.start();
+
+  // 乱序传入也会按 group 层级排序执行，失败自动回滚
+  const result = await manager.load(manager.names());
+  console.log('加载顺序：', result.order.join(' -> '));
+  console.log('体检：', manager.doctor());
+}
+```
+
+### 场景二：检索并安装远端模块
+
+```javascript
+const { ModuleManager } = require('mm_module');
+
+async function addModule() {
+  const manager = new ModuleManager({ cwd: process.cwd(), registry: 'https://registry.npmmirror.com' });
+  await manager.init();
+
+  const specs = await manager.search('pay');           // 检索 mm_pay 前缀模块
+  if (specs.length > 0) {
+    const spec = await manager.install(specs[0].name); // 安装 + 自动加载
+    console.log(`已安装 ${spec.name}@${spec.version}`);
+  }
+}
+```
+
+### 场景三：离线测试（注入假 npm 执行器）
+
+```javascript
+const { ModuleManager } = require('mm_module');
+
+const fakeRunner = async (args) => {
+  if (args[0] === 'search') {
+    return { stdout: JSON.stringify([{ name: 'mm_demo_mod', version: '1.0.0', keywords: ['mm_mod'], group: 'tool' }]) };
+  }
+  return { stdout: '' };
+};
+
+const manager = new ModuleManager({ cwd: process.cwd(), runner: fakeRunner });
+const specs = await manager.search('demo'); // 不触网完成检索
+```
+
+> 完整端到端演示（装配/查找/安装/加载/更新/卸载/体检/释放）见包内 `example/demo.js`，运行：`node example/demo.js`。

package/lib/module_manager.js

@@ -0,0 +1,647 @@
+/**
+ * 模块管理器
+ * 基于 mm_corejs 的 Manager 基类，统一实现模块的查找、安装、卸载、更新版本、加载与卸载：
+ * 受管集合承载已加载模块（dispose 时由基类逆序触发 disposer，即自动全部卸载），
+ * Store 承载本地与远端清单，npm 命令经 lib/npm_channel 执行，清单规范见 lib/spec，
+ * 宿主无需注入任何装载契约
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { Manager } = require('mm_mod');
+const { Store } = require('mm_corejs');
+const {
+  KEYWORD,
+  DEFAULT_PREFIX,
+  UNKNOWN_GROUP,
+  _groupOrder,
+  _readSpec,
+  _checkSpec,
+  _matchSpec,
+  _groupSpecs,
+  _sortedSpecs,
+  _isVersionNewer
+} = require('./spec');
+const { _runNpm, _parseRows, _parseObject } = require('./npm_channel');
+
+// 远端检索条数上限默认值
+const DEFAULT_LIMIT = 250;
+
+/**
+ * 把模块导出识别为生命周期实体：同时具备 init 与 start 函数的对象即实体实例
+ * @param {any} exports 模块导出值
+ * @returns {object|null} 实体实例或 null
+ */
+function _toEntity(exports) {
+  if (exports === null || typeof exports !== 'object') return null;
+  if (typeof exports.init === 'function' && typeof exports.start === 'function') return exports;
+  return null;
+}
+
+/**
+ * 驱动实体进入运行态：具备状态查询的实体按状态补 init/start，
+ * 无状态查询的普通实体依次调用 init 与 start
+ * @param {object} entity 生命周期实体
+ * @returns {Promise<void>} 无返回值
+ */
+async function _startEntity(entity) {
+  if (typeof entity.getState !== 'function') {
+    await entity.init();
+    await entity.start();
+    return;
+  }
+  if ((await entity.getState()) === 'created') await entity.init();
+  if (!(await entity.isRunning())) await entity.start();
+}
+
+/**
+ * 停止并释放实体，非实体时跳过
+ * @param {object|null} entity 生命周期实体
+ * @returns {Promise<void>} 无返回值
+ */
+async function _stopEntity(entity) {
+  if (!entity) return;
+  if (typeof entity.stop === 'function') await entity.stop();
+  if (typeof entity.dispose === 'function') await entity.dispose();
+}
+
+/**
+ * 模块管理器：查找、安装、卸载、更新版本、加载与卸载的唯一门面
+ */
+class ModuleManager extends Manager {
+  static config = {
+    name: 'module',
+    version: '1.0.0',
+    description: '模块管理器：基于 mm_corejs 的模块查找/安装/卸载/更新/加载编排',
+    cwd: '',
+    prefix: DEFAULT_PREFIX,
+    keyword: KEYWORD,
+    limit: DEFAULT_LIMIT,
+    registry: '',
+    runner: null,
+    include_untagged: false,
+    fail_fast: true
+  };
+
+  /**
+   * 构造函数
+   * @param {object} config 实体配置，覆盖静态默认值：cwd / prefix / keyword / limit / registry / runner / include_untagged / fail_fast
+   * @param {object} server 框架引用，满足 mm_corejs Base 的最小契约即可（可为空对象）
+   */
+  constructor(config = {}, server) {
+    super(config, server);
+    if (typeof this.config.cwd !== 'string' || this.config.cwd.length === 0) {
+      this.config.cwd = process.cwd();
+    }
+    if (typeof this.config.prefix !== 'string') this.config.prefix = DEFAULT_PREFIX;
+    /** @type {Store} 本地清单：宿主依赖中声明合规的模块 */
+    this._local = new Store({ key: 'name', like: true });
+    /** @type {Store} 远端检索缓存 */
+    this._remote = new Store({ key: 'name', like: true });
+  }
+
+  // ---------- 生命周期 ----------
+  /**
+   * 初始化钩子：构建本地清单
+   * @returns {Promise<void>} 无返回值
+   */
+  async onInit() {
+    this._rebuildLocal();
+    this.log('info', `本地清单已构建，共 ${this._local.count()} 个模块`);
+  }
+
+  // ---------- 查找 ----------
+  /**
+   * 远端检索模块，只命中配置前缀开头的模块名，并标记本地已装项
+   * @param {string} keyword 检索关键词（前缀之后的部分），空串时按前缀列全量
+   * @param {object} options 检索选项，支持 limit 覆盖条数上限
+   * @returns {Promise<Array>} 模块清单项数组，按层级序排序
+   * @throws {TypeError} 参数类型错误时抛出
+   */
+  async search(keyword = '', options = {}) {
+    if (typeof keyword !== 'string') throw new TypeError('检索关键词必须是字符串');
+    if (options === null || typeof options !== 'object') throw new TypeError('options 必须是对象');
+    const limit = typeof options.limit === 'number' && options.limit > 0 ? options.limit : this.config.limit;
+    const args = ['search', this._buildQuery(keyword), '--json', `--searchlimit=${limit}`];
+    const rows = _parseRows(await this._execNpm(args));
+    const specs = [];
+    this._remote.clear();
+    for (const row of rows) {
+      const spec = this._toSpec(row, true);
+      if (spec === null || !this._hasPrefix(spec.name)) continue;
+      const local = this._local.getById(spec.name);
+      const item = local ? Object.assign({}, spec, { installed: true }) : spec;
+      this._remote.add(item);
+      specs.push(item);
+    }
+    return _sortedSpecs(specs);
+  }
+
+  /**
+   * 查询单个模块，本地清单优先，未装时查远端；非前缀名直接返回 null
+   * @param {string} name 模块名
+   * @returns {Promise<object|null>} 模块清单项，不存在时为 null
+   * @throws {TypeError} name 不是非空字符串时抛出
+   */
+  async inspect(name) {
+    if (typeof name !== 'string' || name.length === 0) {
+      throw new TypeError('模块名必须是非空字符串');
+    }
+    const local = this._local.getById(name);
+    if (local !== undefined) return local;
+    if (!this._hasPrefix(name)) return null;
+    const remote = await this._view(name);
+    if (remote !== null && this._remote.getById(remote.name) === undefined) {
+      this._remote.add(remote);
+    }
+    return remote;
+  }
+
+  /**
+   * 本地已装模块清单
+   * @param {object} filter 过滤条件，支持 group / installed / isolation / keyword / text
+   * @returns {Array} 模块清单项数组，按层级序排序
+   * @throws {TypeError} filter 不是对象时抛出
+   */
+  list(filter = {}) {
+    if (filter === null || typeof filter !== 'object') throw new TypeError('filter 必须是对象');
+    const specs = this._local.list().filter((spec) => _matchSpec(spec, filter));
+    return _sortedSpecs(specs);
+  }
+
+  /**
+   * 本地模块名列表，可直接交给 load
+   * @param {object} filter 过滤条件
+   * @returns {Array} 模块名数组
+   */
+  names(filter = {}) {
+    return this.list(filter).map((spec) => spec.name);
+  }
+
+  /**
+   * 按层级汇总本地模块
+   * @param {object} filter 过滤条件
+   * @returns {object} 含 total 与 groups 的汇总，groups 为层级到模块名数组
+   */
+  summary(filter = {}) {
+    const specs = this.list(filter);
+    const buckets = _groupSpecs(specs);
+    const groups = {};
+    for (const key of Object.keys(buckets)) {
+      groups[key] = buckets[key].map((spec) => spec.name);
+    }
+    return { total: specs.length, groups };
+  }
+
+  // ---------- 安装与卸载 ----------
+  /**
+   * 安装模块：校验发现关键词后执行 npm install，成功后重建本地清单并默认自动加载
+   * @param {string} name 模块名
+   * @param {object} options 安装选项
+   * @param {boolean} options.force 为真时跳过关键词校验
+   * @param {string} options.version 指定安装版本
+   * @param {boolean} options.load 为假时跳过安装后自动加载
+   * @returns {Promise<object>} 安装后的模块清单项
+   * @throws {TypeError} 参数类型错误时抛出
+   * @throws {Error} 模块不存在、未声明关键词或自动加载失败时抛出
+   */
+  async install(name, options = {}) {
+    if (typeof name !== 'string' || name.length === 0) {
+      throw new TypeError('模块名必须是非空字符串');
+    }
+    if (options === null || typeof options !== 'object') throw new TypeError('options 必须是对象');
+    const local = this._local.getById(name);
+    if (local !== undefined) {
+      await this._autoLoad(name, options);
+      return local;
+    }
+    const remote = await this._view(name);
+    this._assertInstallable(remote, name, options);
+    await this._execNpm(['install', this._target(name, options), '--save']);
+    this._rebuildLocal();
+    const spec = this._local.getById(name) || remote;
+    await this._autoLoad(name, options);
+    return spec;
+  }
+
+  /**
+   * 卸载模块：已加载先自动卸载，再执行 npm uninstall 并移出本地清单；未装时幂等返回
+   * @param {string} name 模块名
+   * @returns {Promise<object>} 含 name 与 removed 的结果
+   * @throws {TypeError} name 不是非空字符串时抛出
+   */
+  async uninstall(name) {
+    if (typeof name !== 'string' || name.length === 0) {
+      throw new TypeError('模块名必须是非空字符串');
+    }
+    if (this._local.getById(name) === undefined) return { name, removed: false };
+    if (this.has(name)) await this.del(name);
+    await this._execNpm(['uninstall', name]);
+    this._local.delById(name);
+    return { name, removed: true };
+  }
+
+  // ---------- 更新版本 ----------
+  /**
+   * 更新模块版本：远端最新版高于本地时重装并（若已加载）重载；无新版返回 null
+   * @param {string} name 模块名
+   * @param {object} options 更新选项
+   * @param {boolean} options.load 为假时更新后不重载已加载的模块
+   * @returns {Promise<object|null>} 更新后的模块清单项，无新版时为 null
+   * @throws {TypeError} 参数类型错误时抛出
+   * @throws {Error} 模块未安装或远端信息不可用时抛出
+   */
+  async update(name, options = {}) {
+    if (typeof name !== 'string' || name.length === 0) {
+      throw new TypeError('模块名必须是非空字符串');
+    }
+    if (options === null || typeof options !== 'object') throw new TypeError('options 必须是对象');
+    const local = this._local.getById(name);
+    if (local === undefined) throw new Error(`模块 ${name} 未安装，无法更新`);
+    const remote = await this._view(name);
+    if (remote === null) throw new Error(`模块 ${name} 远端信息不可用，无法更新`);
+    return this._applyUpdate(name, local, remote, options);
+  }
+
+  /**
+   * 执行更新：远端版本高于本地时重装并（若已加载）重载，无新版返回 null
+   * @param {string} name 模块名
+   * @param {object} local 本地清单项
+   * @param {object} remote 远端清单项
+   * @param {object} options 更新选项，load 为假时更新后不重载
+   * @returns {Promise<object|null>} 更新后的模块清单项，无新版时为 null
+   */
+  async _applyUpdate(name, local, remote, options) {
+    if (!_isVersionNewer(remote.version, local.version)) return null;
+    await this._execNpm(['install', `${name}@${remote.version}`, '--save']);
+    const was_loaded = this.has(name);
+    if (was_loaded) await this.del(name);
+    this._rebuildLocal();
+    const spec = this._local.getById(name);
+    if (was_loaded && options.load !== false) await this._loadOne(name);
+    return spec;
+  }
+
+  /**
+   * 更新全部本地模块：逐个查远端，无远端信息与无新版的模块均跳过，返回更新过的清单项
+   * @param {object} options 更新选项，load 为假时更新后不重载
+   * @returns {Promise<Array>} 更新过的模块清单项数组
+   * @throws {TypeError} options 不是对象时抛出
+   */
+  async updateAll(options = {}) {
+    if (options === null || typeof options !== 'object') throw new TypeError('options 必须是对象');
+    const updated = [];
+    for (const spec of this._local.list()) {
+      const remote = await this._view(spec.name);
+      if (remote === null) continue;
+      const result = await this._applyUpdate(spec.name, spec, remote, options);
+      if (result) updated.push(result);
+    }
+    return updated;
+  }
+
+  // ---------- 加载与卸载 ----------
+  /**
+   * 加载模块：按声明层级排序后逐个装载
+   * fail_fast 为真时任一失败即逆序回滚本次新加载的模块并抛错，否则记入 failed 继续
+   * @param {Array} names 模块名列表
+   * @param {object} options 加载选项，fail_fast 覆盖实例配置
+   * @returns {Promise<object>} 含 loaded（本次新加载） / order / failed 的加载结果
+   * @throws {TypeError} 参数类型错误时抛出
+   */
+  async load(names, options = {}) {
+    if (!Array.isArray(names)) throw new TypeError('模块名列表必须是数组');
+    if (options === null || typeof options !== 'object') throw new TypeError('options 必须是对象');
+    const fail_fast =
+      options.fail_fast === undefined
+        ? this.config.fail_fast !== false
+        : options.fail_fast !== false;
+    const order = this._sortNamesByGroup(names);
+    const loaded = [];
+    const failed = [];
+    for (const name of order) {
+      try {
+        const is_loaded = await this._loadOne(name);
+        if (is_loaded) loaded.push(name);
+      } catch (error) {
+        if (fail_fast) {
+          await this._rollback(loaded);
+          throw error;
+        }
+        failed.push({ name, error });
+      }
+    }
+    return { loaded, order, failed };
+  }
+
+  /**
+   * 卸载模块：从受管集合移除并触发 disposer（停止实体、清 require 缓存）
+   * @param {string} name 模块名
+   * @returns {Promise<boolean>} 是否卸载了模块
+   * @throws {TypeError} name 不是非空字符串时抛出
+   */
+  async unload(name) {
+    if (typeof name !== 'string' || name.length === 0) {
+      throw new TypeError('模块名必须是非空字符串');
+    }
+    return this.del(name);
+  }
+
+  /**
+   * 静态体检：报出已加载模块中未带发现关键词与未声明合法层级的模块
+   * @returns {object} 含 untagged 与 ungrouped 的体检报告
+   */
+  doctor() {
+    const untagged = [];
+    const ungrouped = [];
+    for (const name of this.keys()) {
+      const manifest = this._readManifest(name);
+      if (manifest === null) continue;
+      const info = _checkSpec(manifest);
+      if (info.ok !== true) untagged.push(name);
+      if (info.group === UNKNOWN_GROUP) ungrouped.push(name);
+    }
+    return { untagged, ungrouped };
+  }
+
+  // ---------- 私有：装载 ----------
+  /**
+   * 装载单个模块：require 入口，导出若为生命周期实体则驱动到运行态，
+   * 随后登记进受管集合并挂 disposer（停止实体、清 require 缓存）
+   * @param {string} name 模块名
+   * @returns {Promise<boolean>} 本次新装载返回 true，已装载幂等跳过返回 false
+   * @throws {Error} 模块未安装、不可解析或实体启动失败时抛出
+   */
+  async _loadOne(name) {
+    if (this.has(name)) return false;
+    const spec = this._inspectLocal(name);
+    if (spec === null) throw new Error(`模块 ${name} 未安装或声明不可解析`);
+    const entry = this._locate(name);
+    if (entry === null) throw new Error(`模块 ${name} 入口无法解析`);
+    const exports = require(entry);
+    const entity = _toEntity(exports);
+    if (entity) await _startEntity(entity);
+    const dispose = async () => {
+      await _stopEntity(entity);
+      delete require.cache[entry];
+    };
+    this.set(name, { spec, exports, entity }, { dispose });
+    this.log('info', `模块已加载：${name}`);
+    return true;
+  }
+
+  /**
+   * 逆序卸载本次新加载的模块，卸载失败不掩盖原始错误
+   * @param {Array} loaded 本次新加载的模块名
+   * @returns {Promise<void>} 无返回值
+   */
+  async _rollback(loaded) {
+    for (let i = loaded.length - 1; i >= 0; i--) {
+      try {
+        await this.del(loaded[i]);
+      } catch {
+        // 回滚失败忽略
+      }
+    }
+  }
+
+  /**
+   * 按层级序稳定排序模块名，层内保持传入顺序
+   * @param {Array} names 模块名列表
+   * @returns {Array} 层级顺序下的模块名
+   */
+  _sortNamesByGroup(names) {
+    const decorated = names.map((name, index) => {
+      const manifest = this._readManifest(name);
+      const group = manifest === null ? UNKNOWN_GROUP : manifest.group;
+      return { name, index, order: _groupOrder(group) };
+    });
+    decorated.sort((a, b) => (a.order !== b.order ? a.order - b.order : a.index - b.index));
+    return decorated.map((item) => item.name);
+  }
+
+  /**
+   * 安装后自动加载，显式关闭时跳过，失败时抛带上下文的错误
+   * @param {string} name 模块名
+   * @param {object} options 安装选项
+   * @returns {Promise<void>} 无返回值
+   * @throws {Error} 自动加载失败时抛出
+   */
+  async _autoLoad(name, options) {
+    if (options.load === false) return;
+    try {
+      await this.load([name], {});
+    } catch (error) {
+      throw new Error(`模块 ${name} 已安装，但自动加载失败：${error.message}`, { cause: error });
+    }
+  }
+
+  // ---------- 私有：清单 ----------
+  /**
+   * 重建本地清单：读宿主依赖声明，逐包定位并校验后灌入 _local
+   * @returns {void}
+   */
+  _rebuildLocal() {
+    this._local.clear();
+    const host = this._readHost();
+    const prod = Object.keys(host.dependencies);
+    const dev = Object.keys(host.devDependencies);
+    const names = prod.concat(dev.filter((item) => prod.indexOf(item) < 0));
+    for (const name of names) {
+      const spec = this._inspectLocal(name);
+      if (spec !== null) this._local.add(spec);
+    }
+  }
+
+  /**
+   * 单个模块的本地清单项，未安装或声明不合规时为 null
+   * @param {string} name 模块名
+   * @returns {object|null} 模块清单项或 null
+   */
+  _inspectLocal(name) {
+    const manifest = this._readManifest(name);
+    if (manifest === null) return null;
+    const keywords = Array.isArray(manifest.keywords) ? manifest.keywords : [];
+    if (keywords.indexOf(this.config.keyword) < 0 && this.config.include_untagged !== true) {
+      return null;
+    }
+    return _readSpec(manifest, { installed: true, path: this._root(name), source: 'local' });
+  }
+
+  /**
+   * 读取宿主 package.json 的依赖声明
+   * @returns {object} 含 dependencies 与 devDependencies 的对象
+   */
+  _readHost() {
+    const host = this._readJson(path.join(this.config.cwd, 'package.json'));
+    if (host === null) return { dependencies: {}, devDependencies: {} };
+    const deps = host.dependencies;
+    const dev = host.devDependencies;
+    return {
+      dependencies: deps && typeof deps === 'object' ? deps : {},
+      devDependencies: dev && typeof dev === 'object' ? dev : {}
+    };
+  }
+
+  /**
+   * 读取 JSON 文件，读取或解析失败时返回 null
+   * @param {string} file 文件绝对路径
+   * @returns {object|null} 解析结果或 null
+   */
+  _readJson(file) {
+    try {
+      return JSON.parse(fs.readFileSync(file, 'utf8'));
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * 用 require.resolve 定位模块入口
+   * @param {string} name 模块名
+   * @returns {string|null} 入口文件路径或 null
+   */
+  _locate(name) {
+    try {
+      return require.resolve(name, { paths: [this.config.cwd] });
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * 由入口向上查找最近的包根目录
+   * @param {string} name 模块名
+   * @returns {string|null} 包根目录或 null
+   */
+  _root(name) {
+    const entry = this._locate(name);
+    if (entry === null) return null;
+    const top = path.parse(entry).root;
+    let dir = path.dirname(entry);
+    while (true) {
+      if (fs.existsSync(path.join(dir, 'package.json'))) return dir;
+      if (dir === top) return null;
+      dir = path.dirname(dir);
+    }
+  }
+
+  /**
+   * 由入口向上查找包描述文件，包名不符视为无声明
+   * @param {string} name 模块名
+   * @returns {object|null} 包描述文件或 null
+   */
+  _readManifest(name) {
+    const root = this._root(name);
+    if (root === null) return null;
+    const manifest = this._readJson(path.join(root, 'package.json'));
+    if (manifest === null || manifest.name !== name) return null;
+    return manifest;
+  }
+
+  // ---------- 私有：命令与转换 ----------
+  /**
+   * 执行 npm 命令，透传实例配置的 cwd / registry / runner
+   * @param {Array} args 命令参数数组
+   * @returns {Promise<string>} 标准输出文本
+   */
+  async _execNpm(args) {
+    return _runNpm(args, {
+      cwd: this.config.cwd,
+      registry: this.config.registry,
+      runner: this.config.runner
+    });
+  }
+
+  /**
+   * 查询远端单模块详情，命令失败或不存在时返回 null
+   * @param {string} name 模块名
+   * @returns {Promise<object|null>} 模块清单项或 null
+   */
+  async _view(name) {
+    try {
+      const row = _parseObject(await this._execNpm(['view', name, '--json']));
+      return this._toSpec(row, false);
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * 把 npm 记录转换为模块清单项
+   * @param {object} row npm 返回的单条记录
+   * @param {boolean} require_keyword 是否强制要求命中发现关键词
+   * @returns {object|null} 模块清单项，不合规时为 null
+   */
+  _toSpec(row, require_keyword) {
+    if (row === null || typeof row !== 'object') return null;
+    if (typeof row.name !== 'string' || row.name.length === 0) return null;
+    const keywords = Array.isArray(row.keywords) ? row.keywords : [];
+    if (require_keyword === true && keywords.indexOf(this.config.keyword) < 0) return null;
+    const links = row.links && typeof row.links === 'object' ? row.links : {};
+    const manifest = {
+      name: row.name,
+      version: row.version,
+      description: row.description,
+      group: row.group,
+      isolation: row.isolation,
+      keywords,
+      homepage: row.homepage || links.homepage,
+      repository: row.repository || links.repository
+    };
+    return _readSpec(manifest, { installed: false, path: null, source: 'remote' });
+  }
+
+  /**
+   * 组装检索词：关键词为空时仅用前缀，已带前缀时原样，否则前缀拼接
+   * @param {string} keyword 检索关键词
+   * @returns {string} 实际检索词
+   */
+  _buildQuery(keyword) {
+    const prefix = this.config.prefix;
+    if (keyword.length === 0) return prefix;
+    if (prefix.length > 0 && keyword.indexOf(prefix) === 0) return keyword;
+    return prefix + keyword;
+  }
+
+  /**
+   * 模块名是否命中配置前缀，前缀为空时恒为真
+   * @param {string} name 模块名
+   * @returns {boolean} 命中返回 true
+   */
+  _hasPrefix(name) {
+    const prefix = this.config.prefix;
+    if (prefix.length === 0) return true;
+    return typeof name === 'string' && name.indexOf(prefix) === 0;
+  }
+
+  /**
+   * 组装安装目标，带版本时拼成 name@version
+   * @param {string} name 模块名
+   * @param {object} options 安装选项
+   * @returns {string} 安装目标
+   */
+  _target(name, options) {
+    return typeof options.version === 'string' && options.version.length > 0
+      ? `${name}@${options.version}`
+      : name;
+  }
+
+  /**
+   * 校验远端模块是否可安装，不通过时抛错
+   * @param {object|null} remote 远端清单项
+   * @param {string} name 模块名
+   * @param {object} options 安装选项
+   * @returns {void}
+   * @throws {Error} 模块不存在或未声明关键词时抛出
+   */
+  _assertInstallable(remote, name, options) {
+    if (options.force === true) return;
+    if (remote === null) throw new Error(`模块 ${name} 不存在或无法访问`);
+    if (remote.keywords.indexOf(this.config.keyword) < 0) {
+      throw new Error(`模块 ${name} 未声明 ${this.config.keyword} 关键词，拒绝安装`);
+    }
+  }
+}
+
+module.exports = ModuleManager;

package/lib/npm_channel.js

@@ -0,0 +1,123 @@
+/**
+ * npm 命令通道
+ * 统一执行 npm 子进程命令（Windows 经 cmd.exe 调起），支持 runner 注入以适配测试与定制场景；
+ * 并提供 npm search / view 的 JSON 输出解析，全部为无实例状态的纯过程
+ */
+
+const { execFile } = require('child_process');
+
+// npm 默认可执行文件
+const DEFAULT_BIN = 'npm';
+
+// 子进程超时毫秒
+const DEFAULT_TIMEOUT = 120000;
+
+// 子进程输出上限字节
+const MAX_BUFFER = 10485760;
+
+/**
+ * 组装 npm 执行计划，Windows 下经 cmd.exe 调起
+ * @param {Array} args 命令参数数组
+ * @returns {object} 含 file / args / verbatim 的执行计划
+ */
+function _npmPlan(args) {
+  if (process.platform === 'win32') {
+    const head = ['/d', '/s', '/c', DEFAULT_BIN];
+    return { file: 'cmd.exe', args: head.concat(args), verbatim: true };
+  }
+  return { file: DEFAULT_BIN, args, verbatim: false };
+}
+
+/**
+ * 用 execFile 执行 npm 命令，退出码非 0 时抛错
+ * @param {Array} args 命令参数数组
+ * @param {object} options 执行选项，含 cwd
+ * @returns {Promise<string>} 标准输出文本
+ */
+function _execNpmFile(args, options) {
+  const plan = _npmPlan(args);
+  const exec_options = {
+    cwd: typeof options.cwd === 'string' ? options.cwd : process.cwd(),
+    timeout: DEFAULT_TIMEOUT,
+    maxBuffer: MAX_BUFFER,
+    windowsVerbatimArguments: plan.verbatim,
+    windowsHide: true
+  };
+  return new Promise((resolve, reject) => {
+    execFile(plan.file, plan.args, exec_options, (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error(`执行 npm 命令失败：${stderr || error.message}`));
+        return;
+      }
+      resolve(String(stdout));
+    });
+  });
+}
+
+/**
+ * npm 命令通道：runner 为函数时注入执行（测试与定制场景），否则走 execFile
+ * @param {Array} args 命令参数数组
+ * @param {object} options 执行选项，含 cwd / registry / runner
+ * @returns {Promise<string>} 标准输出文本
+ * @throws {TypeError} args 不是数组时抛出
+ */
+async function _runNpm(args, options = {}) {
+  if (!Array.isArray(args)) {
+    throw new TypeError('命令参数必须是数组');
+  }
+  const full = args.slice();
+  if (typeof options.registry === 'string' && options.registry.length > 0) {
+    full.push(`--registry=${options.registry}`);
+  }
+  if (typeof options.runner === 'function') {
+    const result = (await options.runner(full, { cwd: options.cwd })) || {};
+    return typeof result.stdout === 'string' ? result.stdout : '';
+  }
+  return _execNpmFile(full, options);
+}
+
+/**
+ * 解析 npm search 的 JSON 输出
+ * @param {string} text 命令输出
+ * @returns {Array} 记录数组，无法解析时为空数组
+ */
+function _parseRows(text) {
+  const raw = String(text);
+  const start = raw.indexOf('[');
+  const end = raw.lastIndexOf(']');
+  const body = start >= 0 && end > start ? raw.slice(start, end + 1) : raw;
+  try {
+    const rows = JSON.parse(body);
+    return Array.isArray(rows) ? rows : [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * 解析 npm view 的 JSON 输出
+ * @param {string} text 命令输出
+ * @returns {object|null} 记录对象，无法解析时为 null
+ */
+function _parseObject(text) {
+  const raw = String(text);
+  const start = raw.indexOf('{');
+  const end = raw.lastIndexOf('}');
+  if (start < 0 || end <= start) return null;
+  try {
+    return JSON.parse(raw.slice(start, end + 1));
+  } catch {
+    return null;
+  }
+}
+
+module.exports = {
+  DEFAULT_BIN,
+  DEFAULT_TIMEOUT,
+  MAX_BUFFER,
+  _npmPlan,
+  _execNpmFile,
+  _runNpm,
+  _parseRows,
+  _parseObject
+};

package/lib/spec.js

@@ -0,0 +1,231 @@
+/**
+ * 模块清单规范
+ * 领域协议常量（发现关键词、模块前缀、合法层级）与包描述/清单项的纯函数：
+ * 归一化、合法性校验、条件过滤、层级分组、层级排序与版本号比较，不依赖任何实例状态
+ */
+
+// 模块发现关键词：npm 检索命中依据，也是模块声明合法性的唯一判定
+const KEYWORD = 'mm_mod';
+
+// 模块名前缀默认值，可经 config.prefix 配置；检索只命中该前缀开头的模块
+const DEFAULT_PREFIX = 'mm_';
+
+// 合法层级，值域顺序即加载顺序
+const GROUPS = [
+  'tool',
+  'infra',
+  'in_port',
+  'in_adapter',
+  'channel',
+  'service',
+  'domain',
+  'database',
+  'out_adapter',
+  'out_port'
+];
+
+// 未声明或声明非法层级时归入的层级，加载顺序排在全部合法层级之后
+const UNKNOWN_GROUP = 'unknown';
+
+/**
+ * 把任意值归一化为数组，非数组一律补空数组
+ * @param {any} value 待归一化的值
+ * @returns {Array} 归一化后的数组
+ */
+function _toArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+/**
+ * 把任意值归一化为字符串，空串与非字符串一律补 null
+ * @param {any} value 待归一化的值
+ * @returns {string|null} 字符串或 null
+ */
+function _toText(value) {
+  return typeof value === 'string' && value.length > 0 ? value : null;
+}
+
+/**
+ * 从 repository 字段提取仓库地址
+ * @param {string|object} repo repository 字段值
+ * @returns {string|null} 仓库地址或 null
+ */
+function _repoUrl(repo) {
+  if (typeof repo === 'string') return repo;
+  if (repo && typeof repo.url === 'string') return repo.url;
+  return null;
+}
+
+/**
+ * 判定模块层级，未声明或声明非法时归入 unknown
+ * @param {object} manifest 包描述文件
+ * @returns {string} 层级名
+ */
+function _groupOf(manifest) {
+  return GROUPS.indexOf(manifest.group) >= 0 ? manifest.group : UNKNOWN_GROUP;
+}
+
+/**
+ * 解出层级的加载序号，未声明或声明非法时排在最后
+ * @param {string} group 层级名
+ * @returns {number} 层级序号，从 0 起
+ */
+function _groupOrder(group) {
+  const idx = GROUPS.indexOf(group);
+  return idx < 0 ? GROUPS.length : idx;
+}
+
+/**
+ * 文本是否命中模块的名称、描述或关键词
+ * @param {object} spec 模块清单项
+ * @param {string} text 检索文本
+ * @returns {boolean} 命中返回 true
+ */
+function _matchText(spec, text) {
+  const hay = [_toText(spec.name), _toText(spec.description)]
+    .concat(_toArray(spec.keywords))
+    .filter((item) => typeof item === 'string')
+    .join(' ')
+    .toLowerCase();
+  return hay.indexOf(String(text).toLowerCase()) >= 0;
+}
+
+/**
+ * 把包描述文件归一化为模块清单项
+ * @param {object} manifest 包描述文件
+ * @param {object} extra 覆盖字段，支持 installed / path / source
+ * @returns {object} 模块清单项
+ * @throws {TypeError} manifest 不是对象时抛出
+ */
+function _readSpec(manifest, extra = {}) {
+  if (manifest === null || typeof manifest !== 'object') {
+    throw new TypeError('manifest 必须是对象');
+  }
+  return {
+    name: _toText(manifest.name),
+    version: _toText(manifest.version),
+    description: _toText(manifest.description),
+    group: _groupOf(manifest),
+    isolation: _toText(manifest.isolation),
+    keywords: _toArray(manifest.keywords),
+    homepage: _toText(manifest.homepage) || _toText(_repoUrl(manifest.repository)),
+    installed: extra.installed === true,
+    path: _toText(extra.path),
+    source: extra.source === 'remote' ? 'remote' : 'local'
+  };
+}
+
+/**
+ * 校验模块是否按要求声明了发现关键词
+ * @param {object} manifest 包描述文件
+ * @returns {object} 校验结果，含 ok / missing / group
+ * @throws {TypeError} manifest 不是对象时抛出
+ */
+function _checkSpec(manifest) {
+  if (manifest === null || typeof manifest !== 'object') {
+    throw new TypeError('manifest 必须是对象');
+  }
+  const keywords = _toArray(manifest.keywords);
+  const ok = keywords.indexOf(KEYWORD) >= 0;
+  return {
+    ok,
+    missing: ok ? [] : [KEYWORD],
+    group: _groupOf(manifest)
+  };
+}
+
+/**
+ * 按条件过滤模块清单项，条件为 undefined 时不参与
+ * @param {object} spec 模块清单项
+ * @param {object} filter 过滤条件，支持 group / installed / isolation / keyword / text
+ * @returns {boolean} 命中返回 true
+ * @throws {TypeError} spec 或 filter 类型错误时抛出
+ */
+function _matchSpec(spec, filter = {}) {
+  if (spec === null || typeof spec !== 'object') {
+    throw new TypeError('spec 必须是对象');
+  }
+  if (filter === null || typeof filter !== 'object') {
+    throw new TypeError('filter 必须是对象');
+  }
+  if (filter.group !== undefined && spec.group !== filter.group) return false;
+  if (filter.installed !== undefined && spec.installed !== filter.installed) return false;
+  if (filter.isolation !== undefined && spec.isolation !== filter.isolation) return false;
+  if (filter.keyword !== undefined && _toArray(spec.keywords).indexOf(filter.keyword) < 0) {
+    return false;
+  }
+  if (filter.text !== undefined && !_matchText(spec, filter.text)) return false;
+  return true;
+}
+
+/**
+ * 按层级分组模块清单项
+ * @param {Array} specs 模块清单项数组
+ * @returns {object} 层级到清单项数组的映射
+ * @throws {TypeError} specs 不是数组时抛出
+ */
+function _groupSpecs(specs) {
+  if (!Array.isArray(specs)) {
+    throw new TypeError('specs 必须是数组');
+  }
+  const groups = {};
+  for (const key of GROUPS) groups[key] = [];
+  groups[UNKNOWN_GROUP] = [];
+  for (const spec of specs) {
+    if (spec === null || typeof spec !== 'object') continue;
+    const key = GROUPS.indexOf(spec.group) >= 0 ? spec.group : UNKNOWN_GROUP;
+    groups[key].push(spec);
+  }
+  return groups;
+}
+
+/**
+ * 按层级序与模块名排序
+ * @param {Array} specs 模块清单项数组
+ * @returns {Array} 排序后的新数组
+ */
+function _sortedSpecs(specs) {
+  return specs.slice().sort((a, b) => {
+    const a_order = _groupOrder(a.group);
+    const b_order = _groupOrder(b.group);
+    if (a_order !== b_order) return a_order - b_order;
+    return String(a.name).localeCompare(String(b.name));
+  });
+}
+
+/**
+ * 版本号逐段数值比较，candidate 大于 current 时返回 true
+ * @param {string} candidate 候选版本号
+ * @param {string} current 当前版本号
+ * @returns {boolean} 候选是否更新
+ */
+function _isVersionNewer(candidate, current) {
+  const a = String(candidate || '').split('.');
+  const b = String(current || '').split('.');
+  const len = Math.max(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    const a_num = parseInt(a[i], 10) || 0;
+    const b_num = parseInt(b[i], 10) || 0;
+    if (a_num !== b_num) return a_num > b_num;
+  }
+  return false;
+}
+
+module.exports = {
+  KEYWORD,
+  DEFAULT_PREFIX,
+  GROUPS,
+  UNKNOWN_GROUP,
+  _toArray,
+  _toText,
+  _repoUrl,
+  _groupOf,
+  _groupOrder,
+  _matchText,
+  _readSpec,
+  _checkSpec,
+  _matchSpec,
+  _groupSpecs,
+  _sortedSpecs,
+  _isVersionNewer
+};

package/package.json

@@ -1,53 +1,58 @@
 {
-  "name": "mm_module",
-  "version": "1.0.2",
-  "description": "内核模块管理框架件：基于 npm 实现模块的搜索、安装、卸载与清单编排，并按声明的层级分层装载与声明体检（不注册能力）",
-  "main": "./index.js",
-  "exports": {
-    ".": "./index.js",
-    "./package.json": "./package.json"
-  },
-  "files": [
-    "index.js",
-    "src/"
-  ],
-  "scripts": {
-    "test": "jest --passWithNoTests --maxWorkers=1 2>&1",
-    "lint": "eslint src/ test/ index.js --fix",
-    "check": "eslint src/ test/ index.js",
-    "format": "prettier --write \"src/**/*.js\" \"test/**/*.js\" \"*.js\" \"*.json\"",
-    "demo": "node example/demo.js"
-  },
-  "keywords": [
-    "mm_mod",
-    "mm_kernel",
-    "module",
-    "npm",
-    "install",
-    "uninstall",
-    "manager",
-    "catalog"
-  ],
-  "engines": {
-    "node": ">=18"
-  },
-  "dependencies": {
-    "mm_corejs": "file:../mm_corejs"
-  },
-  "devDependencies": {
-    "@eslint/js": "^10.0.1",
-    "eslint": "^10.9.1",
-    "jest": "^30.4.2",
-    "prettier": "^3.9.8"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/mm-modules/mm_module.git"
-  },
-  "homepage": "https://github.com/mm-modules/mm_module#readme",
-  "bugs": {
-    "url": "https://github.com/mm-modules/mm_module/issues"
-  },
-  "author": "qww",
-  "license": "MIT"
+    "name": "mm_module",
+    "version": "1.0.4",
+    "description": "内核模块管理框架件：基于 npm 实现模块的搜索、安装、卸载与清单编排，并按声明的层级分层装载与声明体检（不注册能力）",
+    "main": "./index.js",
+    "exports": {
+        ".": "./index.js",
+        "./package.json": "./package.json"
+    },
+    "files": [
+        "index.js",
+        "lib/"
+    ],
+    "scripts": {
+        "test": "jest --passWithNoTests --maxWorkers=1 2>&1",
+        "lint": "eslint lib/ test/ index.js --fix",
+        "check": "eslint lib/ test/ index.js",
+        "format": "prettier --write \"lib/**/*.js\" \"test/**/*.js\" \"*.js\" \"*.json\"",
+        "demo": "node example/demo.js"
+    },
+    "keywords": [
+        "mm_mod",
+        "mm_infra",
+        "mm_runtime",
+        "mm_kernel",
+        "module",
+        "npm",
+        "install",
+        "uninstall",
+        "manager",
+        "catalog"
+    ],
+    "layer": "crosscut",
+    "group": "runtime",
+    "engines": {
+        "node": ">=18"
+    },
+    "dependencies": {
+        "mm_corejs": "^1.1.4",
+        "mm_mod": "^1.0.1"
+    },
+    "devDependencies": {
+        "@eslint/js": "^10.0.1",
+        "eslint": "^10.9.1",
+        "jest": "^30.4.2",
+        "prettier": "^3.9.8"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://gitee.com/qiuwenwu91/mm_module.git"
+    },
+    "homepage": "https://github.com/mm-modules/mm_module#readme",
+    "bugs": {
+        "url": "https://github.com/mm-modules/mm_module/issues"
+    },
+    "author": "qww",
+    "license": "MIT"
 }