jerob 1.1.1 → 1.2.1

package/Telegram/agent-run.ts

@@ -0,0 +1,174 @@
+import { tool, ToolLoopAgent, stepCountIs } from "ai";
+import { z } from "zod";
+import { getAgentModel } from "../config/ai.config";
+import { ActionTracker } from "../agent/action-tracker.ts";
+import { ToolExecutor } from "../agent/tool-executor.ts";
+import { createAgentTools } from "../agent/agent-tools.ts";
+import { defaultAgentConfig, type AgentConfig } from "../agent/types.ts";
+import { createWebTools } from "../plan/web-tools.ts";
+import type { Plan, PlanStep } from "../plan/types.ts";
+import { clip, replyMd, escapeHtml } from "./text.ts";
+import { finishOrApprove } from "./approval-session.ts";
+
+function readOnlyConfig(): AgentConfig {
+  const c = defaultAgentConfig();
+  c.tools.allowFileCreation = false;
+  c.tools.allowFileModification = false;
+  c.tools.allowFolderCreation = false;
+  c.tools.allowShellExecution = false;
+  return c;
+}
+
+function agentOptions(config: AgentConfig, maxSteps: number) {
+  return {
+    model: getAgentModel(),
+    stopWhen: stepCountIs(maxSteps),
+    instructions: `Workspace root: ${config.codebasePath}`,
+  };
+}
+
+function formatErrorMessage(err: unknown) {
+  if (!err) return "Unknown error";
+  if (typeof err === "string") return err;
+  if (err instanceof Error) {
+    if (err.message) return err.message;
+    return err.name || "Error";
+  }
+  const anyErr = err as Record<string, unknown>;
+  if (anyErr?.vercel && typeof anyErr?.vercel === "object") {
+    const aiError = (anyErr as any).vercel.ai?.error;
+    if (aiError) {
+      const statusCode = (anyErr as any).statusCode ?? (aiError as any).statusCode;
+      const message = (anyErr as any).message ?? (aiError as any).message ?? JSON.stringify((anyErr as any).data ?? aiError, null, 2);
+      return statusCode ? `AI request failed (status ${statusCode}): ${message}` : `AI request failed: ${message}`;
+    }
+  }
+  if (Array.isArray((anyErr as any).errors)) {
+    const last = ((anyErr as any).errors as any[]).slice(-1)[0];
+    if (last?.message) return String(last.message);
+  }
+  try {
+    return JSON.stringify(err, null, 2).slice(0, 2000);
+  } catch {
+    return String(err);
+  }
+}
+
+async function safeReplyError(
+  ctx: { reply: (t: string, o?: object) => Promise<unknown> },
+  subject: string,
+  err: unknown,
+) {
+  const message = `❌ ${subject} failed.\n\n${clip(formatErrorMessage(err), 3500)}`;
+  await ctx.reply(message).catch(console.error);
+}
+
+function createReadOnlyTools(executor: ToolExecutor) {
+  return {
+    read_file: tool({
+      description: "Read a workspace file (relative path).",
+      inputSchema: z.object({ path: z.string() }),
+      execute: async ({ path: p }) => executor.readFile(p),
+    }),
+    list_files: tool({
+      description: "List files/dirs at a path.",
+      inputSchema: z.object({
+        path: z.string(),
+        recursive: z.boolean().optional().default(false),
+      }),
+      execute: async ({ path: p, recursive }) =>
+        executor.listFiles(p, recursive),
+    }),
+    search_files: tool({
+      description:
+        "Find files matching a glob pattern; optional content filter.",
+      inputSchema: z.object({
+        root: z.string(),
+        pattern: z.string(),
+        content_contains: z.string().optional(),
+      }),
+      execute: async ({ root, pattern, content_contains }) =>
+        executor.searchFiles(root, pattern, content_contains),
+    }),
+    analyze_codebase: tool({
+      description: "Summarize the codebase structure.",
+      inputSchema: z.object({ path: z.string().default(".") }),
+      execute: async ({ path: p }) => executor.analyzeCodebase(p),
+    }),
+  };
+}
+
+function extraWebTools(tracker: ActionTracker) {
+  return process.env.FIRECRAWL_API_KEY ? createWebTools(tracker) : {};
+}
+
+export async function runAsk(ctx:{reply:(t:string , o?:object)=>Promise<unknown>} , question:string){
+  const config = readOnlyConfig();
+  const tracker = new ActionTracker();
+  const executor = new ToolExecutor(tracker, config);
+  const tools = { ...createReadOnlyTools(executor), ...extraWebTools(tracker) };
+  const agent = new ToolLoopAgent({
+    ...agentOptions(config, 20),
+    tools,
+  });
+
+  try {
+    const { text } = await agent.generate({ prompt: question });
+    console.log(text);
+    await replyMd(ctx, text.trim() || "no answer");
+  } catch (err) {
+    console.error("runAsk error:", err);
+    await safeReplyError(ctx, "Ask", err);
+  }
+}
+
+export async function runAgent(ctx: { reply: (t: string, o?: object) => Promise<unknown> }, chatId: number, goal: string) {
+  const config = defaultAgentConfig();
+  const tracker = new ActionTracker();
+  const executor = new ToolExecutor(tracker, config);
+  const tools = createAgentTools(executor);
+  const agent = new ToolLoopAgent({
+    ...agentOptions(config, 40),
+    tools,
+  });
+
+  try {
+    const { text } = await agent.generate({ prompt: goal });
+    if (text?.trim()) await replyMd(ctx, text.trim());
+  } catch (err) {
+    console.error("runAgent error:", err);
+    await safeReplyError(ctx, "Agent", err);
+  }
+ await finishOrApprove(ctx, chatId, tracker, executor, '✅ Done. No file changes were needed.');
+}
+
+export async function runPlanSteps(
+  ctx: { reply: (t: string, o?: object) => Promise<unknown> },
+  chatId: number,
+  plan: Plan,
+  steps: PlanStep[],
+) {
+  const config = defaultAgentConfig();
+  const tracker = new ActionTracker();
+  const executor = new ToolExecutor(tracker, config);
+  const tools = { ...createAgentTools(executor), ...extraWebTools(tracker) };
+
+  for (const step of steps) {
+    await ctx.reply(`🔧 Executing: <b>${escapeHtml(step.title)}</b>`, { parse_mode: 'HTML' });
+    const prompt = [`Goal: ${plan.goal}`, `Step: ${step.title}`, step.description].join('\n');
+    const agent = new ToolLoopAgent({
+      ...agentOptions(config, 30),
+      tools,
+    });
+    try {
+      const { text } = await agent.generate({ prompt });
+      if (text?.trim()) await replyMd(ctx, text.trim());
+    } catch (err) {
+      console.error(`runPlanSteps error on step ${step.title}:`, err);
+      await safeReplyError(ctx, `Step ${step.title}`, err);
+      return;
+    }
+  }
+
+ await finishOrApprove(ctx, chatId, tracker, executor, '✅ All steps done. No file changes needed.');
+}

package/Telegram/approval-session.ts

@@ -0,0 +1,82 @@
+import { Markup } from 'telegraf';
+import type { ActionTracker } from '../agent/action-tracker.ts';
+import type { ToolExecutor } from '../agent/tool-executor.ts';
+import type { ActionLog } from '../agent/types.ts';
+import { composeBeforeAfter, formatPatch } from '../agent/diff-view.ts';
+import { clip } from './text.ts';
+
+export interface ApprovalSession {
+  tracker: ActionTracker;
+  executor: ToolExecutor;
+  pending: ActionLog[];
+}
+
+export const approvalSessions = new Map<number, ApprovalSession>();
+
+function groupPending(pending: ActionLog[]) {
+  const files = new Map<string, ActionLog[]>();
+  const shells: ActionLog[] = [];
+  for (const a of pending) {
+    if (a.type === 'tool_execute') shells.push(a);
+    else {
+      if (!files.has(a.path)) files.set(a.path, []);
+      files.get(a.path)!.push(a);
+    }
+  }
+  return { files, shells };
+}
+
+export function approvalSummary(pending: ActionLog[]): string {
+  const { files, shells } = groupPending(pending);
+  const fileLines = [...files].map(([path, actions]) => {
+    const types = [...new Set(actions.map((a) => a.type.replace(/_/g, ' ')))].join(', ');
+    return `📄 ${path} (${types})`;
+  });
+  const shellLines = shells.map((s) => `🖥 Shell: ${s.details.command}`);
+  return ['Staged changes — review before applying', '', ...fileLines, ...shellLines, '', `Total: ${pending.length} change(s)`].join('\n');
+}
+
+export function approvalDiff(pending: ActionLog[]): string {
+  const { files, shells } = groupPending(pending);
+  const parts: string[] = [];
+  for (const [filePath, actions] of files) {
+    const sorted = [...actions].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    const { before, after } = composeBeforeAfter(sorted);
+    parts.push(clip(formatPatch(filePath, before, after), 1500));
+  }
+  for (const s of shells) parts.push(`🖥 Shell: ${s.details.command}`);
+  return parts.join('\n\n').trim();
+}
+
+async function promptApproval(
+  ctx: { reply: (t: string, o?: object) => Promise<unknown> },
+  chatId: number,
+  session: ApprovalSession,
+) {
+  approvalSessions.set(chatId, session);
+  await ctx.reply(approvalSummary(session.pending), {
+    parse_mode: 'Markdown',
+    ...Markup.inlineKeyboard([
+      [Markup.button.callback('📋 Show Diff', 'approval_diff')],
+      [
+        Markup.button.callback('✅ Accept All', 'approval_accept'),
+        Markup.button.callback('❌ Reject All', 'approval_reject'),
+      ],
+    ]),
+  });
+}
+
+export async function finishOrApprove(
+  ctx: { reply: (t: string, o?: object) => Promise<unknown> },
+  chatId: number,
+  tracker: ActionTracker,
+  executor: ToolExecutor,
+  noChangesMsg: string,
+) {
+  const pending = tracker.getPendingMutations();
+  if (pending.length === 0) {
+    await ctx.reply(noChangesMsg);
+    return;
+  }
+  await promptApproval(ctx, chatId, { tracker, executor, pending });
+}

package/Telegram/auth.ts

@@ -0,0 +1 @@
+export const isOwner=(id: Number)=>String(id)===process.env.TELEGRAM_OWNER_ID

package/Telegram/constants.ts

@@ -0,0 +1,6 @@
+export const WELCOME = [
+  '👋 Hi! I am Jimmy your AI Operator bot. Here is what I can do:\n',
+  '/ask — Ask a question about the codebase',
+  '/agent — Let the agent modify your codebase',
+  '/plan — Generate a step-by-step plan for a goal',
+].join('\n');

package/Telegram/handlers.ts

@@ -0,0 +1,161 @@
+import type{ Telegraf} from "telegraf"
+import { isOwner } from "./auth"
+import { WELCOME } from "./constants"
+import { clip, commandArg } from "./text"
+import { runAgent, runAsk, runPlanSteps } from "./agent-run"
+import { generatePlan } from "../plan/planner"
+import { planKeyboard, planMessage, planSessions, refreshPlanUi, type PlanSession } from "./plan-session"
+import { approvalDiff, approvalSessions } from "./approval-session"
+
+async function notifyTelegramError(
+  ctx: { reply: (t: string, o?: object) => Promise<unknown> },
+  err: unknown,
+  action: string,
+) {
+  console.error(`${action} error:`, err);
+  const message = typeof err === 'string'
+    ? err
+    : err instanceof Error
+      ? err.message || err.name
+      : JSON.stringify(err, null, 2);
+  await ctx.reply(`❌ ${action} failed.\n\n${clip(message, 3500)}`)
+    .catch(console.error);
+}
+
+export function registerHandlers(bot: Telegraf){
+    bot.command("start",async(ctx)=>{
+        if(!isOwner(ctx.chat.id)) return 
+        await ctx.reply(WELCOME,{parse_mode:"Markdown"})
+    })
+
+    bot.command("ask",async(ctx)=>{
+        if(!isOwner(ctx.chat.id)) return 
+       const q=commandArg(ctx.message.text,"ask") 
+
+       if(!q){
+       return ctx.reply("Usage /ask your question",{parse_mode:"Markdown"})
+       }
+
+       await ctx.reply("🥁Researching your Question")
+       void runAsk(ctx,q).catch((err)=>notifyTelegramError(ctx, err, 'Ask'))
+    })
+
+
+    bot.command("agent",async(ctx)=>{
+        if(!isOwner(ctx.chat.id)) return 
+       const goal=commandArg(ctx.message.text,"agent") 
+
+       if(!goal){
+       return ctx.reply("Usage /agent your description",{parse_mode:"Markdown"})
+       }
+
+       await ctx.reply("🤖 Agent is Working on your task")
+       void runAgent(ctx,ctx.chat.id,goal).catch((err)=>notifyTelegramError(ctx, err, 'Agent'))
+    })
+
+  bot.command("plan", async (ctx) => {
+    if (!isOwner(ctx.chat.id)) return;
+    const goal = commandArg(ctx.message.text, "plan");
+
+    if (!goal)
+      return ctx.reply("Usage: `/plan <your goal>`", {
+        parse_mode: "Markdown",
+      });
+
+    await ctx.reply("🧭 Generating a plan…");
+
+    void (async ()=>{
+        const plan = await generatePlan(goal)
+        const session:PlanSession = {plan , selected:new Set(plan.steps.map((s)=>s.id))}
+        await ctx.reply(planMessage(session) , {parse_mode:"HTML", ...planKeyboard(session)});
+         planSessions.set(ctx.chat.id, session);
+    })().catch((err)=>notifyTelegramError(ctx, err, 'Plan generation'))
+  });
+
+    bot.action(/^plan_toggle:(.+)$/, async (ctx) => {
+    if (!isOwner(ctx.chat!.id)) return ctx.answerCbQuery();
+    const s = planSessions.get(ctx.chat!.id);
+    if (!s) return ctx.answerCbQuery();
+
+    const id = ctx.match[1]!;
+    if (s.selected.has(id)) s.selected.delete(id);
+    else s.selected.add(id);
+
+    await refreshPlanUi(ctx, s);
+    await ctx.answerCbQuery();
+  });
+
+  
+  bot.action('plan_all', async (ctx) => {
+    if (!isOwner(ctx.chat!.id)) return ctx.answerCbQuery();
+    const s = planSessions.get(ctx.chat!.id);
+    if (!s) return ctx.answerCbQuery();
+    for (const step of s.plan.steps) s.selected.add(step.id);
+    await refreshPlanUi(ctx, s);
+    await ctx.answerCbQuery();
+  });
+
+    bot.action('plan_none', async (ctx) => {
+    if (!isOwner(ctx.chat!.id)) return ctx.answerCbQuery();
+    const s = planSessions.get(ctx.chat!.id);
+    if (!s) return ctx.answerCbQuery();
+    s.selected.clear();
+    await refreshPlanUi(ctx, s);
+    await ctx.answerCbQuery();
+  });
+
+   bot.action('plan_proceed', async (ctx) => {
+    if (!isOwner(ctx.chat!.id)) return ctx.answerCbQuery();
+    const s = planSessions.get(ctx.chat!.id);
+    if (!s) return ctx.answerCbQuery();
+
+    const steps = s.plan.steps.filter((step) => s.selected.has(step.id));
+    if (steps.length === 0) return ctx.answerCbQuery();
+
+    const { plan } = s;
+    planSessions.delete(ctx.chat!.id);
+    const list = steps.map((step, i) => `${i + 1}. ${step.title}`).join('\n');
+    await ctx.editMessageText(`🚀 Executing ${steps.length} step(s)…\n\n${list}`);
+    await ctx.answerCbQuery();
+
+    void runPlanSteps(ctx, ctx.chat!.id, plan, steps).catch((err)=>notifyTelegramError(ctx, err, 'Plan execution'));
+  });
+
+  bot.action('approval_diff', async (ctx) => {
+    if (!isOwner(ctx.chat!.id)) return ctx.answerCbQuery();
+    const s = approvalSessions.get(ctx.chat!.id);
+    if (!s) return ctx.answerCbQuery();
+    await ctx.answerCbQuery();
+    await ctx.reply(clip(approvalDiff(s.pending)));
+  });
+
+  bot.action('approval_accept', async (ctx) => {
+    if (!isOwner(ctx.chat!.id)) return ctx.answerCbQuery();
+    const s = approvalSessions.get(ctx.chat!.id);
+    if (!s) return ctx.answerCbQuery();
+
+    approvalSessions.delete(ctx.chat!.id);
+    for (const a of s.pending) s.tracker.updateStatus(a.id, 'approved', true);
+    const { errors } = s.executor.applyApprovedFromTracker();
+    s.executor.clearStaging();
+
+    await ctx.editMessageText('✅ All changes applied.');
+    await ctx.answerCbQuery('Applied!');
+    if (errors.length) console.error(errors);
+  });
+
+  bot.action('approval_reject', async (ctx) => {
+    if (!isOwner(ctx.chat!.id)) return ctx.answerCbQuery();
+    const s = approvalSessions.get(ctx.chat!.id);
+    if (!s) return ctx.answerCbQuery();
+
+    approvalSessions.delete(ctx.chat!.id);
+    for (const a of s.pending) s.tracker.updateStatus(a.id, 'rejected', false);
+    s.executor.clearStaging();
+
+    await ctx.editMessageText('❌ All changes rejected. Nothing was applied.');
+    await ctx.answerCbQuery('Rejected');
+  });
+
+
+}

package/Telegram/index.ts

@@ -0,0 +1,28 @@
+import { Telegraf } from "telegraf";
+import chalk from "chalk";
+import { WELCOME } from "./constants";
+import { resolve } from "node:dns";
+import { registerHandlers } from "./handlers";
+
+export async function runTelegramMode() {
+  const token = process.env.TELEGRAM_BOT_TOKEN;
+  const ownerId = process.env.TELEGRAM_OWNER_ID;
+
+  const bot = new Telegraf(token!);
+  registerHandlers(bot)
+
+  await bot.telegram.sendMessage(ownerId!, WELCOME, { parse_mode: "Markdown" });
+  console.log(chalk.green("Sent welcome message to Telegram.\n"));
+
+  bot.launch();
+  console.log(chalk.green("Telegram bot is running. Press Ctrl+C to stop.\n"));
+
+  await new Promise<void>((resolve) => {
+    const stop = () => {
+      bot.stop("SIGINT");
+      resolve();
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+  });
+}

package/Telegram/plan-session.ts

@@ -0,0 +1,51 @@
+import { Markup } from 'telegraf';
+import type { Plan } from '../plan/types.ts';
+import { escapeHtml } from './text.ts';
+
+export interface PlanSession {
+  plan: Plan;
+  selected: Set<string>;
+}
+
+export const planSessions = new Map<number, PlanSession>();
+
+export function planMessage(session: PlanSession): string {
+  const lines = session.plan.steps.map((step, i) => {
+    const mark = session.selected.has(step.id) ? '✅' : '⬜';
+    const tag = step.complexity ? ` [${step.complexity}]` : '';
+    return `${mark} ${i + 1}. <b>${escapeHtml(step.title)}</b>${tag}`;
+  });
+  return [
+    `📋 <b>Plan for:</b> ${escapeHtml(session.plan.goal)}`,
+    '',
+    ...lines,
+    '',
+    '<i>Tap steps to toggle, then hit Proceed.</i>',
+  ].join('\n');
+}
+
+export function planKeyboard(session: PlanSession) {
+  const rows = session.plan.steps.map((step, i) => {
+    const mark = session.selected.has(step.id) ? '✅' : '⬜';
+    const label = `${mark} Step ${i + 1}: ${step.title}`;
+    return [Markup.button.callback(label, `plan_toggle:${step.id}`)];
+  });
+  return Markup.inlineKeyboard([
+    ...rows,
+    [
+      Markup.button.callback('✅ Select All', 'plan_all'),
+      Markup.button.callback('⬜ Deselect All', 'plan_none'),
+    ],
+    [Markup.button.callback('🚀 Proceed', 'plan_proceed')],
+  ]);
+}
+
+export async function refreshPlanUi(
+  ctx: { editMessageText: (t: string, o: object) => Promise<unknown> },
+  s: PlanSession,
+) {
+  await ctx.editMessageText(planMessage(s), {
+    parse_mode: 'HTML',
+    reply_markup: planKeyboard(s).reply_markup,
+  });
+}

package/Telegram/text.ts

@@ -0,0 +1,16 @@
+export const clip = (text: string, max = 4000) =>
+  text.length <= max ? text : text.slice(0, max) + '\n…[truncated]';
+
+export const replyMd = (ctx: { reply: (t: string, o?: object) => Promise<unknown> }, text: string) =>
+  ctx.reply(clip(text));
+
+export const escapeHtml = (text: string) =>
+  text
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+
+/** Text after `/name …` */
+export function commandArg(fullText: string, name: string): string {
+  return fullText.replace(new RegExp(`^/${name}\\s*`, 'i'), '').trim();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jerob",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "description": "Personal AI agent CLI — autonomous code agent, planner, browser automation, Q&A, and serverless scheduler",
   "module": "index.ts",
   "private": false,
@@ -20,6 +20,7 @@
     "plan/",
     "scheduler/",
     "supabase/",
+    "Telegram/",
     "tui/",
     "utils/",
     "tsconfig.json",