flk 0.6.3

A CLI tool for managing flake.nix devShell environments
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//! # Migrate Command Handler
//!
//! Convert a legacy flk layout (with `.flk/{default,overlays}.nix` and
//! `.flk/profiles/default.nix`) to the slim layout that uses
//! `flk.lib.mkProject` as a remote driver.

use anyhow::{bail, Context, Result};
use colored::Colorize;
use regex::Regex;
use std::fs;
use std::path::Path;

use flk::flake::generator;
use flk::flake::parsers::config as flk_config;

/// Migrate the current project to the slim layout.
///
/// Steps:
/// 1. Detect layout. If already slim, no-op with a message.
/// 2. Extract `defaultShell` from `.flk/default.nix` (if any).
/// 3. Write slim `flake.nix` + `.flk/config.nix`.
/// 4. Delete legacy driver files (`.flk/{default,overlays}.nix`,
///    `.flk/profiles/default.nix`).
/// 5. Preserve `.flk/pins.nix`, `.flk/profiles/<name>.nix`, `flake.lock`.
pub fn run() -> Result<()> {
    let flake_path = Path::new("flake.nix");
    let legacy_driver = Path::new(".flk/default.nix");
    let legacy_overlays = Path::new(".flk/overlays.nix");
    let legacy_importer = Path::new(".flk/profiles/default.nix");

    if !flake_path.exists() {
        bail!("No flake.nix in the current directory. Run 'flk init' first.");
    }

    if flk_config::exists() && !legacy_driver.exists() {
        println!(
            "{} Project is already on the slim layout — nothing to do.",
            "ℹ".blue()
        );
        return Ok(());
    }

    if !legacy_driver.exists() {
        bail!(
            ".flk/default.nix not found — cannot detect layout. \
             If this is a fresh project, run 'flk init' instead."
        );
    }

    // Extract defaultShell from legacy driver if present.
    let legacy_content =
        fs::read_to_string(legacy_driver).context("Failed to read .flk/default.nix")?;
    let default_profile = extract_default_shell(&legacy_content).unwrap_or_default();

    // Write new slim files.
    let slim_flake = generator::generate_slim_flake()?;
    let config_content = generator::generate_config(&default_profile)?;

    fs::write(flake_path, slim_flake).context("Failed to write slim flake.nix")?;
    fs::write(".flk/config.nix", config_content).context("Failed to write .flk/config.nix")?;

    // Remove legacy driver files. Tolerate already-missing ones.
    remove_if_exists(legacy_driver)?;
    remove_if_exists(legacy_overlays)?;
    remove_if_exists(legacy_importer)?;

    println!(
        "{} Migrated to the slim layout.\n  - wrote {}\n  - wrote {}\n  - removed {}\n  - removed {}\n  - removed {}",
        "✓".green().bold(),
        "flake.nix".cyan(),
        ".flk/config.nix".cyan(),
        ".flk/default.nix".yellow(),
        ".flk/overlays.nix".yellow(),
        ".flk/profiles/default.nix".yellow(),
    );

    if default_profile.is_empty() {
        println!(
            "{} No defaultShell was set in the legacy driver — run {} to pick one.",
            "ℹ".blue(),
            "flk profile set-default <name>".cyan()
        );
    } else {
        println!(
            "{} Preserved default profile: {}",
            "ℹ".blue(),
            default_profile.cyan()
        );
    }

    println!(
        "{} Run {} to refresh inputs against the remote driver.",
        "ℹ".blue(),
        "flk update".cyan()
    );

    Ok(())
}

fn extract_default_shell(content: &str) -> Option<String> {
    let re = Regex::new(r#"(?m)defaultShell\s*=\s*"([^"]*)"\s*;"#).unwrap();
    re.captures(content)
        .and_then(|c| c.get(1).map(|m| m.as_str().to_string()))
        .filter(|s| !s.trim().is_empty())
}

fn remove_if_exists(path: &Path) -> Result<()> {
    if path.exists() {
        fs::remove_file(path).with_context(|| format!("Failed to remove {}", path.display()))?;
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    const LEGACY_DRIVER: &str = r#"inputs: let
  inherit (inputs) flake-utils nixpkgs profile-lib;
in
  flake-utils.lib.eachDefaultSystem (
    system: let
      defaultShell = "rust";
    in
      profileLib.mkProfileOutputs { profileDefinitions; maxCombinations = 3; }
  )
"#;

    #[test]
    fn extracts_default_shell() {
        assert_eq!(
            extract_default_shell(LEGACY_DRIVER),
            Some("rust".to_string())
        );
    }

    #[test]
    fn returns_none_when_default_shell_is_empty() {
        let driver = LEGACY_DRIVER.replace(r#""rust""#, r#""""#);
        assert_eq!(extract_default_shell(&driver), None);
    }

    #[test]
    fn returns_none_when_default_shell_absent() {
        assert_eq!(extract_default_shell("inputs: { }"), None);
    }
}