localmono 0.1.0

package/README.md

@@ -0,0 +1,313 @@
+<div align="center">
+
+# mono
+
+**🚀 Zero-intrusion Monorepo Development Tool**
+
+**Use TypeScript source code directly, no build required, no project restructuring needed**
+
+[![npm version](https://img.shields.io/npm/v/mono.svg?style=flat-square)](https://www.npmjs.com/package/mono)
+[![license](https://img.shields.io/npm/l/mono.svg?style=flat-square)](./LICENSE)
+[![node version](https://img.shields.io/node/v/mono.svg?style=flat-square)](https://nodejs.org)
+
+[English](./README.md) · [简体中文](./README.zh-CN.md)
+
+</div>
+
+---
+
+## � Why mono?
+
+### Zero Intrusion - Keep Your Project Clean
+
+**Are you frustrated with:**
+- ❌ Converting your npm project to pnpm workspace
+- ❌ Dealing with `workspace:*` protocol complexities
+- ❌ Creating workspace configuration files
+- ❌ Restructuring your project for monorepo tools
+
+**With mono:**
+- ✅ **Zero Configuration** - No new files, works with any npm project
+- ✅ **Non-Invasive** - Your project stays a clean npm project
+- ✅ **Drop-in Replacement** - Use like `node` or `tsx`: `mono xxx.ts`
+- ✅ **Auto Discovery** - Automatically finds local packages
+- ✅ **Simple Config** - Optional `local` field in `package.json`, defaults to `./src/index.ts`
+
+### Traditional vs mono
+
+| Approach | Steps Required |
+|----------|---------------|
+| **pnpm workspace** | 1. Convert to pnpm<br/>2. Create `pnpm-workspace.yaml`<br/>3. Use `workspace:*` protocol<br/>4. Restructure project<br/>5. Build packages |
+| **npm link** | 1. Link each package manually<br/>2. Build packages<br/>3. Rebuild on every change |
+| **mono** ✨ | `mono ./src/index.ts` - **that's it!** |
+
+---
+
+## ✨ Key Features
+
+- 🎯 **Zero Intrusion** - No project restructuring, no configuration files
+- 🔍 **Auto Discovery** - Recursively scans and finds all local packages
+- 📦 **Package Manager Agnostic** - Works with npm, yarn, pnpm, bun
+- ⚡️ **Instant Reload** - Changes take effect immediately
+- 🛠️ **Zero Config** - Default `./src/index.ts`, optional `local` field for custom paths
+- 🌐 **ESM Only** - Built for modern JavaScript (`type: "module"`)
+- 📝 **Config File** - Auto-generates `.mono/monoConfig.json` for debugging
+
+---
+
+## 📦 Installation
+
+### Global Installation (Recommended)
+
+```bash
+npm install -g mono
+```
+
+### Requirements
+
+- **Node.js** >= 18.19.0
+- **ESM Projects** - Your `package.json` must have `"type": "module"`
+
+---
+
+## 🚀 Quick Start
+
+### Basic Usage - Just Like `node` or `tsx`
+
+```bash
+# Run TypeScript file directly
+mono ./src/index.ts
+
+# Run with parameters
+mono ./src/index.ts --port 3000
+
+# Enable debug mode
+mono ./src/index.ts debug
+```
+
+### Use in package.json
+
+```json
+{
+  "type": "module",
+  "scripts": {
+    "dev": "mono ./node_modules/vite/bin/vite.js",
+    "start": "mono ./src/index.ts"
+  }
+}
+```
+
+**That's it!** No workspace configuration, no project restructuring.
+
+---
+
+## 📚 How It Works
+
+### 1. Auto Package Discovery
+
+```
+Find farthest project root upward (.idea/.vscode/.git/package.json)
+  └── Recursive Scan
+      └── Find all package.json
+          └── Register by "name" field
+```
+
+### 2. Import Interception
+
+```javascript
+// Your code
+import { utils } from 'my-utils'
+
+// mono automatically redirects to source
+// → /path/to/my-utils/src/index.ts
+```
+
+### 3. Default Convention
+
+- **Default Entry**: `./src/index.ts` for all packages
+- **No Config Needed**: Works out of the box
+
+### 4. Optional Custom Entry
+
+If you need a different entry point, add `local` field:
+
+```json
+{
+  "name": "my-package",
+  "local": "./src/main.ts"
+}
+```
+
+---
+
+## ⚙️ Configuration
+
+### Zero Config (Recommended)
+
+Just use default `./src/index.ts`:
+
+```json
+{
+  "name": "my-package",
+  "type": "module"
+  // No extra config needed!
+}
+```
+
+### Custom Entry Point (Optional)
+
+Add `local` field for custom paths:
+
+```json
+{
+  "name": "@my-org/utils",
+  "type": "module",
+  "local": "./src/custom-entry.ts"
+}
+```
+
+**That's all the configuration you need!** Your project remains a standard npm project.
+
+---
+
+## 🐛 Debugging
+
+Five debug formats supported, parameter can be anywhere:
+
+```bash
+# Before file
+mono --debug ./src/index.ts
+mono -debug ./src/index.ts
+mono -d ./src/index.ts
+
+# After file (Recommended)
+mono ./src/index.ts debug
+mono ./src/index.ts d
+```
+
+Or use environment variable:
+
+```bash
+# Linux/macOS
+MONO_DEBUG=1 mono ./src/index.ts
+
+# Windows PowerShell  
+$env:MONO_DEBUG='1'; mono ./src/index.ts
+```
+
+Debug logs output to:
+- Console
+- `mono-debug.log` file
+
+---
+
+## 📋 Common Use Cases
+
+### With Vite
+
+```json
+{
+  "type": "module",
+  "scripts": {
+    "dev": "mono ./node_modules/vite/bin/vite.js"
+  }
+}
+```
+
+### With Webpack
+
+```json
+{
+  "type": "module",
+  "scripts": {
+    "dev": "mono ./node_modules/webpack/bin/webpack.js serve"
+  }
+}
+```
+
+### Custom Build Scripts
+
+```json
+{
+  "type": "module",
+  "scripts": {
+    "build": "mono ./scripts/build.ts",
+    "codegen": "mono ./scripts/codegen.ts"
+  }
+}
+```
+
+---
+
+## ❓ FAQ
+
+### Q: Why not use pnpm workspace?
+
+**A:** pnpm workspace requires:
+- Converting to pnpm
+- Creating `pnpm-workspace.yaml`
+- Using `workspace:*` protocol
+- Restructuring project
+
+**mono** requires: nothing! Keep your npm project as-is.
+
+### Q: Why not use npm link?
+
+**A:** 
+| Feature | mono | npm link |
+|---------|------|----------|
+| Setup | ✅ None | ❌ Manual per package |
+| TypeScript | ✅ Direct source | ❌ Requires build |
+| Hot Reload | ✅ Instant | ❌ Rebuild needed |
+
+### Q: Does it modify my package.json?
+
+**A:** No! The `local` field is optional. Your package.json stays clean.
+
+### Q: What if I don't add `local` field?
+
+**A:** It defaults to `./src/index.ts`. No configuration needed!
+
+### Q: Will it affect production builds?
+
+**A:** No. `mono` is for development only. Production uses `node_modules`.
+
+---
+
+## 🔧 Technical Details
+
+- **ESM Loader Hooks** - Uses Node.js native module resolution API
+- **TypeScript Compiler** - Powered by `tsx` for latest syntax support
+- **Zero Dependencies** - Only 2 runtime deps: `tsx` and `cross-spawn`
+
+### ESM Only
+
+`mono` requires `"type": "module"` in your `package.json`:
+
+```json
+{
+  "type": "module"
+}
+```
+
+---
+
+## 📄 License
+
+MIT © [alamhubb](https://github.com/alamhubb)
+
+---
+
+## 🔗 Related
+
+- [vite-plugin-mono](../vite-plugin-mono) - Vite plugin for browser-side source development
+
+---
+
+<div align="center">
+
+Made with ❤️ by [alamhubb](https://github.com/alamhubb)
+
+[Report Bug](https://github.com/alamhubb/mono/issues) · [Request Feature](https://github.com/alamhubb/mono/issues)
+
+</div>

package/README.zh-CN.md

@@ -0,0 +1,313 @@
+<div align="center">
+
+# mono
+
+**🚀 零侵入式 Monorepo 开发工具**
+
+**直接使用 TypeScript 源码开发，无需构建，无需改造项目**
+
+[![npm version](https://img.shields.io/npm/v/mono.svg?style=flat-square)](https://www.npmjs.com/package/mono)
+[![license](https://img.shields.io/npm/l/mono.svg?style=flat-square)](./LICENSE)
+[![node version](https://img.shields.io/node/v/mono.svg?style=flat-square)](https://nodejs.org)
+
+[English](./README.md) · [简体中文](./README.zh-CN.md)
+
+</div>
+
+---
+
+## 💡 为什么选择 mono？
+
+### 零侵入 - 保持项目干净
+
+**你是否曾为这些烦恼：**
+- ❌ 需要将 npm 项目转换为 pnpm workspace
+- ❌ 处理 `workspace:*` 协议的复杂性
+- ❌ 创建各种 workspace 配置文件
+- ❌ 为了 monorepo 工具而重构项目结构
+
+**使用 mono：**
+- ✅ **零配置** - 不创建任何新文件，兼容任何 npm 项目
+- ✅ **无侵入** - 你的项目依然是一个干净的 npm 项目
+- ✅ **即插即用** - 像使用 `node` 或 `tsx` 一样使用：`mono xxx.ts`
+- ✅ **自动发现** - 自动查找本地包
+- ✅ **简单配置** - 可选的 `local` 字段，默认 `./src/index.ts`
+
+### 传统方式 vs mono
+
+| 方式 | 需要的步骤 |
+|------|-----------|
+| **pnpm workspace** | 1. 转换为 pnpm<br/>2. 创建 `pnpm-workspace.yaml`<br/>3. 使用 `workspace:*` 协议<br/>4. 重构项目结构<br/>5. 构建包 |
+| **npm link** | 1. 手动链接每个包<br/>2. 构建包<br/>3. 每次修改都要重新构建 |
+| **mono** ✨ | `mono ./src/index.ts` - **就这么简单！** |
+
+---
+
+## ✨ 核心特性
+
+- 🎯 **零侵入** - 无需重构项目，无需配置文件
+- 🔍 **自动发现** - 递归扫描并找到所有本地包
+- 📦 **包管理器无关** - 兼容 npm、yarn、pnpm、bun
+- ⚡️ **即时加载** - 修改立即生效  
+- 🛠️ **零配置** - 默认 `./src/index.ts`，可选 `local` 字段自定义路径
+- 🌐 **仅支持 ESM** - 为现代 JavaScript 设计（`type: "module"`）
+- 📝 **配置文件** - 自动生成 `.mono/monoConfig.json` 用于调试
+
+---
+
+## 📦 安装
+
+### 全局安装（推荐）
+
+```bash
+npm install -g mono
+```
+
+### 环境要求
+
+- **Node.js** >= 18.19.0  
+- **ESM 项目** - 你的 `package.json` 必须包含 `"type": "module"`
+
+---
+
+## 🚀 快速开始
+
+### 基本用法 - 就像 `node` 或 `tsx` 一样
+
+```bash
+# 直接运行 TypeScript 文件
+mono ./src/index.ts
+
+# 带参数运行
+mono ./src/index.ts --port 3000
+
+# 开启调试模式
+mono ./src/index.ts debug
+```
+
+### 在 package.json 中使用
+
+```json
+{
+  "type": "module",
+  "scripts": {
+    "dev": "mono ./node_modules/vite/bin/vite.js",
+    "start": "mono ./src/index.ts"
+  }
+}
+```
+
+**就这样！** 无需 workspace 配置，无需重构项目。
+
+---
+
+## 📚 工作原理
+
+### 1. 自动包发现
+
+```
+直线向上查找距离最远的项目根目录 (.idea/.vscode/.git/package.json)
+  └── 递归扫描
+      └── 查找所有 package.json
+          └── 根据 "name" 字段注册
+```
+
+### 2. 导入拦截
+
+```javascript
+// 你的代码
+import { utils } from 'my-utils'
+
+// mono 自动重定向到源码
+// → /path/to/my-utils/src/index.ts
+```
+
+### 3. 默认约定
+
+- **默认入口**：所有包默认 `./src/index.ts`
+- **无需配置**：开箱即用
+
+### 4. 可选的自定义入口
+
+如果需要不同的入口点，添加 `local` 字段：
+
+```json
+{
+  "name": "my-package",
+  "local": "./src/main.ts"
+}
+```
+
+---
+
+## ⚙️ 配置
+
+### 零配置（推荐）
+
+直接使用默认的 `./src/index.ts`：
+
+```json
+{
+  "name": "my-package",
+  "type": "module"
+  // 无需额外配置！
+}
+```
+
+### 自定义入口（可选）
+
+添加 `local` 字段指定自定义路径：
+
+```json
+{
+  "name": "@my-org/utils",
+  "type": "module",
+  "local": "./src/custom-entry.ts"
+}
+```
+
+**这就是你需要的全部配置！** 你的项目依然是标准的 npm 项目。
+
+---
+
+## 🐛 调试
+
+支持 5 种调试格式，参数可以放在任意位置：
+
+```bash
+# 参数在文件前面
+mono --debug ./src/index.ts
+mono -debug ./src/index.ts
+mono -d ./src/index.ts
+
+# 参数在文件后面（推荐）
+mono ./src/index.ts debug
+mono ./src/index.ts d
+```
+
+或使用环境变量：
+
+```bash
+# Linux/macOS
+MONO_DEBUG=1 mono ./src/index.ts
+
+# Windows PowerShell  
+$env:MONO_DEBUG='1'; mono ./src/index.ts
+```
+
+调试日志输出到：
+- 控制台
+- `mono-debug.log` 文件
+
+---
+
+## 📋 常见使用场景
+
+### 配合 Vite
+
+```json
+{
+  "type": "module",
+  "scripts": {
+    "dev": "mono ./node_modules/vite/bin/vite.js"
+  }
+}
+```
+
+### 配合 Webpack
+
+```json
+{
+  "type": "module",
+  "scripts": {
+    "dev": "mono ./node_modules/webpack/bin/webpack.js serve"
+  }
+}
+```
+
+### 自定义构建脚本
+
+```json
+{
+  "type": "module",
+  "scripts": {
+    "build": "mono ./scripts/build.ts",
+    "codegen": "mono ./scripts/codegen.ts"
+  }
+}
+```
+
+---
+
+## ❓ 常见问题
+
+### Q: 为什么不用 pnpm workspace？
+
+**A:** pnpm workspace 需要：
+- 转换为 pnpm
+- 创建 `pnpm-workspace.yaml`
+- 使用 `workspace:*` 协议
+- 重构项目结构
+
+**mono** 需要：什么都不需要！保持你的 npm 项目原样。
+
+### Q: 为什么不用 npm link？
+
+**A:**  
+| 特性 | mono | npm link |
+|------|------|----------|
+| 设置 | ✅ 无需设置 | ❌ 每个包都要手动链接 |
+| TypeScript | ✅ 直接使用源码 | ❌ 需要构建 |
+| 热更新 | ✅ 即时生效 | ❌ 需要重新构建 |
+
+### Q: 它会修改我的 package.json 吗？
+
+**A:** 不会！`local` 字段是可选的。你的 package.json 保持干净。
+
+### Q: 如果我不添加 `local` 字段呢？
+
+**A:** 默认使用 `./src/index.ts`。无需任何配置！
+
+### Q: 会影响生产构建吗？
+
+**A:** 不会。`mono` 仅用于开发。生产环境使用 `node_modules`。
+
+---
+
+## 🔧 技术细节
+
+- **ESM Loader Hooks** - 使用 Node.js 原生模块解析 API
+- **TypeScript 编译器** - 基于 `tsx`，支持最新语法
+- **零依赖** - 仅 2 个运行时依赖：`tsx` 和 `cross-spawn`
+
+### 仅支持 ESM
+
+`mono` 要求 `package.json` 中包含 `"type": "module"`：
+
+```json
+{
+  "type": "module"
+}
+```
+
+---
+
+## 📄 License
+
+MIT © [alamhubb](https://github.com/alamhubb)
+
+---
+
+## 🔗 相关项目
+
+- [vite-plugin-mono](../vite-plugin-mono) - 用于浏览器端源码开发的 Vite 插件
+
+---
+
+<div align="center">
+
+Made with ❤️ by [alamhubb](https://github.com/alamhubb)
+
+[报告 Bug](https://github.com/alamhubb/mono/issues) · [请求功能](https://github.com/alamhubb/mono/issues)
+
+</div>

package/bin/mono.mjs

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+
+/**
+ * mono CLI 入口
+ * 
+ * 命令:
+ * - mono <file>        运行 TypeScript 文件，注入自定义 loader
+ * - mono --debug <file> 开启调试模式运行
+ * - mono i             递归安装所有嵌套 monorepo 的依赖
+ * 
+ * loader.mjs 会自动：
+ * 1. 注册 tsx ESM loader（TypeScript 支持）
+ * 2. 注册 mono resolve hooks（包名拦截）
+ */
+
+import spawn from 'cross-spawn';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { dirname, join, resolve } from 'node:path';
+import { readFileSync, existsSync, readdirSync } from 'node:fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * 获取 loader 文件路径（file:// URL 格式）
+ */
+function getLoaderUrl() {
+    const loaderPath = join(__dirname, '..', 'src', 'loader.mjs');
+    return pathToFileURL(loaderPath).href;
+}
+
+/**
+ * 递归查找所有嵌套的 monorepo 目录
+ */
+function findAllMonorepos(startDir) {
+    const monorepos = [];
+
+    function scanDir(dir) {
+        const pkgPath = join(dir, 'package.json');
+
+        if (existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+
+                // 如果有 workspaces 配置，这是一个 monorepo
+                if (pkg.workspaces) {
+                    monorepos.push(dir);
+
+                    // 继续查找嵌套的 workspace
+                    let patterns = [];
+                    if (Array.isArray(pkg.workspaces)) {
+                        patterns = pkg.workspaces;
+                    } else if (pkg.workspaces?.packages) {
+                        patterns = pkg.workspaces.packages;
+                    }
+
+                    for (const pattern of patterns) {
+                        const dirs = findMatchingDirs(dir, pattern);
+                        for (const subDir of dirs) {
+                            scanDir(subDir);
+                        }
+                    }
+                }
+            } catch {
+                // 忽略解析错误
+            }
+        }
+    }
+
+    scanDir(startDir);
+    return monorepos;
+}
+
+/**
+ * 查找匹配 pattern 的目录
+ */
+function findMatchingDirs(root, pattern) {
+    const dirs = [];
+
+    if (pattern.endsWith('/*')) {
+        const baseDir = join(root, pattern.slice(0, -2));
+        if (existsSync(baseDir)) {
+            const entries = readdirSync(baseDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory() && entry.name !== 'node_modules') {
+                    dirs.push(join(baseDir, entry.name));
+                }
+            }
+        }
+    } else if (pattern.endsWith('/**')) {
+        const baseDir = join(root, pattern.slice(0, -3));
+        findDirsRecursive(baseDir, dirs);
+    } else {
+        const dir = join(root, pattern);
+        if (existsSync(dir)) {
+            dirs.push(dir);
+        }
+    }
+
+    return dirs;
+}
+
+/**
+ * 递归查找目录
+ */
+function findDirsRecursive(dir, result) {
+    if (!existsSync(dir)) return;
+
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory() && entry.name !== 'node_modules') {
+            const subDir = join(dir, entry.name);
+            result.push(subDir);
+            findDirsRecursive(subDir, result);
+        }
+    }
+}
+
+/**
+ * 在指定目录执行 npm install
+ */
+async function runNpmInstall(dir) {
+    return new Promise((resolve, reject) => {
+        console.log(`\n[mono i] Installing in: ${dir}`);
+
+        const child = spawn('npm', ['install'], {
+            cwd: dir,
+            stdio: 'inherit'
+        });
+
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            } else {
+                reject(new Error(`npm install failed with code ${code}`));
+            }
+        });
+
+        child.on('error', reject);
+    });
+}
+
+/**
+ * mono i - 递归安装所有嵌套 monorepo 的依赖
+ */
+async function installCommand() {
+    const cwd = process.cwd();
+    console.log('[mono i] 扫描嵌套 monorepo...');
+
+    const monorepos = findAllMonorepos(cwd);
+
+    if (monorepos.length === 0) {
+        console.log('[mono i] 未找到任何 monorepo');
+        return;
+    }
+
+    console.log(`[mono i] 找到 ${monorepos.length} 个 monorepo:`);
+    for (const dir of monorepos) {
+        console.log(`  - ${dir}`);
+    }
+
+    // 从外到内安装（父级先安装）
+    for (const dir of monorepos) {
+        try {
+            await runNpmInstall(dir);
+        } catch (err) {
+            console.error(`[mono i] 安装失败: ${dir}`, err.message);
+            process.exit(1);
+        }
+    }
+
+    console.log('\n[mono i] ✅ 所有 monorepo 安装完成！');
+}
+
+/**
+ * 运行 TypeScript 文件
+ */
+function runCommand(args, debug = false) {
+    const loaderUrl = getLoaderUrl();
+
+    const nodeArgs = [
+        `--import=${loaderUrl}`,
+        ...args
+    ];
+
+    // 如果开启 debug，设置环境变量
+    const env = { ...process.env };
+    if (debug) {
+        env.MONO_DEBUG = '1';
+    }
+
+    const child = spawn('node', nodeArgs, {
+        stdio: 'inherit',
+        env
+    });
+
+    child.on('close', (code) => {
+        process.exit(code ?? 0);
+    });
+
+    child.on('error', (err) => {
+        console.error('mono: 无法启动 node 进程', err.message);
+        process.exit(1);
+    });
+}
+
+/**
+ * 主函数
+ */
+async function main() {
+    const args = process.argv.slice(2);
+
+    // 检查调试参数（支持多种格式，可在任意位置）
+    let debug = false;
+    const filteredArgs = [];
+
+    for (const arg of args) {
+        if (arg === '--debug' || arg === '-debug' || arg === '-d' || arg === 'debug' || arg === 'd') {
+            debug = true;
+        } else {
+            filteredArgs.push(arg);
+        }
+    }
+
+    // 检查是否是 install 命令
+    if (filteredArgs[0] === 'i' || filteredArgs[0] === 'install') {
+        await installCommand();
+        return;
+    }
+
+    // 否则运行 TypeScript 文件
+    runCommand(filteredArgs, debug);
+}
+
+main();

package/package.json

@@ -0,0 +1,40 @@
+{
+    "name": "localmono",
+    "version": "0.1.0",
+    "description": "CLI tool for monorepo - auto-discover local packages and use source code in Node.js",
+    "type": "module",
+    "bin": {
+        "mono": "./bin/mono.mjs"
+    },
+    "main": "./src/hooks.mjs",
+    "exports": {
+        ".": "./src/hooks.mjs",
+        "./hooks": "./src/hooks.mjs",
+        "./loader": "./src/loader.mjs"
+    },
+    "files": [
+        "bin",
+        "src"
+    ],
+    "scripts": {
+        "test": "node test/test.mjs"
+    },
+    "keywords": [
+        "monorepo",
+        "cli",
+        "node",
+        "loader",
+        "workspace",
+        "esm",
+        "typescript"
+    ],
+    "author": "alamhubb",
+    "license": "MIT",
+    "engines": {
+        "node": ">=18.19.0"
+    },
+    "dependencies": {
+        "cross-spawn": "^7.0.6",
+        "tsx": "^4.21.0"
+    }
+}

package/src/hooks.mjs

@@ -0,0 +1,247 @@
+/**
+ * ESM Loader Hooks - 被 register() 加载的 hooks 模块
+ * 拦截模块解析，对项目中的本地包应用源码入口
+ *
+ * 新逻辑：
+ * - 向上查找最顶层的包含 .idea / .vscode / package.json 的目录作为根目录
+ * - 从根目录递归向下查找所有有 package.json 的项目
+ * - 根据 package.json 的 name 字段注册
+ * - 默认使用 src/index.ts，如果配置了 local 字段则使用配置的
+ *
+ * 注意：此文件使用纯 JavaScript，以便 Node.js 原生加载
+ */
+
+import { readFileSync, existsSync, readdirSync, appendFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { resolve as pathResolve, dirname, join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+// 根目录标识符列表
+const ROOT_MARKERS = ['.idea', '.vscode', '.git', 'package.json'];
+
+// 默认源码入口
+const DEFAULT_ENTRY = './src/index.ts';
+
+// 调试日志文件
+const DEBUG_LOG = join(process.cwd(), 'mono-debug.log');
+
+// 是否启用调试日志（设置环境变量 MONO_DEBUG=1 开启）
+const DEBUG_ENABLED = process.env.MONO_DEBUG === '1';
+
+function debugLog(msg) {
+    if (!DEBUG_ENABLED) return;
+    // 同时输出到控制台和文件
+    console.log(msg);
+    try {
+        appendFileSync(DEBUG_LOG, `${new Date().toISOString()} ${msg}\n`);
+    } catch { }
+}
+
+if (DEBUG_ENABLED) {
+    debugLog('[mono hooks] hooks.mjs 已加载');
+}
+
+// 缓存：workspace 包信息
+let workspacePackages = null;
+
+/**
+ * 检查目录是否包含根目录标识
+ */
+function hasRootMarker(dir) {
+    for (const marker of ROOT_MARKERS) {
+        if (existsSync(join(dir, marker))) {
+            return true;
+        }
+    }
+    return false;
+}
+
+/**
+ * 向上查找最顶层的根目录
+ * 找到最顶层的包含 .idea / .vscode / package.json 的目录
+ */
+function findProjectRoot(startDir) {
+    let currentDir = pathResolve(startDir);
+    let topMostRoot = null;
+
+    while (currentDir !== dirname(currentDir)) {
+        if (hasRootMarker(currentDir)) {
+            topMostRoot = currentDir;
+        }
+        currentDir = dirname(currentDir);
+    }
+
+    return topMostRoot;
+}
+
+/**
+ * 递归向下查找所有有 package.json 的项目
+ */
+function findAllPackages(rootDir, packages) {
+    // 跳过路径中包含 node_modules 的目录
+    if (rootDir.includes('node_modules')) {
+        debugLog(`[mono] 跳过 node_modules: ${rootDir}`);
+        return;
+    }
+
+    const pkgPath = join(rootDir, 'package.json');
+
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+
+            if (pkg.name) {
+                // 确定入口：优先使用 local 配置，否则使用默认值
+                const entry = typeof pkg.local === 'string' ? pkg.local : DEFAULT_ENTRY;
+
+                packages.set(pkg.name, {
+                    name: pkg.name,
+                    dir: rootDir,
+                    localEntry: entry
+                });
+
+                debugLog(`[mono] 发现包: ${pkg.name} -> ${entry}`);
+            }
+        } catch {
+            // 忽略解析错误
+        }
+    }
+
+    // 递归查找子目录
+    try {
+        const entries = readdirSync(rootDir, { withFileTypes: true });
+
+        for (const entry of entries) {
+            if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                findAllPackages(join(rootDir, entry.name), packages);
+            }
+        }
+    } catch {
+        // 忽略读取错误
+    }
+}
+
+/**
+ * 初始化 workspace 信息
+ * 从根目录递归向下收集所有包
+ */
+function initWorkspace() {
+    if (workspacePackages !== null) return;
+
+    workspacePackages = new Map();
+
+    // 从当前工作目录开始，向上找最顶层根目录
+    const cwd = process.cwd();
+    const projectRoot = findProjectRoot(cwd);
+
+    if (!projectRoot) {
+        debugLog('[mono] 未找到项目根目录');
+        return;
+    }
+
+    debugLog(`[mono] 项目根目录: ${projectRoot}`);
+
+    // 从根目录递归向下查找所有包
+    findAllPackages(projectRoot, workspacePackages);
+
+    debugLog(`[mono] 共发现 ${workspacePackages.size} 个包`);
+
+    // 生成配置文件
+    writeMonoConfig(cwd);
+}
+
+/**
+ * 生成 monoConfig.json 配置文件
+ * 记录包名与文件地址的映射关系
+ * 
+ * @param {string} cwd 当前工作目录
+ */
+function writeMonoConfig(cwd) {
+    const monoDir = join(cwd, '.mono');
+    const configPath = join(monoDir, 'monoConfig.json');
+
+    // 确保 mono 目录存在
+    if (!existsSync(monoDir)) {
+        try {
+            mkdirSync(monoDir, { recursive: true });
+        } catch (err) {
+            debugLog(`[mono] 创建目录失败: ${err.message}`);
+            return;
+        }
+    }
+
+    // 构建包映射
+    const config = {};
+    for (const [name, pkg] of workspacePackages) {
+        const entryPath = join(pkg.dir, pkg.localEntry);
+        config[name] = entryPath;
+    }
+
+    // 写入配置文件
+    try {
+        writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+        debugLog(`[mono] 已生成配置文件: ${configPath}`);
+    } catch (err) {
+        debugLog(`[mono] 写入配置文件失败: ${err.message}`);
+    }
+}
+
+/**
+ * 判断是否是包的主入口导入（不是子路径导入）
+ */
+function isMainEntryImport(specifier) {
+    // 跳过相对路径和绝对路径
+    if (specifier.startsWith('.') || specifier.startsWith('/')) {
+        return false;
+    }
+
+    // 跳过 node: 和其他协议
+    if (specifier.includes(':')) {
+        return false;
+    }
+
+    // 处理 scoped 包名 @scope/name
+    if (specifier.startsWith('@')) {
+        const parts = specifier.split('/');
+        // @scope/name 正好两部分是主入口
+        // @scope/name/sub 三部分及以上是子路径
+        return parts.length === 2;
+    }
+
+    // 普通包名 name
+    // name 是主入口，name/sub 是子路径
+    return !specifier.includes('/');
+}
+
+/**
+ * ESM Loader: resolve hook
+ * 拦截模块解析
+ */
+export async function resolve(specifier, context, nextResolve) {
+    // 初始化 workspace 信息（只初始化一次）
+    initWorkspace();
+
+    // 只处理主入口导入
+    if (!isMainEntryImport(specifier)) {
+        return nextResolve(specifier, context);
+    }
+
+    // 检查是否是本地包
+    const pkg = workspacePackages?.get(specifier);
+
+    if (!pkg) {
+        // 不是本地包，使用默认解析
+        return nextResolve(specifier, context);
+    }
+
+    // 构造新的入口路径
+    const newEntry = join(pkg.dir, pkg.localEntry);
+    const newUrl = pathToFileURL(newEntry).href;
+
+    // 日志：显示拦截的包
+    debugLog(`[mono] 拦截: ${specifier} -> ${pkg.localEntry}`);
+
+    return {
+        url: newUrl,
+        shortCircuit: true
+    };
+}

package/src/loader.mjs

@@ -0,0 +1,39 @@
+/**
+ * ESM Loader 入口
+ * 使用 register() API 注册自定义 hooks
+ * 
+ * 用法: node --import=./src/loader.mjs app.ts
+ * 
+ * 功能：
+ * 1. 注册 tsx 的 ESM loader 以支持 TypeScript 编译
+ * 2. 注册 mono 的 resolve hooks 以拦截包名解析到源码
+ * 
+ * 注册顺序说明：
+ * Node.js loader hooks 使用洋葱模型，后注册的先被调用。
+ * 我们希望 mono 先拦截包名，再由 tsx 编译 .ts 文件。
+ * 所以先注册 tsx，再注册 mono（后注册先调用）。
+ */
+
+import { register } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// 是否启用调试日志（设置环境变量 MONO_DEBUG=1 开启）
+const DEBUG_ENABLED = process.env.MONO_DEBUG === '1';
+
+if (DEBUG_ENABLED) console.log('[mono] 加载 loader.mjs');
+
+// 1. 先注册 tsx 的 ESM loader（TypeScript 编译）
+if (DEBUG_ENABLED) console.log('[mono] 注册 tsx ESM loader...');
+await import('tsx/esm');
+
+// 2. 再注册 mono 的 resolve hooks（包名拦截）
+// 后注册先调用，所以 mono 会先于 tsx 处理 resolve
+const hooksPath = join(__dirname, 'hooks.mjs');
+if (DEBUG_ENABLED) console.log('[mono] 注册 mono hooks:', hooksPath);
+register(pathToFileURL(hooksPath).href, import.meta.url);
+