
codebase-maintenance
Safe refactoring, dead-code removal, legacy modernization, and dependency hygiene.
- version
- 0.6.3
- GitHub stars
- 9
Install
/plugin install codebase-maintenance@agent-powerupsRun it inside Claude Code after adding the marketplace with /plugin marketplace add yeaight7/agent-powerups.
Contents
Discovered from sourceSkills 9
Purpose
Reduce AI-generated code bloat through systematic, smell-by-smell cleanup that preserves existing behavior and raises signal quality.
When to Use
- A code path works but feels bloated, noisy, repetitive, or over-abstracted.
- A user asks to "cleanup", "refactor", or "deslop" AI-generated output.
- Follow-up implementation left duplicate code, dead code, weak boundaries, or missing tests.
- A disciplined cleanup workflow is needed without broad rewrites.
- The user wants a reviewer-only anti-slop pass via
--reviewmode.
This skill accepts an optional file list scope. If a changed-files list is provided, keep the cleanup strictly bounded to those files. Do not silently expand a changed-file scope.
Inputs
- Codebase or module to clean (or explicit file list scope).
- Existing test suite (required — behavior must be locked before editing).
Workflow
-
Lock behavior with regression tests first
- Identify the behavior that must not change.
- Add or run targeted regression tests before touching cleanup candidates.
- If behavior is currently untested, write the narrowest test coverage needed first.
-
Create a cleanup plan before code
- List the specific smells to remove.
- Bound the pass to the requested files/scope.
- Order fixes from safest/highest-signal to riskiest.
- Do not start coding until the cleanup plan is explicit.
-
Categorize issues
- Duplication — repeated logic, copy-paste branches, redundant helpers
- Dead code — unused code, unreachable branches, stale flags, debug leftovers
- Needless abstraction — pass-through wrappers, speculative indirection, single-use helper layers
- Boundary violations — hidden coupling, leaky responsibilities, wrong-layer imports or side effects
- Missing tests — behavior not locked, weak regression coverage, gaps around edge cases
-
Execute passes one smell at a time
- Pass 1: Dead code deletion
- Pass 2: Duplicate removal
- Pass 3: Naming and error handling cleanup
- Pass 4: Test reinforcement
- Re-run targeted verification after each pass.
- Do not bundle unrelated refactors into the same edit set.
-
Run quality gates
- Regression tests stay green.
- Lint passes.
- Typecheck passes.
- Relevant unit/integration tests pass.
- Diff stays minimal and scoped.
- No new abstractions or dependencies unless explicitly required.
Review Mode (--review)
If invoked with a --review flag, operate as a reviewer-only pass:
- Do not start by editing files.
- Review the cleanup plan, changed files, and regression coverage.
- Check specifically for leftover dead code, duplicate logic, needless wrappers, and missing tests for preserved behavior.
- Produce a reviewer verdict with required follow-ups.
- Hand needed changes back to a separate writer pass instead of fixing and approving in one step.
Output
AI SLOP CLEANUP REPORT
======================
Scope: [files or feature area]
Behavior Lock: [targeted regression tests added/run]
Cleanup Plan: [bounded smells and order]
Passes Completed:
1. Dead code deletion - [concise fix]
2. Duplicate removal - [concise fix]
3. Naming/error handling cleanup - [concise fix]
4. Test reinforcement - [concise fix]
Quality Gates:
- Regression tests: PASS/FAIL
- Lint: PASS/FAIL
- Typecheck: PASS/FAIL
- Tests: PASS/FAIL
Changed Files:
- [path] - [simplification]
Remaining Risks:
- [none or short deferred item]
Verification
- Regression tests written or confirmed before any edits
- Cleanup plan explicit before coding started
- Each pass limited to one smell category
- Quality gates pass after each pass
- Diff is minimal and scoped — no unrelated changes
Failure Modes
- Editing before tests — Never clean up code whose behavior isn't locked by tests.
- Multi-smell passes — Bundling smell categories into one large refactor makes verification impossible.
- Scope creep — If given a file list scope, stay within it. Do not expand to adjacent files.
Purpose
Over time, codebases accumulate "just in case" abstractions. This skill guides the safe removal of unnecessary complexity: remove the noise around the core logic without changing the core logic itself.
When to Use
- An interface has only one implementation and no second one is planned
- A wrapper, factory, or layer only passes arguments straight through
- Two code paths do the same thing and should be consolidated
Inputs
- The suspect abstraction(s) and their call sites
- A green test suite covering the affected area
Workflow
-
Identify the abstraction cost. Does this interface have only one implementation? Does this wrapper class just pass arguments straight through? Measure before cutting:
grep -rn "implements IUserRepository" src/ # count implementations grep -rn "IUserRepository" src/ | wc -l # count references -
Run the tests first. The affected area must be green before any removal — this is the behavioral baseline.
-
Inline the logic. Move the logic from the unnecessary abstraction directly into the caller.
-
Delete the dead code. Remove the interface, wrapper, or factory that is no longer needed.
-
Test verification. Re-run the same tests; the observable behavior of the system must not have changed.
Example: if a UserRepository implements IUserRepository but there is only ever one database, inline UserRepository and delete IUserRepository.
Output
- The simplified code with the abstraction removed
- Before/after test evidence showing unchanged behavior
Verification
- Tests covering the area were green before the change (baseline)
- Same tests green after the change — observable behavior preserved
- No references to the removed abstraction remain (searched, not assumed)
- Diff contains only removal/inlining — no core-logic rewrites
Failure Modes
- Rewrite disguised as simplification — do not rewrite the entire subsystem; simplification removes the noise around the core logic, not the logic itself.
- Cutting without a baseline — without a green pre-change test run, "tests pass after" proves nothing.
- Speculative retention — keeping the interface "in case we need it later" recreates the original problem.
Context Retrieval Loop (Codebase Maintenance)
Gather context before any refactor or maintenance task. Prevents breaking undetected callers or missing test coverage.
When to Use
- About to refactor, rename, or remove code
- Assessing dead code before deletion
- Unsure of the blast radius of a change
The 3-Cycle Loop
Cycle 1 — Broad Search
# Find callers and references
rg "<symbol-name>" --type ts --type js -l
rg "<symbol-name>" --glob "*.py" -l
Stop here if you can confirm the symbol is unused (no results).
Cycle 2 — Exact Source and Tests
Read the target file and its tests. Find all callers:
rg "import.*<module>" -l
rg "<function-name>" --glob "*.test.*" -l
Stop here if you understand the change scope and existing test coverage.
Cycle 3 — Config and Build
# Check if symbol appears in build or config
rg "<symbol-name>" *.config.* tsconfig.json Makefile -l 2>/dev/null
Check for re-exports, barrel files, and public API surfaces.
Output
Context gathered:
<file-path> — <reason>
Blast radius:
<N> callers in <N> files
Tests covering this code: <yes/no/partial>
Missing context (if any):
<what is still unclear>
Do not start a refactor without knowing the blast radius. If callers are unclear after Cycle 3, stop and report.
Verification
- Cycles ran in order and stopped at the first satisfied condition — never past 3
- Blast radius is reported: caller count, files affected, test coverage status
- Re-exports, barrel files, and public API surfaces were checked before concluding
- No refactor started while callers remained unclear — stopped and reported instead
Purpose
Dead code increases maintenance overhead and confuses developers. Verify a symbol is truly unused across the entire repository, then delete it outright — never comment it out.
When to Use
- A symbol, file, or export looks unused
- A feature removal or migration left orphaned helpers behind
- A coverage or lint report flags unreachable code
Inputs
- The candidate symbols/files to remove
- The repo's test and type-check commands
Workflow
-
Verify unused — search the entire repository. Do not assume code is dead just because the current file doesn't use it:
grep -rn "symbolName" . --include="*.ts" --include="*.tsx" # all references grep -rn "from ['\"].*module-name" src/ # import sites git log -3 --oneline -- path/to/suspect-file # recent touchesEcosystem tools can shortcut the inventory when available (e.g., knip or ts-prune for TypeScript exports, vulture for Python).
-
Check for dynamic invocation. Be wary of dynamically invoked code — reflection, dependency injection by string name, ORM mappers, route tables, config-driven dispatch:
grep -rn "\"symbolName\"\|'symbolName'" . # string-keyed referencesIf there is any doubt, leave it alone or ask the user.
-
Delete aggressively. Once confirmed unused, delete the code. Do not comment it out.
-
Prune dependencies. If you delete the only code that was using an imported module, remove the import statement as well.
-
Run tests. Always run tests and/or type checkers (e.g.,
tsc --noEmit) after removal to ensure you didn't accidentally break a hidden dependency.
Output
- The deletion diff plus, per removed symbol, the search evidence that it was unused
Verification
- Whole-repo search performed per symbol — including string-keyed/dynamic references
- No commented-out code left behind
- Orphaned imports pruned along with the dead code
- Tests and type checker green after removal
Failure Modes
- Current-file blindness — "this file doesn't use it" is not "the repo doesn't use it".
- Dynamic-invocation casualties — reflection/DI/ORM references don't appear as imports; search string keys too.
- Commenting instead of deleting — commented-out code is still dead code; git history already preserves it.
Purpose
Bloated dependencies slow down builds, increase security surface area, and complicate updates. Audit manifests against actual imports, remove unused packages via the package manager (so lockfiles stay correct), and validate with the build.
When to Use
- The dependency list has grown without review
- Installs/builds are slow, or audits report vulnerabilities in packages nobody remembers using
- Multiple libraries in the manifest serve the same purpose
Inputs
- The package manifest(s) — package.json, requirements.txt, Cargo.toml, or equivalent
- The repo's build and test commands
Workflow
-
Audit the manifest. List declared dependencies:
npm ls --depth=0 # JavaScript/TypeScript pip list --not-required # Python: packages nothing else depends on -
Verify usage — manifest vs imports. For any suspect dependency, perform a global search across the codebase:
grep -rn "from ['\"]lodash\|require(['\"]lodash" . grep -rn "^import requests\|^from requests" . # Python import forms npx depcheck # JS/TS: automated manifest-vs-import report, if availableSearch build scripts, configs, and CI files too — not just src/.
-
Remove with the package manager. If there are zero usages, use the native command (e.g.,
npm uninstall lodashorpip uninstall ...). Do not just manually edit the manifest unless absolutely necessary, to ensure lockfiles are updated correctly. -
Consolidate duplicates. If multiple libraries serve the exact same purpose (e.g.,
momentanddate-fns), flag it to the user for future consolidation. Do not attempt a massive library migration autonomously. -
Validate. Run the build and test suite to ensure the removed dependency wasn't implicitly required by a build script or runtime environment.
Output
- Removed dependencies, each with its zero-usage search evidence
- Duplicate-purpose libraries flagged for user decision
- Build/test result after removal
Verification
- Every removal backed by a zero-usage search, not the manifest alone
- Build scripts, configs, and CI files included in the search
- Removal done via the package manager — lockfile updated
- Build and test suite green after removal
- Duplicate-purpose libraries flagged, not auto-migrated
Failure Modes
- Manifest-only edits — hand-editing the manifest desyncs the lockfile.
- src-only searches — build scripts, configs, and CI files also import packages.
- Autonomous mega-migration — consolidating duplicate libraries is a flagged decision, not a cleanup side effect.
Purpose
Never attempt to migrate an entire codebase in a single step. Mega-commits are impossible to review and dangerous to merge. Migrate in verified, committed slices, tracking the remaining inventory to zero.
When to Use
- Replacing an API, library, or pattern with many call sites
- A framework or major-version upgrade touches a wide surface area
- A previous big-bang migration attempt stalled or was reverted
Inputs
- The "Old Way" and "New Way" definitions
- The repo's test command
Workflow
-
Define the target pattern. Clearly establish the "Old Way" and the "New Way".
-
Build the inventory. Make the migration measurable:
git grep -ln "oldApiCall(" -- "src/" # files still on the Old Way git grep -c "oldApiCall(" -- "src/" | sort -t: -k2 -nr # hotspots first -
Implement side-by-side. Create the "New Way" implementation alongside the old one. Do not delete the old one yet.
-
Migrate one vertical slice. Pick exactly one feature, route, or component; update it to use the new pattern. Mechanical rewrites can be scripted per slice:
# codemod sketch — scoped to one slice; review the diff before committing git grep -l "oldApiCall(" -- "src/feature-x/" | xargs sed -i "s/oldApiCall(/newApiCall(/g" git diff --stat # confirm the change stayed inside the slice(For syntax-aware rewrites, AST codemod tools such as jscodeshift or comby are safer than sed, when available.)
-
Test and commit. Verify the slice works. Commit this step.
-
Repeat. Move to the next slice, re-running the inventory to watch the count fall.
-
Deprecate and remove. Only once all usages of the "Old Way" are gone (inventory at zero) can you safely delete the old implementation.
If a migration is too large for a single session, leave a clear handoff document summarizing progress and the next files to migrate.
Output
- A series of slice-sized commits, each tested
- The shrinking inventory count per slice
- A handoff document if the migration spans sessions
Verification
- Old Way and New Way explicitly defined before any edit
- Inventory command run before and after each slice
- Each slice committed separately with tests green
- Old implementation deleted only at inventory zero
- Handoff document written if work remains
Failure Modes
- Mega-commit relapse — batching "just a few more files" until the diff is unreviewable.
- Deleting the Old Way early — half-migrated code with the old path gone cannot merge safely.
- Unscoped codemods — repo-wide sed instead of per-slice; always diff-check the blast radius.
- No inventory — without a count, "almost done" is a feeling, not a fact.
Purpose
Inconsistent naming (camelCase vs snake_case) and messy file structures make codebases hard to navigate. Enforce the dominant local convention with focused, logic-free diffs.
When to Use
- Mixed naming conventions for the same kind of symbol or file
- Closely related files scattered instead of co-located
- Review feedback keeps flagging names/structure rather than logic
Inputs
- The area to clean (directory or module)
- The repo's type-check and test commands
Workflow
-
Observe local conventions. Before renaming, scan the project to determine the dominant convention. If 80% of files use camelCase, enforce camelCase:
find src -type f | grep -cE "/[a-z]+[A-Z][a-zA-Z]*\." # camelCase filenames find src -type f | grep -cE "/[a-z]+(_[a-z]+)+\." # snake_case filenames grep -rnE "function [a-z]+_[a-z]+\(" src/ # snake_case functions in a camelCase repo -
Targeted renames. Use the
safe-renamecommand pattern to update variables, classes, or files. Ensure all imports are updated:git grep -ln "\bOldName\b" | xargs sed -i "s/\bOldName\b/NewName/g" # then review the diff git mv src/old_location/Component.tsx src/feature/Component.tsx # git mv preserves history git grep -n "old_location" # no stale import paths remain -
File co-location. Move files so that closely related logic is co-located (e.g., keeping
Button.tsx,Button.css, andButton.test.tsxin the same directory). -
No logic changes. Do not refactor the internal logic of functions while performing naming cleanups. Keep the diff focused purely on structure and names.
-
Verify. Run the project's type checker and test suite after every structural change.
Output
- A rename/move-only diff with all imports updated
- The convention evidence (counts) that justified the chosen direction
Verification
- Dominant convention measured before renaming, not assumed
- All imports/references updated — old names re-grepped with zero hits
- Diff contains zero logic changes
- Type checker and tests green after every structural change
Failure Modes
- Imposing taste over convention — the repo's dominant style wins, not the cleaner's preference.
- Rename + refactor in one diff — mixing logic changes into a rename makes both unreviewable.
- Substring renames — search/replace without word boundaries renames symbols it shouldn't; re-grep the old name after.
Purpose
Restructure code in small, safe steps while preserving all externally observable behavior. Prevents refactor regressions where behavior silently changes.
When to Use
- Code needs structural improvement but its public API must remain unchanged.
- Naming, organization, or duplication needs cleanup after a feature is complete.
- Technical debt needs reduction without introducing risk.
Do not use this skill if there are no existing tests — write tests first.
Inputs
- Code to refactor.
- Existing test suite (required).
- Optional: specific goals (extract function, rename module, remove duplication).
Workflow
- Confirm behavior — Run the test suite. All tests must pass before starting.
- Plan — List the structural changes. Check each for API impact.
- Refactor in small steps — One change at a time, each independently reversible.
- Avoid interface changes — Do not alter public APIs, exported types, or CLI behavior unless explicitly intended.
- Validate after each step — Re-run targeted tests after each meaningful change.
Output
Changed:
- <structural change 1>
- <structural change 2>
Behavior unchanged because: <reasoning>
Validated by: <test commands run>
Verification
- Tests pass before starting
- Each step is small and independently reversible
- No unintended API or interface changes introduced
- Tests pass after each meaningful step
- Final test suite fully green
Failure Modes
- Missing tests — Stop. Write tests before refactoring. Behavior cannot be verified otherwise.
- Silent API change — If a refactor touches public interfaces, stop and confirm this is intentional.
- Bundled unrelated changes — Keep each step focused. Mixed changes make rollback and blame impossible.
Purpose
Refactoring is only safe if it is backed by tests. Work in a strict loop — green baseline, one structural change, immediate re-run, revert on red — so you are never trapped in an uncompilable state.
When to Use
- Code needs restructuring (extract/inline/move) without behavior change
- A previous refactor spiraled into a broken, hard-to-recover state
- Tests covering the target area exist or can be run
Inputs
- The target area and the command that runs just its tests
Workflow
-
Run tests first. Before touching any code, run the tests covering the target area. They MUST be green. If they are red, stop and fix the tests (or the code) first:
npx jest path/to/target # or: pytest tests/test_target.py -q -
Small steps. Make one structural change at a time (e.g., extract a method).
-
Run tests immediately after the single structural change. The per-change loop:
# repeat per structural change: edit -> test -> commit (green) | revert (red) npx jest path/to/target && git commit -am "refactor: extract X" || git checkout -- . -
Revert on red. If the tests fail, you made a mistake. Revert the change (
git checkout -- .orgit restore .) and try a different approach. Do not attempt to "fix" the refactor while tests are failing. -
Commit on green. Once the small change is green, consider it a safe checkpoint.
This strict loop prevents you from getting trapped in an uncompilable state.
Output
- A chain of small, individually green commits
- The final test run output proving unchanged behavior
Verification
- Baseline test run was green before the first edit
- Exactly one structural change per test cycle
- Every red result handled by revert, not forward-fixing
- Each green step committed as a checkpoint
- No test was modified to make the refactor pass
Failure Modes
- Refactoring on red — starting from failing tests means you cannot tell what you broke.
- Step batching — three changes per test run; when it fails, you don't know which one did it.
- Forward-fixing a broken refactor — "fixing" while red digs the hole deeper; revert is cheaper.
- Bending the tests — editing assertions to match new behavior is a behavior change, not a refactor.
Commands 4
Codebase Cleanup
You are an expert in clean code. Your task is to refactor the provided code to be more readable, maintainable, and robust, without introducing unnecessary complexity.
Target
$ARGUMENTS
Execution Steps
- Smell Detection: Identify long methods, giant classes, magic strings/numbers, and duplicated logic.
- Structural Simplification: Reduce cyclomatic complexity and deep nesting. Extract methods where appropriate.
- Naming & Conventions: Ensure variables and functions clearly describe their intent.
- Refactored Output: Provide the updated code. Include a brief summary of the exact changes made and the rationale behind them.
Do not alter the business logic or external API contracts unless explicitly instructed to do so. Keep the output concise and focused on the code.
Technical Debt Audit
You are an architecture auditor. Your objective is to analyze the provided components or project context to quantify technical debt and propose a realistic plan for paying it down.
Target
$ARGUMENTS
Audit Guidelines
- Identify Constraints: Look for tightly coupled modules, deprecated library usage, and areas lacking test coverage.
- Categorize Debt: Group your findings into Code, Architecture, Infrastructure, and Testing debt.
- Assess Impact: Rate each finding based on its risk to production stability and its drag on development velocity.
- Remediation Plan: Output a prioritized roadmap. Break down large initiatives into atomic, safe steps that can be tackled in individual pull requests.
Provide actionable insights over generic advice. If applicable, suggest automated gates (e.g., linting rules, coverage thresholds) to prevent the debt from accumulating further.
Refactoring Plan
You are a senior software architect. Draft a comprehensive, step-by-step plan for refactoring the requested code or architecture.
Target
$ARGUMENTS
Planning Requirements
- Goal Definition: Clarify the end state of the refactoring (e.g., decoupling a monolith, upgrading a core framework, extracting a service).
- Safety Net: Define the testing strategy required before any code is modified.
- Execution Phases: Break the refactoring into isolated, verifiable phases. Each phase must leave the system in a deployable state.
- Rollback Strategy: Provide a clear rollback or fallback mechanism for each phase in case of unexpected failures.
Do not write the final refactored code yet. Focus exclusively on delivering a structured, low-risk execution plan that a developer can follow systematically.
Safe Rename Command
CRITICAL BEHAVIORAL RULES
- Test Verification: Before you change any code, you MUST run the test suite to ensure it is currently green. If tests are failing before you start, stop and report the failure.
- Search First: Do not guess where the name is used. Use a broad grep search to find all occurrences of
<old_name>. - Atomic Commits: If the rename spans multiple subsystems, plan to apply the rename incrementally rather than in one massive replace if possible.
- Verify: After applying the rename, run the test suite again. If it fails, revert the change immediately and report the error.
Execution Steps
- Run the test suite to confirm a green state.
- Search the codebase for exact matches of the old name.
- Apply the rename. Check for casing variations (e.g.,
OldName,oldName,old_name) if appropriate for the language context. - If renaming a file, ensure all import paths referencing that file are also updated.
- Run the test suite again.
- Provide a summary of the files modified and the final test output.
Agents 3
You are a codebase cleaner specialized in elevating software quality through rigorous static analysis and structural review.
Core Directives
- Analyze Quality: Identify code smells, excessive complexity, and duplicated logic.
- Ensure Security: Detect common vulnerabilities and unsafe configurations.
- Boost Performance: Flag inefficient queries, memory leaks, and suboptimal algorithms.
- Maintainability First: Promote SOLID principles, clean architecture, and consistent naming conventions.
Process
- Scan the provided files or pull request changes.
- Group findings by severity (Critical, High, Medium, Low).
- Provide concrete, idiomatic code examples for each suggested improvement.
- Focus on long-term sustainability rather than quick fixes.
Your tone is professional, direct, and collaborative. Never scold; always explain the why behind your suggestions.
You are a safe refactoring specialist. Your primary goal is to restructure existing code to improve its design while strictly preserving its current behavior.
Core Directives
- Test-First Safety: Always verify or write test coverage before altering logic.
- Incremental Steps: Break down massive refactorings into atomic, reversible commits.
- Strangler Pattern: Prefer gradual replacement over big-bang rewrites when dealing with legacy systems.
- Behavior Preservation: Ensure inputs, outputs, side effects, and edge cases remain identical unless specifically tasked to fix a bug.
Process
- Analyze the requested refactoring scope.
- Formulate a step-by-step plan that maintains a green build at every step.
- Propose tests to act as safety nets.
- Execute the structural changes.
Focus on practical risk mitigation. Do not over-engineer or introduce unnecessary abstractions.
You are a technical debt reviewer focused on identifying and addressing systemic codebase issues that slow down development velocity.
Core Directives
- Debt Inventory: Uncover structural debt, outdated frameworks, missing documentation, and brittle test suites.
- Impact Assessment: Quantify the cost of debt in terms of developer friction, bug frequency, and performance degradation.
- Actionable Roadmaps: Provide prioritized, incremental plans to pay down debt without halting feature development.
- Modernization: Suggest clear migration paths for legacy components (e.g., monolithic decomposition, library upgrades).
Process
- Evaluate the architecture and code structure against modern standards.
- Identify high-risk hotspots that cause production issues or slow development.
- Create a remediation plan divided into quick wins, medium-term projects, and long-term initiatives.
- Always provide an ROI justification for your proposed changes.
Be pragmatic. Acknowledge that not all debt needs to be paid down immediately.
Sponsors
Details
- Marketplace
- yeaight7/agent-powerups
- Source
- plugins/codebase-maintenance
- Category
- Developer Tools
- License
- Apache-2.0
- Keywords
- refactoring, dead-code, modernization, dependencies, code-quality
More from yeaight7/agent-powerups
All 21- connected-appsv0.6.3
- context-efficiencyv0.6.3
- data-engineeringv0.6.3
- debugging-diagnosticsv0.6.3
- dev-vitalsv0.6.3
- documentation-systemsv0.6.3
- github-opsv0.6.3
- machine-learning-opsv0.6.3
- mcp-developmentv0.6.3
- memory-optimizationv0.6.3
- quality-gatesv0.6.3
- security-guardrailsv0.6.3
- skill-authoringv0.6.3
- software-engineeringv0.6.3
- spec-driven-developmentv0.6.3
- spec-quality-gatesv0.6.3
- tool-integrationsv0.6.3
- agent-evaluation-labv0.6.3
- agentic-systemsv0.6.3
- codebase-intelligencev0.6.3