@toolkit-cli/toolkode 1.3.8 → 1.3.10

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

@@ -1,38 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,154 +0,0 @@
-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

@@ -1,241 +0,0 @@
-/**
- * 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` }
-}