tm-core is the foundational library that powers Task Master AI's task management system. It provides a comprehensive set of tools for creating, managing, and orchestrating tasks with AI integration.

Features

TypeScript-first: Built with full TypeScript support and strict type checking
Dual Format: Supports both ESM and CommonJS with automatic format detection
Modular Architecture: Clean separation of concerns with dedicated modules for different functionality
AI Provider Integration: Pluggable AI provider system for task generation and management
Flexible Storage: Abstracted storage layer supporting different persistence strategies
Task Parsing: Advanced parsing capabilities for various task definition formats
Error Handling: Comprehensive error system with specific error types
Testing: Complete test coverage with Jest and TypeScript support

Installation

npm install @task-master/tm-core

Usage

Basic Usage

import { generateTaskId, PlaceholderTask } from '@task-master/tm-core';

// Generate a unique task ID
const taskId = generateTaskId();

// Create a task (coming soon - full implementation)
const task: PlaceholderTask = {
  id: taskId,
  title: 'My Task',
  status: 'pending',
  priority: 'medium'
};

Modular Imports

You can import specific modules to reduce bundle size:

// Import types only
import type { TaskId, TaskStatus } from '@task-master/tm-core/types';

// Import utilities
import { generateTaskId, formatDate } from '@task-master/tm-core/utils';

// Import providers (AI providers coming soon)
// import { AIProvider } from '@task-master/tm-core/providers';

// Import storage
import { PlaceholderStorage } from '@task-master/tm-core/storage';

// Import parsers
import { PlaceholderParser } from '@task-master/tm-core/parser';

// Import errors
import { TmCoreError, TaskNotFoundError } from '@task-master/tm-core/errors';

Architecture

The library is organized into several key modules:

types/: TypeScript type definitions and interfaces
providers/: AI provider implementations for task generation
storage/: Storage adapters for different persistence strategies
parser/: Task parsing utilities for various formats
utils/: Common utility functions and helpers
errors/: Custom error classes and error handling

Development

Prerequisites

Node.js >= 18.0.0
npm or yarn

Setup

# Install dependencies
npm install

# Build the library
npm run build

# Run tests
npm test

# Run tests with coverage
npm run test:coverage

# Lint code
npm run lint

# Format code
npm run format

Scripts

build: Build the library for both ESM and CJS formats
build:watch: Build in watch mode for development
test: Run the test suite
test:watch: Run tests in watch mode
test:coverage: Run tests with coverage reporting
lint: Lint TypeScript files
lint:fix: Lint and auto-fix issues
format: Format code with Prettier
format:check: Check code formatting
typecheck: Type-check without emitting files
clean: Clean build artifacts
dev: Development mode with watch

ESM and CommonJS Support

This package supports both ESM and CommonJS formats automatically:

// ESM
import { generateTaskId } from '@task-master/tm-core';

// CommonJS
const { generateTaskId } = require('@task-master/tm-core');

Roadmap

This is the initial package structure. The following features are planned for implementation:

Task 116: TypeScript Types

Complete type definitions for tasks, projects, and configurations
Zod schema validation
Generic type utilities

Task 117: AI Provider System

Base provider interface
Anthropic Claude integration
OpenAI integration
Perplexity integration
Provider factory and registry

Task 118: Storage Layer

File system storage adapter
Memory storage adapter
Storage interface and factory

Task 119: Task Parser

PRD parser implementation
Markdown parser
JSON task format parser
Validation utilities

Task 120: Utility Functions

Task ID generation
Date formatting
Validation helpers
File system utilities

Task 121: Error Handling

Task-specific errors
Storage errors
Provider errors
Validation errors

Task 122: Configuration System

Configuration schema
Default configurations
Environment variable support

Task 123: Testing Infrastructure

Unit test coverage
Integration tests
Mock utilities

Task 124: Documentation

API documentation
Usage examples
Migration guides

Task 125: Package Finalization

Final testing and validation
Release preparation
CI/CD integration

Implementation Checklist

✅ Task 115: Initialize tm-core Package Structure (COMPLETED)

Create tm-core directory structure and base configuration files
Configure build and test infrastructure
Create barrel export files for all directories
Add development tooling and documentation
Validate package structure and prepare for development

🚧 Remaining Implementation Tasks

Task 116: TypeScript Types - Complete type definitions for tasks, projects, and configurations
Task 117: AI Provider System - Base provider interface and integrations
Task 118: Storage Layer - File system and memory storage adapters
Task 119: Task Parser - PRD, Markdown, and JSON parsers
Task 120: Utility Functions - Task ID generation, validation helpers
Task 121: Error Handling - Task-specific and validation errors
Task 122: Configuration System - Schema and environment support
Task 123: Testing Infrastructure - Complete unit and integration tests
Task 124: Documentation - API docs and usage examples
Task 125: Package Finalization - Release preparation and CI/CD

Contributing

This package is part of the Task Master AI project. Please refer to the main project's contributing guidelines.

License

MIT - See the main project's LICENSE file for details.

Support

For questions and support, please refer to the main Task Master AI documentation.