@kirosnn/mosaic 0.0.9 → 0.71.0

package/src/utils/commands/approvals.ts

@@ -0,0 +1,48 @@
+import type { Command } from './types'
+import { getCurrentApproval, respondApproval } from '../approvalBridge'
+import { shouldRequireApprovals, setRequireApprovals } from '../config'
+import { notifyNotification } from '../notificationBridge'
+import { emitApprovalMode } from '../approvalModeBridge'
+
+export const approvalsCommand: Command = {
+  name: 'approvals',
+  description: 'Toggle approval prompts for agent changes',
+  usage: '/approvals on|off|toggle|status',
+  aliases: ['approval', 'autoapprove', 'auto-approve'],
+  execute: (args: string[]) => {
+    const raw = args[0]?.toLowerCase()
+    const current = shouldRequireApprovals()
+    let next = current
+
+    if (!raw || raw === 'toggle') {
+      next = !current
+    } else if (raw === 'on' || raw === 'true' || raw === 'yes') {
+      next = true
+    } else if (raw === 'off' || raw === 'false' || raw === 'no') {
+      next = false
+    } else if (raw === 'status') {
+      return {
+        success: true,
+        content: current ? 'Approvals are enabled.' : 'Auto-approve is enabled.'
+      }
+    } else {
+      return {
+        success: false,
+        content: 'Usage: /approvals on|off|toggle|status'
+      }
+    }
+
+    setRequireApprovals(next)
+    if (!next && getCurrentApproval()) {
+      respondApproval(true)
+    }
+    emitApprovalMode(next)
+
+    notifyNotification(next ? 'Approvals enabled.' : 'Auto-approve enabled.', 'info', 2500)
+
+    return {
+      success: true,
+      content: next ? 'Approvals enabled.' : 'Auto-approve enabled.'
+    }
+  }
+}

package/src/utils/commands/image.ts

@@ -0,0 +1,109 @@
+import { existsSync, readFileSync, statSync } from "fs";
+import { basename } from "path";
+import type { Command } from "./types";
+import { guessImageMimeType } from "../images";
+import { emitImageCommand, canUseImages } from "../imageBridge";
+
+const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+
+function parseImagePath(fullCommand: string): string {
+  const trimmed = fullCommand.trim();
+  const without = trimmed.replace(/^\/(image|img)\s+/i, "");
+  return without.trim();
+}
+
+export const imageCommand: Command = {
+  name: "image",
+  description: "Attach an image for the next message",
+  usage: "/image <path> | /image clear",
+  aliases: ["img"],
+  execute: (args, fullCommand) => {
+    const first = args[0]?.toLowerCase();
+    if (!first) {
+      return {
+        success: false,
+        content: "Usage: /image <path> | /image clear",
+        shouldAddToHistory: false
+      };
+    }
+
+    if (first === "clear") {
+      emitImageCommand({ type: "clear" });
+      return {
+        success: true,
+        content: "Image list cleared.",
+        shouldAddToHistory: false
+      };
+    }
+
+    if (!canUseImages()) {
+      return {
+        success: false,
+        content: "Images are not supported by the current model.",
+        shouldAddToHistory: false
+      };
+    }
+
+    const path = parseImagePath(fullCommand);
+    if (!path) {
+      return {
+        success: false,
+        content: "Missing image path.",
+        shouldAddToHistory: false
+      };
+    }
+
+    if (!existsSync(path)) {
+      return {
+        success: false,
+        content: "File not found.",
+        shouldAddToHistory: false
+      };
+    }
+
+    const stat = statSync(path);
+    if (!stat.isFile()) {
+      return {
+        success: false,
+        content: "Not a file.",
+        shouldAddToHistory: false
+      };
+    }
+
+    if (stat.size > MAX_IMAGE_BYTES) {
+      return {
+        success: false,
+        content: "Image too large (max 10 MB).",
+        shouldAddToHistory: false
+      };
+    }
+
+    const name = basename(path);
+    const mimeType = guessImageMimeType(name);
+    if (!mimeType.startsWith("image/")) {
+      return {
+        success: false,
+        content: "Unsupported image type.",
+        shouldAddToHistory: false
+      };
+    }
+
+    const data = readFileSync(path).toString("base64");
+    emitImageCommand({
+      type: "add",
+      image: {
+        id: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        name,
+        mimeType,
+        data,
+        size: stat.size
+      }
+    });
+
+    return {
+      success: true,
+      content: `Image attached: ${name}`,
+      shouldAddToHistory: false
+    };
+  }
+};

package/src/utils/commands/index.ts

@@ -7,6 +7,8 @@ import { undoCommand } from './undo';
 import { redoCommand } from './redo';
 import { sessionsCommand } from './sessions';
 import { webCommand } from './web';
+import { imageCommand } from './image';
+import { approvalsCommand } from './approvals';
 
 export { commandRegistry } from './registry';
 export type { Command, CommandResult, CommandRegistry } from './types';
@@ -65,4 +67,6 @@ export function initializeCommands(): void {
   commandRegistry.register(redoCommand);
   commandRegistry.register(sessionsCommand);
   commandRegistry.register(webCommand);
-}
+  commandRegistry.register(imageCommand);
+  commandRegistry.register(approvalsCommand);
+}

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,28 @@ 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);
+  const colors = getDiffLineColors(parsed);
 
   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>
@@ -56,7 +57,5 @@ export function renderInlineDiffLine(content: string) {
 }
 
 export function getDiffLineBackground(content: string): string | null {
-  const parsed = parseDiffLine(content);
-  const colors = getDiffLineColors(parsed);
-  return colors.contentBackground !== 'transparent' ? colors.contentBackground : null;
+  return null;
 }

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/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 };
                 }

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))
+}