pushkin 0.2.1

Schema-first enforcement harness that gates AI coding agents' file writes against project contracts
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

//! Phase 3 task 3: per-dir AGENTS.md marker injection (spec §15 Phase 3;
//! addendum §6 standing-file row). Committed first, read-only hereafter
//! (charter §4.1). The managed block renders from the manifest — the same
//! single source of truth as `instructions --digest` — between pushkin
//! markers; user content outside the markers is never touched, and
//! `init --remove-agent agents-md` strips exactly the block.

use assert_cmd::Command;
use std::fs;

const MANIFEST: &str = r#"
version = 1
canonical = "json-schema-2020-12"
authoring = "zod"

[[contracts]]
name = "user"
source = "contracts/user.zod.ts"
emit = ["zod"]

[[mappings]]
glob = "app/api/**/*.ts"
contracts = ["user"]
require = "boundary-validation"

[gates]
protected_paths = ["pushkin.toml"]
"#;

fn repo() -> std::io::Result<tempfile::TempDir> {
    let dir = tempfile::tempdir()?;
    fs::write(dir.path().join("pushkin.toml"), MANIFEST)?;
    Ok(dir)
}

fn run(dir: &tempfile::TempDir, args: &[&str]) -> (i32, String) {
    let Ok(mut command) = Command::cargo_bin("pushkin") else {
        return (-1, "cargo_bin resolution failed".to_owned());
    };
    let Ok(output) = command.current_dir(dir.path()).args(args).output() else {
        return (-1, "spawn failed".to_owned());
    };
    (
        output.status.code().unwrap_or(-1),
        format!(
            "{}{}",
            String::from_utf8_lossy(&output.stdout),
            String::from_utf8_lossy(&output.stderr)
        ),
    )
}

#[test]
fn agents_md_managed_block_written_between_markers() {
    let dir = repo().unwrap();
    let (code, output) = run(&dir, &["init", "--agent", "agents-md"]);
    assert_eq!(code, 0, "install succeeds: {output}");
    let agents = fs::read_to_string(dir.path().join("AGENTS.md")).unwrap();
    assert!(
        agents.contains("<!-- pushkin:begin"),
        "begin marker present: {agents}"
    );
    assert!(
        agents.contains("<!-- pushkin:end"),
        "end marker present: {agents}"
    );
    assert!(
        agents.contains("app/api/**/*.ts"),
        "block carries manifest facts (single source of truth): {agents}"
    );
}

#[test]
fn user_content_outside_markers_preserved() {
    let dir = repo().unwrap();
    fs::write(
        dir.path().join("AGENTS.md"),
        "# Team rules\n\nAlways use conventional commits.\n",
    )
    .unwrap();

    run(&dir, &["init", "--agent", "agents-md"]);
    let agents = fs::read_to_string(dir.path().join("AGENTS.md")).unwrap();
    assert!(
        agents.contains("Always use conventional commits."),
        "user content preserved: {agents}"
    );
    assert!(
        agents.contains("<!-- pushkin:begin"),
        "block appended alongside user content: {agents}"
    );
}

#[test]
fn managed_block_regenerates_deterministically() {
    let dir = repo().unwrap();
    fs::write(dir.path().join("AGENTS.md"), "# Team rules\n").unwrap();

    run(&dir, &["init", "--agent", "agents-md"]);
    let first = fs::read_to_string(dir.path().join("AGENTS.md")).unwrap();
    run(&dir, &["init", "--agent", "agents-md"]);
    let second = fs::read_to_string(dir.path().join("AGENTS.md")).unwrap();
    assert_eq!(
        first, second,
        "reinstall replaces the block in place — byte-identical, never stacked"
    );
    let marker_count = second.matches("<!-- pushkin:begin").count();
    assert_eq!(marker_count, 1, "exactly one managed block");
}

#[test]
fn remove_strips_only_managed_block() {
    let dir = repo().unwrap();
    fs::write(
        dir.path().join("AGENTS.md"),
        "# Team rules\n\nAlways use conventional commits.\n",
    )
    .unwrap();

    run(&dir, &["init", "--agent", "agents-md"]);
    let (code, output) = run(&dir, &["init", "--remove-agent", "agents-md"]);
    assert_eq!(code, 0, "remove succeeds: {output}");
    let agents = fs::read_to_string(dir.path().join("AGENTS.md")).unwrap();
    assert!(
        !agents.contains("pushkin:begin"),
        "managed block gone: {agents}"
    );
    assert!(
        agents.contains("Always use conventional commits."),
        "user content survives removal: {agents}"
    );
}