@atomic-ehr/fhir-canonical-manager 0.0.13 → 0.0.14

package/src/package.ts

@@ -0,0 +1,79 @@
+/**
+ * Package management functionality
+ * Merged from package/detector.ts, package/installer.ts, and package/index.ts
+ */
+
+import { exec } from "node:child_process";
+import * as afs from "node:fs/promises";
+import * as Path from "node:path";
+import { promisify } from "node:util";
+import { ensureDir, fileExists } from "./fs/index.js";
+
+const execAsync = promisify(exec);
+
+export type PackageManager = "bun" | "npm";
+
+export const detectPackageManager = async (): Promise<PackageManager | undefined> => {
+    try {
+        await execAsync("bun --version");
+        return "bun";
+    } catch {
+        try {
+            await execAsync("npm --version");
+            return "npm";
+        } catch {
+            return;
+        }
+    }
+};
+
+const ensurePackageJson = async (pwd: string) => {
+    const packageJsonPath = Path.join(pwd, "package.json");
+    if (!(await fileExists(packageJsonPath))) {
+        const minimalPackageJson = {
+            name: "fhir-canonical-manager-workspace",
+            version: "1.0.0",
+            private: true,
+            dependencies: {},
+        };
+        await afs.writeFile(packageJsonPath, JSON.stringify(minimalPackageJson, null, 2));
+    }
+};
+
+export const installPackages = async (packages: string[], pwd: string, registry?: string): Promise<void> => {
+    await ensureDir(pwd);
+    ensurePackageJson(pwd);
+
+    const packageManager = await detectPackageManager();
+    if (!packageManager) throw new Error("No package manager found. Please install bun or npm.");
+
+    for (const pkg of packages) {
+        try {
+            if (packageManager === "bun") {
+                // Use bun with auth bypass trick for FHIR registry
+                const env = {
+                    ...process.env,
+                    HOME: pwd, // Prevent reading user's .npmrc
+                    NPM_CONFIG_USERCONFIG: "/dev/null", // Extra safety
+                };
+
+                const cmd = registry
+                    ? `bun add ${pkg} --cwd='${pwd}' --registry='${registry}'`
+                    : `bun add --cwd='${pwd}' ${pkg}`;
+                await execAsync(cmd, {
+                    env,
+                    maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+                });
+            } else {
+                // Use npm (handles auth correctly)
+                const cmd = registry ? `cd ${pwd} && npm add ${pkg} --registry=${registry}` : `npm add ${pkg}`;
+                await execAsync(cmd, {
+                    maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+                });
+            }
+        } catch (err) {
+            console.error(`Failed to install package ${pkg}:`, err);
+            throw err;
+        }
+    }
+};

package/src/reference/index.ts

@@ -2,9 +2,7 @@
  * Reference management exports
  */
 
-export { generateReferenceId } from './store.js';
-export { createReferenceManager } from './manager.js';
-export type { ReferenceManager } from './manager.js';
-
+export type { ReferenceManager } from "./manager.js";
 // For backward compatibility - function alias (will be deprecated)
-export { createReferenceManager as ReferenceManagerFactory } from './manager.js';
+export { createReferenceManager, createReferenceManager as ReferenceManagerFactory } from "./manager.js";
+export { generateReferenceId } from "./store.js";

package/src/reference/manager.ts

@@ -2,50 +2,54 @@
  * Reference manager factory
  */
 
-import type { Reference, ReferenceMetadata, ReferenceStore } from '../types/index.js';
-import { generateReferenceId } from './store.js';
+import type { Reference, ReferenceMetadata, ReferenceStore } from "../types/index.js";
+import { generateReferenceId } from "./store.js";
 
 export interface ReferenceManager extends ReferenceStore {
-  generateId: typeof generateReferenceId;
-  getIdsByUrl: (url: string) => string[];
-  createReference: (id: string, metadata: ReferenceMetadata) => Reference;
-  getAllReferences: () => Record<string, ReferenceMetadata>;
+    generateId: typeof generateReferenceId;
+    getIdsByUrl: (url: string) => string[];
+    createReference: (id: string, metadata: ReferenceMetadata) => Reference;
+    getAllReferences: () => Record<string, ReferenceMetadata>;
 }
 
 export const createReferenceManager = (): ReferenceManager => {
-  const references: Record<string, ReferenceMetadata> = {};
-  const urlToIds: Record<string, string[]> = {};
+    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 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]);
-  };
+    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,
-  };
-};
+    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,
+    };
+};

package/src/reference/store.ts

@@ -2,14 +2,13 @@
  * Reference store implementation
  */
 
-import { createHash } from 'crypto';
-import type { ReferenceMetadata, ReferenceStore } from '../types/index.js';
+import { createHash } from "node:crypto";
 
 export const generateReferenceId = (metadata: {
-  packageName: string;
-  packageVersion: string;
-  filePath: string;
+    packageName: string;
+    packageVersion: string;
+    filePath: string;
 }): string => {
-  const input = `${metadata.packageName}@${metadata.packageVersion}:${metadata.filePath}`;
-  return createHash("sha256").update(input).digest("base64url");
-};
+    const input = `${metadata.packageName}@${metadata.packageVersion}:${metadata.filePath}`;
+    return createHash("sha256").update(input).digest("base64url");
+};

package/src/resolver/context.ts

@@ -2,24 +2,24 @@
  * Context-aware resolution functionality
  */
 
-import type { SourceContext, IndexEntry } from '../types/index.js';
-import type { ExtendedCache } from '../cache/core.js';
+import type { ExtendedCache } from "../cache.js";
+import type { IndexEntry, SourceContext } from "../types/index.js";
 
 export const resolveWithContext = async (
-  url: string,
-  context: SourceContext,
-  cache: ExtendedCache,
-  resolveEntry: (url: string, options?: any) => Promise<IndexEntry>,
+    url: string,
+    context: SourceContext,
+    _cache: ExtendedCache,
+    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
+    if (context.package) {
+        try {
+            return await resolveEntry(url, {
+                package: context.package.name,
+                version: context.package.version,
+            });
+        } catch {
+            // Fall through to global resolution
+        }
     }
-  }
-  return null;
-};
+    return null;
+};

package/src/resolver/index.ts

@@ -2,4 +2,4 @@
  * Resolver module exports
  */
 
-export { resolveWithContext } from './context.js';
+export { resolveWithContext } from "./context.js";

package/src/scanner/directory.ts

@@ -2,41 +2,35 @@
  * Directory scanning functionality
  */
 
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import type { ExtendedCache } from '../cache/core.js';
-import { isFhirPackage } from '../fs/index.js';
-import { scanPackage } from './package.js';
-
-export const scanDirectory = async (
-  dirPath: string,
-  cache: ExtendedCache,
-): Promise<void> => {
-  try {
-    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { ExtendedCache } from "../cache.js";
+import { isFhirPackage } from "../fs/index.js";
+import { scanPackage } from "./package.js";
 
+export const scanDirectory = async (cache: ExtendedCache, pwd: string): Promise<void> => {
+    const nodeModulesPath = path.join(pwd, "node_modules");
+    const entries = await fs.readdir(nodeModulesPath, { withFileTypes: true });
     for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
+        if (!entry.isDirectory()) continue;
+
+        const fullPath = path.join(entry.parentPath, entry.name);
 
-      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;
 
-      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);
 
-          const scopedPath = path.join(fullPath, scopedEntry.name);
-          if (await isFhirPackage(scopedPath)) {
-            await scanPackage(scopedPath, cache);
-          }
+                if (await isFhirPackage(scopedPath)) {
+                    await scanPackage(scopedPath, cache);
+                }
+            }
+        } else if (await isFhirPackage(fullPath)) {
+            await scanPackage(fullPath, cache);
         }
-      } else if (await isFhirPackage(fullPath)) {
-        await scanPackage(fullPath, cache);
-      }
     }
-  } catch {
-    // Silently ignore scan errors
-  }
-};
+};

package/src/scanner/index.ts

@@ -2,7 +2,7 @@
  * Scanner module exports
  */
 
-export { parseIndex, isValidFileEntry, isValidIndexFile } from './parser.js';
-export { processIndex } from './processor.js';
-export { scanPackage } from './package.js';
-export { scanDirectory } from './directory.js';
+export { scanDirectory } from "./directory.js";
+export { scanPackage } from "./package.js";
+export { isValidFileEntry, isValidIndexFile, parseIndex } from "./parser.js";
+export { processIndex } from "./processor.js";

package/src/scanner/package.ts

@@ -2,37 +2,34 @@
  * Package scanning functionality
  */
 
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import type { PackageJson, PackageInfo } from '../types/index.js';
-import type { ExtendedCache } from '../cache/core.js';
-import { fileExists } from '../fs/index.js';
-import { processIndex } from './processor.js';
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { ExtendedCache } from "../cache.js";
+import { fileExists } from "../fs/index.js";
+import type { PackageInfo, PackageJson } from "../types/index.js";
+import { processIndex } from "./processor.js";
 
-export const scanPackage = async (
-  packagePath: string,
-  cache: ExtendedCache,
-): Promise<void> => {
-  try {
-    const packageJsonPath = path.join(packagePath, "package.json");
-    const packageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
-    const packageJson: PackageJson = JSON.parse(packageJsonContent);
+export const scanPackage = async (packagePath: string, cache: ExtendedCache): 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;
+        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);
+        await processIndex(packagePath, packageJson, cache);
 
-    const examplesPath = path.join(packagePath, "examples");
-    if (await fileExists(path.join(examplesPath, ".index.json"))) {
-      await processIndex(examplesPath, 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
     }
-  } catch {
-    // Silently ignore package scan errors
-  }
-};
+};

package/src/scanner/parser.ts

@@ -2,41 +2,39 @@
  * Index file parsing and validation
  */
 
-import type { IndexFile, IndexFileEntry } from '../types/index.js';
+import type { IndexFile } from "../types/index.js";
 
 export 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;
+    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;
+    const optionalStringFields = ["url", "version", "kind", "type"];
+    for (const field of optionalStringFields) {
+        if (entry[field] !== undefined && typeof entry[field] !== "string") {
+            return false;
+        }
     }
-  }
 
-  return true;
+    return true;
 };
 
 export 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));
+    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));
 };
 
-export const parseIndex = (content: string, filePath: string): IndexFile | null => {
-  try {
-    const data = JSON.parse(content);
-    if (!isValidIndexFile(data)) {
-      return null;
+export 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;
     }
-    return data as IndexFile;
-  } catch {
-    return null;
-  }
-};
+};

package/src/scanner/processor.ts

@@ -2,68 +2,64 @@
  * Index processing functionality
  */
 
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import type { PackageJson, IndexEntry } from '../types/index.js';
-import type { ExtendedCache } from '../cache/core.js';
-import { parseIndex } from './parser.js';
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { ExtendedCache } from "../cache.js";
+import type { IndexEntry, PackageJson } from "../types/index.js";
+import { parseIndex } from "./parser.js";
 
-export const processIndex = async (
-  basePath: string,
-  packageJson: PackageJson,
-  cache: ExtendedCache,
-): Promise<void> => {
-  const indexPath = path.join(basePath, ".index.json");
+export const processIndex = async (basePath: string, packageJson: PackageJson, cache: ExtendedCache): Promise<void> => {
+    const indexPath = path.join(basePath, ".index.json");
 
-  try {
-    const indexContent = await fs.readFile(indexPath, "utf-8");
-    const index = parseIndex(indexContent, indexPath);
+    try {
+        const indexContent = await fs.readFile(indexPath, "utf-8");
+        const index = parseIndex(indexContent, indexPath);
 
-    if (!index) return;
+        if (!index) return;
 
-    for (const file of index.files) {
-      if (!file.url) continue;
+        for (const file of index.files) {
+            if (!file.url) continue;
 
-      const filePath = path.join(basePath, file.filename);
+            const filePath = path.join(basePath, file.filename);
 
-      const id = cache.referenceManager.generateId({
-        packageName: packageJson.name,
-        packageVersion: packageJson.version,
-        filePath,
-      });
+            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,
-      });
+            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,
-        },
-      };
+            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);
-      }
+            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
     }
-  } catch {
-    // Silently ignore index processing errors
-  }
-};
+};

package/src/search/index.ts

@@ -2,5 +2,5 @@
  * Search module exports
  */
 
-export { expandedTerms } from './terms.js';
-export { filterBySmartSearch, type SmartSearchFilters } from './smart.js';
+export { filterBySmartSearch, type SmartSearchFilters } from "./smart.js";
+export { expandedTerms } from "./terms.js";