kennel 0.2.2 → 0.2.5

package/kernel/plugins/tasks/src/api.ts

@@ -1,212 +0,0 @@
-import { readdir, readFile, writeFile } from "node:fs/promises"
-import { dirname, resolve } from "node:path"
-import type { IncomingMessage, ServerResponse } from "node:http"
-
-import type { ApiRouteHandle } from "@raggle-ai/folder-plugin/endpoint"
-import {
-  apiError,
-  jsonResponse,
-  parseJsonBody,
-  runApiRoute,
-} from "@raggle-ai/folder-plugin/endpoint"
-
-import { parseTodoSource, todoIssueSummary } from "./data/parse.ts"
-import { parseQualifiedTaskId, refMatchesFolder } from "./data/task-id.ts"
-
-/**
- * Context provided by the host. `authorizeFolder` enforces the real viewer
- * root (realpath + locked root) and `watch` wires folder live refresh.
- * `readOnly` disables mutations on remote/restricted hosts.
- */
-export type TasksApiContext = {
-  authorizeFolder: (value: string | null) => string
-  /** Mutations are disabled for remote/restricted hosts. */
-  readOnly?: boolean
-  watch: (folder: string) => void
-}
-
-type Handler = ApiRouteHandle<TasksApiContext>
-
-const TASKS_FILE = "todo.json"
-
-function requireString(value: unknown, name: string) {
-  if (typeof value !== "string" || !value.trim()) {
-    throw apiError("bad-request", `Missing ${name} parameter`)
-  }
-  return value.trim()
-}
-
-/**
- * Re-serialize a parsed task document back into source text. Formatting
- * mirrors the original file: the detected item indent (default two spaces)
- * and the trailing newline are preserved so hand-maintained files do not
- * churn.
- */
-export function serializeTodoSource(
-  document: unknown,
-  original: string,
-): string {
-  const indent = /^\{[\s\S]*?\n([ \t]+)"/m.exec(original)?.[1] ?? "  "
-  const trailing = original.endsWith("\n") ? "\n" : ""
-  return `${JSON.stringify(document, null, indent)}${trailing}`
-}
-
-export type TaskToggleResult = {
-  done: boolean
-  next: string
-}
-
-/**
- * Pure toggle transform on the raw source text: a complete (or canceled)
- * task reopens as `todo`; any other task becomes `done` with
- * `resolution: "completed"` and a `completedAt` timestamp. `updatedAt` is
- * always refreshed. Never touches the file system, so tests can exercise it
- * on strings.
- */
-export function toggleTaskSource(source: string, id: string): TaskToggleResult {
-  const parsed = parseTodoSource(source)
-  if (!parsed.ok) {
-    throw apiError("bad-request", todoIssueSummary(parsed.issues))
-  }
-  const tasks = Array.isArray(parsed.document.tasks)
-    ? parsed.document.tasks
-    : []
-  const task = tasks.find((item) => item.id === id || item.key === id)
-  if (!task) throw apiError("not-found", `Task not found: ${id}`)
-
-  const wasDone = task.done === true || task.status === "done"
-  const done = !wasDone
-  const now = new Date().toISOString()
-  if (done) {
-    task.done = true
-    task.status = "done"
-    task.resolution = "completed"
-    task.completedAt = now
-  } else {
-    task.done = false
-    task.status = "todo"
-    task.resolution = null
-    task.completedAt = null
-  }
-  task.updatedAt = now
-
-  return { done, next: serializeTodoSource(parsed.document, source) }
-}
-
-/**
- * Recursively discover the `todo.json` file that owns a task id/key under
- * the authorized folder. Hidden directories and `node_modules` are skipped
- * and directory symlinks are not followed, so the search stays contained
- * (mirrors the plugin's source discovery). Linked folders are never touched:
- * linked content is read-only by contract.
- *
- * `id` may be a qualified address (`<folderPathId(folder)>@<id|key>`), which
- * restricts the search to that exact source file so identical file-local ids
- * `todo:1` edit the right file. A ref matching no file falls back to the
- * bare-id search; a ref matching a real file without the task stays
- * not-found instead of writing a different file.
- */
-async function findTaskSource(folder: string, id: string) {
-  const search = async (
-    paths: string[],
-    target: string,
-  ): Promise<{ path: string; source: string } | undefined> => {
-    for (const path of paths) {
-      const source = await readFile(path, "utf8")
-      const parsed = parseTodoSource(source)
-      if (!parsed.ok) continue
-      const tasks = Array.isArray(parsed.document.tasks)
-        ? parsed.document.tasks
-        : []
-      if (tasks.some((task) => task.id === target || task.key === target)) {
-        return { path, source }
-      }
-    }
-    return undefined
-  }
-
-  const visit = async (current: string): Promise<string[]> => {
-    const entries = await readdir(current, { withFileTypes: true }).catch(
-      () => [],
-    )
-    const paths: string[] = []
-    for (const entry of entries) {
-      if (entry.isFile() && entry.name === TASKS_FILE) {
-        paths.push(resolve(current, entry.name))
-        continue
-      }
-      if (
-        !entry.isDirectory() ||
-        entry.name.startsWith(".") ||
-        entry.name === "node_modules"
-      )
-        continue
-      paths.push(...(await visit(resolve(current, entry.name))))
-    }
-    return paths
-  }
-
-  const paths = (await visit(folder)).sort((left, right) =>
-    left.localeCompare(right),
-  )
-  const qualified = parseQualifiedTaskId(id)
-  if (qualified) {
-    const owned = paths.filter((path) =>
-      refMatchesFolder(qualified.ref, dirname(path)),
-    )
-    if (owned.length > 0) {
-      return await search(owned, qualified.id)
-    }
-  }
-  return await search(paths, qualified?.id ?? id)
-}
-
-const toggleTask: Handler = async ({ body, context, response }) => {
-  if (context.readOnly) {
-    throw apiError("forbidden", "Task updates are disabled for remote access")
-  }
-  const parsed = parseJsonBody(body)
-  const id = requireString(parsed.id, "id")
-  const folder = context.authorizeFolder(
-    typeof parsed.path === "string" && parsed.path ? parsed.path : null,
-  )
-  const found = await findTaskSource(folder, id)
-  if (!found) throw apiError("not-found", `Task not found: ${id}`)
-
-  // The toggle transform matches file-local ids: strip the source qualifier.
-  const target = parseQualifiedTaskId(id)?.id ?? id
-  const { done, next } = toggleTaskSource(found.source, target)
-  await writeFile(found.path, next, "utf8")
-  context.watch(folder)
-
-  jsonResponse(response, 200, { done, folder, id, ok: true })
-}
-
-const specByPath: Record<
-  string,
-  { handle: Handler; maxBodyBytes?: number; method: "POST"; timeoutMs?: number }
-> = {
-  "/api/tasks/toggle": {
-    method: "POST",
-    maxBodyBytes: 16 * 1024,
-    timeoutMs: 30_000,
-    handle: toggleTask,
-  },
-}
-
-/**
- * All tasks HTTP routes. `/api/tasks/toggle` is a POST mutation guarded by
- * the endpoint wrapper's same-origin check, bounded body, and timeout.
- * Returns false for non-tasks paths so the host can continue its routing.
- */
-export async function handleTasksApiRoutes(
-  request: IncomingMessage,
-  response: ServerResponse,
-  context: TasksApiContext,
-): Promise<boolean> {
-  const url = new URL(request.url ?? "/", "http://127.0.0.1")
-  const spec = specByPath[url.pathname]
-  if (!spec) return false
-  await runApiRoute(request, response, url, spec, context)
-  return true
-}

package/kernel/plugins/tasks/src/client.tsx

@@ -1,23 +0,0 @@
-import type { FolderPluginViewProps } from "@raggle-ai/folder-plugin/client"
-
-import { tasksManifest } from "./manifest"
-import { TaskDetailPage } from "./pages/task-detail"
-import { TaskListPage } from "./pages/task-list"
-
-/**
- * Client entry: route between the two task pages by subpath. The list page
- * renders the workspace task list; every subpath renders the single task
- * page for that address.
- */
-export function TasksPlugin(props: FolderPluginViewProps) {
-  return props.subpath ? (
-    <TaskDetailPage {...props} />
-  ) : (
-    <TaskListPage {...props} />
-  )
-}
-
-export const tasksClient = {
-  ...tasksManifest,
-  component: TasksPlugin,
-}