pi-mega-compact 0.13.5 → 0.13.7

package/extensions/dashboard-server/api-contracts/rag-settings.ts

@@ -1,42 +1,52 @@
 /**
- * api-contracts/rag-settings.ts — RAG feature flag API response types.
+ * api-contracts/rag-settings.ts — comprehensive settings API response types.
  *
- * Types for the /api/rag-settings endpoint used by the dashboard RAG Settings
- * panel to read and toggle the five RAG feature flags (B1–B5).
+ * Types for the /api/rag-settings endpoint used by the dashboard Setup panel to
+ * read and update every adjustable MEGACOMPACT_* setting, grouped by category.
  *
  * PREVENT-PI-004: type definitions only, no network code.
  * PREVENT-011: no `any` type — all types are explicit.
  */
 
-/**单个 RAG feature flag state for the dashboard. */
-export interface RagFlagState {
-	/** Env var key without the _DISABLED suffix, e.g. "MEGACOMPACT_HYDE". */
+/** A single configurable setting's metadata + current value. */
+export interface SettingState {
 	readonly key: string;
-	/** Short human-readable label, e.g. "HyDE (Hypothetical Document Embeddings)". */
 	readonly label: string;
-	/** One-line description of what the flag does. */
 	readonly description: string;
-	/** Whether the flag is currently enabled (true = ON, false = disabled via _DISABLED). */
-	readonly enabled: boolean;
-	/** Whether this flag requires an LLM embedder (HttpEmbedder) to function. */
+	readonly category: string;
+	readonly type: "boolean" | "number" | "string";
+	readonly value: string | number | boolean;
+	readonly default: string | number | boolean;
+	readonly disabledConvention: boolean;
 	readonly requiresLlm: boolean;
+	readonly unit?: string;
+	readonly min?: number;
+	readonly max?: number;
 }
 
-/** Response for GET /api/rag-settings. */
-export interface RagSettingsResponse {
-	readonly flags: RagFlagState[];
-	/** Whether an HttpEmbedder (LLM) is currently active — gates HyDE toggle. */
+/** Response for GET /api/rag-settings — all settings grouped by category. */
+export interface SettingsResponse {
+	readonly categories: ReadonlyArray<{ name: string; settings: SettingState[] }>;
 	readonly llmActive: boolean;
 }
 
-/** Request body for POST /api/rag-settings. */
-export interface RagSettingsRequest {
-	/** Map of flag key (e.g. "MEGACOMPACT_HYDE") to desired enabled state. */
-	readonly flags: Record<string, boolean>;
+/** Request body for POST /api/rag-settings — update a single setting. */
+export interface SettingsUpdateRequest {
+	readonly key: string;
+	readonly value: string;
 }
 
 /** Response for POST /api/rag-settings. */
-export interface RagSettingsResponsePost {
+export interface SettingsResponsePost {
 	readonly envPath: string;
 	readonly restartRequired: boolean;
 }
+
+/** @deprecated Use SettingState instead */
+export type RagFlagState = SettingState;
+/** @deprecated Use SettingsResponse instead */
+export type RagSettingsResponse = SettingsResponse;
+/** @deprecated Use SettingsUpdateRequest instead */
+export type RagSettingsRequest = SettingsUpdateRequest;
+/** @deprecated Use SettingsResponsePost instead */
+export type RagSettingsResponsePost = SettingsResponsePost;

package/extensions/dashboard-server/api-contracts/wiki.ts

@@ -0,0 +1,138 @@
+/**
+ * api-contracts/wiki.ts — W2 wiki revival contract types.
+ *
+ * Shapes for the 7 wiki endpoints plus the SSE events the mutations emit.
+ * `CurationResult` is the canonical type from src/wiki/curation.ts (single
+ * source of truth), re-exported here for route + client parity. Type-only —
+ * no network (PREVENT-PI-004), no `any` (PREVENT-011).
+ */
+import type { CurationResult } from "../../../src/wiki/curation.js";
+
+/** One topic row in the wiki index (with resolved custom label). */
+export interface WikiIndexEntry {
+	id: string;
+	label: string;
+	memoryCount: number;
+	lastUpdated: number;
+	/** True when the label is a user override, not the auto-generated one. */
+	edited: boolean;
+	/** Cumulative override kinds for badge provenance. */
+	overrideKinds: Array<"label" | "merge" | "split">;
+}
+
+/** GET /api/wiki/index — wiki landing page payload. */
+export interface WikiIndexResponse {
+	topics: WikiIndexEntry[];
+	totalTopics: number;
+	totalMemories: number;
+	lastRebuildAt: number | null;
+}
+
+/** Provenance for one memory within a wiki topic. */
+export interface MemoryProvenance {
+	memoryId: string;
+	sessionId: string;
+	assignedAt: number;
+	method: string;
+}
+
+/** GET /api/wiki/topic/:topicId — single topic page. */
+export interface WikiPageResponse {
+	topic: WikiIndexEntry;
+	summary: string;
+	keyMemories: Array<{
+		memoryId: string;
+		content: string;
+		timestamp: number;
+		importance: number;
+	}>;
+	provenance: MemoryProvenance[];
+	relatedTopicIds: string[];
+	generatedAt: number;
+}
+
+/** PUT /api/wiki/topic/:topicId/label — rename request body. */
+export interface RenameTopicRequest {
+	label: string;
+}
+
+/** POST /api/wiki/merge — merge source into target. */
+export interface MergeTopicsRequest {
+	sourceTopicId: string;
+	targetTopicId: string;
+}
+
+/** POST /api/wiki/topic/:topicId/split — split request body. */
+export interface SplitTopicRequest {
+	memoryIds: string[];
+}
+
+/** One flat node row in the D3 evolution graph. */
+export interface TopicEvolutionNode {
+	id: string;
+	label: string;
+	memoryCount: number;
+}
+
+/** One edge between evolved topics. */
+export interface TopicEvolutionEdge {
+	source: string;
+	target: string;
+	kind: "merge" | "split";
+	at: number;
+}
+
+/** GET /api/wiki/evolution — nodes + edges + time buckets for D3. */
+export interface TopicEvolutionResponse {
+	nodes: TopicEvolutionNode[];
+	edges: TopicEvolutionEdge[];
+	buckets: Array<{ bucket: number; count: number }>;
+}
+
+/** GET /api/wiki/topic/:topicId/timeline — per-topic time buckets. */
+export interface TopicTimelineResponse {
+	topicId: string;
+	buckets: Array<{ bucket: number; count: number }>;
+	total: number;
+}
+
+/** SSE: wiki model rebuilt. */
+export interface SseWikiRebuilt {
+	type: "wiki_rebuilt";
+	ts: string;
+	topicCount: number;
+}
+
+/** SSE: a topic was renamed. */
+export interface SseWikiTopicRenamed {
+	type: "wiki_topic_renamed";
+	ts: string;
+	topicId: string;
+	label: string;
+	edited: boolean;
+}
+
+/** SSE: two topics were merged. */
+export interface SseWikiTopicsMerged {
+	type: "wiki_topics_merged";
+	ts: string;
+	sourceTopicId: string;
+	targetTopicId: string;
+}
+
+/** SSE: a topic was split. */
+export interface SseWikiTopicSplit {
+	type: "wiki_topic_split";
+	ts: string;
+	fromTopicId: string;
+	toTopicId: string;
+}
+
+/** Union of all wiki SSE events. */
+export type WikiSseEvent =
+	| SseWikiRebuilt
+	| SseWikiTopicRenamed
+	| SseWikiTopicsMerged
+	| SseWikiTopicSplit;
+
+export type { CurationResult };

package/extensions/dashboard-server/index-reader.ts

@@ -17,6 +17,7 @@ import type { IndexRepo, IndexIndex } from "./types.js";
 import {
 	readProviderCacheForRepo,
 } from "../../src/store/sqlite/perf-samples.js";
+import { lookupModelInputRate } from "../../src/pricing.js";
 
 export function getIndexDir(): string {
 	const override = process.env.MEGACOMPACT_INDEX_DIR;
@@ -51,7 +52,8 @@ export function readIndex(): IndexIndex | null {
 			provider: (r.provider as string | null) ?? null,
 			providerName: (r.provider_name as string | null) ?? null,
 			modelName: (r.model_name as string | null) ?? null,
-			inputRate: (r.input_rate as number | null) ?? null,
+			inputRate: ((r.input_rate as number | null) ||
+				lookupModelInputRate(String(r.model_name ?? ""))) ?? null,
 			outputRate: (r.output_rate as number | null) ?? null,
 			lastSeen: Number(r.last_seen ?? 0),
 			// Defaults — enriched below from each repo's own store.

package/extensions/dashboard-server/resolve-snapshot.ts

@@ -0,0 +1,98 @@
+/**
+ * dashboard-server/resolve-snapshot.ts — dynamic per-repo snapshot resolver.
+ *
+ * The dashboard server is launched with a single static stateDir, but the
+ * active pi session may be running in a different repo. This module queries
+ * the repo registry to find the most recently active repo's dashboard.json,
+ * so the Overview always shows live data from the repo pi is actually running
+ * in — not the stale launcher dir.
+ *
+ * Resolution order:
+ * 1. Most recently seen repo (by last_seen in repo_registry) whose
+ *    dashboard.json exists and has a non-null updatedAt
+ * 2. The static launch stateDir's dashboard.json (original behavior)
+ */
+
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { createRequire } from "node:module";
+import { readSnapshot } from "./snapshot.js";
+import type { Snapshot } from "./types.js";
+import { getIndexDir } from "./index-reader.js";
+
+export interface ResolvedSnapshot {
+	snapshot: Snapshot;
+	/** The stateDir that produced this snapshot. */
+	stateDir: string;
+}
+
+const require = createRequire(import.meta.url);
+
+interface RepoRegistryRow {
+	state_dir: string;
+	last_seen: number;
+}
+
+/**
+ * Find the most recently active repo's stateDir by scanning the repo registry
+ * for repos whose dashboard.json exists and was written recently. Returns null
+ * if no suitable repo is found.
+ */
+function mostRecentRepoStateDir(staticStateDir: string): string | null {
+	const indexPath = join(getIndexDir(), "index.sqlite");
+	if (!existsSync(indexPath)) return null;
+	let db;
+	try {
+		const { DatabaseSync } = require("node:sqlite") as typeof import("node:sqlite");
+		db = new DatabaseSync(indexPath, { readOnly: true });
+		const rows = db
+			.prepare(
+				`SELECT state_dir, last_seen FROM repo_registry
+				 WHERE state_dir IS NOT NULL AND state_dir != ?
+				 ORDER BY last_seen DESC`,
+			)
+			.all(staticStateDir) as unknown as RepoRegistryRow[];
+		for (const r of rows) {
+			const dashPath = join(r.state_dir, "dashboard.json");
+			if (!existsSync(dashPath)) continue;
+			const snap = readSnapshot(dashPath);
+			if (snap.updatedAt) {
+				return r.state_dir;
+			}
+		}
+		return null;
+	} catch {
+		return null;
+	} finally {
+		try {
+			db?.close();
+		} catch {
+			/* ignore */
+		}
+	}
+}
+
+/**
+ * Resolve the best snapshot to serve. Tries the most recently active repo's
+ * dashboard.json first, then falls back to the static launch path.
+ */
+export function resolveSnapshot(
+	staticSnapshotPath: string,
+	staticStateDir: string,
+): ResolvedSnapshot {
+	// Try the most recently active repo first.
+	const activeDir = mostRecentRepoStateDir(staticStateDir);
+	if (activeDir) {
+		const activePath = join(activeDir, "dashboard.json");
+		const snap = readSnapshot(activePath);
+		if (snap.updatedAt) {
+			return { snapshot: snap, stateDir: activeDir };
+		}
+	}
+	// Fall back to the static launch path.
+	return {
+		snapshot: readSnapshot(staticSnapshotPath),
+		stateDir: staticStateDir,
+	};
+}
+

package/extensions/dashboard-server/routes-core.ts

@@ -8,7 +8,7 @@
 
 import type { ServerResponse } from "node:http";
 
-import { readSnapshot } from "./snapshot.js";
+import { resolveSnapshot } from "./resolve-snapshot.js";
 import type { IndexIndex, Snapshot } from "./types.js";
 
 // ---------------------------------------------------------------------------
@@ -53,14 +53,19 @@ function makeOverlayCurrentRepo(
 ): (idx: IndexIndex | null) => void {
 	return (idx: IndexIndex | null): void => {
 		if (!idx || !idx.repos.length) return;
+		// Dynamically resolve the most recently active repo's snapshot so the
+		// overlay matches what /api/snapshot serves (not the stale launch dir).
 		let snap: Snapshot | null = null;
+		let activeStateDir = stateDir;
 		try {
-			snap = readSnapshot(snapshotPath);
+			const resolved = resolveSnapshot(snapshotPath, stateDir);
+			snap = resolved.snapshot;
+			activeStateDir = resolved.stateDir;
 		} catch {
 			return;
 		}
 		if (!snap || !snap.repo) return;
-		const cur = idx.repos.find((r) => r.stateDir === stateDir);
+		const cur = idx.repos.find((r) => r.stateDir === activeStateDir);
 		if (!cur) return;
 		const prevSaved = cur.tokensSaved;
 		const prevCp = cur.checkpointCount;

package/extensions/dashboard-server/routes-rag-metrics.ts

@@ -0,0 +1,82 @@
+/**
+ * dashboard-server/routes-rag-metrics.ts — GET /api/rag-metrics route (H2).
+ *
+ * Aggregates the H1 HyDE + recall-quality telemetry columns from turns.db into
+ * a compact response (flags, totals, recent rows, daily series).
+ *
+ * Guardrails: PREVENT-PI-004 (loopback-only), PREVENT-002 (parameterized),
+ * PREVENT-011 (no `any`).
+ */
+
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { DatabaseSync } from "node:sqlite";
+import type { RouteContext } from "./routes-core.js";
+import { openTurnStore } from "../../src/store/turns/connection.js";
+import {
+	listTelemetryTurns,
+	aggregateDailyTelemetry,
+} from "../../src/store/turns/hydeStore.js";
+import { RAG_HYDE_ENABLED, RAG_RECALL_METRICS } from "../../src/config.js";
+import type { RagMetricsResponse } from "./api-contracts/rag-metrics.js";
+
+function sendJson(res: ServerResponse, status: number, body: unknown): void {
+	// guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+	res.writeHead(status, { "Content-Type": "application/json" });
+	res.end(JSON.stringify(body));
+}
+
+export function handleRagMetrics(
+	req: IncomingMessage,
+	res: ServerResponse,
+	ctx: RouteContext,
+): boolean {
+	const url = req.url ?? "";
+	if (url !== "/api/rag-metrics" || req.method !== "GET") return false;
+
+	let db: DatabaseSync | null;
+	try {
+		db = openTurnStore(ctx.stateDir);
+	} catch {
+		db = null;
+	}
+	const recent = db ? listTelemetryTurns(db, { limit: 200 }) : [];
+	const daily = db ? aggregateDailyTelemetry(db, 14) : [];
+
+	const hydeRanTurns = recent.filter((t) => t.hydeRan === 1).length;
+	const liftSum = recent.reduce((s, t) => s + t.hydeLift, 0);
+	const genSum = recent.reduce((s, t) => s + t.hydeGenerationMs, 0);
+	const scored = recent.filter(
+		(t) => t.recallScore > 0 || t.recallPass === 1,
+	);
+	const avgScore =
+		scored.length > 0
+			? Math.round(
+					(scored.reduce((s, t) => s + t.recallScore, 0) / scored.length) * 100,
+				) / 100
+			: null;
+	const passCount = scored.filter((t) => t.recallPass === 1).length;
+	const recentPassRate =
+		scored.length > 0 ? Math.round((passCount / scored.length) * 100) / 100 : 0;
+
+	const body: RagMetricsResponse = {
+		flags: {
+			hydeEnabled: RAG_HYDE_ENABLED(),
+			recallMetricsEnabled: RAG_RECALL_METRICS(),
+		},
+		totals: {
+			telemetryTurns: recent.length,
+			hydeRanTurns,
+			avgLift:
+				recent.length > 0
+					? Math.round((liftSum / recent.length) * 100) / 100
+					: 0,
+			avgScore,
+			avgGenerationMs: recent.length > 0 ? Math.round(genSum / recent.length) : 0,
+			recentPassRate,
+		},
+		recent: recent.slice(0, 50),
+		daily,
+	};
+	sendJson(res, 200, body);
+	return true;
+}