@wingman-ai/gateway 0.1.0

package/dist/cli/core/commandHandler.cjs

@@ -0,0 +1,257 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    CommandHandler: ()=>CommandHandler
+});
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class CommandHandler {
+    isCommand(input) {
+        return input.trim().startsWith("/");
+    }
+    async executeCommand(input) {
+        const trimmed = input.trim();
+        const parts = trimmed.split(/\s+/);
+        const command = parts[0].toLowerCase();
+        const args = parts.slice(1);
+        this.logger.debug(`Executing command: ${command} with args: ${args.join(" ")}`);
+        switch(command){
+            case "/sessions":
+                return this.handleSessions(args);
+            case "/resume":
+                return this.handleResume(args);
+            case "/clear":
+                return this.handleClear(args);
+            case "/show":
+                return this.handleShow(args);
+            case "/help":
+                return this.handleHelp();
+            case "/archive":
+                return this.handleArchive(args);
+            default:
+                return {
+                    type: "error",
+                    message: `Unknown command: ${command}\nType /help for available commands.`
+                };
+        }
+    }
+    handleSessions(args) {
+        try {
+            const limit = args[0] ? parseInt(args[0], 10) : 10;
+            const sessions = this.sessionManager.listSessions({
+                status: "active",
+                limit: Math.min(limit, 50)
+            });
+            return {
+                type: "sessions",
+                data: sessions,
+                message: `Found ${sessions.length} active session(s)`
+            };
+        } catch (error) {
+            this.logger.error(`Failed to list sessions: ${error}`);
+            return {
+                type: "error",
+                message: `Failed to list sessions: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    handleResume(args) {
+        if (0 === args.length) return {
+            type: "error",
+            message: "Usage: /resume <session-id>\nUse /sessions to see available sessions."
+        };
+        const sessionId = args[0];
+        try {
+            const session = this.sessionManager.getSession(sessionId);
+            if (!session) return {
+                type: "error",
+                message: `Session not found: ${sessionId}`
+            };
+            if ("active" !== session.status) return {
+                type: "error",
+                message: `Session ${sessionId} is ${session.status}. Only active sessions can be resumed.`
+            };
+            this.currentSessionId = sessionId;
+            return {
+                type: "text",
+                data: {
+                    sessionId,
+                    session
+                },
+                message: `Resumed session: ${session.name}\nAgent: ${session.agentName}\nMessages: ${session.messageCount}`
+            };
+        } catch (error) {
+            this.logger.error(`Failed to resume session: ${error}`);
+            return {
+                type: "error",
+                message: `Failed to resume session: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    handleClear(args) {
+        try {
+            const agentName = args[0];
+            if (!agentName) return {
+                type: "error",
+                message: "Usage: /clear <agent-name>\nExample: /clear coder"
+            };
+            const newSession = this.sessionManager.createSession(agentName);
+            this.currentSessionId = newSession.id;
+            return {
+                type: "text",
+                data: {
+                    sessionId: newSession.id,
+                    session: newSession
+                },
+                message: `Started new session for agent: ${agentName}\nSession ID: ${newSession.id}`
+            };
+        } catch (error) {
+            this.logger.error(`Failed to create new session: ${error}`);
+            return {
+                type: "error",
+                message: `Failed to create new session: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    handleShow(args) {
+        try {
+            if (!this.currentSessionId) return {
+                type: "text",
+                message: "No active session. Use /clear to start a new session."
+            };
+            const session = this.sessionManager.getSession(this.currentSessionId);
+            if (!session) return {
+                type: "error",
+                message: `Current session not found: ${this.currentSessionId}`
+            };
+            const info = [
+                `Current Session: ${session.name}`,
+                `ID: ${session.id}`,
+                `Agent: ${session.agentName}`,
+                `Messages: ${session.messageCount}`,
+                `Created: ${session.createdAt.toLocaleString()}`,
+                `Updated: ${session.updatedAt.toLocaleString()}`,
+                `Status: ${session.status}`
+            ];
+            if (session.lastMessagePreview) info.push(`\nLast message: ${session.lastMessagePreview}`);
+            return {
+                type: "text",
+                data: session,
+                message: info.join("\n")
+            };
+        } catch (error) {
+            this.logger.error(`Failed to show session info: ${error}`);
+            return {
+                type: "error",
+                message: `Failed to show session info: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    handleArchive(args) {
+        if (0 === args.length) return {
+            type: "error",
+            message: "Usage: /archive <session-id>\nUse /sessions to see available sessions."
+        };
+        const sessionId = args[0];
+        try {
+            const session = this.sessionManager.getSession(sessionId);
+            if (!session) return {
+                type: "error",
+                message: `Session not found: ${sessionId}`
+            };
+            this.sessionManager.archiveSession(sessionId);
+            if (this.currentSessionId === sessionId) this.currentSessionId = null;
+            return {
+                type: "text",
+                message: `Archived session: ${session.name}`
+            };
+        } catch (error) {
+            this.logger.error(`Failed to archive session: ${error}`);
+            return {
+                type: "error",
+                message: `Failed to archive session: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    handleHelp() {
+        const helpText = `
+Available Commands:
+  /sessions [limit]       List recent active sessions (default: 10, max: 50)
+  /resume <id>            Resume a specific session by ID
+  /clear <agent>          Start a new session with specified agent
+  /show                   Show current session information
+  /archive <id>           Archive a session (move to archived status)
+  /help                   Show this help message
+
+Examples:
+  /sessions               List 10 most recent sessions
+  /sessions 20            List 20 most recent sessions
+  /resume abc123          Resume session with ID 'abc123'
+  /clear coder            Start new session with 'coder' agent
+  /show                   Display current session details
+  /archive abc123         Archive session 'abc123'
+
+Tips:
+  - Sessions auto-resume by default when using the same agent
+  - Use /clear to start a fresh conversation
+  - Use /sessions to see all your active sessions
+  - Archived sessions are preserved but won't auto-resume
+`;
+        return {
+            type: "help",
+            message: helpText.trim()
+        };
+    }
+    getCurrentSessionId() {
+        return this.currentSessionId;
+    }
+    setCurrentSessionId(sessionId) {
+        this.currentSessionId = sessionId;
+    }
+    constructor(options){
+        _define_property(this, "sessionManager", void 0);
+        _define_property(this, "currentSessionId", void 0);
+        _define_property(this, "logger", void 0);
+        this.sessionManager = options.sessionManager;
+        this.currentSessionId = options.currentSessionId;
+        this.logger = options.logger;
+    }
+}
+exports.CommandHandler = __webpack_exports__.CommandHandler;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CommandHandler"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cli/core/commandHandler.d.ts

@@ -0,0 +1,62 @@
+import type { SessionManager } from "./sessionManager.js";
+import type { Logger } from "@/logger.js";
+export interface CommandResult {
+    type: "text" | "sessions" | "error" | "help";
+    data?: any;
+    message?: string;
+}
+export interface CommandHandlerOptions {
+    sessionManager: SessionManager;
+    currentSessionId: string | null;
+    logger: Logger;
+}
+/**
+ * CommandHandler processes in-chat slash commands
+ * Commands: /sessions, /resume, /clear, /show, /help
+ */
+export declare class CommandHandler {
+    private sessionManager;
+    private currentSessionId;
+    private logger;
+    constructor(options: CommandHandlerOptions);
+    /**
+     * Check if input is a command (starts with /)
+     */
+    isCommand(input: string): boolean;
+    /**
+     * Parse and execute a command
+     */
+    executeCommand(input: string): Promise<CommandResult>;
+    /**
+     * List recent sessions
+     */
+    private handleSessions;
+    /**
+     * Resume a specific session by ID
+     */
+    private handleResume;
+    /**
+     * Clear current session and start a new one
+     */
+    private handleClear;
+    /**
+     * Show current session info
+     */
+    private handleShow;
+    /**
+     * Archive a session
+     */
+    private handleArchive;
+    /**
+     * Show help information
+     */
+    private handleHelp;
+    /**
+     * Get current session ID
+     */
+    getCurrentSessionId(): string | null;
+    /**
+     * Set current session ID
+     */
+    setCurrentSessionId(sessionId: string | null): void;
+}

package/dist/cli/core/commandHandler.js

@@ -0,0 +1,223 @@
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class CommandHandler {
+    isCommand(input) {
+        return input.trim().startsWith("/");
+    }
+    async executeCommand(input) {
+        const trimmed = input.trim();
+        const parts = trimmed.split(/\s+/);
+        const command = parts[0].toLowerCase();
+        const args = parts.slice(1);
+        this.logger.debug(`Executing command: ${command} with args: ${args.join(" ")}`);
+        switch(command){
+            case "/sessions":
+                return this.handleSessions(args);
+            case "/resume":
+                return this.handleResume(args);
+            case "/clear":
+                return this.handleClear(args);
+            case "/show":
+                return this.handleShow(args);
+            case "/help":
+                return this.handleHelp();
+            case "/archive":
+                return this.handleArchive(args);
+            default:
+                return {
+                    type: "error",
+                    message: `Unknown command: ${command}\nType /help for available commands.`
+                };
+        }
+    }
+    handleSessions(args) {
+        try {
+            const limit = args[0] ? parseInt(args[0], 10) : 10;
+            const sessions = this.sessionManager.listSessions({
+                status: "active",
+                limit: Math.min(limit, 50)
+            });
+            return {
+                type: "sessions",
+                data: sessions,
+                message: `Found ${sessions.length} active session(s)`
+            };
+        } catch (error) {
+            this.logger.error(`Failed to list sessions: ${error}`);
+            return {
+                type: "error",
+                message: `Failed to list sessions: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    handleResume(args) {
+        if (0 === args.length) return {
+            type: "error",
+            message: "Usage: /resume <session-id>\nUse /sessions to see available sessions."
+        };
+        const sessionId = args[0];
+        try {
+            const session = this.sessionManager.getSession(sessionId);
+            if (!session) return {
+                type: "error",
+                message: `Session not found: ${sessionId}`
+            };
+            if ("active" !== session.status) return {
+                type: "error",
+                message: `Session ${sessionId} is ${session.status}. Only active sessions can be resumed.`
+            };
+            this.currentSessionId = sessionId;
+            return {
+                type: "text",
+                data: {
+                    sessionId,
+                    session
+                },
+                message: `Resumed session: ${session.name}\nAgent: ${session.agentName}\nMessages: ${session.messageCount}`
+            };
+        } catch (error) {
+            this.logger.error(`Failed to resume session: ${error}`);
+            return {
+                type: "error",
+                message: `Failed to resume session: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    handleClear(args) {
+        try {
+            const agentName = args[0];
+            if (!agentName) return {
+                type: "error",
+                message: "Usage: /clear <agent-name>\nExample: /clear coder"
+            };
+            const newSession = this.sessionManager.createSession(agentName);
+            this.currentSessionId = newSession.id;
+            return {
+                type: "text",
+                data: {
+                    sessionId: newSession.id,
+                    session: newSession
+                },
+                message: `Started new session for agent: ${agentName}\nSession ID: ${newSession.id}`
+            };
+        } catch (error) {
+            this.logger.error(`Failed to create new session: ${error}`);
+            return {
+                type: "error",
+                message: `Failed to create new session: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    handleShow(args) {
+        try {
+            if (!this.currentSessionId) return {
+                type: "text",
+                message: "No active session. Use /clear to start a new session."
+            };
+            const session = this.sessionManager.getSession(this.currentSessionId);
+            if (!session) return {
+                type: "error",
+                message: `Current session not found: ${this.currentSessionId}`
+            };
+            const info = [
+                `Current Session: ${session.name}`,
+                `ID: ${session.id}`,
+                `Agent: ${session.agentName}`,
+                `Messages: ${session.messageCount}`,
+                `Created: ${session.createdAt.toLocaleString()}`,
+                `Updated: ${session.updatedAt.toLocaleString()}`,
+                `Status: ${session.status}`
+            ];
+            if (session.lastMessagePreview) info.push(`\nLast message: ${session.lastMessagePreview}`);
+            return {
+                type: "text",
+                data: session,
+                message: info.join("\n")
+            };
+        } catch (error) {
+            this.logger.error(`Failed to show session info: ${error}`);
+            return {
+                type: "error",
+                message: `Failed to show session info: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    handleArchive(args) {
+        if (0 === args.length) return {
+            type: "error",
+            message: "Usage: /archive <session-id>\nUse /sessions to see available sessions."
+        };
+        const sessionId = args[0];
+        try {
+            const session = this.sessionManager.getSession(sessionId);
+            if (!session) return {
+                type: "error",
+                message: `Session not found: ${sessionId}`
+            };
+            this.sessionManager.archiveSession(sessionId);
+            if (this.currentSessionId === sessionId) this.currentSessionId = null;
+            return {
+                type: "text",
+                message: `Archived session: ${session.name}`
+            };
+        } catch (error) {
+            this.logger.error(`Failed to archive session: ${error}`);
+            return {
+                type: "error",
+                message: `Failed to archive session: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    handleHelp() {
+        const helpText = `
+Available Commands:
+  /sessions [limit]       List recent active sessions (default: 10, max: 50)
+  /resume <id>            Resume a specific session by ID
+  /clear <agent>          Start a new session with specified agent
+  /show                   Show current session information
+  /archive <id>           Archive a session (move to archived status)
+  /help                   Show this help message
+
+Examples:
+  /sessions               List 10 most recent sessions
+  /sessions 20            List 20 most recent sessions
+  /resume abc123          Resume session with ID 'abc123'
+  /clear coder            Start new session with 'coder' agent
+  /show                   Display current session details
+  /archive abc123         Archive session 'abc123'
+
+Tips:
+  - Sessions auto-resume by default when using the same agent
+  - Use /clear to start a fresh conversation
+  - Use /sessions to see all your active sessions
+  - Archived sessions are preserved but won't auto-resume
+`;
+        return {
+            type: "help",
+            message: helpText.trim()
+        };
+    }
+    getCurrentSessionId() {
+        return this.currentSessionId;
+    }
+    setCurrentSessionId(sessionId) {
+        this.currentSessionId = sessionId;
+    }
+    constructor(options){
+        _define_property(this, "sessionManager", void 0);
+        _define_property(this, "currentSessionId", void 0);
+        _define_property(this, "logger", void 0);
+        this.sessionManager = options.sessionManager;
+        this.currentSessionId = options.currentSessionId;
+        this.logger = options.logger;
+    }
+}
+export { CommandHandler };

package/dist/cli/core/database/bunSqliteAdapter.cjs

@@ -0,0 +1,87 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    BunSqliteAdapter: ()=>BunSqliteAdapter
+});
+const external_bun_sqlite_namespaceObject = require("bun:sqlite");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class BunSqliteAdapter {
+    prepare(sql) {
+        const stmt = this.db.prepare(sql);
+        return {
+            ...stmt,
+            get: (...params)=>{
+                const result = stmt.get(...params);
+                return null === result ? void 0 : result;
+            },
+            all: (...params)=>stmt.all(...params),
+            run: (...params)=>stmt.run(...params)
+        };
+    }
+    exec(sql) {
+        return this.db.run(sql);
+    }
+    run(sql, ...params) {
+        return this.db.run(sql, ...params);
+    }
+    pragma(pragma, simplify) {
+        const result = this.db.prepare(`PRAGMA ${pragma}`).get();
+        return simplify ? result : {
+            [pragma]: result
+        };
+    }
+    transaction(fn) {
+        return this.db.transaction(fn);
+    }
+    close() {
+        return this.db.close();
+    }
+    get inTransaction() {
+        return false;
+    }
+    constructor(filenameOrDatabase){
+        _define_property(this, "db", void 0);
+        this.db = "string" == typeof filenameOrDatabase ? new external_bun_sqlite_namespaceObject.Database(filenameOrDatabase, {
+            create: true
+        }) : filenameOrDatabase;
+    }
+}
+exports.BunSqliteAdapter = __webpack_exports__.BunSqliteAdapter;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BunSqliteAdapter"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cli/core/database/bunSqliteAdapter.d.ts

@@ -0,0 +1,34 @@
+import { Database } from "bun:sqlite";
+/**
+ * Adapter making bun:sqlite compatible with better-sqlite3 interface
+ * for LangGraph's SqliteSaver.
+ *
+ * This allows SqliteSaver to work with bun:sqlite without modification.
+ * The APIs are intentionally similar as bun:sqlite was designed to be
+ * compatible with better-sqlite3.
+ */
+export declare class BunSqliteAdapter {
+    db: Database;
+    constructor(filenameOrDatabase: string | Database);
+    prepare(sql: string): {
+        get: (...params: any[]) => {} | undefined;
+        all: (...params: any[]) => unknown[];
+        run: (...params: any[]) => import("bun:sqlite").Changes;
+        columnNames: string[];
+        paramsCount: number;
+        columnTypes: Array<"INTEGER" | "FLOAT" | "TEXT" | "BLOB" | "NULL" | null>;
+        declaredTypes: Array<string | null>;
+        native: any;
+    };
+    exec(sql: string): import("bun:sqlite").Changes;
+    run(sql: string, ...params: any[]): import("bun:sqlite").Changes;
+    pragma(pragma: string, simplify?: boolean): unknown;
+    transaction(fn: (...args: any[]) => any): {
+        (...args: any[]): any;
+        deferred: (...args: any[]) => any;
+        immediate: (...args: any[]) => any;
+        exclusive: (...args: any[]) => any;
+    };
+    close(): void;
+    get inTransaction(): boolean;
+}