@x4lt7ab/tab-for-projects 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@x4lt7ab/tab-for-projects",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "bin": {
     "tab-for-projects": "./src/index.ts"
@@ -12,7 +12,7 @@
     "bun": ">=1.3"
   },
   "scripts": {
-    "dev": "bun run --hot src/index.ts & cd src/web && vite",
+    "dev": "concurrently --kill-others --names 'api,web' \"bun run --watch src/index.ts\" \"cd src/web && vite\"",
     "build": "cd src/web && vite build",
     "start": "bun run src/index.ts",
     "serve": "bun run build && bun run start",
@@ -20,8 +20,7 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.27.1",
-    "@x4lt7ab/tab-for-projects": "/Users/alttab/AltT4b/project-management",
+    "@modelcontextprotocol/sdk": "1.27.1",
     "hono": "^4",
     "ulid": "^2",
     "zod": "^4.3.6"
@@ -31,9 +30,11 @@
     "@types/react": "^19.1.2",
     "@types/react-dom": "^19.1.2",
     "@vitejs/plugin-react": "^4.4.1",
+    "concurrently": "^9.2.1",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
     "typescript": "^5.8.3",
-    "vite": "^6.3.5"
+    "vite": "^6.3.5",
+    "vite-plugin-webfont-dl": "^3"
   }
 }

package/src/domain/args.ts

@@ -9,7 +9,7 @@ export interface ServerOptions {
 export function parseArgs(defaults: { port: number; portEnv: string }): ServerOptions {
   const args = process.argv.slice(2);
   let port = Number(process.env[defaults.portEnv]) || defaults.port;
-  let host = process.env.PM_HOST ?? "127.0.0.1";
+  let host = process.env.PM_HOST ?? "0.0.0.0";
   let dbPath: string | undefined = process.env.SQLITE_PATH;
 
   for (let i = 0; i < args.length; i++) {
@@ -29,6 +29,16 @@ export function getNetworkAddress(): string | undefined {
   }
 }
 
+export function parseCorsOrigins(envValue?: string): (origin: string) => boolean {
+  if (!envValue) {
+    return (origin) =>
+      origin.startsWith("http://localhost") || origin.startsWith("http://127.0.0.1");
+  }
+  if (envValue.trim() === "*") return () => true;
+  const allowed = new Set(envValue.split(",").map(s => s.trim()).filter(Boolean));
+  return (origin) => allowed.has(origin);
+}
+
 export function logListening(name: string, host: string, port: number): void {
   const displayHost = host === "0.0.0.0" ? "localhost" : host;
   console.error(`${name} listening on http://${displayHost}:${port}`);

package/src/domain/bootstrap.ts

@@ -3,24 +3,32 @@ import { createDatabase } from "./db/connection";
 import { runMigrations } from "./db/schema";
 import { ProjectRepository } from "./repositories/projects";
 import { TaskRepository } from "./repositories/tasks";
+import { TagRepository } from "./repositories/tags";
 import { ProjectService } from "./services/projects";
 import { TaskService } from "./services/tasks";
-import type { IProjectService, ITaskService } from "./services";
+import { TagService } from "./services/tags";
+import type { IProjectService, ITaskService, ITagService } from "./services";
+import { EventBus } from "./events";
 
 export interface AppContext {
   db: Database;
   projectService: IProjectService;
   taskService: ITaskService;
+  tagService: ITagService;
+  eventBus: EventBus;
 }
 
 export function bootstrap(dbPath?: string): AppContext {
   const db = createDatabase(dbPath);
   runMigrations(db);
 
+  const eventBus = new EventBus();
   const projectRepo = new ProjectRepository(db);
   const taskRepo = new TaskRepository(db);
-  const projectService = new ProjectService(projectRepo);
-  const taskService = new TaskService(taskRepo, projectRepo);
+  const tagRepo = new TagRepository(db);
+  const projectService = new ProjectService(projectRepo, eventBus);
+  const taskService = new TaskService(taskRepo, projectRepo, eventBus);
+  const tagService = new TagService(tagRepo, taskRepo);
 
-  return { db, projectService, taskService };
+  return { db, projectService, taskService, tagService, eventBus };
 }

package/src/domain/db/schema.ts

@@ -1,8 +1,4 @@
 import type { Database } from "bun:sqlite";
-import { PROJECT_STATUSES, TASK_STATUSES } from "../statuses";
-
-const projectStatusCheck = PROJECT_STATUSES.map((s) => `'${s}'`).join(", ");
-const taskStatusCheck = TASK_STATUSES.map((s) => `'${s}'`).join(", ");
 
 export function runMigrations(db: Database): void {
   db.run(`
@@ -12,7 +8,7 @@ export function runMigrations(db: Database): void {
       name        TEXT NOT NULL,
       description TEXT NOT NULL DEFAULT '',
       status      TEXT NOT NULL DEFAULT 'active'
-                  CHECK (status IN (${projectStatusCheck})),
+                  CHECK (status IN ('active', 'paused', 'completed', 'archived')),
       created_at  TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
       updated_at  TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
     )
@@ -24,12 +20,37 @@ export function runMigrations(db: Database): void {
     CREATE TABLE IF NOT EXISTS tasks (
       id          TEXT PRIMARY KEY,
       project_id  TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      number      INTEGER NOT NULL,
       title       TEXT NOT NULL,
       description TEXT NOT NULL DEFAULT '',
       status      TEXT NOT NULL DEFAULT 'todo'
-                  CHECK (status IN (${taskStatusCheck})),
+                  CHECK (status IN ('todo', 'in_progress', 'done')),
+      priority    INTEGER CHECK (priority BETWEEN 1 AND 10),
       created_at  TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
-      updated_at  TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+      updated_at  TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+      UNIQUE(project_id, number)
+    )
+  `);
+
+  db.run("CREATE INDEX IF NOT EXISTS idx_tasks_project_id ON tasks(project_id)");
+  db.run("CREATE INDEX IF NOT EXISTS idx_tasks_project_number ON tasks(project_id, number)");
+
+  // ── Tags ──────────────────────────────────────────────────
+  db.run(`
+    CREATE TABLE IF NOT EXISTS tags (
+      id         TEXT PRIMARY KEY,
+      name       TEXT NOT NULL UNIQUE,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+    )
+  `);
+
+  db.run(`
+    CREATE TABLE IF NOT EXISTS task_tags (
+      task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+      tag_id  TEXT NOT NULL REFERENCES tags(id)  ON DELETE CASCADE,
+      PRIMARY KEY (task_id, tag_id)
     )
   `);
+
+  db.run("CREATE INDEX IF NOT EXISTS idx_task_tags_tag_id ON task_tags(tag_id)");
 }

package/src/domain/entities.ts

@@ -13,9 +13,17 @@ export interface Project {
 export interface Task {
   id: string;
   project_id: string;
+  number: number;
   title: string;
   description: string;
   status: TaskStatus;
+  priority: number | null;
   created_at: string;
   updated_at: string;
 }
+
+export interface Tag {
+  id: string;
+  name: string;
+  created_at: string;
+}

package/src/domain/events.ts

@@ -0,0 +1,26 @@
+import type { Project, Task } from "./entities";
+
+export type DomainEvent =
+  | { entity: "project"; action: "created" | "updated" | "deleted"; payload: Project | { id: string } }
+  | { entity: "task"; action: "created" | "updated" | "deleted"; payload: Task | { id: string } };
+
+type Listener = (event: DomainEvent) => void;
+
+export class EventBus {
+  private listeners = new Set<Listener>();
+
+  subscribe(fn: Listener): () => void {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+
+  emit(event: DomainEvent): void {
+    for (const fn of this.listeners) {
+      try {
+        fn(event);
+      } catch {
+        // listener errors must not break the emitter
+      }
+    }
+  }
+}

package/src/domain/index.ts

@@ -3,10 +3,13 @@ export * from "./entities";
 export * from "./inputs";
 export * from "./errors";
 export * from "./services";
+export * from "./events";
 export * from "./bootstrap";
 export { createDatabase, getDbPath } from "./db/connection";
 export { runMigrations } from "./db/schema";
 export { ProjectRepository } from "./repositories/projects";
 export { TaskRepository } from "./repositories/tasks";
+export { TagRepository } from "./repositories/tags";
 export { ProjectService } from "./services/projects";
 export { TaskService } from "./services/tasks";
+export { TagService } from "./services/tags";

package/src/domain/inputs.ts

@@ -8,6 +8,6 @@ export type UpdateProjectInput = Partial<
 >;
 
 export type CreateTaskInput = Pick<Task, "title"> &
-  Partial<Pick<Task, "description" | "status">>;
+  Partial<Pick<Task, "description" | "status" | "priority">>;
 
-export type UpdateTaskInput = Partial<Pick<Task, "title" | "description" | "status">>;
+export type UpdateTaskInput = Partial<Pick<Task, "title" | "description" | "status" | "priority">>;

package/src/domain/repositories/projects.ts

@@ -2,14 +2,27 @@ import type { Database } from "bun:sqlite";
 import { ulid } from "ulid";
 import type { Project } from "../entities";
 import type { CreateProjectInput, UpdateProjectInput } from "../inputs";
+import type { ProjectFilter } from "../services";
 
 export class ProjectRepository {
   constructor(private db: Database) {}
 
-  findAll(): Project[] {
+  findAll(limit: number, offset: number, filter?: ProjectFilter): Project[] {
+    if (filter?.status) {
+      return this.db
+        .query("SELECT * FROM projects WHERE status = ? ORDER BY created_at DESC LIMIT ? OFFSET ?")
+        .all(filter.status, limit, offset) as Project[];
+    }
     return this.db
-      .query("SELECT * FROM projects ORDER BY created_at DESC")
-      .all() as Project[];
+      .query("SELECT * FROM projects ORDER BY created_at DESC LIMIT ? OFFSET ?")
+      .all(limit, offset) as Project[];
+  }
+
+  count(filter?: ProjectFilter): number {
+    if (filter?.status) {
+      return (this.db.query("SELECT COUNT(*) as total FROM projects WHERE status = ?").get(filter.status) as { total: number }).total;
+    }
+    return (this.db.query("SELECT COUNT(*) as total FROM projects").get() as { total: number }).total;
   }
 
   findById(id: string): Project | null {

package/src/domain/repositories/tags.ts

@@ -0,0 +1,77 @@
+import type { Database } from "bun:sqlite";
+import { ulid } from "ulid";
+import type { Tag, Task } from "../entities";
+
+export class TagRepository {
+  constructor(private db: Database) {}
+
+  findAll(limit: number, offset: number): Tag[] {
+    return this.db
+      .query("SELECT * FROM tags ORDER BY name ASC LIMIT ? OFFSET ?")
+      .all(limit, offset) as Tag[];
+  }
+
+  count(): number {
+    return (this.db.query("SELECT COUNT(*) as total FROM tags").get() as { total: number }).total;
+  }
+
+  findById(id: string): Tag | null {
+    return this.db.query("SELECT * FROM tags WHERE id = ?").get(id) as Tag | null;
+  }
+
+  findByName(name: string): Tag | null {
+    return this.db.query("SELECT * FROM tags WHERE name = ?").get(name) as Tag | null;
+  }
+
+  create(name: string): Tag {
+    const id = ulid();
+    this.db.query("INSERT INTO tags (id, name) VALUES (?, ?)").run(id, name);
+    return this.db.query("SELECT * FROM tags WHERE id = ?").get(id) as Tag;
+  }
+
+  delete(id: string): boolean {
+    const result = this.db.query("DELETE FROM tags WHERE id = ?").run(id);
+    return result.changes > 0;
+  }
+
+  addTagToTask(taskId: string, tagId: string): void {
+    this.db
+      .query("INSERT OR IGNORE INTO task_tags (task_id, tag_id) VALUES (?, ?)")
+      .run(taskId, tagId);
+  }
+
+  removeTagFromTask(taskId: string, tagId: string): boolean {
+    const result = this.db
+      .query("DELETE FROM task_tags WHERE task_id = ? AND tag_id = ?")
+      .run(taskId, tagId);
+    return result.changes > 0;
+  }
+
+  getTagsForTask(taskId: string): Tag[] {
+    return this.db
+      .query(
+        `SELECT t.* FROM tags t
+         JOIN task_tags tt ON tt.tag_id = t.id
+         WHERE tt.task_id = ?
+         ORDER BY t.name ASC`
+      )
+      .all(taskId) as Tag[];
+  }
+
+  findTasksByTag(tagId: string, limit: number, offset: number): Task[] {
+    return this.db
+      .query(
+        `SELECT t.* FROM tasks t
+         JOIN task_tags tt ON tt.task_id = t.id
+         WHERE tt.tag_id = ?
+         ORDER BY t.created_at ASC LIMIT ? OFFSET ?`
+      )
+      .all(tagId, limit, offset) as Task[];
+  }
+
+  countTasksByTag(tagId: string): number {
+    return (this.db.query(
+      "SELECT COUNT(*) as total FROM task_tags WHERE tag_id = ?"
+    ).get(tagId) as { total: number }).total;
+  }
+}

package/src/domain/repositories/tasks.ts

@@ -1,62 +1,104 @@
 import type { Database } from "bun:sqlite";
 import { ulid } from "ulid";
 import type { Task } from "../entities";
-import type { CreateTaskInput } from "../inputs";
-import type { UpdateTaskInput } from "../inputs";
+import type { CreateTaskInput, UpdateTaskInput } from "../inputs";
+import type { TaskFilter } from "../services";
 
 export class TaskRepository {
   constructor(private db: Database) {}
 
-  findByProject(projectId: string): Task[] {
+  findByProject(projectId: string, limit: number, offset: number, filter?: TaskFilter): Task[] {
+    if (filter?.tag) {
+      const statusClause = filter.status ? "AND t.status = ?" : "";
+      return this.db
+        .query(
+          `SELECT t.* FROM tasks t
+           JOIN task_tags tt ON tt.task_id = t.id
+           JOIN tags tg ON tg.id = tt.tag_id
+           WHERE tg.name = ? AND t.project_id = ? ${statusClause}
+           ORDER BY t.created_at ASC LIMIT ? OFFSET ?`
+        )
+        .all(filter.tag, projectId, ...(filter.status ? [filter.status] : []), limit, offset) as Task[];
+    }
+    if (filter?.status) {
+      return this.db
+        .query("SELECT * FROM tasks WHERE project_id = ? AND status = ? ORDER BY created_at ASC LIMIT ? OFFSET ?")
+        .all(projectId, filter.status, limit, offset) as Task[];
+    }
     return this.db
-      .query("SELECT * FROM tasks WHERE project_id = ? ORDER BY created_at ASC")
-      .all(projectId) as Task[];
+      .query("SELECT * FROM tasks WHERE project_id = ? ORDER BY created_at ASC LIMIT ? OFFSET ?")
+      .all(projectId, limit, offset) as Task[];
+  }
+
+  countByProject(projectId: string, filter?: TaskFilter): number {
+    if (filter?.tag) {
+      const statusClause = filter.status ? "AND t.status = ?" : "";
+      return (this.db.query(
+        `SELECT COUNT(*) as total FROM tasks t
+         JOIN task_tags tt ON tt.task_id = t.id
+         JOIN tags tg ON tg.id = tt.tag_id
+         WHERE tg.name = ? AND t.project_id = ? ${statusClause}`
+      ).get(filter.tag, projectId, ...(filter.status ? [filter.status] : [])) as { total: number }).total;
+    }
+    if (filter?.status) {
+      return (this.db.query("SELECT COUNT(*) as total FROM tasks WHERE project_id = ? AND status = ?").get(projectId, filter.status) as { total: number }).total;
+    }
+    return (this.db.query("SELECT COUNT(*) as total FROM tasks WHERE project_id = ?").get(projectId) as { total: number }).total;
+  }
+
+  findByNumber(projectId: string, number: number): Task | null {
+    return this.db
+      .query("SELECT * FROM tasks WHERE project_id = ? AND number = ?")
+      .get(projectId, number) as Task | null;
+  }
+
+  findById(id: string): Task | null {
+    return this.db.query("SELECT * FROM tasks WHERE id = ?").get(id) as Task | null;
   }
 
   create(projectId: string, input: CreateTaskInput): Task {
     const id = ulid();
     const now = new Date().toISOString();
 
-    this.db
-      .query(
-        `INSERT INTO tasks (id, project_id, title, description, status, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?)`
-      )
-      .run(
-        id,
-        projectId,
-        input.title,
-        input.description ?? "",
-        input.status ?? "todo",
-        now,
-        now
-      );
+    this.db.transaction(() => {
+      const row = this.db
+        .query("SELECT COALESCE(MAX(number), 0) + 1 as next_number FROM tasks WHERE project_id = ?")
+        .get(projectId) as { next_number: number };
+
+      this.db
+        .query(
+          `INSERT INTO tasks (id, project_id, number, title, description, status, priority, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+        )
+        .run(id, projectId, row.next_number, input.title, input.description ?? "", input.status ?? "todo", input.priority ?? null, now, now);
+    })();
 
     return this.db.query("SELECT * FROM tasks WHERE id = ?").get(id) as Task;
   }
 
-  update(id: string, input: UpdateTaskInput): Task | null {
+  update(id: string, projectId: string, input: UpdateTaskInput): Task | null {
     const existing = this.db
-      .query("SELECT * FROM tasks WHERE id = ?")
-      .get(id) as Task | null;
+      .query("SELECT * FROM tasks WHERE id = ? AND project_id = ?")
+      .get(id, projectId) as Task | null;
     if (!existing) return null;
 
     const title = input.title ?? existing.title;
     const description = input.description ?? existing.description;
     const status = input.status ?? existing.status;
+    const priority = input.priority !== undefined ? input.priority : existing.priority;
     const now = new Date().toISOString();
 
     this.db
       .query(
-        `UPDATE tasks SET title = ?, description = ?, status = ?, updated_at = ? WHERE id = ?`
+        `UPDATE tasks SET title = ?, description = ?, status = ?, priority = ?, updated_at = ? WHERE id = ? AND project_id = ?`
       )
-      .run(title, description, status, now, id);
+      .run(title, description, status, priority, now, id, projectId);
 
-    return this.db.query("SELECT * FROM tasks WHERE id = ?").get(id) as Task;
+    return this.db.query("SELECT * FROM tasks WHERE id = ? AND project_id = ?").get(id, projectId) as Task;
   }
 
-  delete(id: string): boolean {
-    const result = this.db.query("DELETE FROM tasks WHERE id = ?").run(id);
+  delete(id: string, projectId: string): boolean {
+    const result = this.db.query("DELETE FROM tasks WHERE id = ? AND project_id = ?").run(id, projectId);
     return result.changes > 0;
   }
 }

package/src/domain/services/projects.ts

@@ -1,17 +1,21 @@
 import type { Project } from "../entities";
 import type { CreateProjectInput, UpdateProjectInput } from "../inputs";
-import type { IProjectService } from "../services";
+import type { IProjectService, Paginated, ProjectFilter } from "../services";
 import { ServiceError } from "../errors";
 import type { ProjectRepository } from "../repositories/projects";
 import { PROJECT_STATUSES } from "../statuses";
+import type { EventBus } from "../events";
 
 const SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 
 export class ProjectService implements IProjectService {
-  constructor(private repo: ProjectRepository) {}
+  constructor(private repo: ProjectRepository, private eventBus?: EventBus) {}
 
-  findAll(): Project[] {
-    return this.repo.findAll();
+  findAll(limit = 50, offset = 0, filter?: ProjectFilter): Paginated<Project> {
+    return {
+      data: this.repo.findAll(limit, offset, filter),
+      total: this.repo.count(filter),
+    };
   }
 
   findBySlug(slug: string): Project | null {
@@ -43,7 +47,9 @@ export class ProjectService implements IProjectService {
     if (this.repo.findBySlug(input.slug)) {
       throw new ServiceError("slug already exists", 409);
     }
-    return this.repo.create(input);
+    const project = this.repo.create(input);
+    this.eventBus?.emit({ entity: "project", action: "created", payload: project });
+    return project;
   }
 
   update(slug: string, input: UpdateProjectInput): Project | null {
@@ -59,10 +65,19 @@ export class ProjectService implements IProjectService {
     if (input.status !== undefined && !(PROJECT_STATUSES as readonly string[]).includes(input.status)) {
       throw new ServiceError(`status must be one of: ${PROJECT_STATUSES.join(", ")}`, 400);
     }
-    return this.repo.update(slug, input);
+    const project = this.repo.update(slug, input);
+    if (project) {
+      this.eventBus?.emit({ entity: "project", action: "updated", payload: project });
+    }
+    return project;
   }
 
   delete(slug: string): boolean {
-    return this.repo.delete(slug);
+    const project = this.repo.findBySlug(slug);
+    const deleted = this.repo.delete(slug);
+    if (deleted && project) {
+      this.eventBus?.emit({ entity: "project", action: "deleted", payload: { id: project.id } });
+    }
+    return deleted;
   }
 }

package/src/domain/services/tags.ts

@@ -0,0 +1,85 @@
+import type { Tag, Task } from "../entities";
+import type { ITagService, Paginated } from "../services";
+import { ServiceError } from "../errors";
+import type { TagRepository } from "../repositories/tags";
+import type { TaskRepository } from "../repositories/tasks";
+
+export class TagService implements ITagService {
+  constructor(
+    private tagRepo: TagRepository,
+    private taskRepo: TaskRepository,
+  ) {}
+
+  findAll(limit = 100, offset = 0): Paginated<Tag> {
+    return {
+      data: this.tagRepo.findAll(limit, offset),
+      total: this.tagRepo.count(),
+    };
+  }
+
+  findByName(name: string): Tag | null {
+    return this.tagRepo.findByName(name);
+  }
+
+  create(name: string): Tag {
+    const trimmed = name.trim().toLowerCase();
+    if (!trimmed) {
+      throw new ServiceError("tag name is required", 400);
+    }
+    if (trimmed.length > 50) {
+      throw new ServiceError("tag name must be 50 characters or fewer", 400);
+    }
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(trimmed)) {
+      throw new ServiceError("tag name must be lowercase alphanumeric with hyphens", 400);
+    }
+    const existing = this.tagRepo.findByName(trimmed);
+    if (existing) {
+      throw new ServiceError("tag already exists", 409);
+    }
+    return this.tagRepo.create(trimmed);
+  }
+
+  delete(id: string): boolean {
+    return this.tagRepo.delete(id);
+  }
+
+  addTagToTask(taskId: string, tagName: string): Tag {
+    const task = this.taskRepo.findById(taskId);
+    if (!task) {
+      throw new ServiceError("task not found", 404);
+    }
+    const trimmed = tagName.trim().toLowerCase();
+    // Auto-create tag if it doesn't exist
+    let tag = this.tagRepo.findByName(trimmed);
+    if (!tag) {
+      if (!trimmed || trimmed.length > 50) {
+        throw new ServiceError("tag name must be 1-50 lowercase alphanumeric characters with hyphens", 400);
+      }
+      if (!/^[a-z0-9][a-z0-9-]*$/.test(trimmed)) {
+        throw new ServiceError("tag name must be lowercase alphanumeric with hyphens", 400);
+      }
+      tag = this.tagRepo.create(trimmed);
+    }
+    this.tagRepo.addTagToTask(taskId, tag.id);
+    return tag;
+  }
+
+  removeTagFromTask(taskId: string, tagId: string): boolean {
+    return this.tagRepo.removeTagFromTask(taskId, tagId);
+  }
+
+  getTagsForTask(taskId: string): Tag[] {
+    return this.tagRepo.getTagsForTask(taskId);
+  }
+
+  findTasksByTag(tagName: string, limit = 100, offset = 0): Paginated<Task> {
+    const tag = this.tagRepo.findByName(tagName);
+    if (!tag) {
+      throw new ServiceError("tag not found", 404);
+    }
+    return {
+      data: this.tagRepo.findTasksByTag(tag.id, limit, offset),
+      total: this.tagRepo.countTasksByTag(tag.id),
+    };
+  }
+}