@kirosnn/mosaic 0.0.7

package/src/utils/commands/index.ts

@@ -0,0 +1,68 @@
+import type { CommandResult } from './types';
+import { commandRegistry } from './registry';
+import { echoCommand } from './echo';
+import { helpCommand } from './help';
+import { initCommand } from './init';
+import { undoCommand } from './undo';
+import { redoCommand } from './redo';
+import { sessionsCommand } from './sessions';
+import { webCommand } from './web';
+
+export { commandRegistry } from './registry';
+export type { Command, CommandResult, CommandRegistry } from './types';
+
+export function isCommand(input: string): boolean {
+  return input.trim().startsWith('/');
+}
+
+export function parseCommand(input: string): { command: string; args: string[] } | null {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith('/')) {
+    return null;
+  }
+
+  const withoutSlash = trimmed.slice(1);
+  const parts = withoutSlash.split(/\s+/);
+  const command = parts[0]!.toLowerCase();
+  const args = parts.slice(1);
+
+  return { command, args };
+}
+
+export async function executeCommand(input: string): Promise<CommandResult | null> {
+  const parsed = parseCommand(input);
+  if (!parsed) {
+    return null;
+  }
+
+  const { command, args } = parsed;
+  const cmd = commandRegistry.get(command);
+
+  if (!cmd) {
+    return {
+      success: false,
+      content: `Unknown command: /${command}. Type /help for available commands.`,
+      shouldAddToHistory: false
+    };
+  }
+
+  try {
+    return await cmd.execute(args, input);
+  } catch (error) {
+    return {
+      success: false,
+      content: `Error executing command /${command}: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      shouldAddToHistory: false
+    };
+  }
+}
+
+export function initializeCommands(): void {
+  commandRegistry.register(echoCommand);
+  commandRegistry.register(helpCommand);
+  commandRegistry.register(initCommand);
+  commandRegistry.register(undoCommand);
+  commandRegistry.register(redoCommand);
+  commandRegistry.register(sessionsCommand);
+  commandRegistry.register(webCommand);
+}

package/src/utils/commands/init.ts

@@ -0,0 +1,68 @@
+import { mkdir } from 'fs/promises';
+import { join } from 'path';
+import type { Command } from './types';
+
+const INIT_PROMPT = `Analyze the codebase and create or update the MOSAIC.md file in the root of the current workspace.
+
+IMPORTANT: MOSAIC.md is NOT a README. It's a specialized context file that helps AI agents (like me) understand this project better when working in this workspace in the future.
+
+The MOSAIC.md file should contain:
+
+1. **Project Overview** - What this project does and its main purpose
+2. **Architecture** - Key architectural patterns, design decisions, and how the codebase is organized
+3. **Development Guidelines** - Important coding standards, naming conventions, and best practices specific to this project
+4. **Key Files & Directories** - Critical files/folders and their purposes
+5. **Common Tasks** - Frequent development tasks and how to accomplish them
+
+First, analyze the existing codebase:
+- Check package.json, README.md, and main source files
+- Identify the technologies, frameworks, and tools used
+- Understand the project structure and organization
+- Look for existing documentation or comments
+
+**If MOSAIC.md already exists:**
+- Read the existing MOSAIC.md file first
+- Analyze if any sections need updates based on current codebase state
+- Add any missing architectural patterns, new tools, or important workflows discovered
+- Update outdated information (dependencies versions, file paths, deprecated patterns)
+- Improve clarity and add details where needed
+- Keep the existing structure and relevant information
+- DO NOT recreate the file from scratch - use the edit tool to make targeted improvements
+
+**If MOSAIC.md does not exist:**
+- Create a comprehensive MOSAIC.md file that will serve as a contextual guide for AI agents working in this workspace
+
+Even if the file seems complete, always look for potential improvements:
+- Are there new features or patterns in the code not documented?
+- Are all critical workflows explained?
+- Could any section be clearer or more detailed?
+- Are there undocumented conventions or best practices?
+
+Make it clear, concise, and practical. Focus on what an AI agent needs to know to be effective in this codebase.
+
+DO NOT create a .mosaic directory - it has already been created automatically.`;
+
+export const initCommand: Command = {
+  name: 'init',
+  description: 'Initialize the current workspace with Mosaic configuration (creates or updates MOSAIC.md and .mosaic folder)',
+  usage: '/init',
+  aliases: ['i'],
+  execute: async (): Promise<{ success: boolean; content: string; shouldAddToHistory?: boolean }> => {
+    try {
+      const mosaicDir = join(process.cwd(), '.mosaic');
+      await mkdir(mosaicDir, { recursive: true });
+    } catch (error) {
+      return {
+        success: false,
+        content: `Failed to create .mosaic directory: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        shouldAddToHistory: false
+      };
+    }
+
+    return {
+      success: true,
+      content: INIT_PROMPT,
+      shouldAddToHistory: true
+    };
+  }
+};

package/src/utils/commands/redo.ts

@@ -0,0 +1,74 @@
+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/registry.ts

@@ -0,0 +1,29 @@
+import type { Command, CommandRegistry } from './types';
+
+class CommandRegistryImpl implements CommandRegistry {
+  private commands = new Map<string, Command>();
+
+  register(command: Command): void {
+    this.commands.set(command.name, command);
+
+    if (command.aliases) {
+      for (const alias of command.aliases) {
+        this.commands.set(alias, command);
+      }
+    }
+  }
+
+  get(name: string): Command | undefined {
+    return this.commands.get(name);
+  }
+
+  getAll(): Map<string, Command> {
+    return new Map(this.commands);
+  }
+
+  has(name: string): boolean {
+    return this.commands.has(name);
+  }
+}
+
+export const commandRegistry = new CommandRegistryImpl();

package/src/utils/commands/sessions.ts

@@ -0,0 +1,129 @@
+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/types.ts

@@ -0,0 +1,20 @@
+export interface CommandResult {
+  success: boolean;
+  content: string;
+  shouldAddToHistory?: boolean;
+}
+
+export interface Command {
+  name: string;
+  description: string;
+  usage?: string;
+  aliases?: string[];
+  execute: (args: string[], fullCommand: string) => Promise<CommandResult> | CommandResult;
+}
+
+export interface CommandRegistry {
+  register: (command: Command) => void;
+  get: (name: string) => Command | undefined;
+  getAll: () => Map<string, Command>;
+  has: (name: string) => boolean;
+}

package/src/utils/commands/undo.ts

@@ -0,0 +1,75 @@
+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/commands/web.ts

@@ -0,0 +1,77 @@
+import type { Command } from './index';
+
+export const webCommand: Command = {
+  name: 'web',
+  description: 'Launch the web interface on http://127.0.0.1:8192',
+  usage: '/web',
+  aliases: ['w'],
+  execute: async (): Promise<{ success: boolean; content: string; shouldAddToHistory?: boolean }> => {
+    try {
+      const { spawn } = await import('child_process');
+      const path = await import('path');
+      const fs = await import('fs');
+
+      const serverPath = path.join(__dirname, '..', '..', 'web', 'server.ts');
+
+      if (!fs.existsSync(serverPath)) {
+        return {
+          success: false,
+          content: `Web server file not found at: ${serverPath}`,
+          shouldAddToHistory: false
+        };
+      }
+
+      const serverProcess = spawn('bun', ['run', serverPath], {
+        detached: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: {
+          ...process.env,
+          MOSAIC_PROJECT_PATH: process.cwd()
+        }
+      });
+
+      let startupError = '';
+
+      serverProcess.stderr?.on('data', (data) => {
+        startupError += data.toString();
+      });
+
+      await new Promise<void>((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          if (startupError) {
+            reject(new Error(startupError));
+          } else {
+            resolve();
+          }
+        }, 2000);
+
+        serverProcess.on('error', (error) => {
+          clearTimeout(timeout);
+          reject(error);
+        });
+
+        serverProcess.stdout?.on('data', (data) => {
+          const output = data.toString();
+          if (output.includes('running on')) {
+            clearTimeout(timeout);
+            resolve();
+          }
+        });
+      });
+
+      serverProcess.unref();
+
+      return {
+        success: true,
+        content: 'Web interface started successfully!\n\nOpen your browser at: http://127.0.0.1:8192',
+        shouldAddToHistory: false
+      };
+    } catch (error) {
+      return {
+        success: false,
+        content: `Failed to start web interface: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        shouldAddToHistory: false
+      };
+    }
+  }
+};