Refactor cache to support multiple cache types

- Rename default_cache_dir() to base_cache_dir() (no subdirectory)
- Add https_cache_dir() for HTTPS fetched content
- Cache structure: base_cache_dir()/https/ for remote files
- Future cache types can use base_cache_dir()/compile/, etc.
- CLI `cache path` now shows base directory

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: ryo33

crates/eure-cli/src/commands/cache.rs

@@ -4,8 +4,8 @@ use std::path::PathBuf;
 
 use clap::Subcommand;
 use eure_env::cache::{
-    self, CacheOptions, CacheStorage, FsStorage, GcOptions, clean, clean_with_dir,
-    default_cache_dir, gc, gc_with_dir, parse_duration, parse_size,
+    self, CacheOptions, CacheStorage, FsStorage, GcOptions, base_cache_dir, clean, clean_with_dir,
+    gc, gc_with_dir, https_cache_dir, parse_duration, parse_size,
 };
 use url::Url;
 
@@ -75,7 +75,7 @@ pub fn run(args: Args) {
 }
 
 fn run_list(cache_dir: Option<PathBuf>) {
-    let dir = cache_dir.unwrap_or_else(default_cache_dir);
+    let dir = cache_dir.unwrap_or_else(https_cache_dir);
     let storage = FsStorage::new(dir);
 
     match storage.list() {
@@ -164,7 +164,7 @@ fn run_clean(cache_dir: Option<PathBuf>) {
 }
 
 fn run_path() {
-    println!("{}", default_cache_dir().display());
+    println!("{}", base_cache_dir().display());
 }
 
 fn run_fetch(url_str: String, refresh: bool, cache_dir: Option<PathBuf>) {

crates/eure-env/src/cache/fetch.rs

@@ -55,26 +55,39 @@ pub struct FetchResult {
     pub cache_path: Option<std::path::PathBuf>,
 }
 
-/// Get the default cache directory.
-pub fn default_cache_dir() -> std::path::PathBuf {
+/// Get the base cache directory for all eure caches.
+///
+/// Platform-specific paths (via `directories` crate):
+/// - macOS: `~/Library/Caches/dev.eure.eure/`
+/// - Linux: `~/.cache/eure/`
+/// - Windows: `C:\Users\<User>\AppData\Local\eure\eure\cache\`
+///
+/// Override with `$EURE_CACHE_DIR` environment variable.
+pub fn base_cache_dir() -> std::path::PathBuf {
     std::env::var("EURE_CACHE_DIR")
         .map(std::path::PathBuf::from)
         .unwrap_or_else(|_| {
             directories::ProjectDirs::from("dev", "eure", "eure")
                 .map(|p| p.cache_dir().to_path_buf())
                 .unwrap_or_else(|| std::path::PathBuf::from(".cache/eure"))
-                .join("schemas")
         })
 }
 
+/// Get the cache directory for HTTPS fetched content.
+///
+/// Returns `base_cache_dir()/https/`.
+pub fn https_cache_dir() -> std::path::PathBuf {
+    base_cache_dir().join("https")
+}
+
 /// Fetch a URL with caching.
 pub fn fetch(url: &Url, opts: &CacheOptions) -> Result<FetchResult, CacheError> {
     // Check HTTPS requirement
     if url.scheme() == "http" && !opts.allow_http {
         return Err(CacheError::HttpsRequired(url.to_string()));
     }
 
-    let cache_dir = opts.cache_dir.clone().unwrap_or_else(default_cache_dir);
+    let cache_dir = opts.cache_dir.clone().unwrap_or_else(https_cache_dir);
     let storage = FsStorage::new(cache_dir);
 
     // Check cache first (unless refresh is set)

crates/eure-env/src/cache/gc.rs

@@ -3,14 +3,14 @@
 use std::time::Duration;
 
 use super::error::CacheError;
-use super::fetch::default_cache_dir;
+use super::fetch::https_cache_dir;
 use super::storage::{CacheStorage, FsStorage, GcOptions, GcStats};
 
-/// Run garbage collection on the cache.
+/// Run garbage collection on the HTTPS cache.
 ///
 /// This removes old entries based on the provided options.
 pub fn gc(opts: &GcOptions) -> Result<GcStats, CacheError> {
-    let cache_dir = default_cache_dir();
+    let cache_dir = https_cache_dir();
     let storage = FsStorage::new(cache_dir);
     storage.gc(opts)
 }
@@ -21,9 +21,9 @@ pub fn gc_with_dir(cache_dir: &std::path::Path, opts: &GcOptions) -> Result<GcSt
     storage.gc(opts)
 }
 
-/// Remove all cached entries.
+/// Remove all cached entries from the HTTPS cache.
 pub fn clean() -> Result<(), CacheError> {
-    let cache_dir = default_cache_dir();
+    let cache_dir = https_cache_dir();
     let storage = FsStorage::new(cache_dir);
     storage.clean()
 }

crates/eure-env/src/cache/mod.rs

@@ -1,6 +1,6 @@
-//! Remote schema caching module.
+//! Caching module for eure.
 //!
-//! This module provides caching for remote schema files fetched over HTTP(S).
+//! This module provides caching infrastructure with support for multiple cache types.
 //!
 //! # Module Organization
 //!
@@ -10,21 +10,23 @@
 //! # Cache Layout
 //!
 //! The cache is stored in the platform-specific cache directory (via `directories` crate):
-//! - macOS: `~/Library/Caches/dev.eure.eure/schemas/`
-//! - Linux: `~/.cache/eure/schemas/`
-//! - Windows: `C:\Users\<User>\AppData\Local\eure\eure\cache\schemas\`
+//! - macOS: `~/Library/Caches/dev.eure.eure/`
+//! - Linux: `~/.cache/eure/`
+//! - Windows: `C:\Users\<User>\AppData\Local\eure\eure\cache\`
 //!
 //! Override with `$EURE_CACHE_DIR` environment variable.
 //!
-//! Files are organized with 2-level directory sharding to prevent overcrowding:
+//! Cache types are stored in subdirectories:
 //!
 //! ```text
-//! ~/Library/Caches/dev.eure.eure/schemas/  # (macOS example)
-//!   eure.dev/
-//!     a1/
-//!       b2/
-//!         a1b2c3d4-eure-schema.schema.eure       # content
-//!         a1b2c3d4-eure-schema.schema.eure.meta  # metadata (JSON)
+//! ~/Library/Caches/dev.eure.eure/  # base_cache_dir() (macOS example)
+//!   https/                          # https_cache_dir() - HTTPS fetched content
+//!     eure.dev/
+//!       a1/
+//!         b2/
+//!           a1b2c3d4-schema.eure       # content
+//!           a1b2c3d4-schema.eure.meta  # metadata (JSON)
+//!   # (future: compile/, build/, etc.)
 //! ```
 //!
 //! # Example (native only)
@@ -61,7 +63,7 @@ mod storage;
 #[cfg(feature = "native")]
 pub use error::CacheError;
 #[cfg(feature = "native")]
-pub use fetch::{CacheOptions, FetchResult, default_cache_dir, fetch};
+pub use fetch::{CacheOptions, FetchResult, base_cache_dir, fetch, https_cache_dir};
 #[cfg(feature = "native")]
 pub use gc::{clean, clean_with_dir, gc, gc_with_dir, parse_duration, parse_size};
 #[cfg(feature = "native")]

crates/eure/src/query/http.rs

@@ -13,7 +13,7 @@ use crate::query::error::EureQueryError;
 use super::TextFileContent;
 
 #[cfg(feature = "native")]
-pub use eure_env::cache::{CacheOptions, default_cache_dir, parse_duration};
+pub use eure_env::cache::{CacheOptions, base_cache_dir, https_cache_dir, parse_duration};
 
 /// Rate limit: minimum interval between requests to the same URL.
 const RATE_LIMIT_INTERVAL: Duration = Duration::from_secs(10);

crates/eure/src/query/mod.rs

@@ -42,7 +42,7 @@ pub use diagnostics::{DiagnosticMessage, DiagnosticSeverity, GetDiagnostics};
 #[cfg(feature = "http")]
 pub use http::fetch_url;
 #[cfg(feature = "native")]
-pub use http::{CacheOptions, default_cache_dir, fetch_url_cached, parse_duration};
+pub use http::{CacheOptions, base_cache_dir, fetch_url_cached, https_cache_dir, parse_duration};
 pub use parse::{ParseCst, ParseDocument, ParsedCst, ParsedDocument, ValidCst};
 #[cfg(feature = "http")]
 pub use reqwest;