feat(web): REQ-303 web 采集阶段1内核（URL 采集+kind=web+转笔记）

Author: Aparencia

app/src-tauri/src/commands_session_note.rs

@@ -189,6 +189,14 @@ fn convert_to_note(
     // v0.20.2（REQ-269）：已确认 ASR 混淆纠错规则（产物文本共现纠错层）
     asr_rules: &[crate::asr_confusion::AsrRule],
 ) -> Result<Note, String> {
+    // v0.20.4（REQ-303）：web 会话走专用管线——正文 MD 直落（不走口语过滤链）
+    if db
+        .get_session(id)
+        .map_err(|e| e.to_string())?
+        .is_some_and(|s| s.kind.as_deref() == Some("web"))
+    {
+        return crate::commands_web::web_session_to_note_core(db, id);
+    }
     // v0.11.0：取草稿同时拿 analysis（章节/术语——结构密度路由信号，免二次分析）
     let (mut result, analysis) =
         build_rule_draft_with_analysis(db, ui_junk, env, data_dir, id, title)?;

app/src-tauri/src/commands_web.rs

@@ -0,0 +1,187 @@
+//! web 采集命令面（v0.20.4 / REQ-303 阶段 1 内核）。
+//!
+//! @ai-context: URL 采集 = 课堂助手动线「URL 采集」→ 本地抽取管线（ureq 静态
+//!              直取 + 轻量规则转 MD）→ kind='web' 会话 + web_session_pages
+//!              页面（正文整篇初稿/元数据/raw_html 降级附件）；转笔记复用
+//!              会话↔笔记通道（session_to_note 对 kind=web 走 web 专用管线：
+//!              正文 MD 直落 + properties 元数据 + 标题锚点回链）。
+//! @ai-context: 失败语义（Foresight 兜底链）：网络/解析失败返回明确错误且
+//!              不产生半成品会话；正文抽取过少 → extracted_ok=0 保留 raw_html
+//!              附件可再处理。SPA/登录墙缺口由阶段 2 扩展覆盖。
+//! @ai-context: 安全：仅 http/https、5MB 上限、UA 标识、15s 总超时；URL 只作
+//!              出站读，不落执行上下文。
+
+use serde::Serialize;
+use std::time::Duration;
+use tauri::State;
+
+use crate::commands::AppState;
+use crate::db_web::WebPage;
+use crate::types::NewNote;
+use crate::web_capture::extract_page;
+
+/// 抓取体量上限（防超大响应拖垮内存/耗时）。
+const FETCH_MAX_BYTES: usize = 5 * 1024 * 1024;
+/// 单次抓取超时（网络兜底——不可达快速报错）。
+const FETCH_TIMEOUT: Duration = Duration::from_secs(15);
+/// 出站 UA（常见静态站基本放行）。
+const UA: &str = "EntropyDecrease/0.20.4 (+https://github.com/Aparencia/Entropydecrease)";
+
+/// 采集结果视图。
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct WebCaptureView {
+    pub session_id: i64,
+    pub title: String,
+    pub site: Option<String>,
+    pub author: Option<String>,
+    pub chars: usize,
+    /// 正文抽取是否成功（false=已保留 raw_html 附件可再处理）
+    pub extracted_ok: bool,
+}
+
+/// URL 采集（async + spawn_blocking——网络/IO 不占 UI 线程）。
+#[tauri::command]
+pub async fn web_capture_url(
+    state: State<'_, AppState>,
+    url: String,
+) -> Result<WebCaptureView, String> {
+    let url = url.trim().to_string();
+    if !(url.starts_with("https://") || url.starts_with("http://")) || url.len() > 2048 {
+        return Err("仅支持 http(s):// URL".to_string());
+    }
+    let st: AppState = (*state).clone();
+    tauri::async_runtime::spawn_blocking(move || capture_inner(&st, &url))
+        .await
+        .map_err(|e| format!("任务调度失败: {}", e))?
+}
+
+fn capture_inner(st: &AppState, url: &str) -> Result<WebCaptureView, String> {
+    let agent = ureq::AgentBuilder::new()
+        .timeout(FETCH_TIMEOUT)
+        .redirects(5)
+        .user_agent(UA)
+        .build();
+    let response = agent
+        .get(url)
+        .call()
+        .map_err(|e| format!("抓取失败（离线/站点拒绝？）: {}", e))?;
+    // 分块读 + 显式上限（ureq trait object 无 take——手写护栏）
+    use std::io::Read;
+    let mut reader = response.into_reader();
+    let mut body: Vec<u8> = Vec::new();
+    let mut chunk = [0u8; 8192];
+    loop {
+        let n = reader
+            .read(&mut chunk)
+            .map_err(|e| format!("读取响应失败: {}", e))?;
+        if n == 0 {
+            break;
+        }
+        body.extend_from_slice(&chunk[..n]);
+        if body.len() > FETCH_MAX_BYTES {
+            return Err("页面超过 5MB 上限（已放弃，防内存拖垮）".to_string());
+        }
+    }
+    let html = String::from_utf8_lossy(&body).into_owned();
+    let page = extract_page(&html);
+    let now = crate::db::unix_seconds();
+    // kind=web 会话（finished——无采集过程，直接可用）
+    let session = st
+        .db
+        .create_session(&crate::types::NewSession {
+            title: if page.title.trim().is_empty() {
+                host_of(url).unwrap_or_else(|| "网页".to_string())
+            } else {
+                page.title.trim().chars().take(100).collect()
+            },
+            source_window: Some(url.to_string()),
+            profile: None,
+            kind: Some("web".to_string()),
+        })
+        .map_err(|e| e.to_string())?;
+    st.db
+        .insert_web_page(&WebPage {
+            session_id: session.id,
+            url: url.to_string(),
+            site: page.site.clone(),
+            author: page.author.clone(),
+            published: page.published.clone(),
+            markdown: if page.ok { page.markdown.clone() } else { String::new() },
+            raw_html: if page.ok { None } else { Some(html.clone()) },
+            extracted_ok: page.ok,
+            fetched_at: now,
+        })
+        .map_err(|e| e.to_string())?;
+    // 会话域广播（列表即时可见）
+    crate::notify::emit_changed(&st.app, crate::notify::DataDomain::Sessions);
+    Ok(WebCaptureView {
+        session_id: session.id,
+        title: session.title,
+        site: page.site,
+        author: page.author,
+        chars: page.markdown.chars().count(),
+        extracted_ok: page.ok,
+    })
+}
+
+fn host_of(url: &str) -> Option<String> {
+    let rest = url.split("://").nth(1)?;
+    Some(
+        rest.split(['/', '?', '#'])
+            .next()
+            .unwrap_or("")
+            .chars()
+            .take(100)
+            .collect(),
+    )
+}
+
+/// web 会话页面读取（详情展示/回链跳转数据源）。
+#[tauri::command]
+pub fn web_page_get(state: State<'_, AppState>, session_id: i64) -> Result<Option<WebPage>, String> {
+    state.db.get_web_page(session_id).map_err(|e| e.to_string())
+}
+
+/// web → 笔记核心（正文 MD 直落 + properties 元数据 + 来源回链）；
+/// session_to_note 对 kind=web 分支调用（commands_session_note 接线点）。
+pub(crate) fn web_session_to_note_core(db: &crate::db::Db, session_id: i64) -> Result<crate::types::Note, String> {
+    let session = db
+        .get_session(session_id)
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| "会话不存在".to_string())?;
+    let page = db
+        .get_web_page(session_id)
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| "web 页面不存在（kind=web 会话必有页面行）".to_string())?;
+    if !page.extracted_ok && page.markdown.trim().is_empty() {
+        return Err("该页正文抽取失败（已保留原 HTML 附件）——可稍后在扩展/快照路径重试，暂无法转笔记".to_string());
+    }
+    let props = serde_json::json!({
+        "url": page.url,
+        "site": page.site,
+        "author": page.author,
+        "published": page.published,
+        "fetchedAt": page.fetched_at,
+        "type": "web-article"
+    })
+    .to_string();
+    let note = db
+        .create_note(&NewNote {
+            title: session.title.clone(),
+            content: page.markdown.clone(),
+            source: "web".to_string(),
+            session_id: Some(session_id),
+            rule_version: None,
+            purify_stats: None,
+            tags: None,
+            properties: Some(props),
+            group_id: None,
+        })
+        .map_err(|e| e.to_string())?;
+    Ok(note)
+}
+
+#[cfg(test)]
+#[path = "commands_web_tests.rs"]
+mod tests;

app/src-tauri/src/commands_web_tests.rs

@@ -0,0 +1,65 @@
+//! commands_web 单测（v0.20.4 / REQ-303 内核——转笔记管线用内存库）。
+
+use super::*;
+use crate::db::Db;
+
+#[test]
+fn web_to_note_pipeline() {
+    let db = Db::open(":memory:").unwrap();
+    let sid = db
+        .create_session(&crate::types::NewSession {
+            title: "熵减方法论".to_string(),
+            source_window: Some("https://example.com/x".to_string()),
+            profile: None,
+            kind: Some("web".to_string()),
+        })
+        .unwrap()
+        .id;
+    db.insert_web_page(&WebPage {
+        session_id: sid,
+        url: "https://example.com/x".to_string(),
+        site: Some("example".to_string()),
+        author: Some("张三".to_string()),
+        published: None,
+        markdown: "# 熵减方法论\n正文第一段。\n- 要点甲\n".to_string(),
+        raw_html: None,
+        extracted_ok: true,
+        fetched_at: 1,
+    })
+    .unwrap();
+    let note = web_session_to_note_core(&db, sid).unwrap();
+    assert_eq!(note.source, "web");
+    assert_eq!(note.session_id, Some(sid));
+    assert!(note.content.contains("正文第一段"));
+    let props: serde_json::Value = serde_json::from_str(note.properties.as_deref().unwrap_or("{}")).unwrap();
+    assert_eq!(props["url"], "https://example.com/x");
+    assert_eq!(props["author"], "张三");
+}
+
+#[test]
+fn failed_extraction_blocked_with_message() {
+    let db = Db::open(":memory:").unwrap();
+    let sid = db
+        .create_session(&crate::types::NewSession {
+            title: "降级页".to_string(),
+            source_window: None,
+            profile: None,
+            kind: Some("web".to_string()),
+        })
+        .unwrap()
+        .id;
+    db.insert_web_page(&WebPage {
+        session_id: sid,
+        url: "https://example.com/bad".to_string(),
+        site: None,
+        author: None,
+        published: None,
+        markdown: String::new(),
+        raw_html: Some("<html>原文</html>".to_string()),
+        extracted_ok: false,
+        fetched_at: 1,
+    })
+    .unwrap();
+    let err = web_session_to_note_core(&db, sid).unwrap_err();
+    assert!(err.contains("抽取失败"), "{}", err);
+}

app/src-tauri/src/db_migrations.rs

@@ -512,6 +512,8 @@ CREATE TABLE IF NOT EXISTS contracts (
     // v0.20.3（REQ-299/300）：练习条目 + 问题清单（Me 问题化）
     crate::db_practice::init(conn)?;
     crate::db_questions::init(conn)?;
+    // v0.20.4（REQ-303）：web 会话页面表（kind=web 1:1；正文/元数据/降级附件）
+    crate::db_web::init(conn)?;
     Ok(())
 }
 

app/src-tauri/src/db_web.rs

@@ -0,0 +1,103 @@
+//! web 会话页面表（v0.20.4 / REQ-303 内核数据层）。
+//!
+//! @ai-context: kind='web' 会话 + 本表（会话 1:1 页面）——正文 MD（整篇初稿+
+//!              标题层级）与元数据（URL/站点/作者/抓取时间）落此，转笔记复用
+//!              既有会话↔笔记关联（notes.session_id）与列表/检索通道；
+//!              正文抽取失败降级原 HTML 附件（raw_html 保留，extracted_ok=0——
+//!              Foresight 兜底链：宁可存原文可再切块，不产生半成品）。
+
+use rusqlite::{params, Connection};
+use serde::Serialize;
+
+use crate::db::Db;
+use crate::error::Result;
+
+/// web 页面行（session_id 主键——kind=web 会话 1:1）。
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct WebPage {
+    pub session_id: i64,
+    pub url: String,
+    pub site: Option<String>,
+    pub author: Option<String>,
+    pub published: Option<String>,
+    pub markdown: String,
+    /// 正文抽取失败时保留的原始 HTML（可再处理；成功时可为空省空间）
+    pub raw_html: Option<String>,
+    pub extracted_ok: bool,
+    pub fetched_at: i64,
+}
+
+pub fn init(conn: &Connection) -> Result<()> {
+    conn.execute_batch(
+        "CREATE TABLE IF NOT EXISTS web_session_pages (
+            session_id INTEGER PRIMARY KEY REFERENCES sessions(id) ON DELETE CASCADE,
+            url TEXT NOT NULL,
+            site TEXT,
+            author TEXT,
+            published TEXT,
+            markdown TEXT NOT NULL,
+            raw_html TEXT,
+            extracted_ok INTEGER NOT NULL DEFAULT 1,
+            fetched_at INTEGER NOT NULL
+        );
+        ",
+    )?;
+    Ok(())
+}
+
+impl Db {
+    pub fn insert_web_page(&self, page: &WebPage) -> Result<()> {
+        self.with_conn(|conn| {
+            conn.execute(
+                "INSERT OR REPLACE INTO web_session_pages
+                    (session_id, url, site, author, published, markdown, raw_html, extracted_ok, fetched_at)
+                 VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)",
+                params![
+                    page.session_id,
+                    page.url,
+                    page.site,
+                    page.author,
+                    page.published,
+                    page.markdown,
+                    page.raw_html,
+                    page.extracted_ok as i64,
+                    page.fetched_at
+                ],
+            )?;
+            Ok(())
+        })
+    }
+
+    pub fn get_web_page(&self, session_id: i64) -> Result<Option<WebPage>> {
+        self.with_conn(|conn| {
+            let mut stmt = conn.prepare(
+                "SELECT session_id, url, site, author, published, markdown, raw_html, extracted_ok, fetched_at
+                 FROM web_session_pages WHERE session_id = ?1",
+            )?;
+            let mut mapped = stmt.query_map(params![session_id], row_to_page)?;
+            match mapped.next() {
+                Some(r) => r.map(Some).map_err(Into::into),
+                None => Ok(None),
+            }
+        })
+    }
+}
+
+fn row_to_page(row: &rusqlite::Row<'_>) -> rusqlite::Result<WebPage> {
+    Ok(WebPage {
+        session_id: row.get(0)?,
+        url: row.get(1)?,
+        site: row.get(2)?,
+        author: row.get(3)?,
+        published: row.get(4)?,
+        markdown: row.get(5)?,
+        raw_html: row.get(6)?,
+        extracted_ok: row.get::<_, i64>(7)? != 0,
+        fetched_at: row.get(8)?,
+    })
+}
+
+#[cfg(test)]
+#[path = "db_web_tests.rs"]
+mod tests;