@4onstudios/iris-agent 0.1.0

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

@@ -0,0 +1,58 @@
+/**
+ * Get Symbols Tool (LSP-based)
+ * Uses Language Server Protocol to extract symbols from a file
+ * More accurate than regex-based parsing
+ */
+type ParsedSymbol = {
+    name: string;
+    kind: string;
+    line: number;
+    character: number;
+    endLine: number;
+    endCharacter: number;
+    detail?: string;
+    children?: ParsedSymbol[];
+};
+type FlatSymbol = {
+    name: string;
+    kind: string;
+    line: number;
+    detail?: string;
+};
+type SymbolsByKind = Record<string, FlatSymbol[]>;
+type GetSymbolsLSPParams = {
+    filePath: string;
+};
+type GetSymbolsLSPResult = {
+    success: true;
+    filePath: string;
+    totalSymbols: number;
+    hierarchical: ParsedSymbol[];
+    flat: FlatSymbol[];
+    byKind: SymbolsByKind;
+    summary: Array<{
+        kind: string;
+        count: number;
+    }>;
+} | {
+    success: false;
+    message?: string;
+    error?: string;
+    filePath: string;
+};
+declare const getSymbolsLSPTool: {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            filePath: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute({ filePath }: GetSymbolsLSPParams): Promise<GetSymbolsLSPResult>;
+};
+export default getSymbolsLSPTool;

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

@@ -0,0 +1,147 @@
+/**
+ * Get Symbols Tool (LSP-based)
+ * Uses Language Server Protocol to extract symbols from a file
+ * More accurate than regex-based parsing
+ */
+import { coreLsp } from "../../library/lsp/coreLsp.js";
+import fs from "fs/promises";
+const getSymbolsLSPTool = {
+    name: "getSymbolsLSP",
+    description: `Get all symbols (functions, classes, variables, types) from a file using LSP.
+Provides accurate symbol information including:
+- Symbol name and kind (function, class, variable, etc.)
+- Exact location (line, character)
+- Hierarchical structure (nested symbols)
+- More accurate than regex-based parsing
+
+Use this for:
+- Understanding file structure
+- Finding all functions/classes
+- Navigation and code exploration
+- Refactoring preparation`,
+    parameters: {
+        type: "object",
+        properties: {
+            filePath: {
+                type: "string",
+                description: "Absolute path to the file to analyze",
+            },
+        },
+        required: ["filePath"],
+    },
+    async execute({ filePath }) {
+        try {
+            // Verify file exists
+            await fs.access(filePath);
+            // Get document symbols from LSP
+            const symbolsResult = await coreLsp.getDocumentSymbols(filePath);
+            const symbols = symbolsResult;
+            if (!symbols || symbols.length === 0) {
+                return {
+                    success: false,
+                    message: `No symbols found in ${filePath}`,
+                    filePath,
+                };
+            }
+            // Convert symbol kinds to readable names
+            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",
+            };
+            // Parse symbols recursively
+            const parseSymbol = (symbol) => {
+                const range = symbol.range || symbol.location?.range;
+                const selectionRange = symbol.selectionRange || range;
+                if (!range || !selectionRange) {
+                    throw new Error("Symbol is missing range information");
+                }
+                const parsed = {
+                    name: symbol.name,
+                    kind: symbolKindNames[symbol.kind] || `Unknown(${symbol.kind})`,
+                    line: selectionRange.start.line + 1, // Convert to 1-based
+                    character: selectionRange.start.character + 1,
+                    endLine: range.end.line + 1,
+                    endCharacter: range.end.character + 1,
+                    detail: symbol.detail || undefined,
+                };
+                // Parse children recursively
+                if (symbol.children && symbol.children.length > 0) {
+                    parsed.children = symbol.children.map(parseSymbol);
+                }
+                return parsed;
+            };
+            const parsedSymbols = symbols.map(parseSymbol);
+            // Flatten symbols for summary (without children)
+            const flattenSymbols = (symbols, prefix = "") => {
+                const result = [];
+                for (const symbol of symbols) {
+                    const fullName = prefix ? `${prefix}.${symbol.name}` : symbol.name;
+                    result.push({
+                        name: fullName,
+                        kind: symbol.kind,
+                        line: symbol.line,
+                        detail: symbol.detail,
+                    });
+                    if (symbol.children) {
+                        result.push(...flattenSymbols(symbol.children, fullName));
+                    }
+                }
+                return result;
+            };
+            const flatSymbols = flattenSymbols(parsedSymbols);
+            // Group by kind
+            const symbolsByKind = {};
+            flatSymbols.forEach((symbol) => {
+                if (!symbolsByKind[symbol.kind]) {
+                    symbolsByKind[symbol.kind] = [];
+                }
+                symbolsByKind[symbol.kind].push(symbol);
+            });
+            return {
+                success: true,
+                filePath,
+                totalSymbols: flatSymbols.length,
+                hierarchical: parsedSymbols,
+                flat: flatSymbols,
+                byKind: symbolsByKind,
+                summary: Object.keys(symbolsByKind).map((kind) => ({
+                    kind,
+                    count: symbolsByKind[kind].length,
+                })),
+            };
+        }
+        catch (error) {
+            const err = error;
+            return {
+                success: false,
+                error: err.message,
+                filePath,
+            };
+        }
+    },
+};
+export default getSymbolsLSPTool;

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

@@ -0,0 +1,70 @@
+/**
+ * Get Type Information Tool
+ * Uses LSP to retrieve type information for a symbol at a specific position
+ */
+type HoverRange = {
+    start: {
+        line: number;
+        character: number;
+    };
+    end: {
+        line: number;
+        character: number;
+    };
+};
+type MarkupContent = {
+    value?: string;
+};
+type HoverInfo = {
+    contents: string | MarkupContent | Array<string | MarkupContent>;
+    range?: HoverRange;
+};
+type GetTypeInfoParams = {
+    filePath: string;
+    line: number;
+    character: number;
+};
+type GetTypeInfoResult = {
+    success: true;
+    filePath: string;
+    position: {
+        line: number;
+        character: number;
+    };
+    range?: HoverRange;
+    typeInfo: string;
+    raw: HoverInfo;
+} | {
+    success: false;
+    message?: string;
+    error?: string;
+    filePath: string;
+    position: {
+        line: number;
+        character: number;
+    };
+};
+declare const getTypeInfoTool: {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            filePath: {
+                type: string;
+                description: string;
+            };
+            line: {
+                type: string;
+                description: string;
+            };
+            character: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute({ filePath, line, character, }: GetTypeInfoParams): Promise<GetTypeInfoResult>;
+};
+export default getTypeInfoTool;

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

@@ -0,0 +1,84 @@
+/**
+ * Get Type Information Tool
+ * Uses LSP to retrieve type information for a symbol at a specific position
+ */
+import { coreLsp } from "../../library/lsp/coreLsp.js";
+import fs from "fs/promises";
+const getTypeInfoTool = {
+    name: "getTypeInfo",
+    description: `Get type information and documentation for a symbol at a specific position in a file.
+Returns hover information including type definitions, function signatures, and documentation.
+Requires line and character position (1-based indexing).
+
+Use this when you need to:
+- Understand what type a variable has
+- See function signatures and parameters
+- Read inline documentation
+- Understand API contracts`,
+    parameters: {
+        type: "object",
+        properties: {
+            filePath: {
+                type: "string",
+                description: "Absolute path to the file",
+            },
+            line: {
+                type: "number",
+                description: "Line number (1-based) where the symbol is located",
+            },
+            character: {
+                type: "number",
+                description: "Character position (1-based) within the line",
+            },
+        },
+        required: ["filePath", "line", "character"],
+    },
+    async execute({ filePath, line, character, }) {
+        try {
+            // Verify file exists
+            await fs.access(filePath);
+            // Get hover information from LSP
+            const hoverInfo = (await coreLsp.getHover(filePath, line, character));
+            if (!hoverInfo || !hoverInfo.contents) {
+                return {
+                    success: false,
+                    message: `No type information available at ${filePath}:${line}:${character}`,
+                    filePath,
+                    position: { line, character },
+                };
+            }
+            // Extract content (can be string or MarkupContent)
+            let content = "";
+            if (typeof hoverInfo.contents === "string") {
+                content = hoverInfo.contents;
+            }
+            else if (!Array.isArray(hoverInfo.contents) &&
+                hoverInfo.contents.value) {
+                content = hoverInfo.contents.value;
+            }
+            else if (Array.isArray(hoverInfo.contents)) {
+                content = hoverInfo.contents
+                    .map((c) => (typeof c === "string" ? c : c.value || ""))
+                    .join("\n\n");
+            }
+            return {
+                success: true,
+                filePath,
+                position: { line, character },
+                range: hoverInfo.range,
+                typeInfo: content,
+                raw: hoverInfo,
+            };
+        }
+        catch (error) {
+            const err = error;
+            return {
+                success: false,
+                error: err.message,
+                filePath,
+                position: { line, character },
+            };
+        }
+    },
+};
+export default getTypeInfoTool;

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

@@ -0,0 +1,80 @@
+import { z } from "zod";
+type WorkspaceInfoParams = {
+    workspacePath?: string;
+    includeTree?: boolean;
+    maxDepth?: number;
+};
+type GitInfo = {
+    isGitRepo: boolean;
+    branch?: string;
+    remote?: string;
+    rootPath?: string;
+    hasUncommittedChanges?: boolean;
+    uncommittedFiles?: number;
+};
+type PackageInfo = {
+    name?: string;
+    version?: string;
+    description?: string;
+    dependencies: string[];
+    devDependencies: string[];
+    scripts: string[];
+};
+type TreeNode = {
+    name: string;
+    path: string;
+    type: "directory" | "file";
+    depth: number;
+    children: TreeNode[];
+};
+type TreeStats = {
+    totalNodes: number;
+    totalFiles: number;
+    totalDirectories: number;
+    maxDepth: number;
+};
+type WorkspaceInfoResult = {
+    success: true;
+    workspacePath: string;
+    workspaceName: string;
+    projectTypes: string[];
+    fileCount: number;
+    dirCount: number;
+    git: GitInfo | null;
+    package: PackageInfo | null;
+    directoryTree: TreeNode | null;
+    treeStats: TreeStats | null;
+} | {
+    success: false;
+    error: string;
+};
+/**
+ * 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 declare function getWorkspaceInfo({ workspacePath, includeTree, maxDepth, }: WorkspaceInfoParams): Promise<WorkspaceInfoResult>;
+/**
+ * Tool metadata for agent system
+ */
+export declare const getWorkspaceInfoTool: {
+    description: string;
+    parameters: z.ZodObject<{
+        workspacePath: z.ZodOptional<z.ZodString>;
+        includeTree: z.ZodDefault<z.ZodBoolean>;
+        maxDepth: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxDepth?: number;
+        workspacePath?: string;
+        includeTree?: boolean;
+    }, {
+        maxDepth?: number;
+        workspacePath?: string;
+        includeTree?: boolean;
+    }>;
+    execute: typeof getWorkspaceInfo;
+};
+export default getWorkspaceInfoTool;