codex-lens 0.1.0

package/src/snapshot-manager.js

@@ -0,0 +1,230 @@
+import { readFileSync, writeFileSync, statSync, readdirSync, mkdirSync, cpSync, rmSync, existsSync } from 'fs';
+import { join, relative, extname } from 'path';
+import { createLogger } from './lib/logger.js';
+
+const logger = createLogger('SnapshotManager');
+
+const IGNORED_DIRS = [
+  'node_modules', '.git', '.svn', '.hg',
+  '.idea', '.vscode', 'dist', 'build', '.cache',
+  '__pycache__', '.pytest_cache', '.next', '.nuxt',
+  '.venv', '.env', '.DS_Store', '.codex-viewer'
+];
+
+const IGNORED_FILES = [
+  '.DS_Store', 'Thumbs.db', 'desktop.ini'
+];
+
+const IGNORED_EXTENSIONS = [
+  '.log', '.lock'
+];
+
+export class SnapshotManager {
+  constructor(snapshotsDir = '.codex-viewer/snapshots') {
+    this.snapshotsDir = snapshotsDir;
+  }
+
+  async createSnapshot(projectRoot, taskId) {
+    const snapshotPath = join(this.snapshotsDir, taskId);
+    const metadataPath = join(snapshotPath, 'snapshot.json');
+
+    logger.info(`Creating snapshot: ${taskId}`);
+
+    try {
+      if (!existsSync(this.snapshotsDir)) {
+        mkdirSync(this.snapshotsDir, { recursive: true });
+      }
+
+      if (existsSync(snapshotPath)) {
+        rmSync(snapshotPath, { recursive: true, force: true });
+      }
+      mkdirSync(snapshotPath, { recursive: true });
+
+      const files = this.scanProjectFiles(projectRoot);
+      const metadata = {
+        taskId,
+        createdAt: new Date().toISOString(),
+        projectRoot,
+        filesCount: files.length,
+        files: []
+      };
+
+      for (const file of files) {
+        const relativePath = relative(projectRoot, file);
+        const destPath = join(snapshotPath, relativePath);
+        const destDir = join(snapshotPath, relative(projectRoot, join(file, '..')));
+
+        if (!existsSync(destDir)) {
+          mkdirSync(destDir, { recursive: true });
+        }
+
+        try {
+          cpSync(file, destPath, { force: true });
+          const stats = statSync(file);
+          metadata.files.push({
+            path: relativePath,
+            size: stats.size,
+            mtime: stats.mtime.toISOString()
+          });
+        } catch (err) {
+          logger.warn(`Failed to copy file ${file}: ${err.message}`);
+        }
+      }
+
+      writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+
+      logger.info(`Snapshot created: ${taskId}, ${files.length} files`);
+      return { success: true, snapshotPath, filesCount: files.length };
+
+    } catch (error) {
+      logger.error(`Failed to create snapshot: ${error.message}`);
+      return { success: false, error: error.message };
+    }
+  }
+
+  async restoreSnapshot(taskId) {
+    const snapshotPath = join(this.snapshotsDir, taskId);
+    const metadataPath = join(snapshotPath, 'snapshot.json');
+
+    logger.info(`Restoring snapshot: ${taskId}`);
+
+    try {
+      if (!existsSync(snapshotPath)) {
+        return { success: false, error: 'Snapshot not found' };
+      }
+
+      if (!existsSync(metadataPath)) {
+        return { success: false, error: 'Snapshot metadata not found' };
+      }
+
+      const metadata = JSON.parse(readFileSync(metadataPath, 'utf-8'));
+      const projectRoot = metadata.projectRoot;
+      let restoredCount = 0;
+
+      for (const fileInfo of metadata.files) {
+        const sourcePath = join(snapshotPath, fileInfo.path);
+        const destPath = join(projectRoot, fileInfo.path);
+
+        if (!existsSync(sourcePath)) {
+          continue;
+        }
+
+        const destDir = join(projectRoot, fileInfo.path.replace(/[^/\\]+$/, ''));
+        if (!existsSync(destDir)) {
+          mkdirSync(destDir, { recursive: true });
+        }
+
+        try {
+          cpSync(sourcePath, destPath, { force: true });
+          restoredCount++;
+        } catch (err) {
+          logger.warn(`Failed to restore file ${fileInfo.path}: ${err.message}`);
+        }
+      }
+
+      logger.info(`Snapshot restored: ${taskId}, ${restoredCount} files`);
+      return { success: true, restoredCount };
+
+    } catch (error) {
+      logger.error(`Failed to restore snapshot: ${error.message}`);
+      return { success: false, error: error.message };
+    }
+  }
+
+  async deleteSnapshot(taskId) {
+    const snapshotPath = join(this.snapshotsDir, taskId);
+
+    logger.info(`Deleting snapshot: ${taskId}`);
+
+    try {
+      if (existsSync(snapshotPath)) {
+        rmSync(snapshotPath, { recursive: true, force: true });
+        logger.info(`Snapshot deleted: ${taskId}`);
+        return { success: true };
+      }
+      return { success: false, error: 'Snapshot not found' };
+    } catch (error) {
+      logger.error(`Failed to delete snapshot: ${error.message}`);
+      return { success: false, error: error.message };
+    }
+  }
+
+  getSnapshot(taskId) {
+    const snapshotPath = join(this.snapshotsDir, taskId);
+    const metadataPath = join(snapshotPath, 'snapshot.json');
+
+    if (!existsSync(metadataPath)) {
+      return null;
+    }
+
+    try {
+      return JSON.parse(readFileSync(metadataPath, 'utf-8'));
+    } catch {
+      return null;
+    }
+  }
+
+  listSnapshots() {
+    try {
+      if (!existsSync(this.snapshotsDir)) {
+        return [];
+      }
+
+      const entries = readdirSync(this.snapshotsDir, { withFileTypes: true });
+      const snapshots = [];
+
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const metadata = this.getSnapshot(entry.name);
+          if (metadata) {
+            snapshots.push(metadata);
+          }
+        }
+      }
+
+      return snapshots.sort((a, b) =>
+        new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+      );
+    } catch (error) {
+      logger.error(`Failed to list snapshots: ${error.message}`);
+      return [];
+    }
+  }
+
+  scanProjectFiles(projectRoot) {
+    const files = [];
+
+    const scan = (dir) => {
+      try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+
+        for (const entry of entries) {
+          const fullPath = join(dir, entry.name);
+
+          if (entry.isDirectory()) {
+            if (!IGNORED_DIRS.includes(entry.name) && !entry.name.startsWith('.')) {
+              scan(fullPath);
+            }
+          } else if (entry.isFile()) {
+            if (IGNORED_FILES.includes(entry.name)) {
+              continue;
+            }
+            if (IGNORED_EXTENSIONS.some(ext => entry.name.endsWith(ext))) {
+              continue;
+            }
+            files.push(fullPath);
+          }
+        }
+      } catch (err) {
+        logger.warn(`Failed to scan directory ${dir}: ${err.message}`);
+      }
+    };
+
+    scan(projectRoot);
+    return files;
+  }
+}
+
+export function createSnapshotManager(snapshotsDir) {
+  return new SnapshotManager(snapshotsDir);
+}

package/src/watcher.js

@@ -0,0 +1,218 @@
+import chokidar from 'chokidar';
+import { readFileSync, statSync, readdirSync } from 'fs';
+import { diffLines } from 'diff';
+import { extname, basename, join, relative } from 'path';
+import { createLogger } from './lib/logger.js';
+
+const logger = createLogger('Watcher');
+
+const IGNORED_DIRS = [
+  'node_modules', '.git', '.svn', '.hg',
+  '.idea', '.vscode', 'dist', 'build', '.cache',
+  '__pycache__', '.pytest_cache', '.next', '.nuxt',
+  '.venv', '.env', '.DS_Store'
+];
+
+const IGNORED_FILES = [
+  '.DS_Store', 'Thumbs.db', 'desktop.ini'
+];
+
+export function scanDirectory(projectPath, relativeTo = null) {
+  const result = [];
+
+  try {
+    const entries = readdirSync(projectPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = join(projectPath, entry.name);
+
+      if (entry.isDirectory()) {
+        if (IGNORED_DIRS.includes(entry.name)) continue;
+
+        const children = scanDirectory(fullPath, relativeTo);
+        if (children.length > 0 || !IGNORED_DIRS.includes(entry.name)) {
+          result.push({
+            name: entry.name,
+            path: relativeTo ? relative(relativeTo, fullPath) : fullPath,
+            type: 'directory',
+            children: children
+          });
+        }
+      } else if (entry.isFile()) {
+        if (IGNORED_FILES.includes(entry.name)) continue;
+        if (entry.name.endsWith('.log')) continue;
+
+        result.push({
+          name: entry.name,
+          path: relativeTo ? relative(relativeTo, fullPath) : fullPath,
+          type: 'file'
+        });
+      }
+    }
+
+    result.sort((a, b) => {
+      if (a.type !== b.type) {
+        return a.type === 'directory' ? -1 : 1;
+      }
+      return a.name.localeCompare(b.name);
+    });
+
+  } catch (error) {
+    logger.error(`Error scanning directory ${projectPath}: ${error.message}`);
+  }
+
+  return result;
+}
+
+const CODE_EXTENSIONS = new Set([
+  '.js', '.jsx', '.ts', '.tsx', '.json',
+  '.py', '.rb', '.go', '.rs', '.java',
+  '.c', '.cpp', '.h', '.hpp', '.cs',
+  '.php', '.swift', '.kt', '.scala',
+  '.html', '.css', '.scss', '.less',
+  '.md', '.yaml', '.yml', '.toml',
+  '.sh', '.bash', '.zsh', '.ps1',
+  '.sql', '.xml', '.vue', '.svelte'
+]);
+
+class FileWatcher {
+  constructor(projectPath, wsEmitter) {
+    this.projectPath = projectPath;
+    this.wsEmitter = wsEmitter;
+    this.watcher = null;
+    this.fileContents = new Map();
+  }
+
+  async start() {
+    const ignored = [
+      '**/node_modules/**',
+      '**/.git/**',
+      '**/dist/**',
+      '**/build/**',
+      '**/.cache/**',
+      '**/__pycache__/**',
+      '**/.*/**'
+    ].concat(IGNORED_DIRS.map(d => `**/${d}/**`));
+
+    logger.info(`Starting file watcher on: ${this.projectPath}`);
+
+    this.watcher = chokidar.watch(this.projectPath, {
+      ignored,
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 300,
+        pollInterval: 100
+      }
+    });
+
+    this.watcher.on('add', (filePath) => this.handleChange(filePath, 'add'));
+    this.watcher.on('change', (filePath) => this.handleChange(filePath, 'change'));
+    this.watcher.on('unlink', (filePath) => this.handleUnlink(filePath));
+    this.watcher.on('error', (error) => logger.errorWithStack('Watcher error:', error));
+
+    logger.info('File watcher started successfully');
+
+    return this.projectPath;
+  }
+
+  handleChange(filePath, eventType) {
+    try {
+      if (!this.isCodeFile(filePath)) return;
+
+      const stats = statSync(filePath);
+      if (stats.size > 5 * 1024 * 1024) {
+        logger.warn(`Skipping large file: ${filePath}`);
+        return;
+      }
+
+      const newContent = readFileSync(filePath, 'utf-8');
+      const oldContent = this.fileContents.get(filePath) || '';
+
+      this.fileContents.set(filePath, newContent);
+
+      if (eventType === 'add') {
+        logger.info(`File added: ${filePath}`);
+        const lines = newContent.split('\n');
+        const diff = lines.map(line => ({ content: line, added: true }));
+        this.emitFileChange(filePath, newContent, diff);
+      } else {
+        logger.info(`File changed: ${filePath}`);
+        const changes = diffLines(oldContent, newContent);
+        const diff = [];
+
+        for (const change of changes) {
+          const lines = change.value.split('\n').filter(l => l !== '');
+          for (const line of lines) {
+            diff.push({
+              content: line,
+              added: change.added,
+              removed: change.removed
+            });
+          }
+        }
+
+        this.emitFileChange(filePath, newContent, diff);
+      }
+    } catch (error) {
+      logger.errorWithStack(`Error handling file change: ${filePath}`, error);
+    }
+  }
+
+  handleUnlink(filePath) {
+    this.fileContents.delete(filePath);
+    logger.info(`File deleted: ${filePath}`);
+    this.wsEmitter({
+      type: 'file_delete',
+      data: {
+        path: filePath,
+        timestamp: new Date().toISOString()
+      }
+    });
+  }
+
+  emitFileChange(filePath, newContent, diff) {
+    this.wsEmitter({
+      type: 'file_change',
+      data: {
+        path: filePath,
+        fileName: basename(filePath),
+        extension: extname(filePath),
+        newContent,
+        diff,
+        timestamp: new Date().toISOString()
+      }
+    });
+  }
+
+  isCodeFile(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    return CODE_EXTENSIONS.has(ext);
+  }
+
+  readFile(filePath) {
+    try {
+      const stats = statSync(filePath);
+      if (stats.size > 5 * 1024 * 1024) {
+        return { error: 'File too large' };
+      }
+      const content = readFileSync(filePath, 'utf-8');
+      return { content, path: filePath };
+    } catch (error) {
+      return { error: error.message };
+    }
+  }
+
+  stop() {
+    if (this.watcher) {
+      this.watcher.close();
+      logger.info('File watcher stopped');
+    }
+  }
+}
+
+export function createFileWatcher(projectPath, wsEmitter) {
+  return new FileWatcher(projectPath, wsEmitter);
+}
+
+export { FileWatcher };

package/vite.config.js

@@ -0,0 +1,39 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import { resolve } from 'path';
+
+export default defineConfig({
+  plugins: [react()],
+  base: './',
+  root: 'src',
+  build: {
+    outDir: '../dist',
+    emptyOutDir: true,
+    rollupOptions: {
+      input: {
+        main: resolve(__dirname, 'src/index.html'),
+      },
+    },
+  },
+  server: {
+    port: 5173,
+    strictPort: true,
+    proxy: {
+      '/ws': {
+        target: 'http://localhost:5174',
+        ws: true,
+      },
+      '/api': {
+        target: 'http://localhost:5174',
+      },
+      '/lib/xterm': {
+        target: 'http://localhost:5174',
+      },
+    },
+  },
+  resolve: {
+    alias: {
+      '@': resolve(__dirname, 'src'),
+    },
+  },
+});