@aigne/core 1.71.0-beta.4 → 1.71.0-beta.6

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## [1.71.0-beta.6](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.71.0-beta.5...core-v1.71.0-beta.6) (2025-12-11)
+
+
+### Bug Fixes
+
+* **orchestrator:** support custom input schema for planner/worker/completer ([#823](https://github.com/AIGNE-io/aigne-framework/issues/823)) ([3d26f8b](https://github.com/AIGNE-io/aigne-framework/commit/3d26f8bac8b679010f25d9e4eb59fc6e80afda4c))
+
+## [1.71.0-beta.5](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.71.0-beta.4...core-v1.71.0-beta.5) (2025-12-11)
+
+
+### Features
+
+* **afs:** add edit/delete/rename methods for AFS ([#820](https://github.com/AIGNE-io/aigne-framework/issues/820)) ([68cb508](https://github.com/AIGNE-io/aigne-framework/commit/68cb508d1cfc9c516d56303018139f1e567f897e))
+
+
+### Bug Fixes
+
+* **core:** support access agent instance by `this` in function agent ([#822](https://github.com/AIGNE-io/aigne-framework/issues/822)) ([68103bc](https://github.com/AIGNE-io/aigne-framework/commit/68103bc8d6d553e1c1374595db98ff61f3046842))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/afs bumped to 1.3.0-beta.3
+    * @aigne/afs-history bumped to 1.1.3-beta.3
+
 ## [1.71.0-beta.4](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.71.0-beta.3...core-v1.71.0-beta.4) (2025-12-10)
 
 

package/lib/cjs/agents/agent.d.ts

@@ -303,6 +303,7 @@ export declare abstract class Agent<I extends Message = any, O extends Message =
      * @returns The Zod type definition for input data
      */
     get inputSchema(): ZodType<I>;
+    get inputKeys(): string[];
     /**
      * Get the output data schema for this agent
      *
@@ -312,6 +313,7 @@ export declare abstract class Agent<I extends Message = any, O extends Message =
      * @returns The Zod type definition for output data
      */
     get outputSchema(): ZodType<O>;
+    get outputKeys(): string[];
     /**
      * Whether to include the original input in the output
      *
@@ -938,4 +940,4 @@ export declare class FunctionAgent<I extends Message = Message, O extends Messag
  * @param context Execution context
  * @returns Processing result, can be synchronous or asynchronous
  */
-export type FunctionAgentFn<I extends Message = any, O extends Message = any> = (input: I, options: AgentInvokeOptions) => PromiseOrValue<AgentProcessResult<O>>;
+export type FunctionAgentFn<I extends Message = any, O extends Message = any, A extends FunctionAgent<I, O> = FunctionAgent<I, O>> = (this: A, input: I, options: AgentInvokeOptions) => PromiseOrValue<AgentProcessResult<O>>;

package/lib/cjs/agents/agent.js

@@ -278,6 +278,9 @@ class Agent {
         checkAgentInputOutputSchema(schema);
         return schema.passthrough();
     }
+    get inputKeys() {
+        return (0, json_schema_js_1.getZodObjectKeys)(this.inputSchema);
+    }
     /**
      * Get the output data schema for this agent
      *
@@ -292,6 +295,9 @@ class Agent {
         checkAgentInputOutputSchema(schema);
         return schema.passthrough();
     }
+    get outputKeys() {
+        return (0, json_schema_js_1.getZodObjectKeys)(this.outputSchema);
+    }
     /**
      * Whether to include the original input in the output
      *
@@ -917,7 +923,7 @@ class FunctionAgent extends Agent {
      * @returns Processing result
      */
     process(input, options) {
-        return this._process(input, options);
+        return this._process.apply(this, [input, options]);
     }
 }
 exports.FunctionAgent = FunctionAgent;

package/lib/cjs/agents/user-agent.js

@@ -32,7 +32,7 @@ class UserAgent extends agent_js_1.Agent {
     });
     async process(input, options) {
         if (this._process) {
-            return this._process(input, options);
+            return this._process.apply(this, [input, options]);
         }
         if (this.activeAgent) {
             const [output, agent] = await this.invokeChildAgent(this.activeAgent, input, {

package/lib/cjs/memory/recorder.js

@@ -57,7 +57,7 @@ class MemoryRecorder extends agent_js_1.Agent {
         if (!this._process) {
             throw new Error("MemoryRecorder process function is not defined.");
         }
-        return this._process(input, options);
+        return this._process.apply(this, [input, options]);
     }
 }
 exports.MemoryRecorder = MemoryRecorder;

package/lib/cjs/memory/retriever.js

@@ -54,7 +54,7 @@ class MemoryRetriever extends agent_js_1.Agent {
         if (!this._process) {
             throw new Error("MemoryRetriever process function is not implemented.");
         }
-        return this._process(input, options);
+        return this._process.apply(this, [input, options]);
     }
 }
 exports.MemoryRetriever = MemoryRetriever;

package/lib/cjs/prompt/prompt-builder.js

@@ -15,7 +15,7 @@ const type_utils_js_1 = require("../utils/type-utils.js");
 const afs_builtin_prompt_js_1 = require("./prompts/afs-builtin-prompt.js");
 const memory_message_template_js_1 = require("./prompts/memory-message-template.js");
 const structured_stream_instructions_js_1 = require("./prompts/structured-stream-instructions.js");
-const afs_js_1 = require("./skills/afs.js");
+const index_js_2 = require("./skills/afs/index.js");
 const template_js_1 = require("./template.js");
 class PromptBuilder {
     static from(instructions, { workingDir } = {}) {
@@ -117,7 +117,7 @@ class PromptBuilder {
                     const afs = options.agent?.afs;
                     if (!afs)
                         return [];
-                    return (0, afs_js_1.getAFSSkills)(afs).then((skills) => skills.map((s) => (0, type_utils_js_1.pick)(s, ["name", "description"])));
+                    return (0, index_js_2.getAFSSkills)(afs).then((skills) => skills.map((s) => (0, type_utils_js_1.pick)(s, ["name", "description"])));
                 },
             },
             $agent: {
@@ -364,7 +364,7 @@ class PromptBuilder {
             .concat(options.agent?.memoryAgentsAsTools ? options.agent.memories : [])
             .flatMap((i) => (i.isInvokable ? i : i.skills)), (i) => i.name);
         if (options.agent?.afs) {
-            toolAgents.push(...(await (0, afs_js_1.getAFSSkills)(options.agent.afs)));
+            toolAgents.push(...(await (0, index_js_2.getAFSSkills)(options.agent.afs)));
         }
         const tools = toolAgents.map((i) => ({
             type: "function",

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

@@ -0,0 +1,18 @@
+import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "../../../agents/agent.js";
+export interface AFSDeleteInput extends Message {
+    path: string;
+    recursive?: boolean;
+}
+export interface AFSDeleteOutput extends Message {
+    status: string;
+    tool: string;
+    path: string;
+    message?: string;
+}
+export interface AFSDeleteAgentOptions extends AgentOptions<AFSDeleteInput, AFSDeleteOutput> {
+    afs: NonNullable<AgentOptions<AFSDeleteInput, AFSDeleteOutput>["afs"]>;
+}
+export declare class AFSDeleteAgent extends Agent<AFSDeleteInput, AFSDeleteOutput> {
+    constructor(options: AFSDeleteAgentOptions);
+    process(input: AFSDeleteInput, _options: AgentInvokeOptions): Promise<AFSDeleteOutput>;
+}

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AFSDeleteAgent = void 0;
+const zod_1 = require("zod");
+const agent_js_1 = require("../../../agents/agent.js");
+class AFSDeleteAgent extends agent_js_1.Agent {
+    constructor(options) {
+        super({
+            name: "afs_delete",
+            description: "Permanently delete files or directories. Use when removing unwanted files or cleaning up temporary data.",
+            ...options,
+            inputSchema: zod_1.z.object({
+                path: zod_1.z.string().describe("Absolute file or directory path to delete"),
+                recursive: zod_1.z
+                    .boolean()
+                    .optional()
+                    .default(false)
+                    .describe("Allow directory deletion (default: false, required for directories)"),
+            }),
+            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,
+        });
+        return {
+            status: "success",
+            tool: "afs_delete",
+            path: input.path,
+            ...result,
+        };
+    }
+}
+exports.AFSDeleteAgent = AFSDeleteAgent;

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

@@ -0,0 +1,26 @@
+import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "../../../agents/agent.js";
+export interface Patch {
+    start_line: number;
+    end_line: number;
+    replace?: string;
+    delete: boolean;
+}
+export interface AFSEditInput extends Message {
+    path: string;
+    patches: Patch[];
+}
+export interface AFSEditOutput extends Message {
+    status: string;
+    tool: string;
+    path: string;
+    message: string;
+    content: string;
+}
+export interface AFSEditAgentOptions extends AgentOptions<AFSEditInput, AFSEditOutput> {
+    afs: NonNullable<AgentOptions<AFSEditInput, AFSEditOutput>["afs"]>;
+}
+export declare class AFSEditAgent extends Agent<AFSEditInput, AFSEditOutput> {
+    constructor(options: AFSEditAgentOptions);
+    process(input: AFSEditInput, _options: AgentInvokeOptions): Promise<AFSEditOutput>;
+    applyCustomPatches(text: string, patches: Patch[]): string;
+}

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

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AFSEditAgent = void 0;
+const zod_1 = require("zod");
+const agent_js_1 = require("../../../agents/agent.js");
+class AFSEditAgent extends agent_js_1.Agent {
+    constructor(options) {
+        super({
+            name: "afs_edit",
+            description: "Apply precise line-based patches to modify file content. Use when making targeted changes without rewriting the entire file.",
+            ...options,
+            inputSchema: zod_1.z.object({
+                path: zod_1.z.string().describe("Absolute file path to edit"),
+                patches: zod_1.z
+                    .array(zod_1.z.object({
+                    start_line: zod_1.z.number().int().describe("Start line number (0-based, inclusive)"),
+                    end_line: zod_1.z.number().int().describe("End line number (0-based, exclusive)"),
+                    replace: zod_1.z.string().optional().describe("New content to replace the line range"),
+                    delete: zod_1.z.boolean().describe("Delete mode: true to delete lines, false to replace"),
+                }))
+                    .min(1)
+                    .describe("List of patches to apply sequentially"),
+            }),
+            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(),
+                content: zod_1.z.string(),
+            }),
+        });
+    }
+    async process(input, _options) {
+        if (!this.afs)
+            throw new Error("AFS is not configured for this agent.");
+        if (!input.patches?.length) {
+            throw new Error("No patches provided for afs_edit.");
+        }
+        const readResult = await this.afs.read(input.path);
+        if (!readResult.result?.content || typeof readResult.result.content !== "string") {
+            throw new Error(`Cannot read file content from: ${input.path}`);
+        }
+        const originalContent = readResult.result.content;
+        const updatedContent = this.applyCustomPatches(originalContent, input.patches);
+        await this.afs.write(input.path, {
+            content: updatedContent,
+        });
+        return {
+            status: "success",
+            tool: "afs_edit",
+            path: input.path,
+            message: `Applied ${input.patches.length} patches to ${input.path}`,
+            content: updatedContent,
+        };
+    }
+    applyCustomPatches(text, patches) {
+        // Sort by start_line to ensure sequential application
+        const sorted = [...patches].sort((a, b) => a.start_line - b.start_line);
+        const lines = text.split("\n");
+        for (let i = 0; i < sorted.length; i++) {
+            const patch = sorted[i];
+            if (!patch)
+                continue;
+            const start = patch.start_line;
+            const end = patch.end_line;
+            const deleteCount = end - start; // [start, end) range
+            let delta = 0;
+            if (patch.delete) {
+                // Delete mode: remove the specified lines [start, end)
+                lines.splice(start, deleteCount);
+                delta = -deleteCount;
+            }
+            else {
+                // Replace mode: replace the specified lines with new content
+                const replaceLines = patch.replace ? patch.replace.split("\n") : [];
+                lines.splice(start, deleteCount, ...replaceLines);
+                delta = replaceLines.length - deleteCount;
+            }
+            // Update subsequent patches' line numbers
+            // For exclusive-end semantics [start, end), we adjust patches that start >= current patch's start_line
+            // after the current patch has been applied
+            if (delta !== 0) {
+                for (let j = i + 1; j < sorted.length; j++) {
+                    const next = sorted[j];
+                    if (!next)
+                        continue;
+                    // Adjust patches that start at or after the current patch's end line
+                    if (next.start_line >= patch.end_line) {
+                        next.start_line += delta;
+                        next.end_line += delta;
+                    }
+                }
+            }
+        }
+        return lines.join("\n");
+    }
+}
+exports.AFSEditAgent = AFSEditAgent;

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

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

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AFSExecAgent = void 0;
+const zod_1 = require("zod");
+const agent_js_1 = require("../../../agents/agent.js");
+class AFSExecAgent extends agent_js_1.Agent {
+    constructor(options) {
+        super({
+            name: "afs_exec",
+            description: "Execute functions or commands from AFS modules. Use when running operations provided by mounted modules.",
+            ...options,
+            inputSchema: zod_1.z.object({
+                path: zod_1.z.string().describe("Absolute path to the executable function in AFS"),
+                args: zod_1.z.string().describe("JSON string of arguments matching the function's input schema"),
+            }),
+            outputSchema: zod_1.z.object({
+                result: 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), options);
+    }
+}
+exports.AFSExecAgent = AFSExecAgent;

package/lib/cjs/prompt/skills/{afs.d.ts → afs/index.d.ts}

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

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAFSSkills = getAFSSkills;
+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 }),
+    ];
+}

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

@@ -0,0 +1,22 @@
+import type { AFSListOptions } from "@aigne/afs";
+import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "../../../agents/agent.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;
+    result: string;
+}
+export interface AFSListAgentOptions extends AgentOptions<AFSListInput, AFSListOutput> {
+    afs: NonNullable<AgentOptions<AFSListInput, AFSListOutput>["afs"]>;
+}
+export declare class AFSListAgent extends Agent<AFSListInput, AFSListOutput> {
+    constructor(options: AFSListAgentOptions);
+    process(input: AFSListInput, _options: AgentInvokeOptions): Promise<AFSListOutput>;
+    private buildTreeView;
+}

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

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AFSListAgent = void 0;
+const zod_1 = require("zod");
+const agent_js_1 = require("../../../agents/agent.js");
+class AFSListAgent extends agent_js_1.Agent {
+    constructor(options) {
+        super({
+            name: "afs_list",
+            description: "Browse directory structure as a tree view. Use when exploring directory contents or understanding file organization.",
+            ...options,
+            inputSchema: zod_1.z.object({
+                path: zod_1.z.string().describe("Absolute directory path to browse"),
+                options: zod_1.z
+                    .object({
+                    maxDepth: zod_1.z.number().optional().describe("Tree depth limit (default: 1)"),
+                })
+                    .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
+                    .object({
+                    maxDepth: zod_1.z.number().optional(),
+                })
+                    .optional(),
+                message: zod_1.z.string().optional(),
+                result: zod_1.z.string(),
+            }),
+        });
+    }
+    async process(input, _options) {
+        if (!this.afs)
+            throw new Error("AFS is not configured for this agent.");
+        const { list, message } = await this.afs.list(input.path, input.options);
+        const result = this.buildTreeView(list);
+        return {
+            status: "success",
+            tool: "afs_list",
+            path: input.path,
+            options: input.options,
+            message,
+            result,
+        };
+    }
+    buildTreeView(entries) {
+        const tree = {};
+        const entryMap = new Map();
+        for (const entry of entries) {
+            entryMap.set(entry.path, entry);
+            const parts = entry.path.split("/").filter(Boolean);
+            let current = tree;
+            for (const part of parts) {
+                if (!current[part]) {
+                    current[part] = {};
+                }
+                current = current[part];
+            }
+        }
+        const renderTree = (node, prefix = "", currentPath = "") => {
+            let result = "";
+            const keys = Object.keys(node);
+            keys.forEach((key, index) => {
+                const isLast = index === keys.length - 1;
+                const fullPath = currentPath ? `${currentPath}/${key}` : `/${key}`;
+                const entry = entryMap.get(fullPath);
+                // Build metadata suffix
+                const metadataParts = [];
+                // Children count
+                const childrenCount = entry?.metadata?.childrenCount;
+                if (childrenCount !== undefined && childrenCount > 0) {
+                    metadataParts.push(`${childrenCount} items`);
+                }
+                // Executable
+                if (entry?.metadata?.execute) {
+                    metadataParts.push("executable");
+                }
+                const metadataSuffix = metadataParts.length > 0 ? ` [${metadataParts.join(", ")}]` : "";
+                result += `${prefix}${isLast ? "└── " : "├── "}${key}${metadataSuffix}`;
+                result += `\n`;
+                result += renderTree(node[key], `${prefix}${isLast ? "    " : "│   "}`, fullPath);
+            });
+            return result;
+        };
+        return renderTree(tree);
+    }
+}
+exports.AFSListAgent = AFSListAgent;

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

@@ -0,0 +1,21 @@
+import type { AFSEntry } from "@aigne/afs";
+import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "../../../agents/agent.js";
+export interface AFSReadInput extends Message {
+    path: string;
+    withLineNumbers?: boolean;
+}
+export interface AFSReadOutput extends Message {
+    status: string;
+    tool: string;
+    path: string;
+    withLineNumbers?: boolean;
+    result?: AFSEntry;
+    message?: string;
+}
+export interface AFSReadAgentOptions extends AgentOptions<AFSReadInput, AFSReadOutput> {
+    afs: NonNullable<AgentOptions<AFSReadInput, AFSReadOutput>["afs"]>;
+}
+export declare class AFSReadAgent extends Agent<AFSReadInput, AFSReadOutput> {
+    constructor(options: AFSReadAgentOptions);
+    process(input: AFSReadInput, _options: AgentInvokeOptions): Promise<AFSReadOutput>;
+}

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AFSReadAgent = void 0;
+const zod_1 = require("zod");
+const agent_js_1 = require("../../../agents/agent.js");
+class AFSReadAgent extends agent_js_1.Agent {
+    constructor(options) {
+        super({
+            name: "afs_read",
+            description: "Read complete file contents. Use when you need to review, analyze, or understand file content before making changes.",
+            ...options,
+            inputSchema: zod_1.z.object({
+                path: zod_1.z.string().describe("Absolute file path to read"),
+                withLineNumbers: zod_1.z
+                    .boolean()
+                    .optional()
+                    .describe("Include line numbers in output (required when planning to edit the file)"),
+            }),
+            outputSchema: zod_1.z.object({
+                status: zod_1.z.string(),
+                tool: zod_1.z.string(),
+                path: zod_1.z.string(),
+                withLineNumbers: zod_1.z.boolean().optional(),
+                result: zod_1.z.custom().optional(),
+                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.read(input.path);
+        let content = result.result?.content;
+        if (input.withLineNumbers && typeof content === "string") {
+            content = content
+                .split("\n")
+                .map((line, idx) => `${idx + 1}| ${line}`)
+                .join("\n");
+        }
+        return {
+            status: "success",
+            tool: "afs_read",
+            path: input.path,
+            withLineNumbers: input.withLineNumbers,
+            ...result,
+            result: result.result && {
+                ...result.result,
+                content,
+            },
+        };
+    }
+}
+exports.AFSReadAgent = AFSReadAgent;

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

@@ -0,0 +1,20 @@
+import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "../../../agents/agent.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 Agent<AFSRenameInput, AFSRenameOutput> {
+    constructor(options: AFSRenameAgentOptions);
+    process(input: AFSRenameInput, _options: AgentInvokeOptions): Promise<AFSRenameOutput>;
+}

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AFSRenameAgent = void 0;
+const zod_1 = require("zod");
+const agent_js_1 = require("../../../agents/agent.js");
+class AFSRenameAgent extends agent_js_1.Agent {
+    constructor(options) {
+        super({
+            name: "afs_rename",
+            description: "Rename or move files and directories. Use when reorganizing files, changing names, or moving to different locations.",
+            ...options,
+            inputSchema: zod_1.z.object({
+                oldPath: zod_1.z.string().describe("Absolute current file or directory path"),
+                newPath: zod_1.z.string().describe("Absolute new file or directory path"),
+                overwrite: zod_1.z
+                    .boolean()
+                    .optional()
+                    .default(false)
+                    .describe("Overwrite if destination exists (default: false)"),
+            }),
+            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,
+        });
+        return {
+            status: "success",
+            tool: "afs_rename",
+            oldPath: input.oldPath,
+            newPath: input.newPath,
+            ...result,
+        };
+    }
+}
+exports.AFSRenameAgent = AFSRenameAgent;