artifactize 0.14.2

The AI-native collaboration layer for one-of-a-kind teammates and their agents: split a project into Artifacts with their own evals, and reuse every review while it still holds.
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
148
149
150

//! Readiness, maintenance and account command workflows.

use super::{Context, cancellation_listener, print_json};
use serde_json::json;
use std::{
    io::{self, Write},
    path::PathBuf,
};

pub(super) async fn tools(
    context: Context,
    options: artifactize_core::diagnostics::ToolCheckOptions,
) -> Result<u8, String> {
    let (cancellation, listener) = cancellation_listener()?;
    let result = artifactize_core::diagnostics::check_tools(
        &context.repo.unwrap_or_else(|| PathBuf::from(".")),
        context.state_dir.as_deref(),
        &options,
        cancellation,
    )
    .await;
    listener.abort();
    let report = result?;
    print_json(&report)?;
    Ok(u8::from(!report.ok))
}

pub(super) async fn login(context: Context) -> Result<u8, String> {
    artifactize_core::auth::codex::login(context.state_dir.as_deref(), context.repo.as_deref())
        .await?;
    if context.json {
        print_json(&json!({ "provider": "codex", "signed_in": true }))?;
    } else {
        writeln!(io::stdout().lock(), "Signed in with Codex.").map_err(|e| e.to_string())?;
    }
    Ok(0)
}

pub(super) async fn logout(context: Context) -> Result<u8, String> {
    let revoked = artifactize_core::auth::codex::logout(
        context.state_dir.as_deref(),
        context.repo.as_deref(),
    )
    .await?;
    if !revoked {
        writeln!(
            io::stderr().lock(),
            "Local tokens removed; their revocation was not confirmed."
        )
        .map_err(|e| e.to_string())?;
    }
    if context.json {
        print_json(&json!({ "provider": "codex", "signed_in": false, "revoked": revoked }))?;
    } else {
        writeln!(io::stdout().lock(), "Signed out of Codex.").map_err(|e| e.to_string())?;
    }
    Ok(0)
}

pub(super) async fn doctor(context: Context) -> Result<u8, String> {
    let report = artifactize_core::diagnostics::doctor(
        context.state_dir.as_deref(),
        context.repo.as_deref(),
    )
    .await?;
    if context.json {
        print_json(&report)?;
    } else {
        let mut out = io::stdout().lock();
        writeln!(
            out,
            "State directory: {}",
            artifactize_core::platform::path_text(&report.state_dir)
        )
        .map_err(|e| e.to_string())?;
        for check in &report.checks {
            writeln!(out, "{} {}: {}", check.status, check.name, check.message)
                .map_err(|e| e.to_string())?;
        }
    }
    Ok(u8::from(!report.ok))
}

pub(super) async fn prune(
    context: Context,
    older_than: Option<std::time::Duration>,
    dry_run: bool,
) -> Result<u8, String> {
    let state = match context.state_dir {
        Some(state) => state,
        None => artifactize_core::store::state_home().map_err(|e| e.to_string())?,
    };
    let report = artifactize_core::store::prune::prune(
        &state,
        context.repo.as_deref(),
        older_than,
        dry_run,
    )?;
    if context.json {
        print_json(&report)?;
    } else {
        let mut out = io::stdout().lock();
        for path in &report.removed {
            writeln!(
                out,
                "Removed {}",
                artifactize_core::platform::path_text(path)
            )
            .map_err(|e| e.to_string())?;
        }
        for path in &report.would_remove {
            writeln!(
                out,
                "Would remove {}",
                artifactize_core::platform::path_text(path)
            )
            .map_err(|e| e.to_string())?;
        }
        for id in &report.skipped_runs {
            writeln!(out, "Skipped Run {id}").map_err(|e| e.to_string())?;
        }
        for id in &report.removed_sessions {
            writeln!(out, "Removed Agent session {id}").map_err(|e| e.to_string())?;
        }
        for id in &report.would_remove_sessions {
            writeln!(out, "Would remove Agent session {id}").map_err(|e| e.to_string())?;
        }
        writeln!(out, "Database audit and repository files were preserved.")
            .map_err(|e| e.to_string())?;
    }
    Ok(0)
}

pub(super) async fn models(context: Context, provider: super::ModelProvider) -> Result<u8, String> {
    let listing = artifactize_core::llm::models::list(
        provider.backend(),
        context.state_dir.as_deref(),
        context.repo.as_deref(),
    )
    .await?;
    if context.json {
        print_json(&listing)?;
    } else {
        let mut out = io::stdout().lock();
        for model in listing.models {
            writeln!(out, "{}\t{}", model.slug, model.display_name).map_err(|e| e.to_string())?;
        }
    }
    Ok(0)
}