You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Introduces @sverka/constructs for authoring Projects/Pipelines/Steps and rebuilds @sverka/core to synthesize a provider‑neutral Definition Graph with stricter validation and a temporary compat layer. Behavior change: empty artifact output paths now throw ConstructError(INVALID_OUTPUT) on construct creation and SynthesisError(INVALID_OUTPUT) on synthesis; duplicate construct ids throw ConstructError(DUPLICATE_ID); importArtifact.from must be fully‑qualified; unknown dependsOn targets and unexpected construct types are rejected.
Validates cycles, unknown producers (including dependsOn), output collisions (includes importArtifact; duplicate imports deduped), incompatible references, invalid scope, and unexpected construct types; resolves producer ids via a shared resolver.
Adds Definition Graph types and synthesize(project); introduces OutputDefinition/PipelineOutputDefinition (preserves output name and producer stepId) and a discriminated‐union Dependency.
Validates artifact outputs before construct registration and keeps a defense‑in‑depth check during synthesis; extracts step synthesis into focused helpers. Restores old core composables/types/ID functions as a compat export to unblock downstream packages.
Migration
Author with @sverka/constructs (Project, Pipeline, ShellStep, Entry) and call synthesize(project) from @sverka/core; the old core API remains available temporarily.
Set a non‑empty path for each artifact output and verify dependsOn targets exist.
Use fully‑qualified importArtifact.from and avoid duplicate imports; update consumers to new core types where referenced (Dependency union; OutputDefinition/PipelineOutputDefinition).
Written for commit c956507. Summary will update on new commits.
CodeAnt-AI Description
Introduce construct-based pipeline authoring and Definition Graph synthesis
What Changed
Added @sverka/constructs with Projects, Pipelines, shell Steps, Entries, triggers, inputs, outputs, runtimes, and typed references
Replaced the previous operation-composition API with a construct tree that can be synthesized into a provider-neutral Definition Graph
Synthesis creates shell, import, and export operations and infers control, value, and artifact dependencies
Invalid nesting, duplicate IDs, missing artifact paths, dependency cycles, unknown producers, output collisions, and incompatible references now produce clear errors
Added coverage for construct authoring, graph generation, dependency inference, validation, and deterministic synthesis
Impact
✅ Typed pipeline and trigger authoring ✅ Explicit artifact and value transfer between steps ✅ Clearer invalid pipeline errors
💡 Usage Guide
Checking Your Pull Request
Every time you make a pull request, our system automatically looks through it. We check for security issues, mistakes in how you're setting up your infrastructure, and common code problems. We do this to make sure your changes are solid and won't cause any trouble later.
Talking to CodeAnt AI
Got a question or need a hand with something in your pull request? You can easily get in touch with CodeAnt AI right here. Just type the following in a comment on your pull request, and replace "Your question here" with whatever you want to ask:
@codeant-ai ask: Your question here
This lets you have a chat with CodeAnt AI about your pull request, making it easier to understand and improve your code.
Example
@codeant-ai ask: Can you suggest a safer alternative to storing this secret?
Preserve Org Learnings with CodeAnt
You can record team preferences so CodeAnt AI applies them in future reviews. Reply directly to the specific CodeAnt AI suggestion (in the same thread) and replace "Your feedback here" with your input:
@codeant-ai: Your feedback here
This helps CodeAnt AI learn and adapt to your team's coding style and standards.
Example
@codeant-ai: Do not flag unused imports.
Retrigger review
Ask CodeAnt AI to review the PR again, by typing:
@codeant-ai: review
Check Your Repository Health
To analyze the health of your code repository, visit our dashboard at https://app.codeant.ai. This tool helps you identify potential issues and areas for improvement in your codebase, ensuring your repository maintains high standards of code health.
Running ultrareview automatically — This PR rebuilds core around a new Definition Graph and introduces a foundational constructs package — a cross-cutting refactor where subtle synthesis, validation, or graph-construction bugs could break every downstream pipeline.. I'll post findings when complete.
I can't run this ultrareview because you've reached your trial's review limit. Trial plans have lower review limits than paid plans. Upgrade now to resume reviews.
To help optimise your usage, you can tune cubic to get the most out of your usage limits:
Added workflow constructs for projects, pipelines, steps, shell commands, entries, triggers, inputs, outputs, references, and runtimes.
Added synthesis that converts workflows into validated, deterministic definition graphs.
Added clear error categories for invalid scopes, duplicate IDs, invalid outputs, cycles, unknown producers, output collisions, and incompatible references.
Documentation
Added architecture decisions, specifications, and an implementation plan for the new workflow model and definition graph.
Tests
Added coverage for construct behavior, graph generation, synthesis, validation, dependencies, and deterministic output.
Walkthrough
This change adds @sverka/constructs, rebuilds @sverka/core around Definition Graphs and synthesis, adds validation and tests, updates package configuration, and defines the architecture and specifications for Wave A.
Changes
Wave A foundation
Layer / File(s)
Summary
Contracts and package boundaries engdocs/adr/*, engdocs/architecture/*, specs/*
Defines package ownership, public contracts, synthesis rules, validation codes, dependency behavior, and implementation gates.
Construct tree and authoring models packages/constructs/*
Adds construct classes, trigger and reference models, runtime/input/output types, construct errors, package exports, build configuration, and tests.
Adds graph types and synthesis errors, exports the new core API, wires the constructs dependency, and tests graph variants.
Graph synthesis and validation packages/core/src/synthesize.ts, packages/core/src/validate.ts, packages/core/src/__tests__/synthesize.test.ts, packages/core/src/__tests__/validate.test.ts
Converts construct trees into deterministic graphs, emits operations, infers and deduplicates dependencies, and validates cycles, producers, outputs, and reference types.
This PR introduces construct-based authoring and graph synthesis, but the current head can still omit authored steps or generate dangling and invalid dependencies, and the configured quality gate is failing. Those issues can produce incomplete or invalid pipeline definitions, so the PR is not ready to merge until the correctness findings and quality-gate failures are fixed.
Sequence Diagram(s)
sequenceDiagram
participant Project
participant synthesize
participant validate
participant DefinitionGraph
Project->>synthesize: Provide construct tree
synthesize->>DefinitionGraph: Build operations and dependencies
synthesize->>validate: Validate references and cycles
validate-->>synthesize: Return validation result
synthesize-->>Project: Return DefinitionGraph
Loading
Possibly related PRs
sverka-dev/sverka#1: Replaces the legacy core operation and composable workflow model.
sverka-dev/sverka#37: Defines the constructs, Definition Graph, and synthesis contracts implemented here.
sverka-dev/sverka#40: Builds the SDK on the constructs and core APIs introduced here.
🚥 Pre-merge checks | ✅ 4 | ❌ 1
❌ Failed checks (1 warning)
Check name
Status
Explanation
Resolution
Docstring Coverage
⚠️ Warning
Docstring coverage is 35.00% which is insufficient. The required threshold is 80.00%.
Write docstrings for the functions missing them to satisfy the coverage threshold.
✅ Passed checks (4 passed)
Check name
Status
Explanation
Linked Issues check
✅ Passed
Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check
✅ Passed
Check skipped because no linked issues were found for this pull request.
Description check
✅ Passed
The description clearly summarizes the constructs package, Definition Graph rebuild, synthesis behavior, validation, specifications, and tests.
Title check
✅ Passed
The title concisely identifies the main changes: v0 Wave A, constructs, and the Definition Graph.
✨ Finishing Touches 💡 1📝 Generate docstrings 💡
Create stacked PR
Commit on current branch
🧪 Generate unit tests (beta)
Create PR with unit tests
Commit unit tests in branch v0-a-constructs
Comment @coderabbitai help to get the list of available commands.
The reason will be displayed to describe this comment to others. Learn more.
This PR introduces a solid foundation for the v0 Wave A constructs and definition graph implementation. The code is well-structured with comprehensive test coverage (48 tests passing). However, I've identified 2 critical issues that must be fixed before merge:
Dead code in validate.ts - Lines 78-84 contain an unused loop and Set that serves no purpose
Incorrect fallback logic in synthesize.ts - Using empty string as fallback for missing artifact paths will create invalid exports that bypass earlier validation
Both issues have specific fixes provided. Once these are addressed, the PR will be ready to merge.
You can now have the agent implement changes and create commits directly on your pull request's source branch. Simply comment with /q followed by your request in natural language to ask the agent to make changes.
⚠️ This PR contains more than 30 files. Amazon Q is better at reviewing smaller PRs, and may miss issues in larger changesets.
• Add @sverka/constructs for construct-tree authoring and shared typed model.
• Rebuild @sverka/core around Definition Graph types plus synthesize() lifecycle.
• Add validation, tests, and specs/ADR documenting boundaries and behavior.
The following are alternative approaches to this PR:
1. Single package: merge constructs + core
➕ Fewer packages to version/publish
➕ Simpler imports for consumers
➖ Weakens the construct-tree vs derived-graph boundary
➖ Harder to enforce layering as future waves add IR/planning/providers
2. Three packages: extract shared types into @sverka/model
➕ Very explicit layering for shared model types
➕ Keeps constructs focused on tree identity/ownership
➖ Adds extra package overhead for a small shared surface
➖ Types are authored alongside constructs, so separation is somewhat artificial
3. Put shared model types in core (constructs depends on core)
➕ One top-level place for types and synthesis
➖ Inverts desired dependency direction (core should sit above constructs)
➖ Higher risk of circular deps as core grows
Recommendation: The PR’s chosen split (authoring constructs + shared model in @sverka/constructs, derived Definition Graph + synthesize() in @sverka/core) best matches the v0 architecture and keeps dependency direction clean. Alternatives were considered but rejected due to boundary erosion or extra package complexity.
Files changed (27) +2336 / -87
Enhancement (8) +717 / -0
base.tsIntroduce SverkaConstruct insulation base class+6/-0
Introduce SverkaConstruct insulation base class
• Adds 'SverkaConstruct extends Construct' as an insulation layer for future Sverka-specific behavior. Used as the base for all construct classes in this package.
• Implements the authoring construct classes with strict parent-scope validation and duplicate-id wrapping into 'ConstructError'. Adds step metadata (runtime, inputs/outputs, dependsOn, timeout) and validates artifact outputs require a path.
index.tsDefine @sverka/constructs public exports+19/-0
Define @sverka/constructs public exports
• Exports construct classes, shared model types, trigger factories, and 'ConstructError'. Establishes the package as the shared authoring/type layer consumed by core.
model.tsAdd shared model types (Trigger/Reference/Input/Output/Runtime)+107/-0
Add shared model types (Trigger/Reference/Input/Output/Runtime)
• Defines Trigger variants and factories, typed References (step/context), and runtime/input/output type models. These types are shared between construct authoring and core’s Definition Graph.
graph.tsIntroduce Definition Graph types in core+67/-0
Introduce Definition Graph types in core
• Defines the provider-neutral Definition Graph (Project/Pipeline/Entry/Step) plus OperationDefinition and Dependency variants. Reuses shared model types from '@sverka/constructs'.
• Traverses Project/Pipeline/Step/Entry constructs to build graph definitions and normalize operations (shell/export/import). Infers and deduplicates dependencies from inputs and dependsOn, then runs validation before returning the graph.
validate.tsAdd validation for cycles, references, and type compatibility+162/-0
Add validation for cycles, references, and type compatibility
• Implements DFS-based cycle detection and checks for unknown producers and incompatible StepRef types/outputs. Throws 'SynthesisError' with structured codes on the first failure.
errors.tsReplace legacy core errors with SynthesisError+25/-24
Replace legacy core errors with SynthesisError
• Removes the old 'CoreError' hierarchy and introduces 'SynthesisError' and typed error codes used by synthesis validation. Adds optional 'stepId' and 'cause' fields for diagnostics.
index.tsRebuild core public API around graph + synthesis+13/-28
Rebuild core public API around graph + synthesis
• Removes previous exports (composables/runtime/operations) and replaces them with Definition Graph type exports, 'synthesize()', and 'SynthesisError'. Establishes the Wave A public API surface for core.
graph.test.tsAdd Definition Graph type conformance tests+154/-0
Add Definition Graph type conformance tests
• Tests the structural shape of the Definition Graph and variants for operations and dependencies. Verifies optional step fields and pipeline inputs/outputs handling.
synthesize.test.tsAdd synthesis tests for normalization and dependency inference+262/-0
Add synthesis tests for normalization and dependency inference
• Covers synthesis of empty and populated pipelines, operation normalization, dependency inference (value/artifact/control), and deduplication rules. Includes a determinism test to ensure stable graph output for identical trees.
• Documents that '@sverka/constructs' owns authoring constructs and shared model types, while '@sverka/core' owns Definition Graph + synthesis/validation. Records dependency direction and rejected alternatives.
v0-wave-A-plan.mdWave A implementation plan (TDD steps + file layout)+241/-0
Wave A implementation plan (TDD steps + file layout)
• Adds a step-by-step plan for Wave A, including package scaffolding, file layout, and verification checkpoints. Serves as the execution checklist for constructs + Definition Graph delivery.
• Promotes the spec from stub to active and documents the constructs authoring API, shared model types, and error semantics. Clarifies separation from the Definition Graph and core layering.
• Promotes the spec from stub to active, defining Definition Graph interfaces, operations/dependencies, and ID conventions. States that validation is handled by synthesis (spec 05).
spec.mdFill Spec 05: synthesis lifecycle and validation rules+118/-11
Fill Spec 05: synthesis lifecycle and validation rules
• Promotes the spec from stub to active, describing the Wave A synthesis lifecycle, normalization rules, dependency inference, and validation error codes. Documents determinism expectations and a test plan aligned to the new suite.
package.jsonScaffold new @sverka/constructs package+29/-0
Scaffold new @sverka/constructs package
• Introduces a new ESM package with build/test/lint/typecheck scripts and export mapping. Adds runtime dependency on 'constructs@10.8.1' plus dev tooling.
project.jsonAdd NX targets for constructs package+33/-0
Add NX targets for constructs package
• Registers NX build/test/lint/typecheck targets for 'packages/constructs' using bun-run commands. Enables monorepo task execution for the new package.
package.jsonAdd dependency on @sverka/constructs+3/-0
Add dependency on @sverka/constructs
• Adds '@sverka/constructs' as a workspace dependency, reflecting the new layering (core consumes constructs). Keeps existing dev tooling setup for core.
The reason will be displayed to describe this comment to others. Learn more.
Pull Request Overview
The PR introduces a construct-based authoring model and synthesis layer, but currently fails to meet quality standards due to high complexity in core logic and logical gaps in collision detection. Specifically, the validateOutputCollisions logic misses importArtifact operations and contains dead code.
Several acceptance criteria are met, including dependency inference and cycle detection; however, the OUTPUT_COLLISION validation is effectively unreachable or incomplete. High-risk files include packages/core/src/validate.ts and packages/core/src/synthesize.ts due to high cyclomatic complexity and long methods that combine multiple responsibilities. These should be refactored to ensure maintainability.
About this PR
The validation path for 'OUTPUT_COLLISION' is currently unreachable through standard Step authoring because construct IDs and Props use Map/Record structures that enforce uniqueness at the language level. Additionally, PipelineDefinition.outputs aggregates Step outputs into a flat array without associated names, which may complicate mapping for providers.
Test suggestions
Verify Project, Pipeline, and Step nesting constraints (INVALID_SCOPE)
Detect duplicate construct IDs (DUPLICATE_ID)
Validate artifact outputs require a 'path' (INVALID_OUTPUT)
Infer artifact and value dependencies from StepRefs during synthesis
Infer control dependencies from dependsOn
Ensure specific dependencies (value/artifact) override control dependencies for the same producer
Detect dependency cycles (CYCLE)
Detect references to unknown producers (UNKNOWN_PRODUCER)
Detect type mismatches in StepRefs vs producer output (INCOMPATIBLE_REFERENCE)
Detect duplicate output names in a single step (OUTPUT_COLLISION)
Prompt proposal for missing tests
Consider implementing these tests if applicable:
1. Detect duplicate output names in a single step (OUTPUT_COLLISION)
The reason will be displayed to describe this comment to others. Learn more.
Actionable comments posted: 17
🤖 Prompt for all review comments with AI agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
Inline comments:
In `@engdocs/adr/ADR-010-construct-core-boundary.md`:
- Line 4: Align the active-document dates with the review date: update
2026-08-13 in engdocs/adr/ADR-010-construct-core-boundary.md at line 4, and
update 2026-08-13 or mark the plan as future-dated in
engdocs/architecture/v0-wave-A-plan.md at line 5.
In `@engdocs/architecture/v0-wave-A-plan.md`:
- Around line 9-12: Add language identifiers to every listed Markdown code
fence: engdocs/architecture/v0-wave-A-plan.md lines 9-12, 20-30, and 34-45, plus
specs/05-synthesis/spec.md lines 12-14. Use an appropriate identifier for each
dependency, constructs layout, core layout, and synthesis lifecycle block while
preserving their contents.
In `@packages/constructs/src/constructs.ts`:
- Line 4: Remove the unused Construct import from constructs.ts, leaving the
remaining imports and implementation unchanged.
In `@packages/core/src/__tests__/synthesize.test.ts`:
- Around line 65-89: Add a test case alongside the existing artifact StepRef
test that supplies the input step as "ci/build" instead of "build". Synthesize
the pipeline and assert the generated artifact dependency producer is exactly
"ci/build", covering the synthesizeStep handling of already-prefixed references.
In `@packages/core/src/__tests__/validate.test.ts`:
- Around line 43-64: Replace the current collision test in the validation test
suite with a direct `validateOutputCollisions` call using a hand-built
`StepDefinition` containing two export operations with the same name, and assert
it raises `SynthesisError(OUTPUT_COLLISION)`. Rename the existing `synthesize`
case to describe the no-collision path, retaining its successful synthesis
assertion; use the package’s concrete `Runtime` value.
- Around line 17-22: Update the cycle-error test around synthesize(proj) to
assert the thrown SynthesisError once using toThrow with expect.objectContaining
matching code "CYCLE". Remove the separate try/catch and duplicate synthesize
invocation while preserving validation of the error type and code.
In `@packages/core/src/graph.ts`:
- Around line 63-67: Update the exported Dependency type in graph.ts from a
single interface to a discriminated union keyed by kind: keep output absent for
control dependencies, and require output for value and artifact dependencies.
Preserve the readonly producer field across all variants and ensure
synthesizeStep remains compatible with the stricter type.
In `@packages/core/src/synthesize.ts`:
- Around line 40-44: Update synthesize and add or use collectPipelineChildren to
recursively traverse the construct tree, handling every Step subclass, Entry,
and Pipeline while descending into grouping constructs. Replace silent omission
of unsupported nodes with SynthesisError, preserving synthesis of valid nested
pipelines and steps.
- Line 104: Export the existing resolveStepId function from validate.ts and
reuse it in synthesize.ts for producerId, dependsOn references, and entry roots.
Replace unconditional pipeline-prefix concatenation so already-qualified
references such as “ci/build” remain unchanged while local step references still
resolve within the current pipeline.
- Around line 67-68: The synthesized output declarations currently discard
output names, forcing validation to reconstruct them from export operations. In
packages/core/src/synthesize.ts lines 67-68, preserve each output’s map key in
StepDefinition.outputs and qualify pipeline-level output names with the
producing step id; in packages/core/src/validate.ts lines 77-84, validate name
collisions directly from the named step.outputs and remove the operations-based
workaround.
- Around line 14-22: Remove the unused ProjectDefinition type from the import
list in synthesize.ts, leaving the other graph.js imports unchanged.
In `@packages/core/src/validate.ts`:
- Around line 77-84: Remove the empty nested loop over step.outputs, including
the unused seen Set and its speculative comments, while preserving the
surrounding validation logic in the steps iteration.
- Around line 106-149: Reduce cognitive complexity in validateReferenceTypes by
extracting output map construction into a buildOutputTypeMap helper and the
per-reference validation into checkStepRef(step, ref, producerOutputs). Keep
validateReferenceTypes focused on iterating steps and inputs, delegating each
step reference check while preserving existing SynthesisError behavior.
In `@specs/01-constructs/spec.md`:
- Around line 63-69: Update StepProps.outputs in the authoring model so
duplicate output names remain representable for validation, preferably by using
a named declaration array instead of a Record. Then ensure synthesis validation
can detect duplicates and preserve the OUTPUT_COLLISION requirement and
corresponding test; alternatively, consistently remove or redefine that rule and
test.
In `@specs/02-definition-graph/spec.md`:
- Around line 53-59: Resolve the mismatch between PipelineDefinition.outputs and
the authoring contract: update PipelineProps to expose pipeline outputs and
define how they are normalized into PipelineDefinition.outputs, or defer the
field by removing it from the required interface and test plan. Ensure the
synthesis contract and tests consistently reflect the chosen behavior.
- Around line 80-85: Update the exportOutput variant of OperationDefinition to
accept only scalar output types, excluding "artifact" from OutputType; leave
exportArtifact as the required representation for artifact outputs and preserve
the other operation variants unchanged.
In `@specs/05-synthesis/spec.md`:
- Around line 91-99: Specify the synthesis name-resolution rule for
StepRef.step, dependsOn, and Entry.roots: resolve each pipeline-local name to
its path-qualified Definition Graph ID using the containing pipeline path, such
as build in pipeline ci becoming ci/build. Update the dependency and entry-root
requirements to use these qualified IDs, and add tests covering both dependency
references and entry roots.
🪄 Autofix
Fix all unresolved CodeRabbit comments on this PR:
Push a commit to this branch (recommended)
Create a new PR with the fixes
ℹ️ Review info⚙️ Run configuration
Configuration used: Organization UI
Review profile: ASSERTIVE
Plan: Pro Plus
Run ID: d81d58e2-d81e-41bd-8f49-e7ef6d5a336c
📥 Commits
Reviewing files that changed from the base of the PR and between 4f17521 and c93c778.
Learnt from: CR
Repo: sverka-dev/sverka PR: 0
File: AGENTS.md:0-0
Timestamp: 2026-08-12T07:24:02.495Z
Learning: Applies to **/*.{ts,tsx} : - **No `any`:** Use `unknown` and narrow. Strict TypeScript.
Applied to files:
packages/constructs/tsconfig.json
packages/constructs/tsdown.config.ts
📚 Learning: 2026-08-11T20:47:11.392Z
Learnt from: ThePlenkov
Repo: sverka-dev/sverka PR: 28
File: pack/formulas/wave.toml:27-43
Timestamp: 2026-08-11T20:47:11.392Z
Learning: In `pack/formulas/wave.toml`, the `wave` formula is a process description for the Gas City harness. It documents the architect, builder, reviewer, and mayor workflow steps. It is not executable runtime control flow, so reviewer rejection does not require a machine-readable formula gate in this file.
[warning] 152-152: Prefer "expect(pipeline.outputs).toHaveLength(1)" over this generic assertion for better reporting; it works on any object with a numeric length property.
[warning] 49-49: Prefer "expect(step.dependencies).toHaveLength(0)" over this generic assertion for better reporting; it works on any object with a numeric length property.
[warning] 151-151: Prefer "expect(pipeline.inputs).toHaveLength(1)" over this generic assertion for better reporting; it works on any object with a numeric length property.
[warning] 30-30: Prefer "expect(graph.project.pipelines).toHaveLength(1)" over this generic assertion for better reporting; it works on any object with a numeric length property.
[warning] 17-17: Prefer "expect(graph.project.pipelines).toHaveLength(1)" over this generic assertion for better reporting; it works on any object with a numeric length property.
[warning] 80-80: Prefer "expect(proj.node.children).toHaveLength(1)" over this generic assertion for better reporting; it works on any object with a numeric length property.
[warning] 83-83: Prefer "expect(pipeline.node.children).toHaveLength(3)" over this generic assertion for better reporting; it works on any object with a numeric length property.
[warning] 84-84: Prefer "expect(pipeline.node.children.filter((c) => c instanceof ShellStep)).toHaveLength(2)" over this generic assertion for better reporting; it works on any object with a numeric length property.
[warning] 85-85: Prefer "expect(pipeline.node.children.filter((c) => c instanceof Entry)).toHaveLength(1)" over this generic assertion for better reporting; it works on any object with a numeric length property.
[grammar] ~202-~202: Ensure spelling is correct
Context: ...olds command, runtime, outputs, inputs, dependsOn. 4. Entry under Pipeline; holds trigger...
(QB_NEW_EN_ORTHOGRAPHY_ERROR_IDS_1)
specs/05-synthesis/spec.md
[style] ~38-~38: The double modal “needs Run” is nonstandard (only accepted in certain dialects). Consider “to be Run”.
Context: ... Trigger reachability validation (needs Run Plan — wave G) - Context reference avai...
(NEEDS_FIXED)
[style] ~123-~123: Three successive sentences begin with the same word. Consider rewording the sentence or use a thesaurus to find a synonym.
Context: ...n with shell operation. 3. synthesize with scalar output → exportOutput operation....
(ENGLISH_WORD_REPEAT_BEGINNING_RULE)
[style] ~124-~124: Three successive sentences begin with the same word. Consider rewording the sentence or use a thesaurus to find a synonym.
Context: ...exportOutput operation. 4. synthesize with artifact output → exportArtifact operat...
(ENGLISH_WORD_REPEAT_BEGINNING_RULE)
[style] ~125-~125: Three successive sentences begin with the same word. Consider rewording the sentence or use a thesaurus to find a synonym.
Context: ...portArtifact operation. 5. synthesize with artifact StepRef in inputs → importArti...
(ENGLISH_WORD_REPEAT_BEGINNING_RULE)
[style] ~128-~128: Three successive sentences begin with the same word. Consider rewording the sentence or use a thesaurus to find a synonym.
Context: ...uts → value dependency. 7. synthesize with dependsOn → control dependency. 8. `s...
(ENGLISH_WORD_REPEAT_BEGINNING_RULE)
[style] ~132-~132: Three successive sentences begin with the same word. Consider rewording the sentence or use a thesaurus to find a synonym.
Context: ...or(UNKNOWN_PRODUCER). 11. synthesizedetects output collision →SynthesisError(OUTP...
(ENGLISH_WORD_REPEAT_BEGINNING_RULE)
[style] ~133-~133: Three successive sentences begin with the same word. Consider rewording the sentence or use a thesaurus to find a synonym.
Context: ...or(OUTPUT_COLLISION). 12. synthesizedetects incompatible reference type → Synt...
Synthesis converts the name-keyed input map into an array of bare values, permanently discarding
every symbolic input name. The resulting canonical graph cannot identify which declaration
corresponds to a context reference such as inputs.version, and identical declarations become
indistinguishable.
ⓘ Recommendations generated based on similar findings in past PRs
Evidence
Pipeline authoring stores inputs under string keys and ContextRef addresses the inputs namespace
by a field name, but synthesis returns only map values. The architecture requires symbolic pipeline
input references, so stripping keys removes required identity from the canonical graph.
The issue below was found during a code review. Follow the provided context and guidance below and implement a solution
## Issue description
Pipeline input names are lost while converting the construct tree into the Definition Graph.
## Issue Context
Represent graph inputs as named entries or a record/map, and add synthesis tests asserting names survive normalization.
## Fix Focus Areas
- packages/core/src/synthesize.ts[67-77]
- packages/core/src/graph.ts[22-27]
- packages/constructs/src/model.ts[65-69]
ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools
2. Unknown control producers pass✓ Resolved🐞 Bug≡ Correctness
Description
validateReferences checks only StepRef inputs, so dependsOn: ["missing"] returns a graph
containing a control edge to a nonexistent producer. Cycle detection silently processes absent
producer IDs, allowing a malformed graph that cannot enforce the requested ordering.
ⓘ Recommendations generated based on similar findings in past PRs
Evidence
Synthesis creates control producer IDs from every dependsOn value, but reference validation
iterates only step.inputs. When cycle detection visits an unknown producer, stepMap.get(id) is
undefined and the function returns without an error, so the dangling edge survives.
The issue below was found during a code review. Follow the provided context and guidance below and implement a solution
## Issue description
Control dependencies created from `dependsOn` are not checked for unknown producer IDs.
## Issue Context
Validate all generated dependency producers against pipeline step IDs before cycle detection and throw `UNKNOWN_PRODUCER` for missing control dependencies.
## Fix Focus Areas
- packages/core/src/synthesize.ts[127-133]
- packages/core/src/validate.ts[49-70]
- packages/core/src/validate.ts[22-35]
ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools
The rebuilt public index removes APIs that unchanged workspace packages still import, so affected
builds fail with missing exports. The Wave A plan acknowledges the breakage, but CI runs affected
builds and these packages are dependency-linked to @sverka/core.
-export { pipeline } from "./composables/pipeline.js";-export { run } from "./composables/run.js";-export { parallel } from "./composables/parallel.js";-export { when } from "./composables/when.js";
Relevance
●● Moderate
Potential intentional Wave-A breaking change; but repo values stable public API in core.
ⓘ Recommendations generated based on similar findings in past PRs
Evidence
The SDK directly imports the removed composables, types, and errors, while IR imports the removed
canonicalization and ID helpers. Workspace scripts and CI build affected projects, and the PR plan
itself states that the monorepo will fail after this change.
The issue below was found during a code review. Follow the provided context and guidance below and implement a solution
## Issue description
The core rebuild removes public exports still consumed by workspace packages, causing dependent builds and affected CI to fail.
## Issue Context
Retain a compatibility surface or migrate all current consumers in the same merge so the repository remains buildable.
## Fix Focus Areas
- packages/core/src/index.ts[3-29]
- packages/sdk/src/index.ts[3-24]
- packages/ir/src/ids.ts[1-30]
ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools
Pipeline, Step, and Entry constructors in packages/constructs/src/constructs.ts wrap `super(scope,
id) in try/catch and unconditionally rethrow any caught error as ConstructError('DUPLICATE_ID',
...), even when the underlying constructs` library throws for a different reason (e.g. an empty id
under a non-root scope, or other internal Node construction failures). Callers that branch on
err.code will misdiagnose the actual failure as a duplicate id.
+ try {+ super(scope, id);+ } catch (err) {+ throw new ConstructError("DUPLICATE_ID", `Duplicate id '${id}' in Project`, err);+ }
Relevance
●● Moderate
Correctness fix but alters error-code contract; no matching repo precedent for constructs wrappers.
ⓘ Recommendations generated based on similar findings in past PRs
Evidence
The same try/catch-and-relabel pattern appears identically for Pipeline (lines ~44-48), Step
(~81-85), and Entry (~145-149) in packages/constructs/src/constructs.ts. All exceptions thrown by
the wrapped constructs.Construct/Node constructor -- not only duplicate-child-id collisions --
are converted to ConstructError('DUPLICATE_ID', ...). The upstream constructs library's Node
constructor throws distinct errors for other invalid states (e.g. 'Only root constructs may have an
empty ID'), which this code cannot distinguish, so those failures are misreported with the wrong
error code.
The issue below was found during a code review. Follow the provided context and guidance below and implement a solution
## Issue description
Pipeline, Step, and Entry constructors catch any error thrown by `super(scope, id)` and always rethrow it as `ConstructError('DUPLICATE_ID', ...)`, even if the underlying `constructs` library threw for an unrelated reason (e.g. invalid/empty id).
## Issue Context
The wrapped `constructs.Construct`/`Node` constructor from the `constructs` npm package can throw different errors depending on the failure mode (duplicate child name vs. invalid id vs. other invariant violations). The current code has no way to distinguish these and always reports `DUPLICATE_ID`, which is misleading for diagnostics and any caller branching on `ConstructError.code`.
## Fix Focus Areas
- packages/constructs/src/constructs.ts[44-48]
- packages/constructs/src/constructs.ts[81-85]
- packages/constructs/src/constructs.ts[145-149]
ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools
Artifact validation runs after super(scope, id) registers the construct, so catching
INVALID_OUTPUT leaves a failed child in the pipeline and retrying that ID then fails as a
duplicate. The leaked object is also only partially initialized because ShellStep.command is
assigned after the throwing base constructor returns.
+ // Validate artifact outputs have a path.+ for (const [name, decl] of this.outputs) {+ if (decl.type === "artifact" && !decl.path) {+ throw new ConstructError(
Relevance
●● Moderate
Lifecycle/rollback issue after base registration; likely invasive; no close historical precedent
found.
ⓘ Recommendations generated based on similar findings in past PRs
Evidence
The Step constructor calls super before checking artifact paths, and the ShellStep command
assignment occurs only after that constructor returns. Constructs' Node constructor invokes
scope.node.addChild(host, this.id) during construction, proving registration precedes the new
validation.
The issue below was found during a code review. Follow the provided context and guidance below and implement a solution
## Issue description
Invalid artifact output props are rejected only after the construct has been registered with its parent, leaving the tree corrupted after a caught error.
## Issue Context
Validation that does not require `this` can run before `super`; otherwise explicitly roll back registration on failure.
## Fix Focus Areas
- packages/constructs/src/constructs.ts[74-104]
- packages/constructs/src/constructs.ts[119-121]
ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools
6. Inconsistent step-id resolution between synthesize and validate✓ Resolved🐞 Bug≡ Correctness
Description
synthesizeStep in packages/core/src/synthesize.ts always constructs dependency producer ids as
${pipelineId}/${ref.step} for StepRef inputs and dependsOn entries, but resolveStepId in
packages/core/src/validate.ts treats ref.step as already qualified when it already starts with
${pipelineId}/. As a result, an already-prefixed reference like ci/build can validate as
ci/build yet be recorded in the synthesized graph as ci/ci/build, causing the two paths to
disagree about whether a producer exists and leading to dangling edges or incorrect “unknown”
dependency reporting.
+function resolveStepId(pipelineId: string, stepName: string): string {+ // If the reference already includes the pipeline prefix, use as-is.+ if (stepName.startsWith(`${pipelineId}/`)) {+ return stepName;+ }+ return `${pipelineId}/${stepName}`;+}
Relevance
●●● Strong
Deterministic double-prefix ID mismatch between validate/synthesize; likely accepted as clear bug
fix.
ⓘ Recommendations generated based on similar findings in past PRs
Evidence
In packages/core/src/synthesize.ts, synthesizeStep unconditionally interpolates ref.step (and
dependsOn names) into a producer id using ${pipelineId}/${ref.step}, so an input already
containing the pipeline prefix will be double-prefixed in the dependency graph. In contrast,
packages/core/src/validate.ts’s resolveStepId explicitly returns ref.step unchanged when it
already begins with ${pipelineId}/, and validation then checks that resolved value against the
generated step IDs/output types; since both pieces of code operate on the same raw StepRef.step
string from the same StepDefinition inputs, this creates a provable divergence between the id
accepted by validation and the producer id emitted during synthesis.
The issue below was found during a code review. Follow the provided context and guidance below and implement a solution
## Issue description
`synthesizeStep` always prefixes `ref.step` and `dependsOn` names with `${pipelineId}/` when building dependency producer ids, while `validate.ts`'s `resolveStepId` conditionally skips the prefix if the name already starts with `${pipelineId}/`. This mismatch means the id recorded in a StepDefinition's `dependencies` can differ from the id validation checks (e.g., `ci/build` validating as `ci/build` but synthesizing a dependency on `ci/ci/build`), which can create dangling graph edges or incorrect unknown-producer errors.
## Issue Context
`StepRef.step` is documented (specs/01-constructs/spec.md) as a local step name relative to the same Pipeline, so already-prefixed values are an edge case, but synthesis and validation should not disagree on how ids are derived from the same raw string. Consider either using a single shared resolver for validation, dependency construction, and import operations, or rejecting prefixed references consistently so the behavior is uniform.
## Fix Focus Areas
- packages/core/src/synthesize.ts[100-105]
- packages/core/src/synthesize.ts[126-133]
- packages/core/src/synthesize.ts[100-123]
- packages/core/src/validate.ts[156-162]
- packages/core/src/validate.ts[49-69]
- packages/core/src/validate.ts[151-161]
ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools
7. Dead loop in validateOutputCollisions✓ Resolved🐞 Bug⚙ Maintainability
Description
In packages/core/src/validate.ts, validateOutputCollisions contains a `for (const out of
step.outputs) loop with an empty body (only comments) and a seen` Set that is declared but never
used; the actual duplicate-name check happens only in the following loop over step.operations.
This leftover dead code from an abandoned implementation approach adds confusion about which logic
performs the real validation.
+ for (const step of steps) {+ const seen = new Set<string>();+ for (const out of step.outputs) {+ // outputs is an array of OutputDeclaration with names from the map keys.+ // Actually outputs is readonly OutputDeclaration[] — but we need names.+ // The StepDefinition.outputs is OutputDeclaration[] without names baked in.+ // We need to check via the operations (exportOutput/exportArtifact names).+ }
Relevance
●●● Strong
Dead loop/unused Set cleanup; team commonly accepts removing redundant/unused code.
ⓘ Recommendations generated based on similar findings in past PRs
Evidence
packages/core/src/validate.ts new function validateOutputCollisions defines `const seen = new
Set<string>(); and iterates for (const out of step.outputs)` with no executable statements inside
(only comments explaining that this approach doesn't work), then performs the real check via
exportNames and step.operations in a second loop. The first loop and seen variable have zero
effect on behavior and should be removed.
The issue below was found during a code review. Follow the provided context and guidance below and implement a solution
## Issue description
`validateOutputCollisions` contains a no-op loop over `step.outputs` with an unused `seen` Set, left over from an earlier implementation attempt that was replaced by the operations-based check below it.
## Issue Context
The real duplicate output-name detection is performed correctly via `step.operations` and `exportNames` in the same function. The dead loop adds no value and can confuse future maintainers into thinking it participates in validation.
## Fix Focus Areas
- packages/core/src/validate.ts[77-84]
ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools
Review mode: 🧠 Deep: This is a dense redesign spanning new constructs and core packages, graph construction, synthesis, validation, APIs, and broad test replacement, creating many independent logic paths where redundant review is materially valuable.
Tip of the day
💡 Did you know, you can type 'qodo, fix this' on a finding and the fix lands right on your PR
…sing artifact path
- validate.ts: remove unused 'seen' Set and empty loop (dead code from Wave A)
- synthesize.ts: throw SynthesisError(INVALID_OUTPUT) when artifact output
has no path, instead of silently using empty string (defense-in-depth)
- errors.ts: add INVALID_OUTPUT to SynthesisErrorCode union
Addresses PR #38 review findings.
Generated with [Devin](https://devin.ai)
Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
- Move artifact output validation before construct registration.
- Distinguish duplicate-id errors from other construct errors.
- Validate unknown producers for dependsOn control dependencies.
- Include importArtifact in output collision checks and dedupe duplicate imports.
- Use shared resolveStepId for producer ids and fully-qualified importArtifact.from.
- Add OutputDefinition/PipelineOutputDefinition to preserve output names and producer stepId.
- Make Dependency a discriminated union.
- Refactor validateReferenceTypes to reduce cyclomatic complexity.
- Add INVALID_SCOPE/INVALID_OUTPUT SynthesisError codes and reject unexpected construct types.
- Update specs and tests.
…sing artifact path
- validate.ts: remove unused 'seen' Set and empty loop (dead code from Wave A)
- synthesize.ts: throw SynthesisError(INVALID_OUTPUT) when artifact output
has no path, instead of silently using empty string (defense-in-depth)
- errors.ts: add INVALID_OUTPUT to SynthesisErrorCode union
Addresses PR #38 review findings.
Generated with [Devin](https://devin.ai)
Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
- Move artifact output validation before construct registration.
- Distinguish duplicate-id errors from other construct errors.
- Validate unknown producers for dependsOn control dependencies.
- Include importArtifact in output collision checks and dedupe duplicate imports.
- Use shared resolveStepId for producer ids and fully-qualified importArtifact.from.
- Add OutputDefinition/PipelineOutputDefinition to preserve output names and producer stepId.
- Make Dependency a discriminated union.
- Refactor validateReferenceTypes to reduce cyclomatic complexity.
- Add INVALID_SCOPE/INVALID_OUTPUT SynthesisError codes and reject unexpected construct types.
- Update specs and tests.
…sing artifact path
- validate.ts: remove unused 'seen' Set and empty loop (dead code from Wave A)
- synthesize.ts: throw SynthesisError(INVALID_OUTPUT) when artifact output
has no path, instead of silently using empty string (defense-in-depth)
- errors.ts: add INVALID_OUTPUT to SynthesisErrorCode union
Addresses PR #38 review findings.
Generated with [Devin](https://devin.ai)
Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
- Move artifact output validation before construct registration.
- Distinguish duplicate-id errors from other construct errors.
- Validate unknown producers for dependsOn control dependencies.
- Include importArtifact in output collision checks and dedupe duplicate imports.
- Use shared resolveStepId for producer ids and fully-qualified importArtifact.from.
- Add OutputDefinition/PipelineOutputDefinition to preserve output names and producer stepId.
- Make Dependency a discriminated union.
- Refactor validateReferenceTypes to reduce cyclomatic complexity.
- Add INVALID_SCOPE/INVALID_OUTPUT SynthesisError codes and reject unexpected construct types.
- Update specs and tests.
…sing artifact path
- validate.ts: remove unused 'seen' Set and empty loop (dead code from Wave A)
- synthesize.ts: throw SynthesisError(INVALID_OUTPUT) when artifact output
has no path, instead of silently using empty string (defense-in-depth)
- errors.ts: add INVALID_OUTPUT to SynthesisErrorCode union
Addresses PR #38 review findings.
Generated with [Devin](https://devin.ai)
Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
- Move artifact output validation before construct registration.
- Distinguish duplicate-id errors from other construct errors.
- Validate unknown producers for dependsOn control dependencies.
- Include importArtifact in output collision checks and dedupe duplicate imports.
- Use shared resolveStepId for producer ids and fully-qualified importArtifact.from.
- Add OutputDefinition/PipelineOutputDefinition to preserve output names and producer stepId.
- Make Dependency a discriminated union.
- Refactor validateReferenceTypes to reduce cyclomatic complexity.
- Add INVALID_SCOPE/INVALID_OUTPUT SynthesisError codes and reject unexpected construct types.
- Update specs and tests.
…sing artifact path
- validate.ts: remove unused 'seen' Set and empty loop (dead code from Wave A)
- synthesize.ts: throw SynthesisError(INVALID_OUTPUT) when artifact output
has no path, instead of silently using empty string (defense-in-depth)
- errors.ts: add INVALID_OUTPUT to SynthesisErrorCode union
Addresses PR #38 review findings.
Generated with [Devin](https://devin.ai)
Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
- Move artifact output validation before construct registration.
- Distinguish duplicate-id errors from other construct errors.
- Validate unknown producers for dependsOn control dependencies.
- Include importArtifact in output collision checks and dedupe duplicate imports.
- Use shared resolveStepId for producer ids and fully-qualified importArtifact.from.
- Add OutputDefinition/PipelineOutputDefinition to preserve output names and producer stepId.
- Make Dependency a discriminated union.
- Refactor validateReferenceTypes to reduce cyclomatic complexity.
- Add INVALID_SCOPE/INVALID_OUTPUT SynthesisError codes and reject unexpected construct types.
- Update specs and tests.
Wave A rebuilt core with the new Definition Graph model but removed the
old composables, types, and ID functions that downstream packages (sdk,
ir, checks) still depend on. This broke their tests on v0-a-constructs.
Restore the old source files and re-export them from index.ts alongside
the new API. Each wave that rebuilds a downstream package (B: ir, C: sdk,
J: checks) removes its dependency on these compat exports. The compat
layer is removed when no longer needed.
Generated with [Devin](https://devin.ai)
Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Reduce cyclomatic complexity (12→6) and LOC (82→28) by extracting
export, import, and control-dependency logic into dedicated functions.
Generated with [Devin](https://devin.ai)
Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
…sing artifact path
- validate.ts: remove unused 'seen' Set and empty loop (dead code from Wave A)
- synthesize.ts: throw SynthesisError(INVALID_OUTPUT) when artifact output
has no path, instead of silently using empty string (defense-in-depth)
- errors.ts: add INVALID_OUTPUT to SynthesisErrorCode union
Addresses PR #38 review findings.
Generated with [Devin](https://devin.ai)
Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
- Move artifact output validation before construct registration.
- Distinguish duplicate-id errors from other construct errors.
- Validate unknown producers for dependsOn control dependencies.
- Include importArtifact in output collision checks and dedupe duplicate imports.
- Use shared resolveStepId for producer ids and fully-qualified importArtifact.from.
- Add OutputDefinition/PipelineOutputDefinition to preserve output names and producer stepId.
- Make Dependency a discriminated union.
- Refactor validateReferenceTypes to reduce cyclomatic complexity.
- Add INVALID_SCOPE/INVALID_OUTPUT SynthesisError codes and reject unexpected construct types.
- Update specs and tests.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
codeant-ai
Bot
added
the
size:XXL
![amazon-q-developer[bot]](https://avatars.githubusercontent.com/in/1220912?s=60&v=4){kind=small}
![codeant-ai[bot]](https://avatars.githubusercontent.com/in/646884?s=60&v=4){kind=small}
![codacy-production[bot]](https://avatars.githubusercontent.com/in/56611?s=60&v=4){kind=small}
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
![qodo-code-review[bot]](https://avatars.githubusercontent.com/in/484649?s=60&v=4){kind=small}
User description
Summary
@sverka/constructspackage wrappingconstructs@10.8.1with Sverka-specific base classes (SverkaConstruct, Project, Pipeline, Step, ShellStep)@sverka/corearound the Definition Graph: Project → Pipeline → Entry/Trigger → Step → Operation with typed ReferencesTests: 48 passing (20 constructs + 28 core)
Stacks on: #37 (v0 redesign foundation)
Test plan
packages/constructs— 20 tests passpackages/core— 28 tests passGenerated with Devin
Summary by cubic
Introduces
@sverka/constructsfor authoring Projects/Pipelines/Steps and rebuilds@sverka/coreto synthesize a provider‑neutral Definition Graph with stricter validation and a temporary compat layer. Behavior change: empty artifact output paths now throwConstructError(INVALID_OUTPUT)on construct creation andSynthesisError(INVALID_OUTPUT)on synthesis; duplicate construct ids throwConstructError(DUPLICATE_ID);importArtifact.frommust be fully‑qualified; unknowndependsOntargets and unexpected construct types are rejected.dependsOn), output collisions (includesimportArtifact; duplicate imports deduped), incompatible references, invalid scope, and unexpected construct types; resolves producer ids via a shared resolver.synthesize(project); introducesOutputDefinition/PipelineOutputDefinition(preserves outputnameand producerstepId) and a discriminated‐unionDependency.Migration
@sverka/constructs(Project,Pipeline,ShellStep,Entry) and callsynthesize(project)from@sverka/core; the old core API remains available temporarily.pathfor each artifact output and verifydependsOntargets exist.importArtifact.fromand avoid duplicate imports; update consumers to new core types where referenced (Dependencyunion;OutputDefinition/PipelineOutputDefinition).Written for commit c956507. Summary will update on new commits.
CodeAnt-AI Description
Introduce construct-based pipeline authoring and Definition Graph synthesis
What Changed
@sverka/constructswith Projects, Pipelines, shell Steps, Entries, triggers, inputs, outputs, runtimes, and typed referencesImpact
✅ Typed pipeline and trigger authoring✅ Explicit artifact and value transfer between steps✅ Clearer invalid pipeline errors💡 Usage Guide
Checking Your Pull Request
Every time you make a pull request, our system automatically looks through it. We check for security issues, mistakes in how you're setting up your infrastructure, and common code problems. We do this to make sure your changes are solid and won't cause any trouble later.
Talking to CodeAnt AI
Got a question or need a hand with something in your pull request? You can easily get in touch with CodeAnt AI right here. Just type the following in a comment on your pull request, and replace "Your question here" with whatever you want to ask:
This lets you have a chat with CodeAnt AI about your pull request, making it easier to understand and improve your code.
Example
Preserve Org Learnings with CodeAnt
You can record team preferences so CodeAnt AI applies them in future reviews. Reply directly to the specific CodeAnt AI suggestion (in the same thread) and replace "Your feedback here" with your input:
This helps CodeAnt AI learn and adapt to your team's coding style and standards.
Example
Retrigger review
Ask CodeAnt AI to review the PR again, by typing:
Check Your Repository Health
To analyze the health of your code repository, visit our dashboard at https://app.codeant.ai. This tool helps you identify potential issues and areas for improvement in your codebase, ensuring your repository maintains high standards of code health.