unplugin-devpilot 0.0.0

package/dist/index-CyKvTBcJ.d.mts

@@ -0,0 +1,228 @@
+import { r as McpToolRegister, t as DevpilotPluginContext } from "./index-CL0Gw5-1.mjs";
+import { UnpluginInstance } from "unplugin";
+import { WebSocket } from "ws";
+
+//#region src/core/options.d.ts
+interface DevpilotPlugin {
+  namespace: string;
+  /**
+  * The client module path to be injected
+  * - npm package path: 'my-plugin/client'
+  * - absolute path: '/path/to/client.ts'
+  *
+  * Note: relative paths need to be resolved to absolute paths first
+  * @example
+  * ```ts
+  * import { resolveClientModule } from 'unplugin-devpilot'
+  *
+  * clientModule: resolveClientModule(import.meta.url, './client.ts')
+  * ```
+  */
+  clientModule?: string | ((ctx: DevpilotPluginContext) => string);
+  /**
+  * Setup server-side RPC methods for this plugin
+  * These methods can be called from the client via rpcCall()
+  */
+  serverSetup?: (ctx: DevpilotPluginContext) => Record<string, (...args: any[]) => any>;
+  mcpSetup?: (ctx: DevpilotPluginContext) => Array<McpToolRegister>;
+}
+interface Options {
+  wsPort?: number;
+  mcpPort?: number;
+  plugins?: DevpilotPlugin[];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/birpc@4.0.0/node_modules/birpc/dist/index.d.mts
+//#endregion
+//#region src/utils.d.ts
+type ArgumentsType<T> = T extends ((...args: infer A) => any) ? A : never;
+type ReturnType<T> = T extends ((...args: any) => infer R) ? R : never;
+//#endregion
+//#region src/main.d.ts
+type PromisifyFn<T> = ReturnType<T> extends Promise<any> ? T : (...args: ArgumentsType<T>) => Promise<Awaited<ReturnType<T>>>;
+type BirpcFn<T> = PromisifyFn<T> & {
+  /**
+   * Send event without asking for response
+   */
+  asEvent: (...args: ArgumentsType<T>) => Promise<void>;
+};
+interface BirpcReturnBuiltin<RemoteFunctions, LocalFunctions = Record<string, unknown>> {
+  /**
+   * Raw functions object
+   */
+  $functions: LocalFunctions;
+  /**
+   * Whether the RPC is closed
+   */
+  readonly $closed: boolean;
+  /**
+   * Custom meta data attached to the RPC instance
+   */
+  readonly $meta: any;
+  /**
+   * Close the RPC connection
+   */
+  $close: (error?: Error) => void;
+  /**
+   * Reject pending calls
+   */
+  $rejectPendingCalls: (handler?: PendingCallHandler) => Promise<void>[];
+  /**
+   * Call the remote function and wait for the result.
+   * An alternative to directly calling the function
+   */
+  $call: <K$1 extends keyof RemoteFunctions>(method: K$1, ...args: ArgumentsType<RemoteFunctions[K$1]>) => Promise<Awaited<ReturnType<RemoteFunctions[K$1]>>>;
+  /**
+   * Same as `$call`, but returns `undefined` if the function is not defined on the remote side.
+   */
+  $callOptional: <K$1 extends keyof RemoteFunctions>(method: K$1, ...args: ArgumentsType<RemoteFunctions[K$1]>) => Promise<Awaited<ReturnType<RemoteFunctions[K$1]> | undefined>>;
+  /**
+   * Send event without asking for response
+   */
+  $callEvent: <K$1 extends keyof RemoteFunctions>(method: K$1, ...args: ArgumentsType<RemoteFunctions[K$1]>) => Promise<void>;
+  /**
+   * Call the remote function with the raw options.
+   */
+  $callRaw: (options: {
+    method: string;
+    args: unknown[];
+    event?: boolean;
+    optional?: boolean;
+  }) => Promise<Awaited<ReturnType<any>>[]>;
+}
+type ProxifiedRemoteFunctions<RemoteFunctions extends object = Record<string, unknown>> = { [K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]> };
+type BirpcReturn<RemoteFunctions extends object = Record<string, unknown>, LocalFunctions extends object = Record<string, unknown>, Proxify extends boolean = true> = Proxify extends true ? ProxifiedRemoteFunctions<RemoteFunctions> & BirpcReturnBuiltin<RemoteFunctions, LocalFunctions> : BirpcReturnBuiltin<RemoteFunctions, LocalFunctions>;
+type PendingCallHandler = (options: Pick<PromiseEntry, 'method' | 'reject'>) => void | Promise<void>;
+interface PromiseEntry {
+  resolve: (arg: any) => void;
+  reject: (error: any) => void;
+  method: string;
+  timeoutId?: ReturnType<typeof setTimeout>;
+}
+declare const setTimeout: typeof globalThis.setTimeout;
+//#endregion
+//#region src/core/types.d.ts
+interface ClientInfo {
+  clientId: string;
+  url: string;
+  title: string;
+  userAgent: string;
+  connectedAt: number;
+  lastActiveAt: number;
+}
+interface TaskHistory {
+  id: string;
+  sourceClient: string;
+  intent: "analyze" | "modify" | "test" | "style" | "ask";
+  element: {
+    uid: string;
+    selector: string;
+    role: string;
+    name: string;
+    codeLocation?: {
+      file: string;
+      line: number;
+      column: number;
+    };
+  };
+  userNote?: string;
+  timestamp: number;
+  status: "pending" | "in_progress" | "completed" | "failed";
+  completedAt?: number;
+  completedBy?: string;
+  result?: Record<string, any>;
+}
+interface ClientDiscoveryFilter {
+  urlPattern?: string;
+  titlePattern?: string;
+  clientId?: string;
+  activeOnly?: boolean;
+}
+interface PendingTask {
+  id: string;
+  sourceClient: string;
+  intent: "analyze" | "modify" | "test" | "style" | "ask";
+  element: {
+    uid: string;
+    selector: string;
+    role: string;
+    name: string;
+    codeLocation?: {
+      file: string;
+      line: number;
+      column: number;
+    };
+  };
+  userNote?: string;
+  timestamp: number;
+}
+interface BaseServerFunctions {
+  ping: () => string;
+  updateClientInfo: (info: Omit<ClientInfo, "clientId" | "connectedAt" | "lastActiveAt">) => void;
+}
+interface PluginServerFunctions {}
+type ServerFunctions = BaseServerFunctions & PluginServerFunctions;
+interface BaseClientFunctions {
+  notifyTaskUpdate: (count: number) => void;
+  notifyTaskCompleted: (taskId: string) => void;
+}
+interface PluginClientFunctions {}
+type ClientFunctions = BaseClientFunctions & PluginClientFunctions;
+//#endregion
+//#region src/core/client-manager.d.ts
+interface ClientConnection<T extends Record<string, any> = object> {
+  ws: WebSocket;
+  info: ClientInfo;
+  rpc: BirpcReturn<ClientFunctions & T, ServerFunctions>;
+}
+declare class ClientManager {
+  private clients;
+  private taskQueue;
+  private taskHistory;
+  private readonly maxTaskHistory;
+  generateClientId(): string;
+  addClient(clientId: string, ws: WebSocket, rpc: BirpcReturn<ClientFunctions, ServerFunctions>): ClientInfo;
+  removeClient(clientId: string): void;
+  updateClientInfo(clientId: string, update: Partial<Omit<ClientInfo, "clientId" | "connectedAt">>): void;
+  getClient<T extends Record<string, any> = object>(clientId: string): ClientConnection<T> | undefined;
+  getAllClients(activeOnly?: boolean): ClientInfo[];
+  /**
+  * Find clients by URL pattern or other filters
+  */
+  findClients(filter: ClientDiscoveryFilter): ClientInfo[];
+  /**
+  * Get clients grouped by URL for easier identification
+  */
+  getClientsByUrl(): Record<string, ClientInfo[]>;
+  addTask(task: PendingTask): void;
+  getPendingTasks(clear?: boolean): PendingTask[];
+  getTaskCount(): number;
+  /**
+  * Get task history with optional filters
+  */
+  getTaskHistory(filter?: {
+    clientId?: string;
+    status?: TaskHistory["status"];
+    limit?: number;
+  }): TaskHistory[];
+  /**
+  * Mark a task as in progress
+  */
+  markTaskInProgress(taskId: string, clientId: string): void;
+  /**
+  * Mark a task as completed
+  */
+  markTaskCompleted(taskId: string, clientId: string, result?: Record<string, any>): void;
+  /**
+  * Mark a task as failed
+  */
+  markTaskFailed(taskId: string, clientId: string, error?: string): void;
+  private notifyAllClients;
+  notifyTaskCompleted(taskId: string, clientId?: string): void;
+}
+declare const clientManager: ClientManager;
+//#endregion
+//#region src/index.d.ts
+declare const unpluginDevpilot: UnpluginInstance<Options | undefined, false>;
+//#endregion
+export { ClientDiscoveryFilter as a, PendingTask as c, ServerFunctions as d, TaskHistory as f, BaseServerFunctions as i, PluginClientFunctions as l, Options as m, clientManager as n, ClientFunctions as o, DevpilotPlugin as p, BaseClientFunctions as r, ClientInfo as s, unpluginDevpilot as t, PluginServerFunctions as u };

package/dist/index.d.mts

@@ -0,0 +1,3 @@
+import { i as defineMcpToolRegister, n as resolveClientModule, t as DevpilotPluginContext } from "./index-CL0Gw5-1.mjs";
+import { a as ClientDiscoveryFilter, c as PendingTask, d as ServerFunctions, f as TaskHistory, i as BaseServerFunctions, l as PluginClientFunctions, m as Options, n as clientManager, o as ClientFunctions, p as DevpilotPlugin, r as BaseClientFunctions, s as ClientInfo, t as unpluginDevpilot, u as PluginServerFunctions } from "./index-CyKvTBcJ.mjs";
+export { BaseClientFunctions, BaseServerFunctions, ClientDiscoveryFilter, ClientFunctions, ClientInfo, DevpilotPlugin, DevpilotPluginContext, Options, PendingTask, PluginClientFunctions, PluginServerFunctions, ServerFunctions, TaskHistory, clientManager, unpluginDevpilot as default, unpluginDevpilot, defineMcpToolRegister, resolveClientModule };

package/dist/index.mjs

@@ -0,0 +1,4 @@
+import { n as unpluginDevpilot, r as clientManager, t as src_default } from "./src-aMXlip6o.mjs";
+import { n as defineMcpToolRegister, t as resolveClientModule } from "./plugin-PB-j5Ck2.mjs";
+
+export { clientManager, src_default as default, defineMcpToolRegister, resolveClientModule, unpluginDevpilot };

package/dist/plugin-PB-j5Ck2.mjs

@@ -0,0 +1,36 @@
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+//#region src/core/plugin/mcp.ts
+function defineMcpToolRegister(name, config, cb) {
+	return () => ({
+		name,
+		config,
+		cb
+	});
+}
+
+//#endregion
+//#region src/core/plugin/index.ts
+/**
+* Resolve the module path relative to the plugin to an absolute path
+* @param importMetaUrl - Pass in import.meta.url
+* @param relativePath - Path relative to the plugin
+* @example
+* ```ts
+* import { resolveClientModule } from 'unplugin-devpilot'
+*
+* export function myPlugin(): DevpilotPlugin {
+*   return {
+*     name: 'my-plugin',
+*     clientModule: resolveClientModule(import.meta.url, './client.mjs'),
+*   }
+* }
+* ```
+*/
+function resolveClientModule(importMetaUrl, relativePath) {
+	return `${dirname(fileURLToPath(importMetaUrl))}/${relativePath}`;
+}
+
+//#endregion
+export { defineMcpToolRegister as n, resolveClientModule as t };

package/dist/plugin.d.mts

@@ -0,0 +1,2 @@
+import { i as defineMcpToolRegister, n as resolveClientModule, r as McpToolRegister, t as DevpilotPluginContext } from "./index-CL0Gw5-1.mjs";
+export { DevpilotPluginContext, McpToolRegister as McpServerRegister, defineMcpToolRegister, resolveClientModule };

package/dist/plugin.mjs

@@ -0,0 +1,3 @@
+import { n as defineMcpToolRegister, t as resolveClientModule } from "./plugin-PB-j5Ck2.mjs";
+
+export { defineMcpToolRegister, resolveClientModule };

package/dist/rspack.d.mts

@@ -0,0 +1,19 @@
+import { t as unpluginDevpilot } from "./index-CyKvTBcJ.mjs";
+
+//#region src/rspack.d.ts
+/**
+* Rspack plugin
+*
+* @example
+* ```js
+* // rspack.config.js
+* import devpilot from 'unplugin-devpilot/rspack'
+*
+* export default {
+*   plugins: [devpilot()],
+* }
+* ```
+*/
+declare const rspack: typeof unpluginDevpilot.rspack;
+//#endregion
+export { rspack as default, rspack as "module.exports" };

package/dist/rspack.mjs

@@ -0,0 +1,26 @@
+import { n as unpluginDevpilot } from "./src-aMXlip6o.mjs";
+
+//#region src/rspack.ts
+/**
+* This entry file is for Rspack plugin.
+*
+* @module
+*/
+/**
+* Rspack plugin
+*
+* @example
+* ```js
+* // rspack.config.js
+* import devpilot from 'unplugin-devpilot/rspack'
+*
+* export default {
+*   plugins: [devpilot()],
+* }
+* ```
+*/
+const rspack = unpluginDevpilot.rspack;
+var rspack_default = rspack;
+
+//#endregion
+export { rspack_default as default, rspack as "module.exports" };