@aigne/core 1.73.0-beta → 1.74.0-beta

package/lib/cjs/prompt/skills/afs/delete.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AFSDeleteAgent = void 0;
-const zod_1 = require("zod");
-const base_js_1 = require("./base.js");
-class AFSDeleteAgent extends base_js_1.AFSSkillBase {
-    constructor(options) {
-        super({
-            name: "afs_delete",
-            description: `Permanently delete files or directories from the Agentic File System (AFS)
-- Removes files or directories at the specified AFS path
-- Supports recursive deletion for directories with contents
-- Use with caution as deletion is permanent
-
-Usage:
-- The path must be an absolute AFS path starting with "/" (e.g., "/docs/old-file.md", "/temp")
-- This is NOT a local system file path - it operates within the AFS virtual file system
-- To delete a directory, you MUST set recursive=true
-- Deleting a non-empty directory without recursive=true will fail
-- This operation cannot be undone`,
-            ...options,
-            inputSchema: zod_1.z.object({
-                path: zod_1.z
-                    .string()
-                    .describe("Absolute AFS path to delete (e.g., '/docs/old-file.md', '/temp'). Must start with '/'"),
-                recursive: zod_1.z
-                    .boolean()
-                    .optional()
-                    .default(false)
-                    .describe("MUST be set to true to delete directories. Default: false (files only)"),
-            }),
-            outputSchema: zod_1.z.object({
-                status: zod_1.z.string(),
-                tool: zod_1.z.string(),
-                path: zod_1.z.string(),
-                message: zod_1.z.string().optional(),
-            }),
-        });
-    }
-    async process(input, options) {
-        if (!this.afs)
-            throw new Error("AFS is not configured for this agent.");
-        const result = await this.afs.delete(input.path, {
-            recursive: input.recursive ?? false,
-            context: options.context,
-        });
-        return {
-            status: "success",
-            tool: "afs_delete",
-            path: input.path,
-            ...result,
-        };
-    }
-}
-exports.AFSDeleteAgent = AFSDeleteAgent;

package/lib/cjs/prompt/skills/afs/edit.d.ts

@@ -1,24 +0,0 @@
-import type { AgentInvokeOptions, AgentOptions, Message } from "../../../agents/agent.js";
-import { AFSSkillBase } from "./base.js";
-export interface AFSEditInput extends Message {
-    path: string;
-    oldString: string;
-    newString: string;
-    replaceAll?: boolean;
-}
-export interface AFSEditOutput extends Message {
-    status: string;
-    tool: string;
-    path: string;
-    message: string;
-    snippet: string;
-}
-export interface AFSEditAgentOptions extends AgentOptions<AFSEditInput, AFSEditOutput> {
-    afs: NonNullable<AgentOptions<AFSEditInput, AFSEditOutput>["afs"]>;
-}
-export declare class AFSEditAgent extends AFSSkillBase<AFSEditInput, AFSEditOutput> {
-    constructor(options: AFSEditAgentOptions);
-    process(input: AFSEditInput, options: AgentInvokeOptions): Promise<AFSEditOutput>;
-    private countOccurrences;
-    private extractSnippet;
-}

package/lib/cjs/prompt/skills/afs/edit.js

@@ -1,122 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AFSEditAgent = void 0;
-const zod_1 = require("zod");
-const base_js_1 = require("./base.js");
-const CONTEXT_LINES = 4; // Number of lines to show before and after the edit
-class AFSEditAgent extends base_js_1.AFSSkillBase {
-    constructor(options) {
-        super({
-            name: "afs_edit",
-            description: `Performs exact string replacements in files within the Agentic File System (AFS).
-
-Usage:
-- You must use afs_read at least once before editing to understand the file content
-- The path must be an absolute AFS path starting with "/" (e.g., "/docs/readme.md")
-- Preserve exact indentation (tabs/spaces) as it appears in the file
-- The edit will FAIL if oldString is not found in the file
-- The edit will FAIL if oldString appears multiple times (unless replaceAll is true)
-- Use replaceAll to replace/rename strings across the entire file`,
-            ...options,
-            inputSchema: zod_1.z.object({
-                path: zod_1.z
-                    .string()
-                    .describe("Absolute AFS path to the file to edit (e.g., '/docs/readme.md'). Must start with '/'"),
-                oldString: zod_1.z
-                    .string()
-                    .describe("The exact text to replace. Must match file content exactly including whitespace"),
-                newString: zod_1.z
-                    .string()
-                    .describe("The text to replace it with (must be different from oldString)"),
-                replaceAll: zod_1.z
-                    .boolean()
-                    .optional()
-                    .default(false)
-                    .describe("Replace all occurrences of oldString (default: false)"),
-            }),
-            outputSchema: zod_1.z.object({
-                status: zod_1.z.string(),
-                tool: zod_1.z.string(),
-                path: zod_1.z.string(),
-                message: zod_1.z.string(),
-                snippet: zod_1.z.string(),
-            }),
-        });
-    }
-    async process(input, options) {
-        if (!this.afs)
-            throw new Error("AFS is not configured for this agent.");
-        const { path, oldString, newString, replaceAll = false } = input;
-        if (oldString === newString) {
-            throw new Error("oldString and newString must be different");
-        }
-        const readResult = await this.afs.read(path, { context: options.context });
-        if (!readResult.data?.content || typeof readResult.data.content !== "string") {
-            throw new Error(`Cannot read file content from: ${path}`);
-        }
-        const originalContent = readResult.data.content;
-        // Check if oldString exists in the file
-        const occurrences = this.countOccurrences(originalContent, oldString);
-        if (occurrences === 0) {
-            throw new Error(`oldString not found in file: ${path}`);
-        }
-        if (occurrences > 1 && !replaceAll) {
-            throw new Error(`oldString appears ${occurrences} times in file. Use replaceAll=true to replace all occurrences, or provide more context to make oldString unique.`);
-        }
-        // Find the position of the first occurrence for snippet extraction
-        const firstOccurrenceIndex = originalContent.indexOf(oldString);
-        // Perform the replacement
-        const updatedContent = replaceAll
-            ? originalContent.split(oldString).join(newString)
-            : originalContent.replace(oldString, newString);
-        await this.afs.write(path, { content: updatedContent }, { context: options.context });
-        // Generate snippet around the edit location
-        const snippet = this.extractSnippet(updatedContent, firstOccurrenceIndex, newString.length);
-        const replacementCount = replaceAll ? occurrences : 1;
-        return {
-            status: "success",
-            tool: "afs_edit",
-            path,
-            message: `Replaced ${replacementCount} occurrence${replacementCount > 1 ? "s" : ""} in ${path}`,
-            snippet,
-        };
-    }
-    countOccurrences(text, search) {
-        let count = 0;
-        let position = text.indexOf(search);
-        while (position !== -1) {
-            count++;
-            position = text.indexOf(search, position + search.length);
-        }
-        return count;
-    }
-    extractSnippet(content, editStartIndex, newStringLength) {
-        const lines = content.split("\n");
-        // Find the line number where the edit starts
-        let charCount = 0;
-        let editStartLine = 0;
-        for (let i = 0; i < lines.length; i++) {
-            const lineLength = (lines[i]?.length ?? 0) + 1; // +1 for newline
-            if (charCount + lineLength > editStartIndex) {
-                editStartLine = i;
-                break;
-            }
-            charCount += lineLength;
-        }
-        // Calculate how many lines the new content spans
-        const newContentLines = content
-            .substring(editStartIndex, editStartIndex + newStringLength)
-            .split("\n").length;
-        const editEndLine = editStartLine + newContentLines - 1;
-        // Extract lines with context
-        const startLine = Math.max(0, editStartLine - CONTEXT_LINES);
-        const endLine = Math.min(lines.length - 1, editEndLine + CONTEXT_LINES);
-        // Format with line numbers (1-based)
-        const snippetLines = lines.slice(startLine, endLine + 1).map((line, idx) => {
-            const lineNum = startLine + idx + 1;
-            return `${String(lineNum).padStart(4)}| ${line}`;
-        });
-        return snippetLines.join("\n");
-    }
-}
-exports.AFSEditAgent = AFSEditAgent;

package/lib/cjs/prompt/skills/afs/exec.d.ts

@@ -1,16 +0,0 @@
-import type { AgentInvokeOptions, AgentOptions, Message } from "../../../agents/agent.js";
-import { AFSSkillBase } from "./base.js";
-export interface AFSExecInput extends Message {
-    path: string;
-    args: string;
-}
-export interface AFSExecOutput extends Message {
-    data: Record<string, any>;
-}
-export interface AFSExecAgentOptions extends AgentOptions<AFSExecInput, AFSExecOutput> {
-    afs: NonNullable<AgentOptions<AFSExecInput, AFSExecOutput>["afs"]>;
-}
-export declare class AFSExecAgent extends AFSSkillBase<AFSExecInput, AFSExecOutput> {
-    constructor(options: AFSExecAgentOptions);
-    process(input: AFSExecInput, options: AgentInvokeOptions): Promise<AFSExecOutput>;
-}

package/lib/cjs/prompt/skills/afs/exec.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AFSExecAgent = void 0;
-const zod_1 = require("zod");
-const base_js_1 = require("./base.js");
-class AFSExecAgent extends base_js_1.AFSSkillBase {
-    constructor(options) {
-        super({
-            name: "afs_exec",
-            description: `Execute files marked as executable in the Agentic File System (AFS)
-- Runs executable entries (functions, agents, skills) registered at a given AFS path
-- Passes arguments to the executable and returns its output
-- Use this to invoke dynamic functionality stored in AFS
-
-Usage:
-- The path must be an absolute AFS path to an executable entry (e.g., "/skills/summarize", "/agents/translator")
-- This is NOT a local system file path - it operates within the AFS virtual file system
-- Use afs_list to discover available executables (look for entries with execute metadata)
-- Arguments must be a valid JSON string matching the executable's input schema
-- The executable's input/output schema can be found in its metadata`,
-            ...options,
-            inputSchema: zod_1.z.object({
-                path: zod_1.z
-                    .string()
-                    .describe("Absolute AFS path to the executable (e.g., '/skills/summarize'). Must start with '/'"),
-                args: zod_1.z
-                    .string()
-                    .describe('JSON string of arguments matching the executable\'s input schema (e.g., \'{"text": "hello"}\')'),
-            }),
-            outputSchema: zod_1.z.object({
-                data: zod_1.z.record(zod_1.z.any()),
-            }),
-        });
-    }
-    async process(input, options) {
-        if (!this.afs)
-            throw new Error("AFS is not configured for this agent.");
-        return {
-            ...(await this.afs.exec(input.path, JSON.parse(input.args), { context: options.context })),
-        };
-    }
-}
-exports.AFSExecAgent = AFSExecAgent;

package/lib/cjs/prompt/skills/afs/index.d.ts

@@ -1,3 +0,0 @@
-import type { AFS } from "@aigne/afs";
-import type { Agent } from "../../../agents/agent.js";
-export declare function getAFSSkills(afs: AFS): Promise<Agent[]>;

package/lib/cjs/prompt/skills/afs/index.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAFSSkills = getAFSSkills;
-const type_utils_js_1 = require("../../../utils/type-utils.js");
-const skill_loader_js_1 = require("./agent-skill/skill-loader.js");
-const delete_js_1 = require("./delete.js");
-const edit_js_1 = require("./edit.js");
-const exec_js_1 = require("./exec.js");
-const list_js_1 = require("./list.js");
-const read_js_1 = require("./read.js");
-const rename_js_1 = require("./rename.js");
-const search_js_1 = require("./search.js");
-const write_js_1 = require("./write.js");
-async function getAFSSkills(afs) {
-    return [
-        new list_js_1.AFSListAgent({ afs }),
-        new search_js_1.AFSSearchAgent({ afs }),
-        new read_js_1.AFSReadAgent({ afs }),
-        new write_js_1.AFSWriteAgent({ afs }),
-        new edit_js_1.AFSEditAgent({ afs }),
-        new delete_js_1.AFSDeleteAgent({ afs }),
-        new rename_js_1.AFSRenameAgent({ afs }),
-        new exec_js_1.AFSExecAgent({ afs }),
-        await (0, skill_loader_js_1.loadAgentSkillFromAFS)({ afs }),
-    ].filter(type_utils_js_1.isNonNullable);
-}

package/lib/cjs/prompt/skills/afs/list.d.ts

@@ -1,24 +0,0 @@
-import type { AFSListOptions } from "@aigne/afs";
-import type { AgentInvokeOptions, AgentOptions, Message } from "../../../agents/agent.js";
-import type { PromiseOrValue } from "../../../utils/type-utils.js";
-import { AFSSkillBase } from "./base.js";
-export interface AFSListInput extends Message {
-    path: string;
-    options?: AFSListOptions;
-}
-export interface AFSListOutput extends Message {
-    status: string;
-    tool: string;
-    path: string;
-    options?: AFSListOptions;
-    message?: string;
-    data?: unknown;
-}
-export interface AFSListAgentOptions extends AgentOptions<AFSListInput, AFSListOutput> {
-    afs: NonNullable<AgentOptions<AFSListInput, AFSListOutput>["afs"]>;
-}
-export declare class AFSListAgent extends AFSSkillBase<AFSListInput, AFSListOutput> {
-    constructor(options: AFSListAgentOptions);
-    formatOutput(output: AFSListOutput): PromiseOrValue<string>;
-    process(input: AFSListInput, options: AgentInvokeOptions): Promise<AFSListOutput>;
-}

package/lib/cjs/prompt/skills/afs/list.js

@@ -1,82 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AFSListAgent = void 0;
-const zod_1 = require("zod");
-const base_js_1 = require("./base.js");
-class AFSListAgent extends base_js_1.AFSSkillBase {
-    constructor(options) {
-        super({
-            name: "afs_list",
-            description: `List contents within the Agentic File System (AFS)
-- Returns files and directories at the specified AFS path
-- Supports recursive listing with configurable depth
-- Supports glob pattern filtering to match specific files
-- By default respects .gitignore rules to filter out ignored files
-- Use this tool when you need to explore AFS contents or understand file organization
-
-Usage:
-- The path must be an absolute AFS path starting with "/" (e.g., "/", "/docs", "/memory/user")
-- This is NOT a local system file path - it operates within the AFS virtual file system
-- Use maxDepth to control recursion depth (default: 1, current directory only)
-- Use pattern to filter entries by glob pattern:
-  - "*.ts" - match TypeScript files in current directory
-  - "**/*.js" - match all JavaScript files recursively
-  - "src/**/*.{ts,tsx}" - match TypeScript files in src directory
-- Results are filtered by .gitignore by default; set disableGitignore to include ignored files`,
-            ...options,
-            inputSchema: zod_1.z.object({
-                path: zod_1.z
-                    .string()
-                    .describe("Absolute AFS path to list (e.g., '/', '/docs', '/memory/user'). Must start with '/'"),
-                options: zod_1.z
-                    .object({
-                    maxDepth: zod_1.z
-                        .number()
-                        .optional()
-                        .describe("Maximum depth of directory recursion. 1 = current directory only, 2 = include subdirectories, etc. Default: 1"),
-                    disableGitignore: zod_1.z
-                        .boolean()
-                        .optional()
-                        .describe("Set to true to include files normally ignored by .gitignore rules. Default: false (respects .gitignore)"),
-                    maxChildren: zod_1.z
-                        .number()
-                        .optional()
-                        .describe("Maximum number of entries to return per directory. Useful for large directories to avoid overwhelming output"),
-                    pattern: zod_1.z.string().optional().describe("Glob pattern to filter entries by path"),
-                })
-                    .optional(),
-            }),
-            outputSchema: zod_1.z.object({
-                status: zod_1.z.string(),
-                tool: zod_1.z.string(),
-                path: zod_1.z.string(),
-                options: zod_1.z.record(zod_1.z.any()).optional(),
-                message: zod_1.z.string().optional(),
-                data: zod_1.z.unknown(),
-            }),
-        });
-    }
-    formatOutput(output) {
-        if (typeof output.data === "string")
-            return output.data;
-        return super.formatOutput(output);
-    }
-    async process(input, options) {
-        if (!this.afs)
-            throw new Error("AFS is not configured for this agent.");
-        const { data, message } = await this.afs.list(input.path, {
-            ...input.options,
-            format: "simple-list",
-            context: options.context,
-        });
-        return {
-            status: "success",
-            tool: "afs_list",
-            path: input.path,
-            options: input.options,
-            message,
-            data,
-        };
-    }
-}
-exports.AFSListAgent = AFSListAgent;

package/lib/cjs/prompt/skills/afs/read.d.ts

@@ -1,28 +0,0 @@
-import type { AFSEntry } from "@aigne/afs";
-import type { AgentInvokeOptions, AgentOptions, Message } from "../../../agents/agent.js";
-import type { PromiseOrValue } from "../../../utils/type-utils.js";
-import { AFSSkillBase } from "./base.js";
-export interface AFSReadInput extends Message {
-    path: string;
-    offset?: number;
-    limit?: number;
-}
-export interface AFSReadOutput extends Message {
-    status: string;
-    tool: string;
-    path: string;
-    data?: AFSEntry | null;
-    message?: string;
-    totalLines?: number;
-    returnedLines?: number;
-    truncated?: boolean;
-    offset?: number;
-}
-export interface AFSReadAgentOptions extends AgentOptions<AFSReadInput, AFSReadOutput> {
-    afs: NonNullable<AgentOptions<AFSReadInput, AFSReadOutput>["afs"]>;
-}
-export declare class AFSReadAgent extends AFSSkillBase<AFSReadInput, AFSReadOutput> {
-    constructor(options: AFSReadAgentOptions);
-    formatOutput(output: AFSReadOutput): PromiseOrValue<string>;
-    process(input: AFSReadInput, options: AgentInvokeOptions): Promise<AFSReadOutput>;
-}

package/lib/cjs/prompt/skills/afs/read.js

@@ -1,105 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AFSReadAgent = void 0;
-const zod_1 = require("zod");
-const base_js_1 = require("./base.js");
-const DEFAULT_LINE_LIMIT = 2000;
-const MAX_LINE_LENGTH = 2000;
-class AFSReadAgent extends base_js_1.AFSSkillBase {
-    constructor(options) {
-        super({
-            name: "afs_read",
-            description: `Read file contents from the Agentic File System (AFS)
-- Returns the content of a file at the specified AFS path
-- By default reads up to ${DEFAULT_LINE_LIMIT} lines, use offset/limit for large files
-- Lines longer than ${MAX_LINE_LENGTH} characters will be truncated
-
-Usage:
-- The path must be an absolute AFS path starting with "/" (e.g., "/docs/readme.md")
-- Use offset to start reading from a specific line (0-based)
-- Use limit to control number of lines returned (default: ${DEFAULT_LINE_LIMIT})
-- Check truncated field to know if file was partially returned`,
-            ...options,
-            inputSchema: zod_1.z.object({
-                path: zod_1.z
-                    .string()
-                    .describe("Absolute AFS path to the file to read (e.g., '/docs/readme.md'). Must start with '/'"),
-                offset: zod_1.z
-                    .number()
-                    .int()
-                    .min(0)
-                    .optional()
-                    .describe("Line number to start reading from (0-based, default: 0)"),
-                limit: zod_1.z
-                    .number()
-                    .int()
-                    .min(1)
-                    .max(DEFAULT_LINE_LIMIT)
-                    .optional()
-                    .describe(`Maximum number of lines to read (default: ${DEFAULT_LINE_LIMIT})`),
-            }),
-            outputSchema: zod_1.z.object({
-                status: zod_1.z.string(),
-                tool: zod_1.z.string(),
-                path: zod_1.z.string(),
-                data: zod_1.z.custom().optional(),
-                message: zod_1.z.string().optional(),
-                totalLines: zod_1.z.number().optional(),
-                returnedLines: zod_1.z.number().optional(),
-                truncated: zod_1.z.boolean().optional(),
-                offset: zod_1.z.number().optional(),
-            }),
-        });
-    }
-    formatOutput(output) {
-        if (typeof output.data?.content === "string" && output.data.content)
-            return output.data.content;
-        return super.formatOutput({ ...output, data: output.data || null });
-    }
-    async process(input, options) {
-        if (!this.afs)
-            throw new Error("AFS is not configured for this agent.");
-        const result = await this.afs.read(input.path, { context: options.context });
-        if (!result.data?.content || typeof result.data.content !== "string") {
-            return {
-                status: "success",
-                tool: "afs_read",
-                path: input.path,
-                ...result,
-            };
-        }
-        const offset = input.offset ?? 0;
-        const limit = input.limit ?? DEFAULT_LINE_LIMIT;
-        const allLines = result.data.content.split("\n");
-        const totalLines = allLines.length;
-        // Apply offset and limit
-        const selectedLines = allLines.slice(offset, offset + limit);
-        // Truncate long lines
-        const processedLines = selectedLines.map((line) => line.length > MAX_LINE_LENGTH ? `${line.substring(0, MAX_LINE_LENGTH)}... [truncated]` : line);
-        const returnedLines = processedLines.length;
-        const truncated = offset > 0 || offset + limit < totalLines;
-        const processedContent = processedLines.join("\n");
-        let message;
-        if (truncated) {
-            const startLine = offset + 1;
-            const endLine = offset + returnedLines;
-            message = `Showing lines ${startLine}-${endLine} of ${totalLines}. Use offset/limit to read more.`;
-        }
-        return {
-            status: "success",
-            tool: "afs_read",
-            path: input.path,
-            totalLines,
-            returnedLines,
-            truncated,
-            offset,
-            message,
-            ...result,
-            data: {
-                ...result.data,
-                content: processedContent,
-            },
-        };
-    }
-}
-exports.AFSReadAgent = AFSReadAgent;

package/lib/cjs/prompt/skills/afs/rename.d.ts

@@ -1,21 +0,0 @@
-import type { AgentInvokeOptions, AgentOptions, Message } from "../../../agents/agent.js";
-import { AFSSkillBase } from "./base.js";
-export interface AFSRenameInput extends Message {
-    oldPath: string;
-    newPath: string;
-    overwrite?: boolean;
-}
-export interface AFSRenameOutput extends Message {
-    status: string;
-    tool: string;
-    oldPath: string;
-    newPath: string;
-    message?: string;
-}
-export interface AFSRenameAgentOptions extends AgentOptions<AFSRenameInput, AFSRenameOutput> {
-    afs: NonNullable<AgentOptions<AFSRenameInput, AFSRenameOutput>["afs"]>;
-}
-export declare class AFSRenameAgent extends AFSSkillBase<AFSRenameInput, AFSRenameOutput> {
-    constructor(options: AFSRenameAgentOptions);
-    process(input: AFSRenameInput, options: AgentInvokeOptions): Promise<AFSRenameOutput>;
-}

package/lib/cjs/prompt/skills/afs/rename.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AFSRenameAgent = void 0;
-const zod_1 = require("zod");
-const base_js_1 = require("./base.js");
-class AFSRenameAgent extends base_js_1.AFSSkillBase {
-    constructor(options) {
-        super({
-            name: "afs_rename",
-            description: `Rename or move files and directories within the Agentic File System (AFS)
-- Renames a file or directory to a new name
-- Can also move files/directories to a different location
-- Optionally overwrites existing files at the destination
-
-Usage:
-- Both paths must be absolute AFS paths starting with "/" (e.g., "/docs/old-name.md" -> "/docs/new-name.md")
-- This is NOT a local system file path - it operates within the AFS virtual file system
-- To move a file, specify a different directory in newPath (e.g., "/docs/file.md" -> "/archive/file.md")
-- If newPath already exists, the operation will fail unless overwrite=true
-- Moving directories moves all contents recursively`,
-            ...options,
-            inputSchema: zod_1.z.object({
-                oldPath: zod_1.z
-                    .string()
-                    .describe("Current absolute AFS path (e.g., '/docs/old-name.md'). Must start with '/'"),
-                newPath: zod_1.z
-                    .string()
-                    .describe("New absolute AFS path (e.g., '/docs/new-name.md'). Must start with '/'"),
-                overwrite: zod_1.z
-                    .boolean()
-                    .optional()
-                    .default(false)
-                    .describe("Set to true to overwrite if destination already exists. Default: false (fails if exists)"),
-            }),
-            outputSchema: zod_1.z.object({
-                status: zod_1.z.string(),
-                tool: zod_1.z.string(),
-                oldPath: zod_1.z.string(),
-                newPath: zod_1.z.string(),
-                message: zod_1.z.string().optional(),
-            }),
-        });
-    }
-    async process(input, options) {
-        if (!this.afs)
-            throw new Error("AFS is not configured for this agent.");
-        const result = await this.afs.rename(input.oldPath, input.newPath, {
-            overwrite: input.overwrite ?? false,
-            context: options.context,
-        });
-        return {
-            status: "success",
-            tool: "afs_rename",
-            oldPath: input.oldPath,
-            newPath: input.newPath,
-            ...result,
-        };
-    }
-}
-exports.AFSRenameAgent = AFSRenameAgent;

package/lib/cjs/prompt/skills/afs/search.d.ts

@@ -1,24 +0,0 @@
-import type { AFSEntry, AFSSearchOptions } from "@aigne/afs";
-import type { AgentInvokeOptions, AgentOptions, Message } from "../../../agents/agent.js";
-import { AFSSkillBase } from "./base.js";
-export interface AFSSearchInput extends Message {
-    path: string;
-    query: string;
-    options?: AFSSearchOptions;
-}
-export interface AFSSearchOutput extends Message {
-    status: string;
-    tool: string;
-    path: string;
-    query: string;
-    options?: AFSSearchOptions;
-    data: AFSEntry[];
-    message?: string;
-}
-export interface AFSSearchAgentOptions extends AgentOptions<AFSSearchInput, AFSSearchOutput> {
-    afs: NonNullable<AgentOptions<AFSSearchInput, AFSSearchOutput>["afs"]>;
-}
-export declare class AFSSearchAgent extends AFSSkillBase<AFSSearchInput, AFSSearchOutput> {
-    constructor(options: AFSSearchAgentOptions);
-    process(input: AFSSearchInput, options: AgentInvokeOptions): Promise<AFSSearchOutput>;
-}