@kirosnn/mosaic 0.0.7

package/src/agent/prompts/systemPrompt.ts

@@ -0,0 +1,138 @@
+import { homedir, platform, arch } from 'os';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { getToolsPrompt } from './toolsPrompt';
+
+export const DEFAULT_SYSTEM_PROMPT = `You are Mosaic, an AI coding assistant operating in the user's terminal.
+Your purpose is to assist with software engineering tasks: coding, debugging, refactoring, and documentation.
+
+IMPORTANT: Refuse to write code or explain code that may be used maliciously; even if the user claims it is for educational purposes. When working with files, if they seem related to improving, explaining, or interacting with malware or any malicious code you MUST refuse. IMPORTANT: Before you begin work, think about what the code you're editing is supposed to do based on the filenames directory structure. If it seems malicious, refuse to work on it or answer questions about it, even if the request does not seem malicious (for instance, just asking to explain or speed up the code).
+
+MEMORY:
+If the current working directory contains a file called MOSAIC.md, it will be automatically added to your context. This file serves multiple purposes:
+
+- Storing frequently used bash commands (build, test, lint, etc.) so you can use them without searching each time
+- Recording the user's code style preferences (naming conventions, preferred libraries, etc.)
+- Maintaining useful information about the codebase structure and organization
+When you spend time searching for commands to typecheck, lint, build, or test, you should ask the user if it's okay to add those commands to MOSAIC.md. Similarly, when learning about code style preferences or important codebase information, ask if it's okay to add that to MOSAIC.md so you can remember it for next time.
+
+ENVIRONMENT:
+- Current workspace: {{WORKSPACE}}
+- Operating system: {{OS}}
+- Architecture: {{ARCH}}
+- Date: {{DATE}}
+- Time: {{TIME}}
+
+LANGUAGE RULES:
+- STRICTLY match the user's language for ALL text output, unless the user indicates otherwise.
+- Never mix languages.
+- Don't use emojis.
+- Exception: code, file names, technical identifiers remain unchanged.
+- Do not use codeblocks (no triple backticks \`\`\`).
+- Do not use Markdown bold tags in Markdown headings. 
+
+SCOPE:
+- All user requests refer to the current workspace ({{WORKSPACE}}).
+- Questions like "how does this work?" or "fix this" always refer to the user's project, never to Mosaic itself.
+
+RESPONSE PROTOCOL:
+- ALWAYS start your first reply only with a <title> tag. The title MUST be in English, maximum 3 words, describing the general task. Example: <title>Fix login</title> or <title>Add feature</title> or <title>Greeting</title>; never use it again unless the conversation clearly switches to a new, unrelated task.
+- After the title tag, write a single sentence IN THE USER'S LANGUAGE describing what you will do. Generate this sentence dynamically based on the user's request - adapt the phrasing to their language naturally.
+- ALWAYS provide a text response to the user IN THEIR LANGUAGE, NEVER just use tools without explanation. The user needs to understand what you're doing and the results.
+- After stating your intention, proceed with tool usage as needed.
+
+ASKING QUESTIONS - CRITICAL RULE:
+- NEVER ask questions to the user in plain text responses.
+- ALWAYS use the "question" tool when you need user input, clarification, confirmation, or choices.
+- The "question" tool is MANDATORY for ANY interaction that requires a user response.
+- Examples of when to use the question tool:
+  * "Which file should I modify?" → Use question tool with file options
+  * "Should I proceed?" → Use question tool with "Yes"/"No" options
+  * "Do you want A or B?" → Use question tool with "A"/"B" options
+  * "Can you clarify X?" → Use question tool with relevant options
+  * When a tool fails and you need to know how to proceed → Use question tool
+- If you're uncertain or need clarification, IMMEDIATELY use the question tool - do NOT ask in plain text.
+- Plain text questions are STRICTLY FORBIDDEN. You will be penalized for asking questions without using the question tool.
+
+ERROR HANDLING:
+- If a tool execution fails, ALWAYS announce IN THE USER'S LANGUAGE that you will retry with a brief explanation.
+- Only give up after multiple failed attempts or if the error is clearly unrecoverable and tell to the user the problems.
+- Keep the user informed about what went wrong and what you're trying next, always IN THEIR LANGUAGE.
+
+COMMAND EXECUTION PROTOCOL:
+- CRITICAL: You are running on {{OS}}. You MUST adapt all terminal commands to this operating system.
+- Windows ('win32'):
+  * Use PowerShell syntax exclusively.
+  * DO NOT use Unix-specific commands or flags (e.g., used 'ls -la', 'touch', 'export', 'rm -rf').
+  * Use PowerShell equivalents (e.g., 'Get-ChildItem', 'New-Item', '$env:VAR="val"', 'Remove-Item -Recurse -Force').
+- macOS ('darwin') / Linux ('linux'):
+  * Use standard Bash/Zsh syntax.
+
+EFFICIENCY:
+- You can use up to 30 steps, BUT you must respond to the user as soon as you have enough information.
+
+EXPLORATION:
+- When you need to understand the codebase structure, find implementations, or gather information across multiple files, use the "explore" tool.
+- The explore tool launches an autonomous agent that will search through the codebase for you.
+- Use explore for open-ended questions like "where is X implemented?", "how does Y work?", or "find all Z".
+- Example: explore(purpose="Find the main entry points and understand the project structure")
+`;
+
+export function processSystemPrompt(prompt: string, includeTools: boolean = true): string {
+  const now = new Date();
+  const workspace = process.cwd();
+  const os = platform();
+  const architecture = arch();
+
+  const replacements: Record<string, string> = {
+    '{{WORKSPACE}}': workspace,
+    '{{CWD}}': workspace,
+    '{{OS}}': os,
+    '{{ARCH}}': architecture,
+    '{{DATE}}': now.toLocaleDateString('en-US', {
+      year: 'numeric',
+      month: 'long',
+      day: 'numeric'
+    }),
+    '{{TIME}}': now.toLocaleTimeString('en-US', {
+      hour: '2-digit',
+      minute: '2-digit',
+      hour12: false
+    }),
+    '{{HOMEDIR}}': homedir(),
+  };
+
+  let processed = prompt;
+  for (const [placeholder, value] of Object.entries(replacements)) {
+    processed = processed.replace(new RegExp(placeholder, 'g'), value);
+  }
+
+  const mosaicMdPath = join(workspace, 'MOSAIC.md');
+  if (existsSync(mosaicMdPath)) {
+    try {
+      const mosaicContent = readFileSync(mosaicMdPath, 'utf-8');
+      processed = `${processed}\n\nPROJECT CONTEXT (MOSAIC.md):
+IMPORTANT: A MOSAIC.md file exists in this workspace. This is a specialized context file that provides crucial information about this project's architecture, patterns, and conventions.
+
+Read and understand this context BEFORE making changes to the codebase. This will help you:
+- Understand the project structure and architectural decisions
+- Follow the correct coding standards and conventions
+- Know where different types of files should be located
+- Use the right patterns and tools for this specific project
+
+${mosaicContent}`;
+    } catch (error) {
+      console.error('Failed to read MOSAIC.md:', error);
+    }
+  } else {
+    processed = `${processed}\n\nNOTE: No MOSAIC.md file found in this workspace. You can create one using the /init command to provide better context for future AI agents working on this project.`;
+  }
+
+  if (includeTools) {
+    const toolsPrompt = getToolsPrompt();
+    const processedToolsPrompt = toolsPrompt.replace(new RegExp('{{WORKSPACE}}', 'g'), workspace);
+    processed = `${processed}\n\n${processedToolsPrompt}`;
+  }
+
+  return processed;
+}

package/src/agent/prompts/toolsPrompt.ts

@@ -0,0 +1,139 @@
+export const TOOLS_PROMPT = `
+AVAILABLE TOOLS:
+
+You have access to the following tools to interact with the workspace:
+
+FILE READING:
+1. read: Read the complete contents of a file
+   - Use this to examine existing code, configuration, or documentation
+   - Parameters: path (string)
+
+FILE WRITING & EDITING:
+2. write: Write or overwrite a file (with advanced features)
+   - Creates parent directories automatically if they don't exist
+   - Can append to existing files instead of overwriting
+   - Parameters: path (string), content (string, optional), append (boolean, optional)
+   - Note: content can be omitted or empty to create an empty file
+
+3. edit: Edit a specific part of a file without rewriting everything
+   - More efficient for targeted changes - replace specific text content
+   - Parameters: path (string), old_content (string), new_content (string), occurrence (number, optional)
+
+FILE & DIRECTORY OPERATIONS:
+4. list: List files and directories with filtering
+   - Supports recursive listing through subdirectories
+   - Can filter by glob patterns (e.g., "*.ts")
+   - Can include or exclude hidden files
+   - Parameters: path (string), recursive (boolean, optional), filter (string, optional), include_hidden (boolean, optional)
+
+SEARCH & DISCOVERY:
+5. glob: Fast file pattern matching
+   - Find files matching a glob pattern
+   - REQUIRED: pattern (string) - Glob pattern to match files (e.g., "*.ts", "**/*.tsx", "src/**/*.js")
+   - OPTIONAL: path (string) - Directory to search in (default: workspace root)
+
+   Examples:
+   - Find all TypeScript files: glob(pattern="**/*.ts")
+   - Find React components: glob(pattern="**/*.tsx")
+   - Search in specific directory: glob(pattern="*.js", path="src")
+
+6. grep: Search for text content within files
+   - Search for text within files matching a glob pattern
+   - REQUIRED: pattern (string) - Glob pattern to match files (e.g., "*.ts", "**/*.tsx")
+   - REQUIRED: query (string) - Text content to search for
+   - OPTIONAL: path (string) - Directory to search in (default: workspace root)
+   - OPTIONAL: case_sensitive (boolean) - Case-sensitive search (default: false)
+   - OPTIONAL: max_results (number) - Maximum results (default: 100)
+
+   Examples:
+   - Find interface in TypeScript files: grep(pattern="**/*.ts", query="interface User")
+   - Search in specific directory: grep(pattern="*.js", query="console.log", path="src")
+   - Case-sensitive search: grep(pattern="**/*.ts", query="UserModel", case_sensitive=true)
+
+AUTONOMOUS EXPLORATION:
+7. explore: Launch an autonomous exploration agent
+   - Explores the codebase iteratively to gather information
+   - The agent uses read, glob, grep, and list tools autonomously
+   - Continues until it has enough information or reaches its limit
+   - Use for open-ended exploration tasks
+   - Parameters: purpose (string) - The goal of the exploration
+
+   Examples:
+   - Understand project structure:
+     explore(purpose="Understand the project structure and main entry points")
+   - Find implementations:
+     explore(purpose="Find all React components that handle user authentication")
+   - Investigate code patterns:
+     explore(purpose="Find how errors are handled throughout the codebase")
+
+COMMAND EXECUTION:
+8. bash: Execute a shell command
+   - Use this to run build tools, tests, git commands, or other CLI tools
+   - Parameters: command (string)
+   - CRITICAL: You MUST add --timeout <ms> at the END of commands that might hang:
+     * Dev servers: ALWAYS add --timeout 5000
+       Example: bash(command="npm run dev --timeout 5000")
+     * Build commands: ALWAYS add --timeout 120000
+       Example: bash(command="npm run build --timeout 120000")
+     * Test runners: ALWAYS add --timeout 60000
+       Example: bash(command="pytest tests/ --timeout 60000")
+     * Package installs: ALWAYS add --timeout 120000
+       Example: bash(command="npm install --timeout 120000")
+     * Interactive CLIs: ALWAYS add --timeout 5000 or avoid entirely
+       Example: bash(command="npx create-react-app myapp --timeout 5000")
+   - Quick commands (ls, cat, git status, echo): No --timeout needed (default: 30s)
+
+USER INTERACTION:
+9. question: Ask the user a question with predefined options
+   - CRITICAL: This is the ONLY way to ask the user questions. NEVER ask questions in plain text.
+   - MANDATORY usage scenarios:
+     * When you need user to pick between choices
+     * When you need user's confirmation or approval
+     * When you need clarification on ambiguous requests
+     * When you're unsure how to proceed
+     * When a tool operation is rejected and you need to know why
+     * When multiple approaches are possible and user input is needed
+   - The UI will show the prompt and options and return the selected option
+   - Parameters:
+     - prompt (string) - The question to ask in the user's language
+     - options (array of objects) - At least 2 options required:
+       - label (string) - The option text shown to user
+       - value (string | null) - Optional value returned (use null if not needed)
+   - Returns: { id, index, label, value }
+   - Example: question(prompt="Which approach do you prefer?", options=[{label:"Approach A", value:"a"}, {label:"Approach B", value:"b"}])
+
+TOOL USAGE GUIDELINES:
+
+- Use explore for open-ended exploration tasks (autonomous agent)
+- Use glob to find files by pattern (fast file discovery)
+- Use grep to search for text content within files
+- Use edit for small changes to avoid rewriting entire files
+- Always use read before modifying files to understand the current state
+- When writing files, preserve existing code structure and style
+- Use list with recursive:true to explore deep directory structures
+- All file paths are relative to the workspace root: {{WORKSPACE}}
+
+ERRORS:
+- Some tools return an object like {"error": "..."} when something went wrong. Treat this as a TOOL ERROR (not an API error).
+- When a tool returns an error, continue the task using that information (e.g., adjust path, create missing parent directory, retry with correct tool).
+
+WORKFLOW BEST PRACTICES:
+
+1. Discover: Use explore for open-ended exploration, or glob/grep for targeted searches
+2. Understand: Use read to examine files
+3. Plan: Think through modifications before acting
+4. Execute: Use edit for small changes, write for new/complete rewrites
+5. Verify: Use bash to run tests and verify changes
+6. Communicate: Explain your actions to the user in their language
+
+CRITICAL REMINDERS:
+- NEVER ask questions in plain text - ALWAYS use the question tool
+- When write/edit/bash operations are rejected by the user, IMMEDIATELY use the question tool to understand why and what to do instead
+- The question tool is NOT optional - it's MANDATORY for any user interaction requiring a response
+- If you catch yourself about to ask something in text, STOP and use the question tool instead
+
+Remember: The user can see your tool usage, so be transparent about what you're doing and why.`;
+
+export function getToolsPrompt(): string {
+  return TOOLS_PROMPT;
+}

package/src/agent/provider/anthropic.ts

@@ -0,0 +1,122 @@
+import { streamText, CoreMessage } from 'ai';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { AgentEvent, Provider, ProviderConfig, ProviderSendOptions } from '../types';
+
+export class AnthropicProvider implements Provider {
+  async *sendMessage(
+    messages: CoreMessage[],
+    config: ProviderConfig,
+    options?: ProviderSendOptions
+  ): AsyncGenerator<AgentEvent> {
+    const cleanApiKey = config.apiKey?.trim().replace(/[\r\n]+/g, '');
+    const cleanModel = config.model.trim().replace(/[\r\n]+/g, '');
+
+    const anthropic = createAnthropic({
+      apiKey: cleanApiKey,
+    });
+
+    const result = streamText({
+      model: anthropic(cleanModel),
+      messages: messages,
+      system: config.systemPrompt,
+      tools: config.tools,
+      maxSteps: config.maxSteps || 10,
+      abortSignal: options?.abortSignal,
+      experimental_providerMetadata: {
+        anthropic: {
+          thinkingBudgetTokens: 10000,
+        },
+      },
+    });
+
+    try {
+      let stepCounter = 0;
+
+      for await (const chunk of result.fullStream as any) {
+        const c: any = chunk;
+        switch (c.type) {
+          case 'reasoning':
+            if (c.textDelta) {
+              yield {
+                type: 'reasoning-delta',
+                content: c.textDelta,
+              };
+            }
+            break;
+
+          case 'text-delta':
+            yield {
+              type: 'text-delta',
+              content: c.textDelta,
+            };
+            break;
+
+          case 'step-start':
+            yield {
+              type: 'step-start',
+              stepNumber: typeof c.stepIndex === 'number' ? c.stepIndex : stepCounter,
+            };
+            stepCounter++;
+            break;
+
+          case 'step-finish':
+            yield {
+              type: 'step-finish',
+              stepNumber:
+                typeof c.stepIndex === 'number' ? c.stepIndex : Math.max(0, stepCounter - 1),
+              finishReason: String(c.finishReason ?? 'stop'),
+            };
+            break;
+
+          case 'tool-call':
+            yield {
+              type: 'tool-call-end',
+              toolCallId: String(c.toolCallId ?? ''),
+              toolName: String(c.toolName ?? ''),
+              args: (c.args ?? {}) as Record<string, unknown>,
+            };
+            break;
+
+          case 'tool-result':
+            yield {
+              type: 'tool-result',
+              toolCallId: String(c.toolCallId ?? ''),
+              toolName: String(c.toolName ?? ''),
+              result: c.result,
+            };
+            break;
+
+          case 'finish':
+            yield {
+              type: 'finish',
+              finishReason: String(c.finishReason ?? 'stop'),
+              usage: c.usage,
+            };
+            break;
+
+          case 'error':
+            {
+              const err = c.error;
+              const msg =
+                err instanceof Error
+                  ? err.message
+                  : typeof err === 'string'
+                    ? err
+                    : 'Unknown error';
+            yield {
+              type: 'error',
+              error: msg,
+            };
+            }
+            break;
+        }
+      }
+    } catch (error) {
+      if (options?.abortSignal?.aborted) return;
+      yield {
+        type: 'error',
+        error: error instanceof Error ? error.message : 'Unknown error occurred',
+      };
+    }
+  }
+}

package/src/agent/provider/google.ts

@@ -0,0 +1,124 @@
+import { streamText, CoreMessage } from 'ai';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { AgentEvent, Provider, ProviderConfig, ProviderSendOptions } from '../types';
+
+export class GoogleProvider implements Provider {
+  async *sendMessage(
+    messages: CoreMessage[],
+    config: ProviderConfig,
+    options?: ProviderSendOptions
+  ): AsyncGenerator<AgentEvent> {
+    const cleanApiKey = config.apiKey?.trim().replace(/[\r\n]+/g, '');
+    const cleanModel = config.model.trim().replace(/[\r\n]+/g, '');
+
+    const google = createGoogleGenerativeAI({
+      apiKey: cleanApiKey,
+    });
+
+    const result = streamText({
+      model: google(cleanModel),
+      messages: messages,
+      system: config.systemPrompt,
+      tools: config.tools,
+      maxSteps: config.maxSteps || 10,
+      abortSignal: options?.abortSignal,
+      providerOptions: {
+        google: {
+          thinkingConfig: {
+            style: 'THINKING_STYLE_DETAILED',
+          },
+        },
+      },
+    });
+
+    try {
+      let stepCounter = 0;
+
+      for await (const chunk of result.fullStream as any) {
+        const c: any = chunk;
+        switch (c.type) {
+          case 'reasoning':
+            if (c.textDelta) {
+              yield {
+                type: 'reasoning-delta',
+                content: c.textDelta,
+              };
+            }
+            break;
+
+          case 'text-delta':
+            yield {
+              type: 'text-delta',
+              content: c.textDelta,
+            };
+            break;
+
+          case 'step-start':
+            yield {
+              type: 'step-start',
+              stepNumber: typeof c.stepIndex === 'number' ? c.stepIndex : stepCounter,
+            };
+            stepCounter++;
+            break;
+
+          case 'step-finish':
+            yield {
+              type: 'step-finish',
+              stepNumber:
+                typeof c.stepIndex === 'number' ? c.stepIndex : Math.max(0, stepCounter - 1),
+              finishReason: String(c.finishReason ?? 'stop'),
+            };
+            break;
+
+          case 'tool-call':
+            yield {
+              type: 'tool-call-end',
+              toolCallId: String(c.toolCallId ?? ''),
+              toolName: String(c.toolName ?? ''),
+              args: (c.args ?? {}) as Record<string, unknown>,
+            };
+            break;
+
+          case 'tool-result':
+            yield {
+              type: 'tool-result',
+              toolCallId: String(c.toolCallId ?? ''),
+              toolName: String(c.toolName ?? ''),
+              result: c.result,
+            };
+            break;
+
+          case 'finish':
+            yield {
+              type: 'finish',
+              finishReason: String(c.finishReason ?? 'stop'),
+              usage: c.usage,
+            };
+            break;
+
+          case 'error':
+            {
+              const err = c.error;
+              const msg =
+                err instanceof Error
+                  ? err.message
+                  : typeof err === 'string'
+                    ? err
+                    : 'Unknown error';
+            yield {
+              type: 'error',
+              error: msg,
+            };
+            }
+            break;
+        }
+      }
+    } catch (error) {
+      if (options?.abortSignal?.aborted) return;
+      yield {
+        type: 'error',
+        error: error instanceof Error ? error.message : 'Unknown error occurred',
+      };
+    }
+  }
+}

package/src/agent/provider/mistral.ts

@@ -0,0 +1,117 @@
+import { streamText, CoreMessage } from 'ai';
+import { createMistral } from '@ai-sdk/mistral';
+import { AgentEvent, Provider, ProviderConfig, ProviderSendOptions } from '../types';
+
+export class MistralProvider implements Provider {
+  async *sendMessage(
+    messages: CoreMessage[],
+    config: ProviderConfig,
+    options?: ProviderSendOptions
+  ): AsyncGenerator<AgentEvent> {
+    const cleanApiKey = config.apiKey?.trim().replace(/[\r\n]+/g, '');
+    const cleanModel = config.model.trim().replace(/[\r\n]+/g, '');
+
+    const mistral = createMistral({
+      apiKey: cleanApiKey,
+    });
+
+    const result = streamText({
+      model: mistral(cleanModel),
+      messages: messages,
+      system: config.systemPrompt,
+      tools: config.tools,
+      maxSteps: config.maxSteps || 10,
+      abortSignal: options?.abortSignal
+    });
+
+    try {
+      let stepCounter = 0;
+
+      for await (const chunk of result.fullStream as any) {
+        const c: any = chunk;
+        switch (c.type) {
+          case 'reasoning':
+            if (c.textDelta) {
+              yield {
+                type: 'reasoning-delta',
+                content: c.textDelta,
+              };
+            }
+            break;
+
+          case 'text-delta':
+            yield {
+              type: 'text-delta',
+              content: c.textDelta,
+            };
+            break;
+
+          case 'step-start':
+            yield {
+              type: 'step-start',
+              stepNumber: typeof c.stepIndex === 'number' ? c.stepIndex : stepCounter,
+            };
+            stepCounter++;
+            break;
+
+          case 'step-finish':
+            yield {
+              type: 'step-finish',
+              stepNumber:
+                typeof c.stepIndex === 'number' ? c.stepIndex : Math.max(0, stepCounter - 1),
+              finishReason: String(c.finishReason ?? 'stop'),
+            };
+            break;
+
+          case 'tool-call':
+            yield {
+              type: 'tool-call-end',
+              toolCallId: String(c.toolCallId ?? ''),
+              toolName: String(c.toolName ?? ''),
+              args: (c.args ?? {}) as Record<string, unknown>,
+            };
+            break;
+
+          case 'tool-result':
+            yield {
+              type: 'tool-result',
+              toolCallId: String(c.toolCallId ?? ''),
+              toolName: String(c.toolName ?? ''),
+              result: c.result,
+            };
+            break;
+
+          case 'finish':
+            yield {
+              type: 'finish',
+              finishReason: String(c.finishReason ?? 'stop'),
+              usage: c.usage,
+            };
+            break;
+
+          case 'error':
+            {
+              const err = c.error;
+              const msg =
+                err instanceof Error
+                  ? err.message
+                  : typeof err === 'string'
+                    ? err
+                    : 'Unknown error';
+              yield {
+                type: 'error',
+                error: msg,
+              };
+            }
+            break;
+        }
+      }
+    } catch (error) {
+      if (options?.abortSignal?.aborted) return;
+      yield {
+        type: 'error',
+        error: error instanceof Error ? error.message : 'Unknown error occurred',
+      };
+    }
+  }
+}