Factory: show and merge pull requests, issue chats (plan features, cut milestones)
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
a0a4082383
commit
56c20d92f8
10 files changed
+673
-3
No files matched your search
+203
-1
@@ -504,6 +504,64 @@ impl Forge {
|
||||
}
|
||||
|
||||
/// Open a pull request (GitLab: merge request); returns {number, html_url}.
|
||||
/// A pull/merge request in one shape: number, html_url, title, state (open|merged|closed),
|
||||
/// mergeable, changed_files, additions, deletions, head.
|
||||
fn norm_pr(&self, v: &Value) -> Value {
|
||||
match self.kind {
|
||||
Kind::Gitlab => json!({
|
||||
"number": v["iid"], "html_url": v["web_url"], "title": v["title"],
|
||||
"state": match v["state"].as_str() { Some("opened") => "open", Some("merged") => "merged", _ => "closed" },
|
||||
"mergeable": v["merge_status"].as_str() == Some("can_be_merged"),
|
||||
"changed_files": v["changes_count"], "additions": Value::Null, "deletions": Value::Null, "head": v["source_branch"],
|
||||
}),
|
||||
_ => json!({
|
||||
"number": v["number"], "html_url": v["html_url"], "title": v["title"],
|
||||
"state": if v["merged"].as_bool() == Some(true) || v["merged_at"].is_string() { json!("merged") } else if v["state"].as_str() == Some("open") { json!("open") } else { json!("closed") },
|
||||
"mergeable": v["mergeable"], "changed_files": v["changed_files"], "additions": v["additions"], "deletions": v["deletions"], "head": v["head"]["ref"],
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn pr(&self, number: u64) -> Result<Value> {
|
||||
let path = if self.kind == Kind::Gitlab { format!("/merge_requests/{number}") } else { format!("/pulls/{number}") };
|
||||
let v = self.call(reqwest::Method::GET, self.rp(&path), None).await?;
|
||||
Ok(self.norm_pr(&v))
|
||||
}
|
||||
|
||||
/// The open pull request from a branch with its details, if there is one.
|
||||
pub async fn find_pr(&self, head: &str) -> Result<Option<Value>> {
|
||||
let url = self.open_pr(head).await?;
|
||||
let Some(url) = url else { return Ok(None) };
|
||||
let n: u64 = url.trim_end_matches('/').rsplit('/').next().and_then(|n| n.parse().ok()).unwrap_or(0);
|
||||
if n == 0 {
|
||||
return Ok(None);
|
||||
}
|
||||
Ok(Some(self.pr(n).await?))
|
||||
}
|
||||
|
||||
/// Merge a pull request (method: merge, squash or rebase). Only ever called on the user's click.
|
||||
pub async fn merge_pr(&self, number: u64, method: &str) -> Result<()> {
|
||||
match self.kind {
|
||||
Kind::Gitea => self.call(reqwest::Method::POST, self.rp(&format!("/pulls/{number}/merge")), Some(json!({"Do": method}))).await.map(|_| ()),
|
||||
Kind::Github => self.call(reqwest::Method::PUT, self.rp(&format!("/pulls/{number}/merge")), Some(json!({"merge_method": method}))).await.map(|_| ()),
|
||||
Kind::Gitlab => self.call(reqwest::Method::PUT, self.rp(&format!("/merge_requests/{number}/merge")), Some(json!({"squash": method == "squash"}))).await.map(|_| ()),
|
||||
}
|
||||
}
|
||||
|
||||
/// URL of the open pull/merge request from this branch, if there is one.
|
||||
pub async fn open_pr(&self, head: &str) -> Result<Option<String>> {
|
||||
match self.kind {
|
||||
Kind::Gitlab => {
|
||||
let v = self.call(reqwest::Method::GET, self.rp(&format!("/merge_requests?state=opened&source_branch={}", urlenc(head))), None).await?;
|
||||
Ok(v.as_array().and_then(|a| a.first()).and_then(|m| m["web_url"].as_str()).map(String::from))
|
||||
}
|
||||
_ => {
|
||||
let v = self.call(reqwest::Method::GET, self.rp("/pulls?state=open&per_page=100&limit=100"), None).await?;
|
||||
Ok(v.as_array().and_then(|a| a.iter().find(|p| p["head"]["ref"].as_str() == Some(head))).and_then(|p| p["html_url"].as_str()).map(String::from))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn create_pr(&self, title: &str, body: &str, head: &str, base: &str) -> Result<Value> {
|
||||
match self.kind {
|
||||
Kind::Gitlab => {
|
||||
@@ -1082,7 +1140,9 @@ async fn qa(app: Arc<App>, user: User, cfg: RepoCfg, issue: Value) {
|
||||
return;
|
||||
}
|
||||
// Accepted: now the pull request is opened (unless one exists from an earlier run).
|
||||
let mut pr_url = row["pr_url"].as_str().unwrap_or("").to_string();
|
||||
// An earlier pull request may be merged or closed already (later rework commits would be lost):
|
||||
// only an open one counts.
|
||||
let mut pr_url = g.open_pr(&branch).await.ok().flatten().unwrap_or_default();
|
||||
if pr_url.is_empty() {
|
||||
let built = row["note"].as_str().unwrap_or("").trim();
|
||||
let body = format!("Built and accepted by the software factory for #{n}.\n\n**Build**\n{}\n\n**Acceptance** – {summary}\n\n{table}", if built.is_empty() { "–" } else { built });
|
||||
@@ -1201,6 +1261,135 @@ pub fn spawn(app: Arc<App>) {
|
||||
}
|
||||
|
||||
|
||||
// --- issue chats: work out features / cut milestones with a model and file the issues ---------
|
||||
|
||||
/// Instructions of an issue chat. `{repo_dir}` is the checkout (read-only for the chat), `{mode}` the task.
|
||||
pub const ISSUE_INSTRUCTIONS: &str = r#"You are the planning stage of a software factory. Autonomous agents will later review, build and accept every issue you help to write – without being able to ask questions. Answer in the user's language.
|
||||
|
||||
Your working directory is a scratch folder. The project is checked out at {repo_dir} (read it, never change anything in it; do not create issues or touch the forge yourself). Its specification lives under docs/specs/ in that checkout.
|
||||
|
||||
{mode}
|
||||
|
||||
Rules for every issue you propose:
|
||||
- One issue is one deliverable that one agent can build and check in about an hour: a single function or a few closely related ones, never a whole milestone.
|
||||
- Give it a short title WITHOUT numbering prefix unless you are cutting a numbered milestone (then "M2.3 – Title"), a description of what must exist afterwards, and checkable facts (what someone sees in the running app). Do not repeat the spec; name the spec sections instead.
|
||||
- `scope` is one line naming exactly what is in scope (e.g. "M2.3 – Quotas (spec section 12)"); everything else in the spec is out of scope for that issue.
|
||||
- `depends` names the deliverables that must be merged first, or "none".
|
||||
- Order the issues so that each builds on the earlier ones. Point out gaps and contradictions in the spec instead of guessing.
|
||||
|
||||
When the user says the plan is done, end your message with exactly one fenced json block and nothing after it:
|
||||
```json
|
||||
{"decision": "issues", "spec": "docs/specs/<file>.md", "issues": [{"title": "…", "description": "…", "scope": "…", "depends": "…"}]}
|
||||
```
|
||||
The user reviews the list in a dialog and the issues are created from it."#;
|
||||
|
||||
/// The two tasks of an issue chat.
|
||||
fn issue_mode(mode: &str, topic: &str) -> String {
|
||||
if mode == "slice" {
|
||||
format!("Task: cut the milestone \"{topic}\" of the specification into single numbered deliverables (titles like \"{topic}.1 – …\", \"{topic}.2 – …\"). Read the milestone and every feature it names, check what the code already has, and propose the smallest sensible slices in build order. Show the user the list first and adjust it together before you finish.")
|
||||
} else {
|
||||
format!("Task: work out a new feature together with the user{}. Interview step by step (a few questions at a time): goal, users, behaviour and edge cases, how it fits the existing code, what is out of scope, how someone checks that it works. Then propose one or more issues; split a larger feature into deliverables that can be built one after the other.", if topic.trim().is_empty() { String::new() } else { format!(" – starting point: {topic}") })
|
||||
}
|
||||
}
|
||||
|
||||
/// Folder of an issue chat: <factory>/<user>/_issues/<id> (holds repo.txt with the repository URL).
|
||||
pub fn issue_chat_dir(app: &App, user: &User, id: &str) -> Result<std::path::PathBuf> {
|
||||
let home = app.factory_home(user).context("the factory area is not mounted (FACTORY_DIR → /factory)")?;
|
||||
Ok(home.join("_issues").join(id))
|
||||
}
|
||||
|
||||
/// Is this chat an issue chat of the user? Returns its folder.
|
||||
pub fn issue_chat_of(app: &App, user: &User, session: &crate::types::Session) -> Option<std::path::PathBuf> {
|
||||
let home = app.factory_home(user)?.join("_issues");
|
||||
let cwd = std::path::PathBuf::from(&session.cwd);
|
||||
(session.owner_id.as_deref() == Some(&user.id) && cwd.starts_with(&home) && cwd != home).then_some(cwd)
|
||||
}
|
||||
|
||||
/// Start an issue chat for a repository. mode: "feature" or "slice" (topic = the milestone).
|
||||
pub async fn start_issue_chat(app: &Arc<App>, user: &User, cfg: &RepoCfg, model: &str, mode: &str, topic: &str) -> Result<crate::types::Session> {
|
||||
if mode == "slice" && topic.trim().is_empty() {
|
||||
bail!("name the milestone to cut (e.g. M2)");
|
||||
}
|
||||
let repo = checkout(app, user, cfg).await?;
|
||||
let id = crate::types::new_id();
|
||||
let dir = issue_chat_dir(app, user, &id)?;
|
||||
std::fs::create_dir_all(&dir)?;
|
||||
std::fs::write(dir.join("repo.txt"), &cfg.url)?;
|
||||
let model = Some(model.to_string()).filter(|m| !m.is_empty()).or_else(|| Some(app.config().server.default_model.clone()).filter(|m| !m.is_empty())).or_else(|| app.registry().first_model()).context("no model configured")?;
|
||||
let (_, _, name) = cfg.parts()?;
|
||||
let now = crate::types::now_ms();
|
||||
let session = crate::types::Session {
|
||||
id,
|
||||
title: format!("Factory – issues – {name}"),
|
||||
cwd: dir.display().to_string(),
|
||||
model,
|
||||
agent: "build".into(),
|
||||
permission_mode: "default".into(),
|
||||
parent_id: None,
|
||||
owner_id: Some(user.id.clone()),
|
||||
created_at: now,
|
||||
updated_at: now,
|
||||
todos: Value::Null,
|
||||
last_usage: None,
|
||||
clean_room: None,
|
||||
phase: None,
|
||||
worktree: None,
|
||||
pinned: false,
|
||||
archived: false,
|
||||
folder: Some(FACTORY_FOLDER.to_string()),
|
||||
instructions: ISSUE_INSTRUCTIONS.replace("{repo_dir}", &repo.display().to_string()).replace("{mode}", &issue_mode(mode, topic.trim())),
|
||||
telegram_quiet: true,
|
||||
summary: String::new(),
|
||||
color: None,
|
||||
icon: None,
|
||||
};
|
||||
app.save_session(session)
|
||||
}
|
||||
|
||||
/// The issue list the model ended its last message with.
|
||||
pub fn issue_proposal(app: &App, session_id: &str) -> Option<Value> {
|
||||
parse_result(&last_text(app, session_id)).filter(|v| v["decision"] == "issues" && v["issues"].is_array())
|
||||
}
|
||||
|
||||
/// Body of an issue made from a proposal: the description plus the lines the factory reads.
|
||||
pub fn issue_body(description: &str, spec: &str, scope: &str, depends: &str) -> String {
|
||||
let mut body = description.trim().to_string();
|
||||
body.push_str(&format!("\n\nSpec: {spec}"));
|
||||
if !scope.trim().is_empty() {
|
||||
body.push_str(&format!("\nScope: {}", scope.trim().replace('\n', " ")));
|
||||
}
|
||||
let d = depends.trim();
|
||||
if !d.is_empty() && !d.eq_ignore_ascii_case("none") && !d.eq_ignore_ascii_case("keine") {
|
||||
body.push_str(&format!("\n\nPrerequisite: {d} – merge it first, then start this issue."));
|
||||
}
|
||||
body.push('\n');
|
||||
body
|
||||
}
|
||||
|
||||
/// Create the issues on the forge; with `start` they get the factory label (the workflow starts).
|
||||
pub async fn create_issues(cfg: &RepoCfg, spec: &str, issues: &[Value], start: bool) -> Result<Vec<Value>> {
|
||||
let spec = spec.trim();
|
||||
if spec.is_empty() || spec.starts_with('/') || spec.contains("..") {
|
||||
bail!("the spec path is missing or invalid");
|
||||
}
|
||||
let g = Forge::new(cfg)?;
|
||||
if start {
|
||||
g.ensure_labels().await?;
|
||||
}
|
||||
let mut out = Vec::new();
|
||||
for i in issues {
|
||||
let title = i["title"].as_str().unwrap_or("").trim();
|
||||
if title.is_empty() {
|
||||
bail!("an issue has no title");
|
||||
}
|
||||
let body = issue_body(i["description"].as_str().unwrap_or(""), spec, i["scope"].as_str().unwrap_or(""), i["depends"].as_str().unwrap_or(""));
|
||||
let labels = if start { vec![cfg.label.clone()] } else { Vec::new() };
|
||||
let r = g.create_issue(title, &body, &labels).await?;
|
||||
out.push(json!({"number": issue_no(&r), "title": title, "url": r["html_url"]}));
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
// --- spec chat and project creation ---------------------------------------------------
|
||||
|
||||
/// Instructions of the chat in which the user writes a spec together with a model.
|
||||
@@ -1495,6 +1684,19 @@ mod tests {
|
||||
assert!(SPEC_INSTRUCTIONS.contains("setup.json"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn issue_body_carries_the_factory_lines() {
|
||||
let b = issue_body("Do X.", "docs/specs/a.md", "M2.1 – X (section 3)", "M1.4");
|
||||
assert!(b.contains("Spec: docs/specs/a.md") && b.contains("Scope: M2.1 – X (section 3)") && b.contains("Prerequisite: M1.4"));
|
||||
assert!(!issue_body("Do X.", "a.md", "", "none").contains("Prerequisite"));
|
||||
assert_eq!(spec_path(&json!({"body": b})).as_deref(), Some("docs/specs/a.md"));
|
||||
assert!(issue_mode("slice", "M2").contains("\"M2.1 – …\""));
|
||||
let p = ISSUE_INSTRUCTIONS.replace("{repo_dir}", "/f/r");
|
||||
assert!(p.contains("/f/r") && p.contains("\"decision\": \"issues\""));
|
||||
let t = "Fertig.\n```json\n{\"decision\": \"issues\", \"spec\": \"a.md\", \"issues\": []}\n```";
|
||||
assert!(parse_result(t).is_some_and(|v| v["decision"] == "issues"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn encodes_labels() {
|
||||
assert_eq!(urlenc("factory:qa"), "factory%3Aqa");
|
||||
|
||||
Reference in new issue
Block a user