@schlenkr/ragents 0.1.4 → 0.1.6

package/packages/agent/src/core/extensions/loader.ts

@@ -1,67 +1,18 @@
 /**
- * Extension loader - loads TypeScript extension modules using jiti.
- *
+ * Extension loader - creates extensions from inline factories.
  */
 
-import * as fs from "node:fs";
-import { createRequire } from "node:module";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import * as _bundledAgentCore from "@aicontainer/agent-core";
-import * as _bundledAi from "@aicontainer/ai";
-import * as _bundledAiOauth from "@aicontainer/ai/oauth";
-import * as _bundledAiProviders from "@aicontainer/ai/providers/all";
-import { createJiti } from "jiti/static";
-// Static imports of packages that extensions may use.
-// These MUST be static so Bun bundles them into the compiled binary.
-// The virtualModules option then makes them available to extensions.
-import * as _bundledTypebox from "typebox";
-import * as _bundledTypeboxCompile from "typebox/compile";
-import * as _bundledTypeboxValue from "typebox/value";
-import { CONFIG_DIR_NAME, getAgentDir, isBunBinary } from "../../config.ts";
-// NOTE: This import works because loader.ts exports are NOT re-exported from index.ts,
-// avoiding a circular dependency. Extensions can import from @aicontainer/agent.
-import * as _bundledCodingAgent from "../../index.ts";
-import { resolvePath } from "../../utils/paths.ts";
-import { createEventBus, type EventBus } from "../event-bus.ts";
-import type { ExecOptions } from "../exec.ts";
-import { execCommand } from "../exec.ts";
 import { createSyntheticSourceInfo } from "../source-info.ts";
-import { time } from "../timings.ts";
 import type {
 	Extension,
 	ExtensionAPI,
 	ExtensionFactory,
 	ExtensionFactorySettlementObserver,
 	ExtensionRuntime,
-	LoadExtensionsResult,
-	ProviderConfig,
-	RegisteredCommand,
 	ToolDefinition,
 } from "./types.ts";
 
-/** Modules available to extensions via virtualModules (for compiled Bun binary) */
-const VIRTUAL_MODULES: Record<string, unknown> = {
-	typebox: _bundledTypebox,
-	"typebox/compile": _bundledTypeboxCompile,
-	"typebox/value": _bundledTypeboxValue,
-	"@sinclair/typebox": _bundledTypebox,
-	"@sinclair/typebox/compile": _bundledTypeboxCompile,
-	"@sinclair/typebox/value": _bundledTypeboxValue,
-	"@aicontainer/agent-core": _bundledAgentCore,
-	"@aicontainer/ai": _bundledAi,
-	"@aicontainer/ai/oauth": _bundledAiOauth,
-	"@aicontainer/ai/providers/all": _bundledAiProviders,
-	"@aicontainer/agent": _bundledCodingAgent,
-};
-
-const require = createRequire(import.meta.url);
-
-/**
- * Get aliases for jiti (used in Node.js/development mode).
- * In Bun binary mode, virtualModules is used instead.
- */
-let _aliases: Record<string, string> | null = null;
+type HandlerFn = (...args: unknown[]) => Promise<unknown>;
 
 function abortReason(signal: AbortSignal): Error {
 	return signal.reason instanceof Error ? signal.reason : new Error("Extension creation was aborted.");
@@ -82,74 +33,6 @@ function awaitWithSignal<T>(operation: Promise<T>, signal: AbortSignal | undefin
 	});
 }
 
-function getAliases(): Record<string, string> {
-	if (_aliases) return _aliases;
-
-	const __dirname = path.dirname(fileURLToPath(import.meta.url));
-	const packageIndex = path.resolve(__dirname, "../..", "index.js");
-
-	const typeboxEntry = require.resolve("typebox");
-	const typeboxCompileEntry = require.resolve("typebox/compile");
-	const typeboxValueEntry = require.resolve("typebox/value");
-
-	const packagesRoot = path.resolve(__dirname, "../../../../");
-	const resolveWorkspaceOrImport = (workspaceRelativePath: string, specifier: string): string => {
-		const workspacePath = path.join(packagesRoot, workspaceRelativePath);
-		if (fs.existsSync(workspacePath)) {
-			return workspacePath;
-		}
-		return fileURLToPath(import.meta.resolve(specifier));
-	};
-
-	const codingAgentEntry = packageIndex;
-	const agentCoreEntry = resolveWorkspaceOrImport("agent/dist/index.js", "@aicontainer/agent-core");
-	const aiEntry = resolveWorkspaceOrImport("ai/dist/index.js", "@aicontainer/ai");
-	const aiOauthEntry = resolveWorkspaceOrImport("ai/dist/oauth.js", "@aicontainer/ai/oauth");
-	const aiProvidersEntry = resolveWorkspaceOrImport("ai/dist/providers/all.js", "@aicontainer/ai/providers/all");
-
-	_aliases = {
-		"@aicontainer/agent": codingAgentEntry,
-		"@aicontainer/agent-core": agentCoreEntry,
-		"@aicontainer/ai/providers/all": aiProvidersEntry,
-		"@aicontainer/ai/oauth": aiOauthEntry,
-		"@aicontainer/ai": aiEntry,
-		typebox: typeboxEntry,
-		"typebox/compile": typeboxCompileEntry,
-		"typebox/value": typeboxValueEntry,
-		"@sinclair/typebox": typeboxEntry,
-		"@sinclair/typebox/compile": typeboxCompileEntry,
-		"@sinclair/typebox/value": typeboxValueEntry,
-	};
-
-	return _aliases;
-}
-
-type HandlerFn = (...args: unknown[]) => Promise<unknown>;
-
-let extensionCacheCwd: string | undefined;
-let extensionCacheGeneration = 0;
-const extensionCache = new Map<string, ExtensionFactory>();
-
-interface ExtensionCacheToken {
-	cwd: string;
-	generation: number;
-}
-
-export function clearExtensionCache(): void {
-	extensionCache.clear();
-	extensionCacheCwd = undefined;
-	extensionCacheGeneration++;
-}
-
-function useExtensionCacheCwd(cwd: string): ExtensionCacheToken {
-	const resolvedCwd = resolvePath(cwd);
-	if (extensionCacheCwd !== undefined && extensionCacheCwd !== resolvedCwd) {
-		clearExtensionCache();
-	}
-	extensionCacheCwd = resolvedCwd;
-	return { cwd: resolvedCwd, generation: extensionCacheGeneration };
-}
-
 /**
  * Create a runtime with throwing stubs for action methods.
  * Runner.bindCore() replaces these with real implementations.
@@ -159,62 +42,27 @@ export function createExtensionRuntime(): ExtensionRuntime {
 		throw new Error("Extension runtime not initialized. Action methods cannot be called during extension loading.");
 	};
 	const state: { staleMessage?: string } = {};
-	const assertActive = () => {
-		if (state.staleMessage) {
-			throw new Error(state.staleMessage);
-		}
-	};
 
-	const runtime: ExtensionRuntime = {
-		sendMessage: notInitialized,
-		sendUserMessage: notInitialized,
+	return {
 		appendEntry: notInitialized,
-		setSessionName: notInitialized,
-		getSessionName: notInitialized,
-		setLabel: notInitialized,
-		getActiveTools: notInitialized,
 		getAllTools: notInitialized,
 		setActiveTools: notInitialized,
 		// registerTool() is valid during extension load; refresh is only needed post-bind.
 		refreshTools: () => {},
-		getCommands: notInitialized,
-		setModel: () => Promise.reject(new Error("Extension runtime not initialized")),
-		getThinkingLevel: notInitialized,
-		setThinkingLevel: notInitialized,
-		flagValues: new Map(),
-		pendingProviderRegistrations: [],
-		assertActive,
-		invalidate: (message) => {
-			state.staleMessage ??=
-				message ??
-				"This extension ctx is stale after session replacement or reload. Do not use a captured extension or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload().";
-		},
-		// Pre-bind: queue registrations so bindCore() can flush them once the
-		// model registry is available. bindCore() replaces both with direct calls.
-		registerProvider: (name, config, extensionPath = "<unknown>") => {
-			runtime.pendingProviderRegistrations.push({ name, config, extensionPath });
+		assertActive: () => {
+			if (state.staleMessage) {
+				throw new Error(state.staleMessage);
+			}
 		},
-		unregisterProvider: (name) => {
-			runtime.pendingProviderRegistrations = runtime.pendingProviderRegistrations.filter((r) => r.name !== name);
+		invalidate: (message) => {
+			state.staleMessage ??= message ?? "This extension is stale.";
 		},
 	};
-
-	return runtime;
 }
 
-/**
- * Create the ExtensionAPI for an extension.
- * Registration methods write to the extension object.
- * Action methods delegate to the shared runtime.
- */
-function createExtensionAPI(
-	extension: Extension,
-	runtime: ExtensionRuntime,
-	cwd: string,
-	eventBus: EventBus,
-): ExtensionAPI {
-	const api = {
-		// Registration methods - write to extension
+/** Registration methods write to the extension object, action methods delegate to the shared runtime. */
+function createExtensionAPI(extension: Extension, runtime: ExtensionRuntime): ExtensionAPI {
+	return {
 		on(event: string, handler: HandlerFn): void {
 			runtime.assertActive();
 			const list = extension.handlers.get(event) ?? [];
@@ -231,75 +79,11 @@ function createExtensionAPI(
 			runtime.refreshTools();
 		},
 
-		registerCommand(name: string, options: Omit<RegisteredCommand, "name" | "sourceInfo">): void {
-			runtime.assertActive();
-			extension.commands.set(name, {
-				name,
-				sourceInfo: extension.sourceInfo,
-				...options,
-			});
-		},
-
-
-		registerFlag(
-			name: string,
-			options: { description?: string; type: "boolean" | "string"; default?: boolean | string },
-		): void {
-			runtime.assertActive();
-			extension.flags.set(name, { name, extensionPath: extension.path, ...options });
-			if (options.default !== undefined && !runtime.flagValues.has(name)) {
-				runtime.flagValues.set(name, options.default);
-			}
-		},
-
-		// Flag access - checks extension registered it, reads from runtime
-		getFlag(name: string): boolean | string | undefined {
-			runtime.assertActive();
-			if (!extension.flags.has(name)) return undefined;
-			return runtime.flagValues.get(name);
-		},
-
-		// Action methods - delegate to shared runtime
-		sendMessage(message, options): void {
-			runtime.assertActive();
-			runtime.sendMessage(message, options);
-		},
-
-		sendUserMessage(content, options): void {
-			runtime.assertActive();
-			runtime.sendUserMessage(content, options);
-		},
-
 		appendEntry(customType: string, data?: unknown): void {
 			runtime.assertActive();
 			runtime.appendEntry(customType, data);
 		},
 
-		setSessionName(name: string): void {
-			runtime.assertActive();
-			runtime.setSessionName(name);
-		},
-
-		getSessionName(): string | undefined {
-			runtime.assertActive();
-			return runtime.getSessionName();
-		},
-
-		setLabel(entryId: string, label: string | undefined): void {
-			runtime.assertActive();
-			runtime.setLabel(entryId, label);
-		},
-
-		exec(command: string, args: string[], options?: ExecOptions) {
-			runtime.assertActive();
-			return execCommand(command, args, options?.cwd ?? cwd, options);
-		},
-
-		getActiveTools(): string[] {
-			runtime.assertActive();
-			return runtime.getActiveTools();
-		},
-
 		getAllTools() {
 			runtime.assertActive();
 			return runtime.getAllTools();
@@ -309,152 +93,24 @@ function createExtensionAPI(
 			runtime.assertActive();
 			runtime.setActiveTools(toolNames);
 		},
-
-		getCommands() {
-			runtime.assertActive();
-			return runtime.getCommands();
-		},
-
-		setModel(model) {
-			runtime.assertActive();
-			return runtime.setModel(model);
-		},
-
-		getThinkingLevel() {
-			runtime.assertActive();
-			return runtime.getThinkingLevel();
-		},
-
-		setThinkingLevel(level) {
-			runtime.assertActive();
-			runtime.setThinkingLevel(level);
-		},
-
-		registerProvider(name: string, config: ProviderConfig) {
-			runtime.assertActive();
-			runtime.registerProvider(name, config, extension.path);
-		},
-
-		unregisterProvider(name: string) {
-			runtime.assertActive();
-			runtime.unregisterProvider(name, extension.path);
-		},
-
-		events: eventBus,
 	} as ExtensionAPI;
-
-	return api;
 }
 
-function isCurrentCacheToken(cacheToken: ExtensionCacheToken | undefined): cacheToken is ExtensionCacheToken {
-	return (
-		cacheToken !== undefined &&
-		extensionCacheCwd === cacheToken.cwd &&
-		extensionCacheGeneration === cacheToken.generation
-	);
-}
-
-async function loadExtensionModule(extensionPath: string, cacheToken?: ExtensionCacheToken) {
-	if (isCurrentCacheToken(cacheToken)) {
-		const cachedFactory = extensionCache.get(extensionPath);
-		if (cachedFactory) {
-			return cachedFactory;
-		}
-	}
-
-	const jiti = createJiti(import.meta.url, {
-		moduleCache: false,
-		// In Bun binary: use virtualModules for bundled packages (no filesystem resolution)
-		// Also disable tryNative so jiti handles ALL imports (not just the entry point)
-		// In Node.js/dev: use aliases to resolve to node_modules paths
-		...(isBunBinary ? { virtualModules: VIRTUAL_MODULES, tryNative: false } : { alias: getAliases() }),
-	});
-
-	const module = await jiti.import(extensionPath, { default: true });
-	const factory = module as ExtensionFactory;
-	if (typeof factory !== "function") {
-		return undefined;
-	}
-	if (isCurrentCacheToken(cacheToken)) {
-		extensionCache.set(extensionPath, factory);
-	}
-	return factory;
-}
-
-/**
- * Create an Extension object with empty collections.
- */
-function createExtension(extensionPath: string, resolvedPath: string): Extension {
-	const source =
-		extensionPath.startsWith("<") && extensionPath.endsWith(">")
-			? extensionPath.slice(1, -1).split(":")[0] || "temporary"
-			: "local";
-	const baseDir = extensionPath.startsWith("<") ? undefined : path.dirname(resolvedPath);
-
-	return {
-		path: extensionPath,
-		resolvedPath,
-		sourceInfo: createSyntheticSourceInfo(extensionPath, { source, baseDir }),
-		handlers: new Map(),
-		tools: new Map(),
-
-		commands: new Map(),
-		flags: new Map(),
-		
-	};
-}
-
-async function loadExtension(
-	extensionPath: string,
-	cwd: string,
-	eventBus: EventBus,
-	runtime: ExtensionRuntime,
-	cacheToken?: ExtensionCacheToken,
-	signal?: AbortSignal,
-	onFactorySettlement?: ExtensionFactorySettlementObserver,
-): Promise<{ extension: Extension | null; error: string | null }> {
-	const resolvedPath = resolvePath(extensionPath, cwd, { normalizeUnicodeSpaces: true });
-
-	try {
-		const factory = await awaitWithSignal(loadExtensionModule(resolvedPath, cacheToken), signal);
-		time(`${extensionPath} module import`, "extensions");
-		if (!factory) {
-			return { extension: null, error: `Extension does not export a valid factory function: ${extensionPath}` };
-		}
-
-		const extension = createExtension(extensionPath, resolvedPath);
-		const api = createExtensionAPI(extension, runtime, cwd, eventBus);
-		const factorySettlement = Promise.resolve(factory(api, { signal: signal ?? new AbortController().signal }));
-		onFactorySettlement?.(factorySettlement);
-		await awaitWithSignal(factorySettlement, signal);
-		time(`${extensionPath} factory`, "extensions");
-
-		return { extension, error: null };
-	} catch (err) {
-		if (signal?.aborted) {
-			runtime.invalidate("Extension creation was aborted.");
-			throw abortReason(signal);
-		}
-		const message = err instanceof Error ? err.message : String(err);
-		return { extension: null, error: `Failed to load extension: ${message}` };
-	}
-}
-
-/**
- * Create an Extension from an inline factory function.
- */
+/** Create an Extension from an inline factory function. */
 export async function loadExtensionFromFactory(
 	factory: ExtensionFactory,
-	cwd: string,
-	eventBus: EventBus,
 	runtime: ExtensionRuntime,
-	extensionPath = "<inline>",
+	extensionPath: string,
 	signal?: AbortSignal,
 	onFactorySettlement?: ExtensionFactorySettlementObserver,
 ): Promise<Extension> {
-	const extension = createExtension(extensionPath, extensionPath);
-	const resolvedCwd = resolvePath(cwd);
-	const api = createExtensionAPI(extension, runtime, resolvedCwd, eventBus);
+	const extension: Extension = {
+		path: extensionPath,
+		sourceInfo: createSyntheticSourceInfo(extensionPath, { source: "inline" }),
+		handlers: new Map(),
+		tools: new Map(),
+	};
+	const api = createExtensionAPI(extension, runtime);
 	try {
 		const factorySettlement = Promise.resolve(factory(api, { signal: signal ?? new AbortController().signal }));
 		onFactorySettlement?.(factorySettlement);
@@ -465,245 +121,5 @@ export async function loadExtensionFromFactory(
 		}
 		throw error;
 	}
-	time(`${extensionPath} factory`, "extensions");
 	return extension;
 }
-
-/**
- * Load extensions from paths.
- */
-async function loadExtensionsInternal(
-	paths: string[],
-	cwd: string,
-	eventBus?: EventBus,
-	runtime?: ExtensionRuntime,
-	useCache = false,
-	signal?: AbortSignal,
-	onFactorySettlement?: ExtensionFactorySettlementObserver,
-): Promise<LoadExtensionsResult> {
-	const extensions: Extension[] = [];
-	const errors: Array<{ path: string; error: string }> = [];
-	const cacheToken = useCache ? useExtensionCacheCwd(cwd) : undefined;
-	const resolvedCwd = cacheToken?.cwd ?? resolvePath(cwd);
-	const resolvedEventBus = eventBus ?? createEventBus();
-	const resolvedRuntime = runtime ?? createExtensionRuntime();
-	if (signal?.aborted) {
-		resolvedRuntime.invalidate("Extension creation was aborted.");
-		throw abortReason(signal);
-	}
-
-	for (const extPath of paths) {
-		const { extension, error } = await loadExtension(
-			extPath,
-			resolvedCwd,
-			resolvedEventBus,
-			resolvedRuntime,
-			cacheToken,
-			signal,
-			onFactorySettlement,
-		);
-
-		if (error) {
-			errors.push({ path: extPath, error });
-			continue;
-		}
-
-		if (extension) {
-			extensions.push(extension);
-		}
-	}
-	if (signal?.aborted) {
-		resolvedRuntime.invalidate("Extension creation was aborted.");
-		throw abortReason(signal);
-	}
-
-	return {
-		extensions,
-		errors,
-		runtime: resolvedRuntime,
-	};
-}
-
-export async function loadExtensions(
-	paths: string[],
-	cwd: string,
-	eventBus?: EventBus,
-	runtime?: ExtensionRuntime,
-	signal?: AbortSignal,
-	onFactorySettlement?: ExtensionFactorySettlementObserver,
-): Promise<LoadExtensionsResult> {
-	return loadExtensionsInternal(paths, cwd, eventBus, runtime, false, signal, onFactorySettlement);
-}
-
-export async function loadExtensionsCached(
-	paths: string[],
-	cwd: string,
-	eventBus?: EventBus,
-	runtime?: ExtensionRuntime,
-	signal?: AbortSignal,
-	onFactorySettlement?: ExtensionFactorySettlementObserver,
-): Promise<LoadExtensionsResult> {
-	return loadExtensionsInternal(paths, cwd, eventBus, runtime, true, signal, onFactorySettlement);
-}
-
-interface AgentManifest {
-	extensions?: string[];
-	themes?: string[];
-	skills?: string[];
-	prompts?: string[];
-}
-
-function readAgentManifest(packageJsonPath: string): AgentManifest | null {
-	try {
-		const content = fs.readFileSync(packageJsonPath, "utf-8");
-		const pkg = JSON.parse(content);
-		if (pkg.agent && typeof pkg.agent === "object") {
-			return pkg.agent as AgentManifest;
-		}
-		return null;
-	} catch {
-		return null;
-	}
-}
-
-function isExtensionFile(name: string): boolean {
-	return name.endsWith(".ts") || name.endsWith(".js");
-}
-
-/**
- * Resolve extension entry points from a directory.
- *
- * Checks for:
- * 1. package.json with "agent.extensions" field -> returns declared paths
- * 2. index.ts or index.js -> returns the index file
- *
- * Returns resolved paths or null if no entry points found.
- */
-function resolveExtensionEntries(dir: string): string[] | null {
-	// Check for package.json with "agent" field first
-	const packageJsonPath = path.join(dir, "package.json");
-	if (fs.existsSync(packageJsonPath)) {
-		const manifest = readAgentManifest(packageJsonPath);
-		if (manifest?.extensions?.length) {
-			const entries: string[] = [];
-			for (const extPath of manifest.extensions) {
-				const resolvedExtPath = path.resolve(dir, extPath);
-				if (fs.existsSync(resolvedExtPath)) {
-					entries.push(resolvedExtPath);
-				}
-			}
-			if (entries.length > 0) {
-				return entries;
-			}
-		}
-	}
-
-	// Check for index.ts or index.js
-	const indexTs = path.join(dir, "index.ts");
-	const indexJs = path.join(dir, "index.js");
-	if (fs.existsSync(indexTs)) {
-		return [indexTs];
-	}
-	if (fs.existsSync(indexJs)) {
-		return [indexJs];
-	}
-
-	return null;
-}
-
-/**
- * Discover extensions in a directory.
- *
- * Discovery rules:
- * 1. Direct files: `extensions/*.ts` or `*.js` -> load
- * 2. Subdirectory with index: `extensions/* /index.ts` or `index.js` -> load
- * 3. Subdirectory with package.json: `extensions/* /package.json` with "agent" field -> load what it declares
- *
- * No recursion beyond one level. Complex packages must use package.json manifest.
- */
-function discoverExtensionsInDir(dir: string): string[] {
-	if (!fs.existsSync(dir)) {
-		return [];
-	}
-
-	const discovered: string[] = [];
-
-	try {
-		const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-		for (const entry of entries) {
-			const entryPath = path.join(dir, entry.name);
-
-			// 1. Direct files: *.ts or *.js
-			if ((entry.isFile() || entry.isSymbolicLink()) && isExtensionFile(entry.name)) {
-				discovered.push(entryPath);
-				continue;
-			}
-
-			// 2 & 3. Subdirectories
-			if (entry.isDirectory() || entry.isSymbolicLink()) {
-				const entries = resolveExtensionEntries(entryPath);
-				if (entries) {
-					discovered.push(...entries);
-				}
-			}
-		}
-	} catch {
-		return [];
-	}
-
-	return discovered;
-}
-
-/**
- * Discover and load extensions from standard locations.
- */
-export async function discoverAndLoadExtensions(
-	configuredPaths: string[],
-	cwd: string,
-	agentDir: string = getAgentDir(),
-	eventBus?: EventBus,
-): Promise<LoadExtensionsResult> {
-	const resolvedCwd = resolvePath(cwd);
-	const resolvedAgentDir = resolvePath(agentDir);
-	const allPaths: string[] = [];
-	const seen = new Set<string>();
-
-	const addPaths = (paths: string[]) => {
-		for (const p of paths) {
-			const resolved = path.resolve(p);
-			if (!seen.has(resolved)) {
-				seen.add(resolved);
-				allPaths.push(p);
-			}
-		}
-	};
-
-	// 1. Project-local extensions: cwd/${CONFIG_DIR_NAME}/extensions/
-	const localExtDir = path.join(resolvedCwd, CONFIG_DIR_NAME, "extensions");
-	addPaths(discoverExtensionsInDir(localExtDir));
-
-	// 2. Global extensions: agentDir/extensions/
-	const globalExtDir = path.join(resolvedAgentDir, "extensions");
-	addPaths(discoverExtensionsInDir(globalExtDir));
-
-	// 3. Explicitly configured paths
-	for (const p of configuredPaths) {
-		const resolved = resolvePath(p, resolvedCwd, { normalizeUnicodeSpaces: true });
-		if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) {
-			// Check for package.json with agent manifest or index.ts
-			const entries = resolveExtensionEntries(resolved);
-			if (entries) {
-				addPaths(entries);
-				continue;
-			}
-			// No explicit entries - discover individual files in directory
-			addPaths(discoverExtensionsInDir(resolved));
-			continue;
-		}
-
-		addPaths([resolved]);
-	}
-
-	return loadExtensions(allPaths, resolvedCwd, eventBus);
-}