seeclaudecode 1.0.0

package/server.js

@@ -0,0 +1,458 @@
+import express from 'express';
+import { WebSocketServer } from 'ws';
+import { createServer } from 'http';
+import chokidar from 'chokidar';
+import simpleGit from 'simple-git';
+import { fileURLToPath } from 'url';
+import { dirname, join, relative, sep } from 'path';
+import { readdir, stat } from 'fs/promises';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const app = express();
+const server = createServer(app);
+const wss = new WebSocketServer({ server });
+
+// Configuration
+const PORT = process.env.PORT || 3847;
+const TARGET_REPO = process.argv[2] || process.cwd();
+
+console.log(`\n👁️  SeeClaudeCode`);
+console.log(`📁 Monitoring: ${TARGET_REPO}`);
+console.log(`🌐 Starting server on http://localhost:${PORT}\n`);
+
+const git = simpleGit(TARGET_REPO);
+
+// Track active edits and changes
+const state = {
+  activeFiles: new Set(),
+  changedFiles: new Set(),
+  repoStructure: null,
+  lastActivity: Date.now()
+};
+
+// Serve static files
+app.use(express.static(join(__dirname, 'public')));
+
+// API endpoint to get repo structure
+app.get('/api/structure', async (req, res) => {
+  try {
+    const structure = await buildRepoStructure(TARGET_REPO);
+    state.repoStructure = structure;
+    res.json(structure);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// API endpoint to get git diff
+app.get('/api/diff', async (req, res) => {
+  try {
+    const diff = await getGitDiff();
+    res.json(diff);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// API endpoint to get diff for a specific file or directory
+app.get('/api/diff/:path(*)', async (req, res) => {
+  try {
+    const targetPath = req.params.path;
+
+    // Check if it's a directory
+    const fullPath = join(TARGET_REPO, targetPath);
+    const stats = await stat(fullPath).catch(() => null);
+
+    if (stats && stats.isDirectory()) {
+      // Get diffs for all changed files in this directory
+      const diff = await getDirectoryDiff(targetPath);
+      res.json(diff);
+    } else {
+      // Single file diff
+      const diff = await getFileDiff(targetPath);
+      res.json(diff);
+    }
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// API endpoint to get current state
+app.get('/api/state', (req, res) => {
+  res.json({
+    activeFiles: Array.from(state.activeFiles),
+    changedFiles: Array.from(state.changedFiles),
+    lastActivity: state.lastActivity
+  });
+});
+
+// Build repo structure recursively
+async function buildRepoStructure(dirPath, depth = 0, maxDepth = 6) {
+  const name = dirPath.split(sep).pop() || dirPath;
+  const relativePath = relative(TARGET_REPO, dirPath) || '.';
+
+  const node = {
+    name,
+    path: relativePath,
+    type: 'directory',
+    children: [],
+    depth
+  };
+
+  if (depth >= maxDepth) return node;
+
+  try {
+    const entries = await readdir(dirPath, { withFileTypes: true });
+
+    // Filter out common ignored directories/files
+    const ignoredPatterns = [
+      'node_modules', '.git', '.next', 'dist', 'build',
+      '.cache', '.turbo', 'coverage', '__pycache__',
+      '.DS_Store', 'thumbs.db', '.env.local'
+    ];
+
+    const filtered = entries.filter(entry =>
+      !ignoredPatterns.includes(entry.name) &&
+      !entry.name.startsWith('.')
+    );
+
+    for (const entry of filtered) {
+      const fullPath = join(dirPath, entry.name);
+
+      if (entry.isDirectory()) {
+        const child = await buildRepoStructure(fullPath, depth + 1, maxDepth);
+        if (child.children.length > 0 || depth < 2) {
+          node.children.push(child);
+        }
+      } else if (entry.isFile()) {
+        const ext = entry.name.split('.').pop()?.toLowerCase() || '';
+        node.children.push({
+          name: entry.name,
+          path: relative(TARGET_REPO, fullPath),
+          type: 'file',
+          extension: ext,
+          category: getFileCategory(ext)
+        });
+      }
+    }
+
+    // Sort: directories first, then files
+    node.children.sort((a, b) => {
+      if (a.type === 'directory' && b.type === 'file') return -1;
+      if (a.type === 'file' && b.type === 'directory') return 1;
+      return a.name.localeCompare(b.name);
+    });
+
+  } catch (error) {
+    console.error(`Error reading ${dirPath}:`, error.message);
+  }
+
+  return node;
+}
+
+// Categorize files for visual grouping
+function getFileCategory(ext) {
+  const categories = {
+    code: ['js', 'ts', 'jsx', 'tsx', 'py', 'rb', 'go', 'rs', 'java', 'c', 'cpp', 'h', 'cs', 'php', 'swift', 'kt'],
+    style: ['css', 'scss', 'sass', 'less', 'styl'],
+    markup: ['html', 'htm', 'xml', 'svg'],
+    config: ['json', 'yaml', 'yml', 'toml', 'ini', 'env', 'config'],
+    docs: ['md', 'mdx', 'txt', 'rst', 'doc', 'pdf'],
+    data: ['sql', 'graphql', 'prisma'],
+    test: ['test', 'spec'],
+    image: ['png', 'jpg', 'jpeg', 'gif', 'webp', 'ico', 'bmp']
+  };
+
+  for (const [category, extensions] of Object.entries(categories)) {
+    if (extensions.includes(ext)) return category;
+  }
+  return 'other';
+}
+
+// Get git diff for changed files
+async function getGitDiff() {
+  try {
+    const status = await git.status();
+    const diff = await git.diff(['--stat']);
+
+    const changedFiles = [
+      ...status.modified,
+      ...status.created,
+      ...status.deleted,
+      ...status.renamed.map(r => r.to)
+    ];
+
+    // Get detailed diff for each file
+    const fileDiffs = [];
+    for (const file of status.modified.slice(0, 20)) {
+      try {
+        const fileDiff = await git.diff([file]);
+        const additions = (fileDiff.match(/^\+[^+]/gm) || []).length;
+        const deletions = (fileDiff.match(/^-[^-]/gm) || []).length;
+        fileDiffs.push({ file, additions, deletions });
+      } catch (e) {
+        fileDiffs.push({ file, additions: 0, deletions: 0 });
+      }
+    }
+
+    return {
+      modified: status.modified,
+      created: status.created,
+      deleted: status.deleted,
+      staged: status.staged,
+      fileDiffs,
+      summary: diff
+    };
+  } catch (error) {
+    return { error: error.message, modified: [], created: [], deleted: [], staged: [], fileDiffs: [] };
+  }
+}
+
+// Get diff for all changed files in a directory
+async function getDirectoryDiff(dirPath) {
+  try {
+    const status = await git.status();
+
+    // Find all changed files that are in this directory
+    const allChanged = [
+      ...status.modified.map(f => ({ file: f, status: 'modified' })),
+      ...status.created.map(f => ({ file: f, status: 'created' })),
+      ...status.deleted.map(f => ({ file: f, status: 'deleted' }))
+    ];
+
+    // Filter to files in this directory (and subdirectories)
+    const dirPrefix = dirPath === '.' ? '' : dirPath + '/';
+    const filesInDir = allChanged.filter(f =>
+      dirPath === '.' || f.file === dirPath || f.file.startsWith(dirPrefix)
+    );
+
+    if (filesInDir.length === 0) {
+      return {
+        path: dirPath,
+        type: 'directory',
+        status: 'unchanged',
+        files: [],
+        totalAdditions: 0,
+        totalDeletions: 0
+      };
+    }
+
+    // Get diffs for each file
+    const fileDiffs = [];
+    let totalAdditions = 0;
+    let totalDeletions = 0;
+
+    for (const { file, status: fileStatus } of filesInDir.slice(0, 10)) {
+      const fileDiff = await getFileDiff(file);
+      fileDiffs.push({
+        ...fileDiff,
+        status: fileStatus
+      });
+      totalAdditions += fileDiff.additions || 0;
+      totalDeletions += fileDiff.deletions || 0;
+    }
+
+    return {
+      path: dirPath,
+      type: 'directory',
+      status: 'changed',
+      files: fileDiffs,
+      totalAdditions,
+      totalDeletions,
+      fileCount: filesInDir.length,
+      showing: Math.min(filesInDir.length, 10)
+    };
+  } catch (error) {
+    return { path: dirPath, type: 'directory', error: error.message, files: [] };
+  }
+}
+
+// Get diff for a specific file
+async function getFileDiff(filePath) {
+  try {
+    const status = await git.status();
+
+    // Check if file is modified, created, or deleted
+    const isModified = status.modified.includes(filePath);
+    const isCreated = status.created.includes(filePath);
+    const isDeleted = status.deleted.includes(filePath);
+    const isStaged = status.staged.includes(filePath);
+
+    if (!isModified && !isCreated && !isDeleted && !isStaged) {
+      return { file: filePath, status: 'unchanged', lines: [] };
+    }
+
+    let diffOutput = '';
+    if (isModified || isDeleted) {
+      diffOutput = await git.diff([filePath]);
+    } else if (isCreated) {
+      // For new files, show entire content as additions
+      diffOutput = await git.diff(['--cached', filePath]).catch(() => '');
+      if (!diffOutput) {
+        // If not staged, get the file content
+        try {
+          const { readFile } = await import('fs/promises');
+          const content = await readFile(join(TARGET_REPO, filePath), 'utf8');
+          const lines = content.split('\n').map(line => `+${line}`);
+          return {
+            file: filePath,
+            status: 'created',
+            additions: lines.length,
+            deletions: 0,
+            lines: lines.map((line, i) => ({
+              type: 'added',
+              lineNumber: i + 1,
+              content: line.slice(1)
+            }))
+          };
+        } catch (e) {
+          return { file: filePath, status: 'created', lines: [], error: e.message };
+        }
+      }
+    }
+
+    // Parse the diff output into lines
+    const lines = [];
+    let lineNum = 0;
+    let additions = 0;
+    let deletions = 0;
+
+    diffOutput.split('\n').forEach(line => {
+      if (line.startsWith('@@')) {
+        // Parse hunk header for line numbers
+        const match = line.match(/@@ -\d+(?:,\d+)? \+(\d+)/);
+        if (match) {
+          lineNum = parseInt(match[1], 10) - 1;
+        }
+        lines.push({ type: 'hunk', content: line });
+      } else if (line.startsWith('+') && !line.startsWith('+++')) {
+        lineNum++;
+        additions++;
+        lines.push({ type: 'added', lineNumber: lineNum, content: line.slice(1) });
+      } else if (line.startsWith('-') && !line.startsWith('---')) {
+        deletions++;
+        lines.push({ type: 'removed', content: line.slice(1) });
+      } else if (!line.startsWith('diff') && !line.startsWith('index') && !line.startsWith('---') && !line.startsWith('+++')) {
+        lineNum++;
+        lines.push({ type: 'context', lineNumber: lineNum, content: line });
+      }
+    });
+
+    return {
+      file: filePath,
+      status: isModified ? 'modified' : isCreated ? 'created' : 'deleted',
+      additions,
+      deletions,
+      lines
+    };
+  } catch (error) {
+    return { file: filePath, error: error.message, lines: [] };
+  }
+}
+
+// Broadcast to all connected clients
+function broadcast(data) {
+  const message = JSON.stringify(data);
+  wss.clients.forEach(client => {
+    if (client.readyState === 1) {
+      client.send(message);
+    }
+  });
+}
+
+// WebSocket connection handler
+wss.on('connection', (ws) => {
+  console.log('📱 Client connected');
+
+  // Send current state to new client
+  ws.send(JSON.stringify({
+    type: 'init',
+    activeFiles: Array.from(state.activeFiles),
+    changedFiles: Array.from(state.changedFiles)
+  }));
+
+  ws.on('close', () => {
+    console.log('📴 Client disconnected');
+  });
+});
+
+// File watcher for real-time updates
+const watcher = chokidar.watch(TARGET_REPO, {
+  ignored: [
+    /(^|[\/\\])\../, // dotfiles
+    /node_modules/,
+    /\.git/,
+    /dist/,
+    /build/,
+    /__pycache__/
+  ],
+  persistent: true,
+  ignoreInitial: true,
+  awaitWriteFinish: {
+    stabilityThreshold: 300,
+    pollInterval: 100
+  }
+});
+
+// Debounce timer for activity detection
+let activityTimer = null;
+const ACTIVITY_TIMEOUT = 2000; // 2 seconds of no activity = editing complete
+
+function handleFileActivity(eventType, filePath) {
+  const relativePath = relative(TARGET_REPO, filePath);
+
+  // Skip if it's in an ignored directory
+  if (relativePath.includes('node_modules') || relativePath.startsWith('.git')) {
+    return;
+  }
+
+  console.log(`📝 ${eventType}: ${relativePath}`);
+
+  // Mark file as actively being edited
+  state.activeFiles.add(relativePath);
+  state.changedFiles.add(relativePath);
+  state.lastActivity = Date.now();
+
+  // Broadcast active edit
+  broadcast({
+    type: 'active',
+    file: relativePath,
+    event: eventType,
+    timestamp: Date.now()
+  });
+
+  // Clear previous timer and set new one
+  if (activityTimer) clearTimeout(activityTimer);
+
+  activityTimer = setTimeout(async () => {
+    // Activity stopped - editing complete
+    const completedFiles = Array.from(state.activeFiles);
+    state.activeFiles.clear();
+
+    // Get git diff for changed files
+    const diff = await getGitDiff();
+
+    broadcast({
+      type: 'complete',
+      files: completedFiles,
+      diff,
+      timestamp: Date.now()
+    });
+
+    console.log(`✅ Editing complete. Changed files: ${completedFiles.join(', ')}`);
+  }, ACTIVITY_TIMEOUT);
+}
+
+watcher
+  .on('change', (path) => handleFileActivity('change', path))
+  .on('add', (path) => handleFileActivity('add', path))
+  .on('unlink', (path) => handleFileActivity('delete', path));
+
+// Start server
+server.listen(PORT, () => {
+  console.log(`✨ Server running at http://localhost:${PORT}`);
+  console.log(`📂 Watching for changes in: ${TARGET_REPO}`);
+  console.log(`\nOpen the URL in your browser to see the visualization.\n`);
+});