marcus.hinz/ai-control
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Trilium als Archiv: verwaltete Instanz pro Projekt, MD-Archiv und Dokument-Tab entfernt

Browse Source 
- domain/trilium.rs: Runtime-Download (gepinnt 0.104.0), Instanz pro Projekt auf 127.0.0.1
  mit FNV-Port, ETAPI (archive_note, search_notes), Token im Keyring
- Setup bis aufs Passwort automatisiert: trilium_connect macht new-document (skipDemoDb),
  set-password und ETAPI-Login; Modul-Flag erst nach Token-Erfolg
- write_panel legt direkt eine Trilium-Notiz an (text|path, folder/description/tags);
  noteopen-Kanal, das Terminal-Fenster öffnet die Notiz (ersetzt archive_panel)
- MD-Altbestand raus: archive*/wiki*, archiveHome samt Permissions, panel_set/panel_load/
  wiki_open, panel_archive*/archive_docs/*_archive_home, reveal_path, spellcheck
- Dokument-Tab raus: Panel = ToDo/Befehle/Suche + Archiv-Knopf (trilium_open);
  panel-view/archive-form gelöscht, Markup/CSS/Messages bereinigt
- Lösch-Stufe Archiv: Instanz stoppen, Trilium-Datadir und Keyring-Token löschen
This commit is contained in:
marcus hinz
2026-07-24 21:42:03 +02:00
parent f58b9887c7
commit 47951a615b
64 changed files with 1454 additions and 4679 deletions
Download Patch File Download Diff File Expand all files Collapse all files
panel.html
+3 -29
View File
@@ -2,7 +2,7 @@
<html lang="de">
<head>
<meta charset="UTF-8" />
<title data-i18n="panel.windowDocument">Dokument</title>
<title data-i18n="panel.windowPanel">Panel</title>
</head>
<body>
<div class="panel-topbar" data-tauri-drag-region>
@@ -21,38 +21,12 @@
<svg width="12" height="12" viewBox="0 0 12 12"><path d="M3 3l6 6M9 3l-6 6" /></svg>
</button>
</div>
<!-- Modul-Container (<mode>-content) reihen sich hinter der Kopfzeile ein. -->
<div class="panel-head">
<div class="panel-titlerow" data-tauri-drag-region>
<span class="panel-title" data-i18n="panel.tabDraft">Dokument</span>
<button class="panel-btn panel-edit draft-only" id="panel-title-edit" data-i18n-title="panel.editTitle">✎</button>
</div>
<div class="panel-actions">
<select class="panel-lang draft-only" id="panel-lang" data-i18n-title="panel.spellcheckLang">
<option value="de">DE</option>
<option value="en">EN</option>
<option value="en-GB">EN-GB</option>
<option value="fr">FR</option>
<option value="es">ES</option>
<option value="it">IT</option>
<option value="nl">NL</option>
</select>
<button class="panel-btn draft-only" id="panel-wiki-jump" data-i18n-title="panel.openInWiki">
<svg width="14" height="14" viewBox="0 0 16 16"><path d="M8 3.5C6.6 2.4 4.6 2 2.5 2v11c2.1 0 4.1.4 5.5 1.5 1.4-1.1 3.4-1.5 5.5-1.5V2c-2.1 0-4.1.4-5.5 1.5z" /><path d="M8 3.5v11" /></svg>
</button>
<button class="panel-btn draft-only" id="panel-mode" data-i18n-title="panel.toggleRaw" data-i18n="panel.rendered">MD</button>
<button class="panel-btn draft-only" id="panel-content-edit" data-i18n-title="panel.editDraft">
<svg width="14" height="14" viewBox="0 0 16 16"><path d="M10.8 2.6 13.4 5.2 6 12.6l-3.1.5.5-3.1z" /><path d="M9.7 3.7 12.3 6.3" /></svg>
</button>
<button class="panel-btn draft-only" id="panel-copy" data-i18n-title="panel.copy">
<svg width="14" height="14" viewBox="0 0 16 16"><rect x="5.5" y="5.5" width="8" height="8" rx="1.5" /><path d="M10.5 3.2V3A1.5 1.5 0 0 0 9 1.5H3A1.5 1.5 0 0 0 1.5 3v6A1.5 1.5 0 0 0 3 10.5h.2" /></svg>
</button>
<button class="panel-btn draft-only" id="panel-archive" data-i18n-title="panel.archive">
<svg width="14" height="14" viewBox="0 0 16 16"><rect x="1.5" y="2.5" width="13" height="3.5" rx="1" /><path d="M2.8 6v6.5a1 1 0 0 0 1 1h8.4a1 1 0 0 0 1-1V6" /><path d="M6.3 9h3.4" /></svg>
</button>
<span class="panel-title"></span>
</div>
</div>
<!-- Modul-Container (<mode>-content) reihen sich hier ein. -->
<div id="panel-content" class="md"></div>
<div id="resize-grips" aria-hidden="true">
<div class="grip n" data-dir="North"></div>
<div class="grip s" data-dir="South"></div>
src-tauri/Cargo.lock
Generated
+26 -75
View File
@@ -19,18 +19,6 @@ dependencies = [
"version_check",
]
[[package]]
name = "ahash"
version = "0.8.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
dependencies = [
"cfg-if",
"once_cell",
"version_check",
"zerocopy",
]
[[package]]
name = "aho-corasick"
version = "1.1.4"
@@ -54,8 +42,8 @@ dependencies = [
"objc2-app-kit",
"objc2-foundation",
"portable-pty",
"pulldown-cmark",
"rfd 0.15.4",
"rusqlite",
"serde",
"serde_json",
"sha2",
@@ -1256,18 +1244,6 @@ dependencies = [
"pin-project-lite",
]
[[package]]
name = "fallible-iterator"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
[[package]]
name = "fallible-streaming-iterator"
version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
[[package]]
name = "fastrand"
version = "2.4.1"
@@ -1803,16 +1779,7 @@ version = "0.12.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
dependencies = [
"ahash 0.7.8",
]
[[package]]
name = "hashbrown"
version = "0.14.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
dependencies = [
"ahash 0.8.12",
"ahash",
]
[[package]]
@@ -1830,15 +1797,6 @@ version = "0.17.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
[[package]]
name = "hashlink"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6ba4ff7128dee98c7dc9794b6a411377e1404dba1c97deb8d1a55297bd25d8af"
dependencies = [
"hashbrown 0.14.5",
]
[[package]]
name = "heck"
version = "0.4.1"
@@ -2367,17 +2325,6 @@ dependencies = [
"libc",
]
[[package]]
name = "libsqlite3-sys"
version = "0.30.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2e99fb7a497b1e3339bc746195567ed8d3e24945ecd636e3619d20b9de9e9149"
dependencies = [
"cc",
"pkg-config",
"vcpkg",
]
[[package]]
name = "linux-raw-sys"
version = "0.12.1"
@@ -3172,6 +3119,24 @@ dependencies = [
"syn 1.0.109",
]
[[package]]
name = "pulldown-cmark"
version = "0.12.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f86ba2052aebccc42cbbb3ed234b8b13ce76f75c3551a303cb2bcffcff12bb14"
dependencies = [
"bitflags 2.13.0",
"memchr",
"pulldown-cmark-escape",
"unicase",
]
[[package]]
name = "pulldown-cmark-escape"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "007d8adb5ddab6f8e3f491ac63566a7d5002cc7ed73901f72057943fa71ae1ae"
[[package]]
name = "pxfm"
version = "0.1.29"
@@ -3465,20 +3430,6 @@ dependencies = [
"syn 1.0.109",
]
[[package]]
name = "rusqlite"
version = "0.32.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7753b721174eb8ff87a9a0e799e2d7bc3749323e773db92e0984debb00019d6e"
dependencies = [
"bitflags 2.13.0",
"fallible-iterator",
"fallible-streaming-iterator",
"hashlink",
"libsqlite3-sys",
"smallvec",
]
[[package]]
name = "rust_decimal"
version = "1.42.1"
@@ -4930,6 +4881,12 @@ dependencies = [
"unic-common",
]
[[package]]
name = "unicase"
version = "2.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142"
[[package]]
name = "unicode-ident"
version = "1.0.24"
@@ -5009,12 +4966,6 @@ version = "1.12.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7ba6f5989077681266825251a52748b8c1d8a4ad098cc37e440103d0ea717fc0"
[[package]]
name = "vcpkg"
version = "0.2.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
[[package]]
name = "vec_map"
version = "0.8.2"
src-tauri/Cargo.toml
+2 -2
View File
@@ -34,8 +34,8 @@ base64 = "0.22"
sha2 = "0.10"
portable-pty = "0.9"
uuid = { version = "1", features = ["v4"] }
# Volltext-Suche übers Panel-Archiv (SQLite FTS5, in-memory aus dem Baum gebaut).
rusqlite = { version = "0.32", features = ["bundled"] }
# Markdown→HTML beim Archivieren in Trilium (Notizen sind HTML).
pulldown-cmark = { version = "0.12", default-features = false, features = ["html"] }
keyring = { version = "3", features = ["apple-native", "sync-secret-service", "windows-native"] }
[target.'cfg(target_os = "linux")'.dependencies]
src-tauri/build.rs
+5 -17
View File
@@ -41,14 +41,11 @@ fn main() {
"oauth_login",
"keychain_status",
"set_apikey",
"panel_archive_dir_cmd",
"panel_archive_cmd",
"set_archive_home_cmd",
"change_archive_home_cmd",
"clear_archive_home_cmd",
"archive_docs_cmd",
"reveal_path_cmd",
"spellcheck_lang",
"trilium_status",
"trilium_setup",
"trilium_connect",
"trilium_open",
"trilium_disable",
"open_terminal",
"term_start",
"term_log",
@@ -62,16 +59,7 @@ fn main() {
"todos_delete",
"todos_add",
"todos_update",
"panel_set",
"search_run",
"panel_load",
"wiki_open",
"archive_move",
"archive_rename",
"archive_delete",
"archive_move_folder",
"archive_create_folder",
"archive_create_doc",
"open_panel_window",
])),
)
src-tauri/capabilities/main.json
+6 -6
View File
@@ -48,14 +48,14 @@
"allow-oauth-login",
"allow-keychain-status",
"allow-set-apikey",
"allow-panel-archive-dir-cmd",
"allow-set-archive-home-cmd",
"allow-clear-archive-home-cmd",
"allow-archive-docs-cmd",
"allow-delete-preview",
"allow-delete-project-scoped",
"allow-change-archive-home-cmd",
"allow-module-registry",
"allow-set-module"
"allow-set-module",
"allow-trilium-status",
"allow-trilium-setup",
"allow-trilium-connect",
"allow-trilium-open",
"allow-trilium-disable"
]
}
src-tauri/capabilities/panel.json
+2 -14
View File
@@ -20,27 +20,15 @@
"autostart:default",
"dialog:default",
"clipboard-manager:allow-write-text",
"allow-archive-create-doc",
"allow-archive-create-folder",
"allow-archive-delete",
"allow-archive-move",
"allow-archive-move-folder",
"allow-archive-rename",
"allow-buffer-read",
"allow-commands-delete",
"allow-enabled-modules",
"allow-list-projects",
"allow-panel-archive-cmd",
"allow-panel-archive-dir-cmd",
"allow-panel-load",
"allow-panel-set",
"allow-reveal-path-cmd",
"allow-trilium-open",
"allow-search-run",
"allow-spellcheck-lang",
"allow-term-log",
"allow-todos-add",
"allow-todos-delete",
"allow-todos-update",
"allow-wiki-open"
"allow-todos-update"
]
}
src-tauri/capabilities/terminal.json
+2 -14
View File
@@ -20,27 +20,16 @@
"autostart:default",
"dialog:default",
"clipboard-manager:allow-write-text",
"allow-archive-create-doc",
"allow-archive-create-folder",
"allow-archive-delete",
"allow-archive-move",
"allow-archive-move-folder",
"allow-archive-rename",
"allow-buffer-read",
"allow-commands-delete",
"allow-enabled-modules",
"allow-list-projects",
"allow-open-panel-window",
"allow-panel-archive-cmd",
"allow-panel-archive-dir-cmd",
"allow-panel-load",
"allow-panel-set",
"allow-trilium-open",
"allow-pool-label",
"allow-project-icon",
"allow-reveal-path-cmd",
"allow-search-run",
"allow-set-terminal-font-size",
"allow-spellcheck-lang",
"allow-term-log",
"allow-term-resize",
"allow-term-start",
@@ -48,7 +37,6 @@
"allow-terminal-font-size",
"allow-todos-add",
"allow-todos-delete",
"allow-todos-update",
"allow-wiki-open"
"allow-todos-update"
]
}
src-tauri/permissions/autogenerated/archive_docs_cmd.toml
-11
View File
@@ -1,11 +0,0 @@
# Automatically generated - DO NOT EDIT!
[[permission]]
identifier = "allow-archive-docs-cmd"
description = "Enables the archive_docs_cmd command without any pre-configured scope."
commands.allow = ["archive_docs_cmd"]
[[permission]]
identifier = "deny-archive-docs-cmd"
description = "Denies the archive_docs_cmd command without any pre-configured scope."
commands.deny = ["archive_docs_cmd"]
src-tauri/permissions/autogenerated/change_archive_home_cmd.toml
-11
View File
@@ -1,11 +0,0 @@
# Automatically generated - DO NOT EDIT!
[[permission]]
identifier = "allow-change-archive-home-cmd"
description = "Enables the change_archive_home_cmd command without any pre-configured scope."
commands.allow = ["change_archive_home_cmd"]
[[permission]]
identifier = "deny-change-archive-home-cmd"
description = "Denies the change_archive_home_cmd command without any pre-configured scope."
commands.deny = ["change_archive_home_cmd"]
src-tauri/permissions/autogenerated/clear_archive_home_cmd.toml
-11
View File
@@ -1,11 +0,0 @@
# Automatically generated - DO NOT EDIT!
[[permission]]
identifier = "allow-clear-archive-home-cmd"
description = "Enables the clear_archive_home_cmd command without any pre-configured scope."
commands.allow = ["clear_archive_home_cmd"]
[[permission]]
identifier = "deny-clear-archive-home-cmd"
description = "Denies the clear_archive_home_cmd command without any pre-configured scope."
commands.deny = ["clear_archive_home_cmd"]
src-tauri/permissions/autogenerated/panel_archive_cmd.toml
-11
View File
@@ -1,11 +0,0 @@
# Automatically generated - DO NOT EDIT!
[[permission]]
identifier = "allow-panel-archive-cmd"
description = "Enables the panel_archive_cmd command without any pre-configured scope."
commands.allow = ["panel_archive_cmd"]
[[permission]]
identifier = "deny-panel-archive-cmd"
description = "Denies the panel_archive_cmd command without any pre-configured scope."
commands.deny = ["panel_archive_cmd"]
src-tauri/permissions/autogenerated/panel_archive_dir_cmd.toml
-11
View File
@@ -1,11 +0,0 @@
# Automatically generated - DO NOT EDIT!
[[permission]]
identifier = "allow-panel-archive-dir-cmd"
description = "Enables the panel_archive_dir_cmd command without any pre-configured scope."
commands.allow = ["panel_archive_dir_cmd"]
[[permission]]
identifier = "deny-panel-archive-dir-cmd"
description = "Denies the panel_archive_dir_cmd command without any pre-configured scope."
commands.deny = ["panel_archive_dir_cmd"]
src-tauri/permissions/autogenerated/panel_load.toml
-11
View File
@@ -1,11 +0,0 @@
# Automatically generated - DO NOT EDIT!
[[permission]]
identifier = "allow-panel-load"
description = "Enables the panel_load command without any pre-configured scope."
commands.allow = ["panel_load"]
[[permission]]
identifier = "deny-panel-load"
description = "Denies the panel_load command without any pre-configured scope."
commands.deny = ["panel_load"]
src-tauri/permissions/autogenerated/panel_set.toml
-11
View File
@@ -1,11 +0,0 @@
# Automatically generated - DO NOT EDIT!
[[permission]]
identifier = "allow-panel-set"
description = "Enables the panel_set command without any pre-configured scope."
commands.allow = ["panel_set"]
[[permission]]
identifier = "deny-panel-set"
description = "Denies the panel_set command without any pre-configured scope."
commands.deny = ["panel_set"]
src-tauri/permissions/autogenerated/reveal_path_cmd.toml
-11
View File
@@ -1,11 +0,0 @@
# Automatically generated - DO NOT EDIT!
[[permission]]
identifier = "allow-reveal-path-cmd"
description = "Enables the reveal_path_cmd command without any pre-configured scope."
commands.allow = ["reveal_path_cmd"]
[[permission]]
identifier = "deny-reveal-path-cmd"
description = "Denies the reveal_path_cmd command without any pre-configured scope."
commands.deny = ["reveal_path_cmd"]
src-tauri/permissions/autogenerated/set_archive_home_cmd.toml
-11
View File
@@ -1,11 +0,0 @@
# Automatically generated - DO NOT EDIT!
[[permission]]
identifier = "allow-set-archive-home-cmd"
description = "Enables the set_archive_home_cmd command without any pre-configured scope."
commands.allow = ["set_archive_home_cmd"]
[[permission]]
identifier = "deny-set-archive-home-cmd"
description = "Denies the set_archive_home_cmd command without any pre-configured scope."
commands.deny = ["set_archive_home_cmd"]
src-tauri/permissions/autogenerated/spellcheck_lang.toml
-11
View File
@@ -1,11 +0,0 @@
# Automatically generated - DO NOT EDIT!
[[permission]]
identifier = "allow-spellcheck-lang"
description = "Enables the spellcheck_lang command without any pre-configured scope."
commands.allow = ["spellcheck_lang"]
[[permission]]
identifier = "deny-spellcheck-lang"
description = "Denies the spellcheck_lang command without any pre-configured scope."
commands.deny = ["spellcheck_lang"]
src-tauri/permissions/autogenerated/trilium_connect.toml
+11
View File
@@ -0,0 +1,11 @@
# Automatically generated - DO NOT EDIT!
[[permission]]
identifier = "allow-trilium-connect"
description = "Enables the trilium_connect command without any pre-configured scope."
commands.allow = ["trilium_connect"]
[[permission]]
identifier = "deny-trilium-connect"
description = "Denies the trilium_connect command without any pre-configured scope."
commands.deny = ["trilium_connect"]
src-tauri/permissions/autogenerated/trilium_disable.toml
+11
View File
@@ -0,0 +1,11 @@
# Automatically generated - DO NOT EDIT!
[[permission]]
identifier = "allow-trilium-disable"
description = "Enables the trilium_disable command without any pre-configured scope."
commands.allow = ["trilium_disable"]
[[permission]]
identifier = "deny-trilium-disable"
description = "Denies the trilium_disable command without any pre-configured scope."
commands.deny = ["trilium_disable"]
src-tauri/permissions/autogenerated/trilium_open.toml
+11
View File
@@ -0,0 +1,11 @@
# Automatically generated - DO NOT EDIT!
[[permission]]
identifier = "allow-trilium-open"
description = "Enables the trilium_open command without any pre-configured scope."
commands.allow = ["trilium_open"]
[[permission]]
identifier = "deny-trilium-open"
description = "Denies the trilium_open command without any pre-configured scope."
commands.deny = ["trilium_open"]
src-tauri/permissions/autogenerated/trilium_setup.toml
+11
View File
@@ -0,0 +1,11 @@
# Automatically generated - DO NOT EDIT!
[[permission]]
identifier = "allow-trilium-setup"
description = "Enables the trilium_setup command without any pre-configured scope."
commands.allow = ["trilium_setup"]
[[permission]]
identifier = "deny-trilium-setup"
description = "Denies the trilium_setup command without any pre-configured scope."
commands.deny = ["trilium_setup"]
src-tauri/permissions/autogenerated/trilium_status.toml
+11
View File
@@ -0,0 +1,11 @@
# Automatically generated - DO NOT EDIT!
[[permission]]
identifier = "allow-trilium-status"
description = "Enables the trilium_status command without any pre-configured scope."
commands.allow = ["trilium_status"]
[[permission]]
identifier = "deny-trilium-status"
description = "Denies the trilium_status command without any pre-configured scope."
commands.deny = ["trilium_status"]
src-tauri/permissions/autogenerated/wiki_open.toml
-11
View File
@@ -1,11 +0,0 @@
# Automatically generated - DO NOT EDIT!
[[permission]]
identifier = "allow-wiki-open"
description = "Enables the wiki_open command without any pre-configured scope."
commands.allow = ["wiki_open"]
[[permission]]
identifier = "deny-wiki-open"
description = "Denies the wiki_open command without any pre-configured scope."
commands.deny = ["wiki_open"]
src-tauri/src/app.rs
+5 -17
View File
@@ -286,14 +286,11 @@ fn invoke_handlers() -> impl Fn(tauri::ipc::Invoke<tauri::Wry>) -> bool + Send +
commands::oauth_login,
commands::keychain_status,
commands::set_apikey,
commands::panel_archive_dir_cmd,
commands::panel_archive_cmd,
commands::set_archive_home_cmd,
commands::change_archive_home_cmd,
commands::clear_archive_home_cmd,
commands::archive_docs_cmd,
commands::reveal_path_cmd,
commands::spellcheck_lang,
commands::trilium_status,
commands::trilium_setup,
commands::trilium_connect,
commands::trilium_open,
commands::trilium_disable,
commands::enabled_modules,
commands::module_registry,
commands::set_module,
@@ -307,16 +304,7 @@ fn invoke_handlers() -> impl Fn(tauri::ipc::Invoke<tauri::Wry>) -> bool + Send +
terminal::todos_delete,
terminal::todos_add,
terminal::todos_update,
terminal::panel_set,
terminal::search_run,
terminal::panel_load,
terminal::wiki_open,
terminal::archive_move,
terminal::archive_rename,
terminal::archive_delete,
terminal::archive_move_folder,
terminal::archive_create_folder,
terminal::archive_create_doc,
terminal::open_panel_window
]
}
src-tauri/src/commands.rs
+104 -72
View File
@@ -3,9 +3,6 @@
use std::time::{Duration, Instant};
use crate::domain::archive::{
archive_panel_content, project_archive_home, require_archive_home, ArchiveMeta,
};
use crate::domain::credentials::keychain_service;
use crate::domain::paths::Paths;
use crate::domain::pool::{
@@ -350,11 +347,6 @@ pub(crate) fn set_terminal_font_size(size: u32) -> Result<(), String> {
settings::set_terminal_font_size_in(&Paths::real(), size)
}
#[tauri::command]
pub(crate) fn spellcheck_lang() -> String {
settings::spellcheck_lang(&Paths::real())
}
// ---------- Verbrauch ----------
#[tauri::command]
@@ -362,15 +354,6 @@ pub(crate) fn usage_stats(days: u32) -> Result<Vec<UsageRow>, String> {
usage_stats_in(&Paths::real(), days)
}
// ---------- Panel-Archiv ----------
/// Konfiguriertes Archiv-Home des Projekts (für den Panel-Button: entscheidet,
/// ob der Ordner-Dialog nötig ist).
#[tauri::command]
pub(crate) fn panel_archive_dir_cmd(project: String) -> Option<String> {
project_archive_home(&project).map(|p| p.display().to_string())
}
/// Modul-Registry für den Settings-Dialog (Checkbox-Gruppe „Module").
#[tauri::command]
pub(crate) fn module_registry(project: String) -> Result<Vec<crate::domain::modules::ModuleInfo>, String> {
@@ -383,78 +366,127 @@ pub(crate) fn set_module(project: String, module: String, enabled: bool) -> Resu
crate::domain::modules::set_module_in(&Paths::real(), &project, &module, enabled)
}
/// Aktive Module fürs Frontend: Registry-Enablement der Projekt-Config plus
/// `requires_archive` — ohne konfiguriertes Archiv-Home fallen Archiv-Module
/// weg, ihre Tabs erscheinen nicht.
/// Aktive Module fürs Frontend (Registry-Enablement der Projekt-Config).
#[tauri::command]
pub(crate) fn enabled_modules(project: String) -> Result<Vec<String>, String> {
let paths = Paths::real();
let has_archive = read_project_config_in(&paths, &project)?.archive_home.is_some();
Ok(
crate::domain::modules::active_in(&paths, &project)?
crate::domain::modules::active_in(&Paths::real(), &project)?
.iter()
.filter(|m| !m.requires_archive || has_archive)
.map(|m| m.id.to_string())
.collect(),
)
}
/// Setzt das Archiv-Home eines Projekts (Einstellungsdialog) — inklusive
/// Permissions-Eintrag in der Projekt-settings.json.
#[tauri::command]
pub(crate) fn set_archive_home_cmd(project: String, dir: String) -> Result<(), String> {
crate::domain::archive::set_project_archive_home(&project, &dir)
// ---------- Trilium ----------
/// Wizard-Status: Runtime da, Instanz erreichbar, Token gültig. Reine
/// Checks, keine Schreiber.
#[derive(serde::Serialize)]
pub(crate) struct TriliumStatus {
version: &'static str,
port: u16,
data_dir: String,
runtime_ready: bool,
instance_running: bool,
token_ok: bool,
}
fn trilium_status_for(project: &str) -> TriliumStatus {
let paths = Paths::real();
let instance_running = crate::domain::trilium::instance_running(project);
TriliumStatus {
version: crate::domain::trilium::VERSION,
port: crate::domain::trilium::port_for(project),
data_dir: crate::domain::paths::contract_home(
&paths,
&crate::domain::trilium::data_dir(&paths, project),
),
runtime_ready: crate::domain::trilium::runtime_ready(&paths),
instance_running,
token_ok: instance_running && crate::domain::trilium::token_ok(project),
}
}
/// Wechselt das Archiv-Home (Einstellungsdialog, wenn schon eins gesetzt
/// ist): optional ziehen die Dokumente mit um; die Rechte des alten Ordners
/// werden zurückgenommen.
#[tauri::command]
pub(crate) fn change_archive_home_cmd(
pub(crate) async fn trilium_status(project: String) -> TriliumStatus {
trilium_status_for(&project)
}
/// Richtet die Projekt-Instanz ein: Runtime laden (gepinnt, Checksum),
/// Instanz starten. Schreibt KEINE Config — das Modul-Flag setzt erst
/// trilium_connect nach erfolgreichem Token-Login.
#[tauri::command]
pub(crate) async fn trilium_setup(project: String) -> Result<TriliumStatus, String> {
crate::domain::trilium::ensure_instance(&Paths::real(), &project)?;
Ok(trilium_status_for(&project))
}
/// Richtet die Instanz mit dem Passwort aus dem Wizard vollständig ein:
/// Erstlauf legt das Dokument an und setzt das Passwort, dann ETAPI-Token
/// holen, im Keyring ablegen und ERST DANN das Modul in der Projekt-Config
/// freischalten. Das Passwort wird nicht gespeichert.
#[tauri::command]
pub(crate) async fn trilium_connect(
project: String,
dir: String,
migrate: bool,
password: String,
) -> Result<TriliumStatus, String> {
let paths = Paths::real();
crate::domain::trilium::ensure_instance(&paths, &project)?;
if !crate::domain::trilium::initialized(&project)? {
crate::domain::trilium::setup_new_document(&project)?;
crate::domain::trilium::set_password(&project, &password)?;
}
let token = crate::domain::trilium::login(&project, &password)?;
crate::domain::trilium::store_token(&project, &token)?;
if !crate::domain::trilium::token_ok(&project) {
crate::domain::trilium::delete_token(&project);
return Err("Token angenommen, aber ETAPI-Zugriff scheitert".into());
}
crate::domain::modules::set_module_in(&paths, &project, "trilium", true)?;
Ok(trilium_status_for(&project))
}
/// Öffnet das Trilium-Fenster des Projekts (startet die Instanz bei Bedarf);
/// `note_id` springt zur Notiz. Async wie open_panel_window (Fenster-Erzeugung
/// aus synchronen Commands klemmt auf dem GTK-Mainloop).
#[tauri::command]
pub(crate) async fn trilium_open(
app: tauri::AppHandle,
project: String,
note_id: Option<String>,
) -> Result<(), String> {
crate::domain::archive::change_project_archive_home(&project, &dir, migrate)
use tauri::Manager;
crate::domain::trilium::ensure_instance(&Paths::real(), &project)?;
let mut url = crate::domain::trilium::base_url(&project);
if let Some(id) = &note_id {
url.push_str(&format!("/#root/{id}"));
}
let label = format!("trilium-{project}");
if let Some(win) = app.get_webview_window(&label) {
if note_id.is_some() {
win
.eval(&format!("window.location.href = {}", serde_json::json!(url)))
.map_err(|e| e.to_string())?;
}
win.set_focus().map_err(|e| e.to_string())?;
return Ok(());
}
let parsed: tauri::Url = url.parse().map_err(|e| format!("{url}: {e}"))?;
tauri::WebviewWindowBuilder::new(&app, &label, tauri::WebviewUrl::External(parsed))
.title(format!("Trilium — {}", crate::domain::project::display_name_in(&Paths::real(), &project)?))
.inner_size(1100.0, 780.0)
.build()
.map_err(|e| e.to_string())?;
Ok(())
}
/// Wählt das Archiv ab (Einstellungsdialog): Config-Eintrag und Permissions
/// weg, der Ordner bleibt liegen.
/// Wählt das Modul ab und stoppt die Projekt-Instanz. Daten und Token
/// bleiben — erneutes Aktivieren verbindet sich wieder.
#[tauri::command]
pub(crate) fn clear_archive_home_cmd(project: String) -> Result<(), String> {
crate::domain::archive::clear_project_archive_home(&project)
pub(crate) async fn trilium_disable(project: String) -> Result<(), String> {
crate::domain::modules::set_module_in(&Paths::real(), &project, "trilium", false)?;
crate::domain::trilium::stop_instance(&project);
Ok(())
}
/// Archiviert den aktuellen Panel-Entwurf. `dir` (aus dem Ordner-Dialog) setzt
/// das Archiv-Home zugleich; ohne `dir` muss es konfiguriert sein. Ordner,
/// Beschreibung und Schlagwörter kommen aus dem Archiv-Formular im Panel.
#[tauri::command]
pub(crate) fn panel_archive_cmd(
project: String,
dir: Option<String>,
folder: Option<String>,
description: Option<String>,
tags: Option<Vec<String>>,
) -> Result<String, String> {
let meta = ArchiveMeta {
folder: folder.filter(|f| !f.trim().is_empty()),
description: description.filter(|d| !d.trim().is_empty()),
tags: tags.unwrap_or_default(),
};
archive_panel_content(&project, dir.as_deref(), &meta).map(|p| p.display().to_string())
}
/// Dokumentliste des Archiv-Index (frisch gescannt) fürs Panel.
#[tauri::command]
pub(crate) fn archive_docs_cmd(
project: String,
) -> Result<Vec<crate::domain::archive_index::Doc>, String> {
let home = require_archive_home(&project)?;
crate::domain::archive_index::scan_archive(&home)
}
/// Zeigt einen Pfad im Dateimanager (nach dem Archivieren „im Finder zeigen").
#[tauri::command]
pub(crate) fn reveal_path_cmd(path: String) {
crate::platform::reveal_path(std::path::Path::new(&path));
}
src-tauri/src/domain/archive.rs
-565
View File
@@ -1,565 +0,0 @@
//! Archiv: Panel-Entwürfe als Markdown-Dateien mit Frontmatter im
//! konfigurierten Archiv-Ordner des Projekts persistieren.
use std::fs;
use std::path::PathBuf;
use std::time::{SystemTime, UNIX_EPOCH};
use crate::domain::paths::{contract_home, expand_home, panel_file, Paths};
use crate::domain::project::{
read_project_config_in, settings_path, write_project_config_in,
};
use crate::domain::registry::project_dir;
/// Konfiguriertes Archiv-Home des Projekts (config.json: archiveHome),
/// Home-expandiert; None, wenn nicht gesetzt.
pub(crate) fn project_archive_home(project: &str) -> Option<PathBuf> {
let paths = Paths::real();
let dir = read_project_config_in(&paths, project).ok()?.archive_home?;
Some(expand_home(&paths, &dir))
}
/// Archiv-Home als Result — die gemeinsame Vorbedingung aller Archiv-Tools.
/// Legt den konfigurierten Ordner an, falls er (noch) nicht existiert.
pub(crate) fn require_archive_home(project: &str) -> Result<PathBuf, String> {
let home = project_archive_home(project).ok_or("kein Archiv-Ordner gesetzt")?;
fs::create_dir_all(&home).map_err(|e| format!("{}: {e}", home.display()))?;
Ok(home)
}
/// Setzt das Archiv-Home: config.json (~-relativ) und ein Eintrag in
/// permissions.additionalDirectories + Edit der Projekt-settings.json, damit
/// claude das Archiv später lesen/scannen darf.
pub(crate) fn set_project_archive_home(project: &str, dir: &str) -> Result<(), String> {
let paths = Paths::real();
let expanded = expand_home(&paths, dir);
if !expanded.is_absolute() {
return Err(format!("Archiv-Ordner muss ein absoluter Pfad sein: {}", expanded.display()));
}
// Zu weit gefasst? Ein Vorfahre des Home (inkl. Home selbst und Root) würde
// claude über additionalDirectories weiten Zugriff geben — das lehnen wir ab.
if paths.home.starts_with(&expanded) {
return Err(format!(
"Archiv-Ordner zu weit gefasst: {}. Bitte einen spezifischen Unterordner wählen.",
expanded.display()
));
}
fs::create_dir_all(&expanded).map_err(|e| format!("{}: {e}", expanded.display()))?;
let contracted = contract_home(&paths, &expanded);
let mut cfg = read_project_config_in(&paths, project)?;
cfg.archive_home = Some(contracted.clone());
write_project_config_in(&paths, project, &cfg)?;
add_archive_permission(&paths, project, &contracted)
}
/// Trägt den Archiv-Ordner idempotent in additionalDirectories + Edit-Allow ein.
/// Auch beim Projekt-Import im Einsatz (mitgebrachtes archiveHome).
pub(crate) fn add_archive_permission(
paths: &Paths,
project: &str,
dir: &str,
) -> Result<(), String> {
let sp = settings_path(&project_dir(paths, project)?);
crate::domain::update_settings_permissions(&sp, true, |perms| {
let dirs = crate::domain::perm_array(perms, "additionalDirectories")?;
if !dirs.iter().any(|d| d.as_str() == Some(dir)) {
dirs.push(serde_json::json!(dir));
}
let edit = format!("Edit({dir}/**)");
let allow = crate::domain::perm_array(perms, "allow")?;
if !allow.iter().any(|p| p.as_str() == Some(&edit)) {
allow.push(serde_json::json!(edit));
}
Ok(())
})
}
/// Wechselt das Archiv-Home: neues Home setzen (validieren, anlegen, Rechte,
/// Config), auf Wunsch die Dokumente aus dem alten Home hinüberziehen, dann
/// die Rechte des alten zurücknehmen. Ohne `migrate` bleibt das alte Archiv
/// unverändert liegen — nichts wird implizit verschoben; der Umzug ist eine
/// bewusste Option im Dialog.
pub(crate) fn change_project_archive_home(
project: &str,
dir: &str,
migrate: bool,
) -> Result<(), String> {
let paths = Paths::real();
let old = read_project_config_in(&paths, project)?.archive_home;
set_project_archive_home(project, dir)?;
let new_home = expand_home(&paths, dir);
if let Some(old_c) = old {
let old_home = expand_home(&paths, &old_c);
if old_home == new_home {
return Ok(());
}
if migrate && old_home.is_dir() {
move_dir_contents(&old_home, &new_home)?;
}
remove_archive_permission(&paths, project, &old_c)?;
}
Ok(())
}
/// Zieht alle Einträge von `from` nach `to` um. Gleiche Platte per rename,
/// über Dateisystemgrenzen als Kopie + Löschen. Ein im Ziel schon vorhandener
/// Name bricht laut ab — nichts wird überschrieben.
fn move_dir_contents(from: &std::path::Path, to: &std::path::Path) -> Result<(), String> {
for entry in fs::read_dir(from).map_err(|e| format!("{}: {e}", from.display()))? {
let entry = entry.map_err(|e| format!("{}: {e}", from.display()))?;
let src = entry.path();
let dest = to.join(entry.file_name());
if dest.exists() {
return Err(format!("existiert schon im neuen Archiv: {}", dest.display()));
}
match fs::rename(&src, &dest) {
Ok(()) => {}
Err(e) if e.kind() == std::io::ErrorKind::CrossesDevices => {
copy_recursive(&src, &dest)?;
if src.is_dir() {
fs::remove_dir_all(&src).map_err(|e| format!("{}: {e}", src.display()))?;
} else {
fs::remove_file(&src).map_err(|e| format!("{}: {e}", src.display()))?;
}
}
Err(e) => return Err(format!("{}: {e}", src.display())),
}
}
Ok(())
}
fn copy_recursive(src: &std::path::Path, dest: &std::path::Path) -> Result<(), String> {
if src.is_dir() {
fs::create_dir_all(dest).map_err(|e| format!("{}: {e}", dest.display()))?;
for entry in fs::read_dir(src).map_err(|e| format!("{}: {e}", src.display()))? {
let entry = entry.map_err(|e| format!("{}: {e}", src.display()))?;
copy_recursive(&entry.path(), &dest.join(entry.file_name()))?;
}
} else {
fs::copy(src, dest).map_err(|e| format!("{}: {e}", src.display()))?;
}
Ok(())
}
/// Wählt das Archiv ab: archiveHome aus der config.json entfernen und die
/// beim Setzen eingetragenen Rechte (additionalDirectories + Edit-Allow) aus
/// der Projekt-settings.json zurücknehmen. Der Ordner selbst bleibt liegen.
pub(crate) fn clear_project_archive_home(project: &str) -> Result<(), String> {
let paths = Paths::real();
let mut cfg = read_project_config_in(&paths, project)?;
let Some(dir) = cfg.archive_home.take() else {
return Ok(());
};
write_project_config_in(&paths, project, &cfg)?;
remove_archive_permission(&paths, project, &dir)
}
/// Gegenstück zu add_archive_permission; auch der Lösch-Dialog (Stufe „nur
/// Integration") nimmt darüber die Archiv-Rechte zurück.
pub(crate) fn remove_archive_permission(
paths: &Paths,
project: &str,
dir: &str,
) -> Result<(), String> {
let sp = settings_path(&project_dir(paths, project)?);
if !sp.is_file() {
return Ok(());
}
crate::domain::update_settings_permissions(&sp, false, |perms| {
if let Some(dirs) = perms.get_mut("additionalDirectories").and_then(|d| d.as_array_mut()) {
dirs.retain(|d| d.as_str() != Some(dir));
}
let edit = format!("Edit({dir}/**)");
if let Some(allow) = perms.get_mut("allow").and_then(|a| a.as_array_mut()) {
allow.retain(|p| p.as_str() != Some(&edit));
}
Ok(())
})
}
/// Metadaten beim Archivieren: Unterordner im Archiv-Home plus Frontmatter-Felder.
#[derive(Default)]
pub(crate) struct ArchiveMeta {
/// Unterordner relativ zum Archiv-Home (wird angelegt).
pub(crate) folder: Option<String>,
/// Einzeiler fürs Frontmatter.
pub(crate) description: Option<String>,
/// Schlagwörter fürs Frontmatter.
pub(crate) tags: Vec<String>,
}
/// Archiviert den aktuellen Panel-Inhalt des Projekts als Markdown-Datei mit
/// Frontmatter im Archiv-Home. `dir_override` setzt das Home zugleich
/// (Terminal-Fallback ohne Dialog). Liefert den geschriebenen Pfad.
pub(crate) fn archive_panel_content(
project: &str,
dir_override: Option<&str>,
meta: &ArchiveMeta,
) -> Result<PathBuf, String> {
// Erst prüfen, dann konfigurieren: `set_project_archive_home` legt Ordner an
// und trägt eine Berechtigung in die settings.json des Projekts ein. Käme das
// vor der Leer-Prüfung, hinterließe ein Archivieren mit leerem Panel die
// Meldung „nicht archiviert“ — und ein dauerhaft umgestelltes Archiv-Home.
let text = fs::read_to_string(panel_file(project)).unwrap_or_default();
if text.trim().is_empty() {
return Err("Panel ist leer — nichts zu archivieren".into());
}
let folder = meta.folder.as_deref().map(check_folder).transpose()?;
if let Some(d) = dir_override {
set_project_archive_home(project, d)?;
}
let home = require_archive_home(project)?;
let dir = match folder {
Some(f) => home.join(f),
None => home,
};
fs::create_dir_all(&dir).map_err(|e| format!("{}: {e}", dir.display()))?;
let secs = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map_err(|e| e.to_string())?
.as_secs();
let (stamp, iso) = utc_stamp(secs);
let title = first_line(&text);
let (path, mut file) = create_unique(&dir, &stamp, &slugify(&title))?;
// Frontmatter trägt den Anzeigenamen, nicht die Projekt-ID.
let name = crate::domain::project::display_name_in(&Paths::real(), project)?;
let doc = format!("{}{}\n", frontmatter(&title, &name, &iso, meta), text.trim_end());
std::io::Write::write_all(&mut file, doc.as_bytes())
.map_err(|e| format!("{}: {e}", path.display()))?;
Ok(path)
}
/// Archiv-Dokument kollisionsfrei anlegen.
///
/// Der Zeitstempel hat Minutenauflösung; zweimal Archivieren innerhalb einer
/// Minute mit derselben Titelzeile ergäbe denselben Namen — bei Kollision
/// wird `-2`, `-3`, … angehängt. Die Garantie kommt vom Dateisystem
/// (`create_new`), nicht von einem `exists()`-Vorabblick: Beim Archiv-Sync
/// über zwei Maschinen wäre der Vorabblick ein TOCTOU-Fenster, und stiller
/// Datenverlust träfe ausgerechnet die dauerhafte Ablage.
fn create_unique(
dir: &std::path::Path,
stamp: &str,
slug: &str,
) -> Result<(PathBuf, fs::File), String> {
for n in 1.. {
let name = if n == 1 {
format!("{stamp}-{slug}.md")
} else {
format!("{stamp}-{slug}-{n}.md")
};
let path = dir.join(name);
match fs::OpenOptions::new().write(true).create_new(true).open(&path) {
Ok(file) => return Ok((path, file)),
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => continue,
Err(e) => return Err(format!("{}: {e}", path.display())),
}
}
unreachable!()
}
/// Unterordner-Pfad: relativ, nur normale Komponenten (kein `..`, kein Root).
fn check_folder(folder: &str) -> Result<&std::path::Path, String> {
let p = std::path::Path::new(folder);
let normal = p
.components()
.all(|c| matches!(c, std::path::Component::Normal(_)));
if p.components().next().is_some() && normal {
Ok(p)
} else {
Err(format!("Unterordner muss ein relativer Pfad ohne '..' sein: {folder}"))
}
}
/// YAML-Frontmatter des Archiv-Dokuments inklusive optionaler
/// description/tags aus den Metadaten. Gegenstück: `parse_frontmatter` unten —
/// Schreiber und Leser des Formats leben bewusst im selben Modul.
pub(crate) fn frontmatter(
title: &str,
project: &str,
iso: &str,
meta: &ArchiveMeta,
) -> String {
let mut fm = format!(
"---\ntitle: \"{}\"\nproject: {project}\ncreated: {iso}\nsource: ai-control\n",
title.replace('"', "'"),
);
if let Some(d) = &meta.description {
fm.push_str(&format!("description: \"{}\"\n", d.replace('"', "'")));
}
if !meta.tags.is_empty() {
let quoted: Vec<String> =
meta.tags.iter().map(|t| format!("\"{}\"", t.replace('"', "'"))).collect();
fm.push_str(&format!("tags: [{}]\n", quoted.join(", ")));
}
fm.push_str("---\n\n");
fm
}
/// Minimaler Frontmatter-Parser für die selbst geschriebenen Dokumente:
/// `key: value`-Zeilen zwischen den beiden `---`-Markern, Anführungszeichen
/// um Werte werden entfernt.
pub(crate) fn parse_frontmatter(text: &str) -> std::collections::HashMap<String, String> {
let mut map = std::collections::HashMap::new();
let Some(rest) = text.strip_prefix("---\n") else {
return map;
};
let Some(end) = rest.find("\n---") else {
return map;
};
for line in rest[..end].lines() {
let Some((key, value)) = line.split_once(':') else {
continue;
};
map.insert(key.trim().to_string(), unquote(value.trim()).to_string());
}
map
}
/// Dokument-Rumpf ohne den Frontmatter-Block; führende Leerzeilen entfernt.
pub(crate) fn strip_frontmatter(text: &str) -> &str {
let Some(rest) = text.strip_prefix("---\n") else {
return text;
};
match rest.find("\n---\n") {
Some(end) => rest[end + 5..].trim_start_matches('\n'),
None => text,
}
}
fn unquote(s: &str) -> &str {
s.strip_prefix('"')
.and_then(|s| s.strip_suffix('"'))
.unwrap_or(s)
}
/// Inline-Liste `["a", "b"]` bzw. `[a, b]` in Einzel-Tags zerlegen.
pub(crate) fn parse_tag_list(raw: &str) -> Vec<String> {
raw
.trim_start_matches('[')
.trim_end_matches(']')
.split(',')
.map(|t| unquote(t.trim()).to_string())
.filter(|t| !t.is_empty())
.collect()
}
/// Datei-Stem ohne führenden `YYYY-MM-DD_HHMM-`-Zeitstempel — das Gegenstück
/// zum Dateinamen aus `utc_stamp` + `slugify`.
pub(crate) fn strip_stamp(stem: &str) -> &str {
let bytes = stem.as_bytes();
let stamped = bytes.len() > 16
&& bytes[..16].iter().enumerate().all(|(i, b)| match i {
4 | 7 => *b == b'-',
10 => *b == b'_',
15 => *b == b'-',
_ => b.is_ascii_digit(),
});
if stamped {
&stem[16..]
} else {
stem
}
}
/// Titelzeile: erste Überschrift (## …) oder sonst erste nicht-leere Zeile.
fn first_line(text: &str) -> String {
let mut fallback: Option<&str> = None;
for line in text.lines() {
let t = line.trim();
if t.is_empty() {
continue;
}
let h = t.trim_start_matches('#').trim();
if t.starts_with('#') && !h.is_empty() {
return h.to_string();
}
fallback.get_or_insert(t);
}
fallback.unwrap_or("entwurf").to_string()
}
/// Dateinamen-tauglicher Slug (ascii, klein, Bindestriche, max. 60 Zeichen).
pub(crate) fn slugify(s: &str) -> String {
let mut out = String::new();
for c in s.chars() {
// Umlaute/ß transliterieren statt verschlucken („für's" → fuer-s).
match c {
'ä' | 'Ä' => out.push_str("ae"),
'ö' | 'Ö' => out.push_str("oe"),
'ü' | 'Ü' => out.push_str("ue"),
'ß' => out.push_str("ss"),
_ if c.is_ascii_alphanumeric() => out.push(c.to_ascii_lowercase()),
_ if !out.ends_with('-') => out.push('-'),
_ => {}
}
}
let out: String = out.trim_matches('-').chars().take(60).collect();
if out.is_empty() {
"entwurf".into()
} else {
out
}
}
/// Aktuelle UTC-Zeit als ISO-String — Frontmatter-`created` neu angelegter
/// Dokumente.
pub(crate) fn utc_now_iso() -> Result<String, String> {
let secs = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map_err(|e| e.to_string())?
.as_secs();
Ok(utc_stamp(secs).1)
}
/// UTC aus Epoch-Sekunden: (Dateistempel `YYYY-MM-DD_HHMM`, ISO `…Z`).
fn utc_stamp(secs: u64) -> (String, String) {
let (h, mi, s) = (secs / 3600 % 24, secs / 60 % 60, secs % 60);
let (y, m, d) = civil_from_days((secs / 86400) as i64);
(
format!("{y:04}-{m:02}-{d:02}_{h:02}{mi:02}"),
format!("{y:04}-{m:02}-{d:02}T{h:02}:{mi:02}:{s:02}Z"),
)
}
/// Kalenderdatum aus Tagen seit 1970-01-01 (Howard-Hinnant-Algorithmus).
fn civil_from_days(z: i64) -> (i64, u32, u32) {
let z = z + 719468;
let era = (if z >= 0 { z } else { z - 146096 }) / 146097;
let doe = z - era * 146097;
let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
let y = yoe + era * 400;
let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
let mp = (5 * doy + 2) / 153;
let d = (doy - (153 * mp + 2) / 5 + 1) as u32;
let m = (if mp < 10 { mp + 3 } else { mp - 9 }) as u32;
(if m <= 2 { y + 1 } else { y }, m, d)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn utc_stamp_bekannte_zeit() {
// 2026-07-11 (20645 Tage seit Epoch) um 11:14:15 UTC.
let secs = 20_645u64 * 86400 + 11 * 3600 + 14 * 60 + 15;
let (stamp, iso) = utc_stamp(secs);
assert_eq!(stamp, "2026-07-11_1114");
assert_eq!(iso, "2026-07-11T11:14:15Z");
}
/// Zweimal Archivieren in derselben Minute mit gleichem Titel darf die erste
/// Datei nicht überschreiben — der Stempel hat nur Minutenauflösung, und
/// die Datei entsteht bereits beim Anlegen (create_new), nicht erst beim
/// Schreiben.
#[test]
fn gleicher_stempel_und_titel_kollidiert_nicht() {
let dir = crate::domain::testutil::tmp_paths().home.join("archiv");
fs::create_dir_all(&dir).unwrap();
let (erste, mut f1) = create_unique(&dir, "2026-07-19_2118", "notiz").unwrap();
assert_eq!(erste.file_name().unwrap(), "2026-07-19_2118-notiz.md");
std::io::Write::write_all(&mut f1, b"alt").unwrap();
let (zweite, _f2) = create_unique(&dir, "2026-07-19_2118", "notiz").unwrap();
assert_eq!(zweite.file_name().unwrap(), "2026-07-19_2118-notiz-2.md");
assert_eq!(fs::read_to_string(&erste).unwrap(), "alt");
let (dritte, _f3) = create_unique(&dir, "2026-07-19_2118", "notiz").unwrap();
assert_eq!(dritte.file_name().unwrap(), "2026-07-19_2118-notiz-3.md");
}
#[test]
fn civil_from_days_referenz() {
assert_eq!(civil_from_days(0), (1970, 1, 1));
assert_eq!(civil_from_days(20_645), (2026, 7, 11));
}
#[test]
fn slugify_grenzen() {
assert_eq!(slugify("ADR: Logging vereinheitlichen"), "adr-logging-vereinheitlichen");
assert_eq!(slugify(" "), "entwurf");
assert_eq!(slugify("###"), "entwurf");
assert_eq!(slugify("Ein Test für's Archiv"), "ein-test-fuer-s-archiv");
assert_eq!(slugify("Größe ÄÖÜ"), "groesse-aeoeue");
}
#[test]
fn stamp_und_strip_roundtrip() {
let (stamp, _) = utc_stamp(20_645u64 * 86400);
assert_eq!(strip_stamp(&format!("{stamp}-adr-logging")), "adr-logging");
assert_eq!(strip_stamp("adr-logging"), "adr-logging");
assert_eq!(strip_stamp("2026-07-19-adr"), "2026-07-19-adr");
}
#[test]
fn frontmatter_und_parser_roundtrip() {
let meta = ArchiveMeta {
folder: None,
description: Some("Kurz".into()),
tags: vec!["adr".into(), "infra".into()],
};
let fm = frontmatter("Titel", "proj", "2026-07-19T10:00:00Z", &meta);
let map = parse_frontmatter(&fm);
assert_eq!(map.get("title").map(String::as_str), Some("Titel"));
assert_eq!(map.get("description").map(String::as_str), Some("Kurz"));
assert_eq!(parse_tag_list(&map["tags"]), vec!["adr", "infra"]);
}
/// Umzug: Einträge wandern komplett, Namenskollision bricht laut ab.
#[test]
fn archiv_umzug_verschiebt_und_kollidiert_laut() {
let home = crate::domain::testutil::tmp_paths().home;
let (alt, neu) = (home.join("alt"), home.join("neu"));
fs::create_dir_all(alt.join("ordner")).unwrap();
fs::write(alt.join("doc.md"), "inhalt").unwrap();
fs::write(alt.join("ordner/tief.md"), "tief").unwrap();
fs::create_dir_all(&neu).unwrap();
move_dir_contents(&alt, &neu).unwrap();
assert_eq!(fs::read_to_string(neu.join("doc.md")).unwrap(), "inhalt");
assert_eq!(fs::read_to_string(neu.join("ordner/tief.md")).unwrap(), "tief");
assert!(fs::read_dir(&alt).unwrap().next().is_none());
// Kollision: gleicher Name im Ziel → Fehler, nichts überschrieben
fs::write(alt.join("doc.md"), "neuer").unwrap();
let err = move_dir_contents(&alt, &neu).unwrap_err();
assert!(err.contains("existiert schon"));
assert_eq!(fs::read_to_string(neu.join("doc.md")).unwrap(), "inhalt");
}
#[test]
fn check_folder_relativ_ohne_punktpunkt() {
assert!(check_folder("konzepte/panel").is_ok());
assert!(check_folder("../raus").is_err());
assert!(check_folder("a/../b").is_err());
assert!(check_folder("/absolut").is_err());
assert!(check_folder("").is_err());
}
#[test]
fn frontmatter_mit_und_ohne_meta() {
let leer = ArchiveMeta::default();
let fm = frontmatter("Titel", "proj", "2026-07-19T10:00:00Z", &leer);
assert!(fm.starts_with("---\ntitle: \"Titel\"\n"));
assert!(!fm.contains("description:"));
assert!(!fm.contains("tags:"));
let voll = ArchiveMeta {
folder: None,
description: Some("Kurz \"zitiert\"".into()),
tags: vec!["archiv".into(), "wiki".into()],
};
let fm = frontmatter("Titel", "proj", "2026-07-19T10:00:00Z", &voll);
assert!(fm.contains("description: \"Kurz 'zitiert'\"\n"));
assert!(fm.contains("tags: [\"archiv\", \"wiki\"]\n"));
}
#[test]
fn first_line_ueberschrift_oder_erste_zeile() {
assert_eq!(first_line("\n\n# Titel\n\nText"), "Titel");
assert_eq!(first_line("Kein Heading\nzweite"), "Kein Heading");
assert_eq!(first_line(" \n"), "entwurf");
}
}
src-tauri/src/domain/archive_index.rs
-427
View File
@@ -1,427 +0,0 @@
//! Archiv-Index: reproduzierbare Sicht über den Archiv-Baum eines Projekts —
//! pro Markdown-Dokument Name, Frontmatter-Metadaten und Wikilinks; Backlinks
//! fallen beim Scan als Nebenprodukt ab. Der Index ist abgeleitete Information
//! und wird bei Bedarf frisch aus dem Baum gebaut (nichts davon wird gesynct).
//! Das Dateiformat (Frontmatter, Zeitstempel-Stem) definiert archive.rs.
use std::collections::HashMap;
use std::fs;
use std::path::Path;
use crate::domain::archive::{parse_frontmatter, parse_tag_list, slugify, strip_stamp};
#[derive(serde::Serialize, Clone)]
pub(crate) struct Doc {
/// Pfad relativ zum Archiv-Home.
pub(crate) relpath: String,
/// Wikilink-Name: Datei-Stem ohne führenden Zeitstempel.
pub(crate) name: String,
/// Frontmatter-Titel, sonst der Name.
pub(crate) title: String,
pub(crate) description: Option<String>,
pub(crate) tags: Vec<String>,
/// Frontmatter-`created` (ISO) — Datumsquelle für Dokumente ohne
/// Zeitstempel im Dateinamen.
pub(crate) created: Option<String>,
/// Wikilink-Ziele im Dokumenttext (`[[ziel]]`/`[[ziel|label]]`, nur das Ziel).
pub(crate) links: Vec<String>,
/// Namen der Dokumente, die per Wikilink hierher zeigen.
pub(crate) backlinks: Vec<String>,
}
/// Scannt den Archiv-Baum rekursiv über alle Markdown-Dateien; versteckte
/// Einträge (Punkt-Präfix) bleiben außen vor. Reihenfolge: relpath sortiert;
/// Backlinks sind nach dem Scan gefüllt.
pub(crate) fn scan_archive(home: &Path) -> Result<Vec<Doc>, String> {
Ok(scan_with_bodies(home)?.into_iter().map(|(doc, _)| doc).collect())
}
/// Wie `scan_archive`, liefert zu jedem Dokument den bereits gelesenen
/// Volltext mit — die Suche indexiert damit ohne zweite Lesung pro Datei.
pub(crate) fn scan_with_bodies(home: &Path) -> Result<Vec<(Doc, String)>, String> {
let mut docs = Vec::new();
walk(home, home, &mut docs)?;
docs.sort_by(|a, b| a.0.relpath.cmp(&b.0.relpath));
fill_backlinks(&mut docs);
Ok(docs)
}
/// Backlinks in einem Durchlauf: Slug → Doc-Index einmal aufbauen, jeden Link
/// genau einmal auflösen und zu Backlinks invertieren.
fn fill_backlinks(docs: &mut [(Doc, String)]) {
let mut lookup: HashMap<String, usize> = HashMap::new();
for (i, (doc, _)) in docs.iter().enumerate() {
let stem = Path::new(&doc.relpath).file_stem().unwrap_or_default().to_string_lossy();
for key in [slugify(&doc.name), slugify(&doc.title), slugify(&stem)] {
lookup.entry(key).or_insert(i);
}
}
let mut back: Vec<Vec<String>> = vec![Vec::new(); docs.len()];
for (i, (doc, _)) in docs.iter().enumerate() {
let mut targets: std::collections::BTreeSet<usize> = docs[i]
.0
.links
.iter()
.filter_map(|l| lookup.get(&slugify(l)).copied())
.collect();
targets.remove(&i);
for t in targets {
back[t].push(doc.name.clone());
}
}
for ((doc, _), b) in docs.iter_mut().zip(back) {
doc.backlinks = b;
}
}
fn walk(home: &Path, dir: &Path, docs: &mut Vec<(Doc, String)>) -> Result<(), String> {
let entries = fs::read_dir(dir).map_err(|e| format!("{}: {e}", dir.display()))?;
for entry in entries {
let entry = entry.map_err(|e| format!("{}: {e}", dir.display()))?;
let path = entry.path();
let file_name = entry.file_name();
let fname = file_name.to_string_lossy();
if fname.starts_with('.') {
continue;
}
if path.is_dir() {
walk(home, &path, docs)?;
} else if fname.ends_with(".md") {
docs.push(read_doc(home, &path)?);
}
}
Ok(())
}
fn read_doc(home: &Path, path: &Path) -> Result<(Doc, String), String> {
let text = fs::read_to_string(path).map_err(|e| format!("{}: {e}", path.display()))?;
let stem = path.file_stem().unwrap_or_default().to_string_lossy().to_string();
let name = strip_stamp(&stem).to_string();
let fm = parse_frontmatter(&text);
let relpath = path
.strip_prefix(home)
.map_err(|e| format!("{}: {e}", path.display()))?
.display()
.to_string();
let doc = Doc {
relpath,
title: fm.get("title").unwrap_or(&name).clone(),
description: fm.get("description").cloned(),
tags: fm.get("tags").map(|t| parse_tag_list(t)).unwrap_or_default(),
created: fm.get("created").cloned(),
links: wikilinks(&text),
backlinks: Vec::new(),
name,
};
Ok((doc, text))
}
/// Slug-Vergleich eines Wikilink-Ziels gegen Name, Titel und Datei-Stem.
fn matches(doc: &Doc, want: &str) -> bool {
slugify(&doc.name) == want
|| slugify(&doc.title) == want
|| Path::new(&doc.relpath)
.file_stem()
.is_some_and(|s| slugify(&s.to_string_lossy()) == want)
}
/// Übersichts- bzw. Schlagwort-Seite als strukturierte Wiki-Daten: Dokumente
/// nach Ordnern gruppiert (neueste zuerst), Schlagwort-Leiste mit Zählern.
/// Das Panel rendert daraus die Wiki-Ansicht; `kind` unterscheidet im
/// Wiki-Puffer Seite und Dokument.
#[derive(serde::Serialize)]
pub(crate) struct WikiPage {
pub(crate) kind: &'static str,
pub(crate) home: String,
pub(crate) tag: Option<String>,
pub(crate) total: usize,
pub(crate) tags: Vec<TagCount>,
pub(crate) folders: Vec<WikiFolder>,
}
#[derive(serde::Serialize)]
pub(crate) struct TagCount {
pub(crate) name: String,
pub(crate) count: usize,
}
#[derive(serde::Serialize)]
pub(crate) struct WikiFolder {
/// Ordner relativ zum Archiv-Home; leer für die Wurzel.
pub(crate) name: String,
pub(crate) docs: Vec<WikiDocEntry>,
}
#[derive(serde::Serialize)]
pub(crate) struct WikiDocEntry {
/// Pfad relativ zum Archiv-Home — Sprung ins Dokument und Adressat der
/// Zeilen-Aktionen (umbenennen, löschen).
pub(crate) relpath: String,
pub(crate) name: String,
pub(crate) title: String,
pub(crate) description: Option<String>,
pub(crate) tags: Vec<String>,
/// Archivierungsdatum aus dem Zeitstempel-Stem (`YYYY-MM-DD`).
pub(crate) date: Option<String>,
/// Zahl der Dokumente, die per Wikilink hierher zeigen.
pub(crate) backlinks: usize,
}
pub(crate) fn archive_page(home: &Path, tag: Option<&str>) -> Result<WikiPage, String> {
let docs = scan_archive(home)?;
let mut counts: std::collections::BTreeMap<&str, usize> = std::collections::BTreeMap::new();
for doc in &docs {
for t in &doc.tags {
*counts.entry(t).or_default() += 1;
}
}
let selected: Vec<&Doc> = match tag {
Some(t) => docs.iter().filter(|d| d.tags.iter().any(|x| x == t)).collect(),
None => docs.iter().collect(),
};
let mut folders: std::collections::BTreeMap<String, Vec<&Doc>> =
std::collections::BTreeMap::new();
// Die Übersicht führt alle Ordner, auch dokumentlose — der Navigator zeigt
// frisch angelegte Ordner sonst nicht. Schlagwort-Seiten bleiben auf die
// Treffer-Ordner beschränkt.
if tag.is_none() {
let mut dirs = Vec::new();
folder_paths(home, home, &mut dirs)?;
for d in dirs {
folders.entry(d).or_default();
}
}
for doc in &selected {
let folder = Path::new(&doc.relpath)
.parent()
.map(|p| p.display().to_string())
.unwrap_or_default();
folders.entry(folder).or_default().push(doc);
}
Ok(WikiPage {
kind: "page",
home: home.display().to_string(),
tag: tag.map(str::to_string),
total: selected.len(),
tags: counts
.into_iter()
.map(|(name, count)| TagCount { name: name.to_string(), count })
.collect(),
folders: folders
.into_iter()
.map(|(name, mut list)| {
// Zeitstempel-Stems sortieren chronologisch — absteigend = neueste oben.
list.sort_by(|a, b| b.relpath.cmp(&a.relpath));
WikiFolder { name, docs: list.into_iter().map(doc_entry).collect() }
})
.collect(),
})
}
/// Alle Ordner-Relpaths unterhalb von `dir`, rekursiv; versteckte Einträge
/// (Punkt-Präfix) bleiben außen vor — wie beim Dokument-Scan.
fn folder_paths(home: &Path, dir: &Path, out: &mut Vec<String>) -> Result<(), String> {
let entries = fs::read_dir(dir).map_err(|e| format!("{}: {e}", dir.display()))?;
for entry in entries {
let entry = entry.map_err(|e| format!("{}: {e}", dir.display()))?;
let path = entry.path();
if entry.file_name().to_string_lossy().starts_with('.') || !path.is_dir() {
continue;
}
out.push(path.strip_prefix(home).unwrap().display().to_string());
folder_paths(home, &path, out)?;
}
Ok(())
}
fn doc_entry(doc: &Doc) -> WikiDocEntry {
let stem = Path::new(&doc.relpath)
.file_stem()
.unwrap_or_default()
.to_string_lossy()
.to_string();
// Zeitstempel im Dateinamen, sonst der Frontmatter-`created`-Tag —
// im Navigator angelegte Dokumente tragen das Datum nur dort.
let date = (stem != doc.name)
.then(|| stem[..10].to_string())
.or_else(|| {
doc
.created
.as_ref()
.filter(|c| c.len() >= 10)
.map(|c| c[..10].to_string())
});
WikiDocEntry {
relpath: doc.relpath.clone(),
name: doc.name.clone(),
title: doc.title.clone(),
description: doc.description.clone(),
tags: doc.tags.clone(),
date,
backlinks: doc.backlinks.len(),
}
}
/// Löst ein Wikilink-Ziel (Name, Titel oder Datei-Stem) gegen das Archiv auf
/// und liefert den relpath des Dokuments.
pub(crate) fn resolve_doc(home: &Path, target: &str) -> Result<String, String> {
let docs = scan_archive(home)?;
let want = slugify(target);
docs
.iter()
.find(|d| matches(d, &want))
.map(|d| d.relpath.clone())
.ok_or_else(|| format!("kein Archiv-Dokument zu „{target}“ gefunden"))
}
/// Alle `[[ziel]]`-Vorkommen im Text, in Dokumentreihenfolge; bei
/// `[[ziel|label]]` zählt nur das Ziel.
fn wikilinks(text: &str) -> Vec<String> {
let mut out = Vec::new();
let mut rest = text;
while let Some(start) = rest.find("[[") {
rest = &rest[start + 2..];
let Some(end) = rest.find("]]") else {
break;
};
let inner = &rest[..end];
let target = inner.split('|').next().unwrap_or(inner).trim();
if !target.is_empty() {
out.push(target.to_string());
}
rest = &rest[end + 2..];
}
out
}
#[cfg(test)]
mod tests {
use super::*;
use crate::domain::testutil::tmp_paths;
use std::path::PathBuf;
fn write(home: &Path, rel: &str, content: &str) {
let path = home.join(rel);
fs::create_dir_all(path.parent().unwrap()).unwrap();
fs::write(path, content).unwrap();
}
fn archiv() -> PathBuf {
let home = tmp_paths().home.join("archiv");
fs::create_dir_all(&home).unwrap();
write(
&home,
"2026-07-19_1000-adr-logging.md",
"---\ntitle: \"ADR Logging\"\ndescription: \"Logging vereinheitlichen\"\ntags: [\"adr\", \"infra\"]\n---\n\nSiehe [[notiz-deploy|die Deploy-Notiz]].\n",
);
write(
&home,
"konzepte/2026-07-19_1005-notiz-deploy.md",
"---\ntitle: \"Notiz Deploy\"\n---\n\nText ohne Links.\n",
);
write(&home, ".versteckt/ignoriert.md", "unsichtbar");
home
}
#[test]
fn scan_liest_baum_frontmatter_und_links() {
let home = archiv();
let docs = scan_archive(&home).unwrap();
assert_eq!(docs.len(), 2);
let adr = &docs[0];
assert_eq!(adr.name, "adr-logging");
assert_eq!(adr.title, "ADR Logging");
assert_eq!(adr.description.as_deref(), Some("Logging vereinheitlichen"));
assert_eq!(adr.tags, vec!["adr", "infra"]);
assert_eq!(adr.links, vec!["notiz-deploy"]);
assert_eq!(docs[1].relpath, "konzepte/2026-07-19_1005-notiz-deploy.md");
}
#[test]
fn backlinks_aus_wikilinks() {
let home = archiv();
let docs = scan_archive(&home).unwrap();
let deploy = docs.iter().find(|d| d.name == "notiz-deploy").unwrap();
assert_eq!(deploy.backlinks, vec!["adr-logging"]);
let adr = docs.iter().find(|d| d.name == "adr-logging").unwrap();
assert!(adr.backlinks.is_empty());
}
#[test]
fn startseite_gruppiert_und_zaehlt() {
let home = archiv();
let page = archive_page(&home, None).unwrap();
assert_eq!(page.kind, "page");
assert_eq!(page.tag, None);
assert_eq!(page.total, 2);
let tags: Vec<(&str, usize)> =
page.tags.iter().map(|t| (t.name.as_str(), t.count)).collect();
assert_eq!(tags, vec![("adr", 1), ("infra", 1)]);
assert_eq!(page.folders.len(), 2);
assert_eq!(page.folders[0].name, "");
let adr = &page.folders[0].docs[0];
assert_eq!(adr.name, "adr-logging");
assert_eq!(adr.title, "ADR Logging");
assert_eq!(adr.description.as_deref(), Some("Logging vereinheitlichen"));
assert_eq!(adr.date.as_deref(), Some("2026-07-19"));
assert_eq!(adr.relpath, "2026-07-19_1000-adr-logging.md");
assert_eq!(page.folders[1].name, "konzepte");
assert_eq!(page.folders[1].docs[0].name, "notiz-deploy");
assert_eq!(page.folders[1].docs[0].backlinks, 1);
}
#[test]
fn leere_ordner_und_created_datum() {
let home = archiv();
fs::create_dir_all(home.join("leer/unter")).unwrap();
write(
&home,
"notiz-plain.md",
"---\ntitle: \"Plain\"\ncreated: 2026-07-23T10:00:00Z\n---\n\nText.\n",
);
let page = archive_page(&home, None).unwrap();
let names: Vec<&str> = page.folders.iter().map(|f| f.name.as_str()).collect();
// Dokumentlose Ordner erscheinen (Navigator), versteckte weiterhin nicht.
assert!(names.contains(&"leer"));
assert!(names.contains(&"leer/unter"));
assert!(!names.iter().any(|n| n.starts_with(".versteckt")));
// Ohne Zeitstempel im Namen kommt das Datum aus dem Frontmatter-created.
let plain = page
.folders
.iter()
.find(|f| f.name.is_empty())
.unwrap()
.docs
.iter()
.find(|d| d.name == "notiz-plain")
.unwrap();
assert_eq!(plain.date.as_deref(), Some("2026-07-23"));
}
#[test]
fn tag_seite_filtert() {
let home = archiv();
let page = archive_page(&home, Some("adr")).unwrap();
assert_eq!(page.tag.as_deref(), Some("adr"));
assert_eq!(page.total, 1);
assert_eq!(page.folders.len(), 1);
assert_eq!(page.folders[0].docs[0].name, "adr-logging");
// Die Schlagwort-Leiste bleibt vollständig — sie ist die Navigation.
assert_eq!(page.tags.len(), 2);
}
#[test]
fn resolve_ueber_name_titel_und_stem() {
let home = archiv();
// Auflösung über Titel; Name und Stem gehen über dieselben Slug-Vergleiche.
assert_eq!(
resolve_doc(&home, "Notiz Deploy").unwrap(),
"konzepte/2026-07-19_1005-notiz-deploy.md"
);
assert_eq!(
resolve_doc(&home, "2026-07-19_1000-adr-logging").unwrap(),
"2026-07-19_1000-adr-logging.md"
);
assert!(resolve_doc(&home, "fehlt").is_err());
}
}
src-tauri/src/domain/archive_ops.rs
-275
View File
@@ -1,275 +0,0 @@
//! Dokument- und Ordner-Operationen im Archiv-Baum (Baum-Navigation im
//! Panel): verschieben, umbenennen, löschen. Alle Pfade sind relativ zum
//! Archiv-Home und strikt darauf begrenzt — die relpaths kommen aus dem
//! Webview, ein Traversal-Bestandteil bricht laut ab.
use std::fs;
use std::path::{Component, Path, PathBuf};
use crate::domain::archive::{
frontmatter, slugify, strip_frontmatter, strip_stamp, utc_now_iso, ArchiveMeta,
};
/// Relativer Pfad ohne Traversal: nur normale Komponenten, nichts Absolutes.
fn checked_rel(rel: &str) -> Result<(), String> {
if rel.is_empty() {
return Err("leerer Pfad".into());
}
for c in Path::new(rel).components() {
match c {
Component::Normal(_) => {}
_ => return Err(format!("unzulässiger Pfad: {rel}")),
}
}
Ok(())
}
/// Vorhandenes Archiv-Dokument zum relpath.
fn doc_path(home: &Path, relpath: &str) -> Result<PathBuf, String> {
checked_rel(relpath)?;
if !relpath.ends_with(".md") {
return Err(format!("kein Markdown-Dokument: {relpath}"));
}
let path = home.join(relpath);
if !path.is_file() {
return Err(format!("Dokument nicht gefunden: {relpath}"));
}
Ok(path)
}
/// Ziel für rename: darf noch nicht existieren — stilles Überschreiben wäre
/// Datenverlust.
fn fresh_target(target: &Path, home: &Path) -> Result<(), String> {
if target.exists() {
return Err(format!(
"Ziel existiert bereits: {}",
target.strip_prefix(home).unwrap_or(target).display()
));
}
Ok(())
}
/// Verschiebt ein Dokument in einen anderen Ordner (leer = Wurzel); der
/// Zielordner entsteht bei Bedarf. Liefert den neuen relpath.
pub(crate) fn move_doc(home: &Path, relpath: &str, folder: &str) -> Result<String, String> {
let src = doc_path(home, relpath)?;
if !folder.is_empty() {
checked_rel(folder)?;
}
let file_name = src.file_name().unwrap();
let dir = home.join(folder);
let target = dir.join(file_name);
if target == src {
return Ok(relpath.to_string());
}
fresh_target(&target, home)?;
fs::create_dir_all(&dir).map_err(|e| format!("{}: {e}", dir.display()))?;
fs::rename(&src, &target).map_err(|e| format!("{}: {e}", src.display()))?;
Ok(target.strip_prefix(home).unwrap().display().to_string())
}
/// Benennt ein Dokument um: neuer Name als Slug hinter dem (erhaltenen)
/// Zeitstempel. Liefert den neuen relpath.
pub(crate) fn rename_doc(home: &Path, relpath: &str, name: &str) -> Result<String, String> {
let src = doc_path(home, relpath)?;
let stem = src.file_stem().unwrap().to_string_lossy().to_string();
let stamp = &stem[..stem.len() - strip_stamp(&stem).len()];
let target = src.with_file_name(format!("{stamp}{}.md", slugify(name)));
if target == src {
return Ok(relpath.to_string());
}
fresh_target(&target, home)?;
fs::rename(&src, &target).map_err(|e| format!("{}: {e}", src.display()))?;
Ok(target.strip_prefix(home).unwrap().display().to_string())
}
pub(crate) fn delete_doc(home: &Path, relpath: &str) -> Result<(), String> {
let path = doc_path(home, relpath)?;
fs::remove_file(&path).map_err(|e| format!("{}: {e}", path.display()))
}
/// Legt einen (auch leeren) Ordner unterhalb des Archiv-Home an.
pub(crate) fn create_folder(home: &Path, folder: &str) -> Result<(), String> {
checked_rel(folder)?;
let dir = home.join(folder);
fs::create_dir_all(&dir).map_err(|e| format!("{}: {e}", dir.display()))
}
/// Legt ein leeres Dokument an: `<slug>.md` im Ordner (leer = Wurzel), das
/// Datum steht in der Frontmatter (`created`), nicht im Dateinamen. Liefert
/// den relpath.
pub(crate) fn create_doc(
home: &Path,
folder: &str,
name: &str,
project_name: &str,
) -> Result<String, String> {
let name = name.trim();
if name.is_empty() {
return Err("Dokumentname fehlt".into());
}
if !folder.is_empty() {
checked_rel(folder)?;
}
let dir = home.join(folder);
fs::create_dir_all(&dir).map_err(|e| format!("{}: {e}", dir.display()))?;
let target = dir.join(format!("{}.md", slugify(name)));
let fm = frontmatter(name, project_name, &utc_now_iso()?, &ArchiveMeta::default());
let mut file = match fs::OpenOptions::new().write(true).create_new(true).open(&target) {
Ok(f) => f,
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {
return Err(format!(
"Ziel existiert bereits: {}",
target.strip_prefix(home).unwrap_or(&target).display()
))
}
Err(e) => return Err(format!("{}: {e}", target.display())),
};
std::io::Write::write_all(&mut file, fm.as_bytes())
.map_err(|e| format!("{}: {e}", target.display()))?;
Ok(target.strip_prefix(home).unwrap().display().to_string())
}
/// Schreibt den Panel-Body zurück in ein Archiv-Dokument (Quell-Verknüpfung
/// des Dokument-Tabs): der Frontmatter-Block der Datei bleibt, der Rumpf wird
/// ersetzt.
pub(crate) fn write_body(path: &Path, text: &str) -> Result<(), String> {
let doc = fs::read_to_string(path).map_err(|e| format!("{}: {e}", path.display()))?;
let head = doc.len() - strip_frontmatter(&doc).len();
let out = format!("{}{}\n", &doc[..head], text.trim_end());
fs::write(path, out).map_err(|e| format!("{}: {e}", path.display()))
}
/// Verschiebt bzw. benennt einen ganzen Ordner um (fs::rename des
/// Verzeichnisses); Eltern des Ziels entstehen bei Bedarf.
pub(crate) fn move_folder(home: &Path, folder: &str, to: &str) -> Result<(), String> {
checked_rel(folder)?;
checked_rel(to)?;
let src = home.join(folder);
if !src.is_dir() {
return Err(format!("Ordner nicht gefunden: {folder}"));
}
let target = home.join(to);
if target == src {
return Ok(());
}
fresh_target(&target, home)?;
if let Some(parent) = target.parent() {
fs::create_dir_all(parent).map_err(|e| format!("{}: {e}", parent.display()))?;
}
fs::rename(&src, &target).map_err(|e| format!("{}: {e}", src.display()))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::domain::testutil::tmp_paths;
fn archiv() -> PathBuf {
let home = tmp_paths().home.join("archiv");
fs::create_dir_all(home.join("konzepte")).unwrap();
fs::write(home.join("2026-07-19_1000-adr-logging.md"), "a").unwrap();
fs::write(home.join("konzepte/2026-07-19_1005-notiz-deploy.md"), "b").unwrap();
home
}
#[test]
fn verschieben_legt_ordner_an_und_liefert_relpath() {
let home = archiv();
let rel = move_doc(&home, "2026-07-19_1000-adr-logging.md", "adr/2026").unwrap();
assert_eq!(rel, "adr/2026/2026-07-19_1000-adr-logging.md");
assert!(home.join(&rel).is_file());
// In die Wurzel zurück: leerer Zielordner.
let rel = move_doc(&home, &rel, "").unwrap();
assert_eq!(rel, "2026-07-19_1000-adr-logging.md");
// Gleiches Ziel ist ein No-Op, kein Fehler.
assert_eq!(move_doc(&home, &rel, "").unwrap(), rel);
}
#[test]
fn verschieben_ueberschreibt_nicht() {
let home = archiv();
fs::write(home.join("konzepte/2026-07-19_1000-adr-logging.md"), "alt").unwrap();
let err = move_doc(&home, "2026-07-19_1000-adr-logging.md", "konzepte").unwrap_err();
assert!(err.contains("existiert bereits"));
}
#[test]
fn traversal_und_fremde_pfade_brechen_ab() {
let home = archiv();
assert!(move_doc(&home, "../2026-07-19_1000-adr-logging.md", "x").is_err());
assert!(move_doc(&home, "2026-07-19_1000-adr-logging.md", "../raus").is_err());
assert!(move_doc(&home, "/etc/passwd.md", "x").is_err());
assert!(delete_doc(&home, "konzepte").is_err()); // kein .md
assert!(move_folder(&home, "konzepte", "../raus").is_err());
}
#[test]
fn umbenennen_erhaelt_stempel_und_sluggt() {
let home = archiv();
let rel =
rename_doc(&home, "konzepte/2026-07-19_1005-notiz-deploy.md", "Deploy Nötiz!").unwrap();
assert_eq!(rel, "konzepte/2026-07-19_1005-deploy-noetiz.md");
assert!(home.join(&rel).is_file());
// Ohne Stempel bleibt der Name pur.
fs::write(home.join("plain.md"), "c").unwrap();
assert_eq!(rename_doc(&home, "plain.md", "Neu").unwrap(), "neu.md");
}
#[test]
fn anlegen_ordner_und_dokument() {
let home = archiv();
create_folder(&home, "notizen/2026").unwrap();
assert!(home.join("notizen/2026").is_dir());
assert!(create_folder(&home, "../raus").is_err());
let rel = create_doc(&home, "notizen/2026", "Deploy Nötiz!", "proj").unwrap();
assert_eq!(rel, "notizen/2026/deploy-noetiz.md");
let text = fs::read_to_string(home.join(&rel)).unwrap();
assert!(text.starts_with("---\ntitle: \"Deploy Nötiz!\"\n"));
assert!(text.contains("created: "));
// In der Wurzel, gleicher Name kollidiert laut, leerer Name bricht ab.
assert_eq!(create_doc(&home, "", "Plain", "proj").unwrap(), "plain.md");
let err = create_doc(&home, "notizen/2026", "Deploy Nötiz!", "proj").unwrap_err();
assert!(err.contains("existiert bereits"));
assert!(create_doc(&home, "", " ", "proj").is_err());
}
#[test]
fn write_body_ersetzt_rumpf_und_erhaelt_frontmatter() {
let home = archiv();
let path = home.join("mit-fm.md");
fs::write(&path, "---\ntitle: \"T\"\n---\n\nalter Text\n").unwrap();
write_body(&path, "neuer Text").unwrap();
assert_eq!(
fs::read_to_string(&path).unwrap(),
"---\ntitle: \"T\"\n---\n\nneuer Text\n"
);
// Ohne Frontmatter wird die Datei komplett ersetzt.
let plain = home.join("ohne-fm.md");
fs::write(&plain, "alt").unwrap();
write_body(&plain, "neu").unwrap();
assert_eq!(fs::read_to_string(&plain).unwrap(), "neu\n");
assert!(write_body(&home.join("fehlt.md"), "x").is_err());
}
#[test]
fn loeschen_und_ordner_verschieben() {
let home = archiv();
delete_doc(&home, "2026-07-19_1000-adr-logging.md").unwrap();
assert!(!home.join("2026-07-19_1000-adr-logging.md").exists());
move_folder(&home, "konzepte", "notizen/2026").unwrap();
assert!(home.join("notizen/2026/2026-07-19_1005-notiz-deploy.md").is_file());
assert!(!home.join("konzepte").exists());
let err = move_folder(&home, "fehlt", "x").unwrap_err();
assert!(err.contains("nicht gefunden"));
}
}
src-tauri/src/domain/archive_search.rs
-227
View File
@@ -1,227 +0,0 @@
//! Volltext-Suche übers Panel-Archiv: SQLite-FTS5-Index, bei jeder Anfrage
//! frisch in-memory aus dem Archiv-Baum gebaut. Bei den Archiv-Größen dieser
//! App ist der Aufbau Millisekundensache; damit gibt es keinen persistierten
//! Index, keine Staleness und nichts, was gesynct werden könnte. Die
//! Tool-Schnittstelle bleibt engine-unabhängig.
use std::path::Path;
use rusqlite::Connection;
use crate::domain::archive_index::scan_with_bodies;
#[derive(serde::Serialize)]
pub(crate) struct Hit {
/// Pfad relativ zum Archiv-Home.
pub(crate) relpath: String,
pub(crate) title: String,
/// Textausschnitt um die Fundstelle, Treffer in `**…**`.
pub(crate) snippet: String,
}
/// Durchsucht das Archiv unter `home`. `query` ist FTS5-Syntax (Wörter,
/// "Phrasen", Präfix*); `tag` engt auf ein Schlagwort ein. Treffer nach
/// BM25-Rang, höchstens `limit`.
pub(crate) fn search(
home: &Path,
query: &str,
tag: Option<&str>,
limit: usize,
) -> Result<Vec<Hit>, String> {
let q = sanitize_query(query);
let t = tag.and_then(|t| quote_phrase(t, false)).map(|t| format!("tags:{t}"));
let expr = match (q.is_empty(), t) {
(false, Some(t)) => format!("({q}) AND {t}"),
(false, None) => q,
(true, Some(t)) => t,
// Von vornherein leere Anfrage ist ein Bedienfehler. Eine Eingabe, die nur
// aus Satzzeichen bestand (`!?`, ein einzelnes `"`, das angetippte `#`),
// findet dagegen schlicht nichts — und spart sich den Index-Aufbau.
(true, None) if query.trim().is_empty() && tag.is_none() => {
return Err("leere Suchanfrage".into())
}
(true, None) => return Ok(Vec::new()),
};
let conn = build_index(home)?;
let mut stmt = conn
.prepare(
"SELECT relpath, title, snippet(docs, 5, '**', '**', ' … ', 12) \
FROM docs WHERE docs MATCH ?1 ORDER BY rank LIMIT ?2",
)
.map_err(|e| e.to_string())?;
let rows = stmt
.query_map(rusqlite::params![expr, limit as i64], |row| {
Ok(Hit { relpath: row.get(0)?, title: row.get(1)?, snippet: row.get(2)? })
})
.map_err(|e| format!("Suchausdruck „{query}“: {e}"))?;
rows.collect::<Result<Vec<_>, _>>().map_err(|e| e.to_string())
}
/// Übersetzt die Nutzereingabe in einen FTS5-Ausdruck, der nicht scheitern kann.
///
/// Roh durchgereicht ist fast jede natürliche Eingabe ein Syntaxfehler: `ai-control`
/// liest FTS5 als Spaltenfilter (`no such column: control`), `C++` und eine offene
/// Klammer brechen den Parser. Die Live-Suche schickt zudem jeden Zwischenstand beim
/// Tippen ab, also auch das halbe `"Phrase`. Darum wird jedes Wort als Phrase
/// gequotet — die Tokenizer-Regeln bleiben dieselben, nur die Operatorzeichen
/// verlieren ihre Sonderbedeutung. Erhalten bleiben die zwei Formen, die Nutzer
/// bewusst tippen: "Phrasen in Anführungszeichen" und Präfix*.
fn sanitize_query(query: &str) -> String {
let mut out: Vec<String> = Vec::new();
// An `"` aufteilen: ungerade Segmente standen in Anführungszeichen und
// bleiben als Ganzes eine Phrase, gerade zerfallen in Wörter. Ein fehlendes
// schließendes Anführungszeichen (Tippzwischenstand) fällt damit von selbst
// richtig heraus — der Rest der Eingabe ist das letzte ungerade Segment.
for (i, teil) in query.split('"').enumerate() {
if i % 2 == 1 {
out.extend(quote_phrase(teil, false));
} else {
out.extend(
teil
.split_whitespace()
.filter_map(|w| quote_phrase(w.trim_end_matches('*'), w.ends_with('*'))),
);
}
}
out.join(" ")
}
/// `term` als gequotete FTS5-Phrase, sofern überhaupt etwas Indexierbares darin
/// steht. Reine Satzzeichen ergäben die leere Phrase `""` — für FTS5 ein
/// Syntaxfehler. Gilt auch für den Tag-Filter: Das angetippte `#` liefert über
/// `panel-wiring.ts` den leeren Tag.
fn quote_phrase(term: &str, prefix: bool) -> Option<String> {
if !term.chars().any(char::is_alphanumeric) {
return None;
}
let quoted = term.replace('"', "");
Some(if prefix { format!("\"{quoted}\"*") } else { format!("\"{quoted}\"") })
}
/// Baut den FTS5-Index in-memory aus dem Archiv-Baum.
fn build_index(home: &Path) -> Result<Connection, String> {
let conn = Connection::open_in_memory().map_err(|e| e.to_string())?;
conn
.execute_batch(
"CREATE VIRTUAL TABLE docs USING fts5(relpath UNINDEXED, name, title, description, tags, body)",
)
.map_err(|e| e.to_string())?;
let docs = scan_with_bodies(home)?;
let mut insert = conn
.prepare("INSERT INTO docs (relpath, name, title, description, tags, body) VALUES (?1, ?2, ?3, ?4, ?5, ?6)")
.map_err(|e| e.to_string())?;
for (doc, body) in &docs {
insert
.execute(rusqlite::params![
doc.relpath,
doc.name,
doc.title,
doc.description.as_deref().unwrap_or(""),
doc.tags.join(" "),
body,
])
.map_err(|e| e.to_string())?;
}
drop(insert);
Ok(conn)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::domain::testutil::tmp_paths;
use std::fs;
fn archiv() -> std::path::PathBuf {
let home = tmp_paths().home.join("archiv");
fs::create_dir_all(home.join("konzepte")).unwrap();
fs::write(
home.join("2026-07-19_1000-adr-logging.md"),
"---\ntitle: \"ADR Logging\"\ntags: [\"adr\", \"infra\"]\n---\n\nStrukturiertes Logging mit tracing vereinheitlichen.\n",
)
.unwrap();
fs::write(
home.join("konzepte/2026-07-19_1005-notiz-deploy.md"),
"---\ntitle: \"Notiz Deploy\"\ntags: [\"infra\"]\n---\n\nDeploy braucht lsregister auf macOS.\n",
)
.unwrap();
home
}
#[test]
fn findet_nach_inhaltswort() {
let home = archiv();
let hits = search(&home, "tracing", None, 10).unwrap();
assert_eq!(hits.len(), 1);
assert_eq!(hits[0].title, "ADR Logging");
assert!(hits[0].snippet.contains("**tracing**"));
}
#[test]
fn tag_filter_engt_ein() {
let home = archiv();
assert_eq!(search(&home, "", Some("infra"), 10).unwrap().len(), 2);
assert_eq!(search(&home, "", Some("adr"), 10).unwrap().len(), 1);
let hits = search(&home, "deploy", Some("adr"), 10).unwrap();
assert!(hits.is_empty());
}
#[test]
fn phrase_und_praefix() {
let home = archiv();
assert_eq!(search(&home, "\"Strukturiertes Logging\"", None, 10).unwrap().len(), 1);
assert_eq!(search(&home, "lsregist*", None, 10).unwrap().len(), 1);
}
#[test]
fn leere_anfrage_scheitert() {
let home = archiv();
assert!(search(&home, " ", None, 10).is_err());
}
/// Eingaben, die roh durchgereicht einen FTS5-Syntaxfehler warfen. Die
/// Bindestrich-Fälle sind die wichtigsten: Archiv-Dokumente heißen selbst so.
/// Die angefangenen Phrasen stehen für die Tippzwischenstände, die die
/// Live-Suche abschickt.
#[test]
fn sonderzeichen_werfen_keinen_syntaxfehler() {
let home = archiv();
let eingaben = [
"ai-control",
"adr-log",
"TODO: fix",
"C++",
"wiki (",
"\"",
"\"Strukturiertes",
"\"Strukturiertes Logging",
"!?",
];
for q in eingaben {
assert!(search(&home, q, None, 10).is_ok(), "Suche scheiterte an „{q}“");
}
}
/// Der Tag-Filter lief früher an der Quoting-Regel vorbei. `#` allein ist der
/// erste Tastendruck jeder Tag-Suche und kommt als leerer Tag an.
#[test]
fn leerer_tag_wirft_keinen_syntaxfehler() {
let home = archiv();
// Das angetippte `#`: kein Fehler-Toast, sondern schlicht kein Treffer.
assert_eq!(search(&home, "", Some(""), 10).unwrap().len(), 0);
assert_eq!(search(&home, "", Some("!?"), 10).unwrap().len(), 0);
// Mit Volltext daneben zählt nur dieser, der leere Tag engt nichts ein.
assert_eq!(search(&home, "tracing", Some(""), 10).unwrap().len(), 1);
// Fehler bleibt allein die komplett leere Anfrage ohne jeden Tag.
assert!(search(&home, "", None, 10).is_err());
}
#[test]
fn bindestrich_wort_findet_dokument() {
let home = archiv();
let hits = search(&home, "adr-logging", None, 10).unwrap();
assert_eq!(hits.len(), 1);
assert_eq!(hits[0].title, "ADR Logging");
}
}
src-tauri/src/domain/mod.rs
+1 -4
View File
@@ -2,13 +2,10 @@
//! (injizierbares Home) und den `ApikeyStore`-Trait testbar; OS-Aufrufe
//! laufen ausschließlich über crate::platform.
pub(crate) mod archive;
pub(crate) mod archive_index;
pub(crate) mod archive_ops;
pub(crate) mod archive_search;
pub(crate) mod credentials;
pub(crate) mod modules;
pub(crate) mod paths;
pub(crate) mod trilium;
pub(crate) mod pool;
pub(crate) mod project;
pub(crate) mod registry;
src-tauri/src/domain/modules.rs
+24 -44
View File
@@ -36,36 +36,15 @@ pub(crate) struct ModuleDesc {
pub(crate) core: bool,
/// Aktiv ohne Eintrag in der Projekt-Config.
pub(crate) default_enabled: bool,
/// Modul setzt ein konfiguriertes Archiv-Home voraus — ohne Home fallen
/// seine Tabs im Frontend weg. Seine MCP-Tools bleiben absichtlich
/// gelistet: Das Home kann mitten in der Session gesetzt werden, und die
/// Tools melden das fehlende Home selbst verständlich zurück.
pub(crate) requires_archive: bool,
pub(crate) mcp_tools: &'static [&'static str],
pub(crate) buffers: &'static [BufferDesc],
}
pub(crate) const MODULES: &[ModuleDesc] = &[
ModuleDesc {
id: "draft",
core: true,
default_enabled: true,
requires_archive: false,
mcp_tools: &["write_panel"],
buffers: &[BufferDesc {
id: "panel",
env: "AI_CONTROL_PANEL",
event: "panel-update",
file: crate::domain::paths::panel_file,
suffix: "md",
persistent: false,
}],
},
ModuleDesc {
id: "commands",
core: false,
default_enabled: true,
requires_archive: false,
mcp_tools: &["write_commands", "show_commands"],
buffers: &[BufferDesc {
id: "commands",
@@ -81,7 +60,6 @@ pub(crate) const MODULES: &[ModuleDesc] = &[
core: false,
// Opt-in: der Tab erscheint erst, wenn das Modul im Projekt gewählt ist.
default_enabled: false,
requires_archive: false,
mcp_tools: &["write_todos", "show_todos"],
buffers: &[BufferDesc {
id: "todos",
@@ -93,11 +71,14 @@ pub(crate) const MODULES: &[ModuleDesc] = &[
}],
},
ModuleDesc {
id: "archive",
id: "trilium",
core: false,
default_enabled: true,
requires_archive: true,
mcp_tools: &["archive_panel", "show_archive", "search_archive"],
// Opt-in: das Anwählen öffnet im Settings-Dialog den Einricht-Wizard;
// das Modul-Flag schreibt erst der erfolgreiche Setup (Erst-nach-Erfolg).
// Das Modul IST das Archiv: Archivieren und Volltextsuche laufen über
// die ETAPI der projekteigenen Trilium-Instanz.
default_enabled: false,
mcp_tools: &["write_panel", "search_archive"],
buffers: &[
BufferDesc {
id: "search",
@@ -107,12 +88,14 @@ pub(crate) const MODULES: &[ModuleDesc] = &[
suffix: "search.json",
persistent: false,
},
// Signal-Kanal „Notiz öffnen": write_panel legt die Notiz per ETAPI an
// und schreibt hier die noteId; die Fenster reagieren mit trilium_open.
BufferDesc {
id: "wiki",
env: "AI_CONTROL_WIKI",
event: "wiki-update",
file: crate::domain::paths::wiki_file,
suffix: "wiki.json",
id: "noteopen",
env: "AI_CONTROL_NOTEOPEN",
event: "noteopen-update",
file: crate::domain::paths::noteopen_file,
suffix: "noteopen.json",
persistent: false,
},
],
@@ -142,8 +125,7 @@ pub(crate) fn by_tool(tool: &str) -> Option<&'static ModuleDesc> {
}
/// Registry-Zeile für den Settings-Dialog: `enabled` ist der effektive
/// Config-Schalter (ohne `requires_archive` — die Pfadfrage zeigt der
/// Dialog daneben an).
/// Config-Schalter.
#[derive(serde::Serialize)]
pub(crate) struct ModuleInfo {
pub(crate) id: &'static str,
@@ -207,7 +189,7 @@ mod tests {
create_project(&p, "proj").unwrap();
assert_eq!(
ids(&active_in(&p, "proj").unwrap()),
vec!["draft", "commands", "archive"]
vec!["commands"]
);
}
@@ -222,11 +204,10 @@ mod tests {
.join("config.json");
std::fs::write(
&cfg,
r#"{"id": "proj", "name": "proj", "modules": {"commands": false, "draft": false}}"#,
r#"{"id": "proj", "name": "proj", "modules": {"commands": false}}"#,
)
.unwrap();
// commands ist ab; draft ignoriert den Eintrag (Kern-Modul).
assert_eq!(ids(&active_in(&p, "proj").unwrap()), vec!["draft", "archive"]);
assert!(active_in(&p, "proj").unwrap().is_empty());
}
#[test]
@@ -242,7 +223,7 @@ mod tests {
set_module_in(&p, "proj", "todo", true).unwrap();
assert_eq!(
ids(&active_in(&p, "proj").unwrap()),
vec!["draft", "commands", "todo", "archive"]
vec!["commands", "todo"]
);
}
@@ -260,21 +241,20 @@ mod tests {
let p = tmp_paths();
create_project(&p, "proj").unwrap();
set_module_in(&p, "proj", "commands", false).unwrap();
assert_eq!(ids(&active_in(&p, "proj").unwrap()), vec!["draft", "archive"]);
assert!(!module_infos_in(&p, "proj").unwrap()[1].enabled);
assert!(active_in(&p, "proj").unwrap().is_empty());
assert!(!module_infos_in(&p, "proj").unwrap()[0].enabled);
// Zurück auf den Default löscht den Eintrag statt `true` zu speichern.
set_module_in(&p, "proj", "commands", true).unwrap();
let cfg = crate::domain::project::read_project_config_in(&p, "proj").unwrap();
assert!(cfg.modules.is_empty());
// Kern-Modul und unbekannte ID scheitern laut.
assert!(set_module_in(&p, "proj", "draft", false).is_err());
// Unbekannte ID scheitert laut.
assert!(set_module_in(&p, "proj", "gibtsnicht", true).is_err());
}
#[test]
fn tool_zuordnung() {
assert_eq!(by_tool("write_panel").unwrap().id, "draft");
assert_eq!(by_tool("search_archive").unwrap().id, "archive");
assert_eq!(by_tool("write_panel").unwrap().id, "trilium");
assert_eq!(by_tool("search_archive").unwrap().id, "trilium");
assert!(by_tool("unbekannt").is_none());
}
src-tauri/src/domain/paths.rs
+5 -23
View File
@@ -65,22 +65,13 @@ fn checked(project: &str) -> &str {
project
}
/// Panel-Datei eines Projekts (Kanal Skill -> Panel). Der Pfad landet als
/// AI_CONTROL_PANEL in der PTY-Umgebung.
pub(crate) fn panel_file(project: &str) -> PathBuf {
Paths::real().panels_dir().join(format!("{}.md", checked(project)))
}
/// Quell-Verknüpfung des Panel-Inhalts: absoluter Pfad des Archiv-Dokuments,
/// aus dem der Dokument-Tab gerade geladen ist. Solange sie existiert,
/// schreibt jeder Editor-Commit den Body dorthin zurück; ein frischer Entwurf
/// (write_panel, Session-Start) entfernt sie. Liegt neben der Panel-Datei als
/// `<panel>.source`, damit der MCP-Server sie aus AI_CONTROL_PANEL ableiten
/// kann.
pub(crate) fn panel_source_file(project: &str) -> PathBuf {
/// Signal-Datei „Notiz öffnen": write_panel (MCP) schreibt die noteId der
/// frisch angelegten Trilium-Notiz, die Fenster öffnen sie daraufhin. Der
/// Pfad landet als AI_CONTROL_NOTEOPEN in der PTY-Umgebung.
pub(crate) fn noteopen_file(project: &str) -> PathBuf {
Paths::real()
.panels_dir()
.join(format!("{}.md.source", checked(project)))
.join(format!("{}.noteopen.json", checked(project)))
}
/// Command-History eines Projekts (JSONL, anhängend — flüchtig, wird beim
@@ -101,15 +92,6 @@ pub(crate) fn search_file(project: &str) -> PathBuf {
.join(format!("{}.search.json", checked(project)))
}
/// Wiki-Puffer eines Projekts (JSON, jeweils letzte Wiki-Seite bzw. letztes
/// geöffnetes Dokument — flüchtig, wird beim Session-Start geleert). Der Pfad
/// landet als AI_CONTROL_WIKI in der PTY-Umgebung.
pub(crate) fn wiki_file(project: &str) -> PathBuf {
Paths::real()
.panels_dir()
.join(format!("{}.wiki.json", checked(project)))
}
/// Persistente ToDo-Liste eines Projekts (JSONL, anhängend — überlebt
/// Sessions; write_todos hängt an, Kachel-Löschen entfernt Zeilen). Der Pfad
/// landet als AI_CONTROL_TODOS in der PTY-Umgebung.
src-tauri/src/domain/project.rs
+40 -82
View File
@@ -38,6 +38,8 @@ pub(crate) struct Project {
pub(crate) pool: Option<String>,
pub(crate) running: bool,
pub(crate) terminal: TerminalConfig,
/// Trilium-Modul aktiv — die Projektliste zeigt dann den Archiv-Knopf.
pub(crate) archive: bool,
}
#[derive(Serialize, Deserialize, Default)]
@@ -51,16 +53,6 @@ pub(crate) struct ProjectConfig {
pub(crate) name: Option<String>,
#[serde(default, skip_serializing_if = "TerminalConfig::is_empty")]
pub(crate) terminal: TerminalConfig,
/// Archiv-Home des Projekts: Zielordner fürs Archivieren von Panel-Entwürfen
/// (~-relativ gespeichert). Liest den früheren Key `archiveDir` weiterhin ein,
/// geschrieben wird nur noch `archiveHome`.
#[serde(
default,
rename = "archiveHome",
alias = "archiveDir",
skip_serializing_if = "Option::is_none"
)]
pub(crate) archive_home: Option<String>,
/// Modul-Abweichungen vom Default (`"commands": false`); fehlender Key =
/// Default aus der Registry (domain/modules.rs). Kern-Module ignorieren
/// den Eintrag.
@@ -174,6 +166,7 @@ pub(crate) fn list_projects_in(paths: &Paths) -> Result<Vec<Project>, String> {
path: contract_home(paths, &entry.dir),
pool: entry.pool,
name: cfg.name.unwrap_or_else(|| id.clone()),
archive: cfg.modules.get("trilium").copied().unwrap_or(false),
terminal: cfg.terminal,
id,
});
@@ -314,7 +307,6 @@ pub(crate) fn create_project_full_in(
id: Some(id.clone()),
name: Some(name.to_string()),
terminal,
archive_home: None,
modules: Default::default(),
rest: Default::default(),
};
@@ -403,11 +395,6 @@ pub(crate) fn add_project_in(paths: &Paths, path: &str) -> Result<(), String> {
let wd_path = expand_home(paths, &wd);
fs::create_dir_all(&wd_path).map_err(|e| format!("{}: {e}", wd_path.display()))?;
}
if let Some(archive) = cfg.archive_home.as_deref() {
let expanded = expand_home(paths, archive);
fs::create_dir_all(&expanded).map_err(|e| format!("{}: {e}", expanded.display()))?;
crate::domain::archive::add_archive_permission(paths, &id, archive)?;
}
crate::platform::write_terminal_desktop(paths, &id, &cfg);
Ok(())
}
@@ -484,10 +471,10 @@ pub(crate) struct DeletePreview {
pub(crate) name: String,
pub(crate) project_dir: String,
pub(crate) ai_control_dir: bool,
pub(crate) archive_permission: bool,
pub(crate) panel_files: usize,
pub(crate) archive_home: Option<String>,
pub(crate) archive_docs: usize,
/// Trilium-Datenverzeichnis der Projekt-Instanz (~-relativ), sofern es
/// existiert — das Archiv der Lösch-Stufe "archive".
pub(crate) trilium_data: Option<String>,
pub(crate) work_dirs: Vec<String>,
}
@@ -495,25 +482,13 @@ pub(crate) fn delete_preview_in(paths: &Paths, project: &str) -> Result<DeletePr
check_name(project)?;
let dir = project_dir(paths, project)?;
let cfg = read_project_config_in(paths, project)?;
let archive_docs = match cfg.archive_home.as_deref() {
Some(a) => {
let home = expand_home(paths, a);
if home.is_dir() {
crate::domain::archive_index::scan_archive(&home)?.len()
} else {
0
}
}
None => 0,
};
let tri = crate::domain::trilium::data_dir(paths, project);
Ok(DeletePreview {
name: cfg.name.clone().unwrap_or_else(|| project.to_string()),
project_dir: contract_home(paths, &dir),
ai_control_dir: dir.join(PROJECT_CONFIG_DIR).is_dir(),
archive_permission: cfg.archive_home.is_some(),
panel_files: session_files(paths, project).iter().filter(|f| f.is_file()).count(),
archive_home: cfg.archive_home.clone(),
archive_docs,
trilium_data: tri.is_dir().then(|| contract_home(paths, &tri)),
work_dirs: project_work_dirs_in(paths, project)?,
})
}
@@ -533,9 +508,10 @@ fn session_files(paths: &Paths, project: &str) -> Vec<PathBuf> {
/// Löscht ein Projekt in drei Stufen (Eskalationsleiter, jede schließt die
/// vorige ein):
/// - "integration": nur die ai-control-Spuren — Registry, .ai-control/,
/// Archiv-Rechte in der settings.json, Panel-Dateien, .desktop. Ordner,
/// memory/ und das Claude-Code-Grundgerüst der settings.json bleiben.
/// - "archive": zusätzlich der Archiv-Ordner samt Dokumenten.
/// Panel-Dateien, .desktop. Ordner, memory/ und das Claude-Code-Grundgerüst
/// der settings.json bleiben.
/// - "archive": zusätzlich das Trilium-Archiv der Projekt-Instanz
/// (Datenverzeichnis + Keyring-Token; die Instanz wird vorher gestoppt).
/// - "full": zusätzlich der Projektordner; Arbeitsordner per Flag.
pub(crate) fn delete_project_scoped_in(
paths: &Paths,
@@ -548,24 +524,17 @@ pub(crate) fn delete_project_scoped_in(
if !dir.is_dir() {
return Err(format!("Projektordner nicht gefunden: {}", dir.display()));
}
let cfg = read_project_config_in(paths, project)?;
// Archiv vor der Integration räumen — Stufe 1 löscht die Config, die den
// Pfad kennt.
if scope == "archive" || scope == "full" {
if let Some(a) = cfg.archive_home.as_deref() {
let home = expand_home(paths, a);
if home.is_dir() {
fs::remove_dir_all(&home).map_err(|e| format!("{}: {e}", home.display()))?;
}
crate::domain::trilium::stop_instance(project);
let tri = crate::domain::trilium::data_dir(paths, project);
if tri.is_dir() {
fs::remove_dir_all(&tri).map_err(|e| format!("{}: {e}", tri.display()))?;
}
crate::domain::trilium::delete_token(project);
}
match scope {
"integration" | "archive" => {
if let Some(a) = cfg.archive_home.as_deref() {
crate::domain::archive::remove_archive_permission(paths, project, a)?;
}
let ac = dir.join(PROJECT_CONFIG_DIR);
if ac.is_dir() {
fs::remove_dir_all(&ac).map_err(|e| format!("{}: {e}", ac.display()))?;
@@ -664,7 +633,7 @@ pub(crate) fn resolve_icon_path(
/// Liest eine Datei für `write_panel(path)` — den promptfreien MCP-Weg.
/// Erlaubt ist genau, was die Session über ihre Permissions ohnehin promptfrei
/// liest: Projektordner, Arbeitsordner und Archiv-Home. Geprüft wird nach
/// liest: Projektordner und Arbeitsordner. Geprüft wird nach
/// `canonicalize` (symlink-fest), nur reguläre Dateien bis 2 MB — sonst
/// umginge das Tool das Read-Permission-Modell von Claude Code, und ein
/// Device wie /dev/zero hinge den Prozess.
@@ -679,16 +648,13 @@ pub(crate) fn read_for_panel_in(
for d in project_work_dirs_in(paths, project)? {
roots.push(expand_home(paths, &d));
}
if let Some(a) = read_project_config_in(paths, project)?.archive_home {
roots.push(expand_home(paths, &a));
}
let allowed = roots
.iter()
.filter_map(|r| fs::canonicalize(r).ok())
.any(|r| canon.starts_with(&r));
if !allowed {
return Err(format!(
"{src}: liegt außerhalb von Projekt-, Arbeits- und Archiv-Ordnern"
"{src}: liegt außerhalb von Projekt- und Arbeitsordnern"
));
}
let f = fs::File::open(&canon).map_err(|e| format!("{src}: {e}"))?;
@@ -1088,7 +1054,8 @@ mod tests {
let cfg = read_project_config_in(&p, &id).unwrap();
assert_eq!(cfg.id.as_deref(), Some(id.as_str()));
assert_eq!(cfg.name.as_deref(), Some("proj"));
assert_eq!(cfg.archive_home.as_deref(), Some("~/archiv"));
// Unbekannte Alt-Keys (archiveHome) wandern unverändert mit.
assert_eq!(cfg.rest["archiveHome"], "~/archiv");
// Icon liegt jetzt im Projekt, das zentrale Verzeichnis ist geräumt.
assert_eq!(cfg.terminal.icon.as_deref(), Some("icon.png"));
assert!(dir.join(PROJECT_CONFIG_DIR).join("icon.png").is_file());
@@ -1143,8 +1110,7 @@ mod tests {
}
/// Import eines Ordners mit mitgebrachter Config: die ID wird übernommen
/// (Sync-Fall), Arbeitsordner und Archiv-Home werden angelegt, die
/// Archiv-Permission nachgezogen.
/// (Sync-Fall), Arbeitsordner werden angelegt.
#[test]
fn projekt_import_uebernimmt_id_und_legt_pfade_an() {
let p = tmp_paths();
@@ -1152,7 +1118,7 @@ mod tests {
fs::create_dir_all(dir.join(PROJECT_CONFIG_DIR)).unwrap();
fs::write(
dir.join(PROJECT_CONFIG_DIR).join(PROJECT_FILE),
r#"{"id": "sync-id", "name": "Mein Projekt", "archiveHome": "~/archiv/proj"}"#,
r#"{"id": "sync-id", "name": "Mein Projekt"}"#,
)
.unwrap();
fs::create_dir_all(dir.join(".claude")).unwrap();
@@ -1167,10 +1133,6 @@ mod tests {
assert_eq!(project_dir(&p, "sync-id").unwrap(), dir);
assert_eq!(display_name_in(&p, "sync-id").unwrap(), "Mein Projekt");
assert!(p.home.join("work/proj").is_dir());
assert!(p.home.join("archiv/proj").is_dir());
let raw = fs::read_to_string(settings_path(&dir)).unwrap();
assert!(raw.contains("~/archiv/proj"));
assert!(raw.contains("Edit(~/archiv/proj/**)"));
// Doppelt aufnehmen scheitert an der ID.
let err = add_project_in(&p, &dir.display().to_string()).unwrap_err();
@@ -1300,7 +1262,7 @@ mod tests {
// -- write_panel(path): promptfreier Lese-Weg --
#[test]
fn panel_lesen_nur_aus_projekt_arbeits_und_archivordnern() {
fn panel_lesen_nur_aus_projekt_und_arbeitsordnern() {
let p = tmp_paths();
create_project(&p, "proj").unwrap();
let dir = p.projects_dir().join("proj");
@@ -1339,49 +1301,45 @@ mod tests {
let id = create_project_full_in(&p, "proj", None, None, None, false, TerminalConfig::default())
.unwrap();
let dir = p.projects_dir().join("proj");
// Archiv-Home samt Permission wie über die UI gesetzt
let mut cfg = read_project_config_in(&p, &id).unwrap();
cfg.archive_home = Some("~/archiv/proj".into());
write_project_config_in(&p, &id, &cfg).unwrap();
crate::domain::archive::add_archive_permission(&p, &id, "~/archiv/proj").unwrap();
fs::create_dir_all(p.home.join("archiv/proj")).unwrap();
fs::write(p.home.join("archiv/proj/doc.md"), "inhalt").unwrap();
// flüchtige Panel-Datei
// flüchtige Panel-Datei + Trilium-Datenverzeichnis
fs::create_dir_all(p.config_dir().join("panels")).unwrap();
fs::write(p.config_dir().join("panels").join(format!("{id}.md")), "x").unwrap();
fs::write(
p.config_dir().join("panels").join(format!("{id}.commands.jsonl")),
"x",
)
.unwrap();
let tri = crate::domain::trilium::data_dir(&p, &id);
fs::create_dir_all(&tri).unwrap();
let preview = delete_preview_in(&p, &id).unwrap();
assert!(preview.ai_control_dir && preview.archive_permission);
assert!(preview.ai_control_dir);
assert_eq!(preview.panel_files, 1);
assert_eq!(preview.archive_docs, 1);
assert!(preview.trilium_data.is_some());
delete_project_scoped_in(&p, &id, "integration", false).unwrap();
assert!(dir.is_dir());
assert!(!dir.join(PROJECT_CONFIG_DIR).exists());
let sp = fs::read_to_string(settings_path(&dir)).unwrap();
assert!(!sp.contains("archiv/proj"));
assert!(sp.contains("autoMemoryDirectory")); // Claude-Code-Bestand bleibt
assert!(p.home.join("archiv/proj/doc.md").is_file()); // Archiv bleibt
assert!(!p.config_dir().join("panels").join(format!("{id}.md")).exists());
assert!(tri.is_dir()); // Archiv bleibt
assert!(!p.config_dir().join("panels").join(format!("{id}.commands.jsonl")).exists());
assert!(load_registry(&p).unwrap().is_empty());
}
/// Stufe „Integration & Archiv": zusätzlich stirbt der Archiv-Ordner.
/// Stufe „Integration & Archiv": zusätzlich stirbt das Trilium-Datadir.
#[test]
fn loeschen_integration_und_archiv() {
let p = tmp_paths();
let id = create_project_full_in(&p, "proj", None, None, None, false, TerminalConfig::default())
.unwrap();
let mut cfg = read_project_config_in(&p, &id).unwrap();
cfg.archive_home = Some("~/archiv/proj".into());
write_project_config_in(&p, &id, &cfg).unwrap();
fs::create_dir_all(p.home.join("archiv/proj")).unwrap();
let tri = crate::domain::trilium::data_dir(&p, &id);
fs::create_dir_all(&tri).unwrap();
delete_project_scoped_in(&p, &id, "archive", false).unwrap();
assert!(p.projects_dir().join("proj").is_dir());
assert!(!p.home.join("archiv/proj").exists());
assert!(!tri.exists());
assert!(load_registry(&p).unwrap().is_empty());
}
src-tauri/src/domain/settings.rs
+1 -9
View File
@@ -1,5 +1,5 @@
//! App-eigene settings.json unter ~/.config/ai-control (nicht pool-/projektbezogen):
//! claudeCommand, syncOnSessionEnd, poolSyncDir, terminalFontSize, spellcheckLang.
//! claudeCommand, syncOnSessionEnd, poolSyncDir, terminalFontSize.
use std::fs;
use std::path::PathBuf;
@@ -53,14 +53,6 @@ pub(crate) fn set_terminal_font_size_in(paths: &Paths, size: u32) -> Result<(),
write_app_setting(paths, "terminalFontSize", serde_json::json!(size))
}
/// Standard-Sprache der Rechtschreibprüfung (settings.json: spellcheckLang),
/// Default „de". Pro Text im Panel überschreibbar.
pub(crate) fn spellcheck_lang(paths: &Paths) -> String {
read_app_settings(paths)
.and_then(|v| v["spellcheckLang"].as_str().map(str::to_string))
.unwrap_or_else(|| "de".to_string())
}
/// Hat der Nutzer das Angebot, die App nach ~/Applications zu holen, schon
/// abgelehnt? (settings.json: moveOfferDismissed, nur macOS)
#[cfg_attr(not(target_os = "macos"), allow(dead_code))]
src-tauri/src/domain/trilium.rs
+555
View File
@@ -0,0 +1,555 @@
//! Trilium-Integration: das Archiv eines Projekts ist eine eigene, von
//! ai-control verwaltete Trilium-Instanz — Archivieren und Volltextsuche
//! laufen über die dokumentierte ETAPI, die Oberfläche kommt aus dem lokalen
//! Server-Prozess und wird in einem eigenen Tauri-Fenster angezeigt.
//!
//! Verwaltung komplett bei uns: versionsgepinnter Runtime-Download (Checksum),
//! ein Server-Prozess pro Projekt mit eigenem Datenverzeichnis und
//! deterministischem Port (nur 127.0.0.1) — parallele Projekte und ein
//! privates Trilium des Nutzers kollidieren nicht. Es werden ausschließlich
//! dokumentierte Schnittstellen benutzt: TRILIUM_DATA_DIR, TRILIUM_PORT,
//! ETAPI (Token über /etapi/auth/login).
//!
//! Erst-nach-Erfolg-Muster: Config-Einträge (Modul-Flag) schreibt der Wizard
//! erst, wenn Setup und Token-Login durch sind; Datei-Arbeit rollt bei
//! Fehlern zurück.
use std::collections::HashMap;
use std::fs;
use std::path::PathBuf;
use std::process::{Child, Command, Stdio};
use std::sync::Mutex;
use serde_json::{json, Value};
use crate::domain::paths::Paths;
/// Gepinntes Release; Update = Konstanten anheben (der Update-Check beim
/// App-Start vergleicht gegen diese Version, nicht gegen GitHub).
pub(crate) const VERSION: &str = "0.104.0";
/// Download-URL und SHA-256 des Server-Builds je Plattform. macOS/Windows
/// folgen, sobald unsere Pipeline eigene Server-Bundles baut (offizielle
/// Server-Builds gibt es nur für Linux).
#[cfg(target_os = "linux")]
const ASSET: (&str, &str) = (
"https://github.com/TriliumNext/Trilium/releases/download/v0.104.0/TriliumNotes-Server-v0.104.0-linux-x64.tar.xz",
"96b64bd1cf628ef8d851094de813750611d1d8a69c146ea1e8acc896420a2c69",
);
#[cfg(not(target_os = "linux"))]
const ASSET: (&str, &str) = ("", "");
/// Wurzel der Trilium-Verwaltung: Runtime und Projekt-Datenverzeichnisse.
pub(crate) fn trilium_root(paths: &Paths) -> PathBuf {
paths.config_dir().join("trilium")
}
/// Entpackte Runtime der gepinnten Version.
pub(crate) fn runtime_dir(paths: &Paths) -> PathBuf {
trilium_root(paths).join(format!("runtime-{VERSION}"))
}
fn runtime_binary(paths: &Paths) -> PathBuf {
runtime_dir(paths).join("node").join("bin").join("node")
}
fn runtime_main(paths: &Paths) -> PathBuf {
runtime_dir(paths).join("main.cjs")
}
/// Datenverzeichnis der Projekt-Instanz (TRILIUM_DATA_DIR) — maschinenlokal,
/// unter der Projekt-UUID.
pub(crate) fn data_dir(paths: &Paths, project: &str) -> PathBuf {
// Zweite Linie wie bei den Panel-Kanälen: eine Projekt-ID mit
// Pfad-Bestandteilen bricht laut ab, statt einen Pfad zu bilden.
crate::domain::check_name(project).unwrap();
trilium_root(paths).join("data").join(project)
}
/// Deterministischer Port pro Projekt (FNV-1a über die Projekt-ID) im
/// Bereich 27200–27981 — dasselbe Schema wie die übrigen Projekt-Ports.
pub(crate) fn port_for(project: &str) -> u16 {
let mut h: u64 = 0xcbf2_9ce4_8422_2325;
for b in project.bytes() {
h ^= b as u64;
h = h.wrapping_mul(0x0000_0100_0000_01b3);
}
27200 + (h % 782) as u16
}
pub(crate) fn base_url(project: &str) -> String {
format!("http://127.0.0.1:{}", port_for(project))
}
/// Lädt und entpackt die gepinnte Runtime, falls sie fehlt. Download in eine
/// Temp-Datei, SHA-256-Prüfung, Entpacken neben das Ziel, atomares Umbenennen
/// — ein Abbruch lässt keinen halben Runtime-Ordner zurück.
pub(crate) fn ensure_runtime(paths: &Paths) -> Result<(), String> {
if runtime_binary(paths).is_file() {
return Ok(());
}
let (url, sha) = ASSET;
if url.is_empty() {
return Err("Trilium-Runtime für dieses Betriebssystem noch nicht verfügbar".into());
}
let root = trilium_root(paths);
fs::create_dir_all(&root).map_err(|e| format!("{}: {e}", root.display()))?;
let tarball = root.join(format!("download-{VERSION}.tar.xz"));
let status = Command::new("curl")
.args(["-fsSL", "--retry", "2", "-o"])
.arg(&tarball)
.arg(url)
.status()
.map_err(|e| format!("curl: {e}"))?;
if !status.success() {
let _ = fs::remove_file(&tarball);
return Err(format!("Download fehlgeschlagen ({status}): {url}"));
}
let bytes = fs::read(&tarball).map_err(|e| format!("{}: {e}", tarball.display()))?;
let digest = {
use sha2::{Digest, Sha256};
let mut h = Sha256::new();
h.update(&bytes);
format!("{:x}", h.finalize())
};
if digest != sha {
let _ = fs::remove_file(&tarball);
return Err(format!("Checksum-Abweichung beim Trilium-Download: {digest} statt {sha}"));
}
// Ins Temp-Verzeichnis entpacken, dann den inneren Ordner atomar an den
// Zielnamen heben.
let unpack = root.join(format!("unpack-{VERSION}"));
let _ = fs::remove_dir_all(&unpack);
fs::create_dir_all(&unpack).map_err(|e| format!("{}: {e}", unpack.display()))?;
let status = Command::new("tar")
.arg("-xJf")
.arg(&tarball)
.arg("-C")
.arg(&unpack)
.arg("--strip-components=1")
.status()
.map_err(|e| format!("tar: {e}"))?;
let _ = fs::remove_file(&tarball);
if !status.success() {
let _ = fs::remove_dir_all(&unpack);
return Err(format!("Entpacken fehlgeschlagen ({status})"));
}
fs::rename(&unpack, runtime_dir(paths))
.map_err(|e| format!("{}: {e}", runtime_dir(paths).display()))
}
/// Laufende Projekt-Instanzen dieses App-Prozesses.
static INSTANCES: Mutex<Option<HashMap<String, Child>>> = Mutex::new(None);
/// Startet die Projekt-Instanz, falls sie nicht läuft, und wartet bis der
/// Port antwortet. Läuft der Port schon (z. B. Instanz aus einem früheren
/// App-Lauf), wird nichts gestartet.
pub(crate) fn ensure_instance(paths: &Paths, project: &str) -> Result<(), String> {
if http_ok(project, "/", 1) {
return Ok(());
}
ensure_runtime(paths)?;
let dd = data_dir(paths, project);
fs::create_dir_all(&dd).map_err(|e| format!("{}: {e}", dd.display()))?;
let mut guard = INSTANCES.lock().unwrap();
let map = guard.get_or_insert_with(HashMap::new);
// Toter Eintrag (Prozess beendet) fliegt raus, bevor neu gestartet wird.
if let Some(child) = map.get_mut(project) {
match child.try_wait() {
Ok(None) => {}
_ => {
map.remove(project);
}
}
}
if !map.contains_key(project) {
let child = Command::new(runtime_binary(paths))
.arg(runtime_main(paths))
.current_dir(runtime_dir(paths))
.env("TRILIUM_DATA_DIR", &dd)
.env("TRILIUM_PORT", port_for(project).to_string())
.stdout(Stdio::null())
.stderr(Stdio::null())
.spawn()
.map_err(|e| format!("Trilium-Start: {e}"))?;
map.insert(project.to_string(), child);
}
drop(guard);
if http_ok(project, "/", 20) {
Ok(())
} else {
Err(format!("Trilium antwortet nicht auf Port {}", port_for(project)))
}
}
/// Beendet die Projekt-Instanz dieses App-Prozesses (falls von uns gestartet).
pub(crate) fn stop_instance(project: &str) {
let mut guard = INSTANCES.lock().unwrap();
if let Some(map) = guard.as_mut() {
if let Some(mut child) = map.remove(project) {
let _ = child.kill();
let _ = child.wait();
}
}
}
/// Beendet alle von uns gestarteten Instanzen (App-Ende).
pub(crate) fn stop_all() {
let mut guard = INSTANCES.lock().unwrap();
if let Some(map) = guard.as_mut() {
for (_, mut child) in map.drain() {
let _ = child.kill();
let _ = child.wait();
}
}
}
/// Wartet bis zu `tries` Sekunden darauf, dass GET auf `path` antwortet.
fn http_ok(project: &str, path: &str, tries: u32) -> bool {
for i in 0..tries {
if i > 0 {
std::thread::sleep(std::time::Duration::from_secs(1));
}
let ok = Command::new("curl")
.args(["-fsS", "-m", "2", "-o", "/dev/null"])
.arg(format!("{}{}", base_url(project), path))
.status()
.map(|s| s.success())
.unwrap_or(false);
if ok {
return true;
}
}
false
}
/// Ist die Datenbank der Instanz schon initialisiert? (Vor dem ersten Setup
/// liefert Trilium die Setup-Seite aus; der dokumentierte ETAPI-Login
/// existiert erst danach sinnvoll.) Erkennung über die App-Info der ETAPI:
/// 401 = initialisiert (Auth nötig), Verbindung da; die Setup-Seite selbst
/// beantwortet /etapi/… nicht mit 401.
pub(crate) fn etapi(
project: &str,
method: &str,
path: &str,
token: Option<&str>,
body: Option<&Value>,
) -> Result<(u16, Value), String> {
let mut cmd = Command::new("curl");
cmd.args(["-sS", "-m", "10", "-X", method, "-w", "\n%{http_code}"]);
if let Some(token) = token {
cmd.arg("-H").arg(format!("Authorization: {token}"));
}
if let Some(body) = body {
cmd.args(["-H", "Content-Type: application/json", "--data-binary", &body.to_string()]);
}
cmd.arg(format!("{}{}", base_url(project), path));
let out = cmd.output().map_err(|e| format!("curl: {e}"))?;
if !out.status.success() && out.stdout.is_empty() {
return Err(format!("ETAPI {path}: {}", String::from_utf8_lossy(&out.stderr)));
}
let text = String::from_utf8_lossy(&out.stdout);
let (payload, code) = text.rsplit_once('\n').ok_or_else(|| format!("ETAPI {path}: leere Antwort"))?;
let code: u16 = code.trim().parse().map_err(|_| format!("ETAPI {path}: Statuszeile fehlt"))?;
let value = if payload.trim().is_empty() {
Value::Null
} else {
serde_json::from_str(payload).unwrap_or(Value::String(payload.to_string()))
};
Ok((code, value))
}
/// Ist die Datenbank der Instanz schon initialisiert? (GET /api/setup/status,
/// erreichbar ohne Auth.)
pub(crate) fn initialized(project: &str) -> Result<bool, String> {
let (code, value) = etapi(project, "GET", "/api/setup/status", None, None)?;
if code != 200 {
return Err(format!("Setup-Status fehlgeschlagen (HTTP {code})"));
}
Ok(value["isInitialized"].as_bool() == Some(true))
}
/// Legt das Initial-Dokument an (ohne Demo-Notizen). Die Route ist nur
/// erreichbar, solange die Instanz uninitialisiert ist, und antwortet erst
/// nach abgeschlossener Datenbank-Anlage.
pub(crate) fn setup_new_document(project: &str) -> Result<(), String> {
let code = http_post(project, "/api/setup/new-document?skipDemoDb", None, 120)?;
if code >= 300 {
return Err(format!("Dokument-Anlage fehlgeschlagen (HTTP {code})"));
}
Ok(())
}
/// Setzt das Passwort der frischen Instanz (Route nur erreichbar, solange
/// keins gesetzt ist); Trilium antwortet mit Redirect auf die Login-Seite.
pub(crate) fn set_password(project: &str, password: &str) -> Result<(), String> {
let form = format!("password1={0}&password2={0}", uri_encode(password));
let code = http_post(project, "/set-password", Some(&form), 30)?;
if code != 302 {
return Err(format!("Passwort setzen fehlgeschlagen (HTTP {code})"));
}
Ok(())
}
/// Formular-/Setup-POST außerhalb der ETAPI; liefert den Statuscode.
fn http_post(
project: &str,
path: &str,
form: Option<&str>,
timeout_s: u32,
) -> Result<u16, String> {
let mut cmd = Command::new("curl");
cmd.args(["-sS", "-m", &timeout_s.to_string(), "-o", "/dev/null", "-w", "%{http_code}", "-X", "POST"]);
if let Some(form) = form {
cmd.args(["--data", form]);
}
cmd.arg(format!("{}{}", base_url(project), path));
let out = cmd.output().map_err(|e| format!("curl: {e}"))?;
String::from_utf8_lossy(&out.stdout)
.trim()
.parse()
.map_err(|_| format!("POST {path}: {}", String::from_utf8_lossy(&out.stderr)))
}
/// Holt per dokumentiertem Login einen ETAPI-Token (Passwort kommt aus dem
/// Wizard und wird nicht gespeichert).
pub(crate) fn login(project: &str, password: &str) -> Result<String, String> {
let (code, value) = etapi(
project,
"POST",
"/etapi/auth/login",
None,
Some(&json!({ "password": password })),
)?;
if code != 201 {
return Err(format!("ETAPI-Login fehlgeschlagen (HTTP {code})"));
}
value["authToken"]
.as_str()
.map(str::to_string)
.ok_or_else(|| "ETAPI-Login ohne authToken".into())
}
/// Keyring-Ablage des ETAPI-Tokens (Service wie die übrigen ai-control-Keys).
const TOKEN_SERVICE: &str = "ai-control-trilium";
pub(crate) fn store_token(project: &str, token: &str) -> Result<(), String> {
keyring::Entry::new(TOKEN_SERVICE, project)
.and_then(|e| e.set_password(token))
.map_err(|e| format!("Keyring: {e}"))
}
pub(crate) fn read_token(project: &str) -> Result<String, String> {
keyring::Entry::new(TOKEN_SERVICE, project)
.and_then(|e| e.get_password())
.map_err(|e| format!("Keyring: {e}"))
}
pub(crate) fn delete_token(project: &str) {
if let Ok(entry) = keyring::Entry::new(TOKEN_SERVICE, project) {
let _ = entry.delete_credential();
}
}
/// Percent-Encoding für Query-Parameter (ETAPI-Suche).
pub(crate) fn uri_encode(s: &str) -> String {
let mut out = String::new();
for b in s.bytes() {
match b {
b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'.' | b'_' | b'~' => {
out.push(b as char)
}
_ => out.push_str(&format!("%{b:02X}")),
}
}
out
}
/// Runtime der gepinnten Version liegt entpackt da.
pub(crate) fn runtime_ready(paths: &Paths) -> bool {
runtime_binary(paths).is_file()
}
/// Antwortet die Projekt-Instanz gerade? (Ein Versuch, ohne Warten.)
pub(crate) fn instance_running(project: &str) -> bool {
http_ok(project, "/", 1)
}
/// Prüft den gespeicherten Token gegen die Instanz (GET /etapi/app-info).
pub(crate) fn token_ok(project: &str) -> bool {
let Ok(token) = read_token(project) else { return false };
matches!(etapi(project, "GET", "/etapi/app-info", Some(&token), None), Ok((200, _)))
}
/// Findet unter `parent` das Kind mit diesem Titel oder legt es als
/// Buch-Notiz an (Triliums Ordner-Äquivalent: Notiz mit Kindern).
fn find_or_create_child(
project: &str,
token: &str,
parent: &str,
title: &str,
) -> Result<String, String> {
let (code, parent_note) =
etapi(project, "GET", &format!("/etapi/notes/{parent}"), Some(token), None)?;
if code != 200 {
return Err(format!("ETAPI: Notiz {parent} nicht lesbar (HTTP {code})"));
}
for child in parent_note["childNoteIds"].as_array().into_iter().flatten() {
let Some(id) = child.as_str() else { continue };
let (code, note) =
etapi(project, "GET", &format!("/etapi/notes/{id}"), Some(token), None)?;
if code == 200 && note["title"].as_str() == Some(title) {
return Ok(id.to_string());
}
}
let (code, created) = etapi(
project,
"POST",
"/etapi/create-note",
Some(token),
Some(&json!({ "parentNoteId": parent, "title": title, "type": "book", "content": "" })),
)?;
if code != 201 {
return Err(format!("ETAPI: Ordner-Notiz „{title}“ nicht anlegbar (HTTP {code})"));
}
created["note"]["noteId"]
.as_str()
.map(str::to_string)
.ok_or_else(|| "ETAPI: create-note ohne noteId".into())
}
/// Archiviert einen Markdown-Text als Trilium-Notiz: HTML-Konvertierung,
/// Ordner-Pfad als Notiz-Hierarchie unter root, Beschreibung und Schlagwörter
/// als Labels. Liefert die noteId.
pub(crate) fn archive_note(
project: &str,
title: &str,
markdown: &str,
folder: Option<&str>,
description: Option<&str>,
tags: &[String],
) -> Result<String, String> {
let token = read_token(project)?;
let html = {
let parser = pulldown_cmark::Parser::new_ext(markdown, pulldown_cmark::Options::all());
let mut html = String::new();
pulldown_cmark::html::push_html(&mut html, parser);
html
};
let mut parent = "root".to_string();
if let Some(folder) = folder {
for segment in folder.split('/').map(str::trim).filter(|s| !s.is_empty()) {
parent = find_or_create_child(project, &token, &parent, segment)?;
}
}
let (code, created) = etapi(
project,
"POST",
"/etapi/create-note",
Some(&token),
Some(&json!({
"parentNoteId": parent,
"title": title,
"type": "text",
"content": html,
})),
)?;
if code != 201 {
return Err(format!("ETAPI: Notiz nicht anlegbar (HTTP {code})"));
}
let note_id = created["note"]["noteId"]
.as_str()
.map(str::to_string)
.ok_or_else(|| String::from("ETAPI: create-note ohne noteId"))?;
let mut labels: Vec<(&str, String)> = Vec::new();
if let Some(d) = description {
labels.push(("description", d.to_string()));
}
for tag in tags {
labels.push(("tag", tag.clone()));
}
for (name, value) in labels {
let (code, _) = etapi(
project,
"POST",
"/etapi/attributes",
Some(&token),
Some(&json!({ "noteId": note_id, "type": "label", "name": name, "value": value })),
)?;
if code != 201 {
return Err(format!("ETAPI: Label {name} nicht setzbar (HTTP {code})"));
}
}
Ok(note_id)
}
#[derive(serde::Serialize)]
pub(crate) struct Hit {
pub(crate) note_id: String,
pub(crate) title: String,
}
/// Volltextsuche über die Projekt-Instanz; `tag` engt auf das Label
/// `#tag=<wert>` ein (so setzt archive_note Schlagwörter).
pub(crate) fn search_notes(
project: &str,
query: &str,
tag: Option<&str>,
limit: usize,
) -> Result<Vec<Hit>, String> {
let token = read_token(project)?;
let mut q = query.trim().to_string();
if let Some(tag) = tag {
q = format!("{q} #tag=\"{}\"", tag.replace('"', "")).trim().to_string();
}
let (code, value) = etapi(
project,
"GET",
&format!("/etapi/notes?search={}&limit={limit}", uri_encode(&q)),
Some(&token),
None,
)?;
if code != 200 {
return Err(format!("ETAPI-Suche fehlgeschlagen (HTTP {code})"));
}
Ok(
value["results"]
.as_array()
.into_iter()
.flatten()
.filter_map(|n| {
Some(Hit {
note_id: n["noteId"].as_str()?.to_string(),
title: n["title"].as_str().unwrap_or("(ohne Titel)").to_string(),
})
})
.collect(),
)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn port_stabil_und_im_bereich() {
let a = port_for("projekt-a");
assert_eq!(a, port_for("projekt-a"));
assert!((27200..27982).contains(&a));
assert_ne!(a, port_for("projekt-b"));
}
#[test]
fn pfade_unter_config_dir() {
let p = crate::domain::testutil::tmp_paths();
assert!(runtime_dir(&p).starts_with(p.config_dir()));
assert!(data_dir(&p, "proj").starts_with(trilium_root(&p)));
}
}
src-tauri/src/lib.rs
+17 -6
View File
@@ -95,11 +95,16 @@ pub fn run() {
// Das Dock-Icon erst nach dem App-Start setzen: in setup() gesetzt
// überschreibt macOS es beim Anlegen des Dock-Tiles wieder.
.run(move |app, event| {
if let tauri::RunEvent::Ready = event {
if let Some(icon) = icon.as_deref() {
platform::set_dock_icon(icon);
match event {
tauri::RunEvent::Ready => {
if let Some(icon) = icon.as_deref() {
platform::set_dock_icon(icon);
}
platform::activate_self(app);
}
platform::activate_self(app);
// Von diesem Prozess gestartete Trilium-Instanzen enden mit ihm.
tauri::RunEvent::Exit => domain::trilium::stop_all(),
_ => {}
}
});
}
@@ -108,8 +113,14 @@ pub fn run() {
// dem offenen Fenster über ai-control.desktop das App-Icon zu.
platform::set_app_id("ai-control");
app::main_builder()
.run(context)
.expect("error while running tauri application");
.build(context)
.expect("error while building tauri application")
.run(|_, event| {
// Von diesem Prozess gestartete Trilium-Instanzen enden mit ihm.
if let tauri::RunEvent::Exit = event {
domain::trilium::stop_all();
}
});
}
}
}
src-tauri/src/mcp.rs
+94 -154
View File
@@ -1,8 +1,9 @@
//! Minimaler MCP-stdio-Server (`app --mcp-panel`), den claude als Tool-Server
//! startet. Er stellt genau ein Tool bereit: `write_panel(text)` schreibt den
//! Text in die Panel-Datei aus `AI_CONTROL_PANEL` (dieselbe Env, die der
//! Terminal-Prozess der PTY mitgibt und die claude an seine MCP-Kinder vererbt).
//! Der bestehende Datei-Watcher im Terminal-Prozess zieht den Inhalt ins Panel.
//! startet. Die Tools kommen aus der Modul-Registry (domain/modules.rs);
//! Puffer-Kanäle laufen über die AI_CONTROL_*-Dateipfade, die der
//! Terminal-Prozess der PTY mitgibt und die claude an seine MCP-Kinder
//! vererbt. Der Datei-Watcher im Terminal-Prozess zieht Änderungen als
//! Events in die Panel-Fenster.
//!
//! Protokoll: JSON-RPC 2.0, newline-getrennt (ein Objekt pro Zeile).
@@ -97,14 +98,16 @@ fn tool_def(name: &str) -> Value {
"name": "write_panel",
"description":
"Legt einen längeren Entwurf (ADR, E-Mail, Dokument, Spezifikation, \
Commit-Message, Textbaustein) im ai-control-Panel neben dem Terminal \
ab, wo er mit der Maus selektierbar und über einen Button kopierbar \
ist. Statt den Text zusätzlich als Fließtext auszugeben, dieses Tool \
Commit-Message, Textbaustein) als Notiz im Trilium-Archiv des \
Projekts an und öffnet sie im Trilium-Fenster neben dem Terminal. \
Statt den Text zusätzlich als Fließtext auszugeben, dieses Tool \
aufrufen und im Chat nur kurz bestätigen. Für eine bestehende Datei \
IMMER `path` statt `text` übergeben — der Server liest die Datei \
selbst von der Platte, ohne dass ihr Inhalt generiert werden muss. \
`path` muss im Projekt-, Arbeits- oder Archiv-Ordner liegen \
(reguläre Datei, max. 2 MB).",
`path` muss im Projekt- oder Arbeitsordner liegen (reguläre Datei, \
max. 2 MB). `folder`, `description` und `tags` kuratieren die \
Notiz: Ordner werden zur Notiz-Hierarchie, Beschreibung und \
Schlagwörter zu Labels.",
"inputSchema": {
"type": "object",
"properties": {
@@ -115,8 +118,23 @@ fn tool_def(name: &str) -> Value {
"path": {
"type": "string",
"description":
"Statt `text`: Pfad einer vorhandenen Datei, deren Inhalt ins \
Panel geladen wird. Genau eines von beiden angeben.",
"Statt `text`: Pfad einer vorhandenen Datei, deren Inhalt \
die Notiz wird. Genau eines von beiden angeben.",
},
"folder": {
"type": "string",
"description":
"Optionaler Ordner-Pfad im Archiv (z. B. `konzepte/panel`). \
Wird als Notiz-Hierarchie angelegt.",
},
"description": {
"type": "string",
"description": "Einzeiler zum Inhalt (Label `description`).",
},
"tags": {
"type": "array",
"items": { "type": "string" },
"description": "Schlagwörter (Labels `tag`, kurze Slugs).",
}
},
},
@@ -210,69 +228,20 @@ fn tool_def(name: &str) -> Value {
(„zeig die ToDos“).",
"inputSchema": { "type": "object", "properties": {} },
}),
"archive_panel" => json!({
"name": "archive_panel",
"description":
"Archiviert den aktuell im Panel liegenden Entwurf dauerhaft als \
Markdown-Datei im Archiv-Home des Projekts. Auf Wunsch nutzen \
(Nutzer sagt etwa „archiviere das“). Beim Archivieren `folder`, \
`description` und `tags` mitgeben — einmalige Kuratierung im Moment \
des Archivierens, landet im Frontmatter. Ist kein Archiv-Home \
konfiguriert, meldet das Tool das zurück; gesetzt wird es in den \
Projekt-Einstellungen oder im Panel.",
"inputSchema": {
"type": "object",
"properties": {
"folder": {
"type": "string",
"description":
"Optionaler Unterordner im Archiv-Home, relativ (z. B. \
`konzepte/panel`). Wird angelegt.",
},
"description": {
"type": "string",
"description": "Einzeiler zum Inhalt fürs Frontmatter.",
},
"tags": {
"type": "array",
"items": { "type": "string" },
"description": "Schlagwörter fürs Frontmatter (kurze Slugs).",
}
},
},
}),
"show_archive" => json!({
"name": "show_archive",
"description":
"Zeigt die Archiv-Übersicht des Projekts als Wiki-Seite im Panel: \
Dokumente nach Ordnern gruppiert, mit Beschreibungen und \
klickbaren Schlagwort-Links. Mit `tag` stattdessen die Seite eines \
Schlagworts. Nutzen, wenn der Nutzer das Archiv sehen will \
(„zeig das Archiv“).",
"inputSchema": {
"type": "object",
"properties": {
"tag": {
"type": "string",
"description": "Optional: Seite dieses Schlagworts statt der Übersicht.",
}
},
},
}),
"search_archive" => json!({
"name": "search_archive",
"description":
"Volltext-Suche über das Panel-Archiv des Projekts (FTS5-Syntax: \
Wörter, \"Phrasen\", Präfix*). Die Treffer erscheinen als Kacheln \
im Panel; das Tool liefert sie zusätzlich mit Pfad und Snippet \
zurück. Nutzen, wenn der Nutzer im Archiv suchen will („such im \
Archiv nach …“).",
"Volltext-Suche über das Trilium-Archiv des Projekts (Triliums \
Suchsyntax: Wörter, \"Phrasen\", Operatoren). Die Treffer \
erscheinen als Kacheln im Panel; das Tool liefert sie zusätzlich \
mit Titel und noteId zurück. Nutzen, wenn der Nutzer im Archiv \
suchen will („such im Archiv nach …“).",
"inputSchema": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Suchanfrage (FTS5-Syntax).",
"description": "Suchanfrage (Trilium-Suchsyntax).",
},
"tag": {
"type": "string",
@@ -300,9 +269,7 @@ fn call_tool(req: &Value) -> Value {
"show_commands" => call_show_commands(),
"write_todos" => call_write_todos(req),
"show_todos" => call_show_todos(),
"archive_panel" => call_archive(req),
"search_archive" => call_search(req),
"show_archive" => call_show_archive(req),
other => err(format!("Unbekanntes Tool: {other}")),
}
}
@@ -324,44 +291,75 @@ fn env_path(var: &str) -> Result<String, Value> {
.map_err(|_| err(format!("{var} nicht gesetzt (Terminal außerhalb ai-control).")))
}
/// Schreibt Text in die Panel-Datei aus AI_CONTROL_PANEL. Ein frischer
/// Entwurf löst die Quell-Verknüpfung des Dokument-Tabs (`<panel>.source`,
/// gesetzt beim Öffnen eines Archiv-Dokuments) — Edits gehören danach wieder
/// nur dem Panel, nicht der zuletzt geöffneten Archiv-Datei.
fn write_panel_text(text: &str) -> Result<(), Value> {
let path = env_path("AI_CONTROL_PANEL")?;
std::fs::write(&path, text).map_err(|e| err(format!("Panel-Datei nicht schreibbar: {e}")))?;
match std::fs::remove_file(format!("{path}.source")) {
Ok(()) => Ok(()),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()),
Err(e) => Err(err(format!("Quell-Verknüpfung nicht gelöst: {e}"))),
/// Titelzeile: erste Überschrift (## …) oder sonst erste nicht-leere Zeile —
/// wird der Notiz-Titel von write_panel.
fn first_line(text: &str) -> String {
let mut fallback: Option<&str> = None;
for line in text.lines() {
let t = line.trim();
if t.is_empty() {
continue;
}
let h = t.trim_start_matches('#').trim();
if t.starts_with('#') && !h.is_empty() {
return h.to_string();
}
fallback.get_or_insert(t);
}
fallback.unwrap_or("entwurf").to_string()
}
/// Legt den Entwurf als Trilium-Notiz an (ETAPI der Projekt-Instanz; Token
/// aus dem Keyring) und meldet die noteId über den noteopen-Kanal — die
/// Fenster öffnen die Notiz daraufhin im Trilium-Fenster.
fn call_write(req: &Value) -> Value {
let project = std::env::var("AI_CONTROL_PROJECT").unwrap_or_default();
let args = &req["params"]["arguments"];
// `path` lädt eine vorhandene Datei serverseitig — der schnelle Weg, ohne
// dass das Modell den Inhalt Token für Token als `text` generieren muss.
// Der Zugriff ist auf Projekt-, Arbeits- und Archiv-Ordner begrenzt
// Der Zugriff ist auf Projekt- und Arbeitsordner begrenzt
// (read_for_panel_in): das Tool ist promptfrei freigegeben und darf das
// Read-Permission-Modell von Claude Code nicht umgehen.
let (text, ok_msg) = match args["path"].as_str() {
let text = match args["path"].as_str() {
Some(src) => {
let project = std::env::var("AI_CONTROL_PROJECT").unwrap_or_default();
let paths = crate::domain::paths::Paths::real();
match crate::domain::project::read_for_panel_in(&paths, &project, src) {
Ok(content) => (content, "Datei ins Panel geladen."),
Ok(content) => content,
Err(e) => return err(format!("Datei nicht geladen: {e}")),
}
}
None => (
args["text"].as_str().unwrap_or("").to_string(),
"Entwurf ins Panel geschrieben.",
),
None => args["text"].as_str().unwrap_or("").to_string(),
};
match write_panel_text(&text) {
Ok(()) => ok(ok_msg.into()),
Err(e) => e,
if text.trim().is_empty() {
return err("Kein Inhalt — `text` oder `path` angeben.".into());
}
let title = first_line(&text);
let tags: Vec<String> = args["tags"]
.as_array()
.map(|a| a.iter().filter_map(Value::as_str).map(str::to_string).collect())
.unwrap_or_default();
let note_id = match crate::domain::trilium::archive_note(
&project,
&title,
&text,
args["folder"].as_str().filter(|f| !f.trim().is_empty()),
args["description"].as_str().filter(|d| !d.trim().is_empty()),
&tags,
) {
Ok(note_id) => note_id,
Err(e) => {
return err(format!(
"Notiz nicht angelegt: {e}. Läuft die Trilium-Instanz? (Trilium-Modul in den Projekt-Einstellungen)"
))
}
};
let noteopen = match env_path("AI_CONTROL_NOTEOPEN") {
Ok(path) => path,
Err(e) => return e,
};
match std::fs::write(&noteopen, json!({ "noteId": note_id }).to_string()) {
Ok(()) => ok(format!("Notiz {note_id} („{title}“) im Archiv angelegt.")),
Err(e) => err(format!("Notiz {note_id} angelegt, aber Fenster nicht benachrichtigt: {e}")),
}
}
@@ -508,71 +506,15 @@ fn call_write_todos(req: &Value) -> Value {
}
}
/// `dir` gibt es hier bewusst nicht mehr: Das Setzen des Archiv-Homes vergibt
/// über `add_archive_permission` dauerhafte Rechte in der settings.json des
/// Projekts (additionalDirectories + Edit-Allow) — das bleibt der UI mit
/// Nutzer-Dialog vorbehalten, nicht einem Tool-Argument des Modells.
fn call_archive(req: &Value) -> Value {
let project = std::env::var("AI_CONTROL_PROJECT").unwrap_or_default();
let args = &req["params"]["arguments"];
let meta = crate::domain::archive::ArchiveMeta {
folder: args["folder"].as_str().map(str::to_string),
description: args["description"].as_str().map(str::to_string),
tags: args["tags"]
.as_array()
.map(|a| a.iter().filter_map(Value::as_str).map(str::to_string).collect())
.unwrap_or_default(),
};
match crate::domain::archive::archive_panel_content(&project, None, &meta) {
Ok(path) => ok(format!("Archiviert: {}", path.display())),
Err(e) => err(format!(
"Nicht archiviert: {e}. Archiv-Ordner im Panel oder in den Projekt-Einstellungen wählen."
)),
}
}
/// Archiv-Übersicht bzw. Schlagwort-Seite generieren und in den Wiki-Puffer
/// schreiben — der Watcher zieht sie als Wiki-Ansicht ins Panel.
fn call_show_archive(req: &Value) -> Value {
let project = std::env::var("AI_CONTROL_PROJECT").unwrap_or_default();
let home = match crate::domain::archive::require_archive_home(&project) {
Ok(home) => home,
Err(e) => return err(e),
};
let tag = req["params"]["arguments"]["tag"].as_str();
let page = match crate::domain::archive_index::archive_page(&home, tag) {
Ok(page) => page,
Err(e) => return err(e),
};
let path = match env_path("AI_CONTROL_WIKI") {
Ok(path) => path,
Err(e) => return e,
};
let json = match serde_json::to_string(&page) {
Ok(json) => json,
Err(e) => return err(e.to_string()),
};
match std::fs::write(&path, json) {
Ok(()) => ok(match tag {
Some(t) => format!("Schlagwort-Seite #{t} im Panel."),
None => "Archiv-Übersicht im Panel.".to_string(),
}),
Err(e) => err(format!("Wiki-Datei nicht schreibbar: {e}")),
}
}
/// Volltext-Suche übers Archiv: Treffer als JSON in die Suchtreffer-Datei
/// (der Watcher zieht sie als Kacheln ins Panel) und als Text zurück an claude.
/// Volltext-Suche übers Trilium-Archiv: Treffer als JSON in die
/// Suchtreffer-Datei (der Watcher zieht sie als Kacheln ins Panel) und als
/// Text zurück an claude.
fn call_search(req: &Value) -> Value {
let project = std::env::var("AI_CONTROL_PROJECT").unwrap_or_default();
let home = match crate::domain::archive::require_archive_home(&project) {
Ok(home) => home,
Err(e) => return err(e),
};
let args = &req["params"]["arguments"];
let query = args["query"].as_str().unwrap_or("");
let tag = args["tag"].as_str();
let hits = match crate::domain::archive_search::search(&home, query, tag, 20) {
let hits = match crate::domain::trilium::search_notes(&project, query, tag, 20) {
Ok(hits) => hits,
Err(e) => return err(format!("Suche fehlgeschlagen: {e}")),
};
@@ -583,7 +525,6 @@ fn call_search(req: &Value) -> Value {
let payload = json!({
"query": query,
"tag": tag,
"home": home.display().to_string(),
"hits": hits,
});
if let Err(e) = std::fs::write(&search_path, payload.to_string()) {
@@ -591,12 +532,11 @@ fn call_search(req: &Value) -> Value {
}
let list: Vec<String> = hits
.iter()
.map(|h| format!("- {} — {} ({})", h.relpath, h.title, h.snippet))
.map(|h| format!("- {} ({})", h.title, h.note_id))
.collect();
ok(format!(
"{} Treffer, als Kacheln im Panel. Archiv: {}\n{}",
"{} Treffer, als Kacheln im Panel.\n{}",
hits.len(),
home.display(),
list.join("\n")
))
}
src-tauri/src/platform/linux/mod.rs
-5
View File
@@ -44,11 +44,6 @@ pub(crate) fn set_app_id(name: &str) {
glib::set_prgname(Some(name));
}
pub(crate) fn reveal_path(path: &Path) {
let target = path.parent().unwrap_or(path);
let _ = Command::new("xdg-open").arg(target).spawn();
}
/// Selbstinstallation gibt es nur unter macOS — hier installieren deb/rpm.
pub(crate) fn offer_move_to_applications(_paths: &crate::domain::paths::Paths) {}
src-tauri/src/platform/macos.rs
+1 -4
View File
@@ -78,10 +78,6 @@ pub(crate) fn focus_terminal(pid: u32) {
/// Wayland-app_id gibt es nur unter Linux.
pub(crate) fn set_app_id(_name: &str) {}
pub(crate) fn reveal_path(path: &Path) {
let _ = Command::new("open").arg("-R").arg(path).spawn();
}
// ---------- Selbstinstallation ----------
/// App-Bundle zum Programmpfad: …/ai-control.app/Contents/MacOS/ai-control.
@@ -322,3 +318,4 @@ pub(crate) fn init_tray(app: &tauri::AppHandle, cb: TrayCallbacks) -> Result<(),
.map_err(|e| e.to_string())?;
Ok(())
}
src-tauri/src/platform/mod.rs
+1 -1
View File
@@ -6,7 +6,7 @@
//! Prozesse terminal_pids, kill_terminal
//! Fokus/Aktivierung focus_terminal, activate_self, yield_activation
//! Fenster/Icons set_dock_icon, set_app_id
//! Dateisystem home_dir, write_secret_file, symlink, reveal_path
//! Dateisystem home_dir, write_secret_file, symlink
//! Shell shell_command
//! Secrets KeychainStore (impl ApikeyStore), apikey_helper_command,
//! oauth_keychain_exists, oauth_keychain_delete
src-tauri/src/platform/windows.rs
+1 -6
View File
@@ -47,12 +47,6 @@ pub(crate) fn set_app_id(_name: &str) {}
/// Selbstinstallation gibt es nur unter macOS — hier installiert der NSIS-Setup.
pub(crate) fn offer_move_to_applications(_paths: &crate::domain::paths::Paths) {}
pub(crate) fn reveal_path(path: &Path) {
let _ = Command::new("explorer")
.arg(format!("/select,{}", path.display()))
.spawn();
}
// ---------- Dateisystem / Shell ----------
pub(crate) fn home_dir() -> PathBuf {
@@ -125,3 +119,4 @@ pub(crate) fn init_tray(app: &tauri::AppHandle, cb: TrayCallbacks) -> Result<(),
.map_err(|e| e.to_string())?;
Ok(())
}
src-tauri/src/terminal.rs
+23 -185
View File
@@ -5,9 +5,7 @@ use std::io::{Read, Write};
use std::sync::Mutex;
use tauri::{AppHandle, Emitter, Manager, State, WebviewUrl, WebviewWindowBuilder};
use crate::domain::paths::{
commands_file, panel_file, panel_source_file, search_file, wiki_file, Paths,
};
use crate::domain::paths::{commands_file, search_file, Paths};
use crate::domain::project::{
project_config, project_pool_dir, verify_project_dir_in, ProjectConfig,
};
@@ -147,12 +145,19 @@ pub fn term_start(
let _ = std::fs::write(path, "");
}
}
// Quell-Verknüpfung der Vorsession lösen — der Dokument-Puffer startet leer,
// Edits dürfen nicht in die zuletzt geöffnete Archiv-Datei laufen.
match std::fs::remove_file(panel_source_file(&project)) {
Ok(()) => {}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
Err(e) => return Err(e.to_string()),
// Trilium-Modul an: Projekt-Instanz zur Session hochfahren (im Thread —
// der Start wartet bis zu 20 s auf den Port). Fehler landen im Dev-Log;
// die Tools melden eine fehlende Instanz ohnehin laut.
if crate::domain::modules::active_in(&paths, &project)?
.iter()
.any(|m| m.id == "trilium")
{
let proj = project.clone();
std::thread::spawn(move || {
if let Err(e) = crate::domain::trilium::ensure_instance(&Paths::real(), &proj) {
log::warn!("Trilium-Start ({proj}): {e}");
}
});
}
let mut cmd = crate::platform::shell_command(&claude_command(&paths));
@@ -429,191 +434,24 @@ pub fn todos_update(
}
/// Quell-Verknüpfung des Dokument-Tabs setzen: ab jetzt schreibt jeder
/// Editor-Commit den Body in diese Archiv-Datei zurück.
fn link_panel_source(project: &str, path: &std::path::Path) -> Result<(), String> {
std::fs::write(panel_source_file(project), path.display().to_string())
.map_err(|e| e.to_string())
}
/// Aktuelle Quell-Verknüpfung, falls gesetzt.
fn panel_source(project: &str) -> Option<std::path::PathBuf> {
std::fs::read_to_string(panel_source_file(project))
.ok()
.map(|s| std::path::PathBuf::from(s.trim()))
.filter(|p| !p.as_os_str().is_empty())
}
/// Verknüpfung nach einer Dokument-Operation nachziehen: zeigt sie auf den
/// alten Pfad, wandert sie mit; `None` löst sie (gelöschtes Dokument).
fn relink(
project: &str,
old: &std::path::Path,
new: Option<&std::path::Path>,
/// Suche aus dem Panel-Suchfeld: läuft wie das MCP-Tool search_archive über
/// die ETAPI der Projekt-Instanz und schreibt die Treffer-Datei; der Watcher
/// zieht sie in die Ansicht (beide Fenster).
#[tauri::command]
pub async fn search_run(
project: String,
query: String,
tag: Option<String>,
) -> Result<(), String> {
if panel_source(project).as_deref() != Some(old) {
return Ok(());
}
match new {
Some(p) => link_panel_source(project, p),
None => std::fs::remove_file(panel_source_file(project)).map_err(|e| e.to_string()),
}
}
/// Wie `relink`, für einen verschobenen Ordner: eine Verknüpfung auf ein
/// Dokument darin wandert mit.
fn relink_folder(
project: &str,
old: &std::path::Path,
new: &std::path::Path,
) -> Result<(), String> {
let Some(cur) = panel_source(project) else {
return Ok(());
};
match cur.strip_prefix(old) {
Ok(rest) => link_panel_source(project, &new.join(rest)),
Err(_) => Ok(()),
}
}
/// Schreibt den Panel-Inhalt (Titel-Edit im Panel). Der Watcher meldet die
/// Änderung als `panel-update` an alle Fenster. Zeigt der Dokument-Tab ein
/// Archiv-Dokument (Quell-Verknüpfung), wandert der Body implizit in die
/// Archiv-Datei zurück; ihre Frontmatter bleibt.
#[tauri::command]
pub fn panel_set(project: String, text: String) -> Result<(), String> {
std::fs::write(panel_file(&project), &text).map_err(|e| e.to_string())?;
match panel_source(&project) {
Some(src) => crate::domain::archive_ops::write_body(&src, &text),
None => Ok(()),
}
}
/// Lädt ein Archiv-Dokument in den Dokument-Puffer (Treffer-Klick in der
/// Suche) — ohne Frontmatter-Block, wie ein frischer Entwurf — und setzt die
/// Quell-Verknüpfung fürs Zurückschreiben. Der Watcher meldet den neuen
/// Inhalt als `panel-update`.
#[tauri::command]
pub fn panel_load(project: String, path: String) -> Result<(), String> {
let text = std::fs::read_to_string(&path).map_err(|e| format!("{path}: {e}"))?;
let body = crate::domain::archive::strip_frontmatter(&text);
std::fs::write(panel_file(&project), body).map_err(|e| e.to_string())?;
link_panel_source(&project, std::path::Path::new(&path))
}
/// Suche aus dem Panel-Suchfeld: läuft wie das MCP-Tool search_archive und
/// schreibt die Treffer-Datei; der Watcher zieht sie in die Ansicht (beide
/// Fenster).
#[tauri::command]
pub fn search_run(project: String, query: String, tag: Option<String>) -> Result<(), String> {
let home = crate::domain::archive::require_archive_home(&project)?;
let hits = crate::domain::archive_search::search(&home, &query, tag.as_deref(), 20)?;
let hits = crate::domain::trilium::search_notes(&project, &query, tag.as_deref(), 20)?;
let payload = serde_json::json!({
"query": query,
"tag": tag,
"home": home.display().to_string(),
"hits": hits,
});
std::fs::write(search_file(&project), payload.to_string()).map_err(|e| e.to_string())
}
/// Öffnet ein Wiki-Ziel: `tag:x` → Schlagwort-Seite, `tag:` →
/// Archiv-Übersicht in den Wiki-Puffer (`wiki-update`); ein Dokumentname
/// (Wikilink, Backlink) wird über den Index aufgelöst und wie ein
/// Suchtreffer in den Dokument-Puffer geladen (`panel-update`).
#[tauri::command]
pub fn wiki_open(project: String, name: String) -> Result<(), String> {
let home = crate::domain::archive::require_archive_home(&project)?;
match name.strip_prefix("tag:") {
Some(tag) => {
let json = serde_json::to_string(&crate::domain::archive_index::archive_page(
&home,
(!tag.is_empty()).then_some(tag),
)?)
.map_err(|e| e.to_string())?;
std::fs::write(wiki_file(&project), json).map_err(|e| e.to_string())
}
None => {
let rel = crate::domain::archive_index::resolve_doc(&home, &name)?;
let path = home.join(rel);
let text =
std::fs::read_to_string(&path).map_err(|e| format!("{}: {e}", path.display()))?;
let body = crate::domain::archive::strip_frontmatter(&text);
std::fs::write(panel_file(&project), body).map_err(|e| e.to_string())?;
link_panel_source(&project, &path)
}
}
}
/// Frische Archiv-Übersicht in den Wiki-Puffer — Abschluss der
/// Dokument-/Ordner-Operationen; der Watcher meldet `wiki-update`.
fn wiki_refresh_page(project: &str, home: &std::path::Path) -> Result<(), String> {
let json = serde_json::to_string(&crate::domain::archive_index::archive_page(home, None)?)
.map_err(|e| e.to_string())?;
std::fs::write(wiki_file(project), json).map_err(|e| e.to_string())
}
/// Verschiebt ein Archiv-Dokument in einen anderen Ordner (leer = Wurzel).
#[tauri::command]
pub fn archive_move(project: String, relpath: String, folder: String) -> Result<(), String> {
let home = crate::domain::archive::require_archive_home(&project)?;
let old = home.join(&relpath);
let new_rel = crate::domain::archive_ops::move_doc(&home, &relpath, &folder)?;
relink(&project, &old, Some(&home.join(new_rel)))?;
wiki_refresh_page(&project, &home)
}
/// Benennt ein Archiv-Dokument um (Slug hinter erhaltenem Zeitstempel).
#[tauri::command]
pub fn archive_rename(project: String, relpath: String, name: String) -> Result<(), String> {
let home = crate::domain::archive::require_archive_home(&project)?;
let old = home.join(&relpath);
let new_rel = crate::domain::archive_ops::rename_doc(&home, &relpath, &name)?;
relink(&project, &old, Some(&home.join(new_rel)))?;
wiki_refresh_page(&project, &home)
}
/// Löscht ein Archiv-Dokument; danach zeigt das Wiki die Übersicht.
#[tauri::command]
pub fn archive_delete(project: String, relpath: String) -> Result<(), String> {
let home = crate::domain::archive::require_archive_home(&project)?;
crate::domain::archive_ops::delete_doc(&home, &relpath)?;
relink(&project, &home.join(&relpath), None)?;
wiki_refresh_page(&project, &home)
}
/// Verschiebt/benennt einen Archiv-Ordner um; danach Übersicht.
#[tauri::command]
pub fn archive_move_folder(project: String, folder: String, to: String) -> Result<(), String> {
let home = crate::domain::archive::require_archive_home(&project)?;
crate::domain::archive_ops::move_folder(&home, &folder, &to)?;
relink_folder(&project, &home.join(&folder), &home.join(&to))?;
wiki_refresh_page(&project, &home)
}
/// Legt einen Ordner im Archiv an (Plus im Baum); danach Übersicht.
#[tauri::command]
pub fn archive_create_folder(project: String, folder: String) -> Result<(), String> {
let home = crate::domain::archive::require_archive_home(&project)?;
crate::domain::archive_ops::create_folder(&home, &folder)?;
wiki_refresh_page(&project, &home)
}
/// Legt ein leeres Dokument an (Plus im Listenkopf) und öffnet es im
/// Dokument-Tab: leerer Dokument-Puffer plus Quell-Verknüpfung — das
/// Getippte landet über `panel_set` in der Archiv-Datei. Die Übersicht
/// bleibt hier unangetastet; der Wiki-Tab lädt sie beim nächsten Aktivieren
/// frisch (zwei konkurrierende Puffer-Events würden sonst um den aktiven Tab
/// rennen).
#[tauri::command]
pub fn archive_create_doc(project: String, folder: String, name: String) -> Result<(), String> {
let home = crate::domain::archive::require_archive_home(&project)?;
let display = crate::domain::project::display_name_in(&Paths::real(), &project)?;
let rel = crate::domain::archive_ops::create_doc(&home, &folder, &name, &display)?;
let path = home.join(rel);
std::fs::write(panel_file(&project), "").map_err(|e| e.to_string())?;
link_panel_source(&project, &path)
}
/// Löst das Panel in ein eigenes Fenster ab. Existiert es schon, kommt es nach
/// vorn. `panel-detached` blendet das angedockte Panel im Terminal-Fenster aus.
/// Async, weil Fenster-Erzeugung aus einem synchronen Command auf dem
src/archive-form.test.ts
-74
View File
@@ -1,74 +0,0 @@
// Archiv-Formular: Aufklappen, Meta-Aufbereitung, Tastatur.
import { beforeEach, describe, expect, it, vi } from "vitest";
import { initArchiveForm } from "./archive-form";
function setup() {
document.body.innerHTML = `<button id="btn">Archiv</button>`;
const onSubmit = vi.fn();
const form = initArchiveForm(document.getElementById("btn")!, onSubmit);
const root = document.querySelector<HTMLElement>(".archive-form")!;
const inputs = [...root.querySelectorAll("input")];
return { form, onSubmit, root, inputs };
}
describe("initArchiveForm", () => {
beforeEach(() => {
document.body.innerHTML = "";
});
it("klappt auf und zu", () => {
const { form, root } = setup();
expect(root.hidden).toBe(true);
form.toggle();
expect(root.hidden).toBe(false);
form.toggle();
expect(root.hidden).toBe(true);
});
it("liefert getrimmte Meta; Leeres wird undefined, Tags gesplittet", () => {
const { form, onSubmit, root, inputs } = setup();
form.toggle();
inputs[0].value = " konzepte/panel ";
inputs[1].value = "";
inputs[2].value = " adr, infra ,, ";
root.querySelector<HTMLElement>(".archive-form-submit")!.click();
expect(onSubmit).toHaveBeenCalledWith({
folder: "konzepte/panel",
description: undefined,
tags: ["adr", "infra"],
});
expect(root.hidden).toBe(true);
});
/// Sonst gelten Ordner und Schlagwörter des vorigen Dokuments unbemerkt für
/// das nächste — wer direkt Enter drückt, archiviert es falsch einsortiert.
it("startet nach dem Archivieren wieder leer", () => {
const { form, onSubmit, root, inputs } = setup();
form.toggle();
inputs[0].value = "konzepte/panel";
inputs[1].value = "Beschreibung A";
inputs[2].value = "panel, wiki";
root.querySelector<HTMLElement>(".archive-form-submit")!.click();
form.toggle();
expect(inputs.map((i) => i.value)).toEqual(["", "", ""]);
root.querySelector<HTMLElement>(".archive-form-submit")!.click();
expect(onSubmit).toHaveBeenLastCalledWith({
folder: undefined,
description: undefined,
tags: [],
});
});
it("Enter schickt ab, Escape schließt ohne Abschicken", () => {
const { form, onSubmit, root } = setup();
form.toggle();
root.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", bubbles: true }));
expect(root.hidden).toBe(true);
expect(onSubmit).not.toHaveBeenCalled();
form.toggle();
root.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
expect(onSubmit).toHaveBeenCalledOnce();
expect(root.hidden).toBe(true);
});
});
src/archive-form.ts
-74
View File
@@ -1,74 +0,0 @@
/// Archiv-Formular: klappt unter dem Archiv-Button auf und fragt Ordner,
/// Beschreibung und Schlagwörter ab (alles optional); Enter oder der Button
/// archivieren, Escape schließt. Gemeinsam für das angedockte Panel und das
/// abgelöste Fenster.
import { t } from "./messages";
export interface ArchiveFormMeta {
folder?: string;
description?: string;
tags: string[];
}
export function initArchiveForm(
anchor: HTMLElement,
onSubmit: (meta: ArchiveFormMeta) => void,
): { toggle(): void } {
function field(placeholder: string): HTMLInputElement {
const i = document.createElement("input");
i.type = "text";
i.placeholder = placeholder;
return i;
}
const form = document.createElement("div");
form.className = "archive-form";
form.hidden = true;
const folder = field(t("archiveForm.folder"));
const desc = field(t("archiveForm.description"));
const tags = field(t("archiveForm.tags"));
const submit = document.createElement("button");
submit.className = "archive-form-submit";
submit.textContent = t("archiveForm.submit");
form.append(folder, desc, tags, submit);
document.body.append(form);
const meta = (): ArchiveFormMeta => ({
folder: folder.value.trim() || undefined,
description: desc.value.trim() || undefined,
tags: tags.value
.split(",")
.map((t) => t.trim())
.filter(Boolean),
});
// Leeren, weil das Formular zum Fenster gehört und nicht zum Dokument.
const close = () => {
form.hidden = true;
folder.value = "";
desc.value = "";
tags.value = "";
};
const open = () => {
const r = anchor.getBoundingClientRect();
form.style.top = `${r.bottom + 6}px`;
form.style.right = `${Math.max(8, window.innerWidth - r.right - 4)}px`;
form.hidden = false;
folder.focus();
};
const fire = () => {
onSubmit(meta());
close();
};
submit.addEventListener("click", fire);
form.addEventListener("keydown", (e) => {
if (e.key === "Enter") {
e.preventDefault();
fire();
} else if (e.key === "Escape") {
close();
}
});
return { toggle: () => (form.hidden ? open() : close()) };
}
src/commands-view.test.ts
+25 -28
View File
@@ -6,69 +6,66 @@ function modeSetup() {
document.body.innerHTML = `
<div id="tabs">
<button data-mode="commands">Befehle</button>
<button data-mode="draft">Dokument</button>
<button data-mode="wiki">Wiki</button>
<button data-mode="todo">ToDo</button>
<button data-mode="search">Suche</button>
</div>
<div id="title">Mein Titel</div>
<div id="draft-el"></div>
<div id="title"></div>
<div id="cc" hidden></div>
<div id="sc" hidden></div>
<div id="wc" hidden></div>`;
<div id="tc" hidden></div>
<div id="sc" hidden></div>`;
const el = (id: string) => document.getElementById(id)!;
const tab = (m: string) =>
document.querySelector<HTMLElement>(`[data-mode="${m}"]`)!;
const flush = vi.fn();
const mode = initPanelMode({
tabs: [
{ mode: "commands", btn: tab("commands"), content: el("cc"), label: "Befehle" },
{ mode: "draft", btn: tab("draft"), content: null, label: "Dokument" },
{ mode: "wiki", btn: tab("wiki"), content: el("wc"), label: "Wiki" },
{ mode: "todo", btn: tab("todo"), content: el("tc"), label: "ToDo" },
{ mode: "search", btn: tab("search"), content: el("sc"), label: "Suche" },
],
draftEls: [el("draft-el")],
titleEl: el("title"),
flush,
});
return { mode, flush, el, tab };
return { mode, el, tab };
}
describe("initPanelMode", () => {
it("startet im Dokument-Modus mit aktivem Tab", () => {
const { el, tab } = modeSetup();
expect(el("draft-el").hidden).toBe(false);
it("startet ohne aktiven Tab", () => {
const { mode, el } = modeSetup();
expect(mode.current()).toBe(null);
expect(el("cc").hidden).toBe(true);
expect(tab("draft").classList.contains("active")).toBe(true);
expect(document.querySelectorAll(".active").length).toBe(0);
});
it("wechselt Sichtbarkeit, Titel und aktive Markierung", () => {
const { mode, flush, el, tab } = modeSetup();
const { mode, el, tab } = modeSetup();
mode.to("commands");
expect(flush).toHaveBeenCalledOnce();
expect(el("cc").hidden).toBe(false);
expect(el("draft-el").hidden).toBe(true);
expect(el("tc").hidden).toBe(true);
expect(el("title").textContent).toBe("Befehle");
expect(tab("commands").classList.contains("active")).toBe(true);
expect(tab("draft").classList.contains("active")).toBe(false);
mode.to("draft");
expect(el("title").textContent).toBe("Mein Titel");
mode.to("todo");
expect(el("cc").hidden).toBe(true);
expect(el("tc").hidden).toBe(false);
expect(el("title").textContent).toBe("ToDo");
expect(tab("commands").classList.contains("active")).toBe(false);
});
it("Tab-Klick wechselt den Modus", () => {
const { el, tab } = modeSetup();
tab("wiki").click();
expect(el("wc").hidden).toBe(false);
expect(el("draft-el").hidden).toBe(true);
tab("search").click();
expect(el("sc").hidden).toBe(false);
expect(el("cc").hidden).toBe(true);
});
it("clear hebt die Auswahl auf; danach wählt to() wieder aus", () => {
const { mode, el, tab } = modeSetup();
mode.to("commands");
mode.clear();
expect(document.querySelectorAll(".active").length).toBe(0);
expect(el("cc").hidden).toBe(true);
expect(mode.current()).toBe(null);
mode.to("draft");
expect(tab("draft").classList.contains("active")).toBe(true);
expect(el("title").textContent).toBe("Mein Titel");
mode.to("commands");
expect(tab("commands").classList.contains("active")).toBe(true);
expect(el("cc").hidden).toBe(false);
});
});
src/commands-view.ts
+13 -25
View File
@@ -123,54 +123,42 @@ export type PanelMode = string;
export interface ModeTab {
mode: PanelMode;
btn: HTMLElement;
/// Content-Container des Tabs; null für den Entwurfs-Tab, dessen
/// Sichtbarkeit über draftEls läuft.
content: HTMLElement | null;
/// Titelzeilen-Text, wenn der Tab aktiv ist (der Entwurfs-Tab behält
/// seinen Dokument-Titel).
/// Content-Container des Tabs.
content: HTMLElement;
/// Titelzeilen-Text, wenn der Tab aktiv ist.
label: string;
onActivate?: () => void;
}
/// Modus-Umschalter über die Tabs der Registry: blendet Entwurfs-Inhalt samt
/// zugehöriger Kopf-Controls gegen die jeweilige Ansicht aus. Ein Wechsel bei
/// offener Inhalts-Bearbeitung speichert den Entwurf (flush) statt zu
/// blockieren.
export function initPanelMode(opts: {
tabs: ModeTab[];
draftEls: HTMLElement[];
titleEl: HTMLElement;
flush: () => void;
}) {
/// Modus-Umschalter über die Tabs der Registry: blendet die Ansichten
/// gegeneinander aus; die Titelzeile trägt das Label des aktiven Tabs.
export function initPanelMode(opts: { tabs: ModeTab[]; titleEl: HTMLElement }) {
// `null` = kein Tab aktiv (Panel zugeklappt).
let mode: PanelMode | null = "draft";
let draftTitle = "";
let mode: PanelMode | null = null;
function apply() {
for (const tab of opts.tabs) {
if (tab.content) tab.content.hidden = mode !== tab.mode;
tab.content.hidden = mode !== tab.mode;
tab.btn.classList.toggle("active", tab.mode === mode);
}
for (const el of opts.draftEls) el.hidden = mode !== "draft";
const active = opts.tabs.find((tab) => tab.mode === mode);
if (mode && mode !== "draft" && active) opts.titleEl.textContent = active.label;
if (active) opts.titleEl.textContent = active.label;
}
function to(m: PanelMode) {
if (m === mode) return;
opts.flush();
if (mode === "draft") draftTitle = opts.titleEl.textContent || t("panel.tabDraft");
mode = m;
apply();
if (m === "draft") opts.titleEl.textContent = draftTitle;
}
/// Auswahl aufheben (Panel zugeklappt) — der nächste to()-Aufruf oder
/// Tab-Klick wählt wieder aus.
function clear() {
if (mode === "draft") draftTitle = opts.titleEl.textContent || t("panel.tabDraft");
mode = null;
for (const tab of opts.tabs) tab.btn.classList.remove("active");
for (const tab of opts.tabs) {
tab.content.hidden = true;
tab.btn.classList.remove("active");
}
}
for (const tab of opts.tabs) {
src/components/ProjectList.vue
+273 -107
View File
@@ -10,6 +10,7 @@ interface Project {
pool: string | null;
running: boolean;
terminal: { theme: string | null; icon: string | null; title: string | null };
archive: boolean;
}
interface Pool {
@@ -98,6 +99,15 @@ async function openTerminal(project: Project) {
}
}
/// Archiv-Zugang aus der Projektliste: öffnet das Trilium-Fenster des Projekts.
async function openArchive(project: Project) {
try {
await invoke("trilium_open", { project: project.id, noteId: null });
} catch (e) {
error.value = String(e);
}
}
interface PendingRestart {
id: string;
name: string;
@@ -171,7 +181,6 @@ interface TerminalSettings {
icon: string | null;
title: string;
workDirs: string[];
archiveHome: string | null;
modules: ModuleState[];
}
@@ -182,9 +191,6 @@ async function openSettings(p: Project) {
const workDirs = await invoke<string[]>("project_work_dirs", {
project: p.id,
});
const archiveHome = await invoke<string | null>("panel_archive_dir_cmd", {
project: p.id,
});
const modules = await invoke<ModuleState[]>("module_registry", {
project: p.id,
});
@@ -196,7 +202,6 @@ async function openSettings(p: Project) {
icon: p.terminal.icon,
title: p.terminal.title ?? "",
workDirs,
archiveHome,
modules,
};
} catch (e) {
@@ -205,10 +210,22 @@ async function openSettings(p: Project) {
}
// Modul-Schalter schreiben sofort in die Projekt-Config (nur Abweichungen
// vom Default); ein Fehler stellt die Checkbox zurück.
// vom Default); ein Fehler stellt die Checkbox zurück. Ausnahme Trilium:
// Anhaken öffnet nur den Wizard — das Modul-Flag schreibt erst der
// erfolgreiche Setup (trilium_connect im Backend); Abwählen stoppt die
// Instanz mit.
async function toggleModule(m: ModuleState) {
const s = settings.value!;
try {
if (m.id === "trilium") {
if (m.enabled) {
m.enabled = false; // folgt erst dem Setup-Erfolg
await openTriliumWizard();
} else {
await invoke("trilium_disable", { project: s.id });
}
return;
}
await invoke("set_module", { project: s.id, module: m.id, enabled: m.enabled });
} catch (e) {
m.enabled = !m.enabled;
@@ -216,6 +233,83 @@ async function toggleModule(m: ModuleState) {
}
}
// Trilium-Wizard: Runtime laden, Instanz starten, per Passwort den
// ETAPI-Token holen. Reine Checks beim Öffnen; geschrieben wird erst nach
// Erfolg (Backend-Muster), das Passwort wird nicht gespeichert.
interface TriliumStatus {
version: string;
port: number;
data_dir: string;
runtime_ready: boolean;
instance_running: boolean;
token_ok: boolean;
}
interface TriliumWizard {
status: TriliumStatus | null;
password: string;
busy: boolean;
error: string | null;
}
const triWizard = ref<TriliumWizard | null>(null);
async function openTriliumWizard() {
const s = settings.value!;
triWizard.value = { status: null, password: "", busy: false, error: null };
try {
triWizard.value.status = await invoke<TriliumStatus>("trilium_status", {
project: s.id,
});
} catch (e) {
triWizard.value.error = String(e);
}
}
async function triliumSetup() {
const s = settings.value!;
const w = triWizard.value!;
w.busy = true;
w.error = null;
try {
w.status = await invoke<TriliumStatus>("trilium_setup", { project: s.id });
} catch (e) {
w.error = String(e);
}
w.busy = false;
}
async function triliumConnect() {
const s = settings.value!;
const w = triWizard.value!;
w.busy = true;
w.error = null;
try {
w.status = await invoke<TriliumStatus>("trilium_connect", {
project: s.id,
password: w.password,
});
w.password = "";
// Modul-Flag hat das Backend gesetzt — Checkbox nachziehen.
s.modules = await invoke<ModuleState[]>("module_registry", { project: s.id });
} catch (e) {
w.error = String(e);
}
w.busy = false;
}
async function triliumOpen() {
const s = settings.value!;
const w = triWizard.value!;
w.error = null;
try {
await invoke("trilium_open", { project: s.id, noteId: null });
w.status = await invoke<TriliumStatus>("trilium_status", { project: s.id });
} catch (e) {
w.error = String(e);
}
}
// Projektordner neu zuordnen (Root, in dem die Session startet); verschoben
// wird nichts — der gewählte Ordner ist der neue Ort des Projekts.
async function changeProjectDir() {
@@ -256,59 +350,6 @@ async function removeWorkDir(dir: string) {
}
}
// Archiv-Home schreibt wie die Arbeitsordner direkt (Config + Permissions);
// ohne Archiv zeigt das Panel nur Befehle und Dokument. Greift ab dem
// nächsten Session-Start. Ist schon eins gesetzt, fragt ein Dialog nach —
// mit der Option, die Dokumente mitzunehmen (nichts wird implizit verschoben).
interface PendingArchiveChange {
dir: string;
migrate: boolean;
}
const pendingArchive = ref<PendingArchiveChange | null>(null);
async function chooseArchive() {
const s = settings.value!;
const dir = await open({ directory: true, multiple: false });
if (typeof dir !== "string") return;
if (s.archiveHome && s.archiveHome !== dir) {
pendingArchive.value = { dir, migrate: false };
return;
}
try {
await invoke("set_archive_home_cmd", { project: s.id, dir });
s.archiveHome = await invoke<string | null>("panel_archive_dir_cmd", {
project: s.id,
});
} catch (e) {
error.value = String(e);
}
}
async function confirmArchiveChange() {
const s = settings.value!;
const a = pendingArchive.value!;
try {
await invoke("change_archive_home_cmd", { project: s.id, dir: a.dir, migrate: a.migrate });
s.archiveHome = await invoke<string | null>("panel_archive_dir_cmd", {
project: s.id,
});
pendingArchive.value = null;
} catch (e) {
error.value = String(e);
pendingArchive.value = null;
}
}
async function clearArchive() {
const s = settings.value!;
try {
await invoke("clear_archive_home_cmd", { project: s.id });
s.archiveHome = null;
} catch (e) {
error.value = String(e);
}
}
async function pickIcon() {
const file = await open({
multiple: false,
@@ -425,10 +466,8 @@ interface DeletePreview {
name: string;
projectDir: string;
aiControlDir: boolean;
archivePermission: boolean;
panelFiles: number;
archiveHome: string | null;
archiveDocs: number;
triliumData: string | null;
workDirs: string[];
}
@@ -527,6 +566,14 @@ onUnmounted(() => window.clearInterval(timer));
</td>
<td class="cell-actions">
<span class="row-actions">
<button
v-if="p.archive"
class="gear"
:title="$t('projects.openArchive')"
@click="openArchive(p)"
>
🗃
</button>
<button
class="gear"
:title="$t('projects.terminalSettings')"
@@ -665,20 +712,13 @@ onUnmounted(() => window.clearInterval(timer));
<small>{{ $t("projects.scopeIntegrationDesc") }}</small>
</span>
</label>
<label class="scope">
<input
v-model="pendingDelete.scope"
type="radio"
value="archive"
:disabled="!pendingDelete.preview.archiveHome"
/>
<label v-if="pendingDelete.preview.triliumData" class="scope">
<input v-model="pendingDelete.scope" type="radio" value="archive" />
<span>
<strong>{{ $t("projects.scopeArchive") }}</strong>
<small v-if="pendingDelete.preview.archiveHome">
{{ $t("projects.scopeArchiveDesc", { path: pendingDelete.preview.archiveHome }) }}
({{ $t("projects.docCount", pendingDelete.preview.archiveDocs) }})
<small>
{{ $t("projects.scopeArchiveDesc", { path: pendingDelete.preview.triliumData }) }}
</small>
<small v-else>{{ $t("projects.archiveNone") }}</small>
</span>
</label>
<label class="scope">
@@ -700,14 +740,12 @@ onUnmounted(() => window.clearInterval(timer));
<ul class="affected">
<li>{{ $t("projects.artRegistry") }}</li>
<li v-if="pendingDelete.preview.aiControlDir">{{ $t("projects.artAiControl") }}</li>
<li v-if="pendingDelete.preview.archivePermission">{{ $t("projects.artArchivePerm") }}</li>
<li v-if="pendingDelete.preview.panelFiles">
{{ $t("projects.artPanelFiles", pendingDelete.preview.panelFiles) }}
</li>
<li>{{ $t("projects.artDesktop") }}</li>
<li v-if="pendingDelete.scope !== 'integration' && pendingDelete.preview.archiveHome">
{{ $t("projects.artArchive", { path: pendingDelete.preview.archiveHome }) }}
({{ $t("projects.docCount", pendingDelete.preview.archiveDocs) }})
<li v-if="pendingDelete.scope !== 'integration' && pendingDelete.preview.triliumData">
{{ $t("projects.artArchive", { path: pendingDelete.preview.triliumData }) }}
</li>
<li v-if="pendingDelete.scope === 'full'">
{{ $t("projects.artProjectDir", { path: pendingDelete.preview.projectDir }) }}
@@ -818,20 +856,11 @@ onUnmounted(() => window.clearInterval(timer));
<input v-model="m.enabled" type="checkbox" @change="toggleModule(m)" />
<span>{{ $t(`modules.${m.id}`) }} — {{ $t(`modules.${m.id}Desc`) }}</span>
</label>
<div v-if="m.id === 'archive'" class="srow">
<span class="slbl">{{ $t("projects.archive") }}</span>
<span class="sval">
<span v-if="settings.archiveHome" class="spath hover-pop">
{{ contractHome(settings.archiveHome) }}
<span class="pop pop-path">{{ settings.archiveHome }}</span>
</span>
<span v-else class="spath muted">{{ $t("projects.archiveNone") }}</span>
</span>
<div v-if="m.id === 'trilium'" class="srow">
<span class="slbl"></span>
<span class="sval"></span>
<span class="sacts">
<button @click="chooseArchive">{{ $t("projects.changeDir") }}</button>
<button v-if="settings.archiveHome" @click="clearArchive">
{{ $t("projects.remove") }}
</button>
<button @click="openTriliumWizard">{{ $t("trilium.wizard") }}</button>
</span>
</div>
</template>
@@ -849,27 +878,63 @@ onUnmounted(() => window.clearInterval(timer));
</div>
</div>
<div v-if="pendingArchive && settings" class="overlay" @click.self="pendingArchive = null">
<div class="dialog">
<h3>{{ $t("projects.archiveChangeTitle") }}</h3>
<p>
{{ $t("projects.archiveChangeText", {
old: contractHome(settings.archiveHome ?? ""),
neu: contractHome(pendingArchive.dir),
}) }}
<div v-if="triWizard" class="overlay" @click.self="triWizard = null">
<div class="dialog tri-dialog">
<h3>{{ $t("trilium.wizardTitle") }}</h3>
<p class="hint">{{ $t("trilium.wizardIntro") }}</p>
<p v-if="triWizard.error" class="error">{{ triWizard.error }}</p>
<ul v-if="triWizard.status" class="tri-steps">
<li>
<span class="mark" :class="{ ok: triWizard.status.runtime_ready }">{{ triWizard.status.runtime_ready ? "✓" : "✗" }}</span>
<span>
{{ $t("trilium.stepRuntime") }}
<small>Trilium {{ triWizard.status.version }}</small>
</span>
</li>
<li>
<span class="mark" :class="{ ok: triWizard.status.instance_running }">{{ triWizard.status.instance_running ? "✓" : "✗" }}</span>
<span>
{{ $t("trilium.stepInstance") }}
<small>{{ $t("trilium.port", { port: triWizard.status.port }) }}</small>
</span>
</li>
<li>
<span class="mark" :class="{ ok: triWizard.status.token_ok }">{{ triWizard.status.token_ok ? "✓" : "✗" }}</span>
<span>{{ $t("trilium.stepToken") }}</span>
</li>
</ul>
<p v-if="triWizard.status" class="tri-meta">
{{ $t("trilium.dataDir") }}: <code>{{ triWizard.status.data_dir }}</code>
· http://127.0.0.1:{{ triWizard.status.port }}
</p>
<label class="checkline">
<input v-model="pendingArchive.migrate" type="checkbox" />
{{ $t("projects.archiveMigrate") }}
</label>
<p class="hint">{{ $t("projects.archiveMigrateHint") }}</p>
<p class="hint">{{ $t("trilium.firstRunHint") }}</p>
<div v-if="triWizard.status && triWizard.status.instance_running && !triWizard.status.token_ok" class="tri-connect">
<span class="tri-lbl">{{ $t("trilium.password") }}</span>
<input
v-model="triWizard.password"
type="password"
@keydown.enter="triWizard.password && triliumConnect()"
/>
<button :disabled="triWizard.busy || !triWizard.password" @click="triliumConnect">
{{ $t("trilium.connect") }}
</button>
</div>
<div class="actions">
<button type="button" @click="pendingArchive = null">
{{ $t("projects.cancel") }}
<button :disabled="triWizard.busy" @click="triliumSetup">
{{ triWizard.busy ? $t("trilium.working") : $t("trilium.setup") }}
</button>
<button class="primary" @click="confirmArchiveChange">
{{ $t("projects.archiveChangeConfirm") }}
<button
:disabled="triWizard.busy || !triWizard.status?.instance_running"
@click="triliumOpen"
>
{{ $t("trilium.open") }}
</button>
<button class="primary" @click="triWizard = null">{{ $t("trilium.close") }}</button>
</div>
</div>
</div>
@@ -1050,4 +1115,105 @@ onUnmounted(() => window.clearInterval(timer));
.settings-dialog .actions {
margin-top: 0.25rem;
}
/* Trilium-Wizard. Maße nach UI-Guideline (px statt rem): 14 px Basis für
Interaktives, Meta-Zeilen 12 px, Zeilen mindestens 28 px, 4-px-Skala. */
.tri-dialog {
width: min(40rem, 94vw);
max-width: none;
padding: 24px;
gap: 12px;
}
.tri-dialog h3 {
font-size: 16px;
}
.tri-dialog .hint,
.tri-dialog .error {
font-size: 13px;
line-height: 1.5;
}
.tri-steps {
list-style: none;
margin: 4px 0;
padding: 0;
display: flex;
flex-direction: column;
gap: 8px;
}
.tri-steps li {
display: flex;
gap: 12px;
align-items: flex-start;
min-height: 28px;
font-size: 14px;
color: var(--text);
}
.tri-steps li > span:last-child {
display: flex;
flex-direction: column;
gap: 4px;
min-width: 0;
padding-top: 2px;
}
.tri-steps small {
font-family: var(--mono);
font-size: 12px;
color: var(--subtext);
}
.tri-steps .mark {
width: 24px;
height: 24px;
flex: none;
display: flex;
align-items: center;
justify-content: center;
font-size: 14px;
border-radius: 6px;
background: var(--surface0);
color: var(--overlay);
}
.tri-steps .mark.ok {
color: var(--green, #a6e3a1);
}
.tri-meta {
margin: 0;
font-size: 12px;
color: var(--overlay);
}
.tri-meta code {
font-family: var(--mono);
font-size: 12px;
color: var(--subtext);
}
/* Verbinden-Zeile: Label | Passwort | Knopf. */
.tri-connect {
display: grid;
grid-template-columns: 8rem 1fr auto;
align-items: center;
gap: 12px;
min-height: 32px;
font-size: 14px;
color: var(--subtext);
}
.tri-connect input {
min-height: 28px;
font-size: 14px;
}
.tri-dialog .actions button {
min-height: 28px;
font-size: 14px;
}
</style>
src/messages.test.ts
+7 -5
View File
@@ -32,6 +32,7 @@ describe("Nachrichtentabellen", () => {
const erlaubt = new Set([
"Pool",
"Pools",
"Panel",
"Name",
"Theme",
"Wiki",
@@ -47,6 +48,7 @@ describe("Nachrichtentabellen", () => {
"+ apiKey",
"+ ToDo",
"System",
"Trilium",
"Terminal",
"Terminal — {name}",
".desktop-Starter",
@@ -69,7 +71,7 @@ function pick(obj: object, key: string): string {
describe("t()", () => {
it("löst Punkt-Pfade auf", () => {
expect(t("panel.tabDraft")).toBe("Dokument");
expect(t("panel.tabSearch")).toBe("Suche");
});
it("setzt Platzhalter ein", () => {
@@ -88,7 +90,7 @@ describe("t()", () => {
it("folgt der gespeicherten Sprache", () => {
window.localStorage.setItem("lang", "en");
expect(storedLocale()).toBe("en");
expect(t("panel.tabDraft")).toBe("Document");
expect(t("panel.tabSearch")).toBe("Search");
});
it("fällt bei unbekannter Sprache auf die Browsersprache zurück", () => {
@@ -100,13 +102,13 @@ describe("t()", () => {
describe("applyI18n()", () => {
it("beschriftet Text und Attribute", () => {
document.body.innerHTML = `
<button data-i18n="panel.tabWiki" data-i18n-title="panel.tabWikiTitle">alt</button>
<button data-i18n="panel.tabSearch" data-i18n-title="panel.tabSearchTitle">alt</button>
<button data-i18n-aria="panel.close"></button>
<input data-i18n-placeholder="search.placeholder" />`;
applyI18n();
const btn = document.querySelector("button")!;
expect(btn.textContent).toBe("Wiki");
expect(btn.title).toBe("Archiv-Wiki");
expect(btn.textContent).toBe("Suche");
expect(btn.title).toBe("Suchtreffer");
expect(document.querySelectorAll("button")[1].getAttribute("aria-label")).toBe(
"Schließen",
);
src/messages.ts
+57 -113
View File
@@ -34,6 +34,7 @@ const de = {
start: "Starten",
stop: "Beenden",
terminalSettings: "Terminal-Einstellungen",
openArchive: "Archiv öffnen (Trilium)",
stillRunning: "{name} läuft noch",
poolChangeSaved:
"Der Pool-Wechsel ist gespeichert. Die laufende Session arbeitet aber weiter im alten Pool — der neue gilt erst ab dem nächsten Start.",
@@ -59,8 +60,6 @@ const de = {
addFolder: "Projekt importieren …",
addFolderTitle: "Bestehenden Ordner als Projekt aufnehmen",
addWorkDir: "Ordner hinzufügen …",
archive: "Archiv",
archiveNone: "kein Archiv — Panel ohne Wiki und Suche",
changeDir: "Ändern …",
wizardTitle: "Neues Projekt",
name: "Name",
@@ -82,25 +81,17 @@ const de = {
scopeIntegrationDesc:
"ai-control-Spuren werden entfernt; Projektordner, memory/ und Todoliste bleiben.",
scopeArchive: "Integration & Archiv",
scopeArchiveDesc: "zusätzlich {path} — endgültig.",
scopeArchiveDesc: "zusätzlich das Trilium-Archiv {path} — endgültig.",
scopeFull: "Projekt komplett löschen",
scopeFullDesc: "zusätzlich der Projektordner {path} — endgültig.",
deletePreviewTitle: "Wird entfernt:",
docCount: "kein Dokument | 1 Dokument | {count} Dokumente",
artRegistry: "Registry-Eintrag",
artAiControl: ".ai-control/ (Config + Icon)",
artArchivePerm: "Archiv-Berechtigung in .claude/settings.json",
artPanelFiles: "Panel-Kanaldatei | {count} Panel-Kanaldateien",
artDesktop: ".desktop-Starter",
artArchive: "Archiv {path}",
artArchive: "Trilium-Archiv {path}",
artProjectDir: "Projektordner {path}",
artWorkDir: "Arbeitsordner {path}",
archiveChangeTitle: "Archiv wechseln",
archiveChangeText: "Das Archiv wechselt von {old} nach {neu}.",
archiveMigrate: "Dokumente ins neue Archiv verschieben",
archiveMigrateHint:
"Ohne Haken bleibt das bisherige Archiv unverändert liegen; die App verweist künftig nur noch auf das neue.",
archiveChangeConfirm: "Wechseln",
groupAppearance: "Darstellung",
groupFolders: "Ordner",
groupModules: "Module",
@@ -111,8 +102,28 @@ const de = {
commandsDesc: "Befehls-Kacheln im Panel (write_commands)",
todo: "ToDo-Liste",
todoDesc: "persistente Aufgaben-Kacheln mit Fälligkeits-Ampel; öffnet beim Sessionstart",
archive: "Archiv",
archiveDesc: "Archivieren, Wiki und Suche",
trilium: "Trilium",
triliumDesc:
"Archiv als eigene Trilium-Instanz — Archivieren, Suche und Notizen laufen über Trilium",
},
trilium: {
wizardTitle: "Trilium einrichten",
wizardIntro:
"Richtet das Projekt-Archiv als eigene Trilium-Instanz ein: Runtime versionsgepinnt geladen, Instanz nur auf 127.0.0.1 mit eigenem Datenverzeichnis und Port. Das Modul wird erst nach erfolgreicher Verbindung aktiviert.",
stepRuntime: "Runtime vorhanden",
stepInstance: "Instanz läuft",
stepToken: "Verbunden (ETAPI-Token)",
port: "Port {port}",
dataDir: "Daten",
firstRunHint:
"Beim ersten Verbinden legt die App das Dokument an und setzt das gewählte Passwort. Gespeichert wird nur der ETAPI-Token (Keyring), nie das Passwort.",
password: "Passwort",
connect: "Verbinden",
setup: "Einrichten / Starten",
working: "Läuft …",
open: "Trilium öffnen",
close: "Schließen",
wizard: "Einrichtung / Status",
},
todos: {
copyOne: "Aufgabe kopieren",
@@ -178,17 +189,15 @@ const de = {
},
panel: {
windowTerminal: "Terminal",
windowDocument: "Dokument",
windowPanel: "Panel",
windowProjects: "Projekte",
tabCommands: "Befehle",
tabCommandsTitle: "Befehls-History",
tabTodo: "ToDo",
tabTodoTitle: "ToDo-Liste des Projekts",
tabDraft: "Dokument",
tabDraftTitle: "Dokument",
tabWiki: "Wiki",
tabWikiTitle: "Archiv-Wiki",
tabSearch: "Suche",
archiveOpen: "Archiv",
archiveOpenTitle: "Archiv in Trilium öffnen",
tabSearchTitle: "Suchtreffer",
minimize: "Minimieren",
maximize: "Maximieren",
@@ -197,16 +206,6 @@ const de = {
hidePanel: "Panel ausblenden",
detach: "In eigenes Fenster ablösen",
dock: "Wieder andocken",
editTitle: "Titel bearbeiten",
spellcheckLang: "Sprache der Rechtschreibprüfung",
openInWiki: "Im Wiki öffnen",
toggleRaw: "Rohtext / gerendert",
rendered: "MD",
raw: "Roh",
editDraft: "Entwurf bearbeiten (Cmd/Ctrl+Enter speichert, Esc verwirft)",
copy: "In die Zwischenablage kopieren",
archive: "In den Archiv-Ordner speichern",
chooseArchiveDir: "Archiv-Ordner wählen",
processEnded: "[Prozess beendet]",
},
popup: {
@@ -219,39 +218,12 @@ const de = {
copyAll: "Alle kopieren",
session: "Session",
},
archiveForm: {
folder: "Ordner — z. B. konzepte/panel",
description: "Beschreibung",
tags: "Schlagwörter, kommagetrennt",
submit: "Archivieren",
},
search: {
placeholder: "Archiv durchsuchen — #tag filtert",
minChars: "Mindestens 3 Zeichen — oder Enter.",
hits: "{count} Treffer {scope}",
noHits: "Keine Treffer für {scope}",
},
wiki: {
archive: "Archiv",
docOne: "{count} Dokument",
docMany: "{count} Dokumente",
backlinks: "Verweise hierher",
emptyArchive: "Das Archiv ist leer.",
emptyFolder: "Keine Dokumente in diesem Ordner.",
emptyHint:
"Archivieren: Archiv-Button im Entwurf oder „archiviere das“ im Chat — mit Ordner, Beschreibung und Schlagwörtern.",
noPage: "Keine Wiki-Seite geladen.",
openOverview: "Archiv-Übersicht öffnen",
folderRename: "Ordner umbenennen",
renameDoc: "Dokument umbenennen",
deleteDoc: "Dokument löschen",
newFolder: "Neuer Ordner",
newDoc: "Neues Dokument",
create: "Anlegen",
cancel: "Abbrechen",
folderPath: "ordner/unterordner",
docName: "Name des Dokuments",
},
};
const en: typeof de = {
@@ -283,6 +255,7 @@ const en: typeof de = {
start: "Start",
stop: "Stop",
terminalSettings: "Terminal settings",
openArchive: "Open archive (Trilium)",
stillRunning: "{name} is still running",
poolChangeSaved:
"The pool change is saved. The running session keeps working in the old pool — the new one applies from the next start.",
@@ -308,8 +281,6 @@ const en: typeof de = {
addFolder: "Import project …",
addFolderTitle: "Add an existing folder as a project",
addWorkDir: "Add folder …",
archive: "Archive",
archiveNone: "no archive — panel without wiki and search",
changeDir: "Change …",
wizardTitle: "New project",
name: "Name",
@@ -331,25 +302,17 @@ const en: typeof de = {
scopeIntegrationDesc:
"ai-control traces are removed; project folder, memory/ and todo list stay.",
scopeArchive: "Integration & archive",
scopeArchiveDesc: "additionally {path} — permanent.",
scopeArchiveDesc: "additionally the Trilium archive {path} — permanent.",
scopeFull: "Delete project completely",
scopeFullDesc: "additionally the project folder {path} — permanent.",
deletePreviewTitle: "Will be removed:",
docCount: "no documents | 1 document | {count} documents",
artRegistry: "registry entry",
artAiControl: ".ai-control/ (config + icon)",
artArchivePerm: "archive permission in .claude/settings.json",
artPanelFiles: "panel channel file | {count} panel channel files",
artDesktop: ".desktop launcher",
artArchive: "archive {path}",
artArchive: "Trilium archive {path}",
artProjectDir: "project folder {path}",
artWorkDir: "working folder {path}",
archiveChangeTitle: "Change archive",
archiveChangeText: "The archive changes from {old} to {neu}.",
archiveMigrate: "Move documents to the new archive",
archiveMigrateHint:
"Unchecked, the previous archive stays untouched; the app just points to the new one.",
archiveChangeConfirm: "Change",
groupAppearance: "Appearance",
groupFolders: "Folders",
groupModules: "Modules",
@@ -360,8 +323,28 @@ const en: typeof de = {
commandsDesc: "command tiles in the panel (write_commands)",
todo: "ToDo list",
todoDesc: "persistent task tiles with due-date signal; opens at session start",
archive: "Archive",
archiveDesc: "archiving, wiki and search",
trilium: "Trilium",
triliumDesc:
"archive as a dedicated Trilium instance — archiving, search and notes run through Trilium",
},
trilium: {
wizardTitle: "Set up Trilium",
wizardIntro:
"Sets up the project archive as its own Trilium instance: version-pinned runtime download, instance on 127.0.0.1 only with its own data directory and port. The module is enabled only after a successful connection.",
stepRuntime: "Runtime present",
stepInstance: "Instance running",
stepToken: "Connected (ETAPI token)",
port: "port {port}",
dataDir: "Data",
firstRunHint:
"On first connect the app creates the document and sets the chosen password. Only the ETAPI token is stored (keyring), never the password.",
password: "Password",
connect: "Connect",
setup: "Set up / start",
working: "Working …",
open: "Open Trilium",
close: "Close",
wizard: "Setup / status",
},
todos: {
copyOne: "Copy task",
@@ -427,17 +410,15 @@ const en: typeof de = {
},
panel: {
windowTerminal: "Terminal",
windowDocument: "Document",
windowPanel: "Panel",
windowProjects: "Projects",
tabCommands: "Commands",
tabCommandsTitle: "Command history",
tabTodo: "ToDo",
tabTodoTitle: "Project to-do list",
tabDraft: "Document",
tabDraftTitle: "Document",
tabWiki: "Wiki",
tabWikiTitle: "Archive wiki",
tabSearch: "Search",
archiveOpen: "Archive",
archiveOpenTitle: "Open the archive in Trilium",
tabSearchTitle: "Search hits",
minimize: "Minimize",
maximize: "Maximize",
@@ -446,16 +427,6 @@ const en: typeof de = {
hidePanel: "Hide panel",
detach: "Detach into its own window",
dock: "Dock again",
editTitle: "Edit title",
spellcheckLang: "Spell-check language",
openInWiki: "Open in wiki",
toggleRaw: "Raw text / rendered",
rendered: "MD",
raw: "Raw",
editDraft: "Edit draft (Cmd/Ctrl+Enter saves, Esc discards)",
copy: "Copy to clipboard",
archive: "Save to the archive folder",
chooseArchiveDir: "Choose archive folder",
processEnded: "[process ended]",
},
popup: {
@@ -468,39 +439,12 @@ const en: typeof de = {
copyAll: "Copy all",
session: "Session",
},
archiveForm: {
folder: "Folder — e.g. concepts/panel",
description: "Description",
tags: "Tags, comma-separated",
submit: "Archive",
},
search: {
placeholder: "Search the archive — #tag filters",
minChars: "At least 3 characters — or press Enter.",
hits: "{count} hits {scope}",
noHits: "No hits for {scope}",
},
wiki: {
archive: "Archive",
docOne: "{count} document",
docMany: "{count} documents",
backlinks: "Links here",
emptyArchive: "The archive is empty.",
emptyFolder: "No documents in this folder.",
emptyHint:
"To archive: the archive button in the draft, or “archive this” in the chat — with folder, description and tags.",
noPage: "No wiki page loaded.",
openOverview: "Open archive overview",
folderRename: "Rename folder",
renameDoc: "Rename document",
deleteDoc: "Delete document",
newFolder: "New folder",
newDoc: "New document",
create: "Create",
cancel: "Cancel",
folderPath: "folder/subfolder",
docName: "Document name",
},
};
export const messages = { de, en };
@@ -522,7 +466,7 @@ export function storedLocale(): Locale {
return navigator.language.startsWith("de") ? "de" : "en";
}
/// Übersetzt einen Punkt-Pfad (`panel.tabDraft`) und setzt `{platzhalter}` ein.
/// Übersetzt einen Punkt-Pfad (`panel.tabSearch`) und setzt `{platzhalter}` ein.
/// Fehlt der Schlüssel, kommt der Pfad selbst zurück — im UI sichtbar statt
/// still leer.
export function t(key: string, params?: Record<string, string | number>): string {
src/modules/archive.ts
+18 -45
View File
@@ -1,57 +1,30 @@
import { invoke } from "@tauri-apps/api/core";
import { initSearchView } from "../search-view";
import { initWikiView } from "../wiki-view";
import type { PanelTab } from "./index";
export const wikiTab: PanelTab = {
mode: "wiki",
module: "archive",
buffer: "wiki",
labelKey: "panel.tabWiki",
titleKey: "panel.tabWikiTitle",
// Dokument-/Ordner-Operationen laufen als Commands; der neue Stand kommt
// über den Wiki-Puffer (wiki-update) zurück, Fehler als Toast. Der
// Dokument-Sprung lädt wie ein Suchtreffer in den Dokument-Tab.
init: (container, ctx) => {
const run = (cmd: string, args: Record<string, string>) =>
void invoke(cmd, { project: ctx.project, ...args }).catch((e) =>
ctx.toast(String(e)),
);
return initWikiView(container, {
openDoc: ctx.openDoc,
openWiki: ctx.openWiki,
actions: {
rename: (relpath, name) => run("archive_rename", { relpath, name }),
remove: (relpath) => run("archive_delete", { relpath }),
moveFolder: (folder, to) => run("archive_move_folder", { folder, to }),
createFolder: (folder) => run("archive_create_folder", { folder }),
createDoc: (folder, name) => run("archive_create_doc", { folder, name }),
},
});
},
// Beim Aktivieren die Übersicht frisch laden: das Anlegen eines Dokuments
// öffnet den Dokument-Tab, ohne den Wiki-Puffer anzufassen — und auch
// direkt archivierte oder von Hand abgelegte Dateien erscheinen so.
onActivate: (_view, ctx) => ctx.openWiki("tag:"),
};
export const searchTab: PanelTab = {
mode: "search",
module: "archive",
module: "trilium",
buffer: "search",
labelKey: "panel.tabSearch",
titleKey: "panel.tabSearchTitle",
sepAfter: true,
// Treffer-Klick lädt das Dokument in den Dokument-Tab (dort editier- und
// archivierbar); der Sprung ins Wiki geht von dort aus.
// Treffer-Klick öffnet die Notiz im Trilium-Fenster des Projekts.
init: (container, ctx) =>
initSearchView(container, ctx.openDoc, (raw) => {
// `#tag`-Tokens filtern aufs Schlagwort, der Rest ist die Volltext-Query.
const words = raw.split(/\s+/).filter(Boolean);
const tag = words.find((w) => w.startsWith("#"))?.slice(1) ?? null;
const query = words.filter((w) => !w.startsWith("#")).join(" ");
void invoke("search_run", { project: ctx.project, query, tag }).catch((e) =>
ctx.toast(`Suche fehlgeschlagen: ${e}`),
);
}),
initSearchView(
container,
(noteId) =>
void invoke("trilium_open", { project: ctx.project, noteId }).catch((e) =>
ctx.toast(String(e)),
),
(raw) => {
// `#tag`-Tokens filtern aufs Schlagwort, der Rest ist die Volltext-Query.
const words = raw.split(/\s+/).filter(Boolean);
const tag = words.find((w) => w.startsWith("#"))?.slice(1) ?? null;
const query = words.filter((w) => !w.startsWith("#")).join(" ");
void invoke("search_run", { project: ctx.project, query, tag }).catch((e) =>
ctx.toast(`Suche fehlgeschlagen: ${e}`),
);
},
),
};
src/modules/index.ts
+5 -22
View File
@@ -6,7 +6,7 @@
/// `<buffer>-update`-Event.
import { commandsTab } from "./commands";
import { searchTab, wikiTab } from "./archive";
import { searchTab } from "./archive";
import { todoTab } from "./todo";
export interface ModuleView {
@@ -19,10 +19,6 @@ export interface ModuleView {
export interface ModuleCtx {
project: string;
toast(msg: string): void;
/// Dokument in den Entwurfs-Tab laden (Treffer-Klick).
openDoc(path: string): void;
/// Wiki-Ziel öffnen (Wikilink, Chip, `tag:`-Namensraum).
openWiki(name: string): void;
}
export interface PanelTab {
@@ -37,23 +33,10 @@ export interface PanelTab {
titleKey: string;
/// Visueller Trenner hinter dem Tab.
sepAfter?: boolean;
/// Baut die Ansicht des Tabs. Ohne init verdrahtet panel-wiring die
/// Ansicht selbst (Entwurfs-Tab — Kern mit eigenem Markup).
init?(container: HTMLElement, ctx: ModuleCtx): ModuleView;
/// Nach Tab-Klick (z. B. Wiki: leere Ansicht lädt die Übersicht).
/// Baut die Ansicht des Tabs.
init(container: HTMLElement, ctx: ModuleCtx): ModuleView;
/// Nach Tab-Klick.
onActivate?(view: ModuleView, ctx: ModuleCtx): void;
}
export const PANEL_TABS: PanelTab[] = [
todoTab,
commandsTab,
{
mode: "draft",
module: "draft",
buffer: "panel",
labelKey: "panel.tabDraft",
titleKey: "panel.tabDraftTitle",
},
wikiTab,
searchTab,
];
export const PANEL_TABS: PanelTab[] = [todoTab, commandsTab, searchTab];
src/panel-tiles.css
+1 -359
View File
@@ -139,7 +139,7 @@
border: 1px solid var(--ok);
}
/* Kopfzeile mit Anlegen-Knopf und das ToDo-Formular (Anlegen/Bearbeiten),
in-flow über der Liste; Input-Stil wie im Archiv-Formular. */
in-flow über der Liste. */
.todo-head {
display: flex;
justify-content: flex-end;
@@ -311,364 +311,6 @@
font-size: 10px;
}
/* Wiki-Ansicht: Ordner-Baum links, flache Inhaltsliste rechts. */
#wiki-content {
flex: 1;
min-height: 0;
overflow: auto;
padding: 14px 16px;
}
#wiki-content::-webkit-scrollbar {
width: 8px;
}
#wiki-content::-webkit-scrollbar-thumb {
background: var(--line);
border-radius: 4px;
}
/* Baum links, Seite rechts; beide scrollen gemeinsam im Tab. */
.wiki-layout {
display: flex;
align-items: flex-start;
gap: 12px;
}
.wiki-tree {
flex: 0 0 150px;
min-width: 0;
border-right: 1px solid var(--line);
padding-right: 8px;
position: sticky;
top: 0;
}
.wiki-main {
flex: 1;
min-width: 0;
}
.wiki-tree details > .wiki-tree-children {
margin-left: 10px;
}
.wiki-tree summary {
display: flex;
align-items: center;
gap: 2px;
list-style: none;
cursor: pointer;
padding: 2px 2px;
color: var(--muted);
font:
500 11px/1.4 -apple-system,
system-ui,
sans-serif;
user-select: none;
-webkit-user-select: none;
}
.wiki-tree summary::-webkit-details-marker {
display: none;
}
.wiki-tree summary::before {
content: "▸";
color: var(--faint);
font-size: 9px;
margin-right: 3px;
}
.wiki-tree details[open] > summary::before {
content: "▾";
}
.wiki-tree-name {
flex: 1;
min-width: 0;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}
.wiki-tree summary .panel-btn {
visibility: hidden;
}
.wiki-tree summary:hover .panel-btn {
visibility: visible;
}
.wiki-tree summary:hover,
.wiki-tree-root:hover {
background: var(--tile);
border-radius: 4px;
}
.wiki-tree summary.active,
.wiki-tree-root.active {
color: var(--accent);
}
.wiki-tree-root {
display: block;
width: 100%;
text-align: left;
border: none;
background: none;
color: var(--muted);
border-radius: 4px;
padding: 2px 4px;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
font:
500 11px/1.5 -apple-system,
system-ui,
sans-serif;
}
.wiki-tree-input {
box-sizing: border-box;
width: 100%;
background: var(--surface);
border: 1px solid var(--line-strong);
border-radius: 4px;
padding: 2px 4px;
color: var(--text);
font:
400 11px/1.4 -apple-system,
system-ui,
sans-serif;
outline: none;
}
/* Zeilen-Aktionen erst beim Überfahren der Zeile. */
.wiki-doc-actions {
display: flex;
gap: 2px;
visibility: hidden;
}
.wiki-doc:hover .wiki-doc-actions {
visibility: visible;
}
/* Kopfzeile des Baums: Wurzel-Knopf + Ordner anlegen. */
.wiki-tree-head {
display: flex;
align-items: center;
gap: 2px;
}
.wiki-tree-head .wiki-tree-root {
flex: 1;
min-width: 0;
}
.wiki-add {
border: none;
background: none;
color: var(--muted);
border-radius: 4px;
padding: 0 5px;
font:
500 13px/1.4 -apple-system,
system-ui,
sans-serif;
cursor: pointer;
}
.wiki-add:hover {
background: var(--tile);
color: var(--text);
}
/* Anlege-Formular (Ordner/Dokument) oben in der Liste. */
.wiki-form {
display: flex;
align-items: center;
gap: 6px;
background: var(--surface);
border: 1px solid var(--line-strong);
border-radius: 8px;
padding: 8px 10px;
margin: 10px 0 4px;
}
.wiki-form-title {
color: var(--muted);
font:
500 11px/1.4 -apple-system,
system-ui,
sans-serif;
white-space: nowrap;
}
.wiki-form .wiki-tree-input {
flex: 1;
width: auto;
padding: 4px 8px;
font-size: 12px;
}
.wiki-form-submit,
.wiki-form-cancel {
border: none;
background: var(--line);
color: var(--text);
border-radius: 6px;
padding: 4px 10px;
font:
500 11px/1.4 -apple-system,
system-ui,
sans-serif;
}
.wiki-form-submit:hover {
background: var(--line-strong);
}
.wiki-form-cancel {
background: none;
color: var(--muted);
}
.wiki-form-cancel:hover {
background: var(--tile);
}
.wiki-head {
display: flex;
align-items: baseline;
justify-content: space-between;
gap: 8px;
}
.wiki-head-left {
min-width: 0;
}
.wiki-head-title {
color: var(--text);
font:
600 13px/1.3 -apple-system,
system-ui,
sans-serif;
}
.wiki-head-sub {
margin-top: 2px;
color: var(--faint);
font-family: "JetBrains Mono", Menlo, monospace;
font-size: 10px;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}
.wiki-head-right {
color: var(--faint);
font:
500 11px/1 -apple-system,
system-ui,
sans-serif;
white-space: nowrap;
}
/* Einstiegs-Knopf im Leerzustand. */
.wiki-chip {
border: 1px solid var(--line);
background: transparent;
color: var(--muted);
border-radius: 999px;
padding: 2px 8px;
font:
500 10.5px/1.5 -apple-system,
system-ui,
sans-serif;
}
.wiki-chip:hover {
background: var(--line);
color: var(--text);
}
.wiki-doc {
padding: 7px 8px;
margin: 4px -8px 0;
border-radius: 8px;
cursor: pointer;
}
.wiki-doc:hover {
background: var(--tile);
}
.wiki-doc-line {
display: flex;
align-items: baseline;
gap: 8px;
}
.wiki-doc-title {
flex: 1;
min-width: 0;
color: var(--accent);
font:
600 12px/1.4 -apple-system,
system-ui,
sans-serif;
}
.wiki-doc-date {
color: var(--faint);
font-family: "JetBrains Mono", Menlo, monospace;
font-size: 10px;
}
.wiki-doc-desc {
margin-top: 2px;
color: var(--muted);
font:
400 11px/1.5 -apple-system,
system-ui,
sans-serif;
}
.wiki-empty {
margin-top: 18px;
color: var(--muted);
font:
400 12px/1.6 -apple-system,
system-ui,
sans-serif;
}
.wiki-empty strong {
display: block;
margin-bottom: 6px;
color: var(--text);
font-weight: 600;
}
/* Backlink-Zähler in der Dokumentzeile. */
.wiki-doc-back {
color: var(--faint);
font:
500 10px/1 -apple-system,
system-ui,
sans-serif;
white-space: nowrap;
}
/* Archiv-Formular: klappt unter dem Archiv-Button auf. */
.archive-form {
position: fixed;
z-index: 20;
display: flex;
flex-direction: column;
gap: 6px;
width: 260px;
background: var(--surface);
border: 1px solid var(--line-strong);
border-radius: 8px;
padding: 10px;
box-shadow: 0 8px 24px rgba(0, 0, 0, 0.4);
}
.archive-form[hidden] {
display: none;
}
.archive-form input {
box-sizing: border-box;
width: 100%;
background: var(--tile);
border: 1px solid var(--line);
border-radius: 6px;
padding: 6px 10px;
color: var(--text);
font:
400 12px/1.4 -apple-system,
system-ui,
sans-serif;
outline: none;
}
.archive-form input:focus {
border-color: var(--line-strong);
}
.archive-form input::placeholder {
color: var(--faint);
}
.archive-form-submit {
border: none;
background: var(--line);
color: var(--text);
border-radius: 6px;
padding: 6px 10px;
font:
500 12px/1.4 -apple-system,
system-ui,
sans-serif;
}
.archive-form-submit:hover {
background: var(--line-strong);
}
/* Sichtbare Fehlermeldung (panelToast), oben rechts über dem Panel-Inhalt. */
.panel-toast {
position: fixed;
src/panel-view.test.ts
-68
View File
@@ -1,68 +0,0 @@
// Dokument-Ansicht: Wikilink-Verlinkung im DOM und Editor-Flush.
import { describe, expect, it, vi } from "vitest";
import { initPanelView, linkWikiRefs } from "./panel-view";
describe("linkWikiRefs", () => {
it("verlinkt [[ziel]] und [[ziel|Label]], Code bleibt unangetastet", () => {
const root = document.createElement("div");
root.innerHTML =
"<p>Siehe [[adr-logging]] und [[notiz|die Notiz]].</p>" +
"<pre><code>if [[ -f x ]]; then</code></pre>";
const onClick = vi.fn();
linkWikiRefs(root, onClick);
const links = [...root.querySelectorAll<HTMLElement>("a.wiki")];
expect(links.map((a) => a.textContent)).toEqual(["adr-logging", "die Notiz"]);
links[1].click();
expect(onClick).toHaveBeenCalledWith("notiz");
expect(root.querySelector("code")!.textContent).toBe("if [[ -f x ]]; then");
});
});
function viewSetup(onCommit: (text: string) => void | Promise<void>) {
document.body.innerHTML = `
<div id="content"></div>
<button id="copy"></button>
<button id="mode"></button>
<button id="edit"></button>`;
const view = initPanelView({
content: document.getElementById("content")!,
copyBtn: document.getElementById("copy")!,
modeBtn: document.getElementById("mode")!,
editContentBtn: document.getElementById("edit")!,
onCommit,
});
const editor = document.querySelector<HTMLTextAreaElement>(".panel-editor")!;
return { view, editor, editBtn: document.getElementById("edit")! };
}
describe("initPanelView — Editor", () => {
it("flush speichert eine offene Bearbeitung und beendet sie", async () => {
const onCommit = vi.fn();
const { view, editor, editBtn } = viewSetup(onCommit);
view.set("Alt");
editBtn.click();
expect(editor.hidden).toBe(false);
editor.value = "Neu";
await view.flush();
expect(onCommit).toHaveBeenCalledWith("Neu");
expect(editor.hidden).toBe(true);
});
it("flush ohne offene Bearbeitung tut nichts", async () => {
const onCommit = vi.fn();
const { view } = viewSetup(onCommit);
view.set("Alt");
await view.flush();
expect(onCommit).not.toHaveBeenCalled();
});
it("puffert eingehende Updates während der Bearbeitung", () => {
const { view, editor, editBtn } = viewSetup(() => {});
view.set("Alt");
editBtn.click();
view.set("Update von außen");
expect(editBtn.classList.contains("changed")).toBe(true);
editor.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape" }));
expect(view.raw()).toBe("Update von außen");
});
});
src/panel-view.ts
-271
View File
@@ -1,271 +0,0 @@
import { renderMarkdown } from "./markdown";
import { writeText } from "@tauri-apps/plugin-clipboard-manager";
import { flash } from "./tiles";
import { t } from "./messages";
export interface PanelView {
set(text: string): void;
raw(): string;
/// Schreibt eine offene Inhalts-Bearbeitung zurück (und beendet sie);
/// aufgelöst, sobald der Entwurf gespeichert ist.
flush(): Promise<void>;
}
/// Verkabelt einen Panel-Inhaltsbereich: MD/Roh-Umschalter und Copy-Button.
/// Der Rohtext bleibt die Quelle für „Kopieren"; die Ansicht rendert Markdown.
/// Entfernt Inline-Markdown (Emphasis, Code, Links), damit der Plain-Text-Titel
/// nicht die rohen Marker zeigt.
function stripInlineMd(s: string): string {
return s
.replace(/`([^`]*)`/g, "$1")
.replace(/\*\*([^*]+)\*\*/g, "$1")
.replace(/\*([^*]+)\*/g, "$1")
.replace(/__([^_]+)__/g, "$1")
.replace(/_([^_]+)_/g, "$1")
.replace(/~~([^~]+)~~/g, "$1")
.replace(/\[([^\]]+)\]\([^)]*\)/g, "$1")
.trim();
}
/// Titel für den Panel-Kopf: erste Überschrift (# …) oder sonst erste
/// nicht-leere Zeile, ohne Inline-Markdown; „Dokument" bei leerem Text.
function firstLine(text: string): string {
let fallback = "";
for (const line of text.split("\n")) {
const t = line.trim();
if (!t) continue;
const h = t.replace(/^#+/, "").trim();
if (t.startsWith("#") && h) return stripInlineMd(h);
if (!fallback) fallback = t;
}
return fallback ? stripInlineMd(fallback) : t("panel.tabDraft");
}
/// Ersetzt die erste Überschrift (bzw. legt eine an) im Rohtext durch `title`.
function setHeading(text: string, title: string): string {
const lines = text.split("\n");
for (let i = 0; i < lines.length; i++) {
const t = lines[i].trim();
if (!t) continue;
if (t.startsWith("#")) {
const hashes = (t.match(/^#+/) as RegExpMatchArray)[0];
lines[i] = `${hashes} ${title}`;
} else {
lines.splice(i, 0, `# ${title}`, "");
}
return lines.join("\n");
}
return `# ${title}\n`;
}
/// Macht `[[name]]`-Wikilinks im gerendertem Markdown klickbar. Läuft über die
/// Textknoten des DOM statt über den Rohtext, damit Vorkommen in Code-Spans
/// und Code-Blöcken (z. B. bash `[[ -f x ]]`) unangetastet bleiben.
export function linkWikiRefs(root: HTMLElement, onClick: (name: string) => void) {
const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
const nodes: Text[] = [];
for (let n = walker.nextNode(); n; n = walker.nextNode()) {
const t = n as Text;
if (!t.textContent?.includes("[[")) continue;
if (t.parentElement?.closest("code, pre, a")) continue;
nodes.push(t);
}
for (const node of nodes) {
const parts = node.textContent!.split(/\[\[([^\]]+)\]\]/g);
if (parts.length < 3) continue;
const frag = document.createDocumentFragment();
parts.forEach((part, i) => {
if (i % 2) {
// `[[ziel]]` oder `[[ziel|label]]`.
const sep = part.indexOf("|");
const target = sep < 0 ? part : part.slice(0, sep);
const label = sep < 0 ? part : part.slice(sep + 1);
const a = document.createElement("a");
a.href = "#";
a.className = "wiki";
a.textContent = label;
a.addEventListener("click", (e) => {
e.preventDefault();
onClick(target);
});
frag.append(a);
} else if (part) {
frag.append(part);
}
});
node.replaceWith(frag);
}
}
export function initPanelView(opts: {
content: HTMLElement;
copyBtn: HTMLElement;
modeBtn: HTMLElement;
titleEl?: HTMLElement;
editBtn?: HTMLElement;
editContentBtn?: HTMLElement;
langSelect?: HTMLSelectElement;
/// Standard-Sprache der Rechtschreibprüfung (aus den App-Settings).
defaultLang?: string;
/// Wird mit dem neuen Rohtext aufgerufen, wenn Titel oder Inhalt geändert
/// wurden.
onCommit?: (text: string) => void | Promise<void>;
/// Klick auf einen `[[name]]`-Wikilink im gerenderten Markdown.
onWikiLink?: (name: string) => void;
}): PanelView {
let rawText = "";
let rendered = true;
// Content-Edit-Zustand: während des Editierens werden eingehende Updates
// gepuffert statt angewandt.
let editing = false;
let pending: string | null = null;
let flushEditor: () => Promise<void> = async () => {};
function draw() {
if (rendered) {
opts.content.className = "md";
opts.content.innerHTML = renderMarkdown(rawText);
if (opts.onWikiLink) linkWikiRefs(opts.content, opts.onWikiLink);
} else {
opts.content.className = "raw";
opts.content.textContent = rawText;
}
opts.modeBtn.textContent = rendered ? t("panel.rendered") : t("panel.raw");
}
opts.modeBtn.addEventListener("click", () => {
rendered = !rendered;
draw();
});
opts.copyBtn.addEventListener("click", async () => {
await writeText(rawText);
flash(opts.copyBtn, "copied");
});
// Titel-Edit: Edit-Button macht den Titel editierbar, Enter/Blur schreibt die
// geänderte Überschrift zurück, Escape verwirft.
const titleEl = opts.titleEl;
if (opts.editBtn && titleEl && opts.onCommit) {
const commit = () => {
if (titleEl.getAttribute("contenteditable") !== "true") return;
titleEl.removeAttribute("contenteditable");
const nt = (titleEl.textContent || "").trim();
if (nt && nt !== firstLine(rawText)) opts.onCommit!(setHeading(rawText, nt));
else titleEl.textContent = firstLine(rawText);
};
opts.editBtn.addEventListener("click", () => {
titleEl.setAttribute("contenteditable", "true");
titleEl.focus();
const r = document.createRange();
r.selectNodeContents(titleEl);
const sel = window.getSelection();
sel?.removeAllRanges();
sel?.addRange(r);
});
titleEl.addEventListener("keydown", (e) => {
if (e.key === "Enter") {
e.preventDefault();
titleEl.blur();
} else if (e.key === "Escape") {
titleEl.textContent = firstLine(rawText);
titleEl.removeAttribute("contenteditable");
titleEl.blur();
}
});
titleEl.addEventListener("blur", commit);
}
// Content-Edit: Button schaltet den Inhalt auf eine Rohtext-Textarea. Speichern
// (Button erneut oder Cmd/Ctrl+Enter) schreibt zurück, Escape verwirft.
// Eingehende Updates während des Editierens werden gepuffert.
if (opts.editContentBtn && opts.onCommit) {
const editBtn = opts.editContentBtn;
const editor = document.createElement("textarea");
editor.className = "panel-editor";
editor.spellcheck = true;
editor.hidden = true;
opts.content.after(editor);
// Sprache der Rechtschreibprüfung: Default aus den Settings, per Selector
// pro Text überschreibbar.
let lang = opts.defaultLang || "de";
const sel = opts.langSelect;
if (sel) {
if ([...sel.options].some((o) => o.value === lang)) sel.value = lang;
else lang = sel.value;
sel.addEventListener("change", () => {
lang = sel.value;
editor.lang = lang;
// Neuprüfung erzwingen.
editor.spellcheck = false;
editor.spellcheck = true;
if (!editor.hidden) editor.focus();
});
}
editor.lang = lang;
const leave = () => {
editing = false;
editor.hidden = true;
opts.content.hidden = false;
editBtn.classList.remove("active", "changed");
};
const enter = () => {
editing = true;
pending = null;
editor.value = rawText;
opts.content.hidden = true;
editor.hidden = false;
editBtn.classList.add("active");
editor.focus();
};
flushEditor = async () => {
if (!editing) return;
const v = editor.value;
leave();
await opts.onCommit!(v); // schreibt Datei -> panel-update -> set() rendert
};
const save = () => void flushEditor();
const cancel = () => {
const p = pending;
leave();
if (p !== null) applyText(p);
else draw();
};
editBtn.addEventListener("click", () => (editing ? save() : enter()));
editor.addEventListener("keydown", (e) => {
if (e.key === "Enter" && (e.metaKey || e.ctrlKey)) {
e.preventDefault();
save();
} else if (e.key === "Escape") {
e.preventDefault();
cancel();
}
});
}
function applyText(text: string) {
rawText = text;
if (titleEl && titleEl.getAttribute("contenteditable") !== "true") {
titleEl.textContent = firstLine(text);
}
draw();
}
draw();
return {
set(text: string) {
// Während einer Inhalts-Bearbeitung nicht überschreiben — puffern und den
// Edit-Button als „geändert" markieren.
if (editing) {
pending = text;
opts.editContentBtn?.classList.add("changed");
return;
}
applyText(text);
},
raw: () => rawText,
flush: () => flushEditor(),
};
}
src/panel-window.css
+1 -122
View File
@@ -185,12 +185,6 @@ body {
margin: 0 6px;
align-self: center;
}
.panel-actions {
display: flex;
align-items: center;
justify-content: flex-end;
gap: 2px;
}
.panel-title {
flex: 0 1 auto;
min-width: 0;
@@ -199,13 +193,6 @@ body {
white-space: nowrap;
color: var(--muted);
}
.panel-title[contenteditable="true"] {
overflow: visible;
text-overflow: clip;
outline: none;
color: inherit;
cursor: text;
}
.panel-btn {
border: none;
background: transparent;
@@ -249,118 +236,10 @@ body {
.panel-btn.changed {
color: var(--warn);
}
.panel-editor {
flex: 1;
min-height: 0;
resize: none;
border: none;
outline: none;
padding: 16px 20px;
background: transparent;
color: inherit;
font-family: "JetBrains Mono", Menlo, monospace;
font-size: 12px;
line-height: 1.55;
}
.panel-editor[hidden] {
display: none;
}
.panel-tabs {
display: flex;
gap: 2px;
}
.panel-lang {
appearance: none;
-webkit-appearance: none;
margin-right: auto;
background: transparent;
color: var(--muted);
border: none;
border-radius: 6px;
padding: 6px 9px;
font: inherit;
cursor: default;
}
.panel-lang:hover {
background: var(--line);
color: var(--text);
}
#panel-content {
flex: 1;
min-height: 0;
overflow: auto;
padding: 16px 20px;
user-select: text;
-webkit-user-select: text;
cursor: text;
font-size: 13px;
line-height: 1.55;
}
#panel-content::-webkit-scrollbar {
width: 8px;
}
#panel-content::-webkit-scrollbar-thumb {
background: var(--line);
border-radius: 4px;
}
#panel-content.raw {
white-space: pre-wrap;
word-break: break-word;
font-family: "JetBrains Mono", Menlo, monospace;
font-size: 12px;
}
#panel-content.md h1,
#panel-content.md h2,
#panel-content.md h3 {
line-height: 1.25;
margin: 1em 0 0.4em;
}
#panel-content.md h1 {
font-size: 1.4em;
}
#panel-content.md h2 {
font-size: 1.2em;
}
#panel-content.md h3 {
font-size: 1.05em;
}
#panel-content.md :first-child {
margin-top: 0;
}
#panel-content.md p,
#panel-content.md ul,
#panel-content.md ol,
#panel-content.md pre,
#panel-content.md blockquote {
margin: 0 0 0.7em;
}
#panel-content.md code {
font-family: "JetBrains Mono", Menlo, monospace;
font-size: 0.9em;
background: var(--line);
border-radius: 4px;
padding: 1px 5px;
}
#panel-content.md pre {
background: var(--tile);
border-radius: 8px;
padding: 12px 14px;
overflow: auto;
}
#panel-content.md pre code {
background: none;
padding: 0;
}
#panel-content.md blockquote {
border-left: 3px solid var(--line);
padding-left: 12px;
color: var(--muted);
}
#panel-content.md a {
color: var(--accent);
}
.panel-btn[hidden],
.panel-lang[hidden],
#panel-content[hidden] {
.panel-btn[hidden] {
display: none;
}
src/panel-wiring.ts
+39 -98
View File
@@ -1,14 +1,11 @@
/// Gemeinsame Panel-Verdrahtung für das angedockte Panel (terminal.ts) und
/// das abgelöste Fenster (panel.ts): die Entwurfs-Ansicht als Kern, alle
/// weiteren Tabs aus der Modul-Registry (src/modules) — Tab-Knöpfe und
/// Content-Container entstehen hier aus der Liste der aktiven Module,
/// Erstbefüllung per buffer_read, Updates über `<buffer>-update`-Events.
/// Die Element-IDs des Entwurfs-Markups sind in beiden HTML-Dateien
/// identisch; die Draft-Controls trägt das Markup als `.draft-only`.
/// das abgelöste Fenster (panel.ts): alle Tabs kommen aus der Modul-Registry
/// (src/modules) — Tab-Knöpfe und Content-Container entstehen hier aus der
/// Liste der aktiven Module, Erstbefüllung per buffer_read, Updates über
/// `<buffer>-update`-Events.
import { invoke } from "@tauri-apps/api/core";
import { listen } from "@tauri-apps/api/event";
import { initPanelView, type PanelView } from "./panel-view";
import { initPanelMode, type ModeTab, type PanelMode } from "./commands-view";
import { panelToast } from "./tiles";
import { PANEL_TABS, type ModuleCtx, type ModuleView } from "./modules";
@@ -16,12 +13,9 @@ import { t } from "./messages";
import "./panel-tiles.css";
export interface PanelWiring {
view: PanelView;
/// Modul-Ansichten nach Tab-Modus; enthält nur Tabs aktiver Module.
views: Map<string, ModuleView>;
mode: { to(m: PanelMode): void; clear(): void; current(): PanelMode | null };
/// Entwurfstext beim Start (für die Anfangs-Modus-Entscheidung).
draft: string;
}
export async function wirePanel(
@@ -29,59 +23,18 @@ export async function wirePanel(
onIncoming?: () => void,
): Promise<PanelWiring> {
const titleEl = document.querySelector(".panel-title") as HTMLElement;
const [enabled, defaultLang, draft] = await Promise.all([
invoke<string[]>("enabled_modules", { project }),
invoke<string>("spellcheck_lang"),
invoke<string>("buffer_read", { project, buffer: "panel" }),
]);
const enabled = await invoke<string[]>("enabled_modules", { project });
const tabs = PANEL_TABS.filter((tab) => enabled.includes(tab.module));
// Ohne Archiv-Modul (abgewählt oder kein Archiv-Home) verschwinden auch
// die Archiv-Werkzeuge des Entwurfs-Tabs.
if (!enabled.includes("archive")) {
for (const sel of ["#panel-archive", "#panel-wiki-jump"]) {
const el = document.querySelector<HTMLElement>(sel)!;
el.hidden = true;
// Raus aus der draft-only-Menge, sonst blendet der Modus-Umschalter
// die Archiv-Werkzeuge im Dokument-Modus wieder ein.
el.classList.remove("draft-only");
}
}
// Jeder Wiki-Sprung (Wikilink, Chip, Dokument-Sprung) geht als ein Invoke an
// den Kern; das Ergebnis kommt über den Wiki-Puffer und `wiki-update` zurück.
// Fehler (z. B. Ziel nicht im Archiv) erscheinen als Toast.
const openWiki = (name: string) =>
void invoke("wiki_open", { project, name }).catch((e) => panelToast(String(e)));
const ctx: ModuleCtx = {
project,
toast: panelToast,
openDoc: (path) =>
void invoke("panel_load", { project, path }).catch((e) => panelToast(String(e))),
openWiki,
};
const view = initPanelView({
content: document.getElementById("panel-content")!,
copyBtn: document.getElementById("panel-copy")!,
modeBtn: document.getElementById("panel-mode")!,
titleEl,
editBtn: document.getElementById("panel-title-edit")!,
editContentBtn: document.getElementById("panel-content-edit")!,
langSelect: document.getElementById("panel-lang") as HTMLSelectElement,
defaultLang,
onCommit: (text) => invoke("panel_set", { project, text }),
onWikiLink: openWiki,
});
const ctx: ModuleCtx = { project, toast: panelToast };
// Tab-Leiste und Container aus der Registry. Die Container-IDs
// (`<mode>-content`) sind zugleich die CSS-Anker der Ansichten; die
// Container reihen sich hinter #panel-content ein.
// Container reihen sich hinter der Kopfzeile (.panel-head) ein.
const tabsEl = document.getElementById("panel-tabs")!;
const views = new Map<string, ModuleView>();
const modeTabs: ModeTab[] = [];
let anchor = document.getElementById("panel-content")!;
let anchor = document.querySelector(".panel-head") as HTMLElement;
for (const tab of tabs) {
const btn = document.createElement("button");
btn.className = "panel-btn";
@@ -94,15 +47,12 @@ export async function wirePanel(
sep.className = "tab-sep";
tabsEl.append(sep);
}
let content: HTMLElement | null = null;
if (tab.init) {
content = document.createElement("div");
content.id = `${tab.mode}-content`;
content.hidden = true;
anchor.after(content);
anchor = content;
views.set(tab.mode, tab.init(content, ctx));
}
const content = document.createElement("div");
content.id = `${tab.mode}-content`;
content.hidden = true;
anchor.after(content);
anchor = content;
views.set(tab.mode, tab.init(content, ctx));
modeTabs.push({
mode: tab.mode,
btn,
@@ -113,43 +63,34 @@ export async function wirePanel(
: undefined,
});
}
const mode = initPanelMode({
tabs: modeTabs,
draftEls: [
document.getElementById("panel-content")!,
...document.querySelectorAll<HTMLElement>(".draft-only"),
],
titleEl,
flush: () => void view.flush(),
});
// Archiv-Zugang: fester Knopf hinter den Tabs — öffnet das Trilium-Fenster
// des Projekts (kein Modus, kein Content-Container).
if (enabled.includes("trilium")) {
const btn = document.createElement("button");
btn.className = "panel-btn";
btn.textContent = t("panel.archiveOpen");
btn.title = t("panel.archiveOpenTitle");
btn.addEventListener("click", () =>
void invoke("trilium_open", { project, noteId: null }).catch((e) =>
panelToast(String(e)),
),
);
tabsEl.append(btn);
}
// Sprung Dokument → Wiki: öffnet den Archiv-Navigator (Dokumentseiten im
// Wiki gibt es nicht mehr — Dokumente öffnen immer im Dokument-Tab).
document
.getElementById("panel-wiki-jump")!
.addEventListener("click", () => openWiki("tag:"));
const mode = initPanelMode({ tabs: modeTabs, titleEl });
view.set(draft);
await listen<string>("panel-update", (e) => {
// Erst umschalten, dann setzen: to("draft") restauriert den gemerkten
// Titel — der neue Inhalt (und damit sein Titel) muss danach kommen.
mode.to("draft");
view.set(e.payload);
onIncoming?.();
});
await Promise.all(
tabs
.filter((tab) => tab.init)
.map(async (tab) => {
const v = views.get(tab.mode)!;
v.set(await invoke<string>("buffer_read", { project, buffer: tab.buffer }));
await listen<string>(`${tab.buffer}-update`, (e) => {
v.set(e.payload);
mode.to(tab.mode);
onIncoming?.();
});
}),
tabs.map(async (tab) => {
const v = views.get(tab.mode)!;
v.set(await invoke<string>("buffer_read", { project, buffer: tab.buffer }));
await listen<string>(`${tab.buffer}-update`, (e) => {
v.set(e.payload);
mode.to(tab.mode);
onIncoming?.();
});
}),
);
return { view, views, mode, draft };
return { views, mode };
}
src/panel.ts
+10 -45
View File
@@ -6,14 +6,11 @@ import { getCurrentWebviewWindow } from "@tauri-apps/api/webviewWindow";
import { PhysicalPosition, PhysicalSize } from "@tauri-apps/api/dpi";
import { emit } from "@tauri-apps/api/event";
import { wirePanel } from "./panel-wiring";
import { flash, panelToast } from "./tiles";
import { initArchiveForm } from "./archive-form";
import { applyTheme, THEMES } from "./themes";
import { applyI18n, t } from "./messages";
import { applyI18n } from "./messages";
// Abgelöstes Panel-Fenster: liest den aktuellen Entwurf einmal ein und folgt
// danach denselben Update-Events wie das angedockte Panel; startet in
// „Befehle", wenn es (noch) keinen Entwurf gibt.
// Abgelöstes Panel-Fenster: dieselben Modul-Tabs wie das angedockte Panel,
// gespeist aus denselben Puffer-Update-Events.
applyI18n();
const project = new URLSearchParams(location.search).get("project")!;
const win = getCurrentWebviewWindow();
@@ -99,52 +96,20 @@ applyTheme(picked);
document.documentElement.style.background = picked.header;
document.body.style.background = picked.header;
const { view, views, mode, draft } = await wirePanel(project);
const { views, mode } = await wirePanel(project);
// Beim Ablösen kommt der dort aktive Tab als URL-Parameter mit; ohne ihn
// (Kaltstart) gilt die Default-Logik: ohne Entwurf die ToDo-Liste (falls
// gewählt und nicht leer), sonst die Befehle.
// (Kaltstart): ToDo-Liste, falls gewählt und nicht leer, sonst der erste Tab.
const initialMode = new URLSearchParams(location.search).get("mode");
const todos = views.get("todo");
const cmds = views.get("commands");
const first = views.keys().next().value;
if (initialMode) {
mode.to(initialMode);
} else if (!draft.trim()) {
if (todos && !todos.empty()) mode.to("todo");
else if (cmds && !cmds.empty()) mode.to("commands");
} else if (todos && !todos.empty()) {
mode.to("todo");
} else if (first) {
mode.to(first);
}
// Archivieren: wie im angedockten Panel — Formular aufklappen, Abschicken
// wählt notfalls erst das Archiv-Home per Dialog.
const archiveBtn = document.getElementById("panel-archive")!;
const archiveForm = initArchiveForm(archiveBtn, async (meta) => {
try {
const configured = await invoke<string | null>("panel_archive_dir_cmd", {
project,
});
let dir: string | undefined;
if (!configured) {
const { open } = await import("@tauri-apps/plugin-dialog");
const chosen = await open({ directory: true, title: t("panel.chooseArchiveDir") });
if (!chosen) return;
dir = chosen as string;
}
await view.flush(); // offene Bearbeitung erst speichern — archiviert, was zu sehen ist
const path = await invoke<string>("panel_archive_cmd", {
project,
dir,
folder: meta.folder ?? null,
description: meta.description ?? null,
tags: meta.tags,
});
flash(archiveBtn, "copied", 1400);
invoke("reveal_path_cmd", { path });
} catch (e) {
flash(archiveBtn, "error", 1400);
panelToast(`Archivieren fehlgeschlagen: ${e}`);
}
});
archiveBtn.addEventListener("click", () => archiveForm.toggle());
// „Andocken": angedocktes Panel wieder einblenden, dann dieses Fenster schließen.
document.getElementById("panel-dock")!.addEventListener("click", async () => {
await emit("panel-attached");
src/search-view.test.ts
+4 -6
View File
@@ -20,8 +20,7 @@ function setup() {
const run = JSON.stringify({
query: "arch",
tag: null,
home: "/tmp/archiv",
hits: [{ relpath: "a/2026-01-01_0000-x.md", title: "X", snippet: "ein **arch**iv" }],
hits: [{ note_id: "abc123def", title: "X" }],
});
describe("initSearchView", () => {
@@ -74,19 +73,18 @@ describe("initSearchView", () => {
expect(onSearch).toHaveBeenCalledWith("panel arch");
});
it("rendert Treffer; Klick liefert den absoluten Pfad", () => {
it("rendert Treffer; Klick liefert die noteId", () => {
const { view, onOpen } = setup();
view.set(run);
const tile = document.querySelector<HTMLElement>(".hit-tile")!;
expect(tile.querySelector(".hit-title")!.textContent).toBe("X");
expect(tile.querySelectorAll("mark").length).toBe(1);
tile.click();
expect(onOpen).toHaveBeenCalledWith("/tmp/archiv/a/2026-01-01_0000-x.md");
expect(onOpen).toHaveBeenCalledWith("abc123def");
});
it("zeigt „Keine Treffer“ bei leerem Ergebnis", () => {
const { view } = setup();
view.set(JSON.stringify({ query: "nix", tag: "adr", home: "/a", hits: [] }));
view.set(JSON.stringify({ query: "nix", tag: "adr", hits: [] }));
expect(document.querySelector(".hit-head")!.textContent).toBe(
"Keine Treffer für „nix“ · #adr",
);
src/search-view.ts
+9 -27
View File
@@ -1,22 +1,20 @@
/// Kachel-Ansicht der Archiv-Suchtreffer: rendert die Suchtreffer-Datei
/// (search_archive im MCP-Server) als klickbare Kacheln — Klick reicht den
/// absoluten Pfad des Treffers an onOpen. Titel/Snippet/Pfad sind Fremdtext und
/// gehen nie durch innerHTML; die `**…**`-Marker im Snippet werden per
/// Split in <mark>-Elemente übersetzt.
/// (search_archive im MCP-Server bzw. search_run aus dem Suchfeld) als
/// klickbare Kacheln — Klick reicht die noteId des Treffers an onOpen
/// (öffnet die Notiz im Trilium-Fenster). Titel sind Fremdtext und gehen
/// nie durch innerHTML.
import { t } from "./messages";
import { renderTile } from "./tiles";
interface Hit {
relpath: string;
note_id: string;
title: string;
snippet: string;
}
interface SearchRun {
query: string;
tag?: string | null;
home: string;
hits: Hit[];
}
@@ -27,7 +25,7 @@ export interface SearchView {
export function initSearchView(
container: HTMLElement,
onOpen: (path: string) => void,
onOpen: (noteId: string) => void,
onSearch: (query: string) => void,
): SearchView {
let count = 0;
@@ -41,7 +39,7 @@ export function initSearchView(
// Live-Suche ab 3 Zeichen, entprellt (300 ms Debounce); endet die Eingabe
// mitten im Wort, wird das letzte Wort als Präfix gesucht (arch → arch*) —
// außer es ist ein #tag-Token. Enter sucht sofort und wörtlich — für exakte
// FTS-Syntax (Phrasen, OR/NOT).
// Trilium-Suchsyntax (Phrasen, Operatoren).
let pending: number | undefined;
input.addEventListener("input", () => {
clearTimeout(pending);
@@ -73,21 +71,6 @@ export function initSearchView(
const results = document.createElement("div");
container.append(bar, results);
function snippetEl(snippet: string): HTMLElement {
const div = document.createElement("div");
div.className = "hit-snippet";
snippet.split("**").forEach((part, i) => {
if (i % 2) {
const m = document.createElement("mark");
m.textContent = part;
div.append(m);
} else if (part) {
div.append(document.createTextNode(part));
}
});
return div;
}
function render(run: SearchRun) {
results.textContent = "";
const head = document.createElement("div");
@@ -105,10 +88,9 @@ export function initSearchView(
cls: "hit-tile",
parts: [
{ cls: "hit-title", text: hit.title },
snippetEl(hit.snippet),
{ cls: "hit-path", text: hit.relpath },
{ cls: "hit-path", text: hit.note_id },
],
onClick: () => onOpen(`${run.home}/${hit.relpath}`),
onClick: () => onOpen(hit.note_id),
}),
);
}
src/terminal-window.css
+1 -122
View File
@@ -265,12 +265,6 @@ header .panel-tabs[hidden] + #pool {
#panel-detach {
margin-left: auto;
}
.panel-actions {
display: flex;
align-items: center;
justify-content: flex-end;
gap: 2px;
}
.panel-title {
flex: 0 1 auto;
min-width: 0;
@@ -279,13 +273,6 @@ header .panel-tabs[hidden] + #pool {
white-space: nowrap;
color: var(--muted);
}
.panel-title[contenteditable="true"] {
overflow: visible;
text-overflow: clip;
outline: none;
color: inherit;
cursor: text;
}
.panel-btn {
border: none;
background: transparent;
@@ -329,118 +316,10 @@ header .panel-tabs[hidden] + #pool {
.panel-btn.changed {
color: var(--warn);
}
.panel-editor {
flex: 1;
min-height: 0;
resize: none;
border: none;
outline: none;
padding: 14px 16px;
background: transparent;
color: inherit;
font-family: "JetBrains Mono", Menlo, monospace;
font-size: 12px;
line-height: 1.55;
}
.panel-editor[hidden] {
display: none;
}
.panel-tabs {
display: flex;
gap: 2px;
}
.panel-lang {
appearance: none;
-webkit-appearance: none;
margin-right: auto;
background: transparent;
color: var(--muted);
border: none;
border-radius: 6px;
padding: 6px 9px;
font: inherit;
cursor: default;
}
.panel-lang:hover {
background: var(--line);
color: var(--text);
}
#panel-content {
flex: 1;
min-height: 0;
overflow: auto;
padding: 14px 16px;
user-select: text;
-webkit-user-select: text;
cursor: text;
font-size: 13px;
line-height: 1.55;
}
#panel-content::-webkit-scrollbar {
width: 8px;
}
#panel-content::-webkit-scrollbar-thumb {
background: var(--line);
border-radius: 4px;
}
#panel-content.raw {
white-space: pre-wrap;
word-break: break-word;
font-family: "JetBrains Mono", Menlo, monospace;
font-size: 12px;
}
#panel-content.md h1,
#panel-content.md h2,
#panel-content.md h3 {
line-height: 1.25;
margin: 1em 0 0.4em;
}
#panel-content.md h1 {
font-size: 1.4em;
}
#panel-content.md h2 {
font-size: 1.2em;
}
#panel-content.md h3 {
font-size: 1.05em;
}
#panel-content.md :first-child {
margin-top: 0;
}
#panel-content.md p,
#panel-content.md ul,
#panel-content.md ol,
#panel-content.md pre,
#panel-content.md blockquote {
margin: 0 0 0.7em;
}
#panel-content.md code {
font-family: "JetBrains Mono", Menlo, monospace;
font-size: 0.9em;
background: var(--line);
border-radius: 4px;
padding: 1px 5px;
}
#panel-content.md pre {
background: var(--tile);
border-radius: 8px;
padding: 12px 14px;
overflow: auto;
}
#panel-content.md pre code {
background: none;
padding: 0;
}
#panel-content.md blockquote {
border-left: 3px solid var(--line);
padding-left: 12px;
color: var(--muted);
}
#panel-content.md a {
color: var(--accent);
}
.panel-btn[hidden],
.panel-lang[hidden],
#panel-content[hidden] {
.panel-btn[hidden] {
display: none;
}
src/terminal.ts
+16 -40
View File
@@ -15,8 +15,7 @@ import { getCurrentWebviewWindow } from "@tauri-apps/api/webviewWindow";
import { listen } from "@tauri-apps/api/event";
import { wirePanel } from "./panel-wiring";
import { applyTheme, THEMES } from "./themes";
import { flash, panelToast } from "./tiles";
import { initArchiveForm } from "./archive-form";
import { panelToast } from "./tiles";
import { applyI18n, t } from "./messages";
// Debug-Instrumentierung: Fehler auf der Seite anzeigen und ins Dev-Log spiegeln.
@@ -189,10 +188,10 @@ window.addEventListener("resize", () => fit.fit());
await invoke("term_start", { project, rows: term.rows, cols: term.cols });
term.focus();
// --- Andockbares Entwurfs-Panel -------------------------------------------
// Der Skill schreibt Entwürfe in eine Datei; terminal.rs meldet neuen Inhalt
// per `panel-update`. Das Panel blendet sich dann ein — außer es ist gerade in
// ein eigenes Fenster abgelöst (`panel-detached`).
// --- Andockbares Panel ----------------------------------------------------
// Die MCP-Tools schreiben in die Puffer-Dateien; terminal.rs meldet neuen
// Inhalt als `<buffer>-update`. Das Panel blendet sich dann ein — außer es
// ist gerade in ein eigenes Fenster abgelöst (`panel-detached`).
const panel = document.getElementById("panel")!;
const splitter = document.getElementById("splitter")!;
@@ -212,10 +211,20 @@ function hidePanel() {
// Gemeinsame Verdrahtung (Views, Modi, Update-Events); jedes eingehende
// Update blendet das angedockte Panel ein, solange es nicht abgelöst ist.
const { view, views, mode } = await wirePanel(project, () => {
const { views, mode } = await wirePanel(project, () => {
hasContent = true;
if (!detached) showPanel();
});
// write_panel hat eine Notiz angelegt: das Trilium-Fenster des Projekts
// zeigt sie. Leerer Puffer = Session-Start, keine Notiz.
await listen<string>("noteopen-update", (e) => {
if (!e.payload.trim()) return;
const { noteId } = JSON.parse(e.payload);
void invoke("trilium_open", { project, noteId }).catch((err) =>
panelToast(String(err)),
);
});
// Panel startet zugeklappt — außer das ToDo-Modul ist gewählt und die Liste
// nicht leer: dann öffnet das Panel beim Start mit der ToDo-Ansicht.
const todos = views.get("todo");
@@ -265,39 +274,6 @@ document.getElementById("panel-hide")!.addEventListener("click", () => {
mode.clear();
});
// Archivieren: Button klappt das Formular (Ordner/Beschreibung/Schlagwörter)
// auf; Abschicken wählt notfalls erst das Archiv-Home per Dialog.
const archiveBtn = document.getElementById("panel-archive")!;
const archiveForm = initArchiveForm(archiveBtn, async (meta) => {
try {
const configured = await invoke<string | null>("panel_archive_dir_cmd", {
project,
});
let dir: string | undefined;
if (!configured) {
const { open } = await import("@tauri-apps/plugin-dialog");
const chosen = await open({ directory: true, title: t("panel.chooseArchiveDir") });
if (!chosen) return;
dir = chosen as string;
}
await view.flush(); // offene Bearbeitung erst speichern — archiviert, was zu sehen ist
const path = await invoke<string>("panel_archive_cmd", {
project,
dir,
folder: meta.folder ?? null,
description: meta.description ?? null,
tags: meta.tags,
});
flash(archiveBtn, "copied", 1400);
invoke("reveal_path_cmd", { path });
} catch (e) {
flash(archiveBtn, "error", 1400);
panelToast(`Archivieren fehlgeschlagen: ${e}`);
invoke("term_log", { msg: `archive: ${e}` });
}
});
archiveBtn.addEventListener("click", () => archiveForm.toggle());
// Splitter: Panelbreite ziehen.
splitter.addEventListener("mousedown", (e) => {
e.preventDefault();
src/wiki-view.test.ts
-246
View File
@@ -1,246 +0,0 @@
// Wiki-Ansicht: Ordner-Baum links, flache Inhaltsliste rechts, Zeilen-Aktionen
// (öffnen, umbenennen, löschen), Ordner-Umbenennen, Leerzustände.
import { describe, expect, it, vi } from "vitest";
import { initWikiView } from "./wiki-view";
function setup() {
document.body.innerHTML = `<div id="w"></div>`;
const openDoc = vi.fn();
const openWiki = vi.fn();
const actions = {
rename: vi.fn(),
remove: vi.fn(),
moveFolder: vi.fn(),
createFolder: vi.fn(),
createDoc: vi.fn(),
};
const view = initWikiView(document.getElementById("w")!, {
openDoc,
openWiki,
actions,
});
return { view, openDoc, openWiki, actions };
}
const doc = (relpath: string, name: string, extra: object = {}) => ({
relpath,
name,
title: name.toUpperCase(),
description: null,
tags: [],
date: "2026-07-19",
backlinks: 0,
...extra,
});
const page = JSON.stringify({
kind: "page",
home: "/tmp/archiv",
tag: null,
total: 3,
tags: [],
folders: [
{
name: "",
docs: [
doc("2026-07-19_1000-wurzel-doc.md", "wurzel-doc", {
backlinks: 2,
description: "Beschreibung",
}),
],
},
{ name: "konzepte", docs: [doc("konzepte/2026-07-19_1005-neu.md", "neu")] },
{
name: "konzepte/panel",
docs: [doc("konzepte/panel/2026-07-19_1010-alt.md", "alt")],
},
],
});
describe("initWikiView — Baum und Liste", () => {
it("Baum zeigt nur Ordner, Wurzel ist gewählt und listet ihren Inhalt", () => {
const { view } = setup();
view.set(page);
// Baum: Wurzel-Knopf + Ordner (keine Dokumentzeilen im Baum).
expect(document.querySelector(".wiki-tree-root")!.className).toContain("active");
const folders = [...document.querySelectorAll(".wiki-tree .wiki-tree-name")].map(
(e) => e.textContent,
);
expect(folders).toEqual(["konzepte", "panel"]);
// Liste rechts: nur der direkte Wurzel-Inhalt.
expect(document.querySelector(".wiki-head-title")!.textContent).toBe("Archiv");
expect(document.querySelector(".wiki-head-right")!.textContent).toBe("1 Dokument");
const rows = [...document.querySelectorAll(".wiki-doc .wiki-doc-title")].map(
(e) => e.textContent,
);
expect(rows).toEqual(["WURZEL-DOC"]);
expect(document.querySelector(".wiki-doc-back")!.textContent).toBe("↩ 2");
expect(document.querySelector(".wiki-doc-desc")!.textContent).toBe("Beschreibung");
});
it("Ordner-Klick wählt aus und zeigt dessen flache Liste", () => {
const { view } = setup();
view.set(page);
const names = document.querySelectorAll<HTMLElement>(".wiki-tree .wiki-tree-name");
names[0].click(); // konzepte
expect(document.querySelector(".wiki-head-title")!.textContent).toBe("konzepte");
expect(document.querySelector(".wiki-head-sub")!.textContent).toBe(
"/tmp/archiv/konzepte",
);
const rows = [...document.querySelectorAll(".wiki-doc .wiki-doc-title")].map(
(e) => e.textContent,
);
// Nur direkter Inhalt — das Dokument aus konzepte/panel erscheint nicht.
expect(rows).toEqual(["NEU"]);
expect(
document.querySelector(".wiki-tree summary.active .wiki-tree-name")!.textContent,
).toBe("konzepte");
});
it("Dokument-Klick öffnet über den absoluten Pfad", () => {
const { view, openDoc } = setup();
view.set(page);
document.querySelector<HTMLElement>(".wiki-doc")!.click();
expect(openDoc).toHaveBeenCalledWith("/tmp/archiv/2026-07-19_1000-wurzel-doc.md");
});
it("Auswahl übersteht ein Puffer-Update, verschwundener Ordner fällt zur Wurzel", () => {
const { view } = setup();
view.set(page);
document.querySelectorAll<HTMLElement>(".wiki-tree .wiki-tree-name")[0].click();
view.set(page); // Update: Auswahl bleibt
expect(document.querySelector(".wiki-head-title")!.textContent).toBe("konzepte");
view.set(
JSON.stringify({
kind: "page",
home: "/tmp/archiv",
tag: null,
total: 1,
tags: [],
folders: [{ name: "", docs: [doc("2026-07-19_1000-wurzel-doc.md", "wurzel-doc")] }],
}),
);
expect(document.querySelector(".wiki-head-title")!.textContent).toBe("Archiv");
});
});
describe("initWikiView — Aktionen", () => {
it("Stift an der Zeile: Inline-Umbenennen mit Enter, ohne das Dokument zu öffnen", () => {
const { view, actions, openDoc } = setup();
view.set(page);
const row = document.querySelector<HTMLElement>(".wiki-doc")!;
row.querySelector<HTMLElement>(".cmd-edit")!.click();
const input = row.querySelector<HTMLInputElement>(".wiki-tree-input")!;
expect(input.value).toBe("wurzel-doc");
input.value = "Neuer Name";
input.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
expect(actions.rename).toHaveBeenCalledWith(
"2026-07-19_1000-wurzel-doc.md",
"Neuer Name",
);
expect(openDoc).not.toHaveBeenCalled();
});
it("Escape stellt die Zeile wieder her", () => {
const { view, actions } = setup();
view.set(page);
document.querySelector<HTMLElement>(".wiki-doc .cmd-edit")!.click();
const input = document.querySelector<HTMLInputElement>(".wiki-doc .wiki-tree-input")!;
input.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", bubbles: true }));
expect(document.querySelector(".wiki-doc .wiki-doc-title")!.textContent).toBe(
"WURZEL-DOC",
);
expect(actions.rename).not.toHaveBeenCalled();
});
it("Löschen meldet mit relpath, ohne das Dokument zu öffnen", () => {
const { view, actions, openDoc } = setup();
view.set(page);
document.querySelector<HTMLElement>(".wiki-doc .cmd-del")!.click();
expect(actions.remove).toHaveBeenCalledWith("2026-07-19_1000-wurzel-doc.md");
expect(openDoc).not.toHaveBeenCalled();
});
it("Plus im Listenkopf: Formular legt Dokument im gewählten Ordner an", () => {
const { view, actions, openDoc } = setup();
view.set(page);
document.querySelectorAll<HTMLElement>(".wiki-tree .wiki-tree-name")[0].click();
document.querySelector<HTMLElement>(".wiki-head .wiki-add")!.click();
const form = document.querySelector<HTMLElement>(".wiki-form")!;
expect(form.querySelector(".wiki-form-title")!.textContent).toBe("Neues Dokument");
const input = form.querySelector<HTMLInputElement>("input")!;
input.value = "Deploy Notiz";
form.querySelector<HTMLElement>(".wiki-form-submit")!.click();
expect(actions.createDoc).toHaveBeenCalledWith("konzepte", "Deploy Notiz");
expect(document.querySelector(".wiki-form")).toBeNull();
expect(openDoc).not.toHaveBeenCalled();
});
it("Abbrechen und Escape schließen das Formular ohne Aktion", () => {
const { view, actions } = setup();
view.set(page);
document.querySelector<HTMLElement>(".wiki-head .wiki-add")!.click();
document.querySelector<HTMLElement>(".wiki-form-cancel")!.click();
expect(document.querySelector(".wiki-form")).toBeNull();
document.querySelector<HTMLElement>(".wiki-head .wiki-add")!.click();
document
.querySelector<HTMLElement>(".wiki-form")!
.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", bubbles: true }));
expect(document.querySelector(".wiki-form")).toBeNull();
expect(actions.createDoc).not.toHaveBeenCalled();
});
it("Plus im Baum: Formular legt Ordner an, Pfad mit gewähltem Ordner vorbefüllt", () => {
const { view, actions } = setup();
view.set(page);
document.querySelectorAll<HTMLElement>(".wiki-tree .wiki-tree-name")[0].click();
document.querySelector<HTMLElement>(".wiki-tree-head .wiki-add")!.click();
const input = document.querySelector<HTMLInputElement>(".wiki-form input")!;
expect(input.value).toBe("konzepte/");
input.value = "konzepte/neu";
input.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
expect(actions.createFolder).toHaveBeenCalledWith("konzepte/neu");
});
it("Ordner-Stift: Inline-Eingabe des Pfads, Enter meldet moveFolder", () => {
const { view, actions } = setup();
view.set(page);
const summary = document.querySelector<HTMLElement>(".wiki-tree summary")!;
summary.querySelector<HTMLElement>(".cmd-edit")!.click();
const input = summary.querySelector<HTMLInputElement>(".wiki-tree-input")!;
expect(input.value).toBe("konzepte");
input.value = "notizen/2026";
input.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
expect(actions.moveFolder).toHaveBeenCalledWith("konzepte", "notizen/2026");
});
});
describe("initWikiView — Leerzustände", () => {
it("leeres Archiv erklärt das Archivieren", () => {
const { view } = setup();
view.set(
JSON.stringify({
kind: "page",
home: "/a",
tag: null,
total: 0,
tags: [],
folders: [],
}),
);
expect(document.querySelector(".wiki-empty")!.textContent).toContain(
"Das Archiv ist leer.",
);
});
it("leerer Puffer bietet den Übersichts-Einstieg", () => {
const { view, openWiki } = setup();
view.set("");
expect(view.empty()).toBe(true);
document.querySelector<HTMLElement>(".wiki-empty .wiki-chip")!.click();
expect(openWiki).toHaveBeenCalledWith("tag:");
view.set(page);
expect(view.empty()).toBe(false);
});
});
src/wiki-view.ts
-370
View File
@@ -1,370 +0,0 @@
/// Wiki-Ansicht des Panels: Ordner-Navigator übers Archiv. Links der Baum —
/// nur Ordner, oberster Knoten ist die Archiv-Wurzel; Klick auf einen Ordner
/// zeigt rechts die flache Liste seines direkten Inhalts. Klick auf eine
/// Dokumentzeile lädt das Dokument in den Dokument-Tab (wie ein
/// Suchtreffer); an der Zeile: umbenennen (inline) und löschen, am
/// Ordnerknoten: umbenennen. Titel, Beschreibungen und Pfade sind Fremdtext
/// und gehen nie durch innerHTML.
import { t } from "./messages";
import { deleteAction, editAction } from "./tiles";
interface DocEntry {
relpath: string;
name: string;
title: string;
description?: string | null;
tags: string[];
date?: string | null;
backlinks: number;
}
interface Folder {
name: string;
docs: DocEntry[];
}
interface Page {
kind: "page";
home: string;
tag?: string | null;
total: number;
tags: { name: string; count: number }[];
folders: Folder[];
}
/// Dokument-/Ordner-Operationen — laufen als Tauri-Commands, der neue Stand
/// kommt über den Wiki-Puffer zurück.
export interface WikiActions {
rename(relpath: string, name: string): void;
remove(relpath: string): void;
moveFolder(folder: string, to: string): void;
createFolder(folder: string): void;
createDoc(folder: string, name: string): void;
}
export interface WikiCallbacks {
/// Dokument in den Dokument-Tab laden (absoluter Pfad, wie Suchtreffer).
openDoc(path: string): void;
/// Wiki-Ziel laden (`tag:` = Übersicht in den Puffer, Einstiegs-Chip).
openWiki(name: string): void;
actions: WikiActions;
}
export interface WikiView {
set(text: string): void;
/// Noch keine Seite im Puffer (Session-Start)?
empty(): boolean;
}
/// Verschachtelter Ordner-Knoten, aus den Ordnerpfaden gebaut.
interface TreeNode {
children: Map<string, TreeNode>;
}
function buildTree(folders: Folder[]): TreeNode {
const root: TreeNode = { children: new Map() };
for (const folder of folders) {
if (!folder.name) continue;
let node = root;
for (const part of folder.name.split("/")) {
if (!node.children.has(part)) {
node.children.set(part, { children: new Map() });
}
node = node.children.get(part)!;
}
}
return root;
}
export function initWikiView(container: HTMLElement, cb: WikiCallbacks): WikiView {
/// Zugeklappte Ordner und gewählter Ordner ("" = Wurzel) — überleben
/// Puffer-Updates innerhalb der Ansicht.
const closed = new Set<string>();
let selected = "";
let current: Page | null = null;
// ---------- Baum-Spalte (nur Ordner) ----------
function folderRow(name: string, full: string, node: TreeNode): HTMLElement {
const det = document.createElement("details");
det.className = "wiki-tree-folder";
det.open = !closed.has(full);
det.addEventListener("toggle", () => {
if (det.open) closed.delete(full);
else closed.add(full);
});
const sum = document.createElement("summary");
if (full === selected) sum.classList.add("active");
const label = document.createElement("span");
label.className = "wiki-tree-name";
label.textContent = name;
// Name wählt den Ordner aus (ohne zu klappen); der Pfeil davor klappt.
label.addEventListener("click", (e) => {
e.preventDefault();
select(full);
});
const rename = editAction(t("wiki.folderRename"), () => {
const input = document.createElement("input");
input.className = "wiki-tree-input";
input.value = full;
sum.replaceChildren(input);
input.focus();
input.select();
input.addEventListener("keydown", (e) => {
e.stopPropagation();
if (e.key === "Enter") {
cb.actions.moveFolder(full, input.value.trim());
} else if (e.key === "Escape") {
sum.replaceChildren(label, rename);
}
});
input.addEventListener("click", (e) => e.preventDefault());
});
rename.addEventListener("click", (e) => {
e.preventDefault();
e.stopPropagation();
});
sum.append(label, rename);
det.append(sum, renderChildren(node, full));
return det;
}
function renderChildren(node: TreeNode, path: string): HTMLElement {
const box = document.createElement("div");
box.className = "wiki-tree-children";
for (const [name, child] of [...node.children].sort((a, b) =>
a[0].localeCompare(b[0]),
)) {
box.append(folderRow(name, path ? `${path}/${name}` : name, child));
}
return box;
}
function renderTree(p: Page): HTMLElement {
const aside = document.createElement("aside");
aside.className = "wiki-tree";
const head = document.createElement("div");
head.className = "wiki-tree-head";
const root = document.createElement("button");
root.className = "wiki-tree-root" + (selected === "" ? " active" : "");
root.textContent = t("wiki.archive");
root.addEventListener("click", () => select(""));
const add = document.createElement("button");
add.className = "wiki-add";
add.title = t("wiki.newFolder");
add.textContent = "+";
add.addEventListener("click", () =>
openForm(t("wiki.newFolder"), t("wiki.folderPath"), selected ? `${selected}/` : "", (v) =>
cb.actions.createFolder(v),
),
);
head.append(root, add);
aside.append(head, renderChildren(buildTree(p.folders), ""));
return aside;
}
// ---------- Anlege-Formular (Ordner/Dokument) ----------
/// Kleines Formular oben in der Liste: ein Textfeld, Anlegen/Abbrechen;
/// Enter legt an, Escape schließt. Leere oder ungültige Eingaben meldet
/// das Backend als Toast.
function openForm(
title: string,
placeholder: string,
initial: string,
onSubmit: (value: string) => void,
) {
const main = container.querySelector<HTMLElement>(".wiki-main")!;
main.querySelector(".wiki-form")?.remove();
const form = document.createElement("div");
form.className = "wiki-form";
const caption = document.createElement("div");
caption.className = "wiki-form-title";
caption.textContent = title;
const input = document.createElement("input");
input.className = "wiki-tree-input";
input.placeholder = placeholder;
input.value = initial;
const submit = document.createElement("button");
submit.className = "wiki-form-submit";
submit.textContent = t("wiki.create");
const cancel = document.createElement("button");
cancel.className = "wiki-form-cancel";
cancel.textContent = t("wiki.cancel");
const fire = () => {
const value = input.value.trim();
form.remove();
onSubmit(value);
};
submit.addEventListener("click", fire);
cancel.addEventListener("click", () => form.remove());
form.addEventListener("keydown", (e) => {
if (e.key === "Enter") fire();
else if (e.key === "Escape") form.remove();
});
form.append(caption, input, submit, cancel);
main.querySelector(".wiki-head")!.after(form);
input.focus();
}
// ---------- Liste rechts: direkter Ordnerinhalt ----------
function docRow(p: Page, doc: DocEntry): HTMLElement {
const row = document.createElement("div");
row.className = "wiki-doc";
const line = document.createElement("div");
line.className = "wiki-doc-line";
const title = document.createElement("div");
title.className = "wiki-doc-title";
title.textContent = doc.title;
line.append(title);
if (doc.backlinks) {
const back = document.createElement("div");
back.className = "wiki-doc-back";
back.title = t("wiki.backlinks");
back.textContent = `↩ ${doc.backlinks}`;
line.append(back);
}
if (doc.date) {
const date = document.createElement("div");
date.className = "wiki-doc-date";
date.textContent = doc.date;
line.append(date);
}
const acts = document.createElement("div");
acts.className = "wiki-doc-actions";
const rename = editAction(t("wiki.renameDoc"), () => {
const input = document.createElement("input");
input.className = "wiki-tree-input";
input.value = doc.name;
row.replaceChildren(input);
input.focus();
input.select();
input.addEventListener("keydown", (e) => {
if (e.key === "Enter") {
cb.actions.rename(doc.relpath, input.value);
} else if (e.key === "Escape" && current) {
renderMain(current);
}
});
input.addEventListener("click", (e) => e.stopPropagation());
});
acts.append(rename, deleteAction(t("wiki.deleteDoc"), () => cb.actions.remove(doc.relpath)));
for (const btn of acts.querySelectorAll("button")) {
btn.addEventListener("click", (e) => e.stopPropagation());
}
line.append(acts);
row.append(line);
if (doc.description) {
const desc = document.createElement("div");
desc.className = "wiki-doc-desc";
desc.textContent = doc.description;
row.append(desc);
}
row.addEventListener("click", () => cb.openDoc(`${p.home}/${doc.relpath}`));
return row;
}
function renderMain(p: Page) {
const main = container.querySelector<HTMLElement>(".wiki-main")!;
main.textContent = "";
const docs = p.folders.find((f) => f.name === selected)?.docs ?? [];
const head = document.createElement("div");
head.className = "wiki-head";
const left = document.createElement("div");
left.className = "wiki-head-left";
const title = document.createElement("div");
title.className = "wiki-head-title";
title.textContent = selected ? selected.split("/").pop()! : t("wiki.archive");
const sub = document.createElement("div");
sub.className = "wiki-head-sub";
sub.textContent = selected ? `${p.home}/${selected}` : p.home;
left.append(title, sub);
const count = document.createElement("div");
count.className = "wiki-head-right";
count.textContent = t(docs.length === 1 ? "wiki.docOne" : "wiki.docMany", {
count: docs.length,
});
const add = document.createElement("button");
add.className = "wiki-add";
add.title = t("wiki.newDoc");
add.textContent = "+";
add.addEventListener("click", () =>
openForm(t("wiki.newDoc"), t("wiki.docName"), "", (v) =>
cb.actions.createDoc(selected, v),
),
);
head.append(left, count, add);
main.append(head);
if (docs.length === 0) {
const empty = document.createElement("div");
empty.className = "wiki-empty";
const line = document.createElement("strong");
line.textContent = p.total === 0 ? t("wiki.emptyArchive") : t("wiki.emptyFolder");
empty.append(line);
if (p.total === 0) empty.append(t("wiki.emptyHint"));
main.append(empty);
return;
}
for (const doc of docs) main.append(docRow(p, doc));
}
function select(folder: string) {
selected = folder;
if (current) render(current);
}
function render(p: Page) {
container.textContent = "";
const layout = document.createElement("div");
layout.className = "wiki-layout";
const main = document.createElement("div");
main.className = "wiki-main";
layout.append(renderTree(p), main);
container.append(layout);
renderMain(p);
}
/// Leerer Puffer: Einstieg statt leerer Fläche.
function renderIntro() {
const empty = document.createElement("div");
empty.className = "wiki-empty";
const line = document.createElement("strong");
line.textContent = t("wiki.noPage");
empty.append(line);
const open = document.createElement("button");
open.className = "wiki-chip";
open.textContent = t("wiki.openOverview");
open.addEventListener("click", () => cb.openWiki("tag:"));
empty.append(open);
container.append(empty);
}
let loaded = false;
return {
set(text: string) {
container.textContent = "";
loaded = !!text.trim();
if (!loaded) {
current = null;
renderIntro();
return;
}
current = JSON.parse(text);
// Der gewählte Ordner kann nach Umbenennen/Löschen weg sein — dann
// zurück zur Wurzel. Zwischenordner (nur Unterordner, keine eigenen
// Dokumente) bleiben wählbar.
const exists = current!.folders.some(
(f) => f.name === selected || f.name.startsWith(`${selected}/`),
);
if (selected && !exists) {
selected = "";
}
render(current!);
},
empty: () => !loaded,
};
}
terminal.html
+2 -28
View File
@@ -27,10 +27,10 @@
<div id="term"></div>
<div id="splitter" hidden></div>
<aside id="panel" hidden>
<!-- Modul-Container (<mode>-content) reihen sich hinter der Kopfzeile ein. -->
<div class="panel-head">
<div class="panel-titlerow">
<span class="panel-title" data-i18n="panel.tabDraft">Dokument</span>
<button class="panel-btn panel-edit draft-only" id="panel-title-edit" data-i18n-title="panel.editTitle">✎</button>
<span class="panel-title"></span>
<button class="panel-btn" id="panel-detach" data-i18n-title="panel.detach">
<svg width="14" height="14" viewBox="0 0 16 16"><path d="M12.5 8.5V13a1 1 0 0 1-1 1H3a1 1 0 0 1-1-1V4.5a1 1 0 0 1 1-1h4.5" /><path d="M10 2h4v4" /><path d="M14 2 8 8" /></svg>
</button>
@@ -38,33 +38,7 @@
<svg width="12" height="12" viewBox="0 0 12 12"><path d="M3 3l6 6M9 3l-6 6" /></svg>
</button>
</div>
<div class="panel-actions">
<select class="panel-lang draft-only" id="panel-lang" data-i18n-title="panel.spellcheckLang">
<option value="de">DE</option>
<option value="en">EN</option>
<option value="en-GB">EN-GB</option>
<option value="fr">FR</option>
<option value="es">ES</option>
<option value="it">IT</option>
<option value="nl">NL</option>
</select>
<button class="panel-btn draft-only" id="panel-wiki-jump" data-i18n-title="panel.openInWiki">
<svg width="14" height="14" viewBox="0 0 16 16"><path d="M8 3.5C6.6 2.4 4.6 2 2.5 2v11c2.1 0 4.1.4 5.5 1.5 1.4-1.1 3.4-1.5 5.5-1.5V2c-2.1 0-4.1.4-5.5 1.5z" /><path d="M8 3.5v11" /></svg>
</button>
<button class="panel-btn draft-only" id="panel-mode" data-i18n-title="panel.toggleRaw" data-i18n="panel.rendered">MD</button>
<button class="panel-btn draft-only" id="panel-content-edit" data-i18n-title="panel.editDraft">
<svg width="14" height="14" viewBox="0 0 16 16"><path d="M10.8 2.6 13.4 5.2 6 12.6l-3.1.5.5-3.1z" /><path d="M9.7 3.7 12.3 6.3" /></svg>
</button>
<button class="panel-btn draft-only" id="panel-copy" data-i18n-title="panel.copy">
<svg width="14" height="14" viewBox="0 0 16 16"><rect x="5.5" y="5.5" width="8" height="8" rx="1.5" /><path d="M10.5 3.2V3A1.5 1.5 0 0 0 9 1.5H3A1.5 1.5 0 0 0 1.5 3v6A1.5 1.5 0 0 0 3 10.5h.2" /></svg>
</button>
<button class="panel-btn draft-only" id="panel-archive" data-i18n-title="panel.archive">
<svg width="14" height="14" viewBox="0 0 16 16"><rect x="1.5" y="2.5" width="13" height="3.5" rx="1" /><path d="M2.8 6v6.5a1 1 0 0 0 1 1h8.4a1 1 0 0 0 1-1V6" /><path d="M6.3 9h3.4" /></svg>
</button>
</div>
</div>
<!-- Modul-Container (<mode>-content) reihen sich hier ein. -->
<div id="panel-content" class="md"></div>
</aside>
</div>
<div id="resize-grips" aria-hidden="true">