@kirosnn/mosaic 0.0.7

package/src/utils/config.ts

@@ -0,0 +1,357 @@
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { VERSION } from './version';
+
+const CONFIG_DIR = join(homedir(), '.mosaic');
+const CONFIG_FILE = join(CONFIG_DIR, 'mosaic.jsonc');
+
+export interface AIProvider {
+  id: string;
+  name: string;
+  description: string;
+  models: AIModel[];
+  requiresApiKey: boolean;
+}
+
+export interface AIModel {
+  id: string;
+  name: string;
+  description: string;
+  requiresApiKey?: boolean;
+}
+
+export interface CustomProvider extends AIProvider {
+  baseUrl?: string;
+  isCustom: true;
+}
+
+export interface RecentProject {
+  path: string;
+  lastOpened: number;
+}
+
+export interface MosaicConfig {
+  firstRun: boolean;
+  version: string;
+  provider?: string;
+  model?: string;
+  apiKey?: string;
+  systemPrompt?: string;
+  customProviders?: CustomProvider[];
+  customModels?: { [providerId: string]: AIModel[] };
+  requireApprovals?: boolean;
+  recentProjects?: RecentProject[];
+}
+
+export const AI_PROVIDERS: AIProvider[] = [
+  {
+    id: 'openai',
+    name: 'OpenAI',
+    description: 'GPT models from OpenAI',
+    requiresApiKey: true,
+    models: [
+      { id: 'gpt-5.2-2025-12-11', name: 'GPT-5.2', description: 'The best model for coding and agentic tasks across industries' },
+      { id: 'gpt-5.1-2025-11-13', name: 'GPT-5.1', description: 'The best model for coding and agentic tasks with configurable reasoning effort' },
+      { id: 'gpt-5-2025-08-07', name: 'GPT-5', description: 'The first model GPT 5 series from OpenAI' },
+      { id: 'gpt-4.1-2025-04-14', name: 'GPT-4.1', description: 'Smartest non-reasoning model from OpenAI' },
+    ]
+  },
+  {
+    id: 'anthropic',
+    name: 'Anthropic',
+    description: 'Claude models with extended context windows',
+    requiresApiKey: true,
+    models: [
+      { id: 'claude-opus-4-5', name: 'Claude Opus 4.5', description: 'Most capable Claude model' },
+      { id: 'claude-sonnet-4-5', name: 'Claude Sonnet 4.5', description: 'Balanced performance and speed' },
+      { id: 'claude-sonnet-4', name: 'Claude Sonnet 4', description: 'Previous Sonnet model' },
+      { id: 'claude-haiku-4-5', name: 'Claude Haiku 4.5', description: 'Fastest Claude model' },
+    ]
+  },
+  {
+    id: 'mistral',
+    name: 'Mistral',
+    description: 'Mistral AI is a French company that develops open and efficient artificial intelligence models for various applications',
+    requiresApiKey: true,
+    models: [
+      { id: 'mistral-large-latest', name: 'Mistral Large 3', description: 'Mistral Large 3, is a state-of-the-art, open-weight, general-purpose multimodal model' },
+      { id: 'devstral-medium-latest', name: 'Devstral 2', description: 'Frontier code agents model for solving software engineering tasks' },
+      { id: 'mistral-medium-latest', name: 'Mistral Medium 3.1', description: 'Frontier-class multimodal model' },
+    ]
+  },
+  {
+    id: 'xai',
+    name: 'xAI',
+    description: 'xAI is an AI company focused on creating AI for understanding the universe',
+    requiresApiKey: true,
+    models: [
+      { id: 'grok-4-1-fast-reasoning', name: 'Grok 4.1 Fast Reasoning', description: 'A frontier multimodal model optimized specifically for high-performance agentic tool calling' },
+      { id: 'grok-4-fast-reasoning', name: 'Grok 4 Fast Reasoning', description: 'Advancement in cost-efficient reasoning models.' },
+      { id: 'grok-code-fast-1', name: 'Grok Code Fast 1', description: 'Optimized model for coding, programming, and software development tasks' },
+    ]
+  },
+  {
+    id: 'google',
+    name: 'Google',
+    description: 'Introducing Google would almost be insulting',
+    requiresApiKey: true,
+    models: [
+      { id: 'gemini-3-pro-preview', name: 'Gemini 3 Pro Preview', description: 'The first model in the new series, is ideal for complex tasks that require extensive world knowledge and advanced reasoning in multiple modalities' },
+      { id: 'gemini-3-flash-preview', name: 'Gemini 3 Flash Preview', description: 'Latest model in the 3 series. It offers Pro-level intelligence at the speed and price of Flash' },
+      { id: 'gemini-2.5-pro', name: 'Gemini 2.5 Pro', description: 'A versatile, cutting-edge model that excels in complex coding and reasoning tasks' },
+    ]
+  },
+  {
+    id: 'ollama',
+    name: 'Ollama',
+    description: 'Run models locally on your machine',
+    requiresApiKey: false,
+    models: [
+      { id: 'gpt-oss:120b', name: 'GPT OSS 120b', description: 'Best OSS reasoning model (and only one) OpenAI created' },
+      { id: 'glm-4.7:cloud', name: 'GLM 4.7 Cloud', description: 'Advancing the coding capability, from zAI', requiresApiKey: true },
+      { id: 'devstral-2:123b-cloud', name: 'Devstral 2 Cloud', description: 'Devstral is an agentic LLM for software engineering tasks, from Mistral', requiresApiKey: true },
+    ]
+  },
+  {
+    id: 'openrouter',
+    name: 'OpenRouter',
+    description: 'Access to various AI models through a unified API',
+    requiresApiKey: true,
+    models: [
+      { id: 'anthropic/claude-sonnet-4.5', name: 'Claude Sonnet 4.5', description: 'Most capable Claude model' },
+      { id: 'x-ai/grok-code-fast-1', name: 'Grok Code Fast 1', description: 'Grok Code Fast 1 is a speedy and economical reasoning model that excels at agentic coding.' },
+      { id: 'anthropic/claude-opus-4.5', name: 'Claude 3', description: 'Most capable Claude model' },
+    ]
+  }
+];
+
+export function ensureConfigDir(): void {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+export function isFirstRun(): boolean {
+  ensureConfigDir();
+
+  if (!existsSync(CONFIG_FILE)) {
+    return true;
+  }
+
+  try {
+    const config = readConfig();
+    return config.firstRun !== false;
+  } catch {
+    return true;
+  }
+}
+
+export function readConfig(): MosaicConfig {
+  if (!existsSync(CONFIG_FILE)) {
+    return {
+      firstRun: true,
+      version: VERSION,
+      requireApprovals: true
+    };
+  }
+
+  try {
+    const content = readFileSync(CONFIG_FILE, 'utf-8');
+    const config = JSON.parse(content);
+
+    if (config.requireApprovals === undefined) {
+      config.requireApprovals = true;
+    }
+
+    return config;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      console.warn('Config file is corrupted. Resetting to default.');
+      try {
+        const { renameSync } = require('fs');
+        renameSync(CONFIG_FILE, `${CONFIG_FILE}.bak`);
+      } catch { }
+    }
+    return {
+      firstRun: true,
+      version: VERSION,
+      requireApprovals: true
+    };
+  }
+}
+
+export function writeConfig(config: MosaicConfig): void {
+  ensureConfigDir();
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+}
+
+export function markFirstRunComplete(provider: string, model: string, apiKey?: string): void {
+  const config = readConfig();
+  config.firstRun = false;
+  config.provider = provider;
+  config.model = model;
+  config.apiKey = apiKey;
+  writeConfig(config);
+}
+
+export function getConfigDir(): string {
+  return CONFIG_DIR;
+}
+
+export function getAllProviders(): AIProvider[] {
+  const config = readConfig();
+  const customProviders = config.customProviders || [];
+  const customModels = config.customModels || {};
+
+  const providersWithCustomModels = AI_PROVIDERS.map(provider => {
+    const customModelsForProvider = customModels[provider.id] || [];
+    if (customModelsForProvider.length > 0) {
+      return {
+        ...provider,
+        models: [...provider.models, ...customModelsForProvider]
+      };
+    }
+    return provider;
+  });
+
+  return [...providersWithCustomModels, ...customProviders];
+}
+
+export function getProviderById(id: string): AIProvider | undefined {
+  return getAllProviders().find(p => p.id === id);
+}
+
+export function getModelById(providerId: string, modelId: string): AIModel | undefined {
+  const provider = getProviderById(providerId);
+  return provider?.models.find(m => m.id === modelId);
+}
+
+export function modelRequiresApiKey(providerId: string, modelId: string): boolean {
+  const provider = getProviderById(providerId);
+  const model = getModelById(providerId, modelId);
+
+  if (model?.requiresApiKey !== undefined) {
+    return model.requiresApiKey === true;
+  }
+
+  return provider?.requiresApiKey === true;
+}
+
+export function addCustomProvider(provider: CustomProvider): void {
+  const config = readConfig();
+  if (!config.customProviders) {
+    config.customProviders = [];
+  }
+  config.customProviders.push(provider);
+  writeConfig(config);
+}
+
+export function removeCustomProvider(id: string): void {
+  const config = readConfig();
+  if (config.customProviders) {
+    config.customProviders = config.customProviders.filter(p => p.id !== id);
+    writeConfig(config);
+  }
+}
+
+export function updateCustomProvider(id: string, updates: Partial<CustomProvider>): void {
+  const config = readConfig();
+  if (config.customProviders) {
+    const index = config.customProviders.findIndex(p => p.id === id);
+    if (index !== -1) {
+      config.customProviders[index] = { ...config.customProviders[index]!, ...updates };
+      writeConfig(config);
+    }
+  }
+}
+
+export function addCustomModel(providerId: string, model: AIModel): void {
+  const config = readConfig();
+  if (!config.customModels) {
+    config.customModels = {};
+  }
+  if (!config.customModels[providerId]) {
+    config.customModels[providerId] = [];
+  }
+  config.customModels[providerId].push(model);
+  writeConfig(config);
+}
+
+export function removeCustomModel(providerId: string, modelId: string): void {
+  const config = readConfig();
+  if (config.customModels && config.customModels[providerId]) {
+    config.customModels[providerId] = config.customModels[providerId].filter(m => m.id !== modelId);
+    writeConfig(config);
+  }
+}
+
+export function getCustomModels(providerId: string): AIModel[] {
+  const config = readConfig();
+  return config.customModels?.[providerId] || [];
+}
+
+export function updateSystemPrompt(systemPrompt: string): void {
+  const config = readConfig();
+  config.systemPrompt = systemPrompt;
+  writeConfig(config);
+}
+
+export function getSystemPrompt(): string | undefined {
+  const config = readConfig();
+  return config.systemPrompt;
+}
+
+export function shouldRequireApprovals(): boolean {
+  const config = readConfig();
+  return config.requireApprovals !== false;
+}
+
+export function setRequireApprovals(require: boolean): void {
+  const config = readConfig();
+  config.requireApprovals = require;
+  writeConfig(config);
+}
+
+const MAX_RECENT_PROJECTS = 10;
+
+export function getRecentProjects(): RecentProject[] {
+  const config = readConfig();
+  return config.recentProjects || [];
+}
+
+export function addRecentProject(projectPath: string): void {
+  const config = readConfig();
+  const recentProjects = config.recentProjects || [];
+
+  const existingIndex = recentProjects.findIndex(p => p.path === projectPath);
+  if (existingIndex !== -1) {
+    recentProjects.splice(existingIndex, 1);
+  }
+
+  recentProjects.unshift({
+    path: projectPath,
+    lastOpened: Date.now()
+  });
+
+  if (recentProjects.length > MAX_RECENT_PROJECTS) {
+    recentProjects.pop();
+  }
+
+  config.recentProjects = recentProjects;
+  writeConfig(config);
+}
+
+export function removeRecentProject(projectPath: string): void {
+  const config = readConfig();
+  if (config.recentProjects) {
+    config.recentProjects = config.recentProjects.filter(p => p.path !== projectPath);
+    writeConfig(config);
+  }
+}
+
+export function clearRecentProjects(): void {
+  const config = readConfig();
+  config.recentProjects = [];
+  writeConfig(config);
+}

package/src/utils/diff.ts

@@ -0,0 +1,201 @@
+export interface DiffLine {
+  type: 'added' | 'removed' | 'unchanged';
+  lineNumber: number | null;
+  content: string;
+}
+
+export interface DiffResult {
+  lines: DiffLine[];
+  hasChanges: boolean;
+}
+
+function computeLCS(a: string[], b: string[]): number[][] {
+  const m = a.length;
+  const n = b.length;
+  const dp: number[][] = Array(m + 1).fill(0).map(() => Array(n + 1).fill(0));
+
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (a[i - 1] === b[j - 1]) {
+        dp[i]![j] = (dp[i - 1]?.[j - 1] ?? 0) + 1;
+      } else {
+        dp[i]![j] = Math.max(dp[i - 1]?.[j] ?? 0, dp[i]?.[j - 1] ?? 0);
+      }
+    }
+  }
+
+  return dp;
+}
+
+function backtrackLCS(
+  a: string[],
+  b: string[],
+  dp: number[][],
+  i: number,
+  j: number,
+  result: DiffLine[]
+): void {
+  if (i === 0 && j === 0) return;
+
+  if (i > 0 && j > 0 && a[i - 1] === b[j - 1]) {
+    backtrackLCS(a, b, dp, i - 1, j - 1, result);
+    result.push({
+      type: 'unchanged',
+      lineNumber: i,
+      content: a[i - 1] ?? '',
+    });
+  } else if (j > 0 && (i === 0 || (dp[i]?.[j - 1] ?? 0) >= (dp[i - 1]?.[j] ?? 0))) {
+    backtrackLCS(a, b, dp, i, j - 1, result);
+    result.push({
+      type: 'added',
+      lineNumber: null,
+      content: b[j - 1] ?? '',
+    });
+  } else if (i > 0) {
+    backtrackLCS(a, b, dp, i - 1, j, result);
+    result.push({
+      type: 'removed',
+      lineNumber: i,
+      content: a[i - 1] ?? '',
+    });
+  }
+}
+
+export function generateDiff(oldContent: string, newContent: string): DiffResult {
+  const oldLines = oldContent === '' ? [] : oldContent.split('\n');
+  const newLines = newContent === '' ? [] : newContent.split('\n');
+
+  const dp = computeLCS(oldLines, newLines);
+  const diffLines: DiffLine[] = [];
+
+  backtrackLCS(oldLines, newLines, dp, oldLines.length, newLines.length, diffLines);
+
+  const hasChanges = diffLines.some(line => line.type !== 'unchanged');
+
+  return {
+    lines: diffLines,
+    hasChanges,
+  };
+}
+
+export function formatDiffForDisplay(diff: DiffResult, maxLines = 0): string[] {
+  const result: string[] = [];
+  let addedLineNumber = 1;
+  let removedLineNumber = 1;
+
+  for (const line of diff.lines) {
+    if (maxLines > 0 && result.length >= maxLines) {
+      const remaining = diff.lines.length - result.length;
+      if (remaining > 0) {
+        result.push(`... (${remaining} more lines)`);
+      }
+      break;
+    }
+
+    switch (line.type) {
+      case 'added':
+        result.push(`+${String(addedLineNumber).padStart(4)} | ${line.content}`);
+        addedLineNumber++;
+        break;
+      case 'removed':
+        result.push(`-${String(removedLineNumber).padStart(4)} | ${line.content}`);
+        removedLineNumber++;
+        break;
+      case 'unchanged':
+        addedLineNumber++;
+        removedLineNumber++;
+        break;
+    }
+  }
+
+  return result;
+}
+
+export function formatWriteToolResult(result: unknown, isAppend: boolean): string[] {
+  if (isAppend) return ['Appended'];
+
+  if (result && typeof result === 'object') {
+    const obj = result as Record<string, unknown>;
+    const diff = obj.diff;
+    if (Array.isArray(diff)) {
+      if (diff.length === 0) return ['No changes'];
+      const maxLines = 10;
+      if (diff.length > maxLines) {
+        const visibleDiff = diff.slice(0, maxLines);
+        const remaining = diff.length - maxLines;
+        return [...visibleDiff, `(${remaining} more lines)`];
+      }
+      return diff as string[];
+    }
+  }
+
+  const resultStr = typeof result === 'string' ? result : '';
+  const lineCount = resultStr ? resultStr.split('\n').length : 0;
+  return lineCount > 0 ? [`Wrote ${lineCount} lines`] : ['Done'];
+}
+
+export function formatEditToolResult(result: unknown): string[] {
+  if (result && typeof result === 'object') {
+    const obj = result as Record<string, unknown>;
+    const diff = obj.diff;
+    if (Array.isArray(diff)) {
+      if (diff.length === 0) return ['No changes'];
+      return diff as string[];
+    }
+  }
+
+  const resultStr = typeof result === 'string' ? result : '';
+  const lineCount = resultStr ? resultStr.split('\n').length : 0;
+  return lineCount > 0 ? [`Edited ${lineCount} lines`] : ['Edited'];
+}
+
+export interface ParsedDiffLine {
+  isDiffLine: boolean;
+  prefix?: '+' | '-';
+  lineNumber?: string;
+  content?: string;
+  isAdded: boolean;
+  isRemoved: boolean;
+}
+
+export function parseDiffLine(line: string): ParsedDiffLine {
+  const match = line.match(/^([+-])\s*(\d+)\s*\|?\s*(.*)$/);
+
+  if (!match) {
+    return {
+      isDiffLine: false,
+      isAdded: false,
+      isRemoved: false,
+    };
+  }
+
+  const [, prefix, lineNum, content] = match;
+  const isAdded = prefix === '+';
+  const isRemoved = prefix === '-';
+
+  return {
+    isDiffLine: true,
+    prefix: prefix as '+' | '-',
+    lineNumber: lineNum,
+    content,
+    isAdded,
+    isRemoved,
+  };
+}
+
+export function getDiffLineColors(parsed: ParsedDiffLine): {
+  labelBackground: string;
+  contentBackground: string;
+} {
+  if (!parsed.isDiffLine) {
+    return {
+      labelBackground: 'transparent',
+      contentBackground: 'transparent',
+    };
+  }
+
+  return {
+    labelBackground: parsed.isAdded ? '#0d2b0d' : parsed.isRemoved ? '#2b0d0d' : 'transparent',
+    contentBackground: parsed.isAdded ? '#1a3a1a' : parsed.isRemoved ? '#3a1a1a' : 'transparent',
+  };
+}

package/src/utils/diffRendering.tsx

@@ -0,0 +1,62 @@
+import { TextAttributes } from '@opentui/core';
+import { parseDiffLine, getDiffLineColors } from './diff';
+
+export function renderDiffLine(line: string, key: string) {
+  const parsed = parseDiffLine(line);
+
+  if (parsed.isDiffLine) {
+    const colors = getDiffLineColors(parsed);
+
+    return (
+      <box key={key} flexDirection="row">
+        <box backgroundColor={colors.labelBackground}>
+          <text fg="#ffffff">
+            {" "}{parsed.prefix}{parsed.lineNumber?.padStart(5) || ''}{' '}
+          </text>
+        </box>
+        <box flexGrow={1} backgroundColor={colors.contentBackground}>
+          <text fg="#ffffff">
+            {" "}{parsed.content || ''}
+          </text>
+        </box>
+      </box>
+    );
+  }
+
+  return (
+    <text key={key} fg="#ffffff">
+      {line || ' '}
+    </text>
+  );
+}
+
+export function renderInlineDiffLine(content: string) {
+  const parsed = parseDiffLine(content);
+
+  if (parsed.isDiffLine) {
+    const colors = getDiffLineColors(parsed);
+
+    return (
+      <>
+        <box>
+          <text fg="#ffffff">
+            {parsed.prefix}{parsed.lineNumber?.padStart(5) || ''}{' '}
+          </text>
+        </box>
+        <box backgroundColor={colors.contentBackground}>
+          <text fg="#ffffff">
+            {" "}{parsed.content || ''}
+          </text>
+        </box>
+      </>
+    );
+  }
+
+  return null;
+}
+
+export function getDiffLineBackground(content: string): string | null {
+  const parsed = parseDiffLine(content);
+  const colors = getDiffLineColors(parsed);
+  return colors.contentBackground !== 'transparent' ? colors.contentBackground : null;
+}

package/src/utils/exploreBridge.ts

@@ -0,0 +1,87 @@
+type ExploreToolCallback = (toolName: string, args: Record<string, unknown>, result: { success: boolean; preview: string }, tokenEstimate: number) => void;
+
+export interface ExploreToolEvent {
+  toolName: string;
+  args: Record<string, unknown>;
+  success: boolean;
+  preview: string;
+  tokenEstimate: number;
+}
+
+type ExploreToolSubscriber = (event: ExploreToolEvent) => void;
+
+interface ExploreBridgeGlobal {
+  currentAbortController: AbortController | null;
+  toolCallback: ExploreToolCallback | null;
+  totalExploreTokens: number;
+  subscribers: Set<ExploreToolSubscriber>;
+}
+
+const globalKey = '__mosaic_explore_bridge__';
+const g = globalThis as any;
+
+if (!g[globalKey]) {
+  g[globalKey] = {
+    currentAbortController: null,
+    toolCallback: null,
+    totalExploreTokens: 0,
+    subscribers: new Set<ExploreToolSubscriber>(),
+  };
+}
+
+const state: ExploreBridgeGlobal = g[globalKey];
+
+export function setExploreAbortController(controller: AbortController | null): void {
+  state.currentAbortController = controller;
+  if (controller) {
+    state.totalExploreTokens = 0;
+  }
+}
+
+export function getExploreAbortSignal(): AbortSignal | undefined {
+  return state.currentAbortController?.signal;
+}
+
+export function abortExplore(): void {
+  state.currentAbortController?.abort();
+}
+
+export function isExploreAborted(): boolean {
+  return state.currentAbortController?.signal.aborted ?? false;
+}
+
+export function setExploreToolCallback(callback: ExploreToolCallback | null): void {
+  state.toolCallback = callback;
+}
+
+export function notifyExploreTool(toolName: string, args: Record<string, unknown>, result: { success: boolean; preview: string }, resultLength: number): void {
+  const tokenEstimate = Math.ceil(resultLength / 4);
+  state.totalExploreTokens += tokenEstimate;
+  state.toolCallback?.(toolName, args, result, state.totalExploreTokens);
+
+  const event: ExploreToolEvent = {
+    toolName,
+    args,
+    success: result.success,
+    preview: result.preview,
+    tokenEstimate: state.totalExploreTokens,
+  };
+  console.log(`[EXPLORE BRIDGE] notify: ${toolName}, subs=${state.subscribers.size}`);
+  state.subscribers.forEach(sub => {
+    console.log(`[EXPLORE BRIDGE] calling subscriber`);
+    sub(event);
+  });
+}
+
+export function subscribeExploreTool(callback: ExploreToolSubscriber): () => void {
+  state.subscribers.add(callback);
+  console.log(`[EXPLORE BRIDGE] subscribe: now ${state.subscribers.size} subscribers`);
+  return () => {
+    state.subscribers.delete(callback);
+    console.log(`[EXPLORE BRIDGE] unsubscribe: now ${state.subscribers.size} subscribers`);
+  };
+}
+
+export function getExploreTokens(): number {
+  return state.totalExploreTokens;
+}