@kirosnn/mosaic 0.0.91 → 0.73.0

package/src/utils/diffRendering.tsx

@@ -8,13 +8,13 @@ export function renderDiffLine(line: string, key: string) {
     const colors = getDiffLineColors(parsed);
 
     return (
-      <box key={key} flexDirection="row">
-        <box backgroundColor={colors.labelBackground}>
+      <box key={key} flexDirection="row" width="100%" alignItems="stretch">
+        <box backgroundColor={colors.labelBackground} flexShrink={0}>
           <text fg="#ffffff">
             {" "}{parsed.prefix}{parsed.lineNumber?.padStart(5) || ''}{' '}
           </text>
         </box>
-        <box flexGrow={1} backgroundColor={colors.contentBackground}>
+        <box flexGrow={1} backgroundColor={colors.contentBackground} minWidth={0}>
           <text fg="#ffffff">
             {" "}{parsed.content || ''}
           </text>
@@ -24,27 +24,26 @@ export function renderDiffLine(line: string, key: string) {
   }
 
   return (
-    <text key={key} fg="#ffffff">
-      {line || ' '}
-    </text>
+    <box key={key} width="100%">
+      <text fg="#ffffff">
+        {line || ' '}
+      </text>
+    </box>
   );
 }
 
 export function renderInlineDiffLine(content: string) {
   const parsed = parseDiffLine(content);
-
   if (parsed.isDiffLine) {
-    const colors = getDiffLineColors(parsed);
-
     return (
       <>
         <box>
-          <text fg="#ffffff">
+          <text fg="white" attributes={TextAttributes.DIM}>
             {parsed.prefix}{parsed.lineNumber?.padStart(5) || ''}{' '}
           </text>
         </box>
-        <box backgroundColor={colors.contentBackground}>
-          <text fg="#ffffff">
+        <box>
+          <text fg="white">
             {" "}{parsed.content || ''}
           </text>
         </box>
@@ -55,8 +54,6 @@ export function renderInlineDiffLine(content: string) {
   return null;
 }
 
-export function getDiffLineBackground(content: string): string | null {
-  const parsed = parseDiffLine(content);
-  const colors = getDiffLineColors(parsed);
-  return colors.contentBackground !== 'transparent' ? colors.contentBackground : null;
+export function getDiffLineBackground(_content: string): string | null {
+  return null;
 }

package/src/utils/exploreBridge.ts

@@ -15,6 +15,7 @@ interface ExploreBridgeGlobal {
   toolCallback: ExploreToolCallback | null;
   totalExploreTokens: number;
   subscribers: Set<ExploreToolSubscriber>;
+  parentContext: string;
 }
 
 const globalKey = '__mosaic_explore_bridge__';
@@ -26,6 +27,7 @@ if (!g[globalKey]) {
     toolCallback: null,
     totalExploreTokens: 0,
     subscribers: new Set<ExploreToolSubscriber>(),
+    parentContext: '',
   };
 }
 
@@ -85,3 +87,11 @@ export function subscribeExploreTool(callback: ExploreToolSubscriber): () => voi
 export function getExploreTokens(): number {
   return state.totalExploreTokens;
 }
+
+export function setExploreContext(context: string): void {
+  state.parentContext = context;
+}
+
+export function getExploreContext(): string {
+  return state.parentContext;
+}

package/src/utils/history.ts

@@ -1,26 +1,31 @@
-import { existsSync, mkdirSync, writeFileSync, readdirSync, readFileSync } from 'fs';
+import { existsSync, mkdirSync, writeFileSync, readdirSync, readFileSync, unlinkSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 
-export interface ConversationStep {
-  type: 'user' | 'assistant' | 'tool';
-  content: string;
-  toolName?: string;
-  toolArgs?: Record<string, unknown>;
-  toolResult?: unknown;
-  timestamp: number;
-}
-
-export interface ConversationHistory {
-  id: string;
-  timestamp: number;
-  steps: ConversationStep[];
-  totalSteps: number;
-  totalTokens?: {
-    prompt: number;
-    completion: number;
-    total: number;
-  };
+export interface ConversationStep {
+  type: 'user' | 'assistant' | 'tool';
+  content: string;
+  images?: import("./images").ImageAttachment[];
+  toolName?: string;
+  toolArgs?: Record<string, unknown>;
+  toolResult?: unknown;
+  timestamp: number;
+  responseDuration?: number;
+  blendWord?: string;
+}
+
+export interface ConversationHistory {
+  id: string;
+  timestamp: number;
+  steps: ConversationStep[];
+  totalSteps: number;
+  title?: string | null;
+  workspace?: string | null;
+  totalTokens?: {
+    prompt: number;
+    completion: number;
+    total: number;
+  };
   model?: string;
   provider?: string;
 }
@@ -36,14 +41,49 @@ export function getHistoryDir(): string {
   return historyDir;
 }
 
-export function saveConversation(conversation: ConversationHistory): void {
-  const historyDir = getHistoryDir();
-  const filename = `${conversation.id}.json`;
-  const filepath = join(historyDir, filename);
-
-  writeFileSync(filepath, JSON.stringify(conversation, null, 2), 'utf-8');
-}
-
+export function saveConversation(conversation: ConversationHistory): void {
+  const historyDir = getHistoryDir();
+  const filename = `${conversation.id}.json`;
+  const filepath = join(historyDir, filename);
+
+  writeFileSync(filepath, JSON.stringify(conversation, null, 2), 'utf-8');
+}
+
+export function updateConversationTitle(id: string, title: string | null): boolean {
+  const historyDir = getHistoryDir();
+  const filepath = join(historyDir, `${id}.json`);
+
+  if (!existsSync(filepath)) {
+    return false;
+  }
+
+  try {
+    const content = readFileSync(filepath, 'utf-8');
+    const data = JSON.parse(content) as ConversationHistory;
+    data.title = title;
+    writeFileSync(filepath, JSON.stringify(data, null, 2), 'utf-8');
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+export function deleteConversation(id: string): boolean {
+  const historyDir = getHistoryDir();
+  const filepath = join(historyDir, `${id}.json`);
+
+  if (!existsSync(filepath)) {
+    return false;
+  }
+
+  try {
+    unlinkSync(filepath);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
 export function loadConversations(): ConversationHistory[] {
   const historyDir = getHistoryDir();
 
@@ -51,17 +91,19 @@ export function loadConversations(): ConversationHistory[] {
     return [];
   }
 
-  const files = readdirSync(historyDir).filter(f => f.endsWith('.json'));
-  const conversations: ConversationHistory[] = [];
-
-  for (const file of files) {
-    try {
-      const content = readFileSync(join(historyDir, file), 'utf-8');
-      conversations.push(JSON.parse(content));
-    } catch (error) {
-      console.error(`Failed to load ${file}:`, error);
-    }
-  }
+  const files = readdirSync(historyDir).filter(f => f.endsWith('.json') && f !== 'inputs.json');
+  const conversations: ConversationHistory[] = [];
+
+  for (const file of files) {
+    try {
+      const content = readFileSync(join(historyDir, file), 'utf-8');
+      const parsed = JSON.parse(content) as ConversationHistory;
+      if (!parsed || !Array.isArray(parsed.steps)) continue;
+      conversations.push(parsed);
+    } catch (error) {
+      console.error(`Failed to load ${file}:`, error);
+    }
+  }
 
   return conversations.sort((a, b) => b.timestamp - a.timestamp);
 }
@@ -103,4 +145,4 @@ export function addInputToHistory(input: string): void {
 
     saveInputHistory(history);
   }
-}
+}

package/src/utils/imageBridge.ts

@@ -0,0 +1,28 @@
+import type { ImageAttachment } from "./images";
+
+export type ImageCommandEvent =
+  | { type: "add"; image: ImageAttachment }
+  | { type: "clear" }
+  | { type: "remove"; id: string };
+
+const listeners = new Set<(event: ImageCommandEvent) => void>();
+let imageSupport = false;
+
+export function subscribeImageCommand(listener: (event: ImageCommandEvent) => void): () => void {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+export function emitImageCommand(event: ImageCommandEvent): void {
+  listeners.forEach((listener) => listener(event));
+}
+
+export function setImageSupport(enabled: boolean): void {
+  imageSupport = enabled;
+}
+
+export function canUseImages(): boolean {
+  return imageSupport;
+}

package/src/utils/images.ts

@@ -0,0 +1,31 @@
+export type ImageAttachment = {
+  id: string;
+  name: string;
+  mimeType: string;
+  data: string;
+  size: number;
+};
+
+const EXT_TO_MIME: Record<string, string> = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  gif: "image/gif",
+  bmp: "image/bmp",
+  svg: "image/svg+xml",
+  tif: "image/tiff",
+  tiff: "image/tiff"
+};
+
+export function guessImageMimeType(filename: string): string {
+  const clean = filename.trim().toLowerCase();
+  const idx = clean.lastIndexOf(".");
+  if (idx === -1) return "application/octet-stream";
+  const ext = clean.slice(idx + 1);
+  return EXT_TO_MIME[ext] || "application/octet-stream";
+}
+
+export function toDataUrl(image: ImageAttachment): string {
+  return `data:${image.mimeType};base64,${image.data}`;
+}

package/src/utils/markdown.tsx

@@ -121,112 +121,176 @@ export function parseMarkdownContent(content: string): ParsedMarkdownLine[] {
   return result;
 }
 
-export function wrapMarkdownText(text: string, maxWidth: number): { text: string; segments: MarkdownSegment[] }[] {
-  if (!text || maxWidth <= 0) return [{ text: '', segments: [] }];
-
-  const segments = parseMarkdownLine(text);
-  const lines: { text: string; segments: MarkdownSegment[] }[] = [];
-  let currentLine = '';
-  let currentSegments: MarkdownSegment[] = [];
-
-  for (const segment of segments) {
-    const content = segment.content;
-    const fullText = content;
-
-    if (!currentLine) {
-      if (fullText.length <= maxWidth) {
-        currentLine = fullText;
-        currentSegments.push(segment);
-      } else {
-        let remaining = content;
-        while (remaining) {
-          if (remaining.length <= maxWidth) {
-            currentLine = remaining;
-            currentSegments.push({ ...segment, content: remaining });
-            remaining = '';
-          } else {
-            const breakPoint = remaining.lastIndexOf(' ', maxWidth);
-            if (breakPoint > 0) {
-              const chunk = remaining.slice(0, breakPoint);
-              currentLine = chunk;
-              currentSegments.push({ ...segment, content: chunk });
-              lines.push({ text: currentLine, segments: currentSegments });
-              currentLine = '';
-              currentSegments = [];
-              remaining = remaining.slice(breakPoint + 1);
-            } else {
-              const chunk = remaining.slice(0, maxWidth);
-              currentLine = chunk;
-              currentSegments.push({ ...segment, content: chunk });
-              lines.push({ text: currentLine, segments: currentSegments });
-              currentLine = '';
-              currentSegments = [];
-              remaining = remaining.slice(maxWidth);
-            }
-          }
-        }
-      }
+export function wrapMarkdownText(text: string, maxWidth: number): { text: string; segments: MarkdownSegment[] }[] {
+  if (!text || maxWidth <= 0) return [{ text: '', segments: [] }];
+
+  const segments = parseMarkdownLine(text);
+  const lines: { text: string; segments: MarkdownSegment[] }[] = [];
+  let currentLine = '';
+  let currentSegments: MarkdownSegment[] = [];
+
+  const splitSegment = (segment: MarkdownSegment): MarkdownSegment[] => {
+    if (segment.type === 'code') return [segment];
+    const parts = segment.content.match(/\s+|[^\s]+/g);
+    if (!parts) return [segment];
+    return parts.map(part => ({ ...segment, content: part }));
+  };
+
+  const pushLine = () => {
+    if (!currentLine) return;
+    lines.push({ text: currentLine, segments: currentSegments });
+    currentLine = '';
+    currentSegments = [];
+  };
+
+  const addPiece = (piece: MarkdownSegment) => {
+    let remaining = piece.content;
+    while (remaining.length > 0) {
+      if (!currentLine) {
+        if (remaining.trim() === '') {
+          return;
+        }
+        if (remaining.length <= maxWidth) {
+          currentLine = remaining;
+          currentSegments = [{ ...piece, content: remaining }];
+          return;
+        }
+        const chunk = remaining.slice(0, maxWidth);
+        lines.push({ text: chunk, segments: [{ ...piece, content: chunk }] });
+        remaining = remaining.slice(maxWidth);
+        continue;
+      }
+
+      if ((currentLine + remaining).length <= maxWidth) {
+        currentLine += remaining;
+        currentSegments.push({ ...piece, content: remaining });
+        return;
+      }
+
+      pushLine();
+    }
+  };
+
+  for (const segment of segments) {
+    const pieces = splitSegment(segment);
+    for (const piece of pieces) {
+      addPiece(piece);
+    }
+  }
+
+  if (currentLine) {
+    lines.push({ text: currentLine, segments: currentSegments });
+  }
+
+  return lines.length > 0 ? lines : [{ text: '', segments: [] }];
+}
+
+export interface WrappedMarkdownBlock {
+  type: 'line' | 'code';
+  wrappedLines?: { text: string; segments: MarkdownSegment[] }[];
+  codeLines?: string[];
+  language?: string;
+}
+
+function wrapCodeLine(line: string, maxWidth: number): string[] {
+  if (!line) return [''];
+  if (maxWidth <= 0) return [line];
+  if (line.length <= maxWidth) return [line];
+
+  const chunks: string[] = [];
+  let i = 0;
+  while (i < line.length) {
+    chunks.push(line.slice(i, i + maxWidth));
+    i += maxWidth;
+  }
+  return chunks;
+}
+
+function reflowParagraphs(text: string): string {
+  const rawLines = text.split('\n');
+  const result: string[] = [];
+  let inCodeBlock = false;
+
+  for (let i = 0; i < rawLines.length; i++) {
+    const line = rawLines[i]!;
+
+    if (/^```/.test(line)) {
+      inCodeBlock = !inCodeBlock;
+      result.push(line);
+      continue;
+    }
+
+    if (inCodeBlock) {
+      result.push(line);
+      continue;
+    }
+
+    if (line.trim() === '') {
+      result.push(line);
+      continue;
+    }
+
+    if (/^#{1,6}\s/.test(line) || /^[-*+]\s/.test(line) || /^\d+\.\s/.test(line)) {
+      result.push(line);
+      continue;
+    }
+
+    const prev = result.length > 0 ? result[result.length - 1]! : '';
+    const prevIsText = prev.trim() !== '' &&
+      !/^```/.test(prev) &&
+      !/^#{1,6}\s/.test(prev) &&
+      !/^[-*+]\s/.test(prev) &&
+      !/^\d+\.\s/.test(prev);
+
+    if (prevIsText) {
+      result[result.length - 1] = prev + ' ' + line;
     } else {
-      const needsSpace = !currentLine.endsWith(' ') && !fullText.startsWith(' ');
-      const separator = needsSpace ? ' ' : '';
+      result.push(line);
+    }
+  }
 
-      if ((currentLine + separator + fullText).length <= maxWidth) {
-        currentLine += separator + fullText;
-        currentSegments.push(segment);
+  return result.join('\n');
+}
+
+export function parseAndWrapMarkdown(text: string, maxWidth: number): WrappedMarkdownBlock[] {
+  const lines = reflowParagraphs(text).split('\n');
+  const blocks: WrappedMarkdownBlock[] = [];
+  let inCodeBlock = false;
+  let codeLines: string[] = [];
+  let language: string | undefined;
+
+  for (const line of lines) {
+    const fenceMatch = line.match(/^```([A-Za-z0-9_-]+)?\s*$/);
+    if (fenceMatch) {
+      if (!inCodeBlock) {
+        inCodeBlock = true;
+        language = fenceMatch[1];
+        codeLines = [];
       } else {
-        lines.push({ text: currentLine, segments: currentSegments });
-        currentLine = fullText;
-        currentSegments = [segment];
-
-        if (fullText.length > maxWidth) {
-          let remaining = content;
-          while (remaining) {
-            if (remaining.length <= maxWidth) {
-              currentLine = remaining;
-              currentSegments = [{ ...segment, content: remaining }];
-              remaining = '';
-            } else {
-              const breakPoint = remaining.lastIndexOf(' ', maxWidth);
-              if (breakPoint > 0) {
-                const chunk = remaining.slice(0, breakPoint);
-                currentLine = chunk;
-                currentSegments = [{ ...segment, content: chunk }];
-                lines.push({ text: currentLine, segments: currentSegments });
-                currentLine = '';
-                currentSegments = [];
-                remaining = remaining.slice(breakPoint + 1);
-              } else {
-                const chunk = remaining.slice(0, maxWidth);
-                currentLine = chunk;
-                currentSegments = [{ ...segment, content: chunk }];
-                lines.push({ text: currentLine, segments: currentSegments });
-                currentLine = '';
-                currentSegments = [];
-                remaining = remaining.slice(maxWidth);
-              }
-            }
-          }
-        }
+        const wrapped = codeLines.flatMap(codeLine => wrapCodeLine(codeLine, maxWidth));
+        blocks.push({ type: 'code', codeLines: wrapped, language });
+        inCodeBlock = false;
+        codeLines = [];
+        language = undefined;
       }
+      continue;
+    }
+
+    if (inCodeBlock) {
+      codeLines.push(line);
+      continue;
     }
-  }
 
-  if (currentLine) {
-    lines.push({ text: currentLine, segments: currentSegments });
+    blocks.push({
+      type: 'line',
+      wrappedLines: wrapMarkdownText(line, maxWidth)
+    });
   }
 
-  return lines.length > 0 ? lines : [{ text: '', segments: [] }];
-}
+  if (inCodeBlock) {
+    const wrapped = codeLines.flatMap(codeLine => wrapCodeLine(codeLine, maxWidth));
+    blocks.push({ type: 'code', codeLines: wrapped, language });
+  }
 
-export interface WrappedMarkdownBlock {
-  type: 'line';
-  wrappedLines?: { text: string; segments: MarkdownSegment[] }[];
+  return blocks;
 }
-
-export function parseAndWrapMarkdown(text: string, maxWidth: number): WrappedMarkdownBlock[] {
-  const lines = text.split('\n');
-  return lines.map((line) => ({
-    type: 'line',
-    wrappedLines: wrapMarkdownText(line, maxWidth)
-  }));
-}

package/src/utils/models.ts

@@ -152,23 +152,16 @@ export class ModelsDevClient {
 
     async getModelById(modelId: ModelsDevModelId, options: { refresh?: boolean } = {}): Promise<ModelsDevSearchResult | null> {
         const data = await this.getAll(options);
-        // Try exact match first
         for (const provider of Object.values(data)) {
             const model = provider.models?.[modelId];
             if (model) return { provider, model };
         }
-
-        // Try semantic/partial match
-        // e.g. gpt-5.2-2025-12-11 should match gpt-5.2 or vice versa
         const lowerSearch = modelId.toLowerCase();
 
         for (const provider of Object.values(data)) {
             const models = provider.models ?? {};
             for (const [id, model] of Object.entries(models)) {
                 const lowerId = id.toLowerCase();
-                // If the known model ID is a prefix of our search (e.g. search gpt-5.2-v1 matches model gpt-5.2)
-                // OR if our search is a prefix of the known model ID (e.g. search gpt-5.2 matches model gpt-5.2-preview)
-                // OR if one contains the other
                 if (lowerSearch.includes(lowerId) || lowerId.includes(lowerSearch)) {
                     return { provider, model };
                 }
@@ -293,12 +286,34 @@ export async function findModelsDevModelById(
     return modelsDev.getModelById(modelId, options);
 }
 
-export async function searchModelsDev(query: ModelsDevSearchQuery, options: { refresh?: boolean } = {}): Promise<ModelsDevSearchResult[]> {
-    return modelsDev.search(query, options);
-}
-
-export function modelAcceptsImages(model: ModelsDevModel): boolean {
-    if (!model.modalities) return false;
-    const { input } = model.modalities;
-    return Array.isArray(input) && input.includes("image");
-}
+export async function searchModelsDev(query: ModelsDevSearchQuery, options: { refresh?: boolean } = {}): Promise<ModelsDevSearchResult[]> {
+    return modelsDev.search(query, options);
+}
+
+export async function getModelsDevContextLimit(
+    providerId: string,
+    modelId: string,
+    options: { refresh?: boolean } = {}
+): Promise<number | null> {
+    try {
+        const direct = await getModelsDevModel(providerId, modelId, options);
+        const limit = direct?.limit?.context;
+        if (typeof limit === "number" && Number.isFinite(limit) && limit > 0) return limit;
+    } catch {
+    }
+
+    try {
+        const byId = await findModelsDevModelById(modelId, options);
+        const limit = byId?.model?.limit?.context;
+        if (typeof limit === "number" && Number.isFinite(limit) && limit > 0) return limit;
+    } catch {
+    }
+
+    return null;
+}
+
+export function modelAcceptsImages(model: ModelsDevModel): boolean {
+    if (!model.modalities) return false;
+    const { input } = model.modalities;
+    return Array.isArray(input) && input.includes("image");
+}

package/src/utils/notificationBridge.ts

@@ -0,0 +1,23 @@
+export type NotificationType = 'info' | 'success' | 'error' | 'warning'
+
+export interface NotificationPayload {
+  message: string
+  type?: NotificationType
+  duration?: number
+}
+
+type NotificationListener = (payload: NotificationPayload) => void
+
+const listeners = new Set<NotificationListener>()
+
+export function subscribeNotifications(listener: NotificationListener): () => void {
+  listeners.add(listener)
+  return () => {
+    listeners.delete(listener)
+  }
+}
+
+export function notifyNotification(message: string, type: NotificationType = 'info', duration?: number): void {
+  const payload: NotificationPayload = { message, type, duration }
+  listeners.forEach((listener) => listener(payload))
+}