interference-agent 0.1.0

package/src/tools/task.ts

@@ -0,0 +1,71 @@
+import { tool, type ModelMessage } from "ai";
+import { z } from "zod";
+import { getSubagent } from "../agent/subagent.ts";
+import { runTurn } from "../agent/loop.ts";
+import { currentMode } from "../config.ts";
+import { decide } from "../permissions.ts";
+
+export const task = tool({
+  description:
+    "Launch a new subagent to handle complex, multistep tasks autonomously. " +
+    "Use this when you need to delegate research or code exploration to an isolated agent. " +
+    "The subagent runs with its own context and returns a condensed result. " +
+    "Available types: 'explore' (read-only) for searching and understanding code, " +
+    "'general' (full access) for multi-step tasks.",
+  inputSchema: z.object({
+    description: z.string().describe("A short (3-5 words) description of the task"),
+    prompt: z.string().describe("The task for the subagent to perform"),
+    subagent_type: z.enum(["explore", "general"]).describe("The type of subagent to use"),
+    task_id: z
+      .string()
+      .optional()
+      .describe("Resume a previous subagent session by ID"),
+  }),
+  execute: async ({ description, prompt, subagent_type, task_id }) => {
+    const def = getSubagent(subagent_type);
+    if (!def) {
+      return `<task type="${subagent_type}" state="error">Unknown subagent type: ${subagent_type}</task>`;
+    }
+
+    const permissionCheck = decide("task", subagent_type);
+    if (permissionCheck === "deny") {
+      return `<task type="${subagent_type}" state="error">Task denied by permission policy</task>`;
+    }
+
+    const mode = currentMode();
+    if (mode === "plan" && subagent_type === "general") {
+      return `<task type="${subagent_type}" state="error">Cannot run 'general' subagent in Plan mode. Switch to Build mode first.</task>`;
+    }
+
+    const messages: ModelMessage[] = [
+      {
+        role: "user",
+        content: `Task: ${description}\n\n${prompt}`,
+      },
+    ];
+
+    try {
+      let output = "";
+      const chunks = runTurn(messages, undefined, mode, undefined, def.systemPrompt);
+
+      for await (const chunk of chunks) {
+        if (chunk.type === "text") {
+          output += chunk.text;
+        }
+      }
+
+      const id = task_id ?? `${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+      const result = output.slice(0, 4000);
+      const truncated = output.length > 4000 ? " [truncated]" : "";
+
+      return (
+        `<task id="${id}" type="${subagent_type}" state="completed">\n` +
+        `<task_result>${result}${truncated}</task_result>\n` +
+        `</task>`
+      );
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return `<task type="${subagent_type}" state="error">${msg}</task>`;
+    }
+  },
+});

package/src/tools/todowrite.ts

@@ -0,0 +1,84 @@
+import { tool } from "ai";
+import { z } from "zod";
+
+export type TodoStatus = "pending" | "in_progress" | "completed" | "cancelled";
+export type TodoPriority = "high" | "medium" | "low";
+
+export interface Todo {
+  content: string;
+  status: TodoStatus;
+  priority?: TodoPriority;
+}
+
+// Stato osservabile della task list (RF-TOOL pattern: tool senza filesystem).
+// La TUI/CLI si iscrive con subscribeTodos per renderizzare i progressi in tempo reale;
+// la sessione lo persiste con getTodos()/setTodos().
+let currentTodos: Todo[] = [];
+const listeners = new Set<(todos: Todo[]) => void>();
+
+export function getTodos(): Todo[] {
+  return currentTodos;
+}
+
+export function setTodos(todos: Todo[]): void {
+  currentTodos = todos;
+  for (const cb of listeners) cb(currentTodos);
+}
+
+export function resetTodos(): void {
+  setTodos([]);
+}
+
+export function subscribeTodos(cb: (todos: Todo[]) => void): () => void {
+  listeners.add(cb);
+  return () => listeners.delete(cb);
+}
+
+const MARKER: Record<TodoStatus, string> = {
+  pending: "[ ]",
+  in_progress: "[~]",
+  completed: "[x]",
+  cancelled: "[-]",
+};
+
+function render(todos: Todo[]): string {
+  if (todos.length === 0) return "Todo list cleared.";
+  const lines = todos.map((t) => {
+    const prio = t.priority && t.priority !== "medium" ? ` (${t.priority})` : "";
+    return `${MARKER[t.status]} ${t.content}${prio}`;
+  });
+  const done = todos.filter((t) => t.status === "completed").length;
+  return `Todos updated (${done}/${todos.length} done):\n${lines.join("\n")}`;
+}
+
+export const todowrite = tool({
+  description:
+    "Maintain a structured task list for the current work. Replaces the entire list on each call. " +
+    "Use it for non-trivial work (3+ distinct steps): create the plan up front, then update statuses " +
+    "in real time as you progress. Keep exactly ONE task 'in_progress' at a time; mark a task " +
+    "'completed' immediately when it is done before starting the next. Skip it for trivial or single-step tasks.",
+  inputSchema: z.object({
+    todos: z
+      .array(
+        z.object({
+          content: z.string().min(1).describe("Short imperative description of the task"),
+          status: z
+            .enum(["pending", "in_progress", "completed", "cancelled"])
+            .describe("Current status of the task"),
+          priority: z
+            .enum(["high", "medium", "low"])
+            .optional()
+            .describe("Optional priority of the task"),
+        }),
+      )
+      .describe("The full task list (replaces any previous list)"),
+  }),
+  execute: async ({ todos }) => {
+    const inProgress = todos.filter((t) => t.status === "in_progress").length;
+    if (inProgress > 1) {
+      return `Error: only one task may be 'in_progress' at a time (got ${inProgress}). Set the others to 'pending'.`;
+    }
+    setTodos(todos);
+    return render(todos);
+  },
+});

package/src/tools/webfetch.ts

@@ -0,0 +1,111 @@
+import { tool } from "ai";
+import { z } from "zod";
+
+const OUTPUT_CAP = 20_000;
+const TIMEOUT_MS = 15_000;
+
+export const webfetch = tool({
+  description:
+    "Fetch content from a URL and return it as text. " +
+    "Use this to read documentation, check API references, or research external resources. " +
+    "Returns the text content of the page (HTML stripped).",
+  inputSchema: z.object({
+    url: z.string().describe("The URL to fetch. Must be a fully-formed valid URL (http/https)."),
+    timeout: z
+      .number()
+      .int()
+      .min(1_000)
+      .max(60_000)
+      .optional()
+      .describe("Timeout in milliseconds (default: 15000)"),
+  }),
+  execute: async ({ url, timeout }) => {
+    const ms = timeout ?? TIMEOUT_MS;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), ms);
+
+    try {
+      const response = await fetch(url, {
+        signal: controller.signal,
+        headers: {
+          "User-Agent": "interference/0.1 (+https://github.com/ricciviero/interference)",
+          Accept: "text/html, text/plain, */*",
+        },
+      });
+      clearTimeout(timer);
+
+      if (!response.ok) {
+        return `Error fetching URL: ${response.status} ${response.statusText}`;
+      }
+
+      const contentType = response.headers.get("content-type") ?? "";
+      const isHtml = contentType.includes("text/html") || contentType.includes("application/xhtml");
+
+      if (isHtml) {
+        const html = await response.text();
+        const text = stripHtml(html);
+        if (text.length === 0) return "Fetched page but no text content extracted.";
+        return truncate(text, OUTPUT_CAP, url);
+      }
+
+      const text = await response.text();
+      if (text.length === 0) return "Fetched empty response.";
+      return truncate(text, OUTPUT_CAP, url);
+    } catch (err) {
+      clearTimeout(timer);
+      if (err instanceof DOMException && err.name === "AbortError") {
+        return `Fetch timed out after ${ms}ms for URL: ${url}`;
+      }
+      const msg = err instanceof Error ? err.message : String(err);
+      return `Error fetching URL: ${msg}`;
+    }
+  },
+});
+
+function stripHtml(html: string): string {
+  let text = html
+    .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "")
+    .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "")
+    .replace(/<noscript[^>]*>[\s\S]*?<\/noscript>/gi, "")
+    .replace(/<head[^>]*>[\s\S]*?<\/head>/gi, "")
+    .replace(/<header[^>]*>[\s\S]*?<\/header>/gi, "")
+    .replace(/<nav[^>]*>[\s\S]*?<\/nav>/gi, "")
+    .replace(/<footer[^>]*>[\s\S]*?<\/footer>/gi, "")
+    .replace(/<svg[^>]*>[\s\S]*?<\/svg>/gi, "");
+
+  text = text
+    .replace(/<br\s*\/?>/gi, "\n")
+    .replace(/<\/p>/gi, "\n\n")
+    .replace(/<\/h[1-6]>/gi, "\n\n")
+    .replace(/<\/li>/gi, "\n")
+    .replace(/<\/div>/gi, "\n")
+    .replace(/<\/tr>/gi, "\n")
+    .replace(/<\/pre>/gi, "\n");
+
+  text = text.replace(/<[^>]+>/g, "");
+
+  text = text
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&nbsp;/g, " ")
+    .replace(/&#(\d+);/g, (_, n) => String.fromCharCode(Number.parseInt(n)))
+    .replace(/&#x([0-9a-f]+);/gi, (_, n) => String.fromCharCode(Number.parseInt(n, 16)));
+
+  text = text
+    .split("\n")
+    .map((l) => l.trim())
+    .filter((l) => l.length > 0)
+    .join("\n");
+
+  return text.trim();
+}
+
+function truncate(text: string, cap: number, url: string): string {
+  if (text.length <= cap) return text;
+  const truncated = text.slice(0, cap);
+  const originalSize = `${(text.length / 1024).toFixed(1)}K`;
+  return `${truncated}\n\n… [truncated from ${originalSize}, original: ${url}]`;
+}

package/src/tools/write.ts

@@ -0,0 +1,51 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { resolveInWorkspace } from "./_fs.ts";
+import { decide, requestConfirmation } from "../permissions.ts";
+import { snapshotFile } from "../session/snapshot.ts";
+import { mkdir } from "node:fs/promises";
+import * as path from "node:path";
+
+const OUTPUT_CAP = 10_000;
+
+export const write = tool({
+  description:
+    "Create or overwrite a file in the workspace. " +
+    "Use this to create new files from scratch. " +
+    "Prefer `edit` for small targeted changes to existing files.",
+  inputSchema: z.object({
+    path: z.string().describe("Path to the file, relative to workspace root"),
+    content: z.string().describe("The full content to write to the file"),
+  }),
+  execute: async ({ path: filePath, content }) => {
+    const abs = resolveInWorkspace(filePath);
+    const rel = path.relative(process.cwd(), abs) || abs;
+
+    const decision = decide("write", filePath);
+    if (decision === "deny") {
+      return `Error: write denied by policy for '${rel}'`;
+    }
+    if (decision === "ask") {
+      const preview = generateWritePreview(abs, content);
+      const allowed = await requestConfirmation("write", preview);
+      if (!allowed) {
+        return `Write refused by user for '${rel}'`;
+      }
+    }
+
+    await snapshotFile(filePath);
+    await mkdir(path.dirname(abs), { recursive: true });
+    await Bun.write(abs, content);
+
+    const truncated = content.length > OUTPUT_CAP ? " [content truncated]" : "";
+    return `Wrote ${rel} (${content.length} chars)${truncated}`;
+  },
+});
+
+function generateWritePreview(abs: string, content: string): string {
+  const name = path.relative(process.cwd(), abs) || abs;
+  const preview = content.length > 500 ? content.slice(0, 500) + "\n… [truncated preview]" : content;
+  const exists = Bun.file(abs);
+  const action = exists.size > 0 ? "Overwrite" : "Create";
+  return `[write] ${action}: ${name}\n---\n${preview}\n---`;
+}