Deeplint is still in the MVP development phase and not yet available for use.
Github

Roadmap

This roadmap outlines the features required for the MVP, compares them against the current implementation state as of May 2025, and details the remaining work with priorities and timelines.

Status Legend

Status
Description

✅ Implemented

Feature is fully implemented and functional

🟡 Partial

Foundational elements exist, but significant implementation is missing

❌ Planned

Feature is required for MVP but not yet implemented

Implementation Timeline

Implementation Priority

  1. High Priority (Required for core functionality)

    • LLM Integration

    • Analysis Orchestration

    • Output Formatting

  2. Medium Priority (Important for user experience)

    • Check Command

    • Config Command

    • Git Hook Installation

  3. Lower Priority (Nice to have for MVP)

    • Auto-Fix/Wizard

    • Deep Analysis Mode

    • Rule/Policy Integration

1. Core CLI & Setup

  • MVP Requirements:

    • Basic CLI structure (deeplint, init, check, config, help, version).

    • Configuration file handling (.deeplint.yml or deeplint.config.js).

    • Argument parsing (global options like --provider, --api-key, --config, --json, --wizard, --instructions).

    • Environment variable support for config.

    • Basic logging.

  • Current State:

    • ✅ CLI framework (yargs) setup (src/index.ts).

    • ✅ Command registry and discovery (src/commands/registry.ts, src/commands/discovery.ts).

    • ✅ Base command structure (src/commands/base-command.ts).

    • ✅ DefaultCommand implementation with enhanced UI (src/commands/default-command.ts).

    • ✅ InitCommand implementation with enhanced UI (src/commands/init-command.ts).

    • ✅ HelpCommand implementation with formatted help output (src/commands/help-command.ts).

    • ✅ Configuration loading, validation, defaults (src/config/manager.ts, src/config/validator.ts).

    • ✅ Enhanced logging provider (src/providers/logger.ts and src/ui/logger.ts).

    • ✅ Config persistence helpers (src/providers/typed-config-store.ts, src/providers/config.ts).

  • Remaining Work:

    • ❌ Implement check <files> command logic. (Medium Priority - Q2 2025)

    • ❌ Implement config command logic (view/edit). (Medium Priority - Q2 2025)

    • ❌ Implement handling for specific global options (--json, --wizard, --instructions, etc.) within commands. (Medium Priority - Q2 2025)

    • ❌ Fully implement the main analysis logic within DefaultCommand (or a dedicated analysis command). (High Priority - Q2 2025)

2. Git Integration & Change Detection

  • MVP Requirements:

    • Detect staged changes.

    • Install as a Git pre-commit hook.

    • Parse Git diffs.

    • Filter changed files based on config (include/exclude, size).

  • Current State:

    • ✅ Git operations wrapper (src/context-builder/git/git-operations.ts) to check staged status, get diffs.

    • ✅ Diff parser (src/context-builder/git/diff-parser.ts).

    • ✅ File system scanner (src/context-builder/indexer/file-system-scanner.ts) with include/exclude logic.

    • 🟡 Configuration options exist for hooks (git.hooks.pre_commit) in configuration_examples.md.

  • Remaining Work:

    • ❌ Implement the actual Git pre-commit hook installation mechanism (e.g., using a tool like husky). (Medium Priority - Q2 2025)

    • ❌ Integrate file filtering logic (from config) into the change detection process. (Medium Priority - Q2 2025)

    • ❌ Ensure GitOperations correctly identifies the project root and functions within the hook context. (Medium Priority - Q2 2025)

3. Repository Indexing & Context Building

  • MVP Requirements:

    • Scan repository structure (files, types).

    • Basic dependency analysis (imports/exports).

    • Build "Light" context (diffs, immediate dependencies, repo map).

    • Build "Deep" context (diffs, full repo map with exports, agentic file selection).

    • Handle token limits.

  • Current State:

    • ✅ FileSystemScanner for repo structure (src/context-builder/indexer/file-system-scanner.ts).

    • ✅ CodeStructureAnalyzer for file structure/exports (src/context-builder/indexer/code-structure-analyzer.ts).

    • ✅ DependencyAnalyzer for building dependency graph (src/context-builder/indexer/dependency-analyzer.ts).

    • ✅ ContextBuilder class (src/context-builder/context/context-builder.ts) with methods for assembling context components.

    • ✅ TokenCounter for managing token limits (src/context-builder/context/token-counter.ts).

  • Remaining Work:

    • ❌ Implement the specific logic within ContextBuilder to assemble the "Light" context as defined. (High Priority - Q2 2025)

    • ❌ Implement the "Deep" context building logic, including the agentic step where the LLM selects relevant files. (Lower Priority - Q3 2025)

    • ❌ Integrate configuration (analysis.mode, analysis.depth) into ContextBuilder. (Medium Priority - Q2 2025)

    • ❌ Integrate user instructions (--instructions) into the context. (Medium Priority - Q2 2025)

4. LLM Integration & Analysis

  • MVP Requirements:

    • Abstraction layer for multiple LLM providers (OpenAI, Anthropic, Gemini).

    • Send constructed context to the selected LLM.

    • Prompt engineering for analysis and issue detection.

    • Handle API keys securely (env vars).

  • Current State:

    • 🟡 Basic config helpers for API keys/models (src/providers/config.ts).

  • Remaining Work:

    • ❌ Implement the core LLM service/provider abstraction layer. (High Priority - Q2 2025)

    • ❌ Integrate specific LLM SDKs (OpenAI). (High Priority - Q2 2025)

    • ❌ Develop and implement prompt templates for analysis and patch generation. (High Priority - Q2 2025)

    • ❌ Implement logic to call the LLM API with the constructed context and prompt. (High Priority - Q2 2025)

    • ❌ Implement secure API key handling (reading from env vars). (High Priority - Q2 2025)

5. Rule Engine & Policy Definition

  • MVP Requirements:

    • Core built-in rules (cross-file dependencies, security, error handling - interpreted by LLM via prompt).

    • Natural Language policy definition in config.

    • Integrate policies into the LLM prompt.

  • Current State:

    • 🟡 Configuration structure exists for rules/policies (configuration_examples.md).

  • Remaining Work:

    • ❌ Implement logic to read custom NL policies from the config. (Lower Priority - Q3 2025)

    • ❌ Integrate built-in rule concepts and custom policies into the LLM prompt construction. (Lower Priority - Q3 2025)

6. Output & Developer Feedback

  • MVP Requirements:

    • Formatted terminal output (color-coded severity, file/line refs, messages, recommendations).

    • Structured JSON output (--json flag).

    • Clear indication of issues found.

  • Current State:

    • ✅ Basic logging (src/providers/logger.ts).

    • ✅ Enhanced UI components (src/ui/ directory):

      • ✅ Themed color system for consistent styling (src/ui/theme.ts)

      • ✅ Enhanced logger with structured output (src/ui/logger.ts)

      • ✅ Spinners for long-running operations (src/ui/spinner.ts)

      • ✅ Progress bars for tracking progress (src/ui/progress.ts)

      • ✅ Banners and tables for structured information display (src/ui/banner.ts, src/ui/table.ts)

      • ✅ Interactive prompts for user input (src/ui/prompt.ts)

    • ✅ Command-specific UI enhancements for InitCommand and DefaultCommand

  • Remaining Work:

    • ❌ Implement the specific terminal output formatting for analysis results as shown in cli_design.md. (High Priority - Q2 2025)

    • ❌ Implement JSON output generation based on the analysis results. (Medium Priority - Q2 2025)

    • ❌ Integrate analysis results into the output manager. (High Priority - Q2 2025)

7. Auto-Fix Suggestions & Wizard

  • MVP Requirements:

    • LLM generates git-compatible patches for detected issues.

    • Interactive wizard (--wizard) to review and selectively apply patches.

    • Safety classification for fixes (though implementation details are vague - likely LLM-driven).

    • Apply patches using Git commands.

    • Override mechanism (implicit via wizard 'n' option).

    • Note: --fix flag is marked as discontinued in cli_design.md, focus is on --wizard.

  • Current State:

    • 🟡 UI foundation for wizard implementation:

      • ✅ Interactive prompts system (src/ui/prompt.ts) with confirmation dialogs

      • ✅ Spinner component for tracking patch application progress

      • ✅ Styled output for displaying patch information

    • ❌ Core patch generation and application logic not implemented

  • Remaining Work:

    • ❌ Enhance LLM prompting to explicitly request git-compatible patches in the structured output. (Lower Priority - Q3 2025)

    • ❌ Implement the interactive terminal UI for the --wizard mode using the existing prompt components. (Lower Priority - Q3 2025)

    • ❌ Implement logic to parse the patch from the LLM response. (Lower Priority - Q3 2025)

    • ❌ Implement logic to apply the patch to the staged files (potentially using git apply). (Lower Priority - Q3 2025)

    • ❌ Implement safety classification (likely based on LLM confidence or specific heuristics). (Lower Priority - Q3 2025)

    • ❌ Integrate the wizard flow into the main command execution. (Lower Priority - Q3 2025)

MVP Release Criteria

For the initial MVP release, the following components must be completed:

  1. Core CLI & Setup

    • ✅ CLI framework

    • ✅ Command system

    • ✅ Configuration system

    • ❌ Check command

    • ❌ Analysis logic

  2. Git Integration

    • ✅ Git operations

    • ✅ Diff parsing

    • ❌ Hook installation

  3. Context Building

    • ✅ File system scanner

    • ✅ Dependency analyzer

    • ✅ Context assembly

    • ❌ Light context implementation

  4. LLM Integration

    • ❌ Provider abstraction

    • ❌ Prompt engineering

    • ❌ Response parsing

  5. Output & UI

    • ✅ UI components

    • ❌ Analysis output

The following components are considered stretch goals for the MVP and may be deferred to a post-MVP release:

  1. Auto-Fix & Wizard

  2. Deep Context Analysis

  3. Rule Engine & Policy Definition

Summary of Major Gaps for MVP

  1. LLM Service Core: The central component for interacting with LLMs, including provider abstraction, prompt engineering, and response parsing. (High Priority - Q2 2025)

  2. Analysis Orchestration: Implementing the main analysis logic within the default command to tie together context building, LLM calls, and output. (High Priority - Q2 2025)

  3. Output Formatting: Creating the user-facing terminal and JSON output for analysis results. (High Priority - Q2 2025)

  4. Git Hook Installation: Automating the setup of the pre-commit hook. (Medium Priority - Q2 2025)

  5. Auto-Fix/Wizard Implementation: The entire workflow for generating, reviewing, and applying patches. (Lower Priority - Q3 2025)

  6. Rule/Policy Integration: Feeding the configured rules and NL policies into the LLM prompt. (Lower Priority - Q3 2025)

  7. Deep Analysis Mode: Implementing the agentic file selection for deeper context. (Lower Priority - Q3 2025)

Next Steps

The immediate focus should be on the high-priority items:

  1. Implement the LLM service core

  2. Implement the analysis orchestration

  3. Implement the output formatting for analysis results

These components form the critical path for the MVP and should be completed before moving on to the medium and lower priority items.

PreviousAPI Documentation (Planned) 🚧NextChangelog

Last updated