@lgcyaxi/oh-my-claude 1.0.1 → 1.1.2

package/src/hooks/task-tracker.ts

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+/**
+ * Task Tracker Hook (PreToolUse & PostToolUse)
+ *
+ * Tracks Claude Code's Task tool invocations to monitor
+ * Claude-subscription agents (Sisyphus, Claude-Reviewer, Claude-Scout).
+ *
+ * Since Task tool runs as subprocesses, we track:
+ * - PreToolUse: When a Task is about to launch
+ * - PostToolUse: When a Task completes
+ *
+ * Updates the shared status file for statusline display.
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+
+interface ToolUseInput {
+  tool: string;
+  tool_input?: {
+    subagent_type?: string;
+    description?: string;
+    prompt?: string;
+  };
+  tool_output?: string;
+}
+
+interface HookResponse {
+  decision: "approve";
+  hookSpecificOutput?: {
+    hookEventName: "PreToolUse" | "PostToolUse";
+    additionalContext?: string;
+  };
+}
+
+// Status file path (shared with MCP server)
+const STATUS_FILE_PATH = join(homedir(), ".claude", "oh-my-claude", "status.json");
+
+// Task agents file (tracks active Task tool agents)
+const TASK_AGENTS_FILE = join(homedir(), ".claude", "oh-my-claude", "task-agents.json");
+
+interface TaskAgent {
+  id: string;
+  type: string;
+  description: string;
+  startedAt: number;
+}
+
+interface TaskAgentsData {
+  agents: TaskAgent[];
+}
+
+/**
+ * Load current task agents
+ */
+function loadTaskAgents(): TaskAgentsData {
+  try {
+    if (!existsSync(TASK_AGENTS_FILE)) {
+      return { agents: [] };
+    }
+    const content = readFileSync(TASK_AGENTS_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { agents: [] };
+  }
+}
+
+/**
+ * Save task agents
+ */
+function saveTaskAgents(data: TaskAgentsData): void {
+  try {
+    const dir = dirname(TASK_AGENTS_FILE);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(TASK_AGENTS_FILE, JSON.stringify(data, null, 2));
+  } catch {
+    // Silently fail
+  }
+}
+
+/**
+ * Update the shared status file to include Task agents
+ */
+function updateStatusFile(): void {
+  try {
+    // Read current status
+    let status: any = {
+      activeTasks: [],
+      providers: {},
+      updatedAt: new Date().toISOString(),
+    };
+
+    if (existsSync(STATUS_FILE_PATH)) {
+      try {
+        status = JSON.parse(readFileSync(STATUS_FILE_PATH, "utf-8"));
+      } catch {
+        // Use default
+      }
+    }
+
+    // Load task agents and merge with status
+    const taskAgents = loadTaskAgents();
+
+    // Add Task agents to activeTasks (mark with special prefix)
+    const taskAgentTasks = taskAgents.agents.map((agent) => ({
+      agent: `@${agent.type}`, // @ prefix indicates Claude-subscription agent
+      startedAt: agent.startedAt,
+      isTaskTool: true,
+    }));
+
+    // Filter out stale Task agents (older than 30 minutes)
+    const thirtyMinutesAgo = Date.now() - 30 * 60 * 1000;
+    const activeTaskAgents = taskAgentTasks.filter(
+      (t) => t.startedAt > thirtyMinutesAgo
+    );
+
+    // Merge: MCP tasks first, then Task tool agents
+    const mcpTasks = (status.activeTasks || []).filter((t: any) => !t.isTaskTool);
+    status.activeTasks = [...mcpTasks, ...activeTaskAgents];
+    status.updatedAt = new Date().toISOString();
+
+    // Write back
+    const dir = dirname(STATUS_FILE_PATH);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(STATUS_FILE_PATH, JSON.stringify(status, null, 2));
+  } catch {
+    // Silently fail
+  }
+}
+
+/**
+ * Generate a simple ID for tracking
+ */
+function generateId(): string {
+  return `task_${Date.now()}_${Math.random().toString(36).substring(2, 6)}`;
+}
+
+/**
+ * Map subagent_type to display name
+ */
+function getAgentDisplayName(subagentType: string): string {
+  const mapping: Record<string, string> = {
+    Bash: "Bash",
+    Explore: "Scout",
+    Plan: "Planner",
+    "general-purpose": "General",
+    "claude-code-guide": "Guide",
+  };
+  return mapping[subagentType] || subagentType;
+}
+
+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: ToolUseInput;
+  try {
+    toolInput = JSON.parse(inputData);
+  } catch {
+    console.log(JSON.stringify({ decision: "approve" }));
+    return;
+  }
+
+  // Only process Task tool
+  if (toolInput.tool !== "Task") {
+    console.log(JSON.stringify({ decision: "approve" }));
+    return;
+  }
+
+  const subagentType = toolInput.tool_input?.subagent_type || "unknown";
+  const description = toolInput.tool_input?.description || "";
+
+  // Check if this is PreToolUse (no tool_output) or PostToolUse (has tool_output)
+  const isPreToolUse = !toolInput.tool_output;
+
+  if (isPreToolUse) {
+    // Task is about to launch - add to tracking
+    const taskAgents = loadTaskAgents();
+
+    const newAgent: TaskAgent = {
+      id: generateId(),
+      type: getAgentDisplayName(subagentType),
+      description: description,
+      startedAt: Date.now(),
+    };
+
+    taskAgents.agents.push(newAgent);
+    saveTaskAgents(taskAgents);
+    updateStatusFile();
+
+    // Provide context about the launch
+    const response: HookResponse = {
+      decision: "approve",
+    };
+    console.log(JSON.stringify(response));
+  } else {
+    // Task completed - remove from tracking
+    const taskAgents = loadTaskAgents();
+
+    // Remove the most recent agent of this type (LIFO)
+    const displayName = getAgentDisplayName(subagentType);
+    const index = taskAgents.agents.findIndex((a) => a.type === displayName);
+
+    if (index !== -1) {
+      const removedArr = taskAgents.agents.splice(index, 1);
+      const removed = removedArr[0];
+      if (!removed) {
+        console.log(JSON.stringify({ decision: "approve" }));
+        return;
+      }
+      const duration = Math.floor((Date.now() - removed.startedAt) / 1000);
+
+      saveTaskAgents(taskAgents);
+      updateStatusFile();
+
+      // Provide completion notification
+      const durationStr =
+        duration < 60 ? `${duration}s` : `${Math.floor(duration / 60)}m`;
+      const response: HookResponse = {
+        decision: "approve",
+        hookSpecificOutput: {
+          hookEventName: "PostToolUse",
+          additionalContext: `\n[@] ${displayName}: completed (${durationStr})`,
+        },
+      };
+      console.log(JSON.stringify(response));
+      return;
+    }
+
+    console.log(JSON.stringify({ decision: "approve" }));
+  }
+}
+
+main().catch(() => {
+  console.log(JSON.stringify({ decision: "approve" }));
+});

package/src/installer/index.ts

@@ -14,7 +14,7 @@ import { join, dirname } from "node:path";
 import { homedir } from "node:os";
 
 import { generateAllAgentFiles, removeAgentFiles } from "../generators/agent-generator";
-import { installHooks, installMcpServer, uninstallFromSettings } from "./settings-merger";
+import { installHooks, installMcpServer, installStatusLine, uninstallFromSettings, uninstallStatusLine } from "./settings-merger";
 import { DEFAULT_CONFIG } from "../config/schema";
 
 /**
@@ -52,12 +52,20 @@ export function getConfigPath(): string {
   return join(homedir(), ".claude", "oh-my-claude.json");
 }
 
+/**
+ * Get statusline script path
+ */
+export function getStatusLineScriptPath(): string {
+  return join(getInstallDir(), "dist", "statusline", "statusline.js");
+}
+
 export interface InstallResult {
   success: boolean;
   agents: { generated: string[]; skipped: string[] };
   commands: { installed: string[]; skipped: string[] };
   hooks: { installed: string[]; skipped: string[] };
   mcp: { installed: boolean };
+  statusLine: { installed: boolean; wrapperCreated: boolean };
   config: { created: boolean };
   errors: string[];
 }
@@ -74,6 +82,8 @@ export async function install(options?: {
   skipHooks?: boolean;
   /** Skip MCP server installation */
   skipMcp?: boolean;
+  /** Skip statusline installation */
+  skipStatusLine?: boolean;
   /** Force overwrite existing files */
   force?: boolean;
   /** Source directory (for built files) */
@@ -85,6 +95,7 @@ export async function install(options?: {
     commands: { installed: [], skipped: [] },
     hooks: { installed: [], skipped: [] },
     mcp: { installed: false },
+    statusLine: { installed: false, wrapperCreated: false },
     config: { created: false },
     errors: [],
   };
@@ -213,7 +224,30 @@ process.exit(1);
       }
     }
 
-    // 4. Create default config if not exists
+    // 4. Install statusline
+    if (!options?.skipStatusLine) {
+      try {
+        const statusLineDir = join(installDir, "dist", "statusline");
+        if (!existsSync(statusLineDir)) {
+          mkdirSync(statusLineDir, { recursive: true });
+        }
+
+        // Copy statusline script (assuming it's built to dist/statusline/)
+        const builtStatusLineDir = join(sourceDir, "dist", "statusline");
+        if (existsSync(builtStatusLineDir)) {
+          cpSync(builtStatusLineDir, statusLineDir, { recursive: true });
+        }
+
+        // Install statusline into settings.json
+        const statusLineResult = installStatusLine(getStatusLineScriptPath());
+        result.statusLine.installed = statusLineResult.installed;
+        result.statusLine.wrapperCreated = statusLineResult.wrapperCreated;
+      } catch (error) {
+        result.errors.push(`Failed to install statusline: ${error}`);
+      }
+    }
+
+    // 5. Create default config if not exists
     const configPath = getConfigPath();
     if (!existsSync(configPath) || options?.force) {
       try {
@@ -243,6 +277,7 @@ export interface UninstallResult {
   commands: string[];
   hooks: string[];
   mcp: boolean;
+  statusLine: boolean;
   errors: string[];
 }
 
@@ -259,6 +294,7 @@ export async function uninstall(options?: {
     commands: [],
     hooks: [],
     mcp: false,
+    statusLine: false,
     errors: [],
   };
 
@@ -284,11 +320,13 @@ export async function uninstall(options?: {
           "omc-explore",
           "omc-plan",
           "omc-start-work",
+          "omc-status",
           // Quick action commands (omcx-)
           "omcx-commit",
           "omcx-implement",
           "omcx-refactor",
           "omcx-docs",
+          "omcx-issue",
         ];
         const { unlinkSync } = require("node:fs");
         for (const cmd of ourCommands) {
@@ -312,7 +350,14 @@ export async function uninstall(options?: {
       result.errors.push(`Failed to update settings: ${error}`);
     }
 
-    // 3. Remove installation directory
+    // 4. Remove statusline
+    try {
+      result.statusLine = uninstallStatusLine();
+    } catch (error) {
+      result.errors.push(`Failed to remove statusline: ${error}`);
+    }
+
+    // 5. Remove installation directory
     const installDir = getInstallDir();
     if (existsSync(installDir)) {
       try {
@@ -323,7 +368,7 @@ export async function uninstall(options?: {
       }
     }
 
-    // 4. Remove config (unless keepConfig)
+    // 6. Remove config (unless keepConfig)
     if (!options?.keepConfig) {
       const configPath = getConfigPath();
       if (existsSync(configPath)) {
@@ -354,14 +399,19 @@ export function checkInstallation(): {
     agents: boolean;
     hooks: boolean;
     mcp: boolean;
+    statusLine: boolean;
     config: boolean;
   };
 } {
   const installDir = getInstallDir();
   const hooksDir = getHooksDir();
   const mcpServerPath = getMcpServerPath();
+  const statusLineScriptPath = getStatusLineScriptPath();
   const configPath = getConfigPath();
 
+  // Check if statusline is configured in settings
+  const { isStatusLineConfigured } = require("./statusline-merger");
+
   return {
     installed:
       existsSync(installDir) &&
@@ -371,6 +421,7 @@ export function checkInstallation(): {
       agents: existsSync(join(homedir(), ".claude", "agents", "sisyphus.md")),
       hooks: existsSync(join(hooksDir, "comment-checker.js")),
       mcp: existsSync(mcpServerPath),
+      statusLine: existsSync(statusLineScriptPath) && isStatusLineConfigured(),
       config: existsSync(configPath),
     },
   };

package/src/installer/settings-merger.ts

@@ -32,6 +32,11 @@ interface ClaudeSettings {
       env?: Record<string, string>;
     }
   >;
+  statusLine?: {
+    type: "command";
+    command: string;
+    padding?: number;
+  };
   [key: string]: unknown;
 }
 
@@ -199,6 +204,34 @@ export function installHooks(hooksDir: string): { installed: string[]; skipped:
     skipped.push("todo-continuation (already installed)");
   }
 
+  // Task tracker hook (PreToolUse for Task tool)
+  if (
+    addHook(
+      settings,
+      "PreToolUse",
+      "Task",
+      `node ${hooksDir}/task-tracker.js`
+    )
+  ) {
+    installed.push("task-tracker (PreToolUse:Task)");
+  } else {
+    skipped.push("task-tracker (already installed)");
+  }
+
+  // Task tracker hook (PostToolUse for Task tool completion)
+  if (
+    addHook(
+      settings,
+      "PostToolUse",
+      "Task",
+      `node ${hooksDir}/task-tracker.js`
+    )
+  ) {
+    installed.push("task-tracker (PostToolUse:Task)");
+  } else {
+    skipped.push("task-tracker (already installed)");
+  }
+
   saveSettings(settings);
   return { installed, skipped };
 }
@@ -213,7 +246,7 @@ export function installMcpServer(serverPath: string): boolean {
     // Check if already installed
     let alreadyInstalled = false;
     try {
-      const list = execSync("claude mcp list 2>/dev/null", { encoding: "utf-8" });
+      const list = execSync("claude mcp list", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
       alreadyInstalled = list.includes("oh-my-claude-background");
     } catch {
       // Ignore if list fails
@@ -280,7 +313,7 @@ export function uninstallFromSettings(): {
   // Remove MCP server via CLI
   let removedMcp = false;
   try {
-    execSync("claude mcp remove --scope user oh-my-claude-background 2>/dev/null");
+    execSync("claude mcp remove --scope user oh-my-claude-background", { stdio: ["pipe", "pipe", "pipe"] });
     removedMcp = true;
   } catch {
     // Try removing from settings.json as fallback
@@ -293,3 +326,56 @@ export function uninstallFromSettings(): {
 
   return { removedHooks, removedMcp };
 }
+
+/**
+ * Install oh-my-claude statusLine
+ * If user has existing statusLine, creates a wrapper that calls both
+ */
+export function installStatusLine(statusLineScriptPath: string): {
+  installed: boolean;
+  wrapperCreated: boolean;
+  existingBackedUp: boolean;
+} {
+  const { mergeStatusLine } = require("./statusline-merger");
+
+  const settings = loadSettings();
+  const existing = settings.statusLine;
+
+  const result = mergeStatusLine(existing);
+
+  if (result.config.command !== existing?.command) {
+    settings.statusLine = result.config;
+    saveSettings(settings);
+  }
+
+  return {
+    installed: true,
+    wrapperCreated: result.wrapperCreated,
+    existingBackedUp: result.backupCreated,
+  };
+}
+
+/**
+ * Remove oh-my-claude statusLine and restore original if backed up
+ */
+export function uninstallStatusLine(): boolean {
+  const { restoreStatusLine, isStatusLineConfigured } = require("./statusline-merger");
+
+  if (!isStatusLineConfigured()) {
+    return false;
+  }
+
+  const settings = loadSettings();
+
+  // Try to restore original statusLine
+  const backup = restoreStatusLine();
+  if (backup) {
+    settings.statusLine = backup;
+  } else {
+    // No backup - just remove our statusLine
+    delete settings.statusLine;
+  }
+
+  saveSettings(settings);
+  return true;
+}

package/src/installer/statusline-merger.ts

@@ -0,0 +1,169 @@
+/**
+ * StatusLine Merger
+ *
+ * Handles merging oh-my-claude's statusLine with existing user statusLine configuration.
+ * If user already has a statusLine (like CCometixLine), we create a wrapper that calls both.
+ */
+
+import { writeFileSync, chmodSync, existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+export interface StatusLineConfig {
+  type: "command";
+  command: string;
+  padding?: number;
+}
+
+// Our statusline command
+const OMC_STATUSLINE_COMMAND = "node ~/.claude/oh-my-claude/dist/statusline/statusline.js";
+
+// Wrapper script path
+const WRAPPER_SCRIPT_PATH = join(homedir(), ".claude", "oh-my-claude", "statusline-wrapper.sh");
+
+// Backup file for original statusline config
+const BACKUP_FILE_PATH = join(homedir(), ".claude", "oh-my-claude", "statusline-backup.json");
+
+/**
+ * Check if a statusline command is our own
+ */
+function isOurStatusLine(command: string): boolean {
+  return command.includes("oh-my-claude") && command.includes("statusline");
+}
+
+/**
+ * Generate a wrapper script that calls both statuslines
+ * Puts omc status on second line for better visibility
+ */
+function generateWrapperScript(existingCommand: string): string {
+  return `#!/bin/bash
+# oh-my-claude StatusLine Wrapper
+# Calls both the original statusLine and oh-my-claude's statusline
+# Auto-generated - do not edit manually
+
+input=$(cat)
+
+# Call existing statusline
+existing_output=$(echo "$input" | ${existingCommand} 2>/dev/null || echo "")
+
+# Call oh-my-claude statusline
+omc_output=$(echo "$input" | ${OMC_STATUSLINE_COMMAND} 2>/dev/null || echo "omc")
+
+# Combine outputs - put omc on second line for better visibility
+if [ -n "$existing_output" ] && [ -n "$omc_output" ]; then
+  printf "%s\\n%s\\n" "$existing_output" "$omc_output"
+elif [ -n "$existing_output" ]; then
+  printf "%s\\n" "$existing_output"
+elif [ -n "$omc_output" ]; then
+  printf "%s\\n" "$omc_output"
+else
+  echo ""
+fi
+`;
+}
+
+/**
+ * Merge statusLine configuration
+ *
+ * Returns the new config and whether a wrapper was created
+ */
+export function mergeStatusLine(
+  existing: StatusLineConfig | undefined
+): {
+  config: StatusLineConfig;
+  wrapperCreated: boolean;
+  backupCreated: boolean;
+} {
+  // If no existing statusline, just use ours
+  if (!existing) {
+    return {
+      config: {
+        type: "command",
+        command: OMC_STATUSLINE_COMMAND,
+      },
+      wrapperCreated: false,
+      backupCreated: false,
+    };
+  }
+
+  // If existing is already ours or wrapper, don't change anything
+  if (isOurStatusLine(existing.command)) {
+    return {
+      config: existing,
+      wrapperCreated: false,
+      backupCreated: false,
+    };
+  }
+
+  // Check if existing is already our wrapper
+  if (existing.command.includes("statusline-wrapper.sh")) {
+    return {
+      config: existing,
+      wrapperCreated: false,
+      backupCreated: false,
+    };
+  }
+
+  // Create wrapper script
+  const wrapperContent = generateWrapperScript(existing.command);
+  writeFileSync(WRAPPER_SCRIPT_PATH, wrapperContent);
+  chmodSync(WRAPPER_SCRIPT_PATH, 0o755);
+
+  // Backup existing config
+  writeFileSync(BACKUP_FILE_PATH, JSON.stringify(existing, null, 2));
+
+  return {
+    config: {
+      type: "command",
+      command: WRAPPER_SCRIPT_PATH,
+      padding: existing.padding,
+    },
+    wrapperCreated: true,
+    backupCreated: true,
+  };
+}
+
+/**
+ * Restore original statusLine configuration (for uninstall)
+ */
+export function restoreStatusLine(): StatusLineConfig | null {
+  if (!existsSync(BACKUP_FILE_PATH)) {
+    return null;
+  }
+
+  try {
+    const backup = JSON.parse(readFileSync(BACKUP_FILE_PATH, "utf-8"));
+    return backup as StatusLineConfig;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if statusline is configured
+ */
+export function isStatusLineConfigured(): boolean {
+  const settingsPath = join(homedir(), ".claude", "settings.json");
+  if (!existsSync(settingsPath)) {
+    return false;
+  }
+
+  try {
+    const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    if (!settings.statusLine) {
+      return false;
+    }
+
+    const command = settings.statusLine.command || "";
+    return isOurStatusLine(command) || command.includes("statusline-wrapper.sh");
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get the path to our statusline script
+ */
+export function getOmcStatusLineCommand(): string {
+  return OMC_STATUSLINE_COMMAND;
+}