diff --git a/packages/docs-engine-cli/package.json b/packages/docs-engine-cli/package.json
index 623debc..490fc60 100644
--- a/packages/docs-engine-cli/package.json
+++ b/packages/docs-engine-cli/package.json
@@ -20,17 +20,17 @@
     "commander": "^12.0.0",
     "chalk": "^5.3.0",
     "ora": "^8.0.1",
-    "glob": "^10.3.10",
+    "glob": "^11.0.0",
     "unified": "^11.0.5",
     "remark-parse": "^11.0.0",
     "remark-mdx": "^3.0.0",
     "unist-util-visit": "^5.0.0",
-    "p-limit": "^5.0.0"
+    "p-limit": "^7.2.0"
   },
   "devDependencies": {
-    "@types/node": "^20.11.16",
-    "tsup": "^8.0.1",
-    "typescript": "^5.3.3"
+    "@types/node": "^24.10.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.3"
   },
   "keywords": [
     "documentation",
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
new file mode 100644
index 0000000..6b583fc
--- /dev/null
+++ b/pnpm-workspace.yaml
@@ -0,0 +1,4 @@
+packages:
+  - '.'
+  - 'site'
+  - 'packages/*'
diff --git a/site/package.json b/site/package.json
index 41f05f4..1024734 100644
--- a/site/package.json
+++ b/site/package.json
@@ -20,8 +20,8 @@
     "vite": "^7.1.7"
   },
   "dependencies": {
+    "@goobits/docs-engine": "workspace:*",
     "@lucide/svelte": "^0.553.0",
-    "dist": "file:../dist",
     "gray-matter": "^4.0.3",
     "katex": "^0.16.25",
     "mdsvex": "^0.12.6",
diff --git a/site/src/routes/docs/+layout.server.ts b/site/src/routes/docs/+layout.server.ts
index b416eaa..ba5f20c 100644
--- a/site/src/routes/docs/+layout.server.ts
+++ b/site/src/routes/docs/+layout.server.ts
@@ -1,8 +1,8 @@
 import path from 'path';
 import { error } from '@sveltejs/kit';
 import { dev } from '$app/environment';
-import { scanDocumentation } from 'dist/server/index.js';
-import { buildNavigation, createSearchIndex } from 'dist/utils/index.js';
+import { scanDocumentation } from '@goobits/docs-engine/server';
+import { buildNavigation, createSearchIndex } from '@goobits/docs-engine/utils';
 import { logError, createDevError } from '$lib/utils/error-logger';
 import type { LayoutServerLoad } from './$types';
 
diff --git a/site/src/routes/docs/+page.server.ts b/site/src/routes/docs/+page.server.ts
index c1666f7..2927827 100644
--- a/site/src/routes/docs/+page.server.ts
+++ b/site/src/routes/docs/+page.server.ts
@@ -7,7 +7,7 @@ import remarkParse from 'remark-parse';
 import remarkGfm from 'remark-gfm';
 import remarkRehype from 'remark-rehype';
 import rehypeStringify from 'rehype-stringify';
-import { remarkTableOfContents, linksPlugin } from 'dist/plugins/index.js';
+import { remarkTableOfContents, linksPlugin } from '@goobits/docs-engine/plugins';
 import type { PageServerLoad } from './$types';
 
 export const load: PageServerLoad = async () => {
diff --git a/site/src/routes/docs/+page.svelte b/site/src/routes/docs/+page.svelte
index aa54a38..a15bab8 100644
--- a/site/src/routes/docs/+page.svelte
+++ b/site/src/routes/docs/+page.svelte
@@ -8,7 +8,7 @@
 
   import { page } from '$app/stores';
   import { Home } from '@lucide/svelte';
-  import { DocsLayout } from 'dist/components/index.js';
+  import { DocsLayout } from '@goobits/docs-engine/components';
   import type { PageData } from './$types';
 
   interface Props {
diff --git a/site/src/routes/docs/[...slug]/+page.server.ts b/site/src/routes/docs/[...slug]/+page.server.ts
index 0cb6d1e..91d0d27 100644
--- a/site/src/routes/docs/[...slug]/+page.server.ts
+++ b/site/src/routes/docs/[...slug]/+page.server.ts
@@ -21,7 +21,7 @@ import {
   collapsePlugin,
   referencePlugin,
   katexPlugin,
-} from 'dist/plugins/index.js';
+} from '@goobits/docs-engine/plugins';
 import { logError, createDevError } from '$lib/utils/error-logger';
 import type { PageServerLoad } from './$types';
 
diff --git a/site/src/routes/docs/[...slug]/+page.svelte b/site/src/routes/docs/[...slug]/+page.svelte
index 42ac780..aa57190 100644
--- a/site/src/routes/docs/[...slug]/+page.svelte
+++ b/site/src/routes/docs/[...slug]/+page.svelte
@@ -8,7 +8,7 @@
 
   import { page } from '$app/stores';
   import { Home } from '@lucide/svelte';
-  import { DocsLayout } from 'dist/components/index.js';
+  import { DocsLayout } from '@goobits/docs-engine/components';
   import type { PageData } from './$types';
 
   interface Props {
diff --git a/src/lib/components/CodeCopyHydrator.svelte b/src/lib/components/CodeCopyHydrator.svelte
index dcd71fd..ee300f4 100644
--- a/src/lib/components/CodeCopyHydrator.svelte
+++ b/src/lib/components/CodeCopyHydrator.svelte
@@ -5,11 +5,9 @@
    * Finds all code blocks with data-copy-code attribute and mounts copy buttons
    * Use this in your layout or page to hydrate static HTML
    */
-  import { onMount } from 'svelte';
-  import { browser } from '$app/environment';
   import { mount } from 'svelte';
-  import { afterNavigate } from '$app/navigation';
   import CodeCopyButton from './CodeCopyButton.svelte';
+  import { useHydrator } from '@goobits/docs-engine/utils';
 
   interface Props {
     /** Theme for styling */
@@ -71,17 +69,5 @@
     });
   }
 
-  onMount(() => {
-    if (!browser) return;
-
-    const unsubscribe = afterNavigate(() => hydrate());
-    // Defer hydration to avoid conflicts with Svelte's hydration phase
-    queueMicrotask(() => {
-      requestAnimationFrame(hydrate);
-    });
-
-    return () => {
-      unsubscribe?.();
-    };
-  });
+  useHydrator(hydrate);
 </script>
diff --git a/src/lib/components/CodeTabsHydrator.svelte b/src/lib/components/CodeTabsHydrator.svelte
index 9137965..243b4a5 100644
--- a/src/lib/components/CodeTabsHydrator.svelte
+++ b/src/lib/components/CodeTabsHydrator.svelte
@@ -5,12 +5,9 @@
    * Finds all .md-code-tabs divs and hydrates them into interactive tabs
    * Use this in your layout or page to hydrate static HTML
    */
-  import { onMount } from 'svelte';
-  import { browser } from '$app/environment';
   import { mount } from 'svelte';
-  import { afterNavigate } from '$app/navigation';
   import CodeTabs from './CodeTabs.svelte';
-  import { createBrowserLogger } from '@goobits/docs-engine/utils';
+  import { createBrowserLogger, escapeHtml, useHydrator } from '@goobits/docs-engine/utils';
 
   const logger = createBrowserLogger('CodeTabsHydrator');
 
@@ -21,16 +18,6 @@
 
   let { theme = 'dracula' }: Props = $props();
 
-  // Simple HTML escape for error messages
-  function escapeHtml(str: string): string {
-    return str
-      .replace(/&/g, '&amp;')
-      .replace(/</g, '&lt;')
-      .replace(/>/g, '&gt;')
-      .replace(/"/g, '&quot;')
-      .replace(/'/g, '&#039;');
-  }
-
   function hydrate() {
     // Use requestAnimationFrame to ensure DOM is fully rendered
     requestAnimationFrame(() => {
@@ -70,17 +57,5 @@
     });
   }
 
-  onMount(() => {
-    if (!browser) return;
-
-    const unsubscribe = afterNavigate(() => hydrate());
-    // Defer hydration to avoid conflicts with Svelte's hydration phase
-    queueMicrotask(() => {
-      requestAnimationFrame(hydrate);
-    });
-
-    return () => {
-      unsubscribe?.();
-    };
-  });
+  useHydrator(hydrate);
 </script>
diff --git a/src/lib/components/CollapseHydrator.svelte b/src/lib/components/CollapseHydrator.svelte
index 495bc34..3677d41 100644
--- a/src/lib/components/CollapseHydrator.svelte
+++ b/src/lib/components/CollapseHydrator.svelte
@@ -3,10 +3,7 @@
    * Client-side hydrator for collapsible sections
    * Adds animations and accessibility to native <details> elements
    */
-  import { onMount } from 'svelte';
-  import { browser } from '$app/environment';
-  import { afterNavigate } from '$app/navigation';
-  import { createBrowserLogger } from '@goobits/docs-engine/utils';
+  import { createBrowserLogger, useHydrator } from '@goobits/docs-engine/utils';
 
   const logger = createBrowserLogger('CollapseHydrator');
 
@@ -39,19 +36,7 @@
     });
   }
 
-  onMount(() => {
-    if (!browser) return;
-
-    const unsubscribe = afterNavigate(() => hydrate());
-    // Defer hydration to avoid conflicts with Svelte's hydration phase
-    queueMicrotask(() => {
-      requestAnimationFrame(hydrate);
-    });
-
-    return () => {
-      unsubscribe?.();
-    };
-  });
+  useHydrator(hydrate);
 </script>
 
 <style>
diff --git a/src/lib/components/FileTreeHydrator.svelte b/src/lib/components/FileTreeHydrator.svelte
index 22e9e4c..30925d5 100644
--- a/src/lib/components/FileTreeHydrator.svelte
+++ b/src/lib/components/FileTreeHydrator.svelte
@@ -5,11 +5,10 @@
    * Finds all .md-filetree divs and renders them with FileTree component
    * Use this in your layout or page to hydrate static HTML
    */
-  import { onMount, mount } from 'svelte';
-  import { browser } from '$app/environment';
-  import { afterNavigate } from '$app/navigation';
+  import { mount } from 'svelte';
   import FileTree from './FileTree.svelte';
   import type { TreeNode } from '@goobits/docs-engine/utils';
+  import { escapeHtml, useHydrator } from '@goobits/docs-engine/utils';
 
   interface Props {
     githubUrl?: string;
@@ -18,16 +17,6 @@
 
   let { githubUrl, allowCopy = true }: Props = $props();
 
-  // Simple HTML escape for error messages
-  function escapeHtml(str: string): string {
-    return str
-      .replace(/&/g, '&amp;')
-      .replace(/</g, '&lt;')
-      .replace(/>/g, '&gt;')
-      .replace(/"/g, '&quot;')
-      .replace(/'/g, '&#039;');
-  }
-
   function hydrate() {
     requestAnimationFrame(() => {
       try {
@@ -75,17 +64,5 @@
     });
   }
 
-  onMount(() => {
-    if (!browser) return;
-
-    const unsubscribe = afterNavigate(() => hydrate());
-    // Defer hydration to avoid conflicts with Svelte's hydration phase
-    queueMicrotask(() => {
-      requestAnimationFrame(hydrate);
-    });
-
-    return () => {
-      unsubscribe?.();
-    };
-  });
+  useHydrator(hydrate);
 </script>
diff --git a/src/lib/components/MermaidHydrator.svelte b/src/lib/components/MermaidHydrator.svelte
index 0e11dcb..515fc05 100644
--- a/src/lib/components/MermaidHydrator.svelte
+++ b/src/lib/components/MermaidHydrator.svelte
@@ -5,9 +5,7 @@
    * Finds all .md-mermaid divs and renders them
    * Use this in your layout or page to hydrate static HTML
    */
-  import { onMount } from 'svelte';
-  import { browser } from '$app/environment';
-  import { afterNavigate } from '$app/navigation';
+  import { escapeHtml, useHydrator } from '@goobits/docs-engine/utils';
 
   interface Props {
     theme?: 'default' | 'dark' | 'forest' | 'neutral';
@@ -15,16 +13,6 @@
 
   let { theme = 'dark' }: Props = $props();
 
-  // Simple HTML escape for error messages
-  function escapeHtml(str: string): string {
-    return str
-      .replace(/&/g, '&amp;')
-      .replace(/</g, '&lt;')
-      .replace(/>/g, '&gt;')
-      .replace(/"/g, '&quot;')
-      .replace(/'/g, '&#039;');
-  }
-
   let mermaidApi: typeof import('mermaid').default | undefined;
   let initialized = false;
   let modalOpen = $state(false);
@@ -234,19 +222,7 @@
     });
   }
 
-  onMount(() => {
-    if (!browser) return;
-
-    const unsubscribe = afterNavigate(() => hydrate());
-    // Defer hydration to avoid conflicts with Svelte's hydration phase
-    queueMicrotask(() => {
-      requestAnimationFrame(hydrate);
-    });
-
-    return () => {
-      unsubscribe?.();
-    };
-  });
+  useHydrator(hydrate);
 </script>
 
 <!-- Fullscreen Modal -->
diff --git a/src/lib/components/OpenAPIHydrator.svelte b/src/lib/components/OpenAPIHydrator.svelte
index 0172d80..43c772a 100644
--- a/src/lib/components/OpenAPIHydrator.svelte
+++ b/src/lib/components/OpenAPIHydrator.svelte
@@ -5,12 +5,9 @@
    * Finds all OpenAPI doc elements and mounts OpenAPIDoc components
    * Use this in your layout or page to hydrate static HTML
    */
-  import { onMount } from 'svelte';
-  import { browser } from '$app/environment';
   import { mount } from 'svelte';
-  import { afterNavigate } from '$app/navigation';
   import OpenAPIDoc from './OpenAPIDoc.svelte';
-  import { parseOpenAPISpec, filterEndpointsByPath } from '../utils';
+  import { parseOpenAPISpec, filterEndpointsByPath, useHydrator } from '../utils';
   import { sanitizeHtml } from '../utils/index.js';
 
   interface Props {
@@ -91,19 +88,7 @@
     });
   }
 
-  onMount(() => {
-    if (!browser) return;
-
-    const unsubscribe = afterNavigate(() => hydrate());
-    // Defer hydration to avoid conflicts with Svelte's hydration phase
-    queueMicrotask(() => {
-      requestAnimationFrame(hydrate);
-    });
-
-    return () => {
-      unsubscribe?.();
-    };
-  });
+  useHydrator(hydrate);
 </script>
 
 <style>
diff --git a/src/lib/components/ScreenshotHydrator.svelte b/src/lib/components/ScreenshotHydrator.svelte
index 19c3e78..f6bdfd8 100644
--- a/src/lib/components/ScreenshotHydrator.svelte
+++ b/src/lib/components/ScreenshotHydrator.svelte
@@ -5,21 +5,9 @@
    * Finds all .md-screenshot divs and hydrates them into interactive screenshot components
    * Handles both web and CLI screenshots with lazy loading and generation
    */
-  import { onMount } from 'svelte';
-  import { browser } from '$app/environment';
   import { mount } from 'svelte';
-  import { afterNavigate } from '$app/navigation';
   import ScreenshotImage from './ScreenshotImage.svelte';
-
-  // Simple HTML escape for error messages
-  function escapeHtml(str: string): string {
-    return str
-      .replace(/&/g, '&amp;')
-      .replace(/</g, '&lt;')
-      .replace(/>/g, '&gt;')
-      .replace(/"/g, '&quot;')
-      .replace(/'/g, '&#039;');
-  }
+  import { escapeHtml, useHydrator } from '@goobits/docs-engine/utils';
 
   function hydrate() {
     // Use requestAnimationFrame to ensure DOM is fully rendered
@@ -84,55 +72,8 @@
     });
   }
 
-  onMount(() => {
-    if (!browser) return;
-
-    const unsubscribe = afterNavigate(() => hydrate());
-
-    // Defer hydration to avoid conflicts with Svelte's hydration phase
-    queueMicrotask(() => {
-      requestAnimationFrame(() => {
-        hydrate();
-
-        // Set up MutationObserver AFTER initial hydration completes
-        // This prevents the observer from triggering during initial DOM modifications
-        // eslint-disable-next-line no-undef
-        const observer = new MutationObserver((mutations) => {
-          let shouldHydrate = false;
-          for (const mutation of mutations) {
-            if (mutation.type === 'childList') {
-              for (const node of mutation.addedNodes) {
-                // eslint-disable-next-line no-undef
-                if (node instanceof Element) {
-                  if (
-                    node.matches('.md-screenshot[data-name][data-path][data-version]') ||
-                    node.querySelector('.md-screenshot[data-name][data-path][data-version]')
-                  ) {
-                    shouldHydrate = true;
-                    break;
-                  }
-                }
-              }
-            }
-          }
-          if (shouldHydrate) {
-            hydrate();
-          }
-        });
-
-        observer.observe(document.body, {
-          childList: true,
-          subtree: true,
-        });
-
-        // Store observer for cleanup
-        return observer;
-      });
-    });
-
-    return () => {
-      unsubscribe?.();
-      // Observer will be cleaned up when component unmounts
-    };
+  // Use the hydrator composable with MutationObserver for dynamic content
+  useHydrator(hydrate, {
+    observeSelector: '.md-screenshot[data-name][data-path][data-version]',
   });
 </script>
diff --git a/src/lib/generators/generic-generator.ts b/src/lib/generators/generic-generator.ts
index 021f585..254e9cd 100644
--- a/src/lib/generators/generic-generator.ts
+++ b/src/lib/generators/generic-generator.ts
@@ -7,18 +7,11 @@
 
 import { readFile } from 'fs';
 import { promisify } from 'util';
-import { execSync } from 'child_process';
 import type { GeneratorConfig, GeneratorResult, GeneratorStats, CategoryRule } from './types';
+import { parseJSON, parseEnv, parseSQL, parseGrep, type ParsedItem } from './parsers/index';
 
 const readFileAsync = promisify(readFile);
 
-/**
- * Generic parsed item - represents any parsed data structure
- * The actual shape depends on the parser type (JSON, ENV, SQL, etc.)
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type ParsedItem = any;
-
 /**
  * Generic documentation generator
  */
@@ -60,16 +53,16 @@ export class GenericGenerator {
 
     switch (parser.type) {
       case 'json':
-        return this.parseJSON(content, parser.path);
+        return parseJSON(content, parser.path);
 
       case 'env':
-        return this.parseEnv(content, parser.categoryPrefix);
+        return parseEnv(content, parser.categoryPrefix);
 
       case 'sql':
-        return this.parseSQL(content, parser.tablePattern);
+        return parseSQL(content, parser.tablePattern);
 
       case 'grep':
-        return this.parseGrep(parser.command, parser.extractPattern);
+        return parseGrep(parser.command, parser.extractPattern);
 
       case 'custom':
         return parser.parse(content, this.config);
@@ -79,202 +72,6 @@ export class GenericGenerator {
     }
   }
 
-  /**
-   * Parse JSON file
-   */
-  private parseJSON(content: string, path?: string): ParsedItem[] {
-    const data = JSON.parse(content);
-
-    if (!path) {
-      // If no path, assume data is array or convert object to entries
-      return Array.isArray(data)
-        ? data
-        : Object.entries(data).map(([key, value]) => ({ key, value }));
-    }
-
-    // Extract from path (e.g., "scripts" -> data.scripts)
-    const extracted = path.split('.').reduce((obj, key) => obj?.[key], data);
-
-    if (!extracted) {
-      throw new Error(`Path "${path}" not found in JSON`);
-    }
-
-    // Convert to array of items
-    if (Array.isArray(extracted)) {
-      return extracted;
-    }
-
-    // Convert object to array with key-value pairs
-    return Object.entries(extracted).map(([key, value]) => ({
-      name: key,
-      value: typeof value === 'string' ? value : JSON.stringify(value),
-    }));
-  }
-
-  /**
-   * Parse .env file
-   */
-  private parseEnv(content: string, categoryPrefix = '#'): ParsedItem[] {
-    const lines = content.split('\n');
-    const variables: ParsedItem[] = [];
-    let currentCategory = 'General';
-    let currentComments: string[] = [];
-
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const trimmed = line.trim();
-
-      // Empty line
-      if (!trimmed) {
-        currentComments = [];
-        continue;
-      }
-
-      // Category detection
-      if (trimmed.startsWith(categoryPrefix)) {
-        const categoryMatch = trimmed.match(/^#\s*---\s*(.+?)\s*---/);
-        if (categoryMatch) {
-          currentCategory = categoryMatch[1].trim();
-          currentComments = [];
-          continue;
-        }
-
-        // Multi-line category format
-        if (trimmed === '# ---') {
-          const nextLine = lines[i + 1]?.trim();
-          if (nextLine?.startsWith('#')) {
-            const categoryName = nextLine.replace(/^#\s*/, '').trim();
-            if (categoryName && !categoryName.match(/^[-=]+$/)) {
-              currentCategory = categoryName;
-              i += 2; // Skip category lines
-              currentComments = [];
-              continue;
-            }
-          }
-        }
-      }
-
-      // Variable line
-      const varMatch = line.match(/^\s*(#\s*)?([A-Z][A-Z0-9_]*)\s*=\s*(.*)$/);
-      if (varMatch) {
-        const name = varMatch[2];
-        let value = varMatch[3].trim();
-
-        // Remove inline comments
-        value = value.replace(/\s*#.*$/, '');
-
-        // Remove quotes
-        if (
-          (value.startsWith('"') && value.endsWith('"')) ||
-          (value.startsWith("'") && value.endsWith("'"))
-        ) {
-          value = value.slice(1, -1);
-        }
-
-        variables.push({
-          category: currentCategory,
-          name,
-          value: value || '(not set)',
-          description: currentComments.join(' ').trim() || 'No description',
-          isCommented: !!varMatch[1],
-        });
-
-        currentComments = [];
-        continue;
-      }
-
-      // Comment line
-      if (trimmed.startsWith(categoryPrefix)) {
-        const comment = trimmed.replace(/^#\s*/, '').trim();
-        if (comment && !comment.match(/^[-=]+$/)) {
-          currentComments.push(comment);
-        }
-      }
-    }
-
-    return variables;
-  }
-
-  /**
-   * Parse SQL schema
-   */
-  private parseSQL(content: string, _tablePattern?: RegExp): ParsedItem[] {
-    const tables: ParsedItem[] = [];
-    const lines = content.split('\n');
-    let currentTable: ParsedItem | null = null;
-    let inTableDef = false;
-
-    for (const line of lines) {
-      const trimmed = line.trim();
-
-      // Table start
-      const tableMatch = trimmed.match(/CREATE TABLE (?:IF NOT EXISTS )?(\w+)\s*\(/);
-      if (tableMatch) {
-        currentTable = {
-          name: tableMatch[1],
-          columns: [],
-          constraints: [],
-        };
-        inTableDef = true;
-        continue;
-      }
-
-      // Table end
-      if (inTableDef && trimmed === ');') {
-        inTableDef = false;
-        if (currentTable) {
-          tables.push(currentTable);
-          currentTable = null;
-        }
-        continue;
-      }
-
-      // Column definition
-      if (inTableDef && currentTable && !trimmed.startsWith('--')) {
-        if (trimmed.startsWith('CONSTRAINT') || trimmed.startsWith('PRIMARY KEY')) {
-          currentTable.constraints.push(trimmed);
-        } else if (trimmed) {
-          const columnMatch = trimmed.match(/^(\w+)\s+([A-Z]+[^,]*)/);
-          if (columnMatch) {
-            currentTable.columns.push({
-              name: columnMatch[1],
-              type: columnMatch[2].split(/\s+/)[0],
-            });
-          }
-        }
-      }
-    }
-
-    return tables;
-  }
-
-  /**
-   * Parse grep output
-   */
-  private parseGrep(command: string, extractPattern?: RegExp): ParsedItem[] {
-    try {
-      const output = execSync(command, { encoding: 'utf-8' });
-      const lines = output.split('\n').filter(Boolean);
-
-      if (!extractPattern) {
-        return lines.map((line) => ({ value: line.trim() }));
-      }
-
-      const items: ParsedItem[] = [];
-      for (const line of lines) {
-        const match = line.match(extractPattern);
-        if (match) {
-          items.push({ value: match[1] || match[0] });
-        }
-      }
-
-      return items;
-    } catch {
-      console.warn(`Grep command failed: ${command}`);
-      return [];
-    }
-  }
-
   /**
    * Categorize items based on rules
    */
diff --git a/src/lib/generators/parsers/env-parser.ts b/src/lib/generators/parsers/env-parser.ts
new file mode 100644
index 0000000..4f90674
--- /dev/null
+++ b/src/lib/generators/parsers/env-parser.ts
@@ -0,0 +1,94 @@
+/**
+ * ENV Parser
+ *
+ * Parses .env files with support for categories, comments, and variable detection.
+ */
+
+import type { ParsedItem } from './types';
+
+/**
+ * Parse .env file content
+ * @param content - Raw .env file content
+ * @param categoryPrefix - Prefix for category comments (default: '#')
+ * @returns Array of parsed environment variables with metadata
+ */
+export function parseEnv(content: string, categoryPrefix = '#'): ParsedItem[] {
+  const lines = content.split('\n');
+  const variables: ParsedItem[] = [];
+  let currentCategory = 'General';
+  let currentComments: string[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Empty line
+    if (!trimmed) {
+      currentComments = [];
+      continue;
+    }
+
+    // Category detection
+    if (trimmed.startsWith(categoryPrefix)) {
+      const categoryMatch = trimmed.match(/^#\s*---\s*(.+?)\s*---/);
+      if (categoryMatch) {
+        currentCategory = categoryMatch[1].trim();
+        currentComments = [];
+        continue;
+      }
+
+      // Multi-line category format
+      if (trimmed === '# ---') {
+        const nextLine = lines[i + 1]?.trim();
+        if (nextLine?.startsWith('#')) {
+          const categoryName = nextLine.replace(/^#\s*/, '').trim();
+          if (categoryName && !categoryName.match(/^[-=]+$/)) {
+            currentCategory = categoryName;
+            i += 2; // Skip category lines
+            currentComments = [];
+            continue;
+          }
+        }
+      }
+    }
+
+    // Variable line
+    const varMatch = line.match(/^\s*(#\s*)?([A-Z][A-Z0-9_]*)\s*=\s*(.*)$/);
+    if (varMatch) {
+      const name = varMatch[2];
+      let value = varMatch[3].trim();
+
+      // Remove inline comments
+      value = value.replace(/\s*#.*$/, '');
+
+      // Remove quotes
+      if (
+        (value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))
+      ) {
+        value = value.slice(1, -1);
+      }
+
+      variables.push({
+        category: currentCategory,
+        name,
+        value: value || '(not set)',
+        description: currentComments.join(' ').trim() || 'No description',
+        isCommented: !!varMatch[1],
+      });
+
+      currentComments = [];
+      continue;
+    }
+
+    // Comment line
+    if (trimmed.startsWith(categoryPrefix)) {
+      const comment = trimmed.replace(/^#\s*/, '').trim();
+      if (comment && !comment.match(/^[-=]+$/)) {
+        currentComments.push(comment);
+      }
+    }
+  }
+
+  return variables;
+}
diff --git a/src/lib/generators/parsers/grep-parser.ts b/src/lib/generators/parsers/grep-parser.ts
new file mode 100644
index 0000000..9f08d32
--- /dev/null
+++ b/src/lib/generators/parsers/grep-parser.ts
@@ -0,0 +1,38 @@
+/**
+ * Grep Parser
+ *
+ * Executes a grep command and parses the output.
+ */
+
+import { execSync } from 'child_process';
+import type { ParsedItem } from './types';
+
+/**
+ * Execute grep command and parse output
+ * @param command - Shell command to execute
+ * @param extractPattern - Optional regex to extract values from each line
+ * @returns Array of parsed items
+ */
+export function parseGrep(command: string, extractPattern?: RegExp): ParsedItem[] {
+  try {
+    const output = execSync(command, { encoding: 'utf-8' });
+    const lines = output.split('\n').filter(Boolean);
+
+    if (!extractPattern) {
+      return lines.map((line) => ({ value: line.trim() }));
+    }
+
+    const items: ParsedItem[] = [];
+    for (const line of lines) {
+      const match = line.match(extractPattern);
+      if (match) {
+        items.push({ value: match[1] || match[0] });
+      }
+    }
+
+    return items;
+  } catch {
+    console.warn(`Grep command failed: ${command}`);
+    return [];
+  }
+}
diff --git a/src/lib/generators/parsers/index.ts b/src/lib/generators/parsers/index.ts
new file mode 100644
index 0000000..d51f6a8
--- /dev/null
+++ b/src/lib/generators/parsers/index.ts
@@ -0,0 +1,11 @@
+/**
+ * Parser Exports
+ *
+ * Central export point for all parsers.
+ */
+
+export { parseJSON } from './json-parser';
+export { parseEnv } from './env-parser';
+export { parseSQL } from './sql-parser';
+export { parseGrep } from './grep-parser';
+export type { ParsedItem, Parser } from './types';
diff --git a/src/lib/generators/parsers/json-parser.ts b/src/lib/generators/parsers/json-parser.ts
new file mode 100644
index 0000000..1be80a2
--- /dev/null
+++ b/src/lib/generators/parsers/json-parser.ts
@@ -0,0 +1,42 @@
+/**
+ * JSON Parser
+ *
+ * Parses JSON files and extracts items from a specified path.
+ */
+
+import type { ParsedItem } from './types';
+
+/**
+ * Parse JSON content and extract items from a path
+ * @param content - Raw JSON string
+ * @param path - Optional dot-notation path to extract (e.g., "scripts" or "dependencies.dev")
+ * @returns Array of parsed items
+ */
+export function parseJSON(content: string, path?: string): ParsedItem[] {
+  const data = JSON.parse(content);
+
+  if (!path) {
+    // If no path, assume data is array or convert object to entries
+    return Array.isArray(data)
+      ? data
+      : Object.entries(data).map(([key, value]) => ({ key, value }));
+  }
+
+  // Extract from path (e.g., "scripts" -> data.scripts)
+  const extracted = path.split('.').reduce((obj, key) => obj?.[key], data);
+
+  if (!extracted) {
+    throw new Error(`Path "${path}" not found in JSON`);
+  }
+
+  // Convert to array of items
+  if (Array.isArray(extracted)) {
+    return extracted;
+  }
+
+  // Convert object to array with key-value pairs
+  return Object.entries(extracted).map(([key, value]) => ({
+    name: key,
+    value: typeof value === 'string' ? value : JSON.stringify(value),
+  }));
+}
diff --git a/src/lib/generators/parsers/parsers.test.ts b/src/lib/generators/parsers/parsers.test.ts
new file mode 100644
index 0000000..829881c
--- /dev/null
+++ b/src/lib/generators/parsers/parsers.test.ts
@@ -0,0 +1,193 @@
+/**
+ * Parser Tests
+ *
+ * Tests for the parser modules extracted from generic-generator.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { parseJSON } from './json-parser';
+import { parseEnv } from './env-parser';
+import { parseSQL } from './sql-parser';
+
+describe('parseJSON', () => {
+  it('should parse array data directly', () => {
+    const content = '[{"name": "foo"}, {"name": "bar"}]';
+    const result = parseJSON(content);
+    expect(result).toEqual([{ name: 'foo' }, { name: 'bar' }]);
+  });
+
+  it('should convert object to entries without path', () => {
+    const content = '{"foo": "bar", "baz": "qux"}';
+    const result = parseJSON(content);
+    expect(result).toEqual([
+      { key: 'foo', value: 'bar' },
+      { key: 'baz', value: 'qux' },
+    ]);
+  });
+
+  it('should extract nested path from object', () => {
+    const content = '{"scripts": {"build": "tsc", "test": "vitest"}}';
+    const result = parseJSON(content, 'scripts');
+    expect(result).toEqual([
+      { name: 'build', value: 'tsc' },
+      { name: 'test', value: 'vitest' },
+    ]);
+  });
+
+  it('should handle deep nested paths', () => {
+    const content = '{"level1": {"level2": {"items": [{"id": 1}, {"id": 2}]}}}';
+    const result = parseJSON(content, 'level1.level2.items');
+    expect(result).toEqual([{ id: 1 }, { id: 2 }]);
+  });
+
+  it('should throw for invalid path', () => {
+    const content = '{"foo": "bar"}';
+    expect(() => parseJSON(content, 'nonexistent')).toThrow('Path "nonexistent" not found in JSON');
+  });
+
+  it('should stringify non-string values', () => {
+    const content = '{"config": {"nested": {"key": "value"}}}';
+    const result = parseJSON(content, 'config');
+    expect(result[0].value).toBe('{"key":"value"}');
+  });
+});
+
+describe('parseEnv', () => {
+  it('should parse simple variables', () => {
+    const content = 'FOO=bar\nBAZ=qux';
+    const result = parseEnv(content);
+    expect(result).toHaveLength(2);
+    expect(result[0].name).toBe('FOO');
+    expect(result[0].value).toBe('bar');
+    expect(result[1].name).toBe('BAZ');
+    expect(result[1].value).toBe('qux');
+  });
+
+  it('should detect categories with --- format', () => {
+    const content = `# --- Database ---
+DB_HOST=localhost
+DB_PORT=5432
+
+# --- API ---
+API_KEY=secret`;
+    const result = parseEnv(content);
+    expect(result[0].category).toBe('Database');
+    expect(result[1].category).toBe('Database');
+    expect(result[2].category).toBe('API');
+  });
+
+  it('should handle commented variables', () => {
+    const content = '# FOO=commented\nBAR=active';
+    const result = parseEnv(content);
+    expect(result).toHaveLength(2);
+    expect(result[0].isCommented).toBe(true);
+    expect(result[1].isCommented).toBe(false);
+  });
+
+  it('should remove quotes from values', () => {
+    const content = 'FOO="quoted value"\nBAR=\'single quoted\'';
+    const result = parseEnv(content);
+    expect(result[0].value).toBe('quoted value');
+    expect(result[1].value).toBe('single quoted');
+  });
+
+  it('should strip inline comments', () => {
+    const content = 'FOO=value # this is a comment';
+    const result = parseEnv(content);
+    expect(result[0].value).toBe('value');
+  });
+
+  it('should handle empty values', () => {
+    const content = 'FOO=';
+    const result = parseEnv(content);
+    expect(result[0].value).toBe('(not set)');
+  });
+
+  it('should collect description from preceding comments', () => {
+    const content = `# This is the description
+# of the variable
+FOO=bar`;
+    const result = parseEnv(content);
+    expect(result[0].description).toBe('This is the description of the variable');
+  });
+});
+
+describe('parseSQL', () => {
+  it('should parse CREATE TABLE statements', () => {
+    const content = `CREATE TABLE users (
+  id INTEGER PRIMARY KEY,
+  name TEXT NOT NULL,
+  email TEXT
+);`;
+    const result = parseSQL(content);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe('users');
+    expect(result[0].columns).toHaveLength(3);
+  });
+
+  it('should extract column types', () => {
+    const content = `CREATE TABLE items (
+  id INTEGER,
+  price REAL,
+  created_at TIMESTAMP
+);`;
+    const result = parseSQL(content);
+    expect(result[0].columns[0]).toEqual({ name: 'id', type: 'INTEGER' });
+    expect(result[0].columns[1]).toEqual({ name: 'price', type: 'REAL' });
+    expect(result[0].columns[2]).toEqual({ name: 'created_at', type: 'TIMESTAMP' });
+  });
+
+  it('should handle CREATE TABLE IF NOT EXISTS', () => {
+    const content = `CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY
+);`;
+    const result = parseSQL(content);
+    expect(result[0].name).toBe('sessions');
+  });
+
+  it('should extract CONSTRAINT definitions', () => {
+    const content = `CREATE TABLE orders (
+  id INTEGER,
+  user_id INTEGER,
+  CONSTRAINT fk_user FOREIGN KEY (user_id) REFERENCES users(id)
+);`;
+    const result = parseSQL(content);
+    expect(result[0].constraints).toHaveLength(1);
+    expect(result[0].constraints[0]).toContain('CONSTRAINT fk_user');
+  });
+
+  it('should handle PRIMARY KEY constraints', () => {
+    const content = `CREATE TABLE composite (
+  a INTEGER,
+  b INTEGER,
+  PRIMARY KEY (a, b)
+);`;
+    const result = parseSQL(content);
+    expect(result[0].constraints).toHaveLength(1);
+    expect(result[0].constraints[0]).toContain('PRIMARY KEY');
+  });
+
+  it('should parse multiple tables', () => {
+    const content = `CREATE TABLE users (
+  id INTEGER
+);
+
+CREATE TABLE posts (
+  id INTEGER
+);`;
+    const result = parseSQL(content);
+    expect(result).toHaveLength(2);
+    expect(result[0].name).toBe('users');
+    expect(result[1].name).toBe('posts');
+  });
+
+  it('should skip SQL comments', () => {
+    const content = `CREATE TABLE items (
+  -- this is a comment
+  id INTEGER
+);`;
+    const result = parseSQL(content);
+    expect(result[0].columns).toHaveLength(1);
+    expect(result[0].columns[0].name).toBe('id');
+  });
+});
diff --git a/src/lib/generators/parsers/sql-parser.ts b/src/lib/generators/parsers/sql-parser.ts
new file mode 100644
index 0000000..47f8231
--- /dev/null
+++ b/src/lib/generators/parsers/sql-parser.ts
@@ -0,0 +1,63 @@
+/**
+ * SQL Parser
+ *
+ * Parses SQL schema files and extracts table definitions.
+ */
+
+import type { ParsedItem } from './types';
+
+/**
+ * Parse SQL schema content
+ * @param content - Raw SQL content
+ * @param _tablePattern - Optional regex pattern for table names (reserved for future use)
+ * @returns Array of parsed table definitions
+ */
+export function parseSQL(content: string, _tablePattern?: RegExp): ParsedItem[] {
+  const tables: ParsedItem[] = [];
+  const lines = content.split('\n');
+  let currentTable: ParsedItem | null = null;
+  let inTableDef = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    // Table start
+    const tableMatch = trimmed.match(/CREATE TABLE (?:IF NOT EXISTS )?(\w+)\s*\(/);
+    if (tableMatch) {
+      currentTable = {
+        name: tableMatch[1],
+        columns: [],
+        constraints: [],
+      };
+      inTableDef = true;
+      continue;
+    }
+
+    // Table end
+    if (inTableDef && trimmed === ');') {
+      inTableDef = false;
+      if (currentTable) {
+        tables.push(currentTable);
+        currentTable = null;
+      }
+      continue;
+    }
+
+    // Column definition
+    if (inTableDef && currentTable && !trimmed.startsWith('--')) {
+      if (trimmed.startsWith('CONSTRAINT') || trimmed.startsWith('PRIMARY KEY')) {
+        currentTable.constraints.push(trimmed);
+      } else if (trimmed) {
+        const columnMatch = trimmed.match(/^(\w+)\s+([A-Z]+[^,]*)/);
+        if (columnMatch) {
+          currentTable.columns.push({
+            name: columnMatch[1],
+            type: columnMatch[2].split(/\s+/)[0],
+          });
+        }
+      }
+    }
+  }
+
+  return tables;
+}
diff --git a/src/lib/generators/parsers/types.ts b/src/lib/generators/parsers/types.ts
new file mode 100644
index 0000000..de5cc34
--- /dev/null
+++ b/src/lib/generators/parsers/types.ts
@@ -0,0 +1,19 @@
+/**
+ * Parser Types
+ *
+ * Shared types for all parsers in the generic generator system.
+ */
+
+/**
+ * Generic parsed item - represents any parsed data structure
+ * The actual shape depends on the parser type (JSON, ENV, SQL, etc.)
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type ParsedItem = any;
+
+/**
+ * Base parser interface that all parsers implement
+ */
+export interface Parser {
+  parse(content: string): ParsedItem[];
+}
diff --git a/src/lib/server/cli-executor.test.ts b/src/lib/server/cli-executor.test.ts
new file mode 100644
index 0000000..76ceb68
--- /dev/null
+++ b/src/lib/server/cli-executor.test.ts
@@ -0,0 +1,276 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { CliExecutor } from './cli-executor';
+
+describe('CliExecutor', () => {
+  let executor: CliExecutor;
+
+  beforeEach(() => {
+    executor = new CliExecutor({
+      allowedCommands: ['echo', 'git', 'npm'],
+      timeout: 5000,
+      maxOutputLength: 1000,
+    });
+  });
+
+  describe('command validation', () => {
+    describe('allowlist enforcement', () => {
+      it('should allow commands in the allowlist', async () => {
+        const result = await executor.execute('echo hello');
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout.trim()).toBe('hello');
+      });
+
+      it('should reject commands not in the allowlist', async () => {
+        await expect(executor.execute('rm -rf /')).rejects.toThrow('Command not allowed: rm');
+      });
+
+      it('should reject unknown commands', async () => {
+        await expect(executor.execute('malicious-command')).rejects.toThrow(
+          'Command not allowed: malicious-command'
+        );
+      });
+
+      it('should allow commands with path prefix (e.g., git/something)', async () => {
+        // This tests the startsWith(allowed + '/') logic
+        const pathExecutor = new CliExecutor({
+          allowedCommands: ['git'],
+        });
+        // git/subcommand is allowed by the validator (git + /) but will fail to execute
+        // The validation passes, so the command runs and returns non-zero exit code
+        const result = await pathExecutor.execute('git/subcommand');
+        // Command doesn't exist, so it should fail with non-zero exit code
+        expect(result.exitCode).not.toBe(0);
+      });
+
+      it('should handle empty allowlist', async () => {
+        const emptyExecutor = new CliExecutor({
+          allowedCommands: [],
+        });
+        await expect(emptyExecutor.execute('echo test')).rejects.toThrow(
+          'Command not allowed: echo'
+        );
+      });
+    });
+
+    describe('shell metacharacter blocking', () => {
+      it('should block semicolon (command chaining)', async () => {
+        await expect(executor.execute('echo hello; rm -rf /')).rejects.toThrow(
+          'Command not allowed'
+        );
+      });
+
+      it('should block ampersand (background execution)', async () => {
+        await expect(executor.execute('echo hello & malicious')).rejects.toThrow(
+          'Command not allowed'
+        );
+      });
+
+      it('should block pipe (output redirection)', async () => {
+        await expect(executor.execute('echo hello | cat')).rejects.toThrow('Command not allowed');
+      });
+
+      it('should block backticks (command substitution)', async () => {
+        await expect(executor.execute('echo `whoami`')).rejects.toThrow('Command not allowed');
+      });
+
+      it('should block dollar sign (variable expansion)', async () => {
+        await expect(executor.execute('echo $HOME')).rejects.toThrow('Command not allowed');
+      });
+
+      it('should block parentheses (subshell)', async () => {
+        await expect(executor.execute('echo (test)')).rejects.toThrow('Command not allowed');
+      });
+
+      it('should block curly braces (brace expansion)', async () => {
+        await expect(executor.execute('echo {a,b,c}')).rejects.toThrow('Command not allowed');
+      });
+
+      it('should block square brackets', async () => {
+        await expect(executor.execute('echo [test]')).rejects.toThrow('Command not allowed');
+      });
+
+      it('should block angle brackets (redirection)', async () => {
+        await expect(executor.execute('echo hello > /etc/passwd')).rejects.toThrow(
+          'Command not allowed'
+        );
+        await expect(executor.execute('echo hello < /etc/passwd')).rejects.toThrow(
+          'Command not allowed'
+        );
+      });
+
+      it('should block backslash (escape sequences)', async () => {
+        await expect(executor.execute('echo hello\\nworld')).rejects.toThrow('Command not allowed');
+      });
+
+      it('should allow safe arguments with hyphens and equals', async () => {
+        const result = await executor.execute('echo --my-flag=value');
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout.trim()).toBe('--my-flag=value');
+      });
+
+      it('should allow safe arguments with dots and slashes in paths', async () => {
+        // Forward slash is blocked, but let's verify other safe chars work
+        const result = await executor.execute('echo test.txt');
+        expect(result.exitCode).toBe(0);
+      });
+    });
+
+    describe('injection attack prevention', () => {
+      it('should handle commands with quotes safely', async () => {
+        const result = await executor.execute('echo "hello world"');
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout.trim()).toBe('hello world');
+      });
+
+      it('should handle commands with single quotes safely', async () => {
+        const result = await executor.execute("echo 'hello world'");
+        expect(result.exitCode).toBe(0);
+      });
+
+      it('should handle moderately long commands', async () => {
+        const longArg = 'a'.repeat(100);
+        const result = await executor.execute(`echo ${longArg}`);
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout.length).toBeGreaterThan(0);
+      });
+    });
+  });
+
+  describe('command execution', () => {
+    it('should capture stdout', async () => {
+      const result = await executor.execute('echo hello world');
+      expect(result.stdout.trim()).toBe('hello world');
+      expect(result.exitCode).toBe(0);
+    });
+
+    it('should have stderr property in result', async () => {
+      // Test that result has stderr property
+      const result = await executor.execute('echo hello');
+      expect(result).toHaveProperty('stderr');
+      expect(typeof result.stderr).toBe('string');
+    });
+
+    it('should return non-zero exit code for failed commands', async () => {
+      const failExecutor = new CliExecutor({
+        allowedCommands: ['false'],
+      });
+      const result = await failExecutor.execute('false');
+      expect(result.exitCode).not.toBe(0);
+    });
+
+    it('should track execution duration', async () => {
+      const result = await executor.execute('echo fast');
+      expect(result.duration).toBeGreaterThanOrEqual(0);
+      expect(result.duration).toBeLessThan(5000);
+    });
+
+    it('should respect working directory configuration', async () => {
+      const cwdExecutor = new CliExecutor({
+        allowedCommands: ['pwd'],
+        workingDirectory: '/tmp',
+      });
+      const result = await cwdExecutor.execute('pwd');
+      expect(result.stdout.trim()).toBe('/tmp');
+    });
+  });
+
+  describe('output handling', () => {
+    it('should truncate stdout exceeding maxOutputLength', async () => {
+      const smallExecutor = new CliExecutor({
+        allowedCommands: ['echo'],
+        maxOutputLength: 10,
+      });
+      const result = await smallExecutor.execute('echo this is a very long message');
+      expect(result.stdout.length).toBeLessThanOrEqual(10);
+    });
+
+    it('should truncate stderr exceeding maxOutputLength', async () => {
+      const smallExecutor = new CliExecutor({
+        allowedCommands: ['echo'],
+        maxOutputLength: 10,
+      });
+      // stderr truncation is handled similarly
+      expect(smallExecutor).toBeDefined();
+    });
+  });
+
+  describe('timeout handling', () => {
+    it('should timeout long-running commands', async () => {
+      const shortTimeoutExecutor = new CliExecutor({
+        allowedCommands: ['sleep'],
+        timeout: 100, // 100ms timeout
+      });
+
+      const result = await shortTimeoutExecutor.execute('sleep 10');
+      // Command should fail due to timeout
+      expect(result.exitCode).not.toBe(0);
+    }, 5000);
+  });
+
+  describe('environment variables', () => {
+    it('should set FORCE_COLOR environment variable', async () => {
+      const envExecutor = new CliExecutor({
+        allowedCommands: ['printenv'],
+      });
+      const result = await envExecutor.execute('printenv FORCE_COLOR');
+      expect(result.stdout.trim()).toBe('1');
+    });
+
+    it('should set CLICOLOR_FORCE environment variable', async () => {
+      const envExecutor = new CliExecutor({
+        allowedCommands: ['printenv'],
+      });
+      const result = await envExecutor.execute('printenv CLICOLOR_FORCE');
+      expect(result.stdout.trim()).toBe('1');
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle empty command', async () => {
+      await expect(executor.execute('')).rejects.toThrow('Command not allowed');
+    });
+
+    it('should handle whitespace-only command', async () => {
+      await expect(executor.execute('   ')).rejects.toThrow('Command not allowed');
+    });
+
+    it('should handle command with leading whitespace', async () => {
+      const result = await executor.execute('  echo hello');
+      expect(result.stdout.trim()).toBe('hello');
+    });
+
+    it('should handle command with trailing whitespace', async () => {
+      const result = await executor.execute('echo hello  ');
+      expect(result.stdout.trim()).toBe('hello');
+    });
+
+    it('should handle special but safe characters in arguments', async () => {
+      // Quotes are allowed
+      const result = await executor.execute('echo "hello world"');
+      expect(result.exitCode).toBe(0);
+    });
+  });
+
+  describe('configuration defaults', () => {
+    it('should use default timeout when not specified', () => {
+      const defaultExecutor = new CliExecutor({
+        allowedCommands: ['echo'],
+      });
+      expect(defaultExecutor).toBeDefined();
+    });
+
+    it('should use default maxOutputLength when not specified', () => {
+      const defaultExecutor = new CliExecutor({
+        allowedCommands: ['echo'],
+      });
+      expect(defaultExecutor).toBeDefined();
+    });
+
+    it('should use default workingDirectory when not specified', () => {
+      const defaultExecutor = new CliExecutor({
+        allowedCommands: ['echo'],
+      });
+      expect(defaultExecutor).toBeDefined();
+    });
+  });
+});
diff --git a/src/lib/server/cli-executor.ts b/src/lib/server/cli-executor.ts
index 0aaebaa..e7a6882 100644
--- a/src/lib/server/cli-executor.ts
+++ b/src/lib/server/cli-executor.ts
@@ -1,8 +1,8 @@
-import { exec } from 'child_process';
+import { execFile } from 'child_process';
 import { promisify } from 'util';
 import { TIMEOUT, FILE_SIZE } from '../constants.js';
 
-const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 
 /**
  * Result from executing a CLI command
@@ -71,9 +71,58 @@ export class CliExecutor {
 
   /**
    * Pattern to detect shell metacharacters that could enable command injection
+   * Note: Quotes are allowed for argument grouping but will be handled by parseCommand
    */
   private static readonly DANGEROUS_CHARS = /[;&|`$(){}[\]<>\\]/;
 
+  /**
+   * Parse command string into executable and arguments
+   * Handles quoted strings (single and double quotes) for proper argument grouping
+   */
+  private parseCommand(command: string): { executable: string; args: string[] } {
+    const tokens: string[] = [];
+    let current = '';
+    let inQuote: string | null = null;
+
+    for (let i = 0; i < command.length; i++) {
+      const char = command[i];
+
+      if (inQuote) {
+        // Inside a quoted string
+        if (char === inQuote) {
+          // End of quote
+          inQuote = null;
+        } else {
+          current += char;
+        }
+      } else {
+        // Outside quotes
+        if (char === '"' || char === "'") {
+          // Start of quote
+          inQuote = char;
+        } else if (char === ' ' || char === '\t') {
+          // Whitespace separator
+          if (current) {
+            tokens.push(current);
+            current = '';
+          }
+        } else {
+          current += char;
+        }
+      }
+    }
+
+    // Push any remaining token
+    if (current) {
+      tokens.push(current);
+    }
+
+    return {
+      executable: tokens[0] || '',
+      args: tokens.slice(1),
+    };
+  }
+
   /**
    * Validate command against allowlist and check for injection attempts
    * Only allows commands that start with an allowed prefix and contain no shell metacharacters
@@ -100,6 +149,12 @@ export class CliExecutor {
 
   /**
    * Execute CLI command safely with timeout and output limits
+   *
+   * Uses execFile() instead of exec() for improved security:
+   * - Does not spawn a shell, preventing shell injection attacks
+   * - Arguments are passed directly to the executable
+   * - Quoted strings are handled internally for argument grouping
+   *
    * @param command - Command to execute (must be in allowlist)
    * @returns Execution result with stdout, stderr, exit code, and duration
    * @throws Error if command is not allowed
@@ -109,10 +164,11 @@ export class CliExecutor {
       throw new Error(`Command not allowed: ${command.split(' ')[0]}`);
     }
 
+    const { executable, args } = this.parseCommand(command);
     const startTime = Date.now();
 
     try {
-      const { stdout, stderr } = await execAsync(command, {
+      const { stdout, stderr } = await execFileAsync(executable, args, {
         timeout: this.config.timeout,
         maxBuffer: this.config.maxOutputLength,
         cwd: this.config.workingDirectory,
@@ -132,10 +188,13 @@ export class CliExecutor {
       };
     } catch (error: unknown) {
       const err = error as Record<string, unknown>;
+      // Node.js error codes can be strings (e.g., 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER')
+      // Process exit codes are numbers. Use 1 as default for Node.js errors.
+      const exitCode = typeof err.code === 'number' ? err.code : 1;
       return {
         stdout: (err.stdout as string) || '',
         stderr: (err.stderr as string) || (err.message as string) || '',
-        exitCode: (err.code as number) || 1,
+        exitCode,
         duration: Date.now() - startTime,
       };
     }
diff --git a/src/lib/server/screenshot-service.ts b/src/lib/server/screenshot-service.ts
index 9490b51..f54b8f2 100644
--- a/src/lib/server/screenshot-service.ts
+++ b/src/lib/server/screenshot-service.ts
@@ -20,6 +20,83 @@ import {
 
 const logger = createLogger('screenshot-service');
 
+/**
+ * Result from processing screenshot images into multiple formats
+ */
+interface ProcessedImageResult {
+  publicPath: string;
+  webpPath: string;
+  webp2xPath?: string;
+  displayWidth?: number;
+  displayHeight?: number;
+}
+
+/**
+ * Processes a screenshot into multiple formats and resolutions
+ * Shared logic between CLI and web screenshot generation
+ */
+async function processScreenshotImage(options: {
+  screenshot2xPath: string;
+  outputDir: string;
+  name: string;
+  basePath: string;
+}): Promise<ProcessedImageResult> {
+  const { screenshot2xPath, outputDir, name, basePath } = options;
+
+  const sharpImage = sharp(screenshot2xPath);
+  const metadata = await sharpImage.metadata();
+
+  // Generate 2x WebP (from high-res source)
+  const webp2xPath = path.join(outputDir, `${name}@2x.webp`);
+  await sharpImage.clone().webp({ quality: IMAGE_QUALITY.WEBP }).toFile(webp2xPath);
+
+  // Downscale to 1x using bicubic interpolation for better quality
+  const webpPath = path.join(outputDir, `${name}.webp`);
+  const screenshotPath = path.join(outputDir, `${name}.png`);
+
+  if (metadata.width && metadata.width >= DIMENSIONS.MIN_WIDTH_FOR_2X) {
+    await sharp(screenshot2xPath)
+      .resize({
+        width: Math.floor(metadata.width / DIMENSIONS.DEVICE_SCALE_FACTOR),
+        kernel: 'cubic', // Bicubic interpolation for sharp downscaling
+      })
+      .webp({ quality: IMAGE_QUALITY.WEBP })
+      .toFile(webpPath);
+
+    // Also save 1x PNG
+    await sharp(screenshot2xPath)
+      .resize({
+        width: Math.floor(metadata.width / DIMENSIONS.DEVICE_SCALE_FACTOR),
+        kernel: 'cubic',
+      })
+      .png()
+      .toFile(screenshotPath);
+  } else {
+    // If too small, just use the 2x as-is
+    await sharpImage.clone().webp({ quality: IMAGE_QUALITY.WEBP }).toFile(webpPath);
+    await sharpImage.clone().png().toFile(screenshotPath);
+  }
+
+  // Return 1x dimensions for the img element
+  const displayWidth = metadata.width
+    ? Math.floor(metadata.width / DIMENSIONS.DEVICE_SCALE_FACTOR)
+    : metadata.width;
+  const displayHeight = metadata.height
+    ? Math.floor(metadata.height / DIMENSIONS.DEVICE_SCALE_FACTOR)
+    : metadata.height;
+
+  return {
+    publicPath: `${basePath}/${name}.png`,
+    webpPath: `${basePath}/${name}.webp`,
+    webp2xPath:
+      metadata.width && metadata.width >= DIMENSIONS.MIN_WIDTH_FOR_2X
+        ? `${basePath}/${name}@2x.webp`
+        : undefined,
+    displayWidth,
+    displayHeight,
+  };
+}
+
 /**
  * Allowed domains for screenshot generation (SSRF protection)
  * Add your production domains here
@@ -299,72 +376,32 @@ async function generateCliScreenshot(options: {
   await browser.close();
   logger.debug({ path: screenshot2xPath }, 'Screenshot captured, processing image formats');
 
-  // Generate multiple formats and resolutions
+  // Process image into multiple formats using shared function
   const basePath = `${screenshotsConfig.basePath}/v${version}`;
-  const sharpImage = sharp(screenshot2xPath);
-  const metadata = await sharpImage.metadata();
-
-  // Generate 2x WebP (from high-res source)
-  const webp2xPath = path.join(outputDir, `${name}@2x.webp`);
-  await sharpImage.clone().webp({ quality: IMAGE_QUALITY.WEBP }).toFile(webp2xPath);
-
-  // Downscale to 1x using bicubic interpolation for better quality
-  const webpPath = path.join(outputDir, `${name}.webp`);
-  const screenshotPath = path.join(outputDir, `${name}.png`);
-
-  if (metadata.width && metadata.width >= DIMENSIONS.MIN_WIDTH_FOR_2X) {
-    await sharp(screenshot2xPath)
-      .resize({
-        width: Math.floor(metadata.width / DIMENSIONS.DEVICE_SCALE_FACTOR),
-        kernel: 'cubic', // Bicubic interpolation for sharp downscaling
-      })
-      .webp({ quality: IMAGE_QUALITY.WEBP })
-      .toFile(webpPath);
-
-    // Also save 1x PNG
-    await sharp(screenshot2xPath)
-      .resize({
-        width: Math.floor(metadata.width / DIMENSIONS.DEVICE_SCALE_FACTOR),
-        kernel: 'cubic',
-      })
-      .png()
-      .toFile(screenshotPath);
-  } else {
-    // If too small, just use the 2x as-is
-    await sharpImage.clone().webp({ quality: IMAGE_QUALITY.WEBP }).toFile(webpPath);
-    await sharpImage.clone().png().toFile(screenshotPath);
-  }
-
-  const publicPath = `${basePath}/${name}.png`;
-
-  // Return 1x dimensions for the img element
-  const displayWidth = metadata.width
-    ? Math.floor(metadata.width / DIMENSIONS.DEVICE_SCALE_FACTOR)
-    : metadata.width;
-  const displayHeight = metadata.height
-    ? Math.floor(metadata.height / DIMENSIONS.DEVICE_SCALE_FACTOR)
-    : metadata.height;
+  const imageResult = await processScreenshotImage({
+    screenshot2xPath,
+    outputDir,
+    name,
+    basePath,
+  });
 
   logger.info(
     {
       name,
-      publicPath,
-      width: displayWidth,
-      height: displayHeight,
+      publicPath: imageResult.publicPath,
+      width: imageResult.displayWidth,
+      height: imageResult.displayHeight,
     },
     'CLI screenshot generated successfully'
   );
 
   return json({
     success: true,
-    path: publicPath,
-    webpPath: `${basePath}/${name}.webp`,
-    webp2xPath:
-      metadata.width && metadata.width >= DIMENSIONS.MIN_WIDTH_FOR_2X
-        ? `${basePath}/${name}@2x.webp`
-        : undefined,
-    width: displayWidth,
-    height: displayHeight,
+    path: imageResult.publicPath,
+    webpPath: imageResult.webpPath,
+    webp2xPath: imageResult.webp2xPath,
+    width: imageResult.displayWidth,
+    height: imageResult.displayHeight,
   } as ScreenshotResponse);
 }
 
@@ -476,72 +513,32 @@ async function generateWebScreenshot(options: {
   await browser.close();
   logger.debug({ path: screenshot2xPath }, 'Screenshot captured, processing image formats');
 
-  // Generate multiple formats and resolutions
+  // Process image into multiple formats using shared function
   const basePath = `${screenshotsConfig.basePath}/v${version}`;
-  const sharpImage = sharp(screenshot2xPath);
-  const metadata = await sharpImage.metadata();
-
-  // Generate 2x WebP (from high-res source)
-  const webp2xPath = path.join(outputDir, `${name}@2x.webp`);
-  await sharpImage.clone().webp({ quality: IMAGE_QUALITY.WEBP }).toFile(webp2xPath);
-
-  // Downscale to 1x using bicubic interpolation for better quality
-  const webpPath = path.join(outputDir, `${name}.webp`);
-  const screenshotPath = path.join(outputDir, `${name}.png`);
-
-  if (metadata.width && metadata.width >= DIMENSIONS.MIN_WIDTH_FOR_2X) {
-    await sharp(screenshot2xPath)
-      .resize({
-        width: Math.floor(metadata.width / DIMENSIONS.DEVICE_SCALE_FACTOR),
-        kernel: 'cubic', // Bicubic interpolation for sharp downscaling
-      })
-      .webp({ quality: IMAGE_QUALITY.WEBP })
-      .toFile(webpPath);
-
-    // Also save 1x PNG
-    await sharp(screenshot2xPath)
-      .resize({
-        width: Math.floor(metadata.width / DIMENSIONS.DEVICE_SCALE_FACTOR),
-        kernel: 'cubic',
-      })
-      .png()
-      .toFile(screenshotPath);
-  } else {
-    // If too small, just use the 2x as-is
-    await sharpImage.clone().webp({ quality: IMAGE_QUALITY.WEBP }).toFile(webpPath);
-    await sharpImage.clone().png().toFile(screenshotPath);
-  }
-
-  const publicPath = `${basePath}/${name}.png`;
-
-  // Return 1x dimensions for the img element
-  const displayWidth = metadata.width
-    ? Math.floor(metadata.width / DIMENSIONS.DEVICE_SCALE_FACTOR)
-    : metadata.width;
-  const displayHeight = metadata.height
-    ? Math.floor(metadata.height / DIMENSIONS.DEVICE_SCALE_FACTOR)
-    : metadata.height;
+  const imageResult = await processScreenshotImage({
+    screenshot2xPath,
+    outputDir,
+    name,
+    basePath,
+  });
 
   logger.info(
     {
       name,
       url,
-      publicPath,
-      width: displayWidth,
-      height: displayHeight,
+      publicPath: imageResult.publicPath,
+      width: imageResult.displayWidth,
+      height: imageResult.displayHeight,
     },
     'Web screenshot generated successfully'
   );
 
   return json({
     success: true,
-    path: publicPath,
-    webpPath: `${basePath}/${name}.webp`,
-    webp2xPath:
-      metadata.width && metadata.width >= DIMENSIONS.MIN_WIDTH_FOR_2X
-        ? `${basePath}/${name}@2x.webp`
-        : undefined,
-    width: displayWidth,
-    height: displayHeight,
+    path: imageResult.publicPath,
+    webpPath: imageResult.webpPath,
+    webp2xPath: imageResult.webp2xPath,
+    width: imageResult.displayWidth,
+    height: imageResult.displayHeight,
   } as ScreenshotResponse);
 }
diff --git a/src/lib/utils/index.ts b/src/lib/utils/index.ts
index 4969ed4..337ee8f 100644
--- a/src/lib/utils/index.ts
+++ b/src/lib/utils/index.ts
@@ -48,6 +48,10 @@ export * from './sanitize';
 // Logger utilities (browser-safe)
 export { createBrowserLogger } from './browser-logger';
 
+// Hydrator lifecycle composable (browser-only, requires Svelte)
+export { useHydrator } from './use-hydrator';
+export type { HydratorOptions } from './use-hydrator';
+
 // NOTE: Git utilities moved to server/index.ts (requires Node.js child_process)
 // Import from '@goobits/docs-engine/server' instead
 
diff --git a/src/lib/utils/use-hydrator.ts b/src/lib/utils/use-hydrator.ts
new file mode 100644
index 0000000..b8e9dab
--- /dev/null
+++ b/src/lib/utils/use-hydrator.ts
@@ -0,0 +1,128 @@
+/**
+ * Hydrator Lifecycle Composable
+ *
+ * Encapsulates the common lifecycle pattern used by all Hydrator components:
+ * - Browser environment check
+ * - afterNavigate subscription for SPA navigation
+ * - Deferred initial hydration (queueMicrotask + requestAnimationFrame)
+ * - Optional MutationObserver for dynamic content
+ * - Proper cleanup on unmount
+ */
+
+/* eslint-disable no-undef */
+// Browser globals are available when this runs (browser check is done first)
+
+import { onMount } from 'svelte';
+import { browser } from '$app/environment';
+import { afterNavigate } from '$app/navigation';
+
+export interface HydratorOptions {
+  /**
+   * Optional CSS selector for MutationObserver.
+   * When provided, a MutationObserver will watch for elements matching this selector
+   * being added to the DOM and trigger hydration automatically.
+   */
+  observeSelector?: string;
+
+  /**
+   * Whether to use requestAnimationFrame for the hydration function.
+   * Most hydrators already wrap their logic in rAF, so this defaults to false.
+   * Set to true if your hydrate function doesn't use rAF internally.
+   */
+  wrapInRaf?: boolean;
+}
+
+/**
+ * Sets up the hydration lifecycle for a Hydrator component.
+ *
+ * @param hydrate - The hydration function to call
+ * @param options - Configuration options
+ *
+ * @example
+ * ```typescript
+ * // Basic usage - hydrate function should use requestAnimationFrame internally
+ * function hydrate() {
+ *   requestAnimationFrame(() => {
+ *     const elements = document.querySelectorAll('.my-element');
+ *     // ... process elements
+ *   });
+ * }
+ *
+ * useHydrator(hydrate);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With MutationObserver for dynamic content
+ * useHydrator(hydrate, {
+ *   observeSelector: '.md-screenshot[data-name]'
+ * });
+ * ```
+ */
+export function useHydrator(hydrate: () => void, options: HydratorOptions = {}): void {
+  const { observeSelector, wrapInRaf = false } = options;
+
+  onMount(() => {
+    if (!browser) return;
+
+    const wrappedHydrate = wrapInRaf ? () => requestAnimationFrame(hydrate) : hydrate;
+
+    // Subscribe to navigation events for SPA navigation
+    const unsubscribe = afterNavigate(() => wrappedHydrate());
+
+    // Defer initial hydration to avoid conflicts with Svelte's hydration phase
+    queueMicrotask(() => {
+      requestAnimationFrame(() => {
+        wrappedHydrate();
+
+        // Set up MutationObserver if selector provided
+        if (observeSelector) {
+          setupMutationObserver(observeSelector, wrappedHydrate);
+        }
+      });
+    });
+
+    return () => {
+      unsubscribe?.();
+      // Note: MutationObserver cleanup is handled by the component unmounting
+      // and the observer going out of scope
+    };
+  });
+}
+
+/**
+ * Sets up a MutationObserver to watch for dynamically added elements.
+ * This is useful for hydrating content that's added after initial page load.
+ */
+function setupMutationObserver(selector: string, hydrate: () => void): MutationObserver {
+  const observer = new MutationObserver((mutations) => {
+    let shouldHydrate = false;
+
+    for (const mutation of mutations) {
+      if (mutation.type === 'childList') {
+        for (const node of mutation.addedNodes) {
+          if (node instanceof Element) {
+            if (node.matches(selector) || node.querySelector(selector)) {
+              shouldHydrate = true;
+              break;
+            }
+          }
+        }
+      }
+      if (shouldHydrate) break;
+    }
+
+    if (shouldHydrate) {
+      hydrate();
+    }
+  });
+
+  observer.observe(document.body, {
+    childList: true,
+    subtree: true,
+  });
+
+  return observer;
+}
+
+export default useHydrator;
diff --git a/utils/base64.ts b/utils/base64.ts
deleted file mode 100644
index 0dcf8df..0000000
--- a/utils/base64.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-/**
- * Base64 Utilities
- *
- * Provides functions for encoding/decoding base64 data
- */
-
-/**
- * Decode a base64-encoded JSON string
- */
-export function decodeJsonBase64<T = unknown>(encoded: string): T {
-  const decoded =
-    typeof atob !== 'undefined' ? atob(encoded) : Buffer.from(encoded, 'base64').toString('utf-8');
-  return JSON.parse(decoded);
-}
-
-/**
- * Encode data as base64 JSON string
- */
-export function encodeJsonBase64(data: unknown): string {
-  const json = JSON.stringify(data);
-  return typeof btoa !== 'undefined' ? btoa(json) : Buffer.from(json, 'utf-8').toString('base64');
-}
diff --git a/utils/date.ts b/utils/date.ts
deleted file mode 100644
index 95ee42c..0000000
--- a/utils/date.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-/**
- * Date Utility for DocsEngine
- *
- * Provides date formatting utilities for documentation pages
- */
-
-/**
- * Format a date as a relative time string (e.g., "2 days ago")
- */
-export function formatRelativeDate(date: Date): string {
-  const now = new Date();
-  const diffMs = now.getTime() - date.getTime();
-  const diffSecs = Math.floor(diffMs / 1000);
-  const diffMins = Math.floor(diffSecs / 60);
-  const diffHours = Math.floor(diffMins / 60);
-  const diffDays = Math.floor(diffHours / 24);
-  const diffMonths = Math.floor(diffDays / 30);
-  const diffYears = Math.floor(diffDays / 365);
-
-  if (diffSecs < 60) {
-    return 'just now';
-  } else if (diffMins < 60) {
-    return `${diffMins} minute${diffMins !== 1 ? 's' : ''} ago`;
-  } else if (diffHours < 24) {
-    return `${diffHours} hour${diffHours !== 1 ? 's' : ''} ago`;
-  } else if (diffDays < 30) {
-    return `${diffDays} day${diffDays !== 1 ? 's' : ''} ago`;
-  } else if (diffMonths < 12) {
-    return `${diffMonths} month${diffMonths !== 1 ? 's' : ''} ago`;
-  } else {
-    return `${diffYears} year${diffYears !== 1 ? 's' : ''} ago`;
-  }
-}
diff --git a/utils/git.ts b/utils/git.ts
deleted file mode 100644
index a62790b..0000000
--- a/utils/git.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-/**
- * Git Utilities
- *
- * Provides types and functions for working with git metadata
- */
-
-export interface Contributor {
-  name: string;
-  email: string;
-  commits: number;
-  avatar?: string;
-}
diff --git a/utils/index.ts b/utils/index.ts
deleted file mode 100644
index 73a401a..0000000
--- a/utils/index.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-/**
- * Docs Engine Utilities
- *
- * Browser-safe utilities for docs-engine components
- * Re-exported from src/lib/utils for convenience
- */
-
-// Navigation utilities
-export { getAdjacentLinks } from './navigation';
-export type { DocsLink } from './navigation';
-
-// Git utilities
-export type { Contributor } from './git';
-
-// Date utilities
-export { formatRelativeDate } from './date';
-
-// Search utilities
-export { loadSearchIndex, performSearch, highlightMatches } from './search-index';
-export type { SearchResult } from './search-index';
-
-// Base64 utilities
-export { decodeJsonBase64, encodeJsonBase64 } from './base64';
-
-// OpenAPI formatter utilities
-export {
-  parseOpenAPISpec,
-  filterEndpointsByPath,
-  formatSchema,
-  generateCurlExample,
-  generateTypeScriptExample,
-} from './openapi-formatter';
-export type {
-  OpenAPIEndpoint,
-  OpenAPIParameter,
-  OpenAPIRequestBody,
-  OpenAPIResponse,
-} from './openapi-formatter';
-
-// Tree types (for FileTree component)
-export interface TreeNode {
-  name: string;
-  type: 'file' | 'directory';
-  path?: string;
-  children?: TreeNode[];
-}
diff --git a/utils/navigation.ts b/utils/navigation.ts
deleted file mode 100644
index f906cd8..0000000
--- a/utils/navigation.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-/**
- * Navigation Utilities
- *
- * Provides functions for navigating documentation pages
- */
-
-export interface DocsLink {
-  title: string;
-  href: string;
-  category?: string;
-  order?: number;
-}
-
-/**
- * Get adjacent links (previous and next) for a given URL
- * Handles both flat arrays and nested navigation structures
- */
-export function getAdjacentLinks(
-  currentUrl: string,
-  allLinks: any // Can be DocsLink[] or nested navigation structure
-): { prev?: DocsLink; next?: DocsLink } {
-  // Flatten nested navigation if needed
-  let flatLinks: DocsLink[] = [];
-
-  if (Array.isArray(allLinks)) {
-    // Check if it's a nested structure with sections
-    if (allLinks.length > 0 && allLinks[0].links) {
-      // Flatten sections into a single array
-      for (const section of allLinks) {
-        if (section.links && Array.isArray(section.links)) {
-          flatLinks = flatLinks.concat(section.links);
-        }
-      }
-    } else {
-      // Already a flat array
-      flatLinks = allLinks;
-    }
-  } else {
-    // Not an array, can't find adjacent links
-    return {};
-  }
-
-  const currentIndex = flatLinks.findIndex((link) => link.href === currentUrl);
-
-  if (currentIndex === -1) {
-    return {};
-  }
-
-  return {
-    prev: currentIndex > 0 ? flatLinks[currentIndex - 1] : undefined,
-    next: currentIndex < flatLinks.length - 1 ? flatLinks[currentIndex + 1] : undefined,
-  };
-}
diff --git a/utils/openapi-formatter.ts b/utils/openapi-formatter.ts
deleted file mode 100644
index 5ca85d3..0000000
--- a/utils/openapi-formatter.ts
+++ /dev/null
@@ -1,231 +0,0 @@
-/**
- * OpenAPI Formatter Utilities
- *
- * Provides functions to parse and format OpenAPI specifications
- */
-
-export interface OpenAPIParameter {
-  name: string;
-  in: 'path' | 'query' | 'header' | 'cookie';
-  description?: string;
-  required?: boolean;
-  schema: any;
-}
-
-export interface OpenAPIRequestBody {
-  description?: string;
-  required?: boolean;
-  schema: any;
-}
-
-export interface OpenAPIResponse {
-  description: string;
-  schema?: any;
-}
-
-export interface OpenAPIEndpoint {
-  path: string;
-  method: string;
-  summary?: string;
-  description?: string;
-  parameters?: OpenAPIParameter[];
-  requestBody?: OpenAPIRequestBody;
-  responses: Record<string, OpenAPIResponse>;
-}
-
-/**
- * Parse OpenAPI specification into structured endpoints
- */
-export function parseOpenAPISpec(spec: any): OpenAPIEndpoint[] {
-  const endpoints: OpenAPIEndpoint[] = [];
-
-  if (!spec.paths) {
-    return endpoints;
-  }
-
-  for (const [path, pathItem] of Object.entries(spec.paths as Record<string, any>)) {
-    for (const [method, operation] of Object.entries(pathItem as Record<string, any>)) {
-      if (['get', 'post', 'put', 'delete', 'patch'].includes(method.toLowerCase())) {
-        const endpoint: OpenAPIEndpoint = {
-          path,
-          method: method.toUpperCase(),
-          summary: operation.summary,
-          description: operation.description,
-          parameters: operation.parameters,
-          requestBody: operation.requestBody
-            ? {
-                description: operation.requestBody.description,
-                required: operation.requestBody.required,
-                schema: operation.requestBody.content?.['application/json']?.schema,
-              }
-            : undefined,
-          responses: {},
-        };
-
-        // Parse responses
-        if (operation.responses) {
-          for (const [statusCode, response] of Object.entries(
-            operation.responses as Record<string, any>
-          )) {
-            endpoint.responses[statusCode] = {
-              description: response.description || '',
-              schema: response.content?.['application/json']?.schema,
-            };
-          }
-        }
-
-        endpoints.push(endpoint);
-      }
-    }
-  }
-
-  return endpoints;
-}
-
-/**
- * Filter endpoints by path pattern
- */
-export function filterEndpointsByPath(
-  endpoints: OpenAPIEndpoint[],
-  pathFilter: string
-): OpenAPIEndpoint[] {
-  if (!pathFilter || pathFilter === '*') {
-    return endpoints;
-  }
-
-  return endpoints.filter((endpoint) => {
-    return endpoint.path.includes(pathFilter);
-  });
-}
-
-/**
- * Format schema object into readable string
- */
-export function formatSchema(schema: any): string {
-  if (!schema) {
-    return 'any';
-  }
-
-  if (typeof schema === 'string') {
-    return schema;
-  }
-
-  if (schema.type === 'array') {
-    const itemType = formatSchema(schema.items);
-    return `${itemType}[]`;
-  }
-
-  if (schema.type === 'object' || schema.properties) {
-    const props = schema.properties || {};
-    const formatted = Object.entries(props)
-      .map(([key, value]: [string, any]) => {
-        const required = schema.required?.includes(key) ? '' : '?';
-        return `  ${key}${required}: ${formatSchema(value)}`;
-      })
-      .join('\n');
-
-    return `{\n${formatted}\n}`;
-  }
-
-  if (schema.$ref) {
-    // Extract schema name from $ref
-    const parts = schema.$ref.split('/');
-    return parts[parts.length - 1];
-  }
-
-  if (schema.enum) {
-    return schema.enum.map((v: any) => `"${v}"`).join(' | ');
-  }
-
-  return schema.type || 'any';
-}
-
-/**
- * Generate cURL example for an endpoint
- */
-export function generateCurlExample(endpoint: OpenAPIEndpoint, baseUrl: string): string {
-  const url = `${baseUrl}${endpoint.path}`;
-  let curl = `curl -X ${endpoint.method} "${url}"`;
-
-  // Add headers
-  curl += ' \\\n  -H "Content-Type: application/json"';
-
-  // Add request body if present
-  if (endpoint.requestBody?.schema) {
-    const exampleBody = generateExampleFromSchema(endpoint.requestBody.schema);
-    curl += ` \\\n  -d '${JSON.stringify(exampleBody, null, 2)}'`;
-  }
-
-  return curl;
-}
-
-/**
- * Generate TypeScript example for an endpoint
- */
-export function generateTypeScriptExample(endpoint: OpenAPIEndpoint): string {
-  let code = `// ${endpoint.summary || endpoint.path}\n`;
-
-  // Generate type for request body
-  if (endpoint.requestBody?.schema) {
-    code += `interface RequestBody ${formatSchema(endpoint.requestBody.schema)}\n\n`;
-  }
-
-  // Generate type for response
-  const successResponse = endpoint.responses['200'] || endpoint.responses['201'];
-  if (successResponse?.schema) {
-    code += `interface Response ${formatSchema(successResponse.schema)}\n\n`;
-  }
-
-  // Generate fetch example
-  code += `const response = await fetch('${endpoint.path}', {\n`;
-  code += `  method: '${endpoint.method}',\n`;
-  code += `  headers: { 'Content-Type': 'application/json' },\n`;
-
-  if (endpoint.requestBody) {
-    code += `  body: JSON.stringify(requestBody)\n`;
-  }
-
-  code += `});\n\n`;
-  code += `const data = await response.json();`;
-
-  return code;
-}
-
-/**
- * Generate example data from schema
- */
-function generateExampleFromSchema(schema: any): any {
-  if (!schema) {
-    return null;
-  }
-
-  if (schema.example) {
-    return schema.example;
-  }
-
-  if (schema.type === 'string') {
-    return 'string';
-  }
-
-  if (schema.type === 'number' || schema.type === 'integer') {
-    return 0;
-  }
-
-  if (schema.type === 'boolean') {
-    return false;
-  }
-
-  if (schema.type === 'array') {
-    return [generateExampleFromSchema(schema.items)];
-  }
-
-  if (schema.type === 'object' || schema.properties) {
-    const obj: any = {};
-    for (const [key, value] of Object.entries(schema.properties || {})) {
-      obj[key] = generateExampleFromSchema(value);
-    }
-    return obj;
-  }
-
-  return null;
-}
diff --git a/utils/search-index.ts b/utils/search-index.ts
deleted file mode 100644
index 90c63dd..0000000
--- a/utils/search-index.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-/**
- * Search Index Utility for DocsEngine
- *
- * Provides search functionality for documentation pages
- */
-
-import type MiniSearch from 'minisearch';
-
-export interface SearchResult {
-  id: string;
-  title: string;
-  href: string;
-  description?: string;
-  content?: string;
-  score?: number;
-  terms?: string[];
-  match?: Record<string, string[]>;
-}
-
-/**
- * Load the search index
- * Returns a MiniSearch instance with indexed documentation
- */
-export async function loadSearchIndex(_navigation: unknown[]): Promise<MiniSearch<SearchResult>> {
-  // Stub implementation - return null for now
-  // The search feature will be disabled when no index is available
-  return null as any;
-}
-
-/**
- * Perform a search query
- */
-export function performSearch(
-  searchIndex: MiniSearch<SearchResult> | null,
-  query: string
-): SearchResult[] {
-  // Stub implementation - return empty array
-  if (!searchIndex || !query) {
-    return [];
-  }
-  return [];
-}
-
-/**
- * Highlight search term matches in text
- */
-export function highlightMatches(text: string, _terms: string[]): string {
-  // Stub implementation - return text as-is without highlighting
-  return text;
-}