@happyvertical/smrt-workbench 0.40.66

package/dist/chunks/discovery-G9-foyW8.js

@@ -0,0 +1,979 @@
+import { c as commandIdForScript, t as coerceWorkbenchModules } from "./runtime-BTiu5fuP.js";
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import fg from "fast-glob";
+//#region src/discovery.ts
+var require = createRequire(import.meta.url);
+var TS_SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".ts",
+	".tsx",
+	".mts",
+	".cts"
+]);
+var DOCUMENT_LIMIT = 2e4;
+var EXAMPLE_LIMIT = 8e3;
+function findWorkspaceRoot(startDir = process.cwd()) {
+	let current = resolve(startDir);
+	while (true) {
+		if (existsSync(join(current, "pnpm-workspace.yaml"))) return current;
+		const parent = dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+function findSmrtWorkbenchWorkspaceRoot(startDir = process.cwd()) {
+	const workspaceRoot = findWorkspaceRoot(startDir);
+	if (!workspaceRoot) return null;
+	return existsSync(join(workspaceRoot, "packages", "smrt-workbench", "host", "package.json")) ? workspaceRoot : null;
+}
+function findProjectRoot(startDir = process.cwd()) {
+	let current = resolve(startDir);
+	while (true) {
+		if (existsSync(join(current, "package.json"))) return current;
+		const parent = dirname(current);
+		if (parent === current) return resolve(startDir);
+		current = parent;
+	}
+}
+function findPackageDir(startDir = process.cwd(), workspaceRoot) {
+	let current = resolve(startDir);
+	const boundary = workspaceRoot ? resolve(workspaceRoot) : null;
+	while (true) {
+		if (boundary && current === boundary) return null;
+		if (existsSync(join(current, "package.json"))) return current;
+		const parent = dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+function detectWorkbenchMode(projectRoot = process.cwd()) {
+	return findSmrtWorkbenchWorkspaceRoot(projectRoot) ? "workspace" : "consumer";
+}
+function readJson(path) {
+	return JSON.parse(readFileSync(path, "utf-8"));
+}
+function readJsonIfExists(path) {
+	return existsSync(path) ? readJson(path) : null;
+}
+function detectPackageManager(projectRoot) {
+	let current = resolve(projectRoot);
+	while (true) {
+		if (existsSync(join(current, "pnpm-lock.yaml"))) return "pnpm";
+		if (existsSync(join(current, "yarn.lock"))) return "yarn";
+		const packageManager = readJsonIfExists(join(current, "package.json"))?.packageManager;
+		if (packageManager?.startsWith("pnpm@")) return "pnpm";
+		if (packageManager?.startsWith("yarn@")) return "yarn";
+		if (packageManager?.startsWith("npm@")) return "npm";
+		const parent = dirname(current);
+		if (parent === current) return "npm";
+		current = parent;
+	}
+}
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function stringRecord(value) {
+	if (!isRecord(value)) return {};
+	return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"));
+}
+function countItems(value) {
+	if (Array.isArray(value)) return value.length;
+	if (isRecord(value)) return Object.keys(value).length;
+	return 0;
+}
+function truncate(value, limit) {
+	if (value.length <= limit) return {
+		content: value,
+		truncated: false
+	};
+	return {
+		content: value.slice(0, limit),
+		truncated: true
+	};
+}
+function readDocument(packageDir, fileName, kind) {
+	const path = join(packageDir, fileName);
+	if (!existsSync(path)) return null;
+	const { content, truncated } = truncate(readFileSync(path, "utf-8"), DOCUMENT_LIMIT);
+	return {
+		kind,
+		title: fileName,
+		path,
+		content,
+		truncated
+	};
+}
+function exportKeys(exportsField) {
+	if (!exportsField) return [];
+	if (typeof exportsField === "string") return ["."];
+	if (isRecord(exportsField)) return Object.keys(exportsField).sort();
+	return [];
+}
+function dependencyNames(packageJson) {
+	return Object.keys({
+		...packageJson.dependencies,
+		...packageJson.devDependencies,
+		...packageJson.peerDependencies
+	}).sort();
+}
+function smrtDependencyNames(packageJson) {
+	return dependencyNames(packageJson).filter((name) => name.startsWith("@happyvertical/smrt-"));
+}
+function sdkDependencyNames(packageJson) {
+	return dependencyNames(packageJson).filter((name) => name.startsWith("@happyvertical/") && !name.startsWith("@happyvertical/smrt-"));
+}
+function readKnowledgeSummary(packageDir) {
+	const knowledgeCandidates = [join(packageDir, ".smrt", "smrt-knowledge.json"), join(packageDir, "dist", "smrt-knowledge.json")];
+	const manifestCandidates = [
+		join(packageDir, ".smrt", "manifest.json"),
+		join(packageDir, "dist", "manifest.json"),
+		join(packageDir, "src", "manifest", "manifest.json")
+	];
+	const knowledgePath = knowledgeCandidates.find((path) => existsSync(path));
+	const manifestPath = manifestCandidates.find((path) => existsSync(path));
+	const knowledge = knowledgePath ? readJsonIfExists(knowledgePath) : null;
+	const manifest = manifestPath ? readJsonIfExists(manifestPath) : null;
+	const knowledgeObjects = knowledge?.objects;
+	const manifestObjects = manifest?.objects;
+	const objects = countItems(knowledgeObjects) > 0 ? knowledgeObjects : manifestObjects;
+	const objectNames = objectNamesFrom(objects);
+	return {
+		manifestPath,
+		knowledgePath,
+		objectCount: countItems(objects),
+		relationshipCount: countItems(knowledge?.relationshipsV2) || countItems(knowledge?.relationships),
+		promptCount: countItems(knowledge?.prompts),
+		mcpToolCount: countItems(knowledge?.mcpTools),
+		surfaceCount: countItems(knowledge?.surfaces),
+		tags: Array.isArray(knowledge?.tags) ? knowledge.tags.filter((tag) => typeof tag === "string") : [],
+		risks: Array.isArray(knowledge?.risks) ? knowledge.risks.filter((risk) => typeof risk === "string") : [],
+		objectNames
+	};
+}
+function objectNamesFrom(value) {
+	if (Array.isArray(value)) return value.map((item) => {
+		if (!isRecord(item)) return null;
+		return stringValue(item.qualifiedName) || stringValue(item.name);
+	}).filter((name) => Boolean(name)).sort();
+	if (isRecord(value)) return Object.keys(value).sort();
+	return [];
+}
+function stringValue(value) {
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+function booleanValue(value) {
+	return typeof value === "boolean" ? value : void 0;
+}
+function objectRecordsFrom(value) {
+	if (Array.isArray(value)) return value.filter(isRecord);
+	if (!isRecord(value)) return [];
+	return Object.entries(value).map(([key, item]) => {
+		if (isRecord(item)) return {
+			key,
+			...item
+		};
+		return {
+			key,
+			name: key
+		};
+	});
+}
+function fieldSummariesFrom(value) {
+	if (Array.isArray(value)) return value.filter(isRecord).map((field) => ({
+		name: stringValue(field.name) || "unknown",
+		type: stringValue(field.type) || void 0,
+		required: booleanValue(field.required),
+		related: stringValue(field.related) || void 0
+	})).filter((field) => field.name !== "unknown");
+	if (!isRecord(value)) return [];
+	return Object.entries(value).map(([name, field]) => {
+		const fieldRecord = isRecord(field) ? field : {};
+		return {
+			name,
+			type: stringValue(fieldRecord.type) || void 0,
+			required: booleanValue(fieldRecord.required),
+			related: stringValue(fieldRecord.related) || void 0
+		};
+	}).sort((left, right) => left.name.localeCompare(right.name));
+}
+function resolveManifestSourcePath(rootDir, packageDir, sourcePath) {
+	if (!sourcePath) return;
+	if (isAbsolute(sourcePath)) return sourcePath;
+	const rootRelativePath = resolve(rootDir, sourcePath);
+	if (existsSync(rootRelativePath)) return rootRelativePath;
+	return resolve(packageDir, sourcePath);
+}
+function typedocPackageSlug(packageName) {
+	if (!packageName?.startsWith("@happyvertical/smrt-")) return null;
+	return packageName.replace("@happyvertical/smrt-", "");
+}
+function findTypedocClassPath(rootDir, packageDir, packageName, className) {
+	const slug = typedocPackageSlug(packageName);
+	return [
+		slug ? join(rootDir, "docs", "content", "api", slug, "classes", `${className}.md`) : null,
+		join(packageDir, "docs", "classes", `${className}.md`),
+		join(packageDir, "docs", `${className}.md`)
+	].filter((path) => Boolean(path)).find((path) => existsSync(path));
+}
+function extractTypedocSummary(content) {
+	const lines = content.split(/\r?\n/);
+	const summary = [];
+	let hasSeenTitle = false;
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!hasSeenTitle) {
+			if (trimmed.startsWith("# ")) hasSeenTitle = true;
+			continue;
+		}
+		if (!trimmed || trimmed.startsWith("Defined in:")) continue;
+		if (trimmed.startsWith("## ")) break;
+		if (trimmed.startsWith("> ")) continue;
+		summary.push(trimmed);
+	}
+	const value = summary.join("\n").trim();
+	return value.length > 0 ? value : void 0;
+}
+function readTypedocSummary(path) {
+	if (!path) return;
+	return extractTypedocSummary(readFileSync(path, "utf-8"));
+}
+var CRUD_ACTIONS = [
+	"list",
+	"get",
+	"create",
+	"update",
+	"delete"
+];
+var SERVER_MANAGED_FIELDS = /* @__PURE__ */ new Set([
+	"id",
+	"tenantId",
+	"tenant_id",
+	"createdAt",
+	"created_at",
+	"updatedAt",
+	"updated_at"
+]);
+function arrayOfStrings(value) {
+	return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function configObject(value) {
+	return isRecord(value) ? value : {};
+}
+function parameterRequired(value) {
+	if (typeof value.required === "boolean") return value.required;
+	const meta = configObject(value._meta);
+	return typeof meta.required === "boolean" ? meta.required : void 0;
+}
+function parameterDescription(value) {
+	return stringValue(value.description) || stringValue(configObject(value._meta).description) || void 0;
+}
+function parameterDefaultValue(value) {
+	if (!Object.hasOwn(value, "default")) return;
+	const defaultValue = value.default;
+	if (typeof defaultValue === "string" || typeof defaultValue === "number" || typeof defaultValue === "boolean") return String(defaultValue);
+	if (defaultValue === null) return "null";
+	try {
+		return JSON.stringify(defaultValue);
+	} catch {
+		return;
+	}
+}
+function fieldParameter(name, field, location, requiredOverride) {
+	return {
+		name,
+		type: stringValue(field.type) || void 0,
+		required: requiredOverride ?? parameterRequired(field),
+		location,
+		description: parameterDescription(field),
+		defaultValue: parameterDefaultValue(field)
+	};
+}
+function writableFieldEntries(object) {
+	const fields = configObject(object.fields);
+	const apiConfig = configObject(configObject(object.decoratorConfig).api);
+	const writableAllowlist = new Set(arrayOfStrings(apiConfig.writable));
+	const hasWritableAllowlist = writableAllowlist.size > 0;
+	return Object.entries(fields).filter((entry) => isRecord(entry[1])).filter(([name, field]) => {
+		if (name.startsWith("_")) return false;
+		if (SERVER_MANAGED_FIELDS.has(name)) return false;
+		if (field.readonly === true || configObject(field._meta).readonly === true) return false;
+		return !hasWritableAllowlist || writableAllowlist.has(name);
+	}).sort(([left], [right]) => left.localeCompare(right));
+}
+function writableFieldParameters(object, location, requiredMode) {
+	return writableFieldEntries(object).map(([name, field]) => fieldParameter(name, field, location, requiredMode === "field" ? parameterRequired(field) : false));
+}
+function methodParameterSummaries(object, action, location) {
+	const parameters = methodDefinition(object, action).parameters;
+	if (!Array.isArray(parameters)) return [];
+	return parameters.filter(isRecord).map((parameter) => ({
+		name: stringValue(parameter.name) || "parameter",
+		type: stringValue(parameter.type) || void 0,
+		required: parameter.optional !== true,
+		location,
+		description: parameterDescription(parameter),
+		defaultValue: parameterDefaultValue(parameter)
+	}));
+}
+function pathParameterNames(path) {
+	return Array.from(path.matchAll(/\{([^}]+)\}/g)).map((match) => match[1]?.trim()).filter((name) => Boolean(name));
+}
+function pathParameters(path) {
+	return pathParameterNames(path).map((name) => ({
+		name,
+		type: "string",
+		required: true,
+		location: "path"
+	}));
+}
+function restCrudParameters(object, action, path) {
+	if (action === "list") return [{
+		name: "limit",
+		type: "integer",
+		required: false,
+		location: "query",
+		description: "Maximum number of items to return.",
+		defaultValue: "50"
+	}, {
+		name: "offset",
+		type: "integer",
+		required: false,
+		location: "query",
+		description: "Number of items to skip.",
+		defaultValue: "0"
+	}];
+	if (action === "create") return writableFieldParameters(object, "body", "field");
+	if (action === "update") return [...pathParameters(path), ...writableFieldParameters(object, "body", "optional")];
+	return pathParameters(path);
+}
+function restCustomParameters(object, action, method, path) {
+	const pathParams = pathParameters(path);
+	const pathParamNameSet = new Set(pathParams.map((param) => param.name));
+	const bodyOrQueryParams = methodParameterSummaries(object, action, method === "GET" ? "query" : "body").filter((param) => !pathParamNameSet.has(param.name));
+	return [...pathParams, ...bodyOrQueryParams];
+}
+function cliCrudParameters(object, action) {
+	if (action === "list") return [
+		{
+			name: "--limit",
+			type: "integer",
+			required: false,
+			location: "option",
+			description: "Maximum number of items to return.",
+			defaultValue: "50"
+		},
+		{
+			name: "--offset",
+			type: "integer",
+			required: false,
+			location: "option",
+			description: "Number of items to skip.",
+			defaultValue: "0"
+		},
+		{
+			name: "--order-by",
+			type: "string",
+			required: false,
+			location: "option",
+			description: "Ordering expression, for example \"created_at DESC\"."
+		},
+		{
+			name: "--where",
+			type: "object",
+			required: false,
+			location: "option",
+			description: "JSON filter conditions."
+		}
+	];
+	if (action === "get" || action === "delete") return [{
+		name: "id",
+		type: "string",
+		required: true,
+		location: "argument",
+		description: "Object ID. May also be passed as --id."
+	}];
+	const bodyParameters = writableFieldParameters(object, "option", action === "create" ? "field" : "optional").map((param) => ({
+		...param,
+		name: `--${param.name}`
+	}));
+	if (action === "create") return [{
+		name: "--from-file",
+		type: "path",
+		required: false,
+		location: "option",
+		description: "Path to a JSON object payload."
+	}, ...bodyParameters];
+	return [
+		{
+			name: "id",
+			type: "string",
+			required: true,
+			location: "argument",
+			description: "Object ID. May also be passed as --id."
+		},
+		{
+			name: "--from-file",
+			type: "path",
+			required: false,
+			location: "option",
+			description: "Path to a JSON object payload."
+		},
+		...bodyParameters
+	];
+}
+function cliCustomParameters(object, action) {
+	return [{
+		name: "id",
+		type: "string",
+		required: false,
+		location: "argument",
+		description: "Optional object ID for instance actions. May also be passed as --id."
+	}, ...methodParameterSummaries(object, action, "option").map((param) => ({
+		...param,
+		name: `--${param.name}`,
+		required: false
+	}))];
+}
+function mcpCrudParameters(object, action) {
+	if (action === "list") return [
+		{
+			name: "limit",
+			type: "integer",
+			required: false,
+			location: "input",
+			description: "Maximum number of items to return.",
+			defaultValue: "50"
+		},
+		{
+			name: "offset",
+			type: "integer",
+			required: false,
+			location: "input",
+			description: "Number of items to skip.",
+			defaultValue: "0"
+		},
+		{
+			name: "orderBy",
+			type: "string",
+			required: false,
+			location: "input",
+			description: "Ordering expression, for example \"created_at DESC\"."
+		},
+		{
+			name: "where",
+			type: "object",
+			required: false,
+			location: "input",
+			description: "Filter conditions as key-value pairs."
+		}
+	];
+	if (action === "get") return [{
+		name: "id",
+		type: "string",
+		required: true,
+		location: "input",
+		description: "Unique identifier of the object."
+	}, {
+		name: "slug",
+		type: "string",
+		required: false,
+		location: "input",
+		description: "URL-friendly identifier of the object."
+	}];
+	if (action === "delete") return [{
+		name: "id",
+		type: "string",
+		required: true,
+		location: "input",
+		description: "ID of the object to delete."
+	}];
+	if (action === "create") return writableFieldParameters(object, "input", "field");
+	return [{
+		name: "id",
+		type: "string",
+		required: true,
+		location: "input",
+		description: "ID of the object to update."
+	}, ...writableFieldParameters(object, "input", "optional")];
+}
+function mcpCustomParameters(_object, _action) {
+	return [{
+		name: "id",
+		type: "string",
+		required: true,
+		location: "input",
+		description: "ID of the object to execute the action on."
+	}, {
+		name: "options",
+		type: "object",
+		required: false,
+		location: "input",
+		description: "Additional options for the custom action."
+	}];
+}
+function enabledCrudActions(config) {
+	if (config === false) return [];
+	const include = arrayOfStrings(configObject(config).include);
+	const exclude = new Set(arrayOfStrings(configObject(config).exclude));
+	return (include.length > 0 ? include.filter((action) => CRUD_ACTIONS.includes(action)) : [...CRUD_ACTIONS]).filter((action) => !exclude.has(action));
+}
+function publicCustomMethodNames(object) {
+	return Object.entries(configObject(object.methods)).filter(([name, method]) => {
+		if (CRUD_ACTIONS.includes(name) || !isRecord(method)) return false;
+		return method.isPublic === true;
+	}).map(([name]) => name).sort();
+}
+function enabledCustomActions(object, surface) {
+	const surfaceConfig = configObject(object.decoratorConfig)[surface];
+	if (surfaceConfig === false) return [];
+	const include = arrayOfStrings(configObject(surfaceConfig).include);
+	const exclude = new Set(arrayOfStrings(configObject(surfaceConfig).exclude));
+	const publicMethods = publicCustomMethodNames(object);
+	if (surface === "mcp" && include.length > 0) return include.filter((name) => !CRUD_ACTIONS.includes(name)).filter((name) => publicMethods.includes(name)).filter((name) => !exclude.has(name));
+	if (surface === "api") return publicMethods.filter((name) => include.length === 0 || include.includes(name)).filter((name) => !exclude.has(name));
+	const customMethodsInInclude = include.filter((name) => !CRUD_ACTIONS.includes(name));
+	return publicMethods.filter((name) => customMethodsInInclude.length === 0 || customMethodsInInclude.includes(name)).filter((name) => !exclude.has(name));
+}
+function routeOverrides(object) {
+	const routes = configObject(configObject(configObject(object.decoratorConfig).api).routes);
+	return Object.fromEntries(Object.entries(routes).filter((entry) => isRecord(entry[1])));
+}
+function methodDefinition(object, action) {
+	return configObject(configObject(object.methods)[action]);
+}
+function customRoutePath(object, action) {
+	const collection = stringValue(object.collection) || stringValue(object.name) || action;
+	const routeConfig = routeOverrides(object)[action] || {};
+	const method = methodDefinition(object, action);
+	const normalizedPath = (stringValue(routeConfig.path) || action).split("/").map((segment) => segment.trim()).filter(Boolean).join("/").replace(/\[([^\]]+)\]/g, "{$1}");
+	return (stringValue(routeConfig.scope) || (method.isStatic === true ? "collection" : "item")) === "collection" ? `/api/v1/${collection}/${normalizedPath}` : `/api/v1/${collection}/{id}/${normalizedPath}`;
+}
+function restEndpointsFrom(object) {
+	const className = stringValue(object.className) || stringValue(object.name) || "Object";
+	const collection = stringValue(object.collection) || className.toLowerCase();
+	const apiConfig = configObject(object.decoratorConfig).api;
+	const endpoints = [];
+	const crudActions = stringValue(object.extends) === "SmrtCollection" ? [] : enabledCrudActions(apiConfig);
+	for (const action of crudActions) {
+		const route = action === "list" ? [
+			"GET",
+			`/api/v1/${collection}`,
+			`List ${className} objects`
+		] : action === "create" ? [
+			"POST",
+			`/api/v1/${collection}`,
+			`Create ${className}`
+		] : action === "get" ? [
+			"GET",
+			`/api/v1/${collection}/{id}`,
+			`Get ${className} by ID`
+		] : action === "update" ? [
+			"PUT",
+			`/api/v1/${collection}/{id}`,
+			`Update ${className}`
+		] : [
+			"DELETE",
+			`/api/v1/${collection}/{id}`,
+			`Delete ${className}`
+		];
+		endpoints.push({
+			objectName: className,
+			action,
+			method: route[0],
+			path: route[1],
+			description: route[2],
+			parameters: restCrudParameters(object, action, route[1])
+		});
+	}
+	const overrides = routeOverrides(object);
+	for (const action of enabledCustomActions(object, "api")) {
+		const method = stringValue((overrides[action] || {}).method) || "POST";
+		endpoints.push({
+			objectName: className,
+			action,
+			method,
+			path: customRoutePath(object, action),
+			description: `Run ${className}.${action}`,
+			parameters: restCustomParameters(object, action, method, customRoutePath(object, action))
+		});
+	}
+	return endpoints;
+}
+function cliCommandsFrom(object) {
+	const className = stringValue(object.className) || stringValue(object.name) || "Object";
+	const lowerName = className.toLowerCase();
+	const cliConfig = configObject(object.decoratorConfig).cli;
+	const commands = [];
+	for (const action of enabledCrudActions(cliConfig)) {
+		const description = action === "list" ? `List ${className} objects` : action === "get" ? `Get ${className} by ID or slug` : action === "create" ? `Create new ${className}` : action === "update" ? `Update ${className}` : `Delete ${className}`;
+		commands.push({
+			objectName: className,
+			action,
+			command: `${lowerName}:${action}`,
+			description,
+			parameters: cliCrudParameters(object, action)
+		});
+	}
+	for (const action of enabledCustomActions(object, "cli")) commands.push({
+		objectName: className,
+		action,
+		command: `${lowerName}:${action}`,
+		description: `Run ${className}.${action}`,
+		parameters: cliCustomParameters(object, action)
+	});
+	return commands;
+}
+function mcpToolsFrom(object) {
+	const className = stringValue(object.className) || stringValue(object.name) || "Object";
+	const lowerName = className.toLowerCase();
+	const mcpConfig = configObject(object.decoratorConfig).mcp;
+	const tools = [];
+	for (const action of enabledCrudActions(mcpConfig)) {
+		const description = action === "list" ? `List ${className} objects with optional filtering` : action === "get" ? `Get a specific ${className} by ID or slug` : action === "create" ? `Create a new ${className}` : action === "update" ? `Update an existing ${className}` : `Delete a ${className} by ID`;
+		tools.push({
+			objectName: className,
+			action,
+			toolName: `${lowerName}_${action}`,
+			description,
+			parameters: mcpCrudParameters(object, action)
+		});
+	}
+	for (const action of enabledCustomActions(object, "mcp")) tools.push({
+		objectName: className,
+		action,
+		toolName: `${lowerName}_${action}`.toLowerCase(),
+		description: `Execute ${action} action on ${className}`,
+		parameters: mcpCustomParameters(object, action)
+	});
+	return tools;
+}
+function readApiSummary(packageDir, rootDir, packageName, knowledge, routeFiles) {
+	const objectRecords = objectRecordsFrom((knowledge.manifestPath ? readJsonIfExists(knowledge.manifestPath) : null)?.objects);
+	const objects = objectRecords.map((object) => {
+		const name = stringValue(object.className) || stringValue(object.name) || stringValue(object.key) || "unknown";
+		const className = stringValue(object.className) || name;
+		const sourcePath = resolveManifestSourcePath(rootDir, packageDir, stringValue(object.filePath) || stringValue(object.sourcePath));
+		const typedocPath = findTypedocClassPath(rootDir, packageDir, packageName, className);
+		const fields = fieldSummariesFrom(object.fields);
+		return {
+			name,
+			className,
+			qualifiedName: stringValue(object.qualifiedName) || void 0,
+			collection: stringValue(object.collection) || void 0,
+			sourcePath,
+			typedocPath,
+			description: readTypedocSummary(typedocPath),
+			fields
+		};
+	});
+	const objectNames = objects.length > 0 ? objects.map((object) => object.qualifiedName || object.className || object.name).filter(Boolean).sort() : knowledge.objectNames;
+	const restEndpoints = objectRecords.flatMap(restEndpointsFrom);
+	return {
+		objectNames,
+		objects,
+		restEndpoints,
+		cliCommands: objectRecords.flatMap(cliCommandsFrom),
+		mcpTools: objectRecords.flatMap(mcpToolsFrom),
+		endpointCount: restEndpoints.length,
+		routeFiles
+	};
+}
+async function collectRouteFiles(packageDir) {
+	return fg(["src/routes/**/*.{ts,svelte}", "routes/**/*.{ts,svelte}"], {
+		cwd: packageDir,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**", "**/.svelte-kit/**"]
+	});
+}
+async function collectMigrations(packageDir) {
+	return fg(["migrations/**/*", "src/migrations/**/*"], {
+		cwd: packageDir,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"]
+	});
+}
+async function collectExamples(packageDir, docs) {
+	const fileExamples = (await fg([
+		"examples/**/*.{ts,tsx,svelte,md}",
+		"src/**/*.{example,stories}.{ts,tsx,svelte}",
+		"src/**/examples/**/*.{ts,tsx,svelte,md}"
+	], {
+		cwd: packageDir,
+		absolute: true,
+		onlyFiles: true,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/.svelte-kit/**"
+		]
+	})).slice(0, 16).map((path, index) => ({
+		id: `file:${index}`,
+		title: relative(packageDir, path),
+		path,
+		source: "file"
+	}));
+	const readme = docs.find((doc) => doc.kind === "readme");
+	const readmeExamples = readme?.content ? extractReadmeCodeBlocks(readme.content).slice(0, 8) : [];
+	return [...fileExamples, ...readmeExamples];
+}
+function extractReadmeCodeBlocks(content) {
+	const examples = [];
+	const blockPattern = /```([A-Za-z0-9_-]*)\n([\s\S]*?)```/g;
+	let index = 0;
+	let match = blockPattern.exec(content);
+	while (match) {
+		const language = match[1] || void 0;
+		const code = match[2] || "";
+		if (!code.trim()) {
+			match = blockPattern.exec(content);
+			continue;
+		}
+		const { content: trimmedCode } = truncate(code, EXAMPLE_LIMIT);
+		examples.push({
+			id: `readme:${index}`,
+			title: `README example ${index + 1}`,
+			language,
+			code: trimmedCode,
+			source: "readme"
+		});
+		index += 1;
+		match = blockPattern.exec(content);
+	}
+	return examples;
+}
+async function summarizePackage(input, rootDir) {
+	const { packageDir, packageJson, source } = input;
+	const packageName = packageJson.name || relative(rootDir, packageDir) || packageDir;
+	const docs = [
+		readDocument(packageDir, "README.md", "readme"),
+		readDocument(packageDir, "AGENTS.md", "agents"),
+		readDocument(packageDir, "CHANGELOG.md", "changelog")
+	].filter((doc) => Boolean(doc));
+	const examples = await collectExamples(packageDir, docs);
+	const knowledge = readKnowledgeSummary(packageDir);
+	const routeFiles = await collectRouteFiles(packageDir);
+	const migrations = await collectMigrations(packageDir);
+	const scripts = stringRecord(packageJson.scripts);
+	const api = readApiSummary(packageDir, rootDir, packageName, knowledge, routeFiles);
+	return {
+		name: packageName,
+		version: packageJson.version,
+		description: packageJson.description,
+		source,
+		directory: packageDir,
+		relativeDirectory: relative(rootDir, packageDir) || ".",
+		scripts,
+		dependencies: stringRecord(packageJson.dependencies),
+		devDependencies: stringRecord(packageJson.devDependencies),
+		peerDependencies: stringRecord(packageJson.peerDependencies),
+		smrtDependencies: smrtDependencyNames(packageJson),
+		sdkDependencies: sdkDependencyNames(packageJson),
+		exportKeys: exportKeys(packageJson.exports),
+		docs,
+		examples,
+		knowledge,
+		api,
+		migrations,
+		routeModuleCount: 0,
+		routeCount: 0,
+		playgroundEntryCount: 0,
+		recommendedCommands: Object.keys(scripts).filter((scriptName) => [
+			"test",
+			"typecheck",
+			"check",
+			"build",
+			"dev",
+			"workbench"
+		].includes(scriptName)).sort().map((scriptName) => ({
+			id: commandIdForScript(packageName, scriptName),
+			label: scriptName,
+			command: `pnpm --filter ${packageName} ${scriptName}`
+		}))
+	};
+}
+async function discoverWorkspacePackageDirs(workspaceRoot) {
+	return (await fg("packages/*/package.json", {
+		cwd: workspaceRoot,
+		absolute: true,
+		onlyFiles: true
+	})).map((packageJsonPath) => ({
+		packageDir: dirname(packageJsonPath),
+		packageJson: readJson(packageJsonPath),
+		source: "workspace"
+	})).filter((item) => typeof item.packageJson.name === "string" && item.packageJson.name.startsWith("@happyvertical/smrt-")).sort((left, right) => (left.packageJson.name || "").localeCompare(right.packageJson.name || ""));
+}
+function resolveNodeModulePackageDir(projectRoot, packageName) {
+	const packageJsonPath = join(projectRoot, "node_modules", packageName, "package.json");
+	return existsSync(packageJsonPath) ? dirname(packageJsonPath) : null;
+}
+async function discoverConsumerPackageDirs(projectRoot) {
+	const packageJsonPath = join(projectRoot, "package.json");
+	if (!existsSync(packageJsonPath)) return [];
+	const packageJson = readJson(packageJsonPath);
+	const dependencies = {
+		...packageJson.dependencies,
+		...packageJson.devDependencies,
+		...packageJson.peerDependencies
+	};
+	const packageDirs = [];
+	packageDirs.push({
+		packageDir: projectRoot,
+		packageJson,
+		source: packageJson.name?.startsWith("@happyvertical/smrt-") ? "package" : "app"
+	});
+	for (const dependencyName of Object.keys(dependencies).sort()) {
+		if (!dependencyName.startsWith("@happyvertical/smrt-") || dependencyName === "@happyvertical/smrt-workbench") continue;
+		const packageDir = resolveNodeModulePackageDir(projectRoot, dependencyName);
+		if (!packageDir) continue;
+		packageDirs.push({
+			packageDir,
+			packageJson: readJson(join(packageDir, "package.json")),
+			source: "package"
+		});
+	}
+	return packageDirs;
+}
+function resolvePackageByName(workspaceRoot, packageName) {
+	const packagesDir = join(workspaceRoot, "packages");
+	if (!existsSync(packagesDir)) return null;
+	const packageJsonPaths = fg.sync("*/package.json", {
+		cwd: packagesDir,
+		absolute: true,
+		onlyFiles: true
+	});
+	for (const packageJsonPath of packageJsonPaths) if (readJson(packageJsonPath).name === packageName) return dirname(packageJsonPath);
+	return null;
+}
+function resolveWorkbenchScope(cwd = process.cwd(), options = {}) {
+	const resolvedCwd = resolve(cwd);
+	const requestedProjectRoot = options.projectRoot ? resolve(options.projectRoot) : void 0;
+	const workspaceRoot = options.workspaceRoot || (requestedProjectRoot ? findSmrtWorkbenchWorkspaceRoot(requestedProjectRoot) : null) || findSmrtWorkbenchWorkspaceRoot(resolvedCwd);
+	if (workspaceRoot) {
+		const packageDir = (options.packageName ? resolvePackageByName(workspaceRoot, options.packageName) : null) || findPackageDir(resolvedCwd, workspaceRoot) || void 0;
+		const packageJson = packageDir ? readJsonIfExists(join(packageDir, "package.json")) : null;
+		const packageName = options.packageName || packageJson?.name;
+		return {
+			mode: packageName ? "package" : "workspace",
+			cwd: resolvedCwd,
+			projectRoot: workspaceRoot,
+			workspaceRoot,
+			packageName,
+			packageDir,
+			packageManager: "pnpm"
+		};
+	}
+	const projectRoot = requestedProjectRoot || findProjectRoot(resolvedCwd);
+	return {
+		mode: "consumer",
+		cwd: resolvedCwd,
+		projectRoot,
+		packageName: options.packageName,
+		packageManager: detectPackageManager(projectRoot)
+	};
+}
+async function buildWorkbenchProject(scope) {
+	const packageDirs = scope.mode === "consumer" ? await discoverConsumerPackageDirs(scope.projectRoot) : await discoverWorkspacePackageDirs(scope.projectRoot);
+	const filteredPackageDirs = scope.packageName ? packageDirs.filter((item) => item.packageJson.name === scope.packageName) : packageDirs;
+	const packages = await Promise.all(filteredPackageDirs.map((item) => summarizePackage(item, scope.projectRoot)));
+	return {
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		scope,
+		packages
+	};
+}
+async function discoverWorkspaceWorkbenches(workspaceRoot, packagesPattern = "packages/*/src/workbench.ts") {
+	return (await fg(packagesPattern, {
+		cwd: workspaceRoot,
+		absolute: true,
+		onlyFiles: true
+	})).sort().map((sourcePath) => {
+		const packageDir = dirname(dirname(sourcePath));
+		const packageJson = readJson(join(packageDir, "package.json"));
+		const runtimePath = join(packageDir, "dist", "workbench.js");
+		return {
+			packageName: packageJson.name,
+			source: "workspace",
+			sourcePath,
+			runtimePath: existsSync(runtimePath) ? runtimePath : void 0
+		};
+	});
+}
+async function discoverInstalledWorkbenches(projectRoot = process.cwd()) {
+	const packageJsonPath = join(projectRoot, "package.json");
+	if (!existsSync(packageJsonPath)) return [];
+	const packageJson = readJson(packageJsonPath);
+	const dependencies = {
+		...packageJson.dependencies,
+		...packageJson.devDependencies,
+		...packageJson.peerDependencies
+	};
+	const discovered = [];
+	for (const dependencyName of Object.keys(dependencies).sort()) {
+		if (!dependencyName.startsWith("@happyvertical/smrt-") || dependencyName === "@happyvertical/smrt-workbench") continue;
+		const packageDir = resolveNodeModulePackageDir(projectRoot, dependencyName);
+		if (!packageDir) continue;
+		if (exportKeys(readJson(join(packageDir, "package.json")).exports).includes("./workbench")) discovered.push({
+			packageName: dependencyName,
+			source: "package",
+			importSpecifier: `${dependencyName}/workbench`
+		});
+	}
+	return discovered;
+}
+async function discoverWorkbenchTargets(projectRoot = process.cwd(), mode = "auto", localWorkbenchPath = "src/workbench.ts", packageName, packagesPattern = "packages/*/src/workbench.ts") {
+	if ((mode === "auto" ? detectWorkbenchMode(projectRoot) : mode) === "workspace") {
+		const workspaceRoot = mode === "workspace" ? findWorkspaceRoot(projectRoot) : findSmrtWorkbenchWorkspaceRoot(projectRoot);
+		if (!workspaceRoot) return [];
+		const targets2 = await discoverWorkspaceWorkbenches(workspaceRoot, packagesPattern);
+		return packageName ? targets2.filter((target) => target.packageName === packageName) : targets2;
+	}
+	const targets = await discoverInstalledWorkbenches(projectRoot);
+	const localPath = resolve(projectRoot, localWorkbenchPath);
+	if (existsSync(localPath)) {
+		const localPackageJson = readJsonIfExists(join(projectRoot, "package.json"));
+		targets.push({
+			packageName: localPackageJson?.name,
+			source: "app",
+			sourcePath: localPath
+		});
+	}
+	return packageName ? targets.filter((target) => target.packageName === packageName) : targets;
+}
+async function importWorkbenchModule(input) {
+	const imported = isAbsolute(input) || input.startsWith(".") ? await importPathModule(resolve(input)) : await import(
+		/* @vite-ignore */
+		input
+);
+	const module = imported.default ?? imported.workbench ?? imported;
+	return module && typeof module === "object" ? coerceWorkbenchModules(module) : [];
+}
+async function importPathModule(inputPath) {
+	if (!TS_SOURCE_EXTENSIONS.has(extname(inputPath))) return import(
+		/* @vite-ignore */
+		pathToFileURL(inputPath).href
+);
+	let tsxApiPath;
+	try {
+		tsxApiPath = require.resolve("tsx/esm/api");
+	} catch (tsxError) {
+		throw new Error(`Failed to load workbench module from ${inputPath}: source workbench discovery requires the "tsx" package.`, { cause: tsxError });
+	}
+	const { tsImport } = await import(
+		/* @vite-ignore */
+		pathToFileURL(tsxApiPath).href
+);
+	return tsImport(pathToFileURL(inputPath).href, { parentURL: import.meta.url });
+}
+function describeWorkbenchSource(target, cwd = process.cwd()) {
+	if (target.source === "package") return target.importSpecifier || target.packageName || "installed package";
+	const path = target.sourcePath || target.runtimePath;
+	return path ? relative(cwd, path) || "." : target.source;
+}
+//#endregion
+export { discoverWorkbenchTargets as a, findProjectRoot as c, importWorkbenchModule as d, resolveWorkbenchScope as f, discoverInstalledWorkbenches as i, findSmrtWorkbenchWorkspaceRoot as l, describeWorkbenchSource as n, discoverWorkspaceWorkbenches as o, detectWorkbenchMode as r, findPackageDir as s, buildWorkbenchProject as t, findWorkspaceRoot as u };
+
+//# sourceMappingURL=discovery-G9-foyW8.js.map