@codewithdan/zingit 0.0.1

package/server/dist/index.js

@@ -0,0 +1,244 @@
+// server/src/index.ts
+import { WebSocketServer } from 'ws';
+import { CopilotAgent } from './agents/copilot.js';
+import { ClaudeCodeAgent } from './agents/claude.js';
+import { CodexAgent } from './agents/codex.js';
+import { detectAgents } from './utils/agent-detection.js';
+import { GitManager, GitManagerError } from './services/git-manager.js';
+import { sendMessage, handleGetAgents, handleSelectAgent, handleBatch, handleMessage, handleReset, handleStop, handleGetHistory, handleUndo, handleRevertTo, handleClearHistory } from './handlers/messageHandlers.js';
+const PORT = parseInt(process.env.PORT || '3000', 10);
+// Legacy support: still allow AGENT env var for backwards compatibility
+const DEFAULT_AGENT = process.env.AGENT || null;
+if (!process.env.PROJECT_DIR) {
+    console.error('ERROR: PROJECT_DIR environment variable is required');
+    console.error('Example: PROJECT_DIR=/path/to/your/project npm run dev');
+    process.exit(1);
+}
+const PROJECT_DIR = process.env.PROJECT_DIR;
+// Agent registry
+const agentClasses = {
+    copilot: CopilotAgent,
+    claude: ClaudeCodeAgent,
+    codex: CodexAgent,
+};
+// Cache for initialized agents (lazy initialization)
+const initializedAgents = new Map();
+/**
+ * Get or initialize an agent
+ */
+async function getAgent(agentName) {
+    // Check cache first
+    const cached = initializedAgents.get(agentName);
+    if (cached) {
+        return cached;
+    }
+    // Initialize new agent
+    const AgentClass = agentClasses[agentName];
+    if (!AgentClass) {
+        throw new Error(`Unknown agent: ${agentName}`);
+    }
+    const agent = new AgentClass();
+    await agent.start();
+    initializedAgents.set(agentName, agent);
+    return agent;
+}
+// ConnectionState is now defined in handlers/messageHandlers.ts
+async function main() {
+    // Detect available agents on startup
+    const availableAgents = await detectAgents();
+    console.log('✓ Agent availability:');
+    for (const agent of availableAgents) {
+        const status = agent.available ? '✓' : '✗';
+        const version = agent.version ? ` (${agent.version})` : '';
+        const reason = agent.reason ? ` - ${agent.reason}` : '';
+        console.log(`  ${status} ${agent.displayName}${version}${reason}`);
+    }
+    // If DEFAULT_AGENT is set, pre-initialize it for backwards compatibility
+    if (DEFAULT_AGENT) {
+        const agentInfo = availableAgents.find(a => a.name === DEFAULT_AGENT);
+        if (agentInfo?.available) {
+            try {
+                await getAgent(DEFAULT_AGENT);
+                console.log(`✓ Pre-initialized agent: ${DEFAULT_AGENT}`);
+            }
+            catch (err) {
+                console.warn(`⚠ Failed to pre-initialize ${DEFAULT_AGENT}:`, err.message);
+            }
+        }
+    }
+    // WebSocket server with payload limit to prevent accidental memory issues
+    const wss = new WebSocketServer({
+        port: PORT,
+        maxPayload: 10 * 1024 * 1024 // 10MB limit (prevents accidental memory exhaustion)
+    });
+    console.log(`✓ ZingIt server running on ws://localhost:${PORT}`);
+    console.log(`✓ Project directory: ${PROJECT_DIR}`);
+    if (DEFAULT_AGENT) {
+        console.log(`✓ Default agent: ${DEFAULT_AGENT}`);
+    }
+    else {
+        console.log('✓ Dynamic agent selection enabled (client chooses agent)');
+    }
+    // Track connections and use shared global state for session persistence
+    const connections = new Set();
+    // Global state that persists across WebSocket reconnections
+    // NOTE: This is designed for single-user local development.
+    // Multiple simultaneous clients will share the same agent session.
+    const gitManager = new GitManager(PROJECT_DIR);
+    gitManager.initialize().catch((err) => {
+        console.warn('Failed to initialize GitManager:', err.message);
+    });
+    const globalState = {
+        session: null,
+        agentName: DEFAULT_AGENT, // Use default if set
+        agent: DEFAULT_AGENT ? initializedAgents.get(DEFAULT_AGENT) || null : null,
+        gitManager,
+        currentCheckpointId: null,
+    };
+    // Track cleanup timer to prevent race conditions
+    let sessionCleanupTimer = null;
+    wss.on('connection', (ws) => {
+        console.log('Client connected');
+        connections.add(ws);
+        const state = globalState; // Use shared state
+        // Clear any pending cleanup timer since we have an active connection
+        if (sessionCleanupTimer) {
+            clearTimeout(sessionCleanupTimer);
+            sessionCleanupTimer = null;
+            console.log('Cancelled session cleanup - client reconnected');
+        }
+        // Heartbeat mechanism to detect dead connections
+        let isAlive = true;
+        ws.on('pong', () => {
+            isAlive = true;
+        });
+        const heartbeatInterval = setInterval(() => {
+            if (!isAlive) {
+                console.log('Client failed to respond to ping - terminating connection');
+                clearInterval(heartbeatInterval);
+                ws.terminate(); // This will trigger the 'close' event which handles cleanup
+                return;
+            }
+            isAlive = false;
+            ws.ping();
+        }, 30000); // Ping every 30 seconds
+        // Create dependencies object for handlers
+        const deps = {
+            projectDir: PROJECT_DIR,
+            detectAgents,
+            getAgent
+        };
+        ws.on('message', async (data) => {
+            let msg;
+            try {
+                msg = JSON.parse(data.toString());
+            }
+            catch {
+                sendMessage(ws, { type: 'error', message: 'Invalid JSON' });
+                return;
+            }
+            try {
+                switch (msg.type) {
+                    case 'get_agents':
+                        await handleGetAgents(ws, deps);
+                        break;
+                    case 'select_agent':
+                        await handleSelectAgent(ws, state, msg, deps);
+                        break;
+                    case 'batch':
+                        await handleBatch(ws, state, msg, deps);
+                        break;
+                    case 'message':
+                        await handleMessage(ws, state, msg);
+                        break;
+                    case 'reset':
+                        await handleReset(ws, state);
+                        break;
+                    case 'stop':
+                        await handleStop(ws, state);
+                        break;
+                    case 'get_history':
+                        await handleGetHistory(ws, state);
+                        break;
+                    case 'undo':
+                        await handleUndo(ws, state, GitManagerError);
+                        break;
+                    case 'revert_to':
+                        await handleRevertTo(ws, state, msg, GitManagerError);
+                        break;
+                    case 'clear_history':
+                        await handleClearHistory(ws, state);
+                        break;
+                }
+            }
+            catch (err) {
+                sendMessage(ws, { type: 'error', message: err.message });
+            }
+        });
+        ws.on('close', async () => {
+            console.log('Client disconnected');
+            connections.delete(ws);
+            // Clean up heartbeat interval
+            clearInterval(heartbeatInterval);
+            // Don't destroy session immediately - keep it alive for reconnection (page reload)
+            // Clear any existing cleanup timer to prevent race conditions
+            if (sessionCleanupTimer) {
+                clearTimeout(sessionCleanupTimer);
+                sessionCleanupTimer = null;
+            }
+            // Set new cleanup timer only if no connections remain
+            if (connections.size === 0) {
+                sessionCleanupTimer = setTimeout(async () => {
+                    if (state.session && connections.size === 0) {
+                        console.log('Cleaning up stale session after 5 minutes of inactivity');
+                        try {
+                            await state.session.destroy();
+                        }
+                        catch (err) {
+                            console.error('Error destroying session during cleanup:', err.message);
+                        }
+                        finally {
+                            state.session = null;
+                            sessionCleanupTimer = null;
+                        }
+                    }
+                }, 300000); // 5 minutes
+            }
+        });
+        ws.on('error', (err) => {
+            console.error('WebSocket error:', err.message);
+            // Clean up heartbeat interval on error
+            clearInterval(heartbeatInterval);
+        });
+        // Send connected message with current state
+        sendMessage(ws, {
+            type: 'connected',
+            agent: state.agentName || undefined,
+            model: state.agent?.model,
+            projectDir: PROJECT_DIR
+        });
+    });
+    // Graceful shutdown
+    process.on('SIGINT', async () => {
+        console.log('\nShutting down...');
+        if (globalState.session) {
+            try {
+                await globalState.session.destroy();
+            }
+            catch (err) {
+                console.error('Error destroying session during shutdown:', err.message);
+            }
+        }
+        for (const agent of initializedAgents.values()) {
+            try {
+                await agent.stop();
+            }
+            catch (err) {
+                console.error('Error stopping agent during shutdown:', err.message);
+            }
+        }
+        wss.close();
+        process.exit(0);
+    });
+}
+main().catch(console.error);

package/server/dist/services/git-manager.d.ts

@@ -0,0 +1,104 @@
+import type { Annotation } from '../types.js';
+export interface Checkpoint {
+    id: string;
+    timestamp: string;
+    commitHash: string;
+    branchName: string;
+    annotations: AnnotationSummary[];
+    pageUrl: string;
+    pageTitle: string;
+    agentName: string;
+    status: 'pending' | 'applied' | 'reverted';
+    filesModified: number;
+    linesChanged: number;
+}
+export interface AnnotationSummary {
+    id: string;
+    identifier: string;
+    notes: string;
+}
+export interface FileChange {
+    checkpointId: string;
+    filePath: string;
+    changeType: 'created' | 'modified' | 'deleted';
+    linesAdded: number;
+    linesRemoved: number;
+}
+export interface ChangeHistory {
+    projectDir: string;
+    checkpoints: Checkpoint[];
+    currentCheckpointId: string | null;
+}
+export interface CheckpointInfo {
+    id: string;
+    timestamp: string;
+    annotations: AnnotationSummary[];
+    filesModified: number;
+    linesChanged: number;
+    agentName: string;
+    pageUrl: string;
+    status: 'pending' | 'applied' | 'reverted';
+    canUndo: boolean;
+}
+export declare class GitManager {
+    private projectDir;
+    private historyFile;
+    private zingitDir;
+    constructor(projectDir: string);
+    /**
+     * Initialize ZingIt tracking in the project
+     */
+    initialize(): Promise<void>;
+    /**
+     * Check if git repo exists and get status
+     */
+    checkGitStatus(): Promise<{
+        isRepo: boolean;
+        isClean: boolean;
+        branch: string;
+        error?: string;
+    }>;
+    /**
+     * Create a checkpoint before AI modifications
+     */
+    createCheckpoint(metadata: {
+        annotations: Annotation[];
+        pageUrl: string;
+        pageTitle: string;
+        agentName: string;
+    }): Promise<Checkpoint>;
+    /**
+     * Finalize checkpoint after AI modifications complete
+     */
+    finalizeCheckpoint(checkpointId: string): Promise<FileChange[]>;
+    /**
+     * Undo the most recent checkpoint
+     */
+    undoLastCheckpoint(): Promise<{
+        checkpointId: string;
+        filesReverted: string[];
+    }>;
+    /**
+     * Revert to a specific checkpoint
+     */
+    revertToCheckpoint(checkpointId: string): Promise<{
+        filesReverted: string[];
+    }>;
+    /**
+     * Get change history formatted for client
+     */
+    getHistory(): Promise<CheckpointInfo[]>;
+    /**
+     * Clear all history (dangerous operation)
+     */
+    clearHistory(): Promise<void>;
+    private loadHistory;
+    private saveHistory;
+}
+/**
+ * Custom error class for GitManager errors
+ */
+export declare class GitManagerError extends Error {
+    readonly code: 'NOT_GIT_REPO' | 'DIRTY_WORKING_TREE' | 'CHECKPOINT_NOT_FOUND' | 'NO_CHANGES_TO_UNDO' | 'INVALID_CHECKPOINT_STATE';
+    constructor(message: string, code: 'NOT_GIT_REPO' | 'DIRTY_WORKING_TREE' | 'CHECKPOINT_NOT_FOUND' | 'NO_CHANGES_TO_UNDO' | 'INVALID_CHECKPOINT_STATE');
+}

package/server/dist/services/git-manager.js

@@ -0,0 +1,317 @@
+// server/src/services/git-manager.ts
+import { exec, execFile } from 'child_process';
+import { promisify } from 'util';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { v4 as uuidv4 } from 'uuid';
+const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
+/**
+ * Sanitize a string for safe use in git commit messages.
+ * Removes/escapes characters that could cause shell injection.
+ */
+function sanitizeForGit(str) {
+    if (!str)
+        return '';
+    // Remove or replace dangerous characters
+    return str
+        .replace(/[`$"\\]/g, '') // Remove shell-dangerous chars
+        .replace(/[\r\n]/g, ' ') // Replace newlines with spaces
+        .trim()
+        .slice(0, 200); // Limit length
+}
+export class GitManager {
+    projectDir;
+    historyFile;
+    zingitDir;
+    constructor(projectDir) {
+        this.projectDir = projectDir;
+        this.zingitDir = path.join(projectDir, '.zingit');
+        this.historyFile = path.join(this.zingitDir, 'history.json');
+    }
+    /**
+     * Initialize ZingIt tracking in the project
+     */
+    async initialize() {
+        // Ensure .zingit directory exists
+        await fs.mkdir(this.zingitDir, { recursive: true });
+        // Add .zingit to .gitignore if not present
+        const gitignorePath = path.join(this.projectDir, '.gitignore');
+        try {
+            const gitignore = await fs.readFile(gitignorePath, 'utf-8');
+            if (!gitignore.includes('.zingit')) {
+                await fs.appendFile(gitignorePath, '\n# ZingIt history\n.zingit/\n');
+            }
+        }
+        catch {
+            // .gitignore doesn't exist - that's okay, we'll create history anyway
+        }
+        // Initialize history file if it doesn't exist
+        try {
+            await fs.access(this.historyFile);
+        }
+        catch {
+            await this.saveHistory({
+                projectDir: this.projectDir,
+                checkpoints: [],
+                currentCheckpointId: null,
+            });
+        }
+    }
+    /**
+     * Check if git repo exists and get status
+     */
+    async checkGitStatus() {
+        try {
+            const { stdout: branch } = await execAsync('git rev-parse --abbrev-ref HEAD', {
+                cwd: this.projectDir,
+            });
+            const { stdout: status } = await execAsync('git status --porcelain', {
+                cwd: this.projectDir,
+            });
+            return {
+                isRepo: true,
+                isClean: status.trim() === '',
+                branch: branch.trim(),
+            };
+        }
+        catch (err) {
+            return {
+                isRepo: false,
+                isClean: false,
+                branch: '',
+                error: err.message,
+            };
+        }
+    }
+    /**
+     * Create a checkpoint before AI modifications
+     */
+    async createCheckpoint(metadata) {
+        const status = await this.checkGitStatus();
+        if (!status.isRepo) {
+            throw new GitManagerError('Project directory is not a git repository. Initialize git first with: git init', 'NOT_GIT_REPO');
+        }
+        // If there are uncommitted changes, auto-commit them
+        if (!status.isClean) {
+            try {
+                await execFileAsync('git', ['add', '-A'], { cwd: this.projectDir });
+                await execFileAsync('git', ['commit', '-m', '[ZingIt] Auto-save before AI modifications'], {
+                    cwd: this.projectDir,
+                });
+            }
+            catch (err) {
+                // Commit might fail if nothing to commit after add, that's okay
+                console.log('Note: Auto-commit skipped -', err.message);
+            }
+        }
+        // Get current commit hash
+        const { stdout: commitHash } = await execAsync('git rev-parse HEAD', {
+            cwd: this.projectDir,
+        });
+        const checkpoint = {
+            id: uuidv4(),
+            timestamp: new Date().toISOString(),
+            commitHash: commitHash.trim(),
+            branchName: status.branch,
+            annotations: metadata.annotations.map((a) => ({
+                id: a.id,
+                identifier: a.identifier,
+                notes: a.notes,
+            })),
+            pageUrl: metadata.pageUrl,
+            pageTitle: metadata.pageTitle,
+            agentName: metadata.agentName,
+            status: 'pending',
+            filesModified: 0,
+            linesChanged: 0,
+        };
+        // Save checkpoint to history
+        const history = await this.loadHistory();
+        history.checkpoints.push(checkpoint);
+        await this.saveHistory(history);
+        console.log(`[GitManager] Created checkpoint ${checkpoint.id.slice(0, 8)}`);
+        return checkpoint;
+    }
+    /**
+     * Finalize checkpoint after AI modifications complete
+     */
+    async finalizeCheckpoint(checkpointId) {
+        const history = await this.loadHistory();
+        const checkpoint = history.checkpoints.find((c) => c.id === checkpointId);
+        if (!checkpoint) {
+            throw new GitManagerError(`Checkpoint not found: ${checkpointId}`, 'CHECKPOINT_NOT_FOUND');
+        }
+        // Get list of changed files since checkpoint
+        let diffStat = '';
+        try {
+            const result = await execAsync(`git diff --name-status ${checkpoint.commitHash}`, {
+                cwd: this.projectDir,
+            });
+            diffStat = result.stdout;
+        }
+        catch {
+            // No changes
+            diffStat = '';
+        }
+        const fileChanges = [];
+        const lines = diffStat.trim().split('\n').filter((l) => l);
+        let totalLinesAdded = 0;
+        let totalLinesRemoved = 0;
+        for (const line of lines) {
+            const [statusChar, ...filePathParts] = line.split('\t');
+            const filePath = filePathParts.join('\t'); // Handle filenames with tabs
+            const changeType = statusChar === 'A' ? 'created' : statusChar === 'D' ? 'deleted' : 'modified';
+            // Get line counts for this file
+            let linesAdded = 0;
+            let linesRemoved = 0;
+            try {
+                const { stdout: numstat } = await execAsync(`git diff --numstat ${checkpoint.commitHash} -- "${filePath}"`, { cwd: this.projectDir });
+                const parts = numstat.trim().split('\t');
+                linesAdded = parseInt(parts[0]) || 0;
+                linesRemoved = parseInt(parts[1]) || 0;
+            }
+            catch {
+                // Ignore errors for individual files
+            }
+            totalLinesAdded += linesAdded;
+            totalLinesRemoved += linesRemoved;
+            fileChanges.push({
+                checkpointId,
+                filePath,
+                changeType,
+                linesAdded,
+                linesRemoved,
+            });
+        }
+        // Commit the changes if there are any
+        if (fileChanges.length > 0) {
+            try {
+                await execFileAsync('git', ['add', '-A'], { cwd: this.projectDir });
+                const identifiers = checkpoint.annotations.map((a) => sanitizeForGit(a.identifier)).join(', ');
+                const commitMsg = `[ZingIt] ${identifiers}`;
+                // Use execFile with array args to avoid shell injection
+                await execFileAsync('git', ['commit', '-m', commitMsg], { cwd: this.projectDir });
+            }
+            catch (err) {
+                console.log('Note: Commit skipped -', err.message);
+            }
+        }
+        // Update checkpoint status and stats
+        checkpoint.status = 'applied';
+        checkpoint.filesModified = fileChanges.length;
+        checkpoint.linesChanged = totalLinesAdded + totalLinesRemoved;
+        history.currentCheckpointId = checkpointId;
+        await this.saveHistory(history);
+        console.log(`[GitManager] Finalized checkpoint ${checkpointId.slice(0, 8)}: ${fileChanges.length} files, ${checkpoint.linesChanged} lines`);
+        return fileChanges;
+    }
+    /**
+     * Undo the most recent checkpoint
+     */
+    async undoLastCheckpoint() {
+        const history = await this.loadHistory();
+        if (!history.currentCheckpointId) {
+            throw new GitManagerError('No changes to undo', 'NO_CHANGES_TO_UNDO');
+        }
+        const checkpoint = history.checkpoints.find((c) => c.id === history.currentCheckpointId);
+        if (!checkpoint) {
+            throw new GitManagerError('Current checkpoint not found', 'CHECKPOINT_NOT_FOUND');
+        }
+        if (checkpoint.status !== 'applied') {
+            throw new GitManagerError('Checkpoint is not in applied state', 'INVALID_CHECKPOINT_STATE');
+        }
+        // Reset to the checkpoint's original commit
+        await execAsync(`git reset --hard ${checkpoint.commitHash}`, { cwd: this.projectDir });
+        // Get files that were reverted
+        const filesReverted = [];
+        // We could compute this but for now just return empty - the checkpoint has the info
+        // Update history
+        checkpoint.status = 'reverted';
+        const currentIndex = history.checkpoints.findIndex((c) => c.id === history.currentCheckpointId);
+        history.currentCheckpointId =
+            currentIndex > 0 ? history.checkpoints[currentIndex - 1].id : null;
+        await this.saveHistory(history);
+        console.log(`[GitManager] Undid checkpoint ${checkpoint.id.slice(0, 8)}`);
+        return { checkpointId: checkpoint.id, filesReverted };
+    }
+    /**
+     * Revert to a specific checkpoint
+     */
+    async revertToCheckpoint(checkpointId) {
+        const history = await this.loadHistory();
+        const checkpoint = history.checkpoints.find((c) => c.id === checkpointId);
+        if (!checkpoint) {
+            throw new GitManagerError(`Checkpoint not found: ${checkpointId}`, 'CHECKPOINT_NOT_FOUND');
+        }
+        // Reset to that commit
+        await execAsync(`git reset --hard ${checkpoint.commitHash}`, { cwd: this.projectDir });
+        // Mark all checkpoints after this one as reverted
+        const checkpointIndex = history.checkpoints.findIndex((c) => c.id === checkpointId);
+        for (let i = checkpointIndex + 1; i < history.checkpoints.length; i++) {
+            history.checkpoints[i].status = 'reverted';
+        }
+        // The target checkpoint itself should be marked as the current state
+        // but it was the state BEFORE changes, so set currentCheckpointId to previous
+        history.currentCheckpointId = checkpointIndex > 0 ? history.checkpoints[checkpointIndex - 1].id : null;
+        await this.saveHistory(history);
+        console.log(`[GitManager] Reverted to checkpoint ${checkpointId.slice(0, 8)}`);
+        return { filesReverted: [] };
+    }
+    /**
+     * Get change history formatted for client
+     */
+    async getHistory() {
+        const history = await this.loadHistory();
+        return history.checkpoints.map((cp, index) => ({
+            id: cp.id,
+            timestamp: cp.timestamp,
+            annotations: cp.annotations,
+            filesModified: cp.filesModified,
+            linesChanged: cp.linesChanged,
+            agentName: cp.agentName,
+            pageUrl: cp.pageUrl,
+            status: cp.status,
+            canUndo: cp.id === history.currentCheckpointId && cp.status === 'applied',
+        }));
+    }
+    /**
+     * Clear all history (dangerous operation)
+     */
+    async clearHistory() {
+        await this.saveHistory({
+            projectDir: this.projectDir,
+            checkpoints: [],
+            currentCheckpointId: null,
+        });
+        console.log('[GitManager] History cleared');
+    }
+    async loadHistory() {
+        try {
+            const data = await fs.readFile(this.historyFile, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return {
+                projectDir: this.projectDir,
+                checkpoints: [],
+                currentCheckpointId: null,
+            };
+        }
+    }
+    async saveHistory(history) {
+        await fs.mkdir(this.zingitDir, { recursive: true });
+        await fs.writeFile(this.historyFile, JSON.stringify(history, null, 2));
+    }
+}
+/**
+ * Custom error class for GitManager errors
+ */
+export class GitManagerError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'GitManagerError';
+    }
+}

package/server/dist/services/index.d.ts

@@ -0,0 +1,2 @@
+export { GitManager, GitManagerError } from './git-manager.js';
+export type { Checkpoint, CheckpointInfo, ChangeHistory, FileChange, AnnotationSummary } from './git-manager.js';

package/server/dist/services/index.js

@@ -0,0 +1,2 @@
+// server/src/services/index.ts
+export { GitManager, GitManagerError } from './git-manager.js';