@kirosnn/mosaic 0.0.7

package/src/utils/fileChangeTracker.ts

@@ -0,0 +1,98 @@
+import { notifyFileChanges } from './fileChangesBridge';
+
+export interface FileChanges {
+  linesAdded: number;
+  linesRemoved: number;
+  filesModified: number;
+}
+
+interface FileState {
+  path: string;
+  lineCount: number;
+  existed: boolean;
+}
+
+let currentChanges: FileChanges = {
+  linesAdded: 0,
+  linesRemoved: 0,
+  filesModified: 0
+};
+
+let trackedFiles: Map<string, FileState> = new Map();
+
+export function getFileChanges(): FileChanges {
+  return { ...currentChanges };
+}
+
+export function resetFileChanges(): void {
+  currentChanges = {
+    linesAdded: 0,
+    linesRemoved: 0,
+    filesModified: 0
+  };
+  trackedFiles.clear();
+  notifyFileChanges(currentChanges);
+}
+
+export function updateFileChangesFromGit(): void {
+  notifyFileChanges(currentChanges);
+}
+
+export function trackFileChange(filePath: string, oldContent: string, newContent: string): void {
+  const oldLines = oldContent.split('\n');
+  const newLines = newContent.split('\n');
+
+  const oldExisted = oldContent.length > 0;
+  const newExists = newContent.length > 0;
+
+  const tracked = trackedFiles.get(filePath);
+
+  if (tracked) {
+    currentChanges.linesAdded -= Math.max(0, tracked.lineCount);
+    currentChanges.linesRemoved -= Math.max(0, tracked.lineCount);
+  }
+
+  let added = 0;
+  let removed = 0;
+
+  if (!oldExisted && newExists) {
+    added = newLines.length;
+  } else if (oldExisted && !newExists) {
+    removed = oldLines.length;
+  } else {
+    const maxLength = Math.max(oldLines.length, newLines.length);
+    for (let i = 0; i < maxLength; i++) {
+      const oldLine = oldLines[i];
+      const newLine = newLines[i];
+
+      if (oldLine === undefined && newLine !== undefined) {
+        added++;
+      } else if (oldLine !== undefined && newLine === undefined) {
+        removed++;
+      } else if (oldLine !== newLine) {
+        added++;
+        removed++;
+      }
+    }
+  }
+
+  trackedFiles.set(filePath, {
+    path: filePath,
+    lineCount: Math.max(added, removed),
+    existed: newExists
+  });
+
+  currentChanges.linesAdded += added;
+  currentChanges.linesRemoved += removed;
+  currentChanges.filesModified = trackedFiles.size;
+
+  notifyFileChanges(currentChanges);
+}
+
+export function trackFileCreated(filePath: string, content: string): void {
+  trackFileChange(filePath, '', content);
+}
+
+export function trackFileDeleted(filePath: string, oldContent: string): void {
+  trackFileChange(filePath, oldContent, '');
+}

package/src/utils/fileChangesBridge.ts

@@ -0,0 +1,18 @@
+import type { FileChanges } from './fileChangeTracker';
+
+type FileChangesCallback = (changes: FileChanges) => void;
+
+let callback: FileChangesCallback | null = null;
+
+export function subscribeFileChanges(cb: FileChangesCallback): () => void {
+  callback = cb;
+  return () => {
+    callback = null;
+  };
+}
+
+export function notifyFileChanges(changes: FileChanges): void {
+  if (callback) {
+    callback(changes);
+  }
+}

package/src/utils/history.ts

@@ -0,0 +1,106 @@
+import { existsSync, mkdirSync, writeFileSync, readdirSync, readFileSync } 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;
+  };
+  model?: string;
+  provider?: string;
+}
+
+export function getHistoryDir(): string {
+  const configDir = join(homedir(), '.mosaic');
+  const historyDir = join(configDir, 'history');
+
+  if (!existsSync(historyDir)) {
+    mkdirSync(historyDir, { recursive: true });
+  }
+
+  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 loadConversations(): ConversationHistory[] {
+  const historyDir = getHistoryDir();
+
+  if (!existsSync(historyDir)) {
+    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);
+    }
+  }
+
+  return conversations.sort((a, b) => b.timestamp - a.timestamp);
+}
+
+export function getInputHistory(): string[] {
+  const historyDir = getHistoryDir();
+  const inputHistoryPath = join(historyDir, 'inputs.json');
+
+  if (!existsSync(inputHistoryPath)) {
+    return [];
+  }
+
+  try {
+    const content = readFileSync(inputHistoryPath, 'utf-8');
+    return JSON.parse(content);
+  } catch (error) {
+    return [];
+  }
+}
+
+export function saveInputHistory(history: string[]): void {
+  const historyDir = getHistoryDir();
+  const inputHistoryPath = join(historyDir, 'inputs.json');
+
+  writeFileSync(inputHistoryPath, JSON.stringify(history, null, 2), 'utf-8');
+}
+
+export function addInputToHistory(input: string): void {
+  if (!input.trim()) return;
+
+  const history = getInputHistory();
+
+  if (history[history.length - 1] !== input) {
+    history.push(input);
+
+    if (history.length > 100) {
+      history.shift();
+    }
+
+    saveInputHistory(history);
+  }
+}

package/src/utils/markdown.tsx

@@ -0,0 +1,232 @@
+import { TextAttributes } from "@opentui/core";
+
+export interface MarkdownSegment {
+  type: 'text' | 'bold' | 'italic' | 'code' | 'heading' | 'listitem';
+  content: string;
+  level?: number;
+}
+
+function parseInline(text: string): MarkdownSegment[] {
+  const segments: MarkdownSegment[] = [];
+
+  let i = 0;
+  let buffer = '';
+
+  const flushText = () => {
+    if (buffer) {
+      segments.push({ type: 'text', content: buffer });
+      buffer = '';
+    }
+  };
+
+  while (i < text.length) {
+    if (text[i] === '`') {
+      const j = text.indexOf('`', i + 1);
+      if (j !== -1) {
+        flushText();
+        segments.push({ type: 'code', content: text.substring(i + 1, j) });
+        i = j + 1;
+        continue;
+      }
+    }
+
+    if (text.substring(i, i + 2) === '**') {
+      const j = text.indexOf('**', i + 2);
+      if (j !== -1) {
+        flushText();
+        segments.push({ type: 'bold', content: text.substring(i + 2, j) });
+        i = j + 2;
+        continue;
+      }
+    }
+
+    if (text[i] === '*' && text.substring(i, i + 2) !== '**') {
+      const j = text.indexOf('*', i + 1);
+      if (j !== -1) {
+        flushText();
+        segments.push({ type: 'italic', content: text.substring(i + 1, j) });
+        i = j + 1;
+        continue;
+      }
+    }
+
+    buffer += text[i];
+    i++;
+  }
+
+  flushText();
+  return segments.length > 0 ? segments : [{ type: 'text', content: text }];
+}
+
+export function parseMarkdownLine(line: string): MarkdownSegment[] {
+  if (line.match(/^#{1,6}\s/)) {
+    const match = line.match(/^(#{1,6})\s+(.+)$/);
+    if (match && match[2]) {
+      return [{ type: 'heading', content: match[2], level: match[1]?.length || 1 }];
+    }
+  }
+
+  if (line.match(/^[-*+]\s/)) {
+    const content = line.replace(/^[-*+]\s+/, '');
+    return [{ type: 'text', content: '• ' }, ...parseInline(content)];
+  }
+
+  return parseInline(line);
+}
+
+export function renderMarkdownSegment(segment: MarkdownSegment, key: number) {
+  switch (segment.type) {
+    case 'bold':
+      return <text key={key} fg="white" attributes={TextAttributes.BOLD}>{segment.content}</text>;
+
+    case 'italic':
+      return <text key={key} fg="white" attributes={TextAttributes.DIM}>{segment.content}</text>;
+
+    case 'code':
+      return <text key={key} fg="#ffdd80">{`${segment.content}`}</text>;
+
+    case 'heading':
+      return <text key={key} fg="#ffca38" attributes={TextAttributes.BOLD}>{segment.content}</text>;
+
+    case 'listitem':
+      return (
+        <box key={key} flexDirection="row">
+          <text fg="#ffca38">• </text>
+          <text>{segment.content}</text>
+        </box>
+      );
+
+    case 'text':
+    default:
+      return <text key={key} fg="white">{segment.content}</text>;
+  }
+}
+
+export interface ParsedMarkdownLine {
+  segments: MarkdownSegment[];
+  rawLine: string;
+}
+
+export function parseMarkdownContent(content: string): ParsedMarkdownLine[] {
+  const lines = content.split('\n');
+  const result: ParsedMarkdownLine[] = [];
+
+  for (const line of lines) {
+    result.push({
+      segments: parseMarkdownLine(line),
+      rawLine: line
+    });
+  }
+
+  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);
+            }
+          }
+        }
+      }
+    } else {
+      const needsSpace = !currentLine.endsWith(' ') && !fullText.startsWith(' ');
+      const separator = needsSpace ? ' ' : '';
+
+      if ((currentLine + separator + fullText).length <= maxWidth) {
+        currentLine += separator + fullText;
+        currentSegments.push(segment);
+      } 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);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  if (currentLine) {
+    lines.push({ text: currentLine, segments: currentSegments });
+  }
+
+  return lines.length > 0 ? lines : [{ text: '', segments: [] }];
+}
+
+export interface WrappedMarkdownBlock {
+  type: 'line';
+  wrappedLines?: { text: string; segments: MarkdownSegment[] }[];
+}
+
+export function parseAndWrapMarkdown(text: string, maxWidth: number): WrappedMarkdownBlock[] {
+  const lines = text.split('\n');
+  return lines.map((line) => ({
+    type: 'line',
+    wrappedLines: wrapMarkdownText(line, maxWidth)
+  }));
+}