Module 19: Capstone Project

task-tracker/
  src/
    index.ts          # Entry point
    types.ts          # Type definitions
    task-store.ts     # Core logic
    cli.ts            # CLI interface
  tests/
    task-store.test.ts
  package.json
  tsconfig.json
  .gitignore

mkdir ~/task-tracker
cd ~/task-tracker
npm init -y
npm install --save-dev typescript vitest @types/node

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "commonjs",
    "lib": ["ES2022"],
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
    "skipLibCheck": true,
    "declaration": true,
    "sourceMap": true,
    "resolveJsonModule": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist", "tests"]
}

node_modules/
dist/
coverage/
*.js.map
.DS_Store

{
  "scripts": {
    "build": "tsc",
    "start": "node dist/index.js",
    "dev": "npx ts-node src/index.ts",
    "test": "vitest run",
    "test:watch": "vitest",
    "clean": "rm -rf dist"
  }
}

mkdir src tests

// src/types.ts

export type Priority = "low" | "medium" | "high";
export type Status = "todo" | "in-progress" | "done";

export interface Task {
    id: number;
    title: string;
    description: string;
    priority: Priority;
    status: Status;
    createdAt: Date;
    completedAt: Date | null;
}

export interface TaskFilter {
    status?: Status;
    priority?: Priority;
    search?: string;
}

export interface TaskStats {
    total: number;
    todo: number;
    inProgress: number;
    done: number;
    byPriority: Record<Priority, number>;
}

export type CreateTaskInput = Pick<Task, "title" | "description" | "priority">;
export type UpdateTaskInput = Partial<Pick<Task, "title" | "description" | "priority" | "status">>;

// src/task-store.ts
import { Task, CreateTaskInput, UpdateTaskInput, TaskFilter, TaskStats, Status, Priority } from "./types";

export class TaskStore {
    private tasks: Task[] = [];
    private nextId = 1;

    add(input: CreateTaskInput): Task {
        const task: Task = {
            id: this.nextId++,
            title: input.title,
            description: input.description,
            priority: input.priority,
            status: "todo",
            createdAt: new Date(),
            completedAt: null,
        };
        this.tasks.push(task);
        return task;
    }

    getById(id: number): Task | undefined {
        return this.tasks.find(t => t.id === id);
    }

    update(id: number, input: UpdateTaskInput): Task {
        const task = this.getById(id);
        if (!task) throw new Error(`Task ${id} not found`);

        if (input.title !== undefined) task.title = input.title;
        if (input.description !== undefined) task.description = input.description;
        if (input.priority !== undefined) task.priority = input.priority;
        if (input.status !== undefined) {
            task.status = input.status;
            task.completedAt = input.status === "done" ? new Date() : null;
        }

        return task;
    }

    delete(id: number): boolean {
        const index = this.tasks.findIndex(t => t.id === id);
        if (index === -1) return false;
        this.tasks.splice(index, 1);
        return true;
    }

    list(filter?: TaskFilter): Task[] {
        let results = [...this.tasks];

        if (filter?.status) {
            results = results.filter(t => t.status === filter.status);
        }
        if (filter?.priority) {
            results = results.filter(t => t.priority === filter.priority);
        }
        if (filter?.search) {
            const term = filter.search.toLowerCase();
            results = results.filter(
                t => t.title.toLowerCase().includes(term) ||
                     t.description.toLowerCase().includes(term)
            );
        }

        return results;
    }

    getStats(): TaskStats {
        const stats: TaskStats = {
            total: this.tasks.length,
            todo: 0,
            inProgress: 0,
            done: 0,
            byPriority: { low: 0, medium: 0, high: 0 },
        };

        for (const task of this.tasks) {
            if (task.status === "todo") stats.todo++;
            else if (task.status === "in-progress") stats.inProgress++;
            else if (task.status === "done") stats.done++;

            stats.byPriority[task.priority]++;
        }

        return stats;
    }

    clear(): void {
        this.tasks = [];
        this.nextId = 1;
    }
}

// src/cli.ts
import { TaskStore } from "./task-store";
import { Priority, Status, Task } from "./types";

export function formatTask(task: Task): string {
    const statusIcon = task.status === "done" ? "[x]" : task.status === "in-progress" ? "[~]" : "[ ]";
    const priorityTag = `(${task.priority})`;
    return `${statusIcon} #${task.id} ${priorityTag} ${task.title}`;
}

export function formatTaskDetail(task: Task): string {
    const lines = [
        `Task #${task.id}`,
        `  Title:       ${task.title}`,
        `  Description: ${task.description}`,
        `  Priority:    ${task.priority}`,
        `  Status:      ${task.status}`,
        `  Created:     ${task.createdAt.toISOString()}`,
    ];
    if (task.completedAt) {
        lines.push(`  Completed:   ${task.completedAt.toISOString()}`);
    }
    return lines.join("\n");
}

export function runCli(store: TaskStore, args: string[]): string {
    const command = args[0];

    switch (command) {
        case "add": {
            const title = args[1];
            const description = args[2] || "";
            const priority = (args[3] as Priority) || "medium";
            if (!title) return "Usage: add <title> [description] [low|medium|high]";
            const task = store.add({ title, description, priority });
            return `Added: ${formatTask(task)}`;
        }

        case "list": {
            const filter = args[1] as Status | undefined;
            const tasks = store.list(filter ? { status: filter } : undefined);
            if (tasks.length === 0) return "No tasks found.";
            return tasks.map(formatTask).join("\n");
        }

        case "view": {
            const id = parseInt(args[1]);
            if (isNaN(id)) return "Usage: view <id>";
            const task = store.getById(id);
            if (!task) return `Task ${id} not found.`;
            return formatTaskDetail(task);
        }

        case "done": {
            const id = parseInt(args[1]);
            if (isNaN(id)) return "Usage: done <id>";
            try {
                const task = store.update(id, { status: "done" });
                return `Completed: ${formatTask(task)}`;
            } catch (err) {
                return (err as Error).message;
            }
        }

        case "delete": {
            const id = parseInt(args[1]);
            if (isNaN(id)) return "Usage: delete <id>";
            return store.delete(id) ? `Deleted task #${id}.` : `Task ${id} not found.`;
        }

        case "stats": {
            const stats = store.getStats();
            return [
                `Total: ${stats.total}`,
                `  Todo:        ${stats.todo}`,
                `  In Progress: ${stats.inProgress}`,
                `  Done:        ${stats.done}`,
                `  High:        ${stats.byPriority.high}`,
                `  Medium:      ${stats.byPriority.medium}`,
                `  Low:         ${stats.byPriority.low}`,
            ].join("\n");
        }

        default:
            return [
                "Task Tracker Commands:",
                "  add <title> [description] [priority]  — Add a task",
                "  list [status]                         — List tasks",
                "  view <id>                             — View task details",
                "  done <id>                             — Mark task as done",
                "  delete <id>                           — Delete a task",
                "  stats                                 — Show statistics",
            ].join("\n");
    }
}

// src/index.ts
import { TaskStore } from "./task-store";
import { runCli } from "./cli";

const store = new TaskStore();

// Demo: simulate a series of CLI commands
const commands = [
    ["help"],
    ["add", "Learn TypeScript", "Complete all 20 days", "high"],
    ["add", "Write tests", "Unit test the task tracker", "high"],
    ["add", "Read documentation", "Read the TypeScript handbook", "medium"],
    ["add", "Clean up code", "Refactor old exercises", "low"],
    ["list"],
    ["done", "1"],
    ["stats"],
    ["view", "2"],
    ["list", "todo"],
    ["delete", "4"],
    ["list"],
];

for (const args of commands) {
    console.log(`\n> task ${args.join(" ")}`);
    console.log(runCli(store, args));
}

// tests/task-store.test.ts
import { describe, it, expect, beforeEach } from "vitest";
import { TaskStore } from "../src/task-store";

describe("TaskStore", () => {
    let store: TaskStore;

    beforeEach(() => {
        store = new TaskStore();
    });

    describe("add", () => {
        it("creates a task with correct properties", () => {
            const task = store.add({ title: "Test", description: "Desc", priority: "high" });
            expect(task.id).toBe(1);
            expect(task.title).toBe("Test");
            expect(task.status).toBe("todo");
            expect(task.completedAt).toBeNull();
        });

        it("auto-increments ids", () => {
            const t1 = store.add({ title: "A", description: "", priority: "low" });
            const t2 = store.add({ title: "B", description: "", priority: "low" });
            expect(t2.id).toBe(t1.id + 1);
        });
    });

    describe("getById", () => {
        it("finds existing task", () => {
            const task = store.add({ title: "Find me", description: "", priority: "medium" });
            expect(store.getById(task.id)?.title).toBe("Find me");
        });

        it("returns undefined for missing task", () => {
            expect(store.getById(999)).toBeUndefined();
        });
    });

    describe("update", () => {
        it("updates task properties", () => {
            const task = store.add({ title: "Old", description: "", priority: "low" });
            const updated = store.update(task.id, { title: "New", priority: "high" });
            expect(updated.title).toBe("New");
            expect(updated.priority).toBe("high");
        });

        it("sets completedAt when status is done", () => {
            const task = store.add({ title: "Task", description: "", priority: "medium" });
            const done = store.update(task.id, { status: "done" });
            expect(done.completedAt).toBeInstanceOf(Date);
        });

        it("throws for missing task", () => {
            expect(() => store.update(999, { title: "X" })).toThrow("not found");
        });
    });

    describe("delete", () => {
        it("removes existing task", () => {
            const task = store.add({ title: "Delete me", description: "", priority: "low" });
            expect(store.delete(task.id)).toBe(true);
            expect(store.getById(task.id)).toBeUndefined();
        });

        it("returns false for missing task", () => {
            expect(store.delete(999)).toBe(false);
        });
    });

    describe("list", () => {
        beforeEach(() => {
            store.add({ title: "Low task", description: "desc", priority: "low" });
            store.add({ title: "High task", description: "important", priority: "high" });
            store.add({ title: "Medium task", description: "normal", priority: "medium" });
        });

        it("returns all tasks without filter", () => {
            expect(store.list()).toHaveLength(3);
        });

        it("filters by priority", () => {
            const high = store.list({ priority: "high" });
            expect(high).toHaveLength(1);
            expect(high[0].title).toBe("High task");
        });

        it("filters by search term", () => {
            const results = store.list({ search: "important" });
            expect(results).toHaveLength(1);
            expect(results[0].title).toBe("High task");
        });

        it("filters by status", () => {
            store.update(1, { status: "done" });
            const done = store.list({ status: "done" });
            expect(done).toHaveLength(1);
        });
    });

    describe("getStats", () => {
        it("returns correct statistics", () => {
            store.add({ title: "A", description: "", priority: "high" });
            store.add({ title: "B", description: "", priority: "medium" });
            store.add({ title: "C", description: "", priority: "high" });
            store.update(2, { status: "done" });

            const stats = store.getStats();
            expect(stats.total).toBe(3);
            expect(stats.todo).toBe(2);
            expect(stats.done).toBe(1);
            expect(stats.byPriority.high).toBe(2);
            expect(stats.byPriority.medium).toBe(1);
        });
    });
});

# Run the tests
npm test

# Build the project
npm run build

# Run the compiled output
npm start

# Verify the dist/ directory structure
ls dist/