@bosun-sh/logbook 1.1.0 → 2.0.1

package/src/task/current-task.ts

@@ -1,111 +0,0 @@
-import { Effect } from "effect"
-import type { Agent, Task, TaskError } from "../domain/types.js"
-import type { TaskRepository as TaskRepositoryType } from "./ports.js"
-import { TaskRepository } from "./ports.js"
-import { SessionRegistry } from "./session-registry.js"
-
-/**
- * Returns the best available task for the given session, claiming it if needed.
- *
- * Priority chain:
- *   1. Own in_progress  — already assigned to this session → return highest-priority
- *   2. Unassigned in_progress — no assignee → claim highest-priority, return
- *   3. Orphaned in_progress — dead-session assignee → claim highest-priority, return
- *   4. Highest-priority todo — auto-transition to in_progress, claim, return
- *   5. Nothing → fail `no_current_task`
- *
- * Ties in priority are broken by in_progress_since ASC (oldest first).
- * Claiming is a direct repo.update — no hooks, no HookRunner dependency.
- */
-export const currentTask = (
-  sessionId: string
-): Effect.Effect<Task, TaskError, TaskRepository | SessionRegistry> =>
-  Effect.flatMap(TaskRepository, (repo) =>
-    Effect.flatMap(repo.findByStatus("in_progress"), (inProgress) => {
-      const own = inProgress.filter((t) => t.assignee?.id === sessionId)
-      if (own.length > 0) return Effect.succeed(pickHighestPriority(own))
-
-      return stepUnassigned(inProgress, sessionId, repo).pipe(
-        Effect.catchTag("no_current_task", () =>
-          stepOrphan(sessionId, inProgress, repo).pipe(
-            Effect.catchTag("no_current_task", () => stepTodo(sessionId, repo))
-          )
-        )
-      )
-    })
-  )
-
-const pickHighestPriority = <T extends Task>(tasks: readonly T[]): T => {
-  const sorted = [...tasks].sort((a, b) => {
-    if (b.priority !== a.priority) return b.priority - a.priority
-    const aTime = a.in_progress_since?.getTime() ?? Infinity
-    const bTime = b.in_progress_since?.getTime() ?? Infinity
-    return aTime - bTime
-  })
-  // biome-ignore lint/style/noNonNullAssertion: caller guarantees non-empty
-  return sorted[0]!
-}
-
-const claimTask = (
-  task: Task,
-  newAssignee: Agent,
-  repo: TaskRepositoryType
-): Effect.Effect<Task, TaskError, never> => {
-  const claimed = { ...task, assignee: newAssignee }
-  return Effect.map(repo.update(claimed), () => claimed)
-}
-
-const stepUnassigned = (
-  inProgress: readonly Task[],
-  sessionId: string,
-  repo: TaskRepositoryType
-): Effect.Effect<Task, TaskError, never> => {
-  const unassigned = inProgress.filter((t) => t.assignee === undefined)
-  if (unassigned.length === 0) return Effect.fail({ _tag: "no_current_task" as const })
-  const oldest = pickHighestPriority(unassigned)
-  return claimTask(oldest, { id: sessionId, title: "Agent", description: "" }, repo)
-}
-
-const stepOrphan = (
-  sessionId: string,
-  candidates: readonly Task[],
-  repo: TaskRepositoryType
-): Effect.Effect<Task, TaskError, SessionRegistry> => {
-  const foreign = candidates.filter(
-    (t): t is Task & { assignee: Agent } => t.assignee !== undefined && t.assignee.id !== sessionId
-  )
-  if (foreign.length === 0) return Effect.fail({ _tag: "no_current_task" as const })
-  return Effect.flatMap(SessionRegistry, (registry) =>
-    Effect.flatMap(
-      Effect.forEach(foreign, (t) =>
-        registry.isAlive(t.assignee.id).pipe(Effect.map((alive) => ({ task: t, alive })))
-      ),
-      (results) => {
-        const orphans = results.filter((r) => !r.alive).map((r) => r.task)
-        if (orphans.length === 0) return Effect.fail({ _tag: "no_current_task" as const })
-        const oldest = pickHighestPriority(orphans)
-        return claimTask(oldest, { ...oldest.assignee, id: sessionId }, repo)
-      }
-    )
-  )
-}
-
-const stepTodo = (
-  sessionId: string,
-  repo: TaskRepositoryType
-): Effect.Effect<Task, TaskError, never> =>
-  Effect.flatMap(repo.findByStatus("todo"), (todos) => {
-    if (todos.length === 0) return Effect.fail({ _tag: "no_current_task" as const })
-    // biome-ignore lint/style/noNonNullAssertion: length guard above
-    const best = [...todos].sort((a, b) => b.priority - a.priority)[0]!
-    const claimed: Task = {
-      ...best,
-      status: "in_progress",
-      assignee: {
-        ...(best.assignee ?? { title: "Agent", description: "" }),
-        id: sessionId,
-      },
-      in_progress_since: new Date(),
-    }
-    return Effect.map(repo.update(claimed), () => claimed)
-  })

package/src/task/edit-task.ts

@@ -1,59 +0,0 @@
-import { Effect } from "effect"
-import { estimateFromKTokens } from "../domain/kTokens.js"
-import type { Task, TaskError } from "../domain/types.js"
-import { TaskRepository } from "./ports.js"
-
-export interface EditTaskInput {
-  title?: string
-  description?: string
-  definition_of_done?: string
-  predictedKTokens?: number
-  priority?: number
-}
-
-/**
- * Edits mutable fields of an existing task without changing its status.
- * Derives Fibonacci estimation from predictedKTokens when provided.
- * Fails with `not_found` for unknown id.
- * Fails with `validation_error` when a `status` field is attempted via EditTaskInput.
- */
-export const editTask = (
-  id: string,
-  updates: EditTaskInput
-): Effect.Effect<Task, TaskError, TaskRepository> => {
-  // Check for attempted status modification (runtime guard against type system bypass)
-  if ("status" in updates) {
-    return Effect.fail({
-      _tag: "validation_error" as const,
-      message: "status field cannot be edited",
-    })
-  }
-
-  // Derive estimation from predictedKTokens if present
-  if (updates.predictedKTokens !== undefined) {
-    return Effect.flatMap(estimateFromKTokens(updates.predictedKTokens), (estimation) =>
-      Effect.flatMap(TaskRepository, (repo) =>
-        Effect.flatMap(repo.findById(id), (task) => {
-          const { predictedKTokens: _, ...rest } = updates
-          const updatedTask: Task = {
-            ...task,
-            ...rest,
-            estimation,
-          }
-          return Effect.flatMap(repo.update(updatedTask), () => Effect.succeed(updatedTask))
-        })
-      )
-    )
-  }
-
-  // No estimation to derive, proceed directly with find and update
-  return Effect.flatMap(TaskRepository, (repo) =>
-    Effect.flatMap(repo.findById(id), (task) => {
-      const updatedTask: Task = {
-        ...task,
-        ...updates,
-      }
-      return Effect.flatMap(repo.update(updatedTask), () => Effect.succeed(updatedTask))
-    })
-  )
-}

package/src/task/list-tasks.ts

@@ -1,35 +0,0 @@
-import { Effect } from "effect"
-import type { Status, Task, TaskError } from "../domain/types.js"
-import { TaskRepository } from "./ports.js"
-
-type ListTasksOptions = {
-  status: Status | "*"
-  project?: string
-  milestone?: string
-}
-
-const applyFilters = (tasks: readonly Task[], options: ListTasksOptions): readonly Task[] => {
-  let result = tasks
-  if (options.project !== undefined) {
-    result = result.filter((t) => t.project === options.project)
-  }
-  if (options.milestone !== undefined) {
-    result = result.filter((t) => t.milestone === options.milestone)
-  }
-  return result
-}
-
-/**
- * Returns tasks matching the given status (and optional project/milestone), or all tasks when status is '*'.
- * Filters compose: all provided filters must match.
- * Results are ordered by priority DESC.
- * Fails with `validation_error` when the underlying data is malformed.
- */
-export const listTasks = (
-  options: ListTasksOptions
-): Effect.Effect<readonly Task[], TaskError, TaskRepository> =>
-  Effect.flatMap(TaskRepository, (repo) =>
-    Effect.map(repo.findByStatus(options.status), (tasks) =>
-      [...applyFilters(tasks, options)].sort((a, b) => b.priority - a.priority)
-    )
-  )

package/src/task/ports.ts

@@ -1,15 +0,0 @@
-import { Context, type Effect } from "effect"
-import type { Status, Task, TaskError } from "../domain/types.js"
-
-export interface TaskRepository {
-  /** Fails with `not_found` if id is absent. */
-  findById(id: string): Effect.Effect<Task, TaskError>
-  /** Returns empty array when nothing matches; fails with `validation_error` on malformed data. */
-  findByStatus(status: Status | "*"): Effect.Effect<readonly Task[], TaskError>
-  /** Fails with `conflict` if a task with the same id already exists. */
-  save(task: Task): Effect.Effect<void, TaskError>
-  /** Fails with `not_found` if id is absent. */
-  update(task: Task): Effect.Effect<void, TaskError>
-}
-
-export const TaskRepository = Context.GenericTag<TaskRepository>("TaskRepository")

package/src/task/session-registry.ts

@@ -1,9 +0,0 @@
-import { Context, type Effect } from "effect"
-
-export interface SessionRegistry {
-  isAlive(sessionId: string): Effect.Effect<boolean, never>
-  register(sessionId: string, pid: number): Effect.Effect<void, never>
-  deregister(sessionId: string): Effect.Effect<void, never>
-}
-
-export const SessionRegistry = Context.GenericTag<SessionRegistry>("SessionRegistry")

package/src/task/update-task.ts

@@ -1,160 +0,0 @@
-import { Effect } from "effect"
-import { guardTransition } from "../domain/status-machine.js"
-import type { Comment, Status, TaskError } from "../domain/types.js"
-import { HookRunner } from "../hook/ports.js"
-import { TaskRepository } from "./ports.js"
-import { SessionRegistry } from "./session-registry.js"
-
-/**
- * Transitions a task to a new status, optionally attaching or replying to a comment.
- * Enforces transition rules, comment requirements, need_info reply cycle,
- * and concurrent in_progress justification.
- * Fires HookRunner after a successful status change.
- */
-export const updateTask = (
-  id: string,
-  newStatus: Status,
-  comment: Comment | null,
-  sessionId: string
-): Effect.Effect<void, TaskError, TaskRepository | HookRunner | SessionRegistry> =>
-  Effect.gen(function* () {
-    const repo = yield* TaskRepository
-    const hookRunner = yield* HookRunner
-
-    // Step 1: find task or fail with not_found
-    const task = yield* repo.findById(id)
-
-    // Step 2: guard transition (same→same is allowed by guardTransition too)
-    // Pass task id so review tasks can skip pending_review and go directly to done
-    yield* guardTransition(task.status, newStatus, task.id)
-
-    // Step 4: reply handling — comment id matches an existing comment
-    // Must run before the no-op check because a reply update is meaningful
-    // even when the status is not changing.
-    if (comment !== null) {
-      const existing = task.comments.find((c) => c.id === comment.id)
-      if (existing !== undefined) {
-        if (existing.kind === "regular") {
-          return yield* Effect.fail<TaskError>({
-            _tag: "validation_error",
-            message: "reply is only valid on need_info comments",
-            context: { commentId: existing.id, commentKind: existing.kind },
-          })
-        }
-        // existing.kind === 'need_info': merge reply and persist, no hook, no status change
-        const updatedComments = task.comments.map((c) =>
-          c.id === comment.id ? { ...c, reply: comment.reply } : c
-        )
-        const updatedTask = { ...task, comments: updatedComments }
-        yield* repo.update(updatedTask)
-        return
-      }
-    }
-
-    // Step 3: no-op when status unchanged (and no reply was handled above)
-    if (task.status === newStatus) return
-
-    // Step 5: need_info requires a comment
-    if (newStatus === "need_info" && comment === null) {
-      return yield* Effect.fail<TaskError>({
-        _tag: "missing_comment",
-        from: task.status,
-        to: newStatus,
-      })
-    }
-
-    // Step 6: blocked requires a non-empty comment
-    if (newStatus === "blocked") {
-      if (comment === null) {
-        return yield* Effect.fail<TaskError>({
-          _tag: "missing_comment",
-          from: task.status,
-          to: newStatus,
-        })
-      }
-      if (comment.content.trim() === "") {
-        return yield* Effect.fail<TaskError>({
-          _tag: "validation_error",
-          message: "blocked requires a non-empty comment",
-          context: { from: task.status, to: newStatus },
-        })
-      }
-    }
-
-    // Step 7: transitioning FROM need_info — all need_info comments must have a reply
-    if (task.status === "need_info") {
-      const blocking = task.comments.find((c) => c.kind === "need_info" && c.reply === "")
-      if (blocking !== undefined) {
-        return yield* Effect.fail<TaskError>({
-          _tag: "validation_error",
-          message: `blocking comment ${blocking.id} has no reply`,
-          context: {
-            commentId: blocking.id,
-            commentTitle: blocking.title,
-            commentContent: blocking.content,
-            commentTimestamp: blocking.timestamp,
-          },
-        })
-      }
-    }
-
-    // Step 8b: ownership check — reject if a live foreign session owns this task
-    if (
-      newStatus === "in_progress" &&
-      task.assignee !== undefined &&
-      task.assignee.id !== sessionId
-    ) {
-      const registry = yield* SessionRegistry
-      const alive = yield* registry.isAlive(task.assignee.id)
-      if (alive) {
-        return yield* Effect.fail<TaskError>({
-          _tag: "validation_error",
-          message: `task is owned by an active session (${task.assignee.id})`,
-          context: { task },
-        })
-      }
-      // dead session — fall through and let step 9 reassign
-    }
-
-    // Step 8: concurrent in_progress — second task for same session requires justification
-    if (newStatus === "in_progress") {
-      const inProgressTasks = yield* repo.findByStatus("in_progress")
-      const sessionInProgress = inProgressTasks.filter(
-        (t) => t.assignee?.id === sessionId && t.id !== task.id
-      )
-      if (sessionInProgress.length > 0) {
-        if (comment === null || comment.content.trim() === "") {
-          return yield* Effect.fail<TaskError>({
-            _tag: "validation_error",
-            message: "moving a second task to in_progress requires a justification comment",
-            context: {
-              inProgressTasks: sessionInProgress.map((t) => ({ id: t.id, title: t.title })),
-            },
-          })
-        }
-      }
-    }
-
-    // Step 9: apply changes
-    const oldStatus = task.status
-    const updatedComments = comment !== null ? [...task.comments, comment] : task.comments
-    const updatedTask = {
-      ...task,
-      status: newStatus,
-      comments: updatedComments,
-      ...(newStatus === "in_progress"
-        ? {
-            in_progress_since: new Date(),
-            assignee: { id: sessionId, title: "Agent", description: "" },
-          }
-        : {}),
-    }
-    yield* repo.update(updatedTask)
-    yield* hookRunner.run({
-      task_id: id,
-      old_status: oldStatus,
-      new_status: newStatus,
-      comment,
-      session_id: sessionId,
-    })
-  })