@fastino-ai/pioneer-cli 0.2.10 → 0.2.11

package/src/tests/tool-types.test.ts

@@ -1,104 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import type { Tool, ToolParameter, ToolResult } from "../tools/types";
-
-describe("Tool Types", () => {
-  describe("ToolParameter", () => {
-    test("should have valid structure", () => {
-      const param: ToolParameter = {
-        name: "filePath",
-        type: "string",
-        description: "Path to the file",
-        required: true,
-        default: "./default.txt",
-      };
-
-      expect(param.name).toBe("filePath");
-      expect(param.type).toBe("string");
-      expect(param.description).toBeDefined();
-      expect(param.required).toBe(true);
-      expect(param.default).toBe("./default.txt");
-    });
-
-    test("should support all parameter types", () => {
-      const types: Array<ToolParameter["type"]> = [
-        "string",
-        "number",
-        "boolean",
-        "array",
-        "object",
-      ];
-
-      types.forEach((type) => {
-        const param: ToolParameter = {
-          name: "testParam",
-          type,
-          description: `Test ${type} parameter`,
-          required: false,
-        };
-
-        expect(param.type).toBe(type);
-      });
-    });
-  });
-
-  describe("ToolResult", () => {
-    test("should support successful result", () => {
-      const result: ToolResult = {
-        toolCallId: "call-123",
-        output: "Operation completed successfully",
-        success: true,
-      };
-
-      expect(result.success).toBe(true);
-      expect(result.output).toBeDefined();
-      expect(result.toolCallId).toBe("call-123");
-      expect(result.error).toBeUndefined();
-    });
-
-    test("should support error result", () => {
-      const result: ToolResult = {
-        toolCallId: "call-456",
-        output: "",
-        success: false,
-        error: "File not found",
-      };
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe("File not found");
-    });
-  });
-
-  describe("Tool", () => {
-    test("should have valid structure", async () => {
-      const tool: Tool = {
-        name: "test_tool",
-        description: "A test tool",
-        parameters: [
-          {
-            name: "input",
-            type: "string",
-            description: "Input value",
-            required: true,
-          },
-        ],
-        execute: async (args: Record<string, unknown>) => {
-          return {
-            toolCallId: "test-id",
-            output: `Executed with: ${args.input}`,
-            success: true,
-          };
-        },
-      };
-
-      expect(tool.name).toBe("test_tool");
-      expect(tool.description).toBeDefined();
-      expect(tool.parameters.length).toBe(1);
-      expect(typeof tool.execute).toBe("function");
-
-      // Test execution
-      const result = await tool.execute({ input: "test value" });
-      expect(result.success).toBe(true);
-      expect(result.output).toContain("test value");
-    });
-  });
-});

package/src/tests/utils.test.ts

@@ -1,90 +0,0 @@
-import { describe, test, expect, beforeEach } from "bun:test";
-import { FileResolver } from "../utils/FileResolver";
-import * as path from "path";
-import * as os from "os";
-
-describe("FileResolver", () => {
-  let resolver: FileResolver;
-  
-  beforeEach(() => {
-    resolver = new FileResolver(process.cwd());
-  });
-
-  describe("Constructor and setup", () => {
-    test("should initialize with default cwd", () => {
-      const defaultResolver = new FileResolver();
-      expect(defaultResolver).toBeDefined();
-    });
-
-    test("should initialize with custom base path", () => {
-      const customPath = "/custom/path";
-      const customResolver = new FileResolver(customPath);
-      expect(customResolver).toBeDefined();
-    });
-
-    test("should allow setting base path", () => {
-      const newPath = "/new/path";
-      resolver.setBasePath(newPath);
-      expect(resolver).toBeDefined();
-    });
-  });
-
-  describe("Reference parsing", () => {
-    test("should parse simple file reference", () => {
-      const message = "Check @package.json for details";
-      const result = resolver.resolve(message);
-      
-      expect(result.originalMessage).toBe(message);
-      expect(result.references.length).toBeGreaterThanOrEqual(1);
-      expect(result.references[0].relativePath).toBe("package.json");
-    });
-
-    test("should parse multiple file references", () => {
-      const message = "Check @package.json and @tsconfig.json";
-      const result = resolver.resolve(message);
-      
-      expect(result.references.length).toBeGreaterThanOrEqual(2);
-    });
-
-    test("should handle relative path references", () => {
-      const message = "Check @./src/config.ts";
-      const result = resolver.resolve(message);
-      
-      expect(result.references.length).toBeGreaterThanOrEqual(1);
-      expect(result.references[0].relativePath).toBe("./src/config.ts");
-    });
-
-    test("should deduplicate same reference mentioned multiple times", () => {
-      const message = "@package.json is important. Check @package.json again.";
-      const result = resolver.resolve(message);
-      
-      expect(result.references.length).toBe(1);
-    });
-  });
-
-  describe("getSuggestions", () => {
-    test("should return suggestions for empty string", () => {
-      const suggestions = resolver.getSuggestions("");
-      expect(Array.isArray(suggestions)).toBe(true);
-    });
-
-    test("should return suggestions for partial filename", () => {
-      const suggestions = resolver.getSuggestions("pa");
-      expect(Array.isArray(suggestions)).toBe(true);
-      // Should include package.json if it exists
-      const hasPackageJson = suggestions.some(s => s.includes("package.json"));
-      expect(hasPackageJson).toBe(true);
-    });
-
-    test("should limit suggestions to specified count", () => {
-      const limit = 5;
-      const suggestions = resolver.getSuggestions("", limit);
-      expect(suggestions.length).toBeLessThanOrEqual(limit);
-    });
-
-    test("should handle directory paths with trailing slash", () => {
-      const suggestions = resolver.getSuggestions("src/");
-      expect(Array.isArray(suggestions)).toBe(true);
-    });
-  });
-});

package/src/tools/bash.ts

@@ -1,184 +0,0 @@
-/**
- * Bash execution tool - Execute shell commands safely
- */
-
-import { spawn } from "child_process";
-import type { Tool, ToolResult, ToolParameter } from "./types.js";
-
-export interface BashOptions {
-  cwd?: string;
-  timeout?: number;
-  env?: Record<string, string>;
-  maxOutput?: number;
-}
-
-export function createBashTool(options: BashOptions = {}): Tool {
-  const { cwd = process.cwd(), timeout = 60000, maxOutput = 100000 } = options;
-
-  return {
-    name: "bash",
-    description: "Execute a bash command. Use this to run shell commands, install packages, manage files, etc.",
-    parameters: [
-      {
-        name: "command",
-        type: "string",
-        description: "The bash command to execute",
-        required: true,
-      },
-      {
-        name: "workdir",
-        type: "string",
-        description: "Working directory for the command (optional, defaults to current directory)",
-        required: false,
-      },
-    ],
-
-    async execute(args: Record<string, unknown>): Promise<ToolResult> {
-      const command = args.command as string;
-      const workdir = (args.workdir as string) || cwd;
-
-      if (!command || typeof command !== "string") {
-        return {
-          toolCallId: "",
-          output: "",
-          success: false,
-          error: "Command is required and must be a string",
-        };
-      }
-
-      return new Promise((resolve) => {
-        let stdout = "";
-        let stderr = "";
-        let timedOut = false;
-
-        const proc = spawn("bash", ["-c", command], {
-          cwd: workdir,
-          env: { ...process.env, ...options.env },
-          stdio: ["pipe", "pipe", "pipe"],
-        });
-
-        const timer = setTimeout(() => {
-          timedOut = true;
-          proc.kill("SIGTERM");
-          setTimeout(() => proc.kill("SIGKILL"), 5000);
-        }, timeout);
-
-        proc.stdout.on("data", (data: Buffer) => {
-          const chunk = data.toString();
-          if (stdout.length + chunk.length <= maxOutput) {
-            stdout += chunk;
-          } else if (stdout.length < maxOutput) {
-            stdout += chunk.slice(0, maxOutput - stdout.length);
-            stdout += "\n... (output truncated)";
-          }
-        });
-
-        proc.stderr.on("data", (data: Buffer) => {
-          const chunk = data.toString();
-          if (stderr.length + chunk.length <= maxOutput) {
-            stderr += chunk;
-          } else if (stderr.length < maxOutput) {
-            stderr += chunk.slice(0, maxOutput - stderr.length);
-            stderr += "\n... (output truncated)";
-          }
-        });
-
-        proc.on("close", (code) => {
-          clearTimeout(timer);
-
-          let output = "";
-          if (stdout) output += stdout;
-          if (stderr) output += (output ? "\n" : "") + stderr;
-          if (timedOut) output += `\n(Command timed out after ${timeout / 1000}s)`;
-
-          resolve({
-            toolCallId: "",
-            output: output || "(no output)",
-            success: !timedOut && code === 0,
-            error: timedOut
-              ? `Command timed out after ${timeout / 1000}s`
-              : code !== 0
-              ? `Command exited with code ${code}`
-              : undefined,
-          });
-        });
-
-        proc.on("error", (err) => {
-          clearTimeout(timer);
-          resolve({
-            toolCallId: "",
-            output: "",
-            success: false,
-            error: `Failed to execute command: ${err.message}`,
-          });
-        });
-      });
-    },
-  };
-}
-
-// Streaming version for real-time output
-export async function* executeBashStream(
-  command: string,
-  options: BashOptions = {}
-): AsyncGenerator<{ type: "stdout" | "stderr" | "exit"; data: string | number }> {
-  const { cwd = process.cwd(), timeout = 60000 } = options;
-
-  const proc = spawn("bash", ["-c", command], {
-    cwd,
-    env: { ...process.env, ...options.env },
-    stdio: ["pipe", "pipe", "pipe"],
-  });
-
-  let timedOut = false;
-  const timer = setTimeout(() => {
-    timedOut = true;
-    proc.kill("SIGTERM");
-    setTimeout(() => proc.kill("SIGKILL"), 5000);
-  }, timeout);
-
-  const stdoutQueue: string[] = [];
-  const stderrQueue: string[] = [];
-  let exited = false;
-  let exitCode: number | null = null;
-
-  proc.stdout.on("data", (data: Buffer) => {
-    stdoutQueue.push(data.toString());
-  });
-
-  proc.stderr.on("data", (data: Buffer) => {
-    stderrQueue.push(data.toString());
-  });
-
-  const exitPromise = new Promise<number | null>((resolve) => {
-    proc.on("close", (code) => {
-      clearTimeout(timer);
-      exited = true;
-      exitCode = timedOut ? -1 : code;
-      resolve(exitCode);
-    });
-
-    proc.on("error", () => {
-      clearTimeout(timer);
-      exited = true;
-      exitCode = -1;
-      resolve(-1);
-    });
-  });
-
-  // Yield output as it comes
-  while (!exited || stdoutQueue.length > 0 || stderrQueue.length > 0) {
-    while (stdoutQueue.length > 0) {
-      yield { type: "stdout", data: stdoutQueue.shift()! };
-    }
-    while (stderrQueue.length > 0) {
-      yield { type: "stderr", data: stderrQueue.shift()! };
-    }
-    if (!exited) {
-      await new Promise((resolve) => setTimeout(resolve, 10));
-    }
-  }
-
-  yield { type: "exit", data: exitCode ?? -1 };
-}
-