@thinkwell/conductor 0.5.4 → 0.5.6

package/dist/instantiators.js

@@ -1,183 +1,50 @@
-/**
- * Component instantiator helpers
- *
- * These functions create ComponentInstantiator objects that determine how
- * components are created when the conductor receives an initialize request.
- *
- * ## Instantiation Modes
- *
- * - **Static**: Components are determined at construction time (e.g., from a list of commands)
- * - **Dynamic**: Components are determined at runtime based on the initialize request
- *
- * ## Lazy Instantiation
- *
- * All instantiators are lazy - components are only spawned when the first
- * `initialize` request arrives. This allows the conductor to be constructed
- * before the component processes need to exist.
- */
-/**
- * Create a component instantiator from static command specifications.
- *
- * This is the most common way to create an instantiator - provide the
- * commands for each component and they will be spawned when needed.
- *
- * @example
- * ```ts
- * // Simple string commands
- * const instantiator = staticInstantiator({
- *   proxies: ['sparkle-acp'],
- *   agent: 'claude-agent',
- * });
- *
- * // With options
- * const instantiator = staticInstantiator({
- *   agent: {
- *     command: 'my-agent',
- *     args: ['--mode', 'production'],
- *     env: { DEBUG: 'true' },
- *   },
- * });
- * ```
- */
 export function staticInstantiator(config) {
-    return {
-        async instantiate() {
-            // Dynamic import to avoid circular dependency
-            const { StdioConnector } = await import("./connectors/stdio.js");
-            const proxyConnectors = (config.proxies ?? []).map((spec) => new StdioConnector(normalizeCommandSpec(spec)));
-            const agentConnector = new StdioConnector(normalizeCommandSpec(config.agent));
-            return {
-                proxies: proxyConnectors,
-                agent: agentConnector,
-            };
-        },
-    };
+  return {
+    async instantiate() {
+      const { StdioConnector } = await import("./connectors/stdio.js"), proxyConnectors = (config.proxies ?? []).map((spec) => new StdioConnector(normalizeCommandSpec(spec))), agentConnector = new StdioConnector(normalizeCommandSpec(config.agent));
+      return {
+        proxies: proxyConnectors,
+        agent: agentConnector
+      };
+    }
+  };
 }
-/**
- * Create a component instantiator from a simple list of commands.
- *
- * The last command is treated as the agent, all others as proxies.
- * This is a convenience wrapper around `staticInstantiator`.
- *
- * @example
- * ```ts
- * // Single agent (no proxies)
- * const instantiator = fromCommands(['claude-agent']);
- *
- * // Agent with proxies
- * const instantiator = fromCommands(['sparkle-acp', 'claude-agent']);
- * ```
- */
 export function fromCommands(commands) {
-    if (commands.length === 0) {
-        throw new Error("At least one command (the agent) is required");
-    }
-    return staticInstantiator({
-        proxies: commands.slice(0, -1),
-        agent: commands[commands.length - 1],
-    });
+  if (commands.length === 0)
+    throw new Error("At least one command (the agent) is required");
+  return staticInstantiator({
+    proxies: commands.slice(0, -1),
+    agent: commands[commands.length - 1]
+  });
 }
-/**
- * Create a component instantiator from explicit connectors.
- *
- * This is useful when you have pre-configured connectors or want to use
- * in-memory connections for testing.
- *
- * @example
- * ```ts
- * const instantiator = fromConnectors(agentConnector, [proxyConnector]);
- * ```
- */
 export function fromConnectors(agent, proxies = []) {
-    return {
-        async instantiate() {
-            return { proxies, agent };
-        },
-    };
+  return {
+    async instantiate() {
+      return { proxies, agent };
+    }
+  };
 }
-/**
- * Create a component instantiator with a dynamic factory function.
- *
- * The factory function is called when the first `initialize` request arrives,
- * allowing you to make decisions about what components to spawn based on
- * the request content.
- *
- * @example
- * ```ts
- * const instantiator = dynamic(async (initRequest) => {
- *   // Choose agent based on client capabilities
- *   const capabilities = initRequest.params?.capabilities ?? {};
- *   const agentCommand = capabilities.advanced ? 'advanced-agent' : 'basic-agent';
- *
- *   const { StdioConnector } = await import('./connectors/stdio.js');
- *   return {
- *     proxies: [],
- *     agent: new StdioConnector(agentCommand),
- *   };
- * });
- *
- * // Or use it to inspect MCP servers
- * const instantiator = dynamic(async (initRequest) => {
- *   const mcpServers = initRequest.params?.mcpServers ?? [];
- *   console.log('Client provided MCP servers:', mcpServers);
- *
- *   // ... create appropriate components
- * });
- * ```
- */
 export function dynamic(factory) {
-    return {
-        instantiate: factory,
-    };
+  return {
+    instantiate: factory
+  };
 }
-/**
- * Normalize a command specification to full options
- */
 function normalizeCommandSpec(spec) {
-    if (typeof spec === "string") {
-        // Parse command string into command and args
-        const parts = parseCommand(spec);
-        return {
-            command: parts[0],
-            args: parts.slice(1),
-        };
-    }
-    return spec;
+  if (typeof spec == "string") {
+    const parts = parseCommand(spec);
+    return {
+      command: parts[0],
+      args: parts.slice(1)
+    };
+  }
+  return spec;
 }
-/**
- * Parse a command string into command and arguments.
- * Handles quoted strings.
- */
 function parseCommand(command) {
-    const parts = [];
-    let current = "";
-    let inQuote = null;
-    for (let i = 0; i < command.length; i++) {
-        const char = command[i];
-        if (inQuote) {
-            if (char === inQuote) {
-                inQuote = null;
-            }
-            else {
-                current += char;
-            }
-        }
-        else if (char === '"' || char === "'") {
-            inQuote = char;
-        }
-        else if (char === " " || char === "\t") {
-            if (current) {
-                parts.push(current);
-                current = "";
-            }
-        }
-        else {
-            current += char;
-        }
-    }
-    if (current) {
-        parts.push(current);
-    }
-    return parts;
+  const parts = [];
+  let current = "", inQuote = null;
+  for (let i = 0; i < command.length; i++) {
+    const char = command[i];
+    inQuote ? char === inQuote ? inQuote = null : current += char : char === '"' || char === "'" ? inQuote = char : char === " " || char === "	" ? current && (parts.push(current), current = "") : current += char;
+  }
+  return current && parts.push(current), parts;
 }
-//# sourceMappingURL=instantiators.js.map

package/dist/logger.js

@@ -1,162 +1,94 @@
-/**
- * Logging module for the conductor
- *
- * Provides structured logging with configurable levels and optional JSONL tracing.
- * All conductor logging goes through this module to enable consistent output
- * formatting and filtering.
- *
- * ## Log Levels
- *
- * - `error`: Errors that affect operation (component crashes, protocol violations)
- * - `warn`: Warnings about potential issues (missing responses, malformed messages)
- * - `info`: Key operational events (component start/stop, connections)
- * - `debug`: Detailed debugging information (message routing, state changes)
- * - `trace`: Very detailed tracing (every message, internal state)
- *
- * ## Usage
- *
- * ```typescript
- * const logger = createLogger({ level: 'debug', name: 'my-conductor' });
- * logger.info('Component started', { component: 'agent', pid: 1234 });
- * logger.error('Failed to connect', { error: err.message });
- * ```
- *
- * ## JSONL Tracing
- *
- * When enabled, all messages routed through the conductor are written to a
- * JSONL file for debugging and analysis:
- *
- * ```typescript
- * const logger = createLogger({
- *   level: 'info',
- *   trace: { path: '/tmp/conductor.jsonl' }
- * });
- * ```
- */
 import { createWriteStream } from "node:fs";
 const LOG_LEVELS = {
-    error: 0,
-    warn: 1,
-    info: 2,
-    debug: 3,
-    trace: 4,
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+  trace: 4
 };
-/**
- * Create a no-op logger that discards all output
- */
 export function createNoopLogger() {
-    const noop = () => { };
-    return {
-        error: noop,
-        warn: noop,
-        info: noop,
-        debug: noop,
-        trace: noop,
-        traceMessage: noop,
-        isEnabled: () => false,
-        child: () => createNoopLogger(),
-        close: async () => { },
-    };
+  const noop = () => {
+  };
+  return {
+    error: noop,
+    warn: noop,
+    info: noop,
+    debug: noop,
+    trace: noop,
+    traceMessage: noop,
+    isEnabled: () => !1,
+    child: () => createNoopLogger(),
+    close: async () => {
+    }
+  };
 }
-/**
- * Create a logger with the specified options
- */
 export function createLogger(options = {}) {
-    const level = options.level ?? "info";
-    const levelNum = LOG_LEVELS[level];
-    const name = options.name;
-    const useJson = options.json ?? false;
-    // Set up trace file if configured
-    let traceStream = null;
-    if (options.trace) {
-        traceStream = createWriteStream(options.trace.path, { flags: "a" });
-    }
-    function isEnabled(checkLevel) {
-        return LOG_LEVELS[checkLevel] <= levelNum;
-    }
-    function log(logLevel, message, data) {
-        if (!isEnabled(logLevel)) {
-            return;
-        }
-        const entry = {
-            timestamp: new Date().toISOString(),
-            level: logLevel,
-            name,
-            message,
-            data,
-        };
-        if (useJson) {
-            // Output as JSON for machine parsing
-            const output = logLevel === "error" || logLevel === "warn" ? console.error : console.log;
-            output(JSON.stringify(entry));
-        }
-        else {
-            // Human-readable format
-            const prefix = name ? `[${name}]` : "";
-            const levelStr = logLevel.toUpperCase().padEnd(5);
-            const dataStr = data ? ` ${JSON.stringify(data)}` : "";
-            const output = logLevel === "error" || logLevel === "warn" ? console.error : console.log;
-            output(`${entry.timestamp} ${levelStr} ${prefix}${prefix ? " " : ""}${message}${dataStr}`);
-        }
-    }
-    function traceMessage(entry) {
-        if (!traceStream) {
-            return;
-        }
-        const fullEntry = {
-            timestamp: new Date().toISOString(),
-            ...entry,
-        };
-        traceStream.write(JSON.stringify(fullEntry) + "\n");
-    }
-    function child(childName) {
-        const fullName = name ? `${name}:${childName}` : childName;
-        return createLogger({
-            ...options,
-            name: fullName,
-            // Share trace stream with parent
-            trace: undefined, // Don't create new stream
-        });
-    }
-    async function close() {
-        if (traceStream) {
-            await new Promise((resolve, reject) => {
-                traceStream.end((err) => {
-                    if (err)
-                        reject(err);
-                    else
-                        resolve();
-                });
-            });
-            traceStream = null;
-        }
+  const level = options.level ?? "info", levelNum = LOG_LEVELS[level], name = options.name, useJson = options.json ?? !1;
+  let traceStream = null;
+  options.trace && (traceStream = createWriteStream(options.trace.path, { flags: "a" }));
+  function isEnabled(checkLevel) {
+    return LOG_LEVELS[checkLevel] <= levelNum;
+  }
+  function log(logLevel, message, data) {
+    if (!isEnabled(logLevel))
+      return;
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level: logLevel,
+      name,
+      message,
+      data
+    };
+    if (useJson)
+      (logLevel === "error" || logLevel === "warn" ? console.error : console.log)(JSON.stringify(entry));
+    else {
+      const prefix = name ? `[${name}]` : "", levelStr = logLevel.toUpperCase().padEnd(5), dataStr = data ? ` ${JSON.stringify(data)}` : "";
+      (logLevel === "error" || logLevel === "warn" ? console.error : console.log)(`${entry.timestamp} ${levelStr} ${prefix}${prefix ? " " : ""}${message}${dataStr}`);
     }
-    return {
-        error: (message, data) => log("error", message, data),
-        warn: (message, data) => log("warn", message, data),
-        info: (message, data) => log("info", message, data),
-        debug: (message, data) => log("debug", message, data),
-        trace: (message, data) => log("trace", message, data),
-        traceMessage,
-        isEnabled,
-        child,
-        close,
+  }
+  function traceMessage(entry) {
+    if (!traceStream)
+      return;
+    const fullEntry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...entry
     };
+    traceStream.write(JSON.stringify(fullEntry) + `
+`);
+  }
+  function child(childName) {
+    const fullName = name ? `${name}:${childName}` : childName;
+    return createLogger({
+      ...options,
+      name: fullName,
+      // Share trace stream with parent
+      trace: void 0
+      // Don't create new stream
+    });
+  }
+  async function close() {
+    traceStream && (await new Promise((resolve, reject) => {
+      traceStream.end((err) => {
+        err ? reject(err) : resolve();
+      });
+    }), traceStream = null);
+  }
+  return {
+    error: (message, data) => log("error", message, data),
+    warn: (message, data) => log("warn", message, data),
+    info: (message, data) => log("info", message, data),
+    debug: (message, data) => log("debug", message, data),
+    trace: (message, data) => log("trace", message, data),
+    traceMessage,
+    isEnabled,
+    child,
+    close
+  };
 }
-/**
- * Default logger instance (silent by default, can be replaced)
- */
 let defaultLogger = createNoopLogger();
-/**
- * Get the default logger
- */
 export function getLogger() {
-    return defaultLogger;
+  return defaultLogger;
 }
-/**
- * Set the default logger
- */
 export function setLogger(logger) {
-    defaultLogger = logger;
+  defaultLogger = logger;
 }
-//# sourceMappingURL=logger.js.map