@4onstudios/iris-agent 0.1.0

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

@@ -0,0 +1,281 @@
+import fs from "fs/promises";
+import path from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { z } from "zod";
+import { countNodes, getMaxDepth, findAllNodes } from "./treeTraversal.js";
+const execAsync = promisify(exec);
+/**
+ * Tool for getting workspace information
+ * @param {Object} params - The parameters for getting workspace info
+ * @param {string} [params.workspacePath] - The path to the workspace
+ * @param {boolean} [params.includeTree] - Whether to include directory tree
+ * @param {number} [params.maxDepth] - Maximum depth for directory tree
+ * @returns {Promise<Object>} Object containing workspace information or error
+ */
+export async function getWorkspaceInfo({ workspacePath = process.cwd(), includeTree = false, maxDepth = 3, }) {
+    try {
+        const absolutePath = path.resolve(workspacePath);
+        // Check if path exists
+        try {
+            await fs.access(absolutePath, fs.constants.R_OK);
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: `Workspace path not found or not readable: ${workspacePath}`,
+            };
+        }
+        const stats = await fs.stat(absolutePath);
+        if (!stats.isDirectory()) {
+            return {
+                success: false,
+                error: "Workspace path is not a directory",
+            };
+        }
+        // Get workspace name
+        const workspaceName = path.basename(absolutePath);
+        // Try to get git information
+        let gitInfo = null;
+        try {
+            const { stdout: branch } = await execAsync("git rev-parse --abbrev-ref HEAD", { cwd: absolutePath });
+            const { stdout: remote } = await execAsync("git config --get remote.origin.url", { cwd: absolutePath });
+            const { stdout: rootPath } = await execAsync("git rev-parse --show-toplevel", { cwd: absolutePath });
+            gitInfo = {
+                isGitRepo: true,
+                branch: branch.trim(),
+                remote: remote.trim(),
+                rootPath: rootPath.trim(),
+            };
+            // Check for uncommitted changes
+            const { stdout: status } = await execAsync("git status --porcelain", {
+                cwd: absolutePath,
+            });
+            gitInfo.hasUncommittedChanges = status.trim().length > 0;
+            gitInfo.uncommittedFiles = status
+                .trim()
+                .split("\n")
+                .filter(Boolean).length;
+        }
+        catch (err) {
+            gitInfo = { isGitRepo: false };
+        }
+        // Try to detect project type by looking for common files
+        const projectTypes = [];
+        const commonFiles = [
+            { file: "package.json", type: "Node.js/JavaScript" },
+            { file: "requirements.txt", type: "Python" },
+            { file: "Pipfile", type: "Python (Pipenv)" },
+            { file: "pyproject.toml", type: "Python (Poetry)" },
+            { file: "Cargo.toml", type: "Rust" },
+            { file: "go.mod", type: "Go" },
+            { file: "pom.xml", type: "Java (Maven)" },
+            { file: "build.gradle", type: "Java (Gradle)" },
+            { file: "Gemfile", type: "Ruby" },
+            { file: "composer.json", type: "PHP" },
+            { file: ".csproj", type: ".NET" },
+        ];
+        for (const { file, type } of commonFiles) {
+            try {
+                if (file.startsWith(".")) {
+                    // Special handling for extension-based files
+                    const files = await fs.readdir(absolutePath);
+                    if (files.some((f) => f.endsWith(file))) {
+                        projectTypes.push(type);
+                    }
+                }
+                else {
+                    await fs.access(path.join(absolutePath, file), fs.constants.F_OK);
+                    projectTypes.push(type);
+                }
+            }
+            catch (err) {
+                // File doesn't exist, skip
+            }
+        }
+        // Try to read package.json if it exists
+        let packageInfo = null;
+        try {
+            const packageJsonPath = path.join(absolutePath, "package.json");
+            const packageJsonContent = await fs.readFile(packageJsonPath, "utf8");
+            const packageJson = JSON.parse(packageJsonContent);
+            packageInfo = {
+                name: typeof packageJson.name === "string" ? packageJson.name : undefined,
+                version: typeof packageJson.version === "string" ? packageJson.version : undefined,
+                description: typeof packageJson.description === "string"
+                    ? packageJson.description
+                    : undefined,
+                dependencies: Object.keys(packageJson.dependencies || {}),
+                devDependencies: Object.keys(packageJson.devDependencies || {}),
+                scripts: Object.keys(packageJson.scripts || {}),
+            };
+        }
+        catch (err) {
+            // package.json doesn't exist or is invalid
+        }
+        // Count files and directories
+        let fileCount = 0;
+        let dirCount = 0;
+        try {
+            const entries = await fs.readdir(absolutePath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.name.startsWith("."))
+                    continue;
+                if (entry.isDirectory())
+                    dirCount++;
+                else
+                    fileCount++;
+            }
+        }
+        catch (err) {
+            // Unable to count
+        }
+        // Optionally build directory tree structure
+        let directoryTree = null;
+        let treeStats = null;
+        if (includeTree) {
+            try {
+                directoryTree = await buildDirectoryTree(absolutePath, maxDepth);
+                // Calculate tree statistics using efficient traversal utilities
+                if (directoryTree) {
+                    const allFiles = findAllNodes(directoryTree, (node) => node.type === "file");
+                    const allDirs = findAllNodes(directoryTree, (node) => node.type === "directory");
+                    treeStats = {
+                        totalNodes: countNodes(directoryTree),
+                        totalFiles: allFiles.length,
+                        totalDirectories: allDirs.length,
+                        maxDepth: getMaxDepth(directoryTree),
+                    };
+                }
+            }
+            catch (err) {
+                console.error("Failed to build directory tree:", err);
+            }
+        }
+        return {
+            success: true,
+            workspacePath: absolutePath,
+            workspaceName,
+            projectTypes,
+            fileCount,
+            dirCount,
+            git: gitInfo,
+            package: packageInfo,
+            directoryTree,
+            treeStats,
+        };
+    }
+    catch (error) {
+        const err = error;
+        return {
+            success: false,
+            error: err.message,
+        };
+    }
+}
+/**
+ * Build a directory tree structure using BFS (Breadth-First Search)
+ * More efficient than recursive DFS, prevents stack overflow on deep trees
+ */
+async function buildDirectoryTree(dirPath, maxDepth = 3) {
+    const ignorePatterns = [
+        "node_modules",
+        ".git",
+        "dist",
+        "build",
+        ".next",
+        "target",
+        "coverage",
+        ".cache",
+        ".vscode",
+        ".idea",
+    ];
+    // Root node
+    const root = {
+        name: path.basename(dirPath),
+        path: dirPath,
+        type: "directory",
+        children: [],
+        depth: 0,
+    };
+    // Queue for BFS traversal: [node, parentNode]
+    const queue = [[dirPath, root, 0]];
+    while (queue.length > 0) {
+        const next = queue.shift();
+        if (!next) {
+            continue;
+        }
+        const [currentPath, parentNode, currentDepth] = next;
+        // Stop if max depth reached
+        if (currentDepth >= maxDepth)
+            continue;
+        try {
+            const entries = await fs.readdir(currentPath, { withFileTypes: true });
+            // Sort entries: directories first, then files alphabetically
+            const sortedEntries = entries.sort((a, b) => {
+                if (a.isDirectory() === b.isDirectory()) {
+                    return a.name.localeCompare(b.name);
+                }
+                return a.isDirectory() ? -1 : 1;
+            });
+            for (const entry of sortedEntries) {
+                // Skip hidden files and ignored patterns
+                if (entry.name.startsWith(".") || ignorePatterns.includes(entry.name)) {
+                    continue;
+                }
+                const children = parentNode.children ?? (parentNode.children = []);
+                const childPath = path.join(currentPath, entry.name);
+                if (entry.isDirectory()) {
+                    const dirNode = {
+                        name: entry.name,
+                        path: childPath,
+                        type: "directory",
+                        children: [],
+                        depth: currentDepth + 1,
+                    };
+                    children.push(dirNode);
+                    // Add to queue for further exploration
+                    queue.push([childPath, dirNode, currentDepth + 1]);
+                }
+                else {
+                    // Add file node
+                    children.push({
+                        name: entry.name,
+                        path: childPath,
+                        type: "file",
+                        depth: currentDepth + 1,
+                        children: [],
+                    });
+                }
+            }
+        }
+        catch (err) {
+            const error = err;
+            // Skip directories we can't read (permissions, etc.)
+            console.error(`Cannot read directory ${currentPath}:`, error.message || String(err) || "Unknown error");
+        }
+    }
+    return root;
+}
+/**
+ * Tool metadata for agent system
+ */
+export const getWorkspaceInfoTool = {
+    description: "Get information about the current workspace including git status, project type, and structure. IMPORTANT: Leave workspacePath empty to use the current workspace - do NOT pass project names like 'my-project'. Can optionally include the full directory tree to understand the folder structure.",
+    parameters: z.object({
+        workspacePath: z
+            .string()
+            .optional()
+            .describe("Leave empty to use current workspace. Only provide an absolute path if you need a different workspace."),
+        includeTree: z
+            .boolean()
+            .default(false)
+            .describe("Whether to include the full directory tree structure (useful for understanding folder organization)"),
+        maxDepth: z
+            .number()
+            .default(3)
+            .describe("Maximum depth for directory tree (only used if includeTree is true)"),
+    }),
+    execute: getWorkspaceInfo,
+};
+export default getWorkspaceInfoTool;

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

@@ -0,0 +1,53 @@
+/**
+ * Get Workspace Symbols Tool
+ * Uses LSP to search for symbols across the entire workspace by name/query.
+ */
+type GetWorkspaceSymbolsParams = {
+    query: string;
+    languageId?: string;
+    maxResults?: number;
+};
+type WorkspaceSymbol = {
+    name: string;
+    kind: string;
+    containerName: string;
+    filePath: string;
+    line: number;
+    character: number;
+};
+type GetWorkspaceSymbolsResult = {
+    success: true;
+    query: string;
+    totalSymbols: number;
+    symbols: WorkspaceSymbol[];
+    byKind: Record<string, WorkspaceSymbol[]>;
+} | {
+    success: false;
+    message?: string;
+    error?: string;
+    query: string;
+};
+declare const getWorkspaceSymbolsTool: {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            languageId: {
+                type: string;
+                description: string;
+            };
+            maxResults: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute({ query, languageId, maxResults }: GetWorkspaceSymbolsParams): Promise<GetWorkspaceSymbolsResult>;
+};
+export default getWorkspaceSymbolsTool;

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

@@ -0,0 +1,97 @@
+/**
+ * Get Workspace Symbols Tool
+ * Uses LSP to search for symbols across the entire workspace by name/query.
+ */
+import { coreLsp } from "../../library/lsp/coreLsp.js";
+import { fileURLToPath } from "url";
+const symbolKindNames = {
+    1: "File", 2: "Module", 3: "Namespace", 4: "Package", 5: "Class",
+    6: "Method", 7: "Property", 8: "Field", 9: "Constructor", 10: "Enum",
+    11: "Interface", 12: "Function", 13: "Variable", 14: "Constant",
+    15: "String", 16: "Number", 17: "Boolean", 18: "Array", 19: "Object",
+    20: "Key", 21: "Null", 22: "EnumMember", 23: "Struct", 24: "Event",
+    25: "Operator", 26: "TypeParameter",
+};
+const getWorkspaceSymbolsTool = {
+    name: "getWorkspaceSymbols",
+    description: `Search for symbols (functions, classes, variables, types) across the entire workspace by name.
+Returns matching symbols with their file locations and kinds.
+
+Use this when you need to:
+- Find where a class or function is defined without knowing the file
+- Search for all symbols matching a pattern across the project
+- Get a list of all exports or public API symbols
+- Locate a symbol quickly by partial name`,
+    parameters: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "Search query — partial name or pattern to match symbols against",
+            },
+            languageId: {
+                type: "string",
+                description: "Optional language ID to limit search to one language server (e.g. 'typescript')",
+            },
+            maxResults: {
+                type: "number",
+                description: "Maximum number of results to return (default: 50)",
+            },
+        },
+        required: ["query"],
+    },
+    async execute({ query, languageId, maxResults = 50 }) {
+        try {
+            const result = (await coreLsp.getWorkspaceSymbols(query, languageId));
+            if (!result || result.length === 0) {
+                return {
+                    success: false,
+                    message: `No workspace symbols found matching "${query}"`,
+                    query,
+                };
+            }
+            const symbols = result
+                .slice(0, maxResults)
+                .map((sym) => {
+                const uri = sym.location?.uri ?? "";
+                let filePath = uri;
+                try {
+                    filePath = uri.startsWith("file://") ? fileURLToPath(uri) : uri;
+                }
+                catch {
+                    filePath = uri.replace("file://", "");
+                }
+                return {
+                    name: sym.name ?? "",
+                    kind: symbolKindNames[sym.kind ?? 0] ?? `Unknown(${sym.kind})`,
+                    containerName: sym.containerName ?? "",
+                    filePath,
+                    line: (sym.location?.range?.start?.line ?? 0) + 1,
+                    character: (sym.location?.range?.start?.character ?? 0) + 1,
+                };
+            });
+            const byKind = {};
+            for (const sym of symbols) {
+                if (!byKind[sym.kind])
+                    byKind[sym.kind] = [];
+                byKind[sym.kind].push(sym);
+            }
+            return {
+                success: true,
+                query,
+                totalSymbols: symbols.length,
+                symbols,
+                byKind,
+            };
+        }
+        catch (error) {
+            const err = error;
+            return {
+                success: false,
+                error: err.message,
+                query,
+            };
+        }
+    },
+};
+export default getWorkspaceSymbolsTool;

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

@@ -0,0 +1,100 @@
+import { z } from "zod";
+type GrepSearchParams = {
+    searchText: string;
+    filePattern?: string;
+    cwd?: string;
+    caseSensitive?: boolean;
+    regex?: boolean;
+    includeLineNumbers?: boolean;
+    contextLines?: number;
+    maxResults?: number;
+};
+type ContextLine = {
+    lineNumber: number;
+    line: string;
+};
+type LineMatch = {
+    text: string;
+    index: number;
+};
+type GrepMatch = {
+    lineNumber: number;
+    line: string;
+    matches: LineMatch[];
+    before?: ContextLine[];
+    after?: ContextLine[];
+};
+type GrepFileResult = {
+    file: string;
+    relativePath: string;
+    matchCount: number;
+    matches: GrepMatch[];
+};
+type GrepSearchSuccessResult = {
+    success: true;
+    searchText: string;
+    pattern: string;
+    caseSensitive: boolean;
+    regex: boolean;
+    note?: string;
+    totalFiles: number;
+    filesWithMatches: number;
+    totalMatches: number;
+    skippedBinaryFiles: number;
+    results: GrepFileResult[];
+};
+type GrepSearchErrorResult = {
+    success: false;
+    error: string;
+};
+type GrepSearchResult = GrepSearchSuccessResult | GrepSearchErrorResult;
+/**
+ * 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 declare function grepSearch({ searchText, filePattern, cwd, caseSensitive, regex, includeLineNumbers, contextLines, maxResults, }: GrepSearchParams): Promise<GrepSearchResult>;
+/**
+ * Tool metadata for agent system
+ */
+export declare const grepSearchTool: {
+    description: string;
+    parameters: z.ZodObject<{
+        searchText: z.ZodString;
+        filePattern: z.ZodDefault<z.ZodString>;
+        cwd: z.ZodDefault<z.ZodString>;
+        caseSensitive: z.ZodDefault<z.ZodBoolean>;
+        regex: z.ZodDefault<z.ZodBoolean>;
+        includeLineNumbers: z.ZodDefault<z.ZodBoolean>;
+        contextLines: z.ZodDefault<z.ZodNumber>;
+        maxResults: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        cwd?: string;
+        searchText?: string;
+        filePattern?: string;
+        caseSensitive?: boolean;
+        regex?: boolean;
+        includeLineNumbers?: boolean;
+        contextLines?: number;
+        maxResults?: number;
+    }, {
+        cwd?: string;
+        searchText?: string;
+        filePattern?: string;
+        caseSensitive?: boolean;
+        regex?: boolean;
+        includeLineNumbers?: boolean;
+        contextLines?: number;
+        maxResults?: number;
+    }>;
+    execute: typeof grepSearch;
+};
+export default grepSearchTool;