@drewsepsi/nextpi 0.1.0

package/README.md

@@ -0,0 +1,50 @@
+# 🚀 NextPi: The Agentic IDE
+
+**NextPi** is your project's personal secret agent. It's a tiny, powerful workspace that lives in your project folder and helps you research, code, and debug using top-tier AI.
+
+Turn any folder into an intelligent workspace with just one command.
+
+---
+
+## ⚡️ Quick Start
+
+You don't even need to install it! Just run this in any folder on your computer:
+
+```bash
+npx @drewsepsi/nextpi
+```
+
+*Requires [Node.js](https://nodejs.org/) installed.*
+
+### 🔑 Setup
+You will need an [OpenRouter](https://openrouter.ai/) API key to use the AI features. Set it in your terminal:
+```bash
+export OPENROUTER_API_KEY=your_key_here
+```
+
+---
+
+## ✨ Features
+
+- **📂 Folder-Aware**: NextPi instantly understands the files in your current folder.
+- **🌐 Web Research**: It can search the internet, read documentation, and find answers for you.
+- **Code Editing**: Ask it to fix bugs or add features, and watch it work directly on your files.
+- **🧠 Multi-Model Support**: Use any model from OpenRouter (Claude, GPT-4, Gemini, etc.).
+- **🚀 One-Tap Preview**: Run your app and see the changes live inside the NextPi interface.
+
+---
+
+## 🛠 How it Works
+
+NextPi starts a small web server on your machine that only you can access. It uses **Agentic AI**—which means it doesn't just talk; it **takes action**. It can read your code, search the web for solutions, and help you build faster than ever.
+
+---
+
+## 🔒 Privacy & Safety
+
+NextPi runs entirely on **your** computer. While it uses cloud AI models to "think," it only accesses the files in the folder where you started it. You are always in control.
+
+---
+
+Built with ❤️ by [drewsepsi](https://github.com/drewsepsi)
+# nextpi

package/app/api/chat/route.ts

@@ -0,0 +1,28 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getSharedSession } from '@/lib/session-singleton';
+export async function POST(request: NextRequest) {
+  try {
+    const { message } = await request.json();
+    if (!message) {
+      return NextResponse.json({ error: 'Message is required' }, { status: 400 });
+    }
+
+    const agentSession = await getSharedSession();
+    console.log(`[Chat] Received message. Session ID: ${agentSession.sessionId}`);
+    
+    // We launch the prompt in the background and return immediately.
+    // The events will be streamed via the /api/stream connection which 
+    // is subscribed to the same agentSession instance.
+    // NOTE: In Next.js, background tasks should ideally use waitUntil() 
+    // to ensure the process doesn't exit if it were on a serverless platform.
+    agentSession.prompt(message).catch(err => {
+      console.error(`[Chat] Background prompt error for ${agentSession.sessionId}:`, err);
+    });
+
+    console.log(`[Chat] Prompt triggered for session ${agentSession.sessionId}`);
+    return NextResponse.json({ success: true, sessionId: agentSession.sessionId });
+  } catch (error: unknown) {
+    console.error(`[Chat] Error in route handler:`, error);
+    return NextResponse.json({ error: (error as Error).message }, { status: 500 });
+  }
+}

package/app/api/config/route.ts

@@ -0,0 +1,25 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getConfig, saveConfig, getEffectiveApiKey } from '@/lib/config';
+
+export async function GET() {
+  const apiKey = getEffectiveApiKey();
+  return NextResponse.json({ 
+    hasKey: !!apiKey,
+    // We don't return the full key for safety, just first 4 and last 4
+    maskedKey: apiKey ? `${apiKey.slice(0, 4)}...${apiKey.slice(-4)}` : null
+  });
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const { apiKey } = await request.json();
+    if (!apiKey) {
+      return NextResponse.json({ error: 'API Key is required' }, { status: 400 });
+    }
+    
+    saveConfig({ openRouterApiKey: apiKey });
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    return NextResponse.json({ error: 'Failed to save config' }, { status: 500 });
+  }
+}

package/app/api/files/[...path]/route.ts

@@ -0,0 +1,55 @@
+import { NextResponse } from 'next/server';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { getProjectRoot } from '@/lib/root-path';
+export async function GET(
+  request: Request,
+  { params }: { params: Promise<{ path: string[] }> }
+) {
+  try {
+    const { path: pathSegments } = await params;
+    const projectRoot = getProjectRoot();
+    const filePath = path.join(projectRoot, ...pathSegments);
+
+    const content = await fs.readFile(filePath, 'utf-8');
+    return NextResponse.json({ content });
+  } catch (error: any) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}
+
+export async function PUT(
+  request: Request,
+  { params }: { params: Promise<{ path: string[] }> }
+) {
+  try {
+    const { path: pathSegments } = await params;
+    const { content } = await request.json();
+    const projectRoot = getProjectRoot();
+    const filePath = path.join(projectRoot, ...pathSegments);
+
+    // Ensure parent directory exists
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+
+    await fs.writeFile(filePath, content, 'utf-8');
+    return NextResponse.json({ success: true });
+  } catch (error: any) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}
+
+export async function DELETE(
+  request: Request,
+  { params }: { params: Promise<{ path: string[] }> }
+) {
+  try {
+    const { path: pathSegments } = await params;
+    const projectRoot = getProjectRoot();
+    const filePath = path.join(projectRoot, ...pathSegments);
+
+    await fs.unlink(filePath);
+    return NextResponse.json({ success: true });
+  } catch (error: any) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}

package/app/api/files/route.ts

@@ -0,0 +1,62 @@
+import { NextResponse } from 'next/server';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { getProjectRoot } from '@/lib/root-path';
+
+interface TreeViewElement {
+  id: string;
+  name: string;
+  type: 'file' | 'folder';
+  isSelectable?: boolean;
+  children?: TreeViewElement[];
+}
+
+async function scanDirectory(dirPath: string, basePath: string): Promise<TreeViewElement[]> {
+  const entries = await fs.readdir(dirPath, { withFileTypes: true });
+  const elements: TreeViewElement[] = [];
+
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    const relativePath = path.relative(basePath, fullPath);
+    const id = relativePath;
+
+    if (entry.isDirectory()) {
+      if (entry.name === 'node_modules' || entry.name === '.next' || entry.name === '.git') {
+        continue;
+      }
+      const children = await scanDirectory(fullPath, basePath);
+      elements.push({
+        id,
+        name: entry.name,
+        type: 'folder',
+        isSelectable: true,
+        children,
+      });
+    } else {
+      elements.push({
+        id,
+        name: entry.name,
+        type: 'file',
+        isSelectable: true,
+      });
+    }
+  }
+
+  return elements.sort((a, b) => {
+    if (a.type === b.type) {
+      return a.name.localeCompare(b.name);
+    }
+    return a.type === 'folder' ? -1 : 1;
+  });
+}
+
+export async function GET() {
+  try {
+    const projectRoot = getProjectRoot();
+    const elements = await scanDirectory(projectRoot, projectRoot);
+
+    return NextResponse.json({ elements });
+  } catch (error: any) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}

package/app/api/messages/route.ts

@@ -0,0 +1,26 @@
+import { NextResponse } from 'next/server';
+import { getSharedSession } from '@/lib/session-singleton';
+
+export async function GET() {
+  try {
+    const agentSession = await getSharedSession();
+    
+    // Get messages from the session
+    // AgentSession usually has a getHistory() or messages property
+    // Looking at the library types, we can use session.messages
+    const messages = agentSession.messages.map((msg: any) => ({
+      id: msg.id || `msg-${Math.random().toString(36).slice(2, 9)}`,
+      content: Array.isArray(msg.content) 
+        ? msg.content.filter((c: any) => c.type === 'text').map((c: any) => c.text).join('\n')
+        : msg.content,
+      thinking: msg.thinking, // Store thinking if available
+      isUser: msg.role === 'user',
+      timestamp: msg.timestamp
+    }));
+
+    return NextResponse.json({ messages });
+  } catch (error: any) {
+    console.error('[Messages] Error fetching history:', error);
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}

package/app/api/session/route.ts

@@ -0,0 +1,55 @@
+import { NextResponse } from 'next/server';
+import { getSharedSession, resetSharedSession } from '@/lib/session-singleton';
+
+export async function GET() {
+  try {
+    const agentSession = await getSharedSession();
+
+    // Estimate token count from raw message content
+    const tokenCount = agentSession.messages.reduce((sum, msg: any) => {
+      let text = '';
+      if (msg.role === 'user') {
+        if (typeof msg.content === 'string') {
+          text = msg.content;
+        } else if (Array.isArray(msg.content)) {
+          text = msg.content
+            .map((c: any) => (c.type === 'text' ? c.text : ''))
+            .join('');
+        }
+      } else if (msg.role === 'assistant') {
+        text = msg.content
+          .map((c: any) => (c.type === 'text' ? c.text : ''))
+          .join('');
+      } else if (msg.role === 'toolResult') {
+        text = msg.content
+          .map((c: any) => (c.type === 'text' ? c.text : ''))
+          .join('');
+      }
+      return sum + Math.ceil(text.length / 4);
+    }, 0);
+
+    return NextResponse.json({
+      model: agentSession.model?.id,
+      messages: agentSession.messages.length,
+      tokens: tokenCount,
+      tools: agentSession.getActiveToolNames(),
+    });
+  } catch (error: any) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}
+
+export async function POST(req: Request) {
+  try {
+    const { modelId } = await req.json().catch(() => ({}));
+    
+    // Tear down and recreate the shared session
+    resetSharedSession(modelId);
+    const newSession = await getSharedSession();
+
+    return NextResponse.json({ success: true, sessionId: newSession.sessionId });
+  } catch (error: any) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}
+

package/app/api/stream/route.ts

@@ -0,0 +1,76 @@
+import { getSharedSession } from '@/lib/session-singleton';
+import type { AgentSessionEvent } from '@mariozechner/pi-coding-agent';
+
+function translateEvent(event: AgentSessionEvent): { type: string; [key: string]: any } | null {
+  switch (event.type) {
+    case 'agent_start': return { type: 'start' };
+    case 'agent_end': return { type: 'end' };
+    case 'message_update': {
+      const ae = event.assistantMessageEvent;
+      if (ae.type === 'text_delta') return { type: 'content', content: ae.delta };
+      if (ae.type === 'thinking_delta') return { type: 'thinking', content: ae.delta };
+      return null;
+    }
+    case 'tool_execution_start':
+      return { type: 'tool_start', tool: event.toolName, args: event.args };
+    case 'tool_execution_end': {
+      let output = '';
+      if (Array.isArray(event.result?.content)) {
+        output = (event.result.content as any[])
+          .filter((c) => c.type === 'text')
+          .map((c) => c.text ?? '')
+          .join('');
+      }
+      return {
+        type: 'tool_end',
+        tool: event.toolName,
+        isError: event.isError,
+        output: output.slice(0, 2000),
+        error: event.isError ? (event.result?.error ?? '') : '',
+      };
+    }
+    case 'compaction_start': return { type: 'compacting' };
+    case 'auto_retry_start':
+      return { type: 'retry', attempt: event.attempt, maxAttempts: event.maxAttempts, delayMs: event.delayMs };
+    default: return null;
+  }
+}
+
+export async function GET() {
+  const agentSession = await getSharedSession();
+  console.log(`[SSE] Client connected. Session ID: ${agentSession.sessionId}`);
+
+  const encoder = new TextEncoder();
+  let unsubscribe: (() => void) | undefined;
+
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'connected' })}\n\n`));
+
+      unsubscribe = agentSession.subscribe((event: AgentSessionEvent) => {
+        const translated = translateEvent(event);
+        if (translated !== null) {
+          console.log(`[SSE] Emitting event: ${translated.type} for session ${agentSession.sessionId}`);
+          try {
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(translated)}\n\n`));
+          } catch (err) {
+            console.log(`[SSE] Enqueue failed (likely client disconnected)`);
+          }
+        }
+      });
+    },
+    cancel() {
+      console.log(`[SSE] Client disconnected. Session ID: ${agentSession.sessionId}`);
+      unsubscribe?.();
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream; charset=utf-8',
+      'Cache-Control': 'no-cache, no-transform',
+      'Connection': 'keep-alive',
+      'X-Accel-Buffering': 'no',
+    },
+  });
+}