activo 0.2.0

package/src/core/llm/ollama.ts

@@ -0,0 +1,238 @@
+import { OllamaConfig } from "../config.js";
+import { Tool, ToolCall } from "../tools/types.js";
+
+export interface ChatMessage {
+  role: "system" | "user" | "assistant" | "tool";
+  content: string;
+  toolCalls?: ToolCall[];
+  toolCallId?: string;
+}
+
+export interface StreamEvent {
+  type: "content" | "tool_call" | "done" | "error";
+  content?: string;
+  toolCall?: ToolCall;
+  error?: string;
+}
+
+interface OllamaChatResponse {
+  model: string;
+  message: {
+    role: string;
+    content: string;
+    tool_calls?: Array<{
+      function: {
+        name: string;
+        arguments: Record<string, unknown>;
+      };
+    }>;
+  };
+  done: boolean;
+}
+
+export class OllamaClient {
+  private baseUrl: string;
+  private model: string;
+  private contextLength: number;
+  private keepAlive: number;
+
+  constructor(config: OllamaConfig) {
+    this.baseUrl = config.baseUrl;
+    this.model = config.model;
+    this.contextLength = config.contextLength;
+    this.keepAlive = config.keepAlive;
+  }
+
+  async isConnected(): Promise<boolean> {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/tags`);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  async listModels(): Promise<string[]> {
+    const response = await fetch(`${this.baseUrl}/api/tags`);
+    if (!response.ok) throw new Error("Failed to list models");
+    const data = (await response.json()) as { models: Array<{ name: string }> };
+    return data.models.map((m) => m.name);
+  }
+
+  async chat(
+    messages: ChatMessage[],
+    tools?: Tool[]
+  ): Promise<ChatMessage> {
+    const ollamaMessages = this.convertMessages(messages);
+
+    const body: Record<string, unknown> = {
+      model: this.model,
+      messages: ollamaMessages,
+      stream: false,
+      options: {
+        num_ctx: this.contextLength,
+      },
+      keep_alive: this.keepAlive,
+    };
+
+    // Add tools if last message is from user
+    if (tools?.length && messages[messages.length - 1]?.role === "user") {
+      body.tools = tools.map((tool) => ({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters,
+        },
+      }));
+    }
+
+    const response = await fetch(`${this.baseUrl}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Ollama error: ${error}`);
+    }
+
+    const data = (await response.json()) as OllamaChatResponse;
+    return this.parseResponse(data);
+  }
+
+  async *streamChat(
+    messages: ChatMessage[],
+    tools?: Tool[],
+    abortSignal?: AbortSignal
+  ): AsyncGenerator<StreamEvent> {
+    const ollamaMessages = this.convertMessages(messages);
+
+    const body: Record<string, unknown> = {
+      model: this.model,
+      messages: ollamaMessages,
+      stream: true,
+      options: {
+        num_ctx: this.contextLength,
+      },
+      keep_alive: this.keepAlive,
+    };
+
+    if (tools?.length && messages[messages.length - 1]?.role === "user") {
+      body.tools = tools.map((tool) => ({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters,
+        },
+      }));
+    }
+
+    const response = await fetch(`${this.baseUrl}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: abortSignal,
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      yield { type: "error", error: `Ollama error: ${error}` };
+      return;
+    }
+
+    const reader = response.body?.getReader();
+    if (!reader) {
+      yield { type: "error", error: "No response body" };
+      return;
+    }
+
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let accumulatedToolCalls: ToolCall[] = [];
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+
+        try {
+          const data = JSON.parse(line) as OllamaChatResponse;
+
+          if (data.message?.content) {
+            yield { type: "content", content: data.message.content };
+          }
+
+          if (data.message?.tool_calls?.length) {
+            for (const tc of data.message.tool_calls) {
+              const toolCall: ToolCall = {
+                id: `tc_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+                name: tc.function.name,
+                arguments: tc.function.arguments,
+              };
+              accumulatedToolCalls.push(toolCall);
+              yield { type: "tool_call", toolCall };
+            }
+          }
+
+          if (data.done) {
+            yield { type: "done" };
+          }
+        } catch {
+          // Skip invalid JSON
+        }
+      }
+    }
+  }
+
+  private convertMessages(messages: ChatMessage[]): Array<{
+    role: string;
+    content: string;
+  }> {
+    return messages.map((msg) => {
+      if (msg.role === "tool") {
+        return {
+          role: "tool",
+          content: msg.content,
+        };
+      }
+      return {
+        role: msg.role,
+        content: msg.content,
+      };
+    });
+  }
+
+  private parseResponse(data: OllamaChatResponse): ChatMessage {
+    const result: ChatMessage = {
+      role: "assistant",
+      content: data.message.content || "",
+    };
+
+    if (data.message.tool_calls?.length) {
+      result.toolCalls = data.message.tool_calls.map((tc, idx) => ({
+        id: `tc_${Date.now()}_${idx}`,
+        name: tc.function.name,
+        arguments: tc.function.arguments,
+      }));
+    }
+
+    return result;
+  }
+
+  getModel(): string {
+    return this.model;
+  }
+
+  setModel(model: string): void {
+    this.model = model;
+  }
+}

package/src/core/mcp/client.ts

@@ -0,0 +1,143 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { MCPServerConfig } from "../config.js";
+import { Tool, ToolResult } from "../tools/types.js";
+
+export interface MCPConnection {
+  id: string;
+  client: Client;
+  transport: StdioClientTransport;
+  tools: Tool[];
+}
+
+export class MCPManager {
+  private connections: Map<string, MCPConnection> = new Map();
+
+  async connect(id: string, config: MCPServerConfig): Promise<MCPConnection> {
+    // Check if already connected
+    if (this.connections.has(id)) {
+      return this.connections.get(id)!;
+    }
+
+    const transport = new StdioClientTransport({
+      command: config.command,
+      args: config.args,
+      env: config.env,
+    });
+
+    const client = new Client({
+      name: "activo",
+      version: "0.2.0",
+    });
+
+    await client.connect(transport);
+
+    // Get available tools
+    const toolsResult = await client.listTools();
+    const tools: Tool[] = toolsResult.tools.map((t) => ({
+      name: `mcp_${id}_${t.name}`,
+      description: t.description || `MCP tool: ${t.name}`,
+      parameters: {
+        type: "object" as const,
+        properties: (t.inputSchema as any)?.properties || {},
+        required: (t.inputSchema as any)?.required,
+      },
+      handler: async (args: Record<string, unknown>): Promise<ToolResult> => {
+        return this.callTool(id, t.name, args);
+      },
+    }));
+
+    const connection: MCPConnection = {
+      id,
+      client,
+      transport,
+      tools,
+    };
+
+    this.connections.set(id, connection);
+    return connection;
+  }
+
+  async disconnect(id: string): Promise<void> {
+    const connection = this.connections.get(id);
+    if (connection) {
+      await connection.client.close();
+      this.connections.delete(id);
+    }
+  }
+
+  async disconnectAll(): Promise<void> {
+    for (const id of this.connections.keys()) {
+      await this.disconnect(id);
+    }
+  }
+
+  async callTool(connectionId: string, toolName: string, args: Record<string, unknown>): Promise<ToolResult> {
+    const connection = this.connections.get(connectionId);
+    if (!connection) {
+      return {
+        success: false,
+        content: "",
+        error: `MCP connection not found: ${connectionId}`,
+      };
+    }
+
+    try {
+      const result = await connection.client.callTool({
+        name: toolName,
+        arguments: args,
+      });
+
+      if (result.isError) {
+        return {
+          success: false,
+          content: "",
+          error: JSON.stringify(result.content),
+        };
+      }
+
+      const contentArray = result.content as Array<{ type: string; text?: string }>;
+      const content = contentArray
+        .filter((c) => c.type === "text" && c.text)
+        .map((c) => c.text!)
+        .join("\n");
+
+      return {
+        success: true,
+        content,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        content: "",
+        error: String(error),
+      };
+    }
+  }
+
+  getAllTools(): Tool[] {
+    const tools: Tool[] = [];
+    for (const connection of this.connections.values()) {
+      tools.push(...connection.tools);
+    }
+    return tools;
+  }
+
+  getConnection(id: string): MCPConnection | undefined {
+    return this.connections.get(id);
+  }
+
+  isConnected(id: string): boolean {
+    return this.connections.has(id);
+  }
+}
+
+// Singleton instance
+let mcpManager: MCPManager | null = null;
+
+export function getMCPManager(): MCPManager {
+  if (!mcpManager) {
+    mcpManager = new MCPManager();
+  }
+  return mcpManager;
+}

package/src/core/tools/builtIn.ts

@@ -0,0 +1,221 @@
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+import { glob } from "glob";
+import { Tool, ToolResult } from "./types.js";
+
+// Read File Tool
+export const readFileTool: Tool = {
+  name: "read_file",
+  description: "Read the contents of a file. Use this to view source code or any text file.",
+  parameters: {
+    type: "object",
+    required: ["filepath"],
+    properties: {
+      filepath: {
+        type: "string",
+        description: "Path to the file (relative or absolute)",
+      },
+    },
+  },
+  handler: async (args): Promise<ToolResult> => {
+    try {
+      const filepath = path.resolve(args.filepath as string);
+      if (!fs.existsSync(filepath)) {
+        return { success: false, content: "", error: `File not found: ${filepath}` };
+      }
+      const stat = fs.statSync(filepath);
+      if (stat.isDirectory()) {
+        return { success: false, content: "", error: "Path is a directory" };
+      }
+      const content = fs.readFileSync(filepath, "utf-8");
+      return { success: true, content };
+    } catch (error) {
+      return { success: false, content: "", error: String(error) };
+    }
+  },
+};
+
+// Write File Tool
+export const writeFileTool: Tool = {
+  name: "write_file",
+  description: "Write content to a file. Creates directories if needed.",
+  parameters: {
+    type: "object",
+    required: ["filepath", "content"],
+    properties: {
+      filepath: {
+        type: "string",
+        description: "Path to write the file",
+      },
+      content: {
+        type: "string",
+        description: "Content to write",
+      },
+    },
+  },
+  handler: async (args): Promise<ToolResult> => {
+    try {
+      const filepath = path.resolve(args.filepath as string);
+      const dir = path.dirname(filepath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(filepath, args.content as string);
+      return { success: true, content: `Written to ${filepath}` };
+    } catch (error) {
+      return { success: false, content: "", error: String(error) };
+    }
+  },
+};
+
+// List Directory Tool
+export const listDirectoryTool: Tool = {
+  name: "list_directory",
+  description: "List files and directories in a path.",
+  parameters: {
+    type: "object",
+    required: ["path"],
+    properties: {
+      path: {
+        type: "string",
+        description: "Directory path to list",
+      },
+    },
+  },
+  handler: async (args): Promise<ToolResult> => {
+    try {
+      const dirPath = path.resolve((args.path as string) || ".");
+      if (!fs.existsSync(dirPath)) {
+        return { success: false, content: "", error: `Directory not found: ${dirPath}` };
+      }
+      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+      const result = entries.map((e) => `${e.isDirectory() ? "[DIR]" : "[FILE]"} ${e.name}`);
+      return { success: true, content: result.join("\n") };
+    } catch (error) {
+      return { success: false, content: "", error: String(error) };
+    }
+  },
+};
+
+// Grep Search Tool
+export const grepSearchTool: Tool = {
+  name: "grep_search",
+  description: "Search for a pattern in files using regex.",
+  parameters: {
+    type: "object",
+    required: ["pattern"],
+    properties: {
+      pattern: {
+        type: "string",
+        description: "Search pattern (regex)",
+      },
+      path: {
+        type: "string",
+        description: "Directory or file to search (default: current)",
+      },
+      filePattern: {
+        type: "string",
+        description: "File pattern filter (e.g., *.ts)",
+      },
+    },
+  },
+  handler: async (args): Promise<ToolResult> => {
+    try {
+      const searchPath = (args.path as string) || ".";
+      let cmd = `grep -rn "${args.pattern}" "${searchPath}"`;
+      if (args.filePattern) {
+        cmd += ` --include="${args.filePattern}"`;
+      }
+      cmd += " 2>/dev/null || true";
+
+      const output = execSync(cmd, { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
+      if (!output.trim()) {
+        return { success: true, content: "No matches found" };
+      }
+      const lines = output.trim().split("\n").slice(0, 50);
+      return { success: true, content: lines.join("\n") };
+    } catch (error) {
+      return { success: false, content: "", error: String(error) };
+    }
+  },
+};
+
+// Glob Search Tool
+export const globSearchTool: Tool = {
+  name: "glob_search",
+  description: "Find files matching a glob pattern.",
+  parameters: {
+    type: "object",
+    required: ["pattern"],
+    properties: {
+      pattern: {
+        type: "string",
+        description: "Glob pattern (e.g., **/*.ts)",
+      },
+      path: {
+        type: "string",
+        description: "Base directory (default: current)",
+      },
+    },
+  },
+  handler: async (args): Promise<ToolResult> => {
+    try {
+      const basePath = (args.path as string) || ".";
+      const fullPattern = path.join(basePath, args.pattern as string);
+      const files = await glob(fullPattern, {
+        ignore: ["**/node_modules/**", "**/.git/**"],
+      });
+      if (files.length === 0) {
+        return { success: true, content: "No files found" };
+      }
+      return { success: true, content: files.slice(0, 100).join("\n") };
+    } catch (error) {
+      return { success: false, content: "", error: String(error) };
+    }
+  },
+};
+
+// Run Command Tool
+export const runCommandTool: Tool = {
+  name: "run_command",
+  description: "Execute a shell command. Be careful with destructive commands.",
+  parameters: {
+    type: "object",
+    required: ["command"],
+    properties: {
+      command: {
+        type: "string",
+        description: "Command to execute",
+      },
+    },
+  },
+  handler: async (args): Promise<ToolResult> => {
+    try {
+      const cmd = args.command as string;
+      // Block dangerous commands
+      const blocked = ["rm -rf /", "mkfs", "dd if=", "> /dev/"];
+      if (blocked.some((b) => cmd.includes(b))) {
+        return { success: false, content: "", error: "Command blocked for safety" };
+      }
+      const output = execSync(cmd, {
+        encoding: "utf-8",
+        maxBuffer: 10 * 1024 * 1024,
+        timeout: 30000,
+      });
+      return { success: true, content: output };
+    } catch (error: any) {
+      return { success: false, content: error.stdout || "", error: error.stderr || error.message };
+    }
+  },
+};
+
+// All built-in tools
+export const builtInTools: Tool[] = [
+  readFileTool,
+  writeFileTool,
+  listDirectoryTool,
+  grepSearchTool,
+  globSearchTool,
+  runCommandTool,
+];

package/src/core/tools/index.ts

@@ -0,0 +1,53 @@
+import { Tool, ToolCall, ToolResult } from "./types.js";
+import { builtInTools } from "./builtIn.js";
+import { standardsTools } from "./standards.js";
+
+export * from "./types.js";
+export * from "./builtIn.js";
+export * from "./standards.js";
+
+// All available tools
+export function getAllTools(): Tool[] {
+  return [...builtInTools, ...standardsTools];
+}
+
+// Get tool by name
+export function getTool(name: string): Tool | undefined {
+  return getAllTools().find((t) => t.name === name);
+}
+
+// Execute a tool call
+export async function executeTool(toolCall: ToolCall): Promise<ToolResult> {
+  const tool = getTool(toolCall.name);
+
+  if (!tool) {
+    return {
+      success: false,
+      content: "",
+      error: `Unknown tool: ${toolCall.name}`,
+    };
+  }
+
+  try {
+    return await tool.handler(toolCall.arguments);
+  } catch (error) {
+    return {
+      success: false,
+      content: "",
+      error: `Tool execution error: ${error}`,
+    };
+  }
+}
+
+// Get tool definitions for LLM
+export function getToolDefinitions(): Array<{
+  name: string;
+  description: string;
+  parameters: Tool["parameters"];
+}> {
+  return getAllTools().map((t) => ({
+    name: t.name,
+    description: t.description,
+    parameters: t.parameters,
+  }));
+}