gitmaps 1.0.0

package/app/api/repo/clone-stream/route.ts

@@ -0,0 +1,131 @@
+import { measure } from 'measure-fn';
+import path from 'path';
+import fs from 'fs';
+import { spawn } from 'child_process';
+
+const CLONES_DIR = path.join(process.cwd(), 'git-canvas', 'repos');
+
+/**
+ * POST /api/repo/clone-stream
+ * Body: { url: string }
+ * Streams clone progress via SSE, then emits a final "done" or "error" event.
+ *
+ * SSE events:
+ *   event: progress\n data: {"message":"Receiving objects: 45%","percent":45}\n\n
+ *   event: done\n     data: {"ok":true,"path":"...","cached":false}\n\n
+ *   event: error\n    data: {"error":"Clone failed"}\n\n
+ */
+export async function POST(req: Request) {
+    const { url } = await req.json() as { url: string };
+
+    if (!url || typeof url !== 'string') {
+        return Response.json({ error: 'url is required' }, { status: 400 });
+    }
+
+    const isGitUrl = url.startsWith('git@') || url.startsWith('https://') || url.startsWith('http://') || url.endsWith('.git');
+    if (!isGitUrl) {
+        return Response.json({ error: 'Invalid git URL. Use https:// or git@ format.' }, { status: 400 });
+    }
+
+    const repoName = url
+        .replace(/\.git$/, '')
+        .split('/')
+        .pop()!
+        .split(':')
+        .pop()!
+        .replace(/[^a-zA-Z0-9._-]/g, '_');
+
+    if (!repoName) {
+        return Response.json({ error: 'Could not determine repository name from URL' }, { status: 400 });
+    }
+
+    fs.mkdirSync(CLONES_DIR, { recursive: true });
+    const targetPath = path.join(CLONES_DIR, repoName);
+
+    // If already cloned, do a quick pull and return immediately
+    if (fs.existsSync(path.join(targetPath, '.git'))) {
+        return measure('api:repo:clone-stream:cached', async () => {
+            try {
+                const pull = spawn('git', ['pull'], { cwd: targetPath, stdio: 'pipe' });
+                await new Promise<void>((resolve) => pull.on('close', resolve));
+                console.log(`[clone-stream] Updated existing repo: ${repoName}`);
+            } catch {
+                console.log(`[clone-stream] Using existing repo (pull skipped): ${repoName}`);
+            }
+            return Response.json({ ok: true, path: targetPath, cached: true });
+        });
+    }
+
+    // ── Stream clone progress via SSE ──
+    console.log(`[clone-stream] Cloning ${url} → ${targetPath}`);
+
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        start(controller) {
+            function sendSSE(event: string, data: any) {
+                const payload = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+                try { controller.enqueue(encoder.encode(payload)); } catch { /* stream closed */ }
+            }
+
+            sendSSE('progress', { message: `Starting clone of ${repoName}...`, percent: 0 });
+
+            const gitProc = spawn('git', ['clone', '--depth', '100', '--progress', url, targetPath], {
+                stdio: ['ignore', 'pipe', 'pipe']
+            });
+
+            // Git writes progress to stderr
+            let lastPercent = 0;
+
+            function parseProgress(chunk: Buffer) {
+                const lines = chunk.toString().split(/[\r\n]+/);
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed) continue;
+
+                    // Parse percentage from git output like "Receiving objects:  45% (100/222)"
+                    const pctMatch = trimmed.match(/(\d+)%/);
+                    let percent = lastPercent;
+                    if (pctMatch) {
+                        percent = parseInt(pctMatch[1], 10);
+                        // Git has multiple phases — scale the overall progress
+                        if (trimmed.startsWith('Counting')) percent = Math.round(percent * 0.1);
+                        else if (trimmed.startsWith('Compressing')) percent = 10 + Math.round(percent * 0.1);
+                        else if (trimmed.startsWith('Receiving')) percent = 20 + Math.round(percent * 0.6);
+                        else if (trimmed.startsWith('Resolving')) percent = 80 + Math.round(percent * 0.2);
+                        lastPercent = percent;
+                    }
+
+                    sendSSE('progress', { message: trimmed, percent: Math.min(percent, 99) });
+                }
+            }
+
+            gitProc.stderr.on('data', parseProgress);
+            gitProc.stdout.on('data', parseProgress);
+
+            gitProc.on('close', (code) => {
+                if (code === 0) {
+                    console.log(`[clone-stream] ✅ Cloned ${repoName}`);
+                    sendSSE('done', { ok: true, path: targetPath, cached: false });
+                } else {
+                    console.error(`[clone-stream] ✗ git clone exited with code ${code}`);
+                    sendSSE('error', { error: `git clone failed (exit code ${code})` });
+                }
+                try { controller.close(); } catch { /* already closed */ }
+            });
+
+            gitProc.on('error', (err) => {
+                console.error('[clone-stream] spawn error:', err);
+                sendSSE('error', { error: err.message || 'Failed to start git' });
+                try { controller.close(); } catch { /* already closed */ }
+            });
+        }
+    });
+
+    return new Response(stream, {
+        headers: {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+        },
+    });
+}

package/app/api/repo/file-content/route.ts

@@ -0,0 +1,28 @@
+import { measure } from 'measure-fn';
+import simpleGit from 'simple-git';
+import { validateRepoPath } from '../validate-path';
+
+export async function POST(req: Request) {
+    return measure('api:repo:file-content', async () => {
+        try {
+            const { path: repoPath, commit, filePath } = await req.json();
+
+            if (!repoPath || !commit || !filePath) {
+                return new Response('Repository path, commit, and file path are required', { status: 400 });
+            }
+
+            const blocked = validateRepoPath(repoPath);
+            if (blocked) return blocked;
+
+            const git = simpleGit(repoPath);
+
+            // Get file content at this commit
+            const content = await git.show([`${commit}:${filePath}`]);
+
+            return Response.json({ content });
+        } catch (error: any) {
+            console.error('api:repo:file-content:error', error);
+            return new Response(`Error: ${error.message}`, { status: 500 });
+        }
+    });
+}

package/app/api/repo/file-delete/route.ts

@@ -0,0 +1,62 @@
+import { measure } from 'measure-fn';
+import { validateRepoPath } from '../validate-path';
+import * as path from 'path';
+import * as fs from 'fs';
+import simpleGit from 'simple-git';
+
+export async function POST(req: Request) {
+    return measure('api:repo:file-delete', async () => {
+        try {
+            const { path: repoPath, filePath, gitRm } = await req.json();
+
+            if (!repoPath || !filePath) {
+                return new Response('Repository path and file path are required', { status: 400 });
+            }
+
+            const blocked = validateRepoPath(repoPath);
+            if (blocked) return blocked;
+
+            // Resolve absolute path and ensure it's within the repo
+            const absPath = path.resolve(repoPath, filePath);
+            const absRepo = path.resolve(repoPath);
+            if (!absPath.startsWith(absRepo)) {
+                return new Response('File path must be within the repository', { status: 403 });
+            }
+
+            // Check file exists
+            if (!fs.existsSync(absPath)) {
+                return new Response('File not found', { status: 404 });
+            }
+
+            if (gitRm) {
+                // Use git rm to stage the deletion
+                const git = simpleGit(repoPath);
+                await git.rm(filePath);
+            } else {
+                // Just delete the file
+                fs.unlinkSync(absPath);
+            }
+
+            // Clean up empty parent directories
+            let dir = path.dirname(absPath);
+            while (dir !== absRepo && dir.startsWith(absRepo)) {
+                const entries = fs.readdirSync(dir);
+                if (entries.length === 0) {
+                    fs.rmdirSync(dir);
+                    dir = path.dirname(dir);
+                } else {
+                    break;
+                }
+            }
+
+            return Response.json({
+                success: true,
+                path: filePath,
+                gitRm: !!gitRm,
+            });
+        } catch (error: any) {
+            console.error('api:repo:file-delete:error', error);
+            return new Response(`Error: ${error.message}`, { status: 500 });
+        }
+    });
+}

package/app/api/repo/file-history/route.ts

@@ -0,0 +1,45 @@
+import { measure } from 'measure-fn';
+import simpleGit from 'simple-git';
+import { validateRepoPath } from '../validate-path';
+
+export async function POST(req: Request) {
+    return measure('api:repo:file-history', async () => {
+        try {
+            const { path: repoPath, filePath, limit = 20 } = await req.json();
+
+            if (!repoPath || !filePath) {
+                return new Response('Repository path and file path are required', { status: 400 });
+            }
+
+            const blocked = validateRepoPath(repoPath);
+            if (blocked) return blocked;
+
+            const git = simpleGit(repoPath);
+
+            // Get commit history for this specific file
+            const log = await git.log({
+                file: filePath,
+                maxCount: limit,
+                format: {
+                    hash: '%H',
+                    date: '%ai',
+                    message: '%s',
+                    author_name: '%an',
+                }
+            });
+
+            const commits = log.all.map(c => ({
+                hash: c.hash,
+                shortHash: c.hash.substring(0, 7),
+                message: c.message,
+                author: c.author_name,
+                date: c.date,
+            }));
+
+            return Response.json({ commits, total: commits.length });
+        } catch (error: any) {
+            console.error('api:repo:file-history:error', error);
+            return new Response(`Error: ${error.message}`, { status: 500 });
+        }
+    });
+}

package/app/api/repo/file-rename/route.ts

@@ -0,0 +1,83 @@
+import { measure } from 'measure-fn';
+import { validateRepoPath } from '../validate-path';
+import * as path from 'path';
+import * as fs from 'fs';
+import simpleGit from 'simple-git';
+
+export async function POST(req: Request) {
+    return measure('api:repo:file-rename', async () => {
+        try {
+            const { path: repoPath, oldPath, newPath } = await req.json();
+
+            if (!repoPath || !oldPath || !newPath) {
+                return new Response('Repository path, old path, and new path are required', { status: 400 });
+            }
+
+            const blocked = validateRepoPath(repoPath);
+            if (blocked) return blocked;
+
+            // Normalize paths
+            const normalizedOld = oldPath.replace(/\\/g, '/').replace(/^\/+/, '');
+            const normalizedNew = newPath.replace(/\\/g, '/').replace(/^\/+/, '');
+
+            // Validate paths are within repo
+            const absOld = path.resolve(repoPath, normalizedOld);
+            const absNew = path.resolve(repoPath, normalizedNew);
+            const absRepo = path.resolve(repoPath);
+
+            if (!absOld.startsWith(absRepo) || !absNew.startsWith(absRepo)) {
+                return new Response('Paths must be within the repository', { status: 403 });
+            }
+
+            if (normalizedNew.includes('..')) {
+                return new Response('Invalid path — cannot use ..', { status: 400 });
+            }
+
+            // Check source exists
+            if (!fs.existsSync(absOld)) {
+                return new Response('Source file not found', { status: 404 });
+            }
+
+            // Check destination doesn't already exist
+            if (fs.existsSync(absNew)) {
+                return new Response('Destination already exists', { status: 409 });
+            }
+
+            // Ensure destination directory exists
+            const destDir = path.dirname(absNew);
+            if (!fs.existsSync(destDir)) {
+                fs.mkdirSync(destDir, { recursive: true });
+            }
+
+            // Try git mv first, fall back to fs rename
+            try {
+                const git = simpleGit(repoPath);
+                await git.mv(normalizedOld, normalizedNew);
+            } catch {
+                // git mv might fail if file is untracked — just use fs
+                fs.renameSync(absOld, absNew);
+            }
+
+            // Clean up empty parent directories
+            let dir = path.dirname(absOld);
+            while (dir !== absRepo && dir.startsWith(absRepo)) {
+                const entries = fs.readdirSync(dir);
+                if (entries.length === 0) {
+                    fs.rmdirSync(dir);
+                    dir = path.dirname(dir);
+                } else {
+                    break;
+                }
+            }
+
+            return Response.json({
+                success: true,
+                oldPath: normalizedOld,
+                newPath: normalizedNew,
+            });
+        } catch (error: any) {
+            console.error('api:repo:file-rename:error', error);
+            return new Response(`Error: ${error.message}`, { status: 500 });
+        }
+    });
+}

package/app/api/repo/file-save/route.ts

@@ -0,0 +1,45 @@
+import { measure } from 'measure-fn';
+import { validateRepoPath } from '../validate-path';
+import * as path from 'path';
+import * as fs from 'fs';
+
+export async function POST(req: Request) {
+    return measure('api:repo:file-save', async () => {
+        try {
+            const { path: repoPath, filePath, content } = await req.json();
+
+            if (!repoPath || !filePath || content === undefined) {
+                return new Response('Repository path, file path, and content are required', { status: 400 });
+            }
+
+            const blocked = validateRepoPath(repoPath);
+            if (blocked) return blocked;
+
+            // Resolve absolute path and ensure it's within the repo
+            const absPath = path.resolve(repoPath, filePath);
+            const absRepo = path.resolve(repoPath);
+            if (!absPath.startsWith(absRepo)) {
+                return new Response('File path must be within the repository', { status: 403 });
+            }
+
+            // Ensure directory exists
+            const dir = path.dirname(absPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+
+            // Write file
+            fs.writeFileSync(absPath, content, 'utf-8');
+
+            return Response.json({
+                success: true,
+                path: filePath,
+                bytes: Buffer.byteLength(content, 'utf-8'),
+                lines: content.split('\n').length,
+            });
+        } catch (error: any) {
+            console.error('api:repo:file-save:error', error);
+            return new Response(`Error: ${error.message}`, { status: 500 });
+        }
+    });
+}

package/app/api/repo/files/route.ts

@@ -0,0 +1,169 @@
+import { measure } from 'measure-fn';
+import simpleGit from 'simple-git';
+import { validateRepoPath } from '../validate-path';
+
+export async function POST(req: Request) {
+    return measure('api:repo:files', async () => {
+        try {
+            const { path: repoPath, commit } = await req.json();
+
+            if (!repoPath || !commit) {
+                return new Response('Repository path and commit are required', { status: 400 });
+            }
+
+            const blocked = validateRepoPath(repoPath);
+            if (blocked) return blocked;
+
+            const git = simpleGit(repoPath);
+
+            // Get files CHANGED in this specific commit
+            // -M detects renames, -C detects copies
+            // Use --root for initial commits that have no parent
+            let diffResult = '';
+            try {
+                diffResult = await git.raw(['diff-tree', '--no-commit-id', '--name-status', '-M30%', '-r', commit]);
+            } catch (e) { /* ignore */ }
+            // If empty (root commit), try with --root
+            if (!diffResult.trim()) {
+                try {
+                    diffResult = await git.raw(['diff-tree', '--root', '--no-commit-id', '--name-status', '-M30%', '-r', commit]);
+                } catch (e) { /* ignore */ }
+            }
+
+            const changedFiles = [];
+            const lines = diffResult.trim().split('\n').filter(Boolean);
+
+            for (const line of lines) {
+                const parts = line.split('\t');
+                const statusCode = parts[0];
+                if (!statusCode || parts.length < 2) continue;
+
+                // Rename/copy: status is R### or C### (e.g. R100, R087, C100)
+                // Format: R100\toldPath\tnewPath
+                const isRename = statusCode.startsWith('R');
+                const isCopy = statusCode.startsWith('C');
+
+                let filePath: string;
+                let oldPath: string | null = null;
+                let fileStatus: string;
+                let similarity: number | null = null;
+
+                if (isRename || isCopy) {
+                    oldPath = parts[1];
+                    filePath = parts[2];
+                    fileStatus = isRename ? 'renamed' : 'copied';
+                    similarity = parseInt(statusCode.substring(1)) || null;
+                } else {
+                    filePath = parts[1];
+                    fileStatus = statusCode === 'A' ? 'added'
+                        : statusCode === 'D' ? 'deleted'
+                            : statusCode === 'M' ? 'modified'
+                                : statusCode;
+                }
+
+                const name = filePath.split('/').pop()!;
+
+                let content = null;
+                let hunks: DiffHunk[] = [];
+                let error = null;
+
+                if (fileStatus === 'added') {
+                    // New file — get full content
+                    try { content = await git.show([`${commit}:${filePath}`]); } catch (e: any) { error = e.message; }
+
+                } else if (fileStatus === 'deleted') {
+                    // Deleted file — get previous content
+                    try { content = await git.show([`${commit}~1:${filePath}`]); } catch (e: any) { error = e.message; }
+
+                } else if (fileStatus === 'modified') {
+                    // Modified — parse unified diff into hunks + get full new content
+                    try {
+                        const rawDiff = await git.raw(['diff', '-U3', `${commit}~1`, commit, '--', filePath]);
+                        hunks = parseHunks(rawDiff);
+                    } catch (e: any) { error = e.message; }
+                    try { content = await git.show([`${commit}:${filePath}`]); } catch (e: any) { /* ignore, hunks enough */ }
+
+                } else if (fileStatus === 'renamed' || fileStatus === 'copied') {
+                    // Renamed/copied — diff between old path and new path across the commit
+                    try {
+                        const rawDiff = await git.raw([
+                            'diff', '-U3', '-M',
+                            `${commit}~1`, commit,
+                            '--', oldPath!, filePath
+                        ]);
+                        hunks = parseHunks(rawDiff);
+                    } catch (e: any) { error = e.message; }
+                    try { content = await git.show([`${commit}:${filePath}`]); } catch (e: any) { /* ignore */ }
+
+                    // If 100% rename with no content changes, hunks will be empty
+                    // Still include the file so it shows up as renamed
+                }
+
+                changedFiles.push({
+                    path: filePath,
+                    name,
+                    type: 'file',
+                    status: fileStatus,
+                    content,
+                    hunks,
+                    contentError: error,
+                    lines: content ? content.split('\n').length : 0,
+                    // Rename-specific fields
+                    ...(oldPath ? { oldPath } : {}),
+                    ...(similarity != null ? { similarity } : {}),
+                });
+            }
+
+            return Response.json({ files: changedFiles, totalChanged: changedFiles.length });
+        } catch (error: any) {
+            console.error('api:repo:files:error', error);
+            return new Response(`Error: ${error.message}`, { status: 500 });
+        }
+    });
+}
+
+// Parse unified diff into structured hunks
+interface DiffLine { type: string; content: string }
+interface DiffHunk { oldStart: number; oldCount: number; newStart: number; newCount: number; context: string; lines: DiffLine[] }
+
+function parseHunks(rawDiff: string): DiffHunk[] {
+    const allLines = rawDiff.split('\n');
+    const hunks: DiffHunk[] = [];
+    let currentHunk: DiffHunk | null = null;
+
+    for (const line of allLines) {
+        // Parse hunk header: @@ -old,count +new,count @@ optional context
+        const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)/);
+        if (hunkMatch) {
+            if (currentHunk) hunks.push(currentHunk);
+            currentHunk = {
+                oldStart: parseInt(hunkMatch[1]),
+                oldCount: parseInt(hunkMatch[2] || '1'),
+                newStart: parseInt(hunkMatch[3]),
+                newCount: parseInt(hunkMatch[4] || '1'),
+                context: hunkMatch[5]?.trim() || '',
+                lines: []
+            };
+            continue;
+        }
+
+        // Skip diff metadata lines
+        if (line.startsWith('diff ') || line.startsWith('index ') || line.startsWith('---') || line.startsWith('+++')
+            || line.startsWith('similarity ') || line.startsWith('rename ') || line.startsWith('copy ')) continue;
+
+        if (!currentHunk) continue;
+
+        if (line.startsWith('+')) {
+            currentHunk.lines.push({ type: 'add', content: line.substring(1) });
+        } else if (line.startsWith('-')) {
+            currentHunk.lines.push({ type: 'del', content: line.substring(1) });
+        } else if (line.startsWith('\\')) {
+            // "" — skip
+        } else {
+            currentHunk.lines.push({ type: 'ctx', content: line.startsWith(' ') ? line.substring(1) : line });
+        }
+    }
+
+    if (currentHunk) hunks.push(currentHunk);
+    return hunks;
+}

package/app/api/repo/git-blame/route.ts

@@ -0,0 +1,86 @@
+import { measure } from 'measure-fn';
+import { validateRepoPath } from '../validate-path';
+import simpleGit from 'simple-git';
+
+export async function POST(req: Request) {
+    return measure('api:repo:git-blame', async () => {
+        try {
+            const { path: repoPath, filePath, commit } = await req.json();
+
+            if (!repoPath || !filePath) {
+                return new Response('Repository path and file path are required', { status: 400 });
+            }
+
+            const blocked = validateRepoPath(repoPath);
+            if (blocked) return blocked;
+
+            const git = simpleGit(repoPath);
+
+            // Run git blame with porcelain format for machine-readable output
+            const args = ['blame', '--porcelain'];
+            if (commit) args.push(commit);
+            args.push('--', filePath);
+
+            const output = await git.raw(args);
+
+            // Parse porcelain blame output
+            const lines = output.split('\n');
+            const blameEntries: Array<{
+                hash: string;
+                shortHash: string;
+                author: string;
+                authorTime: number;
+                summary: string;
+                line: number;
+                content: string;
+            }> = [];
+
+            let currentHash = '';
+            let currentAuthor = '';
+            let currentTime = 0;
+            let currentSummary = '';
+            let currentLine = 0;
+
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+
+                // Hash line: <hash> <orig-line> <final-line> [<num-lines>]
+                const hashMatch = line.match(/^([0-9a-f]{40})\s+(\d+)\s+(\d+)/);
+                if (hashMatch) {
+                    currentHash = hashMatch[1];
+                    currentLine = parseInt(hashMatch[3]);
+                    continue;
+                }
+
+                if (line.startsWith('author ')) {
+                    currentAuthor = line.slice(7);
+                } else if (line.startsWith('author-time ')) {
+                    currentTime = parseInt(line.slice(12));
+                } else if (line.startsWith('summary ')) {
+                    currentSummary = line.slice(8);
+                } else if (line.startsWith('\t')) {
+                    // Content line — this is the actual source line
+                    blameEntries.push({
+                        hash: currentHash,
+                        shortHash: currentHash.slice(0, 7),
+                        author: currentAuthor,
+                        authorTime: currentTime,
+                        summary: currentSummary,
+                        line: currentLine,
+                        content: line.slice(1), // Remove leading tab
+                    });
+                }
+            }
+
+            return Response.json({
+                success: true,
+                path: filePath,
+                entries: blameEntries,
+                totalLines: blameEntries.length,
+            });
+        } catch (error: any) {
+            console.error('api:repo:git-blame:error', error);
+            return new Response(`Error: ${error.message}`, { status: 500 });
+        }
+    });
+}