A simple command-line task management tool
npm install simple-task-master


A powerful, lightweight command-line task management tool built for developers who prefer markdown files over complex project management systems. STM stores tasks as individual markdown files with YAML frontmatter, making them both human-readable and version control friendly.
- π Markdown-based tasks: Each task is stored as a readable markdown file
- π·οΈ Flexible tagging system: Organize tasks with multiple tags
- π Powerful search: Find tasks by content, title, tags, or status
- π Multiple output formats: JSON, table, CSV, or pretty-printed views
- π Safe concurrent access: Built-in file locking prevents data corruption
- β‘ Fast performance: Optimized for handling thousands of tasks
- π― Simple workflow: Initialize, add, list, update - that's it!
- π Export capabilities: Export tasks to various formats for reporting
- π§ Custom metadata fields: Add any custom fields for external tool integration
- βοΈ Flexible configuration: Configurable task directories and runtime settings with reset capabilities
#### Global Installation (Recommended)
``bash`
npm install -g simple-task-master
#### Using npx (No Installation)
`bash`
npx simple-task-master init
1. Initialize a new task repository:
`bash`
stm init
2. Add your first task:
`bash`
stm add "Implement user authentication" --tags=backend,security --priority=high
3. List all tasks:
`bash`
stm list
4. View a specific task:
`bash`
stm show 1
5. Update task status:
`bash`
stm update 1 --status=in-progress
STM tasks use three main content sections to organize information clearly:
- Description (--description): Why & What--details
- Problem context and background
- Solution overview and approach
- Acceptance criteria and definition of done
- Details (): How
- Implementation approach and technical design
- Architecture notes and design decisions
- Step-by-step implementation plan
- Validation (--validation): Quality Assurance
- Testing strategy and approach
- Verification steps and quality checks
- Manual testing procedures and checklists
`markdown
---
id: 1
title: 'Implement user authentication'
status: 'pending'
---
Problem: Users currently cannot securely access the application.
Solution: Implement JWT-based authentication with secure password handling.
Acceptance Criteria:
- [ ] Users can register with email/password
- [ ] Users can login and receive JWT tokens
- [ ] Protected routes require valid tokens
- [ ] Passwords are securely hashed
Implementation approach:
- Use bcrypt for password hashing (salt rounds: 12)
- JWT tokens with 24-hour expiration
- Express middleware for route protection
- Database schema: users table with email, password_hash, created_at
Architecture:
- auth.ts: Core authentication logic
- middleware/auth.ts: Route protection
- routes/auth.ts: Login/register endpoints
Testing strategy:
- Unit tests for password hashing/verification
- Integration tests for auth endpoints
- E2E tests for complete login flow
Manual verification:
- [ ] Register new user via API
- [ ] Login returns valid JWT
- [ ] Protected routes reject invalid tokens
- [ ] Password reset flow works end-to-end
`
Initialize STM repository in the current directory.
`bashInitialize with default settings
stm init
Creates:
-
.simple-task-master/ directory
- config.json configuration file
- tasks/ directory (or your custom directory)
- Updates .gitignore to exclude task files but include configOptions:
-
--tasks-dir : Custom directory for storing task files (default: .simple-task-master/tasks/)$3
Add a new task with the specified title.
`bash
Basic task
stm add "Fix login bug"Task with tags and priority
stm add "Implement dashboard" --tags=frontend,ui --priority=highTask with description
stm add "Update documentation" --description="Update API docs and examples"Task with due date
stm add "Deploy to production" --due-date="2024-12-31"
`Options:
-
--tags, -t : Comma-separated list of tags
- --priority, -p : Task priority (low, medium, high)
- --description, -d : Task description
- --due-date : Due date (YYYY-MM-DD format)
- --status, -s : Initial status (pending, in-progress, done)$3
List tasks with optional filtering and formatting.
`bash
List all tasks
stm listFilter by status
stm list --status=pending
stm list --status=in-progress
stm list --status=doneFilter by tags
stm list --tags=frontend,ui
stm list --tags=backendSearch in task content
stm list --search="authentication"Combine filters
stm list --status=pending --tags=backend --search="API"Different output formats
stm list --format=json
stm list --format=csv
stm list --format=table
stm list --pretty # Enhanced pretty-printing
`Filtering Options:
-
--status, -s : Filter by status (pending, in-progress, done)
- --tags, -t : Filter by comma-separated tags
- --search : Search in task titles and descriptionsOutput Options:
-
--format, -f : Output format (json, table, csv)
- --pretty, -p: Enable pretty-printing with colors and formatting$3
Display detailed information about a specific task.
`bash
Show task by ID
stm show 1Show with different formats
stm show 1 --format=json
stm show 1 --format=yaml
`Options:
-
--format, -f : Output format (default, json, yaml)$3
Update an existing task's properties with flexible options for metadata, content sections, and editor integration.
#### Basic Property Updates
`bash
Update status
stm update 1 --status=doneUpdate title
stm update 1 --title="New task title"Update tags
stm update 1 --tags=urgent,backend,security
`#### Section-Specific Updates
`bash
Update description section directly
stm update 42 --desc "Revised task description with new requirements"Update details section with multi-line content
stm update 42 --details "## Implementation Notes
- Use TypeScript for type safety
- Add comprehensive error handling
- Include unit tests"Update validation section
stm update 42 --validation "β All tests pass
β Code review completed
β Manual QA approved"
`#### Stdin Input Support
`bash
Pipe content to description section
echo "New description from command output" | stm update 42 --desc -Pipe test results to validation section
npm test | stm update 42 --validation -Use complex piping with other tools
curl -s api.example.com/requirements | stm update 42 --details -Multi-line input using heredoc
stm update 42 --validation - << 'EOF'
β Unit tests: 45/45 passing
β Integration tests: 12/12 passing
β Performance benchmarks within limits
β Security scan: no vulnerabilities
EOF
`#### Key=Value Assignment Syntax
`bash
Basic assignments
stm update 42 status=done title="Completed feature implementation"Content section assignments
stm update 42 desc="Updated description" details="New implementation details"Array operations - adding tags
stm update 42 tags+=security,performanceArray operations - removing tags
stm update 42 tags-=deprecated,oldMultiple mixed operations
stm update 42 status=in-progress tags+=urgent desc="High priority update"
`#### Editor Integration
`bash
Open task in editor when no changes specified
stm update 42Disable editor fallback
stm update 42 --no-editor
`#### Combined Usage Examples
`bash
Update metadata and add validation results
stm update 42 status=done --validation "β All tests pass
β Manual QA complete"Update multiple sections with different input methods
stm update 42 --desc "Updated requirements" details="$(cat implementation-notes.md)"Complex workflow with piped validation
npm run test:full | stm update 42 status=done --validation -Batch update with assignment syntax
stm update 42 status=in-progress tags+=urgent,hotfix desc="Critical bug fix in progress"
`Options:
-
--title, -t : Update task title
- --desc, -d : Update description section (use - for stdin)
- --details : Update details section (use - for stdin)
- --validation : Update validation section (use - for stdin)
- --status, -s : Update status (pending, in-progress, done)
- --tags : Set task tags (comma-separated)
- --deps : Set task dependencies (comma-separated IDs)
- --no-editor: Disable editor fallback when no changes are specifiedAssignment Syntax:
-
key=value: Set field value
- key+=value: Add to array fields (tags, dependencies)
- key-=value: Remove from array fields (tags, dependencies)Valid Fields for Assignments:
-
title: Task title
- content: Full task content (markdown body)
- status: Task status (pending, in-progress, done)
- tags: Task tags (comma-separated for arrays)
- dependencies: Task dependencies (comma-separated IDs)
- desc: Description section content
- details: Details section content
- validation: Validation section content
- Any custom field: You can add custom metadata fields for external tool integration$3
Search for tasks using regular expressions.
`bash
Search in task content
stm grep "authentication"Case-insensitive search
stm grep -i "API"Search in specific fields
stm grep --field=title "user"
stm grep --field=description "implement"Different output formats
stm grep "bug" --format=json
stm grep "feature" --format=table
`Options:
-
--case-insensitive, -i: Case-insensitive search
- --field : Search in specific field (title, description, tags)
- --format, -f : Output format (default, json, table)$3
Export tasks to various formats for reporting and analysis.
`bash
Export all tasks to JSON
stm export --format=json > tasks.jsonExport to CSV
stm export --format=csv > tasks.csvExport filtered tasks
stm export --status=done --format=json > completed-tasks.jsonExport with specific fields
stm export --format=csv --fields=id,title,status,tags
`Options:
-
--format, -f : Export format (json, csv, md)
- --status, -s : Filter by status
- --tags, -t : Filter by tags
- --fields : Comma-separated fields to include in export$3
Delete a task permanently.
`bash
Delete a task
stm delete 123Force delete (bypass dependency checks)
stm delete 123 --force
`Note: Deletion is permanent. Tasks that depend on the deleted task may become invalid unless
--force is used.Options:
-
--force, -f: Force deletion even if other tasks depend on this task$3
View and modify Simple Task Master configuration settings.
`bash
View all configuration
stm config --listGet specific configuration value
stm config --get tasksDir
stm config --get lockTimeoutMs
stm config --get maxTaskSizeBytesChange tasks directory
stm config --set tasksDir=docs/tasksChange lock timeout to 60 seconds
stm config --set lockTimeoutMs=60000Change max task size to 2MB
stm config --set maxTaskSizeBytes=2097152Reset individual configuration values to defaults
stm config --reset tasksDir
stm config --reset lockTimeoutMsReset all configuration values to defaults
stm config --reset-all
`Options:
-
--get : Get a specific configuration value
- --set : Set a configuration value
- --list: List all configuration values as JSON
- --reset : Reset a specific configuration value to its default
- --reset-all: Reset all configuration values to defaultsConfiguration Keys:
-
tasksDir: Directory where task files are stored (relative or absolute path)
- lockTimeoutMs: Lock acquisition timeout in milliseconds (default: 30000)
- maxTaskSizeBytes: Maximum task file size in bytes (default: 1048576)Common Use Cases:
`bash
Move tasks to a project-specific directory
stm config --set tasksDir=./project/tasksIncrease timeout for slower systems
stm config --set lockTimeoutMs=60000Allow larger task files (e.g., 5MB)
stm config --set maxTaskSizeBytes=5242880Check current configuration
stm config --listUse in scripts
TASKS_DIR=$(stm config --get tasksDir)
echo "Tasks are stored in: $TASKS_DIR"Reset to defaults when switching projects
stm config --reset tasksDir # Back to .simple-task-master/tasks
stm config --reset lockTimeoutMs # Back to 30 seconds
stm config --reset-all # Reset everything to defaults
`βοΈ Configuration
STM stores its configuration in
.simple-task-master/config.json. You can view and modify these settings using the config command or by editing the JSON file directly.$3
The
config command provides a safe way to view and modify configuration without manually editing JSON:`bash
View current configuration
stm config --listGet a specific value
stm config --get tasksDirChange a setting
stm config --set lockTimeoutMs=45000Reset settings to defaults
stm config --reset tasksDir
stm config --reset-all
`$3
`json
{
"schema": 1,
"lockTimeoutMs": 30000,
"maxTaskSizeBytes": 1048576,
"tasksDir": "./my-tasks"
}
`$3
####
tasksDir (string)
Directory where task files are stored. Can be relative or absolute path.- Default:
.simple-task-master/tasks/
- Valid values: Any valid directory path within the project
- Restrictions:
- Cannot use system directories (/etc, /usr, etc.)
- Cannot contain path traversal sequences (..)
- Must be within the project directory if absoluteExamples:
`bash
Use a project-specific directory
stm config --set tasksDir=./todosUse a nested structure
stm config --set tasksDir=./docs/project-tasksCheck current value
stm config --get tasksDir
`####
lockTimeoutMs (number)
Maximum time in milliseconds to wait for acquiring a file lock. Prevents indefinite waiting when another process is accessing task files.- Default:
30000 (30 seconds)
- Valid values: Positive integer
- Recommended range: 5000-120000 (5-120 seconds)Examples:
`bash
Increase for slower systems or network drives
stm config --set lockTimeoutMs=60000Decrease for faster failure detection
stm config --set lockTimeoutMs=10000
`####
maxTaskSizeBytes (number)
Maximum allowed size for a single task file in bytes. Prevents excessive memory usage and ensures reasonable performance.- Default:
1048576 (1 MB)
- Valid values: Positive integer
- Recommended range: 10240-10485760 (10 KB - 10 MB)Examples:
`bash
Allow larger tasks (2 MB)
stm config --set maxTaskSizeBytes=2097152Allow very large tasks (5 MB)
stm config --set maxTaskSizeBytes=5242880Common sizes:
512 KB = 524288
1 MB = 1048576 (default)
2 MB = 2097152
5 MB = 5242880
10 MB = 10485760
`$3
The config command validates all settings before saving:
-
tasksDir:
- Must be a valid path format
- Cannot contain system directory paths
- Cannot use path traversal (../)
- Shows warning if changing with existing tasks-
lockTimeoutMs:
- Must be a positive integer
- Values below 1000 (1 second) are not recommended
- Very high values may cause long waits-
maxTaskSizeBytes:
- Must be a positive integer
- Values below 1024 (1 KB) are not practical
- Consider system memory when setting high values$3
By default, STM stores tasks in
.simple-task-master/tasks/. However, you can configure a custom directory for task storage, which is useful for:- Organizing tasks in a project-specific location
- Separating tasks from the STM configuration
- Using existing directories for task management
- Following your team's directory structure conventions
#### Setting Up a Custom Task Directory
Option 1: Initialize with a custom directory
`bash
Use a relative path (recommended)
stm init --tasks-dir ./project-tasksUse a nested directory structure
stm init --tasks-dir ./docs/tasksInitialize in an existing directory
stm init --tasks-dir ./existing-tasks-folder
`Option 2: Modify config.json after initialization
`json
{
"schema": 1,
"lockTimeoutMs": 30000,
"maxTaskSizeBytes": 1048576,
"tasksDir": "./my-custom-tasks"
}
`#### Examples
`bash
Initialize with tasks in a 'todo' directory
stm init --tasks-dir ./todoInitialize with tasks in a documentation folder
stm init --tasks-dir ./docs/project-tasksInitialize with deeply nested structure
stm init --tasks-dir ./project/management/tasks
`#### Important Considerations
1. Relative vs Absolute Paths
- Relative paths (recommended): Portable across different systems and users
- Absolute paths: Must be within the project directory for security
2. Git Integration
- STM automatically updates
.gitignore to exclude task files
- The pattern added depends on your custom directory
- Config file remains tracked for team synchronization3. Migration Guide
If you have an existing STM workspace and want to move tasks to a custom directory:
`bash
# 1. Move existing tasks to the new location
mv .simple-task-master/tasks ./my-tasks
# 2. Update config.json
# Add: "tasksDir": "./my-tasks"
# 3. Update .gitignore
# Replace: .simple-task-master/tasks/
# With: my-tasks/
`4. Limitations
- Custom directories cannot be inside
.simple-task-master/
- System directories (/etc, /usr, etc.) are not allowed
- Directory traversal sequences (..) in paths are blocked
- Absolute paths must be within the current projectπ File Structure
Default Structure:
`
project-root/
βββ .simple-task-master/
β βββ config.json # STM configuration
β βββ tasks/ # Default task files directory
β β βββ 1-task-title.md # Individual task files
β β βββ 2-another-task.md
β β βββ ...
β βββ lock # Lock file (temporary)
βββ .gitignore # Updated to exclude tasks/
`With Custom Task Directory:
`
project-root/
βββ .simple-task-master/
β βββ config.json # Contains "tasksDir": "./my-tasks"
β βββ lock # Lock file (temporary)
βββ my-tasks/ # Custom task directory
β βββ 1-task-title.md # Individual task files
β βββ 2-another-task.md
β βββ ...
βββ .gitignore # Updated to exclude my-tasks/
`$3
Each task is stored as a markdown file with YAML frontmatter:
`markdown
---
id: 1
title: 'Implement user authentication'
status: 'pending'
priority: 'high'
tags:
- backend
- security
created: '2024-01-15T10:30:00.000Z'
updated: '2024-01-15T10:30:00.000Z'
dueDate: '2024-01-31'
Custom fields (added by external tools or workflows)
external_id: 'JIRA-456'
sprint: '2024-Q1-Sprint-2'
story_points: 8
---Implement user authentication
Description
Create a secure authentication system using JWT tokens.
Requirements
- [ ] Password hashing with bcrypt
- [ ] JWT token generation
- [ ] Login/logout endpoints
- [ ] Password reset functionality
Notes
Research industry best practices for session management.
`π‘ Usage Examples
$3
`bash
Start your day by checking pending tasks
stm list --status=pending --prettyAdd a new urgent task
stm add "Fix critical production bug" --tags=urgent,bugfix --priority=highStart working on a task and add implementation notes
stm update 5 status=in-progress --details "Started debugging the authentication flow"Update progress with detailed validation checks
stm update 5 --validation - << 'EOF'
β Reproduced the issue locally
β Identified root cause in JWT validation
β³ Working on fix implementation
EOFComplete the task with final validation
npm test | stm update 5 status=done --validation -Review completed work
stm list --status=done --format=table
`$3
`bash
Add feature tasks with tags
stm add "Design user dashboard" --tags=frontend,design --priority=medium
stm add "Implement user API" --tags=backend,api --priority=high
stm add "Write unit tests" --tags=testing --priority=mediumStart working on API implementation with detailed plan
stm update 2 status=in-progress --details "## Implementation Plan
- Design REST endpoints
- Set up authentication middleware
- Implement CRUD operations
- Add input validation"Update progress with specific validation criteria
stm update 2 --validation "## Acceptance Criteria
- [ ] All endpoints documented in OpenAPI
- [ ] Authentication tests pass
- [ ] Error handling implemented
- [ ] Performance benchmarks met"Add urgent tag when priorities change
stm update 2 tags+=urgentComplete with comprehensive validation results
stm update 2 status=done --validation "## Final Validation
β All endpoints implemented and tested
β API documentation updated
β Security review completed
β Performance tests: avg 45ms response time
β Integration tests: 100% passing"Track frontend work
stm list --tags=frontend --prettyExport project status
stm export --format=csv > project-status.csv
`$3
`bash
Automated testing workflow with piped results
npm run test:unit | stm update 15 --validation -
npm run test:integration | stm update 15 --validation -Code review workflow
stm update 23 --desc "Feature implementation complete" --validation "β Code review requested"CI/CD integration - update from build results
if npm run build; then
stm update 18 status=done --validation "β Build successful: $(date)"
else
stm update 18 --validation "β Build failed: $(date)"
fiMulti-step task progression with section updates
stm update 31 status=in-progress --desc "Starting phase 1: Requirements gathering"
stm update 31 --details "$(cat requirements.md)"
stm update 31 --validation "β Requirements approved by stakeholders"Batch updates with assignment syntax
stm update 42 status=done tags+=completed,released desc="Feature deployed to production"Editor-based updates for complex content
stm update 55 # Opens editor for detailed content editingDependency management with array operations
stm update 60 deps+=45,46 # Add dependencies
stm update 60 deps-=32 # Remove dependencyDocumentation sync from external sources
curl -s https://api.example.com/spec | stm update 67 --details -
cat design-notes.md | stm update 67 --desc -
`$3
`bash
Export tasks for team review
stm export --status=pending --format=json > pending-tasks.jsonFind tasks by keyword
stm grep "authentication" --format=tableTrack progress by status
echo "Pending: $(stm list --status=pending --format=json | jq length)"
echo "In Progress: $(stm list --status=in-progress --format=json | jq length)"
echo "Done: $(stm list --status=done --format=json | jq length)"
`$3
`bash
Check current configuration
stm config --listAdjust settings for your workflow
stm config --set tasksDir=./project-tasks
stm config --set maxTaskSizeBytes=2097152 # 2MB for detailed tasksUse configuration in scripts
TASK_DIR=$(stm config --get tasksDir)
MAX_SIZE=$(stm config --get maxTaskSizeBytes)
echo "Tasks stored in: $TASK_DIR (max size: $MAX_SIZE bytes)"Backup configuration before changes
stm config --list > config-backup.jsonVerify changes took effect
stm config --get tasksDir
ls -la $(stm config --get tasksDir)
`$3
STM allows you to add custom metadata fields to tasks, enabling seamless integration with external tools and workflows:
`bash
Add custom fields for external tool integration
stm update 42 external_id="JIRA-1234" priority="P1"Track AutoAgent execution metadata
stm update 56 agent_id="agent-123" execution_time="45s" success=trueAdd project management metadata
stm update 78 sprint="2024-Q1-Sprint-3" story_points=5 assignee="john.doe"Complex metadata with JSON values
stm update 90 metadata='{"tool":"vscode","extensions":["prettier","eslint"]}'View tasks with custom fields (shown in JSON output)
stm show 42 --format=json
Output includes all fields, both core and custom
Export with custom fields preserved
stm export --format=json > tasks-with-metadata.json
`Custom fields are:
- Preserved: Maintained through all operations (create, update, show, export)
- Flexible: Accept any valid string value
- Tool-friendly: Enable external tools to store their own metadata
- Non-validated: STM doesn't validate custom field values (tools manage their own data)
π§ Development
$3
- Node.js >= 18.0.0
- npm or yarn
$3
`bash
Clone the repository
git clone https://github.com/your-username/simple-task-master.git
cd simple-task-masterInstall dependencies
npm installBuild the project
npm run buildRun tests
npm test
`$3
-
npm run build - Compile TypeScript to JavaScript
- npm run dev - Run in development mode with ts-node
- npm test - Run all tests (excludes performance tests)
- npm run test:all - Run ALL tests including performance
- npm run test:unit - Run unit tests only
- npm run test:integration - Run integration tests only
- npm run test:e2e - Run end-to-end tests only
- npm run test:performance - Run performance benchmarks (~3 min)
- npm run test:coverage - Run tests with coverage report
- npm run lint - Lint code with ESLint (includes formatting rules)
- npm run lint:fix - Auto-fix linting and formatting issues
- npm run typecheck - Type check with TypeScript$3
STM has comprehensive test coverage across three levels:
1. Unit Tests: Test individual functions and classes
2. Integration Tests: Test command interactions and file system operations
3. E2E Tests: Test complete CLI workflows
`bash
Run specific test suites
npm run test:unit
npm run test:integration
npm run test:e2eRun with coverage
npm run test:coverageWatch mode for development
npm run test:watch
`$3
`
src/
βββ cli.ts # Main CLI entry point
βββ commands/ # Command implementations
β βββ add.ts
β βββ export.ts
β βββ grep.ts
β βββ init.ts
β βββ list.ts
β βββ show.ts
β βββ update.ts
βββ lib/ # Core library code
β βββ constants.ts # Application constants
β βββ errors.ts # Error classes
β βββ lock-manager.ts # File locking
β βββ output.ts # Output formatting
β βββ schema.ts # Validation schemas
β βββ task-manager.ts # Task CRUD operations
β βββ types.ts # Type definitions
β βββ utils.ts # Utility functions
βββ types/ # TypeScript type definitions
βββ index.ts
`π Performance
STM is optimized for performance with the following characteristics:
- Task Loading: < 50ms for 1000+ tasks
- Search Operations: < 100ms across 10,000+ tasks
- File Operations: Atomic writes with proper locking
- Memory Usage: ~10MB baseline, scales linearly with task count
- Concurrent Safety: File-level locking prevents corruption
$3
- Maximum task file size: 1MB (configurable)
- Recommended maximum tasks: 50,000 per repository
- Lock timeout: 30 seconds (configurable)
- Node.js requirement: >= 18.0.0
π API Behavior for Custom Fields
STM's API allows custom metadata fields in task frontmatter, enabling external tools to extend tasks with their own data:
$3
Core Fields (strictly validated):
-
id, title, status, created, updated: Required with specific types
- tags, dependencies: Optional arrays with validation
- priority, dueDate: Optional with format validationCustom Fields (flexibly handled):
- Any field name: Allowed except those containing newlines or control characters
- Any value type: Stored as-is without validation
- Preservation: Maintained through all operations (create, update, list, show, export)
- No STM validation: External tools manage their own field semantics
$3
When integrating with STM:
1. Choose unique field names: Prefix with your tool name (e.g.,
jira_id, github_issue)
2. Handle your own validation: STM won't validate custom field values
3. Use consistent formats: Maintain your data format across operations
4. Document your fields: Let users know what custom fields your tool adds$3
`javascript
// External tool adding custom metadata
const task = {
title: 'Implement feature',
status: 'pending',
// Custom fields for integration
jira_id: 'PROJ-123',
github_pr: 456,
ci_status: 'passing',
metrics: {
complexity: 'high',
estimated_hours: 8
}
};// STM preserves all custom fields
const updated = await taskManager.create(task);
console.log(updated.jira_id); // 'PROJ-123'
console.log(updated.metrics); // { complexity: 'high', estimated_hours: 8 }
`π Security
STM implements several security measures:
- Input validation: All user inputs are validated and sanitized
- File path validation: Prevents directory traversal attacks
- Safe file operations: Uses atomic writes to prevent corruption
- No remote connections: All data stays local to your machine
- Minimal dependencies: Reduces attack surface
π€ Contributing
We welcome contributions! Please follow these steps:
1. Fork the repository
2. Create a feature branch:
git checkout -b feature/amazing-feature
3. Make your changes and add tests
4. Ensure all tests pass: npm test
5. Lint your code: npm run lint
6. Commit your changes: git commit -m 'feat: add amazing feature'
7. Push to the branch: git push origin feature/amazing-feature
8. Open a Pull Request$3
This project uses Conventional Commits:
-
feat: New features
- fix: Bug fixes
- docs: Documentation changes
- style: Code style changes
- refactor: Code refactoring
- test: Test changes
- chore`: Build process or auxiliary tool changesThis project is licensed under the MIT License - see the LICENSE file for details.
- Issues: GitHub Issues
- Discussions: GitHub Discussions
- Documentation: This README and inline code documentation
---