jerob 1.0.0

package/plan/browser-agent/planner.ts

@@ -0,0 +1,200 @@
+import { getAgentModel, getAgentModel2, getAgentModel2Fallback } from "../../config/ai.config";
+import type { BrowserPlan, BrowserStep } from "./types";
+import { generateText } from "ai";
+import { z } from "zod";
+import chalk from "chalk";
+import { parseLLMError } from "../../utils/llm-error";
+
+const optionalString = () =>
+  z.preprocess((value) => (value === null ? undefined : value), z.string().optional());
+
+const optionalRecord = () =>
+  z.preprocess(
+    (value) => (value === null ? undefined : value),
+    z.record(z.string()).optional()
+  );
+
+const BrowserStepSchema = z.object({
+  id: z.number(),
+  action: z.enum([
+    "navigate",
+    "click",
+    "type",
+    "extract",
+    "wait",
+    "observe",
+    "scroll",
+  ]),
+  description: z.string(),
+  selector: optionalString(),
+  value: optionalString(),
+  waitFor: optionalString(),
+  extractSchema: optionalRecord(),
+}).strict();
+
+const BrowserPlanSchema = z.object({
+  goal: z.string(),
+  steps: z.array(BrowserStepSchema),
+  reasoning: z.string(),
+}).strict();
+
+function extractJsonObjectFromText(text: string): string | null {
+  let jsonText = text.trim();
+
+  if (jsonText.startsWith("```json")) {
+    jsonText = jsonText.slice(7);
+  }
+  if (jsonText.startsWith("```")) {
+    jsonText = jsonText.slice(3);
+  }
+  if (jsonText.endsWith("```")) {
+    jsonText = jsonText.slice(0, -3);
+  }
+
+  jsonText = jsonText.trim();
+
+  const firstBraceIndex = jsonText.indexOf("{");
+  if (firstBraceIndex === -1) {
+    return null;
+  }
+
+  let depth = 0;
+  for (let i = firstBraceIndex; i < jsonText.length; i += 1) {
+    const char = jsonText[i];
+    if (char === "{") {
+      depth += 1;
+    } else if (char === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return jsonText.slice(firstBraceIndex, i + 1);
+      }
+    }
+  }
+
+  return null;
+}
+
+export async function generateBrowserPlan(
+  query: string,
+  previousFeedback?: string
+): Promise<BrowserPlan> {
+  let model = getAgentModel();
+  let usingFallback = false;
+
+  const systemPrompt = `You are a browser automation planner. Your task is to create a detailed plan for how to automate a browser task.
+
+IMPORTANT: You are helping with legitimate web automation for research, data collection, and productivity purposes. This is not for any harmful activities.
+
+${
+  previousFeedback
+    ? `Previous feedback indicated issues. Address them in this iteration: ${previousFeedback}`
+    : ""
+}
+
+Create a plan with concrete steps that will:
+1. Navigate to relevant URLs
+2. Interact with page elements (click, type, scroll)
+3. Extract information in structured format
+4. Validate the results
+
+Be specific about selectors and values. Each step should be actionable and precise.
+
+You MUST respond with ONLY a valid JSON object (no markdown, no code blocks). If you include any explanation, place it after the JSON object and not inside it.
+
+The exact JSON schema is:
+{
+  "goal": "string",
+  "steps": [
+    {
+      "id": number,
+      "action": "navigate" | "click" | "type" | "extract" | "wait" | "observe" | "scroll",
+      "description": "string",
+      "selector": "string (optional)",
+      "value": "string (optional)",
+      "waitFor": "string (optional)",
+      "extractSchema": {"fieldName": "description"} (optional)
+    }
+  ],
+  "reasoning": "string"
+}`;
+
+  const userPrompt = `Create a browser automation plan for: ${query}
+
+Respond with valid JSON only. No markdown, no explanations, just the JSON object.`;
+
+  let lastError: Error | null = null;
+
+  // Try up to 4 attempts (2 with primary model, 2 with fallback)
+  for (let attempt = 1; attempt <= 4; attempt += 1) {
+    // Switch to fallback model after 2 failed attempts
+    if (attempt === 3 && !usingFallback) {
+      console.log(chalk.dim("Primary model failed, switching to fallback model..."));
+      model = getAgentModel2Fallback();
+      usingFallback = true;
+    }
+
+    let response;
+    try {
+      response = await generateText({
+        model,
+        messages: [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: userPrompt },
+        ],
+        temperature: 0.7,
+      });
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      const parsed = parseLLMError(err);
+      // Don't retry on auth/quota errors
+      if (!parsed.retryable) {
+        throw new Error(`Browser planner: ${parsed.message}`);
+      }
+      continue;
+    }
+
+    const rawText = response.text ?? "";
+    
+    // Check for refusal patterns
+    if (rawText.includes("I'm sorry") || rawText.includes("I can't help") || rawText.includes("cannot assist")) {
+      lastError = new Error(
+        `Model refused to generate plan. This may be due to content safety filters. Raw response: ${rawText}\n\nTry:\n1. Rephrasing your request more explicitly as legitimate research/automation\n2. Using a different model\n3. Being more specific about the legitimate use case`
+      );
+      continue;
+    }
+    
+    const jsonText = extractJsonObjectFromText(rawText);
+
+    if (!jsonText) {
+      lastError = new Error(
+        `Unable to locate a valid JSON object in the model response. Raw response: ${rawText}`
+      );
+      continue;
+    }
+
+    try {
+      const parsed = JSON.parse(jsonText);
+      
+      // Check if this is an error response instead of a valid plan
+      if (parsed.error || (!parsed.goal && !parsed.steps)) {
+        lastError = new Error(
+          `Model returned an error or invalid response instead of a plan: ${JSON.stringify(parsed)}\n\nThis typically means content safety filters were triggered.`
+        );
+        continue;
+      }
+      
+      return BrowserPlanSchema.parse(parsed);
+    } catch (error) {
+      lastError = new Error(
+        `Unable to parse JSON plan from model response. Raw extracted JSON: ${jsonText}. Error: ${
+          error instanceof Error ? error.message : String(error)
+        }`
+      );
+      continue;
+    }
+  }
+
+  throw new Error(
+    `Failed to parse browser plan after trying both primary and fallback models: ${lastError?.message ?? "Unknown parser failure."}`
+  );
+}

package/plan/browser-agent/types.ts

@@ -0,0 +1,62 @@
+export interface BrowserPlan {
+  goal: string;
+  steps: BrowserStep[];
+  reasoning: string;
+}
+
+export interface BrowserStep {
+  id: number;
+  action: "navigate" | "click" | "type" | "extract" | "wait" | "observe" | "scroll";
+  description: string;
+  selector?: string;
+  value?: string;
+  waitFor?: string;
+  extractSchema?: Record<string, string>;
+}
+
+export interface ExecutionResult {
+  success: boolean;
+  data?: unknown;
+  error?: string;
+  message: string;
+  stepNumber: number;
+  action: string;
+  // Raw output from stagehand agent
+  agentOutput?: string;
+  agentMessages?: unknown[];
+}
+
+export interface IterationResult {
+  iteration: number;
+  plan: BrowserPlan;
+  execution: ExecutionResult[];
+  evaluation: EvaluationResult;
+  shouldContinue: boolean;
+}
+
+export interface EvaluationResult {
+  satisfied: boolean;
+  score: number; // 0-100
+  feedback: string;
+  completeness: number; // 0-100
+  accuracy: number; // 0-100
+  issues: string[];
+}
+
+export interface BrowserAgentConfig {
+  maxIterations: number;
+  timeout: number;
+  model: string;
+  apiKey: string;
+  evaluationThreshold: number; // 0-100, default 80
+}
+
+export interface BrowserAgentResult {
+  success: boolean;
+  query: string;
+  finalData: unknown;
+  iterations: IterationResult[];
+  totalIterations: number;
+  completedAt: string;
+  error?: string;
+}

package/plan/browser-tool.ts

@@ -0,0 +1,128 @@
+import { Stagehand } from "@browserbasehq/stagehand";
+import { config } from "dotenv";
+config({ path: "../.env" });
+
+let globalstageHand: InstanceType<typeof Stagehand> | null = null;
+
+function getExtractResults(messages: any[]) {
+  const extracts = [];
+
+  for (const msg of messages) {
+    if (msg.role !== "tool") continue;
+
+    for (const item of msg.content ?? []) {
+      if (item.toolName === "extract" && item.output?.value?.success) {
+        extracts.push(item.output.value.result.extraction);
+      }
+    }
+  }
+
+  return extracts;
+}
+
+const getStagehandClient = () => {
+  if (!globalstageHand) {
+    globalstageHand = new Stagehand({
+      env: "LOCAL",
+          localBrowserLaunchOptions: {
+    headless: false, // Show browser window
+    devtools: false, // Open developer tools
+    port: 9222, // Fixed CDP debugging port
+    args: [
+      '--no-sandbox',
+      '--disable-setuid-sandbox',
+      '--disable-web-security',
+      '--allow-running-insecure-content',
+    ],
+    ignoreHTTPSErrors: true, // Ignore certificate errors
+    locale: 'en-US', // Set browser language
+    deviceScaleFactor: 1.0, // Display scaling
+    downloadsPath: './downloads', // Download directory
+    acceptDownloads: true, // Allow downloads
+    connectTimeoutMs: 30000, // Connection timeout
+    executablePath:"C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe"
+  },
+      model: {
+        modelName: "google/gemini-3.1-flash-lite-preview",
+        apiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY,
+      },
+    });
+  }
+  return globalstageHand;
+};
+export const browserSearch = async (query: string) => {
+  //   const stagehand = new Stagehand({
+  //     env: "LOCAL",
+  //     localBrowserLaunchOptions: {
+  //       headless: false,
+  //       devtools: false,
+  //     },
+  //     model: {
+  //       modelName: "google/gemini-3.1-flash-lite-preview",
+  //       apiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY,
+  //     },
+  //   });
+  const stagehand = getStagehandClient();
+  await stagehand.init();
+
+  const agent = stagehand.agent({
+    mode: "dom",
+
+    systemPrompt: `
+You are a browser automation agent.
+
+Rules:
+- Search efficiently.
+- Avoid unnecessary navigation.
+- Extract structured data.
+- Stop when task is complete.
+
+
+Before calling done:
+
+1. Re-read the original user request.
+
+2. Create a checklist.
+
+3. Verify every item is satisfied.
+
+4. If any requested information is missing,
+   DO NOT call done.
+
+5. Explicitly count collected results.
+
+Example:
+
+User asks:
+"Get top 5 jobs and detailed descriptions."
+
+Required:
+✓ 5 jobs found
+✓ description for job 1
+✓ description for job 2
+✓ description for job 3
+✓ description for job 4
+✓ description for job 5
+
+Only call done when all 6 checks pass.
+`,
+  });
+
+  const res = await agent.execute({
+    instruction: query,
+    maxSteps: 10,
+    highlightCursor: true,
+  });
+
+  res.messages?.forEach((e) => {
+    console.log(e.role);
+    console.log(JSON.stringify(e.content));
+  });
+  const output = getExtractResults(res.messages ?? []);
+  console.log("\n\n\n\n output " + output);
+  await stagehand.close();
+};
+
+browserSearch(
+  `go and find rag youtube video fo piyush garg get its link then go to youtube transcript site and get me its complete transcript`,
+);

package/plan/index.ts

@@ -0,0 +1,12 @@
+export { runPlanMode } from './orchestrator';
+export type { Plan, PlanStep } from './types';
+export { runBrowserAgentMode } from './browser-agent';
+export type {
+  BrowserPlan,
+  BrowserStep,
+  ExecutionResult,
+  IterationResult,
+  EvaluationResult,
+  BrowserAgentConfig,
+  BrowserAgentResult,
+} from './browser-agent';

package/plan/orchestrator.ts

@@ -0,0 +1,214 @@
+import chalk from 'chalk';
+import { confirm, isCancel, text } from '@clack/prompts';
+import fs from 'node:fs';
+import path from 'node:path';
+import { ToolLoopAgent, stepCountIs } from 'ai';
+import { ActionTracker } from '../agent/action-tracker.ts';
+import { ToolExecutor } from '../agent/tool-executor.ts';
+import { createAgentTools } from '../agent/agent-tools.ts';
+import { defaultAgentConfig } from '../agent/types.ts';
+import { runApprovalFlow } from '../agent/approval.ts';
+import { generatePlan } from './planner';
+import { printPlan, selectSteps } from './selection';
+import { createWebTools } from './web-tools';
+import type { PlanStep } from './types';
+import { renderHTMLMarkdown } from '../tui/terminal-render.ts';
+import { getAgentModel } from '../config/ai.config.ts';
+import { withSpinner } from '../tui/spinner';
+import { withLLMRetry, printLLMError } from '../utils/llm-error';
+
+function stepPrompt(goal: string, step: PlanStep, projectDir?: string): string {
+  const parts = [`Overall Goal: ${goal}`, `Current Step: ${step.title}`, step.description];
+  if (projectDir) {
+    parts.push(`\nIMPORTANT: The project already exists at: ${projectDir}\nAll file operations MUST be inside this folder. Do NOT create a new project folder.`);
+  }
+  return parts.join('\n');
+}
+
+/** After each step, detect which project folder was created/modified */
+function detectProjectDir(codebasePath: string, knownDir?: string): string | undefined {
+  if (knownDir) return knownDir;
+  // Look for folders that contain a package.json — likely the project root
+  try {
+    const entries = fs.readdirSync(codebasePath, { withFileTypes: true });
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      if (['node_modules', '.git', 'dist', 'build'].includes(e.name)) continue;
+      const pkgPath = path.join(codebasePath, e.name, 'package.json');
+      if (fs.existsSync(pkgPath)) return e.name;
+    }
+  } catch {}
+  return undefined;
+}
+
+export async function runPlanMode(): Promise<void> {
+  console.log(chalk.bold('\n🧭 Plan Mode\n'));
+
+  const goal = await text({ message: 'What is your goal?' });
+  if (isCancel(goal) || !goal.trim()) return;
+  const includeWorkspace = await confirm({
+    message: 'Include workspace research (scan repository)?',
+    initialValue: true,
+  });
+
+  const spinnerLabel = includeWorkspace ? 'Researching & drafting a plan…' : 'Drafting plan…';
+  let plan;
+  try {
+    plan = await withSpinner(spinnerLabel, async () =>
+      generatePlan(goal.trim(), { useWorkspace: includeWorkspace as boolean }),
+    );
+  } catch (err) {
+    printLLMError(err, "Plan");
+    return;
+  }
+  printPlan(plan);
+
+  const wantsSave = await confirm({
+    message: 'Save this plan to a .md file?',
+    initialValue: true,
+  });
+
+  let savedPath: string | undefined;
+  if (wantsSave) {
+    const filename = await text({ message: 'Filename', initialValue: 'plan.md', validate: (v) => {
+      const s = (v ?? '').trim();
+      if (!s) return 'Required';
+      if (s.includes('..') || s.includes('/') || s.includes('\\')) return 'No paths';
+      if (!s.toLowerCase().endsWith('.md')) return 'Must end with .md';
+    } });
+    if (!isCancel(filename)) {
+      const outPath = path.resolve(process.cwd(), filename.trim());
+      const md = [`# Plan: ${plan.goal}`, '', '```json', JSON.stringify({ goal: plan.goal, researchSummary: plan.researchSummary, steps: plan.steps }, null, 2), '```', ''].join('\n');
+      fs.writeFileSync(outPath, md, 'utf8');
+      savedPath = outPath;
+      console.log(chalk.green(`Saved plan to ${outPath}`));
+    }
+  }
+
+  const selected = await selectSteps(plan);
+  if (selected.length === 0) return;
+
+  const executeNow = await confirm({ message: `Execute ${selected.length} step(s) via Agent Mode?`, initialValue: false });
+  if (!isCancel(executeNow) && executeNow) {
+    // Ensure plan is stored in an .md file to drive execution
+    if (!savedPath) {
+      const mustSave = await confirm({ message: 'Execution requires a saved plan .md file. Save now?', initialValue: true });
+      if (isCancel(mustSave) || !mustSave) {
+        console.log(chalk.yellow('Execution cancelled (plan not saved).'));
+        return;
+      }
+      const filename = await text({ message: 'Filename', initialValue: 'plan.md', validate: (v) => {
+        const s = (v ?? '').trim();
+        if (!s) return 'Required';
+        if (s.includes('..') || s.includes('/') || s.includes('\\')) return 'No paths';
+        if (!s.toLowerCase().endsWith('.md')) return 'Must end with .md';
+      } });
+      if (isCancel(filename)) return;
+      const outPath = path.resolve(process.cwd(), filename.trim());
+      const md = [`# Plan: ${plan.goal}`, '', '```json', JSON.stringify({ goal: plan.goal, researchSummary: plan.researchSummary, steps: plan.steps }, null, 2), '```', ''].join('\n');
+      fs.writeFileSync(outPath, md, 'utf8');
+      savedPath = outPath;
+      console.log(chalk.green(`Saved plan to ${outPath}`));
+    }
+
+    // Read plan from savedPath and parse JSON block
+    let planObj: { goal: string; researchSummary?: string; steps: PlanStep[] } | null= null;
+    try {
+      const raw = fs.readFileSync(savedPath!, 'utf8');
+      const m = raw.match(/```json\s*([\s\S]*?)\s*```/i);
+      if (m && m[1]) {
+        planObj = JSON.parse(m[1]);
+      } else {
+        throw new Error('No JSON block found in plan file');
+      }
+    } catch (err) {
+      console.log(chalk.red('Failed to parse saved plan .md; aborting execution.')); 
+      console.error(err);
+      return;
+    }
+
+    const config = defaultAgentConfig();
+    // Single tracker accumulates all step actions for the final review log
+    const tracker = new ActionTracker();
+    const executor = new ToolExecutor(tracker, config);
+
+    const tools = {
+      ...createAgentTools(executor),
+      ...(process.env.FIRECRAWL_API_KEY ? createWebTools(tracker) : {}),
+    };
+
+    let projectDir: string | undefined;
+    const totalSteps = planObj!.steps.length;
+    const allErrors: string[] = [];
+
+    for (let stepIdx = 0; stepIdx < planObj!.steps.length; stepIdx++) {
+      const step = planObj!.steps[stepIdx]!;
+      console.log(chalk.bold(`\n🔧 [${stepIdx + 1}/${totalSteps}] ${step.title}\n`));
+
+      // Detect project folder from real disk (visible after previous step was applied)
+      projectDir = detectProjectDir(config.codebasePath, projectDir);
+
+      const agent = new ToolLoopAgent({
+        model: getAgentModel(),
+        stopWhen: stepCountIs(30),
+        tools,
+        instructions: `
+WorkDir: ${config.codebasePath}
+You are an AI coding agent executing ONE step of a multi-step plan.
+
+CRITICAL RULES:
+1. This is step ${stepIdx + 1} of ${totalSteps}. Do ONLY what this step describes — no more, no less.
+2. ${projectDir
+  ? `The project already exists at "${projectDir}/" (relative to WorkDir). ALL files MUST go inside "${projectDir}/". NEVER create a new top-level folder.`
+  : `If this step scaffolds a new project, choose ONE folder name. Every subsequent step will use that same folder.`}
+3. ALWAYS call list_files first to see what already exists on disk. Use modify_file for existing files, create_file only for genuinely new ones.
+4. NEVER create a duplicate or alternate project folder. There is exactly ONE project folder.
+5. Use create_file / modify_file / create_folder tools only — never print code as plain text.
+        `.trim(),
+      });
+
+      let r;
+      try {
+        r = await withLLMRetry(
+          () => agent.generate({
+            prompt: stepPrompt(planObj!.goal, step, projectDir),
+            onStepFinish: ({ toolCalls }) => {
+              for (const tc of toolCalls) {
+                const preview = JSON.stringify(tc?.input).slice(0, 160);
+                console.log(chalk.green('  ✓'), chalk.bold(String(tc?.toolName)), chalk.dim(preview + (preview.length >= 160 ? '...' : '')));
+              }
+            },
+          }),
+          { maxRetries: 3, context: `Step: ${step.title}` }
+        );
+      } catch (err) {
+        printLLMError(err, `Step: ${step.title}`);
+        continue;
+      }
+      if (r.text?.trim()) console.log(renderHTMLMarkdown(r.text));
+
+      // Auto-approve and apply this step's staged changes immediately to disk
+      // so the next step's list_files sees the real files
+      const pending = tracker.getPendingMutations();
+      for (const a of pending) tracker.updateStatus(a.id, 'approved', true);
+      const { errors } = executor.applyApprovedFromTracker();
+      executor.clearStaging();
+      if (errors.length) {
+        allErrors.push(...errors.map(e => `[${step.title}] ${e}`));
+        console.log(chalk.yellow(`  ⚠ ${errors.length} error(s) applying step — continuing`));
+      } else {
+        console.log(chalk.green(`  ✓ Step ${stepIdx + 1} applied to disk\n`));
+      }
+
+      // Re-detect project dir now that files are on disk
+      projectDir = detectProjectDir(config.codebasePath, projectDir);
+    }
+
+    if (allErrors.length) {
+      console.log(chalk.red('\nErrors during execution:'));
+      for (const e of allErrors) console.log(chalk.red(`  • ${e}`));
+    } else {
+      console.log(chalk.green('\n✓ All steps applied.\n'));
+    }
+  }
+}