accio-context 1.0.0

package/README.md

@@ -0,0 +1,492 @@
+# Accio 上下文知识库
+
+一个全面的开发知识库和指南仓库，专为Accio项目设计，旨在确保整个开发团队在代码质量、架构模式和开发实践方面的一致性。
+
+---
+
+## 项目概述
+
+本知识库作为Accio应用程序开发标准、架构指南和最佳实践的中心仓库。它提供结构化文档，涵盖从基础继承模式到高级缓存策略和分析实现的各个方面。
+
+**架构模式**: 文档驱动开发，采用模块化规范结构
+**核心技术**: Android SDK、iOS SDK、Web前端技术栈、Java后端技术栈、MVP/PART架构、MTOP网络框架、FastJSON、DX框架
+**主要特性**: 全栈开发规范、分层架构规范、代码风格强制执行、记忆驱动学习系统
+
+## User Growth Agent System
+
+The repository now includes a sophisticated **User Growth Agent System** located in `accio-agent-task/user_growth/`, which implements a multi-agent architecture for intelligent user growth services.
+
+### Key Features
+- 🤖 **Intelligent Agent Routing**: LLM-based intent recognition and agent selection
+- 🔄 **Multi-modal Processing**: Unified handling of text and image inputs
+- ⚡ **Async Streaming**: Real-time SSE event streaming for immediate response
+- 📊 **Full-chain Monitoring**: Complete execution tracking and performance analysis
+- 🧵 **Thread Pool Management**: Custom thread pool executor for high concurrency
+
+### Architecture Documentation
+- **Architecture Diagram**: [UserGrowth_Architecture.drawio](./UserGrowth_Architecture.drawio) - Complete system architecture visualization
+- **Technical Documentation**: [UserGrowth_Architecture_Documentation.md](./UserGrowth_Architecture_Documentation.md) - Comprehensive technical specifications
+
+---
+
+## 目录结构
+
+```
+accio-context/
+├── rules/                   # 开发规范和指南
+│   ├── android/            # Android开发规范
+│   │   └── .cursor/
+│   │       └── rules/
+│   │           ├── 00-page-development-index.mdc
+│   │           ├── 01-base-inheritance.mdc
+│   │           ├── 02-mvp-architecture.mdc
+│   │           ├── 03-part-architecture.mdc
+│   │           ├── 04-network-requests.mdc
+│   │           ├── 05-cache-strategy.mdc
+│   │           ├── 06-analytics-tracking.mdc
+│   │           ├── 07-dx-framework.mdc
+│   │           ├── 08-image-loading.mdc
+│   │           ├── 09-recyclerview-usage.mdc
+│   │           ├── 10-router.mdc
+│   │           ├── 11-dx-default-template-update.mdc
+│   │           ├── accio-android.mdc
+│   │           ├── async-framework-usage.mdc
+│   │           ├── fastjson-usage.mdc
+│   │           ├── memory-guidelines.mdc
+│   │           ├── multilingual-adaptation.mdc
+│   │           ├── nahida-unit-testing.mdc
+│   │           └── ui-styling-rules.mdc
+│   ├── iOS/                # iOS开发规范
+│   │   └── .cursor/
+│   │       └── rules/
+│   │           ├── dynamicx-usage.mdc
+│   │           ├── font.mdc
+│   │           ├── image-assets.mdc
+│   │           ├── learned-memories.mdc
+│   │           ├── memory.mdc
+│   │           ├── network.mdc
+│   │           ├── objetive-c.mdc
+│   │           └── user-track.mdc
+│   ├── web/                # Web开发规范
+│   │   └── .cursor/
+│   │       └── rules/
+│   │           ├── 00-page-development-index.mdc
+│   │           ├── 01-project-structure.mdc
+│   │           ├── 02-network-requests.mdc
+│   │           ├── 03-analytics-log.mdc
+│   │           ├── 04-icon.mdc
+│   │           ├── 05-img.mdc
+│   │           ├── 06-responsive.mdc
+│   │           ├── 07-code-formatting-rules.mdc
+│   │           ├── 08-dependency-architecture.mdc
+│   │           ├── 09-stylelint-configuration.mdc
+│   │           └── monorepo.mdc
+│   ├── java/               # Java后端开发规范
+│   │   └── .cursor/
+│   │       └── rules/
+│   │           ├── 01-overview.mdc
+│   │           ├── 02-code-style.mdc
+│   │           ├── 03-ddd.mdc
+│   │           ├── 04-hsf.mdc
+│   │           ├── 05-mybatis.mdc
+│   │           ├── 06-api-standards.mdc
+│   │           ├── 07-unit-testing.mdc
+│   │           ├── 08-interaction.mdc
+│   │           ├── async-reactive-patterns.mdc
+│   │           ├── configuration-management.mdc
+│   │           ├── database-tddl-patterns.mdc
+│   │           ├── error-handling-patterns.mdc
+│   │           ├── hsf-service-patterns.mdc
+│   │           ├── logging-monitoring-patterns.mdc
+│   │           ├── messaging-patterns.mdc
+│   │           ├── pandora-boot-patterns.mdc
+│   │           └── switch-config-patterns.mdc
+│   └── common/             # 通用开发指南
+│       └── .cursor/
+│           └── rules/
+│               ├── coding-principles.mdc
+│               ├── linux-torvalds.mdc
+│               ├── prd_review.md
+│               ├── r2c_workflow.mdc
+│               ├── readme-guidelines.mdc
+│               └── ux_design.md
+├── specs/                  # 产品规格和设计文档
+├── technical-design/       # 技术设计文档
+├── templates/              # 文档模板
+├── test-cases/            # 测试用例
+├── collaboration/         # 协作文档
+├── tools/                 # 开发工具
+├── todo/                  # 待办事项
+└── README.md
+```
+
+### 关键目录用途
+
+- **`rules/`**: 所有开发规范和指南的根目录
+  - **`android/`**: 全面的Android开发规范和架构模式
+  - **`iOS/`**: iOS开发规范和最佳实践
+  - **`web/`**: Web前端开发规范和指南
+  - **`java/`**: Java后端开发规范和架构模式
+  - **`common/`**: 跨平台的通用开发指南和原则
+- **`specs/`**: 产品规格和设计文档
+- **`technical-design/`**: 技术架构和设计文档
+- **`templates/`**: 文档模板和规范
+- **`test-cases/`**: 测试用例和测试规范
+- **`collaboration/`**: 团队协作文档和流程
+- **`tools/`**: 开发工具和脚本
+- **`todo/`**: 待办事项和任务跟踪
+
+---
+
+## 功能和特性
+
+### 🏗️ 架构规范
+- **基础继承模式**: 标准化的Activity/Fragment基类选择
+- **MVP架构**: 完整的MVP模式实现，包含presenter生命周期管理
+- **PART架构**: 用于复杂UI的高级基于组件的架构
+- **模块化设计**: 分层架构，关注点清晰分离
+
+### 🌐 网络和数据管理
+- **MTOP框架**: 全面的网络请求处理和API集成
+- **四层缓存策略**: 内存、磁盘、数据库和网络缓存实现
+- **FastJSON集成**: 类型安全的JSON解析和错误处理模式
+- **数据模型标准**: 强类型模型优于JSONObject使用
+
+### 📊 用户体验和分析
+- **分析跟踪**: 完整的用户行为和性能跟踪系统
+- **图片加载**: 优化的图片加载，集成LoadableImageView
+- **RecyclerView标准**: 使用AccioDpl框架的标准化列表实现
+- **DX框架**: 用于灵活UI渲染的动态模板系统
+
+### 🧠 记忆驱动学习系统
+- **项目记忆**: 常见错误及其纠正的持久存储
+- **代码风格强制执行**: 反模式的自动检测和预防
+- **最佳实践文档**: 真实世界的示例和实现指南
+- **持续改进**: 基于开发经验的迭代优化
+
+### 🤖 User Growth Intelligence System
+- **Multi-Agent Architecture**: Specialized agents for different types of user growth tasks
+- **Intelligent Routing**: LLM-powered agent selection based on query intent and complexity
+- **Streaming Processing**: Real-time SSE responses for enhanced user experience
+- **Performance Monitoring**: Comprehensive tracking of agent performance and user interactions
+- **Thread Pool Management**: Custom executor for high-concurrency multi-agent operations
+
+### 🌍 Development Support
+- **Multilingual Adaptation**: Guidelines for internationalization and localization
+- **Complex Task Processing**: Structured approach to large feature development
+- **README Standards**: Comprehensive documentation requirements and templates
+- **Memory Management**: Efficient knowledge retention and retrieval system
+
+---
+
+## 开始使用
+
+### 前置要求
+- Android Studio Arctic Fox或更高版本
+- JDK 8或更高版本
+- 对Android开发概念的基本理解
+- 熟悉MVP/MVVM架构模式
+
+### 设置说明
+
+1. **克隆仓库**
+   ```bash
+   git clone http://gitlab.alibaba-inc.com/accio/accio-context.git
+   cd accio-context
+   ```
+
+2. **与Cursor IDE集成**
+   - `.cursor/rules/`目录包含所有开发指南
+   - Cursor IDE将自动加载这些规则以提供上下文感知的协助
+   - 确保您的Cursor设置引用此知识库
+
+3. **审查核心指南**
+   - 从`android/00-page-development-index.mdc`开始，了解全面概述
+   - 阅读`genera/project-memory.mdc`了解常见陷阱和解决方案
+   - 查看`android/accio-android.mdc`了解开发工作流程
+
+4. **环境配置**
+   - 无需额外的构建配置
+   - 知识库仅为文档
+   - 将指南集成到您现有的Android项目工作流程中
+
+---
+
+## CLI 工具使用
+
+为了方便团队在其他项目中安装和使用这些规范，我们提供了 CLI 工具。
+
+### 安装 CLI 工具
+
+```bash
+# 全局安装
+npm install -g accio-context
+
+# 或使用 npx（无需安装）
+npx accio-context install
+```
+
+### 基本使用
+
+#### 列出可用的资源
+
+```bash
+accio-context list
+```
+
+#### 交互式安装
+
+```bash
+accio-context install
+```
+
+这个命令会：
+1. 自动从 git 仓库克隆或更新 accio-context 到 `~/.accio-context/repo`
+2. 显示交互式菜单，让你选择要安装的 rules、skills 和 templates
+3. 将选中的资源安装到当前项目（或指定的目标目录）
+
+**交互方式：**
+- 使用箭头键导航
+- 回车进入目录或安装文件
+- 选择"返回"选项返回上一级
+- 在主菜单选择"完成安装"执行实际安装
+
+#### 安装选项
+
+```bash
+accio-context install [options]
+
+Options:
+  -t, --target <path>    Target project path (default: current directory)
+  -r, --repo <url>        Repository URL (default: auto-detect)
+  -c, --config <path>     Config file (json/yaml)
+  --overwrite              Overwrite existing files
+  --dry-run                Show what would be copied
+  --json                   Output summary as JSON
+```
+
+#### 自定义仓库
+
+默认情况下，工具会：
+- 如果当前目录就是 accio-context 仓库（开发模式），使用当前目录
+- 否则，克隆默认仓库到 `~/.accio-context/repo`
+
+你可以指定自定义仓库 URL：
+
+```bash
+accio-context install --repo http://gitlab.alibaba-inc.com/accio/accio-context.git
+```
+
+或通过环境变量设置：
+
+```bash
+export ACCIO_CONTEXT_REPO=http://gitlab.alibaba-inc.com/accio/accio-context.git
+accio-context install
+```
+
+### 工作原理
+
+1. 工具获取 accio-context 仓库（从 git 或使用本地副本）
+2. 扫描可用的 rules、skills 和 templates
+3. 提供交互式菜单选择要安装的内容
+4. 将选中的文件复制到你的项目：
+   - Rules → `.cursor/rules/`
+   - Skills → `.cursor/skills/`
+   - Templates → `templates/`
+
+### 开发模式
+
+如果你在本地开发 CLI 工具：
+
+```bash
+# 安装依赖
+npm install
+
+# 本地运行
+node bin/accio-context.js install
+```
+
+---
+
+## 使用指南
+
+### 对于新开发者
+
+1. **从这里开始**: 阅读`android/00-page-development-index.mdc`了解完整的开发工作流程
+2. **架构理解**: 查看`02-mvp-architecture.mdc`和`03-part-architecture.mdc`
+3. **常见模式**: 学习`project-memory.mdc`了解经常遇到的问题和解决方案
+
+### 对于有经验的开发者
+
+1. **快速参考**: 使用规范文件作为实现细节的快速查找
+2. **代码审查**: 在代码审查过程中参考指南
+3. **架构决策**: 在做出架构选择之前咨询相关规范文件
+
+### API文档
+
+知识库提供以下规范：
+- **MTOP API集成**: 完整的请求/响应处理模式
+- **分析API**: 用户行为跟踪和性能监控
+- **缓存API**: 多层缓存管理和失效
+- **DX框架API**: 动态模板渲染和事件处理
+
+---
+
+## 实现细节
+
+### 架构概述
+
+知识库遵循**分层规范架构**：
+
+```
+┌─────────────────────────────────────┐
+│           视图层                    │
+├─────────────────────────────────────┤
+│           逻辑层                    │
+├─────────────────────────────────────┤
+│           服务层                    │
+├─────────────────────────────────────┤
+│           框架层                    │
+└─────────────────────────────────────┘
+```
+
+- **视图层**: UI组件、Activities、Fragments
+- **逻辑层**: Presenters、ViewModels、业务逻辑
+- **服务层**: 数据管理器、缓存处理器、API客户端
+- **框架层**: MTOP、DX、分析、图片加载
+
+### 数据流模式
+
+1. **请求流**: 视图 → Presenter → 服务 → 网络/缓存
+2. **响应流**: 网络/缓存 → 服务 → Presenter → 视图
+3. **错误处理**: 一致的错误传播，提供用户友好的消息
+4. **分析流**: 用户操作 → 分析服务 → 后端跟踪
+
+### 关键设计模式
+
+- **MVP模式**: 视图和业务逻辑的清晰分离
+- **仓库模式**: 具有多个源的统一数据访问层
+- **观察者模式**: 响应式数据更新和UI同步
+- **工厂模式**: 标准化对象创建和依赖注入
+- **策略模式**: 用于缓存和图片加载的可插拔算法
+
+### 性能考虑
+
+- **内存管理**: 高效的对象生命周期和垃圾回收
+- **网络优化**: 请求批处理、缓存和重试机制
+- **图片加载**: 懒加载、内存池和大小优化
+- **列表性能**: ViewHolder模式和数据绑定优化
+
+---
+
+## 开发指南
+
+### 代码风格标准
+
+1. **导入管理**: 始终使用import语句，不要使用完整类路径
+2. **类型安全**: 对于已知结构，优先使用数据类而非JSONObject
+3. **错误处理**: 全面的try-catch块，提供有意义的消息
+4. **文档**: 为复杂业务逻辑提供详细注释
+5. **命名约定**: 清晰、描述性的名称，遵循Android约定
+
+### 测试程序
+
+1. **单元测试**: 测试presenters和services中的业务逻辑
+2. **集成测试**: 测试API集成和缓存行为
+3. **UI测试**: 验证用户交互和导航流程
+4. **性能测试**: 监控内存使用和响应时间
+
+### 最佳实践
+
+- **记忆驱动开发**: 在实现之前始终检查`project-memory.mdc`
+- **规范合规**: 在开发过程中参考相关的`.mdc`文件
+- **代码审查**: 在同行审查过程中使用指南作为检查清单
+- **持续学习**: 用新发现和解决方案更新记忆文件
+
+### 要避免的常见陷阱
+
+1. **FastJSON误用**: 不要将Android JSONObject的`opt*`方法与FastJSON一起使用
+2. **数据覆盖**: 永远不要用分布式数据覆盖原始业务数据
+3. **状态管理**: 使用明确的状态标志，不要依赖数据字段存在
+4. **架构违规**: 维护清晰的层边界和职责
+
+---
+
+## 开发工作流程
+
+### 项目理解阶段
+- 分析现有代码以理解架构和模式
+- 识别关键设计模式和编码约定
+- 确保与已建立的项目模式一致
+
+### 需求分析阶段
+- 从用户角度思考以识别实际需求
+- 通过深思熟虑的讨论解决需求差距
+- 选择简单有效的解决方案而非复杂方案
+- 为复杂概念创建可视化图表
+
+### 代码实现阶段
+- 在实现之前充分规划
+- 应用SOLID原则和适当的设计模式
+- 使用具有明确里程碑的逐步方法
+- 为重要代码块编写全面注释
+- 实现适当的错误处理和监控
+
+### 问题解决阶段
+- 彻底分析相关代码以理解功能
+- 识别根本原因而非解决症状
+- 提出具有清晰推理的解决方案
+- 基于反馈迭代直到问题解决
+- 在记忆文件中记录解决方案以供将来参考
+
+---
+
+## 参考资料和资源
+
+### 内部文档
+- [Android页面开发索引](/rules/android/.cursor/rules/00-page-development-index.mdc)
+- [MVP架构指南](/rules/android/.cursor/rules/02-mvp-architecture.mdc)
+- [网络请求规范](/rules/android/.cursor/rules/04-network-requests.mdc)
+- [缓存策略实现](/rules/android/.cursor/rules/05-cache-strategy.mdc)
+- [Web开发索引](/rules/web/.cursor/rules/00-page-development-index.mdc)
+- [Java开发概览](/rules/java/.cursor/rules/01-overview.mdc)
+- [iOS开发指南](/rules/iOS/.cursor/rules/dynamicx-usage.mdc)
+- [通用编码原则](/rules/common/.cursor/rules/coding-principles.mdc)
+
+### 外部资源
+- [Android架构组件](https://developer.android.com/topic/libraries/architecture)
+- [MVP模式最佳实践](https://github.com/MindorksOpenSource/android-mvp-architecture)
+- [FastJSON文档](https://github.com/alibaba/fastjson)
+- [MTOP框架指南](https://internal-docs.alibaba.com/mtop)
+
+### 开发工具
+- **Cursor IDE**: 具有上下文感知的AI驱动开发环境
+- **Android Studio**: 具有插件支持的主要开发IDE
+- **Git**: 版本控制，使用约定式提交消息
+- **Gradle**: 构建自动化和依赖管理
+
+---
+
+## 贡献
+
+### 知识库更新
+1. 为新指南遵循已建立的`.mdc`文件格式
+2. 用新学习和解决方案更新`project-memory.mdc`
+3. 保持与现有文档结构的一致性
+4. 用真实实现示例测试指南
+
+### 记忆管理
+- 在记忆文件中添加新的错误和纠正
+- 保持信息通用和可重用
+- 使用清晰的标题和分类进行结构化
+- 定期清理过时或被取代的信息
+
+### 质量保证
+- 验证所有代码示例都能正常工作并经过测试
+- 确保文档与当前实现匹配
+- 审查清晰度和可访问性
+- 维护所有规范文件的一致性
+
+---
+
+*本知识库基于真实世界的开发经验和团队反馈持续发展。如有问题或建议，请参考项目记忆系统或咨询开发团队负责人。*

package/bin/accio-context.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+const { main } = require("../src/cli");
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "accio-context",
+  "version": "1.0.0",
+  "description": "CLI tool to install Accio context assets (rules, skills, templates) into projects",
+  "main": "src/cli.js",
+  "type": "commonjs",
+  "bin": {
+    "accio-context": "bin/accio-context.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "cursor",
+    "rules",
+    "skills",
+    "templates",
+    "cli"
+  ],
+  "author": "",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "http://gitlab.alibaba-inc.com/accio/accio-context.git"
+  },
+  "files": [
+    "bin",
+    "src",
+    "package.json",
+    "README.md"
+  ],
+  "dependencies": {
+    "commander": "^14.0.2",
+    "prompts": "^2.4.2",
+    "yaml": "^2.8.2"
+  }
+}

package/src/cli.js

@@ -0,0 +1,331 @@
+const fs = require("fs/promises");
+const path = require("path");
+const { Command } = require("commander");
+const prompts = require("prompts");
+const YAML = require("yaml");
+
+const { getInventory } = require("./inventory");
+const { buildCopyPlan, executeCopyPlan } = require("./install");
+const { getRepoRoot } = require("./repo");
+
+async function loadConfig(configPath) {
+  if (!configPath) {
+    return null;
+  }
+  const absolutePath = path.resolve(process.cwd(), configPath);
+  const contents = await fs.readFile(absolutePath, "utf-8");
+  const ext = path.extname(absolutePath).toLowerCase();
+  if (ext === ".json") {
+    return JSON.parse(contents);
+  }
+  if (ext === ".yaml" || ext === ".yml") {
+    return YAML.parse(contents);
+  }
+  throw new Error(`Unsupported config format: ${ext}`);
+}
+
+function printList(inventory) {
+  console.log("Domains:");
+  for (const domain of inventory.domains) {
+    console.log(`- ${domain.name} (${domain.ruleFiles.length} rules)`);
+  }
+  console.log("");
+  console.log("Skills:");
+  for (const skill of inventory.skills) {
+    console.log(`- ${skill.name}`);
+  }
+  console.log("");
+  console.log("Templates:");
+  for (const template of inventory.templates) {
+    console.log(`- ${template.name}`);
+  }
+}
+
+async function promptSelections(inventory) {
+  const selections = { domains: [], skills: [], templates: [], ruleFiles: [] };
+
+  // Navigation-style interaction: Enter to enter directory or install file
+  console.log("Tip: Use arrow keys to navigate, Enter to enter/install.\n");
+
+  while (true) {
+    const installedCount = 
+      selections.ruleFiles.length + selections.skills.length + selections.templates.length;
+    const status = installedCount > 0 ? ` [${installedCount} items ready]` : "";
+    
+    const mainChoices = [
+      { title: "rules", value: "rules" },
+      { title: "skills", value: "skills" },
+      { title: "templates", value: "templates" },
+      { title: `--- Complete and install${status} ---`, value: "done" },
+    ];
+
+    const mainResponse = await prompts({
+      type: "select",
+      name: "action",
+      message: "Main menu",
+      choices: mainChoices,
+    });
+
+    if (!mainResponse.action || mainResponse.action === "done") {
+      break;
+    }
+
+    if (mainResponse.action === "rules") {
+      await navigateRules(inventory, selections);
+    } else if (mainResponse.action === "skills") {
+      await navigateSkills(inventory, selections);
+    } else if (mainResponse.action === "templates") {
+      await navigateTemplates(inventory, selections);
+    }
+  }
+
+  return selections;
+}
+
+async function navigateRules(inventory, selections) {
+  while (true) {
+    const domainChoices = inventory.domains.map((domain) => {
+      const selectedCount = selections.ruleFiles.filter(
+        (r) => r.domain === domain.name
+      ).length;
+      const marker = selectedCount > 0 ? ` [${selectedCount} installed]` : "";
+      return {
+        title: `${domain.name} (${domain.ruleFiles.length} rules)${marker}`,
+        value: domain.name,
+      };
+    });
+    domainChoices.push({ title: "<- Back to main menu", value: "__back__" });
+
+    const domainResponse = await prompts({
+      type: "select",
+      name: "domain",
+      message: "Select a domain (Enter to enter)",
+      choices: domainChoices,
+    });
+
+    if (!domainResponse.domain || domainResponse.domain === "__back__") {
+      break;
+    }
+
+    const domainName = domainResponse.domain;
+    const domain = inventory.domains.find((d) => d.name === domainName);
+    if (!domain) continue;
+
+    // Navigate into domain - show rules
+    await navigateDomainRules(domainName, domain, selections);
+  }
+}
+
+async function navigateDomainRules(domainName, domain, selections) {
+  while (true) {
+    const alreadySelected = new Set(
+      selections.ruleFiles
+        .filter((r) => r.domain === domainName)
+        .map((r) => r.file.name)
+    );
+
+    const ruleChoices = domain.ruleFiles.map((rule) => {
+      const marker = alreadySelected.has(rule.name) ? " [installed]" : "";
+      return {
+        title: `${rule.name}${marker}`,
+        value: { domain: domainName, file: rule },
+      };
+    });
+    ruleChoices.push({ title: "<- Back to domains", value: "__back__" });
+
+    const ruleResponse = await prompts({
+      type: "select",
+      name: "rule",
+      message: `Rules in [${domainName}] (Enter to install)`,
+      choices: ruleChoices,
+    });
+
+    if (!ruleResponse.rule || ruleResponse.rule === "__back__") {
+      break;
+    }
+
+    // Install immediately
+    const ruleEntry = ruleResponse.rule;
+    const existingIndex = selections.ruleFiles.findIndex(
+      (r) => r.domain === domainName && r.file.name === ruleEntry.file.name
+    );
+
+    if (existingIndex < 0) {
+      // Add to selections
+      selections.ruleFiles.push(ruleEntry);
+      if (!selections.domains.includes(domainName)) {
+        selections.domains.push(domainName);
+      }
+      console.log(`  ✓ Installed: ${ruleEntry.file.name}`);
+    } else {
+      console.log(`  Already installed: ${ruleEntry.file.name}`);
+    }
+    // Continue browsing (don't break)
+  }
+}
+
+async function navigateSkills(inventory, selections) {
+  while (true) {
+    const alreadySelected = new Set(selections.skills);
+    const skillChoices = inventory.skills.map((skill) => {
+      const marker = alreadySelected.has(skill.name) ? " [installed]" : "";
+      return {
+        title: `${skill.name}${marker}`,
+        value: skill.name,
+      };
+    });
+    skillChoices.push({ title: "<- Back to main menu", value: "__back__" });
+
+    const skillResponse = await prompts({
+      type: "select",
+      name: "skill",
+      message: "Select a skill (Enter to install)",
+      choices: skillChoices,
+    });
+
+    if (!skillResponse.skill || skillResponse.skill === "__back__") {
+      break;
+    }
+
+    // Install immediately
+    const skillName = skillResponse.skill;
+    const index = selections.skills.indexOf(skillName);
+    if (index < 0) {
+      selections.skills.push(skillName);
+      console.log(`  ✓ Installed: ${skillName}`);
+    } else {
+      console.log(`  Already installed: ${skillName}`);
+    }
+    // Continue browsing (don't break)
+  }
+}
+
+async function navigateTemplates(inventory, selections) {
+  while (true) {
+    const alreadySelected = new Set(selections.templates);
+    const templateChoices = inventory.templates.map((template) => {
+      const marker = alreadySelected.has(template.name) ? " [installed]" : "";
+      return {
+        title: `${template.name}${marker}`,
+        value: template.name,
+      };
+    });
+    templateChoices.push({ title: "<- Back to main menu", value: "__back__" });
+
+    const templateResponse = await prompts({
+      type: "select",
+      name: "template",
+      message: "Select a template (Enter to install)",
+      choices: templateChoices,
+    });
+
+    if (!templateResponse.template || templateResponse.template === "__back__") {
+      break;
+    }
+
+    // Install immediately
+    const templateName = templateResponse.template;
+    const index = selections.templates.indexOf(templateName);
+    if (index < 0) {
+      selections.templates.push(templateName);
+      console.log(`  ✓ Installed: ${templateName}`);
+    } else {
+      console.log(`  Already installed: ${templateName}`);
+    }
+    // Continue browsing (don't break)
+  }
+}
+
+function summarizeSelections(plan) {
+  return {
+    domains: plan.selectedDomains,
+    skills: plan.selectedSkills,
+    templates: plan.selectedTemplates,
+  };
+}
+
+async function runInstall(options) {
+  const repoRoot = await getRepoRoot(options.repo);
+  const inventory = await getInventory(repoRoot);
+  const config = await loadConfig(options.config);
+
+  const targetRoot = path.resolve(
+    process.cwd(),
+    options.target || (config && config.targetPath) || "."
+  );
+
+  const selections =
+    config || (await promptSelections(inventory)) || {
+      domains: [],
+      skills: [],
+      templates: [],
+    };
+
+  const plan = await buildCopyPlan(inventory, selections, targetRoot);
+  const results = await executeCopyPlan(plan, {
+    overwrite: Boolean(options.overwrite),
+    dryRun: Boolean(options.dryRun),
+  });
+
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          targetRoot,
+          selections: summarizeSelections(plan),
+          copied: results.copied.length,
+          conflicts: results.conflicts.length,
+          dryRun: Boolean(options.dryRun),
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+
+  console.log(`Target: ${targetRoot}`);
+  console.log(`Copied: ${results.copied.length}`);
+  if (results.conflicts.length > 0) {
+    console.log(
+      `Conflicts (skipped): ${results.conflicts.length} (use --overwrite to replace)`
+    );
+  }
+  if (options.dryRun) {
+    console.log("Dry run enabled: no files were copied.");
+  }
+}
+
+async function main() {
+  const program = new Command();
+  program.name("accio-context").description("Install Accio context assets.");
+
+  program
+    .command("list")
+    .description("List available domains, skills, and templates")
+    .option("-r, --repo <url>", "Repository URL (default: auto-detect)")
+    .action(async (options) => {
+      const repoRoot = await getRepoRoot(options.repo);
+      const inventory = await getInventory(repoRoot);
+      printList(inventory);
+    });
+
+  program
+    .command("install")
+    .description("Install selected assets into a target project")
+    .option("-c, --config <path>", "Config file (json/yaml)")
+    .option("-t, --target <path>", "Target project path")
+    .option("-r, --repo <url>", "Repository URL (default: auto-detect)")
+    .option("--overwrite", "Overwrite files on conflict")
+    .option("--dry-run", "Show what would be copied")
+    .option("--json", "Output summary as JSON")
+    .action(async (options) => {
+      await runInstall(options);
+    });
+
+  await program.parseAsync(process.argv);
+}
+
+module.exports = {
+  main,
+};

package/src/install.js

@@ -0,0 +1,192 @@
+const fs = require("fs/promises");
+const path = require("path");
+
+const { listFilesRecursive } = require("./inventory");
+
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function ensureDir(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+
+function normalizeTemplatesSelection(selection, templates) {
+  if (selection === true || selection === "all" || selection == null) {
+    return templates.map((template) => template.name);
+  }
+  if (Array.isArray(selection)) {
+    return selection;
+  }
+  return [];
+}
+
+function normalizeSkillsSelection(selection, skills) {
+  if (selection === true || selection === "all" || selection == null) {
+    return skills.map((skill) => skill.name);
+  }
+  if (Array.isArray(selection)) {
+    return selection;
+  }
+  return [];
+}
+
+function normalizeDomainsSelection(selection, domains) {
+  if (selection === true || selection === "all" || selection == null) {
+    return domains.map((domain) => domain.name);
+  }
+  if (Array.isArray(selection)) {
+    return selection;
+  }
+  return [];
+}
+
+async function collectSkillItems(skillsRoot, skillName, targetRoot) {
+  const sourceDir = path.join(skillsRoot, skillName);
+  const targetDir = path.join(targetRoot, ".cursor", "skills", skillName);
+  const sourceFiles = await listFilesRecursive(sourceDir);
+  return sourceFiles.map((sourcePath) => {
+    const relative = path.relative(sourceDir, sourcePath);
+    return {
+      sourcePath,
+      targetPath: path.join(targetDir, relative),
+      label: `skill:${skillName}`,
+    };
+  });
+}
+
+async function collectRuleItems(domain, rulesDir, targetRoot) {
+  const entries = await fs.readdir(rulesDir, { withFileTypes: true });
+  const files = entries.filter((entry) => entry.isFile()).map((entry) => entry.name);
+  return files.map((name) => ({
+    sourcePath: path.join(rulesDir, name),
+    targetPath: path.join(targetRoot, ".cursor", "rules", name),
+    label: `rules:${domain}`,
+  }));
+}
+
+async function collectTemplateItems(templatesRoot, templateName, targetRoot) {
+  const sourcePath = path.join(templatesRoot, templateName);
+  const targetPath = path.join(targetRoot, "templates", templateName);
+  return [{ sourcePath, targetPath, label: "templates" }];
+}
+
+function validateSelection(selected, available, label) {
+  const availableSet = new Set(available);
+  const invalid = selected.filter((item) => !availableSet.has(item));
+  if (invalid.length > 0) {
+    const message = `Unknown ${label}: ${invalid.join(", ")}`;
+    throw new Error(message);
+  }
+}
+
+async function buildCopyPlan(inventory, selections, targetRoot) {
+  const selectedSkills = normalizeSkillsSelection(
+    selections.skills,
+    inventory.skills
+  );
+  const selectedTemplates = normalizeTemplatesSelection(
+    selections.templates,
+    inventory.templates
+  );
+
+  validateSelection(
+    selectedSkills,
+    inventory.skills.map((skill) => skill.name),
+    "skills"
+  );
+  validateSelection(
+    selectedTemplates,
+    inventory.templates.map((template) => template.name),
+    "templates"
+  );
+
+  const items = [];
+
+  // Skills
+  for (const skill of selectedSkills) {
+    items.push(...(await collectSkillItems(inventory.skillsRoot, skill, targetRoot)));
+  }
+
+  // Rules: if ruleFiles provided (interactive mode), use them; otherwise use domains (config mode)
+  if (Array.isArray(selections.ruleFiles) && selections.ruleFiles.length > 0) {
+    for (const entry of selections.ruleFiles) {
+      const { domain, file } = entry;
+      items.push({
+        sourcePath: file.path,
+        targetPath: path.join(targetRoot, ".cursor", "rules", file.name),
+        label: `rules:${domain}`,
+      });
+    }
+  } else if (selections.domains) {
+    const selectedDomains = normalizeDomainsSelection(
+      selections.domains,
+      inventory.domains
+    );
+    validateSelection(
+      selectedDomains,
+      inventory.domains.map((d) => d.name),
+      "domains"
+    );
+    for (const domain of selectedDomains) {
+      const domainInfo = inventory.domains.find((entry) => entry.name === domain);
+      if (domainInfo) {
+        items.push(...(await collectRuleItems(domain, domainInfo.rulesDir, targetRoot)));
+      }
+    }
+  }
+
+  // Templates
+  for (const template of selectedTemplates) {
+    items.push(
+      ...(await collectTemplateItems(inventory.templatesRoot, template, targetRoot))
+    );
+  }
+
+  return {
+    items,
+    selectedDomains: selections.domains || [],
+    selectedSkills,
+    selectedTemplates,
+  };
+}
+
+async function executeCopyPlan(plan, { overwrite, dryRun }) {
+  const results = {
+    copied: [],
+    skipped: [],
+    conflicts: [],
+  };
+
+  for (const item of plan.items) {
+    const exists = await pathExists(item.targetPath);
+    if (exists && !overwrite) {
+      results.conflicts.push(item);
+      continue;
+    }
+
+    if (dryRun) {
+      results.skipped.push(item);
+      continue;
+    }
+
+    await ensureDir(path.dirname(item.targetPath));
+    await fs.copyFile(item.sourcePath, item.targetPath);
+    results.copied.push(item);
+  }
+
+  return results;
+}
+
+module.exports = {
+  buildCopyPlan,
+  executeCopyPlan,
+  normalizeDomainsSelection,
+  normalizeSkillsSelection,
+  normalizeTemplatesSelection,
+};

package/src/inventory.js

@@ -0,0 +1,94 @@
+const fs = require("fs/promises");
+const path = require("path");
+
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function listDirEntries(dirPath) {
+  if (!(await pathExists(dirPath))) {
+    return [];
+  }
+  return fs.readdir(dirPath, { withFileTypes: true });
+}
+
+async function listDirectories(dirPath) {
+  const entries = await listDirEntries(dirPath);
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+}
+
+async function listFiles(dirPath) {
+  const entries = await listDirEntries(dirPath);
+  return entries.filter((entry) => entry.isFile()).map((entry) => entry.name);
+}
+
+async function listFilesRecursive(dirPath) {
+  const entries = await listDirEntries(dirPath);
+  const files = [];
+  for (const entry of entries) {
+    const entryPath = path.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await listFilesRecursive(entryPath);
+      files.push(...nested);
+    } else if (entry.isFile()) {
+      files.push(entryPath);
+    }
+  }
+  return files;
+}
+
+async function getInventory(repoRoot) {
+  const skillsRoot = path.join(repoRoot, ".cursor", "skills");
+  const rulesRoot = path.join(repoRoot, "rules");
+  const templatesRoot = path.join(repoRoot, "templates");
+
+  const skillNames = await listDirectories(skillsRoot);
+  const skills = skillNames.map((name) => ({
+    name,
+    dir: path.join(skillsRoot, name),
+  }));
+
+  const domainNames = await listDirectories(rulesRoot);
+  const domains = [];
+  for (const domain of domainNames) {
+    const domainRulesDir = path.join(rulesRoot, domain, ".cursor", "rules");
+    if (await pathExists(domainRulesDir)) {
+      const ruleFileNames = await listFiles(domainRulesDir);
+      const ruleFiles = ruleFileNames.map((name) => ({
+        name,
+        path: path.join(domainRulesDir, name),
+      }));
+      domains.push({
+        name: domain,
+        rulesDir: domainRulesDir,
+        ruleFiles,
+      });
+    }
+  }
+
+  const templateFiles = await listFiles(templatesRoot);
+  const templates = templateFiles.map((name) => ({
+    name,
+    path: path.join(templatesRoot, name),
+  }));
+
+  return {
+    skillsRoot,
+    rulesRoot,
+    templatesRoot,
+    skills,
+    domains,
+    templates,
+    listFilesRecursive,
+  };
+}
+
+module.exports = {
+  getInventory,
+  listFilesRecursive,
+};

package/src/repo.js

@@ -0,0 +1,69 @@
+const fs = require("fs/promises");
+const path = require("path");
+const { execSync } = require("child_process");
+const os = require("os");
+
+// Default repository URL - can be overridden via --repo option or ACCIO_CONTEXT_REPO env var
+const DEFAULT_REPO_URL = process.env.ACCIO_CONTEXT_REPO || "http://gitlab.alibaba-inc.com/accio/accio-context.git";
+const CACHE_DIR = path.join(os.homedir(), ".accio-context", "repo");
+
+async function ensureRepo(repoUrl = DEFAULT_REPO_URL) {
+  // Check if repo exists and is up to date
+  const repoExists = await pathExists(CACHE_DIR);
+  
+  if (repoExists) {
+    try {
+      // Try to update existing repo
+      console.log("Updating repository...");
+      execSync("git pull", { cwd: CACHE_DIR, stdio: "ignore" });
+      return CACHE_DIR;
+    } catch (error) {
+      // If update fails, remove and re-clone
+      console.log("Repository update failed, re-cloning...");
+      await fs.rm(CACHE_DIR, { recursive: true, force: true });
+    }
+  }
+
+  // Clone repository
+  console.log(`Cloning repository from ${repoUrl}...`);
+  await fs.mkdir(path.dirname(CACHE_DIR), { recursive: true });
+  execSync(`git clone ${repoUrl} "${CACHE_DIR}"`, { stdio: "inherit" });
+  
+  return CACHE_DIR;
+}
+
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function getRepoRoot(repoUrl) {
+  if (repoUrl) {
+    // Custom repo URL provided
+    return await ensureRepo(repoUrl);
+  }
+  
+  // Check if we're running from the repo itself (development mode)
+  const currentDir = __dirname;
+  const repoRoot = path.resolve(currentDir, "..");
+  const hasRepoStructure = 
+    (await pathExists(path.join(repoRoot, ".cursor", "skills"))) ||
+    (await pathExists(path.join(repoRoot, "rules")));
+  
+  if (hasRepoStructure) {
+    // Running from repo itself, use current directory
+    return repoRoot;
+  }
+  
+  // Use cached repo
+  return await ensureRepo();
+}
+
+module.exports = {
+  getRepoRoot,
+  ensureRepo,
+};