@vibe-coder/cli 1.0.0 → 1.0.1

package/README.md

@@ -1,141 +1,161 @@
-
 <div align="center">
 
 # 🌊 Vibe Coding CLI
 
-**专为 OpenCode 打造的 vibe coding 生态构建工具**
-
-[![Version](https://img.shields.io/badge/version-1.0.0-blue.svg)](./package.json)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](../../LICENSE.md)
-[![Built with Bun](https://img.shields.io/badge/Bun-%23000000.svg?logo=bun&logoColor=white)](https://bun.sh)
+**A vibe coding ecosystem builder tailored for OpenCode**
 
-[English](#) · **简体中文**
+**English** · [简体中文](https://github.com/HelloGGX/skill/blob/main/packages/vibe/README.zh.md)
 
 </div>
 
-## 📖 简介 (Introduction)
+## 📖 Introduction
 
-`vibe-coding-cli` 是一个专为 **OpenCode** 平台打造的现代命令行脚手架工具。它的核心目标是简化和自动化 Agent 技能（Skills）与底层脚本工具（Tools）的管理。
+`vibe-coding-cli` is a modern command-line scaffolding tool built specifically for the **OpenCode** platform. Its core objective is to quickly set up a Vibe Coding development environment and simplify resource management for specification-driven development.
 
-通过 `vibe` 命令，你可以一键拉取远程 GitHub 仓库中的 TypeScript 或 Python 工具脚本，自动将其注册到 OpenCode 配置中，并无缝管理其依赖环境（包括自动配置独立的 Python 虚拟环境）。
+With the `vibe` command, you can pull TypeScript/Python tool scripts or Markdown rule files from remote GitHub repositories with a single click. It automatically and seamlessly registers them into your OpenCode configuration and manages the underlying runtime dependency environments, allowing you to focus entirely on "co-creating code with AI".
 
-## ✨ 核心特性 (Features)
+## ✨ Features
 
-- 🛠 **全自动化工具管理**: 支持从任意 GitHub 仓库快速解析、选择并下载 `.ts` / `.py` 工具至本地 `.opencode/tool/` 目录。
-- 📦 **智能配置注入**: 自动维护状态锁文件 (`vibe-lock.json`) 并向 `.opencode/opencode.jsonc` 中无感注入工具注册信息，告别手动配置。
-- 🐍 **自动 Python 环境集成**: 侦测到 Python 工具时，自动在项目根目录创建 `.venv` 虚拟环境，并安装必要的 `requests`、`dotenv` 等基础依赖。
-- 🪄 **标准技能聚合**: 与 `pnpx skills` 生态深度集成，统一管理标准技能库和本地化扩展工具。
-- ⚡ **极致性能**: 基于 [Bun](https://bun.sh/) 编写与构建，极速执行代码和处理文件 IO。
+* 🛠 **Fully Automated Tool Management:** Quickly parse, select, and download `.ts` / `.py` scripts from any GitHub repository straight to your local `.opencode/tool/` directory, ready to use out of the box.
+* 📜 **Integrates Everything You Need for Vibe Coding:** A unique ecosystem aggregation capability that perfectly blends the **Capabilities (tools and skills)** needed for Agent execution with the **Context (guidelines and best practices)**. Supports on-demand installation of `.md` rule files so the AI truly understands your architectural intent and coding standards.
+* 📦 **Smart Configuration Injection:** Automatically intercepts and updates `.opencode/opencode.jsonc`, silently injecting tool enable-switches and Prompt instruction paths. Say goodbye to tedious manual configuration forever.
+* ⚡ **Lightning-Fast Parallel Updates:** Designed with a concurrency model to simultaneously handle resource comparison and pulling from multiple source repositories, drastically reducing update wait times in multi-dependency scenarios.
+* 🪄 **Standard Skills Aggregation:** Deeply integrated with Vercel's `pnpx skills` ecosystem, allowing you to manage standard Agent skill libraries alongside localized extension resources within a unified CLI workflow.
 
 ---
 
-## 🚀 快速开始 (Quick Start)
+## 🚀 Quick Start
 
-### 安装
+### Installation
 
-作为全局包安装（推荐使用 npm 或 bun）：
+Install as a global package (npm or bun recommended):
 
 ```bash
-# 使用 npm
+# Using npm
 npm install -g vibe-coding-cli
 
-# 使用 bun
+# Using bun
 bun add -g vibe-coding-cli
 
 ```
 
-*如果你在本地 monorepo 环境中开发，可以直接使用 `bun run dev` 或构建后执行 `./bin/vibe`。*
-
-### 基础用法
+### Basic Usage
 
-初始化并添加一个技能库（例如本项目的 `helloggx/skill`）：
+Initialize and add an ecosystem library (e.g., `helloggx/skill` from this project):
 
 ```bash
 vibe add helloggx/skill
 
 ```
 
-*此命令将会弹出交互式菜单，让你选择想要安装的底层工具，并自动配置项目结构。*
+*This command will pop up an interactive menu, allowing you to flexibly select the **Tools** and **Rules** you want to install. The CLI will automatically configure the entire environment for you.*
 
 ---
 
-## 📚 命令指南 (Commands)
+## 📚 Commands
 
-### 1. 添加工具与技能 (`add` / `a`)
+### 1. Add Resources (`add` / `a`)
 
 ```bash
 vibe add <repository>
 
 ```
 
-**功能流程**:
+**Execution Flow**:
 
-1. 调用原生能力安装目标仓库中的 Agent 技能。
-2. 克隆并解析目标仓库中的 `tool` 文件夹。
-3. 提供交互式多选列表，让你选择需要的具体工具。
-4. 自动拷贝文件、更新 `opencode.jsonc` 并配置 Python 依赖环境（如果需要）。
+1. Invokes native capabilities to install basic Agent skills from the target repository.
+2. Clones and parses the `skill`, `tool`, and `rules` asset directories in the target repository.
+3. Triggers an interactive multi-select list to pick specific tool scripts and rule documents on demand.
+4. Automatically executes file copying, intelligently merges common rules, updates `opencode.jsonc`, and configures the Python dependency environment (if needed).
 
-### 2. 查看已安装项 (`list` / `ls`)
+### 2. List Installed Items (`list` / `ls`)
 
 ```bash
 vibe list
 
 ```
 
-**功能**:
-清晰打印当前项目中安装的所有本地 Tools（来自 `vibe-lock.json`）以及已安装的标准 Skills，便于进行环境审查。
+**Function**:
+Clearly prints a status map of all installed resources in the current project, including:
 
-### 3. 一键更新 (`update` / `up`)
+* 🛠️ Local Tools
+* 📜 Injected Context Rules (Local Rules)
+* 🪄 Global Standard Skills
+
+### 3. One-Click Sync & Update (`update` / `up`)
 
 ```bash
 vibe update
 
 ```
 
-**功能**:
-自动执行标准 Skills 的升级，并根据锁文件记录的源仓库，拉取并覆盖最新的本地工具脚本，保持生态环境最新。
+**Function**:
+Executes a full workspace update with one click. The CLI will concurrently pull all source repositories recorded in `vibe-lock.json`, intelligently compare and overwrite the latest local scripts and rule files, and simultaneously trigger an upgrade of the standard skills library.
+
+### 4. Remove Resources (`remove` / `rm`)
+
+```bash
+# Interactive mode: Pops up a UI list to select tools and rules to remove
+vibe remove
+
+# Shortcut mode: Directly specify the resource to remove (supports standard skills and local tools/rules)
+vibe remove <resource>
+
+```
+
+**Execution Flow**:
+
+1. Invokes native capabilities to remove standard Agent skills from the target repository (via `pnpx skills remove`).
+2. Parses the list of installed resources in the local `vibe-lock.json`.
+3. **Interactive Mode**: Pops up a multi-select list, allowing you to choose specific tools and rule categories for removal.
+4. **Shortcut Mode**: Directly matches and removes local tool/rule files based on the passed arguments.
+5. Automatically cleans up the corresponding physical files (`.opencode/tool/` and `.opencode/rules/`) and synchronously updates the `opencode.jsonc` configuration.
 
 ---
 
-## 📂 目录与配置规范 (Workspace Structure)
+## 📂 Workspace Structure
 
-运行 `vibe add` 后，工具将在你的项目根目录下自动创建并维护以下结构：
+After running `vibe add`, the tool will automatically create and maintain the following standard Vibe Coding structure in your project's root directory:
 
 ```text
 your-project/
 ├── .opencode/
-│   ├── tool/                   # 存放被拉取下来的底层 .ts / .py 工具脚本
-│   │   ├── get_dsl.ts
-│   │   └── ...
-│   ├── opencode.jsonc          # OpenCode 核心配置（vibe 会自动向 "tools" 字段注入注册信息）
-│   └── vibe-lock.json          # Vibe 状态锁文件，记录工具来源和版本时间戳
-├── .venv/                      # (自动创建) Python 虚拟环境，为 .py 工具提供隔离环境
-└── requirements.txt            # (自动维护) 补充 Python 工具运行所需的核心依赖
+│   ├── tool/                   # Stores the pulled underlying .ts / .py tool scripts
+│   │   ├── get_dsl.ts
+│   │   └── ...
+│   ├── rules/                  # Stores the pulled .md rule files (categorized by type)
+│   │   ├── common/
+│   │   └── typescript/
+│   ├── opencode.jsonc          # Core OpenCode configuration file
+│   │                           # (vibe automatically manages "tools": {...} and "instructions": [...] inside)
+│   └── vibe-lock.json          # Internal state lock file, accurately recording resource sources, versions, and update timestamps
+├── .venv/                      # (Auto-created as needed) Isolated Python virtual environment
+└── requirements.txt            # (Auto-maintained as needed) Dependency list required for Python scripts
 
 ```
 
 ---
 
-## 🛠️ 开发者指南 (Development)
+## 🛠️ Development
 
-本项目使用 Bun 进行包管理和运行。
+This project is built on top of [Bun](https://bun.sh/), offering a lightning-fast execution and bundling experience.
 
 ```bash
-# 1. 安装依赖
+# 1. Install project dependencies
 bun install
 
-# 2. 本地开发运行 CLI
+# 2. Run CLI locally for debugging
 bun run dev --help
 
-# 3. 类型检查
+# 3. Strict type checking
 bun run typecheck
 
-# 4. 构建生产版本 (输出至 ./dist)
+# 4. Build production version (outputs to ./dist)
 bun run build
 
 ```
 
-## 📄 许可证 (License)
+## 📄 License
 
-本项目采用 [MIT License](https://www.google.com/search?q=../../LICENSE.md) 进行开源。
+This project is open-sourced under the [MIT License](https://www.google.com/search?q=../../LICENSE.md).
 © 2026 [HelloGGX](https://github.com/HelloGGX)

package/README.zh.md

@@ -0,0 +1,157 @@
+<div align="center">
+
+# 🌊 Vibe Coding CLI
+
+**专为 OpenCode 打造的 vibe coding 生态构建工具**
+
+[![Version](https://img.shields.io/badge/version-1.0.1-blue.svg)](./package.json)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](../../LICENSE.md)
+[![Built with Bun](https://img.shields.io/badge/Bun-%23000000.svg?logo=bun&logoColor=white)](https://bun.sh)
+
+[English](https://github.com/HelloGGX/skill/blob/main/packages/vibe/README.md) · **简体中文**
+
+</div>
+
+## 📖 简介 (Introduction)
+
+`vibe-coding-cli` 是一个专为 **OpenCode** 平台打造的现代命令行脚手架工具。它的核心目标是快速搭建 Vibe Coding 的开发环境，简化规范驱动开发的资源管理。
+
+通过 `vibe` 命令，你可以一键拉取远程 GitHub 仓库中的 TypeScript/Python 工具脚本或 Markdown 规则文件，自动将其无缝注册到 OpenCode 配置中，并接管其底层的运行依赖环境，让你专注于“与 AI 共创代码”本身。
+
+## ✨ 核心特性 (Features)
+
+- 🛠 **全自动化工具管理**: 支持从任意 GitHub 仓库快速解析、选择并下载 `.ts` / `.py` 脚本至本地 `.opencode/tool/` 目录，开箱即用。
+- 📜 **集成 Vibe Coding 所需的一切**: 独创的生态聚合能力，将 Agent 执行所需的 **Capabilities（工具与技能）** 与 **Context（行为准则与最佳实践）** 完美融合。支持按需安装 `.md` 规则文件，让 AI 真正懂你的架构意图与代码规范。
+- 📦 **智能配置注入**: 自动拦截并更新 `.opencode/opencode.jsonc`，无感注入工具的启用开关与 Prompt 指令（instructions）路径，彻底告别繁琐的手动配置。
+- ⚡ **并行极速更新**: 基于并发模型设计，同时处理多个源仓库的资源对比与拉取，大幅缩短多依赖场景下的更新等待时间。
+- 🪄 **标准技能聚合**: 与 Vercel 的 `pnpx skills` 生态深度集成，在统一的 CLI 流程中同时管理标准 Agent 技能库和本地化扩展资源。
+
+---
+
+## 🚀 快速开始 (Quick Start)
+
+### 安装
+
+作为全局包安装（推荐使用 npm 或 bun）：
+
+```bash
+# 使用 npm
+npm install -g vibe-coding-cli
+
+# 使用 bun
+bun add -g vibe-coding-cli
+```
+
+### 基础用法
+
+初始化并添加一个生态库（例如本项目的 `helloggx/skill`）：
+
+```bash
+vibe add helloggx/skill
+```
+
+*此命令将会弹出交互式菜单，允许你灵活多选想要安装的 **Tools (工具)** 和 **Rules (规则)**，CLI 将会自动为你完成所有环境的配置。*
+
+---
+
+## 📚 命令指南 (Commands)
+
+### 1. 添加资源 (`add` / `a`)
+
+```bash
+vibe add <repository>
+```
+
+**执行流程**:
+
+1. 调用原生能力，安装目标仓库中的基础 Agent 技能。
+2. 克隆并解析目标仓库中的 `skill`、`tool` 和 `rules` 资产目录。
+3. 唤起交互式多选列表，按需挑选具体的工具脚本和规则文档。
+4. 自动执行文件拷贝、智能合并公共规则、更新 `opencode.jsonc` 并配置 Python 依赖环境（如需）。
+
+### 2. 查看已安装项 (`list` / `ls`)
+
+```bash
+vibe list
+```
+
+**功能**:
+清晰打印当前项目中安装的所有资源态势图，包含：
+
+* 🛠️ 本地扩展工具 (Local Tools)
+* 📜 注入的上下文规则 (Local Rules)
+* 🪄 全局标准技能 (Standard Skills)
+
+### 3. 一键同步更新 (`update` / `up`)
+
+```bash
+vibe update
+```
+
+**功能**:
+一键执行工作区全量更新。CLI 会并发拉取 `vibe-lock.json` 中记录的所有源仓库，智能比对并覆盖最新的本地脚本和规则文件，同时触发标准技能库的升级。
+
+### 4. 移除资源 (`remove` / `rm`)
+
+```bash
+# 交互式模式：弹出 UI 列表选择要移除的工具和规则
+vibe remove
+
+# 快捷模式：直接指定要移除的资源（支持标准 skills 和本地工具/规则）
+vibe remove <resource>
+```
+
+**执行流程**:
+
+1. 调用原生能力，移除目标仓库中的标准 Agent 技能（通过 `pnpx skills remove`）。
+2. 解析本地 `vibe-lock.json` 中的已安装资源列表。
+3. **交互模式**：弹出多选列表，允许你选择具体的工具和规则分类进行移除。
+4. **快捷模式**：根据传入的参数直接匹配并移除本地工具/规则文件。
+5. 自动清理对应的物理文件（`.opencode/tool/` 和 `.opencode/rules/`），并同步更新 `opencode.jsonc` 配置。
+
+---
+
+## 📂 目录与配置规范 (Workspace Structure)
+
+运行 `vibe add` 后，工具将在你的项目根目录下自动创建并维护以下标准 Vibe Coding 结构：
+
+```text
+your-project/
+├── .opencode/
+│   ├── tool/                   # 存放被拉取下来的底层 .ts / .py 工具脚本
+│   │   ├── get_dsl.ts
+│   │   └── ...
+│   ├── rules/                  # 存放被拉取下来的 .md 规则文件（按类别分类归档）
+│   │   ├── common/
+│   │   └── typescript/
+│   ├── opencode.jsonc          # OpenCode 核心配置文件
+│   │                           # (vibe 会自动管理其中的 "tools": {...} 和 "instructions": [...])
+│   └── vibe-lock.json          # 内部状态锁文件，精准记录资源来源仓库、版本与更新时间戳
+├── .venv/                      # (按需自动创建) 隔离的 Python 虚拟环境
+└── requirements.txt            # (按需自动维护) Python 脚本所需的依赖清单
+```
+
+---
+
+## 🛠️ 开发者指南 (Development)
+
+本项目底层基于 [Bun](https://bun.sh/) 构建，拥有极速的执行与打包体验。
+
+```bash
+# 1. 安装项目依赖
+bun install
+
+# 2. 本地调试运行 CLI
+bun run dev --help
+
+# 3. 严格类型检查
+bun run typecheck
+
+# 4. 构建生产版本 (输出至 ./dist)
+bun run build
+```
+
+## 📄 许可证 (License)
+
+本项目采用 [MIT License](https://www.google.com/search?q=../../LICENSE.md) 进行开源。
+© 2026 [HelloGGX](https://github.com/HelloGGX)

package/dist/cli.js

@@ -1317,6 +1317,25 @@ class Vt extends x {
     }
   }
 }
+
+class kt extends x {
+  get cursor() {
+    return this.value ? 0 : 1;
+  }
+  get _value() {
+    return this.cursor === 0;
+  }
+  constructor(e) {
+    super(e, false), this.value = !!e.initialValue, this.on("userInput", () => {
+      this.value = this._value;
+    }), this.on("confirm", (s) => {
+      this.output.write(import_sisteransi.cursor.move(0, -1)), this.value = s, this.state = "submit", this.close();
+    }), this.on("cursor", () => {
+      this.value = !this.value;
+    });
+  }
+}
+
 class yt extends x {
   options;
   cursor = 0;
@@ -1689,6 +1708,33 @@ var X2 = (t) => {
       B2.push(w);
   return h && B2.push(g), B2;
 };
+var Re = (t) => {
+  const r = t.active ?? "Yes", s = t.inactive ?? "No";
+  return new kt({ active: r, inactive: s, signal: t.signal, input: t.input, output: t.output, initialValue: t.initialValue ?? true, render() {
+    const i = t.withGuide ?? _.withGuide, a = `${i ? `${import_picocolors2.default.gray(d)}
+` : ""}${W2(this.state)}  ${t.message}
+`, o = this.value ? r : s;
+    switch (this.state) {
+      case "submit": {
+        const u = i ? `${import_picocolors2.default.gray(d)}  ` : "";
+        return `${a}${u}${import_picocolors2.default.dim(o)}`;
+      }
+      case "cancel": {
+        const u = i ? `${import_picocolors2.default.gray(d)}  ` : "";
+        return `${a}${u}${import_picocolors2.default.strikethrough(import_picocolors2.default.dim(o))}${i ? `
+${import_picocolors2.default.gray(d)}` : ""}`;
+      }
+      default: {
+        const u = i ? `${import_picocolors2.default.cyan(d)}  ` : "", l = i ? import_picocolors2.default.cyan(x2) : "";
+        return `${a}${u}${this.value ? `${import_picocolors2.default.green(Q2)} ${r}` : `${import_picocolors2.default.dim(H2)} ${import_picocolors2.default.dim(r)}`}${t.vertical ? i ? `
+${import_picocolors2.default.cyan(d)}  ` : `
+` : ` ${import_picocolors2.default.dim("/")} `}${this.value ? `${import_picocolors2.default.dim(H2)} ${import_picocolors2.default.dim(s)}` : `${import_picocolors2.default.green(Q2)} ${s}`}
+${l}
+`;
+      }
+    }
+  } }).prompt();
+};
 var R2 = { message: (t = [], { symbol: r = import_picocolors2.default.gray(d), secondarySymbol: s = import_picocolors2.default.gray(d), output: i = process.stdout, spacing: a = 1, withGuide: o } = {}) => {
   const u = [], l = o ?? _.withGuide, n = l ? s : "", c = l ? `${r}  ` : "", g = l ? `${s}  ` : "";
   for (let p = 0;p < a; p++)
@@ -1868,10 +1914,10 @@ var bt2 = ({ indicator: t = "dots", onCancel: r, output: s = process.stdout, can
 var zt = { light: C("─", "-"), heavy: C("━", "="), block: C("█", "#") };
 var Qt = `${import_picocolors2.default.gray(d)}  `;
 
-// src/add.ts
-import { execSync } from "child_process";
-import { existsSync, mkdirSync, cpSync, writeFileSync, readFileSync, readdirSync } from "fs";
-import path from "path";
+// src/commands/add.ts
+import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync2 } from "fs";
+import path4 from "path";
 
 // ../../node_modules/.bun/simple-git@3.32.2/node_modules/simple-git/dist/esm/index.js
 var import_file_exists = __toESM(require_dist(), 1);
@@ -5958,6 +6004,10 @@ async function cleanupTempDir(dir) {
   await rm(dir, { recursive: true, force: true });
 }
 
+// src/utils/config.ts
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
+import path from "path";
+
 // src/constants.ts
 var OPENCODE_DIR = ".opencode";
 var TOOL_SUBDIR = "tool";
@@ -5973,7 +6023,29 @@ var YELLOW = "\x1B[33m";
 var DIM = "\x1B[38;5;102m";
 var TEXT = "\x1B[38;5;145m";
 
-// src/add.ts
+// src/utils/error.ts
+function handleExecError(error, context, severity = "warn" /* WARN */) {
+  const message = error instanceof Error ? error.message : String(error);
+  const formatted = `${context}
+${YELLOW}${message}${RESET}`;
+  switch (severity) {
+    case "error" /* ERROR */:
+      R2.error(formatted);
+      process.exit(1);
+    case "warn" /* WARN */:
+      R2.warn(formatted);
+      break;
+    default:
+      R2.info(formatted);
+  }
+}
+
+// src/utils/config.ts
+function parseJsonc(content) {
+  let safeJsonStr = content.replace(/"(?:\\.|[^"\\])*"|\/\/[^\n]*|\/\*[\s\S]*?\*\//g, (m) => m.startsWith('"') ? m : "");
+  safeJsonStr = safeJsonStr.replace(/,\s*([\]}])/g, "$1");
+  return JSON.parse(safeJsonStr);
+}
 function getLockFilePath() {
   return path.join(process.cwd(), OPENCODE_DIR, LOCK_FILE);
 }
@@ -5984,6 +6056,8 @@ function readLockFile() {
       const parsed = JSON.parse(readFileSync(lockPath, "utf-8"));
       if (!parsed.rules)
         parsed.rules = {};
+      if (!parsed.tools)
+        parsed.tools = {};
       return parsed;
     }
   } catch (e2) {}
@@ -6016,138 +6090,174 @@ function ensureOpencodeConfig() {
     writeFileSync(configPath, jsoncContent, "utf-8");
   }
 }
-function updateOpencodeConfigTools(newTools) {
-  if (newTools.length === 0)
+function updateOpencodeConfig(newTools, newRulePaths) {
+  if (newTools.length === 0 && newRulePaths.length === 0)
     return;
   const configPath = path.join(process.cwd(), OPENCODE_DIR, CONFIG_FILE);
   if (!existsSync(configPath))
     return;
   try {
     const content = readFileSync(configPath, "utf-8");
-    let safeJsonStr = content.replace(/"(?:\\.|[^"\\])*"|\/\/[^\n]*|\/\*[\s\S]*?\*\//g, (m) => m.startsWith('"') ? m : "");
-    safeJsonStr = safeJsonStr.replace(/,\s*([\]}])/g, "$1");
-    const config = JSON.parse(safeJsonStr);
-    config.tools = config.tools || {};
+    const config = parseJsonc(content);
     let updated = false;
-    for (const tool of newTools) {
-      if (!config.tools[tool]) {
-        config.tools[tool] = true;
-        updated = true;
+    if (newTools.length > 0) {
+      config.tools = config.tools || {};
+      for (const tool of newTools) {
+        if (!config.tools[tool]) {
+          config.tools[tool] = true;
+          updated = true;
+        }
+      }
+    }
+    if (newRulePaths.length > 0) {
+      config.instructions = config.instructions || [];
+      for (const rulePath of newRulePaths) {
+        if (!config.instructions.includes(rulePath)) {
+          config.instructions.push(rulePath);
+          updated = true;
+        }
       }
     }
     if (updated)
       writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
   } catch (e2) {
-    console.error(`
-${YELLOW}Warning: Failed to inject tools into opencode.jsonc. ${e2.message}${RESET}`);
+    handleExecError(e2, "Failed to update opencode.jsonc", "warn" /* WARN */);
   }
 }
-function updateOpencodeConfigInstructions(rulePaths) {
-  if (rulePaths.length === 0)
+function removeOpencodeConfig(toolsToRemove, rulesToRemove) {
+  if (toolsToRemove.length === 0 && rulesToRemove.length === 0)
     return;
   const configPath = path.join(process.cwd(), OPENCODE_DIR, CONFIG_FILE);
   if (!existsSync(configPath))
     return;
   try {
     const content = readFileSync(configPath, "utf-8");
-    let safeJsonStr = content.replace(/"(?:\\.|[^"\\])*"|\/\/[^\n]*|\/\*[\s\S]*?\*\//g, (m) => m.startsWith('"') ? m : "");
-    safeJsonStr = safeJsonStr.replace(/,\s*([\]}])/g, "$1");
-    const config = JSON.parse(safeJsonStr);
-    config.instructions = config.instructions || [];
+    const config = parseJsonc(content);
     let updated = false;
-    for (const rulePath of rulePaths) {
-      if (!config.instructions.includes(rulePath)) {
-        config.instructions.push(rulePath);
+    if (toolsToRemove.length > 0 && config.tools) {
+      for (const tool of toolsToRemove) {
+        if (tool in config.tools) {
+          delete config.tools[tool];
+          updated = true;
+        }
+      }
+    }
+    if (rulesToRemove.length > 0 && config.instructions) {
+      const originalLength = config.instructions.length;
+      config.instructions = config.instructions.filter((inst) => {
+        return !rulesToRemove.some((rule) => inst.includes(`/${RULES_SUBDIR}/${rule}/`));
+      });
+      if (config.instructions.length !== originalLength) {
         updated = true;
       }
     }
     if (updated)
       writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
   } catch (e2) {
-    console.error(`
-${YELLOW}Warning: Failed to inject instructions into opencode.jsonc. ${e2.message}${RESET}`);
+    handleExecError(e2, "Failed to remove items from opencode.jsonc", "warn" /* WARN */);
   }
 }
+
+// src/utils/file.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, cpSync, readdirSync, rmSync } from "fs";
+import path2 from "path";
 function copyToolFiles(toolName, sourceDir, targetDir) {
   let hasPython = false;
   const tsFile = `${toolName}.ts`;
   const pyFile = `${toolName}.py`;
-  const srcTs = path.join(sourceDir, tsFile);
-  if (existsSync(srcTs))
-    cpSync(srcTs, path.join(targetDir, tsFile), { recursive: true });
-  const srcPy = path.join(sourceDir, pyFile);
-  if (existsSync(srcPy)) {
-    cpSync(srcPy, path.join(targetDir, pyFile), { recursive: true });
+  const srcTs = path2.join(sourceDir, tsFile);
+  if (existsSync2(srcTs))
+    cpSync(srcTs, path2.join(targetDir, tsFile), { recursive: true });
+  const srcPy = path2.join(sourceDir, pyFile);
+  if (existsSync2(srcPy)) {
+    cpSync(srcPy, path2.join(targetDir, pyFile), { recursive: true });
     hasPython = true;
   }
   return hasPython;
 }
 function installRules(categories, rulesSourceDir, targetRulesDir) {
-  if (!existsSync(targetRulesDir))
-    mkdirSync(targetRulesDir, { recursive: true });
+  if (!existsSync2(targetRulesDir))
+    mkdirSync2(targetRulesDir, { recursive: true });
   const installedRulePaths = [];
-  const commonSource = path.join(rulesSourceDir, "common");
-  const commonTarget = path.join(targetRulesDir, "common");
-  if (existsSync(commonSource)) {
-    if (!existsSync(commonTarget))
-      mkdirSync(commonTarget, { recursive: true });
-    const files = readdirSync(commonSource).filter((f) => f.endsWith(".md"));
-    for (const file of files) {
-      cpSync(path.join(commonSource, file), path.join(commonTarget, file));
-      installedRulePaths.push(`./${RULES_SUBDIR}/common/${file}`);
-    }
-  }
-  for (const category of categories) {
-    const catSource = path.join(rulesSourceDir, category);
-    const catTarget = path.join(targetRulesDir, category);
-    if (existsSync(catSource)) {
-      if (!existsSync(catTarget))
-        mkdirSync(catTarget, { recursive: true });
-      const files = readdirSync(catSource).filter((f) => f.endsWith(".md"));
+  const copyDir = (srcFolder, targetFolder, relativePathPrefix) => {
+    if (existsSync2(srcFolder)) {
+      if (!existsSync2(targetFolder))
+        mkdirSync2(targetFolder, { recursive: true });
+      const files = readdirSync(srcFolder).filter((f) => f.endsWith(".md"));
       for (const file of files) {
-        cpSync(path.join(catSource, file), path.join(catTarget, file));
-        installedRulePaths.push(`./${RULES_SUBDIR}/${category}/${file}`);
+        cpSync(path2.join(srcFolder, file), path2.join(targetFolder, file));
+        installedRulePaths.push(`./${RULES_SUBDIR}/${relativePathPrefix}/${file}`);
       }
     }
+  };
+  copyDir(path2.join(rulesSourceDir, "common"), path2.join(targetRulesDir, "common"), "common");
+  for (const category of categories) {
+    copyDir(path2.join(rulesSourceDir, category), path2.join(targetRulesDir, category), category);
   }
   return installedRulePaths;
 }
+function removeToolFiles(toolName, targetDir) {
+  const tsFile = path2.join(targetDir, `${toolName}.ts`);
+  const pyFile = path2.join(targetDir, `${toolName}.py`);
+  if (existsSync2(tsFile))
+    rmSync(tsFile, { force: true });
+  if (existsSync2(pyFile))
+    rmSync(pyFile, { force: true });
+}
+function removeRuleCategory(category, targetRulesDir) {
+  const catDir = path2.join(targetRulesDir, category);
+  if (existsSync2(catDir)) {
+    rmSync(catDir, { recursive: true, force: true });
+  }
+}
+
+// src/utils/python.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync3, writeFileSync as writeFileSync2, readFileSync as readFileSync2 } from "fs";
+import path3 from "path";
 function setupPythonEnvironment(rootDir, spinner) {
   spinner.message(`Initializing Python environment in ./.venv ...`);
   try {
-    const reqPath = path.join(rootDir, "requirements.txt");
+    const reqPath = path3.join(rootDir, "requirements.txt");
     const reqContent = `# 核心依赖
 requests>=2.28.0
 urllib3>=1.26.0
 python-dotenv>=0.19.0
 `;
-    if (!existsSync(reqPath)) {
-      writeFileSync(reqPath, reqContent, "utf-8");
+    if (!existsSync3(reqPath)) {
+      writeFileSync2(reqPath, reqContent, "utf-8");
     } else {
-      const existingReq = readFileSync(reqPath, "utf-8");
+      const existingReq = readFileSync2(reqPath, "utf-8");
       if (!existingReq.includes("requests>="))
-        writeFileSync(reqPath, existingReq + `
+        writeFileSync2(reqPath, existingReq + `
 ` + reqContent, "utf-8");
     }
-    const venvPath = path.join(rootDir, ".venv");
-    if (!existsSync(venvPath)) {
+    const venvPath = path3.join(rootDir, ".venv");
+    if (!existsSync3(venvPath)) {
       try {
         execSync(`python3 -m venv "${venvPath}"`, { stdio: "ignore" });
       } catch {
         execSync(`python -m venv "${venvPath}"`, { stdio: "ignore" });
       }
     }
-    const pipCmd = process.platform === "win32" ? path.join(venvPath, "Scripts", "pip") : path.join(venvPath, "bin", "pip");
+    const pipCmd = process.platform === "win32" ? path3.join(venvPath, "Scripts", "pip") : path3.join(venvPath, "bin", "pip");
     spinner.message(`Installing Python dependencies...`);
     execSync(`"${pipCmd}" install -r "${reqPath}"`, { stdio: "ignore" });
   } catch (pyError) {
-    R2.warn(`⚠️ Failed to initialize Python environment. Manual setup required.`);
+    spinner.stop();
+    handleExecError(pyError, "Failed to initialize Python environment. Manual setup required.", "warn" /* WARN */);
   }
 }
+function getPythonActivationCmd() {
+  const isWin = process.platform === "win32";
+  return isWin ? ".\\.venv\\Scripts\\Activate.ps1" : "source .venv/bin/activate";
+}
+
+// src/commands/add.ts
 async function runAdd(args) {
   const repository = args[0];
   if (!repository) {
-    console.error(`${CYAN}Error:${RESET} Repository name required.`);
+    handleExecError(new Error("Repository name is missing"), "Argument Error", "error" /* ERROR */);
     process.exit(1);
   }
   const repoUrl = `https://github.com/${repository}.git`;
@@ -6156,9 +6266,9 @@ async function runAdd(args) {
 Target: ${CYAN}${OPENCODE_DIR}${RESET}`, "Initializing");
   R2.step("Executing standard skills installer (pnpx skills add)...");
   try {
-    execSync(`pnpx skills add ${repository} --agent opencode`, { stdio: "inherit" });
-  } catch {
-    R2.warn("Skills installer finished with warnings.");
+    execSync2(`pnpx skills add ${repository} --agent opencode`, { stdio: "inherit" });
+  } catch (err) {
+    handleExecError(err, "Skills installer finished with warnings", "warn" /* WARN */);
   }
   const s = bt2();
   s.start("Fetching remote repository...");
@@ -6166,89 +6276,85 @@ Target: ${CYAN}${OPENCODE_DIR}${RESET}`, "Initializing");
   try {
     tempDir = await cloneRepo(repoUrl);
     s.stop("Remote repository parsed.");
-    const toolDirPath = path.join(tempDir, "tool");
-    const rulesDirPath = path.join(tempDir, "rules");
-    const hasTools = existsSync(toolDirPath);
-    const hasRules = existsSync(rulesDirPath);
-    if (!hasTools && !hasRules) {
-      return R2.warn('Neither "tool" nor "rules" directory found in repository.');
-    }
+    const toolDirPath = path4.join(tempDir, "tool");
+    const rulesDirPath = path4.join(tempDir, "rules");
+    const hasTools = existsSync4(toolDirPath);
+    const hasRules = existsSync4(rulesDirPath);
+    if (!hasTools && !hasRules)
+      return handleExecError(new Error(`Neither "tool' nor "rules' directory found in repository.`), "warn" /* WARN */);
     let selectedTools = [];
     let selectedRules = [];
     if (hasTools) {
-      const availableTools = readdirSync(toolDirPath).filter((f) => f.endsWith(".ts")).map((f) => f.replace(/\.ts$/, ""));
-      if (availableTools.length > 0) {
-        const result = await je({
+      const opts = readdirSync2(toolDirPath).filter((f) => f.endsWith(".ts")).map((f) => f.replace(/\.ts$/, ""));
+      if (opts.length > 0) {
+        const res = await je({
           message: "Select tools to install (space to toggle)",
-          options: availableTools.map((t) => ({ value: t, label: t })),
+          options: opts.map((t) => ({ value: t, label: t })),
           required: false
         });
-        if (Ct(result))
+        if (Ct(res))
           return Ne("Installation cancelled.");
-        if (Array.isArray(result))
-          selectedTools = result;
+        if (Array.isArray(res))
+          selectedTools = res;
       }
     }
     if (hasRules) {
-      const availableRules = readdirSync(rulesDirPath, { withFileTypes: true }).filter((dirent) => dirent.isDirectory() && dirent.name !== "common").map((dirent) => dirent.name);
-      if (availableRules.length > 0) {
-        const result = await je({
-          message: "Select rule categories to install (space to toggle)",
-          options: availableRules.map((r) => ({ value: r, label: r })),
+      const opts = readdirSync2(rulesDirPath, { withFileTypes: true }).filter((d2) => d2.isDirectory() && d2.name !== "common").map((d2) => d2.name);
+      if (opts.length > 0) {
+        const res = await je({
+          message: "Select rule categories to install",
+          options: opts.map((r) => ({ value: r, label: r })),
           required: false
         });
-        if (Ct(result))
+        if (Ct(res))
           return Ne("Installation cancelled.");
-        if (Array.isArray(result))
-          selectedRules = result;
+        if (Array.isArray(res))
+          selectedRules = res;
       }
     }
-    if (selectedTools.length === 0 && selectedRules.length === 0) {
-      Ne("No tools or rules selected.");
-      return;
-    }
+    if (selectedTools.length === 0 && selectedRules.length === 0)
+      return Ne("No tools or rules selected.");
     const installSpinner = bt2();
     installSpinner.start(`Installing to ${OPENCODE_DIR}/ ...`);
+    ensureOpencodeConfig();
     const lockData = readLockFile();
     const now = new Date().toISOString();
     let requiresPython = false;
-    ensureOpencodeConfig();
+    let installedRulePaths = [];
     if (selectedTools.length > 0) {
-      const targetToolDir = path.join(process.cwd(), OPENCODE_DIR, TOOL_SUBDIR);
-      if (!existsSync(targetToolDir))
-        mkdirSync(targetToolDir, { recursive: true });
+      const targetToolDir = path4.join(process.cwd(), OPENCODE_DIR, TOOL_SUBDIR);
+      if (!existsSync4(targetToolDir))
+        mkdirSync3(targetToolDir, { recursive: true });
       for (const tool of selectedTools) {
-        const hasPy = copyToolFiles(tool, toolDirPath, targetToolDir);
-        if (hasPy)
+        if (copyToolFiles(tool, toolDirPath, targetToolDir))
           requiresPython = true;
         if (lockData.tools)
           lockData.tools[tool] = { source: repoUrl, installedAt: now };
       }
-      updateOpencodeConfigTools(selectedTools);
     }
     if (selectedRules.length > 0) {
-      const targetRulesDir = path.join(process.cwd(), OPENCODE_DIR, RULES_SUBDIR);
-      const installedRulePaths = installRules(selectedRules, rulesDirPath, targetRulesDir);
+      const targetRulesDir = path4.join(process.cwd(), OPENCODE_DIR, RULES_SUBDIR);
+      installedRulePaths = installRules(selectedRules, rulesDirPath, targetRulesDir);
       for (const rule of selectedRules) {
         if (!lockData.rules)
           lockData.rules = {};
         lockData.rules[rule] = { source: repoUrl, installedAt: now };
       }
-      updateOpencodeConfigInstructions(installedRulePaths);
     }
+    updateOpencodeConfig(selectedTools, installedRulePaths);
     writeLockFile(lockData);
-    if (requiresPython) {
+    if (requiresPython)
       setupPythonEnvironment(process.cwd(), installSpinner);
+    await new Promise((r) => setTimeout(r, 400));
+    installSpinner.stop(`${GREEN}Successfully installed ${selectedTools.length + selectedRules.length} items.${RESET}`);
+    if (requiresPython) {
+      Ve(`Your Python tools are ready. Run:
+
+  ${CYAN}${getPythonActivationCmd()}${RESET}`, "\uD83D\uDC0D Python Environment");
     }
-    const totalInstalled = selectedTools.length + selectedRules.length;
-    installSpinner.stop(`${GREEN}Successfully installed ${totalInstalled} items.${RESET}`);
   } catch (error) {
     s.stop("Failed to fetch repository.");
-    if (error instanceof GitCloneError)
-      R2.error(`${YELLOW}Git Error:${RESET}
-${error.message}`);
-    else
-      R2.error(`Error: ${error.message}`);
+    handleExecError(error, "Repository Fetch Error", "error" /* ERROR */);
   } finally {
     if (tempDir)
       await cleanupTempDir(tempDir).catch(() => {});
@@ -6256,57 +6362,48 @@ ${error.message}`);
   Le(`✨ Workspace updated for ${CYAN}${OPENCODE_DIR}${RESET}`);
 }
 
-// src/list.ts
-import { execSync as execSync2 } from "child_process";
+// src/commands/list.ts
+import { execSync as execSync3 } from "child_process";
 async function runList(args) {
   const lockData = readLockFile();
   console.log(`
 ${BOLD}\uD83D\uDEE0️  Installed Tools (${OPENCODE_DIR}/${TOOL_SUBDIR}):${RESET}
 `);
   const tools = Object.keys(lockData.tools || {});
-  if (tools.length === 0) {
+  if (tools.length === 0)
     console.log(`  ${DIM}No tools installed yet.${RESET}`);
-  } else {
-    tools.forEach((t) => {
-      const source = lockData.tools[t]?.source || "unknown";
-      console.log(`  ${CYAN}◆${RESET} ${t} ${DIM}(${source})${RESET}`);
-    });
-  }
+  else
+    tools.forEach((t) => console.log(`  ${CYAN}◆${RESET} ${t} ${DIM}(${lockData.tools[t]?.source || "unknown"})${RESET}`));
   console.log(`
 ${BOLD}\uD83D\uDCDC  Installed Rules (${OPENCODE_DIR}/${RULES_SUBDIR}):${RESET}
 `);
   const rules = Object.keys(lockData.rules || {});
-  if (rules.length === 0) {
+  if (rules.length === 0)
     console.log(`  ${DIM}No rules installed yet.${RESET}`);
-  } else {
-    rules.forEach((r) => {
-      const source = lockData.rules[r]?.source || "unknown";
-      console.log(`  ${CYAN}◆${RESET} ${r} ${DIM}(${source})${RESET}`);
-    });
-  }
+  else
+    rules.forEach((r) => console.log(`  ${CYAN}◆${RESET} ${r} ${DIM}(${lockData.rules[r]?.source || "unknown"})${RESET}`));
   console.log(`
 ${BOLD}\uD83E\uDE84  Installed Skills (Standard):${RESET}
 `);
   try {
-    execSync2("pnpx skills ls", { stdio: "inherit" });
+    execSync3("pnpx skills ls", { stdio: "inherit" });
   } catch (error) {
-    console.log(`  ${YELLOW}No standard skills found or failed to fetch.${RESET}`);
+    handleExecError(error, "No standard skills found or failed to fetch", "warn" /* WARN */);
   }
-  console.log();
 }
 
-// src/update.ts
-import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync2 } from "fs";
-import path2 from "path";
+// src/commands/update.ts
+import { execSync as execSync4 } from "child_process";
+import { existsSync as existsSync5 } from "fs";
+import path5 from "path";
 async function runUpdate(args) {
   console.log(`
 ${BOLD}\uD83E\uDE84  Updating Standard Skills...${RESET}
 `);
   try {
-    execSync3("pnpx skills update", { stdio: "inherit" });
+    execSync4("pnpx skills update", { stdio: "inherit" });
   } catch (error) {
-    console.log(`  ${YELLOW}Failed to update standard skills or none installed.${RESET}`);
+    handleExecError(error, "Failed to update standard skills", "warn" /* WARN */);
   }
   console.log(`
 ${BOLD}\uD83D\uDCE6  Updating Local Tools & Rules...${RESET}
@@ -6315,73 +6412,174 @@ ${BOLD}\uD83D\uDCE6  Updating Local Tools & Rules...${RESET}
   const toolNames = Object.keys(lockData.tools || {});
   const ruleNames = Object.keys(lockData.rules || {});
   if (toolNames.length === 0 && ruleNames.length === 0) {
-    console.log(`  ${DIM}No local tools or rules tracked in lock file.${RESET}
+    return console.log(`  ${DIM}No local items to update.${RESET}
 `);
-    return;
   }
   const itemsBySource = {};
   toolNames.forEach((t) => {
-    const src = lockData.tools[t]?.source;
-    if (src) {
-      itemsBySource[src] = itemsBySource[src] || { tools: [], rules: [] };
-      itemsBySource[src].tools.push(t);
+    const s2 = lockData.tools[t]?.source;
+    if (s2) {
+      itemsBySource[s2] = itemsBySource[s2] || { tools: [], rules: [] };
+      itemsBySource[s2].tools.push(t);
     }
   });
   ruleNames.forEach((r) => {
-    const src = lockData.rules[r]?.source;
-    if (src) {
-      itemsBySource[src] = itemsBySource[src] || { tools: [], rules: [] };
-      itemsBySource[src].rules.push(r);
+    const s2 = lockData.rules[r]?.source;
+    if (s2) {
+      itemsBySource[s2] = itemsBySource[s2] || { tools: [], rules: [] };
+      itemsBySource[s2].rules.push(r);
     }
   });
-  const targetToolDir = path2.join(process.cwd(), OPENCODE_DIR, TOOL_SUBDIR);
-  const targetRulesDir = path2.join(process.cwd(), OPENCODE_DIR, RULES_SUBDIR);
+  const targetToolDir = path5.join(process.cwd(), OPENCODE_DIR, TOOL_SUBDIR);
+  const targetRulesDir = path5.join(process.cwd(), OPENCODE_DIR, RULES_SUBDIR);
   const now = new Date().toISOString();
-  let successCount = 0;
-  for (const [source, items] of Object.entries(itemsBySource)) {
-    const s = bt2();
-    s.start(`Fetching from ${CYAN}${source}${RESET}...`);
+  const sourcesCount = Object.keys(itemsBySource).length;
+  const s = bt2();
+  s.start(`Fetching from ${CYAN}${sourcesCount}${RESET} source(s) concurrently...`);
+  const updatePromises = Object.entries(itemsBySource).map(async ([source, items]) => {
     let tempDir = null;
+    let successCount = 0;
+    const logs = [];
     try {
       tempDir = await cloneRepo(source);
-      if (items.tools.length > 0) {
-        const toolDirPath = path2.join(tempDir, "tool");
-        if (existsSync2(toolDirPath)) {
-          for (const tool of items.tools) {
-            copyToolFiles(tool, toolDirPath, targetToolDir);
-            if (lockData.tools[tool])
-              lockData.tools[tool].installedAt = now;
-            successCount++;
-            console.log(`  ${GREEN}✓${RESET} Updated tool: ${tool}`);
-          }
+      if (items.tools.length > 0 && existsSync5(path5.join(tempDir, "tool"))) {
+        for (const tool of items.tools) {
+          copyToolFiles(tool, path5.join(tempDir, "tool"), targetToolDir);
+          if (lockData.tools[tool])
+            lockData.tools[tool].installedAt = now;
+          successCount++;
+          logs.push(`  ${GREEN}✓${RESET} Updated tool: ${tool}`);
         }
       }
-      if (items.rules.length > 0) {
-        const rulesDirPath = path2.join(tempDir, "rules");
-        if (existsSync2(rulesDirPath)) {
-          installRules(items.rules, rulesDirPath, targetRulesDir);
-          for (const rule of items.rules) {
-            if (lockData.rules[rule])
-              lockData.rules[rule].installedAt = now;
-            successCount++;
-            console.log(`  ${GREEN}✓${RESET} Updated rule: ${rule}`);
-          }
+      if (items.rules.length > 0 && existsSync5(path5.join(tempDir, "rules"))) {
+        installRules(items.rules, path5.join(tempDir, "rules"), targetRulesDir);
+        for (const rule of items.rules) {
+          if (lockData.rules[rule])
+            lockData.rules[rule].installedAt = now;
+          successCount++;
+          logs.push(`  ${GREEN}✓${RESET} Updated rule: ${rule}`);
         }
       }
-      s.stop(`Done with ${source}`);
+      return { source, success: true, count: successCount, logs };
     } catch (err) {
-      s.stop(`  ${YELLOW}✗ Failed to fetch from ${source}${RESET}`);
+      return { source, success: false, count: 0, error: err, logs: [] };
     } finally {
       if (tempDir)
         await cleanupTempDir(tempDir).catch(() => {});
     }
+  });
+  const results = await Promise.allSettled(updatePromises);
+  s.stop(`Finished fetching from ${sourcesCount} source(s).`);
+  let totalSuccessCount = 0;
+  for (const result of results) {
+    if (result.status === "fulfilled") {
+      const { source, success, count, logs, error } = result.value;
+      if (success) {
+        totalSuccessCount += count;
+        logs.forEach((log) => console.log(log));
+      } else {
+        handleExecError(error, `Failed to fetch from ${source}`, "warn" /* WARN */);
+      }
+    } else {
+      handleExecError(result.reason, "Unexpected error during concurrent update", "error" /* ERROR */);
+    }
   }
   writeLockFile(lockData);
-  console.log();
-  if (successCount > 0) {
-    console.log(`${TEXT}✓ Successfully updated ${successCount} local item(s)${RESET}`);
+  if (totalSuccessCount > 0) {
+    console.log(`${TEXT}✓ Successfully updated ${totalSuccessCount} local item(s)${RESET}
+`);
   }
-  console.log();
+}
+
+// src/commands/remove.ts
+import { execSync as execSync5 } from "child_process";
+import path6 from "path";
+async function runRemove(args) {
+  We(`${BG_CYAN} vibe cli ${RESET}`);
+  R2.step("Executing standard skills remover (pnpx skills remove)...");
+  try {
+    const cmdArgs = args.length > 0 ? args.join(" ") : "";
+    execSync5(`pnpx skills remove ${cmdArgs}`.trim(), { stdio: "inherit" });
+  } catch (err) {
+    R2.warn("Skills remover finished with warnings or nothing to remove.");
+  }
+  const lockData = readLockFile();
+  const installedTools = Object.keys(lockData.tools || {});
+  const installedRules = Object.keys(lockData.rules || {});
+  if (installedTools.length === 0 && installedRules.length === 0) {
+    R2.info(`No local tools or rules found in ${OPENCODE_DIR}.`);
+    return Le(`✨ Removal process completed.`);
+  }
+  let toolsToRemove = [];
+  let rulesToRemove = [];
+  if (args.length > 0) {
+    for (const arg of args) {
+      if (installedTools.includes(arg))
+        toolsToRemove.push(arg);
+      else if (installedRules.includes(arg))
+        rulesToRemove.push(arg);
+      else {
+        R2.info(`Local item '${arg}' not found, skipping local cleanup.`);
+      }
+    }
+  } else {
+    if (installedTools.length > 0) {
+      const res = await je({
+        message: "Select local tools to remove (space to toggle)",
+        options: installedTools.map((t) => ({ value: t, label: t })),
+        required: false
+      });
+      if (Ct(res))
+        return Ne("Operation cancelled.");
+      if (Array.isArray(res))
+        toolsToRemove = res;
+    }
+    if (installedRules.length > 0) {
+      const res = await je({
+        message: "Select rule categories to remove (space to toggle)",
+        options: installedRules.map((r) => ({ value: r, label: r })),
+        required: false
+      });
+      if (Ct(res))
+        return Ne("Operation cancelled.");
+      if (Array.isArray(res))
+        rulesToRemove = res;
+    }
+  }
+  if (toolsToRemove.length === 0 && rulesToRemove.length === 0) {
+    if (args.length === 0)
+      Ne("No local items selected for removal.");
+    else
+      Le(`✨ Removal process completed.`);
+    return;
+  }
+  const confirm = await Re({
+    message: `Are you sure you want to completely remove ${toolsToRemove.length} local tool(s) and ${rulesToRemove.length} local rule(s)?`
+  });
+  if (Ct(confirm) || !confirm) {
+    return Ne("Operation cancelled.");
+  }
+  const s = bt2();
+  s.start(`Cleaning up local workspace...`);
+  try {
+    const targetToolDir = path6.join(process.cwd(), OPENCODE_DIR, TOOL_SUBDIR);
+    const targetRulesDir = path6.join(process.cwd(), OPENCODE_DIR, RULES_SUBDIR);
+    for (const tool of toolsToRemove) {
+      removeToolFiles(tool, targetToolDir);
+      delete lockData.tools[tool];
+    }
+    for (const rule of rulesToRemove) {
+      removeRuleCategory(rule, targetRulesDir);
+      delete lockData.rules[rule];
+    }
+    removeOpencodeConfig(toolsToRemove, rulesToRemove);
+    writeLockFile(lockData);
+    s.stop(`${GREEN}Successfully removed selected local items.${RESET}`);
+  } catch (e2) {
+    s.stop("Failed to complete local removal.");
+    handleExecError(e2, "Removal Error", "error" /* ERROR */);
+  }
+  Le(`✨ Workspace cleaned for ${CYAN}${OPENCODE_DIR}${RESET}`);
 }
 
 // src/cli.ts
@@ -6393,9 +6591,20 @@ var VIBE_LOGO = [
   " ╚████╔╝ ██║██████╔╝███████╗",
   "  ╚═══╝  ╚═╝╚═════╝ ╚══════╝"
 ];
+var GRAYS = [
+  "\x1B[38;5;250m",
+  "\x1B[38;5;248m",
+  "\x1B[38;5;245m",
+  "\x1B[38;5;243m",
+  "\x1B[38;5;240m",
+  "\x1B[38;5;238m"
+];
 function showLogo() {
   console.log();
-  VIBE_LOGO.forEach((line) => console.log(`${CYAN}${line}${RESET}`));
+  VIBE_LOGO.forEach((line, i) => {
+    const color = GRAYS[i] || GRAYS[GRAYS.length - 1];
+    console.log(`${color}${line}${RESET}`);
+  });
   console.log();
 }
 function showBanner() {
@@ -6405,6 +6614,7 @@ function showBanner() {
   console.log(`  ${DIM}$${RESET} ${TEXT}vibe add <repository>${RESET}    ${DIM}Add skills & tools${RESET}`);
   console.log(`  ${DIM}$${RESET} ${TEXT}vibe list${RESET}                ${DIM}List installed tools & skills${RESET}`);
   console.log(`  ${DIM}$${RESET} ${TEXT}vibe update${RESET}              ${DIM}Update installed tools & skills${RESET}`);
+  console.log(`  ${DIM}$${RESET} ${TEXT}vibe remove${RESET}              ${DIM}Remove tools & rules${RESET}`);
   console.log();
   console.log(`${DIM}Example:${RESET} vibe add helloggx/skill`);
   console.log();
@@ -6419,6 +6629,7 @@ ${BOLD}Manage Tools & Skills:${RESET}
                             https://github.com/helloggx/skill
   list, ls             List installed tools & skills for .opencode
   update, up           Update all local tools and standard skills
+  remove, rm         Remove selected tools & rules from .opencode
 
 ${BOLD}Options:${RESET}
   --help, -h        Show this help message
@@ -6427,6 +6638,7 @@ ${BOLD}Examples:${RESET}
   ${DIM}$${RESET} vibe add helloggx/skill
   ${DIM}$${RESET} vibe list                          ${DIM}# list installed tools and skills${RESET}
   ${DIM}$${RESET} vibe update                        ${DIM}# check and update all items${RESET}
+  ${DIM}$${RESET} vibe remove                        ${DIM}# remove selected tools and rules${RESET}
 
 The Design-Driven Agent Skills Ecosystem
 `);
@@ -6445,6 +6657,11 @@ async function main() {
       showLogo();
       await runAdd(args.slice(1));
       break;
+    case "rm":
+    case "remove":
+      console.clear();
+      await runRemove(args.slice(1));
+      break;
     case "ls":
     case "list":
       await runList(args.slice(1));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-coder/cli",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Vibe Coding development tool",
   "private": false,
   "type": "module",