zero-ai-cli 1.0.0

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

@@ -0,0 +1,236 @@
+/**
+ * ZERO History Manager
+ * Adapted from: aider (Python) - Apache 2.0
+ *
+ * Manages conversation history with context window optimization,
+ * summarization, and persistent storage.
+ */
+
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { Message, TokenUsage } from "../types.js";
+
+export interface HistoryEntry {
+  sessionId: string;
+  messages: Message[];
+  totalTokens: TokenUsage;
+  createdAt: number;
+  updatedAt: number;
+  summary?: string;
+}
+
+export interface HistoryManagerOptions {
+  storagePath: string;
+  maxHistoryEntries?: number;
+  maxMessagesPerSession?: number;
+  contextWindowTokens?: number;
+}
+
+export class HistoryManager {
+  private history = new Map<string, HistoryEntry>();
+  private options: Required<HistoryManagerOptions>;
+
+  constructor(options: HistoryManagerOptions) {
+    this.options = {
+      storagePath: options.storagePath,
+      maxHistoryEntries: options.maxHistoryEntries || 100,
+      maxMessagesPerSession: options.maxMessagesPerSession || 200,
+      contextWindowTokens: options.contextWindowTokens || 128000,
+    };
+  }
+
+  /**
+   * Initialize and load history from storage
+   */
+  async init(): Promise<void> {
+    await fs.mkdir(this.options.storagePath, { recursive: true });
+
+    try {
+      const files = await fs.readdir(this.options.storagePath);
+      for (const file of files) {
+        if (file.endsWith(".json")) {
+          try {
+            const data = await fs.readFile(path.join(this.options.storagePath, file), "utf-8");
+            const entry = JSON.parse(data) as HistoryEntry;
+            this.history.set(entry.sessionId, entry);
+          } catch {}
+        }
+      }
+    } catch {}
+  }
+
+  /**
+   * Get or create a history entry for a session
+   */
+  getOrCreate(sessionId: string): HistoryEntry {
+    let entry = this.history.get(sessionId);
+    if (!entry) {
+      entry = {
+        sessionId,
+        messages: [],
+        totalTokens: { inputTokens: 0, outputTokens: 0 },
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      };
+      this.history.set(sessionId, entry);
+    }
+    return entry;
+  }
+
+  /**
+   * Add a message to session history
+   */
+  async addMessage(sessionId: string, message: Message): Promise<void> {
+    const entry = this.getOrCreate(sessionId);
+    entry.messages.push(message);
+    entry.updatedAt = Date.now();
+
+    // Trim if too many messages
+    if (entry.messages.length > this.options.maxMessagesPerSession) {
+      entry.messages = entry.messages.slice(-this.options.maxMessagesPerSession);
+    }
+
+    await this.persist(entry);
+  }
+
+  /**
+   * Get messages for a session, optimized for context window
+   */
+  getMessages(sessionId: string, maxTokens?: number): Message[] {
+    const entry = this.history.get(sessionId);
+    if (!entry) return [];
+
+    const limit = maxTokens || this.options.contextWindowTokens;
+    const messages = [...entry.messages];
+
+    // Simple token estimation (4 chars per token)
+    let totalChars = 0;
+    const selected: Message[] = [];
+
+    // Always include system messages first
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const msg = messages[i];
+      const charCount = JSON.stringify(msg.content).length;
+
+      if (totalChars + charCount > limit * 4) break;
+
+      totalChars += charCount;
+      selected.unshift(msg);
+    }
+
+    return selected;
+  }
+
+  /**
+   * Get recent conversations
+   */
+  getRecentSessions(limit = 10): HistoryEntry[] {
+    return Array.from(this.history.values())
+      .sort((a, b) => b.updatedAt - a.updatedAt)
+      .slice(0, limit);
+  }
+
+  /**
+   * Search history across all sessions
+   */
+  search(query: string, limit = 20): Array<{ sessionId: string; message: Message; relevance: number }> {
+    const results: Array<{ sessionId: string; message: Message; relevance: number }> = [];
+    const queryLower = query.toLowerCase();
+
+    for (const entry of this.history.values()) {
+      for (const msg of entry.messages) {
+        const text = msg.content
+          .filter((c) => c.type === "text")
+          .map((c) => (c as any).text)
+          .join(" ")
+          .toLowerCase();
+
+        if (text.includes(queryLower)) {
+          // Simple relevance: count occurrences
+          const count = (text.match(new RegExp(queryLower, "g")) || []).length;
+          results.push({ sessionId: entry.sessionId, message: msg, relevance: count });
+        }
+      }
+    }
+
+    return results.sort((a, b) => b.relevance - a.relevance).slice(0, limit);
+  }
+
+  /**
+   * Set summary for a session (for context compression)
+   */
+  async setSummary(sessionId: string, summary: string): Promise<void> {
+    const entry = this.history.get(sessionId);
+    if (!entry) return;
+
+    entry.summary = summary;
+    entry.updatedAt = Date.now();
+    await this.persist(entry);
+  }
+
+  /**
+   * Compact old messages into a summary
+   */
+  async compact(sessionId: string, keepRecent = 10, summary?: string): Promise<void> {
+    const entry = this.history.get(sessionId);
+    if (!entry || entry.messages.length <= keepRecent) return;
+
+    const oldMessages = entry.messages.slice(0, -keepRecent);
+    const oldSummary = oldMessages
+      .filter((m) => m.role === "assistant")
+      .map((m) => m.content.filter((c) => c.type === "text").map((c) => (c as any).text).join(""))
+      .join("\n")
+      .slice(0, 500);
+
+    entry.summary = summary || `Previous conversation summary: ${oldSummary}`;
+    entry.messages = entry.messages.slice(-keepRecent);
+    entry.updatedAt = Date.now();
+    await this.persist(entry);
+  }
+
+  /**
+   * Delete a session's history
+   */
+  async delete(sessionId: string): Promise<void> {
+    this.history.delete(sessionId);
+    try {
+      await fs.unlink(path.join(this.options.storagePath, `${sessionId}.json`));
+    } catch {}
+  }
+
+  /**
+   * Get statistics
+   */
+  getStats(): { sessions: number; totalMessages: number; totalTokens: TokenUsage } {
+    let totalMessages = 0;
+    const totalTokens: TokenUsage = { inputTokens: 0, outputTokens: 0 };
+
+    for (const entry of this.history.values()) {
+      totalMessages += entry.messages.length;
+      totalTokens.inputTokens += entry.totalTokens.inputTokens;
+      totalTokens.outputTokens += entry.totalTokens.outputTokens;
+    }
+
+    return { sessions: this.history.size, totalMessages, totalTokens };
+  }
+
+  /**
+   * Update token usage for a session
+   */
+  async updateUsage(sessionId: string, usage: TokenUsage): Promise<void> {
+    const entry = this.history.get(sessionId);
+    if (!entry) return;
+
+    entry.totalTokens.inputTokens += usage.inputTokens;
+    entry.totalTokens.outputTokens += usage.outputTokens;
+    entry.updatedAt = Date.now();
+    await this.persist(entry);
+  }
+
+  private async persist(entry: HistoryEntry): Promise<void> {
+    await fs.writeFile(
+      path.join(this.options.storagePath, `${entry.sessionId}.json`),
+      JSON.stringify(entry, null, 2)
+    );
+  }
+}

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

@@ -0,0 +1,131 @@
+/**
+ * ZERO Image Processing
+ * Adapted from: opencode (SST) - MIT
+ *
+ * Image handling for vision-capable LLMs.
+ * Supports reading, encoding, and resizing images.
+ */
+
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { ToolDefinition, ToolResult } from "../types.js";
+
+export interface ImageData {
+  data: string; // base64
+  mimeType: string;
+  width?: number;
+  height?: number;
+  size: number;
+}
+
+const IMAGE_EXTENSIONS: Record<string, string> = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+};
+
+/**
+ * Read and encode an image file
+ */
+export async function readImage(filePath: string, workingDir: string): Promise<ImageData> {
+  const fullPath = path.resolve(workingDir, filePath);
+  const ext = path.extname(filePath).toLowerCase();
+  const mimeType = IMAGE_EXTENSIONS[ext];
+
+  if (!mimeType) {
+    throw new Error(`Unsupported image format: ${ext}`);
+  }
+
+  const buffer = await fs.readFile(fullPath);
+  const stats = await fs.stat(fullPath);
+
+  return {
+    data: buffer.toString("base64"),
+    mimeType,
+    size: stats.size,
+  };
+}
+
+/**
+ * Check if a file is an image
+ */
+export function isImage(filePath: string): boolean {
+  const ext = path.extname(filePath).toLowerCase();
+  return ext in IMAGE_EXTENSIONS;
+}
+
+/**
+ * Get MIME type for an image
+ */
+export function getMimeType(filePath: string): string | null {
+  const ext = path.extname(filePath).toLowerCase();
+  return IMAGE_EXTENSIONS[ext] || null;
+}
+
+/**
+ * Estimate image dimensions from base64 PNG header
+ */
+export function estimatePngDimensions(base64Data: string): { width: number; height: number } | null {
+  try {
+    const buffer = Buffer.from(base64Data, "base64");
+    // PNG header: 8 bytes signature, then IHDR chunk
+    if (buffer.length < 24) return null;
+    if (buffer[0] !== 0x89 || buffer[1] !== 0x50) return null; // Not PNG
+
+    const width = buffer.readUInt32BE(16);
+    const height = buffer.readUInt32BE(20);
+    return { width, height };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Create a data URI from image data
+ */
+export function toDataURI(image: ImageData): string {
+  return `data:${image.mimeType};base64,${image.data}`;
+}
+
+/**
+ * Format image info for display
+ */
+export function formatImageInfo(image: ImageData, filePath: string): string {
+  const sizeKB = (image.size / 1024).toFixed(1);
+  const dims = image.width && image.height ? ` (${image.width}x${image.height})` : "";
+  return `📷 ${filePath} [${image.mimeType}, ${sizeKB}KB${dims}]`;
+}
+
+/**
+ * Image read tool
+ */
+export const readImageTool: ToolDefinition = {
+  name: "read_image",
+  description: "Read an image file and return it as base64-encoded data. Supports PNG, JPG, GIF, WebP, BMP, SVG.",
+  parameters: {
+    path: { type: "string", description: "Path to the image file", required: true },
+  },
+  category: "file",
+  requiresApproval: false,
+  handler: async (args, context): Promise<ToolResult> => {
+    try {
+      const image = await readImage(args.path as string, context.workingDirectory);
+      return {
+        success: true,
+        output: formatImageInfo(image, args.path as string),
+        data: image,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        output: "",
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  },
+};

package/packages/core/src/index.ts

@@ -0,0 +1,131 @@
+/**
+ * ZERO Core - Main Entry Point
+ *
+ * ⚡ ZERO is a unified AI coding assistant that combines the best features from:
+ *
+ * ┌──────────────────────┬─────────────────────────────────────────────────────┐
+ * │ Gemini CLI (Google)  │ Model Router, Policy Engine, ReAct Loop            │
+ * │ Qwen Code (Alibaba)  │ Confirmation Bus, Provider Presets, Output Format  │
+ * │ Pi (earendil-works)  │ Multi-Agent Orchestrator, IPC Protocol             │
+ * │ OpenCode (SST)       │ Git Service, Permissions, Server                   │
+ * │ Aider                │ EditBlock Editing, Linter, RepoMap, History        │
+ * │ Crush (Charm)        │ Session Service, PubSub, Prompt Engine, LSP        │
+ * │ Cline                │ Agent Config Loader, Sub-Agents, Tool Approval     │
+ * │ Goose (Block)        │ MCP Integration, Skills, Provider Types            │
+ * │ KiloCode             │ Memory Prompts, Indexing, Plugin Architecture       │
+ * └──────────────────────┴─────────────────────────────────────────────────────┘
+ */
+
+// Types
+export * from "./types.js";
+
+// Agent System
+export { AgentEngine } from "./agent/engine.js";
+export { AgentRegistry, DEFAULT_AGENTS } from "./agent/registry.js";
+export { ToolRegistry } from "./agent/registry-tools.js";
+export { loadAgentFromFile, loadAgentsFromDirectory, parseFrontmatter, BUILTIN_TOOLS } from "./agent/config-loader.js";
+export type { AgentFrontmatterConfig, BuiltinTool } from "./agent/config-loader.js";
+
+// Tools
+export { getAllBuiltinTools, getAllTools } from "./tools/builtin.js";
+export { lintTool, lintFile, formatLintResult, detectLanguage } from "./tools/linter.js";
+export { repoMapTool, generateRepoMap, formatRepoMap } from "./tools/repo-map.js";
+
+// LLM Providers
+export { ProviderRegistry, OpenAICompatibleClient } from "./providers/registry.js";
+export { createDeepSeekProvider, createGrokProvider, createOpenRouterProvider, createTogetherProvider, createFireworksProvider, getExtendedProviders } from "./providers/extended.js";
+
+// Model Router
+export { ModelRouterService, DefaultStrategy, OverrideStrategy, CompositeStrategy } from "./routing/model-router.js";
+export type { RoutingDecision, RoutingContext, RoutingStrategy, TerminalStrategy } from "./routing/model-router.js";
+
+// Confirmation Bus
+export { MessageBus, MessageBusType } from "./confirmation/message-bus.js";
+export type { ToolConfirmationRequest, ToolConfirmationResponse, SerializableConfirmationDetails, ToolExecutionSuccess, ToolExecutionFailure, HookExecutionRequest, HookExecutionResponse, Message } from "./confirmation/message-bus.js";
+
+// Orchestrator IPC
+export { OrchestratorServer, OrchestratorClient } from "./orchestrator/server.js";
+export { encodeMessage, parseRequestLine, parseResponseLine } from "./orchestrator/protocol.js";
+export type { SpawnRequest, ListRequest, StopRequest, StatusRequest, RpcRequest, RpcStreamRequest, OrchestratorRequest, InstanceSummary, InstanceStatus, SpawnResponse, ListResponse, StopResponse, StatusResponse, RpcBridgeResponse, RpcReadyResponse, ErrorResponse, OrchestratorResponse, RpcCommand } from "./orchestrator/protocol.js";
+
+// Permissions
+export { createPermissionHandler, createAutoPermissionHandler, DEFAULT_PERMISSION_CONFIG } from "./permissions/index.js";
+export type { PermissionConfig, PermissionRule } from "./permissions/index.js";
+
+// Session Management
+export { SessionManager } from "./session/index.js";
+export { SessionService, hasIncompleteTodos } from "./session/service.js";
+export type { TodoStatus, Todo, SessionRecord, SessionEvent, SessionSubscriber } from "./session/service.js";
+
+// Memory & Context
+export { FileMemoryStore, ContextManager } from "./memory/index.js";
+export { MEMORY_SYSTEM_PROMPT, MEMORY_SAVE_INSTRUCTIONS, CONTEXT_INJECTION_TEMPLATE, INDEXING_SYSTEM_PROMPT } from "./memory/prompts.js";
+
+// MCP Integration
+export { MCPManager } from "./mcp/index.js";
+
+// Git Service
+export { GitService } from "./git/index.js";
+export type { ChangeKind, GitItem, GitStat, GitPatch, GitBase, PatchOptions, GitResult } from "./git/index.js";
+
+// Configuration
+export { ConfigManager, DEFAULT_CONFIG } from "./config/index.js";
+
+// Diff System
+export { generateDiff, formatUnifiedDiff, applySearchReplace, applyMultiEdit, smartMerge } from "./diff/index.js";
+
+// Diff Detect
+export { detectDiff, detectFileDiff, formatDiff, summarizeDiff } from "./diff-detect/index.js";
+export type { DiffStats, DiffHunk, DiffLine, FileDiff } from "./diff-detect/index.js";
+
+// Prompt Engine
+export { PromptEngine, createPromptEngine, ZERO_SYSTEM_PROMPT } from "./prompts/engine.js";
+export type { PromptContext } from "./prompts/engine.js";
+
+// Custom Commands
+export { loadCommandsFromDir, loadAllCommands, executeCommand } from "./commands/index.js";
+export type { CustomCommand, CommandArgument } from "./commands/index.js";
+
+// Skills System
+export { SkillRegistry } from "./skills/index.js";
+export type { Skill, SkillCategory, SkillParameter, SkillContext, SkillResult } from "./skills/index.js";
+
+// PubSub Events
+export { EventBus, ZERO_EVENTS, globalEventBus } from "./events/index.js";
+export type { EventHandler, EventDefinition } from "./events/index.js";
+
+// File Tracker
+export { FileTracker } from "./file-tracker/index.js";
+export type { FileChange, FileTrackerOptions } from "./file-tracker/index.js";
+
+// Output Formatting
+export { formatJSON, formatMarkdown, formatPlainText, createStreamFormatter, calculateCost, formatCost } from "./output/index.js";
+export type { JSONOutput, StreamEvent } from "./output/index.js";
+
+// HTTP API Server
+export { ZeroServer, createAPIServer } from "./server/index.js";
+export type { ServerOptions, RouteHandler } from "./server/index.js";
+
+// Streaming
+export { StreamProcessor, createTextStream, mergeStreams } from "./streaming/index.js";
+export type { StreamOptions, StreamState } from "./streaming/index.js";
+
+// History Manager
+export { HistoryManager } from "./history/index.js";
+export type { HistoryEntry, HistoryManagerOptions } from "./history/index.js";
+
+// EditBlock Coder
+export { parseEditBlocks, applyEditBlocks, applyEditBlocksToFile, formatEditBlock, editBlockTool } from "./edit-coder/index.js";
+export type { EditBlock, EditBlockResult } from "./edit-coder/index.js";
+
+// Sub-Agent System
+export { SubAgentManager, createDelegateTool } from "./sub-agent/index.js";
+export type { SubAgentTask, SubAgentResult, SubAgentOptions } from "./sub-agent/index.js";
+
+// LSP Integration
+export { LSPClient, lspLookupTool } from "./lsp/index.js";
+export type { LSPPosition, LSPRange, LSPLocation, LSPDiagnostic, LSPSymbol } from "./lsp/index.js";
+
+// Image Processing
+export { readImage, isImage, getMimeType, estimatePngDimensions, toDataURI, formatImageInfo, readImageTool } from "./image/index.js";
+export type { ImageData } from "./image/index.js";