@lgcyaxi/oh-my-claude 1.0.1 → 1.1.2

package/src/commands/omc-status.md

@@ -0,0 +1,71 @@
+# /omc-status
+
+Display status dashboard for oh-my-claude MCP background agents.
+
+## Instructions
+
+The user wants to see the current status of MCP background agents. Display a formatted ASCII dashboard showing:
+
+1. **Active Tasks** - Currently running background tasks
+2. **Provider Concurrency** - Usage bars for each provider
+3. **Recent Tasks** - Last 5 completed/failed tasks
+
+**Step 1: Get system status**
+
+```
+Use mcp__oh-my-claude-background__get_status to get:
+- Provider configuration (which have API keys)
+- Concurrency limits per provider
+- Current active task counts
+```
+
+**Step 2: Get task list**
+
+```
+Use mcp__oh-my-claude-background__list_tasks with:
+- limit: 20
+(Gets recent tasks including running, completed, failed, fallback_required)
+```
+
+**Step 3: Display dashboard**
+
+Format the output as an ASCII dashboard:
+
+```
+oh-my-claude Status Dashboard
+==============================
+
+ACTIVE TASKS (count)
+  [agent]     task_id...  Provider  [progress] status duration
+
+PROVIDER CONCURRENCY
+  Provider:   [bar]  active/limit active, queued queued
+
+RECENT TASKS (last 5)
+  [status] task_id agent  time_ago
+```
+
+**ASCII Progress Bar Helper:**
+
+For concurrency bars, use:
+- Full blocks: active tasks
+- Empty blocks: remaining capacity
+- 10 character width total
+
+```
+Example: 4/10 active -> "4/10 active"
+```
+
+**Status indicators:**
+- `running` - Task is executing
+- `completed` - Task finished successfully
+- `failed` - Task encountered an error
+- `fallback_required` - Provider API key not configured
+
+**If no tasks:**
+Display a message that no background tasks have been run yet, and suggest using `/omc-oracle` or other agent commands.
+
+**If MCP server not available:**
+Display an error message suggesting to run `oh-my-claude doctor` to check configuration.
+
+Now gather the status and display the dashboard.

package/src/commands/omcx-issue.md

@@ -0,0 +1,175 @@
+# /omcx-issue
+
+Report a bug to oh-my-claude GitHub Issues.
+
+## Instructions
+
+Create a bug report for the oh-my-claude project with auto-collected environment diagnostics.
+
+### Prerequisites Check
+
+**FIRST**: Verify GitHub MCP is available by calling:
+```
+mcp__plugin_github_github__get_me()
+```
+
+If this fails or the tool is not available, display:
+```
+GitHub MCP is not available. To report issues, you need the GitHub MCP plugin.
+
+Install it with:
+  claude mcp add github -- npx -y @modelcontextprotocol/server-github
+
+Or report manually at: https://github.com/lgcyaxi/oh-my-claude/issues/new
+```
+Then stop execution.
+
+### Workflow
+
+1. **Collect Environment Diagnostics**
+
+   Run these commands to gather system info:
+   ```bash
+   # oh-my-claude version
+   oh-my-claude --version 2>/dev/null || npx @lgcyaxi/oh-my-claude --version 2>/dev/null || echo "unknown"
+
+   # OS info
+   uname -s -r
+
+   # Node.js version
+   node --version
+
+   # Bun version (optional)
+   bun --version 2>/dev/null || echo "not installed"
+
+   # Installation type detection
+   which oh-my-claude >/dev/null 2>&1 && echo "global" || echo "npx"
+
+   # Doctor output (sanitized)
+   oh-my-claude doctor --no-color 2>/dev/null || npx @lgcyaxi/oh-my-claude doctor --no-color 2>/dev/null || echo "doctor command failed"
+   ```
+
+2. **Gather Issue Details from User**
+
+   Ask the user for:
+   - Brief summary of the issue (1 line - used as title)
+   - What happened (actual behavior)
+   - What was expected
+   - Steps to reproduce (optional)
+   - Any additional context
+
+3. **Generate Issue Draft**
+
+   Format the issue body:
+   ```markdown
+   ## Description
+   [User's brief summary]
+
+   ## What happened
+   [User's actual behavior description]
+
+   ## Expected behavior
+   [User's expected behavior]
+
+   ## Steps to reproduce
+   [User's steps, or "N/A" if not provided]
+
+   ## Environment
+
+   | Component | Value |
+   |-----------|-------|
+   | oh-my-claude | [version] |
+   | OS | [os info] |
+   | Node.js | [version] |
+   | Bun | [version or "not installed"] |
+   | Installation | [global/npx] |
+
+   <details>
+   <summary>Doctor output</summary>
+
+   ```
+   [doctor command output - sanitized, no API keys]
+   ```
+
+   </details>
+
+   ## Additional context
+   [User's additional context, or "None"]
+
+   ---
+   *Reported via `/omcx-issue` command*
+   ```
+
+4. **Show Draft and Request Confirmation**
+
+   Display the complete issue to the user:
+   ```
+   Issue Draft
+   -----------
+
+   Title: [Bug] [summary]
+
+   [issue body]
+
+   -----------
+
+   Does this look correct?
+   - "yes" or "submit" to create the issue
+   - "edit" to modify before submitting
+   - "cancel" to abort
+   ```
+
+5. **Submit Issue**
+
+   On confirmation, create the issue:
+   ```
+   mcp__plugin_github_github__issue_write(
+     method: "create",
+     owner: "lgcyaxi",
+     repo: "oh-my-claude",
+     title: "[Bug] <user's summary>",
+     body: "<generated body>",
+     labels: ["bug", "user-reported"]
+   )
+   ```
+
+6. **Report Result**
+
+   On success:
+   ```
+   Issue created successfully!
+
+   View at: https://github.com/lgcyaxi/oh-my-claude/issues/<number>
+
+   Thank you for helping improve oh-my-claude!
+   ```
+
+   On failure:
+   ```
+   Failed to create issue: <error message>
+
+   You can report manually at: https://github.com/lgcyaxi/oh-my-claude/issues/new
+   ```
+
+### Important Notes
+
+- Always sanitize doctor output - never include API keys
+- Use `npx @lgcyaxi/oh-my-claude` as fallback when global command unavailable
+- Labels "bug" and "user-reported" are applied automatically
+- Issue title format: `[Bug] <user's summary>`
+
+### Arguments
+
+`/omcx-issue [quick description]`
+
+- If description provided: Use as the issue summary
+- If no description: Prompt user for issue summary
+
+### Examples
+
+```
+/omcx-issue commands not installing properly
+/omcx-issue MCP server fails to connect
+/omcx-issue oracle agent returns empty response
+/omcx-issue
+```

package/src/commands/ulw.md

@@ -0,0 +1,144 @@
+# /ulw - Ultrawork Mode
+
+**ULTRAWORK MODE ACTIVATED!**
+
+You are now operating in **MAXIMUM PERFORMANCE MODE**. All restrictions on effort, thoroughness, and completion are lifted. You will work relentlessly until the task is FULLY complete.
+
+## Core Mandate
+
+**ZERO PARTIAL COMPLETION. 100% DELIVERY OR NOTHING.**
+
+This is not a suggestion. This is your operating contract:
+- NO scope reduction
+- NO mock versions or placeholders
+- NO skipped requirements
+- NO "good enough" stopping points
+- NO deleting tests to make builds pass
+- NO leaving code in broken state
+
+**60-80% completion is FAILURE. Only 100% is acceptable.**
+
+## Agent Utilization (MANDATORY)
+
+You MUST leverage ALL available agents to their fullest potential:
+
+### Sync Agents (Task tool)
+| Agent | Use For | When |
+|-------|---------|------|
+| **Explore** | Codebase search, pattern finding | FIRST - before any implementation |
+| **Claude-Reviewer** | Code review, verification | AFTER - every significant change |
+| **Claude-Scout** | Fast exploration, quick checks | PARALLEL - multiple searches |
+
+### Async Agents (MCP background)
+| Agent | Use For | When |
+|-------|---------|------|
+| **Oracle** | Architecture decisions, deep reasoning | When stuck or uncertain |
+| **Librarian** | External docs, library research | Before using unfamiliar APIs |
+| **Frontend-UI-UX** | Visual/UI implementation | All frontend work |
+| **Document-Writer** | Documentation, README | After implementation |
+
+**FIRE PARALLEL AGENTS AGGRESSIVELY.** Launch 5-10+ background tasks if needed. Don't wait - collect results when ready.
+
+## Execution Protocol
+
+### 1. Immediate Planning
+```
+FIRST ACTION: Create comprehensive TodoWrite list
+- Break down EVERY step
+- Include verification steps
+- Include documentation steps
+- NO hidden work - everything tracked
+```
+
+### 2. Aggressive Parallelization
+```
+LAUNCH PARALLEL:
+- Explore agents for codebase context
+- Librarian for external documentation
+- Multiple search paths simultaneously
+
+DO NOT wait for one search to complete before starting another.
+```
+
+### 3. Implementation with Verification
+```
+FOR EACH CHANGE:
+1. Implement the change
+2. Run diagnostics immediately
+3. Run tests if applicable
+4. Mark todo complete ONLY after verification passes
+```
+
+### 4. Zero-Tolerance Quality Gates
+
+**Before marking ANY task complete:**
+- [ ] Code compiles/transpiles without errors
+- [ ] Linter passes (no suppressions added)
+- [ ] Tests pass (no tests deleted or skipped)
+- [ ] Build succeeds (if applicable)
+- [ ] Functionality verified with actual execution
+
+**If verification fails:**
+1. Fix immediately
+2. Re-verify
+3. After 3 failures: STOP, consult Oracle, then ask user
+
+### 5. Completion Criteria
+
+The task is NOT complete until:
+- [ ] ALL todo items marked done
+- [ ] ALL verification gates passed
+- [ ] ALL user requirements addressed
+- [ ] Evidence collected for each completion claim
+
+## Anti-Patterns (BLOCKED)
+
+| Violation | Consequence |
+|-----------|-------------|
+| Claiming "done" without verification | REJECTED - redo with proof |
+| Reducing scope without user approval | REJECTED - implement full scope |
+| Skipping agent delegation | REJECTED - suboptimal execution |
+| Batch-completing todos | REJECTED - defeats tracking |
+| Leaving broken code | REJECTED - fix before proceeding |
+
+## Work Until Done Protocol
+
+**If session ends with incomplete todos:**
+1. Boulder state persists your progress
+2. Next session: `/omc-start-work` to resume
+3. Continue from first unchecked item
+4. NEVER restart from scratch
+
+**If you hit a blocker:**
+1. Document the blocker explicitly
+2. Consult Oracle for architecture advice
+3. If still blocked: Ask user for guidance
+4. NEVER silently give up
+
+## Response Format
+
+Start your response with:
+```
+**ULTRAWORK MODE ENABLED!**
+
+[Immediately begin planning/executing - no preamble]
+```
+
+Then execute with maximum intensity until COMPLETE.
+
+## Arguments
+
+`/ulw [task description]`
+
+- Provide the task you want completed
+- Or use after `/omc-plan` to execute an existing plan with ultrawork intensity
+
+## Examples
+
+```
+/ulw implement the authentication system from the plan
+/ulw fix all type errors in the codebase
+/ulw add comprehensive test coverage for the API
+```
+
+**NOW EXECUTE. NO HALF MEASURES. WORK UNTIL DONE.**

package/src/hooks/comment-checker.ts

@@ -31,7 +31,7 @@ interface ToolInput {
 }
 
 interface HookResponse {
-  decision: "approve" | "block" | "skip";
+  decision: "approve" | "block";
   reason?: string;
 }
 
@@ -125,7 +125,7 @@ async function main() {
 
   // Only check Edit and Write tools
   if (toolInput.tool !== "Edit" && toolInput.tool !== "Write") {
-    const response: HookResponse = { decision: "skip" };
+    const response: HookResponse = { decision: "approve" };
     console.log(JSON.stringify(response));
     return;
   }

package/src/hooks/task-notification.ts

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+/**
+ * Task Notification Hook (PostToolUse)
+ *
+ * Monitors for MCP background task completions and provides
+ * notifications in the Claude Code output.
+ *
+ * Usage in settings.json:
+ * {
+ *   "hooks": {
+ *     "PostToolUse": [{
+ *       "matcher": "mcp__oh-my-claude-background__.*",
+ *       "hooks": [{
+ *         "type": "command",
+ *         "command": "node ~/.claude/oh-my-claude/hooks/task-notification.js"
+ *       }]
+ *     }]
+ *   }
+ * }
+ */
+
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+
+interface PostToolUseInput {
+  tool: string;
+  tool_input?: Record<string, unknown>;
+  tool_output?: string;
+}
+
+interface HookResponse {
+  decision: "approve";
+  hookSpecificOutput?: {
+    hookEventName: "PostToolUse";
+    additionalContext?: string;
+  };
+}
+
+// File to track notified task IDs (prevent duplicate notifications)
+const NOTIFIED_FILE_PATH = join(homedir(), ".claude", "oh-my-claude", "notified-tasks.json");
+
+/**
+ * Load list of already-notified task IDs
+ */
+function loadNotifiedTasks(): Set<string> {
+  try {
+    if (!existsSync(NOTIFIED_FILE_PATH)) {
+      return new Set();
+    }
+    const content = readFileSync(NOTIFIED_FILE_PATH, "utf-8");
+    const data = JSON.parse(content);
+    // Clean up old entries (older than 1 hour)
+    const oneHourAgo = Date.now() - 60 * 60 * 1000;
+    const filtered = Object.entries(data)
+      .filter(([_, timestamp]) => (timestamp as number) > oneHourAgo)
+      .map(([id]) => id);
+    return new Set(filtered);
+  } catch {
+    return new Set();
+  }
+}
+
+/**
+ * Save notified task ID
+ */
+function saveNotifiedTask(taskId: string): void {
+  try {
+    const dir = dirname(NOTIFIED_FILE_PATH);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+
+    let data: Record<string, number> = {};
+    if (existsSync(NOTIFIED_FILE_PATH)) {
+      try {
+        data = JSON.parse(readFileSync(NOTIFIED_FILE_PATH, "utf-8"));
+      } catch {
+        data = {};
+      }
+    }
+
+    // Clean up old entries
+    const oneHourAgo = Date.now() - 60 * 60 * 1000;
+    for (const [id, timestamp] of Object.entries(data)) {
+      if (timestamp < oneHourAgo) {
+        delete data[id];
+      }
+    }
+
+    data[taskId] = Date.now();
+    writeFileSync(NOTIFIED_FILE_PATH, JSON.stringify(data));
+  } catch {
+    // Silently fail
+  }
+}
+
+/**
+ * Format duration for display
+ */
+function formatDuration(ms: number): string {
+  const seconds = Math.floor(ms / 1000);
+  if (seconds < 60) {
+    return `${seconds}s`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  return `${minutes}m ${remainingSeconds}s`;
+}
+
+async function main() {
+  // Read input from stdin
+  let inputData = "";
+  try {
+    inputData = readFileSync(0, "utf-8");
+  } catch {
+    console.log(JSON.stringify({ decision: "approve" }));
+    return;
+  }
+
+  if (!inputData.trim()) {
+    console.log(JSON.stringify({ decision: "approve" }));
+    return;
+  }
+
+  let toolInput: PostToolUseInput;
+  try {
+    toolInput = JSON.parse(inputData);
+  } catch {
+    console.log(JSON.stringify({ decision: "approve" }));
+    return;
+  }
+
+  // Only process MCP tool outputs
+  if (!toolInput.tool?.includes("oh-my-claude-background")) {
+    console.log(JSON.stringify({ decision: "approve" }));
+    return;
+  }
+
+  // Check for poll_task or list_tasks responses that contain completed tasks
+  const toolOutput = toolInput.tool_output;
+  if (!toolOutput) {
+    console.log(JSON.stringify({ decision: "approve" }));
+    return;
+  }
+
+  try {
+    const output = JSON.parse(toolOutput);
+    const notifiedTasks = loadNotifiedTasks();
+    const notifications: string[] = [];
+
+    // Check for single task completion (poll_task)
+    if (output.status === "completed" && toolInput.tool?.includes("poll_task")) {
+      // This is handled by the poll itself, no need for additional notification
+      console.log(JSON.stringify({ decision: "approve" }));
+      return;
+    }
+
+    // Check for task list with completed tasks
+    if (output.tasks && Array.isArray(output.tasks)) {
+      for (const task of output.tasks) {
+        if (
+          (task.status === "completed" || task.status === "failed") &&
+          task.id &&
+          !notifiedTasks.has(task.id)
+        ) {
+          // Calculate duration if we have timestamps
+          let durationStr = "";
+          if (task.created && task.completed) {
+            const created = new Date(task.created).getTime();
+            const completed = new Date(task.completed).getTime();
+            durationStr = ` (${formatDuration(completed - created)})`;
+          }
+
+          const statusIcon = task.status === "completed" ? "+" : "!";
+          const agentName = task.agent || "unknown";
+          notifications.push(
+            `[${statusIcon}] ${agentName}: ${task.status}${durationStr}`
+          );
+
+          saveNotifiedTask(task.id);
+        }
+      }
+    }
+
+    if (notifications.length > 0) {
+      const response: HookResponse = {
+        decision: "approve",
+        hookSpecificOutput: {
+          hookEventName: "PostToolUse",
+          additionalContext: `\n[omc] ${notifications.join(" | ")}`,
+        },
+      };
+      console.log(JSON.stringify(response));
+      return;
+    }
+  } catch {
+    // Parsing failed, just approve
+  }
+
+  console.log(JSON.stringify({ decision: "approve" }));
+}
+
+main().catch(() => {
+  console.log(JSON.stringify({ decision: "approve" }));
+});