vtcode 0.99.1

A Rust-based terminal coding agent with modular architecture supporting multiple LLM providers
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

use anyhow::Result;
use itertools::Itertools;
use std::path::Path;
use vtcode_core::config::types::AgentConfig as CoreAgentConfig;
use vtcode_core::utils::colors::style;
use vtcode_core::utils::file_utils::{
    ensure_dir_exists, ensure_dir_exists_sync, write_file_with_context_sync,
};

/// Handle the create-project command
pub async fn handle_create_project_command(
    config: &CoreAgentConfig,
    name: &str,
    features: &[String],
) -> Result<()> {
    println!("{}", style("[CREATE]").cyan().bold());
    println!("  {:16} {}", "name", name);
    println!("  {:16} {}", "workspace", config.workspace.display());
    if !features.is_empty() {
        println!("  {:16} {}\n", "features", features.join(", "));
    } else {
        println!();
    }

    // Project creation implementation
    let project_path = config.workspace.join(name);

    // Create project directory
    ensure_dir_exists(&project_path).await?;
    println!("Created project directory: {}", project_path.display());

    // Create basic project structure based on features
    create_project_structure(&project_path, features)?;

    // Create vtcode configuration
    create_vtcode_config(&project_path)?;

    println!("Project '{}' created successfully!", name);

    Ok(())
}

/// Create project structure based on selected features
fn create_project_structure(project_path: &Path, features: &[String]) -> Result<()> {
    // Create src directory
    let src_path = project_path.join("src");
    ensure_dir_exists_sync(&src_path)?;

    // Create main file (simple template; extend later for feature-specific scaffolds)
    let main_content = r#"fn main() {
    println!("Hello, world!");
}
"#;

    write_file_with_context_sync(&src_path.join("main.rs"), main_content, "main.rs")?;

    // Create README.md
    let readme_content = format!(
        r#"# Project

This is a new project created with VT Code.

## Features

{}"#,
        features.iter().map(|f| format!("- {}\n", f)).join("")
    );

    write_file_with_context_sync(
        &project_path.join("README.md"),
        &readme_content,
        "README.md",
    )?;

    // Create Cargo.toml for Rust projects
    let cargo_content = r#"[package]
name = "project"
version = "0.1.0"
edition = "2021"

[dependencies]
"#;

    write_file_with_context_sync(
        &project_path.join("Cargo.toml"),
        cargo_content,
        "Cargo.toml",
    )?;

    Ok(())
}

/// Create vtcode configuration file
fn create_vtcode_config(project_path: &Path) -> Result<()> {
    let config_content = r#"# VT Code Configuration
[model]
name = "gemini-3-flash-preview"

[workspace]
path = "."

[agent]
verbose = false
"#;

    write_file_with_context_sync(
        &project_path.join("vtcode.toml"),
        config_content,
        "vtcode.toml",
    )?;
    Ok(())
}