@yagr/agent 0.1.0

package/dist/tools/build-tools.d.ts

@@ -0,0 +1,608 @@
+import type { Engine } from '../engine/engine.js';
+import type { ToolExecutionObserver } from './observer.js';
+export declare function buildTools(engine: Engine, observer?: ToolExecutionObserver): {
+    reportProgress: import("ai").Tool<import("zod").ZodObject<{
+        message: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        message: string;
+    }, {
+        message: string;
+    }>, {
+        delivered: boolean;
+        message: string;
+    }> & {
+        execute: (args: {
+            message: string;
+        }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+            delivered: boolean;
+            message: string;
+        }>;
+    };
+    requestRequiredAction: import("ai").Tool<import("zod").ZodObject<{
+        kind: import("zod").ZodEnum<["input", "permission", "external"]>;
+        title: import("zod").ZodString;
+        message: import("zod").ZodString;
+        detail: import("zod").ZodOptional<import("zod").ZodString>;
+        resumable: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    }, "strip", import("zod").ZodTypeAny, {
+        resumable: boolean;
+        title: string;
+        message: string;
+        kind: "input" | "permission" | "external";
+        detail?: string | undefined;
+    }, {
+        title: string;
+        message: string;
+        kind: "input" | "permission" | "external";
+        resumable?: boolean | undefined;
+        detail?: string | undefined;
+    }>, import("../types.js").YagrRequiredAction> & {
+        execute: (args: {
+            resumable: boolean;
+            title: string;
+            message: string;
+            kind: "input" | "permission" | "external";
+            detail?: string | undefined;
+        }, options: import("ai").ToolExecutionOptions) => PromiseLike<import("../types.js").YagrRequiredAction>;
+    };
+    n8nac: import("ai").Tool<import("zod").ZodObject<{
+        action: import("zod").ZodEnum<["setup_check", "init_auth", "init_project", "list", "pull", "push", "verify", "skills", "validate", "update_ai", "resolve", "skillsArgs", "skillsArgv"]>;
+        n8nHost: import("zod").ZodOptional<import("zod").ZodString>;
+        n8nApiKey: import("zod").ZodOptional<import("zod").ZodString>;
+        projectId: import("zod").ZodOptional<import("zod").ZodString>;
+        projectName: import("zod").ZodOptional<import("zod").ZodString>;
+        projectIndex: import("zod").ZodOptional<import("zod").ZodNumber>;
+        listScope: import("zod").ZodOptional<import("zod").ZodEnum<["all", "local", "remote", "distant"]>>;
+        workflowId: import("zod").ZodOptional<import("zod").ZodString>;
+        filename: import("zod").ZodOptional<import("zod").ZodString>;
+        skillsArgs: import("zod").ZodOptional<import("zod").ZodString>;
+        skillsArgv: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        validateFile: import("zod").ZodOptional<import("zod").ZodString>;
+        syncFolder: import("zod").ZodOptional<import("zod").ZodString>;
+        resolveMode: import("zod").ZodOptional<import("zod").ZodEnum<["keep-current", "keep-incoming"]>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        action: "push" | "validate" | "verify" | "list" | "resolve" | "setup_check" | "init_auth" | "init_project" | "pull" | "skills" | "update_ai" | "skillsArgs" | "skillsArgv";
+        syncFolder?: string | undefined;
+        projectId?: string | undefined;
+        projectName?: string | undefined;
+        filename?: string | undefined;
+        workflowId?: string | undefined;
+        validateFile?: string | undefined;
+        skillsArgs?: string | undefined;
+        skillsArgv?: string[] | undefined;
+        n8nHost?: string | undefined;
+        n8nApiKey?: string | undefined;
+        projectIndex?: number | undefined;
+        listScope?: "all" | "local" | "remote" | "distant" | undefined;
+        resolveMode?: "keep-current" | "keep-incoming" | undefined;
+    }, {
+        action: "push" | "validate" | "verify" | "list" | "resolve" | "setup_check" | "init_auth" | "init_project" | "pull" | "skills" | "update_ai" | "skillsArgs" | "skillsArgv";
+        syncFolder?: string | undefined;
+        projectId?: string | undefined;
+        projectName?: string | undefined;
+        filename?: string | undefined;
+        workflowId?: string | undefined;
+        validateFile?: string | undefined;
+        skillsArgs?: string | undefined;
+        skillsArgv?: string[] | undefined;
+        n8nHost?: string | undefined;
+        n8nApiKey?: string | undefined;
+        projectIndex?: number | undefined;
+        listScope?: "all" | "local" | "remote" | "distant" | undefined;
+        resolveMode?: "keep-current" | "keep-incoming" | undefined;
+    }>, {
+        workspaceRoot: string;
+        next: string;
+        initialized: boolean;
+        configPath: string;
+        exitCode?: undefined;
+        timedOut?: undefined;
+        stdout?: undefined;
+        stderr?: undefined;
+        aiContextRefreshed?: undefined;
+        aiContextStdout?: undefined;
+        aiContextStderr?: undefined;
+    } | {
+        exitCode: number;
+        timedOut: boolean;
+        stdout: string;
+        stderr: string;
+        next: string;
+        aiContextRefreshed?: undefined;
+        aiContextStdout?: undefined;
+        aiContextStderr?: undefined;
+    } | {
+        exitCode: number;
+        timedOut: boolean;
+        stdout: string;
+        stderr: string;
+        next?: undefined;
+        aiContextRefreshed?: undefined;
+        aiContextStdout?: undefined;
+        aiContextStderr?: undefined;
+    } | {
+        exitCode: number;
+        timedOut: boolean;
+        stdout: string;
+        stderr: string;
+        aiContextRefreshed: boolean;
+        aiContextStdout: string;
+        aiContextStderr: string;
+        next: string;
+    }> & {
+        execute: (args: {
+            action: "push" | "validate" | "verify" | "list" | "resolve" | "setup_check" | "init_auth" | "init_project" | "pull" | "skills" | "update_ai" | "skillsArgs" | "skillsArgv";
+            syncFolder?: string | undefined;
+            projectId?: string | undefined;
+            projectName?: string | undefined;
+            filename?: string | undefined;
+            workflowId?: string | undefined;
+            validateFile?: string | undefined;
+            skillsArgs?: string | undefined;
+            skillsArgv?: string[] | undefined;
+            n8nHost?: string | undefined;
+            n8nApiKey?: string | undefined;
+            projectIndex?: number | undefined;
+            listScope?: "all" | "local" | "remote" | "distant" | undefined;
+            resolveMode?: "keep-current" | "keep-incoming" | undefined;
+        }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+            workspaceRoot: string;
+            next: string;
+            initialized: boolean;
+            configPath: string;
+            exitCode?: undefined;
+            timedOut?: undefined;
+            stdout?: undefined;
+            stderr?: undefined;
+            aiContextRefreshed?: undefined;
+            aiContextStdout?: undefined;
+            aiContextStderr?: undefined;
+        } | {
+            exitCode: number;
+            timedOut: boolean;
+            stdout: string;
+            stderr: string;
+            next: string;
+            aiContextRefreshed?: undefined;
+            aiContextStdout?: undefined;
+            aiContextStderr?: undefined;
+        } | {
+            exitCode: number;
+            timedOut: boolean;
+            stdout: string;
+            stderr: string;
+            next?: undefined;
+            aiContextRefreshed?: undefined;
+            aiContextStdout?: undefined;
+            aiContextStderr?: undefined;
+        } | {
+            exitCode: number;
+            timedOut: boolean;
+            stdout: string;
+            stderr: string;
+            aiContextRefreshed: boolean;
+            aiContextStdout: string;
+            aiContextStderr: string;
+            next: string;
+        }>;
+    };
+    searchNodes: import("ai").Tool<import("zod").ZodObject<{
+        query: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        query: string;
+    }, {
+        query: string;
+    }>, {
+        nodes: import("../types.js").NodeSummary[];
+    }> & {
+        execute: (args: {
+            query: string;
+        }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+            nodes: import("../types.js").NodeSummary[];
+        }>;
+    };
+    nodeInfo: import("ai").Tool<import("zod").ZodObject<{
+        type: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: string;
+    }, {
+        type: string;
+    }>, {
+        schema: unknown;
+    }> & {
+        execute: (args: {
+            type: string;
+        }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+            schema: unknown;
+        }>;
+    };
+    searchTemplates: import("ai").Tool<import("zod").ZodObject<{
+        query: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        query: string;
+    }, {
+        query: string;
+    }>, {
+        templates: import("../types.js").TemplateSummary[];
+    }> & {
+        execute: (args: {
+            query: string;
+        }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+            templates: import("../types.js").TemplateSummary[];
+        }>;
+    };
+    listDirectory: import("ai").Tool<import("zod").ZodObject<{
+        path: import("zod").ZodDefault<import("zod").ZodString>;
+        recursive: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        maxDepth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    }, "strip", import("zod").ZodTypeAny, {
+        path: string;
+        recursive: boolean;
+        maxDepth: number;
+    }, {
+        path?: string | undefined;
+        recursive?: boolean | undefined;
+        maxDepth?: number | undefined;
+    }>, {
+        ok: boolean;
+        path: string;
+        error: string;
+        entries?: undefined;
+    } | {
+        ok: boolean;
+        path: string;
+        entries: {
+            path: string;
+            type: "file" | "directory";
+        }[];
+        error?: undefined;
+    }> & {
+        execute: (args: {
+            path: string;
+            recursive: boolean;
+            maxDepth: number;
+        }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+            ok: boolean;
+            path: string;
+            error: string;
+            entries?: undefined;
+        } | {
+            ok: boolean;
+            path: string;
+            entries: {
+                path: string;
+                type: "file" | "directory";
+            }[];
+            error?: undefined;
+        }>;
+    };
+    listWorkflows: import("ai").Tool<import("zod").ZodObject<{
+        includeInactive: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        includeInactive: boolean;
+    }, {
+        includeInactive?: boolean | undefined;
+    }>, {
+        workflows: import("../types.js").DeployedWorkflow[];
+    }> & {
+        execute: (args: {
+            includeInactive: boolean;
+        }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+            workflows: import("../types.js").DeployedWorkflow[];
+        }>;
+    };
+    manageWorkflow: import("ai").Tool<import("zod").ZodObject<{
+        workflowId: import("zod").ZodString;
+        action: import("zod").ZodEnum<["activate", "deactivate", "delete"]>;
+    }, "strip", import("zod").ZodTypeAny, {
+        action: "activate" | "deactivate" | "delete";
+        workflowId: string;
+    }, {
+        action: "activate" | "deactivate" | "delete";
+        workflowId: string;
+    }>, {
+        workflowId: string;
+        action: "activate";
+        ok: boolean;
+    } | {
+        workflowId: string;
+        action: "deactivate";
+        ok: boolean;
+    } | {
+        workflowId: string;
+        action: "delete";
+        ok: boolean;
+    }> & {
+        execute: (args: {
+            action: "activate" | "deactivate" | "delete";
+            workflowId: string;
+        }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+            workflowId: string;
+            action: "activate";
+            ok: boolean;
+        } | {
+            workflowId: string;
+            action: "deactivate";
+            ok: boolean;
+        } | {
+            workflowId: string;
+            action: "delete";
+            ok: boolean;
+        }>;
+    };
+    readWorkspaceFile: import("ai").Tool<import("zod").ZodObject<{
+        path: import("zod").ZodString;
+        startLine: import("zod").ZodOptional<import("zod").ZodNumber>;
+        endLine: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, "strip", import("zod").ZodTypeAny, {
+        path: string;
+        startLine?: number | undefined;
+        endLine?: number | undefined;
+    }, {
+        path: string;
+        startLine?: number | undefined;
+        endLine?: number | undefined;
+    }>, {
+        ok: boolean;
+        path: string;
+        error: string;
+        startLine?: undefined;
+        endLine?: undefined;
+        totalLines?: undefined;
+        content?: undefined;
+    } | {
+        ok: boolean;
+        path: string;
+        startLine: number;
+        endLine: number;
+        totalLines: number;
+        content: string;
+        error?: undefined;
+    }> & {
+        execute: (args: {
+            path: string;
+            startLine?: number | undefined;
+            endLine?: number | undefined;
+        }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+            ok: boolean;
+            path: string;
+            error: string;
+            startLine?: undefined;
+            endLine?: undefined;
+            totalLines?: undefined;
+            content?: undefined;
+        } | {
+            ok: boolean;
+            path: string;
+            startLine: number;
+            endLine: number;
+            totalLines: number;
+            content: string;
+            error?: undefined;
+        }>;
+    };
+    searchWorkspace: import("ai").Tool<import("zod").ZodObject<{
+        query: import("zod").ZodString;
+        path: import("zod").ZodDefault<import("zod").ZodString>;
+        isRegexp: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        maxResults: import("zod").ZodDefault<import("zod").ZodNumber>;
+    }, "strip", import("zod").ZodTypeAny, {
+        path: string;
+        query: string;
+        isRegexp: boolean;
+        maxResults: number;
+    }, {
+        query: string;
+        path?: string | undefined;
+        isRegexp?: boolean | undefined;
+        maxResults?: number | undefined;
+    }>, {
+        query: string;
+        matches: never[];
+        ok: boolean;
+        path: string;
+        error: string;
+    } | {
+        ok: boolean;
+        path: string;
+        query: string;
+        matches: import("./search-workspace.js").SearchMatch[];
+        error?: undefined;
+    }> & {
+        execute: (args: {
+            path: string;
+            query: string;
+            isRegexp: boolean;
+            maxResults: number;
+        }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+            query: string;
+            matches: never[];
+            ok: boolean;
+            path: string;
+            error: string;
+        } | {
+            ok: boolean;
+            path: string;
+            query: string;
+            matches: import("./search-workspace.js").SearchMatch[];
+            error?: undefined;
+        }>;
+    };
+    writeWorkspaceFile: import("ai").Tool<import("zod").ZodObject<{
+        path: import("zod").ZodString;
+        content: import("zod").ZodString;
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<["create", "overwrite", "append"]>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        path: string;
+        content: string;
+        mode: "create" | "overwrite" | "append";
+    }, {
+        path: string;
+        content: string;
+        mode?: "create" | "overwrite" | "append" | undefined;
+    }>, {
+        ok: boolean;
+        path: string;
+        error: string;
+        mode?: undefined;
+        bytesWritten?: undefined;
+    } | {
+        ok: boolean;
+        path: string;
+        mode: "create" | "overwrite" | "append";
+        bytesWritten: number;
+        error?: undefined;
+    }> & {
+        execute: (args: {
+            path: string;
+            content: string;
+            mode: "create" | "overwrite" | "append";
+        }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+            ok: boolean;
+            path: string;
+            error: string;
+            mode?: undefined;
+            bytesWritten?: undefined;
+        } | {
+            ok: boolean;
+            path: string;
+            mode: "create" | "overwrite" | "append";
+            bytesWritten: number;
+            error?: undefined;
+        }>;
+    };
+    replaceInWorkspaceFile: import("ai").Tool<import("zod").ZodObject<{
+        path: import("zod").ZodString;
+        oldText: import("zod").ZodString;
+        newText: import("zod").ZodString;
+        replaceAll: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    }, "strip", import("zod").ZodTypeAny, {
+        replaceAll: boolean;
+        path: string;
+        oldText: string;
+        newText: string;
+    }, {
+        path: string;
+        oldText: string;
+        newText: string;
+        replaceAll?: boolean | undefined;
+    }>, {
+        ok: boolean;
+        path: string;
+        error: string;
+        occurrences?: undefined;
+        replaced?: undefined;
+    } | {
+        ok: boolean;
+        path: string;
+        error: string;
+        occurrences: number;
+        replaced?: undefined;
+    } | {
+        ok: boolean;
+        path: string;
+        occurrences: number;
+        replaced: number;
+        error?: undefined;
+    }> & {
+        execute: (args: {
+            replaceAll: boolean;
+            path: string;
+            oldText: string;
+            newText: string;
+        }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+            ok: boolean;
+            path: string;
+            error: string;
+            occurrences?: undefined;
+            replaced?: undefined;
+        } | {
+            ok: boolean;
+            path: string;
+            error: string;
+            occurrences: number;
+            replaced?: undefined;
+        } | {
+            ok: boolean;
+            path: string;
+            occurrences: number;
+            replaced: number;
+            error?: undefined;
+        }>;
+    };
+    moveWorkspaceFile: import("ai").Tool<import("zod").ZodObject<{
+        fromPath: import("zod").ZodString;
+        toPath: import("zod").ZodString;
+        overwrite: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    }, "strip", import("zod").ZodTypeAny, {
+        overwrite: boolean;
+        fromPath: string;
+        toPath: string;
+    }, {
+        fromPath: string;
+        toPath: string;
+        overwrite?: boolean | undefined;
+    }>, {
+        ok: boolean;
+        fromPath: string;
+        toPath: string;
+        error: string;
+    } | {
+        ok: boolean;
+        fromPath: string;
+        toPath: string;
+        error?: undefined;
+    }> & {
+        execute: (args: {
+            overwrite: boolean;
+            fromPath: string;
+            toPath: string;
+        }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+            ok: boolean;
+            fromPath: string;
+            toPath: string;
+            error: string;
+        } | {
+            ok: boolean;
+            fromPath: string;
+            toPath: string;
+            error?: undefined;
+        }>;
+    };
+    deleteWorkspaceFile: import("ai").Tool<import("zod").ZodObject<{
+        path: import("zod").ZodString;
+        allowMissing: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    }, "strip", import("zod").ZodTypeAny, {
+        path: string;
+        allowMissing: boolean;
+    }, {
+        path: string;
+        allowMissing?: boolean | undefined;
+    }>, {
+        ok: boolean;
+        path: string;
+        deleted: boolean;
+        error: string | undefined;
+    } | {
+        ok: boolean;
+        path: string;
+        deleted: boolean;
+        error?: undefined;
+    }> & {
+        execute: (args: {
+            path: string;
+            allowMissing: boolean;
+        }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+            ok: boolean;
+            path: string;
+            deleted: boolean;
+            error: string | undefined;
+        } | {
+            ok: boolean;
+            path: string;
+            deleted: boolean;
+            error?: undefined;
+        }>;
+    };
+};
+//# sourceMappingURL=build-tools.d.ts.map

package/dist/tools/build-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-tools.d.ts","sourceRoot":"","sources":["../../src/tools/build-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAiB3D,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkB1E"}

package/dist/tools/build-tools.js

@@ -0,0 +1,35 @@
+import { createDeleteWorkspaceFileTool } from './delete-workspace-file.js';
+import { createListDirectoryTool } from './list-directory.js';
+import { createListWorkflowsTool } from './list-workflows.js';
+import { createManageWorkflowTool } from './manage-workflow.js';
+import { createMoveWorkspaceFileTool } from './move-workspace-file.js';
+import { createN8nAcTool } from './n8nac.js';
+import { createNodeInfoTool } from './node-info.js';
+import { createReadWorkspaceFileTool } from './read-workspace-file.js';
+import { createReplaceInWorkspaceFileTool } from './replace-in-workspace-file.js';
+import { createReportProgressTool } from './report-progress.js';
+import { createSearchNodesTool } from './search-nodes.js';
+import { createSearchTemplatesTool } from './search-templates.js';
+import { createRequestRequiredActionTool } from './request-required-action.js';
+import { createSearchWorkspaceTool } from './search-workspace.js';
+import { createWriteWorkspaceFileTool } from './write-workspace-file.js';
+export function buildTools(engine, observer) {
+    return {
+        reportProgress: createReportProgressTool(observer),
+        requestRequiredAction: createRequestRequiredActionTool(observer),
+        n8nac: createN8nAcTool(observer),
+        searchNodes: createSearchNodesTool(engine),
+        nodeInfo: createNodeInfoTool(engine),
+        searchTemplates: createSearchTemplatesTool(engine),
+        listDirectory: createListDirectoryTool(observer),
+        listWorkflows: createListWorkflowsTool(engine),
+        manageWorkflow: createManageWorkflowTool(engine),
+        readWorkspaceFile: createReadWorkspaceFileTool(observer),
+        searchWorkspace: createSearchWorkspaceTool(observer),
+        writeWorkspaceFile: createWriteWorkspaceFileTool(observer),
+        replaceInWorkspaceFile: createReplaceInWorkspaceFileTool(observer),
+        moveWorkspaceFile: createMoveWorkspaceFileTool(observer),
+        deleteWorkspaceFile: createDeleteWorkspaceFileTool(observer),
+    };
+}
+//# sourceMappingURL=build-tools.js.map

package/dist/tools/build-tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-tools.js","sourceRoot":"","sources":["../../src/tools/build-tools.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAC3E,OAAO,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC;AACvE,OAAO,EAAE,gCAAgC,EAAE,MAAM,gCAAgC,CAAC;AAClF,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,EAAE,+BAA+B,EAAE,MAAM,8BAA8B,CAAC;AAC/E,OAAO,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,EAAE,4BAA4B,EAAE,MAAM,2BAA2B,CAAC;AAEzE,MAAM,UAAU,UAAU,CAAC,MAAc,EAAE,QAAgC;IACzE,OAAO;QACL,cAAc,EAAE,wBAAwB,CAAC,QAAQ,CAAC;QAClD,qBAAqB,EAAE,+BAA+B,CAAC,QAAQ,CAAC;QAChE,KAAK,EAAE,eAAe,CAAC,QAAQ,CAAC;QAChC,WAAW,EAAE,qBAAqB,CAAC,MAAM,CAAC;QAC1C,QAAQ,EAAE,kBAAkB,CAAC,MAAM,CAAC;QACpC,eAAe,EAAE,yBAAyB,CAAC,MAAM,CAAC;QAClD,aAAa,EAAE,uBAAuB,CAAC,QAAQ,CAAC;QAChD,aAAa,EAAE,uBAAuB,CAAC,MAAM,CAAC;QAC9C,cAAc,EAAE,wBAAwB,CAAC,MAAM,CAAC;QAChD,iBAAiB,EAAE,2BAA2B,CAAC,QAAQ,CAAC;QACxD,eAAe,EAAE,yBAAyB,CAAC,QAAQ,CAAC;QACpD,kBAAkB,EAAE,4BAA4B,CAAC,QAAQ,CAAC;QAC1D,sBAAsB,EAAE,gCAAgC,CAAC,QAAQ,CAAC;QAClE,iBAAiB,EAAE,2BAA2B,CAAC,QAAQ,CAAC;QACxD,mBAAmB,EAAE,6BAA6B,CAAC,QAAQ,CAAC;KAC7D,CAAC;AACJ,CAAC"}

package/dist/tools/delete-workspace-file.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import type { ToolExecutionObserver } from './observer.js';
+export declare function createDeleteWorkspaceFileTool(_observer?: ToolExecutionObserver): import("ai").Tool<z.ZodObject<{
+    path: z.ZodString;
+    allowMissing: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    allowMissing: boolean;
+}, {
+    path: string;
+    allowMissing?: boolean | undefined;
+}>, {
+    ok: boolean;
+    path: string;
+    deleted: boolean;
+    error: string | undefined;
+} | {
+    ok: boolean;
+    path: string;
+    deleted: boolean;
+    error?: undefined;
+}> & {
+    execute: (args: {
+        path: string;
+        allowMissing: boolean;
+    }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+        ok: boolean;
+        path: string;
+        deleted: boolean;
+        error: string | undefined;
+    } | {
+        ok: boolean;
+        path: string;
+        deleted: boolean;
+        error?: undefined;
+    }>;
+};
+//# sourceMappingURL=delete-workspace-file.d.ts.map

package/dist/tools/delete-workspace-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-workspace-file.d.ts","sourceRoot":"","sources":["../../src/tools/delete-workspace-file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAG3D,wBAAgB,6BAA6B,CAAC,SAAS,CAAC,EAAE,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4B9E"}