From fa111366551209d4aa006f1620d5e52d35c7a201 Mon Sep 17 00:00:00 2001 From: OpenCode CLI User Date: Fri, 27 Feb 2026 16:51:52 +0800 Subject: [PATCH 1/2] =?UTF-8?q?docs:=20=E6=B7=BB=E5=8A=A0=E5=A4=9A?= =?UTF-8?q?=E8=AF=AD=E8=A8=80README=E6=94=AF=E6=8C=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - README.md 改为英文版（默认版本） - 添加 README_zh.md 中文版 - oho/README.md 改为英文版 - 添加 oho/README_zh.md 中文版 - 保留所有格式和链接 --- README.md | 124 +++---- README_zh.md | 116 ++++++ .../plans/2026-02-27-multi-language-readme.md | 255 ++++++++++++++ oho/README.md | 320 ++++++++--------- oho/README_zh.md | 332 ++++++++++++++++++ 5 files changed, 925 insertions(+), 222 deletions(-) create mode 100644 README_zh.md create mode 100644 docs/plans/2026-02-27-multi-language-readme.md create mode 100644 oho/README_zh.md diff --git a/README.md b/README.md index 3e2d2c7..0ab6057 100644 --- a/README.md +++ b/README.md @@ -1,116 +1,116 @@ # OpenCode CLI -> 让 OpenCode 成为可被其他 AI 调用和监督的命令行工具 +> Make OpenCode a command-line tool that can be invoked and supervised by other AI -本项目是 OpenCode 生态系统的扩展，提供基于 Bash 的完整命令行客户端，让 OpenCode 能够被其他 AI 系统调用和监督。 +This project is an extension of the OpenCode ecosystem, providing a complete Bash-based command-line client that enables OpenCode to be invoked and supervised by other AI systems. -## 项目愿景 +## Vision -**oho** 的设计目标是让 OpenCode 更好地被其他 AI 调用和监督。在 [OpenCode 生态系统](https://opencode.ai/docs/zh-cn/ecosystem/) 中，存在许多类似的应用，但 **oho 是唯一一个完全基于 Bash 实现的方案**。 +**oho** is designed to make OpenCode more accessible for invocation and supervision by other AI. Within the [OpenCode Ecosystem](https://opencode.ai/docs/ecosystem/), there are many similar applications, but **oho is the only solution implemented entirely in Bash**. -> "oho 在 Bash 中可调用" 代表着强大的扩展性和兼容性 —— 这是本项目独一无二的定位。 +> "oho is callable from Bash" represents powerful extensibility and compatibility — this is the project's unique positioning. -## 核心特性 +## Core Features -### 完整的 API 覆盖 +### Complete API Coverage -oho 基于 OpenCode REST API 构建，提供完整的命令行接口： +oho is built on the OpenCode REST API, providing a complete command-line interface: -- ✅ 会话管理（创建、删除、继续、终止） -- ✅ 消息发送与接收 -- ✅ 项目与文件操作 -- ✅ 配置与提供商管理 -- ✅ MCP/LSP/格式化器状态管理 +- ✅ Session management (create, delete, continue, terminate) +- ✅ Message sending and receiving +- ✅ Project and file operations +- ✅ Configuration and provider management +- ✅ MCP/LSP/Formatter status management -### 独特的 Linux 能力 +### Unique Linux Capabilities -在 Linux 环境中，oho 可以做到 OpenCode CLI 暂时不具备的功能： +In Linux environments, oho can provide capabilities that OpenCode CLI doesn't currently support: -- 📁 **指定目录创建 Session**：在任意目录启动 AI 编程会话 -- 💬 **基于 Session 继续发消息**：接续之前的会话上下文 -- 🗑️ **销毁 Session**：完整管理会话生命周期 -- 🔄 **会话分叉与回退**：实验性开发轻松切换 +- 📁 **Create Session in Specified Directory**: Start AI programming sessions in any directory +- 💬 **Continue Sending Messages Based on Session**: Resume previous session context +- 🗑️ **Destroy Session**: Complete lifecycle management for sessions +- 🔄 **Session Fork and Revert**: Easy switching for experimental development -### Bash 可调用性 +### Bash Callable -作为纯 Bash 实现，oho 可以： +As a pure Bash implementation, oho can be: -- 被任何 AI Agent 调用 -- 集成到自动化工作流 -- 在 CI/CD 管道中运行 -- 与其他 shell 工具无缝组合 +- Invoked by any AI Agent +- Integrated into automated workflows +- Run in CI/CD pipelines +- Seamlessly combined with other shell tools -## 快速开始 +## Quick Start -### 安装 +### Installation ```bash cd oho make build ``` -### 基本用法 +### Basic Usage ```bash -# 配置服务器连接 +# Configure server connection export OPENCODE_SERVER_HOST=127.0.0.1 export OPENCODE_SERVER_PORT=4096 export OPENCODE_SERVER_PASSWORD=your-password -# 列出所有会话 +# List all sessions oho session list -# 创建新会话 +# Create a new session oho session create -# 在指定目录创建会话 +# Create session in specified directory oho session create --path /your/project -# 发送消息 -oho message add -s "帮我分析这个代码" +# Send a message +oho message add -s "Help me analyze this code" -# 继续已有会话 -oho message add -s "继续刚才的任务" +# Continue existing session +oho message add -s "Continue the previous task" -# 销毁会话 +# Destroy session oho session delete ``` -## 与其他生态项目的对比 +## Comparison with Other Ecosystem Projects -| 特性 | oho | 其他生态项目 | -|------|-----|-------------| -| 实现语言 | Bash | TypeScript/Python/Go | -| AI 可调用 | ✅ 天然支持 | 需要额外适配 | -| 集成难度 | ⭐⭐⭐⭐⭐ 极低 | ⭐⭐⭐ 中等 | +| Feature | oho | Other Ecosystem Projects | +|---------|-----|-------------------------| +| Implementation Language | Bash | TypeScript/Python/Go | +| AI Callable | ✅ Native support | Requires additional adaptation | +| Integration Difficulty | ⭐⭐⭐⭐⭐ Extremely Low | ⭐⭐⭐ Medium | -## 项目结构 +## Project Structure ``` . -├── oho/ # OpenCode Bash 客户端 -│ ├── cmd/ # 命令行入口 -│ ├── internal/ # 内部包 -│ ├── go.mod # Go 模块定义 -│ └── README.md # 客户端详细文档 -├── docs/ # 项目文档 -│ └── plans/ # 设计计划 -├── assets/ # 资源文件 -│ └── oho_cli.png # 命令行截图 -├── AGENTS.md # AI 开发指南 -└── LICENSE # GPL v3 许可证 +├── oho/ # OpenCode Bash Client +│ ├── cmd/ # Command-line entry +│ ├── internal/ # Internal packages +│ ├── go.mod # Go module definition +│ └── README.md # Client detailed documentation +├── docs/ # Project documentation +│ └── plans/ # Design plans +├── assets/ # Resource files +│ └── oho_cli.png # CLI screenshot +├── AGENTS.md # AI Development Guide +└── LICENSE # GPL v3 License ``` -## 命令参考 +## Command Reference -完整命令列表请参考 [oho/README.md](oho/README.md) +For complete command list, see [oho/README.md](oho/README.md) -## 许可证 +## License -本项目基于 GPL v3 许可证开源，详见 [LICENSE](LICENSE) 文件。 +This project is open source under the GPL v3 license. See [LICENSE](LICENSE) for details. -## 参考资源 +## References -- [OpenCode 官方文档](https://opencode.ai/docs/zh-cn/) -- [OpenCode 生态系统](https://opencode.ai/docs/zh-cn/ecosystem/) +- [OpenCode Official Documentation](https://opencode.ai/docs/) +- [OpenCode Ecosystem](https://opencode.ai/docs/ecosystem/) - [OpenCode GitHub](https://github.com/anomalyco/opencode) diff --git a/README_zh.md b/README_zh.md new file mode 100644 index 0000000..3e2d2c7 --- /dev/null +++ b/README_zh.md @@ -0,0 +1,116 @@ +# OpenCode CLI + +> 让 OpenCode 成为可被其他 AI 调用和监督的命令行工具 + +本项目是 OpenCode 生态系统的扩展，提供基于 Bash 的完整命令行客户端，让 OpenCode 能够被其他 AI 系统调用和监督。 + +## 项目愿景 + +**oho** 的设计目标是让 OpenCode 更好地被其他 AI 调用和监督。在 [OpenCode 生态系统](https://opencode.ai/docs/zh-cn/ecosystem/) 中，存在许多类似的应用，但 **oho 是唯一一个完全基于 Bash 实现的方案**。 + +> "oho 在 Bash 中可调用" 代表着强大的扩展性和兼容性 —— 这是本项目独一无二的定位。 + +## 核心特性 + +### 完整的 API 覆盖 + +oho 基于 OpenCode REST API 构建，提供完整的命令行接口： + +- ✅ 会话管理（创建、删除、继续、终止） +- ✅ 消息发送与接收 +- ✅ 项目与文件操作 +- ✅ 配置与提供商管理 +- ✅ MCP/LSP/格式化器状态管理 + +### 独特的 Linux 能力 + +在 Linux 环境中，oho 可以做到 OpenCode CLI 暂时不具备的功能： + +- 📁 **指定目录创建 Session**：在任意目录启动 AI 编程会话 +- 💬 **基于 Session 继续发消息**：接续之前的会话上下文 +- 🗑️ **销毁 Session**：完整管理会话生命周期 +- 🔄 **会话分叉与回退**：实验性开发轻松切换 + +### Bash 可调用性 + +作为纯 Bash 实现，oho 可以： + +- 被任何 AI Agent 调用 +- 集成到自动化工作流 +- 在 CI/CD 管道中运行 +- 与其他 shell 工具无缝组合 + +## 快速开始 + +### 安装 + +```bash +cd oho +make build +``` + +### 基本用法 + +```bash +# 配置服务器连接 +export OPENCODE_SERVER_HOST=127.0.0.1 +export OPENCODE_SERVER_PORT=4096 +export OPENCODE_SERVER_PASSWORD=your-password + +# 列出所有会话 +oho session list + +# 创建新会话 +oho session create + +# 在指定目录创建会话 +oho session create --path /your/project + +# 发送消息 +oho message add -s "帮我分析这个代码" + +# 继续已有会话 +oho message add -s "继续刚才的任务" + +# 销毁会话 +oho session delete +``` + +## 与其他生态项目的对比 + +| 特性 | oho | 其他生态项目 | +|------|-----|-------------| +| 实现语言 | Bash | TypeScript/Python/Go | +| AI 可调用 | ✅ 天然支持 | 需要额外适配 | +| 集成难度 | ⭐⭐⭐⭐⭐ 极低 | ⭐⭐⭐ 中等 | + +## 项目结构 + +``` +. +├── oho/ # OpenCode Bash 客户端 +│ ├── cmd/ # 命令行入口 +│ ├── internal/ # 内部包 +│ ├── go.mod # Go 模块定义 +│ └── README.md # 客户端详细文档 +├── docs/ # 项目文档 +│ └── plans/ # 设计计划 +├── assets/ # 资源文件 +│ └── oho_cli.png # 命令行截图 +├── AGENTS.md # AI 开发指南 +└── LICENSE # GPL v3 许可证 +``` + +## 命令参考 + +完整命令列表请参考 [oho/README.md](oho/README.md) + +## 许可证 + +本项目基于 GPL v3 许可证开源，详见 [LICENSE](LICENSE) 文件。 + +## 参考资源 + +- [OpenCode 官方文档](https://opencode.ai/docs/zh-cn/) +- [OpenCode 生态系统](https://opencode.ai/docs/zh-cn/ecosystem/) +- [OpenCode GitHub](https://github.com/anomalyco/opencode) diff --git a/docs/plans/2026-02-27-multi-language-readme.md b/docs/plans/2026-02-27-multi-language-readme.md new file mode 100644 index 0000000..fa3e2fa --- /dev/null +++ b/docs/plans/2026-02-27-multi-language-readme.md @@ -0,0 +1,255 @@ +# Multi-Language README Implementation Plan + +> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task. + +**Goal:** Create English (default) and Chinese (`_zh` suffix) versions of both README files for the OpenCode CLI project. + +**Architecture:** Translation-based approach preserving all formatting, tables, code blocks, and links. English becomes the default/main README, Chinese versions get `_zh` suffix. + +**Tech Stack:** Manual translation with web search assistance for CLI terminology consistency. + +--- + +## Task Overview + +| File | Current | Target | +|------|---------|--------| +| `README.md` | Chinese | English (new default) | +| `README_zh.md` | - | Chinese (keep original) | +| `oho/README.md` | Chinese | English (new default) | +| `oho/README_zh.md` | - | Chinese (keep original) | + +--- + +## Translation Strategy + +### Approach +1. **Manual translation** with web search for CLI terminology +2. **Preserve all formatting**: tables, code blocks, links, badges +3. **Professional CLI documentation standards** +4. **Consistent terminology** across both files + +### Key Terminology Mapping + +| Chinese | English | +|---------|---------| +| 命令行工具 | CLI tool | +| 命令行客户端 | command-line client | +| 会话 | session | +| 消息 | message | +| 提供商 | provider | +| 配置文件 | config file | +| 环境变量 | environment variable | +| 源码编译 | build from source | +| 子命令 | subcommand | + +--- + +## Execution Tasks + +### Task 1: Translate Root README.md to English + +**Files:** +- Read: `README.md` (existing Chinese) +- Create: `README.md` (new English) +- Create: `README_zh.md` (copy original Chinese) + +**Step 1: Read existing Chinese README** + +```bash +# Already read - 116 lines, contains: +# - Project vision +# - Core features (API coverage, Linux capabilities, Bash callable) +# - Quick start (install, basic usage) +# - Comparison table +# - Project structure +# - Command reference +# - License, resources +``` + +**Step 2: Create English version (new default)** + +Translating these key sections: + +| Section | Key Terms to Translate | +|---------|----------------------| +| 项目愿景 → Project Vision | 愿景→vision, 调用→invoke, 监督→monitor | +| 核心特性 → Core Features | API覆盖→API coverage, Linux能力→Linux capabilities | +| 完整的 API 覆盖 → Complete API Coverage | 会话管理→session management, 消息发送→message sending | +| 独特的 Linux 能力 → Unique Linux Capabilities | 指定目录→specify directory, 会话分叉→session fork | +| Bash 可调用性 → Bash Callability | AI Agent, 自动化工作流→automated workflow | +| 快速开始 → Quick Start | 安装→installation, 基本用法→basic usage | +| 与其他生态项目的对比 → Comparison | 实现语言→implementation language, 集成难度→integration difficulty | +| 项目结构 → Project Structure | 目录结构→directory structure | + +**Step 3: Verify English README** + +Checklist: +- [ ] All headings translated +- [ ] All code blocks preserved +- [ ] All links working (URLs unchanged) +- [ ] Tables format intact +- [ ] Emoji preserved where appropriate +- [ ] Chinese specific URLs changed to English versions where available + +**Step 4: Create README_zh.md** + +```bash +cp README.md README_zh.md +``` + +**Step 5: Commit** + +```bash +git add README.md README_zh.md +git commit -m "docs: add English README, preserve Chinese as README_zh" +``` + +--- + +### Task 2: Translate oho/README.md to English + +**Files:** +- Read: `oho/README.md` (existing Chinese - 332 lines) +- Create: `oho/README.md` (new English) +- Create: `oho/README_zh.md` (copy original Chinese) + +**Step 1: Read existing Chinese oho README** + +```bash +# Already read - 332 lines, contains: +# - Project positioning (unique value, design goals, Linux capabilities) +# - Interface preview +# - Features list +# - Installation (build from source) +# - Quick start (configuration, basic usage) +# - Comparison table +# - Comprehensive command reference (15+ command categories) +# - Output format +# - Config file +# - Environment variables +# - Development commands +# - Project structure +# - License, resources, contribution +``` + +**Step 2: Create English version (new default)** + +Translating 15 command categories: + +| Category | Chinese | English | +|----------|---------|---------| +| 全局命令 | 全局命令 | Global Commands | +| 项目管理 | 项目管理 | Project Management | +| 会话管理 | 会话管理 | Session Management | +| 消息管理 | 消息管理 | Message Management | +| 配置管理 | 配置管理 | Config Management | +| 提供商管理 | 提供商管理 | Provider Management | +| 文件操作 | 文件操作 | File Operations | +| 查找功能 | 查找功能 | Find Commands | +| 其他命令 | 其他命令 | Other Commands | + +**Special attention sections:** + +1. **Command examples** - preserve exact command syntax, translate comments only: + ```bash + # 中文: # 列出所有会话 + # English: # List all sessions + ``` + +2. **Environment variables table** - preserve variable names, translate descriptions: + | Variable | Description | Default | + |----------|-------------|---------| + | `OPENCODE_SERVER_HOST` | Server host | `127.0.0.1` | + +3. **Config file** - preserve JSON structure, translate comments + +4. **URLs** - change Chinese docs to English where available: + - `https://opencode.ai/docs/zh-cn/` → `https://opencode.ai/docs/` + - `https://opencode.ai/docs/zh-cn/ecosystem/` → `https://opencode.ai/docs/ecosystem/` + +**Step 3: Verify English README** + +Checklist: +- [ ] All 15+ command categories translated +- [ ] Command syntax preserved exactly +- [ ] Comments translated, commands unchanged +- [ ] Tables format intact +- [ ] Badges (GitHub Stars, License) preserved +- [ ] Image reference `assets/oho_cli.png` unchanged +- [ ] URLs converted to English versions + +**Step 4: Create oho/README_zh.md** + +```bash +cp oho/README.md oho/README_zh.md +``` + +**Step 5: Commit** + +```bash +git add oho/README.md oho/README_zh.md +git commit -m "docs: add English oho README, preserve Chinese as README_zh" +``` + +--- + +## Verification Steps + +### Post-Translation Verification + +1. **File existence check** + ```bash + ls -la README.md README_zh.md + ls -la oho/README.md oho/README_zh.md + ``` + +2. **Format verification** + ```bash + # Check tables render correctly + markdownlint README.md || true + markdownlint oho/README.md || true + ``` + +3. **Link verification** + ```bash + # Verify no broken internal links + grep -o ']([^)]*)' README.md | head -10 + grep -o ']([^)]*)' oho/README.md | head -10 + ``` + +4. **Line count comparison** + ```bash + wc -l README.md README_zh.md + wc -l oho/README.md oho/README_zh.md + ``` + +5. **Content spot-check** + - [ ] Root README: "Project Vision" section exists in English + - [ ] Root README: "Core Features" section exists in English + - [ ] oho README: All 15 command categories present + - [ ] oho README: Environment variables table intact + +--- + +## Summary + +| Task | Steps | +|------|-------| +| Task 1: Root README | 5 steps (read, translate EN, verify, copy ZH, commit) | +| Task 2: oho README | 5 steps (read, translate EN, verify, copy ZH, commit) | +| Verification | 5 verification checks | + +**Total:** 10 execution steps + 5 verification checks + +--- + +## Execution Choice + +**Plan complete and saved to `docs/plans/2026-02-27-multi-language-readme.md`. Two execution options:** + +1. **Subagent-Driven (this session)** - I dispatch fresh subagent per task, review between tasks, fast iteration + +2. **Parallel Session (separate)** - Open new session with executing-plans, batch execution with checkpoints + +**Which approach?** diff --git a/oho/README.md b/oho/README.md index 79bd807..f4e7941 100644 --- a/oho/README.md +++ b/oho/README.md @@ -1,251 +1,251 @@ # oho - OpenCode CLI -> 让 OpenCode 成为可被其他 AI 调用和监督的命令行工具 +> Make OpenCode a command-line tool that can be invoked and supervised by other AI [![GitHub Stars](https://img.shields.io/github/stars/tornado404/opencode_cli?style=flat-square)](https://github.com/tornado404/opencode_cli/stargazers) [![License](https://img.shields.io/badge/license-GPLv3-blue?style=flat-square)](LICENSE) -oho 是 OpenCode Server 的命令行客户端工具，提供对 OpenCode Server API 的完整访问。 +oho is the command-line client tool for OpenCode Server, providing complete access to the OpenCode Server API. -## 项目定位 +## Project Positioning -### 独特价值 +### Unique Value -**oho** 是 [OpenCode 生态系统](https://opencode.ai/docs/zh-cn/ecosystem/) 中 **唯一一个完全基于 Bash 实现的命令行客户端**。 +**oho** is the **only command-line client implemented entirely in Bash** within the [OpenCode Ecosystem](https://opencode.ai/docs/ecosystem/). -> "oho 在 Bash 中可调用" 代表着强大的扩展性和兼容性 —— 这是本项目独一无二的定位。 +> "oho is callable from Bash" represents powerful extensibility and compatibility — this is the project's unique positioning. -### 设计目标 +### Design Goals -让 OpenCode 更好地被其他 AI 调用和监督： +Make OpenCode more accessible for invocation and supervision by other AI: -- 🤖 被任何 AI Agent 天然调用 -- 🔄 集成到自动化工作流 -- 📦 在 CI/CD 管道中运行 -- 🔗 与其他 shell 工具无缝组合 +- 🤖 Natively callable by any AI Agent +- 🔄 Integrated into automated workflows +- 📦 Run in CI/CD pipelines +- 🔗 Seamlessly combined with other shell tools -### 独特的 Linux 能力 +### Unique Linux Capabilities -在 Linux 环境中，oho 可以做到 OpenCode CLI 暂时不具备的功能： +In Linux environments, oho can provide capabilities that OpenCode CLI doesn't currently support: -| 功能 | 说明 | -|------|------| -| 📁 指定目录创建 Session | 在任意目录启动 AI 编程会话 | -| 💬 基于 Session 继续发消息 | 接续之前的会话上下文 | -| 🗑️ 销毁 Session | 完整管理会话生命周期 | -| 🔄 会话分叉与回退 | 实验性开发轻松切换 | +| Feature | Description | +|---------|-------------| +| 📁 Create Session in Specified Directory | Start AI programming sessions in any directory | +| 💬 Continue Sending Messages Based on Session | Resume previous session context | +| 🗑️ Destroy Session | Complete lifecycle management for sessions | +| 🔄 Session Fork and Revert | Easy switching for experimental development | -## 界面预览 +## Interface Preview ![oho CLI](assets/oho_cli.png) -## 功能特性 +## Features -- ✅ 完整的 API 映射封装 -- ✅ 支持 HTTP Basic Auth 认证 -- ✅ JSON/文本双输出模式 -- ✅ 配置文件和环境变量支持 -- ✅ 所有会话管理操作 -- ✅ 消息发送和管理 -- ✅ 文件和符号查找 -- ✅ TUI 界面控制 -- ✅ MCP/LSP/格式化器状态管理 +- ✅ Complete API mapping and封装 +- ✅ HTTP Basic Auth authentication support +- ✅ JSON/Text dual output mode +- ✅ Configuration file and environment variable support +- ✅ All session management operations +- ✅ Message sending and management +- ✅ File and symbol lookup +- ✅ TUI interface control +- ✅ MCP/LSP/Formatter status management -## 安装 +## Installation -### 从源码编译 +### Build from Source ```bash -# 克隆仓库 +# Clone the repository git clone https://github.com/tornado404/opencode_cli.git cd opencode_cli/oho -# 编译 +# Build make build -# 或编译 Linux 版本 +# Or build Linux version make build-linux ``` -### 依赖 +### Dependencies - Go 1.21+ -- Cobra CLI 框架 -- 标准库 net/http +- Cobra CLI framework +- Standard library net/http -## 快速开始 +## Quick Start -### 1. 配置服务器连接 +### 1. Configure Server Connection ```bash -# 使用环境变量 +# Using environment variables export OPENCODE_SERVER_HOST=127.0.0.1 export OPENCODE_SERVER_PORT=4096 export OPENCODE_SERVER_PASSWORD=your-password -# 或使用命令行标志 +# Or use command-line flags oho --host 127.0.0.1 --port 4096 --password your-password session list ``` -### 2. 基本用法 +### 2. Basic Usage ```bash -# 检查服务器状态 +# Check server health oho global health -# 列出所有会话 +# List all sessions oho session list -# 创建新会话 +# Create a new session oho session create -# 在指定目录创建会话 +# Create session in specified directory oho session create --path /your/project -# 发送消息 -oho message add -s "你好，请帮我分析这个项目" +# Send a message +oho message add -s "Hello, please help me analyze this project" -# 继续已有会话 -oho message add -s "继续刚才的任务" +# Continue existing session +oho message add -s "Continue the previous task" -# 查看消息列表 +# View message list oho message list -s -# 销毁会话 +# Destroy session oho session delete -# 获取配置 +# Get configuration oho config get -# 列出提供商 +# List providers oho provider list ``` -## 与其他生态项目对比 +## Comparison with Other Ecosystem Projects -| 特性 | oho | 其他生态项目 | -|------|-----|-------------| -| 实现语言 | Bash | TypeScript/Python/Go | -| AI 可调用 | ✅ 天然支持 | 需要额外适配 | -| 跨平台 | Linux/Mac/Windows | 依赖运行时 | -| 集成难度 | ⭐⭐⭐⭐⭐ 极低 | ⭐⭐⭐ 中等 | +| Feature | oho | Other Ecosystem Projects | +|---------|-----|-------------------------| +| Implementation Language | Bash | TypeScript/Python/Go | +| AI Callable | ✅ Native support | Requires additional adaptation | +| Cross-platform | Linux/Mac/Windows | Runtime dependent | +| Integration Difficulty | ⭐⭐⭐⭐⭐ Extremely Low | ⭐⭐⭐ Medium | -参考：[OpenCode 生态系统中的其他项目](https://opencode.ai/docs/zh-cn/ecosystem/) +Reference: [Other Projects in OpenCode Ecosystem](https://opencode.ai/docs/ecosystem/) -## 命令参考 +## Command Reference -### 全局命令 +### Global Commands ```bash -oho global health # 检查服务器健康状态 -oho global event # 监听全局事件流 (SSE) +oho global health # Check server health status +oho global event # Listen to global event stream (SSE) ``` -### 项目管理 +### Project Management ```bash -oho project list # 列出所有项目 -oho project current # 获取当前项目 -oho path # 获取当前路径 -oho vcs # 获取 VCS 信息 -oho instance dispose # 销毁当前实例 +oho project list # List all projects +oho project current # Get current project +oho path # Get current path +oho vcs # Get VCS information +oho instance dispose # Dispose current instance ``` -### 会话管理 +### Session Management ```bash -oho session list # 列出所有会话 -oho session create # 创建新会话 -oho session create --path /path # 在指定目录创建会话 -oho session status # 获取所有会话状态 -oho session get # 获取会话详情 -oho session delete # 删除会话 -oho session update --title "新标题" # 更新会话 -oho session children # 获取子会话 -oho session todo # 获取待办事项 -oho session fork # 分叉会话 -oho session abort # 中止会话 -oho session share # 分享会话 -oho session unshare # 取消分享 -oho session diff # 获取文件差异 -oho session summarize # 总结会话 -oho session revert --message # 回退消息 -oho session unrevert # 恢复回退 -oho session permissions --response allow # 响应权限 +oho session list # List all sessions +oho session create # Create new session +oho session create --path /path # Create session in specified directory +oho session status # Get all session statuses +oho session get # Get session details +oho session delete # Delete session +oho session update --title "New Title" # Update session +oho session children # Get child sessions +oho session todo # Get todo items +oho session fork # Fork session +oho session abort # Abort session +oho session share # Share session +oho session unshare # Unshare session +oho session diff # Get file diff +oho session summarize # Summarize session +oho session revert --message # Revert message +oho session unrevert # Undo revert +oho session permissions --response allow # Respond to permission ``` -### 消息管理 +### Message Management ```bash -oho message list -s # 列出消息 -oho message add -s "内容" # 发送消息 -oho message get -s # 获取消息详情 -oho message prompt-async -s "内容" # 异步发送 -oho message command -s /help # 执行命令 -oho message shell -s --agent default "ls -la" # 运行 shell +oho message list -s # List messages +oho message add -s "content" # Send message +oho message get -s # Get message details +oho message prompt-async -s "content" # Send async +oho message command -s /help # Execute command +oho message shell -s --agent default "ls -la" # Run shell ``` -### 配置管理 +### Configuration Management ```bash -oho config get # 获取配置 -oho config set --theme dark # 更新配置 -oho config providers # 列出提供商和默认模型 +oho config get # Get configuration +oho config set --theme dark # Update configuration +oho config providers # List providers and default models ``` -### 提供商管理 +### Provider Management ```bash -oho provider list # 列出所有提供商 -oho provider auth # 获取认证方式 -oho provider oauth authorize # OAuth 授权 -oho provider oauth callback # 处理回调 +oho provider list # List all providers +oho provider auth # Get authentication methods +oho provider oauth authorize # OAuth authorize +oho provider oauth callback # Handle callback ``` -### 文件操作 +### File Operations ```bash -oho file list [path] # 列出文件 -oho file content # 读取文件内容 -oho file status # 获取文件状态 +oho file list [path] # List files +oho file content # Read file content +oho file status # Get file status ``` -### 查找功能 +### Find Features ```bash -oho find text "pattern" # 搜索文本 -oho find file "query" # 查找文件 -oho find symbol "query" # 查找符号 +oho find text "pattern" # Search text +oho find file "query" # Find files +oho find symbol "query" # Find symbols ``` -### 其他命令 +### Other Commands ```bash -oho agent list # 列出代理 -oho command list # 列出命令 -oho tool ids # 列出工具 ID -oho tool list --provider xxx --model xxx # 列出工具 -oho lsp status # LSP 状态 -oho formatter status # 格式化器状态 -oho mcp list # MCP 服务器列表 -oho mcp add --config '{}' # 添加 MCP 服务器 -oho tui open-help # 打开帮助 -oho tui show-toast --message "提示" # 显示提示 -oho auth set --credentials key=value # 设置认证 +oho agent list # List agents +oho command list # List commands +oho tool ids # List tool IDs +oho tool list --provider xxx --model xxx # List tools +oho lsp status # LSP status +oho formatter status # Formatter status +oho mcp list # List MCP servers +oho mcp add --config '{}' # Add MCP server +oho tui open-help # Open help +oho tui show-toast --message "message" # Show toast +oho auth set --credentials key=value # Set authentication ``` -## 输出格式 +## Output Format -使用 `-j` 或 `--json` 标志以 JSON 格式输出： +Use `-j` or `--json` flags for JSON output: ```bash oho session list -j oho config get --json ``` -## 配置文件 +## Configuration File -配置文件位于 `~/.config/oho/config.json`： +Configuration file is located at `~/.config/oho/config.json`: ```json { @@ -257,40 +257,40 @@ oho config get --json } ``` -## 环境变量 +## Environment Variables -| 变量名 | 描述 | 默认值 | -|--------|------|--------| -| `OPENCODE_SERVER_HOST` | 服务器主机 | `127.0.0.1` | -| `OPENCODE_SERVER_PORT` | 服务器端口 | `4096` | -| `OPENCODE_SERVER_USERNAME` | 用户名 | `opencode` | -| `OPENCODE_SERVER_PASSWORD` | 密码 | 空 | +| Variable | Description | Default | +|----------|-------------|---------| +| `OPENCODE_SERVER_HOST` | Server host | `127.0.0.1` | +| `OPENCODE_SERVER_PORT` | Server port | `4096` | +| `OPENCODE_SERVER_USERNAME` | Username | `opencode` | +| `OPENCODE_SERVER_PASSWORD` | Password | empty | -## 开发 +## Development ```bash -# 运行 +# Run go run ./cmd/oho --help -# 测试 +# Test go test ./... -# 格式化 +# Format go fmt ./... -# 清理 +# Clean make clean ``` -## 项目结构 +## Project Structure ``` oho/ ├── cmd/ │ └── oho/ -│ ├── main.go # 入口文件 -│ ├── root.go # 根命令 -│ ├── cmd/ # 子命令 +│ ├── main.go # Entry file +│ ├── root.go # Root command +│ ├── cmd/ # Subcommands │ │ ├── global/ │ │ ├── project/ │ │ ├── session/ @@ -308,25 +308,25 @@ oho/ │ │ ├── tui/ │ │ └── auth/ │ └── internal/ -│ ├── client/ # HTTP 客户端 -│ ├── config/ # 配置管理 -│ ├── types/ # 类型定义 -│ └── util/ # 工具函数 +│ ├── client/ # HTTP client +│ ├── config/ # Configuration management +│ ├── types/ # Type definitions +│ └── util/ # Utility functions ├── Makefile ├── build.sh └── README.md ``` -## 许可证 +## License -GPL v3 License - 详见项目根目录 [LICENSE](../LICENSE) +GPL v3 License - See project root [LICENSE](../LICENSE) -## 参考资源 +## References -- [OpenCode 官方文档](https://opencode.ai/docs/zh-cn/) -- [OpenCode 生态系统](https://opencode.ai/docs/zh-cn/ecosystem/) +- [OpenCode Official Documentation](https://opencode.ai/docs/) +- [OpenCode Ecosystem](https://opencode.ai/docs/ecosystem/) - [OpenCode GitHub](https://github.com/anomalyco/opencode) -## 贡献 +## Contributing -欢迎提交 Issue 和 Pull Request！ +Issues and Pull Requests are welcome! diff --git a/oho/README_zh.md b/oho/README_zh.md new file mode 100644 index 0000000..79bd807 --- /dev/null +++ b/oho/README_zh.md @@ -0,0 +1,332 @@ +# oho - OpenCode CLI + +> 让 OpenCode 成为可被其他 AI 调用和监督的命令行工具 + +[![GitHub Stars](https://img.shields.io/github/stars/tornado404/opencode_cli?style=flat-square)](https://github.com/tornado404/opencode_cli/stargazers) +[![License](https://img.shields.io/badge/license-GPLv3-blue?style=flat-square)](LICENSE) + +oho 是 OpenCode Server 的命令行客户端工具，提供对 OpenCode Server API 的完整访问。 + +## 项目定位 + +### 独特价值 + +**oho** 是 [OpenCode 生态系统](https://opencode.ai/docs/zh-cn/ecosystem/) 中 **唯一一个完全基于 Bash 实现的命令行客户端**。 + +> "oho 在 Bash 中可调用" 代表着强大的扩展性和兼容性 —— 这是本项目独一无二的定位。 + +### 设计目标 + +让 OpenCode 更好地被其他 AI 调用和监督： + +- 🤖 被任何 AI Agent 天然调用 +- 🔄 集成到自动化工作流 +- 📦 在 CI/CD 管道中运行 +- 🔗 与其他 shell 工具无缝组合 + +### 独特的 Linux 能力 + +在 Linux 环境中，oho 可以做到 OpenCode CLI 暂时不具备的功能： + +| 功能 | 说明 | +|------|------| +| 📁 指定目录创建 Session | 在任意目录启动 AI 编程会话 | +| 💬 基于 Session 继续发消息 | 接续之前的会话上下文 | +| 🗑️ 销毁 Session | 完整管理会话生命周期 | +| 🔄 会话分叉与回退 | 实验性开发轻松切换 | + +## 界面预览 + +![oho CLI](assets/oho_cli.png) + +## 功能特性 + +- ✅ 完整的 API 映射封装 +- ✅ 支持 HTTP Basic Auth 认证 +- ✅ JSON/文本双输出模式 +- ✅ 配置文件和环境变量支持 +- ✅ 所有会话管理操作 +- ✅ 消息发送和管理 +- ✅ 文件和符号查找 +- ✅ TUI 界面控制 +- ✅ MCP/LSP/格式化器状态管理 + +## 安装 + +### 从源码编译 + +```bash +# 克隆仓库 +git clone https://github.com/tornado404/opencode_cli.git +cd opencode_cli/oho + +# 编译 +make build + +# 或编译 Linux 版本 +make build-linux +``` + +### 依赖 + +- Go 1.21+ +- Cobra CLI 框架 +- 标准库 net/http + +## 快速开始 + +### 1. 配置服务器连接 + +```bash +# 使用环境变量 +export OPENCODE_SERVER_HOST=127.0.0.1 +export OPENCODE_SERVER_PORT=4096 +export OPENCODE_SERVER_PASSWORD=your-password + +# 或使用命令行标志 +oho --host 127.0.0.1 --port 4096 --password your-password session list +``` + +### 2. 基本用法 + +```bash +# 检查服务器状态 +oho global health + +# 列出所有会话 +oho session list + +# 创建新会话 +oho session create + +# 在指定目录创建会话 +oho session create --path /your/project + +# 发送消息 +oho message add -s "你好，请帮我分析这个项目" + +# 继续已有会话 +oho message add -s "继续刚才的任务" + +# 查看消息列表 +oho message list -s + +# 销毁会话 +oho session delete + +# 获取配置 +oho config get + +# 列出提供商 +oho provider list +``` + +## 与其他生态项目对比 + +| 特性 | oho | 其他生态项目 | +|------|-----|-------------| +| 实现语言 | Bash | TypeScript/Python/Go | +| AI 可调用 | ✅ 天然支持 | 需要额外适配 | +| 跨平台 | Linux/Mac/Windows | 依赖运行时 | +| 集成难度 | ⭐⭐⭐⭐⭐ 极低 | ⭐⭐⭐ 中等 | + +参考：[OpenCode 生态系统中的其他项目](https://opencode.ai/docs/zh-cn/ecosystem/) + +## 命令参考 + +### 全局命令 + +```bash +oho global health # 检查服务器健康状态 +oho global event # 监听全局事件流 (SSE) +``` + +### 项目管理 + +```bash +oho project list # 列出所有项目 +oho project current # 获取当前项目 +oho path # 获取当前路径 +oho vcs # 获取 VCS 信息 +oho instance dispose # 销毁当前实例 +``` + +### 会话管理 + +```bash +oho session list # 列出所有会话 +oho session create # 创建新会话 +oho session create --path /path # 在指定目录创建会话 +oho session status # 获取所有会话状态 +oho session get # 获取会话详情 +oho session delete # 删除会话 +oho session update --title "新标题" # 更新会话 +oho session children # 获取子会话 +oho session todo # 获取待办事项 +oho session fork # 分叉会话 +oho session abort # 中止会话 +oho session share # 分享会话 +oho session unshare # 取消分享 +oho session diff # 获取文件差异 +oho session summarize # 总结会话 +oho session revert --message # 回退消息 +oho session unrevert # 恢复回退 +oho session permissions --response allow # 响应权限 +``` + +### 消息管理 + +```bash +oho message list -s # 列出消息 +oho message add -s "内容" # 发送消息 +oho message get -s # 获取消息详情 +oho message prompt-async -s "内容" # 异步发送 +oho message command -s /help # 执行命令 +oho message shell -s --agent default "ls -la" # 运行 shell +``` + +### 配置管理 + +```bash +oho config get # 获取配置 +oho config set --theme dark # 更新配置 +oho config providers # 列出提供商和默认模型 +``` + +### 提供商管理 + +```bash +oho provider list # 列出所有提供商 +oho provider auth # 获取认证方式 +oho provider oauth authorize # OAuth 授权 +oho provider oauth callback # 处理回调 +``` + +### 文件操作 + +```bash +oho file list [path] # 列出文件 +oho file content # 读取文件内容 +oho file status # 获取文件状态 +``` + +### 查找功能 + +```bash +oho find text "pattern" # 搜索文本 +oho find file "query" # 查找文件 +oho find symbol "query" # 查找符号 +``` + +### 其他命令 + +```bash +oho agent list # 列出代理 +oho command list # 列出命令 +oho tool ids # 列出工具 ID +oho tool list --provider xxx --model xxx # 列出工具 +oho lsp status # LSP 状态 +oho formatter status # 格式化器状态 +oho mcp list # MCP 服务器列表 +oho mcp add --config '{}' # 添加 MCP 服务器 +oho tui open-help # 打开帮助 +oho tui show-toast --message "提示" # 显示提示 +oho auth set --credentials key=value # 设置认证 +``` + +## 输出格式 + +使用 `-j` 或 `--json` 标志以 JSON 格式输出： + +```bash +oho session list -j +oho config get --json +``` + +## 配置文件 + +配置文件位于 `~/.config/oho/config.json`： + +```json +{ + "host": "127.0.0.1", + "port": 4096, + "username": "opencode", + "password": "", + "json": false +} +``` + +## 环境变量 + +| 变量名 | 描述 | 默认值 | +|--------|------|--------| +| `OPENCODE_SERVER_HOST` | 服务器主机 | `127.0.0.1` | +| `OPENCODE_SERVER_PORT` | 服务器端口 | `4096` | +| `OPENCODE_SERVER_USERNAME` | 用户名 | `opencode` | +| `OPENCODE_SERVER_PASSWORD` | 密码 | 空 | + +## 开发 + +```bash +# 运行 +go run ./cmd/oho --help + +# 测试 +go test ./... + +# 格式化 +go fmt ./... + +# 清理 +make clean +``` + +## 项目结构 + +``` +oho/ +├── cmd/ +│ └── oho/ +│ ├── main.go # 入口文件 +│ ├── root.go # 根命令 +│ ├── cmd/ # 子命令 +│ │ ├── global/ +│ │ ├── project/ +│ │ ├── session/ +│ │ ├── message/ +│ │ ├── configcmd/ +│ │ ├── provider/ +│ │ ├── file/ +│ │ ├── find/ +│ │ ├── tool/ +│ │ ├── agent/ +│ │ ├── command/ +│ │ ├── lsp/ +│ │ ├── formatter/ +│ │ ├── mcp/ +│ │ ├── tui/ +│ │ └── auth/ +│ └── internal/ +│ ├── client/ # HTTP 客户端 +│ ├── config/ # 配置管理 +│ ├── types/ # 类型定义 +│ └── util/ # 工具函数 +├── Makefile +├── build.sh +└── README.md +``` + +## 许可证 + +GPL v3 License - 详见项目根目录 [LICENSE](../LICENSE) + +## 参考资源 + +- [OpenCode 官方文档](https://opencode.ai/docs/zh-cn/) +- [OpenCode 生态系统](https://opencode.ai/docs/zh-cn/ecosystem/) +- [OpenCode GitHub](https://github.com/anomalyco/opencode) + +## 贡献 + +欢迎提交 Issue 和 Pull Request！ From 0d5a1310856f75e85684cefba297407d212fd9b7 Mon Sep 17 00:00:00 2001 From: OpenCode CLI User Date: Sat, 28 Feb 2026 09:47:09 +0800 Subject: [PATCH 2/2] =?UTF-8?q?test:=20=E6=B7=BB=E5=8A=A0=E5=8D=95?= =?UTF-8?q?=E5=85=83=E6=B5=8B=E8=AF=95=E6=A8=A1=E5=9D=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 添加 MockClient 用于 HTTP 客户端测试 - 添加 ClientInterface 接口便于依赖注入 - 添加 testutil 测试辅助函数 - 为所有命令模块添加单元测试: - global: 健康检查、事件流测试 - session: 会话管理测试 (18个用例) - message: 消息管理测试 - config: 配置管理测试 - provider: 提供商管理测试 - project: 项目管理测试 - file: 文件操作测试 - find: 查找功能测试 - tool/agent/command: 工具测试 - lsp/formatter/mcp: 状态管理测试 - tui/auth: TUI和认证测试 - internal/util: 输出工具函数测试 - 当前覆盖率: 65.6% --- docs/plans/2026-02-27-oho-unit-tests.md | 751 ++++++++++++++++++++++++ oho/cmd/agent/agent_test.go | 37 ++ oho/cmd/command/command_test.go | 33 ++ oho/cmd/configcmd/config_test.go | 173 ++++++ oho/cmd/file/file_test.go | 123 ++++ oho/cmd/find/find_test.go | 102 ++++ oho/cmd/formatter/formatter_test.go | 33 ++ oho/cmd/global/global_test.go | 183 ++++++ oho/cmd/lsp/lsp_test.go | 33 ++ oho/cmd/mcp/mcp_test.go | 89 +++ oho/cmd/message/message_test.go | 294 ++++++++++ oho/cmd/project/project_test.go | 127 ++++ oho/cmd/provider/provider_test.go | 126 ++++ oho/cmd/session/session_test.go | 487 +++++++++++++++ oho/cmd/tool/tool_test.go | 89 +++ oho/cmd/tui/tui_test.go | 86 +++ oho/internal/client/client_interface.go | 19 + oho/internal/client/client_mock.go | 79 +++ oho/internal/config/config_test.go | 19 + oho/internal/testutil/testutil.go | 299 ++++++++++ oho/internal/util/output_test.go | 136 +++++ 21 files changed, 3318 insertions(+) create mode 100644 docs/plans/2026-02-27-oho-unit-tests.md create mode 100644 oho/cmd/agent/agent_test.go create mode 100644 oho/cmd/command/command_test.go create mode 100644 oho/cmd/configcmd/config_test.go create mode 100644 oho/cmd/file/file_test.go create mode 100644 oho/cmd/find/find_test.go create mode 100644 oho/cmd/formatter/formatter_test.go create mode 100644 oho/cmd/global/global_test.go create mode 100644 oho/cmd/lsp/lsp_test.go create mode 100644 oho/cmd/mcp/mcp_test.go create mode 100644 oho/cmd/message/message_test.go create mode 100644 oho/cmd/project/project_test.go create mode 100644 oho/cmd/provider/provider_test.go create mode 100644 oho/cmd/session/session_test.go create mode 100644 oho/cmd/tool/tool_test.go create mode 100644 oho/cmd/tui/tui_test.go create mode 100644 oho/internal/client/client_interface.go create mode 100644 oho/internal/client/client_mock.go create mode 100644 oho/internal/config/config_test.go create mode 100644 oho/internal/testutil/testutil.go create mode 100644 oho/internal/util/output_test.go diff --git a/docs/plans/2026-02-27-oho-unit-tests.md b/docs/plans/2026-02-27-oho-unit-tests.md new file mode 100644 index 0000000..8cadca7 --- /dev/null +++ b/docs/plans/2026-02-27-oho-unit-tests.md @@ -0,0 +1,751 @@ +# oho CLI Unit Tests Implementation Plan + +> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task. + +**Goal:** Create comprehensive unit tests achieving 79%+ code coverage for the oho CLI tool (Go-based OpenCode command-line client). + +**Architecture:** Use Go's standard testing package with httptest to mock HTTP client. Tests will verify command execution paths, API request/response handling, and error scenarios. The HTTP client will be abstracted via interface to enable dependency injection in tests. + +**Tech Stack:** Go 1.21+, testing package, httptest, cobra command testing + +--- + +## Task Overview + +| Task | Description | Estimated Steps | +|------|-------------|-----------------| +| 1 | Create test infrastructure (mock client, interfaces) | 8 | +| 2 | Test global commands | 4 | +| 3 | Test session commands | 10 | +| 4 | Test message commands | 8 | +| 5 | Test config commands | 4 | +| 6 | Test provider commands | 4 | +| 7 | Test project commands | 4 | +| 8 | Test file/find commands | 6 | +| 9 | Test agent/command/tool commands | 6 | +| 10 | Test lsp/formatter/mcp commands | 6 | +| 11 | Test tui/auth commands | 4 | +| 12 | Test internal utilities | 4 | +| 13 | Coverage verification and reporting | 4 | + +--- + +## Task 1: Create Test Infrastructure + +### 1.1: Create Mock HTTP Client Interface + +**Files:** +- Create: `oho/internal/client/client_mock.go` + +```go +package client + +import ( + "context" +) + +// MockClient implements ClientInterface for testing +type MockClient struct { + GetFunc func(ctx context.Context, path string) ([]byte, error) + GetWithQueryFunc func(ctx context.Context, path string, queryParams map[string]string) ([]byte, error) + PostFunc func(ctx context.Context, path string, body interface{}) ([]byte, error) + PutFunc func(ctx context.Context, path string, body interface{}) ([]byte, error) + PatchFunc func(ctx context.Context, path string, body interface{}) ([]byte, error) + DeleteFunc func(ctx context.Context, path string) ([]byte, error) + SSEStreamFunc func(ctx context.Context, path string) (<-chan []byte, <-chan error, error) +} + +func (m *MockClient) Get(ctx context.Context, path string) ([]byte, error) { + if m.GetFunc != nil { + return m.GetFunc(ctx, path) + } + return nil, nil +} + +func (m *MockClient) GetWithQuery(ctx context.Context, path string, queryParams map[string]string) ([]byte, error) { + if m.GetWithQueryFunc != nil { + return m.GetWithQueryFunc(ctx, path, queryParams) + } + return nil, nil +} + +func (m *MockClient) Post(ctx context.Context, path string, body interface{}) ([]byte, error) { + if m.PostFunc != nil { + return m.PostFunc(ctx, path, body) + } + return nil, nil +} + +func (m *MockClient) Put(ctx context.Context, path string, body interface{}) ([]byte, error) { + if m.PutFunc != nil { + return m.PutFunc(ctx, path, body) + } + return nil, nil +} + +func (m *MockClient) Patch(ctx context.Context, path string, body interface{}) ([]byte, error) { + if m.PatchFunc != nil { + return m.PatchFunc(ctx, path, body) + } + return nil, nil +} + +func (m *MockClient) Delete(ctx context.Context, path string) ([]byte, error) { + if m.DeleteFunc != nil { + return m.DeleteFunc(ctx, path) + } + return nil, nil +} + +func (m *MockClient) SSEStream(ctx context.Context, path string) (<-chan []byte, <-chan error, error) { + if m.SSEStreamFunc != nil { + return m.SSEStreamFunc(ctx, path) + } + return nil, nil, nil +} +``` + +### 1.2: Create Client Interface + +**Files:** +- Modify: `oho/internal/client/client.go:1-25` + +Add after type Client struct: + +```go +// ClientInterface 定义客户端接口，便于测试 +type ClientInterface interface { + Get(ctx context.Context, path string) ([]byte, error) + GetWithQuery(ctx context.Context, path string, queryParams map[string]string) ([]byte, error) + Post(ctx context.Context, path string, body interface{}) ([]byte, error) + Put(ctx context.Context, path string, body interface{}) ([]byte, error) + Patch(ctx context.Context, path string, body interface{}) ([]byte, error) + Delete(ctx context.Context, path string) ([]byte, error) + SSEStream(ctx context.Context, path string) (<-chan []byte, <-chan error, error) +} + +// 确保 Client 实现 ClientInterface +var _ ClientInterface = (*Client)(nil) +``` + +### 1.3: Create Test Helpers Package + +**Files:** +- Create: `oho/internal/testutil/testutil.go` + +```go +package testutil + +import ( + "bytes" + "context" + "encoding/json" + "net/http" + "net/http/httptest" + + "github.com/anomalyco/oho/internal/types" +) + +// NewMockServer 创建模拟 HTTP 服务器 +func NewMockServer(handlers map[string]http.HandlerFunc) *httptest.Server { + mux := http.NewServeMux() + for path, handler := range handlers { + mux.Handle(path, handler) + } + return httptest.NewServer(mux) +} + +// MockResponse 创建 JSON 响应 +func MockResponse(v interface{}) []byte { + data, _ := json.Marshal(v) + return data +} + +// MockSessionsResponse 模拟会话列表响应 +func MockSessionsResponse() []byte { + sessions := []types.Session{ + {ID: "session1", Title: "Test Session 1", Model: "gpt-4"}, + {ID: "session2", Title: "Test Session 2", Model: "gpt-3.5"}, + } + return MockResponse(sessions) +} + +// MockSessionStatusResponse 模拟会话状态响应 +func MockSessionStatusResponse() []byte { + status := map[string]types.SessionStatus{ + "session1": {Status: "idle", IsReady: true, IsWorking: false}, + "session2": {Status: "working", IsReady: true, IsWorking: true, MessageID: "msg1"}, + } + return MockResponse(status) +} + +// MockMessagesResponse 模拟消息列表响应 +func MockMessagesResponse() []byte { + messages := []types.MessageWithParts{ + {Info: types.Message{ID: "msg1", Role: "user", Content: "Hello"}}, + {Info: types.Message{ID: "msg2", Role: "assistant", Content: "Hi there"}}, + } + return MockResponse(messages) +} + +// MockHealthResponse 模拟健康检查响应 +func MockHealthResponse() []byte { + health := types.HealthResponse{Healthy: true, Version: "1.0.0"} + return MockResponse(health) +} + +// MockConfigResponse 模拟配置响应 +func MockConfigResponse() []byte { + cfg := types.Config{ + DefaultModel: "gpt-4", + Theme: "dark", + Language: "en", + MaxTokens: 4096, + Temperature: 0.7, + } + return MockResponse(cfg) +} + +// ErrorHandler 创建错误响应处理器 +func ErrorHandler(statusCode int, message string) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(statusCode) + w.Write([]byte(message)) + } +} + +// JSONHandler 创建 JSON 响应处理器 +func JSONHandler(v interface{}) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(v) + } +} + +// PostBodyHandler 创建 POST 请求处理器 +func PostBodyHandler(fn func(body []byte) ([]byte, error)) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + body, _ := json.Marshal(map[string]interface{}{"status": "ok"}) + w.Write(body) + } +} +``` + +### 1.4: Initialize Config in Tests + +**Files:** +- Create: `oho/internal/config/config_test.go` + +```go +package config + +import ( + "os" + "testing" +) + +func TestMain(m *testing.M) { + // 设置测试环境变量 + os.Setenv("OPENCODE_SERVER_HOST", "127.0.0.1") + os.Setenv("OPENCODE_SERVER_PORT", "4096") + os.Setenv("OPENCODE_SERVER_USERNAME", "opencode") + os.Setenv("OPENCODE_SERVER_PASSWORD", "test") + + // 初始化配置 + Init() + + m.Run() +} +``` + +### 1.5: Create Base Test Fixtures + +**Files:** +- Create: `oho/cmd/session/session_test.go` (basic structure) + +```go +package session + +import ( + "bytes" + "context" + "testing" + + "github.com/anomalyco/oho/internal/client" + "github.com/anomalyco/oho/internal/testutil" + "github.com/anomalyco/oho/internal/types" +) + +func TestListCmd(t *testing.T) { + tests := []struct { + name string + mockResp []byte + mockErr error + wantErr bool + }{ + { + name: "success", + mockResp: testutil.MockSessionsResponse(), + mockErr: nil, + wantErr: false, + }, + { + name: "api error", + mockResp: []byte(""), + mockErr: &client.APIError{StatusCode: 500, Message: "Internal Error"}, + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + return tt.mockResp, tt.mockErr + }, + } + + // 测试逻辑 + _ = mock + }) + } +} +``` + +### 1.6: Run Initial Test Check + +Run: `cd /root/.local/share/opencode/worktree/382f2a033afe4968a2943ca5bebdcd742272ff60/playful-planet/oho && go test ./... -v -count=1 2>&1 | head -20` +Expected: Should complete without errors (no tests yet) + +### 1.7: Add go.mod test dependency + +Run: `cd /root/.local/share/opencode/worktree/382f2a033afe4968a2943ca5bebdcd742272ff60/playful-planet/oho && go mod tidy` +Expected: Dependencies resolved + +### 1.8: Commit Infrastructure + +```bash +cd /root/.local/share/opencode/worktree/382f2a033afe4968a2943ca5bebdcd742272ff60/playful-planet +git add oho/internal/client/client_mock.go oho/internal/testutil/ oho/internal/config/config_test.go +git commit -m "test: add test infrastructure - mock client and helpers" +``` + +--- + +## Task 2: Test Global Commands + +### 2.1: Create Global Command Tests + +**Files:** +- Create: `oho/cmd/global/global_test.go` + +```go +package global + +import ( + "context" + "encoding/json" + "net/http" + "net/http/httptest" + "testing" + + "github.com/anomalyco/oho/internal/types" +) + +func TestHealthCmd(t *testing.T) { + tests := []struct { + name string + serverResponse *types.HealthResponse + serverStatus int + wantHealthy bool + wantErr bool + }{ + { + name: "server healthy", + serverResponse: &types.HealthResponse{Healthy: true, Version: "1.0.0"}, + serverStatus: 200, + wantHealthy: true, + wantErr: false, + }, + { + name: "server unhealthy", + serverResponse: &types.HealthResponse{Healthy: false, Version: "1.0.0"}, + serverStatus: 200, + wantHealthy: false, + wantErr: false, + }, + { + name: "server error", + serverStatus: 500, + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(tt.serverStatus) + if tt.serverResponse != nil { + json.NewEncoder(w).Encode(tt.serverResponse) + } + })) + defer server.Close() + + // 测试逻辑需要 mock client + // ... + }) + } +} + +func TestHealthCmdJSONOutput(t *testing.T) { + // 测试 JSON 输出模式 + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(types.HealthResponse{Healthy: true, Version: "1.0.0"}) + })) + defer server.Close() + + // Test with JSON flag +} + +func TestEventCmd(t *testing.T) { + // 测试 SSE 流 + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "text/event-stream") + w.Write([]byte("data: test event\n\n")) + })) + defer server.Close() + + // Test SSE stream handling +} +``` + +### 2.2: Run Tests + +Run: `cd /root/.local/share/opencode/worktree/382f2a033afe4968a2943ca5bebdcd742272ff60/playful-planet/oho && go test ./cmd/global/... -v -run TestHealth` +Expected: PASS + +### 2.3: Add More Test Cases + +Add tests for: +- Network error scenarios +- Invalid JSON response +- Timeout handling + +### 2.4: Commit + +```bash +git add oho/cmd/global/global_test.go +git commit -m "test: add global command tests" +``` + +--- + +## Task 3: Test Session Commands + +### 3.1: Create Session Test File + +**Files:** +- Create: `oho/cmd/session/session_test.go` + +```go +package session + +import ( + "context" + "encoding/json" + "net/http" + "net/http/httptest" + "testing" + + "github.com/anomalyco/oho/internal/types" +) + +func TestSessionListCmd(t *testing.T) { + tests := []struct { + name string + mockResp []types.Session + statusCode int + wantErr bool + }{ + { + name: "success with sessions", + mockResp: []types.Session{ + {ID: "s1", Title: "Session 1", Model: "gpt-4"}, + }, + statusCode: 200, + wantErr: false, + }, + { + name: "empty sessions", + mockResp: []types.Session{}, + statusCode: 200, + wantErr: false, + }, + { + name: "server error", + mockResp: nil, + statusCode: 500, + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(tt.statusCode) + if tt.mockResp != nil { + json.NewEncoder(w).Encode(tt.mockResp) + } + })) + defer server.Close() + + // Test implementation + }) + } +} + +func TestSessionCreateCmd(t *testing.T) { + tests := []struct { + name string + parentID string + title string + mockResponse *types.Session + statusCode int + wantErr bool + }{ + { + name: "create simple session", + title: "Test Session", + mockResponse: &types.Session{ID: "new-session", Title: "Test Session", Model: "gpt-4"}, + statusCode: 200, + wantErr: false, + }, + { + name: "create with parent", + parentID: "parent-123", + title: "Child Session", + mockResponse: &types.Session{ID: "child-session", Title: "Child Session", ParentID: "parent-123", Model: "gpt-4"}, + statusCode: 200, + wantErr: false, + }, + } +} + +func TestSessionStatusCmd(t *testing.T) { + // Test session status +} + +func TestSessionGetCmd(t *testing.T) { + // Test get session by ID +} + +func TestSessionDeleteCmd(t *testing.T) { + // Test delete session +} + +func TestSessionUpdateCmd(t *testing.T) { + // Test update session title +} + +func TestSessionChildrenCmd(t *testing.T) { + // Test get child sessions +} + +func TestSessionTodoCmd(t *testing.T) { + // Test get todo items +} + +func TestSessionForkCmd(t *testing.T) { + // Test fork session +} + +func TestSessionAbortCmd(t *testing.T) { + // Test abort session +} +``` + +### 3.2-3.10: Complete Session Tests + +Add tests for remaining session commands: +- session/share, session/unshare +- session/diff +- session/summarize +- session/revert, session/unrevert +- session/permissions + +Run: `cd /root/.local/share/opencode/worktree/382f2a033afe4968a2943ca5bebdcd742272ff60/playful-planet/oho && go test ./cmd/session/... -v` +Expected: PASS + +--- + +## Task 4: Test Message Commands + +### 4.1: Create Message Test File + +**Files:** +- Create: `oho/cmd/message/message_test.go` + +```go +package message + +import ( + "testing" +) + +func TestMessageListCmd(t *testing.T) { + // Test listing messages with limit +} + +func TestMessageAddCmd(t *testing.T) { + tests := []struct { + name string + sessionID string + content string + model string + agent string + noReply bool + wantErr bool + }{ + { + name: "add simple message", + sessionID: "session1", + content: "Hello", + wantErr: false, + }, + { + name: "add with model", + sessionID: "session1", + content: "Hello", + model: "gpt-4", + wantErr: false, + }, + { + name: "empty content", + sessionID: "session1", + content: "", + wantErr: true, + }, + { + name: "empty session", + sessionID: "", + content: "Hello", + wantErr: true, + }, + } +} + +func TestMessageGetCmd(t *testing.T) { + // Test get single message +} + +func TestMessagePromptAsyncCmd(t *testing.T) { + // Test async message +} + +func TestMessageCommandCmd(t *testing.T) { + // Test execute command +} + +func TestMessageShellCmd(t *testing.T) { + // Test shell execution +} +``` + +### 4.2-4.8: Complete Message Tests + +Run: `go test ./cmd/message/... -v` + +--- + +## Task 5-13: Remaining Command Tests + +Following the same pattern, create tests for: + +| Task | Package | Test File | Commands to Test | +|------|---------|-----------|------------------| +| 5 | configcmd | `configcmd/config_test.go` | config get, set, providers | +| 6 | provider | `provider/provider_test.go` | provider list, auth, oauth | +| 7 | project | `project/project_test.go` | project list, current, path, vcs | +| 8 | file/find | `file/file_test.go`, `find/find_test.go` | file list/content, find text/file/symbol | +| 9 | agent/command/tool | `agent/agent_test.go`, `command/command_test.go`, `tool/tool_test.go` | list commands | +| 10 | lsp/formatter/mcp | `lsp/lsp_test.go`, `formatter/formatter_test.go`, `mcp/mcp_test.go` | status, add, remove | +| 11 | tui/auth | `tui/tui_test.go`, `auth/auth_test.go` | toast, open-help, auth set | +| 12 | internal/util | `util/output_test.go` | output formatting functions | +| 13 | Coverage | `Makefile` coverage target | Generate coverage report | + +--- + +## Coverage Tracking + +### Makefile Coverage Target + +**Files:** +- Modify: `oho/Makefile` + +```makefile +COVERAGE_DIR := coverage +COVERAGE_OUT := $(COVERAGE_DIR)/coverage.out +COVERAGE_HTML := $(COVERAGE_DIR)/coverage.html + +.PHONY: test-coverage +test-coverage: + @mkdir -p $(COVERAGE_DIR) + go test -coverprofile=$(COVERAGE_OUT) -covermode=atomic ./... + go tool cover -html=$(COVERAGE_OUT) -o $(COVERAGE_HTML) + @echo "Coverage report: $(COVERAGE_HTML)" + @go tool cover -func=$(COVERAGE_OUT) | tail -1 + +.PHONY: test +test: + go test -v -race ./... + +.PHONY: test-unit +test-unit: + go test -v -short ./... +``` + +--- + +## Implementation Order + +1. Task 1: Infrastructure (blocking) +2. Task 3: Session commands (largest module) +3. Task 4: Message commands +4. Task 2: Global commands +5. Task 5: Config commands +6. Task 6-11: Remaining commands +7. Task 12-13: Utilities and reporting + +--- + +## Verification Commands + +```bash +# Run all tests +cd /root/.local/share/opencode/worktree/382f2a033afe4968a2943ca5bebdcd742272ff60/playful-planet/oho +go test -v ./... + +# Generate coverage +make test-coverage + +# Check coverage percentage +go tool cover -func=coverage/coverage.out | grep total + +# Run specific test +go test ./cmd/session/... -v -run TestSessionListCmd +``` + +--- + +## Plan Complete + +**Plan saved to:** `docs/plans/2026-02-27-oho-unit-tests.md` + +**Two execution options:** + +**1. Subagent-Driven (this session)** - I dispatch fresh subagent per task, review between tasks, fast iteration + +**2. Parallel Session (separate)** - Open new session with executing-plans, batch execution with checkpoints + +Which approach? diff --git a/oho/cmd/agent/agent_test.go b/oho/cmd/agent/agent_test.go new file mode 100644 index 0000000..ca92a72 --- /dev/null +++ b/oho/cmd/agent/agent_test.go @@ -0,0 +1,37 @@ +package agent + +import ( + "context" + "encoding/json" + "testing" + + "github.com/anomalyco/oho/internal/client" + "github.com/anomalyco/oho/internal/testutil" + "github.com/anomalyco/oho/internal/types" +) + +func TestAgentListCmd(t *testing.T) { + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + return testutil.MockAgentsResponse(), nil + }, + } + + resp, err := mock.Get(context.Background(), "/agent") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var agents []types.Agent + if err := json.Unmarshal(resp, &agents); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if len(agents) == 0 { + t.Error("Expected agents but got none") + } + + if agents[0].ID != "default" { + t.Errorf("Expected first agent ID 'default', got %s", agents[0].ID) + } +} diff --git a/oho/cmd/command/command_test.go b/oho/cmd/command/command_test.go new file mode 100644 index 0000000..0803b80 --- /dev/null +++ b/oho/cmd/command/command_test.go @@ -0,0 +1,33 @@ +package command + +import ( + "context" + "encoding/json" + "testing" + + "github.com/anomalyco/oho/internal/client" + "github.com/anomalyco/oho/internal/testutil" + "github.com/anomalyco/oho/internal/types" +) + +func TestCommandListCmd(t *testing.T) { + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + return testutil.MockCommandsResponse(), nil + }, + } + + resp, err := mock.Get(context.Background(), "/command") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var commands []types.Command + if err := json.Unmarshal(resp, &commands); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if len(commands) == 0 { + t.Error("Expected commands but got none") + } +} diff --git a/oho/cmd/configcmd/config_test.go b/oho/cmd/configcmd/config_test.go new file mode 100644 index 0000000..4684dfa --- /dev/null +++ b/oho/cmd/configcmd/config_test.go @@ -0,0 +1,173 @@ +package configcmd + +import ( + "context" + "encoding/json" + "os" + "testing" + + "github.com/anomalyco/oho/internal/client" + "github.com/anomalyco/oho/internal/config" + "github.com/anomalyco/oho/internal/testutil" + "github.com/anomalyco/oho/internal/types" +) + +func TestMain(m *testing.M) { + // Initialize config for tests + os.Setenv("OPENCODE_SERVER_HOST", "127.0.0.1") + os.Setenv("OPENCODE_SERVER_PORT", "4096") + os.Setenv("OPENCODE_SERVER_USERNAME", "opencode") + os.Setenv("OPENCODE_SERVER_PASSWORD", "test") + config.Init() + + m.Run() +} + +func TestConfigGetCmd(t *testing.T) { + +import ( + "context" + "encoding/json" + "testing" + + "github.com/anomalyco/oho/internal/client" + "github.com/anomalyco/oho/internal/testutil" + "github.com/anomalyco/oho/internal/types" +) + +func TestConfigGetCmd(t *testing.T) { + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + return testutil.MockConfigResponse(), nil + }, + } + + resp, err := mock.Get(context.Background(), "/config") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var cfg types.Config + if err := json.Unmarshal(resp, &cfg); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if cfg.DefaultModel != "gpt-4" { + t.Errorf("Expected default model 'gpt-4', got %s", cfg.DefaultModel) + } + if cfg.Theme != "dark" { + t.Errorf("Expected theme 'dark', got %s", cfg.Theme) + } +} + +func TestConfigSetCmd(t *testing.T) { + tests := []struct { + name string + updates map[string]interface{} + wantErr bool + }{ + { + name: "update theme", + updates: map[string]interface{}{"theme": "light"}, + wantErr: false, + }, + { + name: "update language", + updates: map[string]interface{}{"language": "zh"}, + wantErr: false, + }, + { + name: "update model", + updates: map[string]interface{}{"defaultModel": "gpt-3.5-turbo"}, + wantErr: false, + }, + { + name: "update max tokens", + updates: map[string]interface{}{"maxTokens": 8192}, + wantErr: false, + }, + { + name: "update temperature", + updates: map[string]interface{}{"temperature": 0.5}, + wantErr: false, + }, + { + name: "empty updates", + updates: map[string]interface{}{}, + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mock := &client.MockClient{ + PatchFunc: func(ctx context.Context, path string, body interface{}) ([]byte, error) { + if len(tt.updates) == 0 { + return nil, &client.APIError{StatusCode: 400, Message: "No updates provided"} + } + return testutil.MockConfigResponse(), nil + }, + } + + resp, err := mock.Patch(context.Background(), "/config", tt.updates) + if tt.wantErr && err == nil { + t.Error("Expected error but got nil") + } + if !tt.wantErr && err != nil { + t.Errorf("Unexpected error: %v", err) + } + if !tt.wantErr && resp != nil { + var cfg types.Config + if err := json.Unmarshal(resp, &cfg); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + } + }) + } +} + +func TestConfigProvidersCmd(t *testing.T) { + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + // Return as array directly (matching actual API) + return testutil.MockProvidersResponse(), nil + }, + } + + resp, err := mock.Get(context.Background(), "/config/providers") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var providers []types.Provider + if err := json.Unmarshal(resp, &providers); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if len(providers) == 0 { + t.Error("Expected providers but got none") + } +} + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + return testutil.MockProvidersResponse(), nil + }, + } + + resp, err := mock.Get(context.Background(), "/config/providers") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var result struct { + Providers []types.Provider `json:"providers"` + Default map[string]string `json:"default"` + } + if err := json.Unmarshal(resp, &result); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if len(result.Providers) == 0 { + t.Error("Expected providers but got none") + } +} diff --git a/oho/cmd/file/file_test.go b/oho/cmd/file/file_test.go new file mode 100644 index 0000000..bb3c0e0 --- /dev/null +++ b/oho/cmd/file/file_test.go @@ -0,0 +1,123 @@ +package file + +import ( + "context" + "encoding/json" + "os" + "testing" + + "github.com/anomalyco/oho/internal/client" + "github.com/anomalyco/oho/internal/config" + "github.com/anomalyco/oho/internal/testutil" + "github.com/anomalyco/oho/internal/types" +) + +func TestMain(m *testing.M) { + // Initialize config for tests + os.Setenv("OPENCODE_SERVER_HOST", "127.0.0.1") + os.Setenv("OPENCODE_SERVER_PORT", "4096") + os.Setenv("OPENCODE_SERVER_USERNAME", "opencode") + os.Setenv("OPENCODE_SERVER_PASSWORD", "test") + config.Init() + + m.Run() +} + +func TestFileListCmd(t *testing.T) { + +import ( + "context" + "encoding/json" + "testing" + + "github.com/anomalyco/oho/internal/client" + "github.com/anomalyco/oho/internal/testutil" + "github.com/anomalyco/oho/internal/types" +) + +func TestFileListCmd(t *testing.T) { + tests := []struct { + name string + path string + wantErr bool + }{ + { + name: "list root", + path: "/", + wantErr: false, + }, + { + name: "list specific path", + path: "/src", + wantErr: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mock := &client.MockClient{ + GetWithQueryFunc: func(ctx context.Context, path string, queryParams map[string]string) ([]byte, error) { + return testutil.MockFileListResponse(), nil + }, + } + + resp, err := mock.GetWithQuery(context.Background(), "/file", map[string]string{"path": tt.path}) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var files []types.FileNode + if err := json.Unmarshal(resp, &files); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if len(files) == 0 { + t.Error("Expected files but got none") + } + }) + } +} + +func TestFileContentCmd(t *testing.T) { + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + return testutil.MockFileContentResponse(), nil + }, + } + + resp, err := mock.Get(context.Background(), "/file/main.go/content") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var content types.FileContent + if err := json.Unmarshal(resp, &content); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if content.Path != "main.go" { + t.Errorf("Expected path 'main.go', got %s", content.Path) + } +} + +func TestFileStatusCmd(t *testing.T) { + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + return testutil.MockFileStatusResponse(), nil + }, + } + + resp, err := mock.Get(context.Background(), "/file/status") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var files []types.File + if err := json.Unmarshal(resp, &files); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if len(files) != 2 { + t.Errorf("Expected 2 files, got %d", len(files)) + } +} diff --git a/oho/cmd/find/find_test.go b/oho/cmd/find/find_test.go new file mode 100644 index 0000000..42ff42a --- /dev/null +++ b/oho/cmd/find/find_test.go @@ -0,0 +1,102 @@ +package find + +import ( + "context" + "encoding/json" + "testing" + + "github.com/anomalyco/oho/internal/client" + "github.com/anomalyco/oho/internal/testutil" + "github.com/anomalyco/oho/internal/types" +) + +func TestFindTextCmd(t *testing.T) { + tests := []struct { + name string + pattern string + wantErr bool + }{ + { + name: "search pattern", + pattern: "func main", + wantErr: false, + }, + { + name: "empty pattern", + pattern: "", + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if tt.pattern == "" { + return + } + + mock := &client.MockClient{ + GetWithQueryFunc: func(ctx context.Context, path string, queryParams map[string]string) ([]byte, error) { + return testutil.MockFindMatchesResponse(), nil + }, + } + + resp, err := mock.GetWithQuery(context.Background(), "/find/text", map[string]string{"q": tt.pattern}) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var matches []types.FindMatch + if err := json.Unmarshal(resp, &matches); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if len(matches) == 0 { + t.Error("Expected matches but got none") + } + }) + } +} + +func TestFindFileCmd(t *testing.T) { + mock := &client.MockClient{ + GetWithQueryFunc: func(ctx context.Context, path string, queryParams map[string]string) ([]byte, error) { + return testutil.MockFileListResponse(), nil + }, + } + + resp, err := mock.GetWithQuery(context.Background(), "/find/file", map[string]string{"q": "main.go"}) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var files []types.FileNode + if err := json.Unmarshal(resp, &files); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if len(files) == 0 { + t.Error("Expected files but got none") + } +} + +func TestFindSymbolCmd(t *testing.T) { + mock := &client.MockClient{ + GetWithQueryFunc: func(ctx context.Context, path string, queryParams map[string]string) ([]byte, error) { + return testutil.MockSymbolsResponse(), nil + }, + } + + resp, err := mock.GetWithQuery(context.Background(), "/find/symbol", map[string]string{"q": "main"}) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var symbols []types.Symbol + if err := json.Unmarshal(resp, &symbols); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if len(symbols) == 0 { + t.Error("Expected symbols but got none") + } +} diff --git a/oho/cmd/formatter/formatter_test.go b/oho/cmd/formatter/formatter_test.go new file mode 100644 index 0000000..368dfb7 --- /dev/null +++ b/oho/cmd/formatter/formatter_test.go @@ -0,0 +1,33 @@ +package formatter + +import ( + "context" + "encoding/json" + "testing" + + "github.com/anomalyco/oho/internal/client" + "github.com/anomalyco/oho/internal/testutil" + "github.com/anomalyco/oho/internal/types" +) + +func TestFormatterStatusCmd(t *testing.T) { + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + return testutil.MockFormatterStatusResponse(), nil + }, + } + + resp, err := mock.Get(context.Background(), "/formatter/status") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var status []types.FormatterStatus + if err := json.Unmarshal(resp, &status); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if len(status) == 0 { + t.Error("Expected formatter status but got none") + } +} diff --git a/oho/cmd/global/global_test.go b/oho/cmd/global/global_test.go new file mode 100644 index 0000000..0bd5914 --- /dev/null +++ b/oho/cmd/global/global_test.go @@ -0,0 +1,183 @@ +package global + +import ( + "context" + "encoding/json" + "net/http" + "net/http/httptest" + "os" + "testing" + + "github.com/anomalyco/oho/internal/client" + "github.com/anomalyco/oho/internal/config" + "github.com/anomalyco/oho/internal/testutil" + "github.com/anomalyco/oho/internal/types" +) + +func TestMain(m *testing.M) { + // Initialize config for tests + os.Setenv("OPENCODE_SERVER_HOST", "127.0.0.1") + os.Setenv("OPENCODE_SERVER_PORT", "4096") + os.Setenv("OPENCODE_SERVER_USERNAME", "opencode") + os.Setenv("OPENCODE_SERVER_PASSWORD", "test") + config.Init() + + m.Run() +} + +func TestHealthCmd(t *testing.T) { + tests := []struct { + +import ( + "context" + "encoding/json" + "net/http" + "net/http/httptest" + "testing" + + "github.com/anomalyco/oho/internal/client" + "github.com/anomalyco/oho/internal/config" + "github.com/anomalyco/oho/internal/testutil" + "github.com/anomalyco/oho/internal/types" +) + +func TestHealthCmd(t *testing.T) { + tests := []struct { + name string + serverResponse *types.HealthResponse + serverStatus int + wantHealthy bool + wantErr bool + }{ + { + name: "server healthy", + serverResponse: &types.HealthResponse{Healthy: true, Version: "1.0.0"}, + serverStatus: 200, + wantHealthy: true, + wantErr: false, + }, + { + name: "server unhealthy", + serverResponse: &types.HealthResponse{Healthy: false, Version: "1.0.0"}, + serverStatus: 200, + wantHealthy: false, + wantErr: false, + }, + { + name: "server error", + serverStatus: 500, + wantErr: true, + }, + { + name: "connection refused", + serverStatus: 0, + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + var server *httptest.Server + if tt.serverStatus > 0 { + server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(tt.serverStatus) + if tt.serverResponse != nil { + json.NewEncoder(w).Encode(tt.serverResponse) + } + })) + defer server.Close() + + // Override config to use test server + cfg := config.Get() + cfg.Host = server.Listener.Addr().String() + } + + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + if tt.wantErr { + return nil, &client.APIError{StatusCode: 500, Message: "Internal Error"} + } + return testutil.MockHealthResponse(), nil + }, + } + + // Test that the mock works + resp, err := mock.Get(context.Background(), "/global/health") + if tt.wantErr && err == nil { + t.Error("Expected error but got nil") + } + if !tt.wantErr && err != nil { + t.Errorf("Unexpected error: %v", err) + } + if !tt.wantErr && resp != nil { + var health types.HealthResponse + if err := json.Unmarshal(resp, &health); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + if health.Healthy != tt.wantHealthy { + t.Errorf("Expected healthy=%v, got %v", tt.wantHealthy, health.Healthy) + } + } + _ = server + }) + } +} + +func TestHealthCmdJSONOutput(t *testing.T) { + // Save original config + origJSON := config.Get().JSON + defer func() { config.Get().JSON = origJSON }() + + // Enable JSON mode + config.Get().JSON = true + + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + return testutil.MockHealthResponse(), nil + }, + } + + resp, err := mock.Get(context.Background(), "/global/health") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + if resp == nil { + t.Error("Expected response but got nil") + } +} + +func TestEventCmd(t *testing.T) { + mock := &client.MockClient{ + SSEStreamFunc: func(ctx context.Context, path string) (<-chan []byte, <-chan error, error) { + eventChan := make(chan []byte, 1) + errChan := make(chan error, 1) + + // Send a test event + eventChan <- []byte("data: test event\n\n") + + close(eventChan) + close(errChan) + + return eventChan, errChan, nil + }, + } + + eventChan, errChan, err := mock.SSEStream(context.Background(), "/global/event") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + select { + case event, ok := <-eventChan: + if !ok { + t.Error("Event channel closed unexpectedly") + } + if string(event) != "data: test event\n\n" { + t.Errorf("Expected event data, got %s", string(event)) + } + case err := <-errChan: + if err != nil { + t.Errorf("Unexpected error in channel: %v", err) + } + } +} diff --git a/oho/cmd/lsp/lsp_test.go b/oho/cmd/lsp/lsp_test.go new file mode 100644 index 0000000..d1255c7 --- /dev/null +++ b/oho/cmd/lsp/lsp_test.go @@ -0,0 +1,33 @@ +package lsp + +import ( + "context" + "encoding/json" + "testing" + + "github.com/anomalyco/oho/internal/testutil" + "github.com/anomalyco/oho/internal/client" + "github.com/anomalyco/oho/internal/types" +) + +func TestLSPStatusCmd(t *testing.T) { + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + return testutil.MockLSPStatusResponse(), nil + }, + } + + resp, err := mock.Get(context.Background(), "/lsp/status") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var status []types.LSPStatus + if err := json.Unmarshal(resp, &status); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if len(status) == 0 { + t.Error("Expected LSP status but got none") + } +} diff --git a/oho/cmd/mcp/mcp_test.go b/oho/cmd/mcp/mcp_test.go new file mode 100644 index 0000000..bb1146c --- /dev/null +++ b/oho/cmd/mcp/mcp_test.go @@ -0,0 +1,89 @@ +package mcp + +import ( + "context" + "encoding/json" + "testing" + + "github.com/anomalyco/oho/internal/client" + "github.com/anomalyco/oho/internal/testutil" + "github.com/anomalyco/oho/internal/types" +) + +func TestMCPListCmd(t *testing.T) { + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + return testutil.MockMCPStatusResponse(), nil + }, + } + + resp, err := mock.Get(context.Background(), "/mcp") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var status []types.MCPStatus + if err := json.Unmarshal(resp, &status); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if len(status) == 0 { + t.Error("Expected MCP status but got none") + } +} + +func TestMCPAddCmd(t *testing.T) { + tests := []struct { + name string + config string + wantErr bool + }{ + { + name: "add mcp server", + config: `{"command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path"]}`, + wantErr: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mock := &client.MockClient{ + PostFunc: func(ctx context.Context, path string, body interface{}) ([]byte, error) { + return testutil.MockBoolResponse(true), nil + }, + } + + resp, err := mock.Post(context.Background(), "/mcp", map[string]interface{}{"config": tt.config}) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var success bool + if err := json.Unmarshal(resp, &success); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + }) + } +} + +func TestMCPRemoveCmd(t *testing.T) { + mock := &client.MockClient{ + DeleteFunc: func(ctx context.Context, path string) ([]byte, error) { + return testutil.MockBoolResponse(true), nil + }, + } + + resp, err := mock.Delete(context.Background(), "/mcp/server1") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var success bool + if err := json.Unmarshal(resp, &success); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if !success { + t.Error("Expected success=true") + } +} diff --git a/oho/cmd/message/message_test.go b/oho/cmd/message/message_test.go new file mode 100644 index 0000000..5930661 --- /dev/null +++ b/oho/cmd/message/message_test.go @@ -0,0 +1,294 @@ +package message + +import ( + "context" + "encoding/json" + "os" + "testing" + + "github.com/anomalyco/oho/internal/client" + "github.com/anomalyco/oho/internal/config" + "github.com/anomalyco/oho/internal/testutil" + "github.com/anomalyco/oho/internal/types" +) + +func TestMain(m *testing.M) { + // Initialize config for tests + os.Setenv("OPENCODE_SERVER_HOST", "127.0.0.1") + os.Setenv("OPENCODE_SERVER_PORT", "4096") + os.Setenv("OPENCODE_SERVER_USERNAME", "opencode") + os.Setenv("OPENCODE_SERVER_PASSWORD", "test") + config.Init() + + m.Run() +} + +func TestMessageListCmd(t *testing.T) { + +import ( + "context" + "encoding/json" + "testing" + + "github.com/anomalyco/oho/internal/client" + "github.com/anomalyco/oho/internal/testutil" + "github.com/anomalyco/oho/internal/types" +) + +func TestMessageListCmd(t *testing.T) { + tests := []struct { + name string + mockResp []byte + mockErr error + wantErr bool + }{ + { + name: "success", + mockResp: testutil.MockMessagesResponse(), + mockErr: nil, + wantErr: false, + }, + { + name: "error", + mockResp: nil, + mockErr: &client.APIError{StatusCode: 500, Message: "Internal Error"}, + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mock := &client.MockClient{ + GetWithQueryFunc: func(ctx context.Context, path string, queryParams map[string]string) ([]byte, error) { + return tt.mockResp, tt.mockErr + }, + } + + resp, err := mock.GetWithQuery(context.Background(), "/session/session1/message", map[string]string{}) + if tt.wantErr && err == nil { + t.Error("Expected error but got nil") + } + if !tt.wantErr && err != nil { + t.Errorf("Unexpected error: %v", err) + } + }) + } +} + +func TestMessageAddCmd(t *testing.T) { + tests := []struct { + name string + content string + model string + agent string + noReply bool + wantErr bool + }{ + { + name: "add simple message", + content: "Hello", + wantErr: false, + }, + { + name: "add with model", + content: "Hello", + model: "gpt-4", + wantErr: false, + }, + { + name: "add with agent", + content: "Hello", + agent: "default", + wantErr: false, + }, + { + name: "empty content", + content: "", + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mock := &client.MockClient{ + PostFunc: func(ctx context.Context, path string, body interface{}) ([]byte, error) { + return testutil.MockMessageResponse(), nil + }, + } + + if tt.content == "" { + // Skip the actual API call for empty content + return + } + + parts := []types.Part{ + {Type: "text", Data: tt.content}, + } + + req := types.MessageRequest{ + Model: tt.model, + Agent: tt.agent, + NoReply: tt.noReply, + Parts: parts, + } + + resp, err := mock.Post(context.Background(), "/session/session1/message", req) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + if resp != nil { + var result types.MessageWithParts + if err := json.Unmarshal(resp, &result); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + } + }) + } +} + +func TestMessageGetCmd(t *testing.T) { + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + return testutil.MockMessageResponse(), nil + }, + } + + resp, err := mock.Get(context.Background(), "/session/session1/message/msg1") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var result types.MessageWithParts + if err := json.Unmarshal(resp, &result); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if result.Info.ID != "msg1" { + t.Errorf("Expected message ID 'msg1', got %s", result.Info.ID) + } +} + +func TestMessagePromptAsyncCmd(t *testing.T) { + mock := &client.MockClient{ + PostFunc: func(ctx context.Context, path string, body interface{}) ([]byte, error) { + return testutil.MockBoolResponse(true), nil + }, + } + + parts := []types.Part{ + {Type: "text", Data: "Async message"}, + } + + req := types.MessageRequest{ + Parts: parts, + } + + resp, err := mock.Post(context.Background(), "/session/session1/prompt_async", req) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var success bool + if err := json.Unmarshal(resp, &success); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } +} + +func TestMessageCommandCmd(t *testing.T) { + mock := &client.MockClient{ + PostFunc: func(ctx context.Context, path string, body interface{}) ([]byte, error) { + return testutil.MockMessageResponse(), nil + }, + } + + req := types.CommandRequest{ + Command: "/test", + Arguments: map[string]string{"arg1": "value1"}, + } + + resp, err := mock.Post(context.Background(), "/session/session1/command", req) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var result types.MessageWithParts + if err := json.Unmarshal(resp, &result); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } +} + +func TestMessageShellCmd(t *testing.T) { + tests := []struct { + name string + agent string + command string + wantErr bool + }{ + { + name: "shell with agent", + agent: "default", + command: "ls -la", + wantErr: false, + }, + { + name: "shell without agent", + agent: "", + command: "ls -la", + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if tt.agent == "" { + // Test the error case + return + } + + mock := &client.MockClient{ + PostFunc: func(ctx context.Context, path string, body interface{}) ([]byte, error) { + return testutil.MockMessageResponse(), nil + }, + } + + req := types.ShellRequest{ + Agent: tt.agent, + Command: tt.command, + } + + resp, err := mock.Post(context.Background(), "/session/session1/shell", req) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var result types.MessageWithParts + if err := json.Unmarshal(resp, &result); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + }) + } +} + +func TestIndexOf(t *testing.T) { + tests := []struct { + s string + substr string + want int + }{ + {"hello", "ll", 2}, + {"hello", "lo", 3}, + {"hello", "x", -1}, + {"hello", "", 0}, + {"", "a", -1}, + {"hello", "hell", 0}, + {"hello", "hello", 0}, + {"hello", "o", 4}, + } + + for _, tt := range tests { + result := indexOf(tt.s, tt.substr) + if result != tt.want { + t.Errorf("indexOf(%q, %q) = %d, want %d", tt.s, tt.substr, result, tt.want) + } + } +} diff --git a/oho/cmd/project/project_test.go b/oho/cmd/project/project_test.go new file mode 100644 index 0000000..eb43cb3 --- /dev/null +++ b/oho/cmd/project/project_test.go @@ -0,0 +1,127 @@ +package project + +import ( + "context" + "encoding/json" + "testing" + + "github.com/anomalyco/oho/internal/client" + "github.com/anomalyco/oho/internal/testutil" + "github.com/anomalyco/oho/internal/types" +) + +func TestProjectListCmd(t *testing.T) { + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + return testutil.MockProjectsResponse(), nil + }, + } + + resp, err := mock.Get(context.Background(), "/project") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var projects []types.Project + if err := json.Unmarshal(resp, &projects); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if len(projects) != 2 { + t.Errorf("Expected 2 projects, got %d", len(projects)) + } +} + +func TestProjectCurrentCmd(t *testing.T) { + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + project := types.Project{ + ID: "proj1", + Name: "Current Project", + Path: "/home/user/project", + Vcs: "git", + } + return json.Marshal(project) + }, + } + + resp, err := mock.Get(context.Background(), "/project/current") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var project types.Project + if err := json.Unmarshal(resp, &project); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if project.ID != "proj1" { + t.Errorf("Expected project ID 'proj1', got %s", project.ID) + } +} + +func TestPathCmd(t *testing.T) { + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + return testutil.MockPathResponse(), nil + }, + } + + resp, err := mock.Get(context.Background(), "/project/path") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var path types.Path + if err := json.Unmarshal(resp, &path); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if path.Current == "" { + t.Error("Expected current path but got empty") + } +} + +func TestVCSCmd(t *testing.T) { + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + return testutil.MockVCSResponse(), nil + }, + } + + resp, err := mock.Get(context.Background(), "/project/vcs") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var vcs types.VcsInfo + if err := json.Unmarshal(resp, &vcs); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if vcs.Type != "git" { + t.Errorf("Expected VCS type 'git', got %s", vcs.Type) + } +} + +func TestInstanceDisposeCmd(t *testing.T) { + mock := &client.MockClient{ + PostFunc: func(ctx context.Context, path string, body interface{}) ([]byte, error) { + return testutil.MockBoolResponse(true), nil + }, + } + + resp, err := mock.Post(context.Background(), "/instance/dispose", nil) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var success bool + if err := json.Unmarshal(resp, &success); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if !success { + t.Error("Expected success=true") + } +} diff --git a/oho/cmd/provider/provider_test.go b/oho/cmd/provider/provider_test.go new file mode 100644 index 0000000..9d9650e --- /dev/null +++ b/oho/cmd/provider/provider_test.go @@ -0,0 +1,126 @@ +package provider + +import ( + "context" + "encoding/json" + "testing" + + "github.com/anomalyco/oho/internal/client" + "github.com/anomalyco/oho/internal/testutil" + "github.com/anomalyco/oho/internal/types" +) + +func TestProviderListCmd(t *testing.T) { + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + type ProviderListResult struct { + All []types.Provider `json:"all"` + Default map[string]string `json:"default"` + Connected []string `json:"connected"` + } + result := ProviderListResult{ + All: []types.Provider{ + {ID: "openai", Name: "OpenAI", BaseURL: "https://api.openai.com"}, + {ID: "anthropic", Name: "Anthropic", BaseURL: "https://api.anthropic.com"}, + }, + Default: map[string]string{"default": "gpt-4"}, + Connected: []string{"openai"}, + } + return json.Marshal(result) + }, + } + + resp, err := mock.Get(context.Background(), "/provider") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var result struct { + All []types.Provider `json:"all"` + Default map[string]string `json:"default"` + Connected []string `json:"connected"` + } + if err := json.Unmarshal(resp, &result); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if len(result.All) != 2 { + t.Errorf("Expected 2 providers, got %d", len(result.All)) + } +} + +func TestProviderAuthCmd(t *testing.T) { + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + methods := map[string][]types.ProviderAuthMethod{ + "openai": { + {Type: "api_key", Required: true, Description: "API Key authentication"}, + }, + } + return json.Marshal(methods) + }, + } + + resp, err := mock.Get(context.Background(), "/provider/auth") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var methods map[string][]types.ProviderAuthMethod + if err := json.Unmarshal(resp, &methods); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if len(methods) == 0 { + t.Error("Expected auth methods but got none") + } +} + +func TestProviderOAuthAuthorizeCmd(t *testing.T) { + mock := &client.MockClient{ + PostFunc: func(ctx context.Context, path string, body interface{}) ([]byte, error) { + auth := types.ProviderAuthAuthorization{ + URL: "https://auth.example.com/authorize", + State: "state123", + CodeChallenge: "challenge123", + } + return json.Marshal(auth) + }, + } + + resp, err := mock.Post(context.Background(), "/provider/openai/oauth/authorize", nil) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var auth types.ProviderAuthAuthorization + if err := json.Unmarshal(resp, &auth); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if auth.URL == "" { + t.Error("Expected auth URL but got empty string") + } +} + +func TestProviderOAuthCallbackCmd(t *testing.T) { + mock := &client.MockClient{ + PostFunc: func(ctx context.Context, path string, body interface{}) ([]byte, error) { + return testutil.MockBoolResponse(true), nil + }, + } + + resp, err := mock.Post(context.Background(), "/provider/openai/oauth/callback", nil) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var success bool + if err := json.Unmarshal(resp, &success); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if !success { + t.Error("Expected success=true") + } +} diff --git a/oho/cmd/session/session_test.go b/oho/cmd/session/session_test.go new file mode 100644 index 0000000..1b3404e --- /dev/null +++ b/oho/cmd/session/session_test.go @@ -0,0 +1,487 @@ +package session + +import ( + "context" + "encoding/json" + "net/http" + "net/http/httptest" + "os" + "testing" + + "github.com/anomalyco/oho/internal/client" + "github.com/anomalyco/oho/internal/config" + "github.com/anomalyco/oho/internal/testutil" + "github.com/anomalyco/oho/internal/types" +) + +func TestMain(m *testing.M) { + // Initialize config for tests + os.Setenv("OPENCODE_SERVER_HOST", "127.0.0.1") + os.Setenv("OPENCODE_SERVER_PORT", "4096") + os.Setenv("OPENCODE_SERVER_USERNAME", "opencode") + os.Setenv("OPENCODE_SERVER_PASSWORD", "test") + config.Init() + + m.Run() +} + +func TestSessionListCmd(t *testing.T) { + +import ( + "context" + "encoding/json" + "net/http" + "net/http/httptest" + "testing" + + "github.com/anomalyco/oho/internal/client" + "github.com/anomalyco/oho/internal/testutil" + "github.com/anomalyco/oho/internal/types" +) + +func TestSessionListCmd(t *testing.T) { + tests := []struct { + name string + mockResp []byte + mockErr error + statusCode int + wantErr bool + }{ + { + name: "success with sessions", + mockResp: testutil.MockSessionsResponse(), + mockErr: nil, + statusCode: 200, + wantErr: false, + }, + { + name: "empty sessions", + mockResp: testutil.MockResponse([]types.Session{}), + mockErr: nil, + statusCode: 200, + wantErr: false, + }, + { + name: "server error", + mockResp: nil, + mockErr: &client.APIError{StatusCode: 500, Message: "Internal Error"}, + statusCode: 500, + wantErr: true, + }, + { + name: "invalid JSON", + mockResp: []byte("invalid json"), + mockErr: nil, + statusCode: 200, + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + return tt.mockResp, tt.mockErr + }, + } + + resp, err := mock.Get(context.Background(), "/session") + if tt.wantErr && err == nil { + t.Error("Expected error but got nil") + } + if !tt.wantErr && err != nil { + t.Errorf("Unexpected error: %v", err) + } + if !tt.wantErr && resp != nil { + var sessions []types.Session + if err := json.Unmarshal(resp, &sessions); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + } + }) + } +} + +func TestSessionCreateCmd(t *testing.T) { + tests := []struct { + name string + parentID string + title string + mockResp []byte + mockErr error + statusCode int + wantErr bool + }{ + { + name: "create simple session", + title: "Test Session", + mockResp: testutil.MockSessionResponse(), + mockErr: nil, + statusCode: 200, + wantErr: false, + }, + { + name: "create with parent", + parentID: "parent-123", + title: "Child Session", + mockResp: testutil.MockSessionResponse(), + mockErr: nil, + statusCode: 200, + wantErr: false, + }, + { + name: "server error", + title: "Test Session", + mockResp: nil, + mockErr: &client.APIError{StatusCode: 500, Message: "Internal Error"}, + statusCode: 500, + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mock := &client.MockClient{ + PostFunc: func(ctx context.Context, path string, body interface{}) ([]byte, error) { + return tt.mockResp, tt.mockErr + }, + } + + resp, err := mock.Post(context.Background(), "/session", map[string]interface{}{"title": tt.title}) + if tt.wantErr && err == nil { + t.Error("Expected error but got nil") + } + if !tt.wantErr && err != nil { + t.Errorf("Unexpected error: %v", err) + } + if !tt.wantErr && resp != nil { + var session types.Session + if err := json.Unmarshal(resp, &session); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + } + }) + } +} + +func TestSessionStatusCmd(t *testing.T) { + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + return testutil.MockSessionStatusResponse(), nil + }, + } + + resp, err := mock.Get(context.Background(), "/session/status") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var status map[string]types.SessionStatus + if err := json.Unmarshal(resp, &status); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if len(status) != 2 { + t.Errorf("Expected 2 sessions, got %d", len(status)) + } +} + +func TestSessionGetCmd(t *testing.T) { + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + return testutil.MockSessionResponse(), nil + }, + } + + resp, err := mock.Get(context.Background(), "/session/session1") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var session types.Session + if err := json.Unmarshal(resp, &session); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if session.ID != "session1" { + t.Errorf("Expected session ID 'session1', got %s", session.ID) + } +} + +func TestSessionDeleteCmd(t *testing.T) { + tests := []struct { + name string + mockErr error + wantErr bool + }{ + { + name: "delete success", + mockErr: nil, + wantErr: false, + }, + { + name: "delete error", + mockErr: &client.APIError{StatusCode: 404, Message: "Session not found"}, + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mock := &client.MockClient{ + DeleteFunc: func(ctx context.Context, path string) ([]byte, error) { + return testutil.MockBoolResponse(true), tt.mockErr + }, + } + + resp, err := mock.Delete(context.Background(), "/session/session1") + if tt.wantErr && err == nil { + t.Error("Expected error but got nil") + } + if !tt.wantErr && err != nil { + t.Errorf("Unexpected error: %v", err) + } + if !tt.wantErr && resp != nil { + var deleted bool + if err := json.Unmarshal(resp, &deleted); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + if !deleted { + t.Error("Expected deleted=true") + } + } + }) + } +} + +func TestSessionUpdateCmd(t *testing.T) { + mock := &client.MockClient{ + PatchFunc: func(ctx context.Context, path string, body interface{}) ([]byte, error) { + return testutil.MockSessionResponse(), nil + }, + } + + resp, err := mock.Patch(context.Background(), "/session/session1", map[string]interface{}{"title": "New Title"}) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var session types.Session + if err := json.Unmarshal(resp, &session); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } +} + +func TestSessionChildrenCmd(t *testing.T) { + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + return testutil.MockSessionsResponse(), nil + }, + } + + resp, err := mock.Get(context.Background(), "/session/session1/children") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var sessions []types.Session + if err := json.Unmarshal(resp, &sessions); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } +} + +func TestSessionTodoCmd(t *testing.T) { + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + return testutil.MockTodoResponse(), nil + }, + } + + resp, err := mock.Get(context.Background(), "/session/session1/todo") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var todos []types.Todo + if err := json.Unmarshal(resp, &todos); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if len(todos) != 2 { + t.Errorf("Expected 2 todos, got %d", len(todos)) + } +} + +func TestSessionForkCmd(t *testing.T) { + mock := &client.MockClient{ + PostFunc: func(ctx context.Context, path string, body interface{}) ([]byte, error) { + return testutil.MockSessionResponse(), nil + }, + } + + resp, err := mock.Post(context.Background(), "/session/session1/fork", nil) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var session types.Session + if err := json.Unmarshal(resp, &session); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } +} + +func TestSessionAbortCmd(t *testing.T) { + mock := &client.MockClient{ + PostFunc: func(ctx context.Context, path string, body interface{}) ([]byte, error) { + return testutil.MockBoolResponse(true), nil + }, + } + + resp, err := mock.Post(context.Background(), "/session/session1/abort", nil) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var success bool + if err := json.Unmarshal(resp, &success); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + if !success { + t.Error("Expected success=true") + } +} + +func TestSessionShareCmd(t *testing.T) { + mock := &client.MockClient{ + PostFunc: func(ctx context.Context, path string, body interface{}) ([]byte, error) { + return testutil.MockSessionResponse(), nil + }, + } + + resp, err := mock.Post(context.Background(), "/session/session1/share", nil) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var session types.Session + if err := json.Unmarshal(resp, &session); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } +} + +func TestSessionUnshareCmd(t *testing.T) { + mock := &client.MockClient{ + DeleteFunc: func(ctx context.Context, path string) ([]byte, error) { + return testutil.MockSessionResponse(), nil + }, + } + + resp, err := mock.Delete(context.Background(), "/session/session1/share") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var session types.Session + if err := json.Unmarshal(resp, &session); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } +} + +func TestSessionDiffCmd(t *testing.T) { + mock := &client.MockClient{ + GetWithQueryFunc: func(ctx context.Context, path string, queryParams map[string]string) ([]byte, error) { + return testutil.MockDiffResponse(), nil + }, + } + + resp, err := mock.GetWithQuery(context.Background(), "/session/session1/diff", nil) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var diffs []types.FileDiff + if err := json.Unmarshal(resp, &diffs); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } +} + +func TestSessionSummarizeCmd(t *testing.T) { + mock := &client.MockClient{ + PostFunc: func(ctx context.Context, path string, body interface{}) ([]byte, error) { + return testutil.MockBoolResponse(true), nil + }, + } + + resp, err := mock.Post(context.Background(), "/session/session1/summarize", map[string]interface{}{"providerID": "openai", "modelID": "gpt-4"}) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var success bool + if err := json.Unmarshal(resp, &success); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } +} + +func TestSessionRevertCmd(t *testing.T) { + mock := &client.MockClient{ + PostFunc: func(ctx context.Context, path string, body interface{}) ([]byte, error) { + return testutil.MockBoolResponse(true), nil + }, + } + + resp, err := mock.Post(context.Background(), "/session/session1/revert", map[string]interface{}{"messageID": "msg1"}) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var success bool + if err := json.Unmarshal(resp, &success); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } +} + +func TestSessionUnrevertCmd(t *testing.T) { + mock := &client.MockClient{ + PostFunc: func(ctx context.Context, path string, body interface{}) ([]byte, error) { + return testutil.MockBoolResponse(true), nil + }, + } + + resp, err := mock.Post(context.Background(), "/session/session1/unrevert", nil) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var success bool + if err := json.Unmarshal(resp, &success); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } +} + +func TestSessionPermissionsCmd(t *testing.T) { + mock := &client.MockClient{ + PostFunc: func(ctx context.Context, path string, body interface{}) ([]byte, error) { + return testutil.MockBoolResponse(true), nil + }, + } + + resp, err := mock.Post(context.Background(), "/session/session1/permissions/perm1", map[string]interface{}{"response": "allow"}) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var success bool + if err := json.Unmarshal(resp, &success); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } +} + +// Helper function to create test server +func createTestServer(handlers map[string]http.HandlerFunc) *httptest.Server { + mux := http.NewServeMux() + for path, handler := range handlers { + mux.Handle(path, handler) + } + return httptest.NewServer(mux) +} diff --git a/oho/cmd/tool/tool_test.go b/oho/cmd/tool/tool_test.go new file mode 100644 index 0000000..40330c2 --- /dev/null +++ b/oho/cmd/tool/tool_test.go @@ -0,0 +1,89 @@ +package tool + +import ( + "context" + "encoding/json" + "testing" + + "github.com/anomalyco/oho/internal/client" + "github.com/anomalyco/oho/internal/testutil" + "github.com/anomalyco/oho/internal/types" +) + +func TestToolIDsCmd(t *testing.T) { + mock := &client.MockClient{ + GetFunc: func(ctx context.Context, path string) ([]byte, error) { + return testutil.MockToolIDsResponse(), nil + }, + } + + resp, err := mock.Get(context.Background(), "/tool/ids") + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var ids types.ToolIDs + if err := json.Unmarshal(resp, &ids); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if len(ids.IDs) == 0 { + t.Error("Expected tool IDs but got none") + } +} + +func TestToolListCmd(t *testing.T) { + tests := []struct { + name string + provider string + model string + wantErr bool + }{ + { + name: "list all tools", + wantErr: false, + }, + { + name: "list tools with provider", + provider: "openai", + wantErr: false, + }, + { + name: "list tools with model", + model: "gpt-4", + wantErr: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mock := &client.MockClient{ + GetWithQueryFunc: func(ctx context.Context, path string, queryParams map[string]string) ([]byte, error) { + return testutil.MockToolListResponse(), nil + }, + } + + queryParams := map[string]string{} + if tt.provider != "" { + queryParams["provider"] = tt.provider + } + if tt.model != "" { + queryParams["model"] = tt.model + } + + resp, err := mock.GetWithQuery(context.Background(), "/tool", queryParams) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var tools types.ToolList + if err := json.Unmarshal(resp, &tools); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if len(tools.Tools) == 0 { + t.Error("Expected tools but got none") + } + }) + } +} diff --git a/oho/cmd/tui/tui_test.go b/oho/cmd/tui/tui_test.go new file mode 100644 index 0000000..5d20ee4 --- /dev/null +++ b/oho/cmd/tui/tui_test.go @@ -0,0 +1,86 @@ +package tui + +import ( + "context" + "encoding/json" + "testing" + + "github.com/anomalyco/oho/internal/client" + "github.com/anomalyco/oho/internal/testutil" +) + +func TestTUIOpenHelpCmd(t *testing.T) { + mock := &client.MockClient{ + PostFunc: func(ctx context.Context, path string, body interface{}) ([]byte, error) { + return testutil.MockBoolResponse(true), nil + }, + } + + resp, err := mock.Post(context.Background(), "/tui/open-help", nil) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var success bool + if err := json.Unmarshal(resp, &success); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + + if !success { + t.Error("Expected success=true") + } +} + +func TestTUIShowToastCmd(t *testing.T) { + tests := []struct { + name string + message string + title string + variant string + }{ + { + name: "show toast with message", + message: "Test message", + title: "Test", + variant: "info", + }, + { + name: "show toast error", + message: "Error occurred", + title: "Error", + variant: "error", + }, + { + name: "show toast success", + message: "Operation successful", + title: "Success", + variant: "success", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mock := &client.MockClient{ + PostFunc: func(ctx context.Context, path string, body interface{}) ([]byte, error) { + return testutil.MockBoolResponse(true), nil + }, + } + + req := map[string]interface{}{ + "message": tt.message, + "title": tt.title, + "variant": tt.variant, + } + + resp, err := mock.Post(context.Background(), "/tui/show-toast", req) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + var success bool + if err := json.Unmarshal(resp, &success); err != nil { + t.Errorf("Failed to unmarshal: %v", err) + } + }) + } +} diff --git a/oho/internal/client/client_interface.go b/oho/internal/client/client_interface.go new file mode 100644 index 0000000..99cdc20 --- /dev/null +++ b/oho/internal/client/client_interface.go @@ -0,0 +1,19 @@ +package client + +import ( + "context" +) + +// ClientInterface 定义客户端接口，便于测试 +type ClientInterface interface { + Get(ctx context.Context, path string) ([]byte, error) + GetWithQuery(ctx context.Context, path string, queryParams map[string]string) ([]byte, error) + Post(ctx context.Context, path string, body interface{}) ([]byte, error) + Put(ctx context.Context, path string, body interface{}) ([]byte, error) + Patch(ctx context.Context, path string, body interface{}) ([]byte, error) + Delete(ctx context.Context, path string) ([]byte, error) + SSEStream(ctx context.Context, path string) (<-chan []byte, <-chan error, error) +} + +// 确保 Client 实现 ClientInterface +var _ ClientInterface = (*Client)(nil) diff --git a/oho/internal/client/client_mock.go b/oho/internal/client/client_mock.go new file mode 100644 index 0000000..a2eb03f --- /dev/null +++ b/oho/internal/client/client_mock.go @@ -0,0 +1,79 @@ +package client + +import ( + "context" + "fmt" +) + +// APIError API 错误 +type APIError struct { + StatusCode int + Message string +} + +func (e *APIError) Error() string { + return fmt.Sprintf("API Error [%d]: %s", e.StatusCode, e.Message) +} + +// MockClient implements ClientInterface for testing +type MockClient struct { + GetFunc func(ctx context.Context, path string) ([]byte, error) + GetWithQueryFunc func(ctx context.Context, path string, queryParams map[string]string) ([]byte, error) + PostFunc func(ctx context.Context, path string, body interface{}) ([]byte, error) + PutFunc func(ctx context.Context, path string, body interface{}) ([]byte, error) + PatchFunc func(ctx context.Context, path string, body interface{}) ([]byte, error) + DeleteFunc func(ctx context.Context, path string) ([]byte, error) + SSEStreamFunc func(ctx context.Context, path string) (<-chan []byte, <-chan error, error) +} + +func (m *MockClient) Get(ctx context.Context, path string) ([]byte, error) { + if m.GetFunc != nil { + return m.GetFunc(ctx, path) + } + return nil, nil +} + +func (m *MockClient) GetWithQuery(ctx context.Context, path string, queryParams map[string]string) ([]byte, error) { + if m.GetWithQueryFunc != nil { + return m.GetWithQueryFunc(ctx, path, queryParams) + } + return nil, nil +} + +func (m *MockClient) Post(ctx context.Context, path string, body interface{}) ([]byte, error) { + if m.PostFunc != nil { + return m.PostFunc(ctx, path, body) + } + return nil, nil +} + +func (m *MockClient) Put(ctx context.Context, path string, body interface{}) ([]byte, error) { + if m.PutFunc != nil { + return m.PutFunc(ctx, path, body) + } + return nil, nil +} + +func (m *MockClient) Patch(ctx context.Context, path string, body interface{}) ([]byte, error) { + if m.PatchFunc != nil { + return m.PatchFunc(ctx, path, body) + } + return nil, nil +} + +func (m *MockClient) Delete(ctx context.Context, path string) ([]byte, error) { + if m.DeleteFunc != nil { + return m.DeleteFunc(ctx, path) + } + return nil, nil +} + +func (m *MockClient) SSEStream(ctx context.Context, path string) (<-chan []byte, <-chan error, error) { + if m.SSEStreamFunc != nil { + return m.SSEStreamFunc(ctx, path) + } + return nil, nil, nil +} + +// Ensure MockClient implements ClientInterface +var _ ClientInterface = (*MockClient)(nil) diff --git a/oho/internal/config/config_test.go b/oho/internal/config/config_test.go new file mode 100644 index 0000000..1ec539a --- /dev/null +++ b/oho/internal/config/config_test.go @@ -0,0 +1,19 @@ +package config + +import ( + "os" + "testing" +) + +func TestMain(m *testing.M) { + // 设置测试环境变量 + os.Setenv("OPENCODE_SERVER_HOST", "127.0.0.1") + os.Setenv("OPENCODE_SERVER_PORT", "4096") + os.Setenv("OPENCODE_SERVER_USERNAME", "opencode") + os.Setenv("OPENCODE_SERVER_PASSWORD", "test") + + // 初始化配置 + Init() + + m.Run() +} diff --git a/oho/internal/testutil/testutil.go b/oho/internal/testutil/testutil.go new file mode 100644 index 0000000..d11799b --- /dev/null +++ b/oho/internal/testutil/testutil.go @@ -0,0 +1,299 @@ +package testutil + +import ( + "context" + "encoding/json" + "net/http" + "net/http/httptest" + + "github.com/anomalyco/oho/internal/types" +) + +// NewMockServer 创建模拟 HTTP 服务器 +func NewMockServer(handlers map[string]http.HandlerFunc) *httptest.Server { + mux := http.NewServeMux() + for path, handler := range handlers { + mux.Handle(path, handler) + } + return httptest.NewServer(mux) +} + +// MockResponse 创建 JSON 响应 +func MockResponse(v interface{}) []byte { + data, _ := json.Marshal(v) + return data +} + +// MockSessionsResponse 模拟会话列表响应 +func MockSessionsResponse() []byte { + sessions := []types.Session{ + {ID: "session1", Title: "Test Session 1", Model: "gpt-4"}, + {ID: "session2", Title: "Test Session 2", Model: "gpt-3.5-turbo"}, + } + return MockResponse(sessions) +} + +// MockSessionResponse 模拟单个会话响应 +func MockSessionResponse() []byte { + session := types.Session{ + ID: "session1", + Title: "Test Session", + Model: "gpt-4", + Agent: "default", + CreatedAt: 1234567890, + UpdatedAt: 1234567890, + } + return MockResponse(session) +} + +// MockSessionStatusResponse 模拟会话状态响应 +func MockSessionStatusResponse() []byte { + status := map[string]types.SessionStatus{ + "session1": {Status: "idle", IsReady: true, IsWorking: false}, + "session2": {Status: "working", IsReady: true, IsWorking: true, MessageID: "msg1"}, + } + return MockResponse(status) +} + +// MockMessagesResponse 模拟消息列表响应 +func MockMessagesResponse() []byte { + messages := []types.MessageWithParts{ + {Info: types.Message{ID: "msg1", Role: "user", Content: "Hello"}}, + {Info: types.Message{ID: "msg2", Role: "assistant", Content: "Hi there"}}, + } + return MockResponse(messages) +} + +// MockMessageResponse 模拟单个消息响应 +func MockMessageResponse() []byte { + msg := types.MessageWithParts{ + Info: types.Message{ + ID: "msg1", + SessionID: "session1", + Role: "user", + Content: "Hello world", + CreatedAt: 1234567890, + }, + Parts: []types.Part{ + {Type: "text", Data: "Hello world"}, + }, + } + return MockResponse(msg) +} + +// MockHealthResponse 模拟健康检查响应 +func MockHealthResponse() []byte { + health := types.HealthResponse{Healthy: true, Version: "1.0.0"} + return MockResponse(health) +} + +// MockConfigResponse 模拟配置响应 +func MockConfigResponse() []byte { + cfg := types.Config{ + Providers: map[string]interface{}{}, + DefaultModel: "gpt-4", + Theme: "dark", + Language: "en", + AutoApprove: []string{}, + MaxTokens: 4096, + Temperature: 0.7, + } + return MockResponse(cfg) +} + +// MockProvidersResponse 模拟提供商列表响应 +func MockProvidersResponse() []byte { + providers := []types.Provider{ + {ID: "openai", Name: "OpenAI", BaseURL: "https://api.openai.com", Models: []string{"gpt-4", "gpt-3.5-turbo"}, AuthType: "api_key"}, + {ID: "anthropic", Name: "Anthropic", BaseURL: "https://api.anthropic.com", Models: []string{"claude-3"}, AuthType: "api_key"}, + } + return MockResponse(providers) +} + +// MockProjectsResponse 模拟项目列表响应 +func MockProjectsResponse() []byte { + projects := []types.Project{ + {ID: "proj1", Name: "Project 1", Path: "/home/user/project1", Vcs: "git"}, + {ID: "proj2", Name: "Project 2", Path: "/home/user/project2", Vcs: "none"}, + } + return MockResponse(projects) +} + +// MockPathResponse 模拟路径响应 +func MockPathResponse() []byte { + path := types.Path{ + Current: "/home/user/current", + Home: "/home/user", + IsGit: true, + } + return MockResponse(path) +} + +// MockVCSResponse 模拟 VCS 信息响应 +func MockVCSResponse() []byte { + vcs := types.VcsInfo{ + Type: "git", + Branch: "main", + Commit: "abc123", + Remote: "origin", + IsDirty: false, + } + return MockResponse(vcs) +} + +// MockFileListResponse 模拟文件列表响应 +func MockFileListResponse() []byte { + files := []types.FileNode{ + {Name: "src", Path: "/src", Type: "directory"}, + {Name: "main.go", Path: "/main.go", Type: "file"}, + } + return MockResponse(files) +} + +// MockFileContentResponse 模拟文件内容响应 +func MockFileContentResponse() []byte { + content := types.FileContent{ + Path: "/main.go", + Content: "package main\n\nfunc main() {}", + Encoding: "utf-8", + } + return MockResponse(content) +} + +// MockFileStatusResponse 模拟文件状态响应 +func MockFileStatusResponse() []byte { + files := []types.File{ + {Path: "main.go", Status: "modified"}, + {Path: "go.mod", Status: "unchanged"}, + } + return MockResponse(files) +} + +// MockAgentsResponse 模拟代理列表响应 +func MockAgentsResponse() []byte { + agents := []types.Agent{ + {ID: "default", Name: "Default Agent", Description: "Default programming agent", Tools: []string{"Read", "Edit", "Bash"}}, + {ID: "review", Name: "Review Agent", Description: "Code review agent", Tools: []string{"Read", "Grep"}}, + } + return MockResponse(agents) +} + +// MockCommandsResponse 模拟命令列表响应 +func MockCommandsResponse() []byte { + commands := []types.Command{ + {Name: "test", Description: "Run tests", Usage: "test [package]"}, + {Name: "build", Description: "Build the project", Usage: "build [target]"}, + } + return MockResponse(commands) +} + +// MockToolIDsResponse 模拟工具 ID 列表响应 +func MockToolIDsResponse() []byte { + ids := types.ToolIDs{ + IDs: []string{"Read", "Edit", "Write", "Bash", "Grep", "Glob"}, + } + return MockResponse(ids) +} + +// MockToolListResponse 模拟工具列表响应 +func MockToolListResponse() []byte { + tools := types.ToolList{ + Tools: []types.Tool{ + {Name: "Read", Description: "Read file contents", Schema: map[string]interface{}{}}, + {Name: "Edit", Description: "Edit file contents", Schema: map[string]interface{}{}}, + }, + } + return MockResponse(tools) +} + +// MockLSPStatusResponse 模拟 LSP 状态响应 +func MockLSPStatusResponse() []byte { + status := []types.LSPStatus{ + {Name: "gopls", Status: "running", Port: 1234}, + {Name: "tsserver", Status: "stopped", Port: 0}, + } + return MockResponse(status) +} + +// MockFormatterStatusResponse 模拟格式化器状态响应 +func MockFormatterStatusResponse() []byte { + status := []types.FormatterStatus{ + {Name: "gofmt", Status: "available"}, + {Name: "prettier", Status: "available"}, + } + return MockResponse(status) +} + +// MockMCPStatusResponse 模拟 MCP 状态响应 +func MockMCPStatusResponse() []byte { + status := []types.MCPStatus{ + {Name: "filesystem", Status: "running"}, + {Name: "github", Status: "error", Error: "auth required"}, + } + return MockResponse(status) +} + +// MockTodoResponse 模拟待办事项响应 +func MockTodoResponse() []byte { + todos := []types.Todo{ + {ID: "todo1", Content: "Implement feature X", Status: "pending", MessageID: "msg1"}, + {ID: "todo2", Content: "Fix bug Y", Status: "completed", MessageID: "msg2"}, + } + return MockResponse(todos) +} + +// MockDiffResponse 模拟差异响应 +func MockDiffResponse() []byte { + diffs := []types.FileDiff{ + {Path: "main.go", Before: "func main() {}", After: "func main() {\n}", Status: "modified"}, + } + return MockResponse(diffs) +} + +// MockSymbolsResponse 模拟符号搜索响应 +func MockSymbolsResponse() []byte { + symbols := []types.Symbol{ + {Name: "main", Kind: "function", Path: "main.go", Line: 10, Column: 1}, + {Name: "Config", Kind: "struct", Path: "config.go", Line: 5, Column: 1}, + } + return MockResponse(symbols) +} + +// MockFindMatchesResponse 模拟查找匹配响应 +func MockFindMatchesResponse() []byte { + matches := []types.FindMatch{ + {Path: "main.go", LineNumber: 10, Lines: "func main() {}", AbsoluteOffset: 100, Submatches: []types.Submatch{{Start: 0, End: 4}}}, + } + return MockResponse(matches) +} + +// MockBoolResponse 创建布尔响应 +func MockBoolResponse(b bool) []byte { + return MockResponse(b) +} + +// ErrorHandler 创建错误响应处理器 +func ErrorHandler(statusCode int, message string) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(statusCode) + w.Write([]byte(message)) + } +} + +// JSONHandler 创建 JSON 响应处理器 +func JSONHandler(v interface{}) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(v) + } +} + +// HandlerFuncForPath 创建特定路径的处理器 +func HandlerFuncForPath(path string, fn func(w http.ResponseWriter, r *http.Request)) http.HandlerFunc { + return fn +} + +// NewTestContext 创建测试用的 context +func NewTestContext() context.Context { + return context.Background() +} diff --git a/oho/internal/util/output_test.go b/oho/internal/util/output_test.go new file mode 100644 index 0000000..f41c1d9 --- /dev/null +++ b/oho/internal/util/output_test.go @@ -0,0 +1,136 @@ +package util + +import ( + "os" + "testing" + + "github.com/anomalyco/oho/internal/config" +) + +func TestMain(m *testing.M) { + // Initialize config for tests + os.Setenv("OPENCODE_SERVER_HOST", "127.0.0.1") + os.Setenv("OPENCODE_SERVER_PORT", "4096") + os.Setenv("OPENCODE_SERVER_USERNAME", "opencode") + os.Setenv("OPENCODE_SERVER_PASSWORD", "test") + config.Init() + + m.Run() +} + +func TestOutputJSON(t *testing.T) { + // Save original config + origJSON := config.Get().JSON + defer func() { config.Get().JSON = origJSON }() + + // Enable JSON mode + config.Get().JSON = true + + // Test JSON output + data := map[string]string{"key": "value"} + err := OutputJSON(data) + if err != nil { + t.Errorf("OutputJSON failed: %v", err) + } +} + +func TestOutputText(t *testing.T) { + // Save original config + origJSON := config.Get().JSON + defer func() { config.Get().JSON = origJSON }() + + // Disable JSON mode + config.Get().JSON = false + + // Test text output - should not panic + OutputText("test %s", "value") +} + +func TestOutputLine(t *testing.T) { + // Save original config + origJSON := config.Get().JSON + defer func() { config.Get().JSON = origJSON }() + + // Disable JSON mode + config.Get().JSON = false + + // Test line output - should not panic + OutputLine("test line") +} + +func TestOutputTable(t *testing.T) { + // Save original config + origJSON := config.Get().JSON + defer func() { config.Get().JSON = origJSON }() + + // Disable JSON mode + config.Get().JSON = false + + headers := []string{"Name", "Age"} + rows := [][]string{ + {"Alice", "30"}, + {"Bob", "25"}, + } + + // Should not panic + OutputTable(headers, rows) +} + +func TestOutputTableJSON(t *testing.T) { + // Save original config + origJSON := config.Get().JSON + defer func() { config.Get().JSON = origJSON }() + + // Enable JSON mode + config.Get().JSON = true + + headers := []string{"Name", "Age"} + rows := [][]string{ + {"Alice", "30"}, + {"Bob", "25"}, + } + + // Should not panic + OutputTable(headers, rows) +} + +func TestTruncate(t *testing.T) { + tests := []struct { + input string + maxLen int + expected string + }{ + {"hello", 10, "hello"}, + {"hello", 3, "..."}, + {"hi", 5, "hi"}, + {"", 5, ""}, + } + + for _, tt := range tests { + result := Truncate(tt.input, tt.maxLen) + if result != tt.expected { + t.Errorf("Truncate(%q, %d) = %q, want %q", tt.input, tt.maxLen, result, tt.expected) + } + } +} + +func TestPluralize(t *testing.T) { + tests := []struct { + count int + singular string + plural string + expected string + }{ + {1, "item", "items", "item"}, + {0, "item", "items", "items"}, + {2, "item", "items", "items"}, + {100, "session", "sessions", "sessions"}, + } + + for _, tt := range tests { + result := Pluralize(tt.count, tt.singular, tt.plural) + if result != tt.expected { + t.Errorf("Pluralize(%d, %q, %q) = %q, want %q", tt.count, tt.singular, tt.plural, result, tt.expected) + } + } +}