tulingcode 0.1.0

package/src/task/registry.ts

@@ -0,0 +1,387 @@
+import { Context, Effect, Layer } from "effect"
+import { Database, and, eq, isNull, or, gt, type SQL } from "@/storage"
+import { Bus } from "../bus"
+import { Config } from "../config"
+import type { SessionID } from "../session/schema"
+import { TaskTable, TaskEventTable } from "./task.sql"
+import type { Task, TaskEvent } from "./schema"
+import { Created as TaskCreated, Updated as TaskUpdated, type UpdatedKind } from "./events"
+
+const DAY_MS = 24 * 60 * 60 * 1000
+
+type TaskRow = typeof TaskTable.$inferSelect
+type TaskEventRow = typeof TaskEventTable.$inferSelect
+
+function fromTaskRow(row: TaskRow): Task {
+  return {
+    id: row.id,
+    session_id: row.session_id as SessionID,
+    parent_task_id: row.parent_task_id ?? undefined,
+    status: row.status,
+    summary: row.summary,
+    owner: row.owner ?? undefined,
+    created_at: row.created_at,
+    last_event_at: row.last_event_at,
+    ended_at: row.ended_at ?? undefined,
+    cleanup_after: row.cleanup_after ?? undefined,
+  }
+}
+
+function fromEventRow(row: TaskEventRow): TaskEvent {
+  return {
+    id: row.id,
+    task_id: row.task_id,
+    at: row.at,
+    kind: row.kind as TaskEvent["kind"],
+    summary: row.summary ?? undefined,
+  }
+}
+
+function nextChildId(parentId: string | undefined, siblings: string[]): string {
+  const prefix = parentId ? `${parentId}.` : "T"
+  const used = siblings
+    .filter((s) => (parentId ? s.startsWith(prefix) : /^T\d+$/.test(s)))
+    .map((s) => {
+      const tail = s.slice(prefix.length)
+      return /^\d+$/.test(tail) ? Number(tail) : 0
+    })
+  const next = used.length > 0 ? Math.max(...used) + 1 : 1
+  return `${prefix}${next}`
+}
+
+export interface Interface {
+  readonly create: (input: {
+    session_id: SessionID
+    summary: string
+    parent_id?: string
+    owner?: string
+  }) => Effect.Effect<Task>
+
+  readonly list: (input: {
+    session_id?: SessionID
+    status?: Task["status"]
+    owner?: string
+    include_terminal?: boolean
+    include_archived?: boolean
+  }) => Effect.Effect<Task[]>
+
+  readonly get: (input: { session_id: SessionID; id: string }) => Effect.Effect<Task | undefined>
+
+  readonly block: (input: { session_id: SessionID; id: string; event_summary?: string }) => Effect.Effect<Task>
+  readonly unblock: (input: { session_id: SessionID; id: string; event_summary?: string }) => Effect.Effect<Task>
+  readonly done: (input: { session_id: SessionID; id: string; event_summary?: string }) => Effect.Effect<Task>
+  readonly abandon: (input: { session_id: SessionID; id: string; event_summary?: string }) => Effect.Effect<Task>
+  readonly rename: (input: { session_id: SessionID; id: string; summary: string }) => Effect.Effect<Task>
+
+  readonly start: (input: { session_id: SessionID; id: string; owner?: string; event_summary?: string }) => Effect.Effect<Task>
+
+  readonly events: (input: { session_id: SessionID; task_id: string }) => Effect.Effect<TaskEvent[]>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@tulingcode/TaskRegistry") {}
+
+export const layer: Layer.Layer<Service, never, Bus.Service | Config.Service> = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const bus = yield* Bus.Service
+    const config = yield* Config.Service
+
+    const cleanupAfter = Effect.fn("TaskRegistry.cleanupAfter")(function* (now: number) {
+      const cfg = yield* config.get()
+      const days = cfg.checkpoint?.task_archive_days ?? cfg.checkpoint?.task_cleanup_days ?? 7
+      return now + days * DAY_MS
+    })
+
+    const insertEvent = (
+      session_id: SessionID,
+      task_id: string,
+      kind: TaskEvent["kind"],
+      summary: string | undefined,
+      now: number,
+    ) => {
+      Database.use((db) =>
+        db
+          .insert(TaskEventTable)
+          .values({ session_id, task_id, at: now, kind, summary: summary ?? null })
+          .run(),
+      )
+    }
+
+    const publishCreated = (task: Task) =>
+      Effect.runFork(bus.publish(TaskCreated, { sessionID: task.session_id, task }))
+
+    const publishUpdated = (task: Task, kind: UpdatedKind) =>
+      Effect.runFork(bus.publish(TaskUpdated, { sessionID: task.session_id, task, kind }))
+
+    const create = Effect.fn("TaskRegistry.create")(function* (input: {
+      session_id: SessionID
+      summary: string
+      parent_id?: string
+      owner?: string
+    }) {
+      const now = Date.now()
+      const siblings = Database.use((db) =>
+        db
+          .select({ id: TaskTable.id })
+          .from(TaskTable)
+          .where(
+            and(
+              eq(TaskTable.session_id, input.session_id),
+              input.parent_id ? eq(TaskTable.parent_task_id, input.parent_id) : isNull(TaskTable.parent_task_id),
+            ),
+          )
+          .all(),
+      )
+      const id = nextChildId(
+        input.parent_id,
+        siblings.map((s) => s.id),
+      )
+
+      const row: TaskRow = {
+        id,
+        session_id: input.session_id,
+        parent_task_id: input.parent_id ?? null,
+        status: "open",
+        summary: input.summary,
+        owner: input.owner ?? null,
+        created_at: now,
+        last_event_at: now,
+        ended_at: null,
+        cleanup_after: null,
+      }
+      Database.use((db) => db.insert(TaskTable).values(row).run())
+      insertEvent(input.session_id, id, "created", undefined, now)
+      const task = fromTaskRow(row)
+      publishCreated(task)
+      return task
+    })
+
+    const list = Effect.fn("TaskRegistry.list")(function* (input: {
+      session_id?: SessionID
+      status?: Task["status"]
+      owner?: string
+      include_terminal?: boolean
+      include_archived?: boolean
+    }) {
+      const now = Date.now()
+      const conds: SQL[] = []
+      if (input.session_id) conds.push(eq(TaskTable.session_id, input.session_id))
+      if (input.status) conds.push(eq(TaskTable.status, input.status))
+      if (input.owner) conds.push(eq(TaskTable.owner, input.owner))
+      if (!input.include_terminal) {
+        const nonTerminal = or(
+          eq(TaskTable.status, "open"),
+          eq(TaskTable.status, "in_progress"),
+          eq(TaskTable.status, "blocked"),
+        )
+        if (nonTerminal) conds.push(nonTerminal)
+      }
+      if (!input.include_archived) {
+        const notArchived = or(isNull(TaskTable.cleanup_after), gt(TaskTable.cleanup_after, now))
+        if (notArchived) conds.push(notArchived)
+      }
+      const where = conds.length > 0 ? and(...conds) : undefined
+      const rows = Database.use((db) =>
+        db.select().from(TaskTable).where(where).orderBy(TaskTable.created_at).all(),
+      )
+      return rows.map(fromTaskRow)
+    })
+
+    const get = Effect.fn("TaskRegistry.get")(function* (input: { session_id: SessionID; id: string }) {
+      const row = Database.use((db) =>
+        db
+          .select()
+          .from(TaskTable)
+          .where(and(eq(TaskTable.session_id, input.session_id), eq(TaskTable.id, input.id)))
+          .get(),
+      )
+      return row ? fromTaskRow(row) : undefined
+    })
+
+    const events = Effect.fn("TaskRegistry.events")(function* (input: { session_id: SessionID; task_id: string }) {
+      const rows = Database.use((db) =>
+        db
+          .select()
+          .from(TaskEventTable)
+          .where(and(eq(TaskEventTable.session_id, input.session_id), eq(TaskEventTable.task_id, input.task_id)))
+          .orderBy(TaskEventTable.at)
+          .all(),
+      )
+      return rows.map(fromEventRow)
+    })
+
+    // block/unblock/done/abandon/rename
+
+    const block = Effect.fn("TaskRegistry.block")(function* (input: {
+      session_id: SessionID
+      id: string
+      event_summary?: string
+    }) {
+      const now = Date.now()
+      Database.use((db) =>
+        db
+          .update(TaskTable)
+          .set({ status: "blocked", last_event_at: now })
+          .where(and(eq(TaskTable.session_id, input.session_id), eq(TaskTable.id, input.id)))
+          .run(),
+      )
+      insertEvent(input.session_id, input.id, "blocked", input.event_summary, now)
+      const updated = yield* get({ session_id: input.session_id, id: input.id })
+      if (!updated) return yield* Effect.die(`Task ${input.id} not found in session ${input.session_id}`)
+      publishUpdated(updated, "blocked")
+      return updated
+    })
+
+    const unblock = Effect.fn("TaskRegistry.unblock")(function* (input: {
+      session_id: SessionID
+      id: string
+      event_summary?: string
+    }) {
+      const now = Date.now()
+      Database.use((db) =>
+        db
+          .update(TaskTable)
+          .set({ status: "open", last_event_at: now })
+          .where(and(eq(TaskTable.session_id, input.session_id), eq(TaskTable.id, input.id)))
+          .run(),
+      )
+      insertEvent(input.session_id, input.id, "unblocked", input.event_summary, now)
+      const updated = yield* get({ session_id: input.session_id, id: input.id })
+      if (!updated) return yield* Effect.die(`Task ${input.id} not found in session ${input.session_id}`)
+      publishUpdated(updated, "unblocked")
+      return updated
+    })
+
+    const start = Effect.fn("TaskRegistry.start")(function* (input: {
+      session_id: SessionID
+      id: string
+      owner?: string
+      event_summary?: string
+    }) {
+      const now = Date.now()
+      const existing = yield* get({ session_id: input.session_id, id: input.id })
+      if (!existing) return yield* Effect.die(`Task ${input.id} not found in session ${input.session_id}`)
+
+      // Terminal states are final. Auto-start makes start() a structural side-effect of
+      // every actor spawn, so a stale/reused task_id (ReAct re-entry, verification rerun,
+      // operator typo colliding with an old TID) must NOT silently resurrect a
+      // done/abandoned task. done()/abandon() stamp ended_at + cleanup_after; start()
+      // does not clear them, so resurrection would leave a self-contradictory row
+      // (status=in_progress yet carrying ended_at/cleanup_after) that list() drops from
+      // the active set the moment the old archive window elapses. No-op and warn instead.
+      if (existing.status === "done" || existing.status === "abandoned") {
+        yield* Effect.logWarning(`refusing to start terminal task ${input.id} (status=${existing.status})`)
+        return existing
+      }
+
+      // Idempotent re-start by the same owner is a no-op: re-emitting `started` would
+      // spam the task_event log and the SSE/TUI stream for zero state change. A
+      // *different* owner is a genuine handoff (replacement actor picking up the task)
+      // and falls through to update owner + re-emit.
+      const owner = input.owner ?? existing.owner
+      if (existing.status === "in_progress" && owner === existing.owner) return existing
+
+      Database.use((db) =>
+        db
+          .update(TaskTable)
+          .set({ status: "in_progress", owner: owner ?? null, last_event_at: now })
+          .where(and(eq(TaskTable.session_id, input.session_id), eq(TaskTable.id, input.id)))
+          .run(),
+      )
+      insertEvent(input.session_id, input.id, "started", input.event_summary, now)
+      const updated = yield* get({ session_id: input.session_id, id: input.id })
+      if (!updated) return yield* Effect.die(`Task ${input.id} not found in session ${input.session_id}`)
+      publishUpdated(updated, "started")
+      return updated
+    })
+
+    const done = Effect.fn("TaskRegistry.done")(function* (input: {
+      session_id: SessionID
+      id: string
+      event_summary?: string
+    }) {
+      const now = Date.now()
+      const cleanup = yield* cleanupAfter(now)
+      Database.use((db) =>
+        db
+          .update(TaskTable)
+          .set({
+            status: "done",
+            ended_at: now,
+            cleanup_after: cleanup,
+            last_event_at: now,
+          })
+          .where(and(eq(TaskTable.session_id, input.session_id), eq(TaskTable.id, input.id)))
+          .run(),
+      )
+      insertEvent(input.session_id, input.id, "done", input.event_summary, now)
+      const updated = yield* get({ session_id: input.session_id, id: input.id })
+      if (!updated) return yield* Effect.die(`Task ${input.id} not found in session ${input.session_id}`)
+      publishUpdated(updated, "done")
+      return updated
+    })
+
+    const abandon = Effect.fn("TaskRegistry.abandon")(function* (input: {
+      session_id: SessionID
+      id: string
+      event_summary?: string
+    }) {
+      const now = Date.now()
+      const cleanup = yield* cleanupAfter(now)
+      Database.use((db) =>
+        db
+          .update(TaskTable)
+          .set({
+            status: "abandoned",
+            ended_at: now,
+            cleanup_after: cleanup,
+            last_event_at: now,
+          })
+          .where(and(eq(TaskTable.session_id, input.session_id), eq(TaskTable.id, input.id)))
+          .run(),
+      )
+      insertEvent(input.session_id, input.id, "abandoned", input.event_summary, now)
+      const updated = yield* get({ session_id: input.session_id, id: input.id })
+      if (!updated) return yield* Effect.die(`Task ${input.id} not found in session ${input.session_id}`)
+      publishUpdated(updated, "abandoned")
+      return updated
+    })
+
+    const rename = Effect.fn("TaskRegistry.rename")(function* (input: {
+      session_id: SessionID
+      id: string
+      summary: string
+    }) {
+      const now = Date.now()
+      Database.use((db) =>
+        db
+          .update(TaskTable)
+          .set({ summary: input.summary, last_event_at: now })
+          .where(and(eq(TaskTable.session_id, input.session_id), eq(TaskTable.id, input.id)))
+          .run(),
+      )
+      insertEvent(input.session_id, input.id, "renamed", input.summary, now)
+      const updated = yield* get({ session_id: input.session_id, id: input.id })
+      if (!updated) return yield* Effect.die(`Task ${input.id} not found in session ${input.session_id}`)
+      publishUpdated(updated, "renamed")
+      return updated
+    })
+
+    return Service.of({
+      create,
+      list,
+      get,
+      events,
+      block,
+      unblock,
+      done,
+      abandon,
+      rename,
+      start,
+    })
+  }),
+)
+
+export const defaultLayer = Layer.suspend(() => layer.pipe(Layer.provide(Bus.layer), Layer.provide(Config.defaultLayer)))
+
+export * as TaskRegistry from "./registry"

package/src/task/schema.ts

@@ -0,0 +1,43 @@
+import z from "zod"
+import { SessionID } from "../session/schema"
+
+export const TaskID = z.string().regex(/^T\d+(\.\d+)*$/, "Task ID must be Tn or Tn.m...")
+export type TaskID = z.infer<typeof TaskID>
+
+export const TaskStatus = z.enum(["open", "in_progress", "blocked", "done", "abandoned"])
+export type TaskStatus = z.infer<typeof TaskStatus>
+
+export const Task = z.object({
+  id: TaskID,
+  session_id: SessionID.zod,
+  parent_task_id: TaskID.optional(),
+  status: TaskStatus,
+  summary: z.string(),
+  owner: z.string().optional(),
+  created_at: z.number(),
+  last_event_at: z.number(),
+  ended_at: z.number().optional(),
+  cleanup_after: z.number().optional(),
+})
+export type Task = z.infer<typeof Task>
+
+export const TaskEventKind = z.enum([
+  "created",
+  "started",
+  "unstarted",
+  "blocked",
+  "unblocked",
+  "done",
+  "abandoned",
+  "renamed",
+])
+export type TaskEventKind = z.infer<typeof TaskEventKind>
+
+export const TaskEvent = z.object({
+  id: z.number(),
+  task_id: TaskID,
+  at: z.number(),
+  kind: TaskEventKind,
+  summary: z.string().optional(),
+})
+export type TaskEvent = z.infer<typeof TaskEvent>

package/src/task/task.sql.ts

@@ -0,0 +1,50 @@
+import { sqliteTable, text, integer, index, primaryKey, foreignKey } from "drizzle-orm/sqlite-core"
+import { SessionTable } from "../session/session.sql"
+import type { SessionID } from "../session/schema"
+
+export const TaskTable = sqliteTable(
+  "task",
+  {
+    id: text().notNull(),
+    session_id: text()
+      .$type<SessionID>()
+      .notNull()
+      .references(() => SessionTable.id, { onDelete: "cascade" }),
+    parent_task_id: text(),
+    status: text().$type<"open" | "in_progress" | "blocked" | "done" | "abandoned">().notNull(),
+    summary: text().notNull(),
+    owner: text(),
+    created_at: integer().notNull(),
+    last_event_at: integer().notNull(),
+    ended_at: integer(),
+    cleanup_after: integer(),
+  },
+  (table) => [
+    primaryKey({ columns: [table.session_id, table.id] }),
+    index("task_session_idx").on(table.session_id),
+    index("task_parent_idx").on(table.session_id, table.parent_task_id),
+    index("task_status_idx").on(table.status),
+  ],
+)
+
+export const TaskEventTable = sqliteTable(
+  "task_event",
+  {
+    id: integer().primaryKey({ autoIncrement: true }),
+    session_id: text()
+      .$type<SessionID>()
+      .notNull()
+      .references(() => SessionTable.id, { onDelete: "cascade" }),
+    task_id: text().notNull(),
+    at: integer().notNull(),
+    kind: text().notNull(),
+    summary: text(),
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.session_id, table.task_id],
+      foreignColumns: [TaskTable.session_id, TaskTable.id],
+    }).onDelete("cascade"),
+    index("task_event_task_idx").on(table.session_id, table.task_id, table.at),
+  ],
+)

package/src/team/events.ts

@@ -0,0 +1,22 @@
+import { BusEvent } from "@/bus/bus-event"
+import { SessionID } from "@/session/schema"
+import z from "zod"
+
+export const TeamCreated = BusEvent.define(
+  "team.created",
+  z.object({
+    teamID: z.string(),
+    creatorSessionID: SessionID.zod,
+  }),
+)
+
+export const TeamMemberJoined = BusEvent.define(
+  "team.member.joined",
+  z.object({
+    teamID: z.string(),
+    sessionID: SessionID.zod,
+    agent: z.string(),
+    role: z.string(),
+  }),
+)
+

package/src/team/index.ts

@@ -0,0 +1,113 @@
+import { Effect, Layer, Context } from "effect"
+import { Bus } from "@/bus"
+import { InstanceState } from "@/effect"
+import { SessionID } from "@/session/schema"
+import type { TeamMember } from "./schema"
+import * as Events from "./events"
+import { Log } from "@/util"
+import * as fs from "fs/promises"
+import path from "path"
+
+const log = Log.create({ service: "team" })
+
+export interface Interface {
+  readonly create: (teamID: string, creatorSessionID: SessionID) => Effect.Effect<void>
+  readonly addMember: (
+    teamID: string,
+    sessionID: SessionID,
+    agent: string,
+    role: string,
+  ) => Effect.Effect<void>
+  readonly removeMember: (teamID: string, sessionID: SessionID) => Effect.Effect<void>
+  readonly getMembers: (teamID: string) => Effect.Effect<TeamMember[]>
+  readonly teamDir: (teamID: string) => Effect.Effect<string>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@tulingcode/Team") {}
+
+export const layer: Layer.Layer<Service, never, Bus.Service> = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const bus = yield* Bus.Service
+
+    const resolveTeamDir = (teamID: string) =>
+      Effect.gen(function* () {
+        const ctx = yield* InstanceState.context
+        return path.join(ctx.directory, ".tulingcode", "teams", teamID)
+      })
+
+    const membersFilePath = (teamID: string) =>
+      Effect.map(resolveTeamDir(teamID), (dir) => path.join(dir, "members.json"))
+
+    const readMembersFile = (teamID: string) =>
+      Effect.gen(function* () {
+        const filePath = yield* membersFilePath(teamID)
+        return yield* Effect.promise(async () => {
+          try {
+            const raw = await fs.readFile(filePath, "utf-8")
+            return JSON.parse(raw) as TeamMember[]
+          } catch {
+            return [] as TeamMember[]
+          }
+        })
+      })
+
+    const writeMembersFile = (teamID: string, members: TeamMember[]) =>
+      Effect.gen(function* () {
+        const filePath = yield* membersFilePath(teamID)
+        yield* Effect.promise(() => fs.writeFile(filePath, JSON.stringify(members, null, 2)))
+      })
+
+    const create = Effect.fn("Team.create")(function* (
+      teamID: string,
+      creatorSessionID: SessionID,
+    ) {
+      const dir = yield* resolveTeamDir(teamID)
+      yield* Effect.promise(() => fs.mkdir(dir, { recursive: true }))
+      yield* Effect.promise(() => fs.writeFile(path.join(dir, "members.json"), "[]"))
+      log.info("team created", { teamID })
+      yield* bus.publish(Events.TeamCreated, { teamID, creatorSessionID })
+    })
+
+    const addMember = Effect.fn("Team.addMember")(function* (
+      teamID: string,
+      sessionID: SessionID,
+      agent: string,
+      role: string,
+    ) {
+      const members = yield* readMembersFile(teamID)
+      const existing = members.find((m) => m.sessionID === sessionID)
+      if (!existing) {
+        members.push({ sessionID, agent, role, joinedAt: Date.now() })
+        yield* writeMembersFile(teamID, members)
+        log.info("team member added", { teamID, sessionID, agent, role })
+      }
+    })
+
+    const removeMember = Effect.fn("Team.removeMember")(function* (
+      teamID: string,
+      sessionID: SessionID,
+    ) {
+      const members = yield* readMembersFile(teamID)
+      const filtered = members.filter((m) => m.sessionID !== sessionID)
+      if (filtered.length !== members.length) {
+        yield* writeMembersFile(teamID, filtered)
+        log.info("team member removed", { teamID, sessionID })
+      }
+    })
+
+    const getMembers = Effect.fn("Team.getMembers")(function* (teamID: string) {
+      return yield* readMembersFile(teamID)
+    })
+
+    const teamDir = Effect.fn("Team.teamDir")(function* (teamID: string) {
+      return yield* resolveTeamDir(teamID)
+    })
+
+    return Service.of({ create, addMember, removeMember, getMembers, teamDir })
+  }),
+)
+
+export const defaultLayer = layer.pipe(Layer.provide(Bus.defaultLayer))
+
+export * as Team from "./index"

package/src/team/schema.ts

@@ -0,0 +1,31 @@
+import z from "zod"
+import { SessionID } from "@/session/schema"
+
+export const TeamID = z.string().brand("TeamID")
+export type TeamID = z.infer<typeof TeamID>
+
+export const TeamMessage = z.object({
+  id: z.string(),
+  from: SessionID.zod,
+  fromAgent: z.string(),
+  to: SessionID.zod.optional(),
+  content: z.string(),
+  timestamp: z.number(),
+})
+export type TeamMessage = z.infer<typeof TeamMessage>
+
+export const TeamMember = z.object({
+  sessionID: SessionID.zod,
+  agent: z.string(),
+  role: z.string(),
+  joinedAt: z.number(),
+})
+export type TeamMember = z.infer<typeof TeamMember>
+
+export const TeamInfo = z.object({
+  id: TeamID,
+  members: z.array(TeamMember),
+  createdAt: z.number(),
+  directory: z.string(),
+})
+export type TeamInfo = z.infer<typeof TeamInfo>

package/src/temporary.ts

@@ -0,0 +1,33 @@
+import yargs from "yargs"
+import { TuiThreadCommand } from "./cli/cmd/tui/thread"
+import { InstallationVersion } from "./installation/version"
+import { hideBin } from "yargs/helpers"
+import { Log } from "./node"
+
+Log.init({
+  print: false,
+})
+
+const cli = yargs(hideBin(process.argv))
+  .parserConfiguration({ "populate--": true })
+  .scriptName("tuling")
+  .wrap(100)
+  .help("help", "show help")
+  .alias("help", "h")
+  .version("version", "show version number", InstallationVersion)
+  .alias("version", "v")
+  .option("print-logs", {
+    describe: "print logs to stderr",
+    type: "boolean",
+  })
+  .option("log-level", {
+    describe: "log level",
+    type: "string",
+    choices: ["DEBUG", "INFO", "WARN", "ERROR"],
+  })
+  .option("pure", {
+    describe: "run without external plugins",
+    type: "boolean",
+  })
+  .command(TuiThreadCommand)
+  .parse()