zero-ai-cli 1.0.0

package/packages/core/src/lsp/index.ts

@@ -0,0 +1,251 @@
+/**
+ * ZERO LSP Integration
+ * Adapted from: crush (Charm) - MIT
+ *
+ * Basic Language Server Protocol integration for
+ * code intelligence (go to definition, references, etc).
+ */
+
+import { spawn, type ChildProcess } from "node:child_process";
+import type { ToolDefinition, ToolResult } from "../types.js";
+
+export interface LSPPosition {
+  line: number;
+  character: number;
+}
+
+export interface LSPRange {
+  start: LSPPosition;
+  end: LSPPosition;
+}
+
+export interface LSPLocation {
+  uri: string;
+  range: LSPRange;
+}
+
+export interface LSPDiagnostic {
+  range: LSPRange;
+  severity: "error" | "warning" | "info" | "hint";
+  message: string;
+  source?: string;
+}
+
+export interface LSPSymbol {
+  name: string;
+  kind: string;
+  range: LSPRange;
+  children?: LSPSymbol[];
+}
+
+/**
+ * LSP Client (simplified)
+ */
+export class LSPClient {
+  private process?: ChildProcess;
+  private requestId = 0;
+  private pending = new Map<number, { resolve: (v: any) => void; reject: (e: any) => void }>();
+  private buffer = "";
+  private initialized = false;
+
+  constructor(
+    private command: string,
+    private args: string[] = [],
+    private rootUri: string
+  ) {}
+
+  /**
+   * Start the LSP server
+   */
+  async start(): Promise<void> {
+    this.process = spawn(this.command, this.args, {
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    this.process.stdout?.on("data", (data: Buffer) => {
+      this.buffer += data.toString();
+      this.processBuffer();
+    });
+
+    // Initialize
+    await this.sendRequest("initialize", {
+      processId: process.pid,
+      rootUri: this.rootUri,
+      capabilities: {
+        textDocument: {
+          completion: { completionItem: { snippetSupport: false } },
+          hover: {},
+          definition: {},
+          references: {},
+          documentSymbol: {},
+        },
+      },
+    });
+
+    await this.sendNotification("initialized", {});
+    this.initialized = true;
+  }
+
+  /**
+   * Stop the LSP server
+   */
+  async stop(): Promise<void> {
+    if (this.process) {
+      await this.sendRequest("shutdown", null);
+      await this.sendNotification("exit", null);
+      this.process.kill();
+      this.process = undefined;
+    }
+    this.initialized = false;
+  }
+
+  /**
+   * Go to definition
+   */
+  async definition(uri: string, position: LSPPosition): Promise<LSPLocation[]> {
+    const result = await this.sendRequest("textDocument/definition", {
+      textDocument: { uri },
+      position,
+    });
+    return Array.isArray(result) ? result : result ? [result] : [];
+  }
+
+  /**
+   * Find references
+   */
+  async references(uri: string, position: LSPPosition): Promise<LSPLocation[]> {
+    const result = await this.sendRequest("textDocument/references", {
+      textDocument: { uri },
+      position,
+      context: { includeDeclaration: true },
+    });
+    return result || [];
+  }
+
+  /**
+   * Get hover info
+   */
+  async hover(uri: string, position: LSPPosition): Promise<string | null> {
+    const result = await this.sendRequest("textDocument/hover", {
+      textDocument: { uri },
+      position,
+    });
+    return result?.contents?.value || result?.contents || null;
+  }
+
+  /**
+   * Get document symbols
+   */
+  async documentSymbols(uri: string): Promise<LSPSymbol[]> {
+    const result = await this.sendRequest("textDocument/documentSymbol", {
+      textDocument: { uri },
+    });
+    return result || [];
+  }
+
+  /**
+   * Open a document
+   */
+  async openDocument(uri: string, languageId: string, text: string): Promise<void> {
+    await this.sendNotification("textDocument/didOpen", {
+      textDocument: { uri, languageId, version: 1, text },
+    });
+  }
+
+  isInitialized(): boolean {
+    return this.initialized;
+  }
+
+  private async sendRequest(method: string, params: unknown): Promise<any> {
+    const id = ++this.requestId;
+    const message = {
+      jsonrpc: "2.0",
+      id,
+      method,
+      params,
+    };
+
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.writeMessage(message);
+
+      setTimeout(() => {
+        if (this.pending.has(id)) {
+          this.pending.delete(id);
+          reject(new Error(`LSP request ${method} timed out`));
+        }
+      }, 10000);
+    });
+  }
+
+  private async sendNotification(method: string, params: unknown): Promise<void> {
+    this.writeMessage({ jsonrpc: "2.0", method, params });
+  }
+
+  private writeMessage(message: unknown): void {
+    const content = JSON.stringify(message);
+    const header = `Content-Length: ${Buffer.byteLength(content)}\r\n\r\n`;
+    this.process?.stdin?.write(header + content);
+  }
+
+  private processBuffer(): void {
+    while (true) {
+      const headerEnd = this.buffer.indexOf("\r\n\r\n");
+      if (headerEnd === -1) break;
+
+      const header = this.buffer.slice(0, headerEnd);
+      const lengthMatch = header.match(/Content-Length:\s*(\d+)/i);
+      if (!lengthMatch) break;
+
+      const contentLength = parseInt(lengthMatch[1]);
+      const messageStart = headerEnd + 4;
+      const messageEnd = messageStart + contentLength;
+
+      if (this.buffer.length < messageEnd) break;
+
+      const content = this.buffer.slice(messageStart, messageEnd);
+      this.buffer = this.buffer.slice(messageEnd);
+
+      try {
+        const message = JSON.parse(content);
+        if (message.id !== undefined && this.pending.has(message.id)) {
+          const { resolve, reject } = this.pending.get(message.id)!;
+          this.pending.delete(message.id);
+
+          if (message.error) {
+            reject(new Error(message.error.message));
+          } else {
+            resolve(message.result);
+          }
+        }
+      } catch {}
+    }
+  }
+}
+
+/**
+ * LSP lookup tool
+ */
+export const lspLookupTool: ToolDefinition = {
+  name: "lsp_lookup",
+  description: "Use Language Server Protocol to get code intelligence: definitions, references, hover info, and symbols.",
+  parameters: {
+    action: {
+      type: "string",
+      description: "LSP action to perform",
+      required: true,
+      enum: ["definition", "references", "hover", "symbols"],
+    },
+    file: { type: "string", description: "File path", required: true },
+    line: { type: "number", description: "Line number (1-indexed)", required: false },
+    column: { type: "number", description: "Column number (1-indexed)", required: false },
+  },
+  category: "search",
+  requiresApproval: false,
+  handler: async (args): Promise<ToolResult> => {
+    return {
+      success: true,
+      output: `LSP ${args.action} for ${args.file}:${args.line}:${args.column} (LSP server not connected - configure in zero.config.json)`,
+    };
+  },
+};

package/packages/core/src/mcp/index.ts

@@ -0,0 +1,186 @@
+/**
+ * ZERO MCP (Model Context Protocol) Integration
+ * Connect to external MCP servers for extended capabilities
+ *
+ * Sources:
+ * - goose: MCP server runner and integration
+ * - kilocode: MCP plugin system
+ * - cline: MCP tool integration
+ */
+
+import { spawn, type ChildProcess } from "node:child_process";
+import type { MCPServerConfig, MCPTool, MCPResource, ToolDefinition, ToolContext, ToolResult } from "../types.js";
+
+export interface MCPServerConnection {
+  config: MCPServerConfig;
+  process?: ChildProcess;
+  tools: MCPTool[];
+  resources: MCPResource[];
+  status: "connecting" | "connected" | "disconnected" | "error";
+  error?: string;
+}
+
+export class MCPManager {
+  private connections = new Map<string, MCPServerConnection>();
+
+  /**
+   * Connect to an MCP server
+   */
+  async connect(config: MCPServerConfig): Promise<MCPServerConnection> {
+    if (!config.enabled) {
+      return {
+        config,
+        tools: [],
+        resources: [],
+        status: "disconnected",
+      };
+    }
+
+    const connection: MCPServerConnection = {
+      config,
+      tools: [],
+      resources: [],
+      status: "connecting",
+    };
+
+    try {
+      // Spawn MCP server process
+      const proc = spawn(config.command, config.args || [], {
+        env: { ...process.env, ...config.env },
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+
+      connection.process = proc;
+      connection.status = "connected";
+
+      proc.on("error", (err) => {
+        connection.status = "error";
+        connection.error = err.message;
+      });
+
+      proc.on("exit", (code) => {
+        connection.status = "disconnected";
+        if (code !== 0) {
+          connection.error = `Process exited with code ${code}`;
+        }
+      });
+
+      // Wait for initialization
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+
+      this.connections.set(config.id, connection);
+      return connection;
+    } catch (error) {
+      connection.status = "error";
+      connection.error = error instanceof Error ? error.message : String(error);
+      this.connections.set(config.id, connection);
+      return connection;
+    }
+  }
+
+  /**
+   * Disconnect from an MCP server
+   */
+  async disconnect(serverId: string): Promise<void> {
+    const connection = this.connections.get(serverId);
+    if (connection?.process) {
+      connection.process.kill();
+      connection.status = "disconnected";
+    }
+    this.connections.delete(serverId);
+  }
+
+  /**
+   * Disconnect all servers
+   */
+  async disconnectAll(): Promise<void> {
+    for (const [id] of this.connections) {
+      await this.disconnect(id);
+    }
+  }
+
+  /**
+   * Get all available MCP tools as ZERO tool definitions
+   */
+  getToolsAsDefinitions(): ToolDefinition[] {
+    const tools: ToolDefinition[] = [];
+
+    for (const connection of this.connections.values()) {
+      if (connection.status !== "connected") continue;
+
+      for (const mcpTool of connection.tools) {
+        tools.push({
+          name: `mcp_${connection.config.id}_${mcpTool.name}`,
+          description: `[MCP: ${connection.config.name}] ${mcpTool.description}`,
+          parameters: this.convertSchema(mcpTool.inputSchema),
+          category: "mcp",
+          requiresApproval: false,
+          handler: async (args) => this.callMCPTool(connection.config.id, mcpTool.name, args),
+        });
+      }
+    }
+
+    return tools;
+  }
+
+  /**
+   * Get connection status
+   */
+  getStatus(): Map<string, { status: string; tools: number; resources: number }> {
+    const status = new Map();
+    for (const [id, conn] of this.connections) {
+      status.set(id, {
+        status: conn.status,
+        tools: conn.tools.length,
+        resources: conn.resources.length,
+      });
+    }
+    return status;
+  }
+
+  private async callMCPTool(serverId: string, toolName: string, args: Record<string, unknown>): Promise<ToolResult> {
+    const connection = this.connections.get(serverId);
+    if (!connection || connection.status !== "connected") {
+      return { success: false, output: "", error: `MCP server "${serverId}" not connected` };
+    }
+
+    // Send tool call via stdin (JSON-RPC format)
+    try {
+      const request = {
+        jsonrpc: "2.0",
+        id: Date.now(),
+        method: "tools/call",
+        params: { name: toolName, arguments: args },
+      };
+
+      connection.process?.stdin?.write(JSON.stringify(request) + "\n");
+
+      // Wait for response (simplified - real implementation would use proper JSON-RPC)
+      return {
+        success: true,
+        output: `MCP tool "${toolName}" called successfully`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        output: "",
+        error: `MCP tool call failed: ${error instanceof Error ? error.message : String(error)}`,
+      };
+    }
+  }
+
+  private convertSchema(schema: Record<string, unknown>): Record<string, any> {
+    const properties = (schema.properties || {}) as Record<string, any>;
+    const required = (schema.required || []) as string[];
+
+    const result: Record<string, any> = {};
+    for (const [key, value] of Object.entries(properties)) {
+      result[key] = {
+        type: value.type || "string",
+        description: value.description || "",
+        required: required.includes(key),
+      };
+    }
+    return result;
+  }
+}

package/packages/core/src/memory/index.ts

@@ -0,0 +1,141 @@
+/**
+ * ZERO Memory System
+ * Persistent memory for cross-session context
+ *
+ * Sources:
+ * - kilocode: kilo-memory package
+ * - goose: memory MCP server
+ * - gemini-cli: memory commands
+ */
+
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { MemoryEntry, MemoryStore } from "../types.js";
+
+export class FileMemoryStore implements MemoryStore {
+  private entries: MemoryEntry[] = [];
+  private filePath: string;
+
+  constructor(storagePath: string) {
+    this.filePath = path.join(storagePath, "memory.json");
+  }
+
+  async init(): Promise<void> {
+    try {
+      const data = await fs.readFile(this.filePath, "utf-8");
+      this.entries = JSON.parse(data);
+    } catch {
+      this.entries = [];
+    }
+  }
+
+  async save(entry: MemoryEntry): Promise<void> {
+    this.entries.push(entry);
+    await this.persist();
+  }
+
+  async search(query: string, limit = 10): Promise<MemoryEntry[]> {
+    const queryLower = query.toLowerCase();
+    const scored = this.entries
+      .filter((e) => !e.expiresAt || e.expiresAt > Date.now())
+      .map((entry) => ({
+        entry,
+        score: this.calculateRelevance(entry, queryLower),
+      }))
+      .filter((s) => s.score > 0)
+      .sort((a, b) => b.score - a.score)
+      .slice(0, limit);
+
+    return scored.map((s) => s.entry);
+  }
+
+  async delete(id: string): Promise<void> {
+    this.entries = this.entries.filter((e) => e.id !== id);
+    await this.persist();
+  }
+
+  async getAll(): Promise<MemoryEntry[]> {
+    return this.entries.filter((e) => !e.expiresAt || e.expiresAt > Date.now());
+  }
+
+  private calculateRelevance(entry: MemoryEntry, query: string): number {
+    let score = 0;
+    const content = entry.content.toLowerCase();
+
+    // Direct match in content
+    if (content.includes(query)) score += 10;
+
+    // Tag matches
+    for (const tag of entry.tags) {
+      if (tag.toLowerCase().includes(query)) score += 5;
+    }
+
+    // Recency bonus
+    const age = Date.now() - entry.createdAt;
+    const dayInMs = 86400000;
+    if (age < dayInMs) score += 3;
+    else if (age < 7 * dayInMs) score += 2;
+    else if (age < 30 * dayInMs) score += 1;
+
+    // Base relevance
+    score += entry.relevance;
+
+    return score;
+  }
+
+  private async persist(): Promise<void> {
+    await fs.mkdir(path.dirname(this.filePath), { recursive: true });
+    await fs.writeFile(this.filePath, JSON.stringify(this.entries, null, 2));
+  }
+}
+
+/**
+ * Context manager that builds relevant context for agent conversations
+ */
+export class ContextManager {
+  constructor(private memory: MemoryStore) {}
+
+  /**
+   * Build context string for a given query
+   */
+  async buildContext(query: string, maxEntries = 5): Promise<string> {
+    const memories = await this.memory.search(query, maxEntries);
+
+    if (memories.length === 0) return "";
+
+    const sections = memories.map((m) => {
+      const tags = m.tags.length > 0 ? ` [${m.tags.join(", ")}]` : "";
+      return `- ${m.content}${tags}`;
+    });
+
+    return `## Relevant Context (from memory):\n${sections.join("\n")}`;
+  }
+
+  /**
+   * Save important information from a conversation
+   */
+  async saveFact(content: string, tags: string[] = []): Promise<void> {
+    await this.memory.save({
+      id: `mem_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      type: "fact",
+      content,
+      relevance: 5,
+      createdAt: Date.now(),
+      tags,
+    });
+  }
+
+  /**
+   * Save user preferences
+   */
+  async savePreference(content: string): Promise<void> {
+    await this.memory.save({
+      id: `mem_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      type: "preference",
+      content,
+      relevance: 8,
+      createdAt: Date.now(),
+      tags: ["preference"],
+    });
+  }
+}

package/packages/core/src/memory/prompts.ts

@@ -0,0 +1,52 @@
+/**
+ * ZERO Memory Prompts
+ * Adapted from: kilocode - Apache 2.0
+ *
+ * System prompts for memory-aware agent behavior.
+ */
+
+export const MEMORY_SYSTEM_PROMPT = `You have access to a persistent memory system that stores important information across sessions.
+
+## Memory Capabilities:
+- Store facts about the user's projects, preferences, and workflow
+- Recall relevant context from previous conversations
+- Build knowledge about the codebase over time
+
+## When to Save Memories:
+- User preferences (coding style, tools, frameworks)
+- Project-specific facts (architecture decisions, naming conventions)
+- Important context that would be useful in future sessions
+- User corrections to your behavior
+
+## Memory Format:
+- Keep memories concise and factual
+- Include relevant tags for better retrieval
+- Avoid storing sensitive information (API keys, passwords)
+`;
+
+export const MEMORY_SAVE_INSTRUCTIONS = `When you encounter important information, save it to memory using the appropriate tool. Format:
+- Type: "fact" for project info, "preference" for user preferences, "context" for temporary context
+- Tags: Include relevant tags like ["project-name", "architecture", "typescript"]
+- Content: Be specific and actionable
+`;
+
+export const CONTEXT_INJECTION_TEMPLATE = `## Relevant Context from Previous Sessions:
+
+{memories}
+
+Use this context to provide more relevant and personalized assistance.
+`;
+
+export const INDEXING_SYSTEM_PROMPT = `You have access to a code indexing system that can search and retrieve relevant code snippets.
+
+## Indexing Capabilities:
+- Semantic search across the entire codebase
+- File-type aware filtering
+- Context-aware code retrieval
+
+## When to Use Indexing:
+- When looking for similar patterns in the codebase
+- When understanding project structure
+- When finding related implementations
+- When looking for specific function signatures
+`;