Struct SpecKit 

pub struct SpecKit;

The Spec Kit adapter.

Trait Implementations

impl Adapter for SpecKit

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

Each user story with its scenarios, keyed USn, citing USn-k.

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

NNN-quick-changes and NNN-bugfixes.

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

A Convergence phase, appended by converge.

fn plan_structure(&self, snapshot: &ProjectSnapshot) -> Option<PlanStructure>

The selected unit’s phases and stories, for the plan checks that need them (None: the format has no such structure).

fn init_steps(&self, choices: &FormatInit) -> Vec<InitStep>

The commands of the format’s own init that make a folder a project of it (spec 101’s New Project); empty: speccoder cannot initialise this format, the person does (Messages::make_project).

fn prepare_init(&self, choices: &FormatInit) -> Result<(), String>

Writes what Adapter::init_steps names in speccoder’s state before they run (Spec Kit: the bundled preset, extracted).

fn doctor_checks( &self, root: &Path, env: &dyn Fn(&str) -> Option<String>, ) -> Vec<DoctorCheck>

The format’s own checks of what its tool needs on this machine, as doctor rows, given the person’s environment env.

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 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 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 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 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.

fn bundle( &self, snapshot: &ProjectSnapshot, task_id: &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 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 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 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).

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).

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.

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 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.

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 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.

impl Debug for SpecKit

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

Formats the value using the given formatter.

impl Detect for SpecKit

fn kind(&self) -> FormatKind

Which format.

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

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

fn adapter(&self) -> Option<&'static dyn Adapter>

The adapter, when this build runs the format.