@codebakers/cli 1.2.1 → 1.3.1

package/src/mcp/server.ts

@@ -343,6 +343,40 @@ class CodeBakersServer {
             required: ['patterns'],
           },
         },
+        {
+          name: 'search_patterns',
+          description:
+            'Search CodeBakers patterns by keyword or topic. Returns relevant code snippets without reading entire files. Use this when you need specific guidance like "supabase auth setup", "optimistic updates", "soft delete", "form validation".',
+          inputSchema: {
+            type: 'object' as const,
+            properties: {
+              query: {
+                type: 'string',
+                description: 'Search query (e.g., "supabase auth", "stripe checkout", "zod validation", "loading states")',
+              },
+            },
+            required: ['query'],
+          },
+        },
+        {
+          name: 'get_pattern_section',
+          description:
+            'Get a specific section from a pattern file instead of the whole file. Much faster than get_pattern for targeted lookups.',
+          inputSchema: {
+            type: 'object' as const,
+            properties: {
+              pattern: {
+                type: 'string',
+                description: 'Pattern name (e.g., "02-auth", "03-api")',
+              },
+              section: {
+                type: 'string',
+                description: 'Section name or keyword to find within the pattern (e.g., "OAuth", "rate limiting", "error handling")',
+              },
+            },
+            required: ['pattern', 'section'],
+          },
+        },
       ],
     }));
 
@@ -370,6 +404,12 @@ class CodeBakersServer {
         case 'get_patterns':
           return this.handleGetPatterns(args as { patterns: string[] });
 
+        case 'search_patterns':
+          return this.handleSearchPatterns(args as { query: string });
+
+        case 'get_pattern_section':
+          return this.handleGetPatternSection(args as { pattern: string; section: string });
+
         default:
           throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
       }
@@ -592,6 +632,210 @@ Show the user what their simple request was expanded into, then proceed with the
     return response.json();
   }
 
+  private async handleSearchPatterns(args: { query: string }) {
+    const { query } = args;
+
+    // Call API endpoint for semantic search
+    const response = await fetch(`${this.apiUrl}/api/patterns/search`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify({ query }),
+    });
+
+    if (!response.ok) {
+      // Fallback: If search endpoint doesn't exist, do client-side search
+      return this.fallbackSearch(query);
+    }
+
+    const data = await response.json();
+
+    const results = data.results
+      .map((r: { pattern: string; section: string; content: string; relevance: number }) =>
+        `### ${r.pattern} - ${r.section}\n\n\`\`\`typescript\n${r.content}\n\`\`\`\n\nRelevance: ${Math.round(r.relevance * 100)}%`
+      )
+      .join('\n\n---\n\n');
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `# Search Results for "${query}"\n\n${results || 'No results found. Try a different query.'}`,
+        },
+      ],
+    };
+  }
+
+  private async fallbackSearch(query: string) {
+    // Keyword-based fallback if API search not available
+    const keywordPatternMap: Record<string, string[]> = {
+      'auth': ['02-auth'],
+      'login': ['02-auth'],
+      'oauth': ['02-auth'],
+      'supabase': ['02-auth', '01-database'],
+      'database': ['01-database'],
+      'drizzle': ['01-database'],
+      'schema': ['01-database'],
+      'api': ['03-api'],
+      'route': ['03-api'],
+      'validation': ['03-api', '04-frontend'],
+      'zod': ['03-api', '04-frontend'],
+      'frontend': ['04-frontend'],
+      'form': ['04-frontend'],
+      'react': ['04-frontend'],
+      'component': ['04-frontend'],
+      'stripe': ['05-payments'],
+      'payment': ['05-payments'],
+      'checkout': ['05-payments'],
+      'subscription': ['05-payments'],
+      'email': ['06-integrations'],
+      'webhook': ['06-integrations'],
+      'cache': ['07-performance'],
+      'test': ['08-testing'],
+      'playwright': ['08-testing'],
+      'design': ['09-design'],
+      'ui': ['09-design'],
+      'accessibility': ['09-design'],
+      'websocket': ['11-realtime'],
+      'realtime': ['11-realtime'],
+      'notification': ['11-realtime'],
+      'saas': ['12-saas'],
+      'tenant': ['12-saas'],
+      'mobile': ['13-mobile'],
+      'expo': ['13-mobile'],
+      'ai': ['14-ai'],
+      'openai': ['14-ai'],
+      'embedding': ['14-ai'],
+      'analytics': ['26-analytics'],
+      'search': ['27-search'],
+      'animation': ['30-motion'],
+      'framer': ['30-motion'],
+    };
+
+    const lowerQuery = query.toLowerCase();
+    const matchedPatterns = new Set<string>();
+
+    for (const [keyword, patterns] of Object.entries(keywordPatternMap)) {
+      if (lowerQuery.includes(keyword)) {
+        patterns.forEach(p => matchedPatterns.add(p));
+      }
+    }
+
+    if (matchedPatterns.size === 0) {
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `# No patterns found for "${query}"\n\nTry:\n- "auth" for authentication patterns\n- "api" for API route patterns\n- "form" for frontend form patterns\n- "stripe" for payment patterns\n\nOr use \`list_patterns\` to see all available patterns.`,
+          },
+        ],
+      };
+    }
+
+    const patterns = Array.from(matchedPatterns).slice(0, 3);
+    const result = await this.fetchPatterns(patterns);
+
+    const content = Object.entries(result.patterns || {})
+      .map(([name, text]) => `## ${name}\n\n${text}`)
+      .join('\n\n---\n\n');
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `# Patterns matching "${query}"\n\nFound in: ${patterns.join(', ')}\n\n${content}`,
+        },
+      ],
+    };
+  }
+
+  private async handleGetPatternSection(args: { pattern: string; section: string }) {
+    const { pattern, section } = args;
+
+    // Fetch the full pattern first
+    const result = await this.fetchPatterns([pattern]);
+
+    if (!result.patterns || !result.patterns[pattern]) {
+      throw new McpError(
+        ErrorCode.InvalidRequest,
+        `Pattern "${pattern}" not found. Use list_patterns to see available patterns.`
+      );
+    }
+
+    const fullContent = result.patterns[pattern];
+
+    // Find the section (case-insensitive search for headers or content)
+    const sectionLower = section.toLowerCase();
+    const lines = fullContent.split('\n');
+    const sections: string[] = [];
+    let currentSection = '';
+    let currentContent: string[] = [];
+    let capturing = false;
+    let relevanceScore = 0;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      // Check if this is a header
+      if (line.match(/^#{1,3}\s/)) {
+        // Save previous section if we were capturing
+        if (capturing && currentContent.length > 0) {
+          sections.push(`### ${currentSection}\n\n${currentContent.join('\n')}`);
+        }
+
+        currentSection = line.replace(/^#+\s*/, '');
+        currentContent = [];
+
+        // Check if this section matches our query
+        if (currentSection.toLowerCase().includes(sectionLower)) {
+          capturing = true;
+          relevanceScore++;
+        } else {
+          capturing = false;
+        }
+      } else if (capturing) {
+        currentContent.push(line);
+      }
+
+      // Also check content for keyword matches
+      if (!capturing && line.toLowerCase().includes(sectionLower)) {
+        // Found keyword in content, capture surrounding context
+        const start = Math.max(0, i - 5);
+        const end = Math.min(lines.length, i + 20);
+        const context = lines.slice(start, end).join('\n');
+        sections.push(`### Found at line ${i + 1}\n\n${context}`);
+        relevanceScore++;
+      }
+    }
+
+    // Capture last section if we were still capturing
+    if (capturing && currentContent.length > 0) {
+      sections.push(`### ${currentSection}\n\n${currentContent.join('\n')}`);
+    }
+
+    if (sections.length === 0) {
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `# Section "${section}" not found in ${pattern}\n\nThe pattern exists but doesn't contain a section matching "${section}".\n\nTry:\n- A broader search term\n- \`get_pattern ${pattern}\` to see the full content\n- \`search_patterns ${section}\` to search across all patterns`,
+          },
+        ],
+      };
+    }
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `# ${pattern} - "${section}"\n\n${sections.slice(0, 5).join('\n\n---\n\n')}`,
+        },
+      ],
+    };
+  }
+
   async run(): Promise<void> {
     const transport = new StdioServerTransport();
     await this.server.connect(transport);

package/src/templates/nextjs-supabase.ts

@@ -0,0 +1,371 @@
+// Next.js + Supabase + Drizzle project template
+
+export const PACKAGE_JSON = {
+  name: "my-project",
+  version: "0.1.0",
+  private: true,
+  scripts: {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "next lint",
+    "db:generate": "drizzle-kit generate",
+    "db:push": "drizzle-kit push",
+    "db:studio": "drizzle-kit studio"
+  },
+  dependencies: {
+    "next": "15.1.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "@supabase/supabase-js": "^2.47.10",
+    "@supabase/ssr": "^0.5.2",
+    "drizzle-orm": "^0.38.2",
+    "postgres": "^3.4.5",
+    "zod": "^3.24.1",
+    "react-hook-form": "^7.54.1",
+    "@hookform/resolvers": "^3.9.1",
+    "lucide-react": "^0.468.0",
+    "clsx": "^2.1.1",
+    "tailwind-merge": "^2.6.0"
+  },
+  devDependencies: {
+    "@types/node": "^22.10.2",
+    "@types/react": "^19.0.1",
+    "@types/react-dom": "^19.0.1",
+    "typescript": "^5.7.2",
+    "tailwindcss": "^3.4.17",
+    "postcss": "^8.4.49",
+    "autoprefixer": "^10.4.20",
+    "drizzle-kit": "^0.30.1",
+    "eslint": "^9.17.0",
+    "eslint-config-next": "15.1.0"
+  }
+};
+
+export const ENV_EXAMPLE = `# Supabase
+NEXT_PUBLIC_SUPABASE_URL=your-supabase-url
+NEXT_PUBLIC_SUPABASE_ANON_KEY=your-anon-key
+SUPABASE_SERVICE_ROLE_KEY=your-service-role-key
+
+# Database (from Supabase connection string)
+DATABASE_URL=postgresql://postgres:[password]@db.[project-ref].supabase.co:5432/postgres
+`;
+
+export const DRIZZLE_CONFIG = `import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  schema: "./src/db/schema.ts",
+  out: "./src/db/migrations",
+  dialect: "postgresql",
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+});
+`;
+
+export const DB_SCHEMA = `import { pgTable, text, timestamp, uuid, boolean } from "drizzle-orm/pg-core";
+
+// Users table (synced with Supabase Auth)
+export const users = pgTable("users", {
+  id: uuid("id").primaryKey().notNull(),
+  email: text("email").notNull().unique(),
+  name: text("name"),
+  avatarUrl: text("avatar_url"),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull(),
+});
+
+// Example: Add your tables here following this pattern
+// export const posts = pgTable("posts", {
+//   id: uuid("id").primaryKey().defaultRandom(),
+//   title: text("title").notNull(),
+//   content: text("content"),
+//   authorId: uuid("author_id").references(() => users.id),
+//   published: boolean("published").default(false),
+//   createdAt: timestamp("created_at").defaultNow().notNull(),
+// });
+`;
+
+export const DB_INDEX = `import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+import * as schema from "./schema";
+
+const connectionString = process.env.DATABASE_URL!;
+
+const client = postgres(connectionString, { prepare: false });
+export const db = drizzle(client, { schema });
+
+export type DB = typeof db;
+`;
+
+export const SUPABASE_SERVER = `import { createServerClient } from "@supabase/ssr";
+import { cookies } from "next/headers";
+
+export async function createClient() {
+  const cookieStore = await cookies();
+
+  return createServerClient(
+    process.env.NEXT_PUBLIC_SUPABASE_URL!,
+    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
+    {
+      cookies: {
+        getAll() {
+          return cookieStore.getAll();
+        },
+        setAll(cookiesToSet) {
+          try {
+            cookiesToSet.forEach(({ name, value, options }) =>
+              cookieStore.set(name, value, options)
+            );
+          } catch {
+            // The \`setAll\` method was called from a Server Component.
+            // This can be ignored if you have middleware refreshing user sessions.
+          }
+        },
+      },
+    }
+  );
+}
+`;
+
+export const SUPABASE_CLIENT = `import { createBrowserClient } from "@supabase/ssr";
+
+export function createClient() {
+  return createBrowserClient(
+    process.env.NEXT_PUBLIC_SUPABASE_URL!,
+    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
+  );
+}
+`;
+
+export const SUPABASE_MIDDLEWARE = `import { createServerClient } from "@supabase/ssr";
+import { NextResponse, type NextRequest } from "next/server";
+
+export async function updateSession(request: NextRequest) {
+  let supabaseResponse = NextResponse.next({
+    request,
+  });
+
+  const supabase = createServerClient(
+    process.env.NEXT_PUBLIC_SUPABASE_URL!,
+    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
+    {
+      cookies: {
+        getAll() {
+          return request.cookies.getAll();
+        },
+        setAll(cookiesToSet) {
+          cookiesToSet.forEach(({ name, value }) =>
+            request.cookies.set(name, value)
+          );
+          supabaseResponse = NextResponse.next({
+            request,
+          });
+          cookiesToSet.forEach(({ name, value, options }) =>
+            supabaseResponse.cookies.set(name, value, options)
+          );
+        },
+      },
+    }
+  );
+
+  // This will refresh session if expired
+  await supabase.auth.getUser();
+
+  return supabaseResponse;
+}
+`;
+
+export const MIDDLEWARE = `import { type NextRequest } from "next/server";
+import { updateSession } from "@/lib/supabase/middleware";
+
+export async function middleware(request: NextRequest) {
+  return await updateSession(request);
+}
+
+export const config = {
+  matcher: [
+    /*
+     * Match all request paths except for:
+     * - _next/static (static files)
+     * - _next/image (image optimization)
+     * - favicon.ico
+     * - public files
+     */
+    "/((?!_next/static|_next/image|favicon.ico|.*\\\\.(?:svg|png|jpg|jpeg|gif|webp)$).*)",
+  ],
+};
+`;
+
+export const TAILWIND_CONFIG = `import type { Config } from "tailwindcss";
+
+const config: Config = {
+  content: [
+    "./src/pages/**/*.{js,ts,jsx,tsx,mdx}",
+    "./src/components/**/*.{js,ts,jsx,tsx,mdx}",
+    "./src/app/**/*.{js,ts,jsx,tsx,mdx}",
+  ],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+};
+export default config;
+`;
+
+export const POSTCSS_CONFIG = `module.exports = {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+};
+`;
+
+export const TSCONFIG = {
+  compilerOptions: {
+    lib: ["dom", "dom.iterable", "esnext"],
+    allowJs: true,
+    skipLibCheck: true,
+    strict: true,
+    noEmit: true,
+    esModuleInterop: true,
+    module: "esnext",
+    moduleResolution: "bundler",
+    resolveJsonModule: true,
+    isolatedModules: true,
+    jsx: "preserve",
+    incremental: true,
+    plugins: [{ name: "next" }],
+    paths: {
+      "@/*": ["./src/*"]
+    }
+  },
+  include: ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  exclude: ["node_modules"]
+};
+
+export const NEXT_CONFIG = `import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  /* config options here */
+};
+
+export default nextConfig;
+`;
+
+export const GLOBALS_CSS = `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+:root {
+  --background: #ffffff;
+  --foreground: #171717;
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --background: #0a0a0a;
+    --foreground: #ededed;
+  }
+}
+
+body {
+  color: var(--foreground);
+  background: var(--background);
+  font-family: Arial, Helvetica, sans-serif;
+}
+`;
+
+export const LAYOUT_TSX = `import type { Metadata } from "next";
+import "./globals.css";
+
+export const metadata: Metadata = {
+  title: "My App",
+  description: "Built with CodeBakers patterns",
+};
+
+export default function RootLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <html lang="en">
+      <body>{children}</body>
+    </html>
+  );
+}
+`;
+
+export const PAGE_TSX = `export default function Home() {
+  return (
+    <main className="flex min-h-screen flex-col items-center justify-center p-24">
+      <h1 className="text-4xl font-bold mb-4">Welcome to Your App</h1>
+      <p className="text-gray-600 mb-8">Built with CodeBakers patterns</p>
+      <div className="flex gap-4">
+        <a
+          href="/login"
+          className="px-6 py-3 bg-blue-600 text-white rounded-lg hover:bg-blue-700 transition"
+        >
+          Get Started
+        </a>
+        <a
+          href="/docs"
+          className="px-6 py-3 border border-gray-300 rounded-lg hover:bg-gray-50 transition"
+        >
+          Documentation
+        </a>
+      </div>
+    </main>
+  );
+}
+`;
+
+export const UTILS_CN = `import { clsx, type ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+`;
+
+export const GITIGNORE = `# Dependencies
+node_modules
+.pnpm-debug.log*
+
+# Next.js
+.next/
+out/
+
+# Production
+build
+dist
+
+# Misc
+.DS_Store
+*.pem
+
+# Debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Local env files
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Vercel
+.vercel
+
+# TypeScript
+*.tsbuildinfo
+next-env.d.ts
+
+# IDE
+.idea
+.vscode/*
+!.vscode/settings.json
+`;