Modul-Split: Fachlogik nach domain/, OS-Code nach platform/, Tauri-Verdrahtung in app.rs/commands.rs

- lib.rs nur noch Prozessrollen-Dispatch + Panic-Tracer - KWin-Script als KDE-Pendant zur GNOME-Extension (Popup ans Zeiger- Rechteck), wird von deb/rpm mit ausgeliefert - SNI-Tray auf ksni (pure Rust), appindicator-Depends entfallen
2026-07-15 20:10:33 +02:00
parent cf844c45da
commit 9a99bca466
32 changed files with 4413 additions and 3572 deletions
@@ -0,0 +1,209 @@
+//! 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;
+
+/// Konfigurierter Archiv-Ordner des Projekts (ai-control.json: archiveDir),
+/// Home-expandiert; None, wenn nicht gesetzt.
+pub(crate) fn project_archive_dir(project: &str) -> Option<PathBuf> {
+  let paths = Paths::real();
+  let dir = read_project_config_in(&paths, project).ok()?.archive_dir?;
+  Some(expand_home(&paths, &dir))
+}
+
+/// Setzt den Archiv-Ordner: ai-control.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_dir(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_dir = 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.
+fn add_archive_permission(paths: &Paths, project: &str, dir: &str) -> Result<(), String> {
+  let sp = settings_path(&project_dir(paths, project)?);
+  let mut v: serde_json::Value = if sp.is_file() {
+    serde_json::from_str(&fs::read_to_string(&sp).map_err(|e| format!("{}: {e}", sp.display()))?)
+      .map_err(|e| format!("{}: {e}", sp.display()))?
+  } else {
+    serde_json::json!({})
+  };
+  let root = v.as_object_mut().ok_or("settings.json ist kein Objekt")?;
+  let perms = root
+    .entry("permissions")
+    .or_insert_with(|| serde_json::json!({}))
+    .as_object_mut()
+    .ok_or("permissions ist kein Objekt")?;
+  let dirs = perms
+    .entry("additionalDirectories")
+    .or_insert_with(|| serde_json::json!([]))
+    .as_array_mut()
+    .ok_or("additionalDirectories ist kein Array")?;
+  if !dirs.iter().any(|d| d.as_str() == Some(dir)) {
+    dirs.push(serde_json::json!(dir));
+  }
+  let edit = format!("Edit({dir}/**)");
+  let allow = perms
+    .entry("allow")
+    .or_insert_with(|| serde_json::json!([]))
+    .as_array_mut()
+    .ok_or("allow ist kein Array")?;
+  if !allow.iter().any(|p| p.as_str() == Some(&edit)) {
+    allow.push(serde_json::json!(edit));
+  }
+  let parent = sp.parent().ok_or("settings.json ohne Elternordner")?;
+  fs::create_dir_all(parent).map_err(|e| format!("{}: {e}", parent.display()))?;
+  let raw = serde_json::to_string_pretty(&v).map_err(|e| e.to_string())?;
+  fs::write(&sp, raw + "\n").map_err(|e| format!("{}: {e}", sp.display()))
+}
+
+/// Archiviert den aktuellen Panel-Inhalt des Projekts als Markdown-Datei mit
+/// Frontmatter im Archiv-Ordner. `dir_override` setzt den Ordner zugleich
+/// (Terminal-Fallback ohne Dialog). Liefert den geschriebenen Pfad.
+pub(crate) fn archive_panel_content(
+  project: &str,
+  dir_override: Option<&str>,
+) -> Result<PathBuf, String> {
+  if let Some(d) = dir_override {
+    set_project_archive_dir(project, d)?;
+  }
+  let dir = project_archive_dir(project).ok_or("kein Archiv-Ordner gesetzt")?;
+  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());
+  }
+  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 = dir.join(format!("{stamp}-{}.md", slugify(&title)));
+  let doc = format!(
+    "---\ntitle: \"{}\"\nproject: {project}\ncreated: {iso}\nsource: ai-control\n---\n\n{}\n",
+    title.replace('"', "'"),
+    text.trim_end(),
+  );
+  fs::write(&path, doc).map_err(|e| format!("{}: {e}", path.display()))?;
+  Ok(path)
+}
+
+/// 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).
+fn slugify(s: &str) -> String {
+  let mut out = String::new();
+  for c in s.chars() {
+    if c.is_ascii_alphanumeric() {
+      out.push(c.to_ascii_lowercase());
+    } else if !out.ends_with('-') {
+      out.push('-');
+    }
+  }
+  let out: String = out.trim_matches('-').chars().take(60).collect();
+  if out.is_empty() {
+    "entwurf".into()
+  } else {
+    out
+  }
+}
+
+/// 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");
+  }
+
+  #[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");
+  }
+
+  #[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");
+  }
+}