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

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

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { Agent, } from "../../../agents/agent.js";
+export class AFSExecAgent extends 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: z.object({
+                path: z.string().describe("Absolute path to the executable function in AFS"),
+                args: z.string().describe("JSON string of arguments matching the function's input schema"),
+            }),
+            outputSchema: z.object({
+                result: z.record(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);
+    }
+}

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

@@ -0,0 +1,20 @@
+import { AFSDeleteAgent } from "./delete.js";
+import { AFSEditAgent } from "./edit.js";
+import { AFSExecAgent } from "./exec.js";
+import { AFSListAgent } from "./list.js";
+import { AFSReadAgent } from "./read.js";
+import { AFSRenameAgent } from "./rename.js";
+import { AFSSearchAgent } from "./search.js";
+import { AFSWriteAgent } from "./write.js";
+export async function getAFSSkills(afs) {
+    return [
+        new AFSListAgent({ afs }),
+        new AFSSearchAgent({ afs }),
+        new AFSReadAgent({ afs }),
+        new AFSWriteAgent({ afs }),
+        new AFSEditAgent({ afs }),
+        new AFSDeleteAgent({ afs }),
+        new AFSRenameAgent({ afs }),
+        new AFSExecAgent({ afs }),
+    ];
+}

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

@@ -0,0 +1,86 @@
+import { z } from "zod";
+import { Agent, } from "../../../agents/agent.js";
+export class AFSListAgent extends 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: z.object({
+                path: z.string().describe("Absolute directory path to browse"),
+                options: z
+                    .object({
+                    maxDepth: z.number().optional().describe("Tree depth limit (default: 1)"),
+                })
+                    .optional(),
+            }),
+            outputSchema: z.object({
+                status: z.string(),
+                tool: z.string(),
+                path: z.string(),
+                options: z
+                    .object({
+                    maxDepth: z.number().optional(),
+                })
+                    .optional(),
+                message: z.string().optional(),
+                result: 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);
+    }
+}

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

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { Agent, } from "../../../agents/agent.js";
+export class AFSReadAgent extends 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: z.object({
+                path: z.string().describe("Absolute file path to read"),
+                withLineNumbers: z
+                    .boolean()
+                    .optional()
+                    .describe("Include line numbers in output (required when planning to edit the file)"),
+            }),
+            outputSchema: z.object({
+                status: z.string(),
+                tool: z.string(),
+                path: z.string(),
+                withLineNumbers: z.boolean().optional(),
+                result: z.custom().optional(),
+                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.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,
+            },
+        };
+    }
+}

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

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { Agent, } from "../../../agents/agent.js";
+export class AFSRenameAgent extends 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: z.object({
+                oldPath: z.string().describe("Absolute current file or directory path"),
+                newPath: z.string().describe("Absolute new file or directory path"),
+                overwrite: z
+                    .boolean()
+                    .optional()
+                    .default(false)
+                    .describe("Overwrite if destination exists (default: false)"),
+            }),
+            outputSchema: z.object({
+                status: z.string(),
+                tool: z.string(),
+                oldPath: z.string(),
+                newPath: 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.rename(input.oldPath, input.newPath, {
+            overwrite: input.overwrite ?? false,
+        });
+        return {
+            status: "success",
+            tool: "afs_rename",
+            oldPath: input.oldPath,
+            newPath: input.newPath,
+            ...result,
+        };
+    }
+}

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

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { Agent, } from "../../../agents/agent.js";
+export class AFSSearchAgent extends 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: z.object({
+                path: z.string().describe("Absolute directory path to search in"),
+                query: z.string().describe("Search keywords or patterns"),
+                options: z
+                    .object({
+                    limit: z.number().optional().describe("Max results to return"),
+                    caseSensitive: z
+                        .boolean()
+                        .optional()
+                        .describe("Case-sensitive search (default: false)"),
+                })
+                    .optional(),
+            }),
+            outputSchema: z.object({
+                status: z.string(),
+                tool: z.string(),
+                path: z.string(),
+                query: z.string(),
+                options: z
+                    .object({
+                    limit: z.number().optional(),
+                    caseSensitive: z.boolean().optional(),
+                })
+                    .optional(),
+                list: z.array(z.custom()),
+                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.search(input.path, input.query, input.options);
+        return {
+            status: "success",
+            tool: "afs_search",
+            path: input.path,
+            query: input.query,
+            options: input.options,
+            ...result,
+        };
+    }
+}

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

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { Agent, } from "../../../agents/agent.js";
+export class AFSWriteAgent extends 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: z.object({
+                path: z.string().describe("Absolute file path to write"),
+                content: z.string().describe("Complete file content or content to append"),
+                append: z
+                    .boolean()
+                    .optional()
+                    .default(false)
+                    .describe("Append mode: add content to end of file (default: false, overwrites file)"),
+            }),
+            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.write(input.path, {
+            content: input.content,
+        }, {
+            append: input.append ?? false,
+        });
+        return {
+            status: "success",
+            tool: "afs_write",
+            path: input.path,
+            ...result,
+        };
+    }
+}

package/lib/esm/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/utils/json-schema.js

@@ -107,3 +107,8 @@ export const wrapAutoParseJsonSchema = (schema) => {
     }
     return schema;
 };
+export function getZodObjectKeys(schema) {
+    if ("shape" in schema && schema.shape)
+        return Object.keys(schema.shape);
+    return [];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/core",
-  "version": "1.71.0-beta.4",
+  "version": "1.71.0-beta.6",
   "description": "The functional core of agentic AI",
   "publishConfig": {
     "access": "public"
@@ -92,9 +92,9 @@
     "zod": "^3.25.67",
     "zod-from-json-schema": "^0.0.5",
     "zod-to-json-schema": "^3.24.6",
-    "@aigne/afs": "^1.3.0-beta.2",
-    "@aigne/afs-history": "^1.1.3-beta.2",
+    "@aigne/afs": "^1.3.0-beta.3",
     "@aigne/platform-helpers": "^0.6.6-beta",
+    "@aigne/afs-history": "^1.1.3-beta.3",
     "@aigne/observability-api": "^0.11.13-beta.1"
   },
   "devDependencies": {

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

@@ -1,177 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAFSSkills = getAFSSkills;
-const zod_1 = require("zod");
-const agent_js_1 = require("../../agents/agent.js");
-async function getAFSSkills(afs) {
-    return [
-        agent_js_1.FunctionAgent.from({
-            name: "afs_list",
-            description: "Get a tree view of directory contents in the AFS - shows hierarchical structure of files and folders",
-            inputSchema: zod_1.z.object({
-                path: zod_1.z.string().describe("The directory path to browse (e.g., '/', '/docs', '/src')"),
-                options: zod_1.z
-                    .object({
-                    maxDepth: zod_1.z.number().optional().describe("Maximum depth to display in the tree view"),
-                })
-                    .optional(),
-            }),
-            process: async (input) => {
-                const { list, message } = await afs.list(input.path, input.options);
-                const result = buildTreeView(list);
-                return {
-                    status: "success",
-                    tool: "afs_list",
-                    path: input.path,
-                    options: input.options,
-                    message,
-                    result,
-                };
-            },
-        }),
-        agent_js_1.FunctionAgent.from({
-            name: "afs_search",
-            description: "Find files by searching content using keywords - returns matching files with their paths",
-            inputSchema: zod_1.z.object({
-                path: zod_1.z.string().describe("The directory path to search in (e.g., '/', '/docs')"),
-                query: zod_1.z
-                    .string()
-                    .describe("Keywords to search for in file contents (e.g., 'function authentication', 'database config')"),
-                options: zod_1.z
-                    .object({
-                    limit: zod_1.z.number().optional().describe("Maximum number of entries to return"),
-                    caseSensitive: zod_1.z
-                        .boolean()
-                        .optional()
-                        .describe("Whether the search is case sensitive, default is false"),
-                })
-                    .optional(),
-            }),
-            process: async (input) => {
-                const result = await afs.search(input.path, input.query, input.options);
-                return {
-                    status: "success",
-                    tool: "afs_search",
-                    path: input.path,
-                    query: input.query,
-                    options: input.options,
-                    ...result,
-                };
-            },
-        }),
-        agent_js_1.FunctionAgent.from({
-            name: "afs_read",
-            description: `\
-Read file contents from the AFS - path must be an exact file path from list or search results
-
-Usage:
-- Use withLineNumbers=true to get line numbers for code reviews or edits
-`,
-            inputSchema: zod_1.z.object({
-                path: zod_1.z
-                    .string()
-                    .describe("Exact file path from list or search results (e.g., '/docs/api.md', '/src/utils/helper.js')"),
-                withLineNumbers: zod_1.z
-                    .boolean()
-                    .optional()
-                    .describe(`Whether to include line numbers in the returned content, default is false`),
-            }),
-            process: async (input) => {
-                const result = await 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,
-                        content,
-                    },
-                };
-            },
-        }),
-        agent_js_1.FunctionAgent.from({
-            name: "afs_write",
-            description: "Create or update a file in the AFS with new content - overwrites existing files",
-            inputSchema: zod_1.z.object({
-                path: zod_1.z
-                    .string()
-                    .describe("Full file path where to write content (e.g., '/docs/new-file.md', '/src/component.js')"),
-                content: zod_1.z.string().describe("The text content to write to the file"),
-            }),
-            process: async (input) => {
-                const result = await afs.write(input.path, {
-                    content: input.content,
-                });
-                return {
-                    status: "success",
-                    tool: "afs_write",
-                    path: input.path,
-                    ...result,
-                };
-            },
-        }),
-        agent_js_1.FunctionAgent.from({
-            name: "afs_exec",
-            description: "Execute a function or command available in the AFS modules",
-            inputSchema: zod_1.z.object({
-                path: zod_1.z.string().describe("The exact path to the executable entry in AFS"),
-                args: zod_1.z
-                    .string()
-                    .describe("JSON stringified arguments to pass to the executable, must be an object matching the input schema of the executable"),
-            }),
-            process: async ({ path, args }, options) => {
-                return await afs.exec(path, JSON.parse(args), options);
-            },
-        }),
-    ];
-}
-function 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];
-        }
-    }
-    function 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);
-}