@cleocode/cleo 2026.9.7 → 2026.9.9

package/studio-dist/server/chunks/project-context-BjiqfEBi.js

@@ -1,166 +0,0 @@
-import './dist4-DmC1zSXi.js';
-import { o as openCleoDbSnapshot } from './open-cleo-db--8sYNaYY.js';
-import { g as getCleoHome, a as getCleoProjectDir } from './cleo-home-CCfe6kAQ.js';
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-
-//#region src/lib/server/project-context.ts
-/**
-* Project context resolution for CLEO Studio.
-*
-* The active project is stored as a cookie (`cleo_project_id`).
-* When a project is selected, the studio resolves the project's
-* brain.db and tasks.db paths from the global nexus.db registry,
-* injecting them into database connections for the page load.
-*
-* nexus.db is always global (single instance); brain.db and tasks.db
-* are per-project.
-*
-* @task T622
-*/
-/** Cookie name used to persist the active project selection. */
-var PROJECT_COOKIE = "cleo_project_id";
-/** How long the project context cookie lives (7 days). */
-var COOKIE_MAX_AGE = 3600 * 24 * 7;
-/**
-* Read the active project ID from the request cookie.
-* Returns null if no project is selected.
-*/
-function getActiveProjectId(cookies) {
-	return cookies.get("cleo_project_id") ?? null;
-}
-/**
-* Set the active project context cookie.
-*/
-function setActiveProjectId(cookies, projectId) {
-	cookies.set(PROJECT_COOKIE, projectId, {
-		path: "/",
-		maxAge: COOKIE_MAX_AGE,
-		httpOnly: false,
-		sameSite: "lax"
-	});
-}
-/**
-* Clear the active project context cookie.
-*/
-function clearActiveProjectId(cookies) {
-	cookies.delete(PROJECT_COOKIE, { path: "/" });
-}
-/**
-* Resolve the project context from the nexus.db registry for a given project ID.
-*
-* Returns null if the project is not registered or the DB rows are missing.
-* Falls back to deriving paths from the project_path column if brain_db_path
-* or tasks_db_path are not set in the registry.
-*/
-function resolveProjectContext(projectId) {
-	try {
-		const globalDbPath = join(getCleoHome(), "cleo.db");
-		if (!existsSync(globalDbPath)) return null;
-		const snap = openCleoDbSnapshot(globalDbPath);
-		try {
-			const row = snap.db.prepare("SELECT project_id, name, project_path, brain_db_path, tasks_db_path FROM nexus_project_registry WHERE project_id = ?").get(projectId);
-			if (!row) return null;
-			const brainDbPath = row.brain_db_path ?? join(row.project_path, ".cleo", "brain.db");
-			const tasksDbPath = row.tasks_db_path ?? join(row.project_path, ".cleo", "tasks.db");
-			return {
-				projectId: row.project_id,
-				name: row.name,
-				projectPath: row.project_path,
-				brainDbPath,
-				tasksDbPath,
-				brainDbExists: existsSync(brainDbPath),
-				tasksDbExists: existsSync(tasksDbPath)
-			};
-		} finally {
-			snap.close();
-		}
-	} catch {
-		return null;
-	}
-}
-/**
-* Resolve the default project context (current project from CLEO_ROOT / cwd).
-* Used as fallback when no project cookie is set.
-*/
-function resolveDefaultProjectContext() {
-	const projectDir = getCleoProjectDir();
-	const projectPath = projectDir.replace(/\/.cleo$/, "");
-	const brainDbPath = join(projectDir, "brain.db");
-	const tasksDbPath = join(projectDir, "tasks.db");
-	return {
-		projectId: "",
-		name: projectPath.split("/").pop() ?? "default",
-		projectPath,
-		brainDbPath,
-		tasksDbPath,
-		brainDbExists: existsSync(brainDbPath),
-		tasksDbExists: existsSync(tasksDbPath)
-	};
-}
-/**
-* List all registered projects from nexus.db.
-* Returns an empty array if nexus.db is unavailable.
-*/
-function listRegisteredProjects() {
-	try {
-		const globalDbPath = join(getCleoHome(), "cleo.db");
-		if (!existsSync(globalDbPath)) return [];
-		const snap = openCleoDbSnapshot(globalDbPath);
-		try {
-			const rows = snap.db.prepare(`SELECT
-            project_id,
-            name,
-            project_path,
-            brain_db_path,
-            tasks_db_path,
-            last_indexed,
-            task_count,
-            stats_json,
-            last_seen,
-            health_status
-          FROM nexus_project_registry
-          ORDER BY last_seen DESC`).all();
-			/**
-			* Strict server-side exclusion: any project whose path contains a `.temp/`
-			* segment is filtered out before reaching the client. This rule is
-			* non-negotiable (cannot be revealed via UI toggle) — `.temp/` is reserved
-			* for ephemeral fixture/scratch state that must never appear in the
-			* project switcher.
-			*/
-			const TEMP_PATH_PATTERN = /(^|\/)\.temp(\/|$)/;
-			return rows.filter((row) => !TEMP_PATH_PATTERN.test(row.project_path)).map((row) => {
-				let nodeCount = 0;
-				let relationCount = 0;
-				let fileCount = 0;
-				try {
-					const stats = JSON.parse(row.stats_json ?? "{}");
-					nodeCount = stats.nodeCount ?? 0;
-					relationCount = stats.relationCount ?? 0;
-					fileCount = stats.fileCount ?? 0;
-				} catch {}
-				return {
-					projectId: row.project_id,
-					name: row.name,
-					projectPath: row.project_path,
-					brainDbPath: row.brain_db_path ?? null,
-					tasksDbPath: row.tasks_db_path ?? null,
-					lastIndexed: row.last_indexed ?? null,
-					taskCount: row.task_count ?? 0,
-					nodeCount,
-					relationCount,
-					fileCount,
-					lastSeen: row.last_seen,
-					healthStatus: row.health_status
-				};
-			});
-		} finally {
-			snap.close();
-		}
-	} catch {
-		return [];
-	}
-}
-
-export { resolveDefaultProjectContext as a, clearActiveProjectId as c, getActiveProjectId as g, listRegisteredProjects as l, resolveProjectContext as r, setActiveProjectId as s };
-//# sourceMappingURL=project-context-BjiqfEBi.js.map

package/studio-dist/server/chunks/provider-registry2-Cu7rAF0R.js

@@ -1,35 +0,0 @@
-import { g as getProviderProfile } from './credential-pool-vF6NdtT9.js';
-import './paths-CV7S5-Zm.js';
-import 'node:fs';
-import 'node:path';
-import 'node:os';
-import 'node:events';
-import 'node:diagnostics_channel';
-import 'fs';
-import 'events';
-import 'util';
-import 'path';
-import 'assert';
-import 'worker_threads';
-import 'module';
-import 'node:url';
-import 'url';
-import 'buffer';
-import 'node:module';
-import 'node:child_process';
-import 'node:crypto';
-import 'node:process';
-import 'node:async_hooks';
-import './index-Dtt_h58T.js';
-import 'constants';
-import 'stream';
-import './config-DHj9CcFs.js';
-import './json-Bfixam3g.js';
-import './lock-CA7d6lj7.js';
-import 'node:fs/promises';
-import './index-61916rmV.js';
-
-
-
-export { getProviderProfile };
-//# sourceMappingURL=provider-registry2-Cu7rAF0R.js.map

package/studio-dist/server/chunks/quality-feedback-CuCGEI6S.js

@@ -1,371 +0,0 @@
-import { t as typedAll } from './typed-query-l1D_QElt.js';
-
-//#region ../core/dist/memory/quality-feedback.js
-/**
-* Memory Quality Feedback Loop — BRAIN self-improvement system.
-*
-* Closes the retrieval→usage→outcome loop so that memory quality scores
-* reflect real-world utility, not just insert-time heuristics.
-*
-* Three operations:
-*
-* 1. trackMemoryUsage — record whether a retrieved memory was actually used
-*    by an agent after task completion.
-*
-* 2. correlateOutcomes — scan the retrieval log, join against task outcomes,
-*    and apply quality adjustments:
-*      - Memory retrieved before a successful task completion: +0.05
-*      - Memory retrieved before a failed task: -0.05
-*      - Memory never retrieved in 30 days: flagged for pruning
-*
-* 3. getMemoryQualityReport — dashboard metrics over the entire brain.db.
-*
-* Schema addition: brain_usage_log (entry_id, task_id, used, outcome, created_at).
-* The table is self-healing — created on first access.
-*
-* @task T555
-*/
-/**
-* Ensure brain_usage_log exists. Safe to call multiple times — uses
-* CREATE TABLE IF NOT EXISTS. Returns silently on error (best-effort).
-*/
-async function ensureUsageLogTable(projectRoot) {
-	const { getBrainDb, getBrainNativeDb } = await import('./memory-sqlite2-B7dq8doO.js');
-	await getBrainDb(projectRoot);
-	const nativeDb = getBrainNativeDb(projectRoot);
-	if (!nativeDb) return;
-	try {
-		nativeDb.prepare(`CREATE TABLE IF NOT EXISTS brain_usage_log (
-          id         INTEGER PRIMARY KEY AUTOINCREMENT,
-          entry_id   TEXT    NOT NULL,
-          task_id    TEXT,
-          used       INTEGER NOT NULL DEFAULT 0,
-          outcome    TEXT    NOT NULL DEFAULT 'unknown',
-          created_at TEXT    NOT NULL DEFAULT (datetime('now'))
-        )`).run();
-		nativeDb.prepare(`CREATE INDEX IF NOT EXISTS idx_brain_usage_log_entry_id
-         ON brain_usage_log(entry_id)`).run();
-		nativeDb.prepare(`CREATE INDEX IF NOT EXISTS idx_brain_usage_log_task_id
-         ON brain_usage_log(task_id)`).run();
-	} catch {}
-}
-/**
-* Ensure prune_candidate column exists on all typed brain tables.
-* Added lazily so existing schemas are not broken.
-*/
-async function ensurePruneCandidateColumn(projectRoot) {
-	const { getBrainDb, getBrainNativeDb } = await import('./memory-sqlite2-B7dq8doO.js');
-	await getBrainDb(projectRoot);
-	const nativeDb = getBrainNativeDb(projectRoot);
-	if (!nativeDb) return;
-	for (const tbl of [
-		"brain_decisions",
-		"brain_patterns",
-		"brain_learnings",
-		"brain_observations"
-	]) try {
-		nativeDb.prepare(`ALTER TABLE ${tbl} ADD COLUMN prune_candidate INTEGER DEFAULT 0`).run();
-	} catch {}
-}
-/**
-* Resolve the table name for a brain entry based on its ID prefix.
-*/
-function tableForId(id) {
-	if (id.startsWith("D-") || /^D\d/.test(id)) return "brain_decisions";
-	if (id.startsWith("P-") || /^P\d/.test(id)) return "brain_patterns";
-	if (id.startsWith("L-") || /^L\d/.test(id)) return "brain_learnings";
-	if (id.startsWith("O-") || id.startsWith("CM-") || /^O/.test(id)) return "brain_observations";
-	return null;
-}
-/**
-* Apply a quality delta (+0.05 or -0.05) to a brain entry, clamped to [0.0, 1.0].
-*/
-function applyQualityDelta(nativeDb, table, id, delta, now) {
-	if (!nativeDb) return;
-	try {
-		nativeDb.prepare(`UPDATE ${table}
-         SET quality_score = MAX(0.0, MIN(1.0, COALESCE(quality_score, 0.5) + ?)),
-             updated_at    = ?
-         WHERE id = ?`).run(delta, now, id);
-	} catch {}
-}
-/**
-* Analyse the retrieval log and usage log against task outcomes, then
-* adjust quality scores to reflect real-world utility.
-*
-* Algorithm:
-*   1. Read brain_usage_log where outcome != 'unknown' — these are rows
-*      already tagged with a definitive outcome.
-*   2. For success rows: boost quality_score by +0.05 for each entry used.
-*   3. For failure rows: penalise quality_score by -0.05 for each entry used.
-*   4. Flag entries whose citation_count = 0 AND last retrieval (if any) is
-*      older than 30 days as prune candidates.
-*
-* This is designed to be idempotent — running it twice on the same data
-* applies the delta twice (small, intentional drift toward ground truth).
-* Callers should schedule it once per session end or per task batch.
-*
-* @param projectRoot - Project root directory
-* @returns Summary of changes made
-*/
-async function correlateOutcomes(projectRoot) {
-	await ensureUsageLogTable(projectRoot);
-	await ensurePruneCandidateColumn(projectRoot);
-	const { getBrainDb, getBrainNativeDb } = await import('./memory-sqlite2-B7dq8doO.js');
-	await getBrainDb(projectRoot);
-	const nativeDb = getBrainNativeDb(projectRoot);
-	const ranAt = (/* @__PURE__ */ new Date()).toISOString();
-	if (!nativeDb) return {
-		boosted: 0,
-		penalized: 0,
-		flaggedForPruning: 0,
-		ranAt
-	};
-	const now = ranAt.replace("T", " ").slice(0, 19);
-	let boosted = 0;
-	let penalized = 0;
-	let usageRows = [];
-	try {
-		usageRows = typedAll(nativeDb.prepare(`SELECT entry_id, outcome, SUM(used) AS used_count
-         FROM brain_usage_log
-         WHERE outcome IN ('success', 'failure')
-         GROUP BY entry_id, outcome`));
-	} catch {
-		usageRows = [];
-	}
-	for (const row of usageRows) {
-		const table = tableForId(row.entry_id);
-		if (!table) continue;
-		if (row.outcome === "success" && row.used_count > 0) {
-			applyQualityDelta(nativeDb, table, row.entry_id, .05, now);
-			boosted++;
-		} else if (row.outcome === "failure" && row.used_count > 0) {
-			applyQualityDelta(nativeDb, table, row.entry_id, -0.05, now);
-			penalized++;
-		}
-	}
-	const cutoffDate = (/* @__PURE__ */ new Date(Date.now() - 720 * 60 * 60 * 1e3)).toISOString().replace("T", " ").slice(0, 19);
-	let flaggedForPruning = 0;
-	for (const { table, dateCol } of [
-		{
-			table: "brain_decisions",
-			dateCol: "created_at"
-		},
-		{
-			table: "brain_patterns",
-			dateCol: "extracted_at"
-		},
-		{
-			table: "brain_learnings",
-			dateCol: "created_at"
-		},
-		{
-			table: "brain_observations",
-			dateCol: "created_at"
-		}
-	]) try {
-		const result = nativeDb.prepare(`UPDATE ${table}
-           SET prune_candidate = 1
-           WHERE COALESCE(citation_count, 0) = 0
-             AND ${dateCol} < ?`).run(cutoffDate);
-		flaggedForPruning += result.changes ?? 0;
-	} catch {}
-	return {
-		boosted,
-		penalized,
-		flaggedForPruning,
-		ranAt
-	};
-}
-/**
-* Return dashboard-level quality metrics for the BRAIN memory system.
-*
-* Aggregates across all four typed tables (decisions, patterns, learnings,
-* observations) and the retrieval log to produce a single report object.
-*
-* @param projectRoot - Project root directory
-* @returns Quality metrics report
-*/
-async function getMemoryQualityReport(projectRoot) {
-	await ensureUsageLogTable(projectRoot);
-	const { getBrainDb, getBrainNativeDb } = await import('./memory-sqlite2-B7dq8doO.js');
-	await getBrainDb(projectRoot);
-	const nativeDb = getBrainNativeDb(projectRoot);
-	const emptyReport = {
-		totalRetrievals: 0,
-		uniqueEntriesRetrieved: 0,
-		usageRate: 0,
-		topRetrieved: [],
-		neverRetrieved: [],
-		qualityDistribution: {
-			low: 0,
-			medium: 0,
-			high: 0
-		},
-		tierDistribution: {
-			short: 0,
-			medium: 0,
-			long: 0,
-			unknown: 0
-		},
-		noiseRatio: 0
-	};
-	if (!nativeDb) return emptyReport;
-	let totalRetrievals = 0;
-	let uniqueEntriesRetrieved = 0;
-	try {
-		totalRetrievals = typedAll(nativeDb.prepare("SELECT COUNT(*) AS cnt FROM brain_retrieval_log"))[0]?.cnt ?? 0;
-		uniqueEntriesRetrieved = typedAll(nativeDb.prepare(`SELECT COUNT(DISTINCT je.value) AS cnt
-         FROM brain_retrieval_log AS l,
-              json_each(
-                CASE
-                  WHEN json_valid(l.entry_ids) THEN l.entry_ids
-                  ELSE '["' || replace(l.entry_ids, ',', '","') || '"]'
-                END
-              ) AS je`))[0]?.cnt ?? 0;
-	} catch {}
-	let usageRate = 0;
-	try {
-		const totalUsage = typedAll(nativeDb.prepare("SELECT COUNT(*) AS cnt FROM brain_usage_log"));
-		const usedCount = typedAll(nativeDb.prepare("SELECT COUNT(*) AS cnt FROM brain_usage_log WHERE used = 1"));
-		const total = totalUsage[0]?.cnt ?? 0;
-		const used = usedCount[0]?.cnt ?? 0;
-		usageRate = total > 0 ? used / total : 0;
-	} catch {}
-	const topRetrieved = [];
-	try {
-		const rows = typedAll(nativeDb.prepare(`SELECT id,
-                'decision' AS type,
-                decision    AS title,
-                COALESCE(citation_count, 0) AS citation_count
-         FROM brain_decisions
-         UNION ALL
-         SELECT id,
-                'pattern'  AS type,
-                pattern     AS title,
-                COALESCE(citation_count, 0) AS citation_count
-         FROM brain_patterns
-         UNION ALL
-         SELECT id,
-                'learning' AS type,
-                insight     AS title,
-                COALESCE(citation_count, 0) AS citation_count
-         FROM brain_learnings
-         UNION ALL
-         SELECT id,
-                'observation' AS type,
-                title         AS title,
-                COALESCE(citation_count, 0) AS citation_count
-         FROM brain_observations
-         ORDER BY citation_count DESC
-         LIMIT 10`));
-		for (const r of rows) topRetrieved.push({
-			id: r.id,
-			type: r.type,
-			title: String(r.title ?? "").slice(0, 120),
-			citationCount: r.citation_count
-		});
-	} catch {}
-	const neverRetrieved = [];
-	try {
-		const rows = typedAll(nativeDb.prepare(`SELECT id,
-                'decision' AS type,
-                decision    AS title,
-                COALESCE(quality_score, 0.5) AS quality_score
-         FROM brain_decisions
-         WHERE COALESCE(citation_count, 0) = 0
-         UNION ALL
-         SELECT id,
-                'pattern'  AS type,
-                pattern     AS title,
-                COALESCE(quality_score, 0.5) AS quality_score
-         FROM brain_patterns
-         WHERE COALESCE(citation_count, 0) = 0
-         UNION ALL
-         SELECT id,
-                'learning' AS type,
-                insight     AS title,
-                COALESCE(quality_score, 0.5) AS quality_score
-         FROM brain_learnings
-         WHERE COALESCE(citation_count, 0) = 0
-         UNION ALL
-         SELECT id,
-                'observation' AS type,
-                title         AS title,
-                COALESCE(quality_score, 0.5) AS quality_score
-         FROM brain_observations
-         WHERE COALESCE(citation_count, 0) = 0
-         ORDER BY quality_score ASC
-         LIMIT 10`));
-		for (const r of rows) neverRetrieved.push({
-			id: r.id,
-			type: r.type,
-			title: String(r.title ?? "").slice(0, 120),
-			qualityScore: r.quality_score
-		});
-	} catch {}
-	let qualityDistribution = {
-		low: 0,
-		medium: 0,
-		high: 0
-	};
-	try {
-		const rows = typedAll(nativeDb.prepare(`SELECT
-           SUM(CASE WHEN qs < 0.3 THEN 1 ELSE 0 END)               AS low,
-           SUM(CASE WHEN qs >= 0.3 AND qs <= 0.6 THEN 1 ELSE 0 END) AS medium,
-           SUM(CASE WHEN qs > 0.6 THEN 1 ELSE 0 END)               AS high
-         FROM (
-           SELECT COALESCE(quality_score, 0.5) AS qs FROM brain_decisions
-           UNION ALL
-           SELECT COALESCE(quality_score, 0.5) AS qs FROM brain_patterns
-           UNION ALL
-           SELECT COALESCE(quality_score, 0.5) AS qs FROM brain_learnings
-           UNION ALL
-           SELECT COALESCE(quality_score, 0.5) AS qs FROM brain_observations
-         )`));
-		if (rows[0]) qualityDistribution = {
-			low: rows[0].low ?? 0,
-			medium: rows[0].medium ?? 0,
-			high: rows[0].high ?? 0
-		};
-	} catch {}
-	const tierDistribution = {
-		short: 0,
-		medium: 0,
-		long: 0,
-		unknown: 0
-	};
-	try {
-		const rows = typedAll(nativeDb.prepare(`SELECT memory_tier AS tier, COUNT(*) AS cnt
-         FROM (
-           SELECT memory_tier FROM brain_decisions
-           UNION ALL
-           SELECT memory_tier FROM brain_patterns
-           UNION ALL
-           SELECT memory_tier FROM brain_learnings
-           UNION ALL
-           SELECT memory_tier FROM brain_observations
-         )
-         GROUP BY memory_tier`));
-		for (const r of rows) {
-			const tier = r.tier?.toLowerCase() ?? "unknown";
-			if (tier === "short" || tier === "medium" || tier === "long") tierDistribution[tier] += r.cnt;
-			else tierDistribution.unknown += r.cnt;
-		}
-	} catch {}
-	const totalEntries = qualityDistribution.low + qualityDistribution.medium + qualityDistribution.high;
-	const noiseRatio = totalEntries > 0 ? qualityDistribution.low / totalEntries : 0;
-	return {
-		totalRetrievals,
-		uniqueEntriesRetrieved,
-		usageRate,
-		topRetrieved,
-		neverRetrieved,
-		qualityDistribution,
-		tierDistribution,
-		noiseRatio
-	};
-}
-
-export { correlateOutcomes, getMemoryQualityReport };
-//# sourceMappingURL=quality-feedback-CuCGEI6S.js.map