@danypops/jittor 0.1.0

package/extension/src/tui.ts

@@ -0,0 +1,180 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
+import type { StoredMetricObservation } from "../../src/domain/metric.ts";
+import type { PolicyAction, Route } from "../../src/policy.ts";
+import type { RouterStatus } from "../../src/ports/router-controller.ts";
+import type { ProviderBudget } from "./footer.ts";
+
+export interface JittorPanelClient {
+	call(operation: string, input: unknown): Promise<any>;
+}
+
+type PanelAction = "pause" | "resume" | "refresh" | "override" | "clear-override" | "close";
+
+function latest(rows: StoredMetricObservation[], predicate: (row: StoredMetricObservation) => boolean): StoredMetricObservation | undefined {
+	return rows.filter(predicate).sort((left, right) => right.observedAt - left.observedAt || right.id - left.id)[0];
+}
+
+function longestCodexWindow(rows: StoredMetricObservation[]): StoredMetricObservation | undefined {
+	return rows
+		.filter((row) => row.source === "codex-subscription" && row.metric === "used-fraction" && typeof row.value === "number")
+		.sort((left, right) => Number(right.attributes["windowSeconds"] ?? 0) - Number(left.attributes["windowSeconds"] ?? 0) || right.observedAt - left.observedAt)[0];
+}
+
+function compactWindowName(seconds: number): string {
+	if (seconds >= 6 * 24 * 60 * 60) return "W";
+	if (seconds >= 60 * 60) return `${Math.round(seconds / 3_600)}h`;
+	return `${Math.round(seconds / 60)}m`;
+}
+
+function windowName(seconds: number): string {
+	if (seconds >= 6 * 24 * 60 * 60) return "weekly";
+	if (seconds >= 60 * 60) return `${Math.round(seconds / 3_600)}h`;
+	return `${Math.round(seconds / 60)}m`;
+}
+
+export function buildFooterBudget(status: RouterStatus, metrics: StoredMetricObservation[]): ProviderBudget | null {
+	if (!status.ready || !status.currentRoute) return null;
+	if (status.currentRoute.provider === "openai-codex") {
+		const codex = longestCodexWindow(metrics);
+		if (!codex || typeof codex.value !== "number") return null;
+		return {
+			label: compactWindowName(Number(codex.attributes["windowSeconds"] ?? 0)),
+			fraction: codex.value,
+			valueText: `${(codex.value * 100).toFixed(1)}% used`,
+			observedAt: codex.observedAt,
+		};
+	}
+	if (status.currentRoute.provider === "openrouter") {
+		const openRouter = latest(metrics, (row) => row.source === "openrouter" && row.metric === "usage" && typeof row.value === "number");
+		if (!openRouter || typeof openRouter.value !== "number") return null;
+		return { label: "spend", fraction: null, valueText: `$${openRouter.value.toFixed(3)}`, observedAt: openRouter.observedAt };
+	}
+	return null;
+}
+
+export function formatFooterStatus(status: RouterStatus, metrics: StoredMetricObservation[]): string {
+	const budget = buildFooterBudget(status, metrics);
+	if (!budget) return "";
+	return budget.fraction === null ? budget.valueText : `${budget.label} ${(budget.fraction * 100).toFixed(1)}%`;
+}
+
+function nextAction(action: PolicyAction | undefined): string {
+	switch (action) {
+		case "continue": return "throttle";
+		case "throttle": return "lower thinking";
+		case "lower-thinking": return "switch model";
+		case "switch-model": return "switch provider";
+		case "switch-provider": return "halt";
+		case "halt": return "halted";
+		default: return "waiting for decision";
+	}
+}
+
+function burnLine(rows: StoredMetricObservation[], current: StoredMetricObservation, now: number): string {
+	const previous = rows
+		.filter((row) => row.source === current.source && row.scope === current.scope && row.metric === current.metric && row.id !== current.id && row.observedAt < current.observedAt)
+		.sort((left, right) => right.observedAt - left.observedAt)[0];
+	const resetsAt = Number(current.attributes["resetsAt"] ?? 0) * 1_000;
+	const remainingSeconds = (resetsAt - now) / 1_000;
+	const sustainable = typeof current.value === "number" && remainingSeconds > 0 ? (1 - current.value) / remainingSeconds : null;
+	const observed = previous && typeof previous.value === "number" && typeof current.value === "number" && current.observedAt > previous.observedAt
+		? (current.value - previous.value) / ((current.observedAt - previous.observedAt) / 1_000)
+		: null;
+	const perHour = (rate: number | null) => rate === null ? "n/a" : `${(rate * 3_600 * 100).toFixed(2)}%/h`;
+	return `Burn: observed ${perHour(observed)} · sustainable ${perHour(sustainable)}`;
+}
+
+export function buildStatusView(status: RouterStatus, metrics: StoredMetricObservation[], now = Date.now()): string[] {
+	const lines = [status.ready ? "Ready" : "Not ready"];
+	const codex = status.currentRoute?.provider === "openai-codex" ? longestCodexWindow(metrics) : undefined;
+	if (codex && typeof codex.value === "number") {
+		const seconds = Number(codex.attributes["windowSeconds"] ?? 0);
+		lines.push(`Codex ${windowName(seconds)}: ${(codex.value * 100).toFixed(1)}%`);
+		lines.push(burnLine(metrics, codex, now));
+	}
+	const openRouter = status.currentRoute?.provider === "openrouter"
+		? latest(metrics, (row) => row.source === "openrouter" && row.metric === "usage" && typeof row.value === "number")
+		: undefined;
+	if (openRouter && typeof openRouter.value === "number") lines.push(`OpenRouter spend: $${openRouter.value.toFixed(3)}`);
+	if (status.currentRoute) lines.push(`Route: ${status.currentRoute.provider}/${status.currentRoute.model} · ${status.currentRoute.thinking}`);
+	if (status.lastDecision) lines.push(`Pressure: ${Number.isFinite(status.lastDecision.pressure) ? status.lastDecision.pressure.toFixed(3) : "∞"} · ${status.lastDecision.action}`);
+	lines.push(`Next: ${nextAction(status.lastDecision?.action)}`);
+	lines.push("Telemetry:");
+	for (const source of status.sources.filter((source) => source.provider === status.currentRoute?.provider)) {
+		const freshness = !source.ok ? "failed" : source.observedAt !== undefined && now - source.observedAt > 120_000 ? "stale" : "fresh";
+		lines.push(`  ${source.id}: ${freshness} · ${source.metrics} metrics`);
+	}
+	if (status.override) lines.push(`Override: ${status.override.route.provider}/${status.override.route.model} · ${status.override.route.thinking}`);
+	if (status.paused) lines.push("Emergency halt is active");
+	return lines;
+}
+
+async function snapshot(client: JittorPanelClient): Promise<{ status: RouterStatus; metrics: StoredMetricObservation[] }> {
+	const status = await client.call("router.status", {}) as RouterStatus;
+	const provider = status.currentRoute?.provider;
+	const query = provider === "openai-codex"
+		? { source: "codex-subscription", metric: "used-fraction", order: "desc", limit: 100 }
+		: provider === "openrouter" ? { source: "openrouter", order: "desc", limit: 20 } : null;
+	const metrics = query ? await client.call("metrics.query", query) as StoredMetricObservation[] : [];
+	return { status, metrics };
+}
+
+async function chooseOverride(ctx: ExtensionCommandContext, routes: Route[]): Promise<Route | undefined> {
+	if (routes.length === 0) { ctx.ui.notify("Pi reports no authenticated routes for the current provider.", "warning"); return undefined; }
+	const labels = routes.map((route) => `${route.provider}/${route.model} · ${route.thinking}`);
+	const selected = await ctx.ui.select("Override route", labels);
+	const index = selected ? labels.indexOf(selected) : -1;
+	return index >= 0 ? routes[index] : undefined;
+}
+
+export async function showJittorPanel(ctx: ExtensionCommandContext, client: JittorPanelClient): Promise<void> {
+	for (;;) {
+		const current = await snapshot(client);
+		if (ctx.mode !== "tui") {
+			ctx.ui.notify(buildStatusView(current.status, current.metrics).join("\n"), "info");
+			return;
+		}
+		const action = await ctx.ui.custom<PanelAction>((_tui, theme, _keybindings, done) => ({
+			invalidate() {},
+			render(width: number): string[] {
+				const border = theme.fg("borderMuted", "─".repeat(Math.max(1, width)));
+				const controls = current.status.paused
+					? "r refresh · p release emergency halt · o override · c clear override · Esc close"
+					: "r refresh · p emergency halt · o override · c clear override · Esc close";
+				return [
+					border,
+					truncateToWidth(theme.bold("Jittor"), width, ""),
+					border,
+					...buildStatusView(current.status, current.metrics).map((line) => truncateToWidth(` ${line}`, width, "…")),
+					border,
+					truncateToWidth(theme.fg("dim", controls), width, "…"),
+					border,
+				];
+			},
+			handleInput(data: string): void {
+				if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) done("close");
+				else if (data === "r") done("refresh");
+				else if (data === "p") done(current.status.paused ? "resume" : "pause");
+				else if (data === "o") done("override");
+				else if (data === "c") done("clear-override");
+			},
+		}));
+		if (!action || action === "close") return;
+		if (action === "refresh") { await client.call("telemetry.poll", {}); continue; }
+		if (action === "pause" || action === "resume") {
+			if (await ctx.ui.confirm(action === "pause" ? "Emergency-halt provider requests?" : "Release emergency halt?", "This changes provider-request enforcement. Use /jittor off to disable blocking entirely.")) {
+				await client.call(action === "pause" ? "router.pause" : "router.resume", {});
+			}
+			continue;
+		}
+		if (action === "clear-override") {
+			if (await ctx.ui.confirm("Clear route override?", "Policy-controlled routing will resume.")) await client.call("router.clear_override", {});
+			continue;
+		}
+		const route = await chooseOverride(ctx, current.status.availableRoutes);
+		if (route && await ctx.ui.confirm("Apply route override?", `${route.provider}/${route.model} · ${route.thinking} for one hour`)) {
+			await client.call("router.override", { route, expiresAt: Date.now() + 60 * 60 * 1_000 });
+		}
+	}
+}

package/extension/src/usage.ts

@@ -0,0 +1,169 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { USAGE_CHART_HEIGHT, USAGE_TOKEN_QUERY_LIMIT, USAGE_Y_AXIS_WIDTH } from "../../src/constants.ts";
+import type { StoredMetricObservation } from "../../src/domain/metric.ts";
+import {
+	buildUsageHistogram,
+	USAGE_RANGES,
+	usageRangeStart,
+	type UsageBucket,
+	type UsageHistogram,
+	type UsageRange,
+} from "../../src/domain/usage.ts";
+import type { JittorPanelClient } from "./tui.ts";
+
+type UsageAction = "range-prev" | "range-next" | "refresh" | "close";
+type UsageColor = "accent" | "success" | "warning" | "error" | "thinkingText" | "muted" | "dim" | "borderMuted";
+
+export interface UsageTheme {
+	fg(color: UsageColor, text: string): string;
+	bold(text: string): string;
+}
+
+const SERIES_COLORS: UsageColor[] = ["accent", "success", "warning", "thinkingText", "error"];
+const PARTIAL_BLOCKS = ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+
+function compact(value: number): string {
+	if (value >= 1_000_000_000) return `${(value / 1_000_000_000).toFixed(value >= 10_000_000_000 ? 0 : 1)}B`;
+	if (value >= 1_000_000) return `${(value / 1_000_000).toFixed(value >= 10_000_000 ? 0 : 1)}M`;
+	if (value >= 1_000) return `${(value / 1_000).toFixed(value >= 10_000 ? 0 : 1)}k`;
+	return String(Math.round(value));
+}
+
+function mergeBuckets(buckets: UsageBucket[], maximum: number): UsageBucket[] {
+	if (buckets.length <= maximum) return buckets;
+	const result: UsageBucket[] = [];
+	for (let index = 0; index < maximum; index += 1) {
+		const from = Math.floor(index * buckets.length / maximum);
+		const to = Math.max(from + 1, Math.floor((index + 1) * buckets.length / maximum));
+		const selected = buckets.slice(from, to);
+		const series: Record<string, number> = {};
+		for (const bucket of selected) {
+			for (const [key, value] of Object.entries(bucket.series)) series[key] = (series[key] ?? 0) + value;
+		}
+		result.push({
+			start: selected[0]!.start,
+			end: selected[selected.length - 1]!.end,
+			total: selected.reduce((sum, bucket) => sum + bucket.total, 0),
+			series,
+		});
+	}
+	return result;
+}
+
+function seriesAt(bucket: UsageBucket, chart: UsageHistogram, tokenHeight: number): number {
+	let cumulative = 0;
+	for (let index = 0; index < chart.series.length; index += 1) {
+		cumulative += bucket.series[chart.series[index]!.key] ?? 0;
+		if (tokenHeight <= cumulative) return index;
+	}
+	return Math.max(0, chart.series.length - 1);
+}
+
+function formatRangePoint(value: number, range: UsageRange): string {
+	const date = new Date(value);
+	if (range === "24h") return date.toLocaleTimeString(undefined, { hour: "2-digit", minute: "2-digit" });
+	return date.toLocaleDateString(undefined, { month: "short", day: "numeric" });
+}
+
+function axisLabels(start: number, end: number, range: UsageRange, width: number): string {
+	const labels = [formatRangePoint(start, range), formatRangePoint(start + (end - start) / 2, range), formatRangePoint(end, range)];
+	const positions = [0, Math.max(0, Math.floor((width - labels[1]!.length) / 2)), Math.max(0, width - labels[2]!.length)];
+	const characters = Array.from({ length: width }, () => " ");
+	for (let labelIndex = 0; labelIndex < labels.length; labelIndex += 1) {
+		for (let index = 0; index < labels[labelIndex]!.length && positions[labelIndex]! + index < width; index += 1) {
+			characters[positions[labelIndex]! + index] = labels[labelIndex]![index]!;
+		}
+	}
+	return characters.join("");
+}
+
+function plainTheme(): UsageTheme {
+	return { fg: (_color, text) => text, bold: (text) => text };
+}
+
+export function renderUsageHistogram(chart: UsageHistogram, width: number, theme: UsageTheme): string[] {
+	const safeWidth = Math.max(20, width);
+	const chartColumns = Math.max(1, Math.floor((safeWidth - USAGE_Y_AXIS_WIDTH - 1) / 2));
+	const buckets = mergeBuckets(chart.buckets, chartColumns);
+	const barStep = buckets.length * 2 <= safeWidth - USAGE_Y_AXIS_WIDTH ? 2 : 1;
+	const plotWidth = buckets.length * barStep;
+	const maximum = Math.max(0, ...buckets.map((bucket) => bucket.total));
+	const lines = [
+		truncateToWidth(theme.bold(`Tokens over time · ${chart.range}`), safeWidth, ""),
+		truncateToWidth(`${compact(chart.totalTokens)} tokens · input ${compact(chart.breakdown.input)} · output ${compact(chart.breakdown.output)} · cache ${compact(chart.breakdown.cacheRead + chart.breakdown.cacheWrite)}`, safeWidth, "…"),
+		"",
+	];
+	if (maximum === 0) {
+		lines.push(theme.fg("dim", "No recorded Pi token usage in this range."));
+		return lines.map((line) => truncateToWidth(line, safeWidth, "…"));
+	}
+
+	for (let row = 0; row < USAGE_CHART_HEIGHT; row += 1) {
+		const fromBottom = USAGE_CHART_HEIGHT - row - 1;
+		const label = row === 0 ? compact(maximum) : row === Math.floor(USAGE_CHART_HEIGHT / 2) ? compact(maximum / 2) : "";
+		let plot = "";
+		for (const bucket of buckets) {
+			const scaled = bucket.total / maximum * USAGE_CHART_HEIGHT;
+			const occupancy = Math.max(0, Math.min(1, scaled - fromBottom));
+			if (occupancy <= 0) {
+				plot += " ".repeat(barStep);
+				continue;
+			}
+			const block = PARTIAL_BLOCKS[Math.max(0, Math.ceil(occupancy * PARTIAL_BLOCKS.length) - 1)]!;
+			const tokenHeight = Math.min(bucket.total, maximum * (fromBottom + Math.min(occupancy, 0.5)) / USAGE_CHART_HEIGHT);
+			const color = SERIES_COLORS[seriesAt(bucket, chart, tokenHeight) % SERIES_COLORS.length]!;
+			plot += theme.fg(color, block) + (barStep === 2 ? " " : "");
+		}
+		lines.push(`${label.padStart(USAGE_Y_AXIS_WIDTH - 2)} ${theme.fg("borderMuted", "│")}${plot}`);
+	}
+	lines.push(`${"0".padStart(USAGE_Y_AXIS_WIDTH - 2)} ${theme.fg("borderMuted", `└${"─".repeat(plotWidth)}`)}`);
+	lines.push(`${" ".repeat(USAGE_Y_AXIS_WIDTH)}${axisLabels(chart.start, chart.end, chart.range, plotWidth)}`);
+	lines.push("");
+	for (let index = 0; index < chart.series.length; index += 1) {
+		const series = chart.series[index]!;
+		const bullet = theme.fg(SERIES_COLORS[index % SERIES_COLORS.length]!, "■");
+		lines.push(truncateToWidth(`${bullet} ${series.provider}/${series.model}  ${compact(series.total)}`, safeWidth, "…"));
+	}
+	return lines.map((line) => visibleWidth(line) <= safeWidth ? line : truncateToWidth(line, safeWidth, "…"));
+}
+
+async function loadUsage(client: JittorPanelClient, range: UsageRange, now: number): Promise<UsageHistogram> {
+	const rows = await client.call("metrics.query", {
+		source: "pi",
+		since: usageRangeStart(range, now),
+		until: now,
+		order: "desc",
+		limit: USAGE_TOKEN_QUERY_LIMIT,
+	}) as StoredMetricObservation[];
+	return buildUsageHistogram(rows, { range, now });
+}
+
+export async function showUsagePanel(ctx: ExtensionCommandContext, client: JittorPanelClient, now = Date.now()): Promise<void> {
+	let rangeIndex = 0;
+	for (;;) {
+		const range = USAGE_RANGES[rangeIndex]!;
+		const chart = await loadUsage(client, range, now);
+		if (ctx.mode !== "tui") {
+			ctx.ui.notify(renderUsageHistogram(chart, 80, plainTheme()).join("\n"), "info");
+			return;
+		}
+		const action = await ctx.ui.custom<UsageAction>((_tui, theme, _keybindings, done) => ({
+			invalidate() {},
+			render(width: number): string[] {
+				const lines = renderUsageHistogram(chart, width, theme);
+				const controls = theme.fg("dim", "←/→ range · r refresh · Esc close");
+				return [...lines, "", truncateToWidth(controls, width, "…")];
+			},
+			handleInput(data: string): void {
+				if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c") || data === "q") done("close");
+				else if (matchesKey(data, "left")) done("range-prev");
+				else if (matchesKey(data, "right")) done("range-next");
+				else if (data === "r") done("refresh");
+			},
+		}));
+		if (!action || action === "close") return;
+		if (action === "range-prev") rangeIndex = (rangeIndex - 1 + USAGE_RANGES.length) % USAGE_RANGES.length;
+		if (action === "range-next") rangeIndex = (rangeIndex + 1) % USAGE_RANGES.length;
+	}
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@danypops/jittor",
+  "version": "0.1.0",
+  "description": "Just-in-Time Token Optimizing Router for Pi",
+  "type": "module",
+  "keywords": ["pi-package", "llm-router", "token-budget"],
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "serve": "bun src/cli.ts serve",
+    "service:install": "bun src/cli.ts service install",
+    "guard:install": "git config core.hooksPath .githooks"
+  },
+  "pi": {
+    "extensions": ["extension/src/index.ts"]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
+  },
+  "devDependencies": {
+    "bun-types": "latest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DanyPops/jittor.git"
+  },
+  "files": ["src", "extension", "docs", "README.md"]
+}

package/src/adapters/sqlite-metric-store.ts

@@ -0,0 +1,99 @@
+import type { Database } from "bun:sqlite";
+import { DEFAULT_QUERY_LIMIT, MAX_QUERY_LIMIT } from "../constants.ts";
+import type { MetricObservation, MetricQuery, StoredMetricObservation } from "../domain/metric.ts";
+import { validateMetricObservation } from "../domain/metric.ts";
+import type { MetricStore } from "../ports/metric-store.ts";
+
+interface MetricRow {
+	id: number;
+	source: string;
+	scope: string;
+	metric: string;
+	value: number | null;
+	unit: StoredMetricObservation["unit"];
+	observed_at: number;
+	attributes: string;
+}
+
+function fromRow(row: MetricRow): StoredMetricObservation {
+	return {
+		id: row.id,
+		source: row.source,
+		scope: row.scope,
+		metric: row.metric,
+		value: row.value,
+		unit: row.unit,
+		observedAt: row.observed_at,
+		attributes: JSON.parse(row.attributes) as Record<string, unknown>,
+	};
+}
+
+export class SQLiteMetricStore implements MetricStore {
+	constructor(private readonly db: Database) {}
+
+	record(input: MetricObservation): StoredMetricObservation {
+		const observation = validateMetricObservation(input);
+		const result = this.db.query(`
+			INSERT INTO metric_observations (source, scope, metric, value, unit, observed_at, attributes)
+			VALUES (?, ?, ?, ?, ?, ?, ?)
+		`).run(
+			observation.source,
+			observation.scope,
+			observation.metric,
+			observation.value,
+			observation.unit,
+			observation.observedAt,
+			JSON.stringify(observation.attributes ?? {}),
+		);
+		return this.get(Number(result.lastInsertRowid));
+	}
+
+	query(filter: MetricQuery = {}): StoredMetricObservation[] {
+		const conditions: string[] = [];
+		const parameters: Array<string | number> = [];
+		const addEquals = (column: string, value: string | undefined): void => {
+			if (value === undefined) return;
+			conditions.push(`${column} = ?`);
+			parameters.push(value);
+		};
+		addEquals("source", filter.source);
+		addEquals("scope", filter.scope);
+		addEquals("metric", filter.metric);
+		if (filter.since !== undefined) { conditions.push("observed_at >= ?"); parameters.push(filter.since); }
+		if (filter.until !== undefined) { conditions.push("observed_at <= ?"); parameters.push(filter.until); }
+		const requestedLimit = Number.isFinite(filter.limit) ? Math.floor(filter.limit!) : DEFAULT_QUERY_LIMIT;
+		const limit = Math.max(1, Math.min(MAX_QUERY_LIMIT, requestedLimit));
+		const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+		const order = filter.order === "desc" ? "DESC" : "ASC";
+		const rows = this.db.query(`
+			SELECT id, source, scope, metric, value, unit, observed_at, attributes
+			FROM metric_observations
+			${where}
+			ORDER BY observed_at ${order}, id ${order}
+			LIMIT ${limit}
+		`).all(...parameters) as MetricRow[];
+		return rows.map(fromRow);
+	}
+
+	pruneBefore(cutoff: number): number {
+		if (!Number.isSafeInteger(cutoff) || cutoff < 0) throw new Error("cutoff must be a non-negative integer timestamp");
+		return this.db.query("DELETE FROM metric_observations WHERE observed_at < ?").run(cutoff).changes;
+	}
+
+	checkpoint(): void {
+		this.db.exec("PRAGMA wal_checkpoint(PASSIVE)");
+	}
+
+	close(): void {
+		this.db.close();
+	}
+
+	private get(id: number): StoredMetricObservation {
+		const row = this.db.query(`
+			SELECT id, source, scope, metric, value, unit, observed_at, attributes
+			FROM metric_observations WHERE id = ?
+		`).get(id) as MetricRow | null;
+		if (!row) throw new Error(`metric observation ${id} was not persisted`);
+		return fromRow(row);
+	}
+}

package/src/cli.ts

@@ -0,0 +1,73 @@
+#!/usr/bin/env bun
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { SYSTEMD_UNIT_NAME } from "./constants.ts";
+import { serveMain } from "./daemon.ts";
+import { resolveJittorPaths } from "./state.ts";
+
+export interface SystemdUnitOptions {
+	bunBin: string;
+	cliPath: string;
+	codexAuthFile?: string;
+}
+
+export function renderSystemdUnit(options: SystemdUnitOptions): string {
+	return `[Unit]
+Description=Jittor token optimizing router
+After=default.target network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${options.bunBin} ${options.cliPath} serve
+${options.codexAuthFile ? `Environment="JITTOR_CODEX_AUTH_FILE=${options.codexAuthFile.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"\n` : ""}Restart=always
+RestartSec=2
+NoNewPrivileges=true
+PrivateTmp=true
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+function systemctl(...args: string[]): void {
+	execFileSync("systemctl", ["--user", ...args], { stdio: "inherit" });
+}
+
+function installService(): void {
+	const unitPath = resolveJittorPaths().systemdUnit;
+	mkdirSync(dirname(unitPath), { recursive: true });
+	const codexAuthFile = join(process.env["CODEX_HOME"] ?? join(homedir(), ".codex"), "auth.json");
+	writeFileSync(unitPath, renderSystemdUnit({
+		bunBin: process.execPath,
+		cliPath: fileURLToPath(import.meta.url),
+		...(existsSync(codexAuthFile) ? { codexAuthFile } : {}),
+	}));
+	systemctl("daemon-reload");
+	systemctl("enable", SYSTEMD_UNIT_NAME);
+	systemctl("restart", SYSTEMD_UNIT_NAME);
+}
+
+function usage(): never {
+	console.error("Usage: jittor serve | service <install|start|stop|restart|status>");
+	process.exit(2);
+}
+
+export function main(args: string[] = process.argv.slice(2)): void {
+	const [command, action] = args;
+	if (command === "serve") { serveMain(); return; }
+	if (command !== "service") usage();
+	switch (action) {
+		case "install": installService(); break;
+		case "start": systemctl("start", SYSTEMD_UNIT_NAME); break;
+		case "stop": systemctl("stop", SYSTEMD_UNIT_NAME); break;
+		case "restart": systemctl("restart", SYSTEMD_UNIT_NAME); break;
+		case "status": systemctl("status", SYSTEMD_UNIT_NAME); break;
+		default: usage();
+	}
+}
+
+if (import.meta.main) main();

package/src/client.ts

@@ -0,0 +1,57 @@
+import type { OperationInputs, OperationName, OperationOutputs } from "./service.ts";
+import { ensureAuthToken, readDaemonHandle, resolveJittorPaths, type JittorPaths } from "./state.ts";
+
+export type FetchTransport = (request: Request) => Promise<Response>;
+
+export class JittorClient {
+	constructor(
+		private readonly baseUrl: string,
+		private readonly token: string,
+		private readonly transport: FetchTransport = fetch,
+	) {}
+
+	async call<Name extends OperationName>(operation: Name, input: OperationInputs[Name]): Promise<OperationOutputs[Name]> {
+		const response = await this.transport(new Request(`${this.baseUrl}/api/v1/ops`, {
+			method: "POST",
+			headers: { authorization: `Bearer ${this.token}`, "content-type": "application/json" },
+			body: JSON.stringify({ op: operation, input }),
+		}));
+		const body = await response.json() as { result?: OperationOutputs[Name]; error?: string };
+		if (!response.ok) throw new Error(body.error ?? `Jittor operation failed with HTTP ${response.status}`);
+		return body.result as OperationOutputs[Name];
+	}
+
+	async operations(): Promise<OperationName[]> {
+		const response = await this.transport(new Request(`${this.baseUrl}/api/v1/ops`, {
+			headers: { authorization: `Bearer ${this.token}` },
+		}));
+		const body = await response.json() as { operations?: OperationName[]; error?: string };
+		if (!response.ok) throw new Error(body.error ?? `Jittor discovery failed with HTTP ${response.status}`);
+		return body.operations ?? [];
+	}
+
+	async ready(): Promise<boolean> {
+		const response = await this.transport(new Request(`${this.baseUrl}/ready`, {
+			headers: { authorization: `Bearer ${this.token}` },
+		}));
+		if (response.status === 503) return false;
+		if (!response.ok) throw new Error(`Jittor readiness check failed with HTTP ${response.status}`);
+		return true;
+	}
+
+	async health(): Promise<{ ok: true; version: string }> {
+		const response = await this.transport(new Request(`${this.baseUrl}/health`, {
+			headers: { authorization: `Bearer ${this.token}` },
+		}));
+		const body = await response.json() as { ok?: boolean; version?: string; error?: string };
+		if (!response.ok || body.ok !== true || typeof body.version !== "string") throw new Error(body.error ?? "Jittor health check failed");
+		return { ok: true, version: body.version };
+	}
+}
+
+export function connectJittorClient(paths: JittorPaths = resolveJittorPaths()): JittorClient {
+	const handle = readDaemonHandle(paths);
+	if (!handle) throw new Error("Jittor daemon is not running; install or start jittor.service");
+	const token = ensureAuthToken(paths);
+	return new JittorClient(`http://${handle.host}:${handle.port}`, token);
+}

package/src/config.ts

@@ -0,0 +1,20 @@
+import type { PolicyConfig, Route } from "./policy.ts";
+
+/** Replaced by Pi's active model and authenticated ModelRegistry routes before enforcement. */
+export const UNCONFIGURED_ROUTE: Route = { provider: "unconfigured", model: "unconfigured", thinking: "off" };
+
+export const DEFAULT_POLICY: PolicyConfig = {
+	maxTelemetryAgeMs: 120_000,
+	cooldownMs: 300_000,
+	hysteresisFraction: 0.1,
+	thresholds: {
+		throttle: 1,
+		lowerThinking: 1.25,
+		switchModel: 1.5,
+		switchProvider: 2,
+		halt: 3,
+	},
+	maxThrottleMs: 30_000,
+	hardStopUsedFraction: 0.99,
+	minimumConfidence: 0.5,
+};

package/src/constants.ts

@@ -0,0 +1,26 @@
+export const VERSION = "0.1.0";
+export const SQLITE_SCHEMA_VERSION = 1;
+export const SQLITE_BUSY_TIMEOUT_MS = 5_000;
+export const DEFAULT_QUERY_LIMIT = 1_000;
+export const MAX_QUERY_LIMIT = 10_000;
+export const SERVICE_MAX_BODY_BYTES = 1_048_576;
+export const MAINTENANCE_INTERVAL_MS = 15 * 60 * 1_000;
+export const TELEMETRY_POLL_INTERVAL_MS = 60_000;
+export const TELEMETRY_STALE_AFTER_MS = 120_000;
+export const FOOTER_CONTEXT_ACCENT_FRACTION = 0.5;
+export const FOOTER_CONTEXT_WARNING_FRACTION = 0.7;
+export const FOOTER_CONTEXT_ERROR_FRACTION = 0.9;
+export const FOOTER_BAR_MIN_WIDTH = 4;
+export const FOOTER_BAR_MAX_WIDTH = 8;
+export const FOOTER_WIDE_TERMINAL_WIDTH = 100;
+export const LOOPBACK_HOST = "127.0.0.1";
+export const JITTOR_STATE_DIRECTORY = "jittor";
+export const JITTOR_EXTENSION_SETTINGS_FILENAME = "extension.json";
+export const DATABASE_FILENAME = "jittor.db";
+export const TOKEN_FILENAME = "auth-token";
+export const HANDLE_FILENAME = "daemon.json";
+export const SYSTEMD_UNIT_NAME = "jittor.service";
+export const USAGE_CHART_HEIGHT = 8;
+export const USAGE_Y_AXIS_WIDTH = 7;
+export const USAGE_TOKEN_QUERY_LIMIT = 10_000;
+export const MAX_DYNAMIC_ROUTES = 100;