@kirosnn/mosaic 0.0.91 → 0.71.0

package/src/agent/tools/exploreExecutor.ts

@@ -104,10 +104,10 @@ function createExploreTools() {
       },
     }),
     glob: createTool({
-      description: 'Find files matching a glob pattern',
+      description: 'Find files matching a glob pattern. Do NOT use this to list directory contents (use "list" instead).',
       parameters: z.object({
         pattern: z.string().describe('Glob pattern to match files (e.g., "**/*.ts", "src/**/*.tsx")'),
-        path: z.string().optional().describe('Directory to search in (default: workspace root)'),
+        path: z.string().describe('Directory to search in (use "." for workspace root)'),
       }),
       execute: async (args) => {
         if (isExploreAborted()) return { error: 'Exploration aborted' };
@@ -127,17 +127,17 @@ function createExploreTools() {
       },
     }),
     grep: createTool({
-      description: 'Search for text content within files',
+      description: 'Search for text content within files using regular expressions',
       parameters: z.object({
         pattern: z.string().describe('Glob pattern to match files'),
-        query: z.string().describe('Text to search for'),
-        path: z.string().optional().describe('Directory to search in'),
-        case_sensitive: z.boolean().optional().describe('Case-sensitive search'),
-        max_results: z.number().optional().describe('Maximum results'),
+        query: z.string().describe('Regular expression pattern to search for'),
+        path: z.string().describe('Directory to search in (use "." for workspace root)'),
+        case_sensitive: z.boolean().describe('Case-sensitive search (pass false for default)'),
+        max_results: z.number().describe('Maximum results (pass 50 for default)'),
       }),
       execute: async (args) => {
         if (isExploreAborted()) return { error: 'Exploration aborted' };
-        const result = await executeTool('grep', args);
+        const result = await executeTool('grep', { ...args, regex: true });
         const resultLen = result.result?.length || 0;
         let preview = result.error || 'error';
         if (result.success && result.result) {
@@ -156,9 +156,9 @@ function createExploreTools() {
       description: 'List files and directories',
       parameters: z.object({
         path: z.string().describe('Path to list'),
-        recursive: z.boolean().optional().describe('List recursively'),
-        filter: z.string().optional().describe('Filter pattern'),
-        include_hidden: z.boolean().optional().describe('Include hidden files'),
+        recursive: z.boolean().describe('List recursively (pass false for default)'),
+        filter: z.string().describe('Filter pattern (pass empty string for no filter)'),
+        include_hidden: z.boolean().describe('Include hidden files (pass false for default)'),
       }),
       execute: async (args) => {
         if (isExploreAborted()) return { error: 'Exploration aborted' };
@@ -196,7 +196,7 @@ function formatExploreLogs(): string {
   const lines = ['Tools used:'];
   for (const log of exploreLogs) {
     const argStr = log.args.path || log.args.pattern || log.args.query || '';
-    const status = log.success ? '+' : '-';
+    const status = log.success ? '→' : '-';
     lines.push(`  ${status} ${log.tool}(${argStr}) -> ${log.resultPreview || 'ok'}`);
   }
   return lines.join('\n');

package/src/agent/tools/fetch.ts

@@ -0,0 +1,58 @@
+import { tool, type CoreTool } from 'ai';
+import { z } from 'zod';
+import { executeTool } from './executor';
+
+export const fetch: CoreTool = tool({
+  description: `Fetches a URL from the internet and extracts its contents as markdown.
+
+This tool allows you to retrieve web content and process it for analysis. HTML pages are automatically converted to clean markdown format for easier reading.
+
+Features:
+- Automatic HTML to Markdown conversion with Readability
+- Pagination support for large pages (use start_index to continue reading)
+- Raw HTML retrieval option
+- Link and image URL resolution to absolute paths
+- Configurable content length limits
+
+Use cases:
+- Reading documentation and articles
+- Fetching API responses (JSON, XML, etc.)
+- Researching information from the web
+- Analyzing web page content`,
+  parameters: z.object({
+    url: z.string().describe('The URL to fetch (must be a valid HTTP/HTTPS URL)'),
+    max_length: z
+      .number()
+      .int()
+      .positive()
+      .max(100000)
+      .nullable()
+      .optional()
+      .describe('Maximum number of characters to return (default: 10000, max: 100000)'),
+    start_index: z
+      .number()
+      .int()
+      .nonnegative()
+      .nullable()
+      .optional()
+      .describe('Character index to start reading from. Use this to paginate through large pages when content is truncated.'),
+    raw: z
+      .boolean()
+      .nullable()
+      .optional()
+      .describe('If true, return raw HTML instead of converting to markdown'),
+    timeout: z
+      .number()
+      .int()
+      .positive()
+      .max(60000)
+      .nullable()
+      .optional()
+      .describe('Request timeout in milliseconds (default: 30000, max: 60000)'),
+  }),
+  execute: async (args) => {
+    const result = await executeTool('fetch', args);
+    if (!result.success) return { error: result.error || 'Unknown error occurred' };
+    return result.result;
+  },
+});

package/src/agent/tools/glob.ts

@@ -3,13 +3,29 @@ import { z } from 'zod';
 import { executeTool } from './executor';
 
 export const glob: CoreTool = tool({
-  description: 'Find files matching a glob pattern. Fast pattern-based file discovery.',
+  description: `Find files matching a glob pattern. Fast pattern-based file discovery.
+
+IMPORTANT: Use "**/" prefix to search recursively in all subdirectories.
+- "*.ts" only matches files in the current directory
+- "**/*.ts" matches files in ALL subdirectories (usually what you want)
+
+Note: Do not use this to simply list files in a directory; use the 'list' tool for that. This is for finding specific files by pattern.
+
+Examples:
+- glob(pattern="**/*.ts") - All TypeScript files
+- glob(pattern="**/*.tsx") - All React components
+- glob(pattern="**/package.json") - All package.json files
+- glob(pattern="src/**/*.js") - All JS files in src/`,
   parameters: z.object({
-    pattern: z.string().describe('Glob pattern to match files (e.g., "*.ts", "**/*.tsx", "src/**/*.js")'),
-    path: z.string().nullable().optional().describe('Directory to search in (use null for workspace root)'),
+    pattern: z.string().describe('Glob pattern (use **/ for recursive search, e.g., "**/*.ts")'),
+    path: z.string().optional().describe('Directory to search in (defaults to workspace root)'),
   }),
   execute: async (args) => {
-    const result = await executeTool('glob', args);
+    const cleanArgs = {
+      pattern: args.pattern,
+      path: args.path && args.path !== 'null' ? args.path : undefined,
+    };
+    const result = await executeTool('glob', cleanArgs);
     if (!result.success) return { error: result.error || 'Unknown error occurred' };
     return result.result;
   },

package/src/agent/tools/grep.ts

@@ -2,18 +2,72 @@ import { tool, type CoreTool } from 'ai';
 import { z } from 'zod';
 import { executeTool } from './executor';
 
+const FILE_TYPE_EXTENSIONS: Record<string, string[]> = {
+  ts: ['.ts', '.tsx', '.mts', '.cts'],
+  js: ['.js', '.jsx', '.mjs', '.cjs'],
+  py: ['.py', '.pyw', '.pyi'],
+  java: ['.java'],
+  go: ['.go'],
+  rust: ['.rs'],
+  c: ['.c', '.h'],
+  cpp: ['.cpp', '.cc', '.cxx', '.hpp', '.hh', '.hxx'],
+  cs: ['.cs'],
+  rb: ['.rb', '.rake', '.gemspec'],
+  php: ['.php', '.phtml'],
+  swift: ['.swift'],
+  kt: ['.kt', '.kts'],
+  scala: ['.scala'],
+  html: ['.html', '.htm', '.xhtml'],
+  css: ['.css', '.scss', '.sass', '.less'],
+  json: ['.json', '.jsonc'],
+  yaml: ['.yaml', '.yml'],
+  md: ['.md', '.markdown'],
+  sh: ['.sh', '.bash', '.zsh'],
+  sql: ['.sql'],
+  vue: ['.vue'],
+  svelte: ['.svelte'],
+};
+
+export { FILE_TYPE_EXTENSIONS };
+
 export const grep: CoreTool = tool({
-  description: 'Search for text content within files matching a glob pattern. Combines pattern matching with content search.',
+  description: `Search for text within files using regular expressions.
+  
+RECOMMENDED: Use file_type for best results (automatically searches all subdirectories).
+
+Examples:
+- grep(query="interface User", file_type="ts") - Search in TypeScript files
+- grep(query="export function", file_type="tsx") - Search in React files
+- grep(query="TODO") - Search in all files
+- grep(query="class.*Component", file_type="ts") - Reuse regex search
+- grep(query="handleClick", output_mode="files") - Just list matching files`,
   parameters: z.object({
-    pattern: z.string().describe('Glob pattern to match files (e.g., "*.ts", "**/*.tsx", "src/**/*.js")'),
-    query: z.string().describe('Text content to search for within the matched files'),
-    path: z.string().nullable().optional().describe('Directory to search in (use null for workspace root)'),
-    case_sensitive: z.boolean().nullable().optional().describe('Whether text search should be case-sensitive (use null for false)'),
-    max_results: z.number().nullable().optional().describe('Maximum number of results to return (use null for 100)'),
+    query: z.string().describe('Regular expression pattern to search for'),
+    file_type: z.string().optional().describe('File type: ts, js, tsx, jsx, py, java, go, rust, c, cpp, rb, php, json, yaml, md, html, css'),
+    pattern: z.string().optional().describe('Glob pattern for files (e.g., "**/*.config.ts"). Usually file_type is easier.'),
+    path: z.string().optional().describe('Directory to search (defaults to workspace root)'),
+    case_sensitive: z.boolean().optional().describe('Case-sensitive (default: false)'),
+    whole_word: z.boolean().optional().describe('Match whole words only (default: false)'),
+    context: z.number().optional().describe('Lines of context around matches (default: 0)'),
+    max_results: z.number().optional().describe('Max results (default: 500)'),
+    output_mode: z.enum(['matches', 'files', 'count']).optional().describe('"matches" (default), "files", or "count"'),
+    exclude_pattern: z.string().optional().describe('Glob pattern to exclude'),
   }),
   execute: async (args) => {
-    const result = await executeTool('grep', args);
+    const cleanArgs: Record<string, unknown> = { query: args.query, regex: true };
+
+    if (args.file_type && args.file_type !== 'null') cleanArgs.file_type = args.file_type;
+    if (args.pattern && args.pattern !== 'null') cleanArgs.pattern = args.pattern;
+    if (args.path && args.path !== 'null') cleanArgs.path = args.path;
+    if (args.case_sensitive !== undefined && args.case_sensitive !== null) cleanArgs.case_sensitive = args.case_sensitive;
+    if (args.whole_word !== undefined && args.whole_word !== null) cleanArgs.whole_word = args.whole_word;
+    if (args.context !== undefined && args.context !== null) cleanArgs.context = args.context;
+    if (args.max_results !== undefined && args.max_results !== null) cleanArgs.max_results = args.max_results;
+    if (args.output_mode && (args.output_mode as string) !== 'null') cleanArgs.output_mode = args.output_mode;
+    if (args.exclude_pattern && args.exclude_pattern !== 'null') cleanArgs.exclude_pattern = args.exclude_pattern;
+
+    const result = await executeTool('grep', cleanArgs);
     if (!result.success) return { error: result.error || 'Unknown error occurred' };
     return result.result;
   },
-});
+});

package/src/agent/tools/plan.ts

@@ -0,0 +1,27 @@
+import { tool, type CoreTool } from 'ai';
+import { z } from 'zod';
+
+const PlanStepSchema = z.object({
+  step: z.string().describe('A short, specific action item.'),
+  status: z.enum(['pending', 'in_progress', 'completed']).describe('Current status of the step.'),
+});
+
+export const plan: CoreTool = tool({
+  description: 'Create or update a task plan for longer work, and keep it up to date as you progress. Update the plan after each step.',
+  parameters: z.object({
+    explanation: z.string().optional().describe('Optional context about the plan or changes.'),
+    plan: z.array(PlanStepSchema).min(1).describe('Ordered list of steps with statuses.'),
+  }),
+  execute: async (args) => {
+    const rawPlan = Array.isArray(args.plan) ? args.plan : [];
+    const normalizedPlan = rawPlan
+      .map((item) => ({
+        step: typeof item.step === 'string' ? item.step : '',
+        status: item.status === 'completed' || item.status === 'in_progress' ? item.status : 'pending',
+      }))
+      .filter((item) => item.step.trim().length > 0);
+
+    const explanation = typeof args.explanation === 'string' ? args.explanation : undefined;
+    return { explanation, plan: normalizedPlan };
+  },
+});

package/src/agent/tools/read.ts

@@ -6,6 +6,8 @@ export const read: CoreTool = tool({
   description: 'Read the contents of a file from the workspace',
   parameters: z.object({
     path: z.string().describe('The path to the file relative to the workspace root'),
+    start_line: z.number().optional().describe('The line number to start reading from (1-based)'),
+    end_line: z.number().optional().describe('The line number to end reading at (1-based)'),
   }),
   execute: async (args) => {
     const result = await executeTool('read', args);

package/src/agent/types.ts

@@ -1,4 +1,4 @@
-import { CoreMessage, CoreTool } from 'ai';
+import { CoreMessage, CoreTool, UserContent } from 'ai';
 
 export type AgentEventType =
   | 'text-delta'
@@ -137,10 +137,10 @@ export interface AgentContext {
   config: AgentConfig;
 }
 
-export interface AgentMessage {
-  role: 'user' | 'assistant';
-  content: string;
-}
+export interface AgentMessage {
+  role: 'user' | 'assistant';
+  content: string | UserContent;
+}
 
 export interface ProviderSendOptions {
   abortSignal?: AbortSignal;
@@ -152,4 +152,4 @@ export interface Provider {
     config: ProviderConfig,
     options?: ProviderSendOptions
   ): AsyncGenerator<AgentEvent>;
-}
+}

package/src/components/App.tsx

@@ -1,4 +1,4 @@
-import { useState, useEffect, useCallback } from 'react';
+import { useState, useEffect, useCallback, useRef } from 'react';
 import type { KeyEvent } from '@opentui/core';
 import { isFirstRun, markFirstRunComplete } from '../utils/config';
 import { useRenderer } from '@opentui/react';
@@ -7,9 +7,13 @@ import { Setup } from './Setup';
 import { Main } from './Main';
 import { ShortcutsModal } from './ShortcutsModal';
 import { CommandModal } from './CommandsModal';
-import { Notification, type NotificationData } from './Notification';
-import { exec } from 'child_process';
-import { promisify } from 'util';
+import { Notification, type NotificationData } from './Notification';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { subscribeNotifications } from '../utils/notificationBridge';
+import { shouldRequireApprovals, setRequireApprovals } from '../utils/config';
+import { getCurrentApproval, respondApproval } from '../utils/approvalBridge';
+import { emitApprovalMode } from '../utils/approvalModeBridge';
 
 const execAsync = promisify(exec);
 
@@ -29,6 +33,7 @@ export function App({ initialMessage }: AppProps) {
   const [commandsOpen, setCommandsOpen] = useState(false);
   const [notifications, setNotifications] = useState<NotificationData[]>([]);
   const [pendingMessage, setPendingMessage] = useState<string | undefined>(initialMessage);
+  const lastSelectionRef = useRef<{ text: string; at: number } | null>(null);
 
   const renderer = useRenderer();
 
@@ -41,11 +46,11 @@ export function App({ initialMessage }: AppProps) {
     setNotifications(prev => prev.filter(n => n.id !== id));
   }, []);
 
-  const copyToClipboard = async (text: string) => {
+  const copyToClipboard = useCallback(async (text: string) => {
     try {
       if (process.platform === 'win32') {
-        const escaped = text.replace(/'/g, "''");
-        await execAsync(`powershell -command "Set-Clipboard -Value '${escaped}'"`);
+        const encoded = Buffer.from(text, 'utf8').toString('base64');
+        await execAsync(`powershell.exe -NoProfile -Command "$bytes=[Convert]::FromBase64String('${encoded}');$text=[System.Text.Encoding]::UTF8.GetString($bytes);Set-Clipboard -Value $text"`);
       } else if (process.platform === 'darwin') {
         await execAsync(`echo ${JSON.stringify(text)} | pbcopy`);
       } else {
@@ -54,24 +59,61 @@ export function App({ initialMessage }: AppProps) {
     } catch (error) {
       console.error('Failed to copy to clipboard:', error);
     }
-  };
-
-  useEffect(() => {
-    const isDarwin = process.platform === 'darwin';
-
-    const handleKeyPress = (key: KeyEvent) => {
-      const k = key as any;
+  }, []);
 
-      if (k.name === 'escape') {
-        setShortcutsOpen(false);
-        setCommandsOpen(false);
-        return;
-      }
+  useEffect(() => {
+    const handler = (selection: any) => {
+      if (!selection || selection.isSelecting || !selection.isActive) return;
+      const text = typeof selection.getSelectedText === 'function' ? selection.getSelectedText() : '';
+      if (!text) return;
+      const now = Date.now();
+      const last = lastSelectionRef.current;
+      if (last && last.text === text && now - last.at < 400) return;
+      lastSelectionRef.current = { text, at: now };
+      copyToClipboard(text);
+      addNotification('Copied to clipboard', 'info', 2000);
+    };
 
-      if (shortcutsOpen && (k.name === 'f1' || k.name === 'f2')) {
-        setShortcutsTab(k.name === 'f2' ? 1 : 0);
-        return;
-      }
+    const rendererAny = renderer as any;
+    rendererAny.on?.('selection', handler);
+    return () => {
+      rendererAny.off?.('selection', handler);
+    };
+  }, [renderer, copyToClipboard, addNotification]);
+
+  useEffect(() => {
+    return subscribeNotifications((payload) => {
+      addNotification(payload.message, payload.type ?? 'info', payload.duration);
+    });
+  }, [addNotification]);
+
+  useEffect(() => {
+    const isDarwin = process.platform === 'darwin';
+
+    const handleKeyPress = (key: KeyEvent) => {
+      const k = key as any;
+
+      if (k.name === 'escape') {
+        setShortcutsOpen(false);
+        setCommandsOpen(false);
+        return;
+      }
+
+      if (k.name === 'tab' && k.shift) {
+        const next = !shouldRequireApprovals();
+        setRequireApprovals(next);
+        if (!next && getCurrentApproval()) {
+          respondApproval(true);
+        }
+        emitApprovalMode(next);
+        addNotification(next ? 'Approvals enabled' : 'Auto-approve enabled', 'info', 2500);
+        return;
+      }
+
+      if (shortcutsOpen && (k.name === 'f1' || k.name === 'f2')) {
+        setShortcutsTab(k.name === 'f2' ? 1 : 0);
+        return;
+      }
 
       const seq = k.sequence;
 
@@ -90,7 +132,7 @@ export function App({ initialMessage }: AppProps) {
         return;
       }
 
-      if (k.name === 'c' && !k.shift && (k.ctrl || (isDarwin && k.meta && !k.alt) || (!isDarwin && (k.alt || k.meta) && !k.ctrl)) || seq === '\x03') {
+      if (k.name === 'c' && !k.shift && ((isDarwin && k.meta && !k.ctrl && !k.alt) || (!isDarwin && k.alt && !k.ctrl))) {
         setCopyRequestId(prev => prev + 1);
         return;
       }
@@ -171,4 +213,4 @@ export function App({ initialMessage }: AppProps) {
   );
 }
 
-export default App;
+export default App;