dsh-taskboard 0.1.0

package/src/index.ts

@@ -0,0 +1,124 @@
+/**
+ * Host loader entry for dsh-taskboard.
+ *
+ * Wiring: the ledger store (one JSON file under the DSH home), the eight
+ * `taskboard_*` agent tools, the agent workflow-protocol system-prompt
+ * section, the /taskboard JSON+SSE routes (when a webServer is served),
+ * the host execution service (fresh in-project sessions, pinned models), and
+ * the host-side cron scheduler for scheduled tasks.
+ *
+ * Export shape follows the dsh-tool-todo lesson: a function/namespace plugin —
+ * `name` / `inject` / `apply`, NO default export.
+ *
+ * @module dsh-taskboard
+ */
+import type { Context } from '@deepseek-ai/cordis'
+// Type-only module imports: they load the cordis Context augmentations
+// (ctx.tools / ctx.systemPrompt / ctx.agents) and vanish at compile time —
+// the built host half keeps ZERO runtime @deepseek-ai imports.
+import type {} from '@deepseek-ai/dsh-tools'
+import type {} from '@deepseek-ai/dsh-system-prompt'
+import type {} from '@deepseek-ai/dsh-agent'
+import { PROTOCOL_SECTION_NAME, PROTOCOL_SECTION_ORDER, TASKBOARD_PROTOCOL } from './host/protocol-text.ts'
+import { ExecutionService, type EventsFace } from './host/execution.ts'
+import { registerTaskboardRoutes } from './host/routes.ts'
+import { SchedulerService } from './host/scheduler.ts'
+import { dshHomePath } from './host/sdk.ts'
+import { TaskStore } from './host/store.ts'
+import { registerTaskboardTools, workspaceFace } from './host/tools.ts'
+
+/** Ledger file name under the DSH home. */
+export const LEDGER_FILE = 'dsh-taskboard.json'
+
+/** Cordis plugin name. */
+export const name = 'dsh-taskboard'
+
+/** Required host services (tool registry + prompt assembly). */
+export const inject = ['tools', 'systemPrompt']
+
+/**
+ * Mount the host half.
+ * @param ctx - the plugin context (tools + systemPrompt injected).
+ */
+export function apply(ctx: Context): void {
+  const store = new TaskStore({ file: dshHomePath(LEDGER_FILE) })
+  const now = () => Date.now()
+
+  // Agent workflow protocol (claim discipline, retry rules, done-gate).
+  const disposeSection = ctx.systemPrompt.section({
+    name: PROTOCOL_SECTION_NAME,
+    order: PROTOCOL_SECTION_ORDER,
+    text: TASKBOARD_PROTOCOL,
+  })
+  ctx.effect(() => disposeSection, 'dsh-taskboard: protocol section')
+
+  // Tools, routes, execution, and the scheduler all come up with the
+  // workspace registry (claim boundary + project execution need it).
+  ctx.inject(['workspaceRegistry'], (wsCtx: Context) => {
+    const disposers: Array<() => void> = []
+    disposers.push(...registerTaskboardTools(wsCtx, {
+      store,
+      workspaces: workspaceFace(wsCtx.workspaceRegistry),
+      now,
+    }))
+
+    // Settlement listener over the session event bus.
+    const events: EventsFace = {
+      onSessionEvent: (listener) => wsCtx.on('session/event', (session, event) => {
+        listener(session.id, event as { type: string; data?: unknown })
+      }),
+    }
+
+    wsCtx.inject(['agents'], (agentCtx: Context) => {
+      const execution = new ExecutionService({
+        store,
+        agents: {
+          create: (options): Promise<never> => agentCtx.agents.create(options as never) as Promise<never>,
+        },
+        workspaces: {
+          get: id => workspaceFace(wsCtx.workspaceRegistry).get(id),
+          attach: async (workspaceId, sessionId) => {
+            const ws = wsCtx.workspaceRegistry.get(workspaceId as never)
+            if (ws !== undefined) await ws.attachSession(sessionId as never)
+          },
+        },
+        events,
+        now,
+        defaultModel: () => {
+          try {
+            const selection = agentCtx.get('agentDefaultModel') as { currentSelection?: () => { provider: string; model: string } | undefined } | undefined
+            const read = selection?.currentSelection
+            return read === undefined ? undefined : read.call(selection)
+          } catch { return undefined }
+        },
+      })
+
+      // /dsh-taskboard routes (the run action reaches the execution service).
+      let disposeRoutes: (() => void) | undefined
+      agentCtx.inject(['webServer'], (webCtx: Context) => {
+        disposeRoutes = registerTaskboardRoutes(webCtx, {
+          store,
+          workspaces: workspaceFace(wsCtx.workspaceRegistry),
+          now,
+          run: (taskId: string) => execution.run(taskId, 'manual'),
+        })
+        return () => disposeRoutes?.()
+      })
+
+      // Host-side cron scheduler: due scheduled tasks execute even with no
+      // browser open.
+      const scheduler = new SchedulerService({ store, execution, now })
+      scheduler.start()
+      disposers.push(() => scheduler.dispose())
+
+      return () => {
+        disposeRoutes?.()
+        for (const dispose of disposers.splice(0)) dispose()
+      }
+    })
+
+    return () => {
+      for (const dispose of disposers.splice(0)) dispose()
+    }
+  })
+}

package/src/invariant.ts

@@ -0,0 +1,22 @@
+/**
+ * Invariant companion for dsh-taskboard.
+ *
+ * DSH convention (see dsh-base / dsh-workspace): packages may ship an
+ * `./invariant` export — a minimal companion plugin that reserves package
+ * ownership in compositions that load invariants without the full plugin.
+ * No behavior in P0; the real plugin carries everything.
+ */
+
+/** Cordis plugin name. */
+export const name = 'dsh-taskboard-invariant'
+
+/** No services required. */
+export const inject: string[] = []
+
+/**
+ * Register the invariant companion (no-op in P0).
+ * @param _ctx - the plugin context.
+ */
+export function apply(_ctx: unknown): void {
+  /* nothing to reserve yet */
+}

package/src/shared/api.ts

@@ -0,0 +1,98 @@
+/**
+ * Wire contract for the /taskboard host routes: the JSON envelope,
+ * request/response shapes, and SSE event payloads shared by the host routes
+ * and the browser client.
+ *
+ * @module dsh-taskboard/shared/api
+ */
+import type { TaskLedger, TaskRecord, TaskSummary } from './protocol.ts'
+
+export type { TaskRecord }
+
+/** Route prefix on the shared DSH webserver (same origin as the GUI). */
+export const ROUTE_PREFIX = '/dsh-taskboard'
+
+/** SSE stream path (exact route; longest-prefix wins keep it disjoint). */
+export const SSE_PATH = '/dsh-taskboard/events'
+
+/** Stable error codes (mirror the tool-level codes plus HTTP mapping). */
+export type ApiErrorCode =
+  | 'invalid_input'
+  | 'not_found'
+  | 'version_conflict'
+  | 'invalid_transition'
+  | 'forbidden'
+  | 'internal'
+
+/** Success envelope. */
+export type ApiOk<T> = { ok: true; value: T }
+
+/** Failure envelope. */
+export type ApiFail = { ok: false; error: { code: ApiErrorCode; message: string } }
+
+/** The envelope either way. */
+export type ApiResult<T> = ApiOk<T> | ApiFail
+
+// ---------------------------------------------------------------------------
+// payloads
+// ---------------------------------------------------------------------------
+
+/** Full-state response (the reconnect baseline after an SSE gap). */
+export type StateResponse = TaskLedger
+
+/** Workspace listing for the UI pickers. */
+export type WorkspaceView = { id: string; path: string; title: string; sessionCount: number }
+
+/** Create-task request body (actor is always the GUI user). */
+export type CreateTaskBody = {
+  title: string
+  workspaceId: string
+  urgency: string
+  description?: string
+  prompt?: string
+  execution?: { mode?: string; cron?: string }
+  model?: { provider: string; model: string }
+}
+
+/** Update-task request body (ifVersion mandatory). */
+export type UpdateTaskBody = {
+  ifVersion: number
+  title?: string
+  description?: string
+  prompt?: string
+  urgency?: string
+  blocked?: boolean
+  /** Rebind the task to another project (GUI owner surface only). */
+  workspaceId?: string
+  execution?: { mode?: string; cron?: string }
+  model?: { provider: string; model: string } | null
+}
+
+/** Move-task request body (ifVersion mandatory; the user MAY move to done). */
+export type MoveTaskBody = { ifVersion: number; status: string }
+
+/** Comment request body. */
+export type CommentBody = { body: string }
+
+/** Delete request body (purge=true physically removes a trashed task). */
+export type DeleteTaskBody = { ifVersion?: number; purge?: boolean }
+
+/** Run request body (P3). */
+export type RunTaskBody = Record<string, never>
+
+/** One task (full record) response. */
+export type TaskResponse = TaskRecord
+
+/** Summary response used by list-ish endpoints. */
+export type SummaryResponse = { tasks: TaskSummary[] }
+
+// ---------------------------------------------------------------------------
+// SSE
+// ---------------------------------------------------------------------------
+
+/** Change frame pushed on every committed ledger mutation. */
+export type ChangeEvent = {
+  revision: number
+  kind: 'task-created' | 'task-updated' | 'task-moved' | 'task-deleted' | 'comment-added' | 'execution-recorded'
+  tasks: TaskSummary[]
+}