@repokit/core 3.0.5 → 4.0.0

package/internals/caches/version_cache.rs

@@ -0,0 +1,128 @@
+use std::{
+    fs::File,
+    io::{BufRead, BufReader},
+    path::PathBuf,
+    sync::LazyLock,
+};
+
+use futures::{executor::block_on, join};
+use regex::Regex;
+
+use crate::{
+    caches::{file_cache::FileCache, repokit_version_resolver::RepoKitVersionResolver},
+    context::file_system::FileSystem,
+    logger::logger::Logger,
+};
+
+#[derive(Clone)]
+pub struct VersionCache {
+    pub runtime_version: String,
+    pub installed_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(),
+            cache_directory: cache_directory.clone(),
+        }
+    }
+
+    pub fn refresh_installed_version(&self, files: &FileSystem) -> Option<String> {
+        let installed_version = block_on(self.installed_repokit_version(files));
+        if let Some(version) = &installed_version
+            && *version != self.installed_version
+        {
+            return Some(version.to_string());
+        }
+        None
+    }
+
+    pub async fn initialize(&mut self, files: &FileSystem) {
+        let (runtime_result, install_result) = join!(
+            self.runtime_version(),
+            self.installed_repokit_version(files)
+        );
+        if let Some(installed_version) = install_result {
+            self.installed_version = installed_version;
+        }
+        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)
+        {
+            self.hop_to_installed_version(files);
+        }
+    }
+
+    fn hop_to_installed_version(&self, files: &FileSystem) {
+        Logger::info(
+            format!(
+                "Switching to version {}",
+                Logger::with_theme(|theme| theme.highlight(&self.installed_version))
+            )
+            .as_str(),
+        );
+        RepoKitVersionResolver::hop_to_installed_version(files);
+    }
+
+    async fn runtime_version(&self) -> Option<String> {
+        if let Some((mut lines, _)) = self.read() {
+            let last_known_version = self.unwrap_line(lines.nth(0), "");
+            if VERSION_REGEX.is_match(&last_known_version) {
+                return Some(last_known_version);
+            }
+            return None;
+        }
+        None
+    }
+
+    async fn installed_repokit_version(&self, files: &FileSystem) -> Option<String> {
+        let package_path = FileSystem::join_with(&files.package_directory, "package.json");
+        if !package_path.exists() || !package_path.is_file() {
+            return None;
+        }
+        let file = File::open(package_path);
+        if file.is_err() {
+            return None;
+        }
+        let lines = BufReader::new(file.unwrap()).lines();
+        let version_matcher = Regex::new(r#""([^"]*)""#).unwrap();
+        for line in lines.map_while(Result::ok) {
+            if line.contains("\"version\": ") {
+                let captures: Vec<String> = version_matcher
+                    .captures_iter(&line)
+                    .filter_map(|item| {
+                        item.get(1)
+                            .map(|match_text| match_text.as_str().to_string())
+                    })
+                    .collect();
+                if let Some(version) = captures.get(1)
+                    && VERSION_REGEX.is_match(version)
+                {
+                    return Some(version.to_string());
+                }
+                return None;
+            }
+        }
+        None
+    }
+}
+
+impl FileCache for VersionCache {
+    fn cache_file(&self) -> &str {
+        "../.version"
+    }
+
+    fn cache_directory(&self) -> &Option<PathBuf> {
+        &self.cache_directory
+    }
+}

package/internals/context/cache_scope.rs

@@ -0,0 +1,76 @@
+use futures::{executor::block_on, join};
+use normalize_path::NormalizePath;
+use shellexpand::tilde;
+use std::{
+    fs::create_dir_all,
+    path::{Path, PathBuf},
+};
+
+use crate::{
+    caches::{
+        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 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 mut instance = CacheScope {
+            crawl_cache: CrawlCache::new(&cache_directory),
+            version_cache: VersionCache::new(&cache_directory),
+            settings_cache: SettingsCache::new(&cache_directory),
+        };
+        block_on(instance.initialize_all(git_scope, file_system));
+        instance
+    }
+
+    async fn initialize_all(&mut self, git_scope: &GitScope, file_system: &FileSystem) {
+        self.create_cache_files().await;
+        join!(
+            self.version_cache.initialize(file_system),
+            self.settings_cache.initialize(),
+            self.crawl_cache.initialize(git_scope),
+        );
+    }
+
+    async fn create_cache_files(&self) {
+        join!(
+            self.version_cache.create_cache_file_if_not_exists(),
+            self.settings_cache.create_cache_file_if_not_exists(),
+            self.crawl_cache.create_cache_file_if_not_exists(),
+        );
+    }
+
+    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()
+            && let Some(commit_hash) = root_commit
+        {
+            let cache_dir = home.join(CACHE_DIRECTORY).join(commit_hash);
+            if !cache_dir.exists() && create_dir_all(&cache_dir).is_err() {
+                return None;
+            }
+            return Some(cache_dir);
+        }
+        None
+    }
+}

package/internals/context/file_system.rs

@@ -0,0 +1,66 @@
+use normalize_path::NormalizePath;
+
+use std::{
+    fs::File,
+    path::{Path, PathBuf},
+};
+
+use crate::{internal_filesystem::file_builder::FileBuilder, logger::logger::Logger};
+
+#[derive(Clone)]
+pub struct FileSystem {
+    pub git_root: String,
+    pub git_root_path: PathBuf,
+    pub package_directory: PathBuf,
+    pub commands_directory: PathBuf,
+    pub templates_directory: PathBuf,
+    pub install_script_path: PathBuf,
+    pub install_script_location: &'static str,
+}
+
+static INSTALL_SCRIPT_LOCATION: &str = "installation/install.sh";
+static INSTALLED_PACKAGE_PATH: &str = "node_modules/@repokit/core";
+static TYPESCRIPT_COMMANDS: &str = "dist/commands";
+static TYPESCRIPT_TEMPLATES: &str = "externals/templates";
+
+impl FileSystem {
+    pub fn new(git_root: &str) -> FileSystem {
+        let git_root_path = Path::new(&git_root).normalize();
+        let package_directory = FileSystem::join_with(&git_root_path, INSTALLED_PACKAGE_PATH);
+        FileSystem {
+            git_root_path,
+            git_root: git_root.to_owned(),
+            install_script_path: FileSystem::join_with(&package_directory, INSTALL_SCRIPT_LOCATION),
+            commands_directory: FileSystem::join_with(&package_directory, TYPESCRIPT_COMMANDS),
+            templates_directory: FileSystem::join_with(&package_directory, TYPESCRIPT_TEMPLATES),
+            package_directory,
+            install_script_location: INSTALL_SCRIPT_LOCATION,
+        }
+    }
+
+    pub fn join_with(root: &PathBuf, segment: &str) -> PathBuf {
+        root.join(segment).normalize()
+    }
+
+    pub fn resolve_command(&self, command_name: &str) -> String {
+        FileSystem::path_buf_to_str(&FileSystem::join_with(
+            &self.commands_directory,
+            format!("{command_name}.mjs").as_str(),
+        ))
+    }
+
+    pub fn resolve_template(&self, file_name: &str) -> File {
+        FileBuilder::open(
+            FileSystem::join_with(&self.templates_directory, file_name),
+            |_| {
+                Logger::error(format!("Unable to locate internal {file_name}").as_str());
+                Logger::error("Please file a bug here");
+                Logger::log_issue_link();
+            },
+        )
+    }
+
+    pub fn path_buf_to_str(path: &PathBuf) -> String {
+        path.to_string_lossy().to_string()
+    }
+}

package/internals/context/git_scope.rs

@@ -0,0 +1,55 @@
+use std::path::Path;
+
+use futures::{executor::block_on, join};
+
+use crate::{executor::executor::Executor, logger::logger::Logger};
+
+#[derive(Clone)]
+pub struct GitScope {
+    pub root: String,
+    pub root_commit_hash: Option<String>,
+    pub head_commit_hash: Option<String>,
+}
+
+impl GitScope {
+    pub fn new() -> GitScope {
+        let mut instance = GitScope {
+            root: "".to_string(),
+            root_commit_hash: None,
+            head_commit_hash: None,
+        };
+        block_on(instance.resolve());
+        instance
+    }
+
+    async fn resolve(&mut self) {
+        let (root, root_commit, head_commit) = join!(
+            GitScope::find_root(),
+            GitScope::get_root_commit(),
+            GitScope::get_head_commit()
+        );
+        self.root = root;
+        self.root_commit_hash = root_commit;
+        self.head_commit_hash = head_commit;
+    }
+
+    async fn find_root() -> String {
+        if let Some(root) = Executor::exec_with_stdout("git rev-parse --show-toplevel", |cmd| cmd)
+            && !root.is_empty()
+            && Path::new(&root).exists()
+        {
+            return root;
+        }
+        Logger::info("Please initialize your repository by running");
+        Logger::log_file_path("git init");
+        panic!();
+    }
+
+    async fn get_head_commit() -> Option<String> {
+        Executor::exec_with_stdout("git rev-parse HEAD", |cmd| cmd)
+    }
+
+    async fn get_root_commit() -> Option<String> {
+        Executor::exec_with_stdout("git rev-list --parents HEAD | tail -1", |cmd| cmd)
+    }
+}

package/internals/context/mod.rs

@@ -0,0 +1,5 @@
+pub mod cache_scope;
+pub mod file_system;
+pub mod git_scope;
+pub mod node_scope;
+pub mod typescript_bridge;

package/internals/context/node_scope.rs

@@ -0,0 +1,133 @@
+use std::{collections::HashMap, path::Path};
+
+use normalize_path::NormalizePath;
+
+use crate::{
+    caches::version_cache::VERSION_REGEX, executor::executor::Executor, logger::logger::Logger,
+};
+
+#[derive(Clone)]
+pub struct NodeScope {
+    pub install_command: String,
+    pub command_executor: String,
+    pub package_manager: String,
+    pub resolved_typescript_version: Option<u32>,
+}
+
+impl NodeScope {
+    pub fn new(git_root: &str) -> NodeScope {
+        let package_manager = NodeScope::get_package_manager(git_root).to_string();
+        NodeScope {
+            resolved_typescript_version: None,
+            command_executor: NodeScope::get_node_executor(&package_manager).to_string(),
+            install_command: NodeScope::get_install_command(&package_manager).to_string(),
+            package_manager,
+        }
+    }
+
+    pub fn type_check_file(&mut self, file_path: &str) {
+        let command = self.get_typecheck_command(file_path);
+        Executor::with_stdio(command, |cmd| cmd);
+    }
+
+    pub fn get_typecheck_command(&mut self, file_path: &str) -> String {
+        let typescript_version = self.get_typescript_version();
+        let ignore_config = if typescript_version >= 6 {
+            " --ignoreConfig".to_string()
+        } else {
+            "".to_string()
+        };
+        let tsc_command = format!(
+            "{} tsc {} --noEmit{}",
+            self.command_executor, file_path, ignore_config
+        );
+        tsc_command
+    }
+
+    pub fn prompt_to_fix_errors(config_path: &str) {
+        Logger::info(
+            "Please fix the above type-errors and rerun your command"
+                .to_string()
+                .as_str(),
+        );
+        Logger::log_file_path(config_path);
+    }
+
+    fn get_typescript_version(&mut self) -> u32 {
+        if let Some(resolved_version) = self.resolved_typescript_version {
+            return resolved_version;
+        }
+        let stdout = Executor::exec(format!("{} tsc --version", self.command_executor), |cmd| {
+            cmd
+        });
+        let lines: Vec<&str> = stdout
+            .split("\n")
+            .filter_map(|s| {
+                let trimmed = s.trim();
+                if trimmed.is_empty() {
+                    return None;
+                }
+                Some(trimmed)
+            })
+            .collect();
+        let fallback_version = "5.0.0";
+        let version = lines.last().unwrap_or(&fallback_version);
+        let captures: Vec<String> = VERSION_REGEX
+            .captures_iter(version)
+            .filter_map(|item| {
+                item.get(0)
+                    .map(|match_text| match_text.as_str().to_string())
+            })
+            .collect();
+        let fallback_version_str = fallback_version.to_string();
+        let semver = captures.first().unwrap_or(&fallback_version_str);
+        let major = semver
+            .chars()
+            .next()
+            .unwrap_or('5')
+            .to_digit(10)
+            .unwrap_or(5);
+        self.resolved_typescript_version = Some(major);
+        major
+    }
+
+    fn get_install_command(package_manager: &str) -> &str {
+        let npm_install = "npm i -D";
+        let manager_map = HashMap::from([
+            ("npm", npm_install),
+            ("yarn", "yarn add -D"),
+            ("pnpm", "pnpm i -D"),
+            ("bun", "bun add -D"),
+        ]);
+        manager_map.get(package_manager).unwrap_or(&npm_install)
+    }
+
+    fn get_node_executor(package_manager: &str) -> &str {
+        let npx = "npx";
+        let manager_map = HashMap::from([
+            ("npm", "npx"),
+            ("yarn", "yarn run -T"),
+            ("pnpm", "pnpm run"),
+            ("bun", "bunx"),
+        ]);
+        manager_map.get(package_manager).unwrap_or(&npx)
+    }
+
+    fn get_package_manager(root: &str) -> &str {
+        let manager_map = HashMap::from([
+            ("npm", ["package-lock.json"].to_vec()),
+            ("yarn", ["yarn.lock"].to_vec()),
+            ("pnpm", ["pnpm-lock.yaml"].to_vec()),
+            ("bun", ["bun.lockb", "bun.lock"].to_vec()),
+        ]);
+        for (manager, lock_files) in manager_map {
+            for lock_file in lock_files {
+                let path = Path::new(root).join(lock_file).normalize();
+                if path.exists() && path.is_file() {
+                    return manager;
+                }
+            }
+        }
+        "npm"
+    }
+}

package/internals/context/typescript_bridge.rs

@@ -0,0 +1,68 @@
+use core::panic;
+use std::{
+    path::{Path, PathBuf},
+    sync::MutexGuard,
+};
+
+use serde_json::{Value, from_str};
+
+use crate::{
+    context::{file_system::FileSystem, node_scope::NodeScope},
+    executor::executor::Executor,
+    repokit::{
+        repokit_command::RepoKitCommand, repokit_config::RepoKitConfig,
+        repokit_runtime::RepoKitRuntime,
+    },
+};
+
+pub struct TypeScriptBridge;
+
+impl TypeScriptBridge {
+    pub fn parse_configuration(files: &FileSystem, node: &mut NodeScope) -> RepoKitConfig {
+        let executable = files.resolve_command("parse_configuration");
+        let stdout = TypeScriptBridge::execute_with_node(
+            &files.git_root_path,
+            format!("{executable} --root {}", &files.git_root).as_str(),
+        );
+        if stdout.is_empty() {
+            RepoKitConfig::create(files);
+        }
+        let result: Result<Value, serde_json::Error> = from_str(stdout.as_str());
+        match result {
+            Ok(config) => RepoKitConfig::from_input(&files.git_root, node, config),
+            Err(_) => {
+                RepoKitConfig::on_parsing_error(&files.git_root, node, Value::Null);
+                panic!();
+            }
+        }
+    }
+
+    pub fn parse_commands(path_list: &MutexGuard<Vec<String>>) -> Vec<RepoKitCommand> {
+        let paths = path_list.join(",");
+        let stdout = RepoKitRuntime::with_runtime(|runtime| {
+            let executable = runtime.files.resolve_command("parse_commands");
+            TypeScriptBridge::execute_with_node(
+                &runtime.files.git_root_path,
+                format!(
+                    "{executable} --paths {paths} --root {}",
+                    runtime.files.git_root
+                )
+                .as_str(),
+            )
+        });
+        let result: Result<Vec<Value>, serde_json::Error> = serde_json::from_str(&stdout);
+        match result {
+            Ok(commands) => RepoKitCommand::from_input(commands),
+            Err(_) => {
+                RepoKitCommand::full_blown_crash();
+                panic!();
+            }
+        }
+    }
+
+    fn execute_with_node(root: &PathBuf, args: &str) -> String {
+        Executor::exec(format!("node {args}"), |cmd| {
+            cmd.current_dir(Path::new(root))
+        })
+    }
+}

package/internals/executables/internal_executable.rs

@@ -1,9 +1,15 @@
 use std::collections::HashMap;
 
-use crate::executables::internal_executable_definition::InternalExecutableDefinition;
+use crate::{
+    executables::internal_executable_definition::InternalExecutableDefinition,
+    internal_commands::help::Help,
+};
 
 pub trait InternalExecutable {
     fn run(&self, args: Vec<String>, internals: &HashMap<String, Box<dyn InternalExecutable>>);
-    fn help(&self);
     fn get_definition(&self) -> &InternalExecutableDefinition;
+
+    fn help(&self) {
+        Help::log_internal_command(self.get_definition());
+    }
 }

package/internals/executables/internal_executable_definition.rs

@@ -1,13 +1,5 @@
 use std::collections::HashMap;
 
-use crate::repokit::repokit_config::RepoKitConfig;
-
-#[derive(Clone)]
-pub struct RepoKitScope {
-    pub root: String,
-    pub configuration: RepoKitConfig,
-}
-
 #[derive(Clone)]
 pub struct InternalExecutableDefinition {
     pub name: String,

package/internals/executor/executor.rs

@@ -31,6 +31,19 @@ impl Executor {
         Some(Executor::unwrap(&output.stderr))
     }
 
+    pub fn exec_with_stdout<T: AsRef<OsStr>>(
+        command: T,
+        composer: impl Fn(&mut Command) -> &mut Command,
+    ) -> Option<String> {
+        let output = composer(&mut Executor::spawn(command))
+            .output()
+            .expect("command failed to execute");
+        if output.status.success() {
+            return Some(Executor::unwrap(&output.stdout));
+        }
+        None
+    }
+
     pub fn with_stdio<T: AsRef<OsStr>>(
         command: T,
         composer: impl Fn(&mut Command) -> &mut Command,

package/internals/file_walker/file_walker.rs

@@ -0,0 +1,59 @@
+use std::sync::{Arc, Mutex, MutexGuard};
+
+use ignore::WalkBuilder;
+
+use crate::{file_walker::walker::TSFileVisitorBuilder, repokit::repokit_runtime::RepoKitRuntime};
+
+pub struct FileWalker {
+    pub command_paths: Arc<Mutex<Vec<String>>>,
+}
+
+impl FileWalker {
+    pub fn new() -> Self {
+        let instance = FileWalker {
+            command_paths: Arc::new(Mutex::new(Vec::new())),
+        };
+        instance.resolve();
+        instance
+    }
+
+    pub fn get(&self) -> MutexGuard<'_, Vec<String>> {
+        self.command_paths.lock().unwrap()
+    }
+
+    fn resolve(&self) {
+        if RepoKitRuntime::with_runtime(|runtime| runtime.caches.crawl_cache.crawl_cache_enabled())
+        {
+            self.from_cache();
+        } else {
+            self.crawl_file_system();
+        }
+    }
+
+    fn crawl_file_system(&self) {
+        RepoKitRuntime::with_runtime(|runtime| {
+            let mut visitor = TSFileVisitorBuilder::new(&runtime.git.root, &self.command_paths);
+            WalkBuilder::new(&runtime.files.git_root_path)
+                .build_parallel()
+                .visit(&mut visitor);
+            if let Some(head_commit) = &runtime.git.head_commit_hash {
+                let files = self.command_paths.lock().unwrap();
+                runtime
+                    .caches
+                    .crawl_cache
+                    .cache_crawl_results([head_commit.to_owned(), files.join("\n")].join("\n"));
+            }
+        });
+    }
+
+    fn from_cache(&self) {
+        let mut paths_to_search = self.command_paths.lock().unwrap();
+        RepoKitRuntime::with_runtime(|runtime| {
+            if let Some(files_to_crawl) = &runtime.caches.crawl_cache.files_to_crawl {
+                for file in files_to_crawl {
+                    paths_to_search.push(file.to_owned());
+                }
+            }
+        })
+    }
+}

package/internals/file_walker/mod.rs

@@ -1 +1,2 @@
+pub mod file_walker;
 pub mod walker;

package/internals/internal_commands/help.rs

@@ -10,7 +10,7 @@ use crate::{
     logger::logger::Logger,
     repokit::{
         command_definition::CommandDefinition, repokit_command::RepoKitCommand,
-        repokit_config::RootCommand,
+        repokit_config::RootCommand, repokit_runtime::RepoKitRuntime,
     },
 };
 
@@ -18,12 +18,13 @@ pub struct Help;
 
 impl Help {
     pub fn list_all(
-        root_commands: &HashMap<String, CommandDefinition>,
         internals: &HashMap<String, Box<dyn InternalExecutable>>,
         externals: &HashMap<String, RepoKitCommand>,
     ) {
         Help::log_internal_commands(internals);
-        Help::log_root_commands(root_commands);
+        RepoKitRuntime::with_runtime(|runtime| {
+            Help::log_root_commands(&runtime.configuration.commands);
+        });
         Help::log_external_commands(externals);
     }