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

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

@@ -0,0 +1,23 @@
+import type { AFSEntry, AFSSearchOptions } from "@aigne/afs";
+import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "../../../agents/agent.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;
+    list: AFSEntry[];
+    message?: string;
+}
+export interface AFSSearchAgentOptions extends AgentOptions<AFSSearchInput, AFSSearchOutput> {
+    afs: NonNullable<AgentOptions<AFSSearchInput, AFSSearchOutput>["afs"]>;
+}
+export declare class AFSSearchAgent extends Agent<AFSSearchInput, AFSSearchOutput> {
+    constructor(options: AFSSearchAgentOptions);
+    process(input: AFSSearchInput, _options: AgentInvokeOptions): Promise<AFSSearchOutput>;
+}

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AFSSearchAgent = void 0;
+const zod_1 = require("zod");
+const agent_js_1 = require("../../../agents/agent.js");
+class AFSSearchAgent extends agent_js_1.Agent {
+    constructor(options) {
+        super({
+            name: "afs_search",
+            description: "Search file contents by keywords. Use when finding files containing specific text or code patterns.",
+            ...options,
+            inputSchema: zod_1.z.object({
+                path: zod_1.z.string().describe("Absolute directory path to search in"),
+                query: zod_1.z.string().describe("Search keywords or patterns"),
+                options: zod_1.z
+                    .object({
+                    limit: zod_1.z.number().optional().describe("Max results to return"),
+                    caseSensitive: zod_1.z
+                        .boolean()
+                        .optional()
+                        .describe("Case-sensitive search (default: false)"),
+                })
+                    .optional(),
+            }),
+            outputSchema: zod_1.z.object({
+                status: zod_1.z.string(),
+                tool: zod_1.z.string(),
+                path: zod_1.z.string(),
+                query: zod_1.z.string(),
+                options: zod_1.z
+                    .object({
+                    limit: zod_1.z.number().optional(),
+                    caseSensitive: zod_1.z.boolean().optional(),
+                })
+                    .optional(),
+                list: zod_1.z.array(zod_1.z.custom()),
+                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.search(input.path, input.query, input.options);
+        return {
+            status: "success",
+            tool: "afs_search",
+            path: input.path,
+            query: input.query,
+            options: input.options,
+            ...result,
+        };
+    }
+}
+exports.AFSSearchAgent = AFSSearchAgent;

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

@@ -0,0 +1,19 @@
+import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "../../../agents/agent.js";
+export interface AFSWriteInput extends Message {
+    path: string;
+    content: string;
+    append?: boolean;
+}
+export interface AFSWriteOutput extends Message {
+    status: string;
+    tool: string;
+    path: string;
+    message?: string;
+}
+export interface AFSWriteAgentOptions extends AgentOptions<AFSWriteInput, AFSWriteOutput> {
+    afs: NonNullable<AgentOptions<AFSWriteInput, AFSWriteOutput>["afs"]>;
+}
+export declare class AFSWriteAgent extends Agent<AFSWriteInput, AFSWriteOutput> {
+    constructor(options: AFSWriteAgentOptions);
+    process(input: AFSWriteInput, _options: AgentInvokeOptions): Promise<AFSWriteOutput>;
+}

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AFSWriteAgent = void 0;
+const zod_1 = require("zod");
+const agent_js_1 = require("../../../agents/agent.js");
+class AFSWriteAgent extends agent_js_1.Agent {
+    constructor(options) {
+        super({
+            name: "afs_write",
+            description: "Create new file or append content to existing file. Use when creating files, rewriting entire files, or appending to files.",
+            ...options,
+            inputSchema: zod_1.z.object({
+                path: zod_1.z.string().describe("Absolute file path to write"),
+                content: zod_1.z.string().describe("Complete file content or content to append"),
+                append: zod_1.z
+                    .boolean()
+                    .optional()
+                    .default(false)
+                    .describe("Append mode: add content to end of file (default: false, overwrites file)"),
+            }),
+            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.write(input.path, {
+            content: input.content,
+        }, {
+            append: input.append ?? false,
+        });
+        return {
+            status: "success",
+            tool: "afs_write",
+            path: input.path,
+            ...result,
+        };
+    }
+}
+exports.AFSWriteAgent = AFSWriteAgent;

package/lib/cjs/utils/json-schema.d.ts

@@ -12,3 +12,4 @@ export declare function parseJSON(json: string): any;
 export declare function ensureZodUnionArray<T extends z.ZodType>(union: T[]): [T, T, ...T[]];
 export declare function isZodSchema(schema: ZodType): schema is ZodType;
 export declare const wrapAutoParseJsonSchema: <T extends ZodType>(schema: T) => T;
+export declare function getZodObjectKeys(schema: ZodType): string[];

package/lib/cjs/utils/json-schema.js

@@ -5,6 +5,7 @@ exports.outputSchemaToResponseFormatSchema = outputSchemaToResponseFormatSchema;
 exports.parseJSON = parseJSON;
 exports.ensureZodUnionArray = ensureZodUnionArray;
 exports.isZodSchema = isZodSchema;
+exports.getZodObjectKeys = getZodObjectKeys;
 const zod_1 = require("zod");
 const zod_to_json_schema_1 = require("zod-to-json-schema");
 const json_utils_js_1 = require("./json-utils.js");
@@ -115,3 +116,8 @@ const wrapAutoParseJsonSchema = (schema) => {
     return schema;
 };
 exports.wrapAutoParseJsonSchema = wrapAutoParseJsonSchema;
+function getZodObjectKeys(schema) {
+    if ("shape" in schema && schema.shape)
+        return Object.keys(schema.shape);
+    return [];
+}

package/lib/dts/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/dts/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/dts/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/dts/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/dts/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/dts/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/dts/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/dts/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/dts/prompt/skills/afs/search.d.ts

@@ -0,0 +1,23 @@
+import type { AFSEntry, AFSSearchOptions } from "@aigne/afs";
+import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "../../../agents/agent.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;
+    list: AFSEntry[];
+    message?: string;
+}
+export interface AFSSearchAgentOptions extends AgentOptions<AFSSearchInput, AFSSearchOutput> {
+    afs: NonNullable<AgentOptions<AFSSearchInput, AFSSearchOutput>["afs"]>;
+}
+export declare class AFSSearchAgent extends Agent<AFSSearchInput, AFSSearchOutput> {
+    constructor(options: AFSSearchAgentOptions);
+    process(input: AFSSearchInput, _options: AgentInvokeOptions): Promise<AFSSearchOutput>;
+}

package/lib/dts/prompt/skills/afs/write.d.ts

@@ -0,0 +1,19 @@
+import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "../../../agents/agent.js";
+export interface AFSWriteInput extends Message {
+    path: string;
+    content: string;
+    append?: boolean;
+}
+export interface AFSWriteOutput extends Message {
+    status: string;
+    tool: string;
+    path: string;
+    message?: string;
+}
+export interface AFSWriteAgentOptions extends AgentOptions<AFSWriteInput, AFSWriteOutput> {
+    afs: NonNullable<AgentOptions<AFSWriteInput, AFSWriteOutput>["afs"]>;
+}
+export declare class AFSWriteAgent extends Agent<AFSWriteInput, AFSWriteOutput> {
+    constructor(options: AFSWriteAgentOptions);
+    process(input: AFSWriteInput, _options: AgentInvokeOptions): Promise<AFSWriteOutput>;
+}

package/lib/dts/utils/json-schema.d.ts

@@ -12,3 +12,4 @@ export declare function parseJSON(json: string): any;
 export declare function ensureZodUnionArray<T extends z.ZodType>(union: T[]): [T, T, ...T[]];
 export declare function isZodSchema(schema: ZodType): schema is ZodType;
 export declare const wrapAutoParseJsonSchema: <T extends ZodType>(schema: T) => T;
+export declare function getZodObjectKeys(schema: ZodType): string[];

package/lib/esm/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/esm/agents/agent.js

@@ -6,7 +6,7 @@ import { joinURL } from "ufo";
 import { z } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { sortHooks } from "../utils/agent-utils.js";
-import { isZodSchema } from "../utils/json-schema.js";
+import { getZodObjectKeys, isZodSchema } from "../utils/json-schema.js";
 import { logger } from "../utils/logger.js";
 import { agentResponseStreamToObject, asyncGeneratorToReadableStream, isAsyncGenerator, mergeAgentResponseChunk, objectToAgentResponseStream, onAgentResponseStreamEnd, } from "../utils/stream-utils.js";
 import { checkArguments, createAccessorArray, flat, isEmpty, isNil, isNonNullable, isRecord, } from "../utils/type-utils.js";
@@ -230,6 +230,9 @@ export class Agent {
         checkAgentInputOutputSchema(schema);
         return schema.passthrough();
     }
+    get inputKeys() {
+        return getZodObjectKeys(this.inputSchema);
+    }
     /**
      * Get the output data schema for this agent
      *
@@ -244,6 +247,9 @@ export class Agent {
         checkAgentInputOutputSchema(schema);
         return schema.passthrough();
     }
+    get outputKeys() {
+        return getZodObjectKeys(this.outputSchema);
+    }
     /**
      * Whether to include the original input in the output
      *
@@ -868,7 +874,7 @@ export class FunctionAgent extends Agent {
      * @returns Processing result
      */
     process(input, options) {
-        return this._process(input, options);
+        return this._process.apply(this, [input, options]);
     }
 }
 function functionToAgent(agent) {

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

@@ -29,7 +29,7 @@ export class UserAgent extends 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/esm/memory/recorder.js

@@ -54,6 +54,6 @@ export class MemoryRecorder extends 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]);
     }
 }

package/lib/esm/memory/retriever.js

@@ -51,6 +51,6 @@ export class MemoryRetriever extends 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]);
     }
 }

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

@@ -12,7 +12,7 @@ import { checkArguments, flat, isNonNullable, isRecord, partition, pick, unique,
 import { AFS_DESCRIPTION_PROMPT_TEMPLATE, AFS_EXECUTABLE_TOOLS_PROMPT_TEMPLATE, getAFSSystemPrompt, } from "./prompts/afs-builtin-prompt.js";
 import { MEMORY_MESSAGE_TEMPLATE } from "./prompts/memory-message-template.js";
 import { STRUCTURED_STREAM_INSTRUCTIONS } from "./prompts/structured-stream-instructions.js";
-import { getAFSSkills } from "./skills/afs.js";
+import { getAFSSkills } from "./skills/afs/index.js";
 import { AgentMessageTemplate, ChatMessagesTemplate, PromptTemplate, SystemMessageTemplate, UserMessageTemplate, } from "./template.js";
 export class PromptBuilder {
     static from(instructions, { workingDir } = {}) {

package/lib/esm/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/esm/prompt/skills/afs/delete.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { Agent, } from "../../../agents/agent.js";
+export class AFSDeleteAgent extends 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: z.object({
+                path: z.string().describe("Absolute file or directory path to delete"),
+                recursive: z
+                    .boolean()
+                    .optional()
+                    .default(false)
+                    .describe("Allow directory deletion (default: false, required for directories)"),
+            }),
+            outputSchema: z.object({
+                status: z.string(),
+                tool: z.string(),
+                path: z.string(),
+                message: 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,
+        };
+    }
+}

package/lib/esm/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/esm/prompt/skills/afs/edit.js

@@ -0,0 +1,94 @@
+import { z } from "zod";
+import { Agent, } from "../../../agents/agent.js";
+export class AFSEditAgent extends 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: z.object({
+                path: z.string().describe("Absolute file path to edit"),
+                patches: z
+                    .array(z.object({
+                    start_line: z.number().int().describe("Start line number (0-based, inclusive)"),
+                    end_line: z.number().int().describe("End line number (0-based, exclusive)"),
+                    replace: z.string().optional().describe("New content to replace the line range"),
+                    delete: z.boolean().describe("Delete mode: true to delete lines, false to replace"),
+                }))
+                    .min(1)
+                    .describe("List of patches to apply sequentially"),
+            }),
+            outputSchema: z.object({
+                status: z.string(),
+                tool: z.string(),
+                path: z.string(),
+                message: z.string(),
+                content: 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");
+    }
+}