pi-free 2.0.2 → 2.0.5

package/providers/cline/cline.ts

@@ -18,7 +18,7 @@ import type { OAuthCredentials } from "@mariozechner/pi-ai";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { getClineShowPaid } from "../../config.ts";
 import { BASE_URL_CLINE, PROVIDER_CLINE } from "../../constants.ts";
-import { registerWithGlobalToggle } from "../../lib/registry.ts";
+import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
 import { createToggleState } from "../../lib/toggle-state.ts";
 import { logWarning } from "../../lib/util.ts";
 import { enhanceWithCI } from "../../provider-helper.ts";
@@ -132,25 +132,30 @@ function extractTaskBody(content: unknown): string {
 	if (!Array.isArray(content)) return "";
 	for (const p of content as any[]) {
 		if (p?.type !== "text" || typeof p?.text !== "string") continue;
-		const m = p.text.match(/<task>\s*([\s\S]*?)\s*<\/task>/);
+		const m = p.text.match(/<task>([\s\S]*?)<\/task>/);
 		if (m?.[1]) return m[1].trim();
 	}
 	return "";
 }
 
-function shapeMessagesForCline(messages: any[]): any[] {
-	let lastWrappedIdx = -1;
-	let baseTranscript = "";
+function findLastClineWrappedMessage(messages: any[]): {
+	index: number;
+	transcript: string;
+} {
 	for (let i = messages.length - 1; i >= 0; i--) {
 		if (messages[i]?.role !== "user") continue;
 		if (!isClineWrapped(messages[i]?.content)) continue;
-		lastWrappedIdx = i;
-		baseTranscript = extractTaskBody(messages[i].content);
-		break;
+		return { index: i, transcript: extractTaskBody(messages[i].content) };
 	}
+	return { index: -1, transcript: "" };
+}
 
+function buildTranscriptParts(
+	messages: any[],
+	startIdx: number,
+	baseTranscript: string,
+): string[] {
 	const parts: string[] = baseTranscript ? [baseTranscript] : [];
-	const startIdx = lastWrappedIdx >= 0 ? lastWrappedIdx + 1 : 0;
 
 	for (let i = startIdx; i < messages.length; i++) {
 		const msg = messages[i];
@@ -167,9 +172,10 @@ function shapeMessagesForCline(messages: any[]): any[] {
 		}
 	}
 
-	const transcript = parts.join("\n\n").trim() || "(no conversation yet)";
-	const envDetails = buildEnvironmentDetails();
+	return parts;
+}
 
+function buildCollapsedMessage(messages: any[], transcript: string): any[] {
 	const collapsed: any[] = [];
 	const systemMsg = messages.find((m: any) => m?.role === "system");
 	if (systemMsg) {
@@ -182,13 +188,24 @@ function shapeMessagesForCline(messages: any[]): any[] {
 		content: [
 			{ type: "text", text: `<task>\n${transcript}\n</task>` },
 			{ type: "text", text: TASK_PROGRESS_BLOCK },
-			{ type: "text", text: envDetails },
+			{ type: "text", text: buildEnvironmentDetails() },
 		],
 	});
 
 	return collapsed;
 }
 
+function shapeMessagesForCline(messages: any[]): any[] {
+	const { index: lastWrappedIdx, transcript: baseTranscript } =
+		findLastClineWrappedMessage(messages);
+
+	const startIdx = lastWrappedIdx >= 0 ? lastWrappedIdx + 1 : 0;
+	const parts = buildTranscriptParts(messages, startIdx, baseTranscript);
+	const transcript = parts.join("\n\n").trim() || "(no conversation yet)";
+
+	return buildCollapsedMessage(messages, transcript);
+}
+
 // =============================================================================
 // Extension entry point
 // =============================================================================
@@ -198,7 +215,9 @@ export default async function (pi: ExtensionAPI) {
 		logWarning("cline", "Failed to fetch models at startup", err);
 		return [];
 	});
-	let freeModels = allModels.filter((m) => m.cost.input === 0);
+	let freeModels = allModels.filter((m) =>
+		isFreeModel({ ...m, provider: PROVIDER_CLINE }, allModels),
+	);
 	const stored = { free: freeModels, all: allModels };
 	const toggleState = createToggleState({
 		providerId: PROVIDER_CLINE,
@@ -246,6 +265,29 @@ export default async function (pi: ExtensionAPI) {
 		},
 	});
 
+	// ── Status bar for provider selection ─────────────────────────
+
+	pi.on("model_select", (_event, ctx) => {
+		if (_event.model?.provider !== PROVIDER_CLINE) {
+			ctx.ui.setStatus(`${PROVIDER_CLINE}-status`, undefined);
+			return;
+		}
+
+		const free = stored.free.length;
+		const total = stored.all.length;
+		const paid = total - free;
+		const mode = toggleState.getCurrentMode();
+		let status: string;
+		if (paid === 0) {
+			status = `cline: ${free} free models`;
+		} else if (mode === "all") {
+			status = `cline: ${total} models (free + paid)`;
+		} else {
+			status = `cline: ${free} free \u00b7 ${paid} paid`;
+		}
+		ctx.ui.setStatus(`${PROVIDER_CLINE}-status`, status);
+	});
+
 	pi.on("before_agent_start", async (_event, ctx) => {
 		if (ctx.model?.provider !== PROVIDER_CLINE) return;
 		_currentTaskId = generateUlid();
@@ -263,7 +305,9 @@ export default async function (pi: ExtensionAPI) {
 			const fresh = await fetchClineModels(false);
 			if (fresh.length > 0) {
 				allModels = fresh;
-				freeModels = allModels.filter((m) => m.cost.input === 0);
+				freeModels = allModels.filter((m) =>
+					isFreeModel({ ...m, provider: PROVIDER_CLINE }, allModels),
+				);
 				stored.all = allModels;
 				stored.free = freeModels;
 				toggleState.setModels(stored);

package/providers/crofai/crofai.ts

@@ -0,0 +1,170 @@
+/**
+ * CrofAI Provider Extension
+ *
+ * Provides access to CrofAI API - OpenAI-compatible LLM inference service.
+ *
+ * Setup:
+ *   1. Get API key from https://ai.nahcrof.com
+ *   2. Set CROFAI_API_KEY env var or add to ~/.pi/free.json
+ *
+ * Responds to global free-only filter.
+ *
+ * Usage:
+ *   pi install git:github.com/apmantza/pi-free
+ *   # Set CROFAI_API_KEY env var
+ *   # Models appear in /model selector
+ */
+
+import type {
+	ExtensionAPI,
+	ProviderModelConfig,
+} from "@mariozechner/pi-coding-agent";
+import { getCrofaiApiKey, getCrofaiShowPaid } from "../../config.ts";
+import {
+	BASE_URL_CROFAI,
+	DEFAULT_FETCH_TIMEOUT_MS,
+	PROVIDER_CROFAI,
+} from "../../constants.ts";
+import { createLogger } from "../../lib/logger.ts";
+import {
+	getProxyModelCompat,
+	isLikelyReasoningModel,
+} from "../../lib/provider-compat.ts";
+import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
+import { fetchWithRetry } from "../../lib/util.ts";
+import { createReRegister, setupProvider } from "../../provider-helper.ts";
+
+const _logger = createLogger("crofai");
+
+// =============================================================================
+// Fetch CrofAI models
+// =============================================================================
+
+interface CrofaiModel {
+	id: string;
+	object?: string;
+	created?: number;
+	owned_by?: string;
+}
+
+async function fetchCrofaiModels(
+	apiKey: string,
+): Promise<ProviderModelConfig[]> {
+	_logger.info("[crofai] Fetching models from CrofAI API...");
+
+	try {
+		const response = await fetchWithRetry(
+			`${BASE_URL_CROFAI}/models`,
+			{
+				headers: {
+					Authorization: `Bearer ${apiKey}`,
+					"Content-Type": "application/json",
+				},
+			},
+			3,
+			1000,
+			DEFAULT_FETCH_TIMEOUT_MS,
+		);
+
+		if (!response.ok) {
+			throw new Error(`CrofAI API error: ${response.status}`);
+		}
+
+		const data = (await response.json()) as { data?: CrofaiModel[] };
+		const models = data.data ?? [];
+
+		_logger.info(`[crofai] Fetched ${models.length} models`);
+
+		return models
+			.filter((m) => m.id) // Filter out any empty entries
+			.map((m) => {
+				const name = m.id.split("/").pop() || m.id;
+				return {
+					id: m.id,
+					name,
+					reasoning: isLikelyReasoningModel({ id: m.id, name }),
+					input: ["text"],
+					cost: {
+						input: 0, // CrofAI doesn't expose pricing via API
+						output: 0,
+						cacheRead: 0,
+						cacheWrite: 0,
+					},
+					contextWindow: 128000, // Default, varies by model
+					maxTokens: 4096,
+					compat: getProxyModelCompat({ id: m.id, name }),
+				} satisfies ProviderModelConfig;
+			});
+	} catch (error) {
+		_logger.error("[crofai] Failed to fetch models:", {
+			error: error instanceof Error ? error.message : String(error),
+		});
+		return [];
+	}
+}
+
+// =============================================================================
+// Extension Entry Point
+// =============================================================================
+
+export default async function crofaiProvider(pi: ExtensionAPI) {
+	const apiKey = getCrofaiApiKey();
+
+	if (!apiKey) {
+		_logger.info(
+			"[crofai] Skipping - CROFAI_API_KEY not set (env var or ~/.pi/free.json)",
+		);
+		return;
+	}
+
+	// Fetch models
+	const allModels = await fetchCrofaiModels(apiKey);
+
+	if (allModels.length === 0) {
+		_logger.warn("[crofai] No models available");
+		return;
+	}
+
+	// Use isFreeModel with allModels for proper detection
+	// CrofAI doesn't expose pricing (all costs are $0), so Route B will be used:
+	// FREE only if "free" in name
+	const freeModels = allModels.filter((m) =>
+		isFreeModel({ ...m, provider: PROVIDER_CROFAI }, allModels),
+	);
+
+	const stored = { free: freeModels, all: allModels };
+
+	_logger.info(
+		`[crofai] Registered ${allModels.length} models (${freeModels.length} free)`,
+	);
+
+	// Create re-register function
+	const reRegister = createReRegister(pi, {
+		providerId: PROVIDER_CROFAI,
+		baseUrl: BASE_URL_CROFAI,
+		apiKey,
+	});
+
+	// Register with global toggle
+	registerWithGlobalToggle(PROVIDER_CROFAI, stored, reRegister, true);
+
+	// Setup provider with toggle command
+	setupProvider(
+		pi,
+		{
+			providerId: PROVIDER_CROFAI,
+			initialShowPaid: getCrofaiShowPaid(),
+			reRegister: (models, _stored) => {
+				if (_stored) {
+					stored.free = _stored.free;
+					stored.all = _stored.all;
+				}
+				reRegister(models);
+			},
+		},
+		stored,
+	);
+
+	// Initial registration
+	reRegister(freeModels);
+}