@4onstudios/iris-agent 0.1.0

package/dist/api/core/agent/tools/grepSearch.js

@@ -0,0 +1,211 @@
+import fs from "fs/promises";
+import path from "path";
+import { glob } from "glob";
+import { z } from "zod";
+import { escapeRegExp } from "../../library/regexEscape.js";
+const isProbablyBinary = (data) => {
+    if (data.length === 0) {
+        return false;
+    }
+    // Null bytes are a strong signal for binary data.
+    if (data.includes(0)) {
+        return true;
+    }
+    const sampleLength = Math.min(data.length, 1024);
+    let suspiciousBytes = 0;
+    for (let i = 0; i < sampleLength; i++) {
+        const byte = data[i];
+        const isTab = byte === 9;
+        const isNewline = byte === 10;
+        const isCarriageReturn = byte === 13;
+        const isPrintableAscii = byte >= 32 && byte <= 126;
+        if (!isTab && !isNewline && !isCarriageReturn && !isPrintableAscii) {
+            suspiciousBytes += 1;
+        }
+    }
+    return suspiciousBytes / sampleLength > 0.3;
+};
+/**
+ * Tool for searching text content across files (like grep)
+ * @param {Object} params - The parameters for grep search
+ * @param {string} params.searchText - The text to search for
+ * @param {string} [params.filePattern] - Glob pattern for files to search
+ * @param {string} [params.cwd] - Current working directory for search
+ * @param {boolean} [params.caseSensitive] - Whether search is case sensitive
+ * @param {boolean} [params.regex] - Whether searchText is a regex pattern
+ * @param {boolean} [params.includeLineNumbers] - Whether to include line numbers
+ * @param {number} [params.contextLines] - Number of context lines to show before/after match
+ * @param {number} [params.maxResults] - Maximum number of results to return
+ * @returns {Promise<Object>} Object containing success status and search results or error
+ */
+export async function grepSearch({ searchText, filePattern = "**/*", cwd = process.cwd(), caseSensitive = false, regex = false, includeLineNumbers = true, contextLines = 0, maxResults = 100, }) {
+    try {
+        void includeLineNumbers;
+        // Validate input
+        if (!searchText) {
+            return {
+                success: false,
+                error: "Search text is required",
+            };
+        }
+        // Create search pattern
+        let searchPattern;
+        let note;
+        if (regex) {
+            try {
+                searchPattern = new RegExp(searchText, caseSensitive ? "g" : "gi");
+            }
+            catch (err) {
+                void err;
+                searchPattern = new RegExp(escapeRegExp(searchText), caseSensitive ? "g" : "gi");
+                note =
+                    "Search text treated as literal text (invalid regex). Use JavaScript regex syntax for regex search.";
+            }
+        }
+        else {
+            const escapedText = escapeRegExp(searchText);
+            searchPattern = new RegExp(escapedText, caseSensitive ? "g" : "gi");
+        }
+        // Find matching files
+        const files = await glob(filePattern, {
+            cwd,
+            absolute: true,
+            nodir: true,
+            ignore: [
+                "**/node_modules/**",
+                "**/dist/**",
+                "**/build/**",
+                "**/.git/**",
+                "**/coverage/**",
+                "**/.next/**",
+                "**/out/**",
+            ],
+        });
+        const results = [];
+        let totalMatches = 0;
+        let skippedBinaryFiles = 0;
+        // Search through each file
+        for (const file of files) {
+            if (totalMatches >= maxResults)
+                break;
+            try {
+                const rawContent = await fs.readFile(file);
+                if (isProbablyBinary(rawContent)) {
+                    skippedBinaryFiles += 1;
+                    continue;
+                }
+                const content = rawContent.toString("utf8");
+                const lines = content.split("\n");
+                const fileMatches = [];
+                for (let i = 0; i < lines.length; i++) {
+                    if (totalMatches >= maxResults)
+                        break;
+                    const line = lines[i];
+                    const matches = [...line.matchAll(searchPattern)];
+                    if (matches.length > 0) {
+                        const match = {
+                            lineNumber: i + 1,
+                            line: line,
+                            matches: matches.map((m) => ({
+                                text: m[0],
+                                index: m.index ?? 0,
+                            })),
+                        };
+                        // Add context lines if requested
+                        if (contextLines > 0) {
+                            match.before = [];
+                            match.after = [];
+                            for (let j = 1; j <= contextLines; j++) {
+                                if (i - j >= 0) {
+                                    match.before.unshift({
+                                        lineNumber: i - j + 1,
+                                        line: lines[i - j],
+                                    });
+                                }
+                                if (i + j < lines.length) {
+                                    match.after.push({
+                                        lineNumber: i + j + 1,
+                                        line: lines[i + j],
+                                    });
+                                }
+                            }
+                        }
+                        fileMatches.push(match);
+                        totalMatches++;
+                    }
+                }
+                if (fileMatches.length > 0) {
+                    results.push({
+                        file: file,
+                        relativePath: path.relative(cwd, file),
+                        matchCount: fileMatches.length,
+                        matches: fileMatches,
+                    });
+                }
+            }
+            catch (err) {
+                // Skip files that can't be read (binary, etc.)
+                continue;
+            }
+        }
+        return {
+            success: true,
+            searchText,
+            pattern: filePattern,
+            caseSensitive,
+            regex,
+            ...(note ? { note } : {}),
+            totalFiles: files.length,
+            filesWithMatches: results.length,
+            totalMatches,
+            skippedBinaryFiles,
+            results,
+        };
+    }
+    catch (error) {
+        const err = error;
+        return {
+            success: false,
+            error: err.message,
+        };
+    }
+}
+/**
+ * Tool metadata for agent system
+ */
+export const grepSearchTool = {
+    description: "Search for text content across files (like grep)",
+    parameters: z.object({
+        searchText: z.string().describe("The text to search for"),
+        filePattern: z
+            .string()
+            .default("**/*")
+            .describe("Glob pattern for files to search"),
+        cwd: z
+            .string()
+            .default(process.cwd())
+            .describe("Current working directory for search"),
+        caseSensitive: z
+            .boolean()
+            .default(false)
+            .describe("Whether search is case sensitive"),
+        regex: z
+            .boolean()
+            .default(false)
+            .describe("Whether searchText is a regex pattern"),
+        includeLineNumbers: z
+            .boolean()
+            .default(true)
+            .describe("Whether to include line numbers"),
+        contextLines: z
+            .number()
+            .default(0)
+            .describe("Number of context lines to show before/after match"),
+        maxResults: z
+            .number()
+            .default(100)
+            .describe("Maximum number of results to return"),
+    }),
+    execute: grepSearch,
+};
+export default grepSearchTool;

package/dist/api/core/agent/tools/languageModelToolsIntegration.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Language Model Tools Integration
+ * Initializes and manages the language model tools system for Iris
+ */
+import type { McpServerConfig } from "../../library/mcpSettings.js";
+/**
+ * Initialize language model tools system
+ */
+export declare function initializeLanguageModelTools(mcpServers: McpServerConfig[], workspacePath: string | null): Promise<void>;
+/**
+ * Get all available tools
+ */
+export declare function getAvailableTools(): Promise<import("../../library/languageModelTools.js").LanguageModelToolInformation[]>;

package/dist/api/core/agent/tools/languageModelToolsIntegration.js

@@ -0,0 +1,22 @@
+/**
+ * Language Model Tools Integration
+ * Initializes and manages the language model tools system for Iris
+ */
+import { languageModelTools } from "../../library/languageModelTools.js";
+import { createDefaultProvider } from "../../library/mcpServerProvider.js";
+/**
+ * Initialize language model tools system
+ */
+export async function initializeLanguageModelTools(mcpServers, workspacePath) {
+    // Set workspace path
+    languageModelTools.setWorkspacePath(workspacePath);
+    // Register MCP server provider
+    const mcpProvider = createDefaultProvider(mcpServers);
+    languageModelTools.registerMcpServerDefinitionProvider("iris.default", mcpProvider);
+}
+/**
+ * Get all available tools
+ */
+export async function getAvailableTools() {
+    return languageModelTools.getAvailableTools();
+}

package/dist/api/core/agent/tools/listDirectory.d.ts

@@ -0,0 +1,66 @@
+import { z } from "zod";
+type ListDirectoryParams = {
+    dirPath: string;
+    recursive?: boolean;
+    includeHidden?: boolean;
+    maxDepth?: number;
+};
+type DirectoryItem = {
+    name: string;
+    path: string;
+    relativePath: string;
+    type: "directory" | "file";
+    size: number;
+    modified: Date;
+    created: Date;
+    depth: number;
+};
+type ListDirectorySuccessResult = {
+    success: true;
+    dirPath: string;
+    totalItems: number;
+    fileCount: number;
+    directoryCount: number;
+    contents: DirectoryItem[];
+    files: DirectoryItem[];
+    directories: DirectoryItem[];
+};
+type ListDirectoryErrorResult = {
+    success: false;
+    error: string;
+};
+type ListDirectoryResult = ListDirectorySuccessResult | ListDirectoryErrorResult;
+/**
+ * Tool for listing directory contents
+ * @param {Object} params - The parameters for listing a directory
+ * @param {string} params.dirPath - The path to the directory to list
+ * @param {boolean} [params.recursive=false] - Whether to list recursively
+ * @param {boolean} [params.includeHidden=false] - Whether to include hidden files
+ * @param {number} [params.maxDepth=3] - Maximum depth for recursive listing
+ * @returns {Promise<Object>} Object containing success status and directory contents or error
+ */
+export declare function listDirectory({ dirPath, recursive, includeHidden, maxDepth, }: ListDirectoryParams): Promise<ListDirectoryResult>;
+/**
+ * Tool metadata for agent system
+ */
+export declare const listDirectoryTool: {
+    description: string;
+    parameters: z.ZodObject<{
+        dirPath: z.ZodString;
+        recursive: z.ZodDefault<z.ZodBoolean>;
+        includeHidden: z.ZodDefault<z.ZodBoolean>;
+        maxDepth: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxDepth?: number;
+        recursive?: boolean;
+        dirPath?: string;
+        includeHidden?: boolean;
+    }, {
+        maxDepth?: number;
+        recursive?: boolean;
+        dirPath?: string;
+        includeHidden?: boolean;
+    }>;
+    execute: typeof listDirectory;
+};
+export default listDirectoryTool;

package/dist/api/core/agent/tools/listDirectory.js

@@ -0,0 +1,161 @@
+import fs from "fs/promises";
+import path from "path";
+import { z } from "zod";
+/**
+ * Tool for listing directory contents
+ * @param {Object} params - The parameters for listing a directory
+ * @param {string} params.dirPath - The path to the directory to list
+ * @param {boolean} [params.recursive=false] - Whether to list recursively
+ * @param {boolean} [params.includeHidden=false] - Whether to include hidden files
+ * @param {number} [params.maxDepth=3] - Maximum depth for recursive listing
+ * @returns {Promise<Object>} Object containing success status and directory contents or error
+ */
+export async function listDirectory({ dirPath, recursive = false, includeHidden = false, maxDepth = 3, }) {
+    try {
+        // Validate input
+        if (!dirPath) {
+            return {
+                success: false,
+                error: "Directory path is required",
+            };
+        }
+        // Resolve to absolute path
+        const absolutePath = path.resolve(dirPath);
+        // Check if directory exists
+        try {
+            await fs.access(absolutePath, fs.constants.R_OK);
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: `Directory not found or not readable: ${dirPath}`,
+            };
+        }
+        // Check if it's a directory
+        const stats = await fs.stat(absolutePath);
+        if (!stats.isDirectory()) {
+            return {
+                success: false,
+                error: `Path is not a directory: ${dirPath}`,
+            };
+        }
+        // List directory contents using BFS for better performance
+        const listDir = async () => {
+            if (!recursive) {
+                // Non-recursive: simple single-level listing
+                const entries = await fs.readdir(absolutePath, { withFileTypes: true });
+                const items = [];
+                for (const entry of entries) {
+                    if (!includeHidden && entry.name.startsWith(".")) {
+                        continue;
+                    }
+                    const fullPath = path.join(absolutePath, entry.name);
+                    const relativePath = path.relative(absolutePath, fullPath);
+                    const itemStats = await fs.stat(fullPath);
+                    items.push({
+                        name: entry.name,
+                        path: fullPath,
+                        relativePath,
+                        type: entry.isDirectory() ? "directory" : "file",
+                        size: itemStats.size,
+                        modified: itemStats.mtime,
+                        created: itemStats.birthtime,
+                        depth: 0,
+                    });
+                }
+                return items;
+            }
+            // Recursive: use BFS with queue (more efficient than DFS recursion)
+            const items = [];
+            const queue = [[absolutePath, 0]]; // [path, depth]
+            while (queue.length > 0) {
+                const next = queue.shift();
+                if (!next) {
+                    continue;
+                }
+                const [currentPath, currentDepth] = next;
+                // Stop if max depth reached
+                if (currentDepth > maxDepth)
+                    continue;
+                try {
+                    const entries = await fs.readdir(currentPath, {
+                        withFileTypes: true,
+                    });
+                    for (const entry of entries) {
+                        if (!includeHidden && entry.name.startsWith(".")) {
+                            continue;
+                        }
+                        const fullPath = path.join(currentPath, entry.name);
+                        const relativePath = path.relative(absolutePath, fullPath);
+                        const itemStats = await fs.stat(fullPath);
+                        const item = {
+                            name: entry.name,
+                            path: fullPath,
+                            relativePath,
+                            type: entry.isDirectory() ? "directory" : "file",
+                            size: itemStats.size,
+                            modified: itemStats.mtime,
+                            created: itemStats.birthtime,
+                            depth: currentDepth,
+                        };
+                        items.push(item);
+                        // Add subdirectories to queue for exploration
+                        if (entry.isDirectory()) {
+                            queue.push([fullPath, currentDepth + 1]);
+                        }
+                    }
+                }
+                catch (err) {
+                    const error = err;
+                    // Skip directories we can't read
+                    console.error(`Cannot read directory ${currentPath}:`, error.message || String(err) || "Unknown error");
+                }
+            }
+            return items;
+        };
+        const contents = await listDir();
+        // Separate files and directories
+        const files = contents.filter((item) => item.type === "file");
+        const directories = contents.filter((item) => item.type === "directory");
+        return {
+            success: true,
+            dirPath: absolutePath,
+            totalItems: contents.length,
+            fileCount: files.length,
+            directoryCount: directories.length,
+            contents,
+            files,
+            directories,
+        };
+    }
+    catch (error) {
+        const err = error;
+        return {
+            success: false,
+            error: err.message,
+        };
+    }
+}
+/**
+ * Tool metadata for agent system
+ */
+export const listDirectoryTool = {
+    description: "List the contents of a directory, optionally recursively",
+    parameters: z.object({
+        dirPath: z.string().describe("The path to the directory to list"),
+        recursive: z
+            .boolean()
+            .default(false)
+            .describe("Whether to list recursively"),
+        includeHidden: z
+            .boolean()
+            .default(false)
+            .describe("Whether to include hidden files (starting with .)"),
+        maxDepth: z
+            .number()
+            .default(3)
+            .describe("Maximum depth for recursive listing"),
+    }),
+    execute: listDirectory,
+};
+export default listDirectoryTool;

package/dist/api/core/agent/tools/mcpTools.d.ts

@@ -0,0 +1,48 @@
+import type { McpServerConfig } from "../../library/mcpSettings.js";
+type McpToolDefinition = {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+};
+export type McpToolSummary = {
+    name: string;
+    description?: string;
+};
+export declare const toMcpToolKey: (serverName: string, toolName: string) => string;
+export declare const validateMcpToolInput: (toolName: string, inputSchema: Record<string, unknown> | undefined, params: Record<string, unknown>) => string | null;
+export declare const summarizeMcpToolError: (result: {
+    isError?: boolean;
+    content?: unknown;
+    structuredContent?: unknown;
+}) => string | undefined;
+export declare const listMcpServerTools: (server: McpServerConfig, workspacePath: string) => Promise<McpToolDefinition[]>;
+export declare const executeMcpToolByKey: (servers: McpServerConfig[], workspacePath: string, toolKey: string, input: Record<string, unknown>) => Promise<{
+    success: boolean;
+    server: string;
+    tool: string;
+    isError: boolean;
+    content: unknown;
+    structuredContent: unknown;
+    error: string;
+} | {
+    success: boolean;
+    server: string;
+    tool: string;
+    isError: boolean;
+    error: string;
+    content?: undefined;
+    structuredContent?: undefined;
+} | {
+    success: boolean;
+    isError: boolean;
+    error: string;
+}>;
+/**
+ * Generate MCP tools documentation for persistence in knowledge base.
+ * Only includes servers that are connected and available.
+ * Returns tool metadata that can be stored in the workspace for semantic search.
+ * Returns null if no connected servers with tools are available.
+ */
+export declare const generateMcpToolsDocs: (servers: McpServerConfig[], workspacePath: string) => Promise<string | null>;
+export declare const buildMcpTools: (servers: McpServerConfig[], workspacePath: string) => Promise<Record<string, unknown>>;
+export {};