@kirosnn/mosaic 0.71.0 → 0.73.0

package/README.md

@@ -5,7 +5,7 @@
 <h1 align="center">Mosaic CLI</h1>
 
 <p align="center">
-  <strong>Version 0.71.0</strong>
+  <strong>Version 0.73.0</strong>
 </p>
 
 <p align="center">
@@ -113,9 +113,6 @@ Open http://127.0.0.1:8192 in your browser.
 |-------------|--------------------------------------|
 | `/init`     | Initialize project context (MOSAIC.md) |
 | `/help`     | Show available commands              |
-| `/undo`     | Undo last file change                |
-| `/redo`     | Redo undone change                   |
-| `/sessions` | Manage conversation sessions         |
 | `/web`      | Open web interface                   |
 | `/echo`     | Echo a message (debug)               |
 
@@ -151,7 +148,6 @@ Mosaic relies on a tool registry that exposes safe, focused capabilities to the
 
 **Safety Features:**
 - Write and edit operations require user approval before execution
-- Built-in undo/redo system tracks all file changes (SQLite-backed)
 - Project context via `MOSAIC.md` helps the agent understand your codebase
 
 ## AI Providers

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kirosnn/mosaic",
-  "version": "0.71.0",
+  "version": "0.73.0",
   "description": "The open source coding agent.",
   "license": "MIT",
   "type": "module",
@@ -33,6 +33,7 @@
     "@ai-sdk/mistral": "^1.0.0",
     "@ai-sdk/openai": "^1.0.0",
     "@ai-sdk/xai": "^1.0.0",
+    "@modelcontextprotocol/sdk": "^1.25.3",
     "@mozilla/readability": "^0.6.0",
     "@opentui/core": "^0.1.69",
     "@opentui/react": "^0.1.69",
@@ -41,6 +42,7 @@
     "better-sqlite3": "^12.6.0",
     "linkedom": "^0.18.12",
     "ollama": "^0.5.0",
+    "playwright": "^1.45.0",
     "react": "^19.2.3",
     "react-dom": "^19.2.3",
     "react-markdown": "^10.1.0",
@@ -50,4 +52,4 @@
     "zod": "^3.23.8",
     "zod-to-json-schema": "^3.25.1"
   }
-}
+}

package/src/agent/Agent.ts

@@ -1,131 +1,353 @@
-import { CoreMessage, CoreTool } from 'ai';
-import {
-  AgentEvent,
-  AgentMessage,
-  ProviderConfig,
-  Provider,
-  ProviderSendOptions,
-} from './types';
-import { readConfig } from '../utils/config';
-import { DEFAULT_SYSTEM_PROMPT, processSystemPrompt } from './prompts/systemPrompt';
-import { getTools } from './tools/definitions';
-import { AnthropicProvider } from './provider/anthropic';
-import { OpenAIProvider } from './provider/openai';
-import { GoogleProvider } from './provider/google';
-import { MistralProvider } from './provider/mistral';
-import { XaiProvider } from './provider/xai';
-import { OllamaProvider, checkAndStartOllama } from './provider/ollama';
-
-export class Agent {
-  private messageHistory: CoreMessage[] = [];
-  private provider: Provider;
-  private config: ProviderConfig;
-  private static ollamaChecked = false;
-
-  static async ensureProviderReady(): Promise<{ ready: boolean; started?: boolean; error?: string }> {
-    const userConfig = readConfig();
-
-    if (userConfig.provider === 'ollama') {
-      if (Agent.ollamaChecked) {
-        return { ready: true };
-      }
-
-      const result = await checkAndStartOllama();
-      Agent.ollamaChecked = true;
-
-      if (!result.running) {
-        return { ready: false, error: result.error };
-      }
-
-      return { ready: true, started: result.started };
-    }
-
-    return { ready: true };
-  }
-
-  constructor() {
-    const userConfig = readConfig();
-
-    if (!userConfig.provider || !userConfig.model) {
-      throw new Error('No provider or model configured. Please run setup first.');
-    }
-
-    const rawSystemPrompt = userConfig.systemPrompt || DEFAULT_SYSTEM_PROMPT;
-    const systemPrompt = processSystemPrompt(rawSystemPrompt, true);
-    const tools = getTools();
-
-    this.config = {
-      provider: userConfig.provider,
-      model: userConfig.model,
-      apiKey: userConfig.apiKey,
-      systemPrompt,
-      tools,
-      maxSteps: 60,
-    };
-
-    this.provider = this.createProvider(userConfig.provider);
-  }
-
-  private createProvider(providerName: string): Provider {
-    switch (providerName) {
-      case 'openai':
-        return new OpenAIProvider();
-      case 'anthropic':
-        return new AnthropicProvider();
-      case 'google':
-        return new GoogleProvider();
-      case 'mistral':
-        return new MistralProvider();
-      case 'xai':
-        return new XaiProvider();
-      case 'ollama':
-        return new OllamaProvider();
-      default:
-        throw new Error(`Unknown provider: ${providerName}`);
-    }
-  }
-
-  async *sendMessage(userMessage: string, options?: ProviderSendOptions): AsyncGenerator<AgentEvent> {
-    this.messageHistory.push({
-      role: 'user',
-      content: userMessage,
-    });
-
-    try {
-      yield* this.provider.sendMessage(this.messageHistory, this.config, options);
-    } catch (error) {
-      yield {
-        type: 'error',
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  async *streamMessages(messages: AgentMessage[], options?: ProviderSendOptions): AsyncGenerator<AgentEvent> {
-    this.messageHistory = messages.map(msg => ({
-      role: msg.role,
-      content: msg.content,
-    }));
-
-    try {
-      yield* this.provider.sendMessage(this.messageHistory, this.config, options);
-    } catch (error) {
-      yield {
-        type: 'error',
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  getHistory(): CoreMessage[] {
-    return [...this.messageHistory];
-  }
-
-  clearHistory(): void {
-    this.messageHistory = [];
-  }
-
-  updateConfig(updates: Partial<ProviderConfig>): void {
-    this.config = { ...this.config, ...updates };
-  }
-}
+import { CoreMessage } from 'ai';
+import {
+  AgentEvent,
+  AgentMessage,
+  ProviderConfig,
+  Provider,
+  ProviderSendOptions,
+} from './types';
+import { readConfig } from '../utils/config';
+import { DEFAULT_SYSTEM_PROMPT, processSystemPrompt } from './prompts/systemPrompt';
+import { getTools } from './tools/definitions';
+import { AnthropicProvider } from './provider/anthropic';
+import { OpenAIProvider } from './provider/openai';
+import { GoogleProvider } from './provider/google';
+import { MistralProvider } from './provider/mistral';
+import { XaiProvider } from './provider/xai';
+import { OllamaProvider, checkAndStartOllama } from './provider/ollama';
+import { getModelsDevContextLimit } from '../utils/models';
+import { estimateTokensFromText, estimateTokensForContent, getDefaultContextBudget } from '../utils/tokenEstimator';
+import { setExploreContext } from '../utils/exploreBridge';
+
+function contentToText(content: CoreMessage['content']): string {
+  if (typeof content === 'string') return content;
+  if (!content) return '';
+
+  if (Array.isArray(content)) {
+    const text = content
+      .map((part: any) => {
+        if (part && typeof part.text === 'string') return part.text;
+        if (typeof part === 'string') return part;
+        return '';
+      })
+      .filter(Boolean)
+      .join('');
+
+    if (text) return text;
+  }
+
+  try {
+    return JSON.stringify(content);
+  } catch {
+    return String(content);
+  }
+}
+
+function estimateTokensForMessages(messages: CoreMessage[]): number {
+  let total = 0;
+  for (const message of messages) {
+    total += estimateTokensForContent(contentToText(message.content));
+  }
+  return total;
+}
+
+function normalizeWhitespace(text: string): string {
+  return text.replace(/\s+/g, ' ').trim();
+}
+
+function truncateText(text: string, maxChars: number): string {
+  if (text.length <= maxChars) return text;
+  return text.slice(0, Math.max(0, maxChars - 3)) + '...';
+}
+
+function summarizeMessage(message: CoreMessage, isLastUser: boolean): string {
+  if (message.role === 'tool') {
+    const content: any = message.content;
+    const part = Array.isArray(content) ? content[0] : undefined;
+    const toolName = part?.toolName ?? part?.tool_name ?? 'tool';
+    let resultText = '';
+    if (part?.result !== undefined) {
+      if (typeof part.result === 'string') resultText = part.result;
+      else {
+        try {
+          resultText = JSON.stringify(part.result);
+        } catch {
+          resultText = String(part.result);
+        }
+      }
+    } else {
+      resultText = contentToText(message.content);
+    }
+    const isError = resultText.toLowerCase().includes('error') || resultText.toLowerCase().includes('failed');
+    const status = isError ? 'FAILED' : 'OK';
+    const cleaned = normalizeWhitespace(resultText);
+    return `[tool:${toolName} ${status}] ${truncateText(cleaned, 120)}`;
+  }
+
+  if (message.role === 'assistant') {
+    const text = contentToText(message.content);
+    const cleaned = normalizeWhitespace(text);
+    const sentenceMatch = cleaned.match(/^[^.!?\n]{10,}[.!?]/);
+    const summary = sentenceMatch ? sentenceMatch[0] : cleaned;
+    return `assistant: ${truncateText(summary, 200)}`;
+  }
+
+  const cleaned = normalizeWhitespace(contentToText(message.content));
+  const limit = isLastUser ? cleaned.length : 400;
+  return `user: ${truncateText(cleaned, limit)}`;
+}
+
+function buildSummary(messages: CoreMessage[], maxTokens: number): string {
+  const maxChars = Math.max(0, maxTokens * 3);
+  const header = 'CONVERSATION SUMMARY (auto):';
+  let charCount = header.length + 1;
+  const lines: string[] = [];
+
+  let lastUserIndex = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i]!.role === 'user') { lastUserIndex = i; break; }
+  }
+
+  for (let i = 0; i < messages.length; i++) {
+    if (charCount >= maxChars) break;
+    const line = `- ${summarizeMessage(messages[i]!, i === lastUserIndex)}`;
+    charCount += line.length + 1;
+    lines.push(line);
+  }
+  const body = lines.join('\n');
+  const full = `${header}\n${body}`.trim();
+  return truncateText(full, maxChars);
+}
+
+function compactMessages(
+  messages: CoreMessage[],
+  systemPrompt: string,
+  maxContextTokens?: number,
+  provider?: string
+): CoreMessage[] {
+  const budget = maxContextTokens ?? getDefaultContextBudget(provider);
+  const systemTokens = estimateTokensFromText(systemPrompt) + 8;
+  const messagesTokens = estimateTokensForMessages(messages);
+  const total = systemTokens + messagesTokens;
+
+  if (total <= budget) return messages;
+
+  const summaryTokens = Math.min(2000, Math.max(400, Math.floor(budget * 0.2)));
+  const recentBudget = Math.max(500, budget - summaryTokens);
+
+  let recentTokens = 0;
+  const recent: CoreMessage[] = [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i]!;
+    const msgTokens = estimateTokensForContent(contentToText(message.content));
+    if (recentTokens + msgTokens > recentBudget && recent.length > 0) break;
+    recent.unshift(message);
+    recentTokens += msgTokens;
+  }
+
+  const cutoff = messages.length - recent.length;
+  const older = cutoff > 0 ? messages.slice(0, cutoff) : [];
+
+  if (older.length === 0) return recent;
+
+  const summary = buildSummary(older, summaryTokens);
+  const summaryMessage: CoreMessage = { role: 'assistant', content: summary };
+
+  return [summaryMessage, ...recent];
+}
+
+function buildExploreContext(messages: CoreMessage[]): string {
+  const parts: string[] = [];
+
+  const userMessages: string[] = [];
+  const recentFiles = new Set<string>();
+
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i]!;
+
+    if (msg.role === 'user' && userMessages.length < 2) {
+      const text = normalizeWhitespace(contentToText(msg.content));
+      if (text) userMessages.unshift(truncateText(text, 300));
+    }
+
+    if (msg.role === 'tool' && recentFiles.size < 15) {
+      const content: any = msg.content;
+      const part = Array.isArray(content) ? content[0] : undefined;
+      const toolName = part?.toolName ?? part?.tool_name;
+      if (toolName === 'read' || toolName === 'write' || toolName === 'edit') {
+        const args = part?.args ?? part?.input;
+        const path = args?.path;
+        if (typeof path === 'string') recentFiles.add(path);
+      }
+    }
+  }
+
+  if (userMessages.length > 0) {
+    parts.push(`User intent:\n${userMessages.map(m => `- ${m}`).join('\n')}`);
+  }
+
+  if (recentFiles.size > 0) {
+    parts.push(`Files recently accessed:\n${[...recentFiles].map(f => `- ${f}`).join('\n')}`);
+  }
+
+  return parts.join('\n\n');
+}
+
+export class Agent {
+  private messageHistory: CoreMessage[] = [];
+  private provider: Provider;
+  private config: ProviderConfig;
+  private static ollamaChecked = false;
+  private resolvedMaxContextTokens?: number;
+
+  static async ensureProviderReady(): Promise<{ ready: boolean; started?: boolean; error?: string }> {
+    const userConfig = readConfig();
+
+    if (userConfig.provider === 'ollama') {
+      if (Agent.ollamaChecked) {
+        return { ready: true };
+      }
+
+      const result = await checkAndStartOllama();
+      Agent.ollamaChecked = true;
+
+      if (!result.running) {
+        return { ready: false, error: result.error };
+      }
+
+      return { ready: true, started: result.started };
+    }
+
+    return { ready: true };
+  }
+
+  constructor() {
+    const userConfig = readConfig();
+
+    if (!userConfig.provider || !userConfig.model) {
+      throw new Error('No provider or model configured. Please run setup first.');
+    }
+
+    const rawSystemPrompt = userConfig.systemPrompt || DEFAULT_SYSTEM_PROMPT;
+
+    let mcpToolInfos: Array<{ serverId: string; name: string; description: string; inputSchema: Record<string, unknown>; canonicalId: string; safeId: string }> | undefined;
+    try {
+      const { getMcpCatalog, isMcpInitialized } = require('../mcp/index');
+      if (isMcpInitialized()) {
+        mcpToolInfos = getMcpCatalog().getMcpToolInfos();
+      }
+    } catch {
+      // MCP not available
+    }
+
+    const systemPrompt = processSystemPrompt(rawSystemPrompt, true, mcpToolInfos);
+    const tools = getTools();
+
+    this.config = {
+      provider: userConfig.provider,
+      model: userConfig.model,
+      apiKey: userConfig.apiKey,
+      systemPrompt,
+      tools,
+      maxSteps: userConfig.maxSteps ?? 100,
+      maxContextTokens: userConfig.maxContextTokens,
+    };
+
+    this.provider = this.createProvider(userConfig.provider);
+  }
+
+  private createProvider(providerName: string): Provider {
+    switch (providerName) {
+      case 'openai':
+        return new OpenAIProvider();
+      case 'anthropic':
+        return new AnthropicProvider();
+      case 'google':
+        return new GoogleProvider();
+      case 'mistral':
+        return new MistralProvider();
+      case 'xai':
+        return new XaiProvider();
+      case 'ollama':
+        return new OllamaProvider();
+      default:
+        throw new Error(`Unknown provider: ${providerName}`);
+    }
+  }
+
+  async *sendMessage(userMessage: string, options?: ProviderSendOptions): AsyncGenerator<AgentEvent> {
+    this.messageHistory.push({
+      role: 'user',
+      content: userMessage,
+    });
+
+    try {
+      if (this.resolvedMaxContextTokens === undefined) {
+        const resolved = await getModelsDevContextLimit(this.config.provider, this.config.model);
+        if (typeof resolved === 'number') {
+          this.resolvedMaxContextTokens = resolved;
+          if (!this.config.maxContextTokens) {
+            this.config = { ...this.config, maxContextTokens: resolved };
+          }
+        }
+      }
+      const compacted = compactMessages(
+        this.messageHistory,
+        this.config.systemPrompt,
+        this.config.maxContextTokens ?? this.resolvedMaxContextTokens,
+        this.config.provider
+      );
+      setExploreContext(buildExploreContext(this.messageHistory));
+      yield* this.provider.sendMessage(compacted, this.config, options);
+    } catch (error) {
+      yield {
+        type: 'error',
+        error: error instanceof Error ? error.message : 'Unknown error occurred',
+      };
+    }
+  }
+
+  async *streamMessages(messages: AgentMessage[], options?: ProviderSendOptions): AsyncGenerator<AgentEvent> {
+    this.messageHistory = messages.map(msg => ({
+      role: msg.role,
+      content: msg.content,
+    })) as CoreMessage[];
+
+    try {
+      if (this.resolvedMaxContextTokens === undefined) {
+        const resolved = await getModelsDevContextLimit(this.config.provider, this.config.model);
+        if (typeof resolved === 'number') {
+          this.resolvedMaxContextTokens = resolved;
+          if (!this.config.maxContextTokens) {
+            this.config = { ...this.config, maxContextTokens: resolved };
+          }
+        }
+      }
+      const compacted = compactMessages(
+        this.messageHistory,
+        this.config.systemPrompt,
+        this.config.maxContextTokens ?? this.resolvedMaxContextTokens,
+        this.config.provider
+      );
+      setExploreContext(buildExploreContext(this.messageHistory));
+      yield* this.provider.sendMessage(compacted, this.config, options);
+    } catch (error) {
+      yield {
+        type: 'error',
+        error: error instanceof Error ? error.message : 'Unknown error occurred',
+      };
+    }
+  }
+
+  getHistory(): CoreMessage[] {
+    return [...this.messageHistory];
+  }
+
+  clearHistory(): void {
+    this.messageHistory = [];
+  }
+
+  updateConfig(updates: Partial<ProviderConfig>): void {
+    this.config = { ...this.config, ...updates };
+  }
+}

package/src/agent/context.ts

@@ -73,9 +73,9 @@ export class AgentContextManager {
     return this.currentStep;
   }
 
-  getMaxSteps(): number {
-    return this.config.maxSteps || 10;
-  }
+  getMaxSteps(): number {
+    return this.config.maxSteps || 100;
+  }
 
   canContinue(): boolean {
     return this.currentStep < this.getMaxSteps();
@@ -93,4 +93,4 @@ export class AgentContextManager {
   getMessageCount(): number {
     return this.messages.length;
   }
-}
+}

package/src/agent/prompts/systemPrompt.ts

@@ -5,7 +5,7 @@ import { getToolsPrompt } from './toolsPrompt';
 
 export const DEFAULT_SYSTEM_PROMPT = `You are Mosaic, an AI coding agent operating in the user's terminal.
 You assist with software engineering tasks: coding, debugging, refactoring, testing, and documentation.
-Version : 0.71.0 *(Beta)*
+Version : 0.73.0 *(Beta)*
 
 # Environment
 
@@ -109,10 +109,18 @@ USE glob/grep for TARGETED searches:
 
 CRITICAL: NEVER modify code you haven't read. Always use read before edit/write.
 
-## 2. PLAN (for multi-step tasks)
+## 2. PLAN (Default for non-trivial tasks)
 
-Use the plan tool to outline steps and track progress.
-Always update the plan after each step.
+Use the plan tool for any task that isn't a single obvious step.
+Default to planning when there are 2+ actions, file changes, or when success criteria are unclear.
+Keep plans short (3-6 steps), and make steps outcome-focused.
+Always update the plan after each step:
+- Exactly one step can be "in_progress" at a time
+- Mark a step "completed" before starting the next
+- Keep remaining steps "pending" until started
+Never mark multiple future steps as completed in a single update. Progress must be shown step-by-step as work happens.
+Skip the plan tool only for truly trivial, single-action tasks.
+Never output a plan as plain text, JSON, or tags. The only valid way to create or update a plan is the plan tool call.
 
 ## 3. EXECUTE
 
@@ -153,6 +161,7 @@ When NOT to ask:
 # Error Handling
 
 - If a tool fails, analyze the error and retry with adjusted parameters
+- If a rate limit error occurs, wait with backoff before retrying and avoid immediate reattempts
 - Announce the error to the user and explain your retry strategy
 - Try 2-3 different approaches before giving up
 - Only ask the user for help after multiple failed attempts
@@ -208,7 +217,7 @@ When you discover useful commands or preferences, offer to save them to MOSAIC.m
 All requests refer to the current workspace ({{WORKSPACE}}), never to Mosaic itself.
 `;
 
-export function processSystemPrompt(prompt: string, includeTools: boolean = true): string {
+export function processSystemPrompt(prompt: string, includeTools: boolean = true, mcpToolInfos?: Array<{ serverId: string; name: string; description: string; inputSchema: Record<string, unknown>; canonicalId: string; safeId: string }>): string {
   const now = new Date();
   const workspace = process.cwd();
   const os = platform();
@@ -259,7 +268,7 @@ ${mosaicContent}`;
   }
 
   if (includeTools) {
-    const toolsPrompt = getToolsPrompt();
+    const toolsPrompt = getToolsPrompt(mcpToolInfos);
     const processedToolsPrompt = toolsPrompt.replace(new RegExp('{{WORKSPACE}}', 'g'), workspace);
     processed = `${processed}\n\n${processedToolsPrompt}`;
   }