@radaros/core 0.3.5 → 0.3.6

package/src/logger/logger.ts

@@ -1,249 +0,0 @@
-export type LogLevel = "debug" | "info" | "warn" | "error" | "silent";
-
-const LEVEL_ORDER: Record<LogLevel, number> = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3,
-  silent: 4,
-};
-
-const C = {
-  reset: "\x1b[0m",
-  bold: "\x1b[1m",
-  dim: "\x1b[2m",
-  italic: "\x1b[3m",
-
-  black: "\x1b[30m",
-  red: "\x1b[31m",
-  green: "\x1b[32m",
-  yellow: "\x1b[33m",
-  blue: "\x1b[34m",
-  magenta: "\x1b[35m",
-  cyan: "\x1b[36m",
-  white: "\x1b[37m",
-
-  bgBlack: "\x1b[40m",
-  bgRed: "\x1b[41m",
-  bgGreen: "\x1b[42m",
-  bgYellow: "\x1b[43m",
-  bgBlue: "\x1b[44m",
-  bgMagenta: "\x1b[45m",
-  bgCyan: "\x1b[46m",
-
-  gray: "\x1b[90m",
-  brightGreen: "\x1b[92m",
-  brightYellow: "\x1b[93m",
-  brightBlue: "\x1b[94m",
-  brightMagenta: "\x1b[95m",
-  brightCyan: "\x1b[96m",
-};
-
-function noColor(str: string): string {
-  return str.replace(/\x1b\[[0-9;]*m/g, "");
-}
-
-export interface LoggerConfig {
-  level?: LogLevel;
-  color?: boolean;
-  prefix?: string;
-}
-
-export class Logger {
-  private level: LogLevel;
-  private color: boolean;
-  private prefix: string;
-
-  constructor(config: LoggerConfig = {}) {
-    this.level = config.level ?? "info";
-    this.color = config.color ?? process.stdout.isTTY !== false;
-    this.prefix = config.prefix ?? "radaros";
-  }
-
-  private c(code: string, text: string): string {
-    return this.color ? `${code}${text}${C.reset}` : text;
-  }
-
-  private shouldLog(level: LogLevel): boolean {
-    return LEVEL_ORDER[level] >= LEVEL_ORDER[this.level];
-  }
-
-  private tag(level: LogLevel): string {
-    switch (level) {
-      case "debug":
-        return this.c(C.gray, "DBG");
-      case "info":
-        return this.c(C.brightCyan, "INF");
-      case "warn":
-        return this.c(C.brightYellow, "WRN");
-      case "error":
-        return this.c(C.red, "ERR");
-      default:
-        return "";
-    }
-  }
-
-  private timestamp(): string {
-    const now = new Date();
-    const ts = now.toISOString().slice(11, 23);
-    return this.c(C.dim, ts);
-  }
-
-  private log(level: LogLevel, msg: string, data?: Record<string, unknown>): void {
-    if (!this.shouldLog(level)) return;
-    const parts = [
-      this.timestamp(),
-      this.tag(level),
-      this.c(C.dim, `[${this.prefix}]`),
-      msg,
-    ];
-    if (data && Object.keys(data).length > 0) {
-      const formatted = Object.entries(data)
-        .map(([k, v]) => `${this.c(C.dim, k + "=")}${this.formatValue(v)}`)
-        .join(" ");
-      parts.push(formatted);
-    }
-    console.log(parts.join(" "));
-  }
-
-  private formatValue(v: unknown): string {
-    if (typeof v === "number") return this.c(C.brightGreen, String(v));
-    if (typeof v === "string") return this.c(C.yellow, `"${v}"`);
-    if (typeof v === "boolean") return this.c(C.magenta, String(v));
-    return String(v);
-  }
-
-  debug(msg: string, data?: Record<string, unknown>) {
-    this.log("debug", msg, data);
-  }
-
-  info(msg: string, data?: Record<string, unknown>) {
-    this.log("info", msg, data);
-  }
-
-  warn(msg: string, data?: Record<string, unknown>) {
-    this.log("warn", msg, data);
-  }
-
-  error(msg: string, data?: Record<string, unknown>) {
-    this.log("error", msg, data);
-  }
-
-  // ── Formatted agent output helpers ────────────────────────────────────
-
-  private readonly boxWidth = 80;
-
-  private pipe(): string {
-    return this.c(C.brightCyan, "│");
-  }
-
-  private printBoxLine(label: string, value: string, labelColor = C.dim, valueColor = C.white): void {
-    const lines = value.split("\n");
-    const prefix = `${this.pipe()} ${this.c(labelColor, label)}`;
-    console.log(`${prefix}${this.c(valueColor, lines[0])}`);
-    const pad = " ".repeat(noColor(label).length);
-    for (let i = 1; i < lines.length; i++) {
-      console.log(`${this.pipe()} ${pad}${this.c(valueColor, lines[i])}`);
-    }
-  }
-
-  agentStart(agentName: string, input: string): void {
-    if (!this.shouldLog("info")) return;
-    const title = ` Agent: ${agentName} `;
-    const lineLen = Math.max(0, this.boxWidth - title.length - 2);
-    console.log("");
-    console.log(
-      this.c(C.bold + C.brightCyan, "┌─") +
-        this.c(C.bold + C.brightCyan, title) +
-        this.c(C.dim, "─".repeat(lineLen))
-    );
-    this.printBoxLine("Input:  ", input);
-    console.log(this.pipe());
-  }
-
-  toolCall(toolName: string, args: Record<string, unknown>): void {
-    if (!this.shouldLog("debug")) return;
-    const argsStr = JSON.stringify(args, null, 2);
-    console.log(
-      `${this.pipe()} ${this.c(C.brightMagenta, "⚡")} ${this.c(C.magenta, toolName)}`
-    );
-    if (argsStr !== "{}" && argsStr !== "[]") {
-      const truncated = argsStr.length > 200 ? argsStr.slice(0, 200) + "…" : argsStr;
-      for (const line of truncated.split("\n")) {
-        console.log(`${this.pipe()}   ${this.c(C.dim, line)}`);
-      }
-    }
-  }
-
-  toolResult(toolName: string, result: string): void {
-    if (!this.shouldLog("debug")) return;
-    const truncated = result.length > 300 ? result.slice(0, 300) + "…" : result;
-    console.log(
-      `${this.pipe()} ${this.c(C.green, "✓")} ${this.c(C.dim, toolName + " →")}`
-    );
-    for (const line of truncated.split("\n")) {
-      console.log(`${this.pipe()}   ${this.c(C.gray, line)}`);
-    }
-    console.log(this.pipe());
-  }
-
-  thinking(content: string): void {
-    if (!this.shouldLog("info")) return;
-    const truncated = content.length > 500 ? content.slice(0, 500) + "…" : content;
-    const label = this.c(C.dim + C.italic, "Thinking: ");
-    const lines = truncated.split("\n");
-    console.log(`${this.pipe()} ${label}${this.c(C.dim + C.italic, lines[0])}`);
-    const pad = " ".repeat(10);
-    for (let i = 1; i < lines.length; i++) {
-      console.log(`${this.pipe()} ${pad}${this.c(C.dim + C.italic, lines[i])}`);
-    }
-    console.log(this.pipe());
-  }
-
-  agentEnd(
-    agentName: string,
-    output: string,
-    usage: { promptTokens: number; completionTokens: number; totalTokens: number; reasoningTokens?: number },
-    durationMs: number
-  ): void {
-    if (!this.shouldLog("info")) return;
-
-    console.log(this.pipe());
-    this.printBoxLine("Output: ", output);
-    console.log(this.pipe());
-
-    let tokensLine =
-      this.c(C.dim, "Tokens: ") +
-      this.c(C.brightGreen, `↑ ${usage.promptTokens}`) +
-      this.c(C.dim, "  ") +
-      this.c(C.brightGreen, `↓ ${usage.completionTokens}`) +
-      this.c(C.dim, "  ") +
-      this.c(C.bold + C.brightGreen, `Σ ${usage.totalTokens}`);
-
-    if (usage.reasoningTokens) {
-      tokensLine += this.c(C.dim, "  ") + this.c(C.brightMagenta, `🧠 ${usage.reasoningTokens}`);
-    }
-
-    const duration =
-      this.c(C.dim, "Duration: ") +
-      this.c(C.yellow, this.formatDuration(durationMs));
-
-    console.log(`${this.pipe()} ${tokensLine}`);
-    console.log(`${this.pipe()} ${duration}`);
-    console.log(
-      this.c(C.bold + C.brightCyan, "└") +
-        this.c(C.dim, "─".repeat(this.boxWidth - 1))
-    );
-  }
-
-  separator(): void {
-    if (!this.shouldLog("info")) return;
-    console.log(this.c(C.dim, "─".repeat(this.boxWidth)));
-  }
-
-  private formatDuration(ms: number): string {
-    if (ms < 1000) return `${ms}ms`;
-    const secs = (ms / 1000).toFixed(1);
-    return `${secs}s`;
-  }
-}

package/src/mcp/mcp-client.ts

@@ -1,264 +0,0 @@
-import type { ToolDef, ToolResult } from "../tools/types.js";
-import type { RunContext } from "../agent/run-context.js";
-
-export interface MCPToolProviderConfig {
-  name: string;
-  transport: "stdio" | "http";
-  /** For stdio transport: command to spawn */
-  command?: string;
-  /** For stdio transport: args for the command */
-  args?: string[];
-  /** For stdio transport: environment variables */
-  env?: Record<string, string>;
-  /** For http transport: server URL */
-  url?: string;
-  /** For http transport: custom headers */
-  headers?: Record<string, string>;
-}
-
-/**
- * Connects to an MCP (Model Context Protocol) server and exposes its tools
- * as native RadarOS ToolDef[] that any Agent can use.
- *
- * Supports stdio and HTTP (Streamable HTTP) transports.
- * Requires: npm install @modelcontextprotocol/sdk
- */
-export class MCPToolProvider {
-  readonly name: string;
-  private config: MCPToolProviderConfig;
-  private client: any = null;
-  private transportInstance: any = null;
-  private tools: ToolDef[] = [];
-  private connected = false;
-
-  constructor(config: MCPToolProviderConfig) {
-    this.name = config.name;
-    this.config = config;
-  }
-
-  async connect(): Promise<void> {
-    if (this.connected) return;
-
-    let ClientClass: any;
-    try {
-      const mod = await import("@modelcontextprotocol/sdk/client/index.js");
-      ClientClass = mod.Client;
-    } catch {
-      throw new Error(
-        "@modelcontextprotocol/sdk is required for MCPToolProvider. Install it: npm install @modelcontextprotocol/sdk"
-      );
-    }
-
-    this.client = new ClientClass(
-      { name: `radaros-${this.name}`, version: "1.0.0" },
-      { capabilities: {} }
-    );
-
-    if (this.config.transport === "stdio") {
-      if (!this.config.command) {
-        throw new Error("MCPToolProvider: 'command' is required for stdio transport");
-      }
-      const { StdioClientTransport } = await import(
-        "@modelcontextprotocol/sdk/client/stdio.js"
-      );
-
-      this.transportInstance = new StdioClientTransport({
-        command: this.config.command,
-        args: this.config.args ?? [],
-        env: { ...process.env, ...(this.config.env ?? {}) } as Record<string, string>,
-      });
-    } else if (this.config.transport === "http") {
-      if (!this.config.url) {
-        throw new Error("MCPToolProvider: 'url' is required for http transport");
-      }
-
-      let TransportClass: any;
-      try {
-        const mod = await import(
-          "@modelcontextprotocol/sdk/client/streamableHttp.js"
-        );
-        TransportClass = mod.StreamableHTTPClientTransport;
-      } catch {
-        const mod = await import("@modelcontextprotocol/sdk/client/sse.js");
-        TransportClass = mod.SSEClientTransport;
-      }
-
-      this.transportInstance = new TransportClass(
-        new URL(this.config.url),
-        { requestInit: { headers: this.config.headers ?? {} } }
-      );
-    } else {
-      throw new Error(`MCPToolProvider: unsupported transport '${this.config.transport}'`);
-    }
-
-    await this.client.connect(this.transportInstance);
-    this.connected = true;
-    await this.discoverTools();
-  }
-
-  private async discoverTools(): Promise<void> {
-    const { z } = await import("zod");
-    const result = await this.client.listTools();
-    const mcpTools: any[] = result.tools ?? [];
-
-    this.tools = mcpTools.map((mcpTool: any) => {
-      const toolName = mcpTool.name;
-      const description = mcpTool.description ?? "";
-      const inputSchema = mcpTool.inputSchema ?? { type: "object", properties: {} };
-
-      const parameters = this.jsonSchemaToZod(inputSchema, z);
-
-      const execute = async (
-        args: Record<string, unknown>,
-        _ctx: RunContext
-      ): Promise<string | ToolResult> => {
-        const callResult = await this.client.callTool({
-          name: toolName,
-          arguments: args,
-        });
-
-        const contents: any[] = callResult.content ?? [];
-        const textParts = contents
-          .filter((c: any) => c.type === "text")
-          .map((c: any) => c.text);
-
-        const text = textParts.join("\n") || JSON.stringify(callResult);
-
-        const artifacts = contents
-          .filter((c: any) => c.type !== "text")
-          .map((c: any) => ({
-            type: c.type,
-            data: c.data ?? c.blob ?? c.text,
-            mimeType: c.mimeType,
-          }));
-
-        if (artifacts.length > 0) {
-          return { content: text, artifacts };
-        }
-        return text;
-      };
-
-      return {
-        name: `${this.name}__${toolName}`,
-        description: `[${this.name}] ${description}`,
-        parameters,
-        execute,
-        rawJsonSchema: inputSchema,
-      } satisfies ToolDef;
-    });
-  }
-
-  private jsonSchemaToZod(schema: any, z: any): any {
-    if (!schema || !schema.properties) {
-      return z.object({}).passthrough();
-    }
-
-    const shape: Record<string, any> = {};
-    const required: string[] = schema.required ?? [];
-
-    for (const [key, prop] of Object.entries(schema.properties) as [string, any][]) {
-      let field: any;
-
-      switch (prop.type) {
-        case "string":
-          field = z.string();
-          if (prop.enum) field = z.enum(prop.enum);
-          break;
-        case "number":
-        case "integer":
-          field = z.number();
-          break;
-        case "boolean":
-          field = z.boolean();
-          break;
-        case "array":
-          field = z.array(z.any());
-          break;
-        case "object":
-          field = z.record(z.any());
-          break;
-        default:
-          field = z.any();
-      }
-
-      if (prop.description) {
-        field = field.describe(prop.description);
-      }
-
-      if (!required.includes(key)) {
-        field = field.optional();
-      }
-
-      shape[key] = field;
-    }
-
-    return z.object(shape);
-  }
-
-  /**
-   * Returns tools from this MCP server as RadarOS ToolDef[].
-   * Optionally filter by tool names to reduce token usage.
-   *
-   * @param filter - Tool names to include (without the server name prefix).
-   *                 If omitted, returns all tools.
-   *
-   * @example
-   * // All tools
-   * await mcp.getTools()
-   *
-   * // Only specific tools (pass the original MCP tool names, not prefixed)
-   * await mcp.getTools({ include: ["get_latest_release", "search_repositories"] })
-   *
-   * // Exclude specific tools
-   * await mcp.getTools({ exclude: ["push_files", "create_repository"] })
-   */
-  async getTools(filter?: {
-    include?: string[];
-    exclude?: string[];
-  }): Promise<ToolDef[]> {
-    if (!this.connected) {
-      await this.connect();
-    }
-
-    if (!filter) {
-      return [...this.tools];
-    }
-
-    const prefix = `${this.name}__`;
-
-    return this.tools.filter((tool) => {
-      const shortName = tool.name.startsWith(prefix)
-        ? tool.name.slice(prefix.length)
-        : tool.name;
-
-      if (filter.include) {
-        return filter.include.includes(shortName);
-      }
-      if (filter.exclude) {
-        return !filter.exclude.includes(shortName);
-      }
-      return true;
-    });
-  }
-
-  /** Refresh the tool list from the MCP server. */
-  async refresh(): Promise<void> {
-    if (!this.connected) {
-      throw new Error("MCPToolProvider: not connected. Call connect() first.");
-    }
-    await this.discoverTools();
-  }
-
-  /** Disconnect from the MCP server. */
-  async close(): Promise<void> {
-    if (this.client && this.connected) {
-      try {
-        await this.client.close();
-      } catch {
-        // ignore close errors
-      }
-      this.connected = false;
-      this.tools = [];
-    }
-  }
-}

package/src/memory/memory.ts

@@ -1,87 +0,0 @@
-import { InMemoryStorage } from "../storage/in-memory.js";
-import type { StorageDriver } from "../storage/driver.js";
-import { getTextContent, type ChatMessage } from "../models/types.js";
-import type { MemoryConfig, MemoryEntry } from "./types.js";
-
-const SHORT_TERM_NS = "memory:short";
-const LONG_TERM_NS = "memory:long";
-
-export class Memory {
-  private storage: StorageDriver;
-  private maxShortTermMessages: number;
-  private enableLongTerm: boolean;
-
-  constructor(config?: MemoryConfig) {
-    this.storage = config?.storage ?? new InMemoryStorage();
-    this.maxShortTermMessages = config?.maxShortTermMessages ?? 50;
-    this.enableLongTerm = config?.enableLongTerm ?? false;
-  }
-
-  async addMessages(
-    sessionId: string,
-    messages: ChatMessage[]
-  ): Promise<void> {
-    const existing =
-      (await this.storage.get<ChatMessage[]>(SHORT_TERM_NS, sessionId)) ?? [];
-    const updated = [...existing, ...messages];
-
-    if (updated.length > this.maxShortTermMessages) {
-      const overflow = updated.splice(
-        0,
-        updated.length - this.maxShortTermMessages
-      );
-
-      if (this.enableLongTerm && overflow.length > 0) {
-        await this.summarizeAndStore(sessionId, overflow);
-      }
-    }
-
-    await this.storage.set(SHORT_TERM_NS, sessionId, updated);
-  }
-
-  async getMessages(sessionId: string): Promise<ChatMessage[]> {
-    return (
-      (await this.storage.get<ChatMessage[]>(SHORT_TERM_NS, sessionId)) ?? []
-    );
-  }
-
-  async getSummaries(sessionId: string): Promise<string[]> {
-    if (!this.enableLongTerm) return [];
-
-    const entries = await this.storage.list<MemoryEntry>(
-      LONG_TERM_NS,
-      sessionId
-    );
-    return entries.map((e) => e.value.summary);
-  }
-
-  async getContextString(sessionId: string): Promise<string> {
-    const summaries = await this.getSummaries(sessionId);
-    if (summaries.length === 0) return "";
-    return `Previous context:\n${summaries.join("\n")}`;
-  }
-
-  private async summarizeAndStore(
-    sessionId: string,
-    messages: ChatMessage[]
-  ): Promise<void> {
-    const textParts = messages
-      .filter((m) => m.content)
-      .map((m) => `${m.role}: ${getTextContent(m.content)}`);
-
-    if (textParts.length === 0) return;
-
-    const summary = textParts.join(" | ").slice(0, 500);
-    const entry: MemoryEntry = {
-      key: `${sessionId}:${Date.now()}`,
-      summary,
-      createdAt: new Date(),
-    };
-
-    await this.storage.set(LONG_TERM_NS, entry.key, entry);
-  }
-
-  async clear(sessionId: string): Promise<void> {
-    await this.storage.delete(SHORT_TERM_NS, sessionId);
-  }
-}

package/src/memory/types.ts

@@ -1,13 +0,0 @@
-import type { StorageDriver } from "../storage/driver.js";
-
-export interface MemoryConfig {
-  storage?: StorageDriver;
-  maxShortTermMessages?: number;
-  enableLongTerm?: boolean;
-}
-
-export interface MemoryEntry {
-  key: string;
-  summary: string;
-  createdAt: Date;
-}