@happycastle/oh-my-openclaw 0.3.0 → 0.4.0

package/dist/commands/workflow-commands.js

@@ -1,12 +1,17 @@
 import { readFileSync } from 'fs';
-import { join } from 'path';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// From dist/commands/ → plugin root is ../../
+const PLUGIN_ROOT = join(__dirname, '..', '..');
 function readWorkflow(workflowName) {
     try {
-        const workflowPath = join(process.cwd(), 'workflows', `${workflowName}.md`);
+        const workflowPath = join(PLUGIN_ROOT, 'workflows', `${workflowName}.md`);
         return readFileSync(workflowPath, 'utf-8');
     }
     catch {
-        return `Error: Could not read workflow file 'workflows/${workflowName}.md'. Make sure the oh-my-openclaw skill directory is accessible.`;
+        return `Error: Could not read workflow file 'workflows/${workflowName}.md'. Plugin root: ${PLUGIN_ROOT}`;
     }
 }
 export function registerWorkflowCommands(api) {

package/dist/index.js

@@ -11,7 +11,7 @@ import { registerWorkflowCommands } from './commands/workflow-commands.js';
 import { registerRalphCommands } from './commands/ralph-commands.js';
 export default function register(api) {
     const config = getConfig(api);
-    api.logger.info(`[${PLUGIN_ID}] Initializing plugin v0.3.0`);
+    api.logger.info(`[${PLUGIN_ID}] Initializing plugin v0.3.1`);
     try {
         registerTodoEnforcer(api);
         api.logger.info(`[${PLUGIN_ID}] Todo Enforcer hook registered (enabled: ${config.todo_enforcer_enabled})`);
@@ -79,7 +79,7 @@ export default function register(api) {
         return {
             ok: true,
             plugin: PLUGIN_ID,
-            version: '0.3.0',
+            version: '0.3.1',
             hooks: ['todo-enforcer', 'comment-checker', 'message-monitor'],
             services: ['ralph-loop'],
             tools: ['omoc_delegate', 'omoc_look_at', 'omoc_checkpoint'],

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "oh-my-openclaw",
   "name": "Oh-My-OpenClaw",
   "description": "Multi-agent orchestration plugin \u2014 10 agents, category-based model routing, todo enforcer, ralph loop, and custom tools",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "skills": ["skills"],
   "configSchema": {
     "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happycastle/oh-my-openclaw",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Oh-My-OpenClaw plugin — multi-agent orchestration, todo enforcer, ralph loop, and custom tools for OpenClaw",
   "type": "module",
   "main": "dist/index.js",
@@ -36,6 +36,7 @@
     "dist",
     "bin",
     "skills",
+    "workflows",
     "openclaw.plugin.json"
   ],
   "keywords": [

package/skills/web-search.md

@@ -0,0 +1,155 @@
+---
+name: web-search
+description: 웹 검색 및 정보 수집 스킬. OmO의 websearch/context7/grep_app MCP 패턴을 OpenClaw 네이티브 도구 + mcporter MCP로 통합. 웹 검색, 페이지 읽기, 라이브러리 문서 검색, 오픈소스 코드 검색을 지원한다.
+---
+
+# Web Search Skill
+
+웹에서 정보를 수집하는 통합 스킬. OpenClaw 네이티브 도구(`web_fetch`)와 mcporter MCP 서버를 조합하여 다양한 검색 전략을 제공한다.
+
+## 도구 우선순위
+
+상황에 따라 최적의 도구를 선택:
+
+### 1. OpenClaw 네이티브 `web_fetch` (기본)
+가장 빠르고 간단. URL을 알고 있거나 간단한 페이지 읽기에 적합.
+```
+web_fetch(url="https://example.com", extractMode="markdown")
+```
+- 별도 설정 불필요
+- HTML → markdown/text 자동 변환
+- `maxChars`로 응답 크기 제한 가능
+
+### 2. mcporter `web-search-prime` (웹 검색)
+키워드 기반 웹 검색. 최신 정보, 뉴스, 기술 블로그 검색에 적합.
+```bash
+mcporter call web-search-prime.webSearchPrime \
+  search_query="검색어" \
+  location="us" \
+  content_size="medium"
+```
+**파라미터:**
+- `search_query` (필수): 검색 키워드
+- `location`: `us` | `kr` | `jp` 등 (기본: `us`)
+- `content_size`: `medium` (기본) | `high` (상세, ~2500자)
+- `search_recency_filter`: `oneDay` | `oneWeek` | `oneMonth` | `oneYear` | `noLimit`
+
+### 3. mcporter `web-reader` (페이지 전문 읽기)
+특정 URL의 전체 내용을 깔끔하게 추출. `web_fetch`보다 정확한 추출이 필요할 때.
+```bash
+mcporter call web-reader.webReader \
+  url="https://example.com" \
+  return_format="markdown"
+```
+**파라미터:**
+- `url` (필수): 읽을 URL
+- `return_format`: `markdown` (기본) | `text`
+- `retain_images`: `true` (기본) | `false`
+- `with_links_summary`: `true` | `false` (문서 내 링크 요약)
+
+### 4. mcporter `exa` (시맨틱 웹 검색)
+OmO의 기본 웹서치. 의미 기반(semantic) 검색으로 키워드보다 정확한 결과.
+```bash
+mcporter call exa.web_search_exa \
+  query="검색어"
+```
+- API 키 없이도 동작 (기본 제공)
+- 시맨틱 검색 지원 (질문 형태로 검색하면 더 좋은 결과)
+
+### 5. mcporter `context7` (라이브러리 문서 검색)
+프로그래밍 라이브러리/프레임워크의 공식 문서를 검색.
+```bash
+# 라이브러리 검색
+mcporter call context7.resolve-library-id \
+  libraryName="react"
+
+# 문서 검색
+mcporter call context7.get-library-docs \
+  context7CompatibleLibraryID="/facebook/react" \
+  topic="hooks"
+```
+**용도:**
+- 라이브러리 API 레퍼런스 확인
+- 프레임워크 사용법 검색
+- 최신 버전 변경사항 확인
+
+### 6. mcporter `grep_app` (오픈소스 코드 검색)
+GitHub 등 오픈소스 코드에서 패턴/사용 예시를 검색.
+```bash
+mcporter call grep_app.search \
+  query="useEffect cleanup" \
+  language="typescript"
+```
+**용도:**
+- 실제 프로젝트에서의 API 사용 예시 찾기
+- 특정 패턴/에러의 해결책 검색
+- 라이브러리 통합 방법 확인
+
+### 7. mcporter `zread` (GitHub 리포 직접 탐색)
+특정 GitHub 리포지토리의 파일/문서를 직접 읽기.
+```bash
+# 리포 구조 확인
+mcporter call zread.get_repo_structure \
+  repo_name="owner/repo"
+
+# 파일 읽기
+mcporter call zread.read_file \
+  repo_name="owner/repo" \
+  file_path="src/index.ts"
+
+# 문서/이슈 검색
+mcporter call zread.search_doc \
+  repo_name="owner/repo" \
+  query="검색어"
+```
+
+## 검색 전략 가이드
+
+### 일반 검색 (뉴스, 블로그, 일반 정보)
+1. `web-search-prime` → 검색 결과 → `web_fetch`로 상세 페이지 읽기
+
+### 기술 문서 검색
+1. `context7`로 라이브러리 문서 직접 검색
+2. 없으면 `web-search-prime`으로 공식 문서 URL 찾기 → `web_fetch`
+
+### 코드 예시 검색
+1. `grep_app`으로 오픈소스 코드에서 패턴 검색
+2. `zread`로 특정 리포 파일 직접 읽기
+3. `context7`로 라이브러리 공식 예시 확인
+
+### 특정 사이트 정보
+1. `web_fetch`로 직접 URL 읽기 (가장 빠름)
+2. 내용 추출이 불완전하면 `web-reader`로 재시도
+
+### 최신 정보 (오늘/이번 주)
+1. `web-search-prime` + `search_recency_filter="oneDay"` 또는 `"oneWeek"`
+2. `exa`로 시맨틱 검색 보완
+
+## mcporter 설정
+
+MCP 서버들은 `~/.openclaw/workspace/config/mcporter.json`에 설정되어 있다:
+
+```json
+{
+  "mcpServers": {
+    "web-search-prime": { "type": "remote", "url": "https://api.z.ai/api/mcp/web_search_prime/mcp" },
+    "web-reader": { "type": "remote", "url": "https://api.z.ai/api/mcp/web_reader/mcp" },
+    "exa": { "type": "remote", "url": "https://mcp.exa.ai/mcp?tools=web_search_exa" },
+    "context7": { "type": "remote", "url": "https://mcp.context7.com/mcp" },
+    "grep_app": { "type": "remote", "url": "https://mcp.grep.app" },
+    "zread": { "type": "remote", "url": "https://api.z.ai/api/mcp/zread/mcp" }
+  }
+}
+```
+
+## OmO 대응표
+
+| OmO (MCP)       | oh-my-openclaw 대응                              |
+|------------------|--------------------------------------------------|
+| `websearch` (Exa)| `mcporter call exa.web_search_exa` + `web_fetch` |
+| `websearch` (Tavily)| `mcporter call web-search-prime.webSearchPrime`|
+| `context7`       | `mcporter call context7.resolve-library-id` / `.get-library-docs` |
+| `grep_app`       | `mcporter call grep_app.search`                  |
+| *(없음)*         | `web_fetch` (OpenClaw 네이티브)                   |
+| *(없음)*         | `web-reader` (MCP, 깔끔한 페이지 추출)            |
+| *(없음)*         | `zread` (MCP, GitHub 리포 직접 탐색)               |

package/workflows/plan.md

@@ -0,0 +1,115 @@
+---
+description: Strategic planning workflow - analyze requirements and create execution plan
+---
+
+# Plan Workflow
+
+Strategic planning workflow that analyzes requirements and creates a structured execution plan before any implementation begins.
+
+## When to Use
+
+- Starting a new feature or project
+- Complex multi-step tasks
+- When requirements are ambiguous and need clarification
+- Before any `/ultrawork` or `/start-work` invocation
+
+## Workflow Steps
+
+### Phase 1: Context Gathering
+
+1. **Read existing context**
+   - Check workspace for existing plans: `workspace/plans/`
+   - Check wisdom notepads: `workspace/notepads/`
+   - Review any relevant AGENTS.md or project documentation
+
+2. **Analyze the request**
+   - What is the user asking for?
+   - What are the explicit requirements?
+   - What are the implicit requirements?
+   - What constraints exist?
+
+### Phase 2: Gap Analysis
+
+3. **Identify unknowns**
+   - What information is missing?
+   - What assumptions are being made?
+   - What dependencies exist?
+
+4. **Ask clarifying questions** (if needed)
+   - Only ask questions that materially affect the plan
+   - Batch questions together, don't ask one at a time
+   - Provide default assumptions if the user doesn't respond
+
+### Phase 3: Plan Creation
+
+5. **Create the execution plan**
+   - Save to `workspace/plans/YYYY-MM-DD_<slug>.md`
+   - Use the following structure:
+
+```markdown
+# Plan: <Title>
+
+**Created**: YYYY-MM-DD HH:MM
+**Status**: draft | approved | in-progress | completed
+**Category**: quick | deep | ultrabrain | visual-engineering
+
+## Goal
+<One sentence description of what we're building>
+
+## Requirements
+- [ ] Requirement 1
+- [ ] Requirement 2
+
+## Tasks
+### Task 1: <Name>
+- **Category**: quick | deep
+- **Agent**: sisyphus-junior | oracle | explore | librarian
+- **Dependencies**: none | Task N
+- **Description**: What needs to be done
+- **Acceptance Criteria**:
+  - [ ] Criterion 1
+  - [ ] Criterion 2
+
+### Task 2: <Name>
+...
+
+## Execution Order
+1. Task 1 (no dependencies)
+2. Task 2, Task 3 (parallel, depend on Task 1)
+3. Task 4 (depends on Task 2 + Task 3)
+
+## Risks
+- Risk 1: mitigation strategy
+- Risk 2: mitigation strategy
+
+## Verification
+- [ ] All acceptance criteria met
+- [ ] Code builds without errors
+- [ ] Tests pass (if applicable)
+```
+
+### Phase 4: Plan Review
+
+6. **Self-review the plan**
+   - Is every task actionable and specific?
+   - Are dependencies correctly identified?
+   - Is the execution order optimal (maximize parallelism)?
+   - Are acceptance criteria measurable?
+
+7. **Present plan to user**
+   - Show the plan summary
+   - Highlight any risks or assumptions
+   - Ask for approval before proceeding
+
+## Integration with Other Workflows
+
+- After plan approval, use `/start-work` to begin execution
+- Or use `/ultrawork` for fully automated execution without stops
+- Plan files persist in `workspace/plans/` for future reference
+
+## Wisdom Integration
+
+After planning, record any insights:
+- New patterns discovered → `workspace/notepads/learnings.md`
+- Key decisions made → `workspace/notepads/decisions.md`
+- Potential issues identified → `workspace/notepads/issues.md`

package/workflows/start-work.md

@@ -0,0 +1,110 @@
+---
+description: Start execution from an approved plan - delegate tasks to worker agents
+---
+
+# Start Work Workflow
+
+Execute an approved plan by delegating tasks to appropriate worker agents, tracking progress, and verifying completion.
+
+## Prerequisites
+
+- An approved plan exists in `workspace/plans/`
+- Plan status is "approved" or "in-progress"
+
+## Workflow Steps
+
+### Phase 1: Plan Loading
+
+1. **Load the plan**
+   - Read the most recent plan from `workspace/plans/`
+   - Or specify a plan: `/start-work <plan-file>`
+   - Verify plan status is "approved"
+   - Update plan status to "in-progress"
+
+2. **Initialize tracking**
+   - Create todo items for each task in the plan
+   - Set up wisdom notepads if not already present
+
+### Phase 2: Task Execution
+
+3. **Execute tasks in dependency order**
+
+   For each task (respecting execution order from plan):
+
+   a. **Mark task as in-progress** in todo list
+
+   b. **Select the right agent** based on task category:
+   
+   | Category | Agent | Model |
+   |----------|-------|-------|
+   | quick | sisyphus-junior | claude-sonnet-4-6 |
+   | deep | sisyphus-junior | claude-opus-4-6-thinking |
+   | ultrabrain | oracle | claude-opus-4-5-thinking |
+   | visual-engineering | sisyphus-junior | claude-opus-4-6-thinking |
+
+   c. **Delegate the task** with clear instructions:
+   ```
+   Task: <task name>
+   Description: <from plan>
+   Acceptance Criteria:
+   - <criterion 1>
+   - <criterion 2>
+   Context: <relevant files, dependencies>
+   ```
+
+   d. **Verify task completion** against acceptance criteria
+
+   e. **Mark task as completed** in todo list
+
+   f. **Record wisdom** if any insights were gained
+
+4. **Handle parallel tasks**
+   - Tasks with no mutual dependencies can run in parallel
+   - Use multiple agent spawns simultaneously
+   - Wait for all parallel tasks before moving to dependent tasks
+
+### Phase 3: Error Handling
+
+5. **On task failure**
+   - Record the error in `workspace/notepads/issues.md`
+   - Attempt retry with more context (max 2 retries)
+   - If still failing, escalate to oracle agent for debugging
+   - If oracle can't resolve, pause and ask user
+
+6. **On blocking dependency**
+   - Skip blocked tasks, continue with independent tasks
+   - Return to blocked tasks when dependency resolves
+
+### Phase 4: Completion
+
+7. **Verify all tasks**
+   - Check all acceptance criteria are met
+   - Run build/test verification if applicable
+   - Review overall coherence of changes
+
+8. **Update plan status**
+   - Mark plan as "completed"
+   - Record completion time
+   - Summarize what was accomplished
+
+9. **Final wisdom capture**
+   - Record learnings in `workspace/notepads/learnings.md`
+   - Record any decisions in `workspace/notepads/decisions.md`
+   - Note any remaining issues in `workspace/notepads/issues.md`
+
+## Status Update Format
+
+After each task completion, output:
+
+```
+[N/M] Task: <name> - COMPLETED
+  - <what was done>
+  - <files modified>
+  Next: <next task name>
+```
+
+## Integration
+
+- Plans come from `/plan` workflow
+- `/ultrawork` combines `/plan` + `/start-work` automatically
+- Wisdom notepads persist across sessions for future reference

package/workflows/ultrawork.md

@@ -0,0 +1,90 @@
+---
+description: One-command full automation workflow. Analyzes task, creates plan, executes all steps, verifies results.
+---
+
+# Ultrawork Workflow
+
+Complete automation workflow that takes a task from analysis to verified completion.
+
+## Trigger
+When the user invokes `/ultrawork [task description]` or ultrawork mode is activated.
+
+## Prerequisites
+- Task description must be clear and actionable
+- Working directory must be a valid project
+
+## Workflow Steps
+
+### Phase 1: Analysis (Prometheus)
+```
+1. Read the task description carefully
+2. Analyze the current codebase state
+   - Run `git status` to check working tree
+   - Read relevant files to understand context
+   - Identify affected modules and dependencies
+3. Create a structured plan with:
+   - Clear task breakdown (numbered steps)
+   - Dependencies between steps
+   - Category assignment for each step (quick/deep/ultrabrain/visual-engineering)
+   - Verification criteria for each step
+4. Save plan to `workspace/plans/ultrawork-[timestamp].md`
+```
+
+### Phase 2: Execution (Atlas + Workers)
+```
+5. For each step in the plan:
+   a. Mark step as in_progress in todo list
+   b. Execute the step using appropriate tools
+   c. Verify the step's completion criteria
+   d. Record any learnings in wisdom notepad
+   e. Mark step as completed
+   f. If step fails:
+      - Analyze the failure
+      - Attempt fix (max 3 retries)
+      - If still failing, record issue and continue with next independent step
+```
+
+### Phase 3: Verification
+```
+6. Run full verification:
+   - Build check (if applicable): `npm run build`, `cargo build`, `go build`, etc.
+   - Lint check (if applicable)
+   - Test check (if applicable)
+   - LSP diagnostics check
+7. Fix any issues found during verification
+8. Run verification again until clean
+```
+
+### Phase 4: Completion
+```
+9. Generate completion summary:
+   - What was done
+   - What was changed (files modified/created/deleted)
+   - Any issues encountered and how they were resolved
+   - Wisdom accumulated
+10. Update wisdom notepads with final learnings
+11. Mark all todos as completed
+```
+
+## Todo Enforcer Integration
+
+During ultrawork execution, the following directive is active:
+
+> You MUST use TodoWrite to track every task. Mark tasks in_progress when starting,
+> completed when done. NEVER leave tasks unmarked. If you discover new subtasks,
+> add them immediately. Do not stop until all tasks are completed.
+
+## Error Handling
+
+- **Build failures**: Fix immediately, re-verify
+- **Test failures**: Fix the code, not the test (unless test is wrong)
+- **Lint errors**: Auto-fix where possible, manual fix otherwise
+- **Timeout**: Save progress, report partial completion with clear next steps
+
+## Output
+
+The workflow produces:
+1. Completed task with all changes applied
+2. Plan file in `workspace/plans/`
+3. Updated wisdom notepads (if learnings occurred)
+4. Completion summary in the conversation