rigg 0.17.0

Configuration-as-code CLI for Azure AI Search and Microsoft Foundry
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
142
143
144
145
146
147
148
149

//! Copy a knowledge source and all its managed sub-resources under new names.

use anyhow::{Result, bail};
use colored::Colorize;

use rigg_core::copy::{NameMap, rewrite_references};
use rigg_core::normalize::format_json;
use rigg_core::resources::ResourceKind;
use rigg_core::resources::managed;

use super::rewrite::{rewrite_created_resources, rewrite_index_projections};

/// Copy a knowledge source and all its managed sub-resources under new names.
pub(super) fn copy_knowledge_source(
    service_dir: &std::path::Path,
    source: &str,
    target: &str,
) -> Result<()> {
    let ks_base = service_dir.join("agentic-retrieval/knowledge-sources");
    let source_dir = ks_base.join(source);
    let target_dir = ks_base.join(target);

    if !source_dir.exists() {
        bail!(
            "Knowledge source '{}' not found at {}",
            source,
            source_dir.display()
        );
    }
    if target_dir.exists() {
        bail!(
            "Target '{}' already exists at {}",
            target,
            target_dir.display()
        );
    }

    // Read source KS definition
    let ks_file = source_dir.join(format!("{}.json", source));
    if !ks_file.exists() {
        bail!("KS definition not found at {}", ks_file.display());
    }
    let ks_content = std::fs::read_to_string(&ks_file)?;
    let ks_def: serde_json::Value = serde_json::from_str(&ks_content)?;

    // Extract managed resources to build name map
    let managed = managed::extract_managed_resources(source, &ks_def);

    let mut name_map = NameMap::new();
    name_map.insert(ResourceKind::KnowledgeSource, source, target);

    if let Some(ref old_name) = managed.index {
        let new_name = old_name.replacen(source, target, 1);
        name_map.insert(ResourceKind::Index, old_name, &new_name);
    }
    if let Some(ref old_name) = managed.indexer {
        let new_name = old_name.replacen(source, target, 1);
        name_map.insert(ResourceKind::Indexer, old_name, &new_name);
    }
    if let Some(ref old_name) = managed.datasource {
        let new_name = old_name.replacen(source, target, 1);
        name_map.insert(ResourceKind::DataSource, old_name, &new_name);
    }
    if let Some(ref old_name) = managed.skillset {
        let new_name = old_name.replacen(source, target, 1);
        name_map.insert(ResourceKind::Skillset, old_name, &new_name);
    }

    // Create target directory
    std::fs::create_dir_all(&target_dir)?;

    println!("Copying knowledge source '{}' -> '{}':", source, target);

    // Copy and rewrite KS definition
    let mut new_ks_def = ks_def.clone();
    if let Some(obj) = new_ks_def.as_object_mut() {
        obj.insert(
            "name".to_string(),
            serde_json::Value::String(target.to_string()),
        );
    }
    let warnings = rewrite_references(ResourceKind::KnowledgeSource, &mut new_ks_def, &name_map);
    for w in &warnings {
        println!("  {} {}", "warning:".yellow(), w);
    }
    rewrite_created_resources(&mut new_ks_def, source, target);

    std::fs::write(
        target_dir.join(format!("{}.json", target)),
        format_json(&new_ks_def),
    )?;
    println!("  {} Knowledge Source '{}'", "+".green(), target);

    // Copy and rewrite managed sub-resources
    let suffixes = [
        ("index", ResourceKind::Index),
        ("indexer", ResourceKind::Indexer),
        ("datasource", ResourceKind::DataSource),
        ("skillset", ResourceKind::Skillset),
    ];

    for (suffix, kind) in &suffixes {
        let source_file = source_dir.join(format!("{}-{}.json", source, suffix));
        if !source_file.exists() {
            continue;
        }

        let content = std::fs::read_to_string(&source_file)?;
        let mut def: serde_json::Value = serde_json::from_str(&content)?;

        let old_name = def
            .get("name")
            .and_then(|n| n.as_str())
            .unwrap_or("")
            .to_string();
        let new_name = name_map
            .get(*kind, &old_name)
            .map(|s| s.to_string())
            .unwrap_or_else(|| old_name.replacen(source, target, 1));

        // Update name field
        if let Some(obj) = def.as_object_mut() {
            obj.insert(
                "name".to_string(),
                serde_json::Value::String(new_name.clone()),
            );
        }

        // Rewrite cross-references (e.g., indexer's dataSourceName, targetIndexName)
        let warnings = rewrite_references(*kind, &mut def, &name_map);
        for w in &warnings {
            println!("  {} {}", "warning:".yellow(), w);
        }

        // For skillsets, also rewrite indexProjections.selectors[].targetIndexName
        if *kind == ResourceKind::Skillset {
            rewrite_index_projections(&mut def, source, target);
        }

        let target_filename = format!("{}-{}.json", target, suffix);
        std::fs::write(target_dir.join(&target_filename), format_json(&def))?;
        println!("  {} {} '{}'", "+".green(), kind.display_name(), new_name);
    }

    println!();
    println!("Copy complete. Run 'rigg push --knowledgesources' to push to Azure.");

    Ok(())
}