Conversation
Reviewer's GuideImplements cycle detection in the IR transformation by adding a new CircularDependency error, invoking a DFS-based check in BuildGraph, and updating tests and documentation to cover the new behavior. Flow diagram for cycle detection in BuildGraphflowchart TD
A[Start BuildGraph::from_manifest]
B[process_targets]
C[process_defaults]
D[detect_cycles]
E{Cycle detected?}
F[Return CircularDependency error]
G[Return BuildGraph]
A --> B --> C --> D --> E
E -- Yes --> F
E -- No --> G
File-Level Changes
Tips and commandsInteracting with Sourcery
Customizing Your ExperienceAccess your dashboard to:
Getting Help
|
Summary by CodeRabbit
WalkthroughDocument the addition of cycle detection logic to the build graph IR generation. Update the error handling to include a new error variant for circular dependencies. Extend the documentation and roadmap to reflect this feature. Add targeted tests and test data to verify correct failure behaviour when circular dependencies are present. Changes
Sequence Diagram(s)sequenceDiagram
participant User
participant BuildGraph
participant IrGenError
User->>BuildGraph: from_manifest(manifest)
BuildGraph->>BuildGraph: process rules, targets, defaults
BuildGraph->>BuildGraph: detect_cycles()
alt No cycles
BuildGraph-->>User: Return BuildGraph
else Cycle detected
BuildGraph-->>IrGenError: CircularDependency(cycle)
IrGenError-->>User: Error with cycle path
end
Estimated code review effort🎯 3 (Moderate) | ⏱️ ~18 minutes Possibly related PRs
Suggested reviewers
Poem
📜 Recent review detailsConfiguration used: CodeRabbit UI 📒 Files selected for processing (3)
🧰 Additional context used📓 Path-based instructions (3)**/*.rs📄 CodeRabbit Inference Engine (AGENTS.md)
Files:
⚙️ CodeRabbit Configuration File
Files:
docs/**/*.md📄 CodeRabbit Inference Engine (AGENTS.md)
Files:
**/*.md📄 CodeRabbit Inference Engine (AGENTS.md)
Files:
⚙️ CodeRabbit Configuration File
Files:
🔇 Additional comments (11)
✨ Finishing Touches
🧪 Generate unit tests
🪧 TipsChatThere are 3 ways to chat with CodeRabbit:
SupportNeed help? Create a ticket on our support page for assistance with any issues or questions. Note: Be mindful of the bot's finite context window. It's strongly recommended to break down tasks such as reading entire modules into smaller chunks. For a focused discussion, use review comments to chat about specific files and their changes, instead of using the PR comments. CodeRabbit Commands (Invoked using PR comments)
Other keywords and placeholders
CodeRabbit Configuration File (
|
![codescene-delta-analysis[bot]](https://avatars.githubusercontent.com/in/53921?s=60&v=4){kind=small}
There was a problem hiding this comment.
Gates Failed
(1 file with Bumpy Road Ahead)
Gates Passed
See analysis details in CodeScene
Reason for failure
| Enforce critical code health rules | Violations | Code Health Impact | |
|---|---|---|---|
| ir.rs | 1 critical rule | 10.00 → 9.84 | Suppress |
Quality Gate Profile: Pay Down Tech Debt
Want more control? Customize Code Health rules or catch issues early with our IDE extension and CLI tool.
![sourcery-ai[bot]](https://avatars.githubusercontent.com/in/48477?s=60&v=4){kind=small}
There was a problem hiding this comment.
Hey @leynos - I've reviewed your changes and found some issues that need to be addressed.
- Enhance the CircularDependency error to include the full cycle of targets (not just the repeated node) for improved debugging.
- Refactor detect_cycles to match on graph.targets.get(dep) directly instead of separate contains_key and get() calls to simplify lookup logic.
Prompt for AI Agents
Please address the comments from this code review:
## Overall Comments
- Enhance the CircularDependency error to include the full cycle of targets (not just the repeated node) for improved debugging.
- Refactor detect_cycles to match on graph.targets.get(dep) directly instead of separate contains_key and get() calls to simplify lookup logic.
## Individual Comments
### Comment 1
<location> `src/ir.rs:193` </location>
<code_context>
+ }
+
+ states.insert(node, State::Visiting);
+ if let Some(edge) = graph.targets.get(node) {
+ for dep in edge.inputs.iter().chain(&edge.order_only_deps) {
+ if graph.targets.contains_key(dep) {
+ visit(graph, dep, states)?;
</code_context>
<issue_to_address>
Order-only dependencies are treated the same as regular inputs in cycle detection.
If order-only dependencies should not be part of cycle detection, filter them out before this logic.
</issue_to_address>
### Comment 2
<location> `src/ir.rs:174` </location>
<code_context>
}
}
+
+ fn detect_cycles(&self) -> Result<(), IrGenError> {
+ #[derive(Clone, Copy)]
+ enum State {
</code_context>
<issue_to_address>
Consider refactoring the cycle detection logic by extracting the DFS into a separate function or switching to Kahn’s algorithm for clarity and testability.
You can simplify `detect_cycles` and remove the ad-hoc DFS/state‐enum by either
1. pulling the nested helper + `State` enum out into its own (testable!) function, or
2. switching to a Kahn-style topological sort.
–––
### 1) Minimal refactor: extract the DFS into its own function
```rust
// at module‐scope (so you can unit–test it)
enum VisitState { Visiting, Visited }
fn find_cycle(
targets: &HashMap<PathBuf, Edge>
) -> Option<PathBuf> {
fn visit(
node: &PathBuf,
targets: &HashMap<PathBuf, Edge>,
states: &mut HashMap<&PathBuf, VisitState>,
) -> Option<PathBuf> {
match states.get(node) {
Some(VisitState::Visited) => return None,
Some(VisitState::Visiting) => return Some(node.clone()),
None => {},
}
states.insert(node, VisitState::Visiting);
if let Some(edge) = targets.get(node) {
for dep in edge.inputs.iter().chain(&edge.order_only_deps) {
if targets.contains_key(dep) {
if let Some(cycle_node) = visit(dep, targets, states) {
return Some(cycle_node);
}
}
}
}
states.insert(node, VisitState::Visited);
None
}
let mut states = HashMap::new();
for node in targets.keys() {
if !states.contains_key(node) {
if let Some(cycle_node) = visit(node, targets, &mut states) {
return Some(cycle_node);
}
}
}
None
}
impl BuildGraph {
fn detect_cycles(&self) -> Result<(), IrGenError> {
if let Some(path) = find_cycle(&self.targets) {
Err(IrGenError::CircularDependency { path })
} else {
Ok(())
}
}
}
```
–––
### 2) Alternative: Kahn’s Algorithm (no recursion or enum)
```rust
use std::collections::VecDeque;
impl BuildGraph {
fn detect_cycles(&self) -> Result<(), IrGenError> {
// 1) build indegree map
let mut indegree = HashMap::new();
for (node, edge) in &self.targets {
indegree.entry(node.clone()).or_insert(0);
for dep in edge.inputs.iter().chain(&edge.order_only_deps) {
if self.targets.contains_key(dep) {
*indegree.entry(dep.clone()).or_insert(0) += 1;
}
}
}
// 2) seed queue with zero‐indegree nodes
let mut queue: VecDeque<_> = indegree
.iter()
.filter_map(|(n, &d)| if d == 0 { Some(n.clone()) } else { None })
.collect();
// 3) process
let mut seen = 0;
while let Some(node) = queue.pop_front() {
seen += 1;
if let Some(edge) = self.targets.get(&node) {
for dep in edge.inputs.iter().chain(&edge.order_only_deps) {
if let Some(count) = indegree.get_mut(dep) {
*count -= 1;
if *count == 0 {
queue.push_back(dep.clone());
}
}
}
}
}
// 4) if not all nodes visited, there is a cycle
if seen != self.targets.len() {
// optionally: detect which node(s) remain in indegree>0 as the cycle ‘path’
Err(IrGenError::CircularDependency { path: PathBuf::new() })
} else {
Ok(())
}
}
}
```
Either approach removes the nested enum+function noise, flattens the logic, and makes testing much easier.
</issue_to_address>
### Comment 3
<location> `src/ir.rs:174` </location>
<code_context>
}
}
+
+ fn detect_cycles(&self) -> Result<(), IrGenError> {
+ #[derive(Clone, Copy)]
+ enum State {
</code_context>
<issue_to_address>
The module is missing a `//!` comment at the top as required by the review instructions.
Please add a `//!` module-level comment at the very top of this file to describe its purpose, as per the project guidelines.
</issue_to_address>Help me be more useful! Please click 👍 or 👎 on each comment and I'll use the feedback to improve your reviews.
There was a problem hiding this comment.
Gates Failed
(1 file with Bumpy Road Ahead)
(1 file with Complex Method)
Gates Passed
See analysis details in CodeScene
Reason for failure
| Enforce critical code health rules | Violations | Code Health Impact | |
|---|---|---|---|
| ir.rs | 1 critical rule | 10.00 → 9.54 | Suppress |
| Enforce advisory code health rules | Violations | Code Health Impact | |
|---|---|---|---|
| ir.rs | 1 advisory rule | 10.00 → 9.54 | Suppress |
Quality Gate Profile: Pay Down Tech Debt
Want more control? Customize Code Health rules or catch issues early with our IDE extension and CLI tool.
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
There was a problem hiding this comment.
Actionable comments posted: 2
♻️ Duplicate comments (1)
src/ir.rs (1)
283-338: Refactor to reduce complexity below thresholdThe cycle detection has cyclomatic complexity of 9 and nested conditionals, violating project standards. Extract the DFS logic into a separate module-level function or use Kahn's algorithm as suggested in previous reviews.
Example refactor extracting DFS:
-#[derive(Clone, Copy)] -enum VisitState { - Visiting, - Visited, -} - -fn find_cycle(targets: &HashMap<PathBuf, BuildEdge>) -> Option<Vec<PathBuf>> { - fn visit( - targets: &HashMap<PathBuf, BuildEdge>, - node: &PathBuf, - stack: &mut Vec<PathBuf>, - states: &mut HashMap<PathBuf, VisitState>, - ) -> Option<Vec<PathBuf>> { - match states.get(node) { - Some(VisitState::Visited) => return None, - Some(VisitState::Visiting) => { - if let Some(idx) = stack.iter().position(|n| n == node) { - let mut cycle = stack.get(idx..).expect("slice").to_vec(); - cycle.push(node.clone()); - return Some(cycle); - } - return Some(vec![node.clone()]); - } - None => {} - } - - states.insert(node.clone(), VisitState::Visiting); - stack.push(node.clone()); - - if let Some(edge) = targets.get(node) { - for dep in &edge.inputs { - if targets.get(dep).is_some() - && let Some(cycle) = visit(targets, dep, stack, states) - { - return Some(cycle); - } - } - } - - stack.pop(); - states.insert(node.clone(), VisitState::Visited); - None - } - - let mut states = HashMap::new(); - let mut stack = Vec::new(); - - for node in targets.keys() { - if !states.contains_key(node) - && let Some(cycle) = visit(targets, node, &mut stack, &mut states) - { - return Some(cycle); - } - } - None -} +// At module level for testability +#[derive(Clone, Copy)] +enum VisitState { + Visiting, + Visited, +} + +fn visit_node( + targets: &HashMap<PathBuf, BuildEdge>, + node: &PathBuf, + stack: &mut Vec<PathBuf>, + states: &mut HashMap<PathBuf, VisitState>, +) -> Option<Vec<PathBuf>> { + match states.get(node) { + Some(VisitState::Visited) => return None, + Some(VisitState::Visiting) => { + let idx = stack.iter().position(|n| n == node).unwrap_or(0); + let mut cycle = stack[idx..].to_vec(); + cycle.push(node.clone()); + return Some(cycle); + } + None => {} + } + + states.insert(node.clone(), VisitState::Visiting); + stack.push(node.clone()); + + if let Some(edge) = targets.get(node) { + for dep in &edge.inputs { + if targets.contains_key(dep) { + if let Some(cycle) = visit_node(targets, dep, stack, states) { + return Some(cycle); + } + } + } + } + + stack.pop(); + states.insert(node.clone(), VisitState::Visited); + None +} + +fn find_cycle(targets: &HashMap<PathBuf, BuildEdge>) -> Option<Vec<PathBuf>> { + let mut states = HashMap::new(); + let mut stack = Vec::new(); + + for node in targets.keys() { + if !states.contains_key(node) { + if let Some(cycle) = visit_node(targets, node, &mut stack, &mut states) { + return Some(cycle); + } + } + } + None +}
📜 Review details
Configuration used: CodeRabbit UI
Review profile: ASSERTIVE
Plan: Pro
📒 Files selected for processing (3)
docs/netsuke-design.md(2 hunks)src/ir.rs(4 hunks)tests/ir_from_manifest_tests.rs(4 hunks)
🧰 Additional context used
📓 Path-based instructions (3)
**/*.rs
📄 CodeRabbit Inference Engine (AGENTS.md)
**/*.rs: Clippy warnings MUST be disallowed.
Fix any warnings emitted during tests in the code itself rather than silencing them.
Where a function is too long, extract meaningfully named helper functions adhering to separation of concerns and CQRS.
Where a function has too many parameters, group related parameters in meaningfully named structs.
Where a function is returning a large error consider usingArcto reduce the amount of data returned.
Write unit and behavioural tests for new functionality. Run both before and after making any change.
Every module must begin with a module level (//!) comment explaining the module's purpose and utility.
Document public APIs using Rustdoc comments (///) so documentation can be generated with cargo doc.
Prefer immutable data and avoid unnecessarymutbindings.
Handle errors with theResulttype instead of panicking where feasible.
Avoidunsafecode unless absolutely necessary and document any usage clearly.
Place function attributes after doc comments.
Do not usereturnin single-line functions.
Use predicate functions for conditional criteria with more than two branches.
Lints must not be silenced except as a last resort.
Lint rule suppressions must be tightly scoped and include a clear reason.
Preferexpectoverallow.
Prefer.expect()over.unwrap().
Useconcat!()to combine long string literals rather than escaping newlines with a backslash.
Prefer semantic error enums: Derivestd::error::Error(via thethiserrorcrate) for any condition the caller might inspect, retry, or map to an HTTP status.
Use an opaque error only at the app boundary: Useeyre::Reportfor human-readable logs; these should not be exposed in public APIs.
Never export the opaque type from a library: Convert to domain enums at API boundaries, and toeyreonly in the mainmain()entrypoint or top-level async task.
Files:
tests/ir_from_manifest_tests.rssrc/ir.rs
⚙️ CodeRabbit Configuration File
**/*.rs: * Seek to keep the cyclomatic complexity of functions no more than 12.
Adhere to single responsibility and CQRS
Place function attributes after doc comments.
Do not use
returnin single-line functions.Move conditionals with >2 branches into a predicate function.
Avoid
unsafeunless absolutely necessary.Every module must begin with a
//!doc comment that explains the module's purpose and utility.Comments and docs must follow en-GB-oxendict (-ize / -our) spelling and grammar
Lints must not be silenced except as a last resort.
#[allow]is forbidden.- Only narrowly scoped
#[expect(lint, reason = "...")]is allowed.- No lint groups, no blanket or file-wide suppression.
- Include
FIXME:with link if a fix is expected.Use
rstestfixtures for shared setup and to avoid repetition between tests.Replace duplicated tests with
#[rstest(...)]parameterised cases.Prefer
mockallfor mocks/stubs.Prefer
.expect()over.unwrap()Ensure that any API or behavioural changes are reflected in the documentation in
docs/Ensure that any completed roadmap steps are recorded in the appropriate roadmap in
docs/Files must not exceed 400 lines in length
- Large modules must be decomposed
- Long match statements or dispatch tables should be decomposed by domain and collocated with targets
- Large blocks of inline data (e.g., test fixtures, constants or templates) must be moved to external files and inlined at compile-time or loaded at run-time.
Files:
tests/ir_from_manifest_tests.rssrc/ir.rs
docs/**/*.md
📄 CodeRabbit Inference Engine (AGENTS.md)
docs/**/*.md: Use the markdown files within thedocs/directory as a knowledge base and source of truth for project requirements, dependency choices, and architectural decisions.
Proactively update the relevant file(s) in thedocs/directory to reflect the latest state when new decisions are made, requirements change, libraries are added/removed, or architectural patterns evolve.
Files:
docs/netsuke-design.md
**/*.md
📄 CodeRabbit Inference Engine (AGENTS.md)
**/*.md: Documentation must use en-GB-oxendict spelling and grammar, except for the naming of the "LICENSE" file.
Validate Markdown files usingmake markdownlint.
Runmake fmtafter any documentation changes to format all Markdown files and fix table markup.
Validate Mermaid diagrams in Markdown files by runningmake nixie.
Markdown paragraphs and bullet points must be wrapped at 80 columns.
Code blocks in Markdown must be wrapped at 120 columns.
Tables and headings in Markdown must not be wrapped.
Use dashes (-) for list bullets in Markdown.
Use GitHub-flavoured Markdown footnotes ([^1]) for references and footnotes.
Files:
docs/netsuke-design.md
⚙️ CodeRabbit Configuration File
**/*.md: * Avoid 2nd person or 1st person pronouns ("I", "you", "we")
- Use en-GB-oxendict (-ize / -our) spelling and grammar
- Paragraphs and bullets must be wrapped to 80 columns, except where a long URL would prevent this (in which case, silence MD013 for that line)
- Code blocks should be wrapped to 120 columns.
- Headings must not be wrapped.
- Documents must start with a level 1 heading
- Headings must correctly increase or decrease by no more than one level at a time
- Use GitHub-flavoured Markdown style for footnotes and endnotes.
- Numbered footnotes must be numbered by order of appearance in the document.
Files:
docs/netsuke-design.md
🪛 GitHub Actions: CI
tests/ir_from_manifest_tests.rs
[error] 101-101: Test failure: assertion left == right failed in manifest_error_cases::case_6. Expected ["a", "b", "a"], got ["b", "a", "b"]
src/ir.rs
[error] 369-369: Test failure: assertion left == right failed in ir::tests::find_cycle_identifies_cycle. Expected ["a", "b", "a"], got ["b", "a", "b"]
🔇 Additional comments (6)
src/ir.rs (2)
97-98: Good improvement to error reporting!Including the full cycle path in the error variant provides better debugging information than a single node.
174-179: Clean delegation patternThe method correctly delegates to
find_cycleand converts the result appropriately.tests/ir_from_manifest_tests.rs (2)
42-42: Correct addition of test variantThe new variant properly extends the test enum to handle circular dependency errors.
69-72: Test case properly covers circular dependency scenarioThe test correctly exercises the circular dependency detection with the circular.yml fixture.
docs/netsuke-design.md (2)
992-996: Clear and accurate documentation of cycle detectionThe documentation properly describes the algorithm, design decisions, and error reporting improvements.
1208-1209: Documentation correctly updated for new error variantThe error variant documentation accurately reflects the change from single path to cycle vector.
There was a problem hiding this comment.
Actionable comments posted: 2
♻️ Duplicate comments (1)
src/ir.rs (1)
386-391: Fix test to handle non-deterministic HashMap iterationThe cycle detection order depends on HashMap iteration, which is non-deterministic. Even with canonicalization, verify that the cycle is valid rather than expecting exact order.
📜 Review details
Configuration used: CodeRabbit UI
Review profile: ASSERTIVE
Plan: Pro
📒 Files selected for processing (2)
docs/netsuke-design.md(2 hunks)src/ir.rs(4 hunks)
🧰 Additional context used
📓 Path-based instructions (3)
docs/**/*.md
📄 CodeRabbit Inference Engine (AGENTS.md)
docs/**/*.md: Use the markdown files within thedocs/directory as a knowledge base and source of truth for project requirements, dependency choices, and architectural decisions.
Proactively update the relevant file(s) in thedocs/directory to reflect the latest state when new decisions are made, requirements change, libraries are added/removed, or architectural patterns evolve.
Files:
docs/netsuke-design.md
**/*.md
📄 CodeRabbit Inference Engine (AGENTS.md)
**/*.md: Documentation must use en-GB-oxendict spelling and grammar, except for the naming of the "LICENSE" file.
Validate Markdown files usingmake markdownlint.
Runmake fmtafter any documentation changes to format all Markdown files and fix table markup.
Validate Mermaid diagrams in Markdown files by runningmake nixie.
Markdown paragraphs and bullet points must be wrapped at 80 columns.
Code blocks in Markdown must be wrapped at 120 columns.
Tables and headings in Markdown must not be wrapped.
Use dashes (-) for list bullets in Markdown.
Use GitHub-flavoured Markdown footnotes ([^1]) for references and footnotes.
Files:
docs/netsuke-design.md
⚙️ CodeRabbit Configuration File
**/*.md: * Avoid 2nd person or 1st person pronouns ("I", "you", "we")
- Use en-GB-oxendict (-ize / -our) spelling and grammar
- Paragraphs and bullets must be wrapped to 80 columns, except where a long URL would prevent this (in which case, silence MD013 for that line)
- Code blocks should be wrapped to 120 columns.
- Headings must not be wrapped.
- Documents must start with a level 1 heading
- Headings must correctly increase or decrease by no more than one level at a time
- Use GitHub-flavoured Markdown style for footnotes and endnotes.
- Numbered footnotes must be numbered by order of appearance in the document.
Files:
docs/netsuke-design.md
**/*.rs
📄 CodeRabbit Inference Engine (AGENTS.md)
**/*.rs: Clippy warnings MUST be disallowed.
Fix any warnings emitted during tests in the code itself rather than silencing them.
Where a function is too long, extract meaningfully named helper functions adhering to separation of concerns and CQRS.
Where a function has too many parameters, group related parameters in meaningfully named structs.
Where a function is returning a large error consider usingArcto reduce the amount of data returned.
Write unit and behavioural tests for new functionality. Run both before and after making any change.
Every module must begin with a module level (//!) comment explaining the module's purpose and utility.
Document public APIs using Rustdoc comments (///) so documentation can be generated with cargo doc.
Prefer immutable data and avoid unnecessarymutbindings.
Handle errors with theResulttype instead of panicking where feasible.
Avoidunsafecode unless absolutely necessary and document any usage clearly.
Place function attributes after doc comments.
Do not usereturnin single-line functions.
Use predicate functions for conditional criteria with more than two branches.
Lints must not be silenced except as a last resort.
Lint rule suppressions must be tightly scoped and include a clear reason.
Preferexpectoverallow.
Prefer.expect()over.unwrap().
Useconcat!()to combine long string literals rather than escaping newlines with a backslash.
Prefer semantic error enums: Derivestd::error::Error(via thethiserrorcrate) for any condition the caller might inspect, retry, or map to an HTTP status.
Use an opaque error only at the app boundary: Useeyre::Reportfor human-readable logs; these should not be exposed in public APIs.
Never export the opaque type from a library: Convert to domain enums at API boundaries, and toeyreonly in the mainmain()entrypoint or top-level async task.
Files:
src/ir.rs
⚙️ CodeRabbit Configuration File
**/*.rs: * Seek to keep the cyclomatic complexity of functions no more than 12.
Adhere to single responsibility and CQRS
Place function attributes after doc comments.
Do not use
returnin single-line functions.Move conditionals with >2 branches into a predicate function.
Avoid
unsafeunless absolutely necessary.Every module must begin with a
//!doc comment that explains the module's purpose and utility.Comments and docs must follow en-GB-oxendict (-ize / -our) spelling and grammar
Lints must not be silenced except as a last resort.
#[allow]is forbidden.- Only narrowly scoped
#[expect(lint, reason = "...")]is allowed.- No lint groups, no blanket or file-wide suppression.
- Include
FIXME:with link if a fix is expected.Use
rstestfixtures for shared setup and to avoid repetition between tests.Replace duplicated tests with
#[rstest(...)]parameterised cases.Prefer
mockallfor mocks/stubs.Prefer
.expect()over.unwrap()Ensure that any API or behavioural changes are reflected in the documentation in
docs/Ensure that any completed roadmap steps are recorded in the appropriate roadmap in
docs/Files must not exceed 400 lines in length
- Large modules must be decomposed
- Long match statements or dispatch tables should be decomposed by domain and collocated with targets
- Large blocks of inline data (e.g., test fixtures, constants or templates) must be moved to external files and inlined at compile-time or loaded at run-time.
Files:
src/ir.rs
🔇 Additional comments (5)
src/ir.rs (4)
96-99: LGTM!The new
CircularDependencyerror variant follows the established pattern and provides clear information about the detected cycle.
116-117: LGTM!Cycle detection is correctly placed after graph construction and uses proper error propagation.
173-180: LGTM!Clean implementation that delegates to
find_cycleand properly converts the result to an error.
340-356: LGTM!The canonicalization logic correctly ensures deterministic cycle representation by rotating to start with the lexicographically smallest node.
docs/netsuke-design.md (1)
1210-1211: LGTM!The error variant documentation correctly reflects the implementation change from a single path to a vector of paths representing the full cycle.
1 participant
Summary
CircularDependencyerror fromBuildGraphTesting
make fmtmake lintmake testmake markdownlintmake nixie(fails: too many arguments. Expected 0 arguments but got 1.)https://chatgpt.com/codex/tasks/task_e_6886b9ebfba883228941ef3e1d7eca79
Summary by Sourcery
Implement cycle detection in the IR build graph and fail manifest transformation on circular dependencies
New Features:
Documentation:
Tests: