@mrpatronz/nexusflow 0.2.19 → 1.3.0

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

@@ -1,151 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,174 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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.test.ts

@@ -1,96 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import * as fs from 'node:fs/promises';
-import * as os from 'node:os';
-import { getConfigDir, getDefaultConfig, ensureConfigDir, loadConfig, saveConfig } from './config.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(),
-  };
-});
-
-describe('config core module', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.mocked(os.homedir).mockReturnValue('/mock/home');
-  });
-
-  describe('getConfigDir', () => {
-    it('should return path based on home directory', () => {
-      const dir = getConfigDir();
-      expect(dir).toContain('.nexusflow');
-    });
-  });
-
-  describe('getDefaultConfig', () => {
-    it('should return config with defaults populated', () => {
-      const config = getDefaultConfig();
-      expect(config.version).toBe('1.0.0');
-      expect(config.scanDepth).toBe(2);
-      expect(config.localLlm?.enabled).toBe(false);
-    });
-  });
-
-  describe('ensureConfigDir', () => {
-    it('should invoke fs.mkdir with correct options', async () => {
-      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
-
-      await ensureConfigDir();
-
-      expect(fs.mkdir).toHaveBeenCalledWith(expect.stringContaining('.nexusflow'), { recursive: true });
-    });
-  });
-
-  describe('loadConfig', () => {
-    it('should load config if file exists', async () => {
-      const savedConfig = {
-        devDir: '/custom/dev',
-        localLlm: {
-          enabled: true,
-          model: 'custom-model'
-        }
-      };
-
-      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(savedConfig));
-
-      const config = await loadConfig();
-
-      expect(config.devDir).toBe('/custom/dev');
-      expect(config.localLlm?.enabled).toBe(true);
-      expect(config.localLlm?.model).toBe('custom-model');
-      // Should merge with defaults
-      expect(config.scanDepth).toBe(2);
-    });
-
-    it('should return default config if read fails', async () => {
-      vi.mocked(fs.readFile).mockRejectedValue(new Error('ENOENT'));
-
-      const config = await loadConfig();
-
-      expect(config.version).toBe('1.0.0');
-      expect(config.localLlm?.enabled).toBe(false);
-    });
-  });
-
-  describe('saveConfig', () => {
-    it('should create directory and save configuration', async () => {
-      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
-      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-
-      const config = getDefaultConfig();
-      config.devDir = '/custom/saved/dev';
-
-      await saveConfig(config);
-
-      expect(fs.mkdir).toHaveBeenCalled();
-      expect(fs.writeFile).toHaveBeenCalledWith(
-        expect.stringContaining('config.json'),
-        expect.stringContaining('/custom/saved/dev'),
-        'utf-8'
-      );
-    });
-  });
-});

package/src/core/config.ts

@@ -1,140 +0,0 @@
-/**
- * @module core/config
- * Manages NexusFlow configuration stored at ~/.nexusflow/config.json.
- */
-
-import * as fs from 'node:fs/promises';
-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';
-
-/** Name of the config file. */
-const CONFIG_FILE_NAME = 'config.json';
-
-/**
- * Returns the absolute path to the NexusFlow config directory (~/.nexusflow).
- */
-export function getConfigDir(): string {
-  return path.join(os.homedir(), CONFIG_DIR_NAME);
-}
-
-/**
- * Returns a NexusFlowConfig populated with sensible defaults.
- */
-export function getDefaultConfig(): NexusFlowConfig {
-  return {
-    version: '1.0.0',
-    devDir: path.join(os.homedir(), 'dev'),
-    workspacesDir: path.join(os.homedir(), 'dev', 'workspaces'),
-    defaultAssistant: null,
-    defaultEditor: null,
-    scanDepth: 2,
-    excludePatterns: [
-      '**/node_modules/**',
-      '**/bin/**',
-      '**/obj/**',
-      '**/dist/**',
-      '**/out/**',
-      '**/.git/**',
-      '**/*.lock',
-      '**/package-lock.json',
-      '**/pnpm-lock.yaml',
-      '**/yarn.lock',
-      '**/*.png',
-      '**/*.jpg',
-      '**/*.jpeg',
-      '**/*.gif',
-      '**/*.svg',
-      '**/*.ico',
-      '**/*.pdf',
-      '**/*.zip',
-      '**/*.tar.gz',
-      '**/.vs/**',
-      '**/.vscode/**',
-      '**/.idea/**',
-    ],
-    localLlm: {
-      enabled: false,
-      provider: 'ollama',
-      endpoint: 'http://localhost:11434',
-      model: 'qwen2.5-coder:1.5b',
-    },
-  };
-}
-
-/**
- * Ensures the ~/.nexusflow directory exists, creating it if necessary.
- */
-export async function ensureConfigDir(): Promise<void> {
-  const configDir = getConfigDir();
-  await fs.mkdir(configDir, { recursive: true });
-}
-
-/**
- * Loads the NexusFlow config from disk.
- * Returns default values when the config file does not exist yet.
- *
- * @returns The loaded or default configuration.
- */
-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.
-    merged = { ...getDefaultConfig(), ...parsed };
-    if (parsed.localLlm) {
-      merged.localLlm = { ...getDefaultConfig().localLlm, ...parsed.localLlm };
-    }
-  } catch {
-    // File doesn't exist or is unreadable — return defaults.
-    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;
-}
-
-/**
- * Persists the given configuration to ~/.nexusflow/config.json.
- * Creates the config directory if it doesn't exist.
- *
- * @param config - The configuration to save.
- */
-export async function saveConfig(config: NexusFlowConfig): Promise<void> {
-  await ensureConfigDir();
-
-  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 {}
-}