Feat/sdk cli api improvements #54
Conversation
│ │ │ - Mark smart contracts deployment as completed (Base testnet only) │ │ - Set REST API development as highest priority task │ │ - Add CLI integration with REST API as second priority │ │ - Cancel frontend task (exists in separate agent hub dapp repo) │ │ - Update task dependencies and priorities for current development focus │ │ │ │ 🤖 Generated with [Claude Code](https://claude.ai/code) │ │ │ │ Co-Authored-By: Claude <noreply@anthropic.com>
- Enhanced details to specify Fastify-specific features and plugins - Updated test strategy to include Fastify performance and plugin testing - Added JSON Schema validation and Fastify hooks/decorators - Leveraged Fastify's high-performance architecture for agent discovery 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
│ │ │ - Add wallet command with full-featured subcommands: │ │ - create: Generate new wallets with optional custom keys │ │ - list: Display all wallets with formatted output │ │ - balance: Check ETH and token balances │ │ - import/export: Secure wallet data management │ │ - delete: Remove wallets with safety confirmation │ │ - set-default: Manage default wallet selection │ │ - send: Transfer ETH between addresses │ │ - info: Display detailed wallet information │ │ │ │ - Implement WalletService with secure key management: │ │ - Encrypted storage using AES-256-GCM │ │ - Mnemonic phrase generation and validation │ │ - Private key derivation and import support │ │ - Safe credential handling with automatic clearing │ │ │ │ - Add comprehensive wallet types and interfaces │ │ - Create wallet utilities for formatting and validation │ │ - Add README documentation for CLI usage │ │ - Update CLI configuration manager for wallet integration │ │ │ │ 🤖 Generated with [Claude Code](https://claude.ai/code) │ │ │ │ Co-Authored-By: Claude <noreply@anthropic.com>
WalkthroughThis change introduces a new, full-stack decentralized agent and task management system for the Ensemble Framework, spanning configuration, documentation, CLI tooling, TypeScript and Python SDKs, REST API, and supporting files. It includes comprehensive documentation, environment and configuration files, a detailed CLI and API implementation, wallet management, schema/type definitions, and deployment guides. All components are newly added, with no removals or backward-incompatible changes. Changes
Sequence Diagram(s)sequenceDiagram
participant User
participant CLI
participant WalletService
participant EnsembleSDK
participant API Server
participant Blockchain
User->>CLI: Run agent/wallet/task command
CLI->>WalletService: (if needed) Create/Import/Use wallet
CLI->>EnsembleSDK: (if needed) Query or update agent/task
EnsembleSDK->>Blockchain: Read/write agent/task data
CLI->>API Server: (if needed) Query agent/task info via REST
API Server->>Blockchain: Query agent/task data
API Server->>CLI: Return agent/task data
CLI->>User: Display formatted output (table/json/yaml/csv)
Estimated code review effort🎯 5 (Critical) | ⏱️ ~90+ minutes
Suggested reviewers
Poem
Note ⚡️ Unit Test Generation is now available in beta!Learn more here, or try it out under "Finishing Touches" below. ✨ 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 (
|
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
There was a problem hiding this comment.
Actionable comments posted: 43
🧹 Nitpick comments (110)
packages/python-sdk/src/types.py (1)
64-67: Consider field parity with TypeScript EnsembleConfig.The rename from
ContractConfigtoEnsembleConfigaligns well with the framework naming conventions. However, comparing with the TypeScript version inpackages/sdk/src/types.ts(lines 219-225), the Python version is missing two fields:
serviceRegistryAddress(service_registry_address in Python naming)subgraphUrl(subgraph_url in Python naming, optional)Consider adding these fields for feature parity across SDK implementations.
@dataclass class EnsembleConfig: task_registry_address: str agent_registry_address: str + service_registry_address: str network: NetworkConfig + subgraph_url: Optional[str] = Nonepackages/python-sdk/src/ensemble.py (1)
9-9: Remove unused import.The static analysis correctly identified that
Optionalis imported but not used in this file.-from typing import Callable, Optional +from typing import Callable.env.example (2)
2-10: Trim padding before inline comments to satisfydotenv-linter& avoid accidental value pollutionThe extra spaces between the closing quote and the
#turn the trailing whitespace into part of the value for some parsers and trigger theValueWithoutQuoteslint warnings.
Example fix:-ANTHROPIC_API_KEY="your_anthropic_api_key_here" # Required: Format: sk-ant-api03-... +ANTHROPIC_API_KEY="your_anthropic_api_key_here" # Required: Format: sk-ant-api03-...Apply the same change to all keys in this file.
10-10: Add a newline at EOFA final newline keeps POSIX tools happy and silences the
EndingBlankLinewarning.packages/api/.env.example (2)
6-6: Remind developers to override the default JWT secret
JWT_SECRET=ensemble-jwt-secret-change-in-productionis fine for docs, but forgetting to override it would compromise auth. Consider wrapping the value in quotes and adding an explicit “DO NOT USE IN PROD” notice.-JWT_SECRET=ensemble-jwt-secret-change-in-production +JWT_SECRET="change-me-in-production" # DO NOT USE THIS VALUE IN PROD
16-16: Append a trailing newlineSame
EndingBlankLinewarning here—add a newline to keep linters quiet.packages/api/src/test/setup.ts (1)
3-5: Consider using more realistic test addresses.Using zero addresses as defaults for registry addresses might cause issues if tests actually interact with blockchain methods that validate addresses.
Consider using deterministic test addresses instead:
-process.env.AGENT_REGISTRY_ADDRESS = process.env.AGENT_REGISTRY_ADDRESS || '0x0000000000000000000000000000000000000000'; -process.env.SERVICE_REGISTRY_ADDRESS = process.env.SERVICE_REGISTRY_ADDRESS || '0x0000000000000000000000000000000000000000'; -process.env.TASK_REGISTRY_ADDRESS = process.env.TASK_REGISTRY_ADDRESS || '0x0000000000000000000000000000000000000000'; +process.env.AGENT_REGISTRY_ADDRESS = process.env.AGENT_REGISTRY_ADDRESS || '0x1111111111111111111111111111111111111111'; +process.env.SERVICE_REGISTRY_ADDRESS = process.env.SERVICE_REGISTRY_ADDRESS || '0x2222222222222222222222222222222222222222'; +process.env.TASK_REGISTRY_ADDRESS = process.env.TASK_REGISTRY_ADDRESS || '0x3333333333333333333333333333333333333333';packages/api/__mocks__/graphql-request.js (3)
3-8: Consider adding input validation and default mock behavior.The
GraphQLClientconstructor doesn't validate the URL parameter, and therequestmethod has no default behavior which could lead to undefined returns in tests.class GraphQLClient { constructor(url) { + if (!url || typeof url !== 'string') { + throw new Error('GraphQLClient requires a valid URL string'); + } this.url = url; - this.request = jest.fn(); + this.request = jest.fn(() => Promise.resolve({})); } }
10-17: Simplify the template literal implementation.The manual string concatenation can be simplified using the built-in
String.rawmethod or a more concise approach.function gql(strings, ...values) { - // Handle template literal: combine strings and values - let result = strings[0]; - for (let i = 0; i < values.length; i++) { - result += values[i] + strings[i + 1]; - } - return result; + return strings.reduce((result, string, i) => { + return result + (values[i - 1] || '') + string; + }); }
1-22: Add JSDoc documentation for better test maintainability.Consider adding documentation to explain the mock's purpose and expected behavior for future maintainers.
+/** + * Mock implementation of graphql-request to avoid ESM issues in Jest + * @see https://github.com/prisma-labs/graphql-request + */ + // Mock for graphql-request to avoid ESM issues in Jest +/** + * Mock GraphQL client that mimics the graphql-request GraphQLClient + */ class GraphQLClient { constructor(url) { this.url = url; this.request = jest.fn(); } } +/** + * Mock gql template literal function + * @param {TemplateStringsArray} strings - Template literal strings + * @param {...any} values - Interpolated values + * @returns {string} Combined GraphQL query string + */ function gql(strings, ...values) {.claude/commands/tm/setup/quick-install-taskmaster.md (2)
16-18: Consider adding more robust PATH setup instructions.The PATH export suggestion might not persist across terminal sessions. Consider providing more permanent solutions.
If you see "command not found" after installation, you may need to: 1. Restart your terminal -2. Or add npm global bin to PATH: `export PATH=$(npm bin -g):$PATH` +2. Add npm global bin to PATH permanently: + - For bash: `echo 'export PATH=$(npm bin -g):$PATH' >> ~/.bashrc` + - For zsh: `echo 'export PATH=$(npm bin -g):$PATH' >> ~/.zshrc` + - Or temporarily: `export PATH=$(npm bin -g):$PATH`
22-22: Fix inconsistent command reference.The help command reference
/project:helpdoesn't match the established pattern of/project:tm/helpseen in other documentation.-Quick test: Run `/project:help` to see all available commands. +Quick test: Run `/project:tm/help` to see all available commands.packages/contracts/README.md (1)
246-249: Duplicate address blocks risk diverging – keep a single source of truth
v3 - Base Sepolianow repeats the exact same three proxy addresses shown in thev3.2section above. Having two canonical blocks invites future drift and maintenance pain. Consider dropping the older “v3” subsection or clearly marking it as identical / historical to avoid confusion.packages/cli/tsconfig.json (1)
2-18: TypeScript QoL tweaks for CLI packageA few small compiler-option additions make local DX smoother without altering emitted JS:
"compilerOptions": { + // Guarantee Node globals & types are available + "types": ["node"], "target": "ES2022", "module": "commonjs", @@ "declarationMap": true, "sourceMap": true, + // Speeds up incremental builds in IDEs + "incremental": true, "moduleResolution": "node", "allowSyntheticDefaultImports": true },.claude/commands/tm/models/view-models.md (1)
30-38: Minor rendering nit – align the status table markerSome Markdown renderers treat the leading spaces in the block differently, causing mis-aligned checkmarks. Dropping the indent keeps columns tidy:
-Task Master AI Model Configuration -━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ -Main: ✅ claude-3-5-sonnet (configured) -Research: ✅ perplexity-sonar (configured) -Fallback: ⚠️ Not configured (optional) +Task Master AI Model Configuration +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +Main: ✅ claude-3-5-sonnet (configured) +Research: ✅ perplexity-sonar (configured) +Fallback: ⚠️ Not configured (optional).taskmaster/templates/example_prd.txt (1)
31-36: Clarify “Logical Dependency Chain” bullet listThe wording mixes guidance with imperatives; consider tightening for readability:
-# Logical Dependency Chain -[Define the logical order of development: -- Which features need to be built first (foundation) -- Getting as quickly as possible to something usable/visible front end that works -- Properly pacing and scoping each feature so it is atomic but can also be built upon and improved as development approaches] +# Logical Dependency Chain +[Describe the build order: +- Foundational features that must land first +- Fastest path to a usable, visible front-end +- Scoped, atomic increments that can be iterated on].claude/commands/tm/set-status/to-deferred.md (1)
19-21: Provide an explicit CLI placeholder for task ID to reduce copy-paste errors-task-master set-status --id=$ARGUMENTS --status=deferred +task-master set-status --id=<TASK_ID> --status=deferredSmall UX win: users instantly know to replace the token.
.claude/commands/tm/init/init-project-quick.md (2)
32-34: Add explicit language identifiers to fenced code blocks
markdownlintflags MD040 – each fenced block should specify a language.
Addbash(or another appropriate label) to the three anonymous blocks to avoid lint noise and enable proper syntax highlighting.- ``` + ```bashAlso applies to: 37-39, 42-44
3-4: Clarify$ARGUMENTSplaceholder
$ARGUMENTSis referenced but never described. Readers may not know whether it means a task-id, multiple flags, or something else.
Consider replacing it with a concrete example (e.g.TASK_ID) or adding a sentence that defines the expected input.packages/cli/jest.config.js (1)
5-6: IncludetsxintestMatchif React/JSX files are presentIf the CLI codebase ever adds
.tsxtest files they will be skipped.
Add the extension now for future-proofing.- testMatch: ['**/__tests__/**/*.test.ts', '**/?(*.)+(spec|test).ts'], + testMatch: ['**/__tests__/**/*.test.{ts,tsx}', '**/?(*.)+(spec|test).{ts,tsx}'],packages/cli/src/types/config.ts (1)
25-28: Tightenparamstyping for better DX
Record<string, any>defeats type-safety.
If the structure is unknown, preferunknownand force callers to narrow, or create a dedicated interface.- params?: Record<string, any>; + params?: Record<string, unknown>;packages/cli/package.json (1)
31-34: Missingenginesfield to enforce Node 18+.The README requires Node 18+, but the package does not encode that constraint. Help downstream users avoid cryptic ES-module errors:
+ "engines": { + "node": ">=18" + },.claude/commands/tm/clear-subtasks/clear-subtasks.md (1)
79-86: Specify a language on fenced code blocks to silence MD040.Markdown-lint flags the block because it lacks a language hint.
-``` +# console output +```(If the block is CLI interaction rather than shell script, using
consoleortextavoids misleading syntax highlighting.)packages/cli/README.md (1)
345-362: Replace bold “Common Issues” lines with proper headings (MD036).Markdown-lint warns because emphasis is used instead of headings. It also improves navigation.
-**"No wallet specified and no active wallet set"** +#### No wallet specified and no active wallet set ... -**"Invalid owner address format"** +#### Invalid owner address format ... -**"Wallet not found"** +#### Wallet not found ... -**Network Connection Issues** +#### Network connection issues.claude/commands/tm/add-dependency/add-dependency.md (1)
50-55: Add language identifier to fenced block (MD040).-``` +# console outputThis removes the lint error and provides consistent formatting across docs.
packages/cli/src/utils/wallet.ts (1)
21-23: Consider adding JSDoc type annotation for consistency.While the implementation is correct, consider adding a more detailed JSDoc comment similar to the first function for consistency across the module.
/** - * Get the effective wallet or throw an error with helpful message + * Get the effective wallet or throw an error with helpful message. + * @param globalWalletOption - Optional global wallet name from CLI option + * @returns Promise resolving to the effective wallet name + * @throws Error if no wallet can be resolved */.claude/commands/tm/utils/analyze-project.md (2)
22-24: Add a language identifier to the fenced code block
markdownlint(MD040) complains because the block starting here lacks a language tag. Append a language (e.g.text) right after the opening back-ticks so linters and renderers can apply proper styling.-``` +```text
54-64: Minor formatting – indent list continuation for readability
The dependency graph optimisation bullet (“Optimization: Parallelize #15 and #24”) visually merges with the preceding code block. Add an empty line or indent with four spaces so it is rendered outside the code fence..claude/TM_COMMANDS_GUIDE.md (2)
90-96: Specify language on fenced code samples
Several examples (this block and those at lines 112-118, 120-125, 127-131) omit a language tag, triggering MD040 and reducing syntax highlighting quality. Prefix them withbashto match the earlier “Quick Start” section.-``` +```bash
70-76: Consider alphabetic ordering in “Dependencies” section
For quicker scanning, order the four commands (add-dependency,remove-dependency,validate-dependencies,fix-dependencies) alphabetically or by typical workflow sequence (add → validate → fix → remove)..claude/commands/tm/models/setup-models.md (1)
9-11: Align CLI notation with the rest of the docs
Here the invocation istask-master models --setup, whereas elsewhere commands are presented under the/project:tm/namespace. Standardising the example prevents confusion.-task-master models --setup +/project:tm/models/setup.claude/commands/tm/workflows/smart-workflow.md (1)
23-35: Tighten wording around conditional mapping
The list mapping last commands to workflows mixes command forms (complete,list pending) and sub-commands (status). For clarity and easier future parsing, normalise them (e.g./project:tm/set-status/to-done,/project:tm/list/by-status pending)..claude/commands/tm/parse-prd/parse-prd.md (1)
38-42: Consider adding more specific examples for argument parsing.The options section mentions parsing arguments for modifiers but could benefit from concrete examples showing how to specify these options in practice.
Consider adding examples like:
task-master parse-prd --input=requirements.md 15 research task-master parse-prd --input=requirements.md comprehensivepackages/cli/src/utils/sdk.ts (2)
26-26: Consider making chain ID mapping configurable.The hardcoded chain ID mapping (8453 for mainnet, 84532 for Base Sepolia) should ideally be moved to configuration to support additional networks and make the code more maintainable.
Consider adding chain ID to the configuration:
- chainId: config.network === 'mainnet' ? 8453 : 84532, // Base mainnet : Base Sepolia + chainId: config.chainId || (config.network === 'mainnet' ? 8453 : 84532),
36-39: Consider adding validation for the createSignerFromPrivateKey function.The function should validate that the private key is properly formatted to prevent runtime errors.
Add basic validation:
export function createSignerFromPrivateKey(privateKey: string, rpcUrl: string): ethers.Signer { + if (!privateKey || !privateKey.startsWith('0x')) { + throw new Error('Invalid private key format'); + } + if (!rpcUrl) { + throw new Error('RPC URL is required'); + } const provider = new ethers.JsonRpcProvider(rpcUrl); return new ethers.Wallet(privateKey, provider); }packages/api/postman-collection.json (1)
114-122: Consider using more descriptive placeholder values.The placeholder values for agentId and ownerAddress could be more descriptive to help users understand the expected format.
Consider updating the placeholder values:
- "value": "0xYourAgentAddress", + "value": "0x742d35Cc6635C0532925a3b8D84C7BADC6a5000b", - "value": "0xYourOwnerAddress", + "value": "0x742d35Cc6635C0532925a3b8D84C7BADC6a50001",.claude/commands/tm/status/project-status.md (1)
17-23: Clarify placeholder$ARGUMENTS.The documentation repeatedly references
$ARGUMENTS, but it never defines the expected syntax or examples (e.g., JSON, CLI flags, plain strings). Readers may struggle to supply correct parameters..claude/commands/tm/set-status/to-done.md (1)
18-20: Provide concrete CLI argument example.Using
$ARGUMENTSwithout illustration leaves the exact call ambiguous. A minimal concrete snippet aids copy-paste usage.```bash # Example: mark task #42 as done task-master set-status --id=42 --status=done</blockquote></details> <details> <summary>.claude/commands/tm/workflows/command-pipeline.md (1)</summary><blockquote> `51-57`: **Minor markdown typo – missing back-tick closes code span.** The inline examples `status → $count=pending-count` and `if:$count>10` open a code span with back-ticks but the first one omits the closing back-tick around `pending-count`. </blockquote></details> <details> <summary>.cursor/rules/cursor_rules.mdc (1)</summary><blockquote> `48-53`: **Ensure consistency with existing rule docs.** Great to see explicit DO/DON’T patterns. Double-check that bullet formatting (✅ / ❌) matches the conventions used in existing rules to avoid style drift. </blockquote></details> <details> <summary>packages/api/scripts/test-api-server.ts (1)</summary><blockquote> `102-131`: **Improve server readiness detection robustness.** The current approach relies on stdout string matching which can be fragile. Consider adding a health check endpoint test as a more reliable readiness indicator. ```diff - server.stdout?.on('data', (data) => { - const output = data.toString(); - if (output.includes('Server listening') || output.includes('started')) { - serverReady = true; - } - if (process.env.DEBUG) { - console.log('[SERVER]', output); - } - }); + server.stdout?.on('data', (data) => { + const output = data.toString(); + if (output.includes('Server listening') || output.includes('started')) { + serverReady = true; + } + if (process.env.DEBUG) { + console.log('[SERVER]', output); + } + }); + + // Additional health check approach + const checkServerHealth = async () => { + try { + const response = await fetch(`${baseUrl}/health`); + return response.ok; + } catch { + return false; + } + };packages/api/scripts/test-agent-endpoints.ts (1)
32-34: Consider more robust SDK initialization.The fixed 2-second delay for SDK initialization might not be sufficient in all environments. Consider checking for actual readiness indicators.
- // Wait a bit for SDK initialization - await new Promise(resolve => setTimeout(resolve, 2000)); + // Wait for SDK initialization with readiness check + console.log('⏳ Initializing SDK...'); + let retries = 10; + while (retries > 0) { + try { + // Test a simple operation to verify SDK is ready + await agentService.getAgentCategories(); + console.log('✅ SDK initialized successfully'); + break; + } catch (error) { + retries--; + if (retries === 0) throw error; + await new Promise(resolve => setTimeout(resolve, 1000)); + } + }packages/cli/src/utils/file-operations.ts (1)
85-89: Consider using the utility function consistently.The
ensureDirectoryExistsfunction could be used to reduce code duplication in the other functions that currently have inline directory creation logic.export async function saveAgentRecords( // ... parameters ): Promise<void> { - // Ensure directory exists - if (!existsSync(directory)) { - await mkdir(directory, { recursive: true }); - } + await ensureDirectoryExists(directory); // ... rest of function }Apply similar changes to
saveAgentRecordfunction..claude/commands/tm/validate-dependencies/validate-dependencies.md (2)
1-34: Comprehensive validation documentation with formatting improvements needed.The validation checks are well-categorized and comprehensive. However, address the markdown formatting issues identified by static analysis.
The markdown linter flagged several formatting issues. Consider these improvements:
- Use proper headings instead of bold emphasis for section titles
- Add language specifications to code blocks where applicable
-1. **Circular Dependencies** +### Circular DependenciesApply similar changes to other section headings that use bold emphasis.
45-56: Add language specification to code block.The report format example is clear and helpful. Consider adding a language specification to the code block to address the static analysis warning.
-``` +```text Dependency Validation Report ━━━━━━━━━━━━━━━━━━━━━━━━━━packages/api/package.json (1)
5-12:npm startruns stale code – add a pre-build hook
startinvokesnode dist/index.js, yetbuildis a manual step.
A common pattern is to guarantee fresh artefacts:"scripts": { + "prestart": "npm run build", "build": "tsc",This prevents “cannot find module” errors when contributors forget to rebuild.
.claude/commands/tm/generate/generate-tasks.md (3)
17-46: Add a language identifier to fenced code block to satisfy markdown-lint
markdownlintflags MD040 here. Simply specify a language (e.g.text) to silence the warning and keep tooling green.-``` +```text Task ID: 1 Title: Implement user authentication ...
51-58: Same MD040 issue – second fenced blockRepeat the fix for the directory-tree snippet:
-``` +```text .taskmaster/ └── tasks/
98-108: Third fenced block missing language specAdd a language (e.g.
text) after the back-ticks.-``` +```text Task File Generation Complete ....claude/commands/tm/update/update-tasks-from-id.md (1)
60-75: MD040: fenced code block has no languageApply the same fix:
- ``` + ```text Bulk Update Preview ━━━━━━━━━━━━━━━━━━.claude/commands/tm/show/show-task.md (1)
42-58: Optional: declare language for the rendered task cardAlthough not flagged, adding
textstrengthens consistency with the other docs.-``` +```text 📋 Task #45: Implement User Authentication ....claude/commands/tm/set-status/to-cancelled.md (1)
26-28: Consider including the shell language for clarity-```bash +```bash task-master set-status --id=$ARGUMENTS --status=cancelled.claude/commands/tm/complexity-report/complexity-report.md (1)
50-57: Add language specification to fenced code block.The fenced code block for the Risk Matrix visualization should specify a language for proper syntax highlighting and consistency.
-``` +```text Risk vs Complexity Matrix ━━━━━━━━━━━━━━━━━━━━━━━ High Risk | #5(9) #12(8) | #23(6) Med Risk | #34(7) | #45(5) #67(5) Low Risk | #78(8) | [15 tasks] | High Complex | Med Complex -``` +```.claude/commands/tm/update/update-task.md (2)
30-36: Add language specification to fenced code block.The examples code block should specify a language for proper syntax highlighting.
-``` +```text Examples: - "complete tasks 12, 15, 18" - "all pending auth tasks to in-progress" - "increase priority for tasks blocking 45" - "defer all documentation tasks" -``` +```
47-54: Add language specification to fenced code block.The preview example should specify a language for consistency with markdown standards.
-``` +```text Update Preview: ───────────────── Tasks to update: #23, #24, #25 Change: status → in-progress Impact: Will unblock tasks #30, #31 Warning: Task #24 has unmet dependencies -``` +```.claude/commands/tm/tm-main.md (3)
131-135: Add language specification to fenced code block.The natural language examples should specify a language for proper syntax highlighting.
-``` +```bash /project:tm/add-task create user authentication system /project:tm/update mark all API tasks as high priority /project:tm/list show blocked tasks -``` +```
139-143: Add language specification to fenced code block.The ID-based command examples should specify a language for consistency.
-``` +```bash /project:tm/show 45 /project:tm/expand 23 /project:tm/set-status/to-done 67 -``` +```
121-121: Consider refining the adjective choice.The phrase "Deep project analysis" could be strengthened with a more specific adjective.
-- `analyze-project` - Deep project analysis and insights +- `analyze-project` - Comprehensive project analysis and insightspackages/cli/src/commands/init.ts (3)
86-90: Handle empty attributes array more explicitly.The filter function could result in an empty array when user provides only spaces or commas. Consider adding validation or providing clearer feedback.
{ type: 'input', name: 'attributes', message: 'Attributes (comma-separated):', - filter: (input) => input ? input.split(',').map((s: string) => s.trim()) : [] + filter: (input) => { + if (!input?.trim()) return []; + const attrs = input.split(',').map((s: string) => s.trim()).filter(Boolean); + return attrs.length > 0 ? attrs : []; + } }
135-147: Consider handling empty optional fields more consistently.Some optional fields default to empty strings while others might benefit from being undefined to avoid cluttering the YAML output.
return { name: answers.name, description: answers.description, category: answers.category, attributes: answers.attributes, - imageURI: answers.imageURI || '', + ...(answers.imageURI && { imageURI: answers.imageURI }), communication: { type: answers.communicationType, - url: answers.communicationURL || '', + ...(answers.communicationURL && { url: answers.communicationURL }), params: {} }, - socials: { - twitter: answers.twitter || '', - telegram: answers.telegram || '', - github: answers.github || '', - website: answers.website || '' - }, + socials: Object.fromEntries( + Object.entries({ + twitter: answers.twitter, + telegram: answers.telegram, + github: answers.github, + website: answers.website + }).filter(([_, value]) => value) + ), status: 'active' };
239-240: Add explicit template type validation.Consider validating the template type and providing helpful feedback for invalid types.
+const validTemplateTypes = Object.keys(templates); + +if (!templates[templateType]) { + console.warn(chalk.yellow(`⚠️ Unknown template type '${templateType}'. Using 'basic' template.`)); + console.log(chalk.blue(`Available types: ${validTemplateTypes.join(', ')}`)); +} + return templates[templateType] || templates.basic;.claude/commands/tm/fix-dependencies/fix-dependencies.md (2)
9-11: Add language specification to the code block.The bash code block should specify the language for better syntax highlighting and tooling support.
-```bash +```bash task-master fix-dependencies -``` +```
59-74: Add language specification to the output example.The output example should specify a language (e.g.,
textorconsole) for better rendering.-``` +```text Dependency Auto-Fix Report ━━━━━━━━━━━━━━━━━━━━━━━━ Fixed Automatically: ✅ Removed 2 references to deleted tasks ✅ Resolved 1 self-dependency ✅ Cleaned 3 redundant dependencies Manual Review Needed: ⚠️ Complex circular dependency: #12 → #15 → #18 → #12 Suggestion: Make #15 not depend on #12 ⚠️ Task #45 has 8 dependencies Suggestion: Break into subtasks Run '/project:tm/validate-dependencies' to verify fixes -``` +``` </blockquote></details> <details> <summary>packages/cli/src/commands/config.ts (1)</summary><blockquote> `42-46`: **Hardcoded RPC URLs should be configurable.** The RPC URLs are hardcoded which may not be flexible for different environments or user preferences. Consider extracting these URLs to a configuration object or constants file: ```typescript const NETWORK_CONFIG = { mainnet: 'https://mainnet.base.org', sepolia: 'https://sepolia.base.org' } as const; const rpcUrl = NETWORK_CONFIG[validNetwork];.claude/commands/tm/clear-subtasks/clear-all-subtasks.md (2)
16-26: Add language specification to the summary block.The project summary should specify a language for better rendering.
- ``` + ```text Global Subtask Summary ━━━━━━━━━━━━━━━━━━━━ Total parent tasks: 12 Total subtasks: 47 - Completed: 15 - In-progress: 8 - Pending: 24 Work at risk: ~120 hours - ``` + ``` --- `36-45`: **Add language specification to the warning block.** The confirmation prompt should specify a language for better rendering. ```diff -``` +```text ⚠️ DESTRUCTIVE OPERATION WARNING ⚠️ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ This will remove ALL 47 subtasks from your project Including 8 in-progress and 15 completed subtasks This action CANNOT be undone Type 'CLEAR ALL SUBTASKS' to confirm: -``` +``` </blockquote></details> <details> <summary>.claude/commands/tm/remove-task/remove-task.md (2)</summary><blockquote> `38-51`: **Add a language identifier to this fenced block** `markdownlint` flags this block because it starts with ``` but lacks a language tag. Annotate it with a neutral spec such as `text` (or `bash` if you want shell highlighting) to silence MD040 and keep consistency with the earlier `bash` block. ```diff -``` +```text Task Removal Impact ━━━━━━━━━━━━━━━━━━ … -``` +```
87-99: Same MD040 issue – missing language tagThe example-flow code fence also needs a language spec.
-``` +```text /project:tm/remove-task 5 … /project:tm/remove-task 5 -y … -``` +```.claude/commands/tm/remove-subtask/remove-subtask.md (1)
65-77: Specify a language for the example blockAdd
text(or another suitable identifier) after the opening back-ticks to comply with MD040 and maintain style parity.-``` +```text /project:tm/remove-subtask 5.1 … /project:tm/remove-subtask 5.1 convert … -``` +```.claude/commands/tm/add-subtask/add-subtask.md (1)
59-69: Missing language spec on fenced blockFlagged by markdownlint. Add
textfor clarity and consistency.-``` +```text /project:tm/add-subtask to 5: implement user authentication … /project:tm/add-subtask 5: setup, implement, test … -``` +```.claude/commands/tm/remove-dependency/remove-dependency.md (1)
57-62: Add a language hint to the fenced exampleAlthough not caught by the linter, this block also lacks a language identifier. Adding one improves readability and keeps the docs uniform.
-``` +```text /project:tm/remove-dependency 5 from 3 … -``` +```.claude/commands/tm/update/update-single-task.md (1)
68-83: Fenced example needs a language tagAttach
text(or another apt language) to satisfy MD040 and align with other code samples.-``` +```text /project:tm/update/single 5: add rate limiting … Suggestion: Also update task #6 (API Gateway) for consistency? -``` +```packages/api/src/index.ts (1)
128-129: Consider more restrictive CORS configurationThe CORS origin is set to
truein development, which allows all origins. While acceptable for development, ensure this doesn't accidentally get deployed.Consider using a more explicit development CORS configuration:
await fastify.register(cors, { - origin: process.env.NODE_ENV === 'development' ? true : ['https://ensemble.ai'], + origin: process.env.NODE_ENV === 'development' + ? ['http://localhost:3000', 'http://localhost:5173', 'http://127.0.0.1:3000'] + : ['https://ensemble.ai'], + credentials: true });.claude/commands/tm/workflows/auto-implement-tasks.md (1)
60-68: Add language specification to code blockThe code block should specify a language for proper syntax highlighting.
-``` +```text Step 1/5: Setting up component structure ✓Or use
consoleif you want to emphasize it as terminal output:-``` +```console Step 1/5: Setting up component structure ✓packages/api/src/schemas/definitions.ts (3)
31-31: Consider making social fields optionalRequiring all social media fields (twitter, telegram, dexscreener) might be too restrictive. Not all agents may have presence on all platforms.
AgentSocials: { type: 'object', - required: ['twitter', 'telegram', 'dexscreener'], + required: [], properties: {Or require only essential fields:
- required: ['twitter', 'telegram', 'dexscreener'], + required: ['twitter'],
23-23: Define schemas for generic object typesSeveral properties use generic 'object' type without further specification, which reduces API documentation clarity.
Consider defining more specific schemas:
- communicationParams: { type: 'object', description: 'Additional communication parameters' }, + communicationParams: { + type: 'object', + additionalProperties: true, + description: 'Additional communication parameters' + },For FilterInfo properties:
- applied: { type: 'object', description: 'Currently applied filters' }, - available: { type: 'object', description: 'Available filter options' } + applied: { + type: 'object', + additionalProperties: { type: 'string' }, + description: 'Currently applied filters as key-value pairs' + }, + available: { + type: 'object', + additionalProperties: { + type: 'array', + items: { type: 'string' } + }, + description: 'Available filter options per field' + }Also applies to: 56-57, 71-71
80-80: Update example timestamp to use dynamic dateThe hardcoded timestamp in the example will become outdated over time.
Consider using a more timeless example or documentation indicating it's just an example:
- timestamp: '2024-07-20T14:22:00Z', + timestamp: '2024-01-01T00:00:00Z', // Example timestamppackages/cli/src/bin/ensemble.ts (1)
105-108: Consider using a more robust Ethereum address validation.The current regex validation
!/^0x[a-fA-F0-9]{40}$/.test(ownerAddress)is basic and doesn't validate checksums. Consider using a more comprehensive validation library likeethers.jsfor Ethereum address validation.- if (!/^0x[a-fA-F0-9]{40}$/.test(ownerAddress)) { - console.error(chalk.red('❌ Invalid owner address format. Must be a valid Ethereum address.')); - process.exit(1); - } + try { + // Use ethers.js for proper address validation including checksum + const { isAddress } = await import('ethers'); + if (!isAddress(ownerAddress)) { + console.error(chalk.red('❌ Invalid owner address format. Must be a valid Ethereum address.')); + process.exit(1); + } + } catch (error) { + console.error(chalk.red('❌ Invalid owner address format. Must be a valid Ethereum address.')); + process.exit(1); + }packages/cli/src/commands/validate.ts (1)
21-21: Consider more comprehensive configuration validation.While testing agent count connectivity is good, consider validating other configuration aspects like RPC endpoint response times, authentication status, and supported network features.
// Test basic connectivity const agentService = sdk.agents; + + // Test RPC endpoint health + console.log(chalk.blue(' • Testing RPC endpoint...')); + const startTime = Date.now(); const count = await agentService.getAgentCount(); + const responseTime = Date.now() - startTime; + console.log(chalk.green(` ✅ RPC response time: ${responseTime}ms`));.claude/commands/tm/setup/install-taskmaster.md (1)
94-98: Security consideration for Node.js installation script.The curl command for installing nvm downloads and executes a script directly from the internet. Consider advising users to verify the script or use package managers when available.
# Install Node 18+ via nvm -curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash +# Option 1: Use package manager (recommended) +# For macOS: brew install node +# For Ubuntu: sudo apt install nodejs npm + +# Option 2: If using nvm, verify script first +curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh > nvm-install.sh +# Review the script before running +# cat nvm-install.sh +# bash nvm-install.shpackages/cli/src/commands/agents/get.ts (1)
36-47: Consider validating numeric parameters.The reputation min/max filters use
parseFloatbut don't validate the ranges. Consider adding validation to ensure reputation scores are within expected bounds (e.g., 0-100 or 0-5).if (options.reputationMin !== undefined) { + if (options.reputationMin < 0 || options.reputationMin > 100) { + console.error(chalk.red('❌ Reputation minimum must be between 0 and 100')); + process.exit(1); + } filters.reputation_min = options.reputationMin; } if (options.reputationMax !== undefined) { + if (options.reputationMax < 0 || options.reputationMax > 100) { + console.error(chalk.red('❌ Reputation maximum must be between 0 and 100')); + process.exit(1); + } + if (options.reputationMin !== undefined && options.reputationMax < options.reputationMin) { + console.error(chalk.red('❌ Reputation maximum must be greater than minimum')); + process.exit(1); + } filters.reputation_max = options.reputationMax; }.claude/commands/tm/add-subtask/convert-task-to-subtask.md (1)
55-64: Add language specification to fenced code block.The static analysis tool correctly identified that the fenced code block should have a language specified for proper syntax highlighting and processing.
-``` +```bash /project:tm/add-subtask/from-task 5 8 → Converting: Task #8 becomes subtask #5.1 → Updated: 3 dependency references → Parent task #5 now has 1 subtask → Note: Subtask inherits parent's priority Before: #8 "Implement validation" (standalone) After: #5.1 "Implement validation" (subtask of #5) -``` +```packages/cli/src/utils/validation.ts (3)
118-119: Extract magic numbers into constantsHard-coded limits should be defined as named constants for better maintainability and clarity.
Add these constants at the top of the file:
const VALIDATION_LIMITS = { NAME_MAX_LENGTH: 100, DESCRIPTION_MAX_LENGTH: 1000, ATTRIBUTES_MAX_COUNT: 20, INSTRUCTIONS_MAX_COUNT: 10, PROMPTS_MAX_COUNT: 10 } as const;Then update the validation logic:
- if (agentRecord.name && agentRecord.name.length > 100) { - result.warnings.push('Agent name is longer than 100 characters'); + if (agentRecord.name && agentRecord.name.length > VALIDATION_LIMITS.NAME_MAX_LENGTH) { + result.warnings.push(`Agent name is longer than ${VALIDATION_LIMITS.NAME_MAX_LENGTH} characters`);Also applies to: 123-124, 138-139, 143-144, 148-149
168-178: Consider the performance impact of URL validationMaking HTTP requests during validation can significantly slow down the validation process and may fail due to network issues. Consider:
- Making URL validation opt-in only when explicitly needed
- Reducing the timeout to 2-3 seconds
- Running URL checks concurrently with Promise.all()
- const response = await fetch(value, { - method: 'HEAD', - signal: AbortSignal.timeout(5000) // 5 second timeout - }); + const response = await fetch(value, { + method: 'HEAD', + signal: AbortSignal.timeout(3000) // 3 second timeout + });Consider also implementing concurrent validation:
async function validateUrls(agentRecord: AgentRecordYAML, result: ValidationResult): Promise<void> { const urlFields = [ { field: 'imageURI', value: agentRecord.imageURI }, { field: 'communication.url', value: agentRecord.communication?.url }, { field: 'socials.website', value: agentRecord.socials?.website } ]; const validationPromises = urlFields .filter(({ value }) => value && value.trim() !== '') .map(async ({ field, value }) => { // existing validation logic here }); await Promise.all(validationPromises); }
187-189: Consider using ethers.js for more robust Ethereum validationThe current regex-based validation doesn't verify EIP-55 checksum for addresses. Consider using ethers.js utilities for more comprehensive validation.
import { isAddress, isHexString } from 'ethers'; export function validateEthereumAddress(address: string): boolean { return isAddress(address); }This would provide checksum validation and better handle edge cases.
packages/cli/src/config/manager.ts (2)
36-36: Consider using a proper logging mechanismUsing
console.warndirectly in a library/CLI tool is not ideal. Consider using a logging library or allowing consumers to provide their own logger.- console.warn('Error reading config, using defaults:', error); + // Consider using a logger instance or debug flag + if (process.env.DEBUG) { + console.warn('Error reading config, using defaults:', error); + }
81-82: Simplify object property deletionCreating a new object just to delete a property is unnecessary.
- const newConfig = { ...currentConfig }; - delete newConfig.activeWallet; + const { activeWallet, ...newConfig } = currentConfig;This approach is more idiomatic and creates the new object without the
activeWalletproperty in one step.packages/cli/src/utils/formatters.ts (1)
103-105: Potential precision loss in bigint conversionConverting bigint to number could lose precision for very large reputation values.
- const reputation = typeof agent.reputation === 'bigint' - ? (Number(agent.reputation) / 1e18).toFixed(2) - : agent.reputation; + const reputation = typeof agent.reputation === 'bigint' + ? (agent.reputation / BigInt(1e18)).toString() + '.' + + ((agent.reputation % BigInt(1e18)) / BigInt(1e16)).toString().padStart(2, '0') + : agent.reputation;This preserves precision while still formatting the value correctly.
packages/cli/src/commands/agents/register.ts (1)
112-112: Consider making opening greeting configurableThe opening greeting is hardcoded. Consider allowing it to be specified in the YAML config or using a default from the agentRecord.
- openingGreeting: 'Hello! I am ready to help.', + openingGreeting: agentRecord.openingGreeting || 'Hello! I am ready to help.',Also update the
AgentRecordYAMLinterface to include this optional field.CLAUDE.md (2)
149-149: Fix typo in multi-Claude workflows sectionThere's a typo in the word "Multi-Claude" - it should be consistent with the rest of the documentation.
-#### 3. Multi-Claude Workflows +#### 3. Multi-Claude WorkflowsNote: The static analysis hint about "Multi-Claude" appears to be a false positive as this is the intended term for the workflow.
311-311: Fix typo: "Consdier" should be "Consider"-1. Create a markdown PRD file describing the new changes: `touch task-migration-checklist.md` (prds can be .txt or .md) -2. Use Taskmaster to parse the new prd with `task-master parse-prd --append` (also available in MCP) -3. Use Taskmaster to expand the newly generated tasks into subtasks. Consdier using `analyze-complexity` with the correct --to and --from IDs (the new ids) to identify the ideal subtask amounts for each task. Then expand them. +1. Create a markdown PRD file describing the new changes: `touch task-migration-checklist.md` (prds can be .txt or .md) +2. Use Taskmaster to parse the new prd with `task-master parse-prd --append` (also available in MCP) +3. Use Taskmaster to expand the newly generated tasks into subtasks. Consider using `analyze-complexity` with the correct --to and --from IDs (the new ids) to identify the ideal subtask amounts for each task. Then expand them..taskmaster/tasks/tasks.json (1)
371-372: Remove duplicate instruction about re-initializationThe note about not re-initializing appears to be incomplete or misplaced. Consider removing or completing this instruction.
-DO NOT RE-INITIALIZE. That will not do anything beyond re-adding the same Taskmaster core files.This line appears to be documentation that belongs in a different file, not in the tasks data.
packages/cli/src/services/WalletService.ts (3)
233-235: Consider using a proper logger instead of console.warnUsing console.warn for error logging is not ideal for production code. Consider using a proper logging library.
} catch (error) { // Skip invalid wallet files - console.warn(`Skipping invalid wallet file: ${file}`); + // TODO: Use a proper logger + if (process.env.NODE_ENV !== 'test') { + console.warn(`Skipping invalid wallet file: ${file}`); + } }
372-372: Implement token balance checkingThe TODO comment indicates missing functionality for token balance checking. This is important for a complete wallet implementation.
Would you like me to help implement token balance checking functionality? This would involve querying ERC-20 token contracts for balance information.
386-388: Implement transaction history fetchingThe transaction history method currently returns an empty array with a TODO comment.
Would you like me to help implement transaction history fetching? This could be done using:
- Direct RPC calls with
eth_getLogsand filtering- Integration with a blockchain explorer API (e.g., Etherscan, Blockscout)
- Using a service like The Graph for indexed data
packages/api/src/utils/testUtils/mockAgents.ts (1)
27-28: Consider using BigInt for consistency with blockchain valuesThe reputation field uses a string representation of a large number, while reputationScore uses a decimal. For consistency with blockchain operations, consider using BigInt.
- reputation: '4500000000000000000', // 4.5 * 10^18 + reputation: '4500000000000000000', // 4.5 * 10^18 totalRatings: '120',Note: The current implementation is correct, but you might want to add a comment explaining the relationship between
reputation(on-chain format) andreputationScore(human-readable format)..claude/commands/tm/analyze-complexity/analyze-complexity.md (2)
70-96: Add language specifier to fenced code blockThe markdown linter indicates that the fenced code block should have a language specified for better syntax highlighting.
-``` +```text Task Complexity Analysis Report ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
117-121: Fix command syntax in exampleThe command examples use a different syntax than shown elsewhere in the documentation. Ensure consistency.
After analysis: -``` +```bash /project:tm/expand 5 # Expand specific task /project:tm/expand/all # Expand all recommended /project:tm/complexity-report # View detailed reportpackages/api/src/types/agent.ts (3)
1-2: Consider using type-only imports for better tree-shakingSince
BigNumberishis only used as a type, consider using a type-only import.-import { BigNumberish } from "ethers"; +import type { BigNumberish } from "ethers";
11-11: Consider expanding communication types for future flexibilityThe current union type only supports two communication methods. Consider using an enum or allowing for extensibility.
-export type AgentCommunicationType = 'xmtp' | 'websocket'; +export enum AgentCommunicationType { + XMTP = 'xmtp', + WEBSOCKET = 'websocket', + // Add more types as needed +}Or for better extensibility:
-export type AgentCommunicationType = 'xmtp' | 'websocket'; +export type AgentCommunicationType = 'xmtp' | 'websocket' | string;
86-121: Consider using enums for sort fields and standardizing filter typesThe
AgentDiscoveryRequestinterface has good structure, but could benefit from better type safety.+export enum AgentSortField { + REPUTATION = "reputation", + PRICE = "price", + RESPONSE_TIME = "responseTime", + SUCCESS_RATE = "successRate" +} +export enum SortOrder { + ASC = "asc", + DESC = "desc" +} export interface AgentDiscoveryRequest { query: { text?: string; categories?: string[]; tags?: string[]; excludeTags?: string[]; }; filters?: { reputation?: { min?: number; max?: number; }; pricing?: { min?: string; max?: string; tokens?: string[]; }; availability?: { responseTime?: number; timezone?: string; online?: boolean; }; experience?: { minTasks?: number; successRate?: number; }; }; sort?: Array<{ - field: "reputation" | "price" | "responseTime" | "successRate"; - order: "asc" | "desc"; + field: AgentSortField; + order: SortOrder; }>; pagination?: { page: number; limit: number; }; }packages/api/src/services/agentService.ts (1)
335-348: Improve type safety in sorting logicThe sorting logic uses
anytype and could be more type-safe.private applySorting(agents: AgentRecord[], params: AgentQueryParams): AgentRecord[] { if (!params.sort_by) return agents; return agents.sort((a, b) => { - let aValue: any, bValue: any; + let aValue: string | number | Date; + let bValue: string | number | Date; switch (params.sort_by) { case 'reputation': aValue = a.reputationScore; bValue = b.reputationScore; break; case 'name': aValue = a.name; bValue = b.name; break; case 'created_at': aValue = new Date(a.createdAt); bValue = new Date(b.createdAt); break; case 'total_tasks': aValue = a.totalRatingsCount; bValue = b.totalRatingsCount; break; default: aValue = new Date(a.updatedAt); bValue = new Date(b.updatedAt); } - return params.sort_order === 'asc' ? (aValue > bValue ? 1 : -1) : (aValue < bValue ? 1 : -1); + if (aValue instanceof Date && bValue instanceof Date) { + return params.sort_order === 'asc' ? aValue.getTime() - bValue.getTime() : bValue.getTime() - aValue.getTime(); + } + return params.sort_order === 'asc' ? (aValue > bValue ? 1 : -1) : (aValue < bValue ? 1 : -1); }); }packages/api/src/routes/agents.ts (1)
252-254: TODO comment needs implementationThere's a TODO comment for implementing keystore file reading that should be addressed.
The keystore import functionality is marked as TODO. Would you like me to help implement this feature or create an issue to track it?
packages/cli/src/commands/wallet.ts (1)
416-418: Sensitive data display needs additional warningWhen exporting sensitive wallet data, consider adding an additional confirmation step.
console.log(chalk.yellow('\n🔐 SENSITIVE DATA - Handle with care!')); +console.log(chalk.red('⚠️ WARNING: Never share this information with anyone!')); +console.log(chalk.red('⚠️ Anyone with this data can access your wallet!')); console.log(chalk.cyan(`\n${options.format.toUpperCase()}:`)); console.log(exportedData);.taskmaster/docs/agent-api-endpoints.md (2)
452-454: Documentation: Make example tokens more clearly fakeThe example auth tokens could be mistaken for real tokens. Consider making them more obviously placeholder values.
-curl -X GET "https://api.ensemble.ai/v1/agents?category=ai-assistant&reputation_min=4.0&sort_by=reputation&limit=5" \ - -H "Authorization: Bearer YOUR_TOKEN" +curl -X GET "https://api.ensemble.ai/v1/agents?category=ai-assistant&reputation_min=4.0&sort_by=reputation&limit=5" \ + -H "Authorization: Bearer <YOUR-API-TOKEN-HERE>"
228-229: Documentation: Clarify "Coming Soon" timelineThe "Coming Soon" endpoints should have more specific timeline information or be moved to a separate section.
Consider adding a section at the end of the document for planned/future endpoints, or provide estimated timeline information (e.g., "Planned for Q1 2025").
.cursor/rules/taskmaster/taskmaster.mdc (1)
18-558: Comprehensive and well-structured command reference.This is an excellent reference document with consistent formatting, detailed parameter descriptions, and practical examples. The dual MCP/CLI presentation is particularly valuable for different use cases.
Minor suggestion for improved maintainability:
Consider adding a table of contents or index at the beginning to help users quickly navigate to specific commands, especially given the document's length.# Taskmaster Tool & Command Reference +## Table of Contents +- [Initialization & Setup](#initialization--setup) +- [AI Model Configuration](#ai-model-configuration) +- [Task Listing & Viewing](#task-listing--viewing) +- [Task Creation & Modification](#task-creation--modification) +- [Task Structure & Breakdown](#task-structure--breakdown) +- [Dependency Management](#dependency-management) +- [Analysis & Reporting](#analysis--reporting) +- [File Management](#file-management) +- [AI-Powered Research](#ai-powered-research) +- [Tag Management](#tag-management) +- [Miscellaneous](#miscellaneous) This document provides a detailed reference....taskmaster/docs/prd.txt (1)
28-143: Comprehensive feature specifications with excellent detail.The requirements are well-structured with clear identifiers (REQ-X.Y) that will facilitate tracking and implementation. The TypeScript SDK API specifications are particularly valuable with detailed method signatures, parameters, and return types.
Minor suggestion for API documentation consistency:
Consider adding error handling specifications for each API method to complement the detailed parameter and return type documentation..cursor/rules/taskmaster/dev_workflow.mdc (1)
271-424: Comprehensive implementation guidance with detailed processes.The configuration management section clearly separates concerns between config files and environment variables. The iterative subtask implementation process is particularly valuable with its 10-step detailed approach.
Minor suggestion for improved clarity:
Consider adding a visual flowchart or diagram for the iterative subtask implementation process, as the 10-step process is quite detailed and could benefit from visual representation.The rules management and code analysis sections provide practical operational guidance that will be valuable during development.
packages/cli/src/types/wallet.ts (1)
1-67: Well-designed and comprehensive wallet data interfaces.The interface design is clean and covers all essential wallet operations. The separation between
WalletDataandEncryptedWalletis appropriate, and the various options interfaces provide good flexibility.Minor suggestion for type consistency:
Consider using a union type for thecreatedAtfield consistency betweenWalletDataandEncryptedWallet.export interface WalletData { name: string; address: string; encrypted: boolean; - createdAt: Date; + createdAt: string; // Consistent with EncryptedWallet type: 'mnemonic' | 'private-key' | 'keystore'; }This ensures consistency in date handling across interfaces.
📜 Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro
⛔ Files ignored due to path filters (1)
pnpm-lock.yamlis excluded by!**/pnpm-lock.yaml
📒 Files selected for processing (107)
.claude/TM_COMMANDS_GUIDE.md(1 hunks).claude/commands/tm/add-dependency/add-dependency.md(1 hunks).claude/commands/tm/add-subtask/add-subtask.md(1 hunks).claude/commands/tm/add-subtask/convert-task-to-subtask.md(1 hunks).claude/commands/tm/add-task/add-task.md(1 hunks).claude/commands/tm/analyze-complexity/analyze-complexity.md(1 hunks).claude/commands/tm/clear-subtasks/clear-all-subtasks.md(1 hunks).claude/commands/tm/clear-subtasks/clear-subtasks.md(1 hunks).claude/commands/tm/complexity-report/complexity-report.md(1 hunks).claude/commands/tm/expand/expand-all-tasks.md(1 hunks).claude/commands/tm/expand/expand-task.md(1 hunks).claude/commands/tm/fix-dependencies/fix-dependencies.md(1 hunks).claude/commands/tm/generate/generate-tasks.md(1 hunks).claude/commands/tm/help.md(1 hunks).claude/commands/tm/init/init-project-quick.md(1 hunks).claude/commands/tm/init/init-project.md(1 hunks).claude/commands/tm/learn.md(1 hunks).claude/commands/tm/list/list-tasks-by-status.md(1 hunks).claude/commands/tm/list/list-tasks-with-subtasks.md(1 hunks).claude/commands/tm/list/list-tasks.md(1 hunks).claude/commands/tm/models/setup-models.md(1 hunks).claude/commands/tm/models/view-models.md(1 hunks).claude/commands/tm/next/next-task.md(1 hunks).claude/commands/tm/parse-prd/parse-prd-with-research.md(1 hunks).claude/commands/tm/parse-prd/parse-prd.md(1 hunks).claude/commands/tm/remove-dependency/remove-dependency.md(1 hunks).claude/commands/tm/remove-subtask/remove-subtask.md(1 hunks).claude/commands/tm/remove-task/remove-task.md(1 hunks).claude/commands/tm/set-status/to-cancelled.md(1 hunks).claude/commands/tm/set-status/to-deferred.md(1 hunks).claude/commands/tm/set-status/to-done.md(1 hunks).claude/commands/tm/set-status/to-in-progress.md(1 hunks).claude/commands/tm/set-status/to-pending.md(1 hunks).claude/commands/tm/set-status/to-review.md(1 hunks).claude/commands/tm/setup/install-taskmaster.md(1 hunks).claude/commands/tm/setup/quick-install-taskmaster.md(1 hunks).claude/commands/tm/show/show-task.md(1 hunks).claude/commands/tm/status/project-status.md(1 hunks).claude/commands/tm/sync-readme/sync-readme.md(1 hunks).claude/commands/tm/tm-main.md(1 hunks).claude/commands/tm/update/update-single-task.md(1 hunks).claude/commands/tm/update/update-task.md(1 hunks).claude/commands/tm/update/update-tasks-from-id.md(1 hunks).claude/commands/tm/utils/analyze-project.md(1 hunks).claude/commands/tm/validate-dependencies/validate-dependencies.md(1 hunks).claude/commands/tm/workflows/auto-implement-tasks.md(1 hunks).claude/commands/tm/workflows/command-pipeline.md(1 hunks).claude/commands/tm/workflows/smart-workflow.md(1 hunks).cursor/mcp.json(1 hunks).cursor/rules/cursor_rules.mdc(1 hunks).cursor/rules/self_improve.mdc(1 hunks).cursor/rules/taskmaster/dev_workflow.mdc(1 hunks).cursor/rules/taskmaster/taskmaster.mdc(1 hunks).env.example(1 hunks).gitignore(1 hunks).taskmaster/config.json(1 hunks).taskmaster/docs/agent-api-endpoints.md(1 hunks).taskmaster/docs/prd.txt(1 hunks).taskmaster/state.json(1 hunks).taskmaster/tasks/tasks.json(1 hunks).taskmaster/templates/example_prd.txt(1 hunks)CLAUDE.md(1 hunks)README.md(1 hunks)packages/api/.env.example(1 hunks)packages/api/.gitignore(1 hunks)packages/api/__mocks__/graphql-request.js(1 hunks)packages/api/jest.config.js(1 hunks)packages/api/package.json(1 hunks)packages/api/postman-collection.json(1 hunks)packages/api/scripts/test-agent-endpoints.ts(1 hunks)packages/api/scripts/test-api-server.ts(1 hunks)packages/api/src/index.ts(1 hunks)packages/api/src/routes/agents.ts(1 hunks)packages/api/src/schemas/definitions.ts(1 hunks)packages/api/src/services/agentService.ts(1 hunks)packages/api/src/test/helper.ts(1 hunks)packages/api/src/test/setup.ts(1 hunks)packages/api/src/types/agent.ts(1 hunks)packages/api/src/utils/testUtils/mockAgents.ts(1 hunks)packages/api/tsconfig.json(1 hunks)packages/cli/.gitignore(1 hunks)packages/cli/README.md(1 hunks)packages/cli/jest.config.js(1 hunks)packages/cli/package.json(1 hunks)packages/cli/src/bin/ensemble.ts(1 hunks)packages/cli/src/commands/agents.ts(1 hunks)packages/cli/src/commands/agents/get.ts(1 hunks)packages/cli/src/commands/agents/register.ts(1 hunks)packages/cli/src/commands/agents/update.ts(1 hunks)packages/cli/src/commands/config.ts(1 hunks)packages/cli/src/commands/init.ts(1 hunks)packages/cli/src/commands/validate.ts(1 hunks)packages/cli/src/commands/wallet.ts(1 hunks)packages/cli/src/config/manager.ts(1 hunks)packages/cli/src/services/WalletService.ts(1 hunks)packages/cli/src/types/config.ts(1 hunks)packages/cli/src/types/wallet.ts(1 hunks)packages/cli/src/utils/file-operations.ts(1 hunks)packages/cli/src/utils/formatters.ts(1 hunks)packages/cli/src/utils/sdk.ts(1 hunks)packages/cli/src/utils/validation.ts(1 hunks)packages/cli/src/utils/wallet.ts(1 hunks)packages/cli/tsconfig.json(1 hunks)packages/contracts/README.md(2 hunks)packages/python-sdk/src/ensemble.py(1 hunks)packages/python-sdk/src/types.py(1 hunks)packages/python-sdk/tests/test_sdk.py(2 hunks)
⛔ Files not processed due to max files limit (16)
- packages/sdk/.env.example
- packages/sdk/README.md
- packages/sdk/mocks/graphql-request.js
- packages/sdk/docs/classes/Ensemble.html
- packages/sdk/index.ts
- packages/sdk/jest.config.js
- packages/sdk/package.json
- packages/sdk/scripts/test-agent-methods.ts
- packages/sdk/src/ensemble.ts
- packages/sdk/src/index.ts
- packages/sdk/src/services/AgentService.ts
- packages/sdk/src/types.ts
- packages/sdk/test/agentService.test.ts
- packages/sdk/test/ensemble.test.ts
- packages/subgraph/schema.graphql
- pnpm-workspace.yaml
🧰 Additional context used
🧬 Code Graph Analysis (13)
packages/python-sdk/src/types.py (1)
packages/sdk/src/types.ts (1)
EnsembleConfig(220-226)
packages/python-sdk/src/ensemble.py (2)
packages/sdk/src/types.ts (2)
EnsembleConfig(220-226)Proposal(127-134)packages/python-sdk/src/types.py (2)
EnsembleConfig(64-67)Proposal(8-21)
packages/cli/src/commands/agents.ts (3)
packages/cli/src/commands/agents/get.ts (1)
getAgentsCommand(9-10)packages/cli/src/commands/agents/register.ts (1)
registerAgentCommand(13-161)packages/cli/src/commands/agents/update.ts (1)
updateAgentCommand(12-13)
packages/python-sdk/tests/test_sdk.py (2)
packages/sdk/src/types.ts (3)
EnsembleConfig(220-226)NetworkConfig(214-218)Proposal(127-134)packages/python-sdk/src/types.py (3)
EnsembleConfig(64-67)NetworkConfig(58-61)Proposal(8-21)
packages/cli/src/utils/file-operations.ts (1)
packages/cli/src/types/config.ts (1)
AgentRecordYAML(16-37)
packages/cli/src/utils/sdk.ts (1)
packages/cli/src/config/manager.ts (1)
getConfig(23-39)
packages/cli/src/commands/init.ts (1)
packages/cli/src/types/config.ts (1)
AgentRecordYAML(16-37)
packages/cli/src/commands/config.ts (2)
packages/cli/src/config/manager.ts (3)
getConfig(23-39)updateConfig(54-59)resetConfig(61-64)packages/cli/src/utils/formatters.ts (1)
formatOutput(6-22)
packages/api/src/index.ts (1)
packages/api/src/schemas/definitions.ts (1)
swaggerDefinitions(1-88)
packages/cli/src/utils/wallet.ts (1)
packages/cli/src/config/manager.ts (1)
getActiveWallet(74-77)
packages/cli/src/utils/validation.ts (1)
packages/cli/src/types/config.ts (1)
AgentRecordYAML(16-37)
packages/cli/src/config/manager.ts (1)
packages/cli/src/types/config.ts (1)
CLIConfig(1-14)
packages/api/src/utils/testUtils/mockAgents.ts (2)
packages/api/src/services/agentService.ts (2)
applyFilters(317-333)applySorting(335-348)packages/api/src/types/agent.ts (1)
Pagination(45-52)
🪛 Ruff (0.12.2)
packages/python-sdk/src/ensemble.py
9-9: typing.Optional imported but unused
Remove unused import: typing.Optional
(F401)
🪛 markdownlint-cli2 (0.17.2)
packages/cli/README.md
349-349: Emphasis used instead of a heading
(MD036, no-emphasis-as-heading)
352-352: Emphasis used instead of a heading
(MD036, no-emphasis-as-heading)
355-355: Emphasis used instead of a heading
(MD036, no-emphasis-as-heading)
358-358: Emphasis used instead of a heading
(MD036, no-emphasis-as-heading)
.claude/commands/tm/utils/analyze-project.md
45-45: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
.claude/commands/tm/init/init-project-quick.md
32-32: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
37-37: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
42-42: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
.claude/commands/tm/add-dependency/add-dependency.md
50-50: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
.claude/TM_COMMANDS_GUIDE.md
50-50: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
.claude/commands/tm/generate/generate-tasks.md
17-17: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
51-51: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
98-98: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
.claude/commands/tm/validate-dependencies/validate-dependencies.md
20-20: Emphasis used instead of a heading
(MD036, no-emphasis-as-heading)
21-21: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
29-29: Emphasis used instead of a heading
(MD036, no-emphasis-as-heading)
30-30: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
36-36: Emphasis used instead of a heading
(MD036, no-emphasis-as-heading)
37-37: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
44-44: Emphasis used instead of a heading
(MD036, no-emphasis-as-heading)
45-45: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
53-53: Emphasis used instead of a heading
(MD036, no-emphasis-as-heading)
58-58: Emphasis used instead of a heading
(MD036, no-emphasis-as-heading)
63-63: Emphasis used instead of a heading
(MD036, no-emphasis-as-heading)
.claude/commands/tm/update/update-tasks-from-id.md
45-45: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
.claude/commands/tm/update/update-task.md
30-30: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
47-47: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
.claude/commands/tm/tm-main.md
131-131: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
139-139: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
.claude/commands/tm/remove-subtask/remove-subtask.md
39-39: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
.claude/commands/tm/workflows/auto-implement-tasks.md
22-22: Emphasis used instead of a heading
(MD036, no-emphasis-as-heading)
29-29: Emphasis used instead of a heading
(MD036, no-emphasis-as-heading)
36-36: Emphasis used instead of a heading
(MD036, no-emphasis-as-heading)
45-45: Emphasis used instead of a heading
(MD036, no-emphasis-as-heading)
51-51: Emphasis used instead of a heading
(MD036, no-emphasis-as-heading)
60-60: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
.claude/commands/tm/clear-subtasks/clear-all-subtasks.md
17-17: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
51-51: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
.claude/commands/tm/add-subtask/add-subtask.md
50-50: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
.claude/commands/tm/fix-dependencies/fix-dependencies.md
17-17: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
51-51: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
.claude/commands/tm/complexity-report/complexity-report.md
55-55: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
.claude/commands/tm/add-subtask/convert-task-to-subtask.md
55-55: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
.claude/commands/tm/analyze-complexity/analyze-complexity.md
59-59: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
.claude/commands/tm/remove-task/remove-task.md
39-39: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
87-87: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
.claude/commands/tm/update/update-single-task.md
30-30: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
47-47: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
🪛 dotenv-linter (3.3.0)
packages/api/.env.example
[warning] 3-3: [UnorderedKey] The NODE_ENV key should go before the PORT key
[warning] 10-10: [UnorderedKey] The AGENT_REGISTRY_ADDRESS key should go before the NETWORK_RPC_URL key
[warning] 16-16: [EndingBlankLine] No blank line at the end of the file
[warning] 16-16: [UnorderedKey] The CORS_ORIGINS key should go before the MAX_REQUESTS_PER_MINUTE key
.env.example
[warning] 2-2: [ValueWithoutQuotes] This value needs to be surrounded in quotes
[warning] 4-4: [ValueWithoutQuotes] This value needs to be surrounded in quotes
[warning] 6-6: [UnorderedKey] The MISTRAL_API_KEY key should go before the OPENAI_API_KEY key
[warning] 6-6: [ValueWithoutQuotes] This value needs to be surrounded in quotes
[warning] 8-8: [UnorderedKey] The AZURE_OPENAI_API_KEY key should go before the MISTRAL_API_KEY key
[warning] 8-8: [ValueWithoutQuotes] This value needs to be surrounded in quotes
[warning] 10-10: [EndingBlankLine] No blank line at the end of the file
[warning] 10-10: [UnorderedKey] The GITHUB_API_KEY key should go before the MISTRAL_API_KEY key
[warning] 10-10: [ValueWithoutQuotes] This value needs to be surrounded in quotes
🪛 LanguageTool
.claude/commands/tm/tm-main.md
[style] ~121-~121: Consider a different adjective to strengthen your wording.
Context: ...project:tm/utils-analyze-project- Deep project analysis and insights ###/pr...
(DEEP_PROFOUND)
CLAUDE.md
[grammar] ~165-~165: Ensure spelling is correct
Context: ...d= --status=done ``` #### 3. Multi-Claude Workflows For complex projects, use multiple Cla...
(QB_NEW_EN_ORTHOGRAPHY_ERROR_IDS_1)
[grammar] ~311-~311: Ensure spelling is correct
Context: ...he newly generated tasks into subtasks. Consdier using analyze-complexity with the cor...
(QB_NEW_EN_ORTHOGRAPHY_ERROR_IDS_1)
.claude/commands/tm/analyze-complexity/analyze-complexity.md
[style] ~5-~5: Consider a different adjective to strengthen your wording.
Context: ...ations. Arguments: $ARGUMENTS Perform deep analysis of task complexity across the ...
(DEEP_PROFOUND)
[style] ~19-~19: Consider a different adjective to strengthen your wording.
Context: ...s - --research → Use research AI for deeper analysis - --threshold=5 → Only flag ...
(DEEP_PROFOUND)
🪛 Gitleaks (8.27.2)
.taskmaster/docs/agent-api-endpoints.md
452-453: Discovered a potential authorization token provided in a curl command header, which could compromise the curl accessed resource.
(curl-auth-header)
458-459: Discovered a potential authorization token provided in a curl command header, which could compromise the curl accessed resource.
(curl-auth-header)
477-478: Discovered a potential authorization token provided in a curl command header, which could compromise the curl accessed resource.
(curl-auth-header)
🔇 Additional comments (110)
packages/python-sdk/tests/test_sdk.py (2)
7-7: Import update correctly reflects the type rename.The import change from
ContractConfigtoEnsembleConfigis consistent with the type renaming inpackages/python-sdk/src/types.py.
18-26: Configuration instantiation properly updated.The
EnsembleConfiginstantiation correctly uses the renamed type and maintains all required fields with proper environment variable mapping.packages/python-sdk/src/ensemble.py (2)
8-8: Import update correctly reflects the type rename.The import change from
ContractConfigtoEnsembleConfigis consistent with the renaming inpackages/python-sdk/src/types.py.
12-12: Constructor parameter type correctly updated.The constructor parameter type annotation has been properly updated to use
EnsembleConfig, maintaining compatibility with the renamed type.packages/api/.gitignore (1)
1-15: Looks good – solid baseline ignore list for the package directory.gitignore (1)
1-30: No issues – root ignore list is comprehensive and consistent with typical Node + TS projectsREADME.md (1)
103-109: Verify codebase now references the singularAGENT_REGISTRY_ADDRESSThe doc update switches from
AGENTS_REGISTRY_ADDRESS➜AGENT_REGISTRY_ADDRESS. Make sure every script, test, and deployment config was updated to the new name to avoid hard-to-trace runtime failures..taskmaster/state.json (1)
1-6: LGTM! Clean state management structure.The JSON structure is well-formed with appropriate data types for tracking Taskmaster workflow state. The ISO 8601 timestamp format and clear property names make this suitable for state persistence.
packages/api/src/test/helper.ts (1)
4-22: LGTM! Well-structured test helper function.The Fastify app setup is clean and follows good testing practices by disabling logging and providing a consistent configuration structure.
.cursor/mcp.json (2)
7-15: Ensure API keys are properly secured before deployment.The configuration contains placeholder API keys that need to be replaced with actual values. Ensure these are:
- Never committed to version control with real values
- Set via environment variables or secure configuration management
- Documented in setup instructions for users
Consider adding a
.env.examplefile and updating documentation to guide users on secure API key configuration.
1-19: LGTM! Proper MCP server configuration structure.The JSON structure correctly defines the MCP server configuration with appropriate command and arguments for the task-master-ai package.
packages/cli/src/commands/agents.ts (3)
7-9: LGTM! Clean command structure with helpful alias.The command setup follows Commander.js best practices with a clear description and convenient alias.
11-14: LGTM! Proper subcommand registration.The subcommands are cleanly imported and registered, providing good separation of concerns.
16-20: Excellent user experience with helpful default action.The default action provides clear guidance when users don't specify a subcommand, improving CLI usability.
.claude/commands/tm/list/list-tasks-with-subtasks.md (1)
1-29: Well-structured documentation with comprehensive feature coverage.The documentation clearly explains the hierarchical task listing functionality with good organization of features like enhanced display, smart filtering, and progress indicators. The feature set appears valuable for project management workflows.
.claude/commands/tm/setup/quick-install-taskmaster.md (1)
6-7: Installation Command Verification CompleteThe npm package
task-master-aihas been confirmed to exist in the registry. No changes are needed to the quick-install instructions.packages/api/tsconfig.json (2)
1-21: Well-configured TypeScript setup for API package.The configuration is comprehensive with appropriate strict settings, source mapping, and declaration generation. The compiler options are suitable for a Node.js API server.
3-4: No action needed: CommonJS modules align with server-side packages
A review of alltsconfig.jsonfiles shows that the API package’s"module": "commonjs"matches the CLI and Subgraph packages. The App and Contracts packages deliberately target ESM for Next.js, so no change is required here..claude/commands/tm/help.md (2)
67-72: Excellent natural language examples for user guidance.The natural language command examples effectively demonstrate the system's flexibility and user-friendly approach to task management.
74-80: Clear and actionable getting started sequence.The four-step getting started guide provides a logical progression for new users, from installation through productive workflow usage.
packages/contracts/README.md (1)
226-235: No stale references to the old plural env var remain
I ran a repository-wide search forAGENTS_REGISTRY_ADDRESSand found zero occurrences. The rename toAGENT_REGISTRY_ADDRESSis now consistent across all docs and scripts.packages/cli/.gitignore (1)
1-78: Extensive ignore list looks goodThorough coverage of build artefacts, caches and editor files; nothing stands out as missing or redundant.
.claude/commands/tm/expand/expand-task.md (1)
11-13: Minor: add language to fenced block for consistency-```bash -task-master expand --id=$ARGUMENTS -``` +```bash +task-master expand --id=$ARGUMENTS +```(The first back-tick already has
bash, keep the identifier on opening line.).claude/commands/tm/list/list-tasks-by-status.md (1)
17-20: 👍 Example block is clear and already tagged withbash.No action needed.
.claude/commands/tm/set-status/to-pending.md (1)
1-32: Excellent documentation structure and content.The documentation is well-organized with clear sections covering purpose, execution, validation, and smart actions. The use cases are practical and the validation steps show thoughtful consideration of edge cases like warning about in-progress tasks and checking dependencies.
.claude/commands/tm/set-status/to-review.md (1)
1-40: Comprehensive and well-structured review status documentation.The documentation provides clear guidance on when to use the review status and includes detailed preparation steps. The structured approach with numbered lists and practical examples (PR/MR links, test results) makes it actionable for users.
.claude/commands/tm/list/list-tasks.md (1)
1-43: Intelligent command design with excellent documentation.The documentation showcases sophisticated argument parsing with intuitive filter combinations. The examples clearly demonstrate the command's flexibility ("pending high", "blocked", "1-5") and the workflow from detection to smart suggestions is well-structured.
packages/cli/src/utils/wallet.ts (2)
7-13: Clean implementation with clear priority logic.The function correctly implements the documented priority order and handles the async operation properly. The logic is straightforward and easy to follow.
18-26: Good error handling with actionable user guidance.The error message is helpful and provides clear next steps for users. The function correctly leverages the base
getEffectiveWalletfunction for consistency..claude/commands/tm/init/init-project.md (1)
1-50: Comprehensive initialization documentation with excellent workflow integration.The documentation provides thorough coverage of the initialization process, from argument parsing to post-setup guidance. The integration section effectively demonstrates how the command connects with other system workflows, and the configuration options are clearly explained.
.taskmaster/config.json (1)
4-8: Verify maxTokens values against provider limits
64000and120000tokens exceed or are close to current Anthropic model limits. Confirm these figures with the provider—oversized values are silently truncated by many SDKs and may hide usage bugs..claude/commands/tm/parse-prd/parse-prd.md (1)
1-49: Well-structured command documentation with clear process flow.The documentation effectively outlines the PRD parsing workflow with logical steps and clear execution instructions. The multi-phase approach (analysis, generation, enhancement) is well-organized and the post-generation recommendations add value.
.claude/commands/tm/expand/expand-all-tasks.md (2)
1-51: Comprehensive documentation with intelligent selection criteria.The documentation clearly outlines the bulk expansion process with smart selection logic that prevents unnecessary decomposition. The three-phase approach (analysis, batch processing, quality control) demonstrates thoughtful design for maintaining task coherence.
15-19: Well-defined selection criteria prevent over-expansion.The smart selection criteria effectively filter tasks that would benefit from breakdown while avoiding unnecessary decomposition of simple tasks.
packages/cli/src/utils/sdk.ts (1)
5-34: SDK instance creation logic is sound but could benefit from improvements.The function correctly handles configuration loading, provider setup, and signer creation with appropriate fallbacks for read-only operations.
packages/api/postman-collection.json (2)
1-124: Comprehensive Postman collection with well-structured API requests.The collection provides excellent coverage of the agent API endpoints with proper HTTP methods, headers, and parameter structures. The environment variables and disabled query parameters offer good flexibility for testing different scenarios.
50-53: Well-designed discovery endpoint with comprehensive query structure.The POST request body for agent discovery includes appropriate filters for text search, categories, reputation ranges, and pagination, demonstrating thoughtful API design.
.claude/commands/tm/set-status/to-in-progress.md (3)
1-36: Excellent workflow-oriented approach to task status management.The documentation goes beyond simple status updates to provide comprehensive workflow preparation, including environment setup, pre-start validation, and intelligent suggestions. This holistic approach will significantly improve developer productivity.
9-15: Comprehensive pre-start validation prevents common workflow issues.The pre-start checks cover important workflow prerequisites that help prevent conflicts and ensure tasks are ready for development work.
24-30: Environment setup steps create seamless developer experience.The automated environment preparation (git branches, documentation, test watchers) demonstrates thoughtful UX design that reduces friction when starting task work.
packages/api/jest.config.js (1)
8-13: File-extension inmoduleNameMappercan break resolution on Windows.Appending
.tsin the mapped path makes Jest look for an exact filename, but the resolver already tries relevant extensions automatically. Dropping the extension improves portability.- '^@ensemble-ai/sdk$': '<rootDir>/__mocks__/@ensemble-ai/sdk.ts' + '^@ensemble-ai/sdk$': '<rootDir>/__mocks__/@ensemble-ai/sdk'packages/api/scripts/test-api-server.ts (3)
1-10: Clean shebang and imports setup.The shebang correctly uses
npx tsxfor TypeScript execution, and the imports are appropriate for the functionality needed.
11-81: Well-structured test function with comprehensive endpoint coverage.The
testEndpointsfunction properly tests multiple endpoints with good error handling and clear logging. The test cases cover both success and error scenarios effectively.
135-152: Proper cleanup and export structure.The cleanup logic properly terminates the server in the finally block, and the export structure allows for reuse in other test contexts. Good practice for a test utility script.
packages/api/scripts/test-agent-endpoints.ts (7)
35-54: Well-structured pagination test.The test properly validates pagination functionality with clear logging and appropriate error handling.
56-82: Comprehensive filtering and sorting tests.Tests 2 and 3 properly validate category filtering and reputation-based sorting with clear result logging.
84-105: Proper conditional test execution.Test 4 correctly handles optional environment variables and provides clear feedback when skipping tests.
107-118: Consistent conditional test pattern.Test 5 follows the same well-designed pattern as the previous conditional test.
120-142: Well-formatted category and skills tests.Tests 6 and 7 provide comprehensive coverage with readable output formatting and proper error handling.
144-154: Comprehensive discovery functionality test.Test 8 properly validates the discovery feature with appropriate parameters and clear result reporting.
156-169: Proper main execution and export structure.The main execution logic includes appropriate error handling and allows for script reuse through exports.
.claude/commands/tm/parse-prd/parse-prd-with-research.md (3)
1-14: Clear documentation structure and purpose.The document effectively introduces the research-enhanced PRD parsing feature with proper argument specification and execution instructions.
15-34: Comprehensive benefits documentation.The Research Benefits section clearly articulates the value proposition with well-organized categories and relevant details.
35-48: Practical guidance for feature usage.The Enhanced Output and When to Use sections provide clear, actionable guidance for users to determine when the research mode would be beneficial.
packages/cli/src/utils/file-operations.ts (3)
7-28: Well-structured batch agent saving function.The
saveAgentRecordsfunction properly handles both single and multiple agent scenarios with appropriate filename generation and directory creation.
30-42: Clean single agent saving implementation.The
saveAgentRecordfunction provides a focused interface for single agent saving with consistent directory handling.
44-83: All agent property mappings are correct — no changes needed.The
convertAgentToYAMLfunction aligns with the SDK’sAgentRecordinterface, which usescategory,communicationType,communicationURL,communicationParams, andsocialsfields. Defaults and field names match the codebase, so the mapping is accurate. Approving as-is..claude/commands/tm/validate-dependencies/validate-dependencies.md (1)
58-71: Clear actionable guidance for users.The Actionable Output and Next Steps sections provide practical information for users. Consider applying the same heading formatting improvements mentioned earlier for consistency.
.claude/commands/tm/complexity-report/complexity-report.md (1)
1-117: Well-structured command documentation with comprehensive coverage.The documentation effectively covers all aspects of the complexity-report command including execution, report contents, interactive features, and integration patterns. The examples and usage scenarios provide clear guidance for users.
.claude/commands/tm/next/next-task.md (1)
1-66: Excellent intelligent workflow documentation.This documentation demonstrates sophisticated understanding of task workflow optimization with comprehensive coverage of context analysis, smart decision trees, and seamless integration patterns. The approach to handling different argument types and providing multiple recommendation options shows good UX design.
.claude/commands/tm/update/update-task.md (1)
1-72: Comprehensive task update documentation with intelligent features.The documentation effectively covers natural language processing, bulk operations, validation, and workflow integration. The safety checks and preview functionality demonstrate good UX design for potentially destructive operations.
.claude/commands/tm/tm-main.md (1)
1-146: Excellent comprehensive command reference documentation.This document provides exceptional organization and coverage of the Task Master command ecosystem. The hierarchical structure, natural language support, and integration patterns demonstrate sophisticated design. The usage patterns section effectively guides users on different interaction methods.
packages/cli/src/commands/init.ts (1)
1-259: Well-structured CLI command with comprehensive functionality.This implementation demonstrates good practices with proper error handling, user experience considerations, interactive prompts, and YAML generation. The template system provides good flexibility for different agent types, and the file overwrite protection shows attention to user safety.
.claude/commands/tm/fix-dependencies/fix-dependencies.md (1)
1-81: Excellent documentation structure and comprehensive coverage.The documentation provides clear, actionable information about the dependency fixing tool with good organization, safety considerations, and practical examples. The three-phase approach (analysis, execution, verification) is well-designed.
packages/cli/src/commands/config.ts (6)
1-5: Clean imports and setup.The imports are well-organized and the necessary dependencies are correctly imported.
6-8: Well-structured command definition.The base command is properly defined with a clear description.
13-30: Good security practice for sensitive data masking.The show command correctly masks the private key in the display output while preserving the actual value in storage.
69-81: Security concern: Private key handling.The private key is being stored and handled as a plain string. Consider security implications and add warnings or validation.
// Add validation for private key format if (!key.startsWith('0x') || key.length !== 66) { console.warn(chalk.yellow('⚠️ Warning: Private key format may be invalid')); } // Add security warning console.warn(chalk.yellow('⚠️ Private key will be stored in plaintext configuration file'));
25-29: Consistent and robust error handling pattern.All commands follow a consistent error handling pattern with proper error messages and process exit codes.
Also applies to: 48-52, 62-66, 76-80, 90-94, 104-108
35-40: Add proper TypeScript type constraint.The network parameter should be properly typed to ensure type safety at compile time.
-.action(async (network: 'mainnet' | 'sepolia') => { +.action(async (network: string) => { try { - if (!['mainnet', 'sepolia'].includes(network)) { + if (!['mainnet', 'sepolia'].includes(network as 'mainnet' | 'sepolia')) { console.error(chalk.red('❌ Invalid network. Use: mainnet or sepolia')); process.exit(1); } + + const validNetwork = network as 'mainnet' | 'sepolia';Likely an incorrect or invalid review comment.
.claude/commands/tm/sync-readme/sync-readme.md (5)
21-23: Good command execution example.The bash command example clearly shows the available options and usage pattern.
28-40: Excellent example of generated README header.The example shows a professional, well-structured README format with progress indicators and summary statistics.
77-91: Comprehensive output example with rich formatting.The example demonstrates the visual elements, status indicators, and detailed task information that would be generated.
101-109: Thoughtful post-sync workflow.The post-generation steps show consideration for user workflow, including backup, diff preview, and version control integration.
1-117: Comprehensive and well-structured documentation.The documentation thoroughly covers all aspects of the README synchronization feature with clear examples, customization options, and integration guidance.
.claude/commands/tm/learn.md (5)
11-17: Smart argument-based routing.The conditional logic based on user input provides intelligent contextual help and guidance.
23-33: Clear onboarding path for new users.The guidance for users with no tasks provides clear next steps and practical examples.
43-53: Excellent command discovery organization.Commands are well-organized by both category and scenario, making it easy for users to find relevant functionality.
76-95: Progressive learning paths for different skill levels.The structured progression from beginner to advanced provides clear development paths for users.
1-103: Comprehensive interactive learning system.The documentation presents a well-thought-out learning system that adapts to user needs and provides progressive skill development.
.claude/commands/tm/clear-subtasks/clear-all-subtasks.md (3)
34-53: Excellent safety measures for destructive operation.The double confirmation with explicit phrase requirement and clear warnings appropriately protect against accidental data loss.
81-93: Comprehensive post-operation reporting.The summary report provides valuable feedback on what was accomplished and suggests next steps.
1-93: Well-designed documentation for a destructive operation.The documentation appropriately emphasizes safety, provides multiple confirmation steps, includes backup procedures, and offers comprehensive reporting.
.cursor/rules/self_improve.mdc (1)
1-73: Well-structured continuous improvement guidelinesThe documentation provides a comprehensive framework for evolving Cursor rules based on real-world usage patterns. The content is logically organized with clear sections covering triggers, analysis, updates, quality checks, and maintenance.
.claude/commands/tm/workflows/auto-implement-tasks.md (1)
1-97: Comprehensive auto-implementation workflow documentationThe document provides excellent coverage of the auto-implementation process with clear phases, smart strategies based on task types, quality assurance steps, and recovery mechanisms.
.claude/commands/tm/add-task/add-task.md (1)
1-78: Well-designed task addition command documentationThe documentation excellently describes the intelligent parsing capabilities, provides clear examples of natural language to structured task conversion, and includes interactive refinement features. The YAML preview format effectively shows the task structure.
packages/cli/src/bin/ensemble.ts (3)
79-83: Good validation logic for mutually exclusive flags.The validation preventing simultaneous use of
--mineand--ownerflags is well-implemented and provides clear error messaging.
156-158: Proper handling of sensitive configuration data.Good practice to redact sensitive information like private keys before displaying configuration. This prevents accidental exposure of credentials.
86-102: WalletService.getWalletAddress only exposes the public address
ThegetWalletAddress(name)method simply reads the wallet file, parses its JSON, and returns the storedaddressfield—it does not decrypt or reveal any other data. It throws aWalletNotFoundErrorif the file is missing, and no sensitive fields (encryptedData,salt,iv, etc.) are ever exposed in its output or error messages.packages/cli/src/commands/validate.ts (2)
84-91: Good verbose output with agent details.The conditional verbose output provides useful debugging information while keeping default output concise. The agent property access assumes a consistent agent record structure.
113-116: Validation Implementation VerifiedThe
validateAgentRecordYAMLfunction correctly implements the requested checks:
- Ensures the file exists and reports a “File not found” error if it does not.
- Parses YAML with
yamlParse, catching and reporting parsing errors.- Validates required fields (
name,description,category) and their types.- Checks optional arrays/objects (
attributes,instructions,prompts,communication,socials) and their contents.- Applies business‐rule warnings (length limits, category suggestions, etc.) when
schemaOnlyis false.- When
checkUrlsis true, attempts HTTP HEAD requests (with timeout) on configured URL fields, reporting inaccessible or non‐2xx responses as warnings and invalid URL syntaxes as errors.No gaps were found in YAML structure validation, required‐field enforcement, or URL accessibility logic.
.claude/commands/tm/setup/install-taskmaster.md (2)
55-61: Good guidance on API key configuration.The documentation properly lists the required API keys and provides clear guidance on where to set them. This helps users understand the prerequisites before proceeding.
76-84: Helpful permission troubleshooting.The permission error solutions cover both sudo installation and fixing npm permissions globally. The npm prefix configuration is a good alternative to sudo.
packages/cli/src/commands/agents/get.ts (1)
64-67: Good file saving implementation.The conditional file saving with user feedback is well-implemented. The use of a configurable prefix for saved files provides good flexibility.
.claude/commands/tm/add-subtask/convert-task-to-subtask.md (2)
26-36: Comprehensive validation checklist.The pre-conversion validation steps are thorough and address important concerns like circular dependencies and logical hierarchy. This helps prevent common issues with task management systems.
40-45: Clear conversion process steps.The step-by-step conversion process is well-documented and covers important aspects like ID updates, dependency maintenance, and priority inheritance.
packages/cli/src/utils/formatters.ts (1)
6-47: Well-implemented CSV formatting with proper escapingThe CSV formatting implementation correctly handles edge cases including nested objects, special characters, and proper escaping. Good defensive programming with empty data checks.
packages/cli/src/commands/agents/update.ts (1)
125-135: Good practice: Cleaning undefined values before updateThe implementation correctly removes undefined values to prevent accidentally overwriting fields with undefined. This is a good defensive programming practice.
packages/cli/src/commands/agents/register.ts (2)
26-48: Excellent validation flow with clear user feedbackThe validation implementation provides great user experience with:
- Clear separation of errors and warnings
- Detailed error messages with bullet points
- Spinner feedback during validation
- URL checking enabled for comprehensive validation
145-148: Excellent error handling with actionable suggestionsThe error handling provides great user experience by:
- Detecting specific error conditions (agent already registered)
- Providing actionable suggestions (use update command instead)
- Including the exact command to run
This is a great example of user-friendly CLI design.
.cursor/rules/taskmaster/taskmaster.mdc (1)
1-17: Excellent documentation structure and user expectations setting.The frontmatter metadata is well-defined and the upfront explanation of AI processing times and tagged task lists provides crucial context for users. The structure clearly establishes this as a comprehensive reference document.
.taskmaster/docs/prd.txt (4)
1-27: Strong executive summary and vision articulation.The executive summary clearly defines the Ensemble Framework's purpose and scope. The vision and goals are well-articulated and ambitious yet focused. Target user identification is comprehensive and will help guide feature prioritization.
144-393: Excellent CLI specifications with sound architectural principles.The CLI command specifications are comprehensive with clear usage examples and options. The architectural requirement to use existing SDK/API layers rather than direct blockchain access is a smart design decision that promotes maintainability and consistency.
The Agent Record YAML schema is well-defined and includes good examples that will help users understand the expected structure.
394-466: Well-defined API specifications and comprehensive technical architecture.The REST API endpoints are clearly specified with appropriate functionality for agent management and discovery. The technical architecture requirements appropriately address key concerns like scalability, security, and blockchain integration.
The forward-looking approach with cross-chain compatibility and regulatory compliance considerations shows good strategic planning.
467-533: Strategic planning sections demonstrate thorough project management.The success metrics are well-categorized and measurable, providing clear targets for evaluation. The phased implementation approach is realistic and allows for iterative development. Risk mitigation covers key areas comprehensively.
The conclusion effectively ties together the vision and technical requirements, reinforcing the project's ambitious but achievable goals.
.cursor/rules/taskmaster/dev_workflow.mdc (3)
1-48: Excellent workflow foundation with clear AI agent guidance.The introduction effectively establishes the default approach (master context) while setting up the framework for more advanced workflows. The 8-step basic loop provides a clear, repeatable process that covers the essential development cycle.
The guidance for AI agents about when to suggest advanced features is particularly valuable and shows thoughtful design.
49-188: Sophisticated pattern-based approach to workflow escalation.The pattern-based system for identifying when to introduce tagged task lists is excellent. Each pattern includes clear triggers, suggested responses, and practical examples. The progression from simple git branching to complex PRD-driven development shows good understanding of real-world development scenarios.
The master list strategy section provides valuable guidance on maintaining focus on high-value deliverables while using tags for detailed work.
189-270: Clear technical guidance and system architecture explanation.The comparison between MCP server and CLI interaction methods is well-explained with clear recommendations for when to use each. The tag system explanation provides good technical context without being overly complex.
The task structure field definitions are comprehensive and will serve as a valuable reference during development.
packages/cli/src/types/wallet.ts (2)
80-85: Solid base error class implementation.The
WalletErrorbase class follows standard error handling patterns with appropriate optional properties for error codes and causes. The constructor properly calls super and sets the name property.
87-120: Comprehensive error class hierarchy with good coverage.The specific error classes provide excellent coverage of common wallet error scenarios. Each class has descriptive names, appropriate error codes, and focused constructors. The inheritance from
WalletErrormaintains consistency while providing specific error types for proper error handling.The error scenarios covered (not found, already exists, invalid credentials) represent the most common wallet operation failures.
| #### 🚀 Setup & Installation | ||
| - `/project:tm/setup/install` - Comprehensive installation guide | ||
| - `/project:tm/setup/quick-install` - One-line global install | ||
|
|
||
| #### 📋 Project Setup | ||
| - `/project:tm/init` - Initialize new project | ||
| - `/project:tm/init/quick` - Quick setup with auto-confirm | ||
| - `/project:tm/models` - View AI configuration | ||
| - `/project:tm/models/setup` - Configure AI providers | ||
|
|
||
| #### 🎯 Task Generation | ||
| - `/project:tm/parse-prd` - Generate tasks from PRD | ||
| - `/project:tm/parse-prd/with-research` - Enhanced parsing | ||
| - `/project:tm/generate` - Create task files | ||
|
|
||
| #### 📝 Task Management | ||
| - `/project:tm/list` - List tasks (natural language filters) | ||
| - `/project:tm/show <id>` - Display task details | ||
| - `/project:tm/add-task` - Create new task | ||
| - `/project:tm/update` - Update tasks naturally | ||
| - `/project:tm/next` - Get next task recommendation | ||
|
|
||
| #### 🔄 Status Management | ||
| - `/project:tm/set-status/to-pending <id>` | ||
| - `/project:tm/set-status/to-in-progress <id>` | ||
| - `/project:tm/set-status/to-done <id>` | ||
| - `/project:tm/set-status/to-review <id>` | ||
| - `/project:tm/set-status/to-deferred <id>` | ||
| - `/project:tm/set-status/to-cancelled <id>` | ||
|
|
||
| #### 🔍 Analysis & Breakdown | ||
| - `/project:tm/analyze-complexity` - Analyze task complexity | ||
| - `/project:tm/expand <id>` - Break down complex task | ||
| - `/project:tm/expand/all` - Expand all eligible tasks | ||
|
|
||
| #### 🔗 Dependencies | ||
| - `/project:tm/add-dependency` - Add task dependency | ||
| - `/project:tm/remove-dependency` - Remove dependency | ||
| - `/project:tm/validate-dependencies` - Check for issues | ||
|
|
||
| #### 🤖 Workflows | ||
| - `/project:tm/workflows/smart-flow` - Intelligent workflows | ||
| - `/project:tm/workflows/pipeline` - Command chaining | ||
| - `/project:tm/workflows/auto-implement` - Auto-implementation | ||
|
|
||
| #### 📊 Utilities | ||
| - `/project:tm/utils/analyze` - Project analysis | ||
| - `/project:tm/status` - Project dashboard | ||
| - `/project:tm/learn` - Interactive learning | ||
|
|
There was a problem hiding this comment.
💡 Verification agent
🧩 Analysis chain
Verify all referenced commands exist in the documentation.
Ensure all commands listed in the help file have corresponding documentation files to prevent broken references.
🏁 Script executed:
#!/bin/bash
# Extract command paths from help.md and check if corresponding files exist
grep -o '/project:tm/[^ ]*' .claude/commands/tm/help.md | sed 's|/project:tm/|.claude/commands/tm/|g' | while read path; do
if [[ "$path" == *.md ]]; then
file="$path"
else
file="$path.md"
fi
if [[ ! -f "$file" ]]; then
echo "Missing documentation: $file"
fi
doneLength of output: 11006
🏁 Script executed:
#!/bin/bash
# Extract command paths (strip backticks) and check for corresponding .md files
grep -oE '`?/project:tm/[^` ]+' .claude/commands/tm/help.md \
| tr -d '\`' \
| sed 's|/project:tm/|.claude/commands/tm/|; s|$|.md|' \
| sort -u \
| while read file; do
if [[ ! -f "$file" ]]; then
echo "Missing documentation: $file"
fi
doneLength of output: 5372
Add missing documentation for referenced commands
The following commands are listed in .claude/commands/tm/help.md but lack corresponding markdown files under .claude/commands/tm/. Please create or add these documentation files to prevent broken links:
- .claude/commands/tm/add-dependency.md
- .claude/commands/tm/add-task.md
- .claude/commands/tm/analyze-complexity.md
- .claude/commands/tm/expand.md
- .claude/commands/tm/expand/all.md
- .claude/commands/tm/generate.md
- .claude/commands/tm/init.md
- .claude/commands/tm/init/quick.md
- .claude/commands/tm/list.md
- .claude/commands/tm/models.md
- .claude/commands/tm/models/setup.md
- .claude/commands/tm/next.md
- .claude/commands/tm/parse-prd.md
- .claude/commands/tm/parse-prd/with-research.md
- .claude/commands/tm/remove-dependency.md
- .claude/commands/tm/setup/install.md
- .claude/commands/tm/setup/quick-install.md
- .claude/commands/tm/show.md
- .claude/commands/tm/status.md
- .claude/commands/tm/update.md
- .claude/commands/tm/utils/analyze.md
- .claude/commands/tm/validate-dependencies.md
- .claude/commands/tm/workflows/auto-implement.md
- .claude/commands/tm/workflows/pipeline.md
- .claude/commands/tm/workflows/smart-flow.md
Once these files are in place, all help references will resolve correctly.
🤖 Prompt for AI Agents
In .claude/commands/tm/help.md lines 15 to 64, the help documentation references
many commands that lack corresponding markdown files in the .claude/commands/tm/
directory. To fix this, create the missing markdown files listed in the comment
for each referenced command, ensuring each file documents the command's usage
and details. This will prevent broken links and ensure all help references
resolve correctly.
| ```bash | ||
| task-master list --with-subtasks | ||
| ``` |
There was a problem hiding this comment.
💡 Verification agent
🧩 Analysis chain
Verify CLI command consistency across documentation.
Ensure the command syntax task-master list --with-subtasks is consistent with other documented commands in the framework.
🏁 Script executed:
#!/bin/bash
# Search for other task-master list command variations to ensure consistency
rg -A 2 -B 2 "task-master list" --type mdLength of output: 578
Ensure --with-subtasks is documented in the global CLI reference
The new task-master list --with-subtasks flag isn’t yet listed alongside other task-master list variants in CLAUDE.md. Please add it for consistency:
• File: CLAUDE.md
Under “Daily Development Workflow” (where task-master list appears), insert:
task-master list # Show all tasks with status
+ task-master list --with-subtasks # Show tasks including subtasks
task-master next # Get next available task to work on
task-master show <id> # View detailed task information📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| ```bash | |
| task-master list --with-subtasks | |
| ``` | |
| task-master list # Show all tasks with status | |
| task-master list --with-subtasks # Show tasks including subtasks | |
| task-master next # Get next available task to work on | |
| task-master show <id> # View detailed task information |
🤖 Prompt for AI Agents
In .claude/commands/tm/list/list-tasks-with-subtasks.md around lines 8 to 10,
the new CLI flag `--with-subtasks` for `task-master list` is not documented in
the global CLI reference file CLAUDE.md. To fix this, open CLAUDE.md, locate the
"Daily Development Workflow" section where `task-master list` variants are
listed, and add an entry describing the `--with-subtasks` flag to maintain
consistency and completeness of the documentation.
| "global": { | ||
| "logLevel": "info", | ||
| "debug": false, | ||
| "defaultNumTasks": 10, | ||
| "defaultSubtasks": 5, | ||
| "defaultPriority": "medium", | ||
| "projectName": "Taskmaster", | ||
| "ollamaBaseURL": "http://localhost:11434/api", | ||
| "bedrockBaseURL": "https://bedrock.us-east-1.amazonaws.com", | ||
| "responseLanguage": "English", | ||
| "defaultTag": "master", | ||
| "azureOpenaiBaseURL": "https://your-endpoint.openai.azure.com/", | ||
| "userId": "1234567890" | ||
| }, |
There was a problem hiding this comment.
🛠️ Refactor suggestion
Sensitive identifiers & defaults
Hard-coding "userId": "1234567890" (and other defaults) in VCS may leak PII or encourage copy-paste into downstream repos. Consider moving user-specific settings to a separate, git-ignored override file (e.g. config.local.json) or environment variables.
🤖 Prompt for AI Agents
In .taskmaster/config.json lines 22 to 35, the userId and other default values
are hard-coded, risking exposure of sensitive information. Remove user-specific
settings like userId from this file and move them to a separate git-ignored
override file such as config.local.json or configure them via environment
variables. Update the application to load these sensitive values from the new
location instead of the main config file.
| roots: ['<rootDir>/src'], | ||
| testMatch: ['**/__tests__/**/*.ts', '**/?(*.)+(spec|test).ts'], | ||
| moduleFileExtensions: ['ts', 'js', 'json', 'node'], |
There was a problem hiding this comment.
🛠️ Refactor suggestion
Limit-scoped roots may hide tests outside src/.
Setting roots: ['<rootDir>/src'] restricts Jest’s file discovery to src/. The PR description mentions scripts/ and top-level test helpers that won’t be executed or covered.
Extend roots (or drop it) so all package-local tests run.
- roots: ['<rootDir>/src'],
+ // Include package root to pick up tests in ./scripts, __mocks__, etc.
+ roots: ['<rootDir>/src', '<rootDir>'],📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| roots: ['<rootDir>/src'], | |
| testMatch: ['**/__tests__/**/*.ts', '**/?(*.)+(spec|test).ts'], | |
| moduleFileExtensions: ['ts', 'js', 'json', 'node'], | |
| // Include package root to pick up tests in ./scripts, __mocks__, etc. | |
| roots: ['<rootDir>/src', '<rootDir>'], | |
| testMatch: ['**/__tests__/**/*.ts', '**/?(*.)+(spec|test).ts'], | |
| moduleFileExtensions: ['ts', 'js', 'json', 'node'], |
🤖 Prompt for AI Agents
In packages/api/jest.config.js around lines 15 to 17, the Jest configuration
limits test discovery to the 'src/' directory by setting roots to
['<rootDir>/src'], which excludes tests in other directories like 'scripts/' and
top-level test helpers. To fix this, modify the roots array to include these
additional directories or remove the roots setting entirely to allow Jest to
discover tests throughout the entire package directory.
| "ethers": "^6.8.1", | ||
| "fastify": "^4.24.3" | ||
| }, |
There was a problem hiding this comment.
ethers@^6 is ESM-only – will break if your build outputs CommonJS
Version 6 of ethers publishes pure ES modules.
If tsc is left with its default "module": "CommonJS" (or you run node dist/index.js without "type": "module"), runtime ERR_REQUIRE_ESM errors will occur.
Fix options:
"main": "dist/index.js",
+ "type": "module", # switch the entire package to ESM …
+ "types": "dist/index.d.ts",and in tsconfig.json:
- "module": "CommonJS",
+ "module": "ES2022",OR lock to the CJS-compatible ethers@^5 until the repo is fully ESM ready.
Please align the build target & runtime before publishing.
Committable suggestion skipped: line range outside the PR's diff.
🤖 Prompt for AI Agents
In packages/api/package.json around lines 30 to 32, the ethers dependency is set
to version 6 which is ESM-only and incompatible with a CommonJS build output,
causing runtime errors. To fix this, either update tsconfig.json to set "module"
to "ESNext" or another ESM-compatible option and ensure package.json has "type":
"module" to support ESM at runtime, or alternatively downgrade ethers to version
5 which supports CommonJS until the project fully supports ESM.
| .filter(([_, value]) => value && value !== '') | ||
| .map(([key, value]) => `${key}: ${value}`); | ||
|
|
||
| return socialEntries.join('\\n'); |
There was a problem hiding this comment.
Fix incorrect newline escape sequence
The escape sequence should be \n not \\n to properly render newlines.
- return socialEntries.join('\\n');
+ return socialEntries.join('\n');📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| return socialEntries.join('\\n'); | |
| return socialEntries.join('\n'); |
🤖 Prompt for AI Agents
In packages/cli/src/utils/formatters.ts at line 160, the code uses an incorrect
newline escape sequence '\\n' which results in a literal backslash and n instead
of a newline. Replace '\\n' with '\n' in the join method to correctly render
newlines between socialEntries.
| let output = chalk.red(`❌ Error: ${error.message}`); | ||
|
|
||
| if (verbose && error.stack) { | ||
| output += '\\n' + chalk.gray(error.stack); |
There was a problem hiding this comment.
Fix incorrect newline escape sequence in error formatting
The escape sequence should be \n not \\n.
- output += '\\n' + chalk.gray(error.stack);
+ output += '\n' + chalk.gray(error.stack);📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| output += '\\n' + chalk.gray(error.stack); | |
| output += '\n' + chalk.gray(error.stack); |
🤖 Prompt for AI Agents
In packages/cli/src/utils/formatters.ts at line 167, the newline escape sequence
in the error formatting is incorrectly written as '\\n'. Replace the double
backslash with a single backslash to correctly use '\n' for a newline character
in the string concatenation.
packages/cli/src/utils/sdk.ts
Outdated
| export async function createSDKInstance(): Promise<Ensemble> { | ||
| const config = await getConfig(); | ||
|
|
||
| // Create provider | ||
| const provider = new ethers.JsonRpcProvider(config.rpcUrl); | ||
|
|
||
| // Create signer if private key is available | ||
| let signer: ethers.Signer; | ||
| if (config.privateKey) { | ||
| signer = new ethers.Wallet(config.privateKey, provider); | ||
| } else { | ||
| // Use a dummy signer for read-only operations | ||
| signer = ethers.Wallet.createRandom().connect(provider); | ||
| } | ||
|
|
||
| // Create ensemble config | ||
| const ensembleConfig = { | ||
| taskRegistryAddress: config.contracts.taskRegistry, | ||
| agentRegistryAddress: config.contracts.agentRegistry, | ||
| serviceRegistryAddress: config.contracts.serviceRegistry, | ||
| network: { | ||
| chainId: config.network === 'mainnet' ? 8453 : 84532, // Base mainnet : Base Sepolia | ||
| name: config.network, | ||
| rpcUrl: config.rpcUrl | ||
| }, | ||
| subgraphUrl: config.subgraphUrl | ||
| }; | ||
|
|
||
| return Ensemble.create(ensembleConfig, signer); | ||
| } |
There was a problem hiding this comment.
🛠️ Refactor suggestion
Add error handling for SDK creation.
The function lacks error handling for potential failures during SDK creation, provider connection, or signer setup, which could lead to unhandled promise rejections.
Consider wrapping the SDK creation in a try-catch block:
export async function createSDKInstance(): Promise<Ensemble> {
+ try {
const config = await getConfig();
// ... existing code ...
return Ensemble.create(ensembleConfig, signer);
+ } catch (error) {
+ throw new Error(`Failed to create SDK instance: ${error.message}`);
+ }
}📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| export async function createSDKInstance(): Promise<Ensemble> { | |
| const config = await getConfig(); | |
| // Create provider | |
| const provider = new ethers.JsonRpcProvider(config.rpcUrl); | |
| // Create signer if private key is available | |
| let signer: ethers.Signer; | |
| if (config.privateKey) { | |
| signer = new ethers.Wallet(config.privateKey, provider); | |
| } else { | |
| // Use a dummy signer for read-only operations | |
| signer = ethers.Wallet.createRandom().connect(provider); | |
| } | |
| // Create ensemble config | |
| const ensembleConfig = { | |
| taskRegistryAddress: config.contracts.taskRegistry, | |
| agentRegistryAddress: config.contracts.agentRegistry, | |
| serviceRegistryAddress: config.contracts.serviceRegistry, | |
| network: { | |
| chainId: config.network === 'mainnet' ? 8453 : 84532, // Base mainnet : Base Sepolia | |
| name: config.network, | |
| rpcUrl: config.rpcUrl | |
| }, | |
| subgraphUrl: config.subgraphUrl | |
| }; | |
| return Ensemble.create(ensembleConfig, signer); | |
| } | |
| export async function createSDKInstance(): Promise<Ensemble> { | |
| try { | |
| const config = await getConfig(); | |
| // Create provider | |
| const provider = new ethers.JsonRpcProvider(config.rpcUrl); | |
| // Create signer if private key is available | |
| let signer: ethers.Signer; | |
| if (config.privateKey) { | |
| signer = new ethers.Wallet(config.privateKey, provider); | |
| } else { | |
| // Use a dummy signer for read-only operations | |
| signer = ethers.Wallet.createRandom().connect(provider); | |
| } | |
| // Create ensemble config | |
| const ensembleConfig = { | |
| taskRegistryAddress: config.contracts.taskRegistry, | |
| agentRegistryAddress: config.contracts.agentRegistry, | |
| serviceRegistryAddress: config.contracts.serviceRegistry, | |
| network: { | |
| chainId: config.network === 'mainnet' ? 8453 : 84532, // Base mainnet : Base Sepolia | |
| name: config.network, | |
| rpcUrl: config.rpcUrl | |
| }, | |
| subgraphUrl: config.subgraphUrl | |
| }; | |
| return Ensemble.create(ensembleConfig, signer); | |
| } catch (error: any) { | |
| throw new Error(`Failed to create SDK instance: ${error.message}`); | |
| } | |
| } |
🤖 Prompt for AI Agents
In packages/cli/src/utils/sdk.ts from lines 5 to 34, the createSDKInstance
function lacks error handling for failures during SDK creation, provider
connection, or signer setup. Wrap the entire function body in a try-catch block
to catch any errors thrown during these asynchronous operations. In the catch
block, log or rethrow the error appropriately to prevent unhandled promise
rejections and provide clearer failure diagnostics.
|
|
||
| try { | ||
| agentRecord = yamlParse(fileContent); | ||
| } catch (parseError: any) { |
There was a problem hiding this comment.
🛠️ Refactor suggestion
Improve type safety in error handling
Replace any type with proper error types to maintain TypeScript's type safety benefits.
- } catch (parseError: any) {
+ } catch (parseError: unknown) {
result.errors.push(`YAML parsing error: ${parseError.message}`);
+ result.errors.push(`YAML parsing error: ${parseError instanceof Error ? parseError.message : String(parseError)}`);- } catch (error: any) {
+ } catch (error: unknown) {
- result.errors.push(`Validation error: ${error.message}`);
+ result.errors.push(`Validation error: ${error instanceof Error ? error.message : String(error)}`);Also applies to: 59-59
🤖 Prompt for AI Agents
In packages/cli/src/utils/validation.ts at lines 41 and 59, replace the use of
the `any` type in the catch clauses with a more specific error type such as
`unknown` or `Error`. Update the error handling logic accordingly to safely
handle the error object, for example by using type guards or assertions, to
maintain TypeScript's type safety benefits.
| return result; | ||
| } | ||
|
|
||
| function validateSchema(agentRecord: any, result: ValidationResult): void { |
There was a problem hiding this comment.
🛠️ Refactor suggestion
Use proper typing instead of any
The agentRecord parameter should use the AgentRecordYAML type for better type safety and IDE support.
-function validateSchema(agentRecord: any, result: ValidationResult): void {
+function validateSchema(agentRecord: AgentRecordYAML, result: ValidationResult): void {🤖 Prompt for AI Agents
In packages/cli/src/utils/validation.ts at line 68, replace the type of the
parameter agentRecord from any to AgentRecordYAML to improve type safety and
enable better IDE support. Ensure the AgentRecordYAML type is imported or
defined in the file before using it.
| ```bash | ||
| curl -X GET "https://api.ensemble.ai/v1/agents/agent-123?include=proposals" \ |
There was a problem hiding this comment.
Documentation: Fix query parameter reference
The example shows include=proposals but this parameter is not documented in the endpoint specification.
Either add the include parameter to the endpoint specification for "Get Agent Details" or remove it from the example.
🤖 Prompt for AI Agents
In .taskmaster/docs/agent-api-endpoints.md around lines 476 to 477, the example
curl command uses the query parameter `include=proposals` which is not
documented in the "Get Agent Details" endpoint specification. To fix this,
either add the `include` parameter with its description to the endpoint
specification or remove the `include=proposals` part from the example curl
command to keep the documentation consistent.
| name: 'privateKey', | ||
| message: 'Enter private key:', | ||
| mask: '*', | ||
| validate: (input: string) => { | ||
| if (!input.trim()) { | ||
| return 'Private key is required'; | ||
| } | ||
| return true; | ||
| } | ||
| } | ||
| ]); | ||
| importData.privateKey = privateKey; |
There was a problem hiding this comment.
Security: Private key is exposed in memory
The private key is stored in a variable and could potentially be logged or exposed. Consider clearing it after use.
const { privateKey } = await inquirer.prompt([
{
type: 'password',
name: 'privateKey',
message: 'Enter private key:',
mask: '*',
validate: (input: string) => {
if (!input.trim()) {
return 'Private key is required';
}
return true;
}
}
]);
importData.privateKey = privateKey;
+// Clear the private key from memory after use
+setTimeout(() => {
+ if (importData.privateKey) {
+ importData.privateKey = '';
+ }
+}, 0);📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| name: 'privateKey', | |
| message: 'Enter private key:', | |
| mask: '*', | |
| validate: (input: string) => { | |
| if (!input.trim()) { | |
| return 'Private key is required'; | |
| } | |
| return true; | |
| } | |
| } | |
| ]); | |
| importData.privateKey = privateKey; | |
| name: 'privateKey', | |
| message: 'Enter private key:', | |
| mask: '*', | |
| validate: (input: string) => { | |
| if (!input.trim()) { | |
| return 'Private key is required'; | |
| } | |
| return true; | |
| } | |
| } | |
| ]); | |
| importData.privateKey = privateKey; | |
| // Clear the private key from memory after use | |
| setTimeout(() => { | |
| if (importData.privateKey) { | |
| importData.privateKey = ''; | |
| } | |
| }, 0); |
🤖 Prompt for AI Agents
In packages/cli/src/commands/wallet.ts around lines 239 to 250, the private key
is stored in a variable which risks exposure in memory. After using the
privateKey variable (e.g., after assigning it to importData.privateKey),
explicitly overwrite or clear the privateKey variable to remove sensitive data
from memory and reduce the risk of accidental exposure.
| export interface WalletManager { | ||
| createWallet(options: WalletCreateOptions): Promise<{ address: string; mnemonic?: string }>; | ||
| importWallet(options: WalletImportOptions): Promise<{ address: string }>; | ||
| listWallets(): Promise<WalletData[]>; | ||
| exportWallet(options: WalletExportOptions): Promise<string>; | ||
| deleteWallet(name: string, password: string): Promise<boolean>; | ||
| getWalletAddress(name: string): Promise<string>; | ||
| getWalletSigner(name: string, password: string): Promise<any>; | ||
| getBalance(nameOrAddress: string): Promise<WalletBalance>; | ||
| getTransactionHistory(nameOrAddress: string, limit?: number): Promise<Transaction[]>; | ||
| } |
There was a problem hiding this comment.
🛠️ Refactor suggestion
Comprehensive WalletManager interface with good async design.
The interface covers all essential wallet operations with appropriate async signatures. The method organization is logical and provides good separation of concerns.
Improve type safety for getWalletSigner method:
- getWalletSigner(name: string, password: string): Promise<any>;
+ getWalletSigner(name: string, password: string): Promise<ethers.Signer>;Using any reduces type safety. If ethers is not available in this context, consider defining a minimal Signer interface or using a generic type parameter.
Committable suggestion skipped: line range outside the PR's diff.
🤖 Prompt for AI Agents
In packages/cli/src/types/wallet.ts around lines 68 to 78, the getWalletSigner
method currently returns a Promise<any>, which reduces type safety. To fix this,
replace the any type with a more specific type by either importing the Signer
type from ethers if available or defining a minimal Signer interface locally.
Alternatively, use a generic type parameter to represent the signer type,
ensuring stronger type safety and better code clarity.
There was a problem hiding this comment.
Actionable comments posted: 2
🔭 Outside diff range comments (3)
packages/sdk/README.md (2)
190-193: Removenewand await the async factory
Ensemble.create()is already a (promise-returning) static factory – instantiating it withnewwill throw at runtime.
Update the snippet to await the factory result instead.-const ensemble = new Ensemble.create(config, signer); +const ensemble = await Ensemble.create(config, signer);
161-168: Missingethersimport in exampleThe helper uses
ethers.JsonRpcProviderbut the snippet forgets to import the library, so developers copy-pasting this will hitReferenceError: ethers is not defined.-import { Ensemble } from "@ensemble-ai/sdk"; +import { Ensemble } from "@ensemble-ai/sdk"; +import { ethers } from "ethers";packages/sdk/package.json (1)
29-30: Duplicatejestentry bloats install size
jestappears under bothdependencies(lines 29-30) anddevDependencies(line 40). Keep it only indevDependencies; end-users of the SDK don’t need Jest at runtime.- "jest": "^29.7.0",Also applies to: 40-40
🧹 Nitpick comments (7)
packages/sdk/README.md (2)
67-68: Grammar & clarity pass“This approach useful because you test the SDK againt a local network, which is fast and cheap and do not require mocking the contracts.”
Minor language issues make this section harder to read. Consider:
“This approach is useful because you can test the SDK against a local network, which is fast, cheap, and eliminates the need to mock contracts.”
203-214: Typos in task-execution walkthroughSeveral misspellings may confuse readers (
receieved,Optionaly,propmpt,tas,wrtie,Competing). A quick clean-up keeps the docs polished.- console.log(`receieved a new task ${task.id} to the agent proposal ${task.proposalId} by user ${task.issuer}`) - // TODO: Optionaly validate the task and propmpt - // Task Execution - // This is a KOL tas to wrtie a tweet about the topic, so twitter client is used + console.log(`received a new task ${task.id} for proposal ${task.proposalId} by user ${task.issuer}`) + // TODO: Optionally validate the task and prompt + // Task execution + // This is a KOL task to write a tweet about the topic, so a Twitter client is used ... - // Competing the task with a result + // Completing the task with a resultpackages/sdk/package.json (1)
3-3: Add matching CHANGELOG entry for 0.5.0 bumpThe version has been incremented to
0.5.0, but I don’t see a corresponding CHANGELOG update in this PR. Keeping the log in sync prevents release-time confusion.packages/api/.env.production.example (1)
25-25: Add a terminating newline to satisfy POSIX tools
Several linters (andgit diff) warn when the final line of a text file is not newline-terminated.-# SENTRY_DSN=your-sentry-dsn +# SENTRY_DSN=your-sentry-dsn +packages/api/apprunner.yaml (1)
18-37: Remove trailing whitespace & ensure newline EOF to keep YAML parsers and linters quiet
Trailing spaces don’t break YAML but clutter diffs and tripyamllint. The file also lacks a newline at EOF.-\ No newline at end of file +18 +23 +26 +29 +32 +35 +packages/api/Dockerfile (1)
58-60: Avoid re-installing dependencies in the prod stage – copynode_modulesfrom builder
pnpm install --prodredownloads the entire dependency graph, lengthening builds and opening a second attack surface. Because the builder already produced a pruned store, you can simply copy it:-# Install production dependencies only -RUN pnpm install --prod --frozen-lockfile +# Copy pruned production dependencies from builder +COPY --chown=ensemble:nodejs --from=builder /app/node_modules ./node_modulesYou may need to
RUN pnpm prune --prodin the builder right afterpnpm installto keep only runtime deps.packages/api/DEPLOYMENT.md (1)
79-83: Specify a language for fenced code block to silence MD040 and enable syntax highlighting-``` +```bash JWT_SECRET=your-secure-jwt-secret-256-bits NETWORK_RPC_URL=https://base-sepolia.g.alchemy.com/v2/YOUR_ALCHEMY_KEY
📜 Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro
📒 Files selected for processing (7)
packages/api/.dockerignore(1 hunks)packages/api/.env.production.example(1 hunks)packages/api/DEPLOYMENT.md(1 hunks)packages/api/Dockerfile(1 hunks)packages/api/apprunner.yaml(1 hunks)packages/sdk/README.md(3 hunks)packages/sdk/package.json(2 hunks)
✅ Files skipped from review due to trivial changes (1)
- packages/api/.dockerignore
🧰 Additional context used
🪛 dotenv-linter (3.3.0)
packages/api/.env.production.example
[warning] 3-3: [UnorderedKey] The NODE_ENV key should go before the PORT key
[warning] 10-10: [UnorderedKey] The AGENT_REGISTRY_ADDRESS key should go before the NETWORK_RPC_URL key
[warning] 25-25: [EndingBlankLine] No blank line at the end of the file
🪛 markdownlint-cli2 (0.17.2)
packages/api/DEPLOYMENT.md
79-79: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
🪛 YAMLlint (1.37.1)
packages/api/apprunner.yaml
[error] 18-18: trailing spaces
(trailing-spaces)
[error] 23-23: trailing spaces
(trailing-spaces)
[error] 26-26: trailing spaces
(trailing-spaces)
[error] 29-29: trailing spaces
(trailing-spaces)
[error] 32-32: trailing spaces
(trailing-spaces)
[error] 35-35: trailing spaces
(trailing-spaces)
[error] 37-37: no new line character at the end of file
(new-line-at-end-of-file)
🔇 Additional comments (2)
packages/sdk/README.md (1)
403-410: Confirm return shape ofupdateAgentRecordThe snippet assumes a
successboolean on the result, but the earlier examples only show{ transactionHash, gasUsed }.
Please double-check the SDK typings; ifsuccessisn’t emitted, update the example accordingly or document the field.packages/api/.env.production.example (1)
6-6: Provide a real, high-entropy JWT secret before deploying
The placeholder value makes it too easy to forget to rotate in a proper secret and risks committing it to version control. Generate a 256-bit random secret via a password manager oropenssl rand -hex 32and inject it through your secret-manager/CI rather than the file.
packages/api/apprunner.yaml
Outdated
| network: | ||
| port: 3000 | ||
| env: PORT | ||
| env: |
There was a problem hiding this comment.
PORT env var referenced but never defined – App Runner will inject nothing
network.env: PORT tells App Runner to read the container port from an environment variable called PORT, yet the env: block below omits it. At runtime the service may fail health-checks or bind to the wrong port.
env:
+ - name: PORT
+ value: "3000"📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| network: | |
| port: 3000 | |
| env: PORT | |
| env: | |
| network: | |
| port: 3000 | |
| env: PORT | |
| env: | |
| - name: PORT | |
| value: "3000" |
🤖 Prompt for AI Agents
In packages/api/apprunner.yaml around lines 11 to 14, the environment variable
PORT is referenced under network.env but not defined in the env: section below.
To fix this, add a definition for the PORT environment variable in the env:
block, setting its value to 3000 or the appropriate port number to ensure App
Runner correctly injects and uses the port at runtime.
| "watch": "tsc --watch", | ||
| "test": "jest --verbose", | ||
| "test:agent": "jest test/agentService.test.ts", | ||
| "test:integration": "npx tsx scripts/test-agent-methods.ts", | ||
| "typecheck": "tsc --noEmit", |
There was a problem hiding this comment.
test:integration will fail without a local tsx binary
npx can fetch packages on-the-fly, but relying on that causes network-bound flakiness and hides version drift. Add tsx to devDependencies and pin a version to keep CI deterministic.
"devDependencies": {
+ "tsx": "^4.7.0",
"@babel/preset-typescript": "^7.26.0",🤖 Prompt for AI Agents
In packages/sdk/package.json around lines 13 to 17, the "test:integration"
script uses "npx tsx" which depends on fetching the tsx binary at runtime,
causing potential network issues and version inconsistencies. To fix this, add
"tsx" as a pinned version dependency under "devDependencies" in package.json,
ensuring the binary is locally installed and CI runs deterministically without
network dependency.
There was a problem hiding this comment.
Actionable comments posted: 1
♻️ Duplicate comments (1)
packages/api/apprunner.yaml (1)
20-23:PORTvariable still undefined – previous comment not resolved
network.env: PORTrequires an env var namedPORT, but theenv:list below omits it. App Runner won’t know which port the container exposes and health-checks will fail.env: + - name: PORT + value: "3000"
🧹 Nitpick comments (2)
packages/api/apprunner.yaml (1)
24-46: Trailing whitespace and missing newline at EOFYAML linters flag six trailing-space occurrences (27, 32, 35, 38, 41, 44) and the missing final newline. These won’t break execution but do fail CI lint jobs.
-27·· +27 @@ -32·· +32 @@ -35·· +35 @@ -38·· +38 @@ -41·· +41 @@ -44·· +44 + +# (add one blank line at EOF)packages/api/DEPLOYMENT.md (1)
78-82: Add a language identifier to fenced code blocks for MD lint compliance
markdownlintflags the block without a language spec. Usebash,dotenv, or similar:- ``` + ```env JWT_SECRET=your-secure-jwt-secret-256-bits NETWORK_RPC_URL=https://base-sepolia.g.alchemy.com/v2/YOUR_ALCHEMY_KEY ```Apply the same fix to other unlabeled code fences elsewhere in the document.
📜 Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro
📒 Files selected for processing (3)
packages/api/DEPLOYMENT.md(1 hunks)packages/api/Dockerfile.apprunner(1 hunks)packages/api/apprunner.yaml(1 hunks)
✅ Files skipped from review due to trivial changes (1)
- packages/api/Dockerfile.apprunner
🧰 Additional context used
🪛 markdownlint-cli2 (0.17.2)
packages/api/DEPLOYMENT.md
79-79: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
🪛 YAMLlint (1.37.1)
packages/api/apprunner.yaml
[error] 27-27: trailing spaces
(trailing-spaces)
[error] 32-32: trailing spaces
(trailing-spaces)
[error] 35-35: trailing spaces
(trailing-spaces)
[error] 38-38: trailing spaces
(trailing-spaces)
[error] 41-41: trailing spaces
(trailing-spaces)
[error] 44-44: trailing spaces
(trailing-spaces)
[error] 46-46: no new line character at the end of file
(new-line-at-end-of-file)
packages/api/apprunner.yaml
Outdated
| - cd ../../packages/sdk && pnpm build | ||
| # Build API | ||
| - cd ../api && pnpm build |
There was a problem hiding this comment.
Build paths ascend outside the repository and will break the image build
After pre-build you’re already at the repo root (cd ../..).
cd ../../packages/sdk therefore walks two more levels up (outside the repo), so the following pnpm build will run in a non-existent directory and the build will fail in App Runner.
- - cd ../../packages/sdk && pnpm build
- # Build API
- - cd ../api && pnpm build
+ # Build SDK (workspace root → packages/sdk)
+ - cd packages/sdk && pnpm build
+ # Build API
+ - cd ../api && pnpm buildConsider using pnpm --filter to avoid cd gymnastics altogether.
📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| - cd ../../packages/sdk && pnpm build | |
| # Build API | |
| - cd ../api && pnpm build | |
| # Build SDK (workspace root → packages/sdk) | |
| - cd packages/sdk && pnpm build | |
| # Build API | |
| - cd ../api && pnpm build |
🤖 Prompt for AI Agents
In packages/api/apprunner.yaml around lines 14 to 16, the build commands use
relative paths that ascend outside the repository root, causing the build to
fail. Replace the current 'cd' commands with 'pnpm --filter' commands to run the
build scripts directly in the target packages without changing directories. This
avoids navigating outside the repo and ensures the build runs correctly within
App Runner.
There was a problem hiding this comment.
Actionable comments posted: 1
♻️ Duplicate comments (1)
packages/api/apprunner.yaml (1)
26-31:PORTenvironment variable still undefined
network.env: PORTexpects aPORTentry underenv:but it is absent, so the service won’t expose the intended port at runtime.26 port: 3000 27 env: PORT 28 env: + - name: PORT + value: "3000"
🧹 Nitpick comments (1)
packages/api/apprunner.yaml (1)
20-51: Trailing whitespace and missing EOF newline flagged by yamllint
Several lines contain stray spaces (e.g., 20, 32, 37, 40, 43, 46, 49) and the file lacks a terminating newline. Clean these up to keep CI linters green.
📜 Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro
📒 Files selected for processing (3)
packages/api/Dockerfile.apprunner(1 hunks)packages/api/apprunner.yaml(1 hunks)packages/sdk/tsconfig.json(1 hunks)
✅ Files skipped from review due to trivial changes (2)
- packages/sdk/tsconfig.json
- packages/api/Dockerfile.apprunner
🧰 Additional context used
🪛 YAMLlint (1.37.1)
packages/api/apprunner.yaml
[error] 20-20: trailing spaces
(trailing-spaces)
[error] 32-32: trailing spaces
(trailing-spaces)
[error] 37-37: trailing spaces
(trailing-spaces)
[error] 40-40: trailing spaces
(trailing-spaces)
[error] 43-43: trailing spaces
(trailing-spaces)
[error] 46-46: trailing spaces
(trailing-spaces)
[error] 49-49: trailing spaces
(trailing-spaces)
[error] 51-51: no new line character at the end of file
(new-line-at-end-of-file)
packages/api/apprunner.yaml
Outdated
| # Get to repository root using absolute path resolution | ||
| - export REPO_ROOT=$(pwd)/../../ | ||
| - cd $REPO_ROOT | ||
| # Install all workspace dependencies | ||
| - pnpm install --frozen-lockfile | ||
| build: | ||
| # Set repository root path | ||
| - export REPO_ROOT=$(pwd)/../../ | ||
| # Build SDK package first (required dependency) | ||
| - cd $REPO_ROOT/packages/sdk | ||
| - pnpm build | ||
| # Build API package | ||
| - cd $REPO_ROOT/packages/api |
There was a problem hiding this comment.
🛠️ Refactor suggestion
Build context escapes the repository – will break image build
export REPO_ROOT=$(pwd)/../../ climbs two directories above the repo root, so every subsequent cd $REPO_ROOT/... runs outside the checkout. App Runner won’t find packages/sdk or packages/api, causing the build to fail.
- - export REPO_ROOT=$(pwd)/../../
- - cd $REPO_ROOT
+ # We are already at the repo root – no need to ascend
+ - export REPO_ROOT=$(pwd)Even better, drop the manual cd gymnastics and rely on pnpm --filter:
- - cd $REPO_ROOT/packages/sdk
- - pnpm build
- - cd $REPO_ROOT/packages/api
- - pnpm build
+ - pnpm --filter "./packages/sdk" build
+ - pnpm --filter "./packages/api" buildCommittable suggestion skipped: line range outside the PR's diff.
🧰 Tools
🪛 YAMLlint (1.37.1)
[error] 20-20: trailing spaces
(trailing-spaces)
🤖 Prompt for AI Agents
In packages/api/apprunner.yaml around lines 8 to 20, the build context is set
incorrectly by using 'export REPO_ROOT=$(pwd)/../../', which navigates outside
the repository root and causes subsequent 'cd' commands to fail. Remove the
manual directory changes and instead use 'pnpm --filter' commands to build the
specific packages directly within the correct context, avoiding path issues and
ensuring the build works inside the repository.
There was a problem hiding this comment.
Actionable comments posted: 0
🧹 Nitpick comments (3)
CLAUDE.md (3)
60-80: Add a language identifier to fenced code block (MD040).Markdown-lint flags this block because it starts with triple back-ticks but no language.
Adding a neutral identifier (text,none, or similar) resolves the warning and preserves syntax highlighting consistency.-``` +```text
312-315: Fix typo “Consdier” → “Consider”.Minor spelling error in workflow instructions.
-3. Use Taskmaster to expand the newly generated tasks into subtasks. Consdier using `analyze-complexity` with the correct --to and --from IDs (the new ids) to identify the ideal subtask amounts for each task. Then expand them. +3. Use Taskmaster to expand the newly generated tasks into subtasks. Consider using `analyze-complexity` with the correct --to and --from IDs (the new IDs) to identify the ideal subtask amounts for each task, then expand them.
168-170: Clarify heading wording “Multi-Claude Workflows”.The phrase is slightly ambiguous. Replacing with something like “Multi-session Claude workflows” may read more clearly to new users.
📜 Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro
⛔ Files ignored due to path filters (1)
packages/api/pnpm-lock.yamlis excluded by!**/pnpm-lock.yaml
📒 Files selected for processing (5)
CLAUDE.md(1 hunks)packages/api/Dockerfile(1 hunks)packages/api/package.json(1 hunks)packages/api/src/index.ts(1 hunks)packages/api/tsconfig.json(1 hunks)
🚧 Files skipped from review as they are similar to previous changes (4)
- packages/api/tsconfig.json
- packages/api/Dockerfile
- packages/api/src/index.ts
- packages/api/package.json
🧰 Additional context used
🪛 LanguageTool
CLAUDE.md
[grammar] ~168-~168: Ensure spelling is correct
Context: ...d= --status=done ``` #### 3. Multi-Claude Workflows For complex projects, use multiple Cla...
(QB_NEW_EN_ORTHOGRAPHY_ERROR_IDS_1)
[grammar] ~314-~314: Ensure spelling is correct
Context: ...he newly generated tasks into subtasks. Consdier using analyze-complexity with the cor...
(QB_NEW_EN_ORTHOGRAPHY_ERROR_IDS_1)
🪛 markdownlint-cli2 (0.17.2)
CLAUDE.md
60-60: Fenced code blocks should have a language specified
(MD040, fenced-code-language)
There was a problem hiding this comment.
Actionable comments posted: 5
🧹 Nitpick comments (12)
packages/api/scripts/build-and-push-ecr.sh (1)
24-27: Gracefully handle missing AWS/Docker CLIsIf either CLI is absent the script exits with a cryptic error.
Consider a quick pre-flight check:command -v aws >/dev/null 2>&1 || { echo "aws CLI not found"; exit 1; } command -v docker >/dev/null 2>&1 || { echo "docker not found"; exit 1; }Improves DX, especially in CI containers.
packages/cli/src/commands/agents/list.ts (3)
13-13: Add validation for status option values.The status option mentions specific allowed values (active, inactive, maintenance) but lacks validation to ensure only these values are accepted.
Consider adding validation:
-.option('--status <status>', 'Filter by agent status (active, inactive, maintenance)') +.option('--status <status>', 'Filter by agent status (active, inactive, maintenance)') +.addOption(new Option('--status <status>', 'Filter by agent status').choices(['active', 'inactive', 'maintenance']))
17-17: Consider parsing comma-separated attributes.The attributes option mentions comma-separated values but the parsing logic for splitting and processing them isn't implemented in the filter building section.
You may want to add parsing logic in the action handler around line 46 to split comma-separated attributes.
20-21: Add validation for sort options.The sort-by and sort-order options specify allowed values but lack validation.
Consider adding validation:
-.option('--sort-by <field>', 'Sort by field (reputation, name, created, updated)', 'reputation') -.option('--sort-order <order>', 'Sort order (asc, desc) (default: desc)', 'desc') +.addOption(new Option('--sort-by <field>', 'Sort by field').choices(['reputation', 'name', 'created', 'updated']).default('reputation')) +.addOption(new Option('--sort-order <order>', 'Sort order').choices(['asc', 'desc']).default('desc'))packages/cli/src/commands/agents.ts (1)
20-54: Consider making direct agent lookup output format configurable.The implementation is solid with good error handling and user feedback. However, the direct agent lookup always uses YAML format with full metadata, which might not always be desired.
Consider adding format options to the main command:
export const agentsCommand = new Command('agents') .description('Agent management commands') .argument('[address]', 'Agent address (optional - if provided, fetches specific agent)') .option('-h, --help', 'Display help information') + .option('--format <format>', 'Output format for direct agent lookup (table, json, csv, yaml)', 'yaml') + .option('--include-metadata', 'Include full metadata in output')Then update the action handler to use these options:
- const output = formatOutput([agent], 'yaml', true); + const output = formatOutput([agent], options.format || 'yaml', options.includeMetadata);Otherwise, the dynamic imports, error handling, and user guidance are well implemented.
.taskmaster/tasks/task_014.txt (1)
8-11: Add Fastify-specific Swagger tooling to keep the guidance consistent with the project stackThe list of recommended packages omits the Fastify plugins actually used in the codebase (
@fastify/swagger/@fastify/swagger-ui). This may confuse newcomers who will likely reach for the Express tooling listed here.- - For Node.js/Express: use swagger-jsdoc and swagger-ui-express + - For Node.js/Fastify: use @fastify/swagger and @fastify/swagger-ui + - For Node.js/Express: use swagger-jsdoc and swagger-ui-express.taskmaster/tasks/task_017.txt (1)
36-47: Strengthen quality gates by setting a minimum coverage thresholdThe Test Strategy covers many angles but never quantifies the expected code-coverage bar. Adding an explicit threshold (e.g.
--coverage --passWithNoTests --coverageThreshold) will prevent silent coverage regressions.No diff provided – coverage settings usually live in
jest.config.js..taskmaster/tasks/task_023.txt (1)
27-33: Call out the need for optimistic UI / progress feedback during long L2 confirmationsBlockchain writes can take several seconds. Consider adding a bullet to surface optimistic feedback (spinner, tx hash, block explorer link) so the CLI doesn’t appear frozen while waiting for confirmations.
.taskmaster/tasks/task_016.txt (1)
17-22: Clarify mapping between SDK errors and HTTP status codes“Return 400 for invalid parameters” and “404 for not found” are clear, but the bullet “503 for network issues” is broad.
Specify at least:
- 502 for upstream blockchain gateway errors
- 504 for timeout / transaction not mined in time
This guards against overloading 503 and helps clients handle failures precisely.
.taskmaster/tasks/task_022.txt (1)
76-76: Minor formatting inconsistencyLine 76 is missing the tilde (
~) marker that indicates it's a new/added line, unlike all other lines in the file..taskmaster/tasks/task_021.txt (1)
122-122: Minor formatting inconsistencyLine 122 is missing the tilde (
~) marker, consistent with the same issue in task_022.txt..taskmaster/tasks/task_020.txt (1)
108-108: Minor formatting inconsistencyLine 108 is missing the tilde (
~) marker, following the same pattern as other task files.
📜 Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro
⛔ Files ignored due to path filters (1)
packages/cli/pnpm-lock.yamlis excluded by!**/pnpm-lock.yaml
📒 Files selected for processing (27)
.taskmaster/docs/prd.txt(1 hunks).taskmaster/tasks/task_001.txt(1 hunks).taskmaster/tasks/task_003.txt(1 hunks).taskmaster/tasks/task_005.txt(1 hunks).taskmaster/tasks/task_006.txt(1 hunks).taskmaster/tasks/task_014.txt(1 hunks).taskmaster/tasks/task_016.txt(1 hunks).taskmaster/tasks/task_017.txt(1 hunks).taskmaster/tasks/task_020.txt(1 hunks).taskmaster/tasks/task_021.txt(1 hunks).taskmaster/tasks/task_022.txt(1 hunks).taskmaster/tasks/task_023.txt(1 hunks).taskmaster/tasks/tasks.json(1 hunks)packages/api/package.json(1 hunks)packages/api/scripts/build-and-push-ecr.sh(1 hunks)packages/cli/package.json(1 hunks)packages/cli/src/bin/ensemble.ts(1 hunks)packages/cli/src/commands/agents.ts(1 hunks)packages/cli/src/commands/agents/get.ts(1 hunks)packages/cli/src/commands/agents/list.ts(1 hunks)packages/cli/src/commands/agents/register.ts(1 hunks)packages/cli/src/commands/agents/update.ts(1 hunks)packages/cli/src/config/manager.ts(1 hunks)packages/cli/src/types/config.ts(1 hunks)packages/cli/src/utils/sdk.ts(1 hunks)packages/subgraph/src/agents-registry.ts(2 hunks)packages/subgraph/subgraph.yaml(1 hunks)
✅ Files skipped from review due to trivial changes (3)
- .taskmaster/tasks/task_006.txt
- packages/cli/package.json
- .taskmaster/tasks/task_003.txt
🚧 Files skipped from review as they are similar to previous changes (8)
- packages/cli/src/bin/ensemble.ts
- packages/cli/src/utils/sdk.ts
- packages/cli/src/types/config.ts
- packages/api/package.json
- .taskmaster/tasks/tasks.json
- packages/cli/src/commands/agents/register.ts
- packages/cli/src/config/manager.ts
- packages/cli/src/commands/agents/get.ts
🧰 Additional context used
🧠 Learnings (18)
📓 Common learnings
Learnt from: CR
PR: ensemble-codes/ensemble-framework#0
File: packages/contracts/.cursor/rules/project-intelligence.mdc:0-0
Timestamp: 2025-08-01T07:27:26.601Z
Learning: Applies to packages/contracts/test/EnsembleCredits*.sol : EnsembleCredits contract must have a comprehensive test suite covering edge cases, security scenarios, gas optimization, and integration with the registry system before deployment
📚 Learning: applies to packages/contracts/**/*.sol : implement comprehensive events for all significant state ch...
Learnt from: CR
PR: ensemble-codes/ensemble-framework#0
File: packages/contracts/.cursor/rules/role.mdc:0-0
Timestamp: 2025-08-01T07:27:59.616Z
Learning: Applies to packages/contracts/**/*.sol : Implement comprehensive events for all significant state changes.
Applied to files:
packages/subgraph/subgraph.yaml
📚 Learning: applies to packages/contracts/**/*.sol : use events for off-chain logging and indexing of important ...
Learnt from: CR
PR: ensemble-codes/ensemble-framework#0
File: packages/contracts/.cursor/rules/role.mdc:0-0
Timestamp: 2025-08-01T07:27:59.616Z
Learning: Applies to packages/contracts/**/*.sol : Use events for off-chain logging and indexing of important state changes.
Applied to files:
packages/subgraph/subgraph.yaml
📚 Learning: applies to packages/contracts/contracts/**/*.sol : all state changes in solidity contracts must emit...
Learnt from: CR
PR: ensemble-codes/ensemble-framework#0
File: packages/contracts/.cursor/rules/project-intelligence.mdc:0-0
Timestamp: 2025-08-01T07:27:26.601Z
Learning: Applies to packages/contracts/contracts/**/*.sol : All state changes in Solidity contracts must emit appropriate events
Applied to files:
packages/subgraph/subgraph.yaml
📚 Learning: applies to packages/contracts/test/ensemblecredits*.sol : ensemblecredits contract must have a compr...
Learnt from: CR
PR: ensemble-codes/ensemble-framework#0
File: packages/contracts/.cursor/rules/project-intelligence.mdc:0-0
Timestamp: 2025-08-01T07:27:26.601Z
Learning: Applies to packages/contracts/test/EnsembleCredits*.sol : EnsembleCredits contract must have a comprehensive test suite covering edge cases, security scenarios, gas optimization, and integration with the registry system before deployment
Applied to files:
.taskmaster/tasks/task_001.txt.taskmaster/tasks/task_017.txt.taskmaster/tasks/task_023.txt.taskmaster/tasks/task_016.txt.taskmaster/tasks/task_022.txt.taskmaster/tasks/task_021.txt.taskmaster/docs/prd.txt
📚 Learning: applies to packages/contracts/**/*.sol : design upgradeable contracts using proven patterns like the...
Learnt from: CR
PR: ensemble-codes/ensemble-framework#0
File: packages/contracts/.cursor/rules/role.mdc:0-0
Timestamp: 2025-08-01T07:27:59.616Z
Learning: Applies to packages/contracts/**/*.sol : Design upgradeable contracts using proven patterns like the proxy pattern when necessary.
Applied to files:
.taskmaster/tasks/task_001.txt
📚 Learning: maintain up-to-date api documentation for smart contracts....
Learnt from: CR
PR: ensemble-codes/ensemble-framework#0
File: packages/contracts/.cursor/rules/role.mdc:0-0
Timestamp: 2025-08-01T07:27:59.616Z
Learning: Maintain up-to-date API documentation for smart contracts.
Applied to files:
.taskmaster/tasks/task_001.txt.taskmaster/tasks/task_014.txt.taskmaster/docs/prd.txt
📚 Learning: applies to packages/contracts/test/*registry*.sol : all registry contracts must have extensive test ...
Learnt from: CR
PR: ensemble-codes/ensemble-framework#0
File: packages/contracts/.cursor/rules/project-intelligence.mdc:0-0
Timestamp: 2025-08-01T07:27:26.601Z
Learning: Applies to packages/contracts/test/*Registry*.sol : All registry contracts must have extensive test coverage, including edge cases and integration scenarios
Applied to files:
.taskmaster/tasks/task_001.txt.taskmaster/tasks/task_017.txt
📚 Learning: applies to packages/contracts/test/**/*{integration,ensemblecredits,registry}*.sol : integration tes...
Learnt from: CR
PR: ensemble-codes/ensemble-framework#0
File: packages/contracts/.cursor/rules/project-intelligence.mdc:0-0
Timestamp: 2025-08-01T07:27:26.601Z
Learning: Applies to packages/contracts/test/**/*{Integration,EnsembleCredits,Registry}*.sol : Integration testing must verify interaction between EnsembleCredits and registry contracts
Applied to files:
.taskmaster/tasks/task_001.txt.taskmaster/tasks/task_017.txt.taskmaster/tasks/task_016.txt.taskmaster/tasks/task_022.txt
📚 Learning: implement a robust ci/cd pipeline for smart contract deployments with hardhat ignition....
Learnt from: CR
PR: ensemble-codes/ensemble-framework#0
File: packages/contracts/.cursor/rules/role.mdc:0-0
Timestamp: 2025-08-01T07:27:59.616Z
Learning: Implement a robust CI/CD pipeline for smart contract deployments with Hardhat Ignition.
Applied to files:
.taskmaster/tasks/task_001.txt
📚 Learning: applies to packages/contracts/**/*.sol : implement timelocks and multisig controls for sensitive ope...
Learnt from: CR
PR: ensemble-codes/ensemble-framework#0
File: packages/contracts/.cursor/rules/role.mdc:0-0
Timestamp: 2025-08-01T07:27:59.616Z
Learning: Applies to packages/contracts/**/*.sol : Implement timelocks and multisig controls for sensitive operations in production.
Applied to files:
.taskmaster/tasks/task_001.txt.taskmaster/tasks/task_022.txt
📚 Learning: applies to packages/contracts/contracts/**/*.sol : follow openzeppelin security patterns in all soli...
Learnt from: CR
PR: ensemble-codes/ensemble-framework#0
File: packages/contracts/.cursor/rules/project-intelligence.mdc:0-0
Timestamp: 2025-08-01T07:27:26.601Z
Learning: Applies to packages/contracts/contracts/**/*.sol : Follow OpenZeppelin security patterns in all Solidity contracts
Applied to files:
.taskmaster/tasks/task_001.txt
📚 Learning: applies to packages/contracts/**/*.sol : conduct thorough gas optimization, considering both deploym...
Learnt from: CR
PR: ensemble-codes/ensemble-framework#0
File: packages/contracts/.cursor/rules/role.mdc:0-0
Timestamp: 2025-08-01T07:27:59.616Z
Learning: Applies to packages/contracts/**/*.sol : Conduct thorough gas optimization, considering both deployment and runtime costs.
Applied to files:
.taskmaster/tasks/task_001.txt
📚 Learning: conduct regular security audits and bug bounties for production-grade contracts....
Learnt from: CR
PR: ensemble-codes/ensemble-framework#0
File: packages/contracts/.cursor/rules/role.mdc:0-0
Timestamp: 2025-08-01T07:27:59.616Z
Learning: Conduct regular security audits and bug bounties for production-grade contracts.
Applied to files:
.taskmaster/tasks/task_001.txt
📚 Learning: applies to packages/contracts/**/*.sol : implement effective state machine patterns for complex cont...
Learnt from: CR
PR: ensemble-codes/ensemble-framework#0
File: packages/contracts/.cursor/rules/role.mdc:0-0
Timestamp: 2025-08-01T07:27:59.616Z
Learning: Applies to packages/contracts/**/*.sol : Implement effective state machine patterns for complex contract logic.
Applied to files:
.taskmaster/tasks/task_001.txt
📚 Learning: implement a comprehensive testing strategy including unit, integration, and end-to-end tests....
Learnt from: CR
PR: ensemble-codes/ensemble-framework#0
File: packages/contracts/.cursor/rules/role.mdc:0-0
Timestamp: 2025-08-01T07:27:59.616Z
Learning: Implement a comprehensive testing strategy including unit, integration, and end-to-end tests.
Applied to files:
.taskmaster/tasks/task_017.txt.taskmaster/tasks/task_014.txt.taskmaster/tasks/task_016.txt
📚 Learning: applies to packages/contracts/**/*.sol : implement effective error propagation patterns in internal ...
Learnt from: CR
PR: ensemble-codes/ensemble-framework#0
File: packages/contracts/.cursor/rules/role.mdc:0-0
Timestamp: 2025-08-01T07:27:59.616Z
Learning: Applies to packages/contracts/**/*.sol : Implement effective error propagation patterns in internal functions.
Applied to files:
packages/cli/src/commands/agents/update.ts
📚 Learning: applies to packages/contracts/**/*.sol : use custom errors instead of revert strings for gas efficie...
Learnt from: CR
PR: ensemble-codes/ensemble-framework#0
File: packages/contracts/.cursor/rules/role.mdc:0-0
Timestamp: 2025-08-01T07:27:59.616Z
Learning: Applies to packages/contracts/**/*.sol : Use custom errors instead of revert strings for gas efficiency and better error handling.
Applied to files:
packages/cli/src/commands/agents/update.ts
🧬 Code Graph Analysis (2)
packages/cli/src/commands/agents/list.ts (5)
packages/cli/src/utils/sdk.ts (1)
createSDKInstance(6-50)packages/sdk/src/types.ts (1)
AgentFilterParams(176-185)packages/sdk/src/ensemble.ts (1)
agents(31-33)packages/cli/src/utils/formatters.ts (1)
formatOutput(6-22)packages/cli/src/utils/file-operations.ts (1)
saveAgentRecords(7-28)
packages/subgraph/src/agents-registry.ts (1)
packages/subgraph/src/utils.ts (1)
getContentPath(7-15)
🔇 Additional comments (22)
packages/cli/src/commands/agents/list.ts (2)
32-77: LGTM with minor improvements suggested above.The action handler implementation follows good practices with proper async/await usage, comprehensive error handling, clear user feedback, and appropriate integration with SDK and utility functions. The logic flow is well-structured and the code is readable.
42-46: Fix filter property name mismatch and handle missing options.Two issues with the filter building:
- Property name mismatch:
options.reputationMin/Maxshould map tofilters.reputation_min/max- Missing handling for attributes parsing and search functionality
Apply this diff to fix the property names and add missing filter handling:
if (options.category) filters.category = options.category; if (options.owner) filters.owner = options.owner; if (options.name) filters.name = options.name; - if (options.reputationMin !== undefined) filters.reputation_min = options.reputationMin; - if (options.reputationMax !== undefined) filters.reputation_max = options.reputationMax; + if (options.reputationMin !== undefined) filters.reputation_min = options.reputationMin; + if (options.reputationMax !== undefined) filters.reputation_max = options.reputationMax; + if (options.attributes) { + // Parse comma-separated attributes if needed by the API + filters.attributes = options.attributes.split(',').map((attr: string) => attr.trim()); + }Likely an incorrect or invalid review comment.
packages/subgraph/subgraph.yaml (1)
53-54: LGTM - Event handler addition is correct.The new
AgentDataUpdatedevent handler is properly formatted and follows the existing patterns in the manifest. The event signature matches what would be expected for agent metadata updates, and the handler function name is appropriately descriptive.packages/subgraph/src/agents-registry.ts (2)
6-6: LGTM - Import addition is correct.The import for
AgentDataUpdatedis properly added to support the new event handler.
69-86: LGTM - Event handler implementation follows best practices.The
handleAgentDataUpdatedfunction is well-implemented and follows the established patterns in the codebase:
- Proper entity loading with null checking
- Updates relevant fields from event parameters
- Reuses utility function
getContentPathfor metadata handling- Creates IPFS content template when applicable
- Proper entity saving
The logic correctly handles the case where an agent's metadata URI changes, ensuring the subgraph stays synchronized with on-chain events.
.taskmaster/tasks/task_001.txt (1)
1-12: LGTM - Comprehensive task documentation.The task documentation is well-structured and covers all essential aspects of smart contract deployment:
- Clear task metadata with appropriate priority and dependencies
- Detailed technical requirements including upgradeable patterns and security features
- Comprehensive testing strategy covering unit tests, integration tests, and security considerations
- Proper network configuration for both mainnet and testnet deployments
The "done" status indicates this foundational work is complete, which aligns with other components in the PR that depend on these deployed contracts.
packages/cli/src/commands/agents.ts (1)
1-17: LGTM - Good modular command structure.The command structure follows CLI best practices:
- Clear separation of concerns with separate files for each subcommand
- Descriptive command and argument definitions
- Proper subcommand registration
.taskmaster/tasks/task_005.txt (1)
3-7: Status flag contradicts the description – confirm intended state
Status: donewhile the paragraph below says “This task is deferred until after core functionality is complete.”
Either setStatus: pendingor remove the deferral note to avoid confusion in roadmap tracking..taskmaster/tasks/task_022.txt (1)
1-75: Well-structured wallet management specificationThe task specification comprehensively covers all essential aspects of CLI wallet management including secure storage, transaction signing, and integration with agent commands. The security measures (AES-256-GCM encryption, PBKDF2 key derivation) and test strategies are particularly well-defined.
.taskmaster/tasks/task_021.txt (3)
1-55: Excellent CLI architecture and command structureThe CLI tool specification demonstrates good architectural decisions:
- TypeScript with commander.js/yargs is appropriate for a robust CLI
- SDK-first approach with REST API fallback provides flexibility
- Comprehensive command set covers all agent lifecycle operations
- Proper separation of concerns between CLI, SDK, and API layers
56-84: Comprehensive test strategy covering all aspectsThe test strategy is well-designed with appropriate coverage:
- Unit tests with SDK mocking for isolated testing
- Integration tests against live testnet for real-world validation
- End-to-end workflow testing ensures complete functionality
- User acceptance testing validates usability
- Cross-platform compatibility testing ensures broad support
85-121: Well-organized subtask breakdownThe subtasks provide excellent decomposition of the CLI implementation with clear dependencies and detailed descriptions. The progression from project setup through core commands, YAML processing, output formatting, configuration, and error handling follows a logical development flow.
.taskmaster/tasks/task_020.txt (4)
1-26: Well-designed SDK update methodsThe specification provides excellent separation between batch updates (
updateAgentRecord) and single property updates (updateAgentRecordProperty). The implementation considerations including validation, gas optimization, retry logic, and event emission demonstrate thorough planning.
27-44: Clean TypeScript interface definitionsThe interfaces are well-structured:
AgentRecordwith optional properties enables flexible partial updatesTransactionResultprovides comprehensive transaction feedback- Proper use of
bigintfor gas values- Clear property naming and typing
48-76: Comprehensive test coverage strategyThe test strategy covers all critical aspects:
- Unit tests for method functionality and validation
- Integration tests for smart contract interactions
- Edge case coverage for error scenarios
- Performance benchmarking for gas optimization
- End-to-end validation with REST API integration
77-107: Logical subtask decompositionThe subtasks provide a clear implementation path from type definitions through validation utilities to the actual method implementations and smart contract integration. The progression ensures each component builds on previous work.
packages/cli/src/commands/agents/update.ts (3)
1-39: Well-structured command setup with comprehensive optionsThe command setup provides excellent flexibility with options for individual property updates, config file support, wallet integration, and transaction control options (gas limit, dry-run, confirmation).
183-237: Excellent wallet integration with proper security checksThe implementation provides:
- Multiple private key sources with clear precedence
- Secure password input with masking
- Critical ownership verification preventing unauthorized updates
- Clear user guidance for configuration options
238-277: Well-implemented transaction execution with helpful error guidanceThe implementation provides:
- Clear success feedback with transaction hash
- Actionable next steps for users
- Detailed error messages for IPFS and contract issues
- Helpful troubleshooting suggestions
.taskmaster/docs/prd.txt (3)
81-126: Well-documented SDK API specificationsThe AgentService API methods are comprehensively documented with:
- Clear distinction between lightweight and full data retrieval methods
- Comprehensive filtering and pagination support
- Proper indication of unimplemented methods
- Clear use cases for each method
163-340: Comprehensive CLI command specificationsThe CLI commands are well-designed with:
- Consistent command structure and options
- Detailed agent-record.yaml schema with clear field descriptions
- Comprehensive filtering and output options
- Helpful examples for each command
- Proper alignment with SDK update methods
406-533: Solid technical architecture and implementation strategyThe PRD concludes with:
- Well-defined REST API layer abstracting blockchain complexity
- Appropriate blockchain infrastructure choices (Base mainnet/Sepolia)
- Comprehensive security and scalability requirements
- Realistic phased implementation approach
- Thorough risk mitigation strategies
| # Build and push Docker image to AWS ECR for AppRunner deployment | ||
| # Usage: ./scripts/build-and-push-ecr.sh [region] [ecr-repository-name] | ||
|
|
||
| set -e |
There was a problem hiding this comment.
🛠️ Refactor suggestion
Add pipefail for safer error propagation
set -e won’t catch failures that occur in the left-hand side of a pipeline (e.g., AWS login piping into docker login). Use:
-set -e
+set -euo pipefailThis also ensures undefined variables abort the script.
📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| set -e | |
| set -euo pipefail |
🤖 Prompt for AI Agents
In packages/api/scripts/build-and-push-ecr.sh at line 6, the script uses 'set
-e' which does not catch errors in pipeline commands. Replace or augment this
with 'set -euo pipefail' to ensure the script exits on any command failure,
including in pipelines, and also aborts on undefined variables for safer error
handling.
| cd .. | ||
| # cp ../pnpm-lock.yaml api/ | ||
|
|
||
| # Build Docker image | ||
| echo "Building Docker image..." | ||
| docker build -t ${ECR_REPOSITORY_NAME}:${IMAGE_TAG} -f api/Dockerfile api | ||
|
|
||
| # Clean up | ||
| rm api/pnpm-lock.yaml | ||
|
|
There was a problem hiding this comment.
Broken build-context path & dangling cleanup cause hard failure
cd .. moves the working dir outside packages/api, yet the subsequent paths (api/Dockerfile, api, rm api/pnpm-lock.yaml) are still relative to the old location.
Result:
docker buildfails (api/Dockerfilenot found).rm api/pnpm-lock.yamlruns even if the previouscpis commented out and the file never exists – withset -ethis aborts the script.
Proposed fix – stay path-agnostic and compute locations instead of relying on cd:
-# Prepare build context
-echo "Preparing build context..."
-cd ..
-# cp ../pnpm-lock.yaml api/
+# Prepare build context
+echo "Preparing build context..."
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+ROOT_DIR="$(git rev-parse --show-toplevel)"
+API_DIR="${ROOT_DIR}/packages/api"
+# Uncomment if you really need the lock-file inside the context
+# cp "${ROOT_DIR}/pnpm-lock.yaml" "${API_DIR}/"
...
-docker build -t ${ECR_REPOSITORY_NAME}:${IMAGE_TAG} -f api/Dockerfile api
+docker build -t ${ECR_REPOSITORY_NAME}:${IMAGE_TAG} \
+ -f "${API_DIR}/Dockerfile" \
+ "${API_DIR}"
...
-rm api/pnpm-lock.yaml
+rm -f "${API_DIR}/pnpm-lock.yaml"This makes the script runnable from any directory, prevents path errors, and avoids an unnecessary hard stop on missing files.
Committable suggestion skipped: line range outside the PR's diff.
🤖 Prompt for AI Agents
In packages/api/scripts/build-and-push-ecr.sh around lines 35 to 44, the script
changes directory with `cd ..` but then uses relative paths as if still inside
packages/api, causing docker build to fail and rm to error on missing files. To
fix this, remove the `cd ..` command and update all file paths to be absolute or
correctly relative to the script location, ensuring the script can run from any
directory without path errors or failing on missing files.
| if (options.verbose) { | ||
| console.error(error.stack); | ||
| } |
There was a problem hiding this comment.
Add missing verbose option or remove usage.
The code references options.verbose for stack trace display, but the verbose option is not defined in the command options.
Either add the verbose option to the command definition:
.option('--save-records-prefix <prefix>', 'Prefix for saved agent-record files (default: agent-record)', 'agent-record')
+ .option('--verbose', 'Show detailed error information including stack traces')
.action(async (options) => {Or remove the verbose check and always show stack traces in development:
- if (options.verbose) {
- console.error(error.stack);
- }
+ console.error(error.stack);🤖 Prompt for AI Agents
In packages/cli/src/commands/agents/list.ts around lines 72 to 74, the code
checks options.verbose to conditionally display error stack traces, but the
verbose option is not defined in the command's options. To fix this, either add
a verbose boolean option to the command's option definitions so it can be passed
and recognized, or remove the conditional check and always display the stack
trace during development or error handling.
| } | ||
|
|
||
| // Build update data | ||
| let updateData: any = {}; |
There was a problem hiding this comment.
Replace any type with proper typing for updateData
Using any bypasses TypeScript's type checking. Consider using a properly typed interface.
- let updateData: any = {};
+ let updateData: Partial<AgentRecord> = {};You may need to import or define the AgentRecord type from your SDK types.
📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| let updateData: any = {}; | |
| let updateData: Partial<AgentRecord> = {}; |
🤖 Prompt for AI Agents
In packages/cli/src/commands/agents/update.ts at line 66, the variable
updateData is typed as any, which disables TypeScript's type checking. Replace
the any type with a proper interface or type that matches the expected structure
of updateData, such as AgentRecord or a partial version of it. Import or define
the AgentRecord type from the SDK types if necessary, and use it to type
updateData to ensure type safety and better code clarity.
| console.log(chalk.blue('\nChanges:')); | ||
|
|
||
| Object.entries(updateData).forEach(([key, newValue]) => { | ||
| const currentValue = (currentAgent as any)[key]; |
There was a problem hiding this comment.
🛠️ Refactor suggestion
Avoid using as any for dynamic property access
The type assertion bypasses TypeScript's type checking. Consider using a type-safe approach.
- const currentValue = (currentAgent as any)[key];
+ const currentValue = currentAgent[key as keyof typeof currentAgent];This maintains type safety while allowing dynamic property access.
📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| const currentValue = (currentAgent as any)[key]; | |
| const currentValue = currentAgent[key as keyof typeof currentAgent]; |
🤖 Prompt for AI Agents
In packages/cli/src/commands/agents/update.ts at line 155, avoid using 'as any'
for dynamic property access as it bypasses TypeScript's type checking. Instead,
define a type or interface that includes the possible keys and use it to access
the property in a type-safe manner, or use a type guard or indexed access type
to ensure the key exists on currentAgent while preserving type safety.
![baz-reviewer[bot]](https://avatars.githubusercontent.com/in/933528?s=60&v=4){kind=small}
User description
Summary by CodeRabbit
New Features
Bug Fixes
Documentation
Chores
Tests
Generated description
Below is a concise technical summary of the changes proposed in this PR:
graph LR subgraph "@ensemble-ai/api" ["@ensemble-ai/api"] agentRoutes_("agentRoutes"):::added AgentService_("AgentService"):::added initializeSDK_("initializeSDK"):::added getAgents_("getAgents"):::added generateMockAgents_("generateMockAgents"):::added getAgentById_("getAgentById"):::added discoverAgents_("discoverAgents"):::added getAgentsByOwner_("getAgentsByOwner"):::added agentRoutes_ -- "New API routes use AgentService for agent data handling" --> AgentService_ AgentService_ -- "AgentService initializes Ensemble SDK for blockchain data access" --> initializeSDK_ AgentService_ -- "Fetches paginated, filtered agents from blockchain via SDK" --> getAgents_ AgentService_ -- "Fallback to mock agents if SDK data unavailable" --> generateMockAgents_ agentRoutes_ -- "API route fetches agent list via AgentService.getAgents" --> getAgents_ agentRoutes_ -- "API route fetches agent details via AgentService.getAgentById" --> getAgentById_ agentRoutes_ -- "API route performs advanced agent discovery with filters" --> discoverAgents_ agentRoutes_ -- "API route fetches agents by owner via AgentService.getAgentsByOwner" --> getAgentsByOwner_ classDef added stroke:#15AA7A classDef removed stroke:#CD5270 classDef modified stroke:#EDAC4C linkStyle default stroke:#CBD5E1,font-size:13px end subgraph "ai-agents-sdk" ["ai-agents-sdk"] Ensemble_init_("Ensemble.__init__"):::added EnsembleConfig_("EnsembleConfig"):::modified Ensemble_init_ -- "Added Ensemble.__init__ using renamed EnsembleConfig struct." --> EnsembleConfig_ classDef added stroke:#15AA7A classDef removed stroke:#CD5270 classDef modified stroke:#EDAC4C linkStyle default stroke:#CBD5E1,font-size:13px end subgraph "@ensemble-ai/sdk" ["@ensemble-ai/sdk"] Ensemble_("Ensemble"):::modified AgentService_("AgentService"):::modified Ensemble_getAgentRecord_("Ensemble.getAgentRecord"):::added AgentService_getAgentRecord_("AgentService.getAgentRecord"):::added Ensemble_updateAgentMetadata_("Ensemble.updateAgentMetadata"):::added AgentService_updateAgentMetadata_("AgentService.updateAgentMetadata"):::added Ensemble_getAgentsByOwner_("Ensemble.getAgentsByOwner"):::added AgentService_getAgentsByOwner_("AgentService.getAgentsByOwner"):::added AgentService_convertSubgraphAgentToRecord_("AgentService.convertSubgraphAgentToRecord"):::added PinataSDK_("PinataSDK"):::added AgentsRegistry_("AgentsRegistry"):::added testAgentMethods_("testAgentMethods"):::added Ensemble_ -- "Integrates AgentService for enhanced agent management capabilities." --> AgentService_ Ensemble_getAgentRecord_ -- "Delegates agent record fetching to AgentService subgraph method." --> AgentService_getAgentRecord_ Ensemble_updateAgentMetadata_ -- "Wraps metadata update using IPFS and blockchain calls." --> AgentService_updateAgentMetadata_ Ensemble_getAgentsByOwner_ -- "Provides owner-filtered agent retrieval via AgentService." --> AgentService_getAgentsByOwner_ AgentService_getAgentRecord_ -- "Transforms subgraph agent data into SDK AgentRecord format." --> AgentService_convertSubgraphAgentToRecord_ AgentService_updateAgentMetadata_ -- "Uploads agent metadata JSON to IPFS via PinataSDK." --> PinataSDK_ AgentService_updateAgentMetadata_ -- "Updates agent data on blockchain via AgentsRegistry contract." --> AgentsRegistry_ testAgentMethods_ -- "Integration test script exercises Ensemble agent record methods." --> Ensemble_ classDef added stroke:#15AA7A classDef removed stroke:#CD5270 classDef modified stroke:#EDAC4C linkStyle default stroke:#CBD5E1,font-size:13px end subgraph "ensemble-ai" ["ensemble-ai"] handleAgentDataUpdated_("handleAgentDataUpdated"):::added IpfsContent_create_("IpfsContent.create"):::modified handleAgentDataUpdated_ -- "Adds agent metadata update triggering IPFS content creation" --> IpfsContent_create_ classDef added stroke:#15AA7A classDef removed stroke:#CD5270 classDef modified stroke:#EDAC4C linkStyle default stroke:#CBD5E1,font-size:13px end subgraph "@ensemble-ai/cli" ["@ensemble-ai/cli"] updateAgentCommand_("updateAgentCommand"):::added createSDKInstance_("createSDKInstance"):::added createSignerFromPrivateKey_("createSignerFromPrivateKey"):::added WalletService_("WalletService"):::added registerAgentCommand_("registerAgentCommand"):::added getWalletService_("getWalletService"):::added getConfig_("getConfig"):::added handleWalletError_("handleWalletError"):::added WalletError_("WalletError"):::added updateAgentCommand_ -- "Enables blockchain SDK usage for agent update transactions." --> createSDKInstance_ updateAgentCommand_ -- "Creates signer for transaction signing in agent update." --> createSignerFromPrivateKey_ updateAgentCommand_ -- "Integrates wallet unlocking for signing agent update transactions." --> WalletService_ registerAgentCommand_ -- "Enables blockchain SDK usage for agent registration." --> createSDKInstance_ registerAgentCommand_ -- "Creates signer for transaction signing in agent registration." --> createSignerFromPrivateKey_ getWalletService_ -- "Provides wallet management functionalities in CLI commands." --> WalletService_ getWalletService_ -- "Retrieves CLI config for WalletService initialization." --> getConfig_ handleWalletError_ -- "Provides user-friendly error handling for wallet errors." --> WalletError_ classDef added stroke:#15AA7A classDef removed stroke:#CD5270 classDef modified stroke:#EDAC4C linkStyle default stroke:#CBD5E1,font-size:13px endThis pull request is reviewed by Baz. Review like a pro on <a href=https://baz.co/changes/ensemble-codes/ensemble-framework/54?tool=ast>(Baz).