Struct Store 

pub struct Store {
    pub root: PathBuf,
    pub stealth: bool,
    pub no_git: bool,
    /* private fields */
}

Fields

root: PathBuf

stealth: bool

no_git: bool

True when no git repository is available. Implies stealth.

Implementations

impl Store

pub fn discover(from: &Path) -> Result<Self>

Discover the project root from a starting directory. In a worktree, returns the main repo root so that all writes go there.

pub fn init( from: &Path, stealth: bool, tasks_dir: Option<String>, ) -> Result<Self>

pub fn init_bare(source: &str, hubdir: &Path) -> Result<Self>

Bootstrap a bare central hub at hubdir from source and open a Store rooted there. The convenience wrapper over the by-hand README bootstrap; the heavy lifting (clone, scaffold, materialize config, state wiring) lives in store_init::bootstrap_bare_hub.

pub fn balls_dir(&self) -> PathBuf

pub fn tasks_dir(&self) -> PathBuf

pub fn state_worktree_dir(&self) -> PathBuf

Directory where git operations against task state should run. In non-stealth mode this is the state worktree (commits land on the balls/tasks orphan branch, never on main). In stealth mode the concept is meaningless — callers should branch on stealth before using this.

pub fn local_dir(&self) -> PathBuf

pub fn claims_dir(&self) -> PathBuf

pub fn lock_dir(&self) -> PathBuf

pub fn local_plugins_dir(&self) -> PathBuf

pub fn config_path(&self) -> PathBuf

pub fn load_config(&self) -> Result<Config>

pub fn worktrees_root(&self) -> Result<PathBuf>

pub fn task_path(&self, id: &str) -> Result<PathBuf>

pub fn task_exists(&self, id: &str) -> bool

pub fn load_task(&self, id: &str) -> Result<Task>

pub fn save_task(&self, task: &Task) -> Result<()>

Persist a task. Callers must ensure serialization (typically via the per-task lock helper in worktree.rs); this path relies on atomic tmp+rename for filesystem integrity.

pub fn commit_task(&self, id: &str, message: &str) -> Result<()>

Remove a task’s files from disk and (non-stealth) from the state branch’s index. Unified replacement for the previous delete_task_file + rm_task_git pair. Stage and commit a task file change on the state branch. No-op in stealth mode. Stages the sibling notes file too (always present after a Task::save). Holds the store-wide state-worktree lock for the duration of the git ops.

pub fn close_and_archive(&self, task: &Task, commit_msg: &str) -> Result<()>

Archive a task and commit the archive on the state branch in a single locked sequence. Replaces the old archive_task + commit_staged pair, which could interleave with another worker’s writes between the git rm and the git commit.

The caller has already mutated task (status=Closed, closed_at set, etc.) but must NOT have called save_task — this method handles parent-side bookkeeping and file removal atomically under the state-worktree lock.

pub fn all_tasks(&self) -> Result<Vec<Task>>