@kirosnn/mosaic 0.71.0 → 0.73.0

package/src/utils/commands/redo.ts

@@ -1,74 +0,0 @@
-import type { Command, CommandResult } from './types';
-import { redo, canRedo, isGitRepository } from '../undoRedo';
-import { notifyUndoRedo } from '../undoRedoBridge';
-
-export const redoCommand: Command = {
-  name: 'redo',
-  description: 'Redo a previously undone message. Only available after using /undo. Any file changes will also be restored. Internally, this uses Git to manage the file changes if available.',
-  usage: '/redo',
-  aliases: ['r'],
-  execute: async (): Promise<CommandResult> => {
-    if (!canRedo()) {
-      return {
-        success: false,
-        content: 'Nothing to redo. Use /undo first, or the redo stack is empty.',
-        shouldAddToHistory: false
-      };
-    }
-
-    const result = redo();
-    if (!result) {
-      return {
-        success: false,
-        content: 'Failed to redo. Could not retrieve state.',
-        shouldAddToHistory: false
-      };
-    }
-
-    if (!result.success) {
-      return {
-        success: false,
-        content: `Failed to redo file changes:\n${result.error || 'Unknown error'}`,
-        shouldAddToHistory: false
-      };
-    }
-
-    notifyUndoRedo(result.state, 'redo');
-
-    const messageCountText = result.state.messages.length === 0 ? 'conversation restored' : `${result.state.messages.length} message(s) restored`;
-
-    let details = '';
-
-    if (result.gitChanges && result.gitChanges.length > 0) {
-      const fileDetails = result.gitChanges.map(f => {
-        switch (f.status) {
-          case 'M': return `  • ${f.path} (changes reapplied)`;
-          case 'A': return `  • ${f.path} (created/restored)`;
-          case 'D': return `  • ${f.path} (deleted)`;
-          case 'R': return `  • ${f.path} (renamed)`;
-          default: return `  • ${f.path} (status: ${f.status})`;
-        }
-      }).join('\n');
-      details = `\n- Files affected (${result.gitChanges.length}):\n${fileDetails}`;
-    } else if (result.state.fileSnapshots.length > 0) {
-      const fileDetails = result.state.fileSnapshots.map(f => {
-        if (!f.existed) {
-          return `  • ${f.path} (recreated)`;
-        } else if (f.content === '') {
-          return `  • ${f.path} (deleted)`;
-        } else {
-          return `  • ${f.path} (restored)`;
-        }
-      }).join('\n');
-      details = `\n- Files affected (${result.state.fileSnapshots.length}):\n${fileDetails}`;
-    } else if (result.state.gitCommitHash) {
-      details = `\n- Files restored via Git (commit: ${result.state.gitCommitHash.slice(0, 7)})`;
-    }
-
-    return {
-      success: true,
-      content: `Redone: conversation and file changes restored.${details}\n- ${messageCountText}`,
-      shouldAddToHistory: false
-    };
-  }
-};

package/src/utils/commands/sessions.ts

@@ -1,129 +0,0 @@
-import type { Command, CommandResult } from './types';
-import { getAllSessions, setCurrentSession, deleteSession } from '../undoRedoDb';
-
-export const sessionsCommand: Command = {
-  name: 'sessions',
-  description: 'Manage undo/redo sessions. List all sessions or switch to a specific session.',
-  usage: '/sessions [list|switch <session-id>|delete <session-id>]',
-  aliases: ['s'],
-  execute: async (args: string[], _fullCommand: string): Promise<CommandResult> => {
-    const parts = args;
-    const action = parts[0] || 'list';
-
-    if (action === 'list') {
-      const sessions = getAllSessions();
-
-      if (sessions.length === 0) {
-        return {
-          success: true,
-          content: 'No sessions found.',
-          shouldAddToHistory: false
-        };
-      }
-
-      const lines = ['Available sessions:\n'];
-      for (const session of sessions) {
-        const current = session.isCurrent ? ' (current)' : '';
-        const date = new Date(session.lastAccessedAt).toLocaleString();
-        lines.push(`- ${session.id}${current}`);
-        lines.push(`  Last accessed: ${date}`);
-      }
-
-      return {
-        success: true,
-        content: lines.join('\n'),
-        shouldAddToHistory: false
-      };
-    }
-
-    if (action === 'switch') {
-      const sessionId = parts[1];
-      if (!sessionId) {
-        return {
-          success: false,
-          content: 'Please provide a session ID to switch to.\nUsage: /sessions switch <session-id>',
-          shouldAddToHistory: false
-        };
-      }
-
-      const sessions = getAllSessions();
-      const targetSession = sessions.find(s => s.id === sessionId);
-
-      if (!targetSession) {
-        return {
-          success: false,
-          content: `Session not found: ${sessionId}`,
-          shouldAddToHistory: false
-        };
-      }
-
-      try {
-        setCurrentSession(sessionId);
-        return {
-          success: true,
-          content: `Switched to session: ${sessionId}`,
-          shouldAddToHistory: false
-        };
-      } catch (error) {
-        const errorMsg = error instanceof Error ? error.message : 'Unknown error';
-        return {
-          success: false,
-          content: `Failed to switch session: ${errorMsg}`,
-          shouldAddToHistory: false
-        };
-      }
-    }
-
-    if (action === 'delete') {
-      const sessionId = parts[1];
-      if (!sessionId) {
-        return {
-          success: false,
-          content: 'Please provide a session ID to delete.\nUsage: /sessions delete <session-id>',
-          shouldAddToHistory: false
-        };
-      }
-
-      const sessions = getAllSessions();
-      const targetSession = sessions.find(s => s.id === sessionId);
-
-      if (!targetSession) {
-        return {
-          success: false,
-          content: `Session not found: ${sessionId}`,
-          shouldAddToHistory: false
-        };
-      }
-
-      if (targetSession.isCurrent) {
-        return {
-          success: false,
-          content: 'Cannot delete the current session. Switch to another session first.',
-          shouldAddToHistory: false
-        };
-      }
-
-      try {
-        deleteSession(sessionId);
-        return {
-          success: true,
-          content: `Deleted session: ${sessionId}`,
-          shouldAddToHistory: false
-        };
-      } catch (error) {
-        const errorMsg = error instanceof Error ? error.message : 'Unknown error';
-        return {
-          success: false,
-          content: `Failed to delete session: ${errorMsg}`,
-          shouldAddToHistory: false
-        };
-      }
-    }
-
-    return {
-      success: false,
-      content: `Unknown action: ${action}\nUsage: /sessions [list|switch <session-id>|delete <session-id>]`,
-      shouldAddToHistory: false
-    };
-  }
-};

package/src/utils/commands/undo.ts

@@ -1,75 +0,0 @@
-import type { Command, CommandResult } from './types';
-import { undo, canUndo, isGitRepository } from '../undoRedo';
-import { notifyUndoRedo } from '../undoRedoBridge';
-
-export const undoCommand: Command = {
-  name: 'undo',
-  description: 'Undo last message in the conversation. Removes the most recent user message, all subsequent responses, and any file changes. Any file changes made will also be reverted. Internally, this uses Git to manage the file changes if available (local repository works too).',
-  usage: '/undo',
-  aliases: ['u'],
-  execute: async (): Promise<CommandResult> => {
-    if (!canUndo()) {
-      return {
-        success: false,
-        content: 'Nothing to undo. The undo stack is empty.',
-        shouldAddToHistory: false
-      };
-    }
-
-    const result = undo();
-    if (!result) {
-      return {
-        success: false,
-        content: 'Failed to undo. Could not retrieve previous state.',
-        shouldAddToHistory: false
-      };
-    }
-
-    if (!result.success) {
-      return {
-        success: false,
-        content: `Failed to undo file changes:\n${result.error || 'Unknown error'}`,
-        shouldAddToHistory: false
-      };
-    }
-
-    notifyUndoRedo(result.state, 'undo');
-
-    const messageCountText = result.state.messages.length === 0 ? 'conversation cleared' : `${result.state.messages.length} message(s) restored`;
-
-    let details = '';
-
-    if (result.gitChanges && result.gitChanges.length > 0) {
-      const fileDetails = result.gitChanges.map(f => {
-        switch (f.status) {
-          case 'M': return `  • ${f.path} (reverted changes)`;
-          case 'A': return `  • ${f.path} (restored - was deleted)`;
-          case 'D': return `  • ${f.path} (deleted - was created)`;
-          case 'R': return `  • ${f.path} (renamed back)`;
-          default: return `  • ${f.path} (status: ${f.status})`;
-        }
-      }).join('\n');
-      details = `\n- Files affected (${result.gitChanges.length}):\n${fileDetails}`;
-    } else if (result.state.fileSnapshots.length > 0) {
-      const filesAffected = result.state.fileSnapshots.map(f => f.path).join(', ');
-      const fileDetails = result.state.fileSnapshots.map(f => {
-        if (!f.existed) {
-          return `  • ${f.path} (deleted - was created)`;
-        } else if (f.content === '') {
-          return `  • ${f.path} (restored - was deleted)`;
-        } else {
-          return `  • ${f.path} (restored)`;
-        }
-      }).join('\n');
-      details = `\n- Files affected (${result.state.fileSnapshots.length}):\n${fileDetails}`;
-    } else if (result.state.gitCommitHash) {
-      details = `\n- Files reverted via Git (commit: ${result.state.gitCommitHash.slice(0, 7)})`;
-    }
-
-    return {
-      success: true,
-      content: `Undone last user message and all responses.${details}\n- ${messageCountText}`,
-      shouldAddToHistory: false
-    };
-  }
-};

package/src/utils/undoRedo.ts

@@ -1,429 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync, unlinkSync } from 'fs';
-import { join, resolve } from 'path';
-import { execSync } from 'child_process';
-import type { Message } from '../components/main/types';
-import {
-  createSession,
-  getCurrentSession,
-  pushUndoState,
-  popUndoState,
-  pushRedoState,
-  popRedoState,
-  clearRedoStates,
-  getUndoCount,
-  getRedoCount,
-  cleanupOldSessions,
-  type UndoRedoState,
-  type FileSnapshot
-} from './undoRedoDb';
-
-export type { UndoRedoState, FileSnapshot };
-
-let currentSessionId: string | null = null;
-let pendingFileSnapshots: FileSnapshot[] = [];
-
-function getWorkspaceMosaicDir(): string {
-  const workspace = process.cwd();
-  const mosaicDir = join(workspace, '.mosaic');
-
-  if (!existsSync(mosaicDir)) {
-    mkdirSync(mosaicDir, { recursive: true });
-  }
-
-  return mosaicDir;
-}
-
-function generateId(): string {
-  return `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-}
-
-export function isGitRepository(): boolean {
-  try {
-    execSync('git rev-parse --git-dir', { stdio: 'ignore', cwd: process.cwd() });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export function getGitStatus(): { clean: boolean; hasChanges: boolean } {
-  try {
-    const status = execSync('git status --porcelain', { encoding: 'utf-8', cwd: process.cwd() });
-    const hasChanges = status.trim().length > 0;
-    return { clean: !hasChanges, hasChanges };
-  } catch {
-    return { clean: false, hasChanges: false };
-  }
-}
-
-export function initializeSession(): void {
-  cleanupOldSessions(7);
-
-  const existingSession = getCurrentSession();
-  if (existingSession) {
-    currentSessionId = existingSession.id;
-  } else {
-    currentSessionId = createSession();
-  }
-
-  pendingFileSnapshots = [];
-}
-
-export function getCurrentSessionId(): string | null {
-  return currentSessionId;
-}
-
-export function captureFileSnapshot(filePath: string): void {
-  const workspace = process.cwd();
-  const fullPath = resolve(workspace, filePath);
-
-  let content = '';
-  let existed = false;
-
-  try {
-    const fs = require('fs');
-    content = fs.readFileSync(fullPath, 'utf-8');
-    existed = true;
-  } catch {
-    existed = false;
-  }
-
-  const alreadyCaptured = pendingFileSnapshots.some(s => s.path === filePath);
-  if (!alreadyCaptured) {
-    pendingFileSnapshots.push({
-      path: filePath,
-      content,
-      existed
-    });
-  }
-}
-
-function createGitCommit(message: string): string | null {
-  try {
-    const workspace = process.cwd();
-
-    execSync('git add -A', { cwd: workspace, stdio: 'ignore' });
-
-    execSync(`git commit -m "${message.replace(/"/g, '\\"')}"`, {
-      cwd: workspace,
-      stdio: 'ignore',
-      env: {
-        ...process.env,
-        GIT_AUTHOR_NAME: 'Mosaic',
-        GIT_AUTHOR_EMAIL: 'mosaic@local',
-        GIT_COMMITTER_NAME: 'Mosaic',
-        GIT_COMMITTER_EMAIL: 'mosaic@local'
-      }
-    });
-
-    const hash = execSync('git rev-parse HEAD', { encoding: 'utf-8', cwd: workspace }).trim();
-    return hash;
-  } catch (error) {
-    console.error('Failed to create Git commit:', error);
-    return null;
-  }
-}
-
-export function saveState(messages: Message[]): void {
-  if (!currentSessionId) {
-    return;
-  }
-
-  const useGit = isGitRepository();
-  let gitCommitHash: string | undefined;
-
-  if (useGit) {
-    const gitStatus = getGitStatus();
-    if (gitStatus.hasChanges) {
-      const hash = createGitCommit(`[Mosaic] Save state - ${new Date().toISOString()}`);
-      if (hash) {
-        gitCommitHash = hash;
-      }
-    } else {
-      try {
-        const currentHash = execSync('git rev-parse HEAD', { encoding: 'utf-8', cwd: process.cwd() }).trim();
-        gitCommitHash = currentHash;
-      } catch {
-        gitCommitHash = undefined;
-      }
-    }
-  }
-
-  const state: UndoRedoState = {
-    id: generateId(),
-    timestamp: Date.now(),
-    messages: JSON.parse(JSON.stringify(messages)),
-    gitCommitHash,
-    fileSnapshots: JSON.parse(JSON.stringify(pendingFileSnapshots)),
-    useGit
-  };
-
-  pushUndoState(currentSessionId, state);
-  clearRedoStates(currentSessionId);
-  pendingFileSnapshots = [];
-}
-
-function restoreFileSnapshots(snapshots: FileSnapshot[]): { success: boolean; errors: string[] } {
-  const errors: string[] = [];
-  const workspace = process.cwd();
-
-  for (const snapshot of snapshots) {
-    try {
-      const fullPath = resolve(workspace, snapshot.path);
-      if (snapshot.existed) {
-        writeFileSync(fullPath, snapshot.content, 'utf-8');
-      } else {
-        if (existsSync(fullPath)) {
-          unlinkSync(fullPath);
-        }
-      }
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : 'Unknown error';
-      errors.push(`Failed to restore ${snapshot.path}: ${errorMsg}`);
-    }
-  }
-
-  return {
-    success: errors.length === 0,
-    errors
-  };
-}
-
-export function canUndo(): boolean {
-  if (!currentSessionId) return false;
-  return getUndoCount(currentSessionId) > 0;
-}
-
-export function canRedo(): boolean {
-  if (!currentSessionId) return false;
-  return getRedoCount(currentSessionId) > 0;
-}
-
-
-function getUntrackedFiles(): string[] {
-  try {
-    const workspace = process.cwd();
-    const output = execSync('git ls-files --others --exclude-standard', { encoding: 'utf-8', cwd: workspace });
-    return output.trim().split('\n').filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-
-function getFileSnapshot(filePath: string): FileSnapshot {
-  const workspace = process.cwd();
-  const fullPath = resolve(workspace, filePath);
-  let content = '';
-  let existed = false;
-
-  try {
-    if (existsSync(fullPath)) {
-      const fs = require('fs');
-      content = fs.readFileSync(fullPath, 'utf-8');
-      existed = true;
-    }
-  } catch {
-    existed = false;
-  }
-
-  return { path: filePath, content, existed };
-}
-
-function getGitChanges(targetHash: string): FileChange[] {
-  if (!isGitRepository()) {
-    return [];
-  }
-
-  try {
-    const workspace = process.cwd();
-    const diffOutput = execSync(`git diff --name-status HEAD ${targetHash}`, {
-      encoding: 'utf-8',
-      cwd: workspace
-    });
-
-    const changes = diffOutput
-      .trim()
-      .split('\n')
-      .filter(line => line.length > 0)
-      .map(line => {
-        const parts = line.split('\t');
-        const status = parts[0];
-        const pathParts = parts.slice(1);
-
-        if (!status) return null;
-
-        return {
-          status: status.charAt(0),
-          path: pathParts.join('\t')
-        };
-      })
-      .filter((item): item is FileChange => item !== null);
-
-    const untracked = getUntrackedFiles();
-    const untrackedChanges = untracked.map(path => ({
-      status: 'D',
-      path
-    }));
-
-    return [...changes, ...untrackedChanges];
-  } catch (error) {
-    console.error('Failed to get git changes:', error);
-    return [];
-  }
-}
-
-export interface FileChange {
-  path: string;
-  status: string;
-}
-
-export function undo(): { state: UndoRedoState; success: boolean; error?: string; currentState?: UndoRedoState; gitChanges?: FileChange[] } | null {
-  if (!currentSessionId || !canUndo()) {
-    return null;
-  }
-
-  const workspace = process.cwd();
-  const useGit = isGitRepository();
-
-  let currentStateForRedo: UndoRedoState;
-
-  try {
-    if (useGit) {
-      let currentHash: string | undefined;
-      try {
-        currentHash = execSync('git rev-parse HEAD', { encoding: 'utf-8', cwd: workspace }).trim();
-      } catch {
-        currentHash = undefined;
-      }
-
-      const untrackedFiles = getUntrackedFiles();
-      const untrackedSnapshots = untrackedFiles.map(f => getFileSnapshot(f));
-
-      currentStateForRedo = {
-        id: generateId(),
-        timestamp: Date.now(),
-        messages: [],
-        gitCommitHash: currentHash,
-        fileSnapshots: untrackedSnapshots,
-        useGit: true
-      };
-    } else {
-      currentStateForRedo = {
-        id: generateId(),
-        timestamp: Date.now(),
-        messages: [],
-        gitCommitHash: undefined,
-        fileSnapshots: pendingFileSnapshots.length > 0 ? JSON.parse(JSON.stringify(pendingFileSnapshots)) : [],
-        useGit: false
-      };
-    }
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : 'Unknown error';
-    return { state: { id: '', timestamp: 0, messages: [], fileSnapshots: [], useGit: false }, success: false, error: errorMsg };
-  }
-
-  const state = popUndoState(currentSessionId);
-  if (!state) {
-    return null;
-  }
-
-  let gitChanges: FileChange[] = [];
-
-  try {
-    if (state.useGit && state.gitCommitHash) {
-      gitChanges = getGitChanges(state.gitCommitHash);
-
-      const filesToClean = getUntrackedFiles();
-
-      execSync(`git reset --hard ${state.gitCommitHash}`, { cwd: workspace, stdio: 'ignore' });
-      execSync('git clean -fd', { cwd: workspace, stdio: 'ignore' });
-      if (filesToClean.length > 0) {
-        const fs = require('fs');
-        for (const file of filesToClean) {
-          const fullPath = resolve(workspace, file);
-          if (existsSync(fullPath)) {
-            try {
-              const stat = fs.lstatSync(fullPath);
-              if (stat.isDirectory()) {
-                fs.rmSync(fullPath, { recursive: true, force: true });
-              } else {
-                fs.unlinkSync(fullPath);
-              }
-            } catch (cleanupError) {
-              console.error(`Failed to force delete ${file}:`, cleanupError);
-            }
-          }
-        }
-      }
-    } else {
-      const restoreResult = restoreFileSnapshots(state.fileSnapshots);
-      if (!restoreResult.success) {
-        throw new Error(restoreResult.errors.join('\n'));
-      }
-    }
-
-    pushRedoState(currentSessionId, currentStateForRedo);
-
-    return { state, success: true, currentState: currentStateForRedo, gitChanges };
-  } catch (error) {
-    pushUndoState(currentSessionId, state);
-
-    const errorMsg = error instanceof Error ? error.message : 'Unknown error';
-    return { state, success: false, error: errorMsg };
-  }
-}
-
-export function redo(): { state: UndoRedoState; success: boolean; error?: string; gitChanges?: FileChange[] } | null {
-  if (!currentSessionId || !canRedo()) {
-    return null;
-  }
-
-  const state = popRedoState(currentSessionId);
-  if (!state) {
-    return null;
-  }
-
-  let gitChanges: FileChange[] = [];
-
-  try {
-    if (state.useGit && state.gitCommitHash) {
-      const workspace = process.cwd();
-      gitChanges = getGitChanges(state.gitCommitHash);
-
-      execSync(`git reset --hard ${state.gitCommitHash}`, { cwd: workspace, stdio: 'ignore' });
-      restoreFileSnapshots(state.fileSnapshots);
-    } else {
-      const restoreResult = restoreFileSnapshots(state.fileSnapshots);
-      if (!restoreResult.success) {
-        throw new Error(restoreResult.errors.join('\n'));
-      }
-    }
-
-    pushUndoState(currentSessionId, state);
-
-    return { state, success: true, gitChanges };
-  } catch (error) {
-    pushRedoState(currentSessionId, state);
-
-    const errorMsg = error instanceof Error ? error.message : 'Unknown error';
-    return { state, success: false, error: errorMsg };
-  }
-}
-
-export function getUndoStack(): UndoRedoState[] {
-  return [];
-}
-
-export function getRedoStack(): UndoRedoState[] {
-  return [];
-}
-
-export function clearSession(): void {
-  if (!currentSessionId) return;
-
-  clearRedoStates(currentSessionId);
-  currentSessionId = null;
-  pendingFileSnapshots = [];
-}
-
-export { getAllSessions, setCurrentSession, deleteSession } from './undoRedoDb';