@getjack/jack 0.1.20 → 0.1.23

package/templates/ai-chat/src/index.ts

@@ -0,0 +1,105 @@
+interface Env {
+	AI: Ai;
+	ASSETS: Fetcher;
+}
+
+interface ChatMessage {
+	role: "user" | "assistant" | "system";
+	content: string;
+}
+
+// Rate limiting: 10 requests per minute per IP
+const RATE_LIMIT = 10;
+const RATE_WINDOW_MS = 60_000;
+const rateLimitMap = new Map<string, { count: number; resetAt: number }>();
+
+function checkRateLimit(ip: string): boolean {
+	const now = Date.now();
+	const entry = rateLimitMap.get(ip);
+
+	if (!entry || now >= entry.resetAt) {
+		rateLimitMap.set(ip, { count: 1, resetAt: now + RATE_WINDOW_MS });
+		return true;
+	}
+
+	if (entry.count >= RATE_LIMIT) {
+		return false;
+	}
+
+	entry.count++;
+	return true;
+}
+
+// Clean up old entries periodically to prevent memory leaks
+function cleanupRateLimitMap(): void {
+	const now = Date.now();
+	for (const [ip, entry] of rateLimitMap) {
+		if (now >= entry.resetAt) {
+			rateLimitMap.delete(ip);
+		}
+	}
+}
+
+export default {
+	async fetch(request: Request, env: Env): Promise<Response> {
+		const url = new URL(request.url);
+
+		// Serve static assets for non-API routes
+		if (request.method === "GET" && !url.pathname.startsWith("/api")) {
+			return env.ASSETS.fetch(request);
+		}
+
+		// POST /api/chat - Streaming chat endpoint
+		if (request.method === "POST" && url.pathname === "/api/chat") {
+			const ip = request.headers.get("cf-connecting-ip") || "unknown";
+
+			// Check rate limit
+			if (!checkRateLimit(ip)) {
+				// Cleanup old entries occasionally
+				cleanupRateLimitMap();
+				return Response.json(
+					{ error: "Too many requests. Please wait a moment and try again." },
+					{ status: 429 },
+				);
+			}
+
+			try {
+				const body = (await request.json()) as { messages?: ChatMessage[] };
+				const messages = body.messages;
+
+				if (!messages || !Array.isArray(messages)) {
+					return Response.json(
+						{ error: "Invalid request. Please provide a messages array." },
+						{ status: 400 },
+					);
+				}
+
+				// Stream response using SSE
+				const stream = await env.AI.run(
+					"@cf/mistral/mistral-7b-instruct-v0.1",
+					{
+						messages,
+						stream: true,
+						max_tokens: 1024,
+					},
+				);
+
+				return new Response(stream, {
+					headers: {
+						"Content-Type": "text/event-stream",
+						"Cache-Control": "no-cache",
+						Connection: "keep-alive",
+					},
+				});
+			} catch (err) {
+				console.error("Chat error:", err);
+				return Response.json(
+					{ error: "Something went wrong. Please try again." },
+					{ status: 500 },
+				);
+			}
+		}
+
+		return Response.json({ error: "Not found" }, { status: 404 });
+	},
+};

package/templates/ai-chat/wrangler.jsonc

@@ -0,0 +1,12 @@
+{
+	"name": "jack-template",
+	"main": "src/index.ts",
+	"compatibility_date": "2024-12-01",
+	"ai": {
+		"binding": "AI"
+	},
+	"assets": {
+		"directory": "public",
+		"binding": "ASSETS"
+	}
+}

package/templates/semantic-search/.jack.json

@@ -0,0 +1,26 @@
+{
+	"name": "semantic-search",
+	"description": "Semantic search with AI embeddings + Vectorize",
+	"secrets": [],
+	"capabilities": ["ai", "db"],
+	"intent": {
+		"keywords": ["rag", "semantic", "search", "embeddings", "vectorize", "vector", "similarity"],
+		"examples": ["RAG app", "document search", "semantic search", "knowledge base"]
+	},
+	"hooks": {
+		"postDeploy": [
+			{ "action": "clipboard", "text": "{{url}}", "message": "URL copied" },
+			{
+				"action": "box",
+				"title": "Semantic Search: {{name}}",
+				"lines": [
+					"{{url}}",
+					"",
+					"Open in browser to index documents and search!",
+					"",
+					"Note: Local dev requires 'wrangler dev --remote'"
+				]
+			}
+		]
+	}
+}

package/templates/semantic-search/bun.lock

@@ -0,0 +1,18 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "jack-template",
+      "devDependencies": {
+        "@cloudflare/workers-types": "^4.20241205.0",
+        "typescript": "^5.0.0",
+      },
+    },
+  },
+  "packages": {
+    "@cloudflare/workers-types": ["@cloudflare/workers-types@4.20260120.0", "", {}, "sha512-B8pueG+a5S+mdK3z8oKu1ShcxloZ7qWb68IEyLLaepvdryIbNC7JVPcY0bWsjS56UQVKc5fnyRge3yZIwc9bxw=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+  }
+}

package/templates/semantic-search/package.json

@@ -0,0 +1,12 @@
+{
+	"name": "jack-template",
+	"type": "module",
+	"scripts": {
+		"dev": "wrangler dev --remote",
+		"deploy": "wrangler deploy"
+	},
+	"devDependencies": {
+		"@cloudflare/workers-types": "^4.20241205.0",
+		"typescript": "^5.0.0"
+	}
+}

package/templates/semantic-search/public/app.js

@@ -0,0 +1,120 @@
+const docIdEl = document.getElementById("doc-id");
+const docContentEl = document.getElementById("doc-content");
+const indexBtn = document.getElementById("index-btn");
+const indexStatus = document.getElementById("index-status");
+const searchQueryEl = document.getElementById("search-query");
+const searchBtn = document.getElementById("search-btn");
+const resultsEl = document.getElementById("results");
+
+// Index document
+async function indexDocument() {
+	const id = docIdEl.value.trim();
+	const content = docContentEl.value.trim();
+
+	if (!id || !content) {
+		showStatus(indexStatus, "Please enter both ID and content", "error");
+		return;
+	}
+
+	indexBtn.disabled = true;
+	indexBtn.innerHTML = '<span class="loading"></span>Indexing...';
+
+	try {
+		const response = await fetch("/api/index", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ id, content }),
+		});
+
+		const data = await response.json();
+
+		if (response.ok) {
+			showStatus(indexStatus, `Document "${id}" indexed successfully!`, "success");
+			docIdEl.value = "";
+			docContentEl.value = "";
+		} else {
+			showStatus(indexStatus, data.error || "Failed to index document", "error");
+		}
+	} catch (err) {
+		showStatus(indexStatus, "Network error. Please try again.", "error");
+	} finally {
+		indexBtn.disabled = false;
+		indexBtn.textContent = "Index Document";
+	}
+}
+
+// Search documents
+async function searchDocuments() {
+	const query = searchQueryEl.value.trim();
+
+	if (!query) {
+		resultsEl.innerHTML = '<div class="no-results">Please enter a search query</div>';
+		return;
+	}
+
+	searchBtn.disabled = true;
+	searchBtn.innerHTML = '<span class="loading"></span>Searching...';
+	resultsEl.innerHTML = "";
+
+	try {
+		const response = await fetch("/api/search", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ query, limit: 5 }),
+		});
+
+		const data = await response.json();
+
+		if (response.ok) {
+			if (data.results && data.results.length > 0) {
+				resultsEl.innerHTML = data.results
+					.map(
+						(result) => `
+          <div class="result">
+            <div class="result-header">
+              <span class="result-id">${escapeHtml(result.id)}</span>
+              <span class="result-score">Score: ${(result.score * 100).toFixed(1)}%</span>
+            </div>
+            <div class="result-preview">${escapeHtml(result.metadata?.preview || "No preview available")}</div>
+          </div>
+        `,
+					)
+					.join("");
+			} else {
+				resultsEl.innerHTML = '<div class="no-results">No matching documents found</div>';
+			}
+		} else {
+			resultsEl.innerHTML = `<div class="no-results">${escapeHtml(data.error || "Search failed")}</div>`;
+		}
+	} catch (err) {
+		resultsEl.innerHTML = '<div class="no-results">Network error. Please try again.</div>';
+	} finally {
+		searchBtn.disabled = false;
+		searchBtn.textContent = "Search";
+	}
+}
+
+// Helper functions
+function showStatus(el, message, type) {
+	el.textContent = message;
+	el.className = `status ${type}`;
+}
+
+function escapeHtml(text) {
+	const div = document.createElement("div");
+	div.textContent = text;
+	return div.innerHTML;
+}
+
+// Event listeners
+indexBtn.addEventListener("click", indexDocument);
+searchBtn.addEventListener("click", searchDocuments);
+
+// Enter key support
+docIdEl.addEventListener("keypress", (e) => {
+	if (e.key === "Enter") docContentEl.focus();
+});
+
+searchQueryEl.addEventListener("keypress", (e) => {
+	if (e.key === "Enter") searchDocuments();
+});

package/templates/semantic-search/public/index.html

@@ -0,0 +1,210 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Semantic Search</title>
+  <style>
+    * {
+      box-sizing: border-box;
+    }
+
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      line-height: 1.6;
+      max-width: 800px;
+      margin: 0 auto;
+      padding: 2rem 1rem;
+      background: #f5f5f5;
+      color: #333;
+    }
+
+    h1 {
+      text-align: center;
+      color: #1a1a1a;
+      margin-bottom: 0.5rem;
+    }
+
+    .subtitle {
+      text-align: center;
+      color: #666;
+      margin-bottom: 2rem;
+    }
+
+    .section {
+      background: white;
+      border-radius: 12px;
+      padding: 1.5rem;
+      margin-bottom: 1.5rem;
+      box-shadow: 0 2px 8px rgba(0, 0, 0, 0.08);
+    }
+
+    h2 {
+      margin-top: 0;
+      color: #1a1a1a;
+      font-size: 1.25rem;
+    }
+
+    label {
+      display: block;
+      margin-bottom: 0.5rem;
+      font-weight: 500;
+      color: #444;
+    }
+
+    input[type="text"] {
+      width: 100%;
+      padding: 0.75rem;
+      border: 1px solid #ddd;
+      border-radius: 8px;
+      font-size: 1rem;
+      margin-bottom: 1rem;
+      transition: border-color 0.2s;
+    }
+
+    input[type="text"]:focus {
+      outline: none;
+      border-color: #0066cc;
+    }
+
+    textarea {
+      width: 100%;
+      padding: 0.75rem;
+      border: 1px solid #ddd;
+      border-radius: 8px;
+      font-size: 1rem;
+      min-height: 120px;
+      resize: vertical;
+      font-family: inherit;
+      margin-bottom: 1rem;
+    }
+
+    textarea:focus {
+      outline: none;
+      border-color: #0066cc;
+    }
+
+    button {
+      background: #0066cc;
+      color: white;
+      border: none;
+      padding: 0.75rem 1.5rem;
+      border-radius: 8px;
+      font-size: 1rem;
+      cursor: pointer;
+      transition: background 0.2s;
+    }
+
+    button:hover {
+      background: #0052a3;
+    }
+
+    button:disabled {
+      background: #999;
+      cursor: not-allowed;
+    }
+
+    .status {
+      margin-top: 1rem;
+      padding: 0.75rem;
+      border-radius: 8px;
+      display: none;
+    }
+
+    .status.success {
+      display: block;
+      background: #e6f4ea;
+      color: #1e7e34;
+    }
+
+    .status.error {
+      display: block;
+      background: #fce8e6;
+      color: #c5221f;
+    }
+
+    .results {
+      margin-top: 1rem;
+    }
+
+    .result {
+      background: #f8f9fa;
+      border-radius: 8px;
+      padding: 1rem;
+      margin-bottom: 0.75rem;
+      border-left: 4px solid #0066cc;
+    }
+
+    .result-header {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      margin-bottom: 0.5rem;
+    }
+
+    .result-id {
+      font-weight: 600;
+      color: #1a1a1a;
+    }
+
+    .result-score {
+      font-size: 0.85rem;
+      color: #666;
+      background: #e8e8e8;
+      padding: 0.25rem 0.5rem;
+      border-radius: 4px;
+    }
+
+    .result-preview {
+      color: #555;
+      font-size: 0.95rem;
+    }
+
+    .no-results {
+      text-align: center;
+      color: #666;
+      padding: 2rem;
+    }
+
+    .loading {
+      display: inline-block;
+      width: 16px;
+      height: 16px;
+      border: 2px solid #fff;
+      border-radius: 50%;
+      border-top-color: transparent;
+      animation: spin 0.8s linear infinite;
+      margin-right: 0.5rem;
+      vertical-align: middle;
+    }
+
+    @keyframes spin {
+      to { transform: rotate(360deg); }
+    }
+  </style>
+</head>
+<body>
+  <h1>Semantic Search</h1>
+  <p class="subtitle">Index documents and search by meaning using AI embeddings</p>
+
+  <div class="section">
+    <h2>Index Document</h2>
+    <label for="doc-id">Document ID</label>
+    <input type="text" id="doc-id" placeholder="e.g., doc-001" />
+    <label for="doc-content">Content</label>
+    <textarea id="doc-content" placeholder="Enter the document content to index..."></textarea>
+    <button id="index-btn">Index Document</button>
+    <div id="index-status" class="status"></div>
+  </div>
+
+  <div class="section">
+    <h2>Search</h2>
+    <label for="search-query">Search Query</label>
+    <input type="text" id="search-query" placeholder="Enter your search query..." />
+    <button id="search-btn">Search</button>
+    <div id="results" class="results"></div>
+  </div>
+
+  <script src="/app.js"></script>
+</body>
+</html>

package/templates/semantic-search/schema.sql

@@ -0,0 +1,5 @@
+CREATE TABLE IF NOT EXISTS documents (
+  id TEXT PRIMARY KEY,
+  content TEXT NOT NULL,
+  created_at TEXT DEFAULT CURRENT_TIMESTAMP
+);

package/templates/semantic-search/src/index.ts

@@ -0,0 +1,144 @@
+interface Env {
+	AI: Ai;
+	VECTORS: VectorizeIndex;
+	DB: D1Database;
+	ASSETS: Fetcher;
+}
+
+// Rate limiting: 10 requests per minute per IP
+const RATE_LIMIT = 10;
+const RATE_WINDOW_MS = 60_000;
+const rateLimitMap = new Map<string, { count: number; resetAt: number }>();
+
+function checkRateLimit(ip: string): boolean {
+	const now = Date.now();
+	const entry = rateLimitMap.get(ip);
+
+	if (!entry || now > entry.resetAt) {
+		rateLimitMap.set(ip, { count: 1, resetAt: now + RATE_WINDOW_MS });
+		return true;
+	}
+
+	if (entry.count >= RATE_LIMIT) {
+		return false;
+	}
+
+	entry.count++;
+	return true;
+}
+
+/**
+ * Extract embedding vector from AI response
+ * Handles union type from @cf/baai/bge-base-en-v1.5
+ */
+function getEmbeddingVector(response: Awaited<ReturnType<Ai["run"]>>): number[] | null {
+	if (
+		response &&
+		typeof response === "object" &&
+		"data" in response &&
+		Array.isArray(response.data) &&
+		response.data.length > 0
+	) {
+		return response.data[0] as number[];
+	}
+	return null;
+}
+
+export default {
+	async fetch(request: Request, env: Env): Promise<Response> {
+		const url = new URL(request.url);
+
+		// Serve static assets for non-API routes
+		if (request.method === "GET" && !url.pathname.startsWith("/api")) {
+			return env.ASSETS.fetch(request);
+		}
+
+		// Rate limiting for API routes
+		const ip = request.headers.get("cf-connecting-ip") || "unknown";
+		if (!checkRateLimit(ip)) {
+			return Response.json({ error: "Too many requests. Please wait a moment." }, { status: 429 });
+		}
+
+		// POST /api/index - Index a document
+		if (request.method === "POST" && url.pathname === "/api/index") {
+			try {
+				const body = (await request.json()) as {
+					id?: string;
+					content?: string;
+				};
+				const { id, content } = body;
+
+				if (!id || !content) {
+					return Response.json({ error: "Missing id or content" }, { status: 400 });
+				}
+
+				// Generate embedding using free Cloudflare AI
+				const embedding = await env.AI.run("@cf/baai/bge-base-en-v1.5", {
+					text: content,
+				});
+
+				const embeddingVector = getEmbeddingVector(embedding);
+				if (!embeddingVector) {
+					return Response.json({ error: "Failed to generate embedding" }, { status: 500 });
+				}
+
+				// Store in Vectorize
+				await env.VECTORS.insert([
+					{
+						id,
+						values: embeddingVector,
+						metadata: { preview: content.slice(0, 100) },
+					},
+				]);
+
+				// Store full content in D1
+				await env.DB.prepare("INSERT OR REPLACE INTO documents (id, content) VALUES (?, ?)")
+					.bind(id, content)
+					.run();
+
+				return Response.json({ success: true, id });
+			} catch (err) {
+				console.error("Index error:", err);
+				return Response.json({ error: "Failed to index document" }, { status: 500 });
+			}
+		}
+
+		// POST /api/search - Semantic search
+		if (request.method === "POST" && url.pathname === "/api/search") {
+			try {
+				const body = (await request.json()) as {
+					query?: string;
+					limit?: number;
+				};
+				const { query, limit = 5 } = body;
+
+				if (!query) {
+					return Response.json({ error: "Missing query" }, { status: 400 });
+				}
+
+				// Generate query embedding
+				const embedding = await env.AI.run("@cf/baai/bge-base-en-v1.5", {
+					text: query,
+				});
+
+				const embeddingVector = getEmbeddingVector(embedding);
+				if (!embeddingVector) {
+					return Response.json({ error: "Failed to generate embedding" }, { status: 500 });
+				}
+
+				// Search Vectorize
+				const results = await env.VECTORS.query(embeddingVector, {
+					topK: limit,
+					returnMetadata: "all",
+				});
+
+				return Response.json({ results: results.matches });
+			} catch (err) {
+				console.error("Search error:", err);
+				return Response.json({ error: "Search failed" }, { status: 500 });
+			}
+		}
+
+		return Response.json({ error: "Not found" }, { status: 404 });
+	},
+};

package/templates/semantic-search/tsconfig.json

@@ -0,0 +1,13 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "ES2022",
+		"moduleResolution": "bundler",
+		"strict": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true,
+		"types": ["@cloudflare/workers-types"]
+	},
+	"include": ["src/**/*"]
+}

package/templates/semantic-search/wrangler.jsonc

@@ -0,0 +1,27 @@
+{
+	"name": "jack-template",
+	"main": "src/index.ts",
+	"compatibility_date": "2024-12-01",
+	"ai": {
+		"binding": "AI"
+	},
+	"vectorize": [
+		{
+			"binding": "VECTORS",
+			"index_name": "jack-template-vectors",
+			// preset: cloudflare = 768 dimensions, cosine metric
+			// matches @cf/baai/bge-base-en-v1.5 embedding model
+			"preset": "cloudflare"
+		}
+	],
+	"d1_databases": [
+		{
+			"binding": "DB",
+			"database_name": "jack-template-db"
+		}
+	],
+	"assets": {
+		"directory": "public",
+		"binding": "ASSETS"
+	}
+}