@mastra/factory 0.8.0-alpha.8 → 0.8.0

package/dist/routes/knowledge.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Read-only Mastra `apiRoutes` exposing the factory project's knowledge graph.
+ *
+ * Serves the Knowledge page in factory-ui: a polling graph snapshot (nodes
+ * as nodes, wikilink edges derived from record text), a node flyout payload
+ * with per-record provenance, and the recent activity feed. Every endpoint is a
+ * GET — this module never writes knowledge.
+ *
+ * Scoping is fail-closed: the org and resource rungs are derived server-side
+ * from the authenticated caller and the validated `:id` project. The DEFAULT
+ * view queries `[org:<orgId>, resource:<projectId>]` (org + project records).
+ * Thread-scoped records are reachable ONLY via an explicit, server-validated
+ * `threadId` query parameter (the drill-down view), which appends the thread
+ * rung to the query scope. A thread is drillable iff it produced knowledge
+ * visible under the caller's org/project prefix; unknown or cross-org threads
+ * 404 — never a silent fallback to the default view.
+ */
+import type { ApiRoute } from '@mastra/core/server';
+import type { KnowledgeScope, KnowledgeStorage } from '@mastra/core/storage';
+import type { FactoryProjectsStorage } from '../storage/domains/projects/base.js';
+import type { RouteDependencies } from './route.js';
+import { Route } from './route.js';
+/** Window caps. Injectable at construction only — never per-request. */
+export interface KnowledgeRouteLimits {
+    /** Max nodes in a graph snapshot (newest-first). */
+    maxNodes: number;
+    /** Max records parsed for edges per snapshot (newest-first). */
+    maxRecords: number;
+    /** Max fallback `resolveNode` store lookups per request (deduped per unique name+scope). */
+    maxFallbackLookups: number;
+}
+export interface KnowledgeRoutesDeps extends RouteDependencies {
+    /** Factory projects domain — validates the `:id` project belongs to the caller's org. */
+    projects: FactoryProjectsStorage;
+    /** Lazy handle to the knowledge storage domain; endpoints 503 when absent. */
+    knowledge: () => Promise<KnowledgeStorage | undefined>;
+    limits?: Partial<KnowledgeRouteLimits>;
+}
+/** A graph node. `recordCount` is window-derived (records inside the snapshot window only). */
+export interface KnowledgeGraphNode {
+    id: string;
+    name: string;
+    kind: string;
+    scope: KnowledgeScope;
+    /** Deepest rung of the record's scope: org | resource | thread. */
+    rung: 'org' | 'resource' | 'thread';
+    /**
+     * True when a non-deleted pinned record's wikilinks reference ONLY this
+     * node (A9: multi-target pins mark their edges instead — the pin is
+     * about the relationship; a single-target pin has no edge to carry it).
+     */
+    pinned: boolean;
+    /** Records owned by this node INSIDE the snapshot window (not a total). */
+    recordCount: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface KnowledgeGraphEdge {
+    id: string;
+    /** The owning node of the record (its `node`). */
+    source: string;
+    /** The wikilink-resolved node. */
+    target: string;
+    /**
+     * Always 'wikilink': the record's `node` is the edge SOURCE, so the
+     * plan's "parent link" collapses into the wikilink edge — nodes carry no
+     * separate parent field to derive a second edge type from.
+     */
+    type: 'wikilink';
+    /** The record whose text produced the edge. */
+    recordId: string;
+    /**
+     * True when the edge is derived from a PINNED record linking two nodes —
+     * the pin marks the relationship, so the accent lives on the edge (A9).
+     */
+    pinned?: boolean;
+}
+/**
+ * A knowledge record as a first-class graph element (A11): every record in the window,
+ * with the in-window nodes it touches. The client renders by arity —
+ * 1 node: a small dot linked to it; 2: the connecting line; 3+: a midpoint
+ * junction splitting to each node. Pin records have their hidden reserved
+ * owner omitted, so their arity comes purely from wikilink targets.
+ */
+export interface KnowledgeGraphRecord {
+    /** The record id. */
+    id: string;
+    /** Owner node first (omitted for pins), then resolved wikilink targets. */
+    nodeIds: string[];
+    pinned: boolean;
+    /** Record text, truncated for hover cards. */
+    text: string;
+}
+export interface KnowledgeGraphPayload {
+    view: 'project' | 'thread';
+    threadId?: string;
+    nodes: KnowledgeGraphNode[];
+    edges: KnowledgeGraphEdge[];
+    records: KnowledgeGraphRecord[];
+    /** True when the node or record window cap was hit (newest-first window). */
+    truncated: boolean;
+    /** Wikilink targets that resolved in the store but fell outside the node window. */
+    outOfWindow: Array<{
+        id: string;
+        name: string;
+    }>;
+    /** Unique unknown names skipped once the fallback-lookup cap was hit. */
+    unresolvedCapped: {
+        count: number;
+        names: string[];
+    };
+    /** Pin counts per rung of the active view (thread is null in the default view). */
+    pinCensus: {
+        resource: number;
+        thread: number | null;
+    };
+    /** Change hint: newest knowledge activity id (per-process monotonic — hint only). */
+    version: string | null;
+}
+export interface KnowledgeNodeRecordPayload {
+    id: string;
+    node: string;
+    /** 'owned' when the node is the record's parent, 'mentions' when it only wikilinks it. */
+    relation: 'owned' | 'mentions';
+    text: string;
+    scope: KnowledgeScope;
+    rung: 'org' | 'resource' | 'thread';
+    sourceThreadId: string;
+    capturedAt: string;
+    when?: string;
+    pinned: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface KnowledgeNodePayload {
+    node: {
+        id: string;
+        name: string;
+        kind: string;
+        content: string;
+        scope: KnowledgeScope;
+        rung: 'org' | 'resource' | 'thread';
+        createdAt: string;
+        updatedAt: string;
+    };
+    records: KnowledgeNodeRecordPayload[];
+}
+export declare class KnowledgeRoutes extends Route<KnowledgeRoutesDeps> {
+    #private;
+    constructor(deps: KnowledgeRoutesDeps);
+    routes(): ApiRoute[];
+}
+//# sourceMappingURL=knowledge.d.ts.map

package/dist/routes/knowledge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge.d.ts","sourceRoot":"","sources":["../../src/routes/knowledge.ts"],"names":[],"mappings":"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"}

package/dist/routes/knowledge.js

@@ -0,0 +1,442 @@
+import { Route } from "./route.js";
+import { registerApiRoute } from "@mastra/core/server";
+import { canonicalizeKnowledgeScope, isKnowledgeScopeVisible, knowledgeScopeKey, parseKnowledgeWikilinks } from "@mastra/core/storage";
+//#region src/routes/knowledge.ts
+/** Reserved node that anchors pinned records (see subconscious/pinned.ts). */
+const PINNED_NODE_NAME = "pinned";
+/** Hover-card budget for record text shipped in the graph payload. */
+const RECORD_TEXT_LIMIT = 240;
+function truncateRecordText(text) {
+	return text.length > RECORD_TEXT_LIMIT ? `${text.slice(0, RECORD_TEXT_LIMIT - 1)}…` : text;
+}
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const DEFAULT_LIMITS = {
+	maxNodes: 500,
+	maxRecords: 2e3,
+	maxFallbackLookups: 100
+};
+function loose(c) {
+	return c;
+}
+function deepestRung(scope) {
+	let rung = "org";
+	for (const entry of scope) {
+		const ns = entry.slice(0, entry.indexOf(":"));
+		if (ns === "thread") return "thread";
+		if (ns === "resource") rung = "resource";
+	}
+	return rung;
+}
+function boundedThreadId(raw) {
+	if (!raw) return void 0;
+	const trimmed = raw.trim();
+	return trimmed.length > 0 && trimmed.length <= 512 ? trimmed : void 0;
+}
+/**
+* In-record + capped-fallback wikilink resolver, shared by both endpoints.
+* Resolution uses the store's own algorithm: a descending-prefix walk over the
+* record's canonical scope matching canonical name + exact scope key at each
+* prefix, so an edge never depends on whether the target landed in the window.
+*/
+var WikilinkResolver = class {
+	/** exact `${scopeKey}\u0000${lowerName}` → node, from the fetched window. */
+	#inWindow = /* @__PURE__ */ new Map();
+	#windowIds = /* @__PURE__ */ new Set();
+	/** `${recordScopeKey}\u0000${lowerName}` → fallback result (null = dangling). */
+	#fallbackCache = /* @__PURE__ */ new Map();
+	#fallbackLookups = 0;
+	#store;
+	#maxFallbackLookups;
+	outOfWindow = /* @__PURE__ */ new Map();
+	cappedNames = [];
+	#cappedSeen = /* @__PURE__ */ new Set();
+	constructor(store, nodes, maxFallbackLookups) {
+		this.#store = store;
+		this.#maxFallbackLookups = maxFallbackLookups;
+		for (const node of nodes) {
+			this.#inWindow.set(`${knowledgeScopeKey(node.scope)}\u0000${node.name.trim().toLocaleLowerCase()}`, node);
+			this.#windowIds.add(node.id);
+		}
+	}
+	inWindowId(id) {
+		return this.#windowIds.has(id);
+	}
+	/** Resolve a wikilink name from a knowledge record's scope. Returns the node or null (dangling/capped). */
+	async resolve(name, recordScope) {
+		const canonical = canonicalizeKnowledgeScope(recordScope);
+		const lower = name.trim().toLocaleLowerCase();
+		for (let length = canonical.length; length > 0; length--) {
+			const hit = this.#inWindow.get(`${knowledgeScopeKey(canonical.slice(0, length))}\u0000${lower}`);
+			if (hit) return hit;
+		}
+		const cacheKey = `${knowledgeScopeKey(canonical)}\u0000${lower}`;
+		if (this.#fallbackCache.has(cacheKey)) return this.#trackOutOfWindow(this.#fallbackCache.get(cacheKey) ?? null);
+		if (this.#fallbackLookups >= this.#maxFallbackLookups) {
+			if (!this.#cappedSeen.has(lower) && this.cappedNames.length < 100) {
+				this.#cappedSeen.add(lower);
+				this.cappedNames.push(name.trim());
+			} else if (!this.#cappedSeen.has(lower)) this.#cappedSeen.add(lower);
+			return null;
+		}
+		this.#fallbackLookups += 1;
+		let resolved = null;
+		try {
+			resolved = await this.#store.resolveNode({
+				name,
+				scope: canonical
+			});
+		} catch {
+			resolved = null;
+		}
+		this.#fallbackCache.set(cacheKey, resolved);
+		return this.#trackOutOfWindow(resolved);
+	}
+	#trackOutOfWindow(node) {
+		if (node && !this.#windowIds.has(node.id)) this.outOfWindow.set(node.id, {
+			id: node.id,
+			name: node.name
+		});
+		return node;
+	}
+	get cappedCount() {
+		return this.#cappedSeen.size;
+	}
+};
+var KnowledgeRoutes = class extends Route {
+	#limits;
+	constructor(deps) {
+		super(deps);
+		this.#limits = {
+			...DEFAULT_LIMITS,
+			...deps.limits
+		};
+	}
+	/** Resolve the `(orgId, userId)` tenant or a ready-to-return error response. */
+	async #resolveTenant(c) {
+		await this.deps.auth.ensureUser(c);
+		const tenant = this.deps.auth.tenant(c);
+		if (!tenant) return { response: c.json({ error: "unauthorized" }, 401) };
+		if (!tenant.orgId) return { response: c.json({
+			error: "organization_required",
+			message: "The knowledge graph requires an organization."
+		}, 403) };
+		return {
+			orgId: tenant.orgId,
+			userId: tenant.userId
+		};
+	}
+	/**
+	* Resolve tenant + org-owned project + knowledge store + the active view's
+	* query scope. The ONE seam both endpoints share, so the default/thread view
+	* scope and the pin rungs cannot drift between them.
+	*
+	* threadId validation runs a single `listRecordsBySource` lookup with
+	* `limit: 1` AT THE CANDIDATE SCOPE `[org, resource, thread:<id>]` — the
+	* store's own visibility predicate is the authorization: the thread's own
+	* records (equal scope key) and its project/org captures (prefix) match, while
+	* a cross-org thread's records match nothing → zero rows → 404.
+	*/
+	async #resolveView(c) {
+		const tenant = await this.#resolveTenant(c);
+		if ("response" in tenant) return tenant;
+		const projectId = c.req.param("id");
+		if (!projectId || !UUID_RE.test(projectId)) return { response: c.json({ error: "Project not found" }, 404) };
+		const { projects } = this.deps;
+		await projects.ensureReady();
+		if (!await projects.get({
+			orgId: tenant.orgId,
+			id: projectId
+		})) return { response: c.json({ error: "Project not found" }, 404) };
+		const store = await this.deps.knowledge();
+		if (!store) return { response: c.json({
+			error: "knowledge_unavailable",
+			message: "The knowledge storage domain is not configured."
+		}, 503) };
+		const defaultScope = [`org:${tenant.orgId}`, `resource:${projectId}`];
+		const resourceRungScope = defaultScope;
+		const threadId = boundedThreadId(c.req.query("threadId"));
+		if (c.req.query("threadId") !== void 0 && !threadId) return { response: c.json({ error: "thread_not_found" }, 404) };
+		if (!threadId) return {
+			...tenant,
+			factoryProjectId: projectId,
+			store,
+			view: "project",
+			scope: defaultScope,
+			pinRungs: [{
+				rung: "resource",
+				scope: resourceRungScope
+			}]
+		};
+		const candidateScope = [...defaultScope, `thread:${threadId}`];
+		if ((await store.knowledgeBySource({
+			sourceThreadId: threadId,
+			scope: candidateScope,
+			limit: 1
+		})).records.length === 0) return { response: c.json({ error: "thread_not_found" }, 404) };
+		return {
+			...tenant,
+			factoryProjectId: projectId,
+			store,
+			view: "thread",
+			threadId,
+			scope: candidateScope,
+			pinRungs: [{
+				rung: "resource",
+				scope: resourceRungScope
+			}, {
+				rung: "thread",
+				scope: candidateScope
+			}]
+		};
+	}
+	/** Reserved `pinned` node ids at the active view's rungs (one exact-scope lookup per rung). */
+	async #pinnedNodeIds(view) {
+		const out = [];
+		for (const { rung, scope } of view.pinRungs) {
+			const node = await view.store.getNodeByName({
+				name: PINNED_NODE_NAME,
+				scope
+			});
+			if (node && !node.mergedInto) out.push({
+				rung,
+				id: node.id
+			});
+		}
+		return out;
+	}
+	/** Non-deleted pinned records for the given pinned-node ids, visible in the view. */
+	async #pinnedRecords(view, pinnedNodeIds) {
+		const out = [];
+		for (const { rung, id } of pinnedNodeIds) {
+			const { records } = await view.store.listKnowledgeAbout({
+				node: id,
+				scope: view.scope,
+				limit: 200
+			});
+			for (const record of records) out.push({
+				rung,
+				record
+			});
+		}
+		return out;
+	}
+	routes() {
+		return [
+			registerApiRoute("/web/factory/projects/:id/knowledge/graph", {
+				method: "GET",
+				requiresAuth: false,
+				handler: async (c) => {
+					const view = await this.#resolveView(loose(c));
+					if ("response" in view) return view.response;
+					const { store, scope } = view;
+					const limits = this.#limits;
+					const fetched = await store.listNodes({
+						scope,
+						limit: limits.maxNodes + 1
+					});
+					let truncated = fetched.length > limits.maxNodes;
+					const pinnedNodeIds = await this.#pinnedNodeIds(view);
+					const pinnedNodeIdSet = new Set(pinnedNodeIds.map((p) => p.id));
+					const nodes = fetched.slice(0, limits.maxNodes).filter((node) => !pinnedNodeIdSet.has(node.id));
+					const recordWindow = [];
+					for (const node of nodes) {
+						if (recordWindow.length > limits.maxRecords) break;
+						const { records } = await store.listKnowledgeAbout({
+							node: node.id,
+							scope,
+							limit: limits.maxRecords + 1 - recordWindow.length
+						});
+						recordWindow.push(...records);
+					}
+					recordWindow.sort((a, b) => b.id.localeCompare(a.id));
+					if (recordWindow.length > limits.maxRecords) {
+						truncated = true;
+						recordWindow.length = limits.maxRecords;
+					}
+					const resolver = new WikilinkResolver(store, nodes, limits.maxFallbackLookups);
+					const edges = [];
+					const graphRecords = [];
+					const edgeSeen = /* @__PURE__ */ new Set();
+					const recordCounts = /* @__PURE__ */ new Map();
+					for (const record of recordWindow) {
+						recordCounts.set(record.node, (recordCounts.get(record.node) ?? 0) + 1);
+						const nodeIds = [record.node];
+						for (const name of parseKnowledgeWikilinks(record.text)) {
+							const target = await resolver.resolve(name, record.scope);
+							if (!target) continue;
+							if (target.id === record.node) continue;
+							if (!resolver.inWindowId(target.id)) continue;
+							if (!nodeIds.includes(target.id)) nodeIds.push(target.id);
+							const key = `${record.node}\u0000${target.id}`;
+							if (edgeSeen.has(key)) continue;
+							edgeSeen.add(key);
+							edges.push({
+								id: `wikilink:${record.node}:${target.id}`,
+								source: record.node,
+								target: target.id,
+								type: "wikilink",
+								recordId: record.id
+							});
+						}
+						graphRecords.push({
+							id: record.id,
+							nodeIds,
+							pinned: false,
+							text: truncateRecordText(record.text)
+						});
+					}
+					const pinnedRecords = await this.#pinnedRecords(view, pinnedNodeIds);
+					const accented = /* @__PURE__ */ new Set();
+					for (const { record } of pinnedRecords) {
+						const targets = [];
+						for (const name of parseKnowledgeWikilinks(record.text)) {
+							const target = await resolver.resolve(name, record.scope);
+							if (target && resolver.inWindowId(target.id) && !targets.includes(target.id)) targets.push(target.id);
+						}
+						graphRecords.push({
+							id: record.id,
+							nodeIds: targets,
+							pinned: true,
+							text: truncateRecordText(record.text)
+						});
+						if (targets.length === 1) {
+							accented.add(targets[0]);
+							continue;
+						}
+						for (let a = 0; a < targets.length; a += 1) for (let b = a + 1; b < targets.length; b += 1) {
+							const key = `${targets[a]}\u0000${targets[b]}\u0000pin`;
+							if (edgeSeen.has(key)) continue;
+							edgeSeen.add(key);
+							edges.push({
+								id: `pin:${record.id}:${targets[a]}:${targets[b]}`,
+								source: targets[a],
+								target: targets[b],
+								type: "wikilink",
+								recordId: record.id,
+								pinned: true
+							});
+						}
+					}
+					const pinCensus = {
+						resource: pinnedRecords.filter((p) => p.rung === "resource").length,
+						thread: view.view === "thread" ? pinnedRecords.filter((p) => p.rung === "thread").length : null
+					};
+					const activity = await store.listActivity({
+						scope,
+						limit: 1
+					});
+					const payload = {
+						view: view.view,
+						...view.threadId ? { threadId: view.threadId } : {},
+						nodes: nodes.map((node) => ({
+							id: node.id,
+							name: node.name,
+							kind: node.kind,
+							scope: node.scope,
+							rung: deepestRung(node.scope),
+							pinned: accented.has(node.id),
+							recordCount: recordCounts.get(node.id) ?? 0,
+							createdAt: node.createdAt.toISOString(),
+							updatedAt: node.updatedAt.toISOString()
+						})),
+						edges,
+						records: graphRecords,
+						truncated,
+						outOfWindow: [...resolver.outOfWindow.values()],
+						unresolvedCapped: {
+							count: resolver.cappedCount,
+							names: resolver.cappedNames
+						},
+						pinCensus,
+						version: activity[0]?.id ?? null
+					};
+					return c.json(payload);
+				}
+			}),
+			registerApiRoute("/web/factory/projects/:id/knowledge/nodes/:nodeId", {
+				method: "GET",
+				requiresAuth: false,
+				handler: async (c) => {
+					const view = await this.#resolveView(loose(c));
+					if ("response" in view) return view.response;
+					const { store, scope } = view;
+					const nodeId = loose(c).req.param("nodeId");
+					if (!nodeId || nodeId.length > 512) return c.json({ error: "node_not_found" }, 404);
+					const node = await store.getNode(nodeId);
+					if (!node || !isKnowledgeScopeVisible(node.scope, scope)) return c.json({ error: "node_not_found" }, 404);
+					const pinnedNodeIds = await this.#pinnedNodeIds(view);
+					const pinnedNodeIdSet = new Set(pinnedNodeIds.map((p) => p.id));
+					const [owned, mentioning] = await Promise.all([store.listKnowledgeAbout({
+						node: node.id,
+						scope,
+						limit: 200
+					}), store.listKnowledgeMentioning({
+						node: node.id,
+						scope,
+						limit: 200
+					})]);
+					const seen = /* @__PURE__ */ new Set();
+					const records = [];
+					const push = (record, relation) => {
+						if (seen.has(record.id)) return;
+						seen.add(record.id);
+						records.push({
+							id: record.id,
+							node: record.node,
+							relation,
+							text: record.text,
+							scope: record.scope,
+							rung: deepestRung(record.scope),
+							sourceThreadId: record.sourceThreadId,
+							capturedAt: record.capturedAt.toISOString(),
+							...record.when ? { when: record.when.toISOString() } : {},
+							pinned: pinnedNodeIdSet.has(record.node),
+							...record.metadata ? { metadata: record.metadata } : {}
+						});
+					};
+					for (const record of [...owned.records].sort((a, b) => b.id.localeCompare(a.id))) push(record, "owned");
+					for (const record of [...mentioning.records].sort((a, b) => b.id.localeCompare(a.id))) push(record, "mentions");
+					const payload = {
+						node: {
+							id: node.id,
+							name: node.name,
+							kind: node.kind,
+							content: node.content ?? "",
+							scope: node.scope,
+							rung: deepestRung(node.scope),
+							createdAt: node.createdAt.toISOString(),
+							updatedAt: node.updatedAt.toISOString()
+						},
+						records
+					};
+					return c.json(payload);
+				}
+			}),
+			registerApiRoute("/web/factory/projects/:id/knowledge/activity", {
+				method: "GET",
+				requiresAuth: false,
+				handler: async (c) => {
+					const view = await this.#resolveView(loose(c));
+					if ("response" in view) return view.response;
+					const events = await view.store.listActivity({
+						scope: view.scope,
+						limit: 100
+					});
+					return c.json({ events: events.map((event) => ({
+						id: event.id,
+						action: event.action,
+						recordType: event.recordType,
+						recordId: event.recordId,
+						scope: event.scope,
+						...event.sourceThreadId ? { sourceThreadId: event.sourceThreadId } : {},
+						createdAt: event.createdAt.toISOString()
+					})) });
+				}
+			})
+		];
+	}
+};
+//#endregion
+export { KnowledgeRoutes };
+
+//# sourceMappingURL=knowledge.js.map