@wingman-ai/gateway 0.1.0

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

@@ -0,0 +1,53 @@
+import { Database } from "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 Database(filenameOrDatabase, {
+            create: true
+        }) : filenameOrDatabase;
+    }
+}
+export { BunSqliteAdapter };

package/dist/cli/core/loggerBridge.cjs

@@ -0,0 +1,42 @@
+"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__, {
+    createBridgedLogger: ()=>createBridgedLogger
+});
+const external_logger_cjs_namespaceObject = require("../../logger.cjs");
+function createBridgedLogger(outputManager, level = "info") {
+    return (0, external_logger_cjs_namespaceObject.createEventLogger)((event)=>{
+        const emitToOutput = "1" === process.env.WINGMAN_LOG_TO_OUTPUT;
+        if (emitToOutput && "silent" !== event.level) outputManager.emitLog(event.level, event.message, event.args);
+    }, level);
+}
+exports.createBridgedLogger = __webpack_exports__.createBridgedLogger;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createBridgedLogger"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,8 @@
+import { type LogLevel } from "../../logger.js";
+import type { OutputManager } from "./outputManager.js";
+/**
+ * Create a logger that bridges to the OutputManager
+ * This logger emits log events that are routed through OutputManager
+ * for either Ink UI display or JSON output
+ */
+export declare function createBridgedLogger(outputManager: OutputManager, level?: LogLevel): import("../../logger.js").Logger;

package/dist/cli/core/loggerBridge.js

@@ -0,0 +1,8 @@
+import { createEventLogger } from "../../logger.js";
+function createBridgedLogger(outputManager, level = "info") {
+    return createEventLogger((event)=>{
+        const emitToOutput = "1" === process.env.WINGMAN_LOG_TO_OUTPUT;
+        if (emitToOutput && "silent" !== event.level) outputManager.emitLog(event.level, event.message, event.args);
+    }, level);
+}
+export { createBridgedLogger };

package/dist/cli/core/outputManager.cjs

@@ -0,0 +1,106 @@
+"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__, {
+    OutputManager: ()=>OutputManager
+});
+const external_node_events_namespaceObject = require("node:events");
+const external_logger_cjs_namespaceObject = require("../../logger.cjs");
+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 OutputManager extends external_node_events_namespaceObject.EventEmitter {
+    static detectMode() {
+        return process.stdout.isTTY ? "interactive" : "json";
+    }
+    getMode() {
+        return this.mode;
+    }
+    emitEvent(event) {
+        if ("json" === this.mode) process.stdout.write(`${JSON.stringify(event)}\n`);
+        else this.emit("output-event", event);
+    }
+    emitLog(level, message, args) {
+        this.emitEvent({
+            type: "log",
+            level,
+            message,
+            timestamp: new Date().toISOString(),
+            args
+        });
+    }
+    emitAgentStart(agent, prompt) {
+        this.emitEvent({
+            type: "agent-start",
+            agent,
+            prompt,
+            timestamp: new Date().toISOString()
+        });
+    }
+    emitAgentStream(chunk) {
+        this.emitEvent({
+            type: "agent-stream",
+            chunk,
+            timestamp: new Date().toISOString()
+        });
+    }
+    emitAgentComplete(result) {
+        this.emitEvent({
+            type: "agent-complete",
+            result,
+            timestamp: new Date().toISOString()
+        });
+    }
+    emitAgentError(error) {
+        const errorMsg = error instanceof Error ? error.message : error;
+        const stack = error instanceof Error ? error.stack : void 0;
+        const logFile = (0, external_logger_cjs_namespaceObject.getLogFilePath)();
+        this.emitEvent({
+            type: "agent-error",
+            error: errorMsg,
+            stack,
+            logFile,
+            timestamp: new Date().toISOString()
+        });
+    }
+    constructor(mode = "interactive"){
+        super(), _define_property(this, "mode", void 0);
+        this.mode = mode;
+    }
+}
+exports.OutputManager = __webpack_exports__.OutputManager;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "OutputManager"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,43 @@
+import { EventEmitter } from "node:events";
+import type { OutputMode, OutputEvent } from "../types.js";
+export declare class OutputManager extends EventEmitter {
+    private mode;
+    constructor(mode?: OutputMode);
+    /**
+     * Detect output mode based on TTY status
+     * If stdout is a TTY, use interactive mode
+     * Otherwise (pipe, redirect, etc.), use JSON mode
+     */
+    static detectMode(): OutputMode;
+    /**
+     * Get the current output mode
+     */
+    getMode(): OutputMode;
+    /**
+     * Emit an output event
+     * In JSON mode: writes to stdout as single-line JSON
+     * In interactive mode: emits event for Ink components to handle
+     */
+    emitEvent(event: OutputEvent): void;
+    /**
+     * Emit a log event
+     */
+    emitLog(level: "debug" | "info" | "warn" | "error", message: string, args?: any[]): void;
+    /**
+     * Emit agent start event
+     */
+    emitAgentStart(agent: string, prompt: string): void;
+    /**
+     * Emit agent stream chunk
+     * Forwards raw chunks from deepagents/LangGraph for client-side interpretation
+     */
+    emitAgentStream(chunk: any): void;
+    /**
+     * Emit agent completion
+     */
+    emitAgentComplete(result: any): void;
+    /**
+     * Emit agent error
+     */
+    emitAgentError(error: Error | string): void;
+}

package/dist/cli/core/outputManager.js

@@ -0,0 +1,72 @@
+import { EventEmitter } from "node:events";
+import { getLogFilePath } from "../../logger.js";
+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 OutputManager extends EventEmitter {
+    static detectMode() {
+        return process.stdout.isTTY ? "interactive" : "json";
+    }
+    getMode() {
+        return this.mode;
+    }
+    emitEvent(event) {
+        if ("json" === this.mode) process.stdout.write(`${JSON.stringify(event)}\n`);
+        else this.emit("output-event", event);
+    }
+    emitLog(level, message, args) {
+        this.emitEvent({
+            type: "log",
+            level,
+            message,
+            timestamp: new Date().toISOString(),
+            args
+        });
+    }
+    emitAgentStart(agent, prompt) {
+        this.emitEvent({
+            type: "agent-start",
+            agent,
+            prompt,
+            timestamp: new Date().toISOString()
+        });
+    }
+    emitAgentStream(chunk) {
+        this.emitEvent({
+            type: "agent-stream",
+            chunk,
+            timestamp: new Date().toISOString()
+        });
+    }
+    emitAgentComplete(result) {
+        this.emitEvent({
+            type: "agent-complete",
+            result,
+            timestamp: new Date().toISOString()
+        });
+    }
+    emitAgentError(error) {
+        const errorMsg = error instanceof Error ? error.message : error;
+        const stack = error instanceof Error ? error.stack : void 0;
+        const logFile = getLogFilePath();
+        this.emitEvent({
+            type: "agent-error",
+            error: errorMsg,
+            stack,
+            logFile,
+            timestamp: new Date().toISOString()
+        });
+    }
+    constructor(mode = "interactive"){
+        super(), _define_property(this, "mode", void 0);
+        this.mode = mode;
+    }
+}
+export { OutputManager };