@lgcyaxi/oh-my-claude 1.0.1 → 1.1.2

package/dist/hooks/task-notification.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+
+// src/hooks/task-notification.ts
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+var NOTIFIED_FILE_PATH = join(homedir(), ".claude", "oh-my-claude", "notified-tasks.json");
+function loadNotifiedTasks() {
+  try {
+    if (!existsSync(NOTIFIED_FILE_PATH)) {
+      return new Set;
+    }
+    const content = readFileSync(NOTIFIED_FILE_PATH, "utf-8");
+    const data = JSON.parse(content);
+    const oneHourAgo = Date.now() - 60 * 60 * 1000;
+    const filtered = Object.entries(data).filter(([_, timestamp]) => timestamp > oneHourAgo).map(([id]) => id);
+    return new Set(filtered);
+  } catch {
+    return new Set;
+  }
+}
+function saveNotifiedTask(taskId) {
+  try {
+    const dir = dirname(NOTIFIED_FILE_PATH);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    let data = {};
+    if (existsSync(NOTIFIED_FILE_PATH)) {
+      try {
+        data = JSON.parse(readFileSync(NOTIFIED_FILE_PATH, "utf-8"));
+      } catch {
+        data = {};
+      }
+    }
+    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 {}
+}
+function formatDuration(ms) {
+  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() {
+  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;
+  try {
+    toolInput = JSON.parse(inputData);
+  } catch {
+    console.log(JSON.stringify({ decision: "approve" }));
+    return;
+  }
+  if (!toolInput.tool?.includes("oh-my-claude-background")) {
+    console.log(JSON.stringify({ decision: "approve" }));
+    return;
+  }
+  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 = [];
+    if (output.status === "completed" && toolInput.tool?.includes("poll_task")) {
+      console.log(JSON.stringify({ decision: "approve" }));
+      return;
+    }
+    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)) {
+          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 = {
+        decision: "approve",
+        hookSpecificOutput: {
+          hookEventName: "PostToolUse",
+          additionalContext: `
+[omc] ${notifications.join(" | ")}`
+        }
+      };
+      console.log(JSON.stringify(response));
+      return;
+    }
+  } catch {}
+  console.log(JSON.stringify({ decision: "approve" }));
+}
+main().catch(() => {
+  console.log(JSON.stringify({ decision: "approve" }));
+});

package/dist/hooks/task-tracker.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+
+// src/hooks/task-tracker.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+var STATUS_FILE_PATH = join(homedir(), ".claude", "oh-my-claude", "status.json");
+var TASK_AGENTS_FILE = join(homedir(), ".claude", "oh-my-claude", "task-agents.json");
+function loadTaskAgents() {
+  try {
+    if (!existsSync(TASK_AGENTS_FILE)) {
+      return { agents: [] };
+    }
+    const content = readFileSync(TASK_AGENTS_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { agents: [] };
+  }
+}
+function saveTaskAgents(data) {
+  try {
+    const dir = dirname(TASK_AGENTS_FILE);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(TASK_AGENTS_FILE, JSON.stringify(data, null, 2));
+  } catch {}
+}
+function updateStatusFile() {
+  try {
+    let status = {
+      activeTasks: [],
+      providers: {},
+      updatedAt: new Date().toISOString()
+    };
+    if (existsSync(STATUS_FILE_PATH)) {
+      try {
+        status = JSON.parse(readFileSync(STATUS_FILE_PATH, "utf-8"));
+      } catch {}
+    }
+    const taskAgents = loadTaskAgents();
+    const taskAgentTasks = taskAgents.agents.map((agent) => ({
+      agent: `@${agent.type}`,
+      startedAt: agent.startedAt,
+      isTaskTool: true
+    }));
+    const thirtyMinutesAgo = Date.now() - 30 * 60 * 1000;
+    const activeTaskAgents = taskAgentTasks.filter((t) => t.startedAt > thirtyMinutesAgo);
+    const mcpTasks = (status.activeTasks || []).filter((t) => !t.isTaskTool);
+    status.activeTasks = [...mcpTasks, ...activeTaskAgents];
+    status.updatedAt = new Date().toISOString();
+    const dir = dirname(STATUS_FILE_PATH);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(STATUS_FILE_PATH, JSON.stringify(status, null, 2));
+  } catch {}
+}
+function generateId() {
+  return `task_${Date.now()}_${Math.random().toString(36).substring(2, 6)}`;
+}
+function getAgentDisplayName(subagentType) {
+  const mapping = {
+    Bash: "Bash",
+    Explore: "Scout",
+    Plan: "Planner",
+    "general-purpose": "General",
+    "claude-code-guide": "Guide"
+  };
+  return mapping[subagentType] || subagentType;
+}
+async function main() {
+  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;
+  try {
+    toolInput = JSON.parse(inputData);
+  } catch {
+    console.log(JSON.stringify({ decision: "approve" }));
+    return;
+  }
+  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 || "";
+  const isPreToolUse = !toolInput.tool_output;
+  if (isPreToolUse) {
+    const taskAgents = loadTaskAgents();
+    const newAgent = {
+      id: generateId(),
+      type: getAgentDisplayName(subagentType),
+      description,
+      startedAt: Date.now()
+    };
+    taskAgents.agents.push(newAgent);
+    saveTaskAgents(taskAgents);
+    updateStatusFile();
+    const response = {
+      decision: "approve"
+    };
+    console.log(JSON.stringify(response));
+  } else {
+    const taskAgents = loadTaskAgents();
+    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();
+      const durationStr = duration < 60 ? `${duration}s` : `${Math.floor(duration / 60)}m`;
+      const response = {
+        decision: "approve",
+        hookSpecificOutput: {
+          hookEventName: "PostToolUse",
+          additionalContext: `
+[@] ${displayName}: completed (${durationStr})`
+        }
+      };
+      console.log(JSON.stringify(response));
+      return;
+    }
+    console.log(JSON.stringify({ decision: "approve" }));
+  }
+}
+main().catch(() => {
+  console.log(JSON.stringify({ decision: "approve" }));
+});