add

Author: 文思为

config/config.toml

@@ -26,7 +26,7 @@ password = "123456"
 
 [assist]
 # base_url = "http://117.72.103.91:8888"
-base_url = "http://127.0.0.1:8888"
+base_url = "https://analyze.warpparse.ai"
 
 [warparse]
 enabled = false

src/api/project.rs

@@ -1,8 +1,8 @@
-use actix_web::{HttpRequest, HttpResponse, post};
+use actix_web::{HttpRequest, HttpResponse, post, web};
 use urlencoding::decode;
 
 use crate::error::AppError;
-use crate::server::project::import_project_from_files_logic;
+use crate::server::project::{ProjectImportRequest, import_project_from_files_logic};
 
 fn operator_from_request(req: &HttpRequest) -> Option<String> {
     req.headers().get("x-operator").and_then(|value| {
@@ -18,8 +18,11 @@ fn operator_from_request(req: &HttpRequest) -> Option<String> {
 }
 
 #[post("/api/project/import")]
-pub async fn import_project_from_files(http_req: HttpRequest) -> Result<HttpResponse, AppError> {
+pub async fn import_project_from_files(
+    http_req: HttpRequest,
+    req: web::Json<ProjectImportRequest>,
+) -> Result<HttpResponse, AppError> {
     let operator = operator_from_request(&http_req);
-    let resp = import_project_from_files_logic(operator).await?;
+    let resp = import_project_from_files_logic(operator, req.into_inner()).await?;
     Ok(HttpResponse::Ok().json(resp))
 }

src/db/default_rules_loader.rs

@@ -1,4 +1,5 @@
 use crate::error::AppError;
+use crate::server::Setting;
 use crate::utils::project::resolve_project_root;
 use rust_embed::RustEmbed;
 use std::{
@@ -65,9 +66,7 @@ fn init_default_configs_with_mappings(
 }
 
 pub fn runtime_default_configs_dir() -> Option<PathBuf> {
-    let candidate = std::env::current_dir()
-        .unwrap_or_else(|_| PathBuf::from("."))
-        .join("default_configs");
+    let candidate = Setting::workspace_root().join("default_configs");
 
     if candidate.is_dir() {
         Some(candidate)

src/server/project.rs

@@ -1,20 +1,28 @@
-use std::path::PathBuf;
+use std::ffi::OsStr;
+use std::fs;
+use std::path::{Path, PathBuf};
 
 use chrono::Utc;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
 use crate::db::RuleType;
 use crate::error::AppError;
-use crate::server::ProjectLayout;
 use crate::server::sync::sync_to_gitea_all;
 use crate::server::{
-    OperationLogAction, OperationLogBiz, OperationLogParams, Setting,
+    OperationLogAction, OperationLogBiz, OperationLogParams, ProjectLayout, Setting,
     write_operation_log_for_result,
 };
 use crate::utils::knowledge::reload_knowledge;
-use crate::utils::project_check::check_component;
+use crate::utils::project_check::check_component_in_dir;
 use crate::utils::{ProjectSnapshot, load_project_snapshot_from_layout};
 
+const LEGACY_REQUIRED_DIRS: [&str; 4] = ["conf", "connectors", "topology", "models"];
+
+#[derive(Debug, Deserialize)]
+pub struct ProjectImportRequest {
+    pub source_dir: String,
+}
+
 #[derive(Serialize)]
 pub struct ProjectImportResponse {
     pub summary: ProjectImportSummary,
@@ -30,7 +38,9 @@ pub struct ProjectImportSummary {
     pub rule_breakdown: Vec<ProjectImportBreakdown>,
     pub warnings: Vec<String>,
     pub failed_files: usize,
-    pub project_root: String,
+    pub source_dir: String,
+    pub project_models: String,
+    pub project_infra: String,
 }
 
 #[derive(Serialize)]
@@ -47,22 +57,24 @@ pub struct ProjectImportValidation {
 
 pub async fn import_project_from_files_logic(
     operator: Option<String>,
+    req: ProjectImportRequest,
 ) -> Result<ProjectImportResponse, AppError> {
     let operator_for_log = operator.clone();
     let setting = Setting::load();
     let layout = setting.project_layout();
-    let project_path = resolve_project_path(&layout);
+    let source_dir = normalize_source_dir(&req.source_dir)?;
+
+    validate_legacy_project_dir(&source_dir)?;
+    check_component_in_dir(&source_dir, RuleType::All.to_check_component())?;
+    overwrite_project_layout_from_legacy_dir(&source_dir, &layout)?;
 
     let snapshot = load_project_snapshot_from_layout(&layout)?;
     if snapshot.rules.is_empty() && snapshot.knowledge.is_empty() {
         return Err(AppError::validation(
-            "项目目录中未找到可导入的规则或知识库".to_string(),
+            "导入后的项目目录中未找到可导入的规则或知识库".to_string(),
         ));
     }
 
-    // 文件已经是主数据源；这里先执行组件校验，避免坏配置进入后续同步/发布链路。
-    check_component(RuleType::All.to_check_component())?;
-
     let result = async {
         let ProjectSnapshot {
             rules,
@@ -99,12 +111,14 @@ pub async fn import_project_from_files_logic(
             rule_breakdown: breakdown,
             warnings,
             failed_files,
-            project_root: project_path.to_string_lossy().to_string(),
+            source_dir: source_dir.to_string_lossy().to_string(),
+            project_models: layout.models_root.to_string_lossy().to_string(),
+            project_infra: layout.infra_root.to_string_lossy().to_string(),
         };
 
         let validation = ProjectImportValidation {
             passed: true,
-            message: "项目组件校验通过".to_string(),
+            message: "目录拆分覆盖并校验通过".to_string(),
         };
 
         Ok::<_, AppError>(ProjectImportResponse {
@@ -118,6 +132,7 @@ pub async fn import_project_from_files_logic(
     if let Some(op) = operator_for_log {
         log_params = log_params.with_operator(op);
     }
+    log_params = log_params.with_field("source_dir", source_dir.to_string_lossy().to_string());
     if let Ok(ref resp) = result {
         log_params = log_params
             .with_field("rules_deleted", resp.summary.rules_deleted.to_string())
@@ -126,7 +141,8 @@ pub async fn import_project_from_files_logic(
                 "knowledge_imported",
                 resp.summary.knowledge_imported.to_string(),
             )
-            .with_field("project_root", resp.summary.project_root.clone());
+            .with_field("project_models", resp.summary.project_models.clone())
+            .with_field("project_infra", resp.summary.project_infra.clone());
     }
 
     write_operation_log_for_result(
@@ -140,14 +156,147 @@ pub async fn import_project_from_files_logic(
     result
 }
 
-fn resolve_project_path(layout: &ProjectLayout) -> PathBuf {
-    let base = Setting::workspace_root()
-        .join("tmp")
-        .join("project-import-view");
-    let summary = format!(
-        "{} + {}",
+fn normalize_source_dir(raw: &str) -> Result<PathBuf, AppError> {
+    let trimmed = raw.trim();
+    if trimmed.is_empty() {
+        return Err(AppError::validation("请输入待导入的源目录".to_string()));
+    }
+
+    let path = PathBuf::from(trimmed);
+    let normalized = if path.is_absolute() {
+        path
+    } else {
+        Setting::workspace_root().join(path)
+    };
+
+    if !normalized.is_dir() {
+        return Err(AppError::validation(format!(
+            "源目录不存在或不是目录: {}",
+            normalized.display()
+        )));
+    }
+
+    Ok(normalized)
+}
+
+fn validate_legacy_project_dir(source_dir: &Path) -> Result<(), AppError> {
+    let missing_dirs: Vec<String> = LEGACY_REQUIRED_DIRS
+        .iter()
+        .filter_map(|name| {
+            let path = source_dir.join(name);
+            if path.is_dir() {
+                None
+            } else {
+                Some((*name).to_string())
+            }
+        })
+        .collect();
+
+    if !missing_dirs.is_empty() {
+        return Err(AppError::validation(format!(
+            "源目录结构不完整，缺少必要目录: {}",
+            missing_dirs.join(", ")
+        )));
+    }
+
+    Ok(())
+}
+
+fn overwrite_project_layout_from_legacy_dir(
+    source_dir: &Path,
+    layout: &ProjectLayout,
+) -> Result<(), AppError> {
+    info!(
+        "开始按旧目录结构拆分覆盖双仓库: source_dir={}, models_dir={}, infra_dir={}",
+        source_dir.display(),
+        layout.models_root.display(),
+        layout.infra_root.display()
+    );
+
+    recreate_dir_preserving_git(&layout.models_root)?;
+    recreate_dir_preserving_git(&layout.infra_root)?;
+
+    copy_named_entry(source_dir, &layout.infra_root, "conf")?;
+    copy_named_entry(source_dir, &layout.infra_root, "connectors")?;
+    copy_named_entry(source_dir, &layout.infra_root, "topology")?;
+    copy_named_entry(source_dir, &layout.models_root, "models")?;
+
+    info!(
+        "旧目录拆分覆盖完成: source_dir={}, models_dir={}, infra_dir={}",
+        source_dir.display(),
         layout.models_root.display(),
         layout.infra_root.display()
     );
-    PathBuf::from(format!("{} ({})", base.display(), summary))
+    Ok(())
+}
+
+fn recreate_dir_preserving_git(target_dir: &Path) -> Result<(), AppError> {
+    fs::create_dir_all(target_dir).map_err(AppError::internal)?;
+
+    for entry in fs::read_dir(target_dir).map_err(AppError::internal)? {
+        let entry = entry.map_err(AppError::internal)?;
+        let path = entry.path();
+        if entry.file_name() == OsStr::new(".git") {
+            continue;
+        }
+
+        if path.is_dir() {
+            fs::remove_dir_all(&path).map_err(AppError::internal)?;
+        } else {
+            fs::remove_file(&path).map_err(AppError::internal)?;
+        }
+    }
+
+    Ok(())
+}
+
+fn copy_named_entry(source_root: &Path, target_root: &Path, name: &str) -> Result<(), AppError> {
+    let source = source_root.join(name);
+    if !source.exists() {
+        return Err(AppError::validation(format!(
+            "源目录缺少必要内容: {}",
+            source.display()
+        )));
+    }
+
+    let target = target_root.join(name);
+    if target.exists() {
+        if target.is_dir() {
+            fs::remove_dir_all(&target).map_err(AppError::internal)?;
+        } else {
+            fs::remove_file(&target).map_err(AppError::internal)?;
+        }
+    }
+
+    if source.is_dir() {
+        copy_dir_recursive(&source, &target)?;
+    } else {
+        if let Some(parent) = target.parent() {
+            fs::create_dir_all(parent).map_err(AppError::internal)?;
+        }
+        fs::copy(&source, &target).map_err(AppError::internal)?;
+    }
+
+    Ok(())
+}
+
+fn copy_dir_recursive(source_dir: &Path, target_dir: &Path) -> Result<(), AppError> {
+    fs::create_dir_all(target_dir).map_err(AppError::internal)?;
+
+    for entry in fs::read_dir(source_dir).map_err(AppError::internal)? {
+        let entry = entry.map_err(AppError::internal)?;
+        let source_path = entry.path();
+        let target_path = target_dir.join(entry.file_name());
+
+        if source_path.is_dir() {
+            copy_dir_recursive(&source_path, &target_path)?;
+        } else if source_path.is_file() {
+            if let Some(parent) = target_path.parent() {
+                fs::create_dir_all(parent).map_err(AppError::internal)?;
+            }
+            fs::copy(&source_path, &target_path).map_err(AppError::internal)?;
+        }
+    }
+
+    Ok(())
 }

src/server/sandbox_runner.rs

@@ -444,7 +444,10 @@ async fn stage_run_wpgen(
     metrics.input_count = count;
     metrics.wpgen_generated = Some(count);
 
-    Ok(format!("wpgen已启动, 已发送{}条消息", count))
+    Ok(format!(
+        "wpgen已启动, 已发送{}条消息。命令: {}",
+        count, output.command_line
+    ))
 }
 
 async fn stage_analyse_runtime_output(

src/server/sync.rs

@@ -32,8 +32,22 @@ fn repo_name_for_group(group: ReleaseGroup) -> &'static str {
     }
 }
 
+fn should_skip_gitea_sync() -> bool {
+    std::env::var("WARP_STATION_SKIP_GITEA")
+        .map(|value| value == "1" || value.eq_ignore_ascii_case("true"))
+        .unwrap_or(false)
+}
+
 /// 同步指定分组仓库到 Gitea（支持自动处理冲突）
 pub async fn sync_to_gitea(commit_message: &str, group: ReleaseGroup) {
+    if should_skip_gitea_sync() {
+        info!(
+            "跳过 Gitea 同步: group={}, reason=WARP_STATION_SKIP_GITEA",
+            group.as_ref()
+        );
+        return;
+    }
+
     let setting = Setting::load();
     let layout = setting.project_layout();
 
@@ -68,6 +82,11 @@ const REPO_BASELINE_TAG: &str = "baseline";
 
 /// 初始化双仓库 Gitea 仓库和基线 tag（系统首次启动且本地 .git 不存在时调用）
 pub async fn init_gitea_repo() -> Result<(), AppError> {
+    if should_skip_gitea_sync() {
+        info!("跳过 Gitea 仓库初始化: reason=WARP_STATION_SKIP_GITEA");
+        return Ok(());
+    }
+
     let setting = Setting::load();
     let layout = setting.project_layout();
     let gitea_client = build_gitea_client(&setting)