difflore-core 0.2.0

Core library for the difflore CLI — rule store, retrieval, MCP server, hooks, cloud sync. Not intended for direct use; depend on `difflore-cli` instead.
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
133
134
135
136
137
138
139
140
141

//! Team rule-publish / cloud-id mapping tests.
//!
//! Moved out of the inline `mod tests` in `team/mod.rs` (R4) — a pure
//! positional move, no test logic changed. `super::cloud_id` / `super::types`
//! still resolve to the sibling `team` submodules exactly as before.

use super::cloud_id::{
    build_rule_create_body, resolve_cloud_rule_id_for_unpublish, rule_cloud_mapping_key,
};
use super::types::{LocalRuleUploadRow, TeamRulePublishInput};
use sqlx::SqlitePool;
use uuid::Uuid;

async fn setup_migrated_pool() -> SqlitePool {
    let pool = sqlx::sqlite::SqlitePoolOptions::new()
        .max_connections(1)
        .connect("sqlite::memory:")
        .await
        .expect("open in-memory pool");
    sqlx::migrate!("./migrations")
        .run(&pool)
        .await
        .expect("apply migrations");
    pool
}

#[test]
fn rule_create_body_preserves_local_origin() {
    let row = LocalRuleUploadRow {
        name: "Prefer structured logs".into(),
        rule_type: "review_standard".into(),
        description: "Use logger.info instead of println.".into(),
        version: "1.0.0".into(),
        engines_json: r#"["claude"]"#.into(),
        tags_json: r#"["conversation"]"#.into(),
        trigger: None,
        check_prompt: Some("Check logging calls".into()),
        file_patterns_json: Some(r#"["**/*.rs"]"#.into()),
        origin: "conversation".into(),
        source_repo: Some("acme/widgets".into()),
    };

    let body = build_rule_create_body(&row);
    assert_eq!(body["origin"].as_str(), Some("conversation"));
    assert_eq!(body["content"].as_str(), Some(row.description.as_str()));
    assert_eq!(body["visibility"].as_str(), Some("team"));
    assert_eq!(body["filePatterns"][0].as_str(), Some("**/*.rs"));
    assert_eq!(body["sourceRepo"].as_str(), Some("acme/widgets"));
}

#[test]
fn rule_create_body_falls_back_to_name_for_empty_content() {
    let row = LocalRuleUploadRow {
        name: "Name only".into(),
        rule_type: "skill".into(),
        description: "  ".into(),
        version: "1.0.0".into(),
        engines_json: "[]".into(),
        tags_json: "[]".into(),
        trigger: None,
        check_prompt: None,
        file_patterns_json: None,
        origin: "manual".into(),
        source_repo: None,
    };

    let body = build_rule_create_body(&row);
    assert_eq!(body["content"].as_str(), Some("Name only"));
    assert_eq!(body["origin"].as_str(), Some("manual"));
}

#[tokio::test]
async fn unpublish_resolves_slug_from_auth_mapping() {
    let pool = setup_migrated_pool().await;
    let cloud_id = Uuid::new_v4().to_string();
    let key = rule_cloud_mapping_key("conv-example-12345678");
    sqlx::query!(
        "INSERT INTO auth (key, value) VALUES (?1, ?2)",
        key,
        cloud_id
    )
    .execute(&pool)
    .await
    .expect("seed auth mapping");

    let resolved = resolve_cloud_rule_id_for_unpublish(&pool, "conv-example-12345678")
        .await
        .expect("resolve cloud rule id");
    assert_eq!(resolved, cloud_id);
}

#[tokio::test]
async fn unpublish_resolves_slug_from_cloud_id_column_when_present() {
    let pool = setup_migrated_pool().await;
    let cloud_id = Uuid::new_v4().to_string();
    sqlx::query!(
        "INSERT INTO skills (id, name, source, directory, version, cloud_id) \
         VALUES (?1, 'n', 's', 'd', '1.0.0', ?2)",
        "local-example",
        cloud_id
    )
    .execute(&pool)
    .await
    .expect("seed skill row");

    let resolved = resolve_cloud_rule_id_for_unpublish(&pool, "local-example")
        .await
        .expect("resolve via cloud_id column");
    assert_eq!(resolved, cloud_id);
}

#[tokio::test]
async fn unpublish_missing_slug_mapping_is_not_found() {
    let pool = setup_migrated_pool().await;

    let err = resolve_cloud_rule_id_for_unpublish(&pool, "conv-missing-12345678")
        .await
        .expect_err("expected NotFound");
    assert!(
        err.to_string().contains("publish"),
        "unexpected error: {err}"
    );
}

// `origin` must travel up on the wire so the cloud Dashboard sees the
// input-channel provenance of published rules.
#[test]
fn team_rule_publish_input_includes_origin_on_wire() {
    let input = TeamRulePublishInput {
        rule_id: "rule-1".into(),
        enforcement: Some("required".into()),
        team_id: Some("t1".into()),
        origin: Some("conversation".into()),
    };
    let json = serde_json::to_value(&input).unwrap();
    assert_eq!(json.get("ruleId").and_then(|v| v.as_str()), Some("rule-1"));
    assert_eq!(
        json.get("origin").and_then(|v| v.as_str()),
        Some("conversation")
    );
}