@repokit/core 4.0.0 → 4.0.1

package/Cargo.lock

@@ -988,7 +988,7 @@ checksum = "a96887878f22d7bad8a3b6dc5b7440e0ada9a245242924394987b21cf2210a4c"
 
 [[package]]
 name = "repokit"
-version = "4.0.0"
+version = "4.0.1"
 dependencies = [
  "alphanumeric-sort",
  "colored",

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "repokit"
-version = "4.0.0"
+version = "4.0.1"
 edition = "2024"
 
 [[bin]]

package/installation/install.sh

@@ -1,4 +1,4 @@
-CURRENT_VERSION="4.0.0"
+CURRENT_VERSION="4.0.1"
 CWD=$(pwd)
 
 REPLACEMENT="/node_modules"
@@ -37,14 +37,17 @@ VERSION_FILE=".version"
 SETTINGS_FILE=".settings"
 REPO_CACHE_DIRECTORY="$CACHE_DIRECTORY/$ROOT_COMMIT"
 
-CACHED_THEME=""
+OLD_SCHEMA_CACHED_THEME=""
+OLD_SCHEMA_CACHED_VERSION="$CURRENT_VERSION"
 
-if [ -f "$OLD_CACHE_FILE" ] && [ -n "$ROOT_COMMIT" ] && [ ! -f "$REPO_CACHE_DIRECTORY/$SETTINGS_FILE" ]; then
+if [ -f "$OLD_CACHE_FILE" ]; then
     {
-        read -r
-        read -r CACHED_THEME
+        read -r OLD_SCHEMA_CACHED_VERSION
+        read -r OLD_SCHEMA_CACHED_THEME
     } < "$OLD_CACHE_FILE"
-    echo "CACHED THEME $CACHED_THEME"
+    if [ ! -n "$ROOT_COMMIT" ] || [ -f "$REPO_CACHE_DIRECTORY/$SETTINGS_FILE" ]; then
+        OLD_SCHEMA_CACHED_THEME=""
+    fi
 fi 
 
 if [ ! -d "$CACHE_DIRECTORY" ]; then 
@@ -58,16 +61,16 @@ if [ -n "$ROOT_COMMIT" ]; then
         mkdir "$ROOT_COMMIT"
     fi
     cd $ROOT_COMMIT;
-    if [ -n "$CACHED_THEME" ] && [ ! -f "$SETTINGS_FILE" ]; then
+    if [ -n "$OLD_SCHEMA_CACHED_THEME" ] && [ ! -f "$SETTINGS_FILE" ]; then
         touch "$SETTINGS_FILE"
-        echo "$CACHED_THEME\n" > "$SETTINGS_FILE"
+        echo "$OLD_SCHEMA_CACHED_THEME\n" > "$SETTINGS_FILE"
     fi
     cd "../"
 fi
 
 if [ -f $VERSION_FILE ]; then
     read -r CACHED_VERSION < "$VERSION_FILE"
-    if [ "$CACHED_VERSION" == "$CURRENT_VERSION" ]; then
+    if [ "$CACHED_VERSION" == "$CURRENT_VERSION" ] && [ "$CACHED_VERSION" == "$OLD_SCHEMA_CACHED_VERSION" ]; then
         exit 0;    
     fi
 else 
@@ -76,6 +79,15 @@ fi
 
 echo "$CURRENT_VERSION\n" > "$VERSION_FILE"
 
+cd ../
+
+if [ -f "$OLD_CACHE_FILE" ]; then
+    TEMP_FILE=".repokit_tmp";
+    printf "$CURRENT_VERSION\n" > "$TEMP_FILE"
+    tail +2 "$OLD_CACHE_FILE" >> "$TEMP_FILE"
+    mv "$TEMP_FILE" "$OLD_CACHE_FILE"
+fi
+
 cd $CWD
 
 echo "Compiling from $CWD"

package/internals/caches/mod.rs

@@ -1,5 +1,6 @@
 pub mod crawl_cache;
 pub mod file_cache;
+pub mod old_cache;
 pub mod repokit_version_resolver;
 pub mod settings_cache;
 pub mod version_cache;

package/internals/caches/old_cache.rs

@@ -0,0 +1,35 @@
+use std::{env::home_dir, path::PathBuf, sync::LazyLock};
+
+use crate::caches::{file_cache::FileCache, version_cache::VERSION_REGEX};
+
+static OLD_CACHE_FILE: &str = ".repokit";
+
+static OLD_CACHE_FILE_PATH: LazyLock<Option<PathBuf>> = LazyLock::new(home_dir);
+
+pub struct OldCache;
+
+impl FileCache for OldCache {
+    fn cache_file(&self) -> &str {
+        OLD_CACHE_FILE
+    }
+
+    fn cache_directory(&self) -> &Option<PathBuf> {
+        &OLD_CACHE_FILE_PATH
+    }
+}
+
+impl OldCache {
+    pub fn new() -> Self {
+        OldCache {}
+    }
+
+    pub fn get_version(&self) -> Option<String> {
+        if let Some((mut lines, _)) = self.read() {
+            let version = self.unwrap_line(lines.nth(0), "");
+            if VERSION_REGEX.is_match(&version) {
+                return Some(version);
+            }
+        }
+        None
+    }
+}

package/internals/caches/version_cache.rs

@@ -9,7 +9,10 @@ use futures::{executor::block_on, join};
 use regex::Regex;
 
 use crate::{
-    caches::{file_cache::FileCache, repokit_version_resolver::RepoKitVersionResolver},
+    caches::{
+        file_cache::FileCache, old_cache::OldCache,
+        repokit_version_resolver::RepoKitVersionResolver,
+    },
     context::file_system::FileSystem,
     logger::logger::Logger,
 };
@@ -18,19 +21,19 @@ use crate::{
 pub struct VersionCache {
     pub runtime_version: String,
     pub installed_version: String,
+    pub old_cache_path_version: String,
     pub cache_directory: Option<PathBuf>,
 }
 
-static UNKNOWN: &str = "UNKNOWN";
-
 pub static VERSION_REGEX: LazyLock<Regex> =
     LazyLock::new(|| Regex::new(r#"\d*\.\d*.\d*"#).unwrap());
 
 impl VersionCache {
     pub fn new(cache_directory: &Option<PathBuf>) -> Self {
         VersionCache {
-            runtime_version: UNKNOWN.to_string(),
-            installed_version: UNKNOWN.to_string(),
+            runtime_version: "".to_string(),
+            installed_version: "".to_string(),
+            old_cache_path_version: "".to_string(),
             cache_directory: cache_directory.clone(),
         }
     }
@@ -46,9 +49,10 @@ impl VersionCache {
     }
 
     pub async fn initialize(&mut self, files: &FileSystem) {
-        let (runtime_result, install_result) = join!(
+        let (runtime_result, install_result, old_cache_path_version) = join!(
             self.runtime_version(),
-            self.installed_repokit_version(files)
+            self.installed_repokit_version(files),
+            self.get_old_cache_path_version(),
         );
         if let Some(installed_version) = install_result {
             self.installed_version = installed_version;
@@ -56,8 +60,13 @@ impl VersionCache {
         if let Some(runtime_version) = runtime_result {
             self.runtime_version = runtime_version;
         }
-        if self.installed_version != self.runtime_version
-            && VERSION_REGEX.is_match(&self.installed_version)
+        if let Some(old_cache_version) = old_cache_path_version {
+            self.old_cache_path_version = old_cache_version;
+        }
+        if (self.installed_version != self.runtime_version)
+            || (self.installed_version != self.old_cache_path_version
+                && !self.old_cache_path_version.is_empty())
+                && VERSION_REGEX.is_match(&self.installed_version)
         {
             self.hop_to_installed_version(files);
         }
@@ -115,6 +124,11 @@ impl VersionCache {
         }
         None
     }
+
+    async fn get_old_cache_path_version(&self) -> Option<String> {
+        let old_cache = OldCache::new();
+        old_cache.get_version()
+    }
 }
 
 impl FileCache for VersionCache {

package/internals/context/cache_scope.rs

@@ -1,31 +1,32 @@
 use futures::{executor::block_on, join};
-use normalize_path::NormalizePath;
-use shellexpand::tilde;
 use std::{
+    env::home_dir,
     fs::create_dir_all,
-    path::{Path, PathBuf},
+    path::PathBuf,
 };
 
 use crate::{
     caches::{
-        crawl_cache::CrawlCache, file_cache::FileCache, settings_cache::SettingsCache,
-        version_cache::VersionCache,
+        crawl_cache::CrawlCache, file_cache::FileCache,
+        settings_cache::SettingsCache, version_cache::VersionCache,
     },
     context::{file_system::FileSystem, git_scope::GitScope},
 };
 
 #[derive(Clone)]
 pub struct CacheScope {
+    pub crawl_cache: CrawlCache,
     pub version_cache: VersionCache,
     pub settings_cache: SettingsCache,
-    pub crawl_cache: CrawlCache,
 }
 
 static CACHE_DIRECTORY: &str = ".repokit_cache";
 
 impl CacheScope {
     pub fn new(git_scope: &GitScope, file_system: &FileSystem) -> CacheScope {
-        let cache_directory = CacheScope::resolve_cache_directory(&git_scope.root_commit_hash);
+        let home = home_dir();
+        let cache_directory =
+            CacheScope::resolve_cache_directory(&home, &git_scope.root_commit_hash);
         let mut instance = CacheScope {
             crawl_cache: CrawlCache::new(&cache_directory),
             version_cache: VersionCache::new(&cache_directory),
@@ -52,17 +53,11 @@ impl CacheScope {
         );
     }
 
-    pub fn home() -> Option<PathBuf> {
-        let expanded_path_str = tilde("~/");
-        let path = Path::new(expanded_path_str.as_ref()).normalize();
-        if path.is_absolute() && path.exists() {
-            return Some(path);
-        }
-        None
-    }
-
-    fn resolve_cache_directory(root_commit: &Option<String>) -> Option<PathBuf> {
-        if let Some(home) = CacheScope::home()
+    fn resolve_cache_directory(
+        home_path: &Option<PathBuf>,
+        root_commit: &Option<String>,
+    ) -> Option<PathBuf> {
+        if let Some(home) = home_path
             && let Some(commit_hash) = root_commit
         {
             let cache_dir = home.join(CACHE_DIRECTORY).join(commit_hash);

package/internals/repokit/repokit_command.rs

@@ -46,7 +46,7 @@ impl RepoKitCommand {
                     failed_paths.push(path);
                 }
             } else {
-                let mut valid_command = repokit_command.expect("assertion success");
+                let mut valid_command = repokit_command.expect("parse success");
                 valid_command.location = format!("{}/{}", git_root, valid_command.location);
                 result.push(valid_command);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@repokit/core",
-  "version": "4.0.0",
+  "version": "4.0.1",
   "description": "A knowledgebase for your repository - wrapped in a CLI",
   "keywords": [
     "cli",