Refactor from ai sdk to claude

Author: tecoad

bun.lockb

@@ -5,11 +5,10 @@
 		"deploy": "wrangler deploy --minify"
 	},
 	"dependencies": {
-		"@ai-sdk/anthropic": "^1.0.5",
+		"@anthropic-ai/sdk": "^0.33.1",
 		"@hono/zod-validator": "^0.4.1",
 		"@react-email/components": "0.0.31",
 		"@types/react": "^19.0.1",
-		"ai": "^4.0.14",
 		"hono": "^4.6.13",
 		"react": "19.0.0",
 		"react-dom": "19.0.0",
@@ -18,6 +17,6 @@
 	"devDependencies": {
 		"@biomejs/biome": "1.9.4",
 		"@cloudflare/workers-types": "^4.20241112.0",
-		"wrangler": "^3.95.0"
+		"wrangler": "^3.96.0"
 	}
 }

package.json

@@ -0,0 +1,11 @@
+export async function fetchDomains(url: string): Promise<string[]> {
+	const response = await fetch(url);
+	const text = await response.text();
+
+	// Split text into lines and filter out comments and empty lines
+	return text
+		.split("\n")
+		.map((line) => line.trim())
+		.filter((line) => line && !line.startsWith("#"))
+		.filter(Boolean); // Remove empty lines
+}

src/fetch-domains.ts

@@ -0,0 +1,28 @@
+import { VALID_TLD } from "./send-claude-batch";
+
+// Helper function to get domain length without TLD
+const getDomainLength = (domain: string) =>
+	domain.slice(0, -VALID_TLD.length).length;
+
+// Helper function to sort domains by length
+const sortByLength = (a: string, b: string) =>
+	getDomainLength(a) - getDomainLength(b);
+
+export interface DomainWithScore {
+	domain: string;
+	score: number;
+}
+
+export function filterDomains(domains: string[]): string[] {
+	return [...new Set(domains)]
+		.filter((domain) => {
+			if (!domain.endsWith(VALID_TLD)) return false;
+
+			const domainWithoutTLD = domain.slice(0, -VALID_TLD.length);
+			if (/[\d-]/.test(domainWithoutTLD)) return false;
+
+			const length = domainWithoutTLD.length;
+			return length >= 1 && length <= 9;
+		})
+		.sort(sortByLength);
+}

src/filter-domains.ts

@@ -1,94 +1,85 @@
+import Anthropic from "@anthropic-ai/sdk";
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
-import { processDomainList } from "./process-list";
-import { sendResultsEmail } from "./resend";
+import { fetchDomains } from "./fetch-domains";
+import { filterDomains } from "./filter-domains";
+import { sendClaude } from "./send-claude";
+import { sendClaudeBatch } from "./send-claude-batch";
 
 type Bindings = {
 	ANTHROPIC_API_KEY: string;
-	CRON_URL: string;
+	REGISTROBR_TXT_URL: string;
 };
 
 const app = new Hono<{ Bindings: Bindings }>();
 
-export const querySchema = z.object({
-	url: z.string().url(),
-	batchSize: z
-		.string()
-		.default("500")
-		.transform((val) => Number.parseInt(val)),
-	limit: z
-		.string()
-		.optional()
-		.transform((val) => (val ? Number.parseInt(val) : undefined)),
-});
+app.get("/process-all", async (c) => {
+	try {
+		const domains = await fetchDomains(c.env.REGISTROBR_TXT_URL);
 
-const automateSchema = z.object({
-	to: z.string().email(),
-});
+		// Filter and sort domains
+		const filteredDomains = filterDomains(domains);
 
-app.get("/trigger", zValidator("query", automateSchema), async (c) => {
-	try {
-		const { to } = c.req.valid("query");
-		// Process domains with default parameters
-		const result = await processDomainList(c, { limit: 5000, batchSize: 500 });
-		// Send email with the results
-		await sendResultsEmail(c, to, result);
+		const batchId = await sendClaudeBatch(c, filteredDomains);
 
 		return c.json({
-			message: "Email sent successfully",
-			metadata: result.metadata,
+			message: "Batch sent successfully",
+			batchId,
 		});
 	} catch (error: unknown) {
 		console.error("Error in automation:", error);
 		const errorMessage =
 			error instanceof Error ? error.message : "Unknown error occurred";
 		return c.json(
 			{
-				error: "Failed to process automation",
+				error: "Failed to process batch",
 				message: errorMessage,
 			},
 			500,
 		);
 	}
 });
 
-app.get("/", zValidator("query", querySchema), async (c) => {
+app.get("/list-batches", async (c) => {
+	const anthropic = new Anthropic({
+		apiKey: c.env.ANTHROPIC_API_KEY,
+	});
+	const results = await anthropic.messages.batches.list();
+	return c.json(results);
+});
+
+const pageSchema = z.object({
+	page: z.coerce.number().min(1),
+});
+
+app.get("/process-page", zValidator("query", pageSchema), async (c) => {
 	try {
-		const { url, batchSize, limit } = c.req.valid("query");
-		const decodedUrl = new URL(decodeURIComponent(url)).toString();
+		const { page } = c.req.valid("query");
+		const PAGE_SIZE = 500;
+		const startIndex = (page - 1) * PAGE_SIZE;
+		const endIndex = startIndex + PAGE_SIZE;
 
-		const result = await processDomainList(c, {
-			url: decodedUrl,
-			batchSize,
-			limit,
-		});
+		const domains = await fetchDomains(c.env.REGISTROBR_TXT_URL);
+		const filteredDomains = filterDomains(domains);
+		const paginatedDomains = filteredDomains.slice(startIndex, endIndex);
 
-		return c.json(result);
+		const results = await sendClaude(c, paginatedDomains);
+
+		return c.json({
+			message: "Selected domains by AI:",
+			results,
+		});
 	} catch (error: unknown) {
-		console.error("Error processing domains:", error);
-		const errorMessage =
-			error instanceof Error ? error.message : "Unknown error occurred";
+		console.error("Error in automation:", error);
 		return c.json(
 			{
-				error: "Failed to process domains",
-				message: errorMessage,
+				error: "Failed to process batch",
+				message: error,
 			},
 			500,
 		);
 	}
 });
 
-export default {
-	fetch: app.fetch,
-	scheduled: async (
-		event: ScheduledEvent,
-		env: Bindings,
-		ctx: ExecutionContext,
-	) => {
-		const response = await fetch(env.CRON_URL);
-		if (!response.ok) {
-			console.error("Scheduled trigger failed:", await response.text());
-		}
-	},
-};
+export default app;