@happyvertical/smrt-scanner 0.46.0 → 0.47.0

package/AGENTS.md

@@ -214,6 +214,21 @@ place, `toKnowledgeAgentSurface` in `vite-plugin/index.ts`.
   printed by the Vite plugin, carried into `smrt-knowledge.json`, reported by
   `smrt doctor`, and surfaced by `dev:knowledge-check` as
   `agent-surface-not-static`.
+- **A parameter carries type PROVENANCE, a field does not.**
+  `RawParameterDefinition.typeUnresolved` marks an annotation the scanner could
+  not express (intersection, tuple, conditional, mapped, `typeof`, indexed
+  access) — `type` still reads `'any'` for compatibility, so that flag is the
+  only thing separating it from an authored `any`. `memberTypes` carries the
+  members of an INLINE object literal, which `extractTypeName` otherwise
+  flattens to `'object'`; NAMED bags stay unexpanded on purpose. Core's API
+  wire-ability gate fails closed on both (#2686). The bare `object` keyword is
+  resolved for parameters only — `ManifestAdapter.inferFromAnnotation` gives an
+  `object`-typed FIELD a `{}` column default, so naming it in `extractTypeName`
+  would silently change DDL.
+- **`@method()` config is read with `requireLiteralValues`**, like `@smrt()`: an
+  unresolvable value is a scan error, because a dropped `expose: false` restores
+  the routing the author was withholding. `decoratorConfig` is `undefined` for
+  an undecorated method and `{}` for a bare `@method()`; the two differ.
 - **Relationship targets are resolved, not copied**: `@foreignKey`,
   `@oneToMany` and `@manyToMany` arguments arrive as raw source text.
   `'Target'`/`Target` pass through and a forward-reference thunk

package/dist/chunks/{scanner-C3VqXyzB.js → scanner-9p-PUN-X.js}

@@ -1080,7 +1080,8 @@ function parseFile(filePath) {
 			smrtImports = extractSmrtImports(program.body);
 			const ctx = {
 				constants: extractModuleObjectConstants(program.body, sourceText),
-				unresolved: []
+				unresolved: [],
+				importAliases
 			};
 			for (const node of program.body) {
 				const extracted = extractClassFromNode(node, filePath, sourceText, importAliases, ctx);
@@ -1164,7 +1165,8 @@ function parseSource(sourceText, filename = "test.ts") {
 			smrtImports = extractSmrtImports(program.body);
 			const ctx = {
 				constants: extractModuleObjectConstants(program.body, sourceText),
-				unresolved: []
+				unresolved: [],
+				importAliases
 			};
 			for (const node of program.body) {
 				const extracted = extractClassFromNode(node, filename, sourceText, importAliases, ctx);
@@ -1491,7 +1493,7 @@ function reportUnresolvedSpreads(unresolved, filePath, sourceText, errors) {
 	for (const spread of unresolved) {
 		const loc = spread.start === void 0 ? void 0 : getLineColumn(sourceText, spread.start);
 		errors.push({
-			message: `Cannot statically resolve \`${spread.expression}\` while expanding a @smrt() config. Only literal keys/values and unescaped module-scope \`const\` object literals in the same file are supported. Inline the keys or remove the mutation/alias \u2014 an unresolved expression would drop api/mcp/cli from the manifest, and an absent surface defaults to open.`,
+			message: `Cannot statically resolve \`${spread.expression}\` while expanding a ${spread.decorator ?? "@smrt()"} config. Only literal keys/values and unescaped module-scope \`const\` object literals in the same file are supported. Inline the keys or remove the mutation/alias \u2014 an unresolved expression would drop keys from the manifest, and every absent exposure key defaults to open.`,
 			filePath,
 			line: loc?.line,
 			column: loc?.column,
@@ -1508,9 +1510,9 @@ function extractClassFromNode(node, filePath, sourceText, importAliases, ctx) {
 function extractClassDeclaration(node, filePath, sourceText, importAliases, ctx) {
 	const className = node.id?.name || "AnonymousClass";
 	const decorators = node.decorators || [];
-	const smrtDecorator = decorators.find((d) => isSmrtDecorator(d));
-	const reportDecorator = decorators.find((d) => isNamedDecorator(d, "report"));
-	const tenantScopedDecorator = decorators.find((d) => isNamedDecorator(d, "TenantScoped"));
+	const smrtDecorator = decorators.find((d) => isSmrtDecorator(d, importAliases));
+	const reportDecorator = decorators.find((d) => isNamedDecorator(d, "report", importAliases));
+	const tenantScopedDecorator = decorators.find((d) => isNamedDecorator(d, "TenantScoped", importAliases));
 	const hasSmartDecorator = !!smrtDecorator;
 	const smrtConfig = smrtDecorator ? extractDecoratorConfig(smrtDecorator, sourceText, ctx ? {
 		...ctx,
@@ -1528,7 +1530,7 @@ function extractClassDeclaration(node, filePath, sourceText, importAliases, ctx)
 		const field = extractPropertyDefinition(member, sourceText);
 		if (field) fields.push(field);
 	} else if (member.type === "MethodDefinition") {
-		const method = extractMethodDefinition(member, sourceText);
+		const method = extractMethodDefinition(member, sourceText, ctx);
 		if (method) methods.push(method);
 	}
 	return {
@@ -1544,16 +1546,17 @@ function extractClassDeclaration(node, filePath, sourceText, importAliases, ctx)
 		endLine: node.loc?.end.line || 1
 	};
 }
-function isSmrtDecorator(decorator) {
-	return isNamedDecorator(decorator, "smrt");
+function isSmrtDecorator(decorator, importAliases) {
+	return isNamedDecorator(decorator, "smrt", importAliases);
 }
-function isNamedDecorator(decorator, name) {
+function isNamedDecorator(decorator, name, importAliases) {
 	const expr = decorator.expression;
+	const resolve = (local) => importAliases?.get(local) ?? local;
 	if (expr.type === "CallExpression") {
 		const callee = expr.callee;
-		if (callee.type === "Identifier" && callee.name === name) return true;
+		if (callee.type === "Identifier" && resolve(callee.name) === name) return true;
 	}
-	if (expr.type === "Identifier" && expr.name === name) return true;
+	if (expr.type === "Identifier" && resolve(expr.name) === name) return true;
 	return false;
 }
 function extractDecoratorConfig(decorator, sourceText, ctx) {
@@ -1757,7 +1760,8 @@ function extractTypeName(type) {
 			else if (type.typeName.type === "TSQualifiedName") baseName = getQualifiedName(type.typeName);
 			const typeParams = type.typeArguments?.params || type.typeParameters?.params;
 			if (baseName && typeParams?.length) {
-				const typeArgs = typeParams.map((p) => extractTypeName(p)).filter(Boolean);
+				const typeArgs = typeParams.map((p) => extractTypeName(p));
+				if (typeArgs.some((arg) => arg === null)) return null;
 				if (typeArgs.length > 0) return `${baseName}<${typeArgs.join(", ")}>`;
 			}
 			return baseName;
@@ -1766,7 +1770,12 @@ function extractTypeName(type) {
 		case "TSNumberKeyword": return "number";
 		case "TSBooleanKeyword": return "boolean";
 		case "TSAnyKeyword": return "any";
+		case "TSUnknownKeyword": return "unknown";
+		case "TSNeverKeyword": return "never";
+		case "TSBigIntKeyword": return "bigint";
+		case "TSSymbolKeyword": return "symbol";
 		case "TSVoidKeyword": return "void";
+		case "TSThisType": return "this";
 		case "TSNullKeyword": return "null";
 		case "TSUndefinedKeyword": return "undefined";
 		case "TSLiteralType": {
@@ -1781,7 +1790,11 @@ function extractTypeName(type) {
 			const elementType = extractTypeName(type.elementType);
 			return elementType ? `${elementType}[]` : null;
 		}
-		case "TSUnionType": return type.types.map((t) => extractTypeName(t)).filter(Boolean).join(" | ");
+		case "TSUnionType": {
+			const types = type.types.map((t) => extractTypeName(t));
+			if (types.some((branch) => branch === null)) return null;
+			return types.join(" | ");
+		}
 		case "TSTypeLiteral": return "object";
 		case "TSFunctionType": return "Function";
 		default: return null;
@@ -1861,7 +1874,7 @@ function extractFieldDecorator(decorator, sourceText) {
 		arguments: args
 	};
 }
-function extractMethodDefinition(node, sourceText) {
+function extractMethodDefinition(node, sourceText, ctx) {
 	if (node.kind !== "method") return null;
 	const name = getPropertyKey(node.key);
 	if (!name) return null;
@@ -1872,6 +1885,7 @@ function extractMethodDefinition(node, sourceText) {
 		if (extracted) parameters.push(extracted);
 	}
 	const returnType = func.returnType ? extractTypeName(func.returnType.typeAnnotation) : null;
+	const decoratorConfig = extractMethodDecoratorConfig(node, sourceText, ctx);
 	return {
 		name,
 		async: func.async,
@@ -1880,21 +1894,113 @@ function extractMethodDefinition(node, sourceText) {
 		parameters,
 		returnType,
 		description: null,
+		...decoratorConfig ? { decoratorConfig } : {},
 		line: node.loc?.start.line || 0
 	};
 }
+function extractMethodDecoratorConfig(node, sourceText, ctx) {
+	const decorator = node.decorators?.find((d) => isNamedDecorator(d, "method", ctx?.importAliases));
+	if (!decorator) return void 0;
+	const unresolvedBefore = ctx?.unresolved.length ?? 0;
+	const config = extractDecoratorConfig(decorator, sourceText, ctx ? {
+		...ctx,
+		requireLiteralValues: true
+	} : ctx);
+	if (ctx) for (const entry of ctx.unresolved.slice(unresolvedBefore)) entry.decorator = "@method()";
+	return config ?? {};
+}
+var INLINE_MEMBER_TYPE_MAX_DEPTH = 4;
+function describeParameterType(annotation) {
+	if (!annotation) return {
+		type: null,
+		typeUnresolved: false
+	};
+	const node = annotation.typeAnnotation;
+	if (node.type === "TSObjectKeyword") return {
+		type: "object",
+		typeUnresolved: false
+	};
+	const type = extractTypeName(node);
+	if (type === null) return {
+		type: null,
+		typeUnresolved: true
+	};
+	const members = [];
+	const memberUnresolved = collectInlineMemberTypes(node, members, 0);
+	let unionBranches;
+	if (node.type === "TSUnionType") {
+		const branches = [];
+		for (const branch of node.types) {
+			const branchType = branch.type === "TSObjectKeyword" ? "object" : extractTypeName(branch);
+			if (branchType === null) return {
+				type,
+				typeUnresolved: true
+			};
+			const branchMembers = [];
+			collectInlineMemberTypes(branch, branchMembers, 0);
+			branches.push({
+				type: branchType,
+				...branchMembers.length > 0 ? { memberTypes: [...new Set(branchMembers)] } : {}
+			});
+		}
+		if (branches.length > 0) unionBranches = branches;
+	}
+	return {
+		type,
+		typeUnresolved: memberUnresolved,
+		...members.length > 0 ? { memberTypes: [...new Set(members)] } : {},
+		...unionBranches ? { unionBranches } : {}
+	};
+}
+function collectInlineMemberTypes(node, out, depth) {
+	if (depth > INLINE_MEMBER_TYPE_MAX_DEPTH) return false;
+	switch (node.type) {
+		case "TSTypeLiteral": {
+			let unresolved = false;
+			for (const member of node.members) {
+				if (member.type === "TSMethodSignature") {
+					out.push("Function");
+					continue;
+				}
+				const memberAnnotation = member.typeAnnotation;
+				if (!memberAnnotation) continue;
+				const memberType = extractTypeName(memberAnnotation.typeAnnotation);
+				if (memberType === null) {
+					unresolved = true;
+					continue;
+				}
+				out.push(memberType);
+				if (collectInlineMemberTypes(memberAnnotation.typeAnnotation, out, depth + 1)) unresolved = true;
+			}
+			return unresolved;
+		}
+		case "TSArrayType": return collectInlineMemberTypes(node.elementType, out, depth + 1);
+		case "TSUnionType": {
+			let unresolved = false;
+			for (const branch of node.types) if (collectInlineMemberTypes(branch, out, depth + 1)) unresolved = true;
+			return unresolved;
+		}
+		case "TSTypeReference": {
+			let unresolved = false;
+			const typeParams = node.typeArguments?.params || node.typeParameters?.params;
+			for (const param of typeParams ?? []) if (collectInlineMemberTypes(param, out, depth + 1)) unresolved = true;
+			return unresolved;
+		}
+		default: return false;
+	}
+}
 function extractParameter(param, sourceText) {
 	if (param.type === "AssignmentPattern") {
 		const left = param.left;
 		if (left.type === "Identifier") return {
 			name: left.name,
-			type: left.typeAnnotation ? extractTypeName(left.typeAnnotation.typeAnnotation) : null,
+			...describeParameterTypeFields(left.typeAnnotation),
 			optional: true,
 			defaultValue: sliceSource(param.right, sourceText)
 		};
 		if (left.type === "ObjectPattern" || left.type === "ArrayPattern") return {
 			name: "options",
-			type: left.typeAnnotation ? extractTypeName(left.typeAnnotation.typeAnnotation) : "any",
+			...describeParameterTypeFields(left.typeAnnotation, "any"),
 			optional: true,
 			defaultValue: sliceSource(param.right, sourceText)
 		};
@@ -1904,7 +2010,7 @@ function extractParameter(param, sourceText) {
 		const arg = param.argument;
 		if (arg.type === "Identifier") return {
 			name: `...${arg.name}`,
-			type: param.typeAnnotation ? extractTypeName(param.typeAnnotation.typeAnnotation) : null,
+			...describeParameterTypeFields(param.typeAnnotation),
 			optional: true,
 			defaultValue: null
 		};
@@ -1912,18 +2018,28 @@ function extractParameter(param, sourceText) {
 	}
 	if (param.type === "Identifier") return {
 		name: param.name,
-		type: param.typeAnnotation ? extractTypeName(param.typeAnnotation.typeAnnotation) : null,
+		...describeParameterTypeFields(param.typeAnnotation),
 		optional: param.optional || false,
 		defaultValue: null
 	};
 	if (param.type === "ObjectPattern") return {
 		name: "options",
-		type: param.typeAnnotation ? extractTypeName(param.typeAnnotation.typeAnnotation) : "any",
+		...describeParameterTypeFields(param.typeAnnotation, "any"),
 		optional: false,
 		defaultValue: null
 	};
 	return null;
 }
+function describeParameterTypeFields(annotation, missingAnnotationType = null) {
+	if (!annotation) return { type: missingAnnotationType };
+	const described = describeParameterType(annotation);
+	return {
+		type: described.type,
+		...described.typeUnresolved ? { typeUnresolved: true } : {},
+		...described.memberTypes ? { memberTypes: described.memberTypes } : {},
+		...described.unionBranches ? { unionBranches: described.unionBranches } : {}
+	};
+}
 //#endregion
 //#region src/manifest-adapter.ts
 var MANIFEST_TIMESTAMP = 0;
@@ -2617,12 +2733,16 @@ var ManifestAdapter = class ManifestAdapter {
 				name: p.name,
 				type: p.type || "any",
 				optional: p.optional,
-				default: p.defaultValue ? this.parseDefaultValue(p.defaultValue, "string") : void 0
+				default: p.defaultValue ? this.parseDefaultValue(p.defaultValue, "string") : void 0,
+				...p.typeUnresolved ? { typeUnresolved: true } : {},
+				...p.memberTypes ? { memberTypes: p.memberTypes } : {},
+				...p.unionBranches ? { unionBranches: p.unionBranches } : {}
 			})),
 			returnType: method.returnType || "any",
 			description: method.description || void 0,
 			isStatic: method.isStatic,
-			isPublic: true
+			isPublic: true,
+			...method.decoratorConfig ? { decoratorConfig: method.decoratorConfig } : {}
 		};
 	}
 	/**
@@ -2977,4 +3097,4 @@ var OxcScanner = class {
 //#endregion
 export { sourceMayDeclareAgentSurface as _, parseFile as a, discoverSourceFiles as c, emptyAgentSurface as d, extractAgentSurface as f, scanSvelteAgentSurface as g, mergeAgentSurfaces as h, parseAgentSurfaceFile as i, normalizeGlobSeparators as l, isPrunedAgentSurfacePath as m, ManifestAdapter as n, parseSource as o, isAgentSurfaceSourcePath as p, extractSmrtImports as r, InheritanceResolver as s, OxcScanner as t, relativeGlobToCwd as u };
 
-//# sourceMappingURL=scanner-C3VqXyzB.js.map
+//# sourceMappingURL=scanner-9p-PUN-X.js.map