Struct FileIssueStore 

pub struct FileIssueStore { /* private fields */ }

File-backed issue store.

One instance is shared (via Arc) between the TUI indicator, the agent issue tool, and the oxi issue CLI subcommand. All mutations go through FileIssueStore::create / FileIssueStore::update which serialize per-file content-hash CAS (cross-process / external edits).

Implementations

impl FileIssueStore

pub fn open(issues_dir: PathBuf) -> Result<Self>

Open (or create lazily) the issue store rooted at issues_dir.

pub fn open_from_cwd(start: &Path) -> Result<Self>

Open using project-root discovery from start (cwd).

pub fn issues_dir(&self) -> PathBuf

The issues directory.

pub fn open_count(&self) -> usize

Number of open issues, for the status-bar indicator. Refreshes the cache if the directory mtime changed. Cheap (O(1) when fresh).

pub fn latest_open_title(&self) -> Option<String>

Title of the most recently updated open issue, for the status-bar indicator. Cached alongside open_count, so this is also O(1) on a warm cache. Returns None if there are no open issues.

pub fn summary(&self) -> IssueSummary

Aggregate summary for the footer indicator / panels. Pulled from the in-memory cache, so it’s cheap (O(1) on a warm cache).

pub fn top_free_priority(&self) -> Option<Priority>

Highest priority among open, unassigned issues — the most actionable thing a free agent could pick up right now (#10). Distinct from a plain “top priority” (overall open max): this excludes issues someone is already working on. Returns None when no open issue is free. Cached alongside Self::open_count; O(1) on a warm cache.

pub fn has_any(&self) -> bool

True iff the issues directory has any issues at all (suppresses the indicator when the project has never used the feature).

pub fn invalidate(&self)

Invalidate the cache (force next read to rescan).

pub fn list(&self, filter: &IssueFilter) -> Result<Vec<Issue>>

List all issues, optionally filtered. Sorted by updated_at desc.

pub fn read(&self, id: u32) -> Result<(Issue, String)>

Read a single issue by id. Returns the issue and its current content hash (for optimistic-concurrency writes).

pub fn next_id(&self) -> Result<u32>

Allocate the next issue id by scanning existing filenames.

Cross-process allocation races are possible (two sessions create the next id simultaneously) but bounded: the loser’s create write hits an existing file and we bump to the next free id. No lock needed for correctness, only for avoiding rare retries.

pub fn create( &self, title: String, body: String, priority: Priority, labels: Vec<String>, caller_session: Option<&str>, ) -> Result<Issue>

Create a new issue. caller_session is linked into sessions.

pub async fn update<F>( &self, id: u32, expected_hash: Option<String>, mutator: F, ) -> Result<Issue, IssueError>

where F: FnOnce(Issue) -> Result<Issue, IssueError> + Send + 'static,

Update an issue with optimistic concurrency.

expected_hash should be the hash returned by FileIssueStore::read. If the on-disk content changed since, returns IssueError::Conflict. mutator receives the loaded issue and returns the new state.

All writes go through file_mutation_queue for in-process serialization, exactly like the edit tool.

pub async fn close( &self, id: u32, caller: &str, expected_hash: Option<String>, ) -> Result<Issue, IssueError>

Convenience: close an issue (assignee only).

pub async fn reopen( &self, id: u32, expected_hash: Option<String>, ) -> Result<Issue, IssueError>

Reopen a closed issue. No ownership required (reopening doesn’t assign the issue to anyone; it goes back to the unassigned pool).

Errors with NotFound if the id doesn’t exist, or with no special error if the issue is already open — that case is a no-op.

pub async fn start( &self, id: u32, caller: &str, expected_hash: Option<String>, ) -> Result<Issue, IssueError>

Try to claim an issue for caller (the start action).

If already assigned to a live session, returns IssueError::Assigned. If assigned to a dead session (process exited), reclaims and assigns to the caller. If free, assigns to the caller.

pub async fn release( &self, id: u32, caller: &str, expected_hash: Option<String>, ) -> Result<Issue, IssueError>

Release an assignment (the release action). Caller must be the owner.

pub async fn link_session( &self, id: u32, session: &str, expected_hash: Option<String>, ) -> Result<Issue, IssueError>

Link a session to an issue (append-only; idempotent).

pub async fn apply_patch( &self, id: u32, patch: IssuePatch, caller: Option<String>, expected_hash: Option<String>, ) -> Result<Issue, IssueError>

Apply a precise IssuePatch under strict CAS, preserving the existing ownership policy.

If caller is Some, a different non-empty assignee blocks the update with IssueError::NotAssigned — identical to the legacy update tool action. Setting status = Open also clears closed_at, fixing the latent reopen bug (#4: previously update { status: open } left a stale closed_at on a reopened issue). Prefer the dedicated FileIssueStore::reopen for clarity.

No-op patches (nothing meaningful changed) are detected inside FileIssueStore::update and skip the write entirely.

Trait Implementations

impl Clone for FileIssueStore

fn clone(&self) -> FileIssueStore

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FileIssueStore

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.