weftos 0.4.2

WeftOS: A portable AI kernel with process management, mesh networking, and cognitive substrate
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

//! Project initialization for WeftOS.

use std::path::{Path, PathBuf};
use std::fs;

/// Result of initializing WeftOS in a project.
pub struct InitResult {
    pub project_root: PathBuf,
    pub weave_toml_created: bool,
    pub weftos_dir_created: bool,
    pub agents_installed: usize,
    pub skills_installed: usize,
}

/// Initialize WeftOS in a project directory.
pub fn init_project(project_root: impl AsRef<Path>) -> Result<InitResult, InitError> {
    let root = project_root.as_ref();
    let mut result = InitResult {
        project_root: root.to_path_buf(),
        weave_toml_created: false,
        weftos_dir_created: false,
        agents_installed: 0,
        skills_installed: 0,
    };

    // 1. Create .weftos/ directory for runtime state
    let weftos_dir = root.join(".weftos");
    if !weftos_dir.exists() {
        fs::create_dir_all(&weftos_dir)?;
        fs::create_dir_all(weftos_dir.join("chain"))?;
        fs::create_dir_all(weftos_dir.join("tree"))?;
        fs::create_dir_all(weftos_dir.join("logs"))?;
        fs::create_dir_all(weftos_dir.join("artifacts"))?;
        result.weftos_dir_created = true;
    }

    // 2. Generate weave.toml if not present
    let weave_toml = root.join("weave.toml");
    if !weave_toml.exists() {
        let config = generate_default_config(root);
        fs::write(&weave_toml, config)?;
        result.weave_toml_created = true;
    }

    // 3. Add .weftos/ to .gitignore if git project
    let gitignore = root.join(".gitignore");
    if gitignore.exists() {
        let content = fs::read_to_string(&gitignore).unwrap_or_default();
        if !content.contains(".weftos") {
            let mut f = fs::OpenOptions::new().append(true).open(&gitignore)?;
            use std::io::Write;
            writeln!(f, "\n# WeftOS runtime state")?;
            writeln!(f, ".weftos/")?;
        }
    }

    Ok(result)
}

fn generate_default_config(project_root: &Path) -> String {
    let project_name = project_root
        .file_name()
        .and_then(|n| n.to_str())
        .unwrap_or("project");

    // Detect project type
    let is_rust = project_root.join("Cargo.toml").exists();
    let is_node = project_root.join("package.json").exists();
    let is_python = project_root.join("pyproject.toml").exists()
        || project_root.join("setup.py").exists();
    let has_git = project_root.join(".git").exists();

    let language = if is_rust {
        "rust"
    } else if is_node {
        "javascript"
    } else if is_python {
        "python"
    } else {
        "generic"
    };

    let ext = match language {
        "rust" => "rs",
        "javascript" => "ts,js",
        "python" => "py",
        _ => "*",
    };

    let git_source = if has_git {
        "[sources.git]\npath = \".\"\nbranch = \"main\"\n"
    } else {
        "# No git repository detected\n"
    };

    format!(
        r#"# WeftOS Configuration
# Generated for: {project_name}

[domain]
name = "{project_name}"
language = "{language}"
description = "WeftOS-managed project"

[kernel]
max_processes = 64
health_check_interval_secs = 30

[tick]
interval_ms = 50
budget_ratio = 0.3
adaptive = true

[sources]
{git_source}
[sources.files]
root = "."
patterns = ["**/*.{ext}"]

[embedding]
provider = "mock-sha256"
dimensions = 384
batch_size = 16

[governance]
default_environment = "development"
risk_threshold = 0.9

[mesh]
enabled = false
bind_address = "0.0.0.0:9470"
seed_peers = []
"#
    )
}

#[non_exhaustive]
#[derive(Debug, thiserror::Error)]
pub enum InitError {
    #[error("io error: {0}")]
    Io(#[from] std::io::Error),
    #[error("project already initialized")]
    AlreadyInitialized,
    #[error("init error: {0}")]
    Other(String),
}