agent-enderun 1.1.2 → 1.1.4

package/framework-mcp/node_modules/undici-types/webidl.d.ts

@@ -1,228 +0,0 @@
-// These types are not exported, and are only used internally
-
-/**
- * Take in an unknown value and return one that is of type T
- */
-type Converter<T> = (object: unknown) => T
-
-type SequenceConverter<T> = (object: unknown, iterable?: IterableIterator<T>) => T[]
-
-type RecordConverter<K extends string, V> = (object: unknown) => Record<K, V>
-
-interface ConvertToIntOpts {
-  clamp?: boolean
-  enforceRange?: boolean
-}
-
-interface WebidlErrors {
-  exception (opts: { header: string, message: string }): TypeError
-  /**
-   * @description Throw an error when conversion from one type to another has failed
-   */
-  conversionFailed (opts: {
-    prefix: string
-    argument: string
-    types: string[]
-  }): TypeError
-  /**
-   * @description Throw an error when an invalid argument is provided
-   */
-  invalidArgument (opts: {
-    prefix: string
-    value: string
-    type: string
-  }): TypeError
-}
-
-interface WebidlUtil {
-  /**
-   * @see https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values
-   */
-  Type (object: unknown):
-    | 'Undefined'
-    | 'Boolean'
-    | 'String'
-    | 'Symbol'
-    | 'Number'
-    | 'BigInt'
-    | 'Null'
-    | 'Object'
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
-   */
-  ConvertToInt (
-    V: unknown,
-    bitLength: number,
-    signedness: 'signed' | 'unsigned',
-    opts?: ConvertToIntOpts
-  ): number
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
-   */
-  IntegerPart (N: number): number
-
-  /**
-   * Stringifies {@param V}
-   */
-  Stringify (V: any): string
-
-  /**
-   * Mark a value as uncloneable for Node.js.
-   * This is only effective in some newer Node.js versions.
-   */
-  markAsUncloneable (V: any): void
-}
-
-interface WebidlConverters {
-  /**
-   * @see https://webidl.spec.whatwg.org/#es-DOMString
-   */
-  DOMString (V: unknown, prefix: string, argument: string, opts?: {
-    legacyNullToEmptyString: boolean
-  }): string
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#es-ByteString
-   */
-  ByteString (V: unknown, prefix: string, argument: string): string
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#es-USVString
-   */
-  USVString (V: unknown): string
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#es-boolean
-   */
-  boolean (V: unknown): boolean
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#es-any
-   */
-  any <Value>(V: Value): Value
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#es-long-long
-   */
-  ['long long'] (V: unknown): number
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#es-unsigned-long-long
-   */
-  ['unsigned long long'] (V: unknown): number
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#es-unsigned-long
-   */
-  ['unsigned long'] (V: unknown): number
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#es-unsigned-short
-   */
-  ['unsigned short'] (V: unknown, opts?: ConvertToIntOpts): number
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#idl-ArrayBuffer
-   */
-  ArrayBuffer (V: unknown): ArrayBufferLike
-  ArrayBuffer (V: unknown, opts: { allowShared: false }): ArrayBuffer
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
-   */
-  TypedArray (
-    V: unknown,
-    TypedArray: NodeJS.TypedArray | ArrayBufferLike
-  ): NodeJS.TypedArray | ArrayBufferLike
-  TypedArray (
-    V: unknown,
-    TypedArray: NodeJS.TypedArray | ArrayBufferLike,
-    opts?: { allowShared: false }
-  ): NodeJS.TypedArray | ArrayBuffer
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
-   */
-  DataView (V: unknown, opts?: { allowShared: boolean }): DataView
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#BufferSource
-   */
-  BufferSource (
-    V: unknown,
-    opts?: { allowShared: boolean }
-  ): NodeJS.TypedArray | ArrayBufferLike | DataView
-
-  ['sequence<ByteString>']: SequenceConverter<string>
-  
-  ['sequence<sequence<ByteString>>']: SequenceConverter<string[]>
-
-  ['record<ByteString, ByteString>']: RecordConverter<string, string>
-
-  [Key: string]: (...args: any[]) => unknown
-}
-
-export interface Webidl {
-  errors: WebidlErrors
-  util: WebidlUtil
-  converters: WebidlConverters
-
-  /**
-   * @description Performs a brand-check on {@param V} to ensure it is a
-   * {@param cls} object.
-   */
-  brandCheck <Interface>(V: unknown, cls: Interface, opts?: { strict?: boolean }): asserts V is Interface
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#es-sequence
-   * @description Convert a value, V, to a WebIDL sequence type.
-   */
-  sequenceConverter <Type>(C: Converter<Type>): SequenceConverter<Type>
-
-  illegalConstructor (): never
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#es-to-record
-   * @description Convert a value, V, to a WebIDL record type.
-   */
-  recordConverter <K extends string, V>(
-    keyConverter: Converter<K>,
-    valueConverter: Converter<V>
-  ): RecordConverter<K, V>
-
-  /**
-   * Similar to {@link Webidl.brandCheck} but allows skipping the check if third party
-   * interfaces are allowed.
-   */
-  interfaceConverter <Interface>(cls: Interface): (
-    V: unknown,
-    opts?: { strict: boolean }
-  ) => asserts V is typeof cls
-
-  // TODO(@KhafraDev): a type could likely be implemented that can infer the return type
-  // from the converters given?
-  /**
-   * Converts a value, V, to a WebIDL dictionary types. Allows limiting which keys are
-   * allowed, values allowed, optional and required keys. Auto converts the value to
-   * a type given a converter.
-   */
-  dictionaryConverter (converters: {
-    key: string,
-    defaultValue?: () => unknown,
-    required?: boolean,
-    converter: (...args: unknown[]) => unknown,
-    allowedValues?: unknown[]
-  }[]): (V: unknown) => Record<string, unknown>
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#idl-nullable-type
-   * @description allows a type, V, to be null
-   */
-  nullableConverter <T>(
-    converter: Converter<T>
-  ): (V: unknown) => ReturnType<typeof converter> | null
-
-  argumentLengthCheck (args: { length: number }, min: number, context: string): void
-}

package/framework-mcp/node_modules/undici-types/websocket.d.ts

@@ -1,150 +0,0 @@
-/// <reference types="node" />
-
-import type { Blob } from 'buffer'
-import type { MessagePort } from 'worker_threads'
-import {
-  EventInit,
-  EventListenerOptions,
-  AddEventListenerOptions,
-  EventListenerOrEventListenerObject
-} from './patch'
-import Dispatcher from './dispatcher'
-import { HeadersInit } from './fetch'
-
-export type BinaryType = 'blob' | 'arraybuffer'
-
-interface WebSocketEventMap {
-  close: CloseEvent
-  error: ErrorEvent
-  message: MessageEvent
-  open: Event
-}
-
-interface WebSocket extends EventTarget {
-  binaryType: BinaryType
-  
-  readonly bufferedAmount: number
-  readonly extensions: string
-
-  onclose: ((this: WebSocket, ev: WebSocketEventMap['close']) => any) | null
-  onerror: ((this: WebSocket, ev: WebSocketEventMap['error']) => any) | null
-  onmessage: ((this: WebSocket, ev: WebSocketEventMap['message']) => any) | null
-  onopen: ((this: WebSocket, ev: WebSocketEventMap['open']) => any) | null
-
-  readonly protocol: string
-  readonly readyState: number
-  readonly url: string
-
-  close(code?: number, reason?: string): void
-  send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void
-
-  readonly CLOSED: number
-  readonly CLOSING: number
-  readonly CONNECTING: number
-  readonly OPEN: number
-
-  addEventListener<K extends keyof WebSocketEventMap>(
-    type: K,
-    listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any,
-    options?: boolean | AddEventListenerOptions
-  ): void
-  addEventListener(
-    type: string,
-    listener: EventListenerOrEventListenerObject,
-    options?: boolean | AddEventListenerOptions
-  ): void
-  removeEventListener<K extends keyof WebSocketEventMap>(
-    type: K,
-    listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any,
-    options?: boolean | EventListenerOptions
-  ): void
-  removeEventListener(
-    type: string,
-    listener: EventListenerOrEventListenerObject,
-    options?: boolean | EventListenerOptions
-  ): void
-}
-
-export declare const WebSocket: {
-  prototype: WebSocket
-  new (url: string | URL, protocols?: string | string[] | WebSocketInit): WebSocket
-  readonly CLOSED: number
-  readonly CLOSING: number
-  readonly CONNECTING: number
-  readonly OPEN: number
-}
-
-interface CloseEventInit extends EventInit {
-  code?: number
-  reason?: string
-  wasClean?: boolean
-}
-
-interface CloseEvent extends Event {
-  readonly code: number
-  readonly reason: string
-  readonly wasClean: boolean
-}
-
-export declare const CloseEvent: {
-  prototype: CloseEvent
-  new (type: string, eventInitDict?: CloseEventInit): CloseEvent
-}
-
-interface MessageEventInit<T = any> extends EventInit {
-  data?: T
-  lastEventId?: string
-  origin?: string
-  ports?: (typeof MessagePort)[]
-  source?: typeof MessagePort | null
-}
-
-interface MessageEvent<T = any> extends Event {
-  readonly data: T
-  readonly lastEventId: string
-  readonly origin: string
-  readonly ports: ReadonlyArray<typeof MessagePort>
-  readonly source: typeof MessagePort | null
-  initMessageEvent(
-    type: string,
-    bubbles?: boolean,
-    cancelable?: boolean,
-    data?: any,
-    origin?: string,
-    lastEventId?: string,
-    source?: typeof MessagePort | null,
-    ports?: (typeof MessagePort)[]
-  ): void;
-}
-
-export declare const MessageEvent: {
-  prototype: MessageEvent
-  new<T>(type: string, eventInitDict?: MessageEventInit<T>): MessageEvent<T>
-}
-
-interface ErrorEventInit extends EventInit {
-  message?: string
-  filename?: string
-  lineno?: number
-  colno?: number
-  error?: any
-}
-
-interface ErrorEvent extends Event {
-  readonly message: string
-  readonly filename: string
-  readonly lineno: number
-  readonly colno: number
-  readonly error: any
-}
-
-export declare const ErrorEvent: {
-  prototype: ErrorEvent
-  new (type: string, eventInitDict?: ErrorEventInit): ErrorEvent
-}
-
-interface WebSocketInit {
-  protocols?: string | string[],
-  dispatcher?: Dispatcher,
-  headers?: HeadersInit
-}

package/framework-mcp/tests/tools/file_system/replace_text.test.js

@@ -1,68 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import fs from "fs";
-import path from "path";
-import { handleReplaceText } from "../../../src/tools/file_system/replace_text";
-const TEST_DIR = path.join(__dirname, "../_temp_test_files");
-const TEST_FILE = path.join(TEST_DIR, "test_file.txt");
-beforeEach(() => {
-    fs.mkdirSync(TEST_DIR, { recursive: true });
-});
-afterEach(() => {
-    fs.rmSync(TEST_DIR, { recursive: true, force: true });
-});
-describe("handleReplaceText", () => {
-    it("should replace a single occurrence of text", () => {
-        fs.writeFileSync(TEST_FILE, "hello world", "utf8");
-        const args = {
-            path: TEST_FILE,
-            oldText: "world",
-            newText: "there",
-        };
-        const result = handleReplaceText(TEST_DIR, args);
-        expect(result.content[0].text).toContain("✅ Surgical edit successful");
-        expect(fs.readFileSync(TEST_FILE, "utf8")).toBe("hello there");
-    });
-    it("should throw an error if text is not found", () => {
-        fs.writeFileSync(TEST_FILE, "hello world", "utf8");
-        const args = {
-            path: TEST_FILE,
-            oldText: "missing",
-            newText: "found",
-        };
-        expect(() => handleReplaceText(TEST_DIR, args)).toThrowError("Text not found in file");
-    });
-    it("should throw an error for ambiguous replacement if allowMultiple is false", () => {
-        fs.writeFileSync(TEST_FILE, "hello world world", "utf8");
-        const args = {
-            path: TEST_FILE,
-            oldText: "world",
-            newText: "there",
-            allowMultiple: false,
-        };
-        expect(() => handleReplaceText(TEST_DIR, args)).toThrowError("Ambiguous replacement");
-    });
-    it("should replace all occurrences of text if allowMultiple is true", () => {
-        fs.writeFileSync(TEST_FILE, "hello world world", "utf8");
-        const args = {
-            path: TEST_FILE,
-            oldText: "world",
-            newText: "there",
-            allowMultiple: true,
-        };
-        const result = handleReplaceText(TEST_DIR, args);
-        expect(result.content[0].text).toContain("✅ Surgical edit successful");
-        expect(fs.readFileSync(TEST_FILE, "utf8")).toBe("hello there there");
-    });
-    it("should handle special characters in oldText when allowMultiple is true", () => {
-        fs.writeFileSync(TEST_FILE, "test.txt", "utf8");
-        const args = {
-            path: TEST_FILE,
-            oldText: ".txt",
-            newText: ".md",
-            allowMultiple: true,
-        };
-        const result = handleReplaceText(TEST_DIR, args);
-        expect(result.content[0].text).toContain("✅ Surgical edit successful");
-        expect(fs.readFileSync(TEST_FILE, "utf8")).toBe("test.md");
-    });
-});

package/framework-mcp/tests/tools/file_system/replace_text.test.ts

@@ -1,77 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import fs from "fs";
-import path from "path";
-import { handleReplaceText } from "../../../src/tools/file_system/replace_text.js";
-import { ToolArgs } from "../../../src/tools/types.js";
-
-const TEST_DIR = path.join(__dirname, "../_temp_test_files");
-const TEST_FILE = path.join(TEST_DIR, "test_file.txt");
-
-beforeEach(() => {
-    fs.mkdirSync(TEST_DIR, { recursive: true });
-});
-
-afterEach(() => {
-    fs.rmSync(TEST_DIR, { recursive: true, force: true });
-});
-
-describe("handleReplaceText", () => {
-    it("should replace a single occurrence of text", () => {
-        fs.writeFileSync(TEST_FILE, "hello world", "utf8");
-        const args: ToolArgs = {
-            path: TEST_FILE,
-            oldText: "world",
-            newText: "there",
-        };
-        const result = handleReplaceText(TEST_DIR, args);
-        expect(result.content[0].text).toContain("✅ Surgical edit successful");
-        expect(fs.readFileSync(TEST_FILE, "utf8")).toBe("hello there");
-    });
-
-    it("should throw an error if text is not found", () => {
-        fs.writeFileSync(TEST_FILE, "hello world", "utf8");
-        const args: ToolArgs = {
-            path: TEST_FILE,
-            oldText: "missing",
-            newText: "found",
-        };
-        expect(() => handleReplaceText(TEST_DIR, args)).toThrowError("Text not found in file");
-    });
-
-    it("should throw an error for ambiguous replacement if allowMultiple is false", () => {
-        fs.writeFileSync(TEST_FILE, "hello world world", "utf8");
-        const args: ToolArgs = {
-            path: TEST_FILE,
-            oldText: "world",
-            newText: "there",
-            allowMultiple: false,
-        };
-        expect(() => handleReplaceText(TEST_DIR, args)).toThrowError("Ambiguous replacement");
-    });
-
-    it("should replace all occurrences of text if allowMultiple is true", () => {
-        fs.writeFileSync(TEST_FILE, "hello world world", "utf8");
-        const args: ToolArgs = {
-            path: TEST_FILE,
-            oldText: "world",
-            newText: "there",
-            allowMultiple: true,
-        };
-        const result = handleReplaceText(TEST_DIR, args);
-        expect(result.content[0].text).toContain("✅ Surgical edit successful");
-        expect(fs.readFileSync(TEST_FILE, "utf8")).toBe("hello there there");
-    });
-
-    it("should handle special characters in oldText when allowMultiple is true", () => {
-        fs.writeFileSync(TEST_FILE, "test.txt", "utf8");
-        const args: ToolArgs = {
-            path: TEST_FILE,
-            oldText: ".txt",
-            newText: ".md",
-            allowMultiple: true,
-        };
-        const result = handleReplaceText(TEST_DIR, args);
-        expect(result.content[0].text).toContain("✅ Surgical edit successful");
-        expect(fs.readFileSync(TEST_FILE, "utf8")).toBe("test.md");
-    });
-});

package/mcp.json

@@ -1,11 +0,0 @@
-{
-  "mcpServers": {
-    "agent-enderun": {
-      "command": "node",
-      "args": ["/Users/ybekar/Desktop/Projeler/agent-enderun/framework-mcp/dist/index.js"],
-      "env": {
-        "ENDERUN_PROJECT_ROOT": "/Users/ybekar/Desktop/Projeler/agent-enderun"
-      }
-    }
-  }
-}

package/panda.config.ts

@@ -1,100 +0,0 @@
-import { defineConfig } from "@pandacss/dev";
-
-export default defineConfig({
-    // Whether to use css reset
-    preflight: true,
-
-    // Where to look for your css declarations
-    include: [
-        "./src/**/*.{js,jsx,ts,tsx}",
-        "./pages/**/*.{js,jsx,ts,tsx}",
-        "./apps/**/*.{js,jsx,ts,tsx}",
-        // Project-internal UI components only (no packages/ui by default)
-        "./apps/**/src/components/**/*.{ts,tsx}",
-        "./apps/**/src/ui/**/*.{ts,tsx}",
-    ],
-
-    // Files to exclude
-    exclude: [],
-
-    // Conditions for Dark Mode and other states
-    conditions: {
-        extend: {
-            dark: ".dark &, [data-theme='dark'] &",
-            light: ".light &, [data-theme='light'] &",
-        },
-    },
-
-    // Theme Customization
-    theme: {
-        extend: {
-            // Base Tokens (Absolute Values)
-            tokens: {
-                colors: {
-                    brand: {
-                        50: { value: "#eef2ff" },
-                        100: { value: "#e0e7ff" },
-                        200: { value: "#c7d2fe" },
-                        300: { value: "#a5b4fc" },
-                        400: { value: "#818cf8" },
-                        500: { value: "#6366f1" },
-                        600: { value: "#4f46e5" },
-                        700: { value: "#4338ca" },
-                        800: { value: "#3730a3" },
-                        900: { value: "#312e81" },
-                        950: { value: "#1e1b4b" },
-                    },
-                },
-                spacing: {
-                    container: { value: "1200px" },
-                },
-            },
-            // Semantic Tokens (Theme Aware)
-            semanticTokens: {
-                colors: {
-                    bg: {
-                        canvas: {
-                            value: { base: "{colors.white}", _dark: "{colors.brand.950}" },
-                        },
-                        surface: {
-                            value: { base: "{colors.gray.50}", _dark: "{colors.brand.900}" },
-                        },
-                        muted: {
-                            value: { base: "{colors.gray.100}", _dark: "{colors.brand.800}" },
-                        },
-                    },
-                    text: {
-                        default: {
-                            value: { base: "{colors.gray.900}", _dark: "{colors.white}" },
-                        },
-                        muted: {
-                            value: { base: "{colors.gray.500}", _dark: "{colors.gray.400}" },
-                        },
-                        brand: {
-                            value: { base: "{colors.brand.600}", _dark: "{colors.brand.400}" },
-                        },
-                    },
-                    accent: {
-                        default: {
-                            value: { base: "{colors.brand.500}", _dark: "{colors.brand.500}" },
-                        },
-                        emphasis: {
-                            value: { base: "{colors.brand.600}", _dark: "{colors.brand.400}" },
-                        },
-                        fg: {
-                            value: { base: "{colors.white}", _dark: "{colors.white}" },
-                        },
-                    },
-                    border: {
-                        default: {
-                            value: { base: "{colors.gray.200}", _dark: "{colors.brand.800}" },
-                        },
-                    },
-                },
-            },
-        },
-    },
-
-    // The output directory for your css system
-    outdir: "styled-system",
-});