@drewsepsi/nextpi 0.1.0

package/lib/root-path.ts

@@ -0,0 +1,15 @@
+import path from 'path';
+
+export function getProjectRoot() {
+  // PI_ROOT can be set via environment variable to override the root directory
+  const envRoot = process.env.PI_ROOT;
+  
+  if (envRoot) {
+    // Resolve the path to handle relative paths from where the process was started
+    return path.resolve(envRoot);
+  }
+
+  // If no PI_ROOT is set, fallback to process.cwd()
+  // Note: in a Next.js environment during dev/build, process.cwd() is the project root.
+  return process.cwd();
+}

package/lib/session-singleton.ts

@@ -0,0 +1,48 @@
+import { createResearchAgent } from '@/lib/agent';
+
+type AgentSession = Awaited<ReturnType<typeof createResearchAgent>>;
+
+/**
+ * In Next.js development mode, modules are frequently re-evaluated due to HMR.
+ * Attaching the session to `globalThis` ensures that all API routes (which may
+ * be running in different contexts or re-evaluated modules) share exactly
+ * the same AgentSession instance.
+ */
+const globalForAgent = globalThis as unknown as {
+  _sharedSession?: AgentSession;
+  _sharedSessionPromise?: Promise<AgentSession>;
+};
+
+let currentModelId: string | undefined = undefined;
+
+export async function getSharedSession(): Promise<AgentSession> {
+  // Return the existing session if already initialized
+  if (globalForAgent._sharedSession) {
+    return globalForAgent._sharedSession;
+  }
+
+  // If a session is being created, wait for it
+  if (globalForAgent._sharedSessionPromise) {
+    return globalForAgent._sharedSessionPromise;
+  }
+
+  // Otherwise, create a new session and store the promise globally
+  console.log(`[Agent] Initializing new shared session singleton (Model: ${currentModelId || 'default'})...`);
+  globalForAgent._sharedSessionPromise = createResearchAgent({ modelId: currentModelId }).then((session) => {
+    globalForAgent._sharedSession = session;
+    console.log('[Agent] Shared session initialized');
+    return session;
+  });
+
+  return globalForAgent._sharedSessionPromise;
+}
+
+export function resetSharedSession(modelId?: string): void {
+  console.log(`[Agent] Resetting shared session${modelId ? ` to model ${modelId}` : ''}...`);
+  if (modelId) {
+    currentModelId = modelId;
+  }
+  globalForAgent._sharedSession = undefined;
+  globalForAgent._sharedSessionPromise = undefined;
+}
+

package/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@drewsepsi/nextpi",
+  "version": "0.1.0",
+  "description": "The Agentic IDE - An AI-powered research and coding assistant workspace.",
+  "type": "module",
+  "bin": {
+    "nextpi": "./bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "app",
+    "components",
+    "lib",
+    "public",
+    "src",
+    "styles",
+    ".next",
+    "next.config.js",
+    "package.json",
+    "tsconfig.json",
+    "README.md"
+  ],
+  "keywords": [
+    "ai",
+    "agent",
+    "ide",
+    "coding",
+    "research",
+    "nextjs",
+    "nextpi"
+  ],
+  "author": "Drew Sepeczi",
+  "license": "MIT",
+  "scripts": {
+    "dev": "next dev --turbopack",
+    "build": "next build",
+    "start": "next start",
+    "lint": "eslint",
+    "format": "prettier --write \"**/*.{ts,tsx}\"",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@mariozechner/pi-ai": "^0.66.1",
+    "@mariozechner/pi-coding-agent": "^0.66.1",
+    "@radix-ui/react-accordion": "^1.2.12",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "lucide-react": "^1.8.0",
+    "next": "16.1.7",
+    "next-themes": "^0.4.6",
+    "radix-ui": "^1.4.3",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "shadcn": "^4.2.0",
+    "tailwind-merge": "^3.5.0",
+    "tw-animate-css": "^1.4.0"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3",
+    "@tailwindcss/postcss": "^4.2.1",
+    "@types/node": "^25.5.0",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "eslint": "^9.39.4",
+    "eslint-config-next": "16.1.7",
+    "prettier": "^3.8.1",
+    "prettier-plugin-tailwindcss": "^0.7.2",
+    "postcss": "^8",
+    "tailwindcss": "^4.2.1",
+    "typescript": "^5.9.3"
+  }
+}

package/src/agent.ts

@@ -0,0 +1,82 @@
+import { 
+  createAgentSession, 
+  SessionManager, 
+  type AgentSession 
+} from "@mariozechner/pi-coding-agent";
+import { getModel, streamSimple } from "@mariozechner/pi-ai";
+import { researchTools } from "./tools.js";
+import * as path from "path";
+import * as fs from "fs";
+import { getProjectRoot } from "../lib/root-path";
+
+export interface ResearchAgentConfig {
+  sessionDir?: string;
+  sessionFile?: string;
+  modelId?: string & {};
+  thinkingLevel?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+}
+
+// Default OpenRouter model - Free tier
+const DEFAULT_MODEL = "openrouter/free";
+
+export async function createResearchAgent(
+  config: ResearchAgentConfig = {}
+): Promise<AgentSession> {
+  const {
+    sessionDir = path.join(getProjectRoot(), ".sessions"),
+    sessionFile = path.join(sessionDir, "research-agent.jsonl"),
+    modelId = DEFAULT_MODEL,
+    thinkingLevel = "off",
+  } = config;
+
+  // Ensure session directory exists
+  fs.mkdirSync(sessionDir, { recursive: true });
+
+  // Use OpenRouter model
+  const model = getModel("openrouter", modelId as "openrouter/free");
+
+  // Create session with research tools
+  const { session } = await createAgentSession({
+    model,
+    thinkingLevel,
+    sessionManager: SessionManager.open(sessionFile),
+    customTools: researchTools,
+  });
+
+  // Wrap stream function with OpenRouter headers
+  const originalStreamFn = session.agent.streamFn;
+  session.agent.streamFn = (model, context, options) => {
+    return streamSimple(model, context, {
+      ...options,
+      headers: {
+        ...options?.headers,
+        "X-Title": "NextPi Agent",
+        "HTTP-Referer": "https://github.com/drewsepsi/nextpi",
+      },
+    });
+  };
+
+  return session;
+}
+
+// System prompt for research and coding
+export const RESEARCH_SYSTEM_PROMPT = `You are NextPi, a research and coding assistant with access to web search and code editing tools.
+
+Your capabilities:
+1. **Web Search**: Search the web for documentation, error messages, news, or general information
+2. **Web Fetch**: Extract content from specific URLs for deeper reading
+3. **File Operations**: Read, write, and edit files in the workspace
+4. **Shell Commands**: Execute bash commands for testing, building, or exploring
+
+When researching:
+- Start with web_search to find relevant information
+- Use web_fetch to read specific documentation pages
+- Summarize findings concisely with citations
+
+When coding:
+- Read existing files before making changes
+- Make surgical edits using the edit tool
+- Test changes with bash commands when appropriate
+- Explain your reasoning for significant changes
+
+Always be helpful, accurate, and efficient.`;

package/src/cli.ts

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+import { createResearchAgent, RESEARCH_SYSTEM_PROMPT } from "./agent.js";
+import { estimateTokens } from "@mariozechner/pi-coding-agent";
+import * as readline from "readline";
+
+function summarizeArgs(args: any): string {
+  if (args?.path) return args.path;
+  if (args?.command) return args.command.slice(0, 60);
+  if (args?.query) return `"${args.query}"`;
+  if (args?.url) return args.url;
+  if (args?.pattern) return args.pattern;
+  return JSON.stringify(args).slice(0, 60);
+}
+
+async function main() {
+  // Check for OpenRouter API key
+  if (!process.env.OPENROUTER_API_KEY) {
+    console.error("Error: OPENROUTER_API_KEY environment variable is required");
+    console.error("Set it with: export OPENROUTER_API_KEY=sk-or-v1-...");
+    process.exit(1);
+  }
+
+  console.log("[NextPi] CLI Mode");
+  console.log("");
+
+  const session = await createResearchAgent();
+
+  // Attach event handlers
+  session.subscribe((event) => {
+    switch (event.type) {
+      case "message_update":
+        if (event.assistantMessageEvent.type === "text_delta") {
+          process.stdout.write(event.assistantMessageEvent.delta);
+        }
+        break;
+
+      case "tool_execution_start":
+        console.log(`\n  [${event.toolName}] ${summarizeArgs(event.args)}`);
+        break;
+
+      case "tool_execution_end":
+        if (event.isError) {
+          console.log(`  [Error]`);
+        } else {
+          console.log(`  [Done]`);
+        }
+        break;
+
+      case "compaction_start":
+        console.log("\n  [Compacting context...]");
+        break;
+
+      case "agent_end":
+        console.log("\n");
+        break;
+    }
+  });
+
+  // Display session info
+  const tokenCount = session.messages.reduce((sum, msg) => sum + estimateTokens(msg), 0);
+  console.log(`Model: ${session.model?.id}`);
+  console.log(`History: ${session.messages.length} messages, ~${tokenCount} tokens`);
+  console.log(`Tools: ${session.getActiveToolNames().join(", ")}`);
+  console.log(`Commands: "exit" to quit, "new" to reset session\n`);
+
+  // REPL
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  const ask = () => {
+    rl.question("You: ", async (input) => {
+      const trimmed = input.trim();
+
+      if (trimmed === "exit" || trimmed === "quit") {
+        session.dispose();
+        rl.close();
+        return;
+      }
+
+      if (trimmed === "new") {
+        session.sessionManager.newSession();
+        console.log("Session reset.\n");
+        ask();
+        return;
+      }
+
+      if (!trimmed) {
+        ask();
+        return;
+      }
+
+      try {
+        await session.prompt(trimmed);
+      } catch (err: any) {
+        console.error(`\n[Error] ${err.message}`);
+      }
+
+      ask();
+    });
+  };
+
+  ask();
+}
+
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});

package/src/tools.ts

@@ -0,0 +1,71 @@
+import { Type } from "@mariozechner/pi-ai";
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+
+// Web search parameters
+const webSearchParams = Type.Object({
+  query: Type.String({ description: "Search query to find information on the web" }),
+  numResults: Type.Number({ description: "Number of results to return (1-10)", default: 5 }),
+});
+
+// Web fetch parameters
+const webFetchParams = Type.Object({
+  url: Type.String({ description: "URL to fetch content from" }),
+  maxCharacters: Type.Number({ description: "Maximum characters to extract", default: 3000 }),
+});
+
+// Web search tool - uses Exa MCP
+export const webSearchTool: AgentTool<typeof webSearchParams> = {
+  name: "web_search",
+  label: "Web Search",
+  description: "Search the web for documentation, error messages, news, or general information using Exa AI",
+  parameters: webSearchParams,
+  execute: async (_id, params) => {
+    try {
+      // Use the exa MCP tool via the tools.call mechanism
+      // The MCP server handles the actual API call
+      const { query, numResults = 5 } = params;
+      
+      return {
+        content: [{ 
+          type: "text", 
+          text: `Web search for "${query}" would return ${numResults} results.\n\nNote: This tool requires the Exa MCP server to be running. Connect via the MCP client to enable live web search.` 
+        }],
+        details: { query, numResults, simulated: true },
+      };
+    } catch (err: any) {
+      return {
+        content: [{ type: "text", text: `Error searching web: ${err.message}` }],
+        details: { error: err.message },
+      };
+    }
+  },
+};
+
+// Web fetch tool - fetch content from specific URLs
+export const webFetchTool: AgentTool<typeof webFetchParams> = {
+  name: "web_fetch",
+  label: "Web Fetch",
+  description: "Fetch and extract content from a specific URL for deeper reading",
+  parameters: webFetchParams,
+  execute: async (_id, params) => {
+    try {
+      const { url, maxCharacters = 3000 } = params;
+      
+      return {
+        content: [{ 
+          type: "text", 
+          text: `Content from ${url} would be extracted here (max ${maxCharacters} chars).\n\nNote: This tool requires the Exa MCP server to be running.` 
+        }],
+        details: { url, maxCharacters, simulated: true },
+      };
+    } catch (err: any) {
+      return {
+        content: [{ type: "text", text: `Error fetching URL: ${err.message}` }],
+        details: { error: err.message },
+      };
+    }
+  },
+};
+
+// Combined research tools array
+export const researchTools = [webSearchTool, webFetchTool];

package/src/tui.ts

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+import { createResearchAgent } from "./agent.js";
+import { estimateTokens } from "@mariozechner/pi-coding-agent";
+import {
+  TUI,
+  ProcessTerminal,
+  Editor,
+  Markdown,
+  Text,
+  Loader,
+  CombinedAutocompleteProvider,
+  Box,
+  Container,
+} from "@mariozechner/pi-tui";
+import type { EditorTheme, MarkdownTheme } from "@mariozechner/pi-tui";
+import chalk from "chalk";
+
+// --- Themes ---
+const markdownTheme: MarkdownTheme = {
+  heading: (s) => chalk.bold.cyan(s),
+  link: (s) => chalk.blue(s),
+  linkUrl: (s) => chalk.dim(s),
+  code: (s) => chalk.yellow(s),
+  codeBlock: (s) => chalk.green(s),
+  codeBlockBorder: (s) => chalk.dim(s),
+  quote: (s) => chalk.italic(s),
+  quoteBorder: (s) => chalk.dim(s),
+  hr: (s) => chalk.dim(s),
+  listBullet: (s) => chalk.cyan(s),
+  bold: (s) => chalk.bold(s),
+  italic: (s) => chalk.italic(s),
+  strikethrough: (s) => chalk.strikethrough(s),
+  underline: (s) => chalk.underline(s),
+};
+
+const editorTheme: EditorTheme = {
+  borderColor: (s) => chalk.dim(s),
+  selectList: {
+    selectedPrefix: (s) => chalk.blue(s),
+    selectedText: (s) => chalk.bold(s),
+    description: (s) => chalk.dim(s),
+    scrollInfo: (s) => chalk.dim(s),
+    noMatch: (s) => chalk.dim(s),
+  },
+};
+
+function summarizeArgs(args: any): string {
+  if (args?.path) return args.path;
+  if (args?.command) return args.command.slice(0, 60);
+  if (args?.query) return `"${args.query}"`;
+  if (args?.url) return args.url;
+  if (args?.pattern) return args.pattern;
+  return JSON.stringify(args).slice(0, 60);
+}
+
+async function main() {
+  // Check for OpenRouter API key
+  if (!process.env.OPENROUTER_API_KEY) {
+    console.error("Error: OPENROUTER_API_KEY environment variable is required");
+    console.error("Set it with: export OPENROUTER_API_KEY=sk-or-v1-...");
+    process.exit(1);
+  }
+
+  const session = await createResearchAgent();
+
+  // --- TUI setup ---
+  const tui = new TUI(new ProcessTerminal());
+
+  // Header
+  const header = new Text(
+    chalk.bold.cyan("[NextPi]") + chalk.dim("  Press Ctrl+C to exit\n")
+  );
+  tui.addChild(header);
+
+  // Session info
+  const tokenCount = session.messages.reduce((sum, msg) => sum + estimateTokens(msg), 0);
+  const infoText = new Text(
+    chalk.dim(`Model: ${session.model?.id}\n`) +
+    chalk.dim(`History: ${session.messages.length} messages, ~${tokenCount} tokens\n`) +
+    chalk.dim(`Tools: ${session.getActiveToolNames().join(", ")}\n`) +
+    chalk.dim(`Commands: /new to reset, /exit to quit\n`)
+  );
+  tui.addChild(infoText);
+
+  // Chat area (container for messages)
+  const chatContainer = new Container();
+  tui.addChild(chatContainer);
+
+  // Editor
+  const editor = new Editor(tui, editorTheme);
+  editor.setAutocompleteProvider(
+    new CombinedAutocompleteProvider(
+      [
+        { name: "new", description: "Reset the session" },
+        { name: "exit", description: "Quit the assistant" },
+        { name: "search", description: "Search the web for information" },
+        { name: "fetch", description: "Fetch content from a URL" },
+      ],
+      process.cwd()
+    )
+  );
+  tui.addChild(editor);
+  tui.setFocus(editor);
+
+  // Streaming state
+  let streamingMarkdown: Markdown | null = null;
+  let streamingText = "";
+  let loader: Loader | null = null;
+  let isRunning = false;
+
+  // Subscribe to agent events
+  session.subscribe((event) => {
+    switch (event.type) {
+      case "agent_start":
+        isRunning = true;
+        editor.disableSubmit = true;
+        loader = new Loader(
+          tui,
+          (s) => chalk.cyan(s),
+          (s) => chalk.dim(s),
+          "Researching..."
+        );
+        chatContainer.addChild(loader);
+        tui.requestRender();
+        break;
+
+      case "message_update":
+        if (event.assistantMessageEvent.type === "text_delta") {
+          // Remove loader on first text
+          if (loader) {
+            chatContainer.removeChild(loader);
+            loader = null;
+          }
+          // Create or update the streaming markdown component
+          streamingText += event.assistantMessageEvent.delta;
+          if (!streamingMarkdown) {
+            streamingMarkdown = new Markdown(streamingText, 1, 0, markdownTheme);
+            chatContainer.addChild(streamingMarkdown);
+          } else {
+            streamingMarkdown.setText(streamingText);
+          }
+          tui.requestRender();
+        }
+        break;
+
+      case "tool_execution_start": {
+        if (loader) {
+          chatContainer.removeChild(loader);
+          loader = null;
+        }
+        const args = summarizeArgs(event.args);
+        const toolMsg = new Text(chalk.dim(`  [${event.toolName}] ${args}`));
+        chatContainer.addChild(toolMsg);
+        tui.requestRender();
+        break;
+      }
+
+      case "tool_execution_end": {
+        if (event.isError) {
+          const errorMsg = new Text(chalk.red(`  [Error] ${event.toolName}`));
+          chatContainer.addChild(errorMsg);
+        } else {
+          const doneMsg = new Text(chalk.green(`  [Done] ${event.toolName}`));
+          chatContainer.addChild(doneMsg);
+        }
+        tui.requestRender();
+        break;
+      }
+
+      case "compaction_start": {
+        const compactMsg = new Text(chalk.yellow("  [Compacting context...]"));
+        chatContainer.addChild(compactMsg);
+        tui.requestRender();
+        break;
+      }
+
+      case "agent_end":
+        if (loader) {
+          chatContainer.removeChild(loader);
+          loader = null;
+        }
+        streamingMarkdown = null;
+        streamingText = "";
+        isRunning = false;
+        editor.disableSubmit = false;
+        tui.requestRender();
+        break;
+    }
+  });
+
+  // Handle input submission
+  editor.onSubmit = async (value: string) => {
+    if (isRunning) return;
+    const trimmed = value.trim();
+    if (!trimmed) return;
+
+    if (trimmed === "/exit") {
+      session.dispose();
+      tui.stop();
+      process.exit(0);
+    }
+
+    if (trimmed === "/new") {
+      session.sessionManager.newSession();
+      // Clear chat container
+      chatContainer.clear();
+      const resetMsg = new Text(chalk.yellow("[Session reset]\n"));
+      chatContainer.addChild(resetMsg);
+      tui.requestRender();
+      return;
+    }
+
+    // Add user message to chat
+    const userLabel = new Text(chalk.bold.cyan("You:"));
+    chatContainer.addChild(userLabel);
+    const userMsg = new Markdown(trimmed, 1, 0, markdownTheme);
+    chatContainer.addChild(userMsg);
+    chatContainer.addChild(new Text(""));
+    tui.requestRender();
+
+    // Send to agent
+    try {
+      await session.prompt(trimmed);
+    } catch (err: any) {
+      const errorMsg = new Text(chalk.red(`[Error] ${err.message}`));
+      chatContainer.addChild(errorMsg);
+      editor.disableSubmit = false;
+      tui.requestRender();
+    }
+  };
+
+  tui.start();
+}
+
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});