@atomic-ehr/fhir-canonical-manager 0.0.8 → 0.0.9

package/src/index.ts

@@ -1,998 +1,21 @@
 /**
- * FHIR Canonical Manager - Functional Implementation
+ * FHIR Canonical Manager - Modular Implementation
  * A package manager for FHIR resources with canonical URL resolution
  */
 
-import * as path from "path";
-import * as fs from "fs/promises";
-import { createHash } from "crypto";
-import { exec } from "child_process";
-import { promisify } from "util";
+// Re-export all public types
+export * from './types';
 
-// Shell command utilities
-const execAsync = promisify(exec);
+// Re-export reference management
+export { createReferenceManager, ReferenceManagerFactory as ReferenceManager } from './reference';
+export type { ReferenceManager as ReferenceManagerType } from './reference';
 
-// Shell error type
-class ShellError extends Error {
-  exitCode: number;
-  stdout: string;
-  stderr: string;
+// Re-export main CanonicalManager
+export { CanonicalManager, createCanonicalManager } from './manager';
 
-  constructor(
-    message: string,
-    exitCode: number,
-    stdout: string,
-    stderr: string,
-  ) {
-    super(message);
-    this.name = "ShellError";
-    this.exitCode = exitCode;
-    this.stdout = stdout;
-    this.stderr = stderr;
-  }
-}
+// Type export for CanonicalManager (the interface is already exported from types)
+// CanonicalManager function is exported from manager as a factory function
 
-interface ShellResult {
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-}
-
-interface ShellPromise extends Promise<ShellResult> {
-  quiet(): Promise<ShellResult>;
-  env(variables: Record<string, string>): ShellPromise;
-}
-
-/**
- * Shell command execution using standard Node.js child_process
- */
-function $(strings: TemplateStringsArray, ...values: any[]): ShellPromise {
-  const command = strings.reduce((acc, str, i) => {
-    return acc + str + (values[i] || "");
-  }, "");
-
-  let envVars: Record<string, string> = {};
-
-  // Always use Node.js child_process for consistent behavior
-  const execute = async (options: { quiet?: boolean } = {}) => {
-    try {
-      const execOptions: any = {
-        shell: true,
-        maxBuffer: 10 * 1024 * 1024, // 10MB buffer
-      };
-
-      // Apply environment variables if set
-      if (Object.keys(envVars).length > 0) {
-        execOptions.env = { ...process.env, ...envVars };
-      }
-
-      const { stdout, stderr } = await execAsync(command, execOptions);
-
-      return {
-        stdout: stdout?.toString() || "",
-        stderr: stderr?.toString() || "",
-        exitCode: 0,
-      };
-    } catch (error: any) {
-      // Extract error details
-      const code = error.code || 1;
-      const stdout = error.stdout?.toString() || "";
-      const stderr = error.stderr?.toString() || error.message || "";
-
-      throw new ShellError(`Command failed: ${command}`, code, stdout, stderr);
-    }
-  };
-
-  // Create a lazy promise that only executes when awaited
-  let executed = false;
-  let resultPromise: Promise<ShellResult> | null = null;
-
-  const lazyPromise = {
-    then(onFulfilled?: any, onRejected?: any) {
-      if (!executed) {
-        executed = true;
-        resultPromise = execute();
-      }
-      return resultPromise!.then(onFulfilled, onRejected);
-    },
-    catch(onRejected?: any) {
-      return this.then(undefined, onRejected);
-    },
-    finally(onFinally?: any) {
-      return this.then(
-        (value: any) => {
-          onFinally?.();
-          return value;
-        },
-        (reason: any) => {
-          onFinally?.();
-          throw reason;
-        },
-      );
-    },
-    quiet() {
-      return execute({ quiet: true });
-    },
-    env(vars: Record<string, string>) {
-      envVars = vars;
-      return this;
-    },
-    // Add Symbol.toStringTag to satisfy Promise interface
-    [Symbol.toStringTag]: "ShellPromise" as const,
-  };
-
-  return lazyPromise as any as ShellPromise;
-}
-
-/**
- * Detect available package manager
- */
-async function detectPackageManager(): Promise<"bun" | "npm" | null> {
-  try {
-    // Check for bun first
-    await $`bun --version`.quiet();
-    return "bun";
-  } catch {
-    try {
-      // Fall back to npm
-      await $`npm --version`.quiet();
-      return "npm";
-    } catch {
-      return null;
-    }
-  }
-}
-
-// Export shell utilities for testing
-export { ShellError, detectPackageManager };
-
-// Types
-export interface Reference {
-  id: string;
-  resourceType: string;
-}
-
-export interface PackageId {
-  name: string;
-  version: string;
-}
-
-export interface IndexEntry extends Reference {
-  indexVersion: number;
-  kind?: string;
-  url?: string;
-  type?: string;
-  version?: string;
-  package?: PackageId;
-}
-
-export interface Resource extends Reference {
-  url?: string;
-  version?: string;
-  [key: string]: any;
-}
-
-export interface SourceContext {
-  id?: string;
-  package?: PackageId;
-  url?: string;
-  path?: string;
-}
-
-export interface Config {
-  packages: string[];
-  workingDir: string;
-  registry?: string;
-}
-
-export interface CanonicalManager {
-  init(): Promise<void>;
-  destroy(): Promise<void>;
-  packages(): Promise<PackageId[]>;
-  resolveEntry(
-    canonicalUrl: string,
-    options?: {
-      package?: string;
-      version?: string;
-      sourceContext?: SourceContext;
-    },
-  ): Promise<IndexEntry>;
-  resolve(
-    canonicalUrl: string,
-    options?: {
-      package?: string;
-      version?: string;
-      sourceContext?: SourceContext;
-    },
-  ): Promise<Resource>;
-  read(reference: Reference): Promise<Resource>;
-  searchEntries(params: {
-    kind?: string;
-    url?: string;
-    type?: string;
-    version?: string;
-    package?: PackageId;
-  }): Promise<IndexEntry[]>;
-  search(params: {
-    kind?: string;
-    url?: string;
-    type?: string;
-    version?: string;
-    package?: PackageId;
-  }): Promise<Resource[]>;
-  smartSearch(
-    searchTerms: string[],
-    filters?: {
-      resourceType?: string;
-      type?: string;
-      kind?: string;
-      package?: PackageId;
-    }
-  ): Promise<IndexEntry[]>;
-}
-
-// Internal types
-interface IndexFile {
-  "index-version": number;
-  files: IndexFileEntry[];
-}
-
-interface IndexFileEntry {
-  filename: string;
-  resourceType: string;
-  id: string;
-  url?: string;
-  version?: string;
-  kind?: string;
-  type?: string;
-}
-
-interface PackageJson {
-  name: string;
-  version: string;
-  fhirVersions?: string[];
-  type?: string;
-  canonical?: string;
-  dependencies?: Record<string, string>;
-}
-
-export interface PackageInfo {
-  id: PackageId;
-  path: string;
-  canonical?: string;
-  fhirVersions?: string[];
-}
-
-interface ReferenceMetadata {
-  packageName: string;
-  packageVersion: string;
-  filePath: string;
-  resourceType: string;
-  url?: string;
-  version?: string;
-}
-
-interface IndexCache {
-  entries: Record<string, IndexEntry[]>;
-  packages: Record<string, PackageInfo>;
-  references: Record<string, ReferenceMetadata>;
-}
-
-interface CacheData {
-  entries: Record<string, IndexEntry[]>;
-  packages: Record<string, PackageInfo>;
-  references: Record<string, ReferenceMetadata>;
-  packageLockHash?: string; // Hash of package-lock.json to detect changes
-}
-
-// Reference management functions
-export interface ReferenceStore {
-  get(id: string): ReferenceMetadata | undefined;
-  set(id: string, metadata: ReferenceMetadata): void;
-  has(id: string): boolean;
-  clear(): void;
-  size(): number;
-}
-
-export type { ReferenceMetadata };
-
-const generateReferenceId = (metadata: {
-  packageName: string;
-  packageVersion: string;
-  filePath: string;
-}): string => {
-  const input = `${metadata.packageName}@${metadata.packageVersion}:${metadata.filePath}`;
-  return createHash("sha256").update(input).digest("base64url");
-};
-
-export const ReferenceManager = (): ReferenceStore & {
-  generateId: typeof generateReferenceId;
-  getIdsByUrl: (url: string) => string[];
-  createReference: (id: string, metadata: ReferenceMetadata) => Reference;
-  getAllReferences: () => Record<string, ReferenceMetadata>;
-} => {
-  const references: Record<string, ReferenceMetadata> = {};
-  const urlToIds: Record<string, string[]> = {};
-
-  const set = (id: string, metadata: ReferenceMetadata): void => {
-    references[id] = metadata;
-    if (metadata.url) {
-      if (!urlToIds[metadata.url]) {
-        urlToIds[metadata.url] = [];
-      }
-      const ids = urlToIds[metadata.url];
-      if (ids && !ids.includes(id)) {
-        ids.push(id);
-      }
-    }
-  };
-
-  const clear = (): void => {
-    Object.keys(references).forEach((key) => delete references[key]);
-    Object.keys(urlToIds).forEach((key) => delete urlToIds[key]);
-  };
-
-  return {
-    generateId: generateReferenceId,
-    get: (id: string) => references[id],
-    set,
-    has: (id: string) => id in references,
-    clear,
-    size: () => Object.keys(references).length,
-    getIdsByUrl: (url: string) => urlToIds[url] || [],
-    createReference: (id: string, metadata: ReferenceMetadata): Reference => ({
-      id,
-      resourceType: metadata.resourceType,
-    }),
-    getAllReferences: () => references,
-  };
-};
-
-// Parser functions
-const isValidFileEntry = (entry: any): boolean => {
-  if (!entry || typeof entry !== "object") return false;
-  if (!entry.filename || typeof entry.filename !== "string") return false;
-  if (!entry.resourceType || typeof entry.resourceType !== "string")
-    return false;
-  if (!entry.id || typeof entry.id !== "string") return false;
-
-  const optionalStringFields = ["url", "version", "kind", "type"];
-  for (const field of optionalStringFields) {
-    if (entry[field] !== undefined && typeof entry[field] !== "string") {
-      return false;
-    }
-  }
-
-  return true;
-};
-
-const isValidIndexFile = (data: any): boolean => {
-  if (!data || typeof data !== "object") return false;
-  if (!data["index-version"] || typeof data["index-version"] !== "number")
-    return false;
-  if (!Array.isArray(data.files)) return false;
-  return data.files.every((file: any) => isValidFileEntry(file));
-};
-
-const parseIndex = (content: string, filePath: string): IndexFile | null => {
-  try {
-    const data = JSON.parse(content);
-    if (!isValidIndexFile(data)) {
-      return null;
-    }
-    return data as IndexFile;
-  } catch {
-    return null;
-  }
-};
-
-// File system utilities
-const fileExists = async (filePath: string): Promise<boolean> => {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-const ensureDir = async (dirPath: string): Promise<void> => {
-  try {
-    await fs.mkdir(dirPath, { recursive: true });
-  } catch {
-    // Ignore errors
-  }
-};
-
-const isFhirPackage = async (dirPath: string): Promise<boolean> => {
-  const indexPath = path.join(dirPath, ".index.json");
-  return fileExists(indexPath);
-};
-
-// Cache creation
-const createCache = (): IndexCache & {
-  referenceManager: ReturnType<typeof ReferenceManager>;
-} => {
-  const referenceManager = ReferenceManager();
-  return {
-    entries: {},
-    packages: {},
-    references: {},
-    referenceManager,
-  };
-};
-
-// Compute hash of package-lock.json or bun.lock for cache validation
-const computePackageLockHash = async (
-  workingDir: string,
-): Promise<string | null> => {
-  try {
-    // Try package-lock.json first
-    const packageLockPath = path.join(workingDir, "package-lock.json");
-    try {
-      const content = await fs.readFile(packageLockPath, "utf-8");
-      return createHash("sha256").update(content).digest("hex");
-    } catch {
-      // Try bun.lock if package-lock.json doesn't exist
-      const bunLockPath = path.join(workingDir, "bun.lock");
-      const content = await fs.readFile(bunLockPath, "utf-8");
-      return createHash("sha256").update(content).digest("hex");
-    }
-  } catch {
-    return null;
-  }
-};
-
-// Cache persistence functions
-const saveCacheToDisk = async (
-  cache: ReturnType<typeof createCache>,
-  cacheDir: string,
-  workingDir: string,
-): Promise<void> => {
-  const packageLockHash = await computePackageLockHash(workingDir);
-
-  const cacheData: CacheData = {
-    entries: cache.entries,
-    packages: cache.packages,
-    references: cache.referenceManager.getAllReferences(),
-    packageLockHash: packageLockHash || undefined,
-  };
-
-  const cachePath = path.join(cacheDir, "index.json");
-  await fs.writeFile(cachePath, JSON.stringify(cacheData, null, 2));
-};
-
-const loadCacheFromDisk = async (
-  cacheDir: string,
-): Promise<CacheData | null> => {
-  try {
-    const cachePath = path.join(cacheDir, "index.json");
-    const content = await fs.readFile(cachePath, "utf-8");
-    return JSON.parse(content) as CacheData;
-  } catch {
-    return null;
-  }
-};
-
-// Package management functions
-const installPackages = async (
-  packages: string[],
-  workingDir: string,
-  registry?: string,
-): Promise<void> => {
-  await ensureDir(workingDir);
-
-  // Check if package.json exists
-  const packageJsonPath = path.join(workingDir, "package.json");
-  if (!(await fileExists(packageJsonPath))) {
-    // Create minimal package.json
-    const minimalPackageJson = {
-      name: "fhir-canonical-manager-workspace",
-      version: "1.0.0",
-      private: true,
-      dependencies: {},
-    };
-    await fs.writeFile(
-      packageJsonPath,
-      JSON.stringify(minimalPackageJson, null, 2),
-    );
-  }
-
-  // Detect available package manager
-  const packageManager = await detectPackageManager();
-  if (!packageManager) {
-    throw new Error("No package manager found. Please install npm or bun.");
-  }
-
-  // Install packages
-  for (const pkg of packages) {
-    try {
-      if (packageManager === "bun") {
-        // Use bun with auth bypass trick for FHIR registry
-        const env = {
-          HOME: workingDir, // Prevent reading user's .npmrc
-          NPM_CONFIG_USERCONFIG: "/dev/null", // Extra safety
-        };
-
-        const cmd = registry
-          ? `cd ${workingDir} && bun add ${pkg} --registry ${registry}`
-          : `cd ${workingDir} && bun add ${pkg}`;
-
-        await $`${cmd}`.env(env);
-      } else {
-        // Use npm (handles auth correctly)
-        const cmd = registry
-          ? `cd ${workingDir} && npm add ${pkg} --registry ${registry}`
-          : `cd ${workingDir} && npm add ${pkg}`;
-
-        await $`${cmd}`;
-      }
-    } catch (err) {
-      console.error(`Failed to install package ${pkg}:`, err);
-      throw err;
-    }
-  }
-};
-
-// Package processing functions
-const processIndex = async (
-  basePath: string,
-  packageJson: PackageJson,
-  cache: ReturnType<typeof createCache>,
-): Promise<void> => {
-  const indexPath = path.join(basePath, ".index.json");
-
-  try {
-    const indexContent = await fs.readFile(indexPath, "utf-8");
-    const index = parseIndex(indexContent, indexPath);
-
-    if (!index) return;
-
-    for (const file of index.files) {
-      if (!file.url) continue;
-
-      const filePath = path.join(basePath, file.filename);
-
-      const id = cache.referenceManager.generateId({
-        packageName: packageJson.name,
-        packageVersion: packageJson.version,
-        filePath,
-      });
-
-      cache.referenceManager.set(id, {
-        packageName: packageJson.name,
-        packageVersion: packageJson.version,
-        filePath,
-        resourceType: file.resourceType,
-        url: file.url,
-        version: file.version,
-      });
-
-      const entry: IndexEntry = {
-        id,
-        resourceType: file.resourceType,
-        indexVersion: index["index-version"],
-        url: file.url,
-        version: file.version,
-        kind: file.kind,
-        type: file.type,
-        package: {
-          name: packageJson.name,
-          version: packageJson.version,
-        },
-      };
-
-      if (!cache.entries[file.url]) {
-        cache.entries[file.url] = [];
-      }
-      const entries = cache.entries[file.url];
-      if (entries) {
-        entries.push(entry);
-      }
-    }
-  } catch {
-    // Silently ignore index processing errors
-  }
-};
-
-const scanPackage = async (
-  packagePath: string,
-  cache: ReturnType<typeof createCache>,
-): Promise<void> => {
-  try {
-    const packageJsonPath = path.join(packagePath, "package.json");
-    const packageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
-    const packageJson: PackageJson = JSON.parse(packageJsonContent);
-
-    const packageInfo: PackageInfo = {
-      id: { name: packageJson.name, version: packageJson.version },
-      path: packagePath,
-      canonical: packageJson.canonical,
-      fhirVersions: packageJson.fhirVersions,
-    };
-    cache.packages[packageJson.name] = packageInfo;
-
-    await processIndex(packagePath, packageJson, cache);
-
-    const examplesPath = path.join(packagePath, "examples");
-    if (await fileExists(path.join(examplesPath, ".index.json"))) {
-      await processIndex(examplesPath, packageJson, cache);
-    }
-  } catch {
-    // Silently ignore package scan errors
-  }
-};
-
-const scanDirectory = async (
-  dirPath: string,
-  cache: ReturnType<typeof createCache>,
-): Promise<void> => {
-  try {
-    const entries = await fs.readdir(dirPath, { withFileTypes: true });
-
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-
-      const fullPath = path.join(dirPath, entry.name);
-
-      if (entry.name.startsWith("@")) {
-        const scopedEntries = await fs.readdir(fullPath, {
-          withFileTypes: true,
-        });
-        for (const scopedEntry of scopedEntries) {
-          if (!scopedEntry.isDirectory()) continue;
-
-          const scopedPath = path.join(fullPath, scopedEntry.name);
-          if (await isFhirPackage(scopedPath)) {
-            await scanPackage(scopedPath, cache);
-          }
-        }
-      } else if (await isFhirPackage(fullPath)) {
-        await scanPackage(fullPath, cache);
-      }
-    }
-  } catch {
-    // Silently ignore scan errors
-  }
-};
-
-// Resolution functions
-const resolveWithContext = async (
-  url: string,
-  context: SourceContext,
-  cache: ReturnType<typeof createCache>,
-  resolveEntry: (url: string, options?: any) => Promise<IndexEntry>,
-): Promise<IndexEntry | null> => {
-  if (context.package) {
-    try {
-      return await resolveEntry(url, {
-        package: context.package.name,
-        version: context.package.version,
-      });
-    } catch {
-      // Fall through to global resolution
-    }
-  }
-  return null;
-};
-
-// Default FHIR package registry
-const DEFAULT_REGISTRY = "https://fs.get-ig.org/pkgs/";
-
-// Main implementation
-export const CanonicalManager = (config: Config): CanonicalManager => {
-  const { packages, workingDir } = config;
-  // Ensure registry URL ends with /
-  const registry = config.registry 
-    ? config.registry.endsWith('/') ? config.registry : `${config.registry}/`
-    : DEFAULT_REGISTRY;
-  const nodeModulesPath = path.join(workingDir, "node_modules");
-  const cacheDir = path.join(workingDir, ".fcm", "cache");
-
-  let cache = createCache();
-  let initialized = false;
-
-  const ensureInitialized = (): void => {
-    if (!initialized) {
-      throw new Error("CanonicalManager not initialized. Call init() first.");
-    }
-  };
-
-  const init = async (): Promise<void> => {
-    if (initialized) return;
-
-    // Ensure directories exist
-    await ensureDir(workingDir);
-    await ensureDir(cacheDir);
-
-    // Get current package-lock.json hash
-    const currentPackageLockHash = await computePackageLockHash(workingDir);
-
-    // Try to load cache from disk
-    const cachedData = await loadCacheFromDisk(cacheDir);
-
-    // Check if cache is valid (exists and package-lock.json hasn't changed)
-    const cacheValid =
-      cachedData &&
-      cachedData.packageLockHash === currentPackageLockHash &&
-      currentPackageLockHash !== null;
-
-    if (cacheValid) {
-      // Restore cache from disk
-      cache.entries = cachedData.entries;
-      cache.packages = cachedData.packages;
-      Object.entries(cachedData.references).forEach(([id, metadata]) => {
-        cache.referenceManager.set(id, metadata);
-      });
-    } else {
-      // Cache is invalid or doesn't exist - rebuild it
-      if (cachedData && cachedData.packageLockHash !== currentPackageLockHash) {
-        console.log("Package dependencies have changed, rebuilding index...");
-      }
-
-      // Install packages if needed
-      await installPackages(packages, workingDir, registry);
-
-      // Clear cache before scanning
-      cache = createCache();
-
-      // Scan installed packages
-      await scanDirectory(nodeModulesPath, cache);
-
-      // Save cache to disk with current package-lock hash
-      await saveCacheToDisk(cache, cacheDir, workingDir);
-    }
-
-    initialized = true;
-  };
-
-  const destroy = async (): Promise<void> => {
-    cache.entries = {};
-    cache.packages = {};
-    cache.referenceManager.clear();
-    initialized = false;
-  };
-
-  const getPackages = async (): Promise<PackageId[]> => {
-    ensureInitialized();
-    return Object.values(cache.packages).map((p) => p.id);
-  };
-
-  const resolveEntry = async (
-    canonicalUrl: string,
-    options?: {
-      package?: string;
-      version?: string;
-      sourceContext?: SourceContext;
-    },
-  ): Promise<IndexEntry> => {
-    ensureInitialized();
-
-    if (options?.sourceContext) {
-      const contextResolved = await resolveWithContext(
-        canonicalUrl,
-        options.sourceContext,
-        cache,
-        resolveEntry,
-      );
-      if (contextResolved) {
-        return contextResolved;
-      }
-    }
-
-    const entries = cache.entries[canonicalUrl] || [];
-
-    if (entries.length === 0) {
-      throw new Error(`Cannot resolve canonical URL: ${canonicalUrl}`);
-    }
-
-    let filtered = [...entries];
-
-    if (options?.package) {
-      filtered = filtered.filter((e) => e.package?.name === options.package);
-    }
-
-    if (options?.version) {
-      filtered = filtered.filter((e) => e.version === options.version);
-    }
-
-    if (filtered.length === 0) {
-      throw new Error(
-        `No matching resource found for ${canonicalUrl} with given options`,
-      );
-    }
-
-    return filtered[0]!;
-  };
-
-  const resolve = async (
-    canonicalUrl: string,
-    options?: {
-      package?: string;
-      version?: string;
-      sourceContext?: SourceContext;
-    },
-  ): Promise<Resource> => {
-    const entry = await resolveEntry(canonicalUrl, options);
-    return read(entry);
-  };
-
-  const read = async (reference: Reference): Promise<Resource> => {
-    ensureInitialized();
-
-    const metadata = cache.referenceManager.get(reference.id);
-    if (!metadata) {
-      throw new Error(`Invalid reference ID: ${reference.id}`);
-    }
-
-    try {
-      const content = await fs.readFile(metadata.filePath, "utf-8");
-      const resource = JSON.parse(content);
-
-      return {
-        ...resource,
-        id: reference.id,
-        resourceType: reference.resourceType,
-      };
-    } catch (err) {
-      throw new Error(`Failed to read resource: ${err}`);
-    }
-  };
-
-  const searchEntries = async (params: {
-    kind?: string;
-    url?: string;
-    type?: string;
-    version?: string;
-    package?: PackageId;
-  }): Promise<IndexEntry[]> => {
-    ensureInitialized();
-
-    let results: IndexEntry[] = [];
-
-    if (params.url) {
-      results = cache.entries[params.url] || [];
-    } else {
-      for (const entries of Object.values(cache.entries)) {
-        results.push(...entries);
-      }
-    }
-
-    if (params.kind !== undefined) {
-      results = results.filter((e) => e.kind === params.kind);
-    }
-
-    if (params.type !== undefined) {
-      results = results.filter((e) => e.type === params.type);
-    }
-
-    if (params.version !== undefined) {
-      results = results.filter((e) => e.version === params.version);
-    }
-
-    if (params.package) {
-      const pkg = params.package;
-      results = results.filter(
-        (e) =>
-          e.package?.name === pkg.name && e.package?.version === pkg.version,
-      );
-    }
-
-    return results;
-  };
-
-  const search = async (params: {
-    kind?: string;
-    url?: string;
-    type?: string;
-    version?: string;
-    package?: PackageId;
-  }): Promise<Resource[]> => {
-    const entries = await searchEntries(params);
-    const resources = await Promise.all(entries.map((entry) => read(entry)));
-    return resources;
-  };
-
-  const smartSearch = async (
-    searchTerms: string[],
-    filters?: {
-      resourceType?: string;
-      type?: string;
-      kind?: string;
-      package?: PackageId;
-    }
-  ): Promise<IndexEntry[]> => {
-    ensureInitialized();
-    
-    // Start with base search using filters
-    let results = await searchEntries({
-      kind: filters?.kind,
-      package: filters?.package,
-    });
-
-    // Apply resourceType filter
-    if (filters?.resourceType) {
-      results = results.filter(entry => entry.resourceType === filters.resourceType);
-    }
-
-    // Apply type filter
-    if (filters?.type) {
-      results = results.filter(entry => entry.type === filters.type);
-    }
-
-    // Apply smart search terms if provided
-    if (searchTerms.length > 0) {
-      const terms = searchTerms.map(t => t.toLowerCase());
-      
-      results = results.filter(entry => {
-        if (!entry.url) return false;
-        const urlLower = entry.url.toLowerCase();
-        
-        // Also check type and resourceType for matching
-        const fullText = [
-          urlLower,
-          entry.type?.toLowerCase() || '',
-          entry.resourceType?.toLowerCase() || ''
-        ].join(' ');
-        
-        // Check if all search terms match
-        return terms.every(term => {
-          // Split the text into parts (by /, -, _, ., spaces)
-          const allParts = fullText.split(/[\/\-_\.\s]+/);
-          
-          // Check if any part starts with the search term
-          const directMatch = allParts.some(part => part.startsWith(term));
-          if (directMatch) return true;
-          
-          // Smart matching for common abbreviations
-          const expandedTerms: Record<string, string[]> = {
-            'str': ['structure'],
-            'struct': ['structure'],
-            'def': ['definition'],
-            'pati': ['patient'],
-            'obs': ['observation'],
-            'org': ['organization'],
-            'pract': ['practitioner'],
-            'med': ['medication', 'medicinal'],
-            'req': ['request'],
-            'resp': ['response'],
-            'ref': ['reference'],
-            'val': ['value'],
-            'code': ['codesystem', 'code'],
-            'cs': ['codesystem'],
-            'vs': ['valueset'],
-            'sd': ['structuredefinition'],
-          };
-          
-          // Check if the term is an abbreviation
-          const expansions = expandedTerms[term] || [];
-          for (const expansion of expansions) {
-            if (allParts.some(part => part.startsWith(expansion))) {
-              return true;
-            }
-          }
-          
-          // If still no match, check if the term appears anywhere (substring match)
-          return fullText.includes(term);
-        });
-      });
-    }
-
-    return results;
-  };
-
-  return {
-    init,
-    destroy,
-    packages: getPackages,
-    resolveEntry,
-    resolve,
-    read,
-    searchEntries,
-    search,
-    smartSearch,
-  };
-};
-
-// Default export
-export default CanonicalManager;
+// Default export for backward compatibility
+import { createCanonicalManager } from './manager';
+export default createCanonicalManager;