inkhaven 1.2.3

Inkhaven — TUI literary work editor for Typst books
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use std::path::Path;

use crate::config::Config;
use crate::error::{Error, Result};
use crate::project::ProjectLayout;
use crate::store::Store;
use crate::store::hierarchy::Hierarchy;
use crate::store::node::NodeKind;
use crate::store::InsertPosition;

pub fn run(
    project: &Path,
    kind: NodeKind,
    title: &str,
    parent_path: Option<&str>,
    slug_override: Option<&str>,
    after_path: Option<&str>,
) -> Result<()> {
    let layout = ProjectLayout::new(project);
    layout.require_initialized()?;

    let cfg = Config::load(&layout.config_path())?;
    let store = Store::open(layout.clone(), &cfg)?;
    let hierarchy = Hierarchy::load(&store)?;

    // --after takes precedence and implies the parent.
    let (parent, position) = if let Some(after) = after_path {
        let anchor = hierarchy
            .find_by_path(after)
            .ok_or_else(|| Error::Store(format!("--after anchor not found: `{after}`")))?;
        if anchor.kind != kind {
            return Err(Error::Store(format!(
                "--after expects a sibling of kind `{}`, got `{}`",
                kind.as_str(),
                anchor.kind.as_str()
            )));
        }
        let parent_node = anchor
            .parent_id
            .and_then(|pid| hierarchy.get(pid));
        (parent_node, InsertPosition::After(anchor.id))
    } else {
        let parent = match (kind, parent_path) {
            (NodeKind::Book, None) => None,
            (NodeKind::Book, Some(_)) => {
                return Err(Error::Store(
                    "books are root nodes; do not pass --parent".into(),
                ));
            }
            (_, None) => {
                return Err(Error::Store(format!(
                    "--parent is required when adding a {}",
                    kind.as_str()
                )));
            }
            (_, Some(path)) => Some(
                hierarchy
                    .find_by_path(path)
                    .ok_or_else(|| Error::Store(format!("parent not found: `{path}`")))?,
            ),
        };
        // User-added Books at root slot ABOVE the system block (Notes,
        // Research, Prompts, Places, Characters, Help) — same behaviour as
        // the TUI's Tree-pane `B` shortcut.
        let position = if kind == NodeKind::Book && parent.is_none() {
            match hierarchy.iter().find(|n| {
                n.kind == NodeKind::Book
                    && n.system_tag.as_deref() == Some(crate::store::SYSTEM_TAG_NOTES)
            }) {
                Some(notes) => InsertPosition::Before(notes.id),
                None => InsertPosition::End,
            }
        } else {
            InsertPosition::End
        };
        (parent, position)
    };

    let node = store.create_node(
        &cfg,
        &hierarchy,
        kind,
        title,
        parent,
        slug_override,
        position,
    )?;

    // Per-book artefacts directory + Typst skeleton. No-op for non-Book
    // kinds and for system books; safe to always invoke.
    store.provision_user_book(&cfg, &node)?;

    let display_path = {
        let mut parts: Vec<String> = node.path.clone();
        parts.push(node.slug.clone());
        parts.join("/")
    };

    let rel = if let Some(file) = &node.file {
        file.clone()
    } else {
        // Branch — reconstruct directory path
        let mut p = std::path::PathBuf::from(crate::project::BOOKS_DIR);
        for slug in &node.path {
            // Walk hierarchy to get fs_name with order prefix. The freshly
            // loaded snapshot above doesn't include the new node yet, but its
            // ancestors are all there.
            if let Some(ancestor) = hierarchy
                .iter()
                .find(|n| n.slug == *slug && n.kind != NodeKind::Paragraph)
            {
                p.push(ancestor.fs_name());
            } else {
                p.push(slug);
            }
        }
        p.push(node.fs_name());
        p.to_string_lossy().into_owned()
    };

    eprintln!(
        "Added {} `{}` at {}",
        kind.as_str(),
        node.title,
        display_path
    );
    eprintln!("  uuid: {}", node.id);
    eprintln!("  file: {}", rel);
    Ok(())
}