Coverage / crates/hub/src/starter.rs 88.9%

pub async fn assistants_for(pool: &Pool, owner: &str) -> sqlx::Result<Vec<Available>> {

    let scope = match db::accounts::org_by_name(pool, owner).await? {

        None => Scope::Site,

    Ok(assistants::available(pool, scope, owner).await?.into_iter().filter(Available::on).collect())

}

static STATES: LazyLock<Mutex<HashMap<PathBuf, State>>> = LazyLock::new(|| Mutex::new(HashMap::new()));

fn key(app: &Shared, name: &RepoName) -> PathBuf {

    app.repos.dir(name)

}

pub fn state(app: &Shared, name: &RepoName) -> Option<State> {

    STATES.lock().unwrap_or_else(|p| p.into_inner()).get(&key(app, name)).cloned()

}

fn set(app: &Shared, name: &RepoName, s: State) {

    STATES.lock().unwrap_or_else(|p| p.into_inner()).insert(key(app, name), s);

}

pub fn system_prompt(a: &Assistant, site: &str, owner_prompts: &str) -> String {

    let mut s = format!(

    if !owner_prompts.trim().is_empty() {

    }

    s

}

pub fn parse_files(answer: &str) -> Result<Vec<(String, String)>, String> {

    let mut files: Vec<(String, String)> = vec![];

    let mut current: Option<(String, Vec<&str>)> = None;

    for line in answer.lines() {

        let t = line.trim_end();

        if let Some((path, body)) = current.as_mut() {

            if t.trim() == "<<<END>>>" {

                let path = std::mem::take(path);

                let content = body.join("\n") + "\n";

                current = None;

                files.push((path, content));

            } else {

                body.push(line);

            }

            continue;

        }

        if let Some(rest) = t.trim().strip_prefix("<<<FILE ") {

            let path = rest.strip_suffix(">>>").ok_or_else(|| format!("a file line is not closed with >>>: {t:?}"))?.trim();

            current = Some((path.to_string(), vec![]));

        }

    if let Some((path, _)) = current {

        return Err(format!("the answer stopped inside {path:?} (no <<<END>>>)"));

    }

    if files.is_empty() {

        return Err("the assistant answered without any files".into());

    }

    if files.len() > MAX_FILES {

        return Err(format!("the assistant wrote {} files; a starter has at most {MAX_FILES}", files.len()));

    }

    let mut total = 0;

    let mut seen = std::collections::BTreeSet::new();

    for (path, content) in &files {

        check_path(path)?;

        if !seen.insert(path.clone()) {

            return Err(format!("the assistant wrote {path} twice"));

        }

        if content.len() > MAX_FILE {

            return Err(format!("{path} is {} bytes; a starter's files are at most {MAX_FILE}", content.len()));

        }

        if content.contains('\0') {

        }

        total += content.len();

    if total > MAX_TOTAL {

    }

    Ok(files)

}

fn check_path(path: &str) -> Result<(), String> {

    let bad = |why: &str| Err(format!("the path {path:?} {why}"));

    if path.is_empty() || path.len() > 200 {

    }

    if path.starts_with('/') || path.contains('\\') || path.contains(':') {

        return bad("is not relative to the repository's root");

    }

    for part in path.split('/') {

        if part.is_empty() || part == "." || part == ".." {

            return bad("has an empty, . or .. part");

        }

        if part.eq_ignore_ascii_case(".oxy") {

            return bad("is inside the repository's own metadata");

        }

        if part.chars().any(char::is_control) {

        }

    Ok(())

}

pub async fn is_empty(app: &Shared, name: &RepoName, bookmark: &str) -> Result<bool, String> {

    let b = bookmark.to_string();

    app.repos

        .read(name, move |r, _| {

            let view = r.view()?;

            Ok(match view.bookmarks.get(&b) {

                Some(st) => r.store().get_state(st)?.heads.is_empty(),

        })

        .await

        .map_err(|e| e.to_string())

}

pub fn start(app: Shared, row: db::repos::RepoRow, by: db::accounts::Account, a: Assistant, description: String) {

    let Some(name) = RepoName::new(&row.owner, &row.name) else { return };

    set(&app, &name, State::Running { assistant: a.name.clone() });

    tokio::spawn(async move {

        let outcome = run(&app, &row, &by, &a, &description).await;

        let s = match outcome {

            Ok((change, files)) => State::Done { assistant: a.name.clone(), change, files },

            Err(error) => {

                tracing::warn!("starter for {}/{}: {error}", row.owner, row.name);

                State::Failed { assistant: a.name.clone(), error }

        set(&app, &name, s);

    });

}

async fn run(

    app: &Shared,

    row: &db::repos::RepoRow,

    by: &db::accounts::Account,

    a: &Assistant,

    description: &str,

) -> Result<(String, Vec<String>), String> {

    let name = RepoName::new(&row.owner, &row.name).ok_or("bad repository name")?;

    let signer = crate::web::edit::signer_for(app, by.id).await?;

    let scope = match db::accounts::org_by_name(&app.db, &row.owner).await.map_err(|e| e.to_string())? {

        None => Scope::Site,

    let mut prompts = assistants::inherited_prompts(&app.db, scope, &row.owner).await.map_err(|e| e.to_string())?;

    let own = assistants::prompt(&app.db, scope).await.map_err(|e| e.to_string())?;

    if !own.is_empty() && scope != Scope::Site {

    } else if !own.is_empty() {

    }

    let prompts: String =

        prompts.into_iter().map(|(from, text)| format!("## Instructions from {from}\n\n{text}\n")).collect::<Vec<_>>().join("\n");

    let site = app.config.base_url();

    let user = format!("The repository is {}/{}.\n\nWhat they want:\n\n{}", row.owner, row.name, description.trim());

    let answer = assistants::ask(app, a, &system_prompt(a, site, &prompts), &user, assistants::BACKGROUND_TIMEOUT).await?;

    let files = parse_files(&answer)?;

    if !is_empty(app, &name, &row.default_bookmark).await? {

    }

    let paths: Vec<String> = files.iter().map(|(p, _)| p.clone()).collect();

    let edits: Vec<FileEdit> = files.into_iter().map(|(path, content)| FileEdit { path, content: Some(content.into_bytes()) }).collect();

    let short: String = description.trim().chars().take(400).collect();

    let message = format!("Starter files drafted by {} ({})\n\nAsked for by {}: {short}", a.name, a.model, by.username);

    let b = row.default_bookmark.clone();

    let done = crate::repos::edits::commit(&app.repos, &name, b.clone(), b, edits, message, signer).await.map_err(|e| e.to_string())?;

    db::accounts::audit(&app.db, Some(by), "repo.starter", &name.to_string(), &format!("{} files drafted by {}", paths.len(), a.name))

        .await

        .ok();

    Ok((done.change.to_hex(), paths))

}

    fn an_answer_is_read_as_files_and_checked() {

        let answer = "<<<FILE README.md>>>\n# Hello\n<<<END>>>\n<<<FILE src/main.rs>>>\nfn main() {}\n<<<END>>>\n";

        let files = parse_files(answer).unwrap();

        assert_eq!(

            vec![("README.md".to_string(), "# Hello\n".to_string()), ("src/main.rs".to_string(), "fn main() {}\n".to_string())]

        assert!(parse_files("Sure! Here you go.").unwrap_err().contains("without any files"));

        assert!(parse_files("<<<FILE a>>>\nx").unwrap_err().contains("no <<<END>>>"));

        for bad in ["/etc/passwd", "../up", "a//b", "C:\\x", ".oxy/config"] {

            assert!(parse_files(&format!("<<<FILE {bad}>>>\nx\n<<<END>>>")).is_err(), "{bad}");

        assert!(parse_files("<<<FILE a>>>\n1\n<<<END>>>\n<<<FILE a>>>\n2\n<<<END>>>").unwrap_err().contains("twice"));

        let many: String = (0..=MAX_FILES).map(|i| format!("<<<FILE f{i}>>>\nx\n<<<END>>>\n")).collect();

        assert!(parse_files(&many).unwrap_err().contains("at most"));

        let big = format!("<<<FILE big>>>\n{}\n<<<END>>>", "x".repeat(MAX_FILE + 1));

        assert!(parse_files(&big).unwrap_err().contains("at most"));

    }