gitmaps 1.0.0

package/app/api/github/repos/route.ts

@@ -0,0 +1,111 @@
+import { measure } from 'measure-fn';
+
+/**
+ * GET /api/github/repos?user=<username>&page=<n>&sort=<updated|stars|name>
+ * Fetches public repositories from GitHub API for a given user/org.
+ * No auth required for public repos (60 req/hr rate limit).
+ */
+export async function GET(req: Request) {
+    return measure('api:github:repos', async () => {
+        try {
+            const url = new URL(req.url);
+            const user = url.searchParams.get('user')?.trim();
+            const page = parseInt(url.searchParams.get('page') || '1');
+            const sort = url.searchParams.get('sort') || 'updated';
+            const perPage = 30;
+
+            if (!user) {
+                return Response.json({ error: 'user parameter is required' }, { status: 400 });
+            }
+
+            // Try as user first, then as org
+            let ghUrl = `https://api.github.com/users/${encodeURIComponent(user)}/repos?per_page=${perPage}&page=${page}&sort=${sort}&direction=desc`;
+
+            const headers: Record<string, string> = {
+                'Accept': 'application/vnd.github.v3+json',
+                'User-Agent': 'GitCanvas/1.0',
+            };
+
+            // Use GITHUB_TOKEN if available for higher rate limits
+            const token = process.env.GITHUB_TOKEN;
+            if (token) {
+                headers['Authorization'] = `Bearer ${token}`;
+            }
+
+            let res = await fetch(ghUrl, { headers });
+
+            // If user 404, try as org
+            if (res.status === 404) {
+                ghUrl = `https://api.github.com/orgs/${encodeURIComponent(user)}/repos?per_page=${perPage}&page=${page}&sort=${sort}&direction=desc`;
+                res = await fetch(ghUrl, { headers });
+            }
+
+            if (res.status === 403) {
+                const rateLimitReset = res.headers.get('x-ratelimit-reset');
+                const resetTime = rateLimitReset ? new Date(parseInt(rateLimitReset) * 1000).toLocaleTimeString() : 'soon';
+                return Response.json({
+                    error: `GitHub API rate limit exceeded. Resets at ${resetTime}. Set GITHUB_TOKEN env var for higher limits.`
+                }, { status: 429 });
+            }
+
+            if (!res.ok) {
+                return Response.json({ error: `GitHub user/org "${user}" not found` }, { status: 404 });
+            }
+
+            const repos = await res.json();
+
+            // Parse Link header for pagination
+            const linkHeader = res.headers.get('link') || '';
+            const hasNext = linkHeader.includes('rel="next"');
+            const hasPrev = page > 1;
+
+            // Extract useful fields
+            const items = repos.map((r: any) => ({
+                name: r.name,
+                full_name: r.full_name,
+                description: r.description || '',
+                clone_url: r.clone_url,
+                html_url: r.html_url,
+                language: r.language,
+                stars: r.stargazers_count,
+                forks: r.forks_count,
+                updated_at: r.updated_at,
+                size: r.size, // KB
+                default_branch: r.default_branch,
+                is_fork: r.fork,
+                topics: r.topics || [],
+            }));
+
+            // Also fetch user/org profile info
+            let profile = null;
+            try {
+                const profileRes = await fetch(`https://api.github.com/users/${encodeURIComponent(user)}`, { headers });
+                if (profileRes.ok) {
+                    const p = await profileRes.json();
+                    profile = {
+                        login: p.login,
+                        name: p.name,
+                        avatar_url: p.avatar_url,
+                        bio: p.bio,
+                        public_repos: p.public_repos,
+                        type: p.type, // "User" or "Organization"
+                    };
+                }
+            } catch { /* ignore profile fetch errors */ }
+
+            return Response.json({
+                repos: items,
+                page,
+                hasNext,
+                hasPrev,
+                profile,
+            });
+        } catch (error: any) {
+            console.error('api:github:repos:error', error);
+            return Response.json(
+                { error: error.message || 'Failed to fetch repos' },
+                { status: 500 }
+            );
+        }
+    });
+}

package/app/api/positions/route.ts

@@ -0,0 +1,80 @@
+import { measure, measureSync } from 'measure-fn';
+import { Database, z } from 'sqlite-zod-orm';
+import path from 'path';
+
+const dbPath = path.join(process.cwd(), 'db', 'positions_v3.sqlite');
+
+const db = new Database(dbPath, {
+    positions: z.object({
+        commit_hash: z.string(),
+        file_path: z.string(),
+        x: z.number(),
+        y: z.number(),
+        width: z.number().optional(),
+        height: z.number().optional(),
+    }),
+}, {
+    indexes: { positions: ['commit_hash'] },
+    reactive: false,
+});
+
+export async function GET(req: Request) {
+    return measure('api:positions:get', async () => {
+        try {
+            const url = new URL(req.url);
+            const commitHash = url.searchParams.get('commit');
+
+            const query = commitHash
+                ? db.positions.select().where({ commit_hash: commitHash })
+                : db.positions.select();
+
+            const positions = query.all();
+
+            // Convert to map format
+            const positionMap: Record<string, { x: number; y: number; width?: number; height?: number }> = {};
+            for (const pos of positions) {
+                positionMap[`${pos.commit_hash}:${pos.file_path}`] = {
+                    x: pos.x,
+                    y: pos.y,
+                    width: pos.width ?? undefined,
+                    height: pos.height ?? undefined,
+                };
+            }
+
+            return Response.json(positionMap);
+        } catch (error: any) {
+            console.error('api:positions:get:error', error);
+            return new Response(`Error: ${error.message}`, { status: 500 });
+        }
+    });
+}
+
+export async function POST(req: Request) {
+    return measure('api:positions:save', async () => {
+        try {
+            const body = await req.json();
+            const { commitHash, filePath, x, y, width, height } = body;
+
+            if (!commitHash || !filePath || x === undefined || y === undefined) {
+                return new Response('commitHash, filePath, x, and y are required', { status: 400 });
+            }
+
+            db.positions.upsert(
+                { commit_hash: commitHash, file_path: filePath },
+                {
+                    commit_hash: commitHash,
+                    file_path: filePath,
+                    x,
+                    y,
+                    width: width || undefined,
+                    height: height || undefined,
+                },
+            );
+
+            return Response.json({ success: true });
+        } catch (error: any) {
+            console.error('api:positions:save:error', error);
+            return new Response(`Error: ${error.message}`, { status: 500 });
+        }
+    });
+}

package/app/api/repo/branch-diff/route.ts

@@ -0,0 +1,201 @@
+import { measure } from 'measure-fn';
+import simpleGit from 'simple-git';
+import { validateRepoPath } from '../validate-path';
+
+/**
+ * POST /api/repo/branch-diff
+ *
+ * Compare two branches and return the diff (changed files with hunks).
+ * Body: { path: string, base: string, compare: string }
+ *
+ * Returns the same shape as /api/repo/files (commit diff) so the
+ * existing card rendering (createFileCard, DiffCardPlugin) can be
+ * reused without changes.
+ */
+
+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) {
+        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;
+        }
+
+        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;
+}
+
+export async function POST(req: Request) {
+    return measure('api:repo:branch-diff', async () => {
+        try {
+            const { path: repoPath, base, compare } = await req.json();
+
+            if (!repoPath || !base || !compare) {
+                return new Response('path, base, and compare are required', { status: 400 });
+            }
+
+            const blocked = validateRepoPath(repoPath);
+            if (blocked) return blocked;
+
+            const git = simpleGit(repoPath);
+
+            // Get list of changed files between the two branches
+            const nameStatus = await git.raw([
+                'diff', '--name-status', '-M30%', `${base}...${compare}`
+            ]);
+
+            if (!nameStatus.trim()) {
+                // Still fetch branches even when no diff
+                const branchSummary = await git.branchLocal();
+                return Response.json({
+                    files: [],
+                    totalChanged: 0,
+                    base,
+                    compare,
+                    mergeBase: base,
+                    branches: branchSummary.all,
+                });
+            }
+
+            // Get merge base for accurate stats
+            let mergeBase = base;
+            try {
+                mergeBase = (await git.raw(['merge-base', base, compare])).trim();
+            } catch { /* use base as fallback */ }
+
+            const changedFiles = [];
+            const lines = nameStatus.trim().split('\n').filter(Boolean);
+
+            // Get branches list for the response
+            const branchSummary = await git.branchLocal();
+
+            for (const line of lines) {
+                const parts = line.split('\t');
+                const statusCode = parts[0];
+                if (!statusCode || parts.length < 2) continue;
+
+                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') {
+                    try { content = await git.show([`${compare}:${filePath}`]); } catch (e: any) { error = e.message; }
+                } else if (fileStatus === 'deleted') {
+                    try { content = await git.show([`${base}:${filePath}`]); } catch (e: any) { error = e.message; }
+                } else if (fileStatus === 'modified') {
+                    try {
+                        const rawDiff = await git.raw(['diff', '-U3', `${base}...${compare}`, '--', filePath]);
+                        hunks = parseHunks(rawDiff);
+                    } catch (e: any) { error = e.message; }
+                    try { content = await git.show([`${compare}:${filePath}`]); } catch { /* hunks enough */ }
+                } else if (fileStatus === 'renamed' || fileStatus === 'copied') {
+                    try {
+                        const rawDiff = await git.raw([
+                            'diff', '-U3', '-M',
+                            `${base}...${compare}`,
+                            '--', oldPath!, filePath
+                        ]);
+                        hunks = parseHunks(rawDiff);
+                    } catch (e: any) { error = e.message; }
+                    try { content = await git.show([`${compare}:${filePath}`]); } catch { /* ignore */ }
+                }
+
+                changedFiles.push({
+                    path: filePath,
+                    name,
+                    type: 'file',
+                    status: fileStatus,
+                    content,
+                    hunks,
+                    contentError: error,
+                    lines: content ? content.split('\n').length : 0,
+                    ...(oldPath ? { oldPath } : {}),
+                    ...(similarity != null ? { similarity } : {}),
+                });
+            }
+
+            // Stats summary
+            let totalAdd = 0, totalDel = 0;
+            try {
+                const statOutput = await git.raw(['diff', '--stat', `${base}...${compare}`]);
+                const statMatch = statOutput.match(/(\d+) insertions?\(\+\)/);
+                const delMatch = statOutput.match(/(\d+) deletions?\(-\)/);
+                totalAdd = statMatch ? parseInt(statMatch[1]) : 0;
+                totalDel = delMatch ? parseInt(delMatch[1]) : 0;
+            } catch { /* ignore */ }
+
+            return Response.json({
+                files: changedFiles,
+                totalChanged: changedFiles.length,
+                base,
+                compare,
+                mergeBase,
+                stats: { totalAdd, totalDel },
+                branches: branchSummary.all,
+            });
+        } catch (error: any) {
+            console.error('api:repo:branch-diff:error', error);
+            return new Response(`Error: ${error.message}`, { status: 500 });
+        }
+    });
+}

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

@@ -0,0 +1,53 @@
+import { measure } from 'measure-fn';
+import simpleGit from 'simple-git';
+import { validateRepoPath } from '../validate-path';
+
+/**
+ * POST /api/repo/branches
+ *
+ * List all branches (local + optionally remote) for a repository.
+ * Body: { path: string, includeRemote?: boolean }
+ *
+ * Returns: { branches: string[], current: string, remote?: string[] }
+ */
+
+export async function POST(req: Request) {
+    return measure('api:repo:branches', async () => {
+        try {
+            const { path: repoPath, includeRemote } = await req.json();
+
+            if (!repoPath) {
+                return new Response('path is required', { status: 400 });
+            }
+
+            const blocked = validateRepoPath(repoPath);
+            if (blocked) return blocked;
+
+            const git = simpleGit(repoPath);
+
+            // Get local branches
+            const branchSummary = await git.branchLocal();
+            const result: any = {
+                branches: branchSummary.all,
+                current: branchSummary.current,
+            };
+
+            // Optionally include remote branches
+            if (includeRemote) {
+                try {
+                    const remoteBranches = await git.branch(['-r']);
+                    result.remote = remoteBranches.all
+                        .filter(b => !b.includes('HEAD'))
+                        .map(b => b.replace(/^origin\//, ''));
+                } catch {
+                    result.remote = [];
+                }
+            }
+
+            return Response.json(result);
+        } catch (error: any) {
+            console.error('api:repo:branches:error', error);
+            return new Response(`Error: ${error.message}`, { status: 500 });
+        }
+    });
+}

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

@@ -0,0 +1,55 @@
+import { measure } from 'measure-fn';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { blockInProduction } from '../validate-path';
+
+const execAsync = promisify(exec);
+
+export async function POST(req: Request) {
+    const blocked = blockInProduction('Folder browser');
+    if (blocked) return blocked;
+
+    return measure('api:repo:browse', async () => {
+        try {
+            // Use PowerShell with -EncodedCommand to avoid quoting issues
+            // Use TopMost Form to ensure the dialog pops up ABOVE the browser window
+            const psScript = `
+Add-Type -AssemblyName System.Windows.Forms
+$dialog = New-Object System.Windows.Forms.FolderBrowserDialog
+$dialog.Description = "Select Git Repository"
+$dialog.ShowNewFolderButton = $false
+
+$form = New-Object System.Windows.Forms.Form
+$form.TopMost = $true
+$result = $dialog.ShowDialog($form)
+
+if ($result -eq [System.Windows.Forms.DialogResult]::OK) {
+    Write-Output $dialog.SelectedPath
+} else {
+    Write-Output ""
+}
+$form.Dispose()
+`.trim();
+
+            const encoded = Buffer.from(psScript, 'utf16le').toString('base64');
+
+            // Use async exec so we don't block the entire melina server (which freezes the UI's live updates)
+            const { stdout } = await execAsync(
+                `powershell -sta -WindowStyle Hidden -NoProfile -EncodedCommand ${encoded}`,
+                { encoding: 'utf-8', timeout: 86400000 }
+            );
+
+            const selected = stdout.trim();
+
+            if (!selected) {
+                return Response.json({ cancelled: true, path: null });
+            }
+
+            return Response.json({ cancelled: false, path: selected });
+        } catch (error: any) {
+            console.error('api:repo:browse:error', error);
+            // Even if cancelled or errored, don't crash the server. Let UI reset the dropdown.
+            return Response.json({ cancelled: true, path: null, error: error.message });
+        }
+    });
+}

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

@@ -0,0 +1,78 @@
+import { measure } from 'measure-fn';
+import simpleGit from 'simple-git';
+import path from 'path';
+import fs from 'fs';
+
+const CLONES_DIR = path.join(process.cwd(), 'git-canvas', 'repos');
+
+/**
+ * POST /api/repo/clone
+ * Body: { url: string }
+ * Clones a remote git repo into git-canvas/repos/<name> and returns the local path.
+ * If already cloned, returns existing path immediately.
+ */
+export async function POST(req: Request) {
+    return measure('api:repo:clone', async () => {
+        try {
+            const { url } = await req.json() as { url: string };
+
+            if (!url || typeof url !== 'string') {
+                return Response.json({ error: 'url is required' }, { status: 400 });
+            }
+
+            // Validate URL format (git@... or https://...)
+            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 });
+            }
+
+            // Derive folder name from URL
+            // e.g. https://github.com/user/repo.git → repo
+            // e.g. git@github.com:user/repo.git → repo
+            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 });
+            }
+
+            // Ensure clones directory exists
+            fs.mkdirSync(CLONES_DIR, { recursive: true });
+
+            const targetPath = path.join(CLONES_DIR, repoName);
+
+            // Check if already cloned
+            if (fs.existsSync(path.join(targetPath, '.git'))) {
+                // Pull latest
+                try {
+                    const git = simpleGit(targetPath);
+                    await git.pull();
+                    console.log(`[clone] Updated existing repo: ${repoName}`);
+                } catch {
+                    // Pull failed (maybe detached HEAD, dirty, etc) — that's fine
+                    console.log(`[clone] Using existing repo (pull skipped): ${repoName}`);
+                }
+                return Response.json({ ok: true, path: targetPath, cached: true });
+            }
+
+            // Clone
+            console.log(`[clone] Cloning ${url} → ${targetPath}`);
+            const git = simpleGit();
+            await git.clone(url, targetPath, ['--depth', '100']);
+
+            console.log(`[clone] ✅ Cloned ${repoName}`);
+            return Response.json({ ok: true, path: targetPath, cached: false });
+        } catch (error: any) {
+            console.error('api:repo:clone:error', error);
+            return Response.json(
+                { error: error.message || 'Clone failed' },
+                { status: 500 }
+            );
+        }
+    });
+}