feat(tasks): REQ-292 任务行原子层与 task_index 保存钩子

Author: Aparencia

app/src-tauri/src/db_migrations.rs

@@ -503,6 +503,8 @@ CREATE TABLE IF NOT EXISTS contracts (
     // v0.20.2（REQ-268/270）：会话精修草稿表（离线第二遍/LLM 校对派生落点——
     // 原料 session_segments 不可变，替换文本走草稿表 + 有效轴合成）
     crate::db_session_refine::init(conn)?;
+    // v0.20.3（REQ-292）：任务行增量索引表（真相=md 行；聚合查询缓存）
+    crate::db_task_index::init(conn)?;
     Ok(())
 }
 

app/src-tauri/src/db_notes.rs

@@ -9,6 +9,7 @@ use rusqlite::{params, OptionalExtension};
 
 use crate::db::{unix_seconds, Db};
 use crate::error::Result;
+use crate::db_task_index::rebuild_note_tasks;
 use crate::kb_index::soft_rebuild_note;
 use crate::types::{NewNote, Note};
 
@@ -35,6 +36,8 @@ impl Db {
             // v0.19.0（REQ-258）索引钩子：新建笔记即入派生索引（同事务软失败
             // 记录不阻断——失败可见于 kb_index_stats 角标）
             soft_rebuild_note(conn, id, &new.content);
+            // v0.20.3（REQ-292）：任务行索引同钩子重扫（真相仍在正文 md 行）
+            rebuild_note_tasks(conn, id, &new.content);
             Ok(Note {
                 id,
                 title: new.title.clone(),
@@ -98,6 +101,9 @@ impl Db {
             )?;
             if affected > 0 && cur.as_deref() != Some(content) {
                 soft_rebuild_note(conn, id, content);
+                // v0.20.3（REQ-292）：正文变化即重扫任务索引（勾选/编辑/裁决
+                // 回写全收敛于此——行号漂移由重扫吸收）
+                rebuild_note_tasks(conn, id, content);
             }
             Ok(affected > 0)
         })

app/src-tauri/src/db_task_index.rs

@@ -0,0 +1,141 @@
+//! 任务行增量索引表（v0.20.3 / REQ-292 行动底座）。
+//!
+//! @ai-context: 正文 md 任务行为唯一真相（不复制正文）——本表只是聚合查询缓存：
+//!              保存钩子（notes 写路径）对正文按行重扫重建（行号漂移由"重扫式
+//!              刷新"吸收，不做增量行号补丁）；勾选回写仍走既有字符级路径
+//!              （NoteMarkdown/前端 → update_note → 本表随保存刷新）。
+//! @ai-context: disposition/plan_date 为索引列元数据（行动中心裁决写；不写回
+//!              正文——正文只承载任务行本身）。行解析纯逻辑见 tasks_core.rs。
+//! @ai-context: 建表幂等（db_migrations init_schema 尾链挂）；删除笔记由 FK
+//!              CASCADE 清行。软失败记录（不阻断保存——派生索引职责）。
+
+use rusqlite::{params, Connection};
+
+use crate::db::Db;
+use crate::error::Result;
+use crate::tasks_core::{parse_task_line, TaskStatus};
+
+/// 任务行索引表（notes 1:N；UNIQUE(note_id, line_no) 幂等重扫）。
+pub fn init(conn: &Connection) -> Result<()> {
+    conn.execute_batch(
+        "CREATE TABLE IF NOT EXISTS task_index (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            note_id INTEGER NOT NULL REFERENCES notes(id) ON DELETE CASCADE,
+            line_no INTEGER NOT NULL,
+            task_text TEXT NOT NULL,
+            status TEXT NOT NULL DEFAULT 'todo',
+            unrefined INTEGER NOT NULL DEFAULT 0,
+            plan_date INTEGER,
+            disposition TEXT,
+            created_at INTEGER NOT NULL,
+            updated_at INTEGER NOT NULL,
+            UNIQUE (note_id, line_no)
+        );
+        CREATE INDEX IF NOT EXISTS idx_task_index_note ON task_index(note_id, status);
+        ",
+    )?;
+    Ok(())
+}
+
+/// 任务行视图（队列展示：笔记上下文 JOIN）。
+#[derive(Debug, Clone, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TaskIndexRow {
+    pub id: i64,
+    pub note_id: i64,
+    pub line_no: i64,
+    pub task_text: String,
+    pub status: String,
+    pub unrefined: bool,
+    pub plan_date: Option<i64>,
+    pub disposition: Option<String>,
+    /// 所属笔记标题（队列行上下文）
+    pub note_title: String,
+    pub updated_at: i64,
+}
+
+/// 按正文重扫重建某笔记任务索引（保存钩子；conn 已在写事务/闭包内）。
+///
+/// @ai-context: 全删全插单事务语义（调用方已在 with_conn 闭包内）——
+///              失败打印日志不阻断保存（派生索引可下次刷新，真相仍在正文）。
+pub fn rebuild_note_tasks(conn: &Connection, note_id: i64, content: &str) {
+    if let Err(e) = rebuild_inner(conn, note_id, content) {
+        eprintln!("[task-index] 笔记 {} 任务索引重建失败（可下次保存自动恢复）: {}", note_id, e);
+    }
+}
+
+fn rebuild_inner(conn: &Connection, note_id: i64, content: &str) -> Result<()> {
+    let now = crate::db::unix_seconds();
+    conn.execute("DELETE FROM task_index WHERE note_id = ?1", params![note_id])?;
+    let mut stmt = conn.prepare(
+        "INSERT INTO task_index (note_id, line_no, task_text, status, unrefined, created_at, updated_at)
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?6)",
+    )?;
+    for (line_no, line) in content.split('\n').enumerate() {
+        if let Some(p) = parse_task_line(line) {
+            let status = match p.status {
+                TaskStatus::Todo => "todo",
+                TaskStatus::Done => "done",
+            };
+            stmt.execute(params![
+                note_id,
+                line_no as i64,
+                p.payload,
+                status,
+                p.unrefined as i64,
+                now
+            ])?;
+        }
+    }
+    Ok(())
+}
+
+impl Db {
+    /// 任务队列查询（行动中心数据源；scope_note_id=单笔记过滤，None=跨组全量）。
+    pub fn list_task_queue(&self, scope_note_id: Option<i64>) -> Result<Vec<TaskIndexRow>> {
+        self.with_conn(|conn| {
+            let rows = match scope_note_id {
+                Some(nid) => {
+                    let mut stmt = conn.prepare(QUEUE_SQL_SCOPE)?;
+                    let mapped = stmt.query_map(params![nid], row_to_task)?;
+                    mapped.collect::<rusqlite::Result<Vec<_>>>()?
+                }
+                None => {
+                    let mut stmt = conn.prepare(QUEUE_SQL)?;
+                    let mapped = stmt.query_map([], row_to_task)?;
+                    mapped.collect::<rusqlite::Result<Vec<_>>>()?
+                }
+            };
+            Ok(rows)
+        })
+    }
+}
+
+const QUEUE_SQL: &str = "SELECT t.id, t.note_id, t.line_no, t.task_text, t.status, t.unrefined,
+                        t.plan_date, t.disposition, n.title AS note_title, t.updated_at
+                 FROM task_index t JOIN notes n ON n.id = t.note_id
+                 ORDER BY t.status = 'done', t.updated_at DESC, t.id DESC";
+const QUEUE_SQL_SCOPE: &str = "SELECT t.id, t.note_id, t.line_no, t.task_text, t.status, t.unrefined,
+                        t.plan_date, t.disposition, n.title AS note_title, t.updated_at
+                 FROM task_index t JOIN notes n ON n.id = t.note_id
+                 WHERE t.note_id = ?1
+                 ORDER BY t.status = 'done', t.updated_at DESC, t.id DESC";
+
+fn row_to_task(row: &rusqlite::Row<'_>) -> rusqlite::Result<TaskIndexRow> {
+    Ok(TaskIndexRow {
+        id: row.get(0)?,
+        note_id: row.get(1)?,
+        line_no: row.get(2)?,
+        task_text: row.get(3)?,
+        status: row.get(4)?,
+        unrefined: row.get::<_, i64>(5)? != 0,
+        plan_date: row.get(6)?,
+        disposition: row.get(7)?,
+        note_title: row.get(8)?,
+        updated_at: row.get(9)?,
+    })
+}
+
+#[cfg(test)]
+#[path = "db_task_index_tests.rs"]
+mod tests;

app/src-tauri/src/db_task_index_tests.rs

@@ -0,0 +1,80 @@
+//! task_index 表读写单测（v0.20.3 / REQ-292）。
+//!
+//! @ai-context: 内存库隔离；断言「保存钩子重扫」幂等语义：重复重建无重复行、
+//!              行号漂移由重扫吸收、正文原样（索引零回写——真相唯一）。
+
+use super::*;
+use crate::db::Db;
+
+fn create_note_with(db: &Db, content: &str) -> i64 {
+    db.create_note(&crate::types::NewNote {
+        title: "任务笔记".to_string(),
+        content: content.to_string(),
+        source: "manual".to_string(),
+        session_id: None,
+        rule_version: None,
+        purify_stats: None,
+        tags: None,
+        properties: None,
+        group_id: None,
+    })
+    .unwrap()
+    .id
+}
+
+#[test]
+fn save_hook_indexes_task_lines() {
+    // Arrange：新建即建索引（create_note 钩子）
+    let db = Db::open(":memory:").unwrap();
+    let id = create_note_with(
+        &db,
+        "# 标题\n- [ ] 任务一\n普通段落\n- [x] 已办事项\n- ☑️ 待办 找资料\n",
+    );
+    // Act
+    let rows = db.list_task_queue(Some(id)).unwrap();
+    // Assert：三行入索引（任务一 todo/已办 done/☑️ unrefined）；普通行不入
+    assert_eq!(rows.len(), 3);
+    assert!(rows.iter().any(|r| r.task_text == "任务一" && r.status == "todo" && !r.unrefined));
+    assert!(rows.iter().any(|r| r.task_text == "已办事项" && r.status == "done"));
+    assert!(rows.iter().any(|r| r.task_text == "找资料" && r.unrefined));
+    assert_eq!(rows[0].note_title, "任务笔记");
+}
+
+#[test]
+fn update_hook_rescans_and_absorbs_line_shift() {
+    let db = Db::open(":memory:").unwrap();
+    let id = create_note_with(&db, "- [ ] 原任务\n");
+    // Act：前插两行（行号漂移）+ 勾选原任务 → 保存触发重扫
+    db.update_note(id, "任务笔记", "新增段落\n\n- [x] 原任务\n").unwrap();
+    // Assert：重扫吸收漂移（唯一行、内容为勾选后正文）
+    let rows = db.list_task_queue(Some(id)).unwrap();
+    assert_eq!(rows.len(), 1);
+    assert_eq!(rows[0].task_text, "原任务");
+    assert_eq!(rows[0].status, "done");
+    // 正文原样（索引零回写——由字符级迁移路径保证，另行断言正文未变）
+    let note = db.get_note(id).unwrap().unwrap();
+    assert_eq!(note.content, "新增段落\n\n- [x] 原任务\n");
+}
+
+#[test]
+fn rebuild_is_idempotent_and_delete_cleans() {
+    let db = Db::open(":memory:").unwrap();
+    let id = create_note_with(&db, "- [ ] 甲\n- [ ] 乙\n");
+    // 更新同内容（触发重扫两次路径）——不重复
+    db.update_note(id, "任务笔记", "- [ ] 甲\n- [ ] 乙\n").unwrap();
+    let rows = db.list_task_queue(Some(id)).unwrap();
+    assert_eq!(rows.len(), 2, "重扫式刷新幂等无重复");
+    // 删除笔记 → FK 级联清行（无孤儿）
+    db.delete_note(id).unwrap();
+    assert!(db.list_task_queue(Some(id)).unwrap().is_empty());
+    // 跨组全量查询（None）不含已删行
+    assert!(db.list_task_queue(None).unwrap().is_empty());
+}
+
+#[test]
+fn content_without_tasks_indexes_empty() {
+    let db = Db::open(":memory:").unwrap();
+    let id = create_note_with(&db, "纯文本笔记，无任务行。\n");
+    let rows = db.list_task_queue(Some(id)).unwrap();
+    assert!(rows.is_empty());
+}

app/src-tauri/src/lib.rs

@@ -73,6 +73,8 @@ mod ai_chat_stream;
 mod ai_chat_client;
 mod commands_ai_chat;
 mod asr;
+mod tasks_core;
+mod db_task_index;
 mod asr_clean;
 mod asr_confusion;
 mod asr_dedupe;

app/src-tauri/src/tasks_core.rs

@@ -0,0 +1,117 @@
+//! 任务行回写原子层（v0.20.3 / REQ-292 行动底座）。
+//!
+//! @ai-context: markdown 任务行为唯一真相（v1 不引入新符号）——解析/迁移/行替换
+//!              全部收敛到本模块纯函数（前端勾选、行动中心裁决、未来通知多入口
+//!              共用）；字符级迁移（NoteMarkdown 先例：勾选=只改 [ ]→[x]，正文
+//!              其余字节不动——可逆、可 diff、不破坏用户排版）。
+//! @ai-context: 识别形态：GFM `- [ ]`/`- [x]`（todo/done）+ 产物遗留行
+//!              `- ☑️ 待办`（unrefined——行动中心「待提炼」区消费，裁决后
+//!              提炼为标准任务行）。行号以换行切分为准（0 基）。
+//! @ai-context: 纯逻辑无 IO——解析/迁移/替换全可单测（tasks_core_tests.rs）。
+
+/// 任务状态（任务行标记侧）。
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TaskStatus {
+    Todo,
+    Done,
+}
+
+/// 解析出的任务行信息。
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ParsedTaskLine {
+    pub status: TaskStatus,
+    /// 是否产物遗留行（`- ☑️ 待办` 型——待提炼为任务行）
+    pub unrefined: bool,
+    /// 载荷文本（去前缀/勾选框后的正文；trim）
+    pub payload: String,
+}
+
+/// 行首列表符号之一（-/*/+ 或有序 `1.`）；返回 (前缀跳过量, 符号后内容)。
+fn split_marker(line: &str) -> Option<(usize, &str)> {
+    let trimmed = line.trim_start();
+    let lead = line.len() - trimmed.len();
+    for p in ["- ", "* ", "+ "] {
+        if let Some(rest) = trimmed.strip_prefix(p) {
+            return Some((lead + p.len(), rest));
+        }
+    }
+    // 有序列表：数字 + . / ) + 空格
+    let bytes = trimmed.as_bytes();
+    let mut i = 0usize;
+    while i < bytes.len() && bytes[i].is_ascii_digit() {
+        i += 1;
+    }
+    if i > 0 && i < trimmed.len() && matches!(bytes[i], b'.' | b')') && i + 1 < trimmed.len() && bytes[i + 1] == b' ' {
+        return Some((lead + i + 2, &trimmed[i + 2..]));
+    }
+    None
+}
+
+/// 解析任务行（纯函数）：非任务行 → None。
+///
+/// @ai-context: GFM 勾选框以 `[ ]`/`[x]`/`[X]`（±空格）识别；`☑️` 前缀标记为
+///              产物遗留（unrefined）；其余形态（任务符号在段落中间等）不猜。
+pub fn parse_task_line(line: &str) -> Option<ParsedTaskLine> {
+    let (skip, rest) = split_marker(line)?;
+    let _ = skip;
+    if let Some(after_box) = rest.strip_prefix("[ ]").or_else(|| rest.strip_prefix("[]")) {
+        return Some(ParsedTaskLine {
+            status: TaskStatus::Todo,
+            unrefined: false,
+            payload: after_box.trim().to_string(),
+        });
+    }
+    if let Some(after_box) = rest.strip_prefix("[x]").or_else(|| rest.strip_prefix("[X]")) {
+        return Some(ParsedTaskLine {
+            status: TaskStatus::Done,
+            unrefined: false,
+            payload: after_box.trim().to_string(),
+        });
+    }
+    if let Some(after) = rest.strip_prefix("☑️") {
+        // 产物遗留行形如 `- ☑️ 待办 xxx`：待办为标记词（剥离），载荷=后续内容
+        let after = after.trim_start();
+        let after = after.strip_prefix("待办").map(|a| a.trim_start()).unwrap_or(after);
+        return Some(ParsedTaskLine {
+            status: TaskStatus::Todo,
+            unrefined: true,
+            payload: after.trim().to_string(),
+        });
+    }
+    None
+}
+
+/// 迁移任务行状态（纯函数，字符级）：把原行勾选框改写为 to 对应形态；
+/// 非任务行或目标即当前状态 → 原样返回。
+pub fn migrate_status(line: &str, to: TaskStatus) -> Option<String> {
+    let parsed = parse_task_line(line)?;
+    if parsed.unrefined {
+        return None; // 产物遗留行无勾选框——提炼（replace_line）而非迁移
+    }
+    let marker = match (parsed.status, to) {
+        (TaskStatus::Done, TaskStatus::Todo) => "[ ]",
+        (TaskStatus::Todo, TaskStatus::Done) => "[x]",
+        (TaskStatus::Todo, TaskStatus::Todo) | (TaskStatus::Done, TaskStatus::Done) => return Some(line.to_string()),
+    };
+    let mut chars: Vec<char> = line.chars().collect();
+    // 定位 `[` 索引（首个 `[` 前的空白与前缀保持不动——只换方括号内容）
+    let start = line.find('[')?;
+    let _ = &mut chars;
+    let mut out = line.to_string();
+    out.replace_range(start..start + 3, marker);
+    Some(out)
+}
+
+/// 替换指定行（纯函数，0 基；body 以换行切分——行号越界 → None）。
+pub fn replace_line(body: &str, line_no: usize, new_text: &str) -> Option<String> {
+    let mut parts: Vec<&str> = body.split('\n').collect();
+    if line_no >= parts.len() {
+        return None;
+    }
+    parts[line_no] = new_text;
+    Some(parts.join("\n"))
+}
+
+#[cfg(test)]
+#[path = "tasks_core_tests.rs"]
+mod tests;