@critical-path/core 0.2.0 → 0.3.0

package/src/store/sqlite.ts

@@ -3,13 +3,16 @@ import type { StorageAdapter } from './index.js';
 import type {
   Project,
   Task,
-  Sprint,
+  Iteration,
+  Team,
+  TaskContainer,
   Comment,
   TimeEntry,
   Activity,
   Webhook,
   TaskDependency
 } from '../types/index.js';
+import { generateProjectKey } from '../utils/key.js';
 
 export interface SQLiteStoreConfig {
   /**
@@ -44,11 +47,36 @@ export class SQLiteStore implements StorageAdapter {
         description TEXT,
         ownerId TEXT,
         members TEXT,
+        teamIds TEXT,
+        statusDefinitions TEXT,
+        priorityDefinitions TEXT,
         customFieldDefinitions TEXT,
         createdAt TEXT NOT NULL,
         updatedAt TEXT NOT NULL
       );
 
+      CREATE TABLE IF NOT EXISTS teams (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        description TEXT,
+        leaderId TEXT,
+        memberIds TEXT NOT NULL,
+        createdAt TEXT NOT NULL,
+        updatedAt TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS containers (
+        id TEXT PRIMARY KEY,
+        projectId TEXT NOT NULL,
+        name TEXT NOT NULL,
+        description TEXT,
+        parentId TEXT,
+        type TEXT,
+        color TEXT,
+        createdAt TEXT NOT NULL,
+        updatedAt TEXT NOT NULL
+      );
+
       CREATE TABLE IF NOT EXISTS tasks (
         id TEXT PRIMARY KEY,
         projectId TEXT NOT NULL,
@@ -58,10 +86,22 @@ export class SQLiteStore implements StorageAdapter {
         priority TEXT NOT NULL,
         assigneeId TEXT,
         reporterId TEXT,
-        sprintId TEXT,
+        reviewerId TEXT,
+        iterationId TEXT,
+        teamId TEXT,
+        containerId TEXT,
+        plannedStartDate TEXT,
+        actualStartDate TEXT,
+        actualEndDate TEXT,
         dueDate TEXT,
         estimatedHours REAL,
         loggedHours REAL,
+        actualHours REAL,
+        billableHours REAL,
+        estimatedDurationMinutes REAL,
+        actualDurationMinutes REAL,
+        billableDurationMinutes REAL,
+        progress REAL,
         tags TEXT,
         customFields TEXT,
         parentId TEXT,
@@ -69,11 +109,12 @@ export class SQLiteStore implements StorageAdapter {
         updatedAt TEXT NOT NULL
       );
 
-      CREATE TABLE IF NOT EXISTS sprints (
+      CREATE TABLE IF NOT EXISTS iterations (
         id TEXT PRIMARY KEY,
         projectId TEXT NOT NULL,
         name TEXT NOT NULL,
         goal TEXT,
+        type TEXT,
         startDate TEXT,
         endDate TEXT,
         status TEXT NOT NULL,
@@ -104,6 +145,7 @@ export class SQLiteStore implements StorageAdapter {
         taskId TEXT NOT NULL,
         userId TEXT NOT NULL,
         hours REAL NOT NULL,
+        isBillable INTEGER,
         description TEXT,
         loggedAt TEXT NOT NULL
       );
@@ -142,19 +184,23 @@ export class SQLiteStore implements StorageAdapter {
   async createProject(project: Omit<Project, 'id' | 'createdAt' | 'updatedAt'>): Promise<Project> {
     const id = `proj_${Math.random().toString(36).substring(2, 9)}`;
     const now = new Date().toISOString();
-    const newProj: Project = { ...project, id, createdAt: now, updatedAt: now };
+    const key = project.key || generateProjectKey(project.name);
+    const newProj: Project = { ...project, key, id, createdAt: now, updatedAt: now };
 
     const stmt = this.db.prepare(`
-      INSERT INTO projects (id, key, name, description, ownerId, members, customFieldDefinitions, createdAt, updatedAt)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO projects (id, key, name, description, ownerId, members, teamIds, statusDefinitions, priorityDefinitions, customFieldDefinitions, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
     stmt.run(
       newProj.id,
-      newProj.key,
+      newProj.key || '',
       newProj.name,
       newProj.description || null,
       newProj.ownerId || null,
       JSON.stringify(newProj.members || []),
+      JSON.stringify(newProj.teamIds || []),
+      JSON.stringify(newProj.statusDefinitions || []),
+      JSON.stringify(newProj.priorityDefinitions || []),
       JSON.stringify(newProj.customFieldDefinitions || []),
       newProj.createdAt,
       newProj.updatedAt
@@ -174,15 +220,18 @@ export class SQLiteStore implements StorageAdapter {
 
     const stmt = this.db.prepare(`
       UPDATE projects
-      SET key = ?, name = ?, description = ?, ownerId = ?, members = ?, customFieldDefinitions = ?, updatedAt = ?
+      SET key = ?, name = ?, description = ?, ownerId = ?, members = ?, teamIds = ?, statusDefinitions = ?, priorityDefinitions = ?, customFieldDefinitions = ?, updatedAt = ?
       WHERE id = ?
     `);
     stmt.run(
-      updated.key,
+      updated.key || '',
       updated.name,
       updated.description || null,
       updated.ownerId || null,
       JSON.stringify(updated.members || []),
+      JSON.stringify(updated.teamIds || []),
+      JSON.stringify(updated.statusDefinitions || []),
+      JSON.stringify(updated.priorityDefinitions || []),
       JSON.stringify(updated.customFieldDefinitions || []),
       updated.updatedAt,
       id
@@ -196,6 +245,129 @@ export class SQLiteStore implements StorageAdapter {
     return (result.changes ?? 0) > 0;
   }
 
+  // --- Teams ---
+  async getTeams(): Promise<Team[]> {
+    const stmt = this.db.prepare('SELECT * FROM teams');
+    const rows = stmt.all() as any[];
+    return rows.map((r) => this.mapTeam(r));
+  }
+
+  async getTeam(id: string): Promise<Team | null> {
+    const stmt = this.db.prepare('SELECT * FROM teams WHERE id = ?');
+    const row = stmt.get(id) as any;
+    return row ? this.mapTeam(row) : null;
+  }
+
+  async createTeam(team: Omit<Team, 'id' | 'createdAt' | 'updatedAt'>): Promise<Team> {
+    const id = `team_${Math.random().toString(36).substring(2, 9)}`;
+    const now = new Date().toISOString();
+    const newTeam: Team = { ...team, id, createdAt: now, updatedAt: now };
+
+    const stmt = this.db.prepare(`
+      INSERT INTO teams (id, name, description, leaderId, memberIds, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      newTeam.id,
+      newTeam.name,
+      newTeam.description || null,
+      newTeam.leaderId || null,
+      JSON.stringify(newTeam.memberIds || []),
+      newTeam.createdAt,
+      newTeam.updatedAt
+    );
+    return newTeam;
+  }
+
+  async updateTeam(id: string, updates: Partial<Team>): Promise<Team | null> {
+    const existing = await this.getTeam(id);
+    if (!existing) return null;
+
+    const updated: Team = { ...existing, ...updates, updatedAt: new Date().toISOString() };
+    const stmt = this.db.prepare(`
+      UPDATE teams SET name = ?, description = ?, leaderId = ?, memberIds = ?, updatedAt = ?
+      WHERE id = ?
+    `);
+    stmt.run(
+      updated.name,
+      updated.description || null,
+      updated.leaderId || null,
+      JSON.stringify(updated.memberIds || []),
+      updated.updatedAt,
+      id
+    );
+    return updated;
+  }
+
+  async deleteTeam(id: string): Promise<boolean> {
+    const stmt = this.db.prepare('DELETE FROM teams WHERE id = ?');
+    const result = stmt.run(id);
+    return (result.changes ?? 0) > 0;
+  }
+
+  // --- Task Containers ---
+  async getContainers(projectId: string): Promise<TaskContainer[]> {
+    const stmt = this.db.prepare('SELECT * FROM containers WHERE projectId = ?');
+    const rows = stmt.all(projectId) as any[];
+    return rows;
+  }
+
+  async getContainer(id: string): Promise<TaskContainer | null> {
+    const stmt = this.db.prepare('SELECT * FROM containers WHERE id = ?');
+    const row = stmt.get(id) as any;
+    return row || null;
+  }
+
+  async createContainer(container: Omit<TaskContainer, 'id' | 'createdAt' | 'updatedAt'>): Promise<TaskContainer> {
+    const id = `cnt_${Math.random().toString(36).substring(2, 9)}`;
+    const now = new Date().toISOString();
+    const newContainer: TaskContainer = { ...container, id, createdAt: now, updatedAt: now };
+
+    const stmt = this.db.prepare(`
+      INSERT INTO containers (id, projectId, name, description, parentId, type, color, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      newContainer.id,
+      newContainer.projectId,
+      newContainer.name,
+      newContainer.description || null,
+      newContainer.parentId || null,
+      newContainer.type || null,
+      newContainer.color || null,
+      newContainer.createdAt,
+      newContainer.updatedAt
+    );
+    return newContainer;
+  }
+
+  async updateContainer(id: string, updates: Partial<TaskContainer>): Promise<TaskContainer | null> {
+    const existing = await this.getContainer(id);
+    if (!existing) return null;
+
+    const updated: TaskContainer = { ...existing, ...updates, updatedAt: new Date().toISOString() };
+    const stmt = this.db.prepare(`
+      UPDATE containers SET name = ?, description = ?, parentId = ?, type = ?, color = ?, updatedAt = ?
+      WHERE id = ?
+    `);
+    stmt.run(
+      updated.name,
+      updated.description || null,
+      updated.parentId || null,
+      updated.type || null,
+      updated.color || null,
+      updated.updatedAt,
+      id
+    );
+    return updated;
+  }
+
+  async deleteContainer(id: string): Promise<boolean> {
+    const stmt = this.db.prepare('DELETE FROM containers WHERE id = ?');
+    const result = stmt.run(id);
+    return (result.changes ?? 0) > 0;
+  }
+
   // --- Tasks ---
   async getTasks(projectId?: string): Promise<Task[]> {
     let rows: any[];
@@ -223,8 +395,11 @@ export class SQLiteStore implements StorageAdapter {
     const stmt = this.db.prepare(`
       INSERT INTO tasks (
         id, projectId, title, description, status, priority, assigneeId, reporterId,
-        sprintId, dueDate, estimatedHours, loggedHours, tags, customFields, parentId, createdAt, updatedAt
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        reviewerId, iterationId, teamId, containerId, plannedStartDate, actualStartDate, actualEndDate,
+        dueDate, estimatedHours, loggedHours, actualHours, billableHours,
+        estimatedDurationMinutes, actualDurationMinutes, billableDurationMinutes, progress,
+        tags, customFields, parentId, createdAt, updatedAt
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
     stmt.run(
       newTask.id,
@@ -235,10 +410,22 @@ export class SQLiteStore implements StorageAdapter {
       newTask.priority,
       newTask.assigneeId || null,
       newTask.reporterId || null,
-      newTask.sprintId || null,
+      newTask.reviewerId || null,
+      newTask.iterationId || null,
+      newTask.teamId || null,
+      newTask.containerId || null,
+      newTask.plannedStartDate || null,
+      newTask.actualStartDate || null,
+      newTask.actualEndDate || null,
       newTask.dueDate || null,
       newTask.estimatedHours ?? null,
       newTask.loggedHours ?? null,
+      newTask.actualHours ?? null,
+      newTask.billableHours ?? null,
+      newTask.estimatedDurationMinutes ?? null,
+      newTask.actualDurationMinutes ?? null,
+      newTask.billableDurationMinutes ?? null,
+      newTask.progress ?? null,
       JSON.stringify(newTask.tags || []),
       JSON.stringify(newTask.customFields || {}),
       newTask.parentId || null,
@@ -261,8 +448,11 @@ export class SQLiteStore implements StorageAdapter {
     const stmt = this.db.prepare(`
       UPDATE tasks SET
         projectId = ?, title = ?, description = ?, status = ?, priority = ?,
-        assigneeId = ?, reporterId = ?, sprintId = ?, dueDate = ?,
-        estimatedHours = ?, loggedHours = ?, tags = ?, customFields = ?, parentId = ?, updatedAt = ?
+        assigneeId = ?, reporterId = ?, reviewerId = ?, iterationId = ?, teamId = ?, containerId = ?,
+        plannedStartDate = ?, actualStartDate = ?, actualEndDate = ?, dueDate = ?,
+        estimatedHours = ?, loggedHours = ?, actualHours = ?, billableHours = ?,
+        estimatedDurationMinutes = ?, actualDurationMinutes = ?, billableDurationMinutes = ?, progress = ?,
+        tags = ?, customFields = ?, parentId = ?, updatedAt = ?
       WHERE id = ?
     `);
     stmt.run(
@@ -273,10 +463,22 @@ export class SQLiteStore implements StorageAdapter {
       updated.priority,
       updated.assigneeId || null,
       updated.reporterId || null,
-      updated.sprintId || null,
+      updated.reviewerId || null,
+      updated.iterationId || null,
+      updated.teamId || null,
+      updated.containerId || null,
+      updated.plannedStartDate || null,
+      updated.actualStartDate || null,
+      updated.actualEndDate || null,
       updated.dueDate || null,
       updated.estimatedHours ?? null,
       updated.loggedHours ?? null,
+      updated.actualHours ?? null,
+      updated.billableHours ?? null,
+      updated.estimatedDurationMinutes ?? null,
+      updated.actualDurationMinutes ?? null,
+      updated.billableDurationMinutes ?? null,
+      updated.progress ?? null,
       JSON.stringify(updated.tags || []),
       JSON.stringify(updated.customFields || {}),
       updated.parentId || null,
@@ -292,53 +494,56 @@ export class SQLiteStore implements StorageAdapter {
     return (result.changes ?? 0) > 0;
   }
 
-  // --- Sprints ---
-  async getSprints(projectId: string): Promise<Sprint[]> {
-    const stmt = this.db.prepare('SELECT * FROM sprints WHERE projectId = ?');
+  // --- Iterations ---
+  async getIterations(projectId: string): Promise<Iteration[]> {
+    const stmt = this.db.prepare('SELECT * FROM iterations WHERE projectId = ?');
     const rows = stmt.all(projectId) as any[];
-    return rows.map((r) => ({
-      ...r,
-      description: r.goal
-    }));
+    return rows;
   }
 
-  async createSprint(sprint: Omit<Sprint, 'id' | 'createdAt'>): Promise<Sprint> {
-    const id = `sprint_${Math.random().toString(36).substring(2, 9)}`;
+  async getIteration(id: string): Promise<Iteration | null> {
+    const stmt = this.db.prepare('SELECT * FROM iterations WHERE id = ?');
+    const row = stmt.get(id) as any;
+    return row || null;
+  }
+
+  async createIteration(iteration: Omit<Iteration, 'id' | 'createdAt'>): Promise<Iteration> {
+    const id = `iter_${Math.random().toString(36).substring(2, 9)}`;
     const now = new Date().toISOString();
-    const newSprint: Sprint = { ...sprint, id, createdAt: now };
+    const newIteration: Iteration = { ...iteration, id, createdAt: now };
 
     const stmt = this.db.prepare(`
-      INSERT INTO sprints (id, projectId, name, goal, startDate, endDate, status, createdAt)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO iterations (id, projectId, name, goal, type, startDate, endDate, status, createdAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
     stmt.run(
-      newSprint.id,
-      newSprint.projectId,
-      newSprint.name,
-      newSprint.goal || null,
-      newSprint.startDate || null,
-      newSprint.endDate || null,
-      newSprint.status,
-      newSprint.createdAt
+      newIteration.id,
+      newIteration.projectId,
+      newIteration.name,
+      newIteration.goal || null,
+      newIteration.type || null,
+      newIteration.startDate || null,
+      newIteration.endDate || null,
+      newIteration.status,
+      newIteration.createdAt
     );
-    return newSprint;
+    return newIteration;
   }
 
-  async updateSprint(id: string, updates: Partial<Sprint>): Promise<Sprint | null> {
-    const stmt = this.db.prepare('SELECT * FROM sprints WHERE id = ?');
-    const existingRow = stmt.get(id) as any;
-    if (!existingRow) return null;
+  async updateIteration(id: string, updates: Partial<Iteration>): Promise<Iteration | null> {
+    const existing = await this.getIteration(id);
+    if (!existing) return null;
 
-    const existing: Sprint = { ...existingRow, goal: existingRow.goal };
-    const updated: Sprint = { ...existing, ...updates };
+    const updated: Iteration = { ...existing, ...updates };
 
     const updateStmt = this.db.prepare(`
-      UPDATE sprints SET name = ?, goal = ?, startDate = ?, endDate = ?, status = ?
+      UPDATE iterations SET name = ?, goal = ?, type = ?, startDate = ?, endDate = ?, status = ?
       WHERE id = ?
     `);
     updateStmt.run(
       updated.name,
       updated.goal || null,
+      updated.type || null,
       updated.startDate || null,
       updated.endDate || null,
       updated.status,
@@ -347,6 +552,12 @@ export class SQLiteStore implements StorageAdapter {
     return updated;
   }
 
+  async deleteIteration(id: string): Promise<boolean> {
+    const stmt = this.db.prepare('DELETE FROM iterations WHERE id = ?');
+    const result = stmt.run(id);
+    return (result.changes ?? 0) > 0;
+  }
+
   // --- Comments & Activity ---
   async getComments(taskId: string): Promise<Comment[]> {
     const stmt = this.db.prepare('SELECT * FROM comments WHERE taskId = ?');
@@ -417,7 +628,8 @@ export class SQLiteStore implements StorageAdapter {
   // --- Time Tracking ---
   async getTimeEntries(taskId: string): Promise<TimeEntry[]> {
     const stmt = this.db.prepare('SELECT * FROM time_entries WHERE taskId = ?');
-    return stmt.all(taskId) as any[];
+    const rows = stmt.all(taskId) as any[];
+    return rows.map((r) => ({ ...r, isBillable: r.isBillable !== null ? Boolean(r.isBillable) : undefined }));
   }
 
   async logTime(entry: Omit<TimeEntry, 'id' | 'loggedAt'>): Promise<TimeEntry> {
@@ -426,10 +638,18 @@ export class SQLiteStore implements StorageAdapter {
     const newEntry: TimeEntry = { ...entry, id, loggedAt: now };
 
     const stmt = this.db.prepare(`
-      INSERT INTO time_entries (id, taskId, userId, hours, description, loggedAt)
-      VALUES (?, ?, ?, ?, ?, ?)
+      INSERT INTO time_entries (id, taskId, userId, hours, isBillable, description, loggedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
     `);
-    stmt.run(newEntry.id, newEntry.taskId, newEntry.userId, newEntry.hours, newEntry.description || null, newEntry.loggedAt);
+    stmt.run(
+      newEntry.id,
+      newEntry.taskId,
+      newEntry.userId,
+      newEntry.hours,
+      newEntry.isBillable !== undefined ? (newEntry.isBillable ? 1 : 0) : null,
+      newEntry.description || null,
+      newEntry.loggedAt
+    );
     return newEntry;
   }
 
@@ -487,10 +707,20 @@ export class SQLiteStore implements StorageAdapter {
     return {
       ...row,
       members: row.members ? JSON.parse(row.members) : [],
+      teamIds: row.teamIds ? JSON.parse(row.teamIds) : [],
+      statusDefinitions: row.statusDefinitions ? JSON.parse(row.statusDefinitions) : [],
+      priorityDefinitions: row.priorityDefinitions ? JSON.parse(row.priorityDefinitions) : [],
       customFieldDefinitions: row.customFieldDefinitions ? JSON.parse(row.customFieldDefinitions) : []
     };
   }
 
+  private mapTeam(row: any): Team {
+    return {
+      ...row,
+      memberIds: row.memberIds ? JSON.parse(row.memberIds) : []
+    };
+  }
+
   private mapTask(row: any): Task {
     return {
       ...row,

package/src/types/index.ts

@@ -1,6 +1,19 @@
-export type Priority = 'urgent' | 'high' | 'medium' | 'low' | 'none';
+export type DefaultPriority = 'urgent' | 'high' | 'medium' | 'low' | 'none';
+export type Priority = DefaultPriority | (string & {});
 
-export type TaskStatus = 'backlog' | 'todo' | 'in_progress' | 'in_review' | 'done' | 'canceled';
+export type DefaultTaskStatus = 'backlog' | 'todo' | 'in_progress' | 'in_review' | 'done' | 'canceled';
+export type TaskStatus = DefaultTaskStatus | (string & {});
+
+export type CompletionState = 'done' | 'not_done';
+export type ExecutionState = 'active' | 'inactive';
+
+export interface StatusDefinition {
+  key: string;
+  label: string;
+  completionState: CompletionState;
+  executionState: ExecutionState;
+  isCancelled?: boolean;
+}
 
 export type Role = 'admin' | 'project_manager' | 'contributor' | 'viewer';
 
@@ -13,6 +26,16 @@ export interface User {
   createdAt: string;
 }
 
+export interface Team {
+  id: string;
+  name: string;
+  description?: string;
+  leaderId?: string;
+  memberIds: string[];
+  createdAt: string;
+  updatedAt: string;
+}
+
 export interface CustomFieldDefinition {
   id: string;
   key: string;
@@ -25,16 +48,31 @@ export interface CustomFieldDefinition {
 
 export interface Project {
   id: string;
-  key: string; // e.g. "CP" or "PROJ"
+  key?: string; // e.g. "CP" or "PROJ"
   name: string;
   description?: string;
   ownerId?: string;
   members?: string[]; // user IDs
+  teamIds?: string[]; // team IDs
+  statusDefinitions?: StatusDefinition[];
+  priorityDefinitions?: Array<{ key: string; label: string; level?: number }>;
   customFieldDefinitions?: CustomFieldDefinition[];
   createdAt: string;
   updatedAt: string;
 }
 
+export interface TaskContainer {
+  id: string;
+  projectId: string;
+  name: string;
+  description?: string;
+  parentId?: string; // nested container hierarchy (e.g., folder -> epic -> group)
+  type?: 'epic' | 'group' | 'section' | 'folder' | string;
+  color?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
 export interface TaskDependency {
   id: string;
   taskId: string;
@@ -42,19 +80,41 @@ export interface TaskDependency {
   type: 'blocking' | 'blocked_by' | 'relates_to';
 }
 
+export interface TaskDependencyGraph {
+  taskId: string;
+  upstreamTasks: Task[];   // tasks that this task depends on
+  downstreamTasks: Task[]; // tasks that depend on this task
+  dependencies: TaskDependency[];
+}
+
 export interface Task {
   id: string;
   projectId: string;
+  key?: string; // e.g. "MOB-12"
   title: string;
   description?: string;
   status: TaskStatus;
   priority: Priority;
   assigneeId?: string;
   reporterId?: string;
-  sprintId?: string;
+  reviewerId?: string;
+  iterationId?: string;
+  teamId?: string;
+  containerId?: string;
+  plannedStartDate?: string;
+  actualStartDate?: string;
+  actualEndDate?: string;
   dueDate?: string;
+  // Duration & Effort (in hours and/or minutes)
   estimatedHours?: number;
   loggedHours?: number;
+  actualHours?: number;
+  billableHours?: number;
+  estimatedDurationMinutes?: number;
+  actualDurationMinutes?: number;
+  billableDurationMinutes?: number;
+  // Progress (0 to 100 percentage)
+  progress?: number;
   tags?: string[];
   customFields?: Record<string, unknown>;
   parentId?: string; // Subtask support
@@ -62,13 +122,14 @@ export interface Task {
   updatedAt: string;
 }
 
-export interface Sprint {
+export interface Iteration {
   id: string;
   projectId: string;
   name: string;
   goal?: string;
-  startDate: string;
-  endDate: string;
+  type?: 'sprint' | 'cycle' | 'milestone' | string;
+  startDate?: string;
+  endDate?: string;
   status: 'planning' | 'active' | 'completed';
   createdAt: string;
 }
@@ -87,6 +148,7 @@ export interface TimeEntry {
   taskId: string;
   userId: string;
   hours: number;
+  isBillable?: boolean;
   description?: string;
   loggedAt: string;
 }
@@ -119,8 +181,10 @@ export type WebhookEvent =
   | 'task.deleted'
   | 'task.status_changed'
   | 'comment.created'
-  | 'sprint.started'
-  | 'sprint.completed';
+  | 'iteration.started'
+  | 'iteration.completed'
+  | 'team.created'
+  | 'container.created';
 
 export interface PluginHooks {
   beforeTaskCreate?: (task: Partial<Task>) => Promise<Partial<Task>> | Partial<Task>;
@@ -149,6 +213,8 @@ export interface CriticalPathConfig {
     projects?: Project[];
     tasks?: Task[];
     users?: User[];
-    sprints?: Sprint[];
+    iterations?: Iteration[];
+    teams?: Team[];
+    containers?: TaskContainer[];
   };
 }

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './status.js';
+export * from './key.js';