verybot 0.1.8

package/dist/tools/fs.js

@@ -0,0 +1,335 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { readFile, writeFile, mkdir, readdir } from "fs/promises";
+import { execSync } from "child_process";
+import { dirname, resolve } from "path";
+import { sanitizeEnv } from "../security/env-filter.js";
+import { logger } from "../logger.js";
+/* ------------------------------------------------------------------ */
+/*  Constants                                                          */
+/* ------------------------------------------------------------------ */
+const MAX_OUTPUT = 10_000;
+const DEFAULT_LINE_LIMIT = 2_000;
+const DEFAULT_SEARCH_LIMIT = 200;
+const EXEC_TIMEOUT = 15_000;
+/* ------------------------------------------------------------------ */
+/*  Helpers                                                            */
+/* ------------------------------------------------------------------ */
+function sliceLines(text, offset, limit) {
+    const lines = text.split("\n");
+    const start = Math.max(0, offset);
+    const end = Math.min(lines.length, start + limit);
+    return lines
+        .slice(start, end)
+        .map((line, i) => `${start + i + 1}\t${line}`)
+        .join("\n");
+}
+function truncate(text, max = MAX_OUTPUT) {
+    if (text.length <= max)
+        return text;
+    return text.slice(0, max) + "\n…[truncated]";
+}
+/** Truncate output to N lines (for limiting search results in JS). */
+function truncateLines(text, maxLines) {
+    const lines = text.split("\n");
+    if (lines.length <= maxLines)
+        return text;
+    return lines.slice(0, maxLines).join("\n") + "\n…[truncated]";
+}
+let rgAvailable = null;
+function isRipgrepAvailable() {
+    if (rgAvailable === null) {
+        try {
+            execSync("rg --version", { stdio: "ignore", timeout: 3_000 });
+            rgAvailable = true;
+        }
+        catch {
+            rgAvailable = false;
+        }
+    }
+    return rgAvailable;
+}
+function shellEscape(arg) {
+    if (arg.includes("\0")) {
+        throw new Error("Null bytes not allowed in shell arguments");
+    }
+    return `'${arg.replace(/'/g, "'\\''")}'`;
+}
+/* ------------------------------------------------------------------ */
+/*  Tools                                                              */
+/* ------------------------------------------------------------------ */
+const readTool = tool({
+    description: "Read a file from the filesystem. Returns numbered lines. " +
+        "Use offset/limit for large files.",
+    inputSchema: z.object({
+        path: z.string().describe("Absolute or relative file path"),
+        offset: z
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe("0-based line offset to start reading from"),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe("Max number of lines to return"),
+    }),
+    execute: async ({ path, offset, limit }) => {
+        try {
+            const content = await readFile(resolve(path), "utf-8");
+            const lineOffset = offset ?? 0;
+            const lineLimit = limit ?? DEFAULT_LINE_LIMIT;
+            return truncate(sliceLines(content, lineOffset, lineLimit));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.warn(`read failed: ${msg}`);
+            return `Error: ${msg}`;
+        }
+    },
+});
+const writeTool = tool({
+    description: "Write content to a file. Creates parent directories if needed. " +
+        "Overwrites existing files.",
+    inputSchema: z.object({
+        path: z.string().describe("Absolute or relative file path"),
+        content: z.string().describe("File content to write"),
+    }),
+    execute: async ({ path, content }) => {
+        try {
+            const resolved = resolve(path);
+            await mkdir(dirname(resolved), { recursive: true });
+            await writeFile(resolved, content, "utf-8");
+            return `Wrote ${content.split("\n").length} lines to ${resolved}`;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.warn(`write failed: ${msg}`);
+            return `Error: ${msg}`;
+        }
+    },
+});
+const editTool = tool({
+    description: "Edit a file by replacing an exact text match. " +
+        "oldText must appear exactly once in the file.",
+    inputSchema: z.object({
+        path: z.string().describe("Absolute or relative file path"),
+        oldText: z.string().min(1).describe("Exact text to find (must be unique in file)"),
+        newText: z.string().describe("Replacement text"),
+    }),
+    execute: async ({ path, oldText, newText }) => {
+        try {
+            const resolved = resolve(path);
+            const content = await readFile(resolved, "utf-8");
+            const occurrences = content.split(oldText).length - 1;
+            if (occurrences === 0) {
+                return "Error: oldText not found in file";
+            }
+            if (occurrences > 1) {
+                return `Error: oldText found ${occurrences} times — must be unique. Provide more surrounding context.`;
+            }
+            // Use function replacement to avoid special pattern interpretation ($&, $`, etc.)
+            const updated = content.replace(oldText, () => newText);
+            await writeFile(resolved, updated, "utf-8");
+            return `Edited ${resolved} — replaced 1 occurrence`;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.warn(`edit failed: ${msg}`);
+            return `Error: ${msg}`;
+        }
+    },
+});
+const grepTool = tool({
+    description: "Search file contents using ripgrep (rg) or grep. " +
+        "Returns matching lines with file paths and line numbers.",
+    inputSchema: z.object({
+        pattern: z.string().describe("Search pattern (regex unless literal=true)"),
+        path: z
+            .string()
+            .optional()
+            .describe("Directory or file to search (default: cwd)"),
+        glob: z
+            .string()
+            .optional()
+            .describe("File glob filter, e.g. '*.ts'"),
+        ignoreCase: z
+            .boolean()
+            .optional()
+            .describe("Case-insensitive search"),
+        literal: z
+            .boolean()
+            .optional()
+            .describe("Treat pattern as literal string, not regex"),
+        context: z
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe("Lines of context around each match"),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe("Max number of result lines to return"),
+    }),
+    execute: async ({ pattern, path, glob: fileGlob, ignoreCase, literal, context, limit }) => {
+        const searchPath = resolve(path ?? ".");
+        const maxLines = limit ?? DEFAULT_SEARCH_LIMIT;
+        try {
+            let cmd;
+            if (isRipgrepAvailable()) {
+                const args = ["rg", "--no-heading", "-n"];
+                if (ignoreCase)
+                    args.push("-i");
+                if (literal)
+                    args.push("-F");
+                if (context)
+                    args.push("-C", String(context));
+                if (fileGlob)
+                    args.push("--glob", fileGlob);
+                args.push("--", pattern, searchPath);
+                cmd = args.map(shellEscape).join(" ");
+            }
+            else {
+                const args = ["grep", "-rn"];
+                if (ignoreCase)
+                    args.push("-i");
+                if (literal)
+                    args.push("-F");
+                if (context)
+                    args.push("-C", String(context));
+                if (fileGlob)
+                    args.push("--include", fileGlob);
+                args.push("--", pattern, searchPath);
+                cmd = args.map(shellEscape).join(" ");
+            }
+            const output = execSync(cmd, {
+                encoding: "utf-8",
+                timeout: EXEC_TIMEOUT,
+                maxBuffer: 2 * 1024 * 1024,
+                env: sanitizeEnv(),
+            });
+            return truncate(truncateLines(output || "No matches found", maxLines));
+        }
+        catch (err) {
+            // grep/rg exit code 1 = no matches (not an error)
+            const code = err.status;
+            if (code === 1)
+                return "No matches found";
+            const stderr = err.stderr ?? "";
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.warn(`grep failed: ${msg}`);
+            return `Error: ${stderr || msg}`.slice(0, MAX_OUTPUT);
+        }
+    },
+});
+const findTool = tool({
+    description: "Find files by name pattern. Uses the system `find` command. " +
+        "Returns matching file paths.",
+    inputSchema: z.object({
+        pattern: z
+            .string()
+            .describe("Filename glob pattern, e.g. '*.ts' or 'index.*'"),
+        path: z
+            .string()
+            .optional()
+            .describe("Directory to search in (default: cwd)"),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe("Max number of results"),
+    }),
+    execute: async ({ pattern, path, limit }) => {
+        const searchPath = resolve(path ?? ".");
+        const maxResults = limit ?? DEFAULT_SEARCH_LIMIT;
+        try {
+            const cmd = [
+                "find",
+                shellEscape(searchPath),
+                "-name",
+                shellEscape(pattern),
+                "-not",
+                "-path",
+                shellEscape("*/node_modules/*"),
+                "-not",
+                "-path",
+                shellEscape("*/.git/*"),
+            ].join(" ");
+            const output = execSync(cmd, {
+                encoding: "utf-8",
+                timeout: EXEC_TIMEOUT,
+                maxBuffer: 2 * 1024 * 1024,
+                env: sanitizeEnv(),
+            });
+            return truncate(truncateLines(output || "No files found", maxResults));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.warn(`find failed: ${msg}`);
+            return `Error: ${msg}`.slice(0, MAX_OUTPUT);
+        }
+    },
+});
+const lsTool = tool({
+    description: "List directory contents with type indicators. " +
+        "Directories end with /, symlinks with @.",
+    inputSchema: z.object({
+        path: z
+            .string()
+            .optional()
+            .describe("Directory to list (default: cwd)"),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe("Max number of entries to return"),
+    }),
+    execute: async ({ path, limit }) => {
+        const dirPath = resolve(path ?? ".");
+        const maxEntries = limit ?? DEFAULT_SEARCH_LIMIT;
+        try {
+            const entries = await readdir(dirPath, { withFileTypes: true });
+            const lines = entries.slice(0, maxEntries).map((entry) => {
+                if (entry.isDirectory())
+                    return `${entry.name}/`;
+                if (entry.isSymbolicLink())
+                    return `${entry.name}@`;
+                return entry.name;
+            });
+            if (entries.length > maxEntries) {
+                lines.push(`…and ${entries.length - maxEntries} more`);
+            }
+            return lines.join("\n") || "(empty directory)";
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.warn(`ls failed: ${msg}`);
+            return `Error: ${msg}`;
+        }
+    },
+});
+/* ------------------------------------------------------------------ */
+/*  Export                                                             */
+/* ------------------------------------------------------------------ */
+const SANDBOX_ERROR = "Error: This tool is disabled in sandbox mode. Use bash instead (cat, tee, grep, find, ls).";
+function sandboxGuard(t) {
+    return { ...t, execute: async () => SANDBOX_ERROR };
+}
+export function createFsTools(opts) {
+    const wrap = opts?.sandboxed ? sandboxGuard : (t) => t;
+    return {
+        read: wrap(readTool),
+        write: wrap(writeTool),
+        edit: wrap(editTool),
+        grep: wrap(grepTool),
+        find: wrap(findTool),
+        ls: wrap(lsTool),
+    };
+}

package/dist/tools/integration-toggle.d.ts

@@ -0,0 +1,14 @@
+import type { IntegrationRegistry } from "../integrations/registry.js";
+/**
+ * Create enable_integration and disable_integration tools.
+ * These mutate the session's active integrations set so that
+ * subsequent runs include/exclude the integration tools.
+ */
+export declare function createIntegrationToggleTools(registry: IntegrationRegistry, activeIntegrations: Set<string>): {
+    enable_integration: import("ai").Tool<{
+        name: string;
+    }, string>;
+    disable_integration: import("ai").Tool<{
+        name: string;
+    }, string>;
+};

package/dist/tools/integration-toggle.js

@@ -0,0 +1,47 @@
+import { tool } from "ai";
+import { z } from "zod";
+/**
+ * Create enable_integration and disable_integration tools.
+ * These mutate the session's active integrations set so that
+ * subsequent runs include/exclude the integration tools.
+ */
+export function createIntegrationToggleTools(registry, activeIntegrations) {
+    const available = registry.names;
+    const availableList = available.join(", ");
+    const enableIntegration = tool({
+        description: `Enable an integration for this session. Available: ${availableList}. ` +
+            `Once enabled, the integration's tools will be available in subsequent messages.`,
+        inputSchema: z.object({
+            name: z.string().describe("Integration name to enable"),
+        }),
+        execute: async ({ name }) => {
+            const normalized = name.toLowerCase();
+            if (!registry.has(normalized)) {
+                return `Unknown integration "${name}". Available: ${availableList}`;
+            }
+            if (activeIntegrations.has(normalized)) {
+                return `Integration "${normalized}" is already enabled.`;
+            }
+            activeIntegrations.add(normalized);
+            const integration = registry.get(normalized);
+            const toolNames = Object.keys(integration.tools.tools).join(", ");
+            return `Integration "${normalized}" enabled. Tools now available: ${toolNames}`;
+        },
+    });
+    const disableIntegration = tool({
+        description: `Disable an integration for this session. ` +
+            `Once disabled, the integration's tools will no longer be available.`,
+        inputSchema: z.object({
+            name: z.string().describe("Integration name to disable"),
+        }),
+        execute: async ({ name }) => {
+            const normalized = name.toLowerCase();
+            if (!activeIntegrations.has(normalized)) {
+                return `Integration "${normalized}" is not currently enabled.`;
+            }
+            activeIntegrations.delete(normalized);
+            return `Integration "${normalized}" disabled.`;
+        },
+    });
+    return { enable_integration: enableIntegration, disable_integration: disableIntegration };
+}

package/dist/tools/memory.d.ts

@@ -0,0 +1,13 @@
+import { type Tool } from "ai";
+import type { MemoryStore } from "../memory/store.js";
+import type { EmbeddingProvider } from "../memory/embedding.js";
+/**
+ * Create a session-scoped memory_search tool.
+ * Called per-run so results are restricted to the current session's memories.
+ */
+export declare function createMemorySearchTool(store: MemoryStore, embeddingProvider: EmbeddingProvider | null, maxResults: number, teamId?: string): Tool;
+/**
+ * Create a session-scoped memory_save tool.
+ * Allows the agent to explicitly persist facts when the user asks to remember something.
+ */
+export declare function createMemorySaveTool(store: MemoryStore, embeddingProvider: EmbeddingProvider | null, sessionKey: string, teamId?: string): Tool;

package/dist/tools/memory.js

@@ -0,0 +1,59 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { searchMemory } from "../memory/search.js";
+import { saveExplicitMemory } from "../memory/explicit.js";
+/**
+ * Create a session-scoped memory_search tool.
+ * Called per-run so results are restricted to the current session's memories.
+ */
+export function createMemorySearchTool(store, embeddingProvider, maxResults, teamId) {
+    return tool({
+        description: "Search long-term memory for facts about this user. " +
+            "ALWAYS call BEFORE responding to personal questions (name, location, preferences, history). " +
+            "Call multiple times with different queries to gather all relevant facts. " +
+            "When in doubt, search — it is fast.",
+        inputSchema: z.object({
+            query: z
+                .string()
+                .describe("What to search for, e.g. 'favorite food' or 'project details'"),
+        }),
+        execute: async ({ query }) => {
+            const facts = await searchMemory(store, query, {
+                limit: maxResults,
+                embeddingProvider,
+                teamId,
+            });
+            if (facts.length === 0)
+                return "No relevant memories found.";
+            return facts.map((f, i) => `${i + 1}. ${f}`).join("\n");
+        },
+    });
+}
+/**
+ * Create a session-scoped memory_save tool.
+ * Allows the agent to explicitly persist facts when the user asks to remember something.
+ */
+export function createMemorySaveTool(store, embeddingProvider, sessionKey, teamId) {
+    return tool({
+        description: "Save a fact about the user to long-term memory. Use this when the user " +
+            "explicitly asks you to remember something, or shares personal information " +
+            "they expect you to retain (name, location, preferences, etc.). " +
+            "Each call saves ONE atomic fact — call multiple times for multiple facts.",
+        inputSchema: z.object({
+            fact: z
+                .string()
+                .describe("A single factual statement to remember, e.g. 'User lives in Singapore' " +
+                "or 'User's favorite food is noodles'"),
+        }),
+        execute: async ({ fact }) => {
+            const { saved, fact: normalizedFact } = await saveExplicitMemory(store, embeddingProvider, {
+                fact,
+                source: sessionKey,
+                teamId,
+            });
+            return saved
+                ? `Saved: "${normalizedFact}"`
+                : `Already known: "${normalizedFact}"`;
+        },
+    });
+}

package/dist/tools/prompt-templates.d.ts

@@ -0,0 +1,7 @@
+import { type ToolSet } from "ai";
+import type { PromptTemplateStore } from "../prompt-templates/store.js";
+/**
+ * Creates AI-facing tools for prompt template management.
+ * Lets the LLM list, read, create, and update prompt templates.
+ */
+export declare function createPromptTemplateTools(store: PromptTemplateStore): ToolSet;

package/dist/tools/prompt-templates.js

@@ -0,0 +1,133 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { emit } from "../events.js";
+const VALID_ROLES = ["orchestrator", "worker"];
+/**
+ * Creates AI-facing tools for prompt template management.
+ * Lets the LLM list, read, create, and update prompt templates.
+ */
+export function createPromptTemplateTools(store) {
+    const listTemplates = tool({
+        description: "List all prompt templates. Returns name, role, and whether each is built-in.",
+        inputSchema: z.object({}),
+        execute: async () => {
+            const templates = store.listPromptTemplates();
+            if (templates.length === 0)
+                return "No prompt templates found.";
+            return templates
+                .map((t) => `[${t.id}] ${t.name} (${t.role}${t.builtin ? ", builtin" : ""}) — ${t.description || "no description"}`)
+                .join("\n");
+        },
+    });
+    const getTemplate = tool({
+        description: "Read the full content of a prompt template by ID or name.",
+        inputSchema: z.object({
+            id: z.string().optional().describe("Template ID"),
+            name: z.string().optional().describe("Template name (used if id is not provided)"),
+        }),
+        execute: async ({ id, name }) => {
+            if (!id && !name)
+                return "Either id or name is required";
+            let tpl = id ? store.getPromptTemplateById(id) : null;
+            if (!tpl && name) {
+                const all = store.listPromptTemplates();
+                tpl = all.find((t) => t.name.toLowerCase() === name.toLowerCase()) ?? null;
+            }
+            if (!tpl)
+                return `Template not found: ${id ?? name}`;
+            return [
+                `**${tpl.name}** (${tpl.role}${tpl.builtin ? ", builtin" : ""})`,
+                tpl.description ? `Description: ${tpl.description}` : "",
+                `---`,
+                tpl.content,
+            ].filter(Boolean).join("\n");
+        },
+    });
+    const createTemplate = tool({
+        description: "Create a new prompt template.",
+        inputSchema: z.object({
+            name: z.string().describe("Template name (must be unique)"),
+            description: z.string().optional().describe("Short description of the template"),
+            role: z.enum(VALID_ROLES).describe("Role: orchestrator or worker"),
+            content: z.string().max(50_000).describe("The prompt template content"),
+        }),
+        execute: async ({ name, description, role, content }) => {
+            try {
+                const tpl = store.createPromptTemplate({ name, description, role, content });
+                emit("promptTemplateChange", { action: "created", promptTemplate: tpl });
+                return `Template created: [${tpl.id}] ${tpl.name} (${tpl.role})`;
+            }
+            catch (err) {
+                return `Failed to create template: ${err instanceof Error ? err.message : err}`;
+            }
+        },
+    });
+    const updateTemplate = tool({
+        description: "Update an existing prompt template. Cannot modify built-in templates.",
+        inputSchema: z.object({
+            id: z.string().describe("Template ID to update"),
+            name: z.string().optional().describe("New name"),
+            description: z.string().optional().describe("New description"),
+            role: z.enum(VALID_ROLES).optional().describe("New role"),
+            content: z.string().max(50_000).optional().describe("New content"),
+        }),
+        execute: async ({ id, name, description, role, content }) => {
+            try {
+                const tpl = store.updatePromptTemplate(id, { name, description, role, content });
+                if (!tpl)
+                    return `Template not found: ${id}`;
+                emit("promptTemplateChange", { action: "updated", promptTemplate: tpl });
+                return `Template updated: [${tpl.id}] ${tpl.name} (${tpl.role})`;
+            }
+            catch (err) {
+                return `Failed to update template: ${err instanceof Error ? err.message : err}`;
+            }
+        },
+    });
+    const forkTemplate = tool({
+        description: "Fork an existing prompt template into a new user-editable copy. Useful for built-in templates.",
+        inputSchema: z.object({
+            id: z.string().describe("Template ID to fork"),
+            name: z.string().optional().describe("Optional name for the forked template"),
+            description: z.string().optional().describe("Optional description override"),
+        }),
+        execute: async ({ id, name, description }) => {
+            try {
+                const tpl = store.forkPromptTemplate(id, { name, description });
+                if (!tpl)
+                    return `Template not found: ${id}`;
+                emit("promptTemplateChange", { action: "created", promptTemplate: tpl });
+                return `Template forked: [${tpl.id}] ${tpl.name} (${tpl.role})`;
+            }
+            catch (err) {
+                return `Failed to fork template: ${err instanceof Error ? err.message : err}`;
+            }
+        },
+    });
+    const deleteTemplate = tool({
+        description: "Delete a prompt template by ID. Cannot delete built-in templates.",
+        inputSchema: z.object({
+            id: z.string().describe("Template ID to delete"),
+        }),
+        execute: async ({ id }) => {
+            try {
+                const deleted = store.deletePromptTemplate(id);
+                if (!deleted)
+                    return `Template not found: ${id}`;
+                emit("promptTemplateChange", { action: "deleted", id });
+                return `Template deleted: ${id}`;
+            }
+            catch (err) {
+                return `Failed to delete template: ${err instanceof Error ? err.message : err}`;
+            }
+        },
+    });
+    return {
+        prompt_template_list: listTemplates,
+        prompt_template_get: getTemplate,
+        prompt_template_create: createTemplate,
+        prompt_template_fork: forkTemplate,
+        prompt_template_update: updateTemplate,
+        prompt_template_delete: deleteTemplate,
+    };
+}

package/dist/tools/registry.d.ts

@@ -0,0 +1,6 @@
+import type { Tool, ToolSet } from "ai";
+export declare class ToolRegistry {
+    private tools;
+    register(name: string, tool: Tool): void;
+    getAll(): ToolSet;
+}

package/dist/tools/registry.js

@@ -0,0 +1,9 @@
+export class ToolRegistry {
+    tools = new Map();
+    register(name, tool) {
+        this.tools.set(name, tool);
+    }
+    getAll() {
+        return Object.fromEntries(this.tools);
+    }
+}

package/dist/tools/schedule.d.ts

@@ -0,0 +1,8 @@
+import { type ToolSet } from "ai";
+import type { ScheduleStore } from "../scheduler/store.js";
+/**
+ * Create schedule management tools scoped to a team.
+ * These let the LLM create, list, delete, pause, resume schedules
+ * and set the team's timezone.
+ */
+export declare function createScheduleTools(store: ScheduleStore, teamId: string, availableIntegrations: string[]): ToolSet;