@every-app/mcp 0.0.1

package/README.md

@@ -0,0 +1,102 @@
+# @every-app/mcp
+
+MCP (Model Context Protocol) server for Every App coding agents. This server provides AI coding assistants with tools to explore example apps, search code patterns, and access documentation.
+
+## Quick Start
+
+Just add the MCP server to your AI tool's configuration. The examples will be automatically downloaded on first run.
+
+### Claude Code
+
+Run this command:
+
+```sh
+claude mcp add every-app -- npx -y @every-app/mcp
+```
+
+### Cursor
+
+Add to `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "every-app": {
+      "command": "npx",
+      "args": ["-y", "@every-app/mcp"]
+    }
+  }
+}
+```
+
+### OpenCode
+
+Add to `opencode.json`:
+
+```json
+{
+  "mcp": {
+    "every-app": {
+      "type": "local",
+      "command": ["npx", "-y", "@every-app/mcp"]
+    }
+  }
+}
+```
+
+That's it! The server will automatically clone the Every App examples to `~/.every-app-mcp/examples` on first run.
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `every_app_mcp_list_examples` | List all available example apps with descriptions |
+| `every_app_mcp_list_directory` | Browse directory structure of example apps |
+| `every_app_mcp_read_file` | Read file contents with line numbers |
+| `every_app_mcp_search_code` | Search for patterns using regex |
+| `every_app_mcp_find_files` | Find files matching a glob pattern |
+| `every_app_mcp_fetch_docs` | Fetch Every App documentation pages |
+
+## Configuration (Optional)
+
+You can customize the examples location by setting environment variables:
+
+```json
+{
+  "mcpServers": {
+    "every-app": {
+      "command": "npx",
+      "args": ["-y", "@every-app/mcp"],
+      "env": {
+        "EVERY_APP_EXAMPLES_DIR": "/custom/path/to/examples"
+      }
+    }
+  }
+}
+```
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `EVERY_APP_EXAMPLES_DIR` | Path to examples | `~/.every-app-mcp/examples` |
+| `EVERY_APP_DOCS_DIR` | Path to local docs | Falls back to GitHub |
+
+## Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Build
+pnpm run build
+
+# Type check
+pnpm run types:check
+
+# Run locally
+node dist/index.js
+```
+
+## Requirements
+
+- Node.js 18+
+- Git (for automatic example cloning)

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerAllTools } from "./tools/index.js";
+import { registerAllResources } from "./resources/index.js";
+import { ensureExamplesExist } from "./setup.js";
+// Create server instance
+const server = new McpServer({
+    name: "every-app",
+    version: "0.0.1",
+});
+// Register all tools and resources
+registerAllTools(server);
+registerAllResources(server);
+// Main function
+async function main() {
+    // Ensure examples are available (clone if needed)
+    const setupResult = await ensureExamplesExist();
+    if (!setupResult.success) {
+        console.error(`Warning: ${setupResult.message}`);
+        console.error("Some tools may not work correctly without the examples.");
+    }
+    else {
+        console.error(setupResult.message);
+    }
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Every App MCP Server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/dist/resources/index.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerAllResources(server: McpServer): void;

package/dist/resources/index.js

@@ -0,0 +1,4 @@
+import { registerPromptResources } from "./prompts.js";
+export function registerAllResources(server) {
+    registerPromptResources(server);
+}

package/dist/resources/prompts.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerPromptResources(server: McpServer): void;

package/dist/resources/prompts.js

@@ -0,0 +1,87 @@
+const MOCKUP_FROM_SPEC_PROMPT = `# Task: Build Mockup UI for App
+Below is a description of a Product Spec for my app idea that I want to create a functional mockup for. 
+
+Please implement all the pages and key interactions described in the product spec. Please use Daisy UI to accomplish this. Reference the context7 tool to read the DaisyUI docs if necessary. 
+
+Please implement any interactions that seem reasonable. You can mock all data / should not implement any backend logic. 
+
+## Goal
+Functional mockup of product spec supporting key flows built using Daisy UI
+
+## Non-Goals
+Implementing any backend functionality
+
+## Coding Guidelines
+Please still try to follow good frontend coding practices like breaking things into smaller components / file so that the code is readable. 
+
+## Checklist before implementing
+- Please ask any clarifying questions if the Product Spec is ambigious
+    - Asking these are not essential and you should only do so if there are major things which are not clear in the spec. 
+
+--
+# Product Spec
+[PASTE PRODUCT SPEC HERE]`;
+const REVIEW_CODE_PROMPT = `# Task: Review Code for Every App Best Practices
+
+Please review the code changes in this PR/file for the following:
+
+## Security
+- Check for exposed secrets or sensitive data
+- Validate input handling and sanitization
+- Review authentication and authorization patterns
+
+## Schema Design
+- Check Drizzle schema for proper relationships
+- Verify indexes are appropriate
+- Review migration safety
+
+## Simplification
+- Look for opportunities to simplify complex logic
+- Identify duplicate code that could be extracted
+- Check for unused imports or dead code
+
+## Every App Patterns
+- Verify proper use of TanStack hooks
+- Check optimistic mutation patterns
+- Review error handling
+
+## Output
+Provide specific, actionable feedback organized by category.`;
+export function registerPromptResources(server) {
+    // Register as prompts (user-driven: user selects from prompt list)
+    server.prompt("every-app-mockup-from-spec", "Build a UI mockup from a product spec using DaisyUI", async () => ({
+        messages: [
+            {
+                role: "user",
+                content: { type: "text", text: MOCKUP_FROM_SPEC_PROMPT },
+            },
+        ],
+    }));
+    server.prompt("every-app-review-code", "Review code for Every App best practices", async () => ({
+        messages: [
+            {
+                role: "user",
+                content: { type: "text", text: REVIEW_CODE_PROMPT },
+            },
+        ],
+    }));
+    // Register as resources (application-driven: AI can fetch these proactively)
+    server.resource("prompts/mockup-from-spec", "every-app://prompts/mockup-from-spec", async (uri) => ({
+        contents: [
+            {
+                uri: uri.href,
+                mimeType: "text/markdown",
+                text: MOCKUP_FROM_SPEC_PROMPT,
+            },
+        ],
+    }));
+    server.resource("prompts/review-code", "every-app://prompts/review-code", async (uri) => ({
+        contents: [
+            {
+                uri: uri.href,
+                mimeType: "text/markdown",
+                text: REVIEW_CODE_PROMPT,
+            },
+        ],
+    }));
+}

package/dist/setup.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Get the examples directory, using environment variable or default location
+ */
+export declare function getExamplesDirectory(): string;
+/**
+ * Clone or update the examples repository
+ * Uses sparse checkout to only get apps/ and templates/ directories
+ */
+export declare function ensureExamplesExist(): Promise<{
+    success: boolean;
+    dir: string;
+    message: string;
+}>;

package/dist/setup.js

@@ -0,0 +1,113 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { execSync, execFileSync } from "node:child_process";
+// Default location for examples
+const DEFAULT_EXAMPLES_DIR = path.join(os.homedir(), ".every-app-mcp", "examples");
+// Repository info
+const REPO_URL = "https://github.com/every-app/every-app.git";
+const SPARSE_PATHS = ["apps", "templates"];
+/**
+ * Get the examples directory, using environment variable or default location
+ */
+export function getExamplesDirectory() {
+    return process.env.EVERY_APP_EXAMPLES_DIR || DEFAULT_EXAMPLES_DIR;
+}
+/**
+ * Check if git is available
+ */
+function hasGit() {
+    try {
+        execSync("git --version", { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Clone or update the examples repository
+ * Uses sparse checkout to only get apps/ and templates/ directories
+ */
+export async function ensureExamplesExist() {
+    const examplesDir = getExamplesDirectory();
+    // Check if examples already exist and have content
+    if (fs.existsSync(examplesDir)) {
+        const hasApps = fs.existsSync(path.join(examplesDir, "apps"));
+        const hasTemplates = fs.existsSync(path.join(examplesDir, "templates"));
+        if (hasApps || hasTemplates) {
+            // Try to update if it's a git repo
+            if (fs.existsSync(path.join(examplesDir, ".git"))) {
+                try {
+                    execFileSync("git", ["pull", "--quiet"], {
+                        cwd: examplesDir,
+                        stdio: "ignore",
+                        timeout: 30000,
+                    });
+                    return {
+                        success: true,
+                        dir: examplesDir,
+                        message: "Examples updated successfully",
+                    };
+                }
+                catch {
+                    // Pull failed, but we have existing examples so continue
+                    return {
+                        success: true,
+                        dir: examplesDir,
+                        message: "Using existing examples (update failed)",
+                    };
+                }
+            }
+            return {
+                success: true,
+                dir: examplesDir,
+                message: "Using existing examples",
+            };
+        }
+    }
+    // Need to clone the examples
+    if (!hasGit()) {
+        return {
+            success: false,
+            dir: examplesDir,
+            message: "Git is not installed. Please install git and try again, or manually clone the examples.",
+        };
+    }
+    // Create parent directory
+    const parentDir = path.dirname(examplesDir);
+    if (!fs.existsSync(parentDir)) {
+        fs.mkdirSync(parentDir, { recursive: true });
+    }
+    try {
+        console.error("Cloning Every App examples (this may take a moment)...");
+        // Use sparse checkout to only get apps/ and templates/
+        execFileSync("git", ["clone", "--filter=blob:none", "--sparse", REPO_URL, examplesDir], { stdio: "ignore", timeout: 120000 });
+        execFileSync("git", ["sparse-checkout", "set", ...SPARSE_PATHS], {
+            cwd: examplesDir,
+            stdio: "ignore",
+            timeout: 30000,
+        });
+        return {
+            success: true,
+            dir: examplesDir,
+            message: `Examples cloned to ${examplesDir}`,
+        };
+    }
+    catch (error) {
+        // Clean up failed clone
+        if (fs.existsSync(examplesDir)) {
+            try {
+                fs.rmSync(examplesDir, { recursive: true });
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+        return {
+            success: false,
+            dir: examplesDir,
+            message: `Failed to clone examples: ${error instanceof Error ? error.message : "Unknown error"}`,
+        };
+    }
+}

package/dist/tools/fetch-docs.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerFetchDocsTool(server: McpServer): void;

package/dist/tools/fetch-docs.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { errorResponse, textResponse } from "../utils.js";
+const AVAILABLE_DOCS = `Available pages include:
+- introduction
+- tech-stack/overview
+- tech-stack/tanstack-start
+- tech-stack/drizzle
+- tech-stack/cloudflare
+- embedded-sdk/overview
+- embedded-sdk/client
+- embedded-sdk/server
+- build-an-app/start-from-template
+- build-an-app/development-workflow
+- build-an-app/deployment
+- coding-agent/setup`;
+export function registerFetchDocsTool(server) {
+    server.tool("every_app_mcp_fetch_docs", "Fetch content from the Every App documentation. Use this to understand concepts, APIs, and best practices.", {
+        page: z
+            .string()
+            .describe('Documentation page path (e.g., "introduction", "tech-stack/drizzle", "embedded-sdk/client")'),
+    }, async ({ page }) => {
+        // Validate page contains only safe characters (alphanumeric, hyphens, slashes)
+        if (!/^[a-zA-Z0-9\-\/]+$/.test(page)) {
+            return errorResponse(`Invalid page path: ${page}\n\n${AVAILABLE_DOCS}`);
+        }
+        // Try to read from local docs directory first
+        const docsDir = process.env.EVERY_APP_DOCS_DIR;
+        if (docsDir) {
+            // Try to read from local docs directory
+            const localPath = path.join(docsDir, `${page}.mdx`);
+            if (fs.existsSync(localPath)) {
+                const content = fs.readFileSync(localPath, "utf-8");
+                return textResponse(`# ${page}\n\n${content}`);
+            }
+            // Try without .mdx extension (might be a directory index)
+            const indexPath = path.join(docsDir, page, "index.mdx");
+            if (fs.existsSync(indexPath)) {
+                const content = fs.readFileSync(indexPath, "utf-8");
+                return textResponse(`# ${page}\n\n${content}`);
+            }
+        }
+        // Fallback to fetching from GitHub raw content
+        const rawUrl = `https://raw.githubusercontent.com/every-app/every-app/main/landing-page/src/content/docs/docs/${page}.mdx`;
+        try {
+            const response = await fetch(rawUrl);
+            if (!response.ok) {
+                return errorResponse(`Documentation page not found: ${page}\n\n${AVAILABLE_DOCS}`);
+            }
+            const content = await response.text();
+            return textResponse(`# ${page}\n\n${content}`);
+        }
+        catch (error) {
+            return errorResponse(`Error fetching docs: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    });
+}

package/dist/tools/find-files.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerFindFilesTool(server: McpServer): void;

package/dist/tools/find-files.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import * as fs from "node:fs";
+import { findFiles, getExamplesDir, errorResponse, textResponse, validatePathWithinBase, } from "../utils.js";
+export function registerFindFilesTool(server) {
+    server.tool("every_app_mcp_find_files", "Find files matching a glob pattern in the Every App examples.", {
+        pattern: z
+            .string()
+            .describe('Glob pattern to match (e.g., "**/*.tsx", "**/schema.ts")'),
+        path: z
+            .string()
+            .optional()
+            .describe("Path to search within (relative to examples root). Defaults to entire examples directory."),
+    }, async ({ pattern, path: inputPath }) => {
+        const result = getExamplesDir();
+        if ("error" in result) {
+            return errorResponse(result.error);
+        }
+        const examplesDir = result.dir;
+        // Validate path stays within examples directory
+        let searchPath = examplesDir;
+        if (inputPath) {
+            const pathValidation = validatePathWithinBase(examplesDir, inputPath);
+            if (!pathValidation.valid) {
+                return errorResponse(pathValidation.error);
+            }
+            searchPath = pathValidation.resolvedPath;
+        }
+        if (!fs.existsSync(searchPath)) {
+            return errorResponse(`Path not found: ${inputPath || "(root)"}`);
+        }
+        try {
+            const files = findFiles(searchPath, pattern, { maxResults: 100 });
+            if (files.length === 0) {
+                return textResponse(`No files found matching: ${pattern}`);
+            }
+            // Prepend the input path to make paths relative to examples root
+            const displayFiles = inputPath
+                ? files.map((f) => `${inputPath}/${f}`)
+                : files;
+            const truncated = files.length >= 100;
+            let output = displayFiles.join("\n");
+            if (truncated) {
+                output += "\n\n... (results truncated, refine your pattern)";
+            }
+            return textResponse(`Found ${files.length} files:\n\n${output}`);
+        }
+        catch (error) {
+            return errorResponse(`Search error: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    });
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerAllTools(server: McpServer): void;

package/dist/tools/index.js

@@ -0,0 +1,14 @@
+import { registerListDirectoryTool } from "./list-directory.js";
+import { registerReadFileTool } from "./read-file.js";
+import { registerSearchCodeTool } from "./search-code.js";
+import { registerFindFilesTool } from "./find-files.js";
+import { registerFetchDocsTool } from "./fetch-docs.js";
+import { registerListExamplesTool } from "./list-examples.js";
+export function registerAllTools(server) {
+    registerListDirectoryTool(server);
+    registerReadFileTool(server);
+    registerSearchCodeTool(server);
+    registerFindFilesTool(server);
+    registerFetchDocsTool(server);
+    registerListExamplesTool(server);
+}

package/dist/tools/list-directory.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerListDirectoryTool(server: McpServer): void;

package/dist/tools/list-directory.js

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { IGNORE_PATTERNS, getExamplesDir, errorResponse, textResponse, validatePathWithinBase, } from "../utils.js";
+export function registerListDirectoryTool(server) {
+    server.tool("every_app_mcp_list_directory", "List files and directories in the Every App examples. Use this to explore the structure of example apps.", {
+        path: z
+            .string()
+            .optional()
+            .describe('Path relative to the Every App examples root (e.g., "apps/todo-app/src"). Defaults to root.'),
+    }, async ({ path: inputPath }) => {
+        const result = getExamplesDir();
+        if ("error" in result) {
+            return errorResponse(result.error);
+        }
+        const examplesDir = result.dir;
+        // Validate path stays within examples directory
+        let targetPath = examplesDir;
+        if (inputPath) {
+            const pathValidation = validatePathWithinBase(examplesDir, inputPath);
+            if (!pathValidation.valid) {
+                return errorResponse(pathValidation.error);
+            }
+            targetPath = pathValidation.resolvedPath;
+        }
+        if (!fs.existsSync(targetPath)) {
+            return errorResponse(`Directory not found: ${inputPath || "(root)"}`);
+        }
+        const stat = fs.statSync(targetPath);
+        if (!stat.isDirectory()) {
+            return errorResponse(`Path is not a directory: ${inputPath}`);
+        }
+        // Build directory tree
+        function buildTree(dir, prefix = "", depth = 0) {
+            if (depth > 3)
+                return [`${prefix}...`]; // Limit depth
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            const filtered = entries.filter((e) => !IGNORE_PATTERNS.includes(e.name) && !e.name.startsWith("."));
+            const lines = [];
+            filtered.forEach((entry, idx) => {
+                const isLast = idx === filtered.length - 1;
+                const connector = isLast ? "└── " : "├── ";
+                const childPrefix = isLast ? "    " : "│   ";
+                lines.push(`${prefix}${connector}${entry.name}${entry.isDirectory() ? "/" : ""}`);
+                if (entry.isDirectory()) {
+                    const subLines = buildTree(path.join(dir, entry.name), prefix + childPrefix, depth + 1);
+                    lines.push(...subLines);
+                }
+            });
+            return lines;
+        }
+        const tree = buildTree(targetPath);
+        const output = [`${inputPath || "."}/`, ...tree].join("\n");
+        return textResponse(output);
+    });
+}

package/dist/tools/list-examples.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerListExamplesTool(server: McpServer): void;

package/dist/tools/list-examples.js

@@ -0,0 +1,39 @@
+import { textResponse } from "../utils.js";
+const EXAMPLE_APPS = [
+    {
+        name: "apps/todo-app",
+        description: "Simple todo application demonstrating basic CRUD operations, routing, and embedded app patterns",
+        goodFor: [
+            "Basic data relationships",
+            "Complex Drag & Drop",
+            "Route setup",
+            "Embedded provider usage",
+        ],
+    },
+    {
+        name: "apps/workout-tracker",
+        description: "Workout tracking app with complex data relationships and forms",
+        goodFor: [
+            "Complex TanstackDB Optimistic Updates",
+            "Simple Drag & Drop",
+            "Complex data relationships",
+            "Form handling",
+            "Advanced queries",
+        ],
+    },
+    {
+        name: "apps/every-chef",
+        description: "Cooking assistant with LLM integration",
+        goodFor: [
+            "LLM integration patterns",
+            "AI-powered features",
+            "Streaming responses",
+        ],
+    },
+];
+export function registerListExamplesTool(server) {
+    server.tool("every_app_mcp_list_examples", "List available Every App example applications and what they demonstrate.", {}, async () => {
+        const output = EXAMPLE_APPS.map((ex) => `## ${ex.name}\n${ex.description}\n\n**Good for learning:**\n${ex.goodFor.map((g) => `- ${g}`).join("\n")}`).join("\n\n---\n\n");
+        return textResponse(`# Available Every App Examples\n\n${output}\n\n---\n\nUse \`every_app_mcp_list_directory\` to explore the structure of any example, and \`every_app_mcp_read_file\` to view implementation details.`);
+    });
+}

package/dist/tools/read-file.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerReadFileTool(server: McpServer): void;

package/dist/tools/read-file.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import * as fs from "node:fs";
+import { getExamplesDir, errorResponse, textResponse, validatePathWithinBase } from "../utils.js";
+export function registerReadFileTool(server) {
+    server.tool("every_app_mcp_read_file", "Read the contents of a file from the Every App examples. Use this to see how patterns are implemented.", {
+        path: z
+            .string()
+            .describe('Path relative to the Every App examples root (e.g., "apps/todo-app/src/routes/index.tsx")'),
+        startLine: z
+            .number()
+            .optional()
+            .describe("Line number to start reading from (1-based). Defaults to 1."),
+        endLine: z
+            .number()
+            .optional()
+            .describe("Line number to stop reading at (inclusive). Defaults to end of file."),
+    }, async ({ path: inputPath, startLine, endLine }) => {
+        const result = getExamplesDir();
+        if ("error" in result) {
+            return errorResponse(result.error);
+        }
+        const examplesDir = result.dir;
+        // Validate path stays within examples directory
+        const pathValidation = validatePathWithinBase(examplesDir, inputPath);
+        if (!pathValidation.valid) {
+            return errorResponse(pathValidation.error);
+        }
+        const filePath = pathValidation.resolvedPath;
+        if (!fs.existsSync(filePath)) {
+            return errorResponse(`File not found: ${inputPath}`);
+        }
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory()) {
+            return errorResponse(`Path is a directory, not a file: ${inputPath}. Use list_directory instead.`);
+        }
+        const content = fs.readFileSync(filePath, "utf-8");
+        const lines = content.split("\n");
+        const start = Math.max(1, startLine || 1);
+        const end = Math.min(lines.length, endLine || lines.length);
+        const selectedLines = lines.slice(start - 1, end);
+        const numberedLines = selectedLines.map((line, idx) => `${(start + idx).toString().padStart(5, " ")}| ${line}`);
+        const header = `File: ${inputPath} (lines ${start}-${end} of ${lines.length})`;
+        const output = [header, "─".repeat(60), ...numberedLines].join("\n");
+        return textResponse(output);
+    });
+}

package/dist/tools/search-code.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerSearchCodeTool(server: McpServer): void;

package/dist/tools/search-code.js

@@ -0,0 +1,66 @@
+import { z } from "zod";
+import * as fs from "node:fs";
+import { searchFiles, getExamplesDir, errorResponse, textResponse, validatePathWithinBase, } from "../utils.js";
+export function registerSearchCodeTool(server) {
+    server.tool("every_app_mcp_search_code", "Search for patterns in the Every App examples using regex. Use this to find implementations of specific patterns.", {
+        pattern: z.string().describe("Regular expression pattern to search for"),
+        path: z
+            .string()
+            .optional()
+            .describe("Path to search within (relative to examples root). Defaults to entire examples directory."),
+        filePattern: z
+            .string()
+            .optional()
+            .describe('Glob pattern for files to include (e.g., "**/*.tsx", "**/*.ts")'),
+    }, async ({ pattern, path: inputPath, filePattern }) => {
+        const result = getExamplesDir();
+        if ("error" in result) {
+            return errorResponse(result.error);
+        }
+        const examplesDir = result.dir;
+        // Validate path stays within examples directory
+        if (inputPath) {
+            const pathValidation = validatePathWithinBase(examplesDir, inputPath);
+            if (!pathValidation.valid) {
+                return errorResponse(pathValidation.error);
+            }
+            if (!fs.existsSync(pathValidation.resolvedPath)) {
+                return errorResponse(`Path not found: ${inputPath}`);
+            }
+        }
+        try {
+            const matches = searchFiles(examplesDir, pattern, {
+                filePattern,
+                searchPath: inputPath,
+                maxResults: 100,
+            });
+            if (matches.length === 0) {
+                return textResponse(`No matches found for pattern: ${pattern}`);
+            }
+            // Group matches by file
+            const byFile = new Map();
+            for (const match of matches) {
+                const existing = byFile.get(match.file) || [];
+                existing.push(match);
+                byFile.set(match.file, existing);
+            }
+            // Format output
+            const lines = [`Found ${matches.length} matches:\n`];
+            for (const [file, fileMatches] of byFile) {
+                lines.push(file);
+                for (const match of fileMatches) {
+                    lines.push(`  ${match.line}: ${match.text}`);
+                }
+                lines.push("");
+            }
+            const truncated = matches.length >= 100;
+            if (truncated) {
+                lines.push("... (results truncated, refine your search)");
+            }
+            return textResponse(lines.join("\n"));
+        }
+        catch (error) {
+            return errorResponse(`Search error: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    });
+}

package/dist/utils.d.ts

@@ -0,0 +1,38 @@
+export declare const IGNORE_PATTERNS: string[];
+export declare function getExamplesDir(): {
+    dir: string;
+} | {
+    error: string;
+};
+export declare function errorResponse(text: string): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};
+export declare function validatePathWithinBase(baseDir: string, inputPath: string): {
+    valid: true;
+    resolvedPath: string;
+} | {
+    valid: false;
+    error: string;
+};
+export declare function textResponse(text: string): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};
+export declare function findFiles(baseDir: string, pattern: string, options?: {
+    maxResults?: number;
+}): string[];
+export interface SearchMatch {
+    file: string;
+    line: number;
+    text: string;
+}
+export declare function searchFiles(baseDir: string, searchPattern: string, options?: {
+    filePattern?: string;
+    maxResults?: number;
+    searchPath?: string;
+}): SearchMatch[];

package/dist/utils.js

@@ -0,0 +1,168 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getExamplesDirectory } from "./setup.js";
+// Ignore patterns for directory listings and searches
+export const IGNORE_PATTERNS = [
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    ".next",
+    ".turbo",
+    ".cache",
+    "coverage",
+    ".wrangler",
+    ".mf",
+];
+// Binary file extensions to skip when searching
+const BINARY_EXTENSIONS = new Set([
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".ico",
+    ".webp",
+    ".svg",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".eot",
+    ".mp3",
+    ".mp4",
+    ".wav",
+    ".pdf",
+    ".zip",
+    ".tar",
+    ".gz",
+    ".lock",
+]);
+// Helper to get examples directory or return error
+export function getExamplesDir() {
+    const examplesDir = getExamplesDirectory();
+    if (!fs.existsSync(examplesDir)) {
+        return {
+            error: `Examples directory not found at ${examplesDir}. The server may still be initializing - please try again in a moment.`,
+        };
+    }
+    return { dir: examplesDir };
+}
+// Helper to create error response
+export function errorResponse(text) {
+    return {
+        content: [{ type: "text", text }],
+    };
+}
+// Validate that a resolved path stays within the base directory (prevents path traversal)
+export function validatePathWithinBase(baseDir, inputPath) {
+    const resolvedBase = path.resolve(baseDir);
+    const resolvedPath = path.resolve(baseDir, inputPath);
+    if (!resolvedPath.startsWith(resolvedBase + path.sep) && resolvedPath !== resolvedBase) {
+        return {
+            valid: false,
+            error: "Path traversal detected - access denied",
+        };
+    }
+    return { valid: true, resolvedPath };
+}
+// Helper to create success response
+export function textResponse(text) {
+    return {
+        content: [{ type: "text", text }],
+    };
+}
+// Check if a path should be ignored
+function shouldIgnore(name) {
+    return IGNORE_PATTERNS.includes(name) || name.startsWith(".");
+}
+// Check if a file is binary based on extension
+function isBinaryFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return BINARY_EXTENSIONS.has(ext);
+}
+// Recursively find all files matching a glob-like pattern
+export function findFiles(baseDir, pattern, options = {}) {
+    const { maxResults = 500 } = options;
+    const results = [];
+    // Convert glob pattern to regex
+    const regexPattern = pattern
+        .replace(/\*\*/g, "{{GLOBSTAR}}")
+        .replace(/\*/g, "[^/]*")
+        .replace(/\?/g, ".")
+        .replace(/{{GLOBSTAR}}/g, ".*");
+    const regex = new RegExp(`^${regexPattern}$`);
+    function walk(dir, relativePath = "") {
+        if (results.length >= maxResults)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return; // Skip directories we can't read
+        }
+        for (const entry of entries) {
+            if (results.length >= maxResults)
+                break;
+            if (shouldIgnore(entry.name))
+                continue;
+            const fullPath = path.join(dir, entry.name);
+            const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                walk(fullPath, relPath);
+            }
+            else if (entry.isFile()) {
+                if (regex.test(relPath)) {
+                    results.push(relPath);
+                }
+            }
+        }
+    }
+    walk(baseDir);
+    return results;
+}
+export function searchFiles(baseDir, searchPattern, options = {}) {
+    const { filePattern, maxResults = 100, searchPath } = options;
+    const matches = [];
+    const searchDir = searchPath ? path.join(baseDir, searchPath) : baseDir;
+    // Get all files to search
+    const globPattern = filePattern || "**/*";
+    const files = findFiles(searchDir, globPattern, { maxResults: 1000 });
+    let regex;
+    try {
+        regex = new RegExp(searchPattern, "gi");
+    }
+    catch {
+        throw new Error(`Invalid regex pattern: ${searchPattern}`);
+    }
+    for (const file of files) {
+        if (matches.length >= maxResults)
+            break;
+        const fullPath = path.join(searchDir, file);
+        // Skip binary files
+        if (isBinaryFile(fullPath))
+            continue;
+        let content;
+        try {
+            content = fs.readFileSync(fullPath, "utf-8");
+        }
+        catch {
+            continue; // Skip files we can't read
+        }
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+            if (matches.length >= maxResults)
+                break;
+            const line = lines[i];
+            regex.lastIndex = 0; // Reset regex state
+            if (regex.test(line)) {
+                const relativePath = searchPath ? `${searchPath}/${file}` : file;
+                matches.push({
+                    file: relativePath,
+                    line: i + 1,
+                    text: line.length > 200 ? line.substring(0, 200) + "..." : line,
+                });
+            }
+        }
+    }
+    return matches;
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@every-app/mcp",
+  "version": "0.0.1",
+  "description": "MCP server for Every App coding agents",
+  "type": "module",
+  "bin": {
+    "every-app-mcp": "./dist/index.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "types:check": "tsc --noEmit",
+    "start": "node dist/index.js",
+    "build:prepublish": "pnpm install --ignore-scripts && npm run types:check && npm run build",
+    "prepublishOnly": "npm run build:prepublish"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "typescript": "^5.7.2"
+  }
+}