@toolkit-cli/toolkode 1.3.7

package/src/control-plane/adaptors/worktree.ts

@@ -0,0 +1,38 @@
+import z from "zod"
+import { Worktree } from "@/worktree"
+import { type Adaptor, WorkspaceInfo } from "../types"
+
+const Config = WorkspaceInfo.extend({
+  name: WorkspaceInfo.shape.name.unwrap(),
+  branch: WorkspaceInfo.shape.branch.unwrap(),
+  directory: WorkspaceInfo.shape.directory.unwrap(),
+})
+
+type Config = z.infer<typeof Config>
+
+export const WorktreeAdaptor: Adaptor = {
+  async configure(info) {
+    const worktree = await Worktree.makeWorktreeInfo(info.name ?? undefined)
+    return {
+      ...info,
+      name: worktree.name,
+      branch: worktree.branch,
+      directory: worktree.directory,
+    }
+  },
+  async create(info) {
+    const config = Config.parse(info)
+    await Worktree.createFromInfo({
+      name: config.name,
+      directory: config.directory,
+      branch: config.branch,
+    })
+  },
+  async remove(info) {
+    const config = Config.parse(info)
+    await Worktree.remove({ directory: config.directory })
+  },
+  async fetch(_info, _input: RequestInfo | URL, _init?: RequestInit) {
+    throw new Error("fetch not implemented")
+  },
+}

package/src/control-plane/schema.ts

@@ -0,0 +1,17 @@
+import { Schema } from "effect"
+import z from "zod"
+
+import { withStatics } from "@/util/schema"
+import { Identifier } from "@/id/id"
+
+const workspaceIdSchema = Schema.String.pipe(Schema.brand("WorkspaceID"))
+
+export type WorkspaceID = typeof workspaceIdSchema.Type
+
+export const WorkspaceID = workspaceIdSchema.pipe(
+  withStatics((schema: typeof workspaceIdSchema) => ({
+    make: (id: string) => schema.makeUnsafe(id),
+    ascending: (id?: string) => schema.makeUnsafe(Identifier.ascending("workspace", id)),
+    zod: Identifier.schema("workspace").pipe(z.custom<WorkspaceID>()),
+  })),
+)

package/src/control-plane/sse.ts

@@ -0,0 +1,66 @@
+export async function parseSSE(
+  body: ReadableStream<Uint8Array>,
+  signal: AbortSignal,
+  onEvent: (event: unknown) => void,
+) {
+  const reader = body.getReader()
+  const decoder = new TextDecoder()
+  let buf = ""
+  let last = ""
+  let retry = 1000
+
+  const abort = () => {
+    void reader.cancel().catch(() => undefined)
+  }
+
+  signal.addEventListener("abort", abort)
+
+  try {
+    while (!signal.aborted) {
+      const chunk = await reader.read().catch(() => ({ done: true, value: undefined as Uint8Array | undefined }))
+      if (chunk.done) break
+
+      buf += decoder.decode(chunk.value, { stream: true })
+      buf = buf.replace(/\r\n/g, "\n").replace(/\r/g, "\n")
+
+      const chunks = buf.split("\n\n")
+      buf = chunks.pop() ?? ""
+
+      chunks.forEach((chunk) => {
+        const data: string[] = []
+        chunk.split("\n").forEach((line) => {
+          if (line.startsWith("data:")) {
+            data.push(line.replace(/^data:\s*/, ""))
+            return
+          }
+          if (line.startsWith("id:")) {
+            last = line.replace(/^id:\s*/, "")
+            return
+          }
+          if (line.startsWith("retry:")) {
+            const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10)
+            if (!Number.isNaN(parsed)) retry = parsed
+          }
+        })
+
+        if (!data.length) return
+        const raw = data.join("\n")
+        try {
+          onEvent(JSON.parse(raw))
+        } catch {
+          onEvent({
+            type: "sse.message",
+            properties: {
+              data: raw,
+              id: last || undefined,
+              retry,
+            },
+          })
+        }
+      })
+    }
+  } finally {
+    signal.removeEventListener("abort", abort)
+    reader.releaseLock()
+  }
+}

package/src/control-plane/types.ts

@@ -0,0 +1,21 @@
+import z from "zod"
+import { ProjectID } from "@/project/schema"
+import { WorkspaceID } from "./schema"
+
+export const WorkspaceInfo = z.object({
+  id: WorkspaceID.zod,
+  type: z.string(),
+  branch: z.string().nullable(),
+  name: z.string().nullable(),
+  directory: z.string().nullable(),
+  extra: z.unknown().nullable(),
+  projectID: ProjectID.zod,
+})
+export type WorkspaceInfo = z.infer<typeof WorkspaceInfo>
+
+export type Adaptor = {
+  configure(input: WorkspaceInfo): WorkspaceInfo | Promise<WorkspaceInfo>
+  create(input: WorkspaceInfo, from?: WorkspaceInfo): Promise<void>
+  remove(config: WorkspaceInfo): Promise<void>
+  fetch(config: WorkspaceInfo, input: RequestInfo | URL, init?: RequestInit): Promise<Response>
+}

package/src/control-plane/workspace.sql.ts

@@ -0,0 +1,17 @@
+import { sqliteTable, text } from "drizzle-orm/sqlite-core"
+import { ProjectTable } from "../project/project.sql"
+import type { ProjectID } from "../project/schema"
+import type { WorkspaceID } from "./schema"
+
+export const WorkspaceTable = sqliteTable("workspace", {
+  id: text().$type<WorkspaceID>().primaryKey(),
+  type: text().notNull(),
+  branch: text(),
+  name: text(),
+  directory: text(),
+  extra: text({ mode: "json" }),
+  project_id: text()
+    .$type<ProjectID>()
+    .notNull()
+    .references(() => ProjectTable.id, { onDelete: "cascade" }),
+})

package/src/control-plane/workspace.ts

@@ -0,0 +1,154 @@
+import z from "zod"
+import { setTimeout as sleep } from "node:timers/promises"
+import { fn } from "@/util/fn"
+import { Database, eq } from "@/storage/db"
+import { Project } from "@/project/project"
+import { BusEvent } from "@/bus/bus-event"
+import { GlobalBus } from "@/bus/global"
+import { Log } from "@/util/log"
+import { ProjectID } from "@/project/schema"
+import { WorkspaceTable } from "./workspace.sql"
+import { getAdaptor } from "./adaptors"
+import { WorkspaceInfo } from "./types"
+import { WorkspaceID } from "./schema"
+import { parseSSE } from "./sse"
+
+export namespace Workspace {
+  export const Event = {
+    Ready: BusEvent.define(
+      "workspace.ready",
+      z.object({
+        name: z.string(),
+      }),
+    ),
+    Failed: BusEvent.define(
+      "workspace.failed",
+      z.object({
+        message: z.string(),
+      }),
+    ),
+  }
+
+  export const Info = WorkspaceInfo.meta({
+    ref: "Workspace",
+  })
+  export type Info = z.infer<typeof Info>
+
+  function fromRow(row: typeof WorkspaceTable.$inferSelect): Info {
+    return {
+      id: row.id,
+      type: row.type,
+      branch: row.branch,
+      name: row.name,
+      directory: row.directory,
+      extra: row.extra,
+      projectID: row.project_id,
+    }
+  }
+
+  const CreateInput = z.object({
+    id: WorkspaceID.zod.optional(),
+    type: Info.shape.type,
+    branch: Info.shape.branch,
+    projectID: ProjectID.zod,
+    extra: Info.shape.extra,
+  })
+
+  export const create = fn(CreateInput, async (input) => {
+    const id = WorkspaceID.ascending(input.id)
+    const adaptor = await getAdaptor(input.type)
+
+    const config = await adaptor.configure({ ...input, id, name: null, directory: null })
+
+    const info: Info = {
+      id,
+      type: config.type,
+      branch: config.branch ?? null,
+      name: config.name ?? null,
+      directory: config.directory ?? null,
+      extra: config.extra ?? null,
+      projectID: input.projectID,
+    }
+
+    Database.use((db) => {
+      db.insert(WorkspaceTable)
+        .values({
+          id: info.id,
+          type: info.type,
+          branch: info.branch,
+          name: info.name,
+          directory: info.directory,
+          extra: info.extra,
+          project_id: info.projectID,
+        })
+        .run()
+    })
+
+    await adaptor.create(config)
+    return info
+  })
+
+  export function list(project: Project.Info) {
+    const rows = Database.use((db) =>
+      db.select().from(WorkspaceTable).where(eq(WorkspaceTable.project_id, project.id)).all(),
+    )
+    return rows.map(fromRow).sort((a, b) => a.id.localeCompare(b.id))
+  }
+
+  export const get = fn(WorkspaceID.zod, async (id) => {
+    const row = Database.use((db) => db.select().from(WorkspaceTable).where(eq(WorkspaceTable.id, id)).get())
+    if (!row) return
+    return fromRow(row)
+  })
+
+  export const remove = fn(WorkspaceID.zod, async (id) => {
+    const row = Database.use((db) => db.select().from(WorkspaceTable).where(eq(WorkspaceTable.id, id)).get())
+    if (row) {
+      const info = fromRow(row)
+      const adaptor = await getAdaptor(row.type)
+      adaptor.remove(info)
+      Database.use((db) => db.delete(WorkspaceTable).where(eq(WorkspaceTable.id, id)).run())
+      return info
+    }
+  })
+  const log = Log.create({ service: "workspace-sync" })
+
+  async function workspaceEventLoop(space: Info, stop: AbortSignal) {
+    while (!stop.aborted) {
+      const adaptor = await getAdaptor(space.type)
+      const res = await adaptor.fetch(space, "/event", { method: "GET", signal: stop }).catch(() => undefined)
+      if (!res || !res.ok || !res.body) {
+        await sleep(1000)
+        continue
+      }
+      await parseSSE(res.body, stop, (event) => {
+        GlobalBus.emit("event", {
+          directory: space.id,
+          payload: event,
+        })
+      })
+      // Wait 250ms and retry if SSE connection fails
+      await sleep(250)
+    }
+  }
+
+  export function startSyncing(project: Project.Info) {
+    const stop = new AbortController()
+    const spaces = list(project).filter((space) => space.type !== "worktree")
+
+    spaces.forEach((space) => {
+      void workspaceEventLoop(space, stop.signal).catch((error) => {
+        log.warn("workspace sync listener failed", {
+          workspaceID: space.id,
+          error,
+        })
+      })
+    })
+
+    return {
+      async stop() {
+        stop.abort()
+      },
+    }
+  }
+}

package/src/cron/index.ts

@@ -0,0 +1,241 @@
+/**
+ * tk_ toolkode — Session-scoped cron scheduler
+ *
+ * Fires prompts on cron schedules between user turns.
+ * Session-scoped: all tasks die when the process exits.
+ */
+import { Log } from "../util/log"
+import { parseCron, nextMatch } from "./parse"
+
+const log = Log.create({ service: "cron" })
+
+export namespace Cron {
+  export interface Task {
+    id: string
+    cron: string
+    prompt: string
+    recurring: boolean
+    createdAt: number
+    lastFiredAt?: number
+    nextFireAt: number
+    expiresAt: number
+    jitterMs: number
+    fireCount: number
+  }
+
+  type FireCallback = (task: Task) => void
+
+  const MAX_TASKS = 50
+  const EXPIRY_MS = 3 * 24 * 60 * 60 * 1000 // 3 days
+  const CHECK_INTERVAL_MS = 1000 // check every second
+
+  const tasks = new Map<string, Task>()
+  let timer: ReturnType<typeof setInterval> | null = null
+  let fireCallback: FireCallback | null = null
+  let busy = false
+  let disabled = false
+
+  /** Generate an 8-character hex ID */
+  function generateId(): string {
+    const bytes = new Uint8Array(4)
+    crypto.getRandomValues(bytes)
+    return Array.from(bytes)
+      .map((b) => b.toString(16).padStart(2, "0"))
+      .join("")
+  }
+
+  /** Compute deterministic jitter from task ID */
+  function computeJitter(id: string, intervalMs: number): number {
+    let hash = 0
+    for (let i = 0; i < id.length; i++) {
+      hash = ((hash << 5) - hash + id.charCodeAt(i)) | 0
+    }
+    const maxJitter = Math.min(intervalMs * 0.1, 15 * 60 * 1000) // 10% of period, max 15 min
+    return Math.abs(hash) % Math.max(maxJitter, 1)
+  }
+
+  /** Estimate interval in ms from a cron expression (for jitter calc) */
+  function estimateIntervalMs(cron: string): number {
+    const parts = cron.split(/\s+/)
+    if (parts.length !== 5) return 10 * 60 * 1000
+    const [min, hour, dom, mon, dow] = parts
+
+    // Simple heuristics
+    if (min.startsWith("*/")) return parseInt(min.slice(2)) * 60 * 1000
+    if (hour.startsWith("*/")) return parseInt(hour.slice(2)) * 60 * 60 * 1000
+    if (min !== "*" && hour === "*") return 60 * 60 * 1000 // every hour at specific minute
+    if (min !== "*" && hour !== "*" && dom === "*") return 24 * 60 * 60 * 1000 // daily
+    return 10 * 60 * 1000
+  }
+
+  /** Create a new scheduled task */
+  export function create(input: {
+    cron: string
+    prompt: string
+    recurring?: boolean
+  }): Task | { error: string } {
+    if (disabled) return { error: "Scheduler is disabled (TOOLKODE_DISABLE_CRON=1)" }
+    if (tasks.size >= MAX_TASKS) return { error: `Maximum ${MAX_TASKS} scheduled tasks reached` }
+
+    // Validate cron expression
+    const parts = input.cron.trim().split(/\s+/)
+    if (parts.length !== 5) return { error: `Invalid cron expression: expected 5 fields, got ${parts.length}` }
+
+    const now = Date.now()
+    const id = generateId()
+    const recurring = input.recurring ?? true
+    const intervalMs = estimateIntervalMs(input.cron)
+    const jitterMs = recurring ? computeJitter(id, intervalMs) : 0
+
+    const next = nextMatch(input.cron, new Date(now))
+    if (!next) return { error: "Could not compute next fire time from cron expression" }
+
+    const task: Task = {
+      id,
+      cron: input.cron.trim(),
+      prompt: input.prompt,
+      recurring,
+      createdAt: now,
+      nextFireAt: next.getTime() + jitterMs,
+      expiresAt: now + EXPIRY_MS,
+      jitterMs,
+      fireCount: 0,
+    }
+
+    tasks.set(id, task)
+    log.info("task created", { id, cron: task.cron, recurring, nextFire: new Date(task.nextFireAt).toISOString() })
+    return task
+  }
+
+  /** List all scheduled tasks */
+  export function list(): Task[] {
+    return Array.from(tasks.values()).sort((a, b) => a.nextFireAt - b.nextFireAt)
+  }
+
+  /** Delete a task by ID */
+  export function remove(id: string): boolean {
+    const existed = tasks.delete(id)
+    if (existed) log.info("task deleted", { id })
+    return existed
+  }
+
+  /** Get a task by ID */
+  export function get(id: string): Task | undefined {
+    return tasks.get(id)
+  }
+
+  /** Mark the session as busy (mid-response) or idle */
+  export function setBusy(value: boolean) {
+    busy = value
+  }
+
+  /** Start the scheduler loop */
+  export function start(callback: FireCallback) {
+    if (process.env.TOOLKODE_DISABLE_CRON === "1" || process.env.TOOLKODE_DISABLE_CRON === "true") {
+      disabled = true
+      log.info("scheduler disabled via TOOLKODE_DISABLE_CRON")
+      return
+    }
+
+    fireCallback = callback
+    if (timer) return // already running
+
+    timer = setInterval(() => {
+      if (busy || !fireCallback) return
+
+      const now = Date.now()
+      for (const task of tasks.values()) {
+        // Check expiry
+        if (now >= task.expiresAt) {
+          log.info("task expired", { id: task.id })
+          // Fire one last time for recurring tasks
+          if (task.recurring && fireCallback) {
+            fireCallback(task)
+          }
+          tasks.delete(task.id)
+          continue
+        }
+
+        // Check if due
+        if (now >= task.nextFireAt) {
+          task.lastFiredAt = now
+          task.fireCount++
+          fireCallback(task)
+
+          if (task.recurring) {
+            // Compute next fire time
+            const next = nextMatch(task.cron, new Date(now + 60_000)) // at least 1 min ahead
+            if (next) {
+              task.nextFireAt = next.getTime() + task.jitterMs
+            } else {
+              tasks.delete(task.id)
+            }
+          } else {
+            // One-shot: delete after firing
+            tasks.delete(task.id)
+            log.info("one-shot task completed", { id: task.id })
+          }
+        }
+      }
+    }, CHECK_INTERVAL_MS)
+
+    timer.unref() // don't keep process alive
+    log.info("scheduler started")
+  }
+
+  /** Stop the scheduler */
+  export function stop() {
+    if (timer) {
+      clearInterval(timer)
+      timer = null
+    }
+    tasks.clear()
+    fireCallback = null
+    log.info("scheduler stopped")
+  }
+
+  /** Check if scheduler is disabled */
+  export function isDisabled(): boolean {
+    return disabled
+  }
+
+  /** Convert a human interval like "5m" or "2h" to a cron expression */
+  export function intervalToCron(interval: string): { cron: string; description: string } | { error: string } {
+    const match = interval.match(/^(\d+)\s*(s|sec|seconds?|m|min|minutes?|h|hours?|d|days?)$/i)
+    if (!match) return { error: `Cannot parse interval: "${interval}". Use format like 5m, 2h, 1d` }
+
+    let value = parseInt(match[1])
+    const unit = match[2].charAt(0).toLowerCase()
+
+    switch (unit) {
+      case "s":
+        // Round up to nearest minute
+        value = Math.max(1, Math.ceil(value / 60))
+        return cronFromMinutes(value)
+      case "m":
+        return cronFromMinutes(value)
+      case "h":
+        if (value === 1) return { cron: "0 * * * *", description: "every hour" }
+        if (value <= 12 && 24 % value === 0) return { cron: `0 */${value} * * *`, description: `every ${value} hours` }
+        // Non-clean: round to nearest clean divisor
+        const cleanH = [1, 2, 3, 4, 6, 8, 12].find((h) => h >= value) || 12
+        return { cron: `0 */${cleanH} * * *`, description: `every ${cleanH} hours (rounded from ${value}h)` }
+      case "d":
+        return { cron: `0 0 */${Math.min(value, 28)} * *`, description: `every ${value} day${value > 1 ? "s" : ""}` }
+      default:
+        return { error: `Unknown unit: ${unit}` }
+    }
+  }
+}
+
+function cronFromMinutes(minutes: number): { cron: string; description: string } {
+  if (minutes <= 0) minutes = 1
+  if (minutes < 60) {
+    // Find clean divisor of 60
+    const clean = [1, 2, 3, 5, 10, 15, 20, 30].find((m) => m >= minutes) || 30
+    return { cron: `*/${clean} * * * *`, description: `every ${clean} minutes${clean !== minutes ? ` (rounded from ${minutes}m)` : ""}` }
+  }
+  const hours = Math.round(minutes / 60)
+  if (hours <= 12 && 24 % hours === 0) return { cron: `0 */${hours} * * *`, description: `every ${hours} hours` }
+  return { cron: `0 */${Math.min(hours, 12)} * * *`, description: `every ${Math.min(hours, 12)} hours` }
+}