@allpepper/task-orchestrator 0.1.0

package/src/repos/base.ts

@@ -0,0 +1,151 @@
+import { db, generateId, now } from '../db/client';
+import type { Result } from '../domain/types';
+import { NotFoundError, ValidationError, ConflictError } from '../domain/types';
+
+// Re-export for convenience
+export { db, generateId, now };
+
+// --- Query helpers ---
+
+/** Get a single row by query, or null */
+export function queryOne<T>(sql: string, params: any[] = []): T | null {
+  return db.query<T, any[]>(sql).get(...params) ?? null;
+}
+
+/** Get all rows matching query */
+export function queryAll<T>(sql: string, params: any[] = []): T[] {
+  return db.query<T, any[]>(sql).all(...params);
+}
+
+/** Execute a write statement, return changes count */
+export function execute(sql: string, params: any[] = []): number {
+  const result = db.run(sql, params);
+  return result.changes;
+}
+
+// --- UUID helpers ---
+
+/** Convert hex string ID to the format used in queries */
+export function toId(hex: string): string {
+  return hex;
+}
+
+// --- Timestamp helpers ---
+
+/** Parse ISO timestamp string to Date */
+export function toDate(ts: string): Date {
+  return new Date(ts);
+}
+
+/** Format Date to ISO string for storage */
+export function toTimestamp(date: Date): string {
+  return date.toISOString();
+}
+
+// --- Search vector builder ---
+
+/** Build a search vector from text fields for LIKE-based searching */
+export function buildSearchVector(...fields: (string | undefined | null)[]): string {
+  return fields
+    .filter(Boolean)
+    .map(f => f!.toLowerCase())
+    .join(' ');
+}
+
+// --- Tag helpers (entity_tags table) ---
+
+/** Load tags for an entity */
+export function loadTags(entityId: string, entityType: string): string[] {
+  const rows = queryAll<{ tag: string }>(
+    'SELECT tag FROM entity_tags WHERE entity_id = ? AND entity_type = ?',
+    [entityId, entityType]
+  );
+  return rows.map(r => r.tag);
+}
+
+/** Save tags for an entity (replaces existing) */
+export function saveTags(entityId: string, entityType: string, tags: string[]): void {
+  execute('DELETE FROM entity_tags WHERE entity_id = ? AND entity_type = ?', [entityId, entityType]);
+
+  // Normalize and deduplicate tags
+  const uniqueTags = new Set<string>();
+  for (const tag of tags) {
+    const normalizedTag = tag.trim().toLowerCase();
+    if (normalizedTag) {
+      uniqueTags.add(normalizedTag);
+    }
+  }
+
+  // Insert unique tags
+  for (const normalizedTag of uniqueTags) {
+    execute(
+      'INSERT INTO entity_tags (id, entity_id, entity_type, tag, created_at) VALUES (?, ?, ?, ?, ?)',
+      [generateId(), entityId, entityType, normalizedTag, now()]
+    );
+  }
+}
+
+/** Delete all tags for an entity */
+export function deleteTags(entityId: string, entityType: string): void {
+  execute('DELETE FROM entity_tags WHERE entity_id = ? AND entity_type = ?', [entityId, entityType]);
+}
+
+// --- Result helpers ---
+
+/** Wrap a value in a success result */
+export function ok<T>(data: T): Result<T> {
+  return { success: true, data };
+}
+
+/** Wrap an error in a failure result */
+export function err<T>(error: string, code?: string): Result<T> {
+  return { success: false, error, code };
+}
+
+// --- Pagination helper ---
+
+export interface PaginationParams {
+  limit?: number;
+  offset?: number;
+}
+
+export function buildPaginationClause(params: PaginationParams): string {
+  const limit = params.limit ?? 20;
+  const offset = params.offset ?? 0;
+  return ` LIMIT ${limit} OFFSET ${offset}`;
+}
+
+// --- Count helper ---
+
+export interface TaskCounts {
+  total: number;
+  byStatus: Record<string, number>;
+}
+
+export function countTasksByFeature(featureId: string): TaskCounts {
+  const rows = queryAll<{ status: string; count: number }>(
+    'SELECT status, COUNT(*) as count FROM tasks WHERE feature_id = ? GROUP BY status',
+    [featureId]
+  );
+  const byStatus: Record<string, number> = {};
+  let total = 0;
+  for (const row of rows) {
+    byStatus[row.status] = row.count;
+    total += row.count;
+  }
+  return { total, byStatus };
+}
+
+export function countTasksByProject(projectId: string): TaskCounts {
+  const rows = queryAll<{ status: string; count: number }>(
+    'SELECT status, COUNT(*) as count FROM tasks WHERE project_id = ? GROUP BY status',
+    [projectId]
+  );
+  const byStatus: Record<string, number> = {};
+  let total = 0;
+  for (const row of rows) {
+    byStatus[row.status] = row.count;
+    total += row.count;
+  }
+  return { total, byStatus };
+}

package/src/repos/dependencies.ts

@@ -0,0 +1,356 @@
+import {
+  db,
+  generateId,
+  now,
+  queryOne,
+  queryAll,
+  execute,
+  ok,
+  err,
+  toDate
+} from './base';
+import type { Result, Dependency, DependencyType, Task } from '../domain/types';
+import { ValidationError, NotFoundError, ConflictError } from '../domain/types';
+
+// ============================================================================
+// Helper: Circular Dependency Detection
+// ============================================================================
+
+/**
+ * Check if adding a dependency would create a circular dependency.
+ * Uses BFS to traverse the dependency graph from toTaskId following BLOCKS dependencies.
+ * If we reach fromTaskId, it means adding fromTaskId -> toTaskId would create a cycle.
+ */
+function hasCircularDependency(fromTaskId: string, toTaskId: string): boolean {
+  const visited = new Set<string>();
+  const queue = [toTaskId];
+
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+
+    if (current === fromTaskId) {
+      return true;
+    }
+
+    if (visited.has(current)) {
+      continue;
+    }
+
+    visited.add(current);
+
+    // Follow BLOCKS dependencies from current task
+    const deps = queryAll<{ to_task_id: string }>(
+      "SELECT to_task_id FROM dependencies WHERE from_task_id = ? AND type = 'BLOCKS'",
+      [current]
+    );
+
+    for (const dep of deps) {
+      queue.push(dep.to_task_id);
+    }
+  }
+
+  return false;
+}
+
+// ============================================================================
+// Mapping Functions
+// ============================================================================
+
+/** Map database row to Dependency domain object */
+function mapRowToDependency(row: any): Dependency {
+  return {
+    id: row.id,
+    fromTaskId: row.from_task_id,
+    toTaskId: row.to_task_id,
+    type: row.type as DependencyType,
+    createdAt: toDate(row.created_at)
+  };
+}
+
+/** Map database row to Task domain object */
+function mapRowToTask(row: any): Task {
+  return {
+    id: row.id,
+    projectId: row.project_id ?? undefined,
+    featureId: row.feature_id ?? undefined,
+    title: row.title,
+    summary: row.summary,
+    description: row.description ?? undefined,
+    status: row.status,
+    priority: row.priority,
+    complexity: row.complexity,
+    version: row.version,
+    lastModifiedBy: row.last_modified_by ?? undefined,
+    lockStatus: row.lock_status,
+    createdAt: toDate(row.created_at),
+    modifiedAt: toDate(row.modified_at)
+  };
+}
+
+// ============================================================================
+// Repository Functions
+// ============================================================================
+
+/**
+ * Create a new dependency between two tasks.
+ *
+ * Validates:
+ * - fromTaskId != toTaskId (no self-dependency)
+ * - Both tasks exist
+ * - No circular dependencies (if A blocks B, B cannot block A)
+ * - No duplicate dependencies
+ */
+export function createDependency(params: {
+  fromTaskId: string;
+  toTaskId: string;
+  type: DependencyType;
+}): Result<Dependency> {
+  const { fromTaskId, toTaskId, type } = params;
+
+  // Validate: no self-dependency
+  if (fromTaskId === toTaskId) {
+    return err('Cannot create a dependency from a task to itself', 'SELF_DEPENDENCY');
+  }
+
+  // Validate: both tasks exist
+  const fromTask = queryOne<{ id: string }>(
+    'SELECT id FROM tasks WHERE id = ?',
+    [fromTaskId]
+  );
+
+  if (!fromTask) {
+    return err(`Task not found: ${fromTaskId}`, 'NOT_FOUND');
+  }
+
+  const toTask = queryOne<{ id: string }>(
+    'SELECT id FROM tasks WHERE id = ?',
+    [toTaskId]
+  );
+
+  if (!toTask) {
+    return err(`Task not found: ${toTaskId}`, 'NOT_FOUND');
+  }
+
+  // Validate: no circular dependencies for BLOCKS type
+  if (type === 'BLOCKS' && hasCircularDependency(fromTaskId, toTaskId)) {
+    return err(
+      'Cannot create dependency: would create a circular dependency',
+      'CIRCULAR_DEPENDENCY'
+    );
+  }
+
+  // Check for duplicate
+  const existing = queryOne<{ id: string }>(
+    'SELECT id FROM dependencies WHERE from_task_id = ? AND to_task_id = ? AND type = ?',
+    [fromTaskId, toTaskId, type]
+  );
+
+  if (existing) {
+    return err(
+      'Dependency already exists between these tasks with this type',
+      'DUPLICATE_DEPENDENCY'
+    );
+  }
+
+  // Create dependency
+  const id = generateId();
+  const createdAt = now();
+
+  try {
+    execute(
+      'INSERT INTO dependencies (id, from_task_id, to_task_id, type, created_at) VALUES (?, ?, ?, ?, ?)',
+      [id, fromTaskId, toTaskId, type, createdAt]
+    );
+
+    const dependency: Dependency = {
+      id,
+      fromTaskId,
+      toTaskId,
+      type,
+      createdAt: toDate(createdAt)
+    };
+
+    return ok(dependency);
+  } catch (error: any) {
+    return err(`Failed to create dependency: ${error.message}`, 'CREATE_FAILED');
+  }
+}
+
+/**
+ * Get dependencies for a task.
+ *
+ * @param taskId - The task ID to query
+ * @param direction - Filter by direction:
+ *   - 'dependencies': tasks that this task depends on (from_task_id = taskId)
+ *   - 'dependents': tasks that depend on this task (to_task_id = taskId)
+ *   - 'both': union of above (default)
+ */
+export function getDependencies(
+  taskId: string,
+  direction: 'dependencies' | 'dependents' | 'both' = 'both'
+): Result<Dependency[]> {
+  try {
+    let dependencies: Dependency[] = [];
+
+    if (direction === 'dependencies' || direction === 'both') {
+      const rows = queryAll<any>(
+        'SELECT * FROM dependencies WHERE from_task_id = ? ORDER BY created_at',
+        [taskId]
+      );
+      dependencies.push(...rows.map(mapRowToDependency));
+    }
+
+    if (direction === 'dependents' || direction === 'both') {
+      const rows = queryAll<any>(
+        'SELECT * FROM dependencies WHERE to_task_id = ? ORDER BY created_at',
+        [taskId]
+      );
+      dependencies.push(...rows.map(mapRowToDependency));
+    }
+
+    return ok(dependencies);
+  } catch (error: any) {
+    return err(`Failed to get dependencies: ${error.message}`, 'QUERY_FAILED');
+  }
+}
+
+/**
+ * Delete a dependency by ID.
+ */
+export function deleteDependency(id: string): Result<boolean> {
+  try {
+    const changes = execute('DELETE FROM dependencies WHERE id = ?', [id]);
+
+    if (changes === 0) {
+      return err(`Dependency not found: ${id}`, 'NOT_FOUND');
+    }
+
+    return ok(true);
+  } catch (error: any) {
+    return err(`Failed to delete dependency: ${error.message}`, 'DELETE_FAILED');
+  }
+}
+
+/**
+ * Get all blocked tasks.
+ *
+ * Returns tasks that either:
+ * - Have status = 'BLOCKED', OR
+ * - Have incomplete blocking dependencies (tasks that block them but are not completed)
+ *
+ * @param params - Optional filters for projectId and/or featureId
+ */
+export function getBlockedTasks(params?: {
+  projectId?: string;
+  featureId?: string;
+}): Result<Task[]> {
+  try {
+    let sql = `
+      SELECT DISTINCT t.*
+      FROM tasks t
+      WHERE (
+        t.status = 'BLOCKED'
+        OR EXISTS (
+          SELECT 1
+          FROM dependencies d
+          JOIN tasks blocker ON blocker.id = d.from_task_id
+          WHERE d.to_task_id = t.id
+            AND d.type = 'BLOCKS'
+            AND blocker.status NOT IN ('COMPLETED', 'CANCELLED')
+        )
+      )
+    `;
+
+    const sqlParams: string[] = [];
+
+    if (params?.projectId) {
+      sql += ' AND t.project_id = ?';
+      sqlParams.push(params.projectId);
+    }
+
+    if (params?.featureId) {
+      sql += ' AND t.feature_id = ?';
+      sqlParams.push(params.featureId);
+    }
+
+    sql += ' ORDER BY t.priority DESC, t.created_at ASC';
+
+    const rows = queryAll<any>(sql, sqlParams);
+    const tasks = rows.map(mapRowToTask);
+
+    return ok(tasks);
+  } catch (error: any) {
+    return err(`Failed to get blocked tasks: ${error.message}`, 'QUERY_FAILED');
+  }
+}
+
+/**
+ * Get the next task to work on.
+ *
+ * Returns the highest priority PENDING task that has no incomplete blocking dependencies.
+ * Considers priority and complexity.
+ *
+ * @param params - Optional filters and priority preference
+ */
+export function getNextTask(params?: {
+  projectId?: string;
+  featureId?: string;
+  priority?: string;
+}): Result<Task | null> {
+  try {
+    let sql = `
+      SELECT t.*
+      FROM tasks t
+      WHERE t.status = 'PENDING'
+        AND NOT EXISTS (
+          SELECT 1
+          FROM dependencies d
+          JOIN tasks blocker ON blocker.id = d.from_task_id
+          WHERE d.to_task_id = t.id
+            AND d.type = 'BLOCKS'
+            AND blocker.status NOT IN ('COMPLETED', 'CANCELLED')
+        )
+    `;
+
+    const sqlParams: string[] = [];
+
+    if (params?.projectId) {
+      sql += ' AND t.project_id = ?';
+      sqlParams.push(params.projectId);
+    }
+
+    if (params?.featureId) {
+      sql += ' AND t.feature_id = ?';
+      sqlParams.push(params.featureId);
+    }
+
+    if (params?.priority) {
+      sql += ' AND t.priority = ?';
+      sqlParams.push(params.priority);
+    }
+
+    // Order by priority (HIGH > MEDIUM > LOW), then by complexity (simpler first), then by creation time
+    sql += `
+      ORDER BY
+        CASE t.priority
+          WHEN 'HIGH' THEN 1
+          WHEN 'MEDIUM' THEN 2
+          WHEN 'LOW' THEN 3
+        END,
+        t.complexity ASC,
+        t.created_at ASC
+      LIMIT 1
+    `;
+
+    const row = queryOne<any>(sql, sqlParams);
+
+    if (!row) {
+      return ok(null);
+    }
+
+    const task = mapRowToTask(row);
+    return ok(task);
+  } catch (error: any) {
+    return err(`Failed to get next task: ${error.message}`, 'QUERY_FAILED');
+  }
+}