Trait Adapter 

pub trait Adapter:
    Send
    + Sync
    + Debug {
    // Required methods
    fn kind(&self) -> FormatKind;
    fn detect(&self, start: &Path) -> Option<PathBuf>;
    fn inspect(
        &self,
        start: &Path,
        feature: Option<&str>,
    ) -> Option<ProjectSnapshot>;
    fn parse_tasks(
        &self,
        path: &str,
        text: &str,
    ) -> (ParsedTasks, Vec<Diagnostic>);
    fn rules(&self) -> &'static Rules;
    fn wording(&self) -> &'static Wording;
    fn messages(&self) -> &'static Messages;
    fn planning(&self) -> &'static Planning;
    fn bundle(
        &self,
        snapshot: &ProjectSnapshot,
        task: &str,
    ) -> Result<Bundle, BundleError>;
    fn scenarios(
        &self,
        snapshot: &ProjectSnapshot,
        task: &str,
    ) -> Vec<ScenarioRef>;
    fn acceptance_testable(&self, bundle: &Bundle) -> bool;
    fn is_convergence(&self, phase: &str) -> bool;
    fn convergence_texts(&self, root: &Path, unit_dir: &Path) -> [String; 4];
    fn checklists(&self, root: &Path, unit_dir: &str) -> Vec<ChecklistStatus>;
    fn tick(
        &self,
        tasks_file: &Path,
        task: &str,
        line_hash: &str,
    ) -> Result<(), String>;
    fn append(
        &self,
        tasks_file: &Path,
        file_hash: &str,
        items: &[String],
    ) -> Result<Vec<String>, String>;
    fn commit_precondition(
        &self,
        root: &Path,
        join: &dyn Fn(&str) -> String,
        unit_dir: &str,
    ) -> CommitPrecondition;

    // Provided methods
    fn open(
        &self,
        start: &Path,
        feature: Option<&str>,
    ) -> Option<ProjectSnapshot> { ... }
    fn blocking<'s>(
        &self,
        _snapshot: &'s ProjectSnapshot,
    ) -> Vec<&'s Diagnostic> { ... }
    fn crosscheck(
        &self,
        _snapshot: &ProjectSnapshot,
        _runner: &dyn CommandRunner,
    ) -> Vec<Diagnostic> { ... }
    fn tool(&self) -> Option<(&'static str, &'static str)> { ... }
    fn requirements_file(&self) -> Option<&'static str> { ... }
    fn requirements_in(&self, _text: &str) -> Vec<(String, String)> { ... }
    fn record_change(
        &self,
        _root: &Path,
        _request: &str,
        _checks: &[String],
    ) -> Result<Recorded, String> { ... }
    fn extensions(&self, _root: &Path) -> Option<Inventory> { ... }
    fn bug_unit(&self, _root: &Path) -> Result<BugHome, BugRefusal> { ... }
    fn record_bug(
        &self,
        _root: &Path,
        _home: &BugHome,
        _triad: &Triad,
    ) -> Result<RecordedBug, BugRefusal> { ... }
    fn bug_step(&self) -> Option<BugStep> { ... }
    fn bug_dir(&self, _home: &BugHome, _slug: &str) -> Option<(String, String)> { ... }
    fn bug_slug(&self, _root: &Path, _home: &BugHome, _title: &str) -> String { ... }
    fn read_bug(
        &self,
        _root: &Path,
        _home: &BugHome,
        _key: &str,
    ) -> Result<ReadBug, BugRefusal> { ... }
    fn oracle_requirements(
        &self,
        _snapshot: &ProjectSnapshot,
    ) -> Vec<OracleRequirement> { ... }
    fn standing_units(&self, _root: &Path) -> Vec<(String, Rung)> { ... }
    fn requirement_ids(
        &self,
        root: &Path,
        unit_dir: &str,
    ) -> Vec<(String, String)> { ... }
    fn current_pointer(&self) -> Option<&'static str> { ... }
    fn set_current(
        &self,
        _root: &Path,
        _unit_dir: Option<&str>,
    ) -> Result<String, String> { ... }
}

One spec format the runtime can run.

Required Methods

fn kind(&self) -> FormatKind

Which format.

fn detect(&self, start: &Path) -> Option<PathBuf>

The project root containing start, by the format’s marker.

fn inspect( &self, start: &Path, feature: Option<&str>, ) -> Option<ProjectSnapshot>

Discovers the project containing start and selects feature. Read-only.

fn parse_tasks(&self, path: &str, text: &str) -> (ParsedTasks, Vec<Diagnostic>)

Parses a task list.

fn rules(&self) -> &'static Rules

Which paths are intent and what planning may write.

fn wording(&self) -> &'static Wording

What the model is told about the format.

fn messages(&self) -> &'static Messages

What a person is told.

fn planning(&self) -> &'static Planning

Hosted planning skills.

fn bundle( &self, snapshot: &ProjectSnapshot, task: &str, ) -> Result<Bundle, BundleError>

The context bundle for task of the selected unit.

fn scenarios(&self, snapshot: &ProjectSnapshot, task: &str) -> Vec<ScenarioRef>

The scenarios task’s acceptance tests cite, with the spec’s words (judge-side: the implementer sees the spec text, not this list).

fn acceptance_testable(&self, bundle: &Bundle) -> bool

Whether the bundle states acceptance examples to derive tests from.

fn is_convergence(&self, phase: &str) -> bool

Whether a task closes a gap found after implementation (its phase).

fn convergence_texts(&self, root: &Path, unit_dir: &Path) -> [String; 4]

What the convergence assessment reads, in order: the project’s rules, the spec, the plan, the task list (each may be empty).

fn checklists(&self, root: &Path, unit_dir: &str) -> Vec<ChecklistStatus>

The unit’s unfinished-checklist state.

fn tick( &self, tasks_file: &Path, task: &str, line_hash: &str, ) -> Result<(), String>

Ticks task (one byte, under the line-hash guard).

fn append( &self, tasks_file: &Path, file_hash: &str, items: &[String], ) -> Result<Vec<String>, String>

Appends convergence tasks (prefix-guarded); returns their IDs.

fn commit_precondition( &self, root: &Path, join: &dyn Fn(&str) -> String, unit_dir: &str, ) -> CommitPrecondition

What must be committed before a worktree is made; paths are repository-relative, join maps a project-relative path to one.

Provided Methods

fn open(&self, start: &Path, feature: Option<&str>) -> Option<ProjectSnapshot>

Adapter::inspect for a command a person ran: the format’s own selection settings (its environment variables) apply.

fn blocking<'s>(&self, _snapshot: &'s ProjectSnapshot) -> Vec<&'s Diagnostic>

Diagnostics that stop a run of the selected unit before any model call (the format’s preflight).

fn crosscheck( &self, _snapshot: &ProjectSnapshot, _runner: &dyn CommandRunner, ) -> Vec<Diagnostic>

The format’s own tools’ opinion of the selected unit, when they are installed (read-only commands through runner).

fn tool(&self) -> Option<(&'static str, &'static str)>

The format’s own command-line tool and how to install it, for doctor (None: the format has none).

fn requirements_file(&self) -> Option<&'static str>

The unit’s document that defines its requirements (spec.md in Spec Kit), relative to the unit’s directory; None when the format has no requirement identifiers.

fn requirements_in(&self, _text: &str) -> Vec<(String, String)>

The requirements text (the requirements file) defines, each with the line that defines it, in the document’s order.

fn record_change( &self, _root: &Path, _request: &str, _checks: &[String], ) -> Result<Recorded, String>

Records a quick change: request (with acceptance checks) becomes a story, a requirement and a task in the format’s standing unit for such changes. Err: the format has none.

fn extensions(&self, _root: &Path) -> Option<Inventory>

The format’s installed extensions, from its own inventory (None: the format has none, or none could be read). The only reader of the format’s extension files.

fn bug_unit(&self, _root: &Path) -> Result<BugHome, BugRefusal>

Where a bug lives: the format’s own bug structure when it has one, else its standing bug-fix unit. Err: neither (BUG-NO-UNIT).

Errors

The format has no place for a bug.

fn record_bug( &self, _root: &Path, _home: &BugHome, _triad: &Triad, ) -> Result<RecordedBug, BugRefusal>

Records triad as a story, an approved-to-be requirement and a task in the standing bug-fix unit home names (appends only, verified at write time).

Errors

The home is not a standing unit, or the files changed meanwhile.

fn bug_step(&self) -> Option<BugStep>

The format’s own bug step, for a native home.

fn bug_dir(&self, _home: &BugHome, _slug: &str) -> Option<(String, String)>

A native home’s directory for slug, project-relative, and its unit name.

fn bug_slug(&self, _root: &Path, _home: &BugHome, _title: &str) -> String

A new slug for title that no bug of home has yet.

fn read_bug( &self, _root: &Path, _home: &BugHome, _key: &str, ) -> Result<ReadBug, BugRefusal>

The triad as the home holds it: the bug key (a native home’s slug, a standing unit’s requirement). Pure: no model, no tool.

Errors

The file is missing or not in a shape the adapter reads.

fn oracle_requirements( &self, _snapshot: &ProjectSnapshot, ) -> Vec<OracleRequirement>

The selected unit’s requirements with their scenarios, in document order: what a review writes tests for. None when the format yields no requirement with scenarios.

fn standing_units(&self, _root: &Path) -> Vec<(String, Rung)>

The project’s standing units and their rungs (a quick change’s, a bug’s): what speccoder_core::ladder::rung_of decides by.

fn requirement_ids(&self, root: &Path, unit_dir: &str) -> Vec<(String, String)>

The unit’s requirement identifiers, each with the hash of the line that defines it (FR-001, SC-002 in Spec Kit): the rows of the trace matrix. None when the format has no such identifiers.

fn current_pointer(&self) -> Option<&'static str>

The format’s per-checkout pointer to the current unit (repository-relative), if it has one.

fn set_current( &self, _root: &Path, _unit_dir: Option<&str>, ) -> Result<String, String>

Records unit_dir (repository-relative) as the current unit in the format’s own per-checkout pointer, or clears it (None); returns the pointer’s path. Err: the format has no current unit.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl Adapter for OpenSpec

impl Adapter for SpecKit