ashlrcode 1.0.0

package/src/tools/web-browser.ts

@@ -0,0 +1,263 @@
+/**
+ * WebBrowserTool — headless browser automation for JavaScript-heavy pages.
+ * Uses Puppeteer (if installed) for full browser rendering.
+ * Fallback: errors with install instructions.
+ *
+ * Gated behind BROWSER_TOOL feature flag.
+ */
+
+import type { Tool, ToolContext } from "./types.ts";
+
+interface BrowserResult {
+  title: string;
+  url: string;
+  text: string;
+  links: Array<{ text: string; href: string }>;
+  screenshot?: string; // base64
+}
+
+async function getPuppeteer(): Promise<any | null> {
+  try {
+    // Dynamic import — puppeteer may not be installed
+    // @ts-expect-error — optional peer dependency
+    return await import("puppeteer");
+  } catch {
+    try {
+      // @ts-expect-error — optional peer dependency
+      return await import("puppeteer-core");
+    } catch {
+      return null;
+    }
+  }
+}
+
+async function findChromePath(): Promise<string | null> {
+  const paths =
+    process.platform === "darwin"
+      ? [
+          "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+          "/Applications/Chromium.app/Contents/MacOS/Chromium",
+        ]
+      : process.platform === "linux"
+        ? ["/usr/bin/google-chrome", "/usr/bin/chromium-browser", "/usr/bin/chromium"]
+        : [
+            "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+            "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+          ];
+
+  const { existsSync } = await import("fs");
+  for (const p of paths) {
+    if (existsSync(p)) return p;
+  }
+  return null;
+}
+
+let _browser: any = null;
+
+async function getBrowser(): Promise<any> {
+  if (_browser?.isConnected?.()) return _browser;
+  _browser = null;
+
+  const puppeteer = await getPuppeteer();
+  if (!puppeteer) {
+    throw new Error("Puppeteer not installed. Run: bun add puppeteer");
+  }
+
+  const chromePath = await findChromePath();
+  _browser = await puppeteer.launch({
+    headless: "new",
+    executablePath: chromePath ?? undefined,
+    args: ["--no-sandbox", "--disable-setuid-sandbox", "--disable-dev-shm-usage"],
+  });
+
+  return _browser;
+}
+
+async function browsePage(
+  url: string,
+  action: string,
+  selector?: string,
+  value?: string,
+  waitMs?: number
+): Promise<BrowserResult> {
+  const browser = await getBrowser();
+  const page = await browser.newPage();
+
+  try {
+    await page.setViewport({ width: 1280, height: 720 });
+    await page.setUserAgent(
+      "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AshlrCode/1.0"
+    );
+
+    await page.goto(url, { waitUntil: "networkidle2", timeout: 30_000 });
+
+    if (waitMs) await page.waitForTimeout(waitMs);
+
+    switch (action) {
+      case "read":
+        break; // Just read the page
+      case "click":
+        if (selector) {
+          await page.waitForSelector(selector, { timeout: 5000 });
+          await page.click(selector);
+          await page.waitForTimeout(1000);
+        }
+        break;
+      case "type":
+        if (selector && value) {
+          await page.waitForSelector(selector, { timeout: 5000 });
+          await page.type(selector, value);
+        }
+        break;
+      case "screenshot": {
+        const screenshotBuffer = await page.screenshot({ encoding: "base64" });
+        return {
+          title: await page.title(),
+          url: page.url(),
+          text: "",
+          links: [],
+          screenshot: screenshotBuffer as string,
+        };
+      }
+    }
+
+    // Extract page content after JS has rendered.
+    // The callback runs inside the browser context (Puppeteer serializes it),
+    // so DOM globals like `document` exist at runtime but not in our TS lib.
+    const result: { title: string; text: string; links: Array<{ text: string; href: string }> } =
+      await page.evaluate(`
+        (() => {
+          const title = document.title;
+          const bodyText = (document.body && document.body.innerText || "").slice(0, 10000);
+          const links = Array.from(document.querySelectorAll("a[href]"))
+            .slice(0, 20)
+            .map(a => ({
+              text: (a.textContent || "").trim().slice(0, 50),
+              href: a.href,
+            }));
+          return { title, text: bodyText, links };
+        })()
+      `);
+
+    return { ...result, url: page.url() };
+  } finally {
+    await page.close();
+  }
+}
+
+export const webBrowserTool: Tool = {
+  name: "WebBrowser",
+
+  prompt() {
+    return `Browse web pages with full JavaScript rendering. Use for:
+- Reading JavaScript-heavy SPAs that WebFetch can't handle
+- Clicking buttons and filling forms
+- Taking screenshots of web pages
+- Extracting text from dynamically-rendered content
+
+Requires Puppeteer (bun add puppeteer). Actions: read, click, type, screenshot.`;
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "URL to navigate to" },
+        action: {
+          type: "string",
+          enum: ["read", "click", "type", "screenshot"],
+          description: "Action to perform on the page",
+        },
+        selector: {
+          type: "string",
+          description: "CSS selector for click/type actions",
+        },
+        value: {
+          type: "string",
+          description: "Text to type (for type action)",
+        },
+        waitMs: {
+          type: "number",
+          description: "Extra wait time in ms after page load",
+        },
+      },
+      required: ["url", "action"],
+    };
+  },
+
+  isReadOnly() {
+    return true;
+  },
+  isDestructive() {
+    return false;
+  },
+  isConcurrencySafe() {
+    return false;
+  },
+
+  validateInput(input) {
+    if (!input.url || typeof input.url !== "string") return "url is required";
+    if (!input.action || typeof input.action !== "string") return "action is required";
+
+    const validActions = ["read", "click", "type", "screenshot"];
+    if (!validActions.includes(input.action as string)) {
+      return `Invalid action: ${input.action}. Must be one of: ${validActions.join(", ")}`;
+    }
+
+    try {
+      new URL(input.url as string);
+    } catch {
+      return "Invalid URL";
+    }
+
+    if (input.action === "click" && !input.selector) {
+      return "selector is required for click action";
+    }
+    if (input.action === "type" && (!input.selector || !input.value)) {
+      return "selector and value are required for type action";
+    }
+
+    return null;
+  },
+
+  async call(input, _context) {
+    const url = input.url as string;
+    const action = input.action as string;
+    const selector = input.selector as string | undefined;
+    const value = input.value as string | undefined;
+    const waitMs = input.waitMs as number | undefined;
+
+    try {
+      const result = await browsePage(url, action, selector, value, waitMs);
+
+      if (result.screenshot) {
+        return `Screenshot captured (base64, ${result.screenshot.length} chars)\nTitle: ${result.title}\nURL: ${result.url}`;
+      }
+
+      const lines: string[] = [];
+      lines.push(`Title: ${result.title}`);
+      lines.push(`URL: ${result.url}`);
+      lines.push("");
+      lines.push(result.text.slice(0, 8000));
+
+      if (result.links.length > 0) {
+        lines.push("\nLinks:");
+        for (const link of result.links.slice(0, 10)) {
+          lines.push(`  [${link.text}](${link.href})`);
+        }
+      }
+
+      return lines.join("\n");
+    } catch (err) {
+      return `Browser error: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  },
+};
+
+/** Gracefully shut down the shared browser instance. */
+export async function shutdownBrowser(): Promise<void> {
+  if (_browser) {
+    await _browser.close().catch(() => {});
+    _browser = null;
+  }
+}

package/src/tools/web-fetch.ts

@@ -0,0 +1,118 @@
+/**
+ * WebFetch tool — HTTP requests for research and exploration.
+ */
+
+import type { Tool, ToolContext } from "./types.ts";
+
+const MAX_RESPONSE_SIZE = 50_000; // chars
+
+export const webFetchTool: Tool = {
+  name: "WebFetch",
+
+  prompt() {
+    return "Fetch a URL and return its content. Useful for reading documentation, APIs, or web pages. Returns text content, truncated if too large.";
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The URL to fetch",
+        },
+        method: {
+          type: "string",
+          enum: ["GET", "POST", "PUT", "DELETE"],
+          description: "HTTP method (default: GET)",
+        },
+        headers: {
+          type: "object",
+          description: "Additional HTTP headers",
+        },
+        body: {
+          type: "string",
+          description: "Request body (for POST/PUT)",
+        },
+      },
+      required: ["url"],
+    };
+  },
+
+  isReadOnly() {
+    return true;
+  },
+  isDestructive() {
+    return false;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+
+  validateInput(input) {
+    if (!input.url || typeof input.url !== "string") {
+      return "url is required";
+    }
+    try {
+      new URL(input.url as string);
+    } catch {
+      return "Invalid URL";
+    }
+    return null;
+  },
+
+  async call(input, _context) {
+    const url = input.url as string;
+    const method = (input.method as string) ?? "GET";
+    const headers = (input.headers as Record<string, string>) ?? {};
+    const body = input.body as string | undefined;
+
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: {
+          "User-Agent": "AshlrCode/0.1.0",
+          ...headers,
+        },
+        body: method !== "GET" ? body : undefined,
+        signal: AbortSignal.timeout(30_000),
+      });
+
+      const contentType = response.headers.get("content-type") ?? "";
+      const status = response.status;
+
+      let text = await response.text();
+
+      // Truncate if too large
+      if (text.length > MAX_RESPONSE_SIZE) {
+        text =
+          text.slice(0, MAX_RESPONSE_SIZE) +
+          `\n\n[... truncated at ${MAX_RESPONSE_SIZE} chars, total: ${text.length} chars]`;
+      }
+
+      // Strip HTML tags for readability if it's HTML
+      if (contentType.includes("text/html")) {
+        text = stripHtml(text);
+      }
+
+      return `HTTP ${status} ${response.statusText}\nContent-Type: ${contentType}\n\n${text}`;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return `Fetch error: ${message}`;
+    }
+  },
+};
+
+function stripHtml(html: string): string {
+  return html
+    .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "")
+    .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "")
+    .replace(/<[^>]+>/g, " ")
+    .replace(/\s{2,}/g, " ")
+    .replace(/&nbsp;/g, " ")
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .trim();
+}

package/src/tools/web-search.ts

@@ -0,0 +1,107 @@
+/**
+ * WebSearch tool — search the web using DuckDuckGo HTML API.
+ */
+
+import type { Tool, ToolContext } from "./types.ts";
+
+export const webSearchTool: Tool = {
+  name: "WebSearch",
+
+  prompt() {
+    return "Search the web and return top results with titles, URLs, and snippets. Uses DuckDuckGo.";
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Search query",
+        },
+        maxResults: {
+          type: "number",
+          description: "Maximum number of results (default: 5)",
+        },
+      },
+      required: ["query"],
+    };
+  },
+
+  isReadOnly() {
+    return true;
+  },
+  isDestructive() {
+    return false;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+
+  validateInput(input) {
+    if (!input.query || typeof input.query !== "string") {
+      return "query is required";
+    }
+    return null;
+  },
+
+  async call(input, _context) {
+    const query = input.query as string;
+    const maxResults = (input.maxResults as number) ?? 5;
+
+    try {
+      // Use DuckDuckGo HTML search (no API key needed)
+      const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+      const response = await fetch(url, {
+        headers: {
+          "User-Agent": "AshlrCode/1.0",
+        },
+        signal: AbortSignal.timeout(15_000),
+      });
+
+      const html = await response.text();
+
+      // Extract results from DDG HTML
+      const results = extractDDGResults(html, maxResults);
+
+      if (results.length === 0) {
+        return `No results found for: "${query}"`;
+      }
+
+      return results
+        .map((r, i) => `${i + 1}. **${r.title}**\n   ${r.url}\n   ${r.snippet}`)
+        .join("\n\n");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return `Search error: ${message}`;
+    }
+  },
+};
+
+interface SearchResult {
+  title: string;
+  url: string;
+  snippet: string;
+}
+
+function extractDDGResults(html: string, max: number): SearchResult[] {
+  const results: SearchResult[] = [];
+
+  // Match result blocks in DDG HTML
+  const resultRegex = /<a[^>]*class="result__a"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a[^>]*class="result__snippet"[^>]*>([\s\S]*?)<\/a>/g;
+
+  let match;
+  while ((match = resultRegex.exec(html)) !== null && results.length < max) {
+    const url = decodeURIComponent(
+      match[1]!.replace(/.*uddg=/, "").replace(/&.*/, "")
+    );
+    const title = match[2]!.replace(/<[^>]+>/g, "").trim();
+    const snippet = match[3]!.replace(/<[^>]+>/g, "").trim();
+
+    if (title && url) {
+      results.push({ title, url, snippet });
+    }
+  }
+
+  return results;
+}

package/src/tools/workflow.ts

@@ -0,0 +1,188 @@
+/**
+ * WorkflowTool — manage and run multi-step automation workflows.
+ * Workflows define a sequence of prompts, shell commands, and tool calls
+ * stored in .ashlrcode/workflows/.
+ */
+
+import type { Tool, ToolContext } from "./types.ts";
+import {
+  listWorkflows,
+  loadWorkflow,
+  deleteWorkflow,
+  createWorkflow,
+  executeWorkflow,
+  markWorkflowRun,
+  type WorkflowStep,
+} from "../agent/workflow.ts";
+
+export const workflowTool: Tool = {
+  name: "Workflow",
+
+  prompt() {
+    return `Manage and run multi-step workflows. Workflows define a sequence of prompts, shell commands, and tool calls that execute in order.
+
+Actions:
+- list: Show all saved workflows
+- run: Execute a workflow by ID
+- create: Define a new workflow with steps
+- delete: Remove a workflow by ID
+
+Each step has a type: "prompt" (send text to the LLM), "command" (run a shell command), or "tool" (invoke a tool by name). Steps run sequentially and halt on failure unless continueOnError is set.`;
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["list", "run", "create", "delete"],
+          description: "What to do",
+        },
+        workflowId: {
+          type: "string",
+          description: "Workflow ID (required for run/delete)",
+        },
+        name: {
+          type: "string",
+          description: "Workflow name (required for create)",
+        },
+        description: {
+          type: "string",
+          description: "Workflow description (for create)",
+        },
+        steps: {
+          type: "array",
+          description:
+            'Array of workflow steps (for create). Each step: { name: string, type: "prompt"|"command"|"tool", value: string, input?: object, continueOnError?: boolean }',
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              type: { type: "string", enum: ["prompt", "command", "tool"] },
+              value: { type: "string" },
+              input: { type: "object" },
+              continueOnError: { type: "boolean" },
+            },
+            required: ["name", "type", "value"],
+          },
+        },
+      },
+      required: ["action"],
+    };
+  },
+
+  isReadOnly() {
+    return false;
+  },
+  isDestructive() {
+    return false;
+  },
+  isConcurrencySafe() {
+    return false;
+  },
+
+  validateInput(input) {
+    const action = input.action as string;
+    if (!action) return "action is required";
+    if (!["list", "run", "create", "delete"].includes(action))
+      return `Invalid action: ${action}`;
+    if ((action === "run" || action === "delete") && !input.workflowId)
+      return "workflowId is required for run/delete";
+    if (action === "create") {
+      if (!input.name) return "name is required for create";
+      if (!input.steps || !Array.isArray(input.steps) || input.steps.length === 0)
+        return "steps array is required for create (must have at least one step)";
+    }
+    return null;
+  },
+
+  async call(input, context) {
+    const action = input.action as string;
+
+    if (action === "list") {
+      const workflows = await listWorkflows();
+      if (workflows.length === 0)
+        return "No workflows found. Create one with action: create.";
+      return workflows
+        .map(
+          (w) =>
+            `${w.id} — ${w.name} (${w.steps.length} steps, run ${w.runCount}x)${w.description ? `\n  ${w.description}` : ""}`,
+        )
+        .join("\n");
+    }
+
+    if (action === "delete") {
+      const ok = await deleteWorkflow(input.workflowId as string);
+      return ok ? "Workflow deleted." : "Workflow not found.";
+    }
+
+    if (action === "create") {
+      const wf = await createWorkflow(
+        input.name as string,
+        (input.description as string) ?? "",
+        input.steps as WorkflowStep[],
+      );
+      return `Workflow "${wf.name}" created (${wf.id}, ${wf.steps.length} steps)`;
+    }
+
+    if (action === "run") {
+      const wf = await loadWorkflow(input.workflowId as string);
+      if (!wf) return "Workflow not found.";
+
+      const result = await executeWorkflow(wf, {
+        // Prompt execution: placeholder — real agent integration would
+        // feed the prompt into the conversation loop
+        runPrompt: async (prompt) =>
+          `[Would execute prompt: ${prompt.slice(0, 200)}]`,
+
+        // Command execution: runs via Bun.spawn
+        runCommand: async (cmd) => {
+          const proc = Bun.spawn(["bash", "-c", cmd], {
+            cwd: context.cwd,
+            stdout: "pipe",
+            stderr: "pipe",
+          });
+          const stdout = await new Response(proc.stdout).text();
+          const stderr = await new Response(proc.stderr).text();
+          const exitCode = await proc.exited;
+          const output = (stdout + (stderr ? `\n${stderr}` : "")).trim();
+          return { output, exitCode };
+        },
+
+        // Tool execution: placeholder — real integration would dispatch
+        // through the ToolRegistry
+        runTool: async (name, toolInput) => {
+          return {
+            result: `[Would call tool: ${name} with ${JSON.stringify(toolInput).slice(0, 200)}]`,
+            isError: false,
+          };
+        },
+
+        onStepStart: (step, i) => {
+          console.log(
+            `  Step ${i + 1}/${wf.steps.length}: ${step.name} (${step.type})`,
+          );
+        },
+        onStepEnd: (_step, _i, success, _output) => {
+          console.log(`  ${success ? "OK" : "FAIL"}: ${_step.name}`);
+        },
+      });
+
+      await markWorkflowRun(wf.id);
+
+      const lines = [
+        `Workflow: ${result.workflow}`,
+        `Steps: ${result.stepsCompleted}/${result.stepsTotal}`,
+        `Duration: ${result.durationMs}ms`,
+        "",
+      ];
+      for (const r of result.results) {
+        lines.push(`${r.success ? "[OK]" : "[FAIL]"} ${r.step}: ${r.output.slice(0, 200)}`);
+      }
+      return lines.join("\n");
+    }
+
+    return `Unknown action: ${action}`;
+  },
+};