syncable-cli 0.37.1

A Rust-based CLI that analyzes code repositories and generates Infrastructure as Code configurations
Documentation 
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

use crate::analyzer::{
    AnalysisConfig, BuildScript, DetectedLanguage, DetectedTechnology, EntryPoint, EnvVar, Port,
    ProjectType,
};
use crate::error::Result;
use std::collections::{HashMap, HashSet};
use std::path::Path;

use super::file_analyzers::{docker, env, makefile};
use super::language_analyzers::{go, javascript, jvm, python, rust};
use super::microservices;
use super::project_type;
use super::tech_specific;

/// Project context information
pub struct ProjectContext {
    pub entry_points: Vec<EntryPoint>,
    pub ports: Vec<Port>,
    pub environment_variables: Vec<EnvVar>,
    pub project_type: ProjectType,
    pub build_scripts: Vec<BuildScript>,
}

/// Analyzes project context including entry points, ports, and environment variables
pub fn analyze_context(
    project_root: &Path,
    languages: &[DetectedLanguage],
    technologies: &[DetectedTechnology],
    config: &AnalysisConfig,
) -> Result<ProjectContext> {
    log::info!("Analyzing project context");

    let mut entry_points = Vec::new();
    let mut ports = HashSet::new();
    let mut env_vars = HashMap::new();
    let mut build_scripts = Vec::new();

    // Analyze based on detected languages
    for language in languages {
        match language.name.as_str() {
            "JavaScript" | "TypeScript" => {
                javascript::analyze_node_project(
                    project_root,
                    &mut entry_points,
                    &mut ports,
                    &mut env_vars,
                    &mut build_scripts,
                    config,
                )?;
            }
            "Python" => {
                python::analyze_python_project(
                    project_root,
                    &mut entry_points,
                    &mut ports,
                    &mut env_vars,
                    &mut build_scripts,
                    config,
                )?;
            }
            "Rust" => {
                rust::analyze_rust_project(
                    project_root,
                    &mut entry_points,
                    &mut ports,
                    &mut env_vars,
                    &mut build_scripts,
                    config,
                )?;
            }
            "Go" => {
                go::analyze_go_project(
                    project_root,
                    &mut entry_points,
                    &mut ports,
                    &mut env_vars,
                    &mut build_scripts,
                    config,
                )?;
            }
            "Java" | "Kotlin" => {
                jvm::analyze_jvm_project(
                    project_root,
                    &mut ports,
                    &mut env_vars,
                    &mut build_scripts,
                    config,
                )?;
            }
            _ => {}
        }
    }

    // Analyze common configuration files
    docker::analyze_docker_files(project_root, &mut ports, &mut env_vars)?;
    env::analyze_env_files(project_root, &mut env_vars)?;
    makefile::analyze_makefile(project_root, &mut build_scripts)?;

    // Technology-specific analysis
    for technology in technologies {
        tech_specific::analyze_technology_specifics(
            technology,
            project_root,
            &mut entry_points,
            &mut ports,
        )?;
    }

    // Detect microservices structure
    let microservices = microservices::detect_microservices_structure(project_root)?;

    // Determine project type
    let ports_vec: Vec<Port> = ports.iter().cloned().collect();
    let project_type = project_type::determine_project_type_with_structure(
        languages,
        technologies,
        &entry_points,
        &ports_vec,
        &microservices,
    );

    // Convert collections to vectors
    let ports: Vec<Port> = ports.into_iter().collect();
    let environment_variables: Vec<EnvVar> = env_vars
        .into_iter()
        .map(|(name, (default, required, desc))| EnvVar {
            name,
            default_value: default,
            required,
            description: desc,
        })
        .collect();

    Ok(ProjectContext {
        entry_points,
        ports,
        environment_variables,
        project_type,
        build_scripts,
    })
}