@gonzih/cc-tg 0.6.2 → 0.6.4

package/dist/cc-agent-events.d.ts

@@ -4,7 +4,7 @@
  * Listens to the `cca:events` pub/sub channel for job completion events,
  * asks Claude to decide what to do, and acts accordingly:
  *   NOTIFY_ONLY    — send a Telegram message to the configured chat
- *   SPAWN_FOLLOWUP — spawn a follow-up cc-agent job via MCP
+ *   SPAWN_FOLLOWUP — spawn a follow-up cc-agent job via MCP + notify Telegram
  *   SILENT         — log and do nothing
  *
  * Controlled via CC_AGENT_EVENTS_ENABLED env var (default: true).
@@ -19,6 +19,13 @@ export interface JobEvent {
     score?: number;
     timestamp: number;
 }
+export interface CoordinatorPlan {
+    nextStep?: {
+        repo_url: string;
+        task: string;
+    };
+    summary: string;
+}
 export interface DecisionResult {
     action: "NOTIFY_ONLY" | "SPAWN_FOLLOWUP" | "SILENT";
     message?: string;
@@ -32,8 +39,12 @@ export interface HandlerDeps {
     askClaude: (prompt: string) => Promise<string>;
     sendTelegramMessage: (chatId: number, text: string) => Promise<void>;
     spawnFollowupAgent: (repoUrl: string, task: string) => Promise<void>;
+    readJobOutput: (jobId: string) => Promise<string[]>;
+    readCoordinatorPlan: (jobId: string) => Promise<CoordinatorPlan | null>;
+    getRunningJobCount: () => Promise<number>;
+    getActiveChatIds: () => Promise<number[]>;
 }
-export declare function buildDecisionPrompt(event: JobEvent): string;
+export declare function buildDecisionPrompt(event: JobEvent, last40lines: string[], coordinatorPlan: CoordinatorPlan | null): string;
 export declare function parseDecision(raw: string): DecisionResult;
 /**
  * Ask Claude to make a decision about a completed job.
@@ -42,6 +53,27 @@ export declare function parseDecision(raw: string): DecisionResult;
 export declare function defaultAskClaude(prompt: string): Promise<string>;
 export declare function defaultSendTelegramMessage(chatId: number, text: string): Promise<void>;
 export declare function defaultSpawnFollowupAgent(repoUrl: string, task: string): Promise<void>;
+export declare function defaultReadJobOutput(jobId: string): Promise<string[]>;
+export declare function defaultReadCoordinatorPlan(jobId: string): Promise<CoordinatorPlan | null>;
+export declare function defaultGetRunningJobCount(): Promise<number>;
+/**
+ * Returns chat IDs to notify about job events.
+ * Reads unique chatIds from the cron jobs file (same users who set up cron jobs).
+ * Falls back to CC_AGENT_NOTIFY_CHAT_ID env var for backward compatibility.
+ */
+export declare function defaultGetActiveChatIds(): Promise<number[]>;
+/**
+ * Write a coordinator plan for a job, so cc-tg knows what follow-up to spawn.
+ * Call this when spawning a job that has a planned follow-up.
+ * TTL: 7 days.
+ */
+export declare function writeCoordinatorPlan(jobId: string, plan: {
+    nextStep?: {
+        repo_url: string;
+        task: string;
+    };
+    summary: string;
+}): Promise<void>;
 /**
  * Handle a single job event message from Redis pub/sub.
  * Exported for testability — production code passes defaultDeps.

package/dist/cc-agent-events.js

@@ -4,12 +4,14 @@
  * Listens to the `cca:events` pub/sub channel for job completion events,
  * asks Claude to decide what to do, and acts accordingly:
  *   NOTIFY_ONLY    — send a Telegram message to the configured chat
- *   SPAWN_FOLLOWUP — spawn a follow-up cc-agent job via MCP
+ *   SPAWN_FOLLOWUP — spawn a follow-up cc-agent job via MCP + notify Telegram
  *   SILENT         — log and do nothing
  *
  * Controlled via CC_AGENT_EVENTS_ENABLED env var (default: true).
  * Requires CC_AGENT_NOTIFY_CHAT_ID to send Telegram notifications.
  */
+import { readFileSync } from "fs";
+import { join } from "path";
 import { Redis } from "ioredis";
 import TelegramBot from "node-telegram-bot-api";
 import { ClaudeProcess, extractText } from "./claude.js";
@@ -21,42 +23,80 @@ function log(level, ...args) {
             : console.log;
     fn("[cc-agent-events]", ...args);
 }
-export function buildDecisionPrompt(event) {
+export function buildDecisionPrompt(event, last40lines, coordinatorPlan) {
+    const scoreStr = event.score !== undefined ? String(event.score) : "n/a";
+    const planStr = coordinatorPlan ? JSON.stringify(coordinatorPlan, null, 2) : "none";
     return `A cc-agent job just completed.
 
 Job: ${event.title}
 Repo: ${event.repoUrl}
 Status: ${event.status}
-Last output:
-${event.lastLines.join("\n")}
+Score: ${scoreStr}
 
-Decide what to do next. Options:
-1. NOTIFY_ONLY — send a brief Telegram message to Maksim summarizing what completed
-2. SPAWN_FOLLOWUP — spawn a follow-up cc-agent job (provide repo_url and task)
-3. SILENT — log it, no action needed (routine/expected completion)
+Last output + LEARNINGS:
+${last40lines.join("\n")}
 
-Reply in this exact JSON format:
+Coordinator plan for this job (if any):
+${planStr}
+
+Decide what to do next:
+1. SPAWN_FOLLOWUP — spawn a follow-up job (provide repo_url and task)
+2. NOTIFY_ONLY — send Telegram message, no spawn needed
+3. SILENT — routine completion, no action
+
+Rules:
+- If LEARNINGS has "Recommendations for next agent" with a clear actionable next step → consider SPAWN_FOLLOWUP
+- If coordinator plan has nextStep → SPAWN_FOLLOWUP with that task (prefer coordinator plan over LEARNINGS)
+- Failed jobs → NOTIFY_ONLY always
+- Score < 0.5 → NOTIFY_ONLY
+- Routine/expected completions → SILENT
+
+Reply in JSON:
 {
-  "action": "NOTIFY_ONLY" | "SPAWN_FOLLOWUP" | "SILENT",
-  "message": "...",
-  "followup": {
-    "repo_url": "...",
-    "task": "..."
-  }
+  "action": "SPAWN_FOLLOWUP" | "NOTIFY_ONLY" | "SILENT",
+  "message": "brief telegram message (1-2 lines)",
+  "followup": { "repo_url": "...", "task": "..." } | null
+}`;
 }
-
-Be conservative. Only SPAWN_FOLLOWUP if clearly needed. Only NOTIFY_ONLY for important completions. Use SILENT for routine jobs.`;
+function extractJson(text) {
+    // Strip ```json ... ``` fences
+    const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (fenced)
+        return fenced[1].trim();
+    // Find first { ... } block
+    const start = text.indexOf("{");
+    const end = text.lastIndexOf("}");
+    if (start !== -1 && end !== -1)
+        return text.slice(start, end + 1);
+    return "";
 }
 export function parseDecision(raw) {
-    const match = raw.match(/\{[\s\S]*\}/);
-    if (!match)
+    const extracted = extractJson(raw);
+    if (!extracted)
         throw new Error(`No JSON found in Claude response: ${raw.slice(0, 200)}`);
-    const parsed = JSON.parse(match[0]);
+    const parsed = JSON.parse(extracted);
     if (!["NOTIFY_ONLY", "SPAWN_FOLLOWUP", "SILENT"].includes(parsed.action)) {
         throw new Error(`Unknown action: ${parsed.action}`);
     }
     return parsed;
 }
+function formatSpawnMessage(event, followup, runningCount) {
+    const scoreStr = event.score !== undefined ? ` (score: ${event.score})` : "";
+    const repoShort = followup.repo_url.replace(/^https?:\/\/github\.com\//, "");
+    const lines = [
+        `✓ ${event.title} done${scoreStr}`,
+        `→ spawned: ${followup.task} (${repoShort})`,
+    ];
+    if (runningCount > 0) {
+        lines.push(`${runningCount} jobs running`);
+    }
+    return lines.join("\n");
+}
+function formatFailureMessage(event) {
+    const lastLine = event.lastLines[event.lastLines.length - 1] ?? "";
+    const repoShort = event.repoUrl.replace(/^https?:\/\/github\.com\//, "");
+    return `✗ ${event.title} failed\n${repoShort} — exit 1\nLast line: ${lastLine}`;
+}
 /**
  * Ask Claude to make a decision about a completed job.
  * Returns the raw text response from Claude.
@@ -149,6 +189,95 @@ Call the spawn_agent tool now with these exact parameters. Report the job ID whe
         claude.sendPrompt(prompt);
     });
 }
+function makeRedisClient() {
+    return new Redis(process.env.REDIS_URL || "redis://localhost:6379", {
+        lazyConnect: true,
+        enableOfflineQueue: false,
+    });
+}
+export async function defaultReadJobOutput(jobId) {
+    const redis = makeRedisClient();
+    try {
+        await redis.connect();
+        const lines = await redis.lrange(`cca:job:${jobId}:output`, -40, -1);
+        return lines;
+    }
+    finally {
+        try {
+            redis.disconnect();
+        }
+        catch { }
+    }
+}
+export async function defaultReadCoordinatorPlan(jobId) {
+    const redis = makeRedisClient();
+    try {
+        await redis.connect();
+        const raw = await redis.get(`cca:coordinator:plan:${jobId}`);
+        if (!raw)
+            return null;
+        return JSON.parse(raw);
+    }
+    finally {
+        try {
+            redis.disconnect();
+        }
+        catch { }
+    }
+}
+export async function defaultGetRunningJobCount() {
+    return 0;
+}
+/**
+ * Returns chat IDs to notify about job events.
+ * Reads unique chatIds from the cron jobs file (same users who set up cron jobs).
+ * Falls back to CC_AGENT_NOTIFY_CHAT_ID env var for backward compatibility.
+ */
+export async function defaultGetActiveChatIds() {
+    const ids = new Set();
+    // Backward compat: explicit env var
+    const chatIdStr = process.env.CC_AGENT_NOTIFY_CHAT_ID;
+    if (chatIdStr) {
+        const chatId = Number(chatIdStr);
+        if (!isNaN(chatId))
+            ids.add(chatId);
+    }
+    // Read chatIds from cron jobs persistence file
+    try {
+        const cwd = process.env.CWD ?? process.cwd();
+        const cronFile = join(cwd, ".cc-tg", "crons.json");
+        const raw = readFileSync(cronFile, "utf-8");
+        const jobs = JSON.parse(raw);
+        for (const job of jobs) {
+            if (typeof job.chatId === "number")
+                ids.add(job.chatId);
+        }
+    }
+    catch {
+        // file doesn't exist or parse error — ignore
+    }
+    return Array.from(ids);
+}
+/**
+ * Write a coordinator plan for a job, so cc-tg knows what follow-up to spawn.
+ * Call this when spawning a job that has a planned follow-up.
+ * TTL: 7 days.
+ */
+export async function writeCoordinatorPlan(jobId, plan) {
+    const redis = makeRedisClient();
+    try {
+        await redis.connect();
+        const key = `cca:coordinator:plan:${jobId}`;
+        const ttlSeconds = 7 * 24 * 60 * 60; // 7 days
+        await redis.set(key, JSON.stringify(plan), "EX", ttlSeconds);
+    }
+    finally {
+        try {
+            redis.disconnect();
+        }
+        catch { }
+    }
+}
 /**
  * Handle a single job event message from Redis pub/sub.
  * Exported for testability — production code passes defaultDeps.
@@ -168,29 +297,59 @@ export async function handleJobEvent(message, deps) {
         return;
     }
     log("info", `Processing ${event.status} event for job: ${event.title} (${event.jobId})`);
+    // Read job output from Redis (fall back to event.lastLines on error)
+    let last40lines = event.lastLines;
+    try {
+        const lines = await deps.readJobOutput(event.jobId);
+        if (lines.length > 0)
+            last40lines = lines;
+    }
+    catch (err) {
+        log("warn", "Failed to read job output, using event.lastLines:", err.message);
+    }
+    // Read coordinator plan from Redis (fall back to null on error)
+    let coordinatorPlan = null;
+    try {
+        coordinatorPlan = await deps.readCoordinatorPlan(event.jobId);
+    }
+    catch (err) {
+        log("warn", "Failed to read coordinator plan:", err.message);
+    }
     let decision;
+    let rawResponse = "";
     try {
-        const rawResponse = await deps.askClaude(buildDecisionPrompt(event));
+        rawResponse = await deps.askClaude(buildDecisionPrompt(event, last40lines, coordinatorPlan));
         decision = parseDecision(rawResponse);
     }
     catch (err) {
-        log("error", "Claude decision failed:", err.message);
-        return;
+        if (rawResponse) {
+            log("error", "[cc-agent-events] Claude raw response:", rawResponse.slice(0, 200));
+        }
+        log("error", "Claude decision failed, falling back to NOTIFY_ONLY:", err.message);
+        const fallbackMsg = event.status === "failed"
+            ? formatFailureMessage(event)
+            : `Job completed: ${event.title}`;
+        decision = { action: "NOTIFY_ONLY", message: fallbackMsg };
     }
     log("info", `Decision: ${decision.action} for job ${event.jobId}`);
+    let chatIds = [];
+    try {
+        chatIds = await deps.getActiveChatIds();
+    }
+    catch (err) {
+        log("warn", "Failed to get active chat IDs:", err.message);
+    }
     try {
         if (decision.action === "NOTIFY_ONLY") {
-            const chatIdStr = process.env.CC_AGENT_NOTIFY_CHAT_ID;
-            if (!chatIdStr) {
-                log("warn", "NOTIFY_ONLY: CC_AGENT_NOTIFY_CHAT_ID not set, skipping notification");
+            if (chatIds.length === 0) {
+                log("warn", "NOTIFY_ONLY: no active chat IDs, skipping notification");
                 return;
             }
-            const chatId = Number(chatIdStr);
-            if (isNaN(chatId)) {
-                log("warn", `NOTIFY_ONLY: invalid CC_AGENT_NOTIFY_CHAT_ID: ${chatIdStr}`);
-                return;
+            const msg = decision.message
+                ?? (event.status === "failed" ? formatFailureMessage(event) : `Job completed: ${event.title}`);
+            for (const chatId of chatIds) {
+                await deps.sendTelegramMessage(chatId, msg);
             }
-            await deps.sendTelegramMessage(chatId, decision.message ?? `Job completed: ${event.title}`);
         }
         else if (decision.action === "SPAWN_FOLLOWUP") {
             if (!decision.followup) {
@@ -198,6 +357,18 @@ export async function handleJobEvent(message, deps) {
                 return;
             }
             await deps.spawnFollowupAgent(decision.followup.repo_url, decision.followup.task);
+            // Send Telegram notification about the spawn
+            if (chatIds.length > 0) {
+                let runningCount = 0;
+                try {
+                    runningCount = await deps.getRunningJobCount();
+                }
+                catch { }
+                const spawnMsg = formatSpawnMessage(event, decision.followup, runningCount);
+                for (const chatId of chatIds) {
+                    await deps.sendTelegramMessage(chatId, spawnMsg);
+                }
+            }
         }
         else {
             // SILENT — log only
@@ -213,6 +384,10 @@ function makeDefaultDeps() {
         askClaude: defaultAskClaude,
         sendTelegramMessage: defaultSendTelegramMessage,
         spawnFollowupAgent: defaultSpawnFollowupAgent,
+        readJobOutput: defaultReadJobOutput,
+        readCoordinatorPlan: defaultReadCoordinatorPlan,
+        getRunningJobCount: defaultGetRunningJobCount,
+        getActiveChatIds: defaultGetActiveChatIds,
     };
 }
 let subscriberClient = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonzih/cc-tg",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "Claude Code Telegram bot — chat with Claude Code via Telegram",
   "type": "module",
   "bin": {