@fresh-editor/fresh-editor 0.1.97 → 0.1.99

package/plugins/pkg.ts

@@ -40,6 +40,7 @@ const CONFIG_DIR = editor.getConfigDir();
 const PACKAGES_DIR = editor.pathJoin(CONFIG_DIR, "plugins", "packages");
 const THEMES_PACKAGES_DIR = editor.pathJoin(CONFIG_DIR, "themes", "packages");
 const LANGUAGES_PACKAGES_DIR = editor.pathJoin(CONFIG_DIR, "languages", "packages");
+const BUNDLES_PACKAGES_DIR = editor.pathJoin(CONFIG_DIR, "bundles", "packages");
 const INDEX_DIR = editor.pathJoin(PACKAGES_DIR, ".index");
 const CACHE_DIR = editor.pathJoin(PACKAGES_DIR, ".cache");
 const LOCKFILE_PATH = editor.pathJoin(CONFIG_DIR, "fresh.lock");
@@ -58,11 +59,60 @@ const DEFAULT_REGISTRY = "https://github.com/sinelaw/fresh-plugins-registry";
 //   - docs/internal/package-index-template/schemas/package.schema.json
 //   - crates/fresh-editor/plugins/schemas/package.schema.json
 
+// Bundle language definition (used in fresh.languages[])
+interface BundleLanguage {
+  /** Language identifier (e.g., 'elixir', 'heex') */
+  id: string;
+  /** Grammar configuration */
+  grammar?: {
+    file: string;
+    extensions?: string[];
+    firstLine?: string;
+  };
+  /** Language configuration */
+  language?: {
+    commentPrefix?: string;
+    blockCommentStart?: string;
+    blockCommentEnd?: string;
+    useTabs?: boolean;
+    tabSize?: number;
+    autoIndent?: boolean;
+    showWhitespaceTabs?: boolean;
+    formatter?: {
+      command: string;
+      args?: string[];
+    };
+  };
+  /** LSP server configuration */
+  lsp?: {
+    command: string;
+    args?: string[];
+    autoStart?: boolean;
+    initializationOptions?: Record<string, unknown>;
+  };
+}
+
+// Bundle plugin definition (used in fresh.plugins[])
+interface BundlePlugin {
+  /** Plugin entry point file relative to package */
+  entry: string;
+}
+
+// Bundle theme definition (used in fresh.themes[])
+interface BundleTheme {
+  /** Theme JSON file path relative to package */
+  file: string;
+  /** Display name for the theme */
+  name: string;
+  /** Theme variant (dark or light) */
+  variant?: "dark" | "light";
+}
+
 interface PackageManifest {
   name: string;
   version: string;
   description: string;
-  type: "plugin" | "theme" | "theme-pack" | "language";
+  type: "plugin" | "theme" | "theme-pack" | "language" | "bundle";
   author?: string;
   license?: string;
   repository?: string;
@@ -104,6 +154,12 @@ interface PackageManifest {
       autoStart?: boolean;
       initializationOptions?: Record<string, unknown>;
     };
+
+    // Bundle fields
+    /** Languages included in this bundle */
+    languages?: BundleLanguage[];
+    /** Plugins included in this bundle */
+    plugins?: BundlePlugin[];
   };
   keywords?: string[];
 }
@@ -130,7 +186,7 @@ interface RegistryData {
 interface InstalledPackage {
   name: string;
   path: string;
-  type: "plugin" | "theme" | "language";
+  type: "plugin" | "theme" | "language" | "bundle";
   source: string;
   version: string;
   commit?: string;
@@ -155,12 +211,14 @@ interface Lockfile {
 // =============================================================================
 
 interface ParsedPackageUrl {
-  /** The base git repository URL (without fragment) */
+  /** The base git repository URL or local path (without fragment) */
   repoUrl: string;
-  /** Optional path within the repository (from fragment) */
+  /** Optional path within the repository/directory (from fragment) */
   subpath: string | null;
   /** Extracted package name */
   name: string;
+  /** Whether this is a local file path (not a remote URL) */
+  isLocal: boolean;
 }
 
 // =============================================================================
@@ -206,6 +264,29 @@ async function gitCommand(args: string[]): Promise<{ exit_code: number; stdout:
   return result;
 }
 
+/**
+ * Check if a string is a local file path (not a URL).
+ */
+function isLocalPath(str: string): boolean {
+  // Absolute paths start with /
+  if (str.startsWith("/")) return true;
+  // Windows absolute paths (C:\, D:\, etc.)
+  if (/^[A-Za-z]:[\\\/]/.test(str)) return true;
+  // Relative paths starting with . or ..
+  if (str.startsWith("./") || str.startsWith("../")) return true;
+  // Home directory expansion
+  if (str.startsWith("~/")) return true;
+  // Not a URL scheme (http://, https://, git://, ssh://, file://)
+  if (!/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(str)) {
+    // If it doesn't look like a URL and doesn't contain @, it's probably a path
+    // (git@github.com:user/repo is a git URL)
+    if (!str.includes("@") || str.startsWith("/")) {
+      return true;
+    }
+  }
+  return false;
+}
+
 /**
  * Parse a package URL that may contain a subpath fragment.
  *
@@ -213,6 +294,8 @@ async function gitCommand(args: string[]): Promise<{ exit_code: number; stdout:
  * - `https://github.com/user/repo` - standard repo
  * - `https://github.com/user/repo#path/to/plugin` - monorepo with subpath
  * - `https://github.com/user/repo.git#packages/my-plugin` - with .git suffix
+ * - `/path/to/local/repo#subdir` - local path with subpath
+ * - `/path/to/local/package` - direct local package path
  *
  * The fragment (after #) specifies a subdirectory within the repo.
  */
@@ -234,19 +317,22 @@ function parsePackageUrl(url: string): ParsedPackageUrl {
     repoUrl = url;
   }
 
+  // Determine if this is a local path
+  const isLocal = isLocalPath(repoUrl);
+
   // Extract package name
   let name: string;
   if (subpath) {
-    // For monorepo, use the last component of the subpath
+    // For monorepo/directory, use the last component of the subpath
     const parts = subpath.split("/");
     name = parts[parts.length - 1].replace(/^fresh-/, "");
   } else {
-    // For regular repo, use repo name
+    // For regular repo/path, use the last component
     const match = repoUrl.match(/\/([^\/]+?)(\.git)?$/);
     name = match ? match[1].replace(/^fresh-/, "") : "unknown";
   }
 
-  return { repoUrl, subpath, name };
+  return { repoUrl, subpath, name, isLocal };
 }
 
 /**
@@ -446,9 +532,10 @@ function isRegistrySynced(): boolean {
 /**
  * Get list of installed packages
  */
-function getInstalledPackages(type: "plugin" | "theme" | "language"): InstalledPackage[] {
+function getInstalledPackages(type: "plugin" | "theme" | "language" | "bundle"): InstalledPackage[] {
   const packagesDir = type === "plugin" ? PACKAGES_DIR
                     : type === "theme" ? THEMES_PACKAGES_DIR
+                    : type === "bundle" ? BUNDLES_PACKAGES_DIR
                     : LANGUAGES_PACKAGES_DIR;
   const packages: InstalledPackage[] = [];
 
@@ -543,14 +630,14 @@ function validatePackage(packageDir: string, packageName: string): ValidationRes
   if (!manifest.type) {
     return {
       valid: false,
-      error: "Invalid package.json - missing 'type' field (should be 'plugin', 'theme', or 'language')"
+      error: "Invalid package.json - missing 'type' field (should be 'plugin', 'theme', 'language', or 'bundle')"
     };
   }
 
-  if (manifest.type !== "plugin" && manifest.type !== "theme" && manifest.type !== "language") {
+  if (manifest.type !== "plugin" && manifest.type !== "theme" && manifest.type !== "language" && manifest.type !== "bundle") {
     return {
       valid: false,
-      error: `Invalid package.json - 'type' must be 'plugin', 'theme', or 'language', got '${manifest.type}'`
+      error: `Invalid package.json - 'type' must be 'plugin', 'theme', 'language', or 'bundle', got '${manifest.type}'`
     };
   }
 
@@ -598,64 +685,122 @@ function validatePackage(packageDir: string, packageName: string): ValidationRes
     return { valid: true, manifest };
   }
 
+  // For bundles, validate at least one language, plugin, or theme is defined
+  if (manifest.type === "bundle") {
+    const hasLanguages = manifest.fresh?.languages && manifest.fresh.languages.length > 0;
+    const hasPlugins = manifest.fresh?.plugins && manifest.fresh.plugins.length > 0;
+    const hasThemes = manifest.fresh?.themes && manifest.fresh.themes.length > 0;
+
+    if (!hasLanguages && !hasPlugins && !hasThemes) {
+      return {
+        valid: false,
+        error: "Bundle package must define at least one language, plugin, or theme"
+      };
+    }
+
+    // Validate each language entry
+    if (manifest.fresh?.languages) {
+      for (const lang of manifest.fresh.languages) {
+        if (!lang.id) {
+          return {
+            valid: false,
+            error: "Bundle language entry missing required 'id' field"
+          };
+        }
+        // Validate grammar file exists if specified
+        if (lang.grammar?.file) {
+          const grammarPath = editor.pathJoin(packageDir, lang.grammar.file);
+          if (!editor.fileExists(grammarPath)) {
+            return {
+              valid: false,
+              error: `Grammar file not found for language '${lang.id}': ${lang.grammar.file}`
+            };
+          }
+        }
+      }
+    }
+
+    // Validate each plugin entry
+    if (manifest.fresh?.plugins) {
+      for (const plugin of manifest.fresh.plugins) {
+        if (!plugin.entry) {
+          return {
+            valid: false,
+            error: "Bundle plugin entry missing required 'entry' field"
+          };
+        }
+        const entryPath = editor.pathJoin(packageDir, plugin.entry);
+        if (!editor.fileExists(entryPath)) {
+          // Try .js as fallback
+          const jsEntryPath = entryPath.replace(/\.ts$/, ".js");
+          if (!editor.fileExists(jsEntryPath)) {
+            return {
+              valid: false,
+              error: `Plugin entry file not found: ${plugin.entry}`
+            };
+          }
+        }
+      }
+    }
+
+    return { valid: true, manifest };
+  }
+
   // Themes don't need entry file validation
   return { valid: true, manifest };
 }
 
 /**
- * Install a package from git URL.
+ * Install a package from git URL or local path.
  *
- * Supports monorepo URLs with subpath fragments:
- * - `https://github.com/user/repo#packages/my-plugin`
+ * Supports:
+ * - `https://github.com/user/repo` - standard git repo
+ * - `https://github.com/user/repo#packages/my-plugin` - monorepo with subpath
+ * - `/path/to/local/repo#subdir` - local path with subpath
+ * - `/path/to/local/package` - direct local package path
  *
- * For subpath packages, clones to temp directory and copies the subdirectory.
+ * For subpath packages, clones/copies to temp directory and copies the subdirectory.
  */
 async function installPackage(
   url: string,
   name?: string,
-  type: "plugin" | "theme" | "language" = "plugin",
+  _type?: "plugin" | "theme" | "language" | "bundle",  // Ignored - type is auto-detected from manifest
   version?: string
 ): Promise<boolean> {
   const parsed = parsePackageUrl(url);
   const packageName = name || parsed.name;
-  const packagesDir = type === "plugin" ? PACKAGES_DIR
-                    : type === "theme" ? THEMES_PACKAGES_DIR
-                    : LANGUAGES_PACKAGES_DIR;
-  const targetDir = editor.pathJoin(packagesDir, packageName);
-
-  if (editor.fileExists(targetDir)) {
-    editor.setStatus(`Package '${packageName}' is already installed`);
-    return false;
-  }
-
-  await ensureDir(packagesDir);
 
   editor.setStatus(`Installing ${packageName}...`);
 
-  if (parsed.subpath) {
-    // Monorepo installation: clone to temp, copy subdirectory
-    return await installFromMonorepo(parsed, packageName, targetDir, version);
+  if (parsed.isLocal) {
+    // Local path installation: copy directly
+    return await installFromLocalPath(parsed, packageName);
+  } else if (parsed.subpath) {
+    // Remote monorepo installation: clone to temp, copy subdirectory
+    return await installFromMonorepo(parsed, packageName, version);
   } else {
-    // Standard installation: clone directly
-    return await installFromRepo(parsed.repoUrl, packageName, targetDir, version);
+    // Standard git installation: clone directly
+    return await installFromRepo(parsed.repoUrl, packageName, version);
   }
 }
 
 /**
  * Install from a standard git repository (no subpath)
+ * Clones to temp first to detect type, then moves to correct location.
  */
 async function installFromRepo(
   repoUrl: string,
   packageName: string,
-  targetDir: string,
   version?: string
 ): Promise<boolean> {
-  // Clone the repository
+  // Clone to temp directory first to detect package type
+  const tempDir = `/tmp/fresh-pkg-clone-${hashString(repoUrl)}-${Date.now()}`;
+
   const cloneArgs = ["clone"];
   if (!version || version === "latest") {
     cloneArgs.push("--depth", "1");
   }
-  cloneArgs.push(`${repoUrl}`, `${targetDir}`);
+  cloneArgs.push(`${repoUrl}`, `${tempDir}`);
 
   const result = await gitCommand(cloneArgs);
 
@@ -671,53 +816,196 @@ async function installFromRepo(
 
   // Checkout specific version if requested
   if (version && version !== "latest") {
-    const checkoutResult = await checkoutVersion(targetDir, version);
+    const checkoutResult = await checkoutVersion(tempDir, version);
     if (!checkoutResult) {
       editor.setStatus(`Installed ${packageName} but failed to checkout version ${version}`);
     }
   }
 
   // Validate package structure
-  const validation = validatePackage(targetDir, packageName);
+  const validation = validatePackage(tempDir, packageName);
   if (!validation.valid) {
     editor.warn(`[pkg] Invalid package '${packageName}': ${validation.error}`);
     editor.setStatus(`Failed to install ${packageName}: ${validation.error}`);
-    // Clean up the invalid package
-    await editor.spawnProcess("rm", ["-rf", targetDir]);
+    // Clean up
+    await editor.spawnProcess("rm", ["-rf", tempDir]);
     return false;
   }
 
   const manifest = validation.manifest;
 
-  // Dynamically load plugins, reload themes, or load language packs
+  // Use manifest name as the authoritative package name
+  if (manifest?.name) packageName = manifest.name;
+
+  // Determine correct target directory based on actual package type
+  const actualType = manifest?.type || "plugin";
+  const correctPackagesDir = actualType === "plugin" ? PACKAGES_DIR
+                           : actualType === "theme" ? THEMES_PACKAGES_DIR
+                           : actualType === "bundle" ? BUNDLES_PACKAGES_DIR
+                           : LANGUAGES_PACKAGES_DIR;
+  const correctTargetDir = editor.pathJoin(correctPackagesDir, packageName);
+
+  // Check if already installed in correct location
+  if (editor.fileExists(correctTargetDir)) {
+    editor.setStatus(`Package '${packageName}' is already installed`);
+    await editor.spawnProcess("rm", ["-rf", tempDir]);
+    return false;
+  }
+
+  // Ensure correct directory exists and move from temp
+  await ensureDir(correctPackagesDir);
+  const moveResult = await editor.spawnProcess("mv", [tempDir, correctTargetDir]);
+  if (moveResult.exit_code !== 0) {
+    editor.setStatus(`Failed to install ${packageName}: ${moveResult.stderr}`);
+    await editor.spawnProcess("rm", ["-rf", tempDir]);
+    return false;
+  }
+
+  // Dynamically load plugins, reload themes, load language packs, or load bundles
   if (manifest?.type === "plugin" && validation.entryPath) {
-    await editor.loadPlugin(validation.entryPath);
+    // Update entry path to new location
+    const newEntryPath = validation.entryPath.replace(tempDir, correctTargetDir);
+    await editor.loadPlugin(newEntryPath);
     editor.setStatus(`Installed and activated ${packageName}${manifest ? ` v${manifest.version}` : ""}`);
   } else if (manifest?.type === "theme") {
     editor.reloadThemes();
     editor.setStatus(`Installed theme ${packageName}${manifest ? ` v${manifest.version}` : ""}`);
   } else if (manifest?.type === "language") {
-    await loadLanguagePack(targetDir, manifest);
+    await loadLanguagePack(correctTargetDir, manifest);
     editor.setStatus(`Installed language pack ${packageName}${manifest ? ` v${manifest.version}` : ""}`);
+  } else if (manifest?.type === "bundle") {
+    await loadBundle(correctTargetDir, manifest);
+    editor.setStatus(`Installed bundle ${packageName}${manifest ? ` v${manifest.version}` : ""}`);
   } else {
     editor.setStatus(`Installed ${packageName}${manifest ? ` v${manifest.version}` : ""}`);
   }
   return true;
 }
 
+/**
+ * Install from a local file path.
+ *
+ * Strategy:
+ * - If subpath is specified: copy that subdirectory
+ * - Otherwise: copy the entire directory
+ * - Store the source path for reference
+ * - Auto-detect package type from manifest and install to correct directory
+ */
+async function installFromLocalPath(
+  parsed: ParsedPackageUrl,
+  packageName: string
+): Promise<boolean> {
+  // Resolve the full source path
+  let sourcePath = parsed.repoUrl;
+
+  // Handle home directory expansion
+  if (sourcePath.startsWith("~/")) {
+    const home = editor.getEnv("HOME") || editor.getEnv("USERPROFILE") || "";
+    sourcePath = editor.pathJoin(home, sourcePath.slice(2));
+  }
+
+  // If there's a subpath, append it
+  if (parsed.subpath) {
+    sourcePath = editor.pathJoin(sourcePath, parsed.subpath);
+  }
+
+  // Check if source exists
+  if (!editor.fileExists(sourcePath)) {
+    editor.setStatus(`Local path not found: ${sourcePath}`);
+    return false;
+  }
+
+  // Check if it's a directory (by checking for package.json)
+  const manifestPath = editor.pathJoin(sourcePath, "package.json");
+  if (!editor.fileExists(manifestPath)) {
+    editor.setStatus(`Not a valid package (no package.json): ${sourcePath}`);
+    return false;
+  }
+
+  // Read manifest FIRST to determine actual package type and name
+  const manifest = readJsonFile<PackageManifest>(manifestPath);
+  if (!manifest) {
+    editor.setStatus(`Invalid package.json in ${sourcePath}`);
+    return false;
+  }
+
+  // Use manifest name as the authoritative package name
+  packageName = manifest.name;
+
+  // Determine correct target directory based on actual package type
+  const actualType = manifest.type || "plugin";
+  const correctPackagesDir = actualType === "plugin" ? PACKAGES_DIR
+                           : actualType === "theme" ? THEMES_PACKAGES_DIR
+                           : actualType === "bundle" ? BUNDLES_PACKAGES_DIR
+                           : LANGUAGES_PACKAGES_DIR;
+  const correctTargetDir = editor.pathJoin(correctPackagesDir, packageName);
+
+  // Check if already installed in correct location
+  if (editor.fileExists(correctTargetDir)) {
+    editor.setStatus(`Package '${packageName}' is already installed`);
+    return false;
+  }
+
+  // Ensure correct directory exists
+  await ensureDir(correctPackagesDir);
+
+  // Copy the directory to correct target
+  editor.setStatus(`Copying from ${sourcePath}...`);
+  const copyResult = await editor.spawnProcess("cp", ["-r", sourcePath, correctTargetDir]);
+  if (copyResult.exit_code !== 0) {
+    editor.setStatus(`Failed to copy package: ${copyResult.stderr}`);
+    return false;
+  }
+
+  // Validate package structure
+  const validation = validatePackage(correctTargetDir, packageName);
+  if (!validation.valid) {
+    editor.warn(`[pkg] Invalid package '${packageName}': ${validation.error}`);
+    editor.setStatus(`Failed to install ${packageName}: ${validation.error}`);
+    // Clean up the invalid package
+    await editor.spawnProcess("rm", ["-rf", correctTargetDir]);
+    return false;
+  }
+
+  // Store the source path for reference
+  const sourceInfo = {
+    local_path: sourcePath,
+    original_url: parsed.subpath ? `${parsed.repoUrl}#${parsed.subpath}` : parsed.repoUrl,
+    installed_at: new Date().toISOString()
+  };
+  await writeJsonFile(editor.pathJoin(correctTargetDir, ".fresh-source.json"), sourceInfo);
+
+  // Dynamically load plugins, reload themes, load language packs, or load bundles
+  if (manifest.type === "plugin" && validation.entryPath) {
+    await editor.loadPlugin(validation.entryPath);
+    editor.setStatus(`Installed and activated ${packageName} v${manifest.version || "unknown"}`);
+  } else if (manifest.type === "theme") {
+    editor.reloadThemes();
+    editor.setStatus(`Installed theme ${packageName} v${manifest.version || "unknown"}`);
+  } else if (manifest.type === "language") {
+    await loadLanguagePack(correctTargetDir, manifest);
+    editor.setStatus(`Installed language pack ${packageName} v${manifest.version || "unknown"}`);
+  } else if (manifest.type === "bundle") {
+    await loadBundle(correctTargetDir, manifest);
+    editor.setStatus(`Installed bundle ${packageName} v${manifest.version || "unknown"}`);
+  } else {
+    editor.setStatus(`Installed ${packageName} v${manifest.version || "unknown"}`);
+  }
+  return true;
+}
+
 /**
  * Install from a monorepo (URL with subpath fragment)
  *
  * Strategy:
  * 1. Clone the repo to a temp directory
- * 2. Copy the subdirectory to the target location
- * 3. Initialize a new git repo in the target (for updates)
+ * 2. Detect package type from manifest
+ * 3. Copy the subdirectory to the correct target location
  * 4. Store the original URL for reference
  */
 async function installFromMonorepo(
   parsed: ParsedPackageUrl,
   packageName: string,
-  targetDir: string,
   version?: string
 ): Promise<boolean> {
   const tempDir = `/tmp/fresh-pkg-${hashString(parsed.repoUrl)}-${Date.now()}`;
@@ -755,26 +1043,47 @@ async function installFromMonorepo(
       return false;
     }
 
-    // Copy subdirectory to target
-    editor.setStatus(`Installing ${packageName} from ${parsed.subpath}...`);
-    const copyResult = await editor.spawnProcess("cp", ["-r", subpathDir, targetDir]);
-    if (copyResult.exit_code !== 0) {
-      editor.setStatus(`Failed to copy package: ${copyResult.stderr}`);
+    // Validate package structure (validates against subpath dir)
+    const validation = validatePackage(subpathDir, packageName);
+    if (!validation.valid) {
+      editor.warn(`[pkg] Invalid package '${packageName}': ${validation.error}`);
+      editor.setStatus(`Failed to install ${packageName}: ${validation.error}`);
       await editor.spawnProcess("rm", ["-rf", tempDir]);
       return false;
     }
 
-    // Validate package structure
-    const validation = validatePackage(targetDir, packageName);
-    if (!validation.valid) {
-      editor.warn(`[pkg] Invalid package '${packageName}': ${validation.error}`);
-      editor.setStatus(`Failed to install ${packageName}: ${validation.error}`);
-      // Clean up the invalid package
-      await editor.spawnProcess("rm", ["-rf", targetDir]);
+    const manifest = validation.manifest;
+
+    // Use manifest name as the authoritative package name
+    if (manifest?.name) packageName = manifest.name;
+
+    // Determine correct target directory based on actual package type
+    const actualType = manifest?.type || "plugin";
+    const correctPackagesDir = actualType === "plugin" ? PACKAGES_DIR
+                             : actualType === "theme" ? THEMES_PACKAGES_DIR
+                             : actualType === "bundle" ? BUNDLES_PACKAGES_DIR
+                             : LANGUAGES_PACKAGES_DIR;
+    const correctTargetDir = editor.pathJoin(correctPackagesDir, packageName);
+
+    // Check if already installed
+    if (editor.fileExists(correctTargetDir)) {
+      editor.setStatus(`Package '${packageName}' is already installed`);
+      await editor.spawnProcess("rm", ["-rf", tempDir]);
+      return false;
+    }
+
+    // Ensure correct directory exists
+    await ensureDir(correctPackagesDir);
+
+    // Copy subdirectory to correct target
+    editor.setStatus(`Installing ${packageName} from ${parsed.subpath}...`);
+    const copyResult = await editor.spawnProcess("cp", ["-r", subpathDir, correctTargetDir]);
+    if (copyResult.exit_code !== 0) {
+      editor.setStatus(`Failed to copy package: ${copyResult.stderr}`);
+      await editor.spawnProcess("rm", ["-rf", tempDir]);
       return false;
     }
 
-    // Initialize git in target for future updates
     // Store the original monorepo URL in a .fresh-source file
     const sourceInfo = {
       repository: parsed.repoUrl,
@@ -782,20 +1091,23 @@ async function installFromMonorepo(
       installed_from: `${parsed.repoUrl}#${parsed.subpath}`,
       installed_at: new Date().toISOString()
     };
-    await writeJsonFile(editor.pathJoin(targetDir, ".fresh-source.json"), sourceInfo);
-
-    const manifest = validation.manifest;
+    await writeJsonFile(editor.pathJoin(correctTargetDir, ".fresh-source.json"), sourceInfo);
 
-    // Dynamically load plugins, reload themes, or load language packs
+    // Dynamically load plugins, reload themes, load language packs, or load bundles
     if (manifest?.type === "plugin" && validation.entryPath) {
-      await editor.loadPlugin(validation.entryPath);
+      // Update entry path to new location
+      const newEntryPath = validation.entryPath.replace(subpathDir, correctTargetDir);
+      await editor.loadPlugin(newEntryPath);
       editor.setStatus(`Installed and activated ${packageName}${manifest ? ` v${manifest.version}` : ""}`);
     } else if (manifest?.type === "theme") {
       editor.reloadThemes();
       editor.setStatus(`Installed theme ${packageName}${manifest ? ` v${manifest.version}` : ""}`);
     } else if (manifest?.type === "language") {
-      await loadLanguagePack(targetDir, manifest);
+      await loadLanguagePack(correctTargetDir, manifest);
       editor.setStatus(`Installed language pack ${packageName}${manifest ? ` v${manifest.version}` : ""}`);
+    } else if (manifest?.type === "bundle") {
+      await loadBundle(correctTargetDir, manifest);
+      editor.setStatus(`Installed bundle ${packageName}${manifest ? ` v${manifest.version}` : ""}`);
     } else {
       editor.setStatus(`Installed ${packageName}${manifest ? ` v${manifest.version}` : ""}`);
     }
@@ -852,6 +1164,90 @@ async function loadLanguagePack(packageDir: string, manifest: PackageManifest):
   editor.reloadGrammars();
 }
 
+/**
+ * Load a bundle package (register all languages and load all plugins)
+ */
+async function loadBundle(packageDir: string, manifest: PackageManifest): Promise<void> {
+  const bundleName = manifest.name;
+  editor.debug(`[pkg] Loading bundle: ${bundleName}`);
+
+  // Load all languages from the bundle
+  if (manifest.fresh?.languages) {
+    for (const lang of manifest.fresh.languages) {
+      const langId = lang.id;
+      editor.debug(`[pkg] Loading bundle language: ${langId}`);
+
+      // Register grammar if present
+      if (lang.grammar) {
+        const grammarPath = editor.pathJoin(packageDir, lang.grammar.file);
+        const extensions = lang.grammar.extensions || [];
+        editor.registerGrammar(langId, grammarPath, extensions);
+      }
+
+      // Register language config if present
+      if (lang.language) {
+        const langConfig = lang.language;
+        editor.registerLanguageConfig(langId, {
+          commentPrefix: langConfig.commentPrefix ?? null,
+          blockCommentStart: langConfig.blockCommentStart ?? null,
+          blockCommentEnd: langConfig.blockCommentEnd ?? null,
+          useTabs: langConfig.useTabs ?? null,
+          tabSize: langConfig.tabSize ?? null,
+          autoIndent: langConfig.autoIndent ?? null,
+          showWhitespaceTabs: langConfig.showWhitespaceTabs ?? null,
+          formatter: langConfig.formatter ? {
+            command: langConfig.formatter.command,
+            args: langConfig.formatter.args ?? [],
+          } : null,
+        });
+      }
+
+      // Register LSP server if present
+      if (lang.lsp) {
+        const lsp = lang.lsp;
+        editor.registerLspServer(langId, {
+          command: lsp.command,
+          args: lsp.args ?? [],
+          autoStart: lsp.autoStart ?? null,
+          initializationOptions: lsp.initializationOptions ?? null,
+        });
+      }
+    }
+  }
+
+  // Load all plugins from the bundle
+  if (manifest.fresh?.plugins) {
+    for (const plugin of manifest.fresh.plugins) {
+      let entryPath = editor.pathJoin(packageDir, plugin.entry);
+
+      // Try .js fallback if .ts doesn't exist
+      if (!editor.fileExists(entryPath) && entryPath.endsWith(".ts")) {
+        const jsPath = entryPath.replace(/\.ts$/, ".js");
+        if (editor.fileExists(jsPath)) {
+          entryPath = jsPath;
+        }
+      }
+
+      if (editor.fileExists(entryPath)) {
+        editor.debug(`[pkg] Loading bundle plugin: ${plugin.entry}`);
+        await editor.loadPlugin(entryPath);
+      } else {
+        editor.warn(`[pkg] Bundle plugin not found: ${plugin.entry}`);
+      }
+    }
+  }
+
+  // Reload themes if bundle contains any (uses same format as theme-packs)
+  if (manifest.fresh?.themes && manifest.fresh.themes.length > 0) {
+    editor.debug(`[pkg] Bundle contains ${manifest.fresh.themes.length} theme(s), reloading themes`);
+    editor.reloadThemes();
+  }
+
+  // Apply grammar changes
+  editor.reloadGrammars();
+  editor.debug(`[pkg] Bundle loaded: ${bundleName}`);
+}
+
 /**
  * Checkout a specific version in a package directory
  */
@@ -1126,7 +1522,7 @@ interface PackageListItem {
   stars?: number;
   downloads?: number;
   keywords?: string[];
-  packageType: "plugin" | "theme" | "language";
+  packageType: "plugin" | "theme" | "language" | "bundle";
   // For installed packages
   installedPackage?: InstalledPackage;
   // For available packages
@@ -1135,7 +1531,7 @@ interface PackageListItem {
 
 // Focus target types for Tab navigation
 type FocusTarget =
-  | { type: "filter"; index: number }  // 0=All, 1=Installed, 2=Plugins, 3=Themes, 4=Languages
+  | { type: "filter"; index: number }  // 0=All, 1=Installed, 2=Plugins, 3=Themes, 4=Languages, 5=Bundles
   | { type: "sync" }
   | { type: "search" }
   | { type: "list" }  // Package list (use arrows to navigate)
@@ -1146,7 +1542,7 @@ interface PkgManagerState {
   bufferId: number | null;
   splitId: number | null;
   sourceBufferId: number | null;
-  filter: "all" | "installed" | "plugins" | "themes" | "languages";
+  filter: "all" | "installed" | "plugins" | "themes" | "languages" | "bundles";
   searchQuery: string;
   items: PackageListItem[];
   selectedIndex: number;
@@ -1277,9 +1673,10 @@ function buildPackageList(): PackageListItem[] {
   const installedPlugins = getInstalledPackages("plugin");
   const installedThemes = getInstalledPackages("theme");
   const installedLanguages = getInstalledPackages("language");
+  const installedBundles = getInstalledPackages("bundle");
   const installedMap = new Map<string, InstalledPackage>();
 
-  for (const pkg of [...installedPlugins, ...installedThemes, ...installedLanguages]) {
+  for (const pkg of [...installedPlugins, ...installedThemes, ...installedLanguages, ...installedBundles]) {
     installedMap.set(pkg.name, pkg);
     items.push({
       type: "installed",
@@ -1393,6 +1790,9 @@ function getFilteredItems(): PackageListItem[] {
     case "languages":
       items = items.filter(i => i.packageType === "language");
       break;
+    case "bundles":
+      items = items.filter(i => i.packageType === "bundle");
+      break;
   }
 
   // Apply search (case insensitive)
@@ -1519,6 +1919,7 @@ function buildListViewEntries(): TextPropertyEntry[] {
     { id: "plugins", label: "Plugins" },
     { id: "themes", label: "Themes" },
     { id: "languages", label: "Languages" },
+    { id: "bundles", label: "Bundles" },
   ];
 
   // Build filter buttons with position tracking
@@ -1600,7 +2001,7 @@ function buildListViewEntries(): TextPropertyEntry[] {
       const isSelected = idx === pkgState.selectedIndex;
       const listFocused = pkgState.focus.type === "list";
       const prefix = isSelected && listFocused ? "▸" : " ";
-      const typeTag = item.packageType === "theme" ? "T" : item.packageType === "language" ? "L" : "P";
+      const typeTag = item.packageType === "theme" ? "T" : item.packageType === "language" ? "L" : item.packageType === "bundle" ? "B" : "P";
       const name = item.name.length > 22 ? item.name.slice(0, 21) + "…" : item.name;
       const line = `${prefix} ${name.padEnd(22)} [${typeTag}]`;
       leftLines.push({ text: line, type: "package-row", selected: isSelected, installed: false });
@@ -2006,6 +2407,7 @@ function getFocusOrder(): FocusTarget[] {
     { type: "filter", index: 2 },  // Plugins
     { type: "filter", index: 3 },  // Themes
     { type: "filter", index: 4 },  // Languages
+    { type: "filter", index: 5 },  // Bundles
     { type: "sync" },
     { type: "list" },
   ];
@@ -2089,7 +2491,7 @@ globalThis.pkg_activate = async function(): Promise<void> {
 
   // Handle filter button activation
   if (focus.type === "filter") {
-    const filters = ["all", "installed", "plugins", "themes", "languages"] as const;
+    const filters = ["all", "installed", "plugins", "themes", "languages", "bundles"] as const;
     pkgState.filter = filters[focus.index];
     pkgState.selectedIndex = 0;
     pkgState.items = buildPackageList();
@@ -2497,10 +2899,11 @@ editor.registerCommand("%cmd.install_url", "%cmd.install_url_desc", "pkg_install
 // are available via the package manager UI and don't need global command palette entries.
 
 // =============================================================================
-// Startup: Load installed language packs
+// Startup: Load installed language packs and bundles
 // =============================================================================
 
-(async function loadInstalledLanguagePacks() {
+(async function loadInstalledPackages() {
+  // Load language packs
   const languages = getInstalledPackages("language");
   for (const pkg of languages) {
     if (pkg.manifest) {
@@ -2511,6 +2914,18 @@ editor.registerCommand("%cmd.install_url", "%cmd.install_url_desc", "pkg_install
   if (languages.length > 0) {
     editor.debug(`[pkg] Loaded ${languages.length} language pack(s)`);
   }
+
+  // Load bundles
+  const bundles = getInstalledPackages("bundle");
+  for (const pkg of bundles) {
+    if (pkg.manifest) {
+      editor.debug(`[pkg] Loading bundle: ${pkg.name}`);
+      await loadBundle(pkg.path, pkg.manifest);
+    }
+  }
+  if (bundles.length > 0) {
+    editor.debug(`[pkg] Loaded ${bundles.length} bundle(s)`);
+  }
 })();
 
 editor.debug("Package Manager plugin loaded");