@inetafrica/open-claudia 1.5.0 → 1.6.0

package/bot.js

@@ -170,6 +170,7 @@ bot.setMyCommands([
   { command: "compact", description: "Summarize conversation context" },
   { command: "continue", description: "Resume last conversation" },
   { command: "worktree", description: "Toggle isolated git branch" },
+  { command: "agents", description: "Toggle direct/parallel agent mode" },
   { command: "cron", description: "Manage scheduled tasks" },
   { command: "vault", description: "Manage credentials (password required)" },
   { command: "soul", description: "View/edit assistant identity" },
@@ -267,7 +268,8 @@ const savedState = loadState();
 
 // ── State ───────────────────────────────────────────────────────────
 let currentSession = savedState.currentSession || null;
-let runningProcess = null;
+let runningProcess = null;        // Primary process (direct mode)
+let runningTasks = new Map();     // taskId -> { proc, statusMessageId, streamInterval, startTime } (parallel mode)
 let statusMessageId = null;
 let streamBuffer = "";
 let streamInterval = null;
@@ -277,13 +279,14 @@ let activeCrons = new Map();
 let pendingVaultUnlock = false; // Waiting for password
 let pendingVaultAction = null;  // What to do after unlock
 let isFirstMessage = !lastSessionId; // Track if this is first message in session
+let taskCounter = 0;
 
 let settings = savedState.settings || {
-  model: null, effort: null, budget: null, permissionMode: null, worktree: false,
+  model: null, effort: null, budget: null, permissionMode: null, worktree: false, agentMode: "direct",
 };
 
 function resetSettings() {
-  settings = { model: null, effort: null, budget: null, permissionMode: null, worktree: false };
+  settings = { model: null, effort: null, budget: null, permissionMode: null, worktree: false, agentMode: settings.agentMode };
 }
 
 function isAuthorized(msg) {
@@ -653,6 +656,19 @@ function parseStreamEvents(data) {
   return events;
 }
 
+/**
+ * Route to the appropriate runner based on agent mode setting.
+ * In direct mode: serial execution with shared session.
+ * In parallel mode: concurrent independent processes.
+ * Commands like /compact and /continue always use direct mode (they need session context).
+ */
+async function runClaudeRouted(prompt, cwd, replyToMsgId, opts = {}) {
+  if (opts.forceDirect || settings.agentMode !== "parallel") {
+    return runClaude(prompt, cwd, replyToMsgId, opts);
+  }
+  return runClaudeParallel(prompt, cwd, replyToMsgId, opts);
+}
+
 function buildClaudeArgs(prompt, opts = {}) {
   const args = ["-p", "--verbose", "--output-format", "stream-json",
     "--append-system-prompt", buildSystemPrompt()];
@@ -800,6 +816,126 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   });
 }
 
+/**
+ * Run Claude in parallel mode — each call gets its own independent process.
+ * No queueing, no shared session. Multiple tasks can run simultaneously.
+ */
+async function runClaudeParallel(prompt, cwd, replyToMsgId, opts = {}) {
+  bot.sendChatAction(CHAT_ID, "typing").catch(() => {});
+
+  const taskId = `task-${++taskCounter}`;
+  let taskStatusMsgId = null;
+  let taskStreamBuf = "";
+  let taskText = "";
+  let taskToolUses = [];
+  let taskCurrentTool = null;
+  let taskCurrentToolDetail = "";
+  let taskSessionId = null;
+
+  // Build args — always fresh session in parallel mode (no --resume)
+  const args = ["-p", "--verbose", "--output-format", "stream-json",
+    "--append-system-prompt", buildSystemPrompt()];
+  if (settings.model) args.push("--model", settings.model);
+  if (settings.effort) args.push("--effort", settings.effort);
+  if (settings.budget) args.push("--max-budget-usd", String(settings.budget));
+  if (settings.permissionMode) args.push("--permission-mode", settings.permissionMode);
+  else args.push("--dangerously-skip-permissions");
+  if (settings.worktree) args.push("--worktree");
+  args.push(prompt);
+
+  const proc = spawn(CLAUDE_PATH, args, {
+    cwd,
+    env: { ...process.env, PATH: FULL_PATH, HOME: process.env.HOME },
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: process.platform !== "win32",
+  });
+
+  const startTime = Date.now();
+  let taskInterval = null;
+  let lastUpdate = "";
+
+  // Adaptive progress updates
+  const scheduleTaskUpdate = () => {
+    const elapsed = Math.floor((Date.now() - startTime) / 1000);
+    const interval = elapsed > 120 ? 5000 : 2000;
+    taskInterval = setTimeout(doTaskUpdate, interval);
+  };
+  const doTaskUpdate = async () => {
+    const elapsed = Math.floor((Date.now() - startTime) / 1000);
+    try {
+      bot.sendChatAction(CHAT_ID, "typing").catch(() => {});
+      const display = formatProgress(taskText, taskToolUses, taskCurrentTool, elapsed, taskCurrentToolDetail);
+      if (display && display !== lastUpdate) {
+        if (!taskStatusMsgId && taskText) {
+          taskStatusMsgId = await send(display.length > 4000 ? display.slice(-4000) : display, { replyTo: replyToMsgId });
+        } else if (taskStatusMsgId) {
+          await editMessage(taskStatusMsgId, display.length > 4000 ? display.slice(-4000) : display);
+        }
+        lastUpdate = display;
+      }
+    } catch (e) {
+      console.error(`Task ${taskId} progress error:`, e.message);
+    }
+    if (runningTasks.has(taskId)) scheduleTaskUpdate();
+  };
+
+  runningTasks.set(taskId, { proc, startTime, prompt: prompt.slice(0, 50) });
+  scheduleTaskUpdate();
+
+  proc.stdout.on("data", (data) => {
+    taskStreamBuf += data.toString();
+    const events = parseStreamEvents(taskStreamBuf);
+    const lastNewline = taskStreamBuf.lastIndexOf("\n");
+    taskStreamBuf = lastNewline >= 0 ? taskStreamBuf.slice(lastNewline + 1) : taskStreamBuf;
+    for (const evt of events) {
+      if (evt.type === "assistant" && evt.message?.content) {
+        for (const block of evt.message.content) {
+          if (block.type === "text") taskText += block.text;
+          else if (block.type === "tool_use") {
+            taskCurrentTool = block.name;
+            taskToolUses.push(block.name);
+            const input = block.input || {};
+            if (block.name === "Bash" && input.command) taskCurrentToolDetail = input.command.slice(0, 80);
+            else if ((block.name === "Read" || block.name === "Edit" || block.name === "Write") && input.file_path)
+              taskCurrentToolDetail = input.file_path.split("/").slice(-2).join("/");
+            else if (block.name === "Grep" && input.pattern) taskCurrentToolDetail = input.pattern.slice(0, 40);
+            else if (block.name === "Glob" && input.pattern) taskCurrentToolDetail = input.pattern;
+            else taskCurrentToolDetail = "";
+          }
+        }
+      }
+      if (evt.type === "result" && evt.session_id) taskSessionId = evt.session_id;
+      if (evt.type === "result" && evt.result) taskText = evt.result;
+    }
+  });
+
+  proc.stderr.on("data", (d) => console.error(`Task ${taskId} STDERR:`, d.toString()));
+
+  proc.on("close", async (code) => {
+    runningTasks.delete(taskId);
+    clearTimeout(taskInterval);
+    try {
+      const finalText = taskText || "(no output)";
+      const chunks = splitMessage(finalText);
+      const sent = await send(chunks[0], { replyTo: replyToMsgId });
+      if (!sent) await send(chunks[0]);
+      for (let i = 1; i < chunks.length; i++) await send(chunks[i]);
+      if (code !== 0 && code !== null) await send(`Exit code: ${code}`);
+    } catch (e) {
+      console.error(`Task ${taskId} final delivery failed:`, e.message);
+      await send("Task completed but failed to deliver the response.");
+    }
+  });
+
+  proc.on("error", async (err) => {
+    runningTasks.delete(taskId);
+    clearTimeout(taskInterval);
+    await send(`Task error: ${err.message}`, { replyTo: replyToMsgId });
+  });
+
+  return taskId;
+}
+
 async function runClaudeSilent(prompt, cwd, label) {
   return new Promise((resolve) => {
     const args = ["-p", "--output-format", "text", "--verbose",
@@ -910,7 +1046,7 @@ bot.onText(/\/help/, (msg) => {
   if (!isAuthorized(msg)) return;
   send([
     "Session: /session /sessions /projects /continue /status /stop /end",
-    "Settings: /model /effort /budget /plan /compact /worktree",
+    "Settings: /model /effort /budget /plan /compact /worktree /agents",
     "Automation: /cron /vault /soul",
     "System: /restart /upgrade",
     "",
@@ -1018,17 +1154,45 @@ bot.onText(/\/compact/, async (msg) => { if (!isAuthorized(msg)) return; if (!re
 bot.onText(/\/continue$/, async (msg) => { if (!isAuthorized(msg)) return; if (!requireSession(msg)) return; await runClaude("continue where we left off", currentSession.dir, msg.message_id, { continueSession: true }); });
 bot.onText(/\/worktree$/, (msg) => { if (!isAuthorized(msg)) return; settings.worktree = !settings.worktree; send(settings.worktree ? "Worktree on." : "Worktree off."); });
 
+bot.onText(/\/agents$/, (msg) => {
+  if (!isAuthorized(msg)) return;
+  const mode = settings.agentMode || "direct";
+  send(`Agent mode: *${mode}*\n\n` +
+    `*direct* — one task at a time, shared session context, queues messages\n` +
+    `*parallel* — concurrent tasks, independent sessions, no queue`, {
+    parseMode: "Markdown",
+    keyboard: { inline_keyboard: [
+      [{ text: mode === "direct" ? "Direct (active)" : "Switch to Direct", callback_data: "am:direct" },
+       { text: mode === "parallel" ? "Parallel (active)" : "Switch to Parallel", callback_data: "am:parallel" }],
+    ] },
+  });
+});
+
 bot.onText(/\/stop/, async (msg) => {
   if (!isAuthorized(msg)) return;
+
+  // Stop parallel tasks
+  if (runningTasks.size > 0) {
+    for (const [taskId, task] of runningTasks) {
+      try { process.kill(-task.proc.pid, "SIGTERM"); } catch (e) {
+        try { task.proc.kill("SIGTERM"); } catch (e2) {}
+      }
+      setTimeout(() => { try { process.kill(-task.proc.pid, "SIGKILL"); } catch (e) {} }, 3000);
+    }
+    const count = runningTasks.size;
+    runningTasks.clear();
+    await send(`Cancelled ${count} task${count > 1 ? "s" : ""}.`);
+    return;
+  }
+
+  // Stop direct mode process
   if (runningProcess) {
     const pid = runningProcess.pid;
     try {
-      // Kill entire process group to catch child processes (dev servers, etc.)
       process.kill(-pid, "SIGTERM");
     } catch (e) {
       try { runningProcess.kill("SIGTERM"); } catch (e2) {}
     }
-    // Force kill after 3 seconds if still alive
     setTimeout(() => {
       try { process.kill(-pid, "SIGKILL"); } catch (e) {}
     }, 3000);
@@ -1036,19 +1200,33 @@ bot.onText(/\/stop/, async (msg) => {
     if (streamInterval) clearTimeout(streamInterval);
     messageQueue = [];
     await send("Cancelled.");
+    return;
   }
-  else await send("Nothing running.");
+
+  await send("Nothing running.");
 });
 
 bot.onText(/\/status/, (msg) => {
   if (!isAuthorized(msg)) return;
   if (!currentSession) return send("No session.", { keyboard: { inline_keyboard: [[{ text: "Pick", callback_data: "show:projects" }]] } });
-  send([
+  const mode = settings.agentMode || "direct";
+  const lines = [
     `Project: ${currentSession.name}`,
-    `Model: ${settings.model || "default"} | Effort: ${settings.effort || "default"}`,
+    `Model: ${settings.model || "default"} | Effort: ${settings.effort || "default"} | Mode: ${mode}`,
     `Vault: ${vault.isUnlocked() ? "unlocked" : "locked"} | Crons: ${activeCrons.size}`,
-    runningProcess ? "Working..." : "Ready.",
-  ].join("\n"));
+  ];
+  if (mode === "parallel" && runningTasks.size > 0) {
+    lines.push(`Running: ${runningTasks.size} task${runningTasks.size > 1 ? "s" : ""}`);
+    for (const [id, task] of runningTasks) {
+      const elapsed = Math.floor((Date.now() - task.startTime) / 1000);
+      lines.push(`  ${id}: ${task.prompt}... (${elapsed}s)`);
+    }
+  } else if (runningProcess) {
+    lines.push("Working...");
+  } else {
+    lines.push("Ready.");
+  }
+  send(lines.join("\n"));
 });
 
 bot.onText(/\/end/, (msg) => {
@@ -1184,6 +1362,7 @@ bot.on("callback_query", async (q) => {
   if (d.startsWith("m:")) { settings.model = d.slice(2) === "default" ? null : d.slice(2); await send(`Model: ${settings.model || "default"}`); return; }
   if (d.startsWith("e:")) { const e = d.slice(2); settings.effort = e === "default" ? null : e; await send(`Effort: ${settings.effort || "default"}`); return; }
   if (d.startsWith("b:")) { const b = d.slice(2); settings.budget = b === "none" ? null : parseFloat(b); await send(`Budget: ${settings.budget ? "$"+settings.budget : "none"}`); return; }
+  if (d.startsWith("am:")) { settings.agentMode = d.slice(3); saveState(); await send(`Agent mode: ${settings.agentMode}`); return; }
 
   // Cron presets
   if (d.startsWith("cp:") && d !== "cp:clear") {
@@ -1217,7 +1396,7 @@ bot.on("voice", async (msg) => {
     try { fs.unlinkSync(oggPath); } catch (e) {}
     if (!transcript) return send("Couldn't transcribe. Try typing it.");
     await send(`Heard: "${transcript}"`, { replyTo: msg.message_id });
-    await runClaude(transcript, currentSession.dir, msg.message_id);
+    await runClaudeRouted(transcript, currentSession.dir, msg.message_id);
   } catch (err) { await send(`Voice failed: ${err.message}`); }
 });
 
@@ -1232,7 +1411,7 @@ bot.on("audio", async (msg) => {
     try { fs.unlinkSync(p); } catch (e) {}
     if (!t) return send("Couldn't transcribe.");
     await send(`Heard: "${t}"`, { replyTo: msg.message_id });
-    await runClaude(t, currentSession.dir, msg.message_id);
+    await runClaudeRouted(t, currentSession.dir, msg.message_id);
   } catch (err) { await send(`Audio failed: ${err.message}`); }
 });
 
@@ -1243,7 +1422,7 @@ bot.on("photo", async (msg) => {
   try {
     const p = await downloadFile(msg.photo[msg.photo.length - 1].file_id, ".jpg");
     const caption = msg.caption || "Describe this image. If code/UI/error — explain and fix.";
-    await runClaude(`Image at ${p}\n\nView it, then: ${caption}`, currentSession.dir, msg.message_id);
+    await runClaudeRouted(`Image at ${p}\n\nView it, then: ${caption}`, currentSession.dir, msg.message_id);
   } catch (err) { await send(`Image failed: ${err.message}`); }
 });
 
@@ -1271,7 +1450,7 @@ bot.on("document", async (msg) => {
       prompt = `File received: ${fileName} (${mime})\nSaved at: ${savePath}\n\nRead this file and ${caption || "summarize its contents. If it's code, explain what it does. If it's a document, give key points."}`;
     }
     await send(`File saved: ${fileName}`, { replyTo: msg.message_id });
-    await runClaude(prompt, currentSession.dir, msg.message_id);
+    await runClaudeRouted(prompt, currentSession.dir, msg.message_id);
   } catch (err) { await send(`Failed: ${err.message}`); }
 });
 
@@ -1376,7 +1555,7 @@ bot.on("message", async (msg) => {
     }
   }
 
-  await runClaude(prompt, currentSession.dir, msg.message_id);
+  await runClaudeRouted(prompt, currentSession.dir, msg.message_id);
 });
 
 // ── Startup ─────────────────────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Your always-on AI coding assistant — Claude Code via Telegram",
   "main": "bot.js",
   "bin": {