logbook-mcp 0.2.0

package/src/infra/hook-config-loader.ts

@@ -0,0 +1,99 @@
+import { readdir, readFile } from "node:fs/promises"
+import { join } from "node:path"
+import { z } from "zod"
+import type { HookConfig } from "../hook/hook-executor.js"
+
+const HookConfigFileSchema = z.object({
+  event: z.string(),
+  condition: z.string().optional(),
+  timeout_ms: z.number().optional(),
+})
+
+/**
+ * Parses a strict subset of YAML: flat key-value pairs, no nesting.
+ * Supports quoted strings and bare integers.
+ */
+const parseSimpleYaml = (content: string): Record<string, unknown> => {
+  const result: Record<string, unknown> = {}
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim()
+    if (!trimmed || trimmed.startsWith("#")) continue
+    const colonIdx = trimmed.indexOf(":")
+    if (colonIdx === -1) continue
+    const key = trimmed.slice(0, colonIdx).trim()
+    let value: unknown = trimmed.slice(colonIdx + 1).trim()
+    if (typeof value === "string" && value.startsWith('"') && value.endsWith('"')) {
+      value = value.slice(1, -1)
+    } else if (typeof value === "string" && value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1)
+    } else if (typeof value === "string" && /^\d+$/.test(value)) {
+      value = parseInt(value, 10)
+    }
+    result[key] = value
+  }
+  return result
+}
+
+const SCRIPT_CANDIDATES = ["script.ts", "script.sh"] as const
+
+const findScript = async (hookDir: string): Promise<string | undefined> => {
+  for (const name of SCRIPT_CANDIDATES) {
+    const candidate = join(hookDir, name)
+    try {
+      await readFile(candidate)
+      return candidate
+    } catch {
+      // try next candidate
+    }
+  }
+  return undefined
+}
+
+export const loadHookConfigs = async (hooksDir: string): Promise<HookConfig[]> => {
+  let entries: string[]
+  try {
+    entries = await readdir(hooksDir)
+  } catch (e: unknown) {
+    if (isEnoent(e)) return []
+    throw e
+  }
+
+  const configs: HookConfig[] = []
+
+  for (const entry of entries) {
+    const hookDir = join(hooksDir, entry)
+    try {
+      const configPath = join(hookDir, "config.yml")
+      const raw = await readFile(configPath, "utf8")
+      const parsed = parseSimpleYaml(raw)
+      const validated = HookConfigFileSchema.safeParse(parsed)
+      if (!validated.success) {
+        console.warn(
+          `[hook-config-loader] invalid config at ${configPath}:`,
+          validated.error.message
+        )
+        continue
+      }
+      const script = await findScript(hookDir)
+      if (script === undefined) {
+        console.warn(`[hook-config-loader] no script found in ${hookDir}, skipping`)
+        continue
+      }
+      const { event, condition, timeout_ms } = validated.data
+      const config: HookConfig = {
+        event,
+        script,
+        ...(condition !== undefined ? { condition } : {}),
+        ...(timeout_ms !== undefined ? { timeout_ms } : {}),
+      }
+      configs.push(config)
+    } catch (e: unknown) {
+      console.warn(`[hook-config-loader] failed to load hook "${entry}":`, String(e))
+    }
+  }
+
+  return configs
+}
+
+const isEnoent = (e: unknown): boolean =>
+  typeof e === "object" && e !== null && (e as { code?: unknown }).code === "ENOENT"

package/src/infra/jsonl-task-repository.ts

@@ -0,0 +1,156 @@
+import { appendFile, readFile, rename, writeFile } from "node:fs/promises"
+import { Effect } from "effect"
+import type { Status, Task, TaskError } from "../domain/types.js"
+import { TaskSchema } from "../domain/types.js"
+import type { TaskRepository } from "../task/ports.js"
+
+/**
+ * JSONL-backed TaskRepository.
+ * Each line is a JSON-serialized Task.
+ * Reads scan the full file; writes are append-only for save, full-rewrite for update.
+ */
+export class JsonlTaskRepository implements TaskRepository {
+  constructor(private readonly filePath: string) {}
+
+  save(task: Task): Effect.Effect<void, TaskError> {
+    return Effect.tryPromise<void, TaskError>({
+      try: async () => {
+        const content = await readFile(this.filePath, "utf8").catch((e: unknown) => {
+          if (isEnoent(e)) return ""
+          throw e
+        })
+        const lines = splitLines(content)
+        const conflict = lines.some((line) => {
+          try {
+            const parsed = JSON.parse(line) as unknown
+            return (parsed as { id?: unknown }).id === task.id
+          } catch {
+            return false
+          }
+        })
+        if (conflict) {
+          throw mkTagged<TaskError>({ _tag: "conflict", taskId: task.id })
+        }
+        await appendFile(this.filePath, `${JSON.stringify(task)}\n`, "utf8")
+      },
+      catch: (e) => asTaskError(e, task.id),
+    })
+  }
+
+  update(task: Task): Effect.Effect<void, TaskError> {
+    return Effect.tryPromise<void, TaskError>({
+      try: async () => {
+        const content = await readFile(this.filePath, "utf8").catch((e: unknown) => {
+          if (isEnoent(e)) return ""
+          throw e
+        })
+        const lines = splitLines(content)
+        let found = false
+        const updated = lines.map((line) => {
+          try {
+            const parsed = JSON.parse(line) as unknown
+            if ((parsed as { id?: unknown }).id === task.id) {
+              found = true
+              return JSON.stringify(task)
+            }
+          } catch {
+            // keep malformed lines as-is
+          }
+          return line
+        })
+        if (!found) {
+          throw mkTagged<TaskError>({ _tag: "not_found", taskId: task.id })
+        }
+        const tmpPath = `${this.filePath}.tmp`
+        await writeFile(tmpPath, `${updated.join("\n")}\n`, "utf8")
+        await rename(tmpPath, this.filePath)
+      },
+      catch: (e) => asTaskError(e, task.id),
+    })
+  }
+
+  findById(id: string): Effect.Effect<Task, TaskError> {
+    return Effect.tryPromise<Task, TaskError>({
+      try: async () => {
+        const content = await readFile(this.filePath, "utf8").catch((e: unknown) => {
+          if (isEnoent(e)) return ""
+          throw e
+        })
+        const lines = splitLines(content)
+        for (const line of lines) {
+          const result = parseLine(line)
+          if (result._tag === "error") {
+            console.warn("[JsonlTaskRepository] skipping malformed line:", result.reason)
+            continue
+          }
+          if (result.task.id === id) return result.task
+        }
+        throw mkTagged<TaskError>({ _tag: "not_found", taskId: id })
+      },
+      catch: (e) => asTaskError(e, id),
+    })
+  }
+
+  findByStatus(status: Status | "*"): Effect.Effect<readonly Task[], TaskError> {
+    return Effect.tryPromise<readonly Task[], TaskError>({
+      try: async () => {
+        const content = await readFile(this.filePath, "utf8").catch((e: unknown) => {
+          if (isEnoent(e)) return ""
+          throw e
+        })
+        const lines = splitLines(content)
+        const tasks: Task[] = []
+        for (const line of lines) {
+          const result = parseLine(line)
+          if (result._tag === "error") {
+            throw mkTagged<TaskError>({ _tag: "validation_error", message: result.reason })
+          }
+          if (status === "*" || result.task.status === status) {
+            tasks.push(result.task)
+          }
+        }
+        return tasks
+      },
+      catch: (e) => asTaskError(e, ""),
+    })
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers (pure)
+// ---------------------------------------------------------------------------
+
+type ParseResult =
+  | { readonly _tag: "ok"; readonly task: Task }
+  | { readonly _tag: "error"; readonly reason: string }
+
+const parseLine = (line: string): ParseResult => {
+  let raw: unknown
+  try {
+    raw = JSON.parse(line)
+  } catch (e) {
+    return { _tag: "error", reason: `invalid JSON: ${String(e)}` }
+  }
+  const result = TaskSchema.safeParse(raw)
+  if (!result.success) {
+    return { _tag: "error", reason: result.error.message }
+  }
+  return { _tag: "ok", task: result.data }
+}
+
+const splitLines = (content: string): readonly string[] =>
+  content.split("\n").filter((l) => l.trim() !== "")
+
+const isEnoent = (e: unknown): boolean =>
+  typeof e === "object" && e !== null && (e as { code?: unknown }).code === "ENOENT"
+
+/** Carries a typed TaskError through the tryPromise boundary. */
+const mkTagged = <E>(value: E): E => value
+
+const asTaskError = (e: unknown, _taskId: string): TaskError => {
+  if (isTaskError(e)) return e
+  return { _tag: "validation_error", message: String(e) } satisfies TaskError
+}
+
+const isTaskError = (e: unknown): e is TaskError =>
+  typeof e === "object" && e !== null && typeof (e as { _tag?: unknown })._tag === "string"

package/src/mcp/error-codes.ts

@@ -0,0 +1,28 @@
+import type { TaskError } from "../domain/types.js"
+
+export interface McpError {
+  code: number
+  message: string
+  data: Record<string, unknown>
+}
+
+export const taskErrorToMcpError = (err: TaskError): McpError => {
+  switch (err._tag) {
+    case "not_found":
+      return { code: -32001, message: "Task not found", data: { taskId: err.taskId } }
+    case "transition_not_allowed":
+      return {
+        code: -32002,
+        message: "Status transition not allowed",
+        data: { from: err.from, to: err.to },
+      }
+    case "validation_error":
+      return { code: -32003, message: "Validation error", data: { message: err.message } }
+    case "missing_comment":
+      return { code: -32004, message: "A comment is required for this transition", data: {} }
+    case "conflict":
+      return { code: -32005, message: "Task already exists", data: { taskId: err.taskId } }
+    case "no_current_task":
+      return { code: -32006, message: "No current task for this session", data: {} }
+  }
+}

package/src/mcp/server.ts

@@ -0,0 +1,214 @@
+#!/usr/bin/env bun
+import { createInterface } from "node:readline"
+import { Layer } from "effect"
+import { executeHooks } from "../hook/hook-executor.js"
+import type { HookEvent } from "../hook/ports.js"
+import { HookRunner } from "../hook/ports.js"
+import { loadHookConfigs } from "../infra/hook-config-loader.js"
+import { JsonlTaskRepository } from "../infra/jsonl-task-repository.js"
+import { TaskRepository } from "../task/ports.js"
+import { taskErrorToMcpError } from "./error-codes.js"
+import { newSessionId } from "./session.js"
+import { toolCreateTask } from "./tool-create-task.js"
+import { toolCurrentTask } from "./tool-current-task.js"
+import { toolEditTask } from "./tool-edit-task.js"
+import { toolListTasks } from "./tool-list-tasks.js"
+import { toolUpdateTask } from "./tool-update-task.js"
+
+// ---------------------------------------------------------------------------
+// JSON-RPC 2.0 types
+// ---------------------------------------------------------------------------
+
+interface JsonRpcRequest {
+  jsonrpc: "2.0"
+  id: string | number | null
+  method: string
+  params?: unknown
+}
+
+interface JsonRpcSuccess {
+  jsonrpc: "2.0"
+  id: string | number | null
+  result: unknown
+}
+
+interface JsonRpcError {
+  jsonrpc: "2.0"
+  id: string | number | null
+  error: {
+    code: number
+    message: string
+    data?: unknown
+  }
+}
+
+type JsonRpcResponse = JsonRpcSuccess | JsonRpcError
+
+// ---------------------------------------------------------------------------
+// Response helpers (pure)
+// ---------------------------------------------------------------------------
+
+const successResponse = (id: string | number | null, result: unknown): JsonRpcSuccess => ({
+  jsonrpc: "2.0",
+  id,
+  result,
+})
+
+const errorResponse = (
+  id: string | number | null,
+  code: number,
+  message: string,
+  data?: unknown
+): JsonRpcError => ({
+  jsonrpc: "2.0",
+  id,
+  error: data !== undefined ? { code, message, data } : { code, message },
+})
+
+const parseError = (id: string | number | null): JsonRpcError =>
+  errorResponse(id, -32700, "Parse error")
+const methodNotFound = (id: string | number | null, method: string): JsonRpcError =>
+  errorResponse(id, -32601, `Method not found: ${method}`)
+const internalError = (id: string | number | null, message: string): JsonRpcError =>
+  errorResponse(id, -32603, message)
+
+// ---------------------------------------------------------------------------
+// Server bootstrap
+// ---------------------------------------------------------------------------
+
+export const startServer = async (): Promise<void> => {
+  const tasksFile = process.env.LOGBOOK_TASKS_FILE ?? "./tasks.jsonl"
+  const hooksDir = process.env.LOGBOOK_HOOKS_DIR ?? "./hooks"
+
+  const configs = await loadHookConfigs(hooksDir)
+  const repo = new JsonlTaskRepository(tasksFile)
+
+  const hookRunnerImpl: HookRunner = {
+    run: (event: HookEvent) => executeHooks(event, configs),
+  }
+
+  const repoLayer: Layer.Layer<TaskRepository> = Layer.succeed(TaskRepository, repo)
+  const fullLayer: Layer.Layer<TaskRepository | HookRunner> = Layer.merge(
+    repoLayer,
+    Layer.succeed(HookRunner, hookRunnerImpl)
+  )
+
+  const sessionId = newSessionId()
+
+  // ---------------------------------------------------------------------------
+  // Tool dispatch
+  // ---------------------------------------------------------------------------
+
+  const dispatch = async (method: string, params: unknown): Promise<unknown> => {
+    switch (method) {
+      case "list_tasks":
+        return toolListTasks(params, repoLayer)
+      case "current_task":
+        return toolCurrentTask(sessionId, repoLayer)
+      case "update_task":
+        return toolUpdateTask(params, sessionId, fullLayer)
+      case "create_task":
+        return toolCreateTask(params, sessionId, repoLayer)
+      case "edit_task":
+        return toolEditTask(params, repoLayer)
+      default:
+        return Promise.reject(new MethodNotFoundError(method))
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // stdio JSON-RPC loop
+  // ---------------------------------------------------------------------------
+
+  const rl = createInterface({ input: process.stdin, terminal: false })
+
+  const send = (response: JsonRpcResponse): void => {
+    process.stdout.write(`${JSON.stringify(response)}\n`)
+  }
+
+  rl.on("line", (line) => {
+    const trimmed = line.trim()
+    if (trimmed === "") return
+
+    let request: JsonRpcRequest
+    try {
+      request = JSON.parse(trimmed) as JsonRpcRequest
+    } catch {
+      send(parseError(null))
+      return
+    }
+
+    const id = request.id ?? null
+
+    dispatch(request.method, request.params ?? {})
+      .then((result) => {
+        send(successResponse(id, result))
+      })
+      .catch((err: unknown) => {
+        if (err instanceof MethodNotFoundError) {
+          send(methodNotFound(id, err.method))
+          return
+        }
+        // Task domain errors come through Effect.runPromise rejections
+        if (isTaskError(err)) {
+          const mcpErr = taskErrorToMcpError(err)
+          send(errorResponse(id, mcpErr.code, mcpErr.message, mcpErr.data))
+          return
+        }
+        // Zod parse errors from tool input validation
+        if (isZodError(err)) {
+          send(errorResponse(id, -32602, "Invalid params", { issues: err.errors }))
+          return
+        }
+        send(internalError(id, String(err)))
+      })
+  })
+
+  rl.on("close", () => {
+    process.exit(0)
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Internal error sentinel
+// ---------------------------------------------------------------------------
+
+class MethodNotFoundError extends Error {
+  constructor(readonly method: string) {
+    super(`Method not found: ${method}`)
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Type narrowing helpers (pure)
+// ---------------------------------------------------------------------------
+
+const isTaskError = (e: unknown): e is import("../domain/types.js").TaskError =>
+  typeof e === "object" &&
+  e !== null &&
+  typeof (e as { _tag?: unknown })._tag === "string" &&
+  [
+    "not_found",
+    "transition_not_allowed",
+    "validation_error",
+    "missing_comment",
+    "conflict",
+    "no_current_task",
+  ].includes((e as { _tag: string })._tag)
+
+interface ZodError {
+  errors: unknown[]
+}
+
+const isZodError = (e: unknown): e is ZodError =>
+  typeof e === "object" &&
+  e !== null &&
+  Array.isArray((e as { errors?: unknown }).errors) &&
+  "name" in (e as object) &&
+  (e as { name: string }).name === "ZodError"
+
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+
+await startServer()

package/src/mcp/session.ts

@@ -0,0 +1 @@
+export const newSessionId = (): string => crypto.randomUUID()

package/src/mcp/tool-create-task.ts

@@ -0,0 +1,27 @@
+import { Effect, type Layer } from "effect"
+import { z } from "zod"
+import { createTask } from "../task/create-task.js"
+import type { TaskRepository } from "../task/ports.js"
+
+const InputSchema = z.object({
+  project: z.string().min(1),
+  milestone: z.string().min(1),
+  title: z.string().min(1),
+  definition_of_done: z.string().min(1),
+  description: z.string().min(1),
+  predictedKTokens: z.number().positive(),
+})
+
+export const toolCreateTask = (
+  rawInput: unknown,
+  sessionId: string,
+  layer: Layer.Layer<TaskRepository>
+): Promise<{ task: unknown }> => {
+  const input = InputSchema.parse(rawInput)
+  return Effect.runPromise(
+    Effect.provide(
+      createTask(input, sessionId).pipe(Effect.map((task) => ({ task }))),
+      layer
+    ) as Effect.Effect<{ task: unknown }, never>
+  )
+}

package/src/mcp/tool-current-task.ts

@@ -0,0 +1,15 @@
+import { Effect, type Layer } from "effect"
+import { currentTask } from "../task/current-task.js"
+import type { TaskRepository } from "../task/ports.js"
+
+export const toolCurrentTask = (
+  sessionId: string,
+  layer: Layer.Layer<TaskRepository>
+): Promise<{ task: unknown }> => {
+  return Effect.runPromise(
+    Effect.provide(
+      currentTask(sessionId).pipe(Effect.map((task) => ({ task }))),
+      layer
+    ) as Effect.Effect<{ task: unknown }, never>
+  )
+}

package/src/mcp/tool-edit-task.ts

@@ -0,0 +1,35 @@
+import { Effect, type Layer } from "effect"
+import { z } from "zod"
+import type { EditTaskInput } from "../task/edit-task.js"
+import { editTask } from "../task/edit-task.js"
+import type { TaskRepository } from "../task/ports.js"
+
+const InputSchema = z.object({
+  id: z.string().min(1),
+  title: z.string().optional(),
+  description: z.string().optional(),
+  definition_of_done: z.string().optional(),
+  predictedKTokens: z.number().positive().optional(),
+})
+
+export const toolEditTask = (
+  rawInput: unknown,
+  layer: Layer.Layer<TaskRepository>
+): Promise<{ task: unknown }> => {
+  const parsed = InputSchema.parse(rawInput)
+  const { id } = parsed
+  // Build updates by omitting undefined fields (exact optional property types compliance)
+  const updates: EditTaskInput = {}
+  if (parsed.title !== undefined) updates.title = parsed.title
+  if (parsed.description !== undefined) updates.description = parsed.description
+  if (parsed.definition_of_done !== undefined)
+    updates.definition_of_done = parsed.definition_of_done
+  if (parsed.predictedKTokens !== undefined) updates.predictedKTokens = parsed.predictedKTokens
+
+  return Effect.runPromise(
+    Effect.provide(
+      editTask(id, updates).pipe(Effect.map((task) => ({ task }))),
+      layer
+    ) as Effect.Effect<{ task: unknown }, never>
+  )
+}

package/src/mcp/tool-list-tasks.ts

@@ -0,0 +1,22 @@
+import { Effect, type Layer } from "effect"
+import { z } from "zod"
+import { StatusSchema } from "../domain/types.js"
+import { listTasks } from "../task/list-tasks.js"
+import type { TaskRepository } from "../task/ports.js"
+
+const InputSchema = z.object({
+  status: z.union([StatusSchema, z.literal("*")]).default("in_progress"),
+})
+
+export const toolListTasks = (
+  rawInput: unknown,
+  layer: Layer.Layer<TaskRepository>
+): Promise<{ tasks: unknown[] }> => {
+  const input = InputSchema.parse(rawInput)
+  return Effect.runPromise(
+    Effect.provide(
+      listTasks(input.status).pipe(Effect.map((tasks) => ({ tasks: tasks as unknown[] }))),
+      layer
+    ) as Effect.Effect<{ tasks: unknown[] }, never>
+  )
+}

package/src/mcp/tool-update-task.ts

@@ -0,0 +1,47 @@
+import { Effect, type Layer } from "effect"
+import { z } from "zod"
+import { CommentKindSchema, StatusSchema } from "../domain/types.js"
+import type { HookRunner } from "../hook/ports.js"
+import type { TaskRepository } from "../task/ports.js"
+import { updateTask } from "../task/update-task.js"
+
+const CommentInputSchema = z
+  .object({
+    title: z.string().min(1),
+    content: z.string(),
+    kind: CommentKindSchema,
+  })
+  .optional()
+
+const InputSchema = z.object({
+  id: z.string().min(1),
+  new_status: StatusSchema,
+  comment: CommentInputSchema,
+})
+
+export const toolUpdateTask = (
+  rawInput: unknown,
+  sessionId: string,
+  layer: Layer.Layer<TaskRepository | HookRunner>
+): Promise<{ ok: boolean }> => {
+  const input = InputSchema.parse(rawInput)
+  const comment = input.comment
+    ? {
+        id: crypto.randomUUID(),
+        timestamp: new Date(),
+        title: input.comment.title,
+        content: input.comment.content,
+        reply: "",
+        kind: input.comment.kind,
+      }
+    : null
+
+  return Effect.runPromise(
+    Effect.provide(
+      updateTask(input.id, input.new_status, comment, sessionId).pipe(
+        Effect.map(() => ({ ok: true }))
+      ),
+      layer
+    ) as Effect.Effect<{ ok: boolean }, never>
+  )
+}