yardlet 0.5.1

Yardlet: a local AI workbench. Plan, queue, route, validate, and hand off long-running work using your already-installed Codex and Claude Code CLIs as hidden workers.
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

//! `yardlet init`: scaffold canonical `.agents/` state into a workspace.

use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
use std::path::Path;

use anyhow::{bail, Result};
use chrono::Utc;

use crate::schemas::YardConfig;
use crate::state::{self, write_str, Workspace, STATE_DIR};
use crate::templates;

pub fn init(root: &Path, force: bool) -> Result<Vec<String>> {
    let ws = Workspace::at(root);
    if ws.is_initialized() && !force {
        bail!(
            "this workspace already has {}/yardlet.yaml. Use --force to overwrite policy templates.",
            STATE_DIR
        );
    }

    let mut written = Vec::new();
    let agents = ws.agents_dir();
    std::fs::create_dir_all(&agents)?;
    std::fs::create_dir_all(ws.runs_dir())?;
    std::fs::create_dir_all(ws.checkpoints_dir())?;
    std::fs::create_dir_all(ws.handoffs_dir())?;

    // Dynamic config.
    let config = YardConfig {
        schema_version: 1,
        product: "yardlet".to_string(),
        workspace_id: workspace_id(root),
        created_at: Utc::now().to_rfc3339(),
        state_dir: STATE_DIR.to_string(),
        default_interface: "tui".to_string(),
        canonical_queue: format!("{STATE_DIR}/work-queue.yaml"),
        current_intent: format!("{STATE_DIR}/intent-contract.yaml"),
        language: "auto".to_string(),
        default_access: "sandboxed".to_string(),
        max_parallel: 1,
        auto_ime: true,
        harness_discovery: true,
        ambiguity_gate: true,
        skill_library: String::new(),
        auto_equip: true,
        auto_skill: true,
        auto_rule: true,
        auto_prune: true,
        hooks: true,
    };
    state::save_yaml(&ws.config_path(), &config)?;
    written.push("yardlet.yaml".to_string());

    // Static templates.
    let files: &[(&str, &str)] = &[
        ("billing-policy.yaml", templates::BILLING_POLICY),
        ("tool-policy.yaml", templates::TOOL_POLICY),
        ("approval-policy.yaml", templates::APPROVAL_POLICY),
        ("interaction-policy.yaml", templates::INTERACTION_POLICY),
        ("research-policy.yaml", templates::RESEARCH_POLICY),
        ("workers.yaml", templates::WORKERS),
        ("work-queue.yaml", templates::WORK_QUEUE),
    ];
    for (name, body) in files {
        let path = agents.join(name);
        if path.exists() && !force {
            continue;
        }
        write_str(&path, body)?;
        written.push((*name).to_string());
    }

    let skill = agents.join("skills/planning-gate/SKILL.md");
    if !skill.exists() || force {
        write_str(&skill, templates::PLANNING_GATE_SKILL)?;
        written.push("skills/planning-gate/SKILL.md".to_string());
    }

    // H3 hooks: create the (empty) hook dirs and a documented README so the
    // feature is discoverable. Yardlet ships no enabled hooks — only the docs.
    std::fs::create_dir_all(agents.join("hooks/pre-run.d"))?;
    std::fs::create_dir_all(agents.join("hooks/post-run.d"))?;
    let hooks_readme = agents.join("hooks/README.md");
    if !hooks_readme.exists() || force {
        write_str(&hooks_readme, templates::HOOKS_README)?;
        written.push("hooks/README.md".to_string());
    }

    Ok(written)
}

/// Resolve a workspace, creating `.agents/` state on first use if none exists
/// in this directory or any parent. Returns `(workspace, just_created)`.
///
/// This is what makes `yardlet` work in a fresh directory without a separate
/// setup step: like the worker CLIs, it initializes on demand.
pub fn ensure_initialized(cwd: &Path) -> Result<(Workspace, bool)> {
    if let Some(ws) = Workspace::discover(cwd) {
        return Ok((ws, false));
    }
    init(cwd, false)?;
    Ok((Workspace::at(cwd), true))
}

/// A stable id derived from the canonical workspace path.
fn workspace_id(root: &Path) -> String {
    let canonical = std::fs::canonicalize(root).unwrap_or_else(|_| root.to_path_buf());
    let mut hasher = DefaultHasher::new();
    canonical.hash(&mut hasher);
    format!("ws-{:016x}", hasher.finish())
}