gitmaps 1.1.0 → 1.1.1

package/app/api/build-info/route.ts

@@ -0,0 +1,19 @@
+import path from 'path';
+
+function runGit(args: string[]): string {
+    const repoRoot = path.resolve(import.meta.dir, '../../..');
+    const proc = Bun.spawnSync(['git', ...args], {
+        cwd: repoRoot,
+        stdout: 'pipe',
+        stderr: 'pipe',
+    });
+
+    if (proc.exitCode !== 0) return '';
+    return proc.stdout.toString().trim();
+}
+
+export async function GET() {
+    const commit = process.env.GIT_COMMIT_HASH || runGit(['rev-parse', '--short', 'HEAD']) || 'unknown';
+    const commitDate = process.env.GIT_COMMIT_DATE || runGit(['log', '-1', '--format=%cs']) || '';
+    return Response.json({ commit, commitDate });
+}

package/app/api/chat/route.ts

@@ -41,7 +41,12 @@ Help the user understand this file. You can:
 - Suggest refactorings
 - Explain the diff/changes
 
-Be concise but thorough. Use code blocks with language tags for code examples. Reference line numbers when relevant.`;
+Be concise but thorough. Use code blocks with language tags for code examples. Reference line numbers when relevant.
+
+To suggest physical refactors or file changes, ALWAYS use the following format:
+<edit_file path="path/to/file.ts">
+// Full replacement file content goes here
+</edit_file>`;
             } else if (canvasContext) {
                 systemPrompt = `You are an AI code assistant helping analyze a Git repository's commit changes.
 
@@ -51,7 +56,13 @@ CURRENT COMMIT: ${canvasContext.commitHash || 'none'} — ${canvasContext.commit
 FILES ON CANVAS:
 ${(canvasContext.files || []).map(f => `- ${f.path} (${f.status})`).join('\n')}
 
-Help the user understand the codebase, the commit changes, relationships between files, architecture patterns, and potential issues. Be concise and actionable.`;
+Help the user understand the codebase, the commit changes, relationships between files, architecture patterns, and potential issues. Be concise and actionable.
+
+To suggest physical refactors or file changes, ALWAYS use the following format:
+<edit_file path="path/to/file.ts">
+// Full replacement file content goes here
+</edit_file>
+You may output multiple <edit_file> blocks in a single response to perform bulk refactoring across multiple files.`;
             } else {
                 systemPrompt = `You are an AI code assistant. Help the user with their coding questions. Be concise and use code blocks with language tags.`;
             }

package/app/api/og-image/route.ts

@@ -0,0 +1,14 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+const ogBuffer = readFileSync(join(import.meta.dir, '..', '..', 'og-image.png'));
+
+// GET /api/og-image — serves the Open Graph social sharing image
+export function GET() {
+    return new Response(ogBuffer, {
+        headers: {
+            'Content-Type': 'image/png',
+            'Cache-Control': 'public, max-age=86400',
+        },
+    });
+}

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

@@ -1,28 +1,81 @@
-import { measure } from 'measure-fn';
-import simpleGit from 'simple-git';
-import { validateRepoPath } from '../validate-path';
+import { measure } from "measure-fn";
+import simpleGit from "simple-git";
+import { readFileSync } from "fs";
+import path from "path";
+import { validateRepoPath } from "../validate-path";
+
+const MIME_TYPES: Record<string, string> = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".bmp": "image/bmp",
+  ".ico": "image/x-icon",
+};
 
 export async function POST(req: Request) {
-    return measure('api:repo:file-content', async () => {
-        try {
-            const { path: repoPath, commit, filePath } = await req.json();
+  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);
+      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 });
+    }
+  });
+}
+
+export async function GET(req: Request) {
+  return measure("api:repo:file-image", async () => {
+    try {
+      const url = new URL(req.url);
+      const repoPath = url.searchParams.get("path");
+      const file = url.searchParams.get("file");
+
+      if (!repoPath || !file) {
+        return new Response("Repository path and file are required", {
+          status: 400,
+        });
+      }
 
-            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 blocked = validateRepoPath(repoPath);
-            if (blocked) return blocked;
+      const ext = path.extname(file).toLowerCase();
+      const mimeType = MIME_TYPES[ext];
 
-            const git = simpleGit(repoPath);
+      if (!mimeType) {
+        return new Response("Not an image file", { status: 400 });
+      }
 
-            // Get file content at this commit
-            const content = await git.show([`${commit}:${filePath}`]);
+      const fullPath = path.join(repoPath, file);
+      const buffer = readFileSync(fullPath);
 
-            return Response.json({ content });
-        } catch (error: any) {
-            console.error('api:repo:file-content:error', error);
-            return new Response(`Error: ${error.message}`, { status: 500 });
-        }
-    });
+      return new Response(buffer, {
+        headers: {
+          "Content-Type": mimeType,
+          "Cache-Control": "public, max-age=31536000",
+        },
+      });
+    } catch (error: any) {
+      console.error("api:repo:file-image:error", error);
+      return new Response(`Error: ${error.message}`, { status: 500 });
+    }
+  });
 }

package/app/api/repo/load/route.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from 'bun:test';
+import { extractCanonicalForgeSlugInfo } from './route';
+
+describe('extractCanonicalForgeSlugInfo', () => {
+    test('parses GitHub HTTPS remote', () => {
+        expect(
+            extractCanonicalForgeSlugInfo('https://github.com/7flash/gitmaps.git')
+        ).toEqual({
+            slug: '7flash/gitmaps',
+            source: 'github.com · https://github.com/7flash/gitmaps',
+        });
+    });
+
+    test('parses GitHub SSH remote', () => {
+        expect(
+            extractCanonicalForgeSlugInfo('git@github.com:7flash/gitmaps.git')
+        ).toEqual({
+            slug: '7flash/gitmaps',
+            source: 'github.com · git@github.com:7flash/gitmaps',
+        });
+    });
+
+    test('preserves deep GitLab namespace', () => {
+        expect(
+            extractCanonicalForgeSlugInfo('git@gitlab.com:team/platform/tools/gitmaps.git')
+        ).toEqual({
+            slug: 'team/platform/tools/gitmaps',
+            source: 'gitlab.com · git@gitlab.com:team/platform/tools/gitmaps',
+        });
+    });
+
+    test('filters forge helper path segments like scm', () => {
+        expect(
+            extractCanonicalForgeSlugInfo('https://git.example.com/scm/team/gitmaps.git')
+        ).toEqual({
+            slug: 'team/gitmaps',
+            source: 'git.example.com · https://git.example.com/scm/team/gitmaps',
+        });
+    });
+
+    test('returns null slug for too-deep namespaces', () => {
+        expect(
+            extractCanonicalForgeSlugInfo('https://git.example.com/a/b/c/d/e/f.git')
+        ).toEqual({
+            slug: null,
+            source: 'https://git.example.com/a/b/c/d/e/f',
+        });
+    });
+
+    test('returns null slug for invalid segments', () => {
+        expect(
+            extractCanonicalForgeSlugInfo('https://git.example.com/team/bad:name.git')
+        ).toEqual({
+            slug: null,
+            source: 'https://git.example.com/team/bad:name',
+        });
+    });
+
+    test('handles missing remote gracefully', () => {
+        expect(extractCanonicalForgeSlugInfo(null)).toEqual({ slug: null, source: '' });
+    });
+});

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

@@ -3,6 +3,33 @@ import simpleGit from 'simple-git';
 import path from 'path';
 import { validateRepoPath } from '../validate-path';
 
+export function extractCanonicalForgeSlugInfo(remoteUrl?: string | null): { slug: string | null; source: string } {
+    if (!remoteUrl) return { slug: null, source: '' };
+
+    const normalized = remoteUrl.trim().replace(/\.git$/i, '');
+
+    const sshMatch = normalized.match(/^[^@]+@([^:]+):(.+)$/);
+    const httpsMatch = normalized.match(/^(?:https?|ssh):\/\/([^/]+)\/(.+)$/i);
+    const host = sshMatch?.[1] || httpsMatch?.[1] || '';
+    const pathPart = sshMatch?.[2] || httpsMatch?.[2];
+    if (!pathPart) return { slug: null, source: normalized };
+
+    const segments = pathPart
+        .split('/')
+        .map(s => s.trim())
+        .filter(Boolean)
+        .filter(s => s !== '-' && s !== 'scm');
+
+    if (segments.length < 2) return { slug: null, source: normalized };
+    if (segments.length > 5) return { slug: null, source: normalized };
+    if (segments.some(part => /[:\\]/.test(part))) return { slug: null, source: normalized };
+
+    return {
+        slug: segments.join('/'),
+        source: host ? `${host} · ${normalized}` : normalized,
+    };
+}
+
 export async function POST(req: Request) {
     return measure('api:repo:load', async () => {
         try {
@@ -47,7 +74,20 @@ export async function POST(req: Request) {
                 refs: commit.refs ? commit.refs.split(',').map(r => r.trim()).filter(Boolean) : []
             }));
 
-            return Response.json({ commits });
+            let canonicalSlug: string | null = null;
+            let canonicalSlugSource = '';
+            try {
+                const remotes = await git.getRemotes(true);
+                const origin = remotes.find(r => r.name === 'origin') || remotes[0];
+                const info = extractCanonicalForgeSlugInfo(origin?.refs?.fetch || origin?.refs?.push || null);
+                canonicalSlug = info.slug;
+                canonicalSlugSource = info.source;
+            } catch {
+                canonicalSlug = null;
+                canonicalSlugSource = '';
+            }
+
+            return Response.json({ commits, canonicalSlug, canonicalSlugSource });
         } catch (error: any) {
             console.error('api:repo:load:error', error);
             return new Response(`Error: ${error.message}`, { status: 500 });

package/app/api/repo/pdf-thumb/route.ts

@@ -0,0 +1,127 @@
+import path from 'path';
+import { existsSync } from 'fs';
+import { validateRepoPath } from '../validate-path';
+
+/**
+ * GET /api/repo/pdf-thumb?path=REPO&file=FILE&page=0&width=600
+ *
+ * Converts a PDF page to a PNG thumbnail using Bun's native sharp or
+ * falls back to pdftoppm (poppler-utils) if available.
+ * Returns the image directly as image/png.
+ */
+export async function GET(req: Request) {
+    const url = new URL(req.url);
+    const repoPath = url.searchParams.get('path') || '';
+    const filePath = url.searchParams.get('file') || '';
+    const page = parseInt(url.searchParams.get('page') || '0', 10);
+    const width = parseInt(url.searchParams.get('width') || '800', 10);
+
+    if (!repoPath || !filePath) {
+        return new Response('path and file params required', { status: 400 });
+    }
+
+    const blocked = validateRepoPath(repoPath);
+    if (blocked) return blocked;
+
+    // Prevent path traversal
+    if (filePath.includes('..') || filePath.startsWith('/')) {
+        return new Response('Invalid file path', { status: 400 });
+    }
+
+    const fullPath = path.join(repoPath, filePath);
+    if (!existsSync(fullPath)) {
+        return new Response('File not found', { status: 404 });
+    }
+
+    // Cache key based on file path + modification time
+    const file = Bun.file(fullPath);
+    const cacheKey = `pdf-thumb:${fullPath}:${file.size}:p${page}:w${width}`;
+
+    // Try pdftoppm (poppler-utils) — most reliable cross-platform PDF renderer
+    try {
+        const proc = Bun.spawnSync([
+            'pdftoppm',
+            '-png',
+            '-f', String(page + 1),
+            '-l', String(page + 1),
+            '-scale-to-x', String(width),
+            '-scale-to-y', '-1',
+            '-singlefile',
+            fullPath,
+            '-',
+        ], {
+            stdout: 'pipe',
+            stderr: 'pipe',
+            timeout: 15000,
+        });
+
+        if (proc.exitCode === 0 && proc.stdout.length > 0) {
+            return new Response(proc.stdout, {
+                headers: {
+                    'Content-Type': 'image/png',
+                    'Cache-Control': 'public, max-age=86400',
+                },
+            });
+        }
+
+        // pdftoppm outputs to stdout with `-` but some versions need a prefix
+        // Try alternative invocation
+        const proc2 = Bun.spawnSync([
+            'pdftoppm',
+            '-png',
+            '-f', String(page + 1),
+            '-l', String(page + 1),
+            '-scale-to-x', String(width),
+            '-scale-to-y', '-1',
+            '-singlefile',
+            fullPath,
+        ], {
+            stdout: 'pipe',
+            stderr: 'pipe',
+            timeout: 15000,
+        });
+
+        if (proc2.exitCode === 0 && proc2.stdout.length > 0) {
+            return new Response(proc2.stdout, {
+                headers: {
+                    'Content-Type': 'image/png',
+                    'Cache-Control': 'public, max-age=86400',
+                },
+            });
+        }
+    } catch (_) {
+        // pdftoppm not available
+    }
+
+    // Fallback: try magick (ImageMagick)
+    try {
+        const proc = Bun.spawnSync([
+            'magick',
+            '-density', '150',
+            `${fullPath}[${page}]`,
+            '-resize', `${width}x`,
+            'png:-',
+        ], {
+            stdout: 'pipe',
+            stderr: 'pipe',
+            timeout: 30000,
+        });
+
+        if (proc.exitCode === 0 && proc.stdout.length > 0) {
+            return new Response(proc.stdout, {
+                headers: {
+                    'Content-Type': 'image/png',
+                    'Cache-Control': 'public, max-age=86400',
+                },
+            });
+        }
+    } catch (_) {
+        // magick not available
+    }
+
+    // No PDF renderer available — return a helpful placeholder
+    return new Response('PDF preview requires poppler-utils (pdftoppm) or ImageMagick (magick). Install one to enable PDF thumbnails.', {
+        status: 501,
+        headers: { 'Content-Type': 'text/plain' },
+    });
+}

package/app/api/repo/resolve-slug/route.ts

@@ -0,0 +1,51 @@
+import { existsSync, readdirSync, statSync } from 'fs';
+import path from 'path';
+import simpleGit from 'simple-git';
+import { extractCanonicalForgeSlugInfo } from '../load/route';
+
+const CLONES_DIR = path.join(process.cwd(), 'git-canvas', 'repos');
+
+async function findRepoByCanonicalSlug(slug: string): Promise<string | null> {
+  if (!slug || !existsSync(CLONES_DIR)) return null;
+
+  const entries = readdirSync(CLONES_DIR);
+  for (const entry of entries) {
+    const fullPath = path.join(CLONES_DIR, entry);
+    try {
+      const stat = statSync(fullPath);
+      if (!stat.isDirectory()) continue;
+      if (!existsSync(path.join(fullPath, '.git'))) continue;
+
+      try {
+        const git = simpleGit(fullPath);
+        const remotes = await git.getRemotes(true);
+        const origin = remotes.find((r) => r.name === 'origin') || remotes[0];
+        const info = extractCanonicalForgeSlugInfo(origin?.refs?.fetch || origin?.refs?.push || null);
+        if (info.slug === slug) {
+          return fullPath.replace(/\\/g, '/');
+        }
+      } catch {
+        // ignore invalid repos
+      }
+    } catch {
+      // ignore bad entries
+    }
+  }
+
+  return null;
+}
+
+export async function POST(req: Request) {
+  try {
+    const { slug } = await req.json() as { slug?: string };
+    const normalizedSlug = (slug || '').trim().replace(/^\/+|\/+$/g, '');
+    if (!normalizedSlug) {
+      return Response.json({ error: 'slug is required' }, { status: 400 });
+    }
+
+    const resolvedPath = await findRepoByCanonicalSlug(normalizedSlug);
+    return Response.json({ path: resolvedPath });
+  } catch (error: any) {
+    return Response.json({ error: error?.message || 'Failed to resolve slug' }, { status: 500 });
+  }
+}