@nseng-ai/kernel 0.1.2

package/src/extensions/loader.ts

@@ -0,0 +1,49 @@
+import { formatUnknownError } from "./command-registry.ts";
+import {
+	matchNsCommandModuleReference,
+	moduleReferenceDisplay,
+	type NsCommandModuleReference,
+} from "./module-reference.ts";
+import { importDefaultExport } from "../runtime/module-import.ts";
+import { loadNsUserModuleDefault } from "../runtime/module-loader.ts";
+
+export interface ExtensionLoadDiagnostic {
+	severity: "error";
+	code: string;
+	message: string;
+	path: string;
+}
+
+export type NsExtensionContributionLoadResult =
+	| { ok: true; defaultExport: unknown }
+	| { ok: false; diagnostic: ExtensionLoadDiagnostic };
+
+export async function loadNsExtensionContribution(
+	reference: NsCommandModuleReference,
+): Promise<NsExtensionContributionLoadResult> {
+	const displayPath = moduleReferenceDisplay(reference);
+	try {
+		return { ok: true, defaultExport: await loadDefaultExport(reference) };
+	} catch (error) {
+		return {
+			ok: false,
+			diagnostic: diagnostic(
+				"ns_extension_contribution_import_failed",
+				`Failed to load ns extension contribution ${displayPath}.\n${formatUnknownError(error)}`,
+				displayPath,
+			),
+		};
+	}
+}
+
+async function loadDefaultExport(reference: NsCommandModuleReference): Promise<unknown> {
+	return await matchNsCommandModuleReference(reference, {
+		file: async (fileReference) => await loadNsUserModuleDefault(fileReference.path),
+		package: async (packageReference) => await importDefaultExport(packageReference.specifier),
+		loaded: async (loadedReference) => await loadedReference.load(),
+	});
+}
+
+function diagnostic(code: string, message: string, path: string): ExtensionLoadDiagnostic {
+	return { severity: "error", code, message, path };
+}

package/src/extensions/module-reference.ts

@@ -0,0 +1,54 @@
+export type NsCommandModuleLoader = () => unknown | Promise<unknown>;
+
+export type NsCommandModuleReference =
+	| { type: "file"; path: string }
+	| { type: "package"; specifier: string }
+	| { type: "loaded"; displayPath: string; load: NsCommandModuleLoader };
+
+export interface NsCommandModuleReferenceHandlers<T> {
+	file: (reference: Extract<NsCommandModuleReference, { type: "file" }>) => T;
+	package: (reference: Extract<NsCommandModuleReference, { type: "package" }>) => T;
+	loaded: (reference: Extract<NsCommandModuleReference, { type: "loaded" }>) => T;
+}
+
+export function matchNsCommandModuleReference<T>(
+	reference: NsCommandModuleReference,
+	handlers: NsCommandModuleReferenceHandlers<T>,
+): T {
+	switch (reference.type) {
+		case "file":
+			return handlers.file(reference);
+		case "package":
+			return handlers.package(reference);
+		case "loaded":
+			return handlers.loaded(reference);
+	}
+	return unsupportedModuleReference(reference);
+}
+
+export function fileModuleReference(path: string): NsCommandModuleReference {
+	return { type: "file", path };
+}
+
+export function packageModuleReference(specifier: string): NsCommandModuleReference {
+	return { type: "package", specifier };
+}
+
+export function loadedModuleReference(
+	displayPath: string,
+	load: NsCommandModuleLoader,
+): NsCommandModuleReference {
+	return { type: "loaded", displayPath, load };
+}
+
+export function moduleReferenceDisplay(reference: NsCommandModuleReference): string {
+	return matchNsCommandModuleReference(reference, {
+		file: (fileReference) => fileReference.path,
+		package: (packageReference) => packageReference.specifier,
+		loaded: (loadedReference) => loadedReference.displayPath,
+	});
+}
+
+function unsupportedModuleReference(reference: never): never {
+	throw new Error(`Unsupported ns command module reference: ${JSON.stringify(reference)}`);
+}