@getjack/jack 0.1.23 → 0.1.25

package/src/lib/services/vectorize-create.ts

@@ -0,0 +1,166 @@
+/**
+ * Vectorize index creation logic for jack MCP tools
+ *
+ * Uses wrangler CLI to create Vectorize indexes.
+ */
+
+import { join } from "node:path";
+import { $ } from "bun";
+import { getProjectNameFromDir } from "../storage/index.ts";
+import { addVectorizeBinding, getExistingVectorizeBindings } from "./vectorize-config.ts";
+
+export type VectorizeMetric = "cosine" | "euclidean" | "dot-product";
+
+export interface CreateVectorizeOptions {
+	name?: string;
+	dimensions?: number;
+	metric?: VectorizeMetric;
+}
+
+export interface CreateVectorizeResult {
+	indexName: string;
+	bindingName: string;
+	dimensions: number;
+	metric: VectorizeMetric;
+	created: boolean; // false if reused existing
+}
+
+/**
+ * Convert an index name to SCREAMING_SNAKE_CASE for the binding name.
+ * Special case: first index in a project gets "VECTORS" as the binding.
+ */
+function toBindingName(indexName: string, isFirst: boolean): string {
+	if (isFirst) {
+		return "VECTORS";
+	}
+	// Convert kebab-case/snake_case to SCREAMING_SNAKE_CASE
+	return indexName
+		.replace(/-/g, "_")
+		.replace(/[^a-zA-Z0-9_]/g, "")
+		.toUpperCase();
+}
+
+/**
+ * Generate a unique index name for a project.
+ * First index: {project}-vectors
+ * Subsequent: {project}-vectors-{n}
+ */
+function generateIndexName(projectName: string, existingCount: number): string {
+	if (existingCount === 0) {
+		return `${projectName}-vectors`;
+	}
+	return `${projectName}-vectors-${existingCount + 1}`;
+}
+
+interface ExistingIndex {
+	name: string;
+	dimensions?: number;
+	metric?: string;
+}
+
+/**
+ * List all Vectorize indexes in the Cloudflare account via wrangler
+ */
+async function listIndexesViaWrangler(): Promise<ExistingIndex[]> {
+	const result = await $`wrangler vectorize list --json`.nothrow().quiet();
+
+	if (result.exitCode !== 0) {
+		// If wrangler fails, return empty list (might not be logged in)
+		return [];
+	}
+
+	try {
+		const output = result.stdout.toString().trim();
+		const data = JSON.parse(output);
+		// wrangler vectorize list --json returns array: [{ "name": "...", ... }]
+		return Array.isArray(data) ? data : [];
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Find an existing Vectorize index by name
+ */
+async function findExistingIndex(indexName: string): Promise<ExistingIndex | null> {
+	const indexes = await listIndexesViaWrangler();
+	return indexes.find((idx) => idx.name === indexName) ?? null;
+}
+
+/**
+ * Create a Vectorize index via wrangler
+ */
+async function createIndexViaWrangler(
+	indexName: string,
+	dimensions: number,
+	metric: VectorizeMetric,
+): Promise<{ created: boolean }> {
+	// Check if index already exists
+	const existing = await findExistingIndex(indexName);
+	if (existing) {
+		return { created: false };
+	}
+
+	const result =
+		await $`wrangler vectorize create ${indexName} --dimensions=${dimensions} --metric=${metric}`.nothrow().quiet();
+
+	if (result.exitCode !== 0) {
+		const stderr = result.stderr.toString().trim();
+		throw new Error(stderr || `Failed to create Vectorize index ${indexName}`);
+	}
+
+	return { created: true };
+}
+
+/**
+ * Create a Vectorize index for the current project.
+ *
+ * Uses wrangler vectorize create to create the index, then updates
+ * wrangler.jsonc with the new binding.
+ */
+export async function createVectorizeIndex(
+	projectDir: string,
+	options: CreateVectorizeOptions = {},
+): Promise<CreateVectorizeResult> {
+	// Get project name from wrangler config
+	const projectName = await getProjectNameFromDir(projectDir);
+
+	// Get existing Vectorize bindings to determine naming
+	const wranglerPath = join(projectDir, "wrangler.jsonc");
+	const existingBindings = await getExistingVectorizeBindings(wranglerPath);
+	const existingCount = existingBindings.length;
+
+	// Determine index name
+	const indexName = options.name ?? generateIndexName(projectName, existingCount);
+
+	// Determine binding name
+	const isFirst = existingCount === 0;
+	const bindingName = toBindingName(indexName, isFirst);
+
+	// Check if binding name already exists
+	const bindingExists = existingBindings.some((b) => b.binding === bindingName);
+	if (bindingExists) {
+		throw new Error(`Binding "${bindingName}" already exists. Choose a different index name.`);
+	}
+
+	// Use omakase defaults: 768 dimensions (for bge-base-en-v1.5), cosine metric
+	const dimensions = options.dimensions ?? 768;
+	const metric = options.metric ?? "cosine";
+
+	// Create via wrangler
+	const result = await createIndexViaWrangler(indexName, dimensions, metric);
+
+	// Update wrangler.jsonc with the new binding
+	await addVectorizeBinding(wranglerPath, {
+		binding: bindingName,
+		index_name: indexName,
+	});
+
+	return {
+		indexName,
+		bindingName,
+		dimensions,
+		metric,
+		created: result.created,
+	};
+}

package/src/lib/services/vectorize-delete.ts

@@ -0,0 +1,54 @@
+/**
+ * Vectorize index deletion logic for jack MCP tools
+ *
+ * Uses wrangler CLI to delete Vectorize indexes.
+ */
+
+import { join } from "node:path";
+import { $ } from "bun";
+import { removeVectorizeBinding } from "./vectorize-config.ts";
+
+export interface DeleteVectorizeResult {
+	indexName: string;
+	deleted: boolean;
+	bindingRemoved: boolean;
+}
+
+/**
+ * Delete a Vectorize index via wrangler
+ */
+async function deleteIndexViaWrangler(indexName: string): Promise<void> {
+	const result = await $`wrangler vectorize delete ${indexName} --force`.nothrow().quiet();
+
+	if (result.exitCode !== 0) {
+		const stderr = result.stderr.toString().trim();
+		// Ignore "not found" errors - the index might already be deleted
+		if (!stderr.includes("not found") && !stderr.includes("does not exist")) {
+			throw new Error(stderr || `Failed to delete Vectorize index ${indexName}`);
+		}
+	}
+}
+
+/**
+ * Delete a Vectorize index for the current project.
+ *
+ * Uses wrangler vectorize delete to delete the index, then removes
+ * the binding from wrangler.jsonc.
+ */
+export async function deleteVectorizeIndex(
+	projectDir: string,
+	indexName: string,
+): Promise<DeleteVectorizeResult> {
+	// Delete via wrangler
+	await deleteIndexViaWrangler(indexName);
+
+	// Remove binding from wrangler.jsonc
+	const wranglerPath = join(projectDir, "wrangler.jsonc");
+	const bindingRemoved = await removeVectorizeBinding(wranglerPath, indexName);
+
+	return {
+		indexName,
+		deleted: true,
+		bindingRemoved,
+	};
+}

package/src/lib/services/vectorize-info.ts

@@ -0,0 +1,52 @@
+/**
+ * Vectorize index info logic for jack MCP tools
+ *
+ * Uses wrangler CLI to get information about Vectorize indexes.
+ */
+
+import { $ } from "bun";
+
+export interface VectorizeInfo {
+	name: string;
+	dimensions: number;
+	metric: string;
+	vectorCount: number;
+	createdOn?: string;
+	modifiedOn?: string;
+}
+
+/**
+ * Get Vectorize index info via wrangler vectorize info
+ */
+export async function getVectorizeInfo(indexName: string): Promise<VectorizeInfo | null> {
+	const result = await $`wrangler vectorize info ${indexName} --json`.nothrow().quiet();
+
+	if (result.exitCode !== 0) {
+		return null;
+	}
+
+	try {
+		const output = result.stdout.toString().trim();
+		const data = JSON.parse(output);
+
+		// wrangler vectorize info --json returns:
+		// {
+		//   "name": "...",
+		//   "config": { "dimensions": N, "metric": "..." },
+		//   "vectorsCount": N,
+		//   "created_on": "...",
+		//   "modified_on": "..."
+		// }
+		return {
+			name: data.name || indexName,
+			dimensions: data.config?.dimensions || 0,
+			metric: data.config?.metric || "unknown",
+			vectorCount: data.vectorsCount || 0,
+			createdOn: data.created_on,
+			modifiedOn: data.modified_on,
+		};
+	} catch {
+		// Failed to parse JSON output
+		return null;
+	}
+}

package/src/lib/services/vectorize-list.ts

@@ -0,0 +1,56 @@
+/**
+ * Vectorize index listing logic for jack MCP tools
+ *
+ * Lists Vectorize indexes configured in wrangler.jsonc with their metadata.
+ */
+
+import { join } from "node:path";
+import { getExistingVectorizeBindings } from "./vectorize-config.ts";
+import { getVectorizeInfo } from "./vectorize-info.ts";
+
+export interface VectorizeListEntry {
+	name: string;
+	binding: string;
+	dimensions?: number;
+	metric?: string;
+	vectorCount?: number;
+}
+
+/**
+ * List all Vectorize indexes configured for a project.
+ *
+ * Reads bindings from wrangler.jsonc and fetches additional metadata
+ * (dimensions, metric, vector count) via wrangler vectorize info for each index.
+ */
+export async function listVectorizeIndexes(projectDir: string): Promise<VectorizeListEntry[]> {
+	const wranglerPath = join(projectDir, "wrangler.jsonc");
+
+	// Get existing Vectorize bindings from wrangler.jsonc
+	const bindings = await getExistingVectorizeBindings(wranglerPath);
+
+	if (bindings.length === 0) {
+		return [];
+	}
+
+	// Fetch detailed info for each index
+	const entries: VectorizeListEntry[] = [];
+
+	for (const binding of bindings) {
+		const entry: VectorizeListEntry = {
+			name: binding.index_name,
+			binding: binding.binding,
+		};
+
+		// Try to get additional metadata via wrangler
+		const info = await getVectorizeInfo(binding.index_name);
+		if (info) {
+			entry.dimensions = info.dimensions;
+			entry.metric = info.metric;
+			entry.vectorCount = info.vectorCount;
+		}
+
+		entries.push(entry);
+	}
+
+	return entries;
+}

package/src/lib/version-check.ts

@@ -91,11 +91,11 @@ export async function checkForUpdate(
 	skipCache = false,
 ): Promise<string | null> {
 	const currentVersion = getCurrentVersion();
+	const now = Date.now();
 
 	// Check cache first (unless skipCache is true)
 	if (!skipCache) {
 		const cache = await readVersionCache();
-		const now = Date.now();
 
 		if (cache && now - cache.checkedAt < CACHE_TTL_MS) {
 			// Use cached value
@@ -106,7 +106,7 @@ export async function checkForUpdate(
 		}
 	}
 
-	// Fetch fresh version (don't await in caller for non-blocking)
+	// Fetch fresh version
 	const latestVersion = await fetchLatestVersion();
 	if (!latestVersion) return null;
 

package/src/mcp/test-utils.ts

@@ -1,5 +1,9 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { createMcpServer } from "./server.ts";
+import type { McpServerOptions } from "./types.ts";
 
 export interface McpClientOptions {
 	command: string;
@@ -12,12 +16,50 @@ export interface McpClientOptions {
 
 export interface McpTestClient {
 	client: Client;
-	transport: StdioClientTransport;
+	transport: Transport;
 	getStderr(): string;
 	close(): Promise<void>;
 }
 
-export async function openMcpTestClient(options: McpClientOptions): Promise<McpTestClient> {
+/**
+ * Open an MCP test client using in-memory transport.
+ * This is the recommended approach for testing - no process spawning,
+ * no race conditions, deterministic behavior.
+ */
+export async function openMcpTestClientInMemory(
+	serverOptions: McpServerOptions = {},
+): Promise<McpTestClient> {
+	// Create linked transport pair
+	const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+
+	// Create and connect server
+	const { server } = await createMcpServer(serverOptions);
+	await server.connect(serverTransport);
+
+	// Create and connect client
+	const client = new Client({
+		name: "jack-mcp-test",
+		version: "0.1.0",
+	});
+	await client.connect(clientTransport);
+
+	return {
+		client,
+		transport: clientTransport,
+		getStderr: () => "(in-memory transport - no stderr)",
+		close: async () => {
+			await clientTransport.close();
+			await serverTransport.close();
+		},
+	};
+}
+
+/**
+ * Open an MCP test client using stdio transport (spawns a child process).
+ * This tests the full stdio path but is prone to race conditions.
+ * Use openMcpTestClientInMemory() for reliable testing.
+ */
+export async function openMcpTestClientStdio(options: McpClientOptions): Promise<McpTestClient> {
 	const transport = new StdioClientTransport({
 		command: options.command,
 		args: options.args ?? [],
@@ -51,6 +93,9 @@ export async function openMcpTestClient(options: McpClientOptions): Promise<McpT
 	};
 }
 
+// Legacy alias for backwards compatibility
+export const openMcpTestClient = openMcpTestClientStdio;
+
 export function parseMcpToolResult(toolResult: {
 	content?: Array<{ type: string; text?: string }>;
 	[key: string]: unknown;