psadk 1.1.0 → 1.1.1

package/build/module/lib/tools/PSCommandLineTool.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PSCommandLineTool = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const child_process_1 = require("child_process");
+const v4_1 = require("zod/v4");
+const PSAgentTool_1 = require("../PSAgentTool");
+const helpers_1 = require("../utils/helpers");
+class PSCommandLineTool extends PSAgentTool_1.PSAgentTool {
+    static toolName = "run_commandline";
+    cwd;
+    constructor(options) {
+        super({
+            name: PSCommandLineTool.toolName,
+            description: "executes a shell command in the command shell like bash.",
+            type: "API",
+            local_execution: true,
+            hitl: true,
+            inputschema: {
+                url: "http://localhost/run_commandline",
+                method: "POST",
+                requestBody: v4_1.z.toJSONSchema(v4_1.z.object({
+                    command: v4_1.z.string().meta({
+                        title: "command",
+                        description: "The command to run in the bash command shell."
+                    }),
+                }).meta({
+                    title: "run_commandline_request_body",
+                    description: "The request body parameters for the run_commandline tool.",
+                }), { "io": "input" }),
+            },
+        });
+        this.cwd = options.cwd || process.cwd();
+    }
+    run(input, log) {
+        if (!input.command || typeof input.command !== "string") {
+            throw new Error("Invalid command provided.");
+        }
+        const logger = log || console;
+        return new Promise((resolve, reject) => {
+            const command = (0, helpers_1.unEscapeHTML)(input.command);
+            try {
+                logger.info(`🛠️ Running command: \`${command}\``);
+                const output = (0, child_process_1.execSync)(command, { cwd: this.cwd, encoding: 'utf-8' });
+                logger.info("```bash\n"
+                    + `> ${command}\n`
+                    + `${output}\n`
+                    + "```\n\n");
+                return resolve({
+                    status: 'success',
+                    output: output || "Command executed successfully with no output.",
+                });
+            }
+            catch (error) {
+                console.error(error);
+                const sperr = error;
+                if (error instanceof Error) {
+                    reject(new Error(`Failed to execute command: ${command}. Error: ${error.message}`));
+                }
+                else if (sperr) {
+                    if (sperr.stderr !== '' && sperr.stderr !== undefined && sperr.stdout !== undefined) {
+                        reject(new Error(`${sperr.stderr}\n${sperr.stdout}\nexit code: ${sperr.status}`));
+                    }
+                    else
+                        reject(new Error(`Failed to execute command: ${command}. Exit code: ${sperr.status}, Error: ${sperr.stderr}`));
+                }
+                else {
+                    reject(new Error(`Failed to execute command: ${command}. Unknown error.`));
+                }
+            }
+        });
+    }
+}
+exports.PSCommandLineTool = PSCommandLineTool;
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/lib/tools/PSReadFileTool.d.ts

@@ -0,0 +1,10 @@
+import { PSAgentLogger } from "../PSAgentLogger";
+import { PSAgentTool } from "../PSAgentTool";
+export declare class PSReadFileTool extends PSAgentTool {
+    static readonly toolName = "read_file";
+    private paths;
+    constructor(options: {
+        paths?: string[];
+    });
+    run(input: Record<string, any>, log?: PSAgentLogger): Promise<Record<string, any>>;
+}

package/build/module/lib/tools/PSReadFileTool.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PSReadFileTool = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const v4_1 = require("zod/v4");
+const PSAgentTool_1 = require("../PSAgentTool");
+const helpers_1 = require("../utils/helpers");
+class PSReadFileTool extends PSAgentTool_1.PSAgentTool {
+    static toolName = "read_file";
+    paths = [];
+    constructor(options) {
+        super({
+            name: PSReadFileTool.toolName,
+            description: "Reads content of a 'file' from the repository identified by 'path'.",
+            type: "API",
+            local_execution: true,
+            hitl: true,
+            inputschema: {
+                url: `http://localhost/${PSReadFileTool.toolName}`,
+                method: "POST",
+                requestBody: v4_1.z.toJSONSchema(v4_1.z.object({
+                    path: v4_1.z.string().meta({
+                        title: "File_Path",
+                        description: "The path of the file to be read. This should be a valid file path of files in the repository."
+                    }),
+                }).meta({
+                    title: `${PSReadFileTool.toolName}_request_body`,
+                    description: `The request body parameters for the ${PSReadFileTool.toolName} tool.`,
+                }), { "io": "input" }),
+            },
+        });
+        this.paths = options.paths || [];
+    }
+    run(input, log) {
+        if (!input.path || typeof input.path !== "string") {
+            throw new Error("Invalid file path provided.");
+        }
+        const logger = log || console;
+        return new Promise((resolve, reject) => {
+            const filePath = path_1.default.resolve(...this.paths, input.path);
+            if (!fs_1.default.existsSync(filePath)) {
+                reject(new Error(`File not found at path: ${input.path}`));
+                return;
+            }
+            const stats = fs_1.default.statSync(filePath); // Ensure the file exists
+            if (stats.isFile()) {
+                logger.info(`📖 Reading file:\`${input.path}\` ${(0, helpers_1.formatFileSize)(stats.size)}`);
+                const content = fs_1.default.readFileSync(filePath, 'utf-8');
+                // logger.info(`> Read ${stats.size} bytes from file.`);
+                return resolve({
+                    status: 'success',
+                    content,
+                    size: stats.size,
+                });
+            }
+            else {
+                reject(new Error(`Path is not a file: ${input.path}`));
+            }
+        });
+    }
+}
+exports.PSReadFileTool = PSReadFileTool;
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/lib/tools/PSSubAgentTool.d.ts

@@ -0,0 +1,20 @@
+import { AgentExecutionEvent, ExecutionEventBus } from "@a2a-js/sdk/server";
+import { PSAgent } from "../PSAgent";
+import { PSAgentTool } from "../PSAgentTool";
+export declare class PSExecutionEventBus implements ExecutionEventBus {
+    listeners: {
+        [eventName: string]: ((event: AgentExecutionEvent) => void)[];
+    };
+    publish(event: AgentExecutionEvent): void;
+    on(eventName: 'event' | 'finished', listener: (event: AgentExecutionEvent) => void): this;
+    off(eventName: 'event' | 'finished', listener: (event: AgentExecutionEvent) => void): this;
+    once(eventName: 'event' | 'finished', listener: (event: AgentExecutionEvent) => void): this;
+    removeAllListeners(eventName?: 'event' | 'finished'): this;
+    finished(): void;
+}
+export declare class PSSubAgentTool extends PSAgentTool {
+    static TOOL_NAME: string;
+    private readonly sub_agents;
+    constructor(sub_agents: PSAgent[]);
+    run(input: Record<string, any>): Promise<Record<string, any>>;
+}

package/build/module/lib/tools/PSSubAgentTool.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PSSubAgentTool = exports.PSExecutionEventBus = void 0;
+const server_1 = require("@a2a-js/sdk/server");
+const zod_1 = require("zod");
+const PSAgentTool_1 = require("../PSAgentTool");
+class PSExecutionEventBus {
+    listeners = {};
+    publish(event) {
+        console.log(`Event published: ${JSON.stringify(event)}`);
+    }
+    on(eventName, listener) {
+        console.log(`Listener added for event: ${eventName}`);
+        if (!this.listeners[eventName]) {
+            this.listeners[eventName] = [];
+        }
+        this.listeners[eventName].push(listener);
+        return this;
+    }
+    ;
+    off(eventName, listener) {
+        console.log(`Listener removed for event: ${eventName}`);
+        if (!this.listeners[eventName])
+            return this;
+        this.listeners[eventName] = this.listeners[eventName].filter(l => l !== listener);
+        return this;
+    }
+    once(eventName, listener) {
+        console.log(`Once listener added for event: ${eventName}`);
+        if (!this.listeners[eventName]) {
+            this.listeners[eventName] = [];
+        }
+        const onceListener = (event) => {
+            listener(event);
+            this.off(eventName, onceListener);
+        };
+        this.listeners[eventName].push(onceListener);
+        return this;
+    }
+    removeAllListeners(eventName) {
+        if (eventName) {
+            console.log(`All listeners removed for event: ${eventName}`);
+            delete this.listeners[eventName];
+        }
+        else {
+            console.log(`All listeners removed`);
+            this.listeners = {};
+        }
+        return this;
+    }
+    finished() {
+        this.listeners = {};
+        console.log(`Event bus finished`);
+    }
+}
+exports.PSExecutionEventBus = PSExecutionEventBus;
+class PSSubAgentTool extends PSAgentTool_1.PSAgentTool {
+    static TOOL_NAME = "subagent_tool";
+    sub_agents;
+    constructor(sub_agents) {
+        super({
+            name: PSSubAgentTool.TOOL_NAME,
+            description: generateDescription(sub_agents),
+            inputschema: {
+                url: `http://localhost/${PSSubAgentTool.TOOL_NAME}`,
+                method: "POST",
+                requestBody: {
+                    type: "object",
+                    properties: {
+                        sub_agents: {
+                            type: "array",
+                            title: "sub_agents",
+                            description: "Array of sub agents to be invoked",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    name: {
+                                        type: "string",
+                                        title: "subagent name",
+                                        description: "The name of the sub agent",
+                                    },
+                                    input: {
+                                        type: "object",
+                                        title: "input",
+                                        description: "The input to the sub agent",
+                                    },
+                                },
+                                required: ["name", "input"]
+                            },
+                        }
+                    },
+                    required: ["sub_agents"],
+                }
+            }
+        });
+        this.sub_agents = sub_agents || [];
+    }
+    async run(input) {
+        console.log(`Invoking ${PSSubAgentTool.TOOL_NAME} with input: ${JSON.stringify(input)}`);
+        const agentworkers = Array();
+        for (const sa_input of input.sub_agents) {
+            const sa = this.sub_agents.find(s => s.Name === sa_input.name);
+            if (!sa) {
+                return {
+                    status: "error",
+                    output: `Sub agent with name ${sa_input.name} not found`
+                };
+            }
+            // TODO: validate input against sa.InputSchema
+            // if valid, invoke the sub agent
+            // else return error
+            // const validation = sa.validateInput(sa_input.input as any);
+            // if(!validation.valid) {
+            //   return {
+            //     status: "error",
+            //     output: `Input validation failed for sub agent ${sa_input.name}: ${validation.errors?.map(e=>e.message).join(", ")}`
+            //   }
+            // }
+            agentworkers.push(new Promise((resolve, reject) => {
+                try {
+                    const taskId = (0, zod_1.uuidv4)().toString();
+                    const userMessage = {
+                        kind: "message",
+                        messageId: (0, zod_1.uuidv4)().toString(),
+                        parts: [
+                            {
+                                kind: "text",
+                                text: JSON.stringify(sa_input.input, null, 2)
+                            }
+                        ],
+                        role: "user",
+                        taskId
+                    };
+                    const reqContext = new server_1.RequestContext(userMessage, taskId, (0, zod_1.uuidv4)().toString());
+                    console.log(userMessage, taskId, reqContext);
+                    const eventBus = new PSExecutionEventBus();
+                    sa.execute(reqContext, eventBus).then((result) => {
+                        console.log(`Sub agent ${sa_input.name} completed with result: ${JSON.stringify(result)}`);
+                        resolve({
+                            status: "success",
+                            output: result
+                        });
+                    }).catch((e) => {
+                        console.error(`Sub agent ${sa_input.name} failed with error: ${e.message}`);
+                        reject({
+                            status: "error",
+                            output: `Sub agent ${sa_input.name} invocation failed with error: ${e.message}`
+                        });
+                    });
+                }
+                catch (e) {
+                    reject({
+                        status: "error",
+                        output: `Sub agent ${sa_input.name} invocation failed with error: ${e.message}`
+                    });
+                }
+            }));
+            const results = await Promise.all(agentworkers).then((results) => {
+                console.log(`All sub agents completed with results: ${JSON.stringify(results)}`);
+                return {
+                    status: "success",
+                    output: results
+                };
+            }).catch((e) => {
+                console.error(`One or more sub agents failed with error: ${e.message}`);
+                return {
+                    status: "error",
+                    output: `One or more sub agents invocation failed with error: ${e.message}`
+                };
+            });
+            return results;
+        }
+        return {
+            status: "error",
+            output: `Not implemented yet`
+        };
+    }
+}
+exports.PSSubAgentTool = PSSubAgentTool;
+function generateDescription(sub_agents) {
+    //`Use this ${PSSubAgentTool.TOOL_NAME} one or more of sub agents available.
+    const description = `
+Launch a new agent to handle complex, multi-step tasks autonomously.
+
+Available agent types and the tools they have access to:
+${sub_agents.map(sa => `- ${sa.Name}: ${sa.Description.replace(/\n/g, '\n  ')}\n  input schema for ${sa.Name} : ${JSON.stringify(sa.InputSchema)}\n`).join("\n")}
+
+The input is a JSON array with each object in array having the following properties:
+  - 'name' (string) - the name of the sub agent to be created or modified.
+  - 'input' (object) - the input to the sub agent matching to its input schema.
+The output will be a JSON array outputs from the agents.
+
+Examples:
+
+- <example>
+  Context: User wants to add a new feature to the support bot
+  user: "I want to add a feature that automatically detects when customers are asking about refunds and processes them"
+  assistant: "I'll use the requirements-analyzer agent to analyze this request and create an implementation plan"
+  <commentary>
+  The user has provided a feature request that needs analysis and planning before implementation.
+  </commentary>
+
+</example>
+- <example>
+  Context: User reports a vague issue
+  user: "The bot isn't working properly with some messages"
+  assistant: "Let me use the requirements-analyzer agent to explore this issue and determine what clarification is needed"
+  <commentary>
+  This is a vague issue report that needs exploration and likely clarification from the user.
+  </commentary>
+</example>
+- <example>
+  Context: User provides a clear, specific task
+  user: "Add logging to the message debouncer in start-bot.ts to track when messages are combined"
+  assistant: "I'll analyze this request with the requirements-analyzer agent to create an implementation plan"
+  <commentary>
+  Even clear requests benefit from analysis to ensure proper implementation planning.
+  </commentary>
+</example> (Tools: Glob, Grep, LS, ExitPlanMode, Read, NotebookRead, WebFetch, TodoWrite, WebSearch, Bash)
+- playwright-test-engineer: Use this agent when you need to create or improve Playwright E2E tests for web applications. Examples: <example>Context: User has a specification for a login form but hasn't implemented the UI yet. user: 'I need tests for a login form with email, password fields and a submit button that shows validation errors' assistant: 'I'll use the playwright-test-engineer agent to create test-first E2E tests based on your specification' <commentary>Since the user needs Playwright tests written before implementation, use the playwright-test-engineer agent to create semantic, specification-driven tests.</commentary></example> <example>Context: User has implemented a booking form component and wants comprehensive E2E tests. user: 'Here's my BookingForm.tsx component, can you write Playwright tests for it?' assistant: 'I'll analyze your BookingForm component and use the playwright-test-engineer agent to create comprehensive E2E tests' <commentary>Since the user has existing UI code and needs tests, use the playwright-test-engineer agent to inspect the component and write targeted tests.</commentary></example> (Tools: *)
+
+When using the subagent tool, you must specify a subagent name parameter to select which agent to use.
+
+When NOT to use the Sub Agent tool:
+
+- If you want to read a specific file path, use the Read or Glob tool instead of the Agent tool, to find the match more
+  quickly
+- If you are searching for a specific class definition like "class Foo", use the Glob tool instead, to find the match
+  more quickly
+- If you are searching for code within a specific file or set of 2-3 files, use the Read tool instead of the Agent tool,
+  to find the match more quickly
+- Other tasks that are not related to the agent descriptions above
+
+Usage notes:
+
+1. Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with
+   multiple tool uses
+2. When the agent is done, it will return a single message back to you. The result returned by the agent is not visible
+   to the user. To show the user the result, you should send a text message back to the user with a concise summary of
+   the result.
+3. Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent
+   be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed
+   task description for the agent to perform autonomously and you should specify exactly what information the agent
+   should return back to you in its final and only message to you.
+4. The agent's outputs should generally be trusted
+5. Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, web fetches,
+   etc.), since it is not aware of the user's intent
+6. If the agent description mentions that it should be used proactively, then you should try your best to use it without
+   the user having to ask for it first. Use your judgement.
+
+Example usage:
+
+<example_agent_descriptions>
+"code-reviewer": use this agent after you are done writing a signficant piece of code
+"greeting-responder": use this agent when to respond to user greetings with a friendly joke
+</example_agent_description>
+
+<example>
+user: "Please write a function that checks if a number is prime"
+assistant: Sure let me write a function that checks if a number is prime
+assistant: First let me use the Write tool to write a function that checks if a number is prime
+assistant: I'm going to use the Write tool to write the following code:
+<code>
+function isPrime(n) {
+  if (n <= 1) return false
+  for (let i = 2; i * i <= n; i++) {
+    if (n % i === 0) return false
+  }
+  return true
+}
+</code>
+<commentary>
+Since a signficant piece of code was written and the task was completed, now use the code-reviewer agent to review the code
+</commentary>
+assistant: Now let me use the code-reviewer agent to review the code
+assistant: Uses the Task tool to launch the with the code-reviewer agent
+</example>
+
+<example>
+user: "Hello"
+<commentary>
+Since the user is greeting, use the greeting-responder agent to respond with a friendly joke
+</commentary>
+assistant: "I'm going to use the Task tool to launch the with the greeting-responder agent"
+</example>
+`;
+    return description;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/lib/tools/PSWriteFileTool.d.ts

@@ -0,0 +1,10 @@
+import { PSAgentLogger } from "../PSAgentLogger";
+import { PSAgentTool } from "../PSAgentTool";
+export declare class PSWriteFileTool extends PSAgentTool {
+    static readonly toolName = "write_file";
+    private paths;
+    constructor(options: {
+        paths?: string[];
+    });
+    run(input: Record<string, any>, log?: PSAgentLogger): Promise<Record<string, any>>;
+}

package/build/module/lib/tools/PSWriteFileTool.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PSWriteFileTool = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const v4_1 = require("zod/v4");
+const PSAgentTool_1 = require("../PSAgentTool");
+const helpers_1 = require("../utils/helpers");
+class PSWriteFileTool extends PSAgentTool_1.PSAgentTool {
+    static toolName = "write_file";
+    paths = [];
+    constructor(options) {
+        super({
+            name: PSWriteFileTool.toolName,
+            description: "Writes content to a file in repository identified by 'path'.",
+            type: "API",
+            local_execution: true,
+            hitl: true,
+            inputschema: {
+                url: `http://localhost/${PSWriteFileTool.toolName}`,
+                method: "POST",
+                requestBody: v4_1.z.toJSONSchema(v4_1.z.object({
+                    path: v4_1.z.string().meta({
+                        title: "File_Path",
+                        description: "The path of the file to be write. This should be a valid file path in the repository."
+                    }),
+                    content: v4_1.z.string().meta({
+                        title: "File_Content",
+                        description: "The content to be written to the file. This should be a valid string content."
+                    }),
+                }).meta({
+                    title: `${PSWriteFileTool.toolName}_request_body`,
+                    description: `The request body parameters for the ${PSWriteFileTool.toolName} tool.`,
+                }), { "io": "input" }),
+            },
+        });
+        this.paths = options.paths || [];
+    }
+    run(input, log) {
+        if (!input.path || typeof input.path !== "string") {
+            throw new Error("Invalid file path provided.");
+        }
+        const logger = log || console;
+        return new Promise((resolve, reject) => {
+            const filePath = path_1.default.resolve(...this.paths, input.path);
+            const content = input.content;
+            // if (!filePath.startsWith(run.srcDir))
+            // 	filePath = path.join(run.srcDir, lastevent.toolInput.request_body.path);
+            try {
+                logger.info(`📝 Writing ${(0, helpers_1.formatFileSize)(content.length)} to file:\`${input.path}\``);
+                fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
+                fs_1.default.writeFileSync(filePath, (0, helpers_1.unEscapeHTML)(content), 'utf-8');
+                // logger.info(`> Wrote ${content.length} bytes to file.`);
+                return resolve({
+                    status: 'success'
+                });
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    reject(new Error(`Failed to write file at path: ${input.path}. Error: ${error.message}`));
+                }
+                else {
+                    reject(new Error(`Failed to write file at path: ${input.path}. Unknown error.`));
+                }
+            }
+        });
+    }
+}
+exports.PSWriteFileTool = PSWriteFileTool;
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/lib/tools/TodoTool.d.ts

@@ -0,0 +1,57 @@
+import { PSAgentLogger } from "../PSAgentLogger";
+import { PSAgentTool } from "../PSAgentTool";
+export declare enum TodoStatus {
+    PENDING = "pending",
+    IN_PROGRESS = "in_progress",
+    COMPLETED = "completed"
+}
+export declare enum TodoPriority {
+    HIGH = "high",
+    MEDIUM = "medium",
+    LOW = "low"
+}
+export interface Todo {
+    id: string;
+    content: string;
+    status: TodoStatus;
+    priority: TodoPriority;
+    created_at: string;
+    updated_at: string;
+    metadata?: Record<string, any>;
+}
+export declare class TaskStore {
+    private lastModified;
+    private todos;
+    private filename?;
+    constructor(todos: Todo[], filename?: string);
+    get LastModified(): string;
+    get Todos(): Todo[];
+    set Todos(todos: Todo[]);
+}
+export interface TodoReadResponse {
+    todos: Todo[];
+}
+export interface TodoWriteParams {
+    todos: Array<Record<string, any>>;
+}
+export interface TodoWriteResponse {
+    success: boolean;
+    count: number;
+}
+export declare class PSTodoReadTool extends PSAgentTool {
+    static readonly toolName = "read_todo";
+    private store;
+    constructor(options: {
+        store: TaskStore;
+    });
+    run(_input: Record<string, any>, log?: PSAgentLogger): Promise<Record<string, any>>;
+}
+export declare class PSTodoWriteTool extends PSAgentTool {
+    static readonly toolName = "write_todo";
+    private store;
+    constructor(options: {
+        store: TaskStore;
+    });
+    get Todos(): Todo[];
+    run(input: Record<string, any>, log?: PSAgentLogger): Promise<Record<string, any>>;
+}