mirror of
https://github.com/jparkerweb/plan2code.git
synced 2026-11-16 20:45:33 -08:00
feat: run each loop phase on its own strength (Thrifty, Balanced, Best)
AI Assisted
This commit is contained in:
1 parent
e963513a8a
commit
81d14c8e78
41 files changed
+3290
-81
No files matched your search
@@ -7,8 +7,9 @@
|
||||
//! agents never come through here: their menu is their own `models` in
|
||||
//! agents.json.
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::Value;
|
||||
use std::collections::HashSet;
|
||||
use std::collections::{BTreeMap, HashSet};
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use crate::agents::CustomModel;
|
||||
@@ -108,6 +109,126 @@ pub fn models_for_builtin(cli_id: &str) -> Vec<CustomModel> {
|
||||
)
|
||||
}
|
||||
|
||||
/// The loop's strength words, lightest first (`STRENGTH_ORDER` in
|
||||
/// src/web-console/strengths.mjs).
|
||||
pub const STRENGTH_ORDER: [&str; 3] = ["thrifty", "balanced", "best"];
|
||||
|
||||
/// One strength's model, and the effort when the agent takes one.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct StrengthRow {
|
||||
pub model: String,
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub effort: Option<String>,
|
||||
}
|
||||
|
||||
/// A row as the resolver keeps it, or None when it is not usable: the model
|
||||
/// must be a string in `models`; an effort survives only when the agent takes
|
||||
/// one and it is low, medium or high (`validRow` in strengths.mjs).
|
||||
fn valid_strength_row(
|
||||
row: Option<&Value>,
|
||||
models: &[String],
|
||||
has_effort: bool,
|
||||
) -> Option<StrengthRow> {
|
||||
let row = row?.as_object()?;
|
||||
let model = row.get("model")?.as_str()?;
|
||||
if !models.iter().any(|m| m == model) {
|
||||
return None;
|
||||
}
|
||||
let effort = row
|
||||
.get("effort")
|
||||
.and_then(Value::as_str)
|
||||
.filter(|e| has_effort && matches!(*e, "low" | "medium" | "high"))
|
||||
.map(str::to_string);
|
||||
Some(StrengthRow {
|
||||
model: model.to_string(),
|
||||
effort,
|
||||
})
|
||||
}
|
||||
|
||||
/// `{ thrifty?, balanced?, best? }` for one agent from the shipped and the
|
||||
/// user's `strengths` objects (each keyed by agent id): per word the user's row
|
||||
/// if it is valid, else the shipped row if it is valid; a word with neither is
|
||||
/// left out. The twin of `resolveStrengths` in strengths.mjs, held to
|
||||
/// scripts/fixtures/strength-cases.json.
|
||||
pub fn resolve_strengths(
|
||||
shipped: &Value,
|
||||
user: &Value,
|
||||
agent: &str,
|
||||
models: &[String],
|
||||
has_effort: bool,
|
||||
) -> BTreeMap<String, StrengthRow> {
|
||||
let mut resolved = BTreeMap::new();
|
||||
for word in STRENGTH_ORDER {
|
||||
let row = valid_strength_row(
|
||||
user.get(agent).and_then(|a| a.get(word)),
|
||||
models,
|
||||
has_effort,
|
||||
)
|
||||
.or_else(|| {
|
||||
valid_strength_row(
|
||||
shipped.get(agent).and_then(|a| a.get(word)),
|
||||
models,
|
||||
has_effort,
|
||||
)
|
||||
});
|
||||
if let Some(row) = row {
|
||||
resolved.insert(word.to_string(), row);
|
||||
}
|
||||
}
|
||||
resolved
|
||||
}
|
||||
|
||||
/// The first mapped word after `word` in `STRENGTH_ORDER`, else None
|
||||
/// (`nextStrength` in strengths.mjs).
|
||||
pub fn next_strength(resolved: &BTreeMap<String, StrengthRow>, word: &str) -> Option<String> {
|
||||
let at = STRENGTH_ORDER.iter().position(|w| *w == word)?;
|
||||
STRENGTH_ORDER[at + 1..]
|
||||
.iter()
|
||||
.find(|w| resolved.contains_key(**w))
|
||||
.map(|w| w.to_string())
|
||||
}
|
||||
|
||||
/// `strengths_for` from explicit file paths, so tests never touch the real
|
||||
/// home. The shipped file falls back to the baked list, like `models_for`.
|
||||
fn strengths_from(
|
||||
agent: &str,
|
||||
models: &[String],
|
||||
has_effort: bool,
|
||||
shipped_file: Option<&Path>,
|
||||
user_file: Option<&Path>,
|
||||
) -> BTreeMap<String, StrengthRow> {
|
||||
let shipped = shipped_file
|
||||
.and_then(read_json)
|
||||
.or_else(|| serde_json::from_str(BAKED_MODELS).ok())
|
||||
.unwrap_or(Value::Null);
|
||||
let user = user_file.and_then(read_json).unwrap_or(Value::Null);
|
||||
resolve_strengths(
|
||||
shipped.get("strengths").unwrap_or(&Value::Null),
|
||||
user.get("strengths").unwrap_or(&Value::Null),
|
||||
agent,
|
||||
models,
|
||||
has_effort,
|
||||
)
|
||||
}
|
||||
|
||||
/// What each strength word maps to for the built-in `agent`, from the same
|
||||
/// shipped and user files as `models_for_builtin`. `models` is the ids of the
|
||||
/// agent's menu; a row naming a model outside it reads unmapped.
|
||||
pub fn strengths_for(
|
||||
agent: &str,
|
||||
models: &[String],
|
||||
has_effort: bool,
|
||||
) -> BTreeMap<String, StrengthRow> {
|
||||
strengths_from(
|
||||
agent,
|
||||
models,
|
||||
has_effort,
|
||||
shipped_models_file().as_deref(),
|
||||
user_models_file().as_deref(),
|
||||
)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
@@ -211,7 +332,7 @@ mod tests {
|
||||
assert!(baked.len() > 1);
|
||||
std::fs::write(&missing, "{ nope").unwrap();
|
||||
assert!(models_for("claude", Some(&missing), Some(&missing)).len() > 1);
|
||||
assert!(models_for("codex", Some(&missing), Some(&missing)).is_empty());
|
||||
assert!(models_for("nonesuch", Some(&missing), Some(&missing)).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -234,4 +355,157 @@ mod tests {
|
||||
vec![model("sonnet", Some("S"))]
|
||||
);
|
||||
}
|
||||
|
||||
/// Every case in the shared strength fixture: the same file drives
|
||||
/// scripts/test-web-console-strengths.mjs, so the console's resolver and
|
||||
/// this one stay the one rule.
|
||||
#[test]
|
||||
fn the_shared_strength_cases_all_resolve_the_same() {
|
||||
let cases: Value = serde_json::from_str(include_str!(
|
||||
"../../../scripts/fixtures/strength-cases.json"
|
||||
))
|
||||
.unwrap();
|
||||
assert_eq!(cases["schema"], 1);
|
||||
let list = cases["cases"].as_array().unwrap();
|
||||
assert!(list.len() >= 10);
|
||||
for case in list {
|
||||
let name = case["name"].as_str().unwrap();
|
||||
let agent = case["agent"].as_str().unwrap();
|
||||
let models: Vec<String> = case["models"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.map(|m| m.as_str().unwrap().to_string())
|
||||
.collect();
|
||||
// The fixture holds one agent's rows; the resolver reads them by agent id.
|
||||
let wrap = |rows: &Value| json!({ agent: rows.clone() });
|
||||
let resolved = resolve_strengths(
|
||||
&wrap(&case["shipped"]),
|
||||
&wrap(&case["user"]),
|
||||
agent,
|
||||
&models,
|
||||
case["hasEffort"].as_bool().unwrap(),
|
||||
);
|
||||
let got = serde_json::to_value(&resolved).unwrap();
|
||||
assert_eq!(got, case["expect"]["resolved"], "{name}: resolved");
|
||||
for word in STRENGTH_ORDER {
|
||||
let want = case["expect"]["next"][word].as_str().map(str::to_string);
|
||||
assert_eq!(
|
||||
next_strength(&resolved, word),
|
||||
want,
|
||||
"{name}: next after {word}"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn next_strength_of_an_unknown_word_is_none() {
|
||||
let mut resolved = BTreeMap::new();
|
||||
resolved.insert(
|
||||
"best".to_string(),
|
||||
StrengthRow {
|
||||
model: "x".to_string(),
|
||||
effort: None,
|
||||
},
|
||||
);
|
||||
assert_eq!(next_strength(&resolved, "cheap"), None);
|
||||
assert_eq!(
|
||||
next_strength(&resolved, "thrifty"),
|
||||
Some("best".to_string())
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn strengths_for_reads_the_shipped_and_user_files() {
|
||||
let dir = temp_dir("strengths");
|
||||
let shipped = dir.join("bin").join("models.json");
|
||||
let user = dir.join("models.json");
|
||||
std::fs::write(
|
||||
&shipped,
|
||||
r#"{ "claude": [{ "id": "sonnet", "label": "S" }, { "id": "opus", "label": "O" }],
|
||||
"strengths": { "claude": {
|
||||
"thrifty": { "model": "sonnet", "effort": "low" },
|
||||
"best": { "model": "opus", "effort": "medium" } } } }"#,
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::write(
|
||||
&user,
|
||||
r#"{ "strengths": { "claude": { "best": { "model": "sonnet", "effort": "high" } } } }"#,
|
||||
)
|
||||
.unwrap();
|
||||
let models = vec!["sonnet".to_string(), "opus".to_string()];
|
||||
let got = strengths_from("claude", &models, true, Some(&shipped), Some(&user));
|
||||
assert_eq!(got["thrifty"].model, "sonnet");
|
||||
assert_eq!(got["best"].model, "sonnet");
|
||||
assert_eq!(got["best"].effort.as_deref(), Some("high"));
|
||||
assert!(!got.contains_key("balanced"));
|
||||
// No user file: the shipped rows alone.
|
||||
let got = strengths_from("claude", &models, true, Some(&shipped), None);
|
||||
assert_eq!(got["best"].model, "opus");
|
||||
// An agent with no rows anywhere has none.
|
||||
assert!(strengths_from("codex", &models, false, Some(&shipped), Some(&user)).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_baked_copy_ships_the_claude_and_devin_strengths() {
|
||||
let dir = temp_dir("baked-strengths");
|
||||
let missing = dir.join("bin").join("models.json");
|
||||
let ids = |agent: &str| -> Vec<String> {
|
||||
models_for(agent, Some(&missing), Some(&missing))
|
||||
.into_iter()
|
||||
.map(|m| m.id)
|
||||
.collect()
|
||||
};
|
||||
let claude = strengths_from(
|
||||
"claude",
|
||||
&ids("claude"),
|
||||
true,
|
||||
Some(&missing),
|
||||
Some(&missing),
|
||||
);
|
||||
assert_eq!(claude.len(), 3);
|
||||
let devin = strengths_from(
|
||||
"devin",
|
||||
&ids("devin"),
|
||||
false,
|
||||
Some(&missing),
|
||||
Some(&missing),
|
||||
);
|
||||
assert_eq!(devin.len(), 3);
|
||||
assert!(strengths_from(
|
||||
"codex",
|
||||
&ids("codex"),
|
||||
false,
|
||||
Some(&missing),
|
||||
Some(&missing)
|
||||
)
|
||||
.is_empty());
|
||||
}
|
||||
|
||||
/// A `strengths` key beside the agents' lists is never read as a model
|
||||
/// list: the menus come out as they did without it.
|
||||
#[test]
|
||||
fn a_strengths_key_leaves_the_model_menus_unchanged() {
|
||||
let dir = temp_dir("strengths-menu");
|
||||
let shipped = dir.join("bin").join("models.json");
|
||||
let user = dir.join("models.json");
|
||||
std::fs::write(
|
||||
&shipped,
|
||||
r#"{ "claude": [{ "id": "sonnet", "label": "S" }],
|
||||
"strengths": { "claude": { "best": { "model": "sonnet" } } } }"#,
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::write(
|
||||
&user,
|
||||
r#"{ "claude": [{ "id": "mine", "label": "M" }],
|
||||
"strengths": { "claude": { "best": { "model": "mine" } } } }"#,
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
models_for("claude", Some(&shipped), Some(&user)),
|
||||
vec![model("sonnet", Some("S")), model("mine", Some("M"))]
|
||||
);
|
||||
assert!(models_for("strengths", Some(&shipped), Some(&user)).is_empty());
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user