@lgcyaxi/oh-my-claude 1.0.0 → 1.1.1

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/config/loader.ts

@@ -103,3 +103,76 @@ export function getProviderDetails(
   }
   return null;
 }
+
+/**
+ * Check if a provider is configured (has API key set)
+ */
+export function isProviderConfigured(
+  config: OhMyClaudeConfig,
+  providerName: string
+): boolean {
+  const providerConfig = config.providers[providerName];
+  if (!providerConfig) {
+    return false;
+  }
+
+  // Claude subscription is always "configured"
+  if (providerConfig.type === "claude-subscription") {
+    return true;
+  }
+
+  // Check if API key environment variable is set
+  if (providerConfig.api_key_env) {
+    const apiKey = process.env[providerConfig.api_key_env];
+    return !!apiKey && apiKey.length > 0;
+  }
+
+  return false;
+}
+
+/**
+ * Get fallback configuration for an agent
+ */
+export function getAgentFallback(
+  config: OhMyClaudeConfig,
+  agentName: string
+): { provider: string; model: string; executionMode?: string } | null {
+  const agentConfig = config.agents[agentName];
+  if (agentConfig?.fallback) {
+    return {
+      provider: agentConfig.fallback.provider,
+      model: agentConfig.fallback.model,
+      executionMode: agentConfig.fallback.executionMode,
+    };
+  }
+  return null;
+}
+
+/**
+ * Check if an agent should use fallback (primary provider not configured)
+ */
+export function shouldUseFallback(
+  config: OhMyClaudeConfig,
+  agentName: string
+): { useFallback: boolean; reason?: string; fallback?: { provider: string; model: string; executionMode?: string } } {
+  const agentConfig = config.agents[agentName];
+  if (!agentConfig) {
+    return { useFallback: false };
+  }
+
+  // Check if primary provider is configured
+  if (!isProviderConfigured(config, agentConfig.provider)) {
+    const fallback = getAgentFallback(config, agentName);
+    if (fallback) {
+      const providerConfig = config.providers[agentConfig.provider];
+      const envVar = providerConfig?.api_key_env ?? `${agentConfig.provider.toUpperCase()}_API_KEY`;
+      return {
+        useFallback: true,
+        reason: `${envVar} is not set`,
+        fallback,
+      };
+    }
+  }
+
+  return { useFallback: false };
+}

package/src/config/schema.ts

@@ -15,6 +15,13 @@ export const ProviderConfigSchema = z.object({
   note: z.string().optional(),
 });
 
+// Agent fallback configuration schema
+export const AgentFallbackConfigSchema = z.object({
+  provider: z.string(),
+  model: z.string(),
+  executionMode: z.enum(["task", "mcp"]).optional(),
+});
+
 // Agent configuration schema
 export const AgentConfigSchema = z.object({
   provider: z.string(),
@@ -27,6 +34,7 @@ export const AgentConfigSchema = z.object({
       budget_tokens: z.number().optional(),
     })
     .optional(),
+  fallback: AgentFallbackConfigSchema.optional(),
 });
 
 // Category configuration schema
@@ -77,6 +85,7 @@ export const OhMyClaudeConfigSchema = z.object({
   }),
 
   agents: z.record(z.string(), AgentConfigSchema).default({
+    // Claude subscription agents (no fallback needed)
     Sisyphus: { provider: "claude", model: "claude-opus-4-5" },
     "claude-reviewer": {
       provider: "claude",
@@ -88,22 +97,36 @@ export const OhMyClaudeConfigSchema = z.object({
       model: "claude-haiku-4-5",
       temperature: 0.3,
     },
+    // External API agents (with Claude fallbacks)
     oracle: {
       provider: "deepseek",
       model: "deepseek-reasoner",
       temperature: 0.1,
+      fallback: { provider: "claude", model: "claude-opus-4-5", executionMode: "task" },
+    },
+    librarian: {
+      provider: "zhipu",
+      model: "glm-4.7",
+      temperature: 0.3,
+      fallback: { provider: "claude", model: "claude-sonnet-4-5", executionMode: "task" },
+    },
+    explore: {
+      provider: "deepseek",
+      model: "deepseek-chat",
+      temperature: 0.1,
+      fallback: { provider: "claude", model: "claude-haiku-4-5", executionMode: "task" },
     },
-    librarian: { provider: "zhipu", model: "glm-4.7", temperature: 0.3 },
-    explore: { provider: "deepseek", model: "deepseek-chat", temperature: 0.1 },
     "frontend-ui-ux": {
       provider: "zhipu",
       model: "glm-4v-flash",
       temperature: 0.7,
+      fallback: { provider: "claude", model: "claude-sonnet-4-5", executionMode: "task" },
     },
     "document-writer": {
       provider: "minimax",
       model: "MiniMax-M2.1",
       temperature: 0.5,
+      fallback: { provider: "claude", model: "claude-sonnet-4-5", executionMode: "task" },
     },
   }),
 

package/src/generators/agent-generator.ts

@@ -35,7 +35,7 @@ export function generateAgentMarkdown(agent: AgentDefinition): string {
   lines.push(`> ${agent.description}`);
   lines.push("");
 
-  // Execution mode note
+  // Execution mode note with fallback info
   if (agent.executionMode === "task") {
     lines.push(
       `<!-- Execution: Claude Code Task tool (sync) - Uses Claude subscription -->`
@@ -44,12 +44,28 @@ export function generateAgentMarkdown(agent: AgentDefinition): string {
     lines.push(
       `<!-- Execution: oh-my-claude MCP server (async) - Uses ${agent.defaultProvider} API -->`
     );
+    // Add fallback info for MCP agents
+    if (agent.fallback) {
+      lines.push(
+        `<!-- Fallback: ${agent.fallback.provider}/${agent.fallback.model} via Task tool (when ${agent.defaultProvider.toUpperCase()}_API_KEY is not set) -->`
+      );
+    }
   }
   lines.push("");
 
   // The actual prompt
   lines.push(agent.prompt);
 
+  // Add fallback usage note for MCP agents
+  if (agent.executionMode === "mcp" && agent.fallback) {
+    lines.push("");
+    lines.push("## Fallback Mode");
+    lines.push("");
+    lines.push(`If \`${agent.defaultProvider.toUpperCase()}_API_KEY\` is not configured, this agent will automatically fall back to using **${agent.fallback.model}** via Claude's Task tool.`);
+    lines.push("");
+    lines.push("The fallback provides similar capabilities using your Claude subscription, though the primary provider may offer specialized features.");
+  }
+
   return lines.join("\n");
 }
 

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" }));
+});