formal-ai 0.299.0

Formal symbolic AI implementation with OpenAI-compatible APIs
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

use std::ffi::OsStr;
use std::fs::{self, OpenOptions};
use std::io;
use std::path::PathBuf;

pub const MEMORY_PATH_ENV: &str = "FORMAL_AI_MEMORY_PATH";
pub const MEMORY_DIRECTORY_NAME: &str = ".formal-ai";
pub const MEMORY_FILE_NAME: &str = "memory.lino";

#[must_use]
pub fn resolve_memory_path_from(
    memory_path: Option<&OsStr>,
    home: Option<&OsStr>,
    app_data: Option<&OsStr>,
    windows: bool,
) -> PathBuf {
    if let Some(path) = memory_path
        .filter(|value| !value.to_string_lossy().trim().is_empty())
        .map(PathBuf::from)
    {
        return path;
    }

    if windows {
        return app_data
            .or(home)
            .map_or_else(|| PathBuf::from("."), PathBuf::from)
            .join("formal-ai")
            .join(MEMORY_FILE_NAME);
    }

    home.map_or_else(|| PathBuf::from("."), PathBuf::from)
        .join(MEMORY_DIRECTORY_NAME)
        .join(MEMORY_FILE_NAME)
}

#[must_use]
pub fn shared_memory_path() -> PathBuf {
    resolve_memory_path_from(
        std::env::var_os(MEMORY_PATH_ENV).as_deref(),
        std::env::var_os("HOME").as_deref(),
        std::env::var_os("APPDATA").as_deref(),
        cfg!(windows),
    )
}

pub fn ensure_shared_memory_file(path: &std::path::Path) -> io::Result<()> {
    if let Some(parent) = path
        .parent()
        .filter(|parent| !parent.as_os_str().is_empty())
    {
        let existed = parent.exists();
        fs::create_dir_all(parent)?;
        #[cfg(unix)]
        if !existed {
            use std::os::unix::fs::PermissionsExt;
            fs::set_permissions(parent, fs::Permissions::from_mode(0o700))?;
        }
    }
    OpenOptions::new().create(true).append(true).open(path)?;
    Ok(())
}