@mrpatronz/nexusflow 0.2.13 → 0.2.18

package/src/core/adapters/local-storage.ts

@@ -0,0 +1,66 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import type { StoragePort, StorageAdapterMeta } from '../ports/storage.js';
+
+export class LocalStorageAdapter implements StoragePort {
+  readonly meta: StorageAdapterMeta = {
+    name: 'local',
+    displayName: 'Local Workspace',
+    description: 'Write context files directly into the workspace directory.',
+    configFields: [],
+  };
+
+  async writeWorkspaceFile(workspacePath: string, featureId: string, filename: string, content: string): Promise<void> {
+    const filePath = path.join(workspacePath, filename);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, content, 'utf8');
+  }
+
+  async readWorkspaceFile(workspacePath: string, featureId: string, filename: string): Promise<string> {
+    const filePath = path.join(workspacePath, filename);
+    return await fs.readFile(filePath, 'utf8');
+  }
+
+  async workspaceFileExists(workspacePath: string, featureId: string, filename: string): Promise<boolean> {
+    const filePath = path.join(workspacePath, filename);
+    try {
+      await fs.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  resolveWorkspaceFileUrl(workspacePath: string, featureId: string, filename: string): string {
+    return path.join(workspacePath, filename).replace(/\\/g, '/');
+  }
+
+  async writeBaseFile(workspacePath: string, repoName: string, filename: string, content: string): Promise<void> {
+    const filePath = path.join(workspacePath, filename);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, content, 'utf8');
+  }
+
+  async readBaseFile(workspacePath: string, repoName: string, filename: string): Promise<string> {
+    const filePath = path.join(workspacePath, filename);
+    return await fs.readFile(filePath, 'utf8');
+  }
+
+  async baseFileExists(workspacePath: string, repoName: string, filename: string): Promise<boolean> {
+    const filePath = path.join(workspacePath, filename);
+    try {
+      await fs.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  resolveBaseFileUrl(workspacePath: string, repoName: string, filename: string): string {
+    return path.join(workspacePath, filename).replace(/\\/g, '/');
+  }
+
+  async deleteWorkspace(workspacePath: string, featureId: string): Promise<void> {
+    // NOP - local files are inside workspacePath, which is deleted directly on workspace removal.
+  }
+}

package/src/core/adapters/obsidian-storage.ts

@@ -0,0 +1,151 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import type { StoragePort, StorageAdapterMeta } from '../ports/storage.js';
+
+/**
+ * Obsidian-native storage adapter.
+ *
+ * Writes markdown files to a configurable Obsidian vault path with optional
+ * YAML frontmatter (tags, dates, type). Uses the same two-layer structure
+ * as CentralVaultAdapter (_base/<repo>/ + <workspace>/).
+ */
+export class ObsidianStorageAdapter implements StoragePort {
+  readonly meta: StorageAdapterMeta = {
+    name: 'obsidian',
+    displayName: 'Obsidian Vault',
+    description: 'Store context in an Obsidian vault with YAML frontmatter and wikilinks.',
+    configFields: [
+      {
+        key: 'vaultPath',
+        label: 'Obsidian Vault Path',
+        type: 'path',
+        required: true,
+        description: 'Absolute path to your Obsidian vault folder (e.g. ~/Obsidian/Dev)',
+      },
+      {
+        key: 'addFrontmatter',
+        label: 'Add YAML Frontmatter',
+        type: 'boolean',
+        default: true,
+        description: 'Add tags, created date, and type metadata to each file',
+      },
+    ],
+  };
+
+  private vaultPath: string = '';
+  private addFrontmatter: boolean = true;
+
+  constructor() {
+    try {
+      const home = os.homedir();
+      if (home) {
+        this.vaultPath = path.join(home, 'Obsidian', 'NexusFlow');
+      }
+    } catch {}
+  }
+
+  configure(settings: Record<string, unknown>): void {
+    if (settings.vaultPath && typeof settings.vaultPath === 'string') {
+      this.vaultPath = settings.vaultPath.startsWith('~')
+        ? path.join(os.homedir(), settings.vaultPath.slice(1))
+        : settings.vaultPath;
+    }
+    if (typeof settings.addFrontmatter === 'boolean') {
+      this.addFrontmatter = settings.addFrontmatter;
+    }
+  }
+
+  // ── Frontmatter helpers ──────────────────────────────────
+
+  private wrapWithFrontmatter(content: string, tags: string[], type: string): string {
+    if (!this.addFrontmatter) return content;
+
+    const now = new Date().toISOString();
+    const fm = [
+      '---',
+      `tags: [${tags.map(t => `"${t}"`).join(', ')}]`,
+      `type: ${type}`,
+      `created: ${now}`,
+      `modified: ${now}`,
+      `generator: nexusflow`,
+      '---',
+      '',
+    ].join('\n');
+
+    // Strip existing frontmatter if present
+    const stripped = content.replace(/^---\n[\s\S]*?\n---\n*/, '');
+    return fm + stripped;
+  }
+
+  // ── Workspace (feature) layer ────────────────────────────
+
+  private getFeaturePath(featureId: string): string {
+    return path.join(this.vaultPath, 'nexusflow', 'workspaces', featureId);
+  }
+
+  async writeWorkspaceFile(workspacePath: string, featureId: string, filename: string, content: string): Promise<void> {
+    const dir = this.getFeaturePath(featureId);
+    const filePath = path.join(dir, filename);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const wrapped = this.wrapWithFrontmatter(content, [featureId, 'workspace'], 'workspace-context');
+    await fs.writeFile(filePath, wrapped, 'utf8');
+  }
+
+  async readWorkspaceFile(workspacePath: string, featureId: string, filename: string): Promise<string> {
+    const dir = this.getFeaturePath(featureId);
+    return await fs.readFile(path.join(dir, filename), 'utf8');
+  }
+
+  async workspaceFileExists(workspacePath: string, featureId: string, filename: string): Promise<boolean> {
+    try {
+      await fs.access(path.join(this.getFeaturePath(featureId), filename));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  resolveWorkspaceFileUrl(workspacePath: string, featureId: string, filename: string): string {
+    return path.join(this.getFeaturePath(featureId), filename).replace(/\\/g, '/');
+  }
+
+  // ── Base (repo) layer ────────────────────────────────────
+
+  private getBasePath(repoName: string): string {
+    return path.join(this.vaultPath, 'nexusflow', '_base', repoName);
+  }
+
+  async writeBaseFile(workspacePath: string, repoName: string, filename: string, content: string): Promise<void> {
+    const dir = this.getBasePath(repoName);
+    const filePath = path.join(dir, filename);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const wrapped = this.wrapWithFrontmatter(content, [repoName, 'base'], 'base-knowledge');
+    await fs.writeFile(filePath, wrapped, 'utf8');
+  }
+
+  async readBaseFile(workspacePath: string, repoName: string, filename: string): Promise<string> {
+    const dir = this.getBasePath(repoName);
+    return await fs.readFile(path.join(dir, filename), 'utf8');
+  }
+
+  async baseFileExists(workspacePath: string, repoName: string, filename: string): Promise<boolean> {
+    try {
+      await fs.access(path.join(this.getBasePath(repoName), filename));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  resolveBaseFileUrl(workspacePath: string, repoName: string, filename: string): string {
+    return path.join(this.getBasePath(repoName), filename).replace(/\\/g, '/');
+  }
+
+  async deleteWorkspace(workspacePath: string, featureId: string): Promise<void> {
+    const dir = this.getFeaturePath(featureId);
+    try {
+      await fs.rm(dir, { recursive: true, force: true });
+    } catch {}
+  }
+}

package/src/core/adapters/registry.ts

@@ -0,0 +1,44 @@
+import type { StoragePort, StorageAdapterMeta } from '../ports/storage.js';
+import { LocalStorageAdapter } from './local-storage.js';
+import { CentralVaultAdapter } from './vault-storage.js';
+import { ObsidianStorageAdapter } from './obsidian-storage.js';
+
+const storageProviders = new Map<string, StoragePort>();
+let activeProvider: StoragePort | null = null;
+
+export function registerStorageProvider(name: string, provider: StoragePort) {
+  storageProviders.set(name, provider);
+}
+
+// Auto-register built-in adapters
+registerStorageProvider('local', new LocalStorageAdapter());
+registerStorageProvider('central-vault', new CentralVaultAdapter());
+registerStorageProvider('obsidian', new ObsidianStorageAdapter());
+
+/** Returns metadata for all registered storage providers. */
+export function listStorageProviders(): StorageAdapterMeta[] {
+  return Array.from(storageProviders.values()).map(p => p.meta);
+}
+
+export function getStorageProvider(name: string): StoragePort {
+  const provider = storageProviders.get(name);
+  if (!provider) {
+    throw new Error(`Storage provider "${name}" is not registered.`);
+  }
+  return provider;
+}
+
+export function setActiveStorageProvider(provider: StoragePort) {
+  activeProvider = provider;
+}
+
+export function getActiveStorageProvider(): StoragePort {
+  if (!activeProvider) {
+    const local = storageProviders.get('local');
+    if (!local) {
+      throw new Error('No storage providers registered.');
+    }
+    return local;
+  }
+  return activeProvider;
+}

package/src/core/adapters/storage.test.ts

@@ -0,0 +1,174 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+import { LocalStorageAdapter } from './local-storage.js';
+import { CentralVaultAdapter } from './vault-storage.js';
+import { ObsidianStorageAdapter } from './obsidian-storage.js';
+
+vi.mock('node:fs/promises');
+vi.mock('node:os', async () => {
+  const actual = await vi.importActual<typeof import('node:os')>('node:os');
+  return {
+    ...actual,
+    homedir: vi.fn().mockReturnValue('/mock/home'),
+  };
+});
+
+describe('Storage Adapters', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(os.homedir).mockReturnValue('/mock/home');
+  });
+
+  describe('LocalStorageAdapter', () => {
+    const adapter = new LocalStorageAdapter();
+
+    it('should declare correct meta', () => {
+      expect(adapter.meta.name).toBe('local');
+      expect(adapter.meta.configFields.length).toBe(0);
+    });
+
+    it('should write workspace files directly to the workspace path', async () => {
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+
+      await adapter.writeWorkspaceFile('/ws/path', 'feature-1', 'test.txt', 'hello');
+
+      expect(fs.mkdir).toHaveBeenCalledWith(expect.stringContaining(path.normalize('/ws/path')), { recursive: true });
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        path.normalize('/ws/path/test.txt'),
+        'hello',
+        'utf8'
+      );
+    });
+
+    it('should resolve local workspace paths', () => {
+      const resolved = adapter.resolveWorkspaceFileUrl('/ws/path', 'feature-1', 'test.txt');
+      expect(resolved).toContain('/ws/path/test.txt');
+    });
+
+    it('should delete workspace as NOP', async () => {
+      await adapter.deleteWorkspace('/ws/path', 'feature-1');
+      expect(fs.rm).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('CentralVaultAdapter', () => {
+    const adapter = new CentralVaultAdapter();
+
+    it('should declare correct meta', () => {
+      expect(adapter.meta.name).toBe('central-vault');
+    });
+
+    it('should write workspace files to ~/.nexusflow/vault/<featureId>', async () => {
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+
+      await adapter.writeWorkspaceFile('/ws/path', 'feature-1', 'test.txt', 'hello');
+
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        expect.stringContaining(path.normalize('.nexusflow/vault/feature-1/test.txt')),
+        'hello',
+        'utf8'
+      );
+    });
+
+    it('should write base files to ~/.nexusflow/vault/_base/<repoName>', async () => {
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+
+      await adapter.writeBaseFile('/ws/path', 'RepoName', 'map.md', 'content');
+
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        expect.stringContaining(path.normalize('.nexusflow/vault/_base/RepoName/map.md')),
+        'content',
+        'utf8'
+      );
+    });
+
+    it('should delete workspace folder from ~/.nexusflow/vault', async () => {
+      vi.mocked(fs.rm).mockResolvedValue(undefined);
+      await adapter.deleteWorkspace('/ws/path', 'feature-1');
+      expect(fs.rm).toHaveBeenCalledWith(
+        expect.stringContaining(path.normalize('.nexusflow/vault/feature-1')),
+        { recursive: true, force: true }
+      );
+    });
+  });
+
+  describe('ObsidianStorageAdapter', () => {
+    it('should declare correct meta and configuration settings', () => {
+      const adapter = new ObsidianStorageAdapter();
+      expect(adapter.meta.name).toBe('obsidian');
+      expect(adapter.meta.configFields.some(f => f.key === 'vaultPath')).toBe(true);
+    });
+
+    it('should respect custom vaultPath configuration', async () => {
+      const adapter = new ObsidianStorageAdapter();
+      adapter.configure({ vaultPath: '/custom/obsidian/vault' });
+
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+
+      await adapter.writeWorkspaceFile('/ws/path', 'feature-1', 'test.txt', 'hello');
+
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        path.normalize('/custom/obsidian/vault/nexusflow/workspaces/feature-1/test.txt'),
+        expect.any(String),
+        'utf8'
+      );
+    });
+
+    it('should wrap content with YAML frontmatter by default', async () => {
+      const adapter = new ObsidianStorageAdapter();
+      adapter.configure({ vaultPath: '/custom/obsidian/vault', addFrontmatter: true });
+
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+
+      await adapter.writeWorkspaceFile('/ws/path', 'feature-1', 'test.txt', 'hello');
+
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.stringContaining('tags: ["feature-1", "workspace"]'),
+        'utf8'
+      );
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.stringContaining('generator: nexusflow'),
+        'utf8'
+      );
+    });
+
+    it('should not wrap content with frontmatter if addFrontmatter is disabled', async () => {
+      const adapter = new ObsidianStorageAdapter();
+      adapter.configure({ vaultPath: '/custom/obsidian/vault', addFrontmatter: false });
+
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+
+      await adapter.writeWorkspaceFile('/ws/path', 'feature-1', 'test.txt', 'hello');
+
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        expect.any(String),
+        'hello',
+        'utf8'
+      );
+    });
+
+    it('should delete workspace folder from custom vault path under nexusflow', async () => {
+      const adapter = new ObsidianStorageAdapter();
+      adapter.configure({ vaultPath: '/custom/obsidian/vault' });
+      vi.mocked(fs.rm).mockResolvedValue(undefined);
+
+      await adapter.deleteWorkspace('/ws/path', 'feature-1');
+
+      expect(fs.rm).toHaveBeenCalledWith(
+        path.normalize('/custom/obsidian/vault/nexusflow/workspaces/feature-1'),
+        { recursive: true, force: true }
+      );
+    });
+  });
+});

package/src/core/adapters/vault-storage.ts

@@ -0,0 +1,86 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import type { StoragePort, StorageAdapterMeta } from '../ports/storage.js';
+
+export class CentralVaultAdapter implements StoragePort {
+  readonly meta: StorageAdapterMeta = {
+    name: 'central-vault',
+    displayName: 'Central Vault',
+    description: 'Store context in ~/.nexusflow/vault/ — keeps repos clean, Obsidian-compatible.',
+    configFields: [],
+  };
+
+  private getVaultPath(featureId: string): string {
+    return path.join(os.homedir(), '.nexusflow', 'vault', featureId);
+  }
+
+  async writeWorkspaceFile(workspacePath: string, featureId: string, filename: string, content: string): Promise<void> {
+    const vaultDir = this.getVaultPath(featureId);
+    const filePath = path.join(vaultDir, filename);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, content, 'utf8');
+  }
+
+  async readWorkspaceFile(workspacePath: string, featureId: string, filename: string): Promise<string> {
+    const vaultDir = this.getVaultPath(featureId);
+    const filePath = path.join(vaultDir, filename);
+    return await fs.readFile(filePath, 'utf8');
+  }
+
+  async workspaceFileExists(workspacePath: string, featureId: string, filename: string): Promise<boolean> {
+    const vaultDir = this.getVaultPath(featureId);
+    const filePath = path.join(vaultDir, filename);
+    try {
+      await fs.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  resolveWorkspaceFileUrl(workspacePath: string, featureId: string, filename: string): string {
+    const vaultDir = this.getVaultPath(featureId);
+    return path.join(vaultDir, filename).replace(/\\/g, '/');
+  }
+
+  private getBaseVaultPath(repoName: string): string {
+    return path.join(os.homedir(), '.nexusflow', 'vault', '_base', repoName);
+  }
+
+  async writeBaseFile(workspacePath: string, repoName: string, filename: string, content: string): Promise<void> {
+    const baseDir = this.getBaseVaultPath(repoName);
+    const filePath = path.join(baseDir, filename);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, content, 'utf8');
+  }
+
+  async readBaseFile(workspacePath: string, repoName: string, filename: string): Promise<string> {
+    const baseDir = this.getBaseVaultPath(repoName);
+    const filePath = path.join(baseDir, filename);
+    return await fs.readFile(filePath, 'utf8');
+  }
+
+  async baseFileExists(workspacePath: string, repoName: string, filename: string): Promise<boolean> {
+    const baseDir = this.getBaseVaultPath(repoName);
+    const filePath = path.join(baseDir, filename);
+    try {
+      await fs.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  resolveBaseFileUrl(workspacePath: string, repoName: string, filename: string): string {
+    const baseDir = this.getBaseVaultPath(repoName);
+    return path.join(baseDir, filename).replace(/\\/g, '/');
+  }
+
+  async deleteWorkspace(workspacePath: string, featureId: string): Promise<void> {
+    const dir = this.getVaultPath(featureId);
+    try {
+      await fs.rm(dir, { recursive: true, force: true });
+    } catch {}
+  }
+}

package/src/core/config.ts

@@ -8,6 +8,7 @@ import * as path from 'node:path';
 import * as os from 'node:os';
 
 import type { NexusFlowConfig } from '../types.js';
+import { getStorageProvider, setActiveStorageProvider } from './adapters/registry.js';
 
 /** Name of the config directory under the user's home folder. */
 const CONFIG_DIR_NAME = '.nexusflow';
@@ -33,7 +34,6 @@ export function getDefaultConfig(): NexusFlowConfig {
     defaultAssistant: null,
     defaultEditor: null,
     scanDepth: 2,
-    packContextXml: false,
     excludePatterns: [
       '**/node_modules/**',
       '**/bin/**',
@@ -84,20 +84,34 @@ export async function ensureConfigDir(): Promise<void> {
 export async function loadConfig(): Promise<NexusFlowConfig> {
   const configPath = path.join(getConfigDir(), CONFIG_FILE_NAME);
 
+  let merged: NexusFlowConfig;
   try {
     const raw = await fs.readFile(configPath, 'utf-8');
     const parsed = JSON.parse(raw) as Partial<NexusFlowConfig>;
 
     // Merge with defaults so newly-added keys are always present.
-    const merged = { ...getDefaultConfig(), ...parsed };
+    merged = { ...getDefaultConfig(), ...parsed };
     if (parsed.localLlm) {
       merged.localLlm = { ...getDefaultConfig().localLlm, ...parsed.localLlm };
     }
-    return merged;
   } catch {
     // File doesn't exist or is unreadable — return defaults.
-    return getDefaultConfig();
+    merged = getDefaultConfig();
   }
+
+  // Set the active storage provider based on configuration
+  try {
+    const providerName = merged.storageProvider || 'local';
+    const provider = getStorageProvider(providerName);
+    // Pass per-adapter settings if available
+    const adapterSettings = merged.adapterConfig?.[providerName] ?? {};
+    if (provider.configure) {
+      provider.configure(adapterSettings);
+    }
+    setActiveStorageProvider(provider);
+  } catch {}
+
+  return merged;
 }
 
 /**
@@ -112,4 +126,15 @@ export async function saveConfig(config: NexusFlowConfig): Promise<void> {
   const configPath = path.join(getConfigDir(), CONFIG_FILE_NAME);
   const data = JSON.stringify(config, null, 2) + '\n';
   await fs.writeFile(configPath, data, 'utf-8');
+
+  // Set the active storage provider based on configuration
+  try {
+    const providerName = config.storageProvider || 'local';
+    const provider = getStorageProvider(providerName);
+    const adapterSettings = config.adapterConfig?.[providerName] ?? {};
+    if (provider.configure) {
+      provider.configure(adapterSettings);
+    }
+    setActiveStorageProvider(provider);
+  } catch {}
 }

package/src/core/plugins/index.ts

@@ -0,0 +1,17 @@
+import type { StoragePort } from '../ports/storage.js';
+
+export type { StoragePort, StorageAdapterMeta, AdapterConfigField } from '../ports/storage.js';
+
+export interface PluginRegistryContext {
+  /** Registers a custom storage provider/adapter. The provider must include a `meta` property. */
+  registerStorageProvider(name: string, provider: StoragePort): void;
+
+  /** Registers a custom commander CLI subcommand. */
+  registerCommand(commandBuilder: (program: any) => void): void;
+}
+
+export interface NexusFlowPlugin {
+  name: string;
+  version: string;
+  register(context: PluginRegistryContext): void | Promise<void>;
+}

package/src/core/plugins/loader.ts

@@ -0,0 +1,36 @@
+import * as path from 'node:path';
+import type { PluginRegistryContext, NexusFlowPlugin } from './index.js';
+import { registerStorageProvider } from '../adapters/registry.js';
+
+export async function loadPlugins(program: any, pluginsList: string[]): Promise<void> {
+  const context: PluginRegistryContext = {
+    registerStorageProvider(name, provider) {
+      registerStorageProvider(name, provider);
+    },
+    registerCommand(commandBuilder) {
+      commandBuilder(program);
+    }
+  };
+
+  for (const pluginPath of pluginsList) {
+    try {
+      let resolvedPath = pluginPath;
+      if (pluginPath.startsWith('.') || path.isAbsolute(pluginPath)) {
+        resolvedPath = path.resolve(pluginPath);
+      }
+      
+      // Dynamic import works with file:// URLs on Windows
+      const fileUrl = resolvedPath.startsWith('file://') ? resolvedPath : `file:///${resolvedPath.replace(/\\/g, '/')}`;
+      const module = await import(fileUrl);
+      const plugin: NexusFlowPlugin = module.default || module.plugin;
+      
+      if (plugin && typeof plugin.register === 'function') {
+        await plugin.register(context);
+      } else {
+        console.warn(`Warning: Plugin at "${pluginPath}" does not export a valid NexusFlowPlugin.`);
+      }
+    } catch (error: any) {
+      console.error(`Failed to load plugin "${pluginPath}":`, error.message);
+    }
+  }
+}