@geminilight/mindos 0.1.0

package/app/app/api/ask/route.ts

@@ -0,0 +1,170 @@
+export const dynamic = 'force-dynamic';
+import { streamText, stepCountIs, type ModelMessage } from 'ai';
+import { NextRequest, NextResponse } from 'next/server';
+import fs from 'fs';
+import path from 'path';
+import { getFileContent, getMindRoot } from '@/lib/fs';
+import { getModel, knowledgeBaseTools, truncate, AGENT_SYSTEM_PROMPT } from '@/lib/agent';
+
+function readKnowledgeFile(filePath: string): { ok: boolean; content: string; error?: string } {
+  try {
+    return { ok: true, content: truncate(getFileContent(filePath)) };
+  } catch (err) {
+    return { ok: false, content: '', error: err instanceof Error ? err.message : String(err) };
+  }
+}
+
+function readAbsoluteFile(absPath: string): { ok: boolean; content: string; error?: string } {
+  try {
+    const raw = fs.readFileSync(absPath, 'utf-8');
+    return { ok: true, content: truncate(raw) };
+  } catch (err) {
+    return { ok: false, content: '', error: err instanceof Error ? err.message : String(err) };
+  }
+}
+
+function dirnameOf(filePath?: string): string | null {
+  if (!filePath) return null;
+  const normalized = filePath.replace(/\\/g, '/');
+  const idx = normalized.lastIndexOf('/');
+  if (idx <= 0) return null;
+  return normalized.slice(0, idx);
+}
+
+export async function POST(req: NextRequest) {
+  let body: {
+    messages: ModelMessage[];
+    currentFile?: string;
+    attachedFiles?: string[];
+    uploadedFiles?: Array<{ name: string; content: string }>;
+    maxSteps?: number;
+  };
+  try {
+    body = await req.json();
+  } catch {
+    return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 });
+  }
+
+  const { messages, currentFile, attachedFiles, uploadedFiles, maxSteps } = body;
+  const stepLimit = Number.isFinite(maxSteps) ? Math.min(30, Math.max(1, Number(maxSteps))) : 20;
+
+  // Auto-load skill + bootstrap context for each request.
+  const skillPath = path.resolve(process.cwd(), 'data/skills/mindos/SKILL.md');
+  const skill = readAbsoluteFile(skillPath);
+
+  const targetDir = dirnameOf(currentFile);
+  const bootstrap = {
+    instruction: readKnowledgeFile('INSTRUCTION.md'),
+    index: readKnowledgeFile('README.md'),
+    config_json: readKnowledgeFile('CONFIG.json'),
+    config_md: readKnowledgeFile('CONFIG.md'),
+    target_readme: targetDir ? readKnowledgeFile(`${targetDir}/README.md`) : null,
+    target_instruction: targetDir ? readKnowledgeFile(`${targetDir}/INSTRUCTION.md`) : null,
+    target_config_json: targetDir ? readKnowledgeFile(`${targetDir}/CONFIG.json`) : null,
+    target_config_md: targetDir ? readKnowledgeFile(`${targetDir}/CONFIG.md`) : null,
+  };
+
+  const initStatus = [
+    `skill.mindos: ${skill.ok ? 'ok' : `failed (${skill.error})`} [${skillPath}]`,
+    `bootstrap.instruction: ${bootstrap.instruction.ok ? 'ok' : `failed (${bootstrap.instruction.error})`}`,
+    `bootstrap.index: ${bootstrap.index.ok ? 'ok' : `failed (${bootstrap.index.error})`}`,
+    `bootstrap.config_json: ${bootstrap.config_json.ok ? 'ok' : `failed (${bootstrap.config_json.error})`}`,
+    `bootstrap.config_md: ${bootstrap.config_md.ok ? 'ok' : `failed (${bootstrap.config_md.error})`}`,
+    `bootstrap.target_dir: ${targetDir ?? '(none)'}`,
+    `bootstrap.target_readme: ${bootstrap.target_readme ? (bootstrap.target_readme.ok ? 'ok' : `failed (${bootstrap.target_readme.error})`) : 'skipped'}`,
+    `bootstrap.target_instruction: ${bootstrap.target_instruction ? (bootstrap.target_instruction.ok ? 'ok' : `failed (${bootstrap.target_instruction.error})`) : 'skipped'}`,
+    `bootstrap.target_config_json: ${bootstrap.target_config_json ? (bootstrap.target_config_json.ok ? 'ok' : `failed (${bootstrap.target_config_json.error})`) : 'skipped'}`,
+    `bootstrap.target_config_md: ${bootstrap.target_config_md ? (bootstrap.target_config_md.ok ? 'ok' : `failed (${bootstrap.target_config_md.error})`) : 'skipped'}`,
+    `bootstrap.mind_root: ${getMindRoot()}`,
+  ].join('\n');
+
+  const initContextBlocks: string[] = [];
+  if (skill.ok) initContextBlocks.push(`## mindos_skill_md\n\n${skill.content}`);
+  if (bootstrap.instruction.ok) initContextBlocks.push(`## bootstrap_instruction\n\n${bootstrap.instruction.content}`);
+  if (bootstrap.index.ok) initContextBlocks.push(`## bootstrap_index\n\n${bootstrap.index.content}`);
+  if (bootstrap.config_json.ok) initContextBlocks.push(`## bootstrap_config_json\n\n${bootstrap.config_json.content}`);
+  if (bootstrap.config_md.ok) initContextBlocks.push(`## bootstrap_config_md\n\n${bootstrap.config_md.content}`);
+  if (bootstrap.target_readme?.ok) initContextBlocks.push(`## bootstrap_target_readme\n\n${bootstrap.target_readme.content}`);
+  if (bootstrap.target_instruction?.ok) initContextBlocks.push(`## bootstrap_target_instruction\n\n${bootstrap.target_instruction.content}`);
+  if (bootstrap.target_config_json?.ok) initContextBlocks.push(`## bootstrap_target_config_json\n\n${bootstrap.target_config_json.content}`);
+  if (bootstrap.target_config_md?.ok) initContextBlocks.push(`## bootstrap_target_config_md\n\n${bootstrap.target_config_md.content}`);
+
+  // Build initial context from attached/current files
+  const contextParts: string[] = [];
+  const seen = new Set<string>();
+  const hasAttached = Array.isArray(attachedFiles) && attachedFiles.length > 0;
+
+  if (hasAttached) {
+    for (const filePath of attachedFiles) {
+      if (seen.has(filePath)) continue;
+      seen.add(filePath);
+      try {
+        const content = truncate(getFileContent(filePath));
+        contextParts.push(`## Attached: ${filePath}\n\n${content}`);
+      } catch {}
+    }
+  }
+
+  if (currentFile && !seen.has(currentFile)) {
+    seen.add(currentFile);
+    try {
+      const content = truncate(getFileContent(currentFile));
+      contextParts.push(`## Current file: ${currentFile}\n\n${content}`);
+    } catch {}
+  }
+
+  // Uploaded files go into a SEPARATE top-level section so the Agent
+  // treats them with high priority and never tries to look them up via tools.
+  const uploadedParts: string[] = [];
+  if (Array.isArray(uploadedFiles) && uploadedFiles.length > 0) {
+    for (const f of uploadedFiles.slice(0, 8)) {
+      if (!f || typeof f.name !== 'string' || typeof f.content !== 'string') continue;
+      uploadedParts.push(`### ${f.name}\n\n${truncate(f.content)}`);
+    }
+  }
+
+  const promptParts: string[] = [AGENT_SYSTEM_PROMPT];
+  promptParts.push(`---\n\nInitialization status (auto-loaded at request start):\n\n${initStatus}`);
+
+  if (initContextBlocks.length > 0) {
+    promptParts.push(`---\n\nInitialization context:\n\n${initContextBlocks.join('\n\n---\n\n')}`);
+  }
+
+  if (contextParts.length > 0) {
+    promptParts.push(`---\n\nThe user is currently viewing these files:\n\n${contextParts.join('\n\n---\n\n')}`);
+  }
+
+  if (uploadedParts.length > 0) {
+    promptParts.push(
+      `---\n\n## ⚠️ USER-UPLOADED FILES (ACTIVE ATTACHMENTS)\n\n` +
+      `The user has uploaded the following file(s) in this conversation. ` +
+      `Their FULL CONTENT is provided below. You MUST use this content directly when the user refers to these files. ` +
+      `Do NOT use read_file or search tools to find them — they exist only here, not in the knowledge base.\n\n` +
+      uploadedParts.join('\n\n---\n\n'),
+    );
+  }
+
+  const systemPrompt = promptParts.join('\n\n');
+
+  try {
+    const model = getModel();
+    const result = streamText({
+      model,
+      system: systemPrompt,
+      messages,
+      tools: knowledgeBaseTools,
+      stopWhen: stepCountIs(stepLimit),
+      onError: ({ error }) => {
+        console.error('[ask] Stream error:', error);
+      },
+    });
+
+    return result.toTextStreamResponse();
+  } catch (err) {
+    console.error('[ask] Failed to initialize model:', err);
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : 'Failed to initialize AI model' },
+      { status: 500 },
+    );
+  }
+}

package/app/app/api/ask-sessions/route.ts

@@ -0,0 +1,90 @@
+export const dynamic = 'force-dynamic';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { NextRequest, NextResponse } from 'next/server';
+
+interface Message {
+  role: 'user' | 'assistant';
+  content: string;
+}
+
+interface ChatSession {
+  id: string;
+  currentFile?: string;
+  createdAt: number;
+  updatedAt: number;
+  messages: Message[];
+}
+
+const STORE_PATH = path.resolve(os.homedir(), '.mindos', 'sessions.json');
+const MAX_SESSIONS = 30;
+
+function ensureStoreDir() {
+  fs.mkdirSync(path.dirname(STORE_PATH), { recursive: true });
+}
+
+function readSessions(): ChatSession[] {
+  try {
+    const raw = fs.readFileSync(STORE_PATH, 'utf-8');
+    const parsed = JSON.parse(raw) as ChatSession[];
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((s) => s && typeof s.id === 'string' && Array.isArray(s.messages));
+  } catch {
+    return [];
+  }
+}
+
+function writeSessions(sessions: ChatSession[]) {
+  ensureStoreDir();
+  fs.writeFileSync(STORE_PATH, JSON.stringify(sessions.slice(0, MAX_SESSIONS), null, 2), 'utf-8');
+}
+
+export async function GET() {
+  const sessions = readSessions()
+    .sort((a, b) => b.updatedAt - a.updatedAt)
+    .slice(0, MAX_SESSIONS);
+  return NextResponse.json(sessions);
+}
+
+export async function POST(req: NextRequest) {
+  let body: { session?: ChatSession };
+  try {
+    body = await req.json();
+  } catch {
+    return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 });
+  }
+
+  const session = body.session;
+  if (!session || typeof session.id !== 'string' || !Array.isArray(session.messages)) {
+    return NextResponse.json({ error: 'Invalid session payload' }, { status: 400 });
+  }
+
+  const sessions = readSessions();
+  const idx = sessions.findIndex((s) => s.id === session.id);
+  if (idx >= 0) {
+    sessions[idx] = session;
+  } else {
+    sessions.push(session);
+  }
+
+  sessions.sort((a, b) => b.updatedAt - a.updatedAt);
+  writeSessions(sessions);
+  return NextResponse.json({ ok: true });
+}
+
+export async function DELETE(req: NextRequest) {
+  let body: { id?: string };
+  try {
+    body = await req.json();
+  } catch {
+    return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 });
+  }
+
+  const id = body.id;
+  if (!id) return NextResponse.json({ error: 'id is required' }, { status: 400 });
+
+  const sessions = readSessions().filter((s) => s.id !== id);
+  writeSessions(sessions);
+  return NextResponse.json({ ok: true });
+}

package/app/app/api/auth/route.ts

@@ -0,0 +1,37 @@
+export const dynamic = 'force-dynamic';
+import { NextRequest, NextResponse } from 'next/server';
+import { signJwt } from '@/lib/jwt';
+
+const COOKIE_NAME = 'mindos-session';
+const COOKIE_MAX_AGE = 60 * 60 * 24 * 7; // 7 days
+
+// POST /api/auth — validate password and set JWT session cookie
+export async function POST(req: NextRequest) {
+  const webPassword = process.env.WEB_PASSWORD;
+  if (!webPassword) return NextResponse.json({ ok: false }, { status: 401 });
+
+  const body = await req.json().catch(() => ({})) as { password?: string };
+  if (body.password !== webPassword) return NextResponse.json({ ok: false }, { status: 401 });
+
+  const token = await signJwt(
+    { sub: 'user', exp: Math.floor(Date.now() / 1000) + COOKIE_MAX_AGE },
+    webPassword,
+  );
+
+  // Only set Secure flag when served over HTTPS (x-forwarded-proto set by reverse proxy)
+  const isHttps = req.headers.get('x-forwarded-proto') === 'https';
+  const secure = isHttps ? '; Secure' : '';
+  const res = NextResponse.json({ ok: true });
+  res.headers.set(
+    'Set-Cookie',
+    `${COOKIE_NAME}=${token}; HttpOnly; SameSite=Strict; Max-Age=${COOKIE_MAX_AGE}; Path=/${secure}`,
+  );
+  return res;
+}
+
+// DELETE /api/auth — clear session cookie (logout)
+export async function DELETE() {
+  const res = NextResponse.json({ ok: true });
+  res.headers.set('Set-Cookie', `${COOKIE_NAME}=; HttpOnly; SameSite=Strict; Max-Age=0; Path=/`);
+  return res;
+}

package/app/app/api/backlinks/route.ts

@@ -0,0 +1,22 @@
+export const dynamic = 'force-dynamic';
+import { NextRequest, NextResponse } from 'next/server';
+import { findBacklinks } from '@/lib/fs';
+
+// GET /api/backlinks?path=Profile/Identity.md
+// Returns: Array<{ filePath: string; snippets: string[] }>
+// (transforms core BacklinkEntry shape to frontend-expected shape)
+export async function GET(req: NextRequest) {
+  const target = req.nextUrl.searchParams.get('path');
+  if (!target) return NextResponse.json({ error: 'path required' }, { status: 400 });
+
+  try {
+    const backlinks = findBacklinks(target);
+    // Transform core shape { source, line, context } → frontend shape { filePath, snippets }
+    return NextResponse.json(backlinks.map(b => ({
+      filePath: b.source,
+      snippets: [b.context],
+    })));
+  } catch (e) {
+    return NextResponse.json({ error: (e as Error).message }, { status: 500 });
+  }
+}

package/app/app/api/bootstrap/route.ts

@@ -0,0 +1,37 @@
+export const dynamic = 'force-dynamic';
+import { NextRequest, NextResponse } from 'next/server';
+import { getFileContent } from '@/lib/fs';
+import path from 'path';
+
+function tryRead(filePath: string): string | undefined {
+  try {
+    return getFileContent(filePath);
+  } catch {
+    return undefined;
+  }
+}
+
+// GET /api/bootstrap?target_dir=Workflows/Research
+export async function GET(req: NextRequest) {
+  const targetDir = req.nextUrl.searchParams.get('target_dir') ?? undefined;
+
+  try {
+    const result: Record<string, string | undefined> = {
+      instruction: tryRead('INSTRUCTION.md'),
+      index: tryRead('README.md'),
+      config_json: tryRead('CONFIG.json'),
+      config_md: tryRead('CONFIG.md'),
+    };
+
+    if (targetDir) {
+      result.target_readme = tryRead(path.join(targetDir, 'README.md'));
+      result.target_instruction = tryRead(path.join(targetDir, 'INSTRUCTION.md'));
+      result.target_config_json = tryRead(path.join(targetDir, 'CONFIG.json'));
+      result.target_config_md = tryRead(path.join(targetDir, 'CONFIG.md'));
+    }
+
+    return NextResponse.json(result);
+  } catch (e) {
+    return NextResponse.json({ error: (e as Error).message }, { status: 500 });
+  }
+}

package/app/app/api/extract-pdf/route.ts

@@ -0,0 +1,82 @@
+export const dynamic = 'force-dynamic';
+import { NextRequest, NextResponse } from 'next/server';
+import { execFileSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+
+export const runtime = 'nodejs';
+
+const MAX_TEXT_CHARS = 30_000;
+const MAX_BYTES = 12 * 1024 * 1024; // 12MB
+
+function truncateText(text: string): string {
+  if (text.length <= MAX_TEXT_CHARS) return text;
+  return `${text.slice(0, MAX_TEXT_CHARS)}\n\n[...truncated from PDF]`;
+}
+
+/**
+ * Extract PDF text by spawning a Node child process.
+ *
+ * pdfjs-dist requires a web-worker file. Turbopack rewrites the ESM
+ * `import.meta.url` references inside the bundle, breaking the worker
+ * resolution at runtime. Running the extraction in a plain Node process
+ * avoids the bundler entirely.
+ */
+function extractPdf(buf: Buffer): { text: string; pages: number } {
+  // Write PDF to a temp file so the child script can read it.
+  const tmpDir = os.tmpdir();
+  const tmpPdf = path.join(tmpDir, `pdf-extract-${Date.now()}.pdf`);
+  // Dynamic path construction to prevent Turbopack static analysis
+  const scriptPath = [process.cwd(), 'scripts', 'extract-pdf.cjs'].join(path.sep);
+
+  fs.writeFileSync(tmpPdf, buf);
+  try {
+    const stdout = execFileSync('node', [scriptPath, tmpPdf], {
+      encoding: 'utf-8',
+      timeout: 30_000,
+      maxBuffer: 10 * 1024 * 1024,
+    });
+    return JSON.parse(stdout);
+  } finally {
+    try { fs.unlinkSync(tmpPdf); } catch { /* ignore */ }
+  }
+}
+
+export async function POST(req: NextRequest) {
+  let body: { name?: string; dataBase64?: string };
+  try {
+    body = await req.json();
+  } catch {
+    return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 });
+  }
+
+  const name = body.name ?? 'uploaded.pdf';
+  const dataBase64 = body.dataBase64;
+  if (!dataBase64 || typeof dataBase64 !== 'string') {
+    return NextResponse.json({ error: 'dataBase64 is required' }, { status: 400 });
+  }
+
+  try {
+    const raw = Buffer.from(dataBase64, 'base64');
+    if (raw.byteLength > MAX_BYTES) {
+      return NextResponse.json({ error: 'PDF is too large (max 12MB)' }, { status: 400 });
+    }
+
+    const { text: rawText, pages } = extractPdf(raw);
+    const text = rawText.replace(/\u0000/g, '').trim();
+
+    return NextResponse.json({
+      name,
+      text: truncateText(text),
+      extracted: text.length > 0,
+      pagesParsed: pages,
+    });
+  } catch (err) {
+    console.error('[extract-pdf] Error:', err);
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : 'Failed to extract PDF text' },
+      { status: 500 },
+    );
+  }
+}

package/app/app/api/file/route.ts

@@ -0,0 +1,138 @@
+export const dynamic = 'force-dynamic';
+import { NextRequest, NextResponse } from 'next/server';
+import {
+  getFileContent,
+  saveFileContent,
+  createFile,
+  appendToFile,
+  readLines,
+  insertLines,
+  updateLines,
+  insertAfterHeading,
+  updateSection,
+  deleteFile,
+  renameFile,
+  moveFile,
+  appendCsvRow,
+} from '@/lib/fs';
+
+function err(msg: string, status = 400) {
+  return NextResponse.json({ error: msg }, { status });
+}
+
+// GET /api/file?path=foo.md&op=read_file|read_lines
+export async function GET(req: NextRequest) {
+  const filePath = req.nextUrl.searchParams.get('path');
+  const op = req.nextUrl.searchParams.get('op') ?? 'read_file';
+  if (!filePath) return err('missing path');
+
+  try {
+    if (op === 'read_lines') {
+      return NextResponse.json({ lines: readLines(filePath) });
+    }
+    // default: read_file
+    return NextResponse.json({ content: getFileContent(filePath) });
+  } catch (e) {
+    return err((e as Error).message, 500);
+  }
+}
+
+// POST /api/file  body: { op, path, ...params }
+export async function POST(req: NextRequest) {
+  let body: Record<string, unknown>;
+  try { body = await req.json(); } catch { return err('invalid JSON'); }
+
+  const { op, path: filePath, ...params } = body as Record<string, unknown>;
+  if (!op || typeof op !== 'string') return err('missing op');
+  if (!filePath || typeof filePath !== 'string') return err('missing path');
+
+  try {
+    switch (op) {
+
+      case 'save_file': {
+        const { content } = params as { content: string };
+        if (typeof content !== 'string') return err('missing content');
+        saveFileContent(filePath, content);
+        return NextResponse.json({ ok: true });
+      }
+
+      case 'append_to_file': {
+        const { content } = params as { content: string };
+        if (typeof content !== 'string') return err('missing content');
+        appendToFile(filePath, content);
+        return NextResponse.json({ ok: true });
+      }
+
+      case 'insert_lines': {
+        const { after_index, lines } = params as { after_index: number; lines: string[] };
+        if (typeof after_index !== 'number') return err('missing after_index');
+        if (!Array.isArray(lines)) return err('lines must be array');
+        insertLines(filePath, after_index, lines);
+        return NextResponse.json({ ok: true });
+      }
+
+      case 'update_lines': {
+        const { start, end, lines } = params as { start: number; end: number; lines: string[] };
+        if (typeof start !== 'number' || typeof end !== 'number') return err('missing start/end');
+        if (!Array.isArray(lines)) return err('lines must be array');
+        if (start < 0 || end < 0) return err('start/end must be >= 0');
+        if (start > end) return err('start must be <= end');
+        updateLines(filePath, start, end, lines);
+        return NextResponse.json({ ok: true });
+      }
+
+      case 'insert_after_heading': {
+        const { heading, content } = params as { heading: string; content: string };
+        if (typeof heading !== 'string') return err('missing heading');
+        if (typeof content !== 'string') return err('missing content');
+        insertAfterHeading(filePath, heading, content);
+        return NextResponse.json({ ok: true });
+      }
+
+      case 'update_section': {
+        const { heading, content } = params as { heading: string; content: string };
+        if (typeof heading !== 'string') return err('missing heading');
+        if (typeof content !== 'string') return err('missing content');
+        updateSection(filePath, heading, content);
+        return NextResponse.json({ ok: true });
+      }
+
+      case 'delete_file': {
+        deleteFile(filePath);
+        return NextResponse.json({ ok: true });
+      }
+
+      case 'rename_file': {
+        const { new_name } = params as { new_name: string };
+        if (typeof new_name !== 'string' || !new_name) return err('missing new_name');
+        const newPath = renameFile(filePath, new_name);
+        return NextResponse.json({ ok: true, newPath });
+      }
+
+      case 'create_file': {
+        const { content } = params as { content?: string };
+        createFile(filePath, typeof content === 'string' ? content : '');
+        return NextResponse.json({ ok: true });
+      }
+
+      case 'move_file': {
+        const { to_path } = params as { to_path: string };
+        if (typeof to_path !== 'string' || !to_path) return err('missing to_path');
+        const result = moveFile(filePath, to_path);
+        return NextResponse.json({ ok: true, ...result });
+      }
+
+      case 'append_csv': {
+        const { row } = params as { row: string[] };
+        if (!Array.isArray(row) || row.length === 0) return err('row must be non-empty array');
+        const result = appendCsvRow(filePath, row);
+        return NextResponse.json({ ok: true, ...result });
+      }
+
+      default:
+        return err(`unknown op: ${op}`);
+    }
+  } catch (e) {
+    return err((e as Error).message, 500);
+  }
+}

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

@@ -0,0 +1,12 @@
+export const dynamic = 'force-dynamic';
+import { collectAllFiles } from '@/lib/fs';
+import { NextResponse } from 'next/server';
+
+export async function GET() {
+  try {
+    const files = collectAllFiles();
+    return NextResponse.json(files);
+  } catch (e) {
+    return NextResponse.json({ error: (e as Error).message }, { status: 500 });
+  }
+}

package/app/app/api/git/route.ts

@@ -0,0 +1,42 @@
+export const dynamic = 'force-dynamic';
+import { NextRequest, NextResponse } from 'next/server';
+import { isGitRepo, gitLog, gitShowFile } from '@/lib/fs';
+
+function err(msg: string, status = 400) {
+  return NextResponse.json({ error: msg }, { status });
+}
+
+// GET /api/git?op=is_repo|history|show&path=x&limit=10&commit=abc
+export async function GET(req: NextRequest) {
+  const op = req.nextUrl.searchParams.get('op') ?? 'is_repo';
+
+  try {
+    switch (op) {
+      case 'is_repo': {
+        return NextResponse.json({ isRepo: isGitRepo() });
+      }
+
+      case 'history': {
+        const filePath = req.nextUrl.searchParams.get('path');
+        if (!filePath) return err('missing path');
+        const limit = parseInt(req.nextUrl.searchParams.get('limit') ?? '10', 10);
+        const entries = gitLog(filePath, limit);
+        return NextResponse.json({ entries });
+      }
+
+      case 'show': {
+        const filePath = req.nextUrl.searchParams.get('path');
+        const commit = req.nextUrl.searchParams.get('commit');
+        if (!filePath) return err('missing path');
+        if (!commit) return err('missing commit');
+        const content = gitShowFile(filePath, commit);
+        return NextResponse.json({ content });
+      }
+
+      default:
+        return err(`unknown op: ${op}`);
+    }
+  } catch (e) {
+    return err((e as Error).message, 500);
+  }
+}