saeeol 1.4.1 → 1.4.3

package/src/sync/index.ts

@@ -1,387 +0,0 @@
-import z from "zod"
-import { Database } from "@/storage/db"
-import { eq } from "drizzle-orm"
-import { GlobalBus } from "@/bus/global"
-import { Bus as ProjectBus } from "@/bus"
-import { BusEvent } from "@/bus/bus-event"
-import type { InstanceContext } from "@/project/instance"
-import { EventSequenceTable, EventTable } from "./event.sql"
-import type { WorkspaceID } from "@/control-plane/schema"
-import { EventID } from "./schema"
-import { Flag } from "@saeeol/core/flag/flag"
-import { Context, Effect, Layer, Schema as EffectSchema } from "effect"
-import { zodObject } from "@/util/effect-zod"
-import type { DeepMutable } from "@/util/schema"
-import { makeRuntime } from "@/effect/run-service"
-import { serviceUse } from "@/effect/service-use"
-import { InstanceState } from "@/effect/instance-state"
-
-// Keep `Event["data"]` mutable because projectors mutate the persisted shape
-// when writing to the database. Bus payloads (`Properties`) stay readonly —
-// subscribers only read.
-
-export type Definition<
-  Type extends string = string,
-  Schema extends EffectSchema.Top = EffectSchema.Top,
-  BusSchema extends EffectSchema.Top = Schema,
-> = {
-  type: Type
-  version: number
-  aggregate: string
-  schema: Schema
-  // Bus event payload schema. Defaults to `schema` unless `busSchema` was
-  // passed at definition time (see `session.updated`, whose projector
-  // expands the persisted data to a `{ sessionID, info }` bus payload).
-  properties: BusSchema
-}
-
-export type Event<Def extends Definition = Definition> = {
-  id: string
-  seq: number
-  aggregateID: string
-  data: DeepMutable<EffectSchema.Schema.Type<Def["schema"]>>
-}
-
-export type Properties<Def extends Definition = Definition> = EffectSchema.Schema.Type<Def["properties"]>
-
-export type SerializedEvent<Def extends Definition = Definition> = Event<Def> & { type: string }
-
-type ProjectorFunc = (db: Database.TxOrDb, data: unknown) => void
-type ConvertEvent = (type: string, data: Event["data"]) => unknown | Promise<unknown>
-type PublishContext = {
-  instance?: InstanceContext
-  workspace?: WorkspaceID
-}
-
-export interface Interface {
-  readonly run: <Def extends Definition>(
-    def: Def,
-    data: Event<Def>["data"],
-    options?: { publish?: boolean },
-  ) => Effect.Effect<void>
-  readonly replay: (event: SerializedEvent, options?: { publish: boolean }) => Effect.Effect<void>
-  readonly replayAll: (events: SerializedEvent[], options?: { publish: boolean }) => Effect.Effect<string | undefined>
-  readonly remove: (aggregateID: string) => Effect.Effect<void>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@saeeol/SyncEvent") {}
-
-export const layer = Layer.effect(Service)(
-  Effect.gen(function* () {
-    const replay: Interface["replay"] = Effect.fn("SyncEvent.replay")(function* (event, options) {
-      const def = registry.get(event.type)
-      if (!def) {
-        throw new Error(`Unknown event type: ${event.type}`)
-      }
-
-      const row = Database.use((db) =>
-        db
-          .select({ seq: EventSequenceTable.seq })
-          .from(EventSequenceTable)
-          .where(eq(EventSequenceTable.aggregate_id, event.aggregateID))
-          .get(),
-      )
-
-      const latest = row?.seq ?? -1
-      if (event.seq <= latest) return
-
-      const expected = latest + 1
-      if (event.seq !== expected) {
-        throw new Error(
-          `Sequence mismatch for aggregate "${event.aggregateID}": expected ${expected}, got ${event.seq}`,
-        )
-      }
-
-      const publish = !!options?.publish
-      const context = publish
-        ? {
-            instance: yield* InstanceState.context,
-            workspace: yield* InstanceState.workspaceID,
-          }
-        : undefined
-      process(def, event, { publish, context })
-    })
-
-    const replayAll: Interface["replayAll"] = Effect.fn("SyncEvent.replayAll")(function* (events, options) {
-      const source = events[0]?.aggregateID
-      if (!source) return undefined
-      if (events.some((item) => item.aggregateID !== source)) {
-        throw new Error("Replay events must belong to the same session")
-      }
-      const start = events[0].seq
-      for (const [i, item] of events.entries()) {
-        const seq = start + i
-        if (item.seq !== seq) {
-          throw new Error(`Replay sequence mismatch at index ${i}: expected ${seq}, got ${item.seq}`)
-        }
-      }
-      for (const item of events) {
-        yield* replay(item, options)
-      }
-      return source
-    })
-
-    const run: Interface["run"] = Effect.fn("SyncEvent.run")(function* (def, data, options) {
-      const agg = (data as Record<string, string>)[def.aggregate]
-      // This should never happen: we've enforced it via typescript in
-      // the definition
-      if (agg == null) {
-        throw new Error(`SyncEvent.run: "${def.aggregate}" required but not found: ${JSON.stringify(data)}`)
-      }
-
-      if (def.version !== versions.get(def.type)) {
-        throw new Error(`SyncEvent.run: running old versions of events is not allowed: ${def.type}`)
-      }
-
-      const { publish = true } = options || {}
-      const context = publish
-        ? {
-            instance: yield* InstanceState.context,
-            workspace: yield* InstanceState.workspaceID,
-          }
-        : undefined
-
-      // Note that this is an "immediate" transaction which is critical.
-      // We need to make sure we can safely read and write with nothing
-      // else changing the data from under us
-      Database.transaction(
-        (tx) => {
-          const id = EventID.ascending()
-          const row = tx
-            .select({ seq: EventSequenceTable.seq })
-            .from(EventSequenceTable)
-            .where(eq(EventSequenceTable.aggregate_id, agg))
-            .get()
-          const seq = row?.seq != null ? row.seq + 1 : 0
-
-          const event = { id, seq, aggregateID: agg, data }
-          process(def, event, { publish, context })
-        },
-        {
-          behavior: "immediate",
-        },
-      )
-    })
-
-    const remove: Interface["remove"] = Effect.fn("SyncEvent.remove")(function* (aggregateID) {
-      Database.transaction((tx) => {
-        tx.delete(EventSequenceTable).where(eq(EventSequenceTable.aggregate_id, aggregateID)).run()
-        tx.delete(EventTable).where(eq(EventTable.aggregate_id, aggregateID)).run()
-      })
-    })
-
-    return Service.of({
-      run,
-      replay,
-      replayAll,
-      remove,
-    })
-  }),
-)
-
-export const defaultLayer = layer
-
-export const use = serviceUse(Service)
-
-const runtime = makeRuntime(Service, defaultLayer)
-
-export const registry = new Map<string, Definition>()
-let projectors: Map<Definition, ProjectorFunc> | undefined
-const versions = new Map<string, number>()
-let frozen = false
-let convertEvent: ConvertEvent
-
-export function reset() {
-  frozen = false
-  projectors = undefined
-  convertEvent = (_, data) => data
-}
-
-export function init(input: { projectors: Array<[Definition, ProjectorFunc]>; convertEvent?: ConvertEvent }) {
-  projectors = new Map(input.projectors)
-
-  // Install all the latest event defs to the bus. We only ever emit
-  // latest versions from code, and keep around old versions for
-  // replaying. Replaying does not go through the bus, and it
-  // simplifies the bus to only use unversioned latest events
-  for (let [type, version] of versions.entries()) {
-    let def = registry.get(versionedType(type, version))!
-
-    BusEvent.define(def.type, def.properties)
-  }
-
-  // Freeze the system so it clearly errors if events are defined
-  // after `init` which would cause bugs
-  frozen = true
-  convertEvent = input.convertEvent ?? ((_, data) => data)
-}
-
-export function versionedType<A extends string>(type: A): A
-export function versionedType<A extends string, B extends number>(type: A, version: B): `${A}/${B}`
-export function versionedType(type: string, version?: number) {
-  return version ? `${type}.${version}` : type
-}
-
-export function define<
-  Type extends string,
-  Agg extends string,
-  Schema extends EffectSchema.Top,
-  BusSchema extends EffectSchema.Top = Schema,
->(input: {
-  type: Type
-  version: number
-  aggregate: Agg
-  schema: Schema
-  busSchema?: BusSchema
-}): Definition<Type, Schema, BusSchema> {
-  if (frozen) {
-    throw new Error("Error defining sync event: sync system has been frozen")
-  }
-
-  const def = {
-    type: input.type,
-    version: input.version,
-    aggregate: input.aggregate,
-    schema: input.schema,
-    properties: (input.busSchema ?? input.schema) as BusSchema,
-  }
-
-  versions.set(def.type, Math.max(def.version, versions.get(def.type) || 0))
-
-  registry.set(versionedType(def.type, def.version), def)
-
-  return def
-}
-
-export function project<Def extends Definition>(
-  def: Def,
-  func: (db: Database.TxOrDb, data: Event<Def>["data"]) => void,
-): [Definition, ProjectorFunc] {
-  return [def, func as ProjectorFunc]
-}
-
-function process<Def extends Definition>(
-  def: Def,
-  event: Event<Def>,
-  options: { publish: boolean; context?: PublishContext },
-) {
-  if (projectors == null) {
-    throw new Error("No projectors available. Call `SyncEvent.init` to install projectors")
-  }
-
-  const projector = projectors.get(def)
-  if (!projector) {
-    throw new Error(`Projector not found for event: ${def.type}`)
-  }
-
-  // idempotent: need to ignore any events already logged
-
-  Database.transaction((tx) => {
-    projector(tx, event.data)
-
-    if (Flag.SAEEOL_EXPERIMENTAL_WORKSPACES) {
-      tx.insert(EventSequenceTable)
-        .values({
-          aggregate_id: event.aggregateID,
-          seq: event.seq,
-        })
-        .onConflictDoUpdate({
-          target: EventSequenceTable.aggregate_id,
-          set: { seq: event.seq },
-        })
-        .run()
-      tx.insert(EventTable)
-        .values({
-          id: event.id,
-          seq: event.seq,
-          aggregate_id: event.aggregateID,
-          type: versionedType(def.type, def.version),
-          data: event.data as Record<string, unknown>,
-        })
-        .run()
-    }
-
-    Database.effect(() => {
-      if (options?.publish) {
-        if (!options.context?.instance) {
-          throw new Error("SyncEvent.process: publish requires instance context")
-        }
-
-        const result = convertEvent(def.type, event.data)
-        const publish = (data: unknown) => ProjectBus.publish(def, data as Properties<Def>)
-        if (result instanceof Promise) {
-          void result.then(publish)
-        } else {
-          void publish(result)
-        }
-
-        GlobalBus.emit("event", {
-          directory: options.context.instance.directory,
-          project: options.context.instance.project.id,
-          workspace: options.context.workspace,
-          payload: {
-            type: "sync",
-            syncEvent: {
-              type: versionedType(def.type, def.version),
-              ...event,
-            },
-          },
-        })
-      }
-    })
-  })
-}
-
-export function replay(event: SerializedEvent, options?: { publish: boolean }) {
-  return runtime.runSync((sync) => sync.replay(event, options))
-}
-
-export function replayAll(events: SerializedEvent[], options?: { publish: boolean }) {
-  return runtime.runSync((sync) => sync.replayAll(events, options))
-}
-
-export function run<Def extends Definition>(def: Def, data: Event<Def>["data"], options?: { publish?: boolean }) {
-  return runtime.runSync((sync) => sync.run(def, data, options))
-}
-
-export function remove(aggregateID: string) {
-  return runtime.runSync((sync) => sync.remove(aggregateID))
-}
-
-export function payloads() {
-  return registry
-    .entries()
-    .map(([type, def]) => {
-      return z
-        .object({
-          type: z.literal("sync"),
-          name: z.literal(type),
-          id: z.string(),
-          seq: z.number(),
-          aggregateID: z.literal(def.aggregate),
-          data: zodObject(def.schema),
-        })
-        .meta({
-          ref: `SyncEvent.${def.type}`,
-        })
-    })
-    .toArray()
-}
-
-export function effectPayloads() {
-  return registry
-    .entries()
-    .map(([type, def]) =>
-      EffectSchema.Struct({
-        type: EffectSchema.Literal("sync"),
-        name: EffectSchema.Literal(type),
-        id: EffectSchema.String,
-        seq: EffectSchema.Finite,
-        aggregateID: EffectSchema.Literal(def.aggregate),
-        data: def.schema,
-      }).annotate({ identifier: `SyncEvent.${type}` }),
-    )
-    .toArray()
-}
-
-export * as SyncEvent from "."

package/src/sync/schema.ts

@@ -1,13 +0,0 @@
-import { Schema } from "effect"
-
-import { Identifier } from "@/id/id"
-import { zod, ZodOverride } from "@/util/effect-zod"
-import { withStatics } from "@/util/schema"
-
-export const EventID = Schema.String.annotate({ [ZodOverride]: Identifier.schema("event") }).pipe(
-  Schema.brand("EventID"),
-  withStatics((s) => ({
-    ascending: (id?: string) => s.make(Identifier.ascending("event", id)),
-    zod: zod(s),
-  })),
-)

package/src/temporary.ts

@@ -1,33 +0,0 @@
-import yargs from "yargs"
-import { TuiThreadCommand } from "./cli/cmd/tui/thread"
-import { InstallationVersion } from "@saeeol/core/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("saeeol")
-  .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()

package/src/tool/apply_patch.ts

@@ -1 +0,0 @@
-export * from "./file/apply_patch"

package/src/tool/bash.ts

@@ -1 +0,0 @@
-export * from "./file/bash"

package/src/tool/core/external-directory.ts

@@ -1,55 +0,0 @@
-import path from "path"
-import { Effect } from "effect"
-import * as EffectLogger from "@saeeol/core/effect/logger"
-import { InstanceState } from "@/effect/instance-state"
-import type * as Tool from "./tool"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-
-type Kind = "file" | "directory"
-
-type Options = {
-  bypass?: boolean
-  kind?: Kind
-}
-function root(dir: string) {
-  return path.parse(dir).root === dir
-}
-
-function inside(dir: string, file: string) {
-  return !root(dir) && AppFileSystem.contains(dir, file)
-}
-
-export const assertExternalDirectoryEffect = Effect.fn("Tool.assertExternalDirectory")(function* (
-  ctx: Tool.Context,
-  target?: string,
-  options?: Options,
-) {
-  if (!target) return
-
-  if (options?.bypass) return
-
-  const ins = yield* InstanceState.context
-  const full = process.platform === "win32" ? AppFileSystem.normalizePath(target) : target
-  if (inside(ins.directory, full) || inside(ins.worktree, full)) return
-
-  const kind = options?.kind ?? "file"
-  const dir = kind === "directory" ? full : path.dirname(full)
-  const glob =
-    process.platform === "win32"
-      ? AppFileSystem.normalizePathPattern(path.join(dir, "*"))
-      : path.join(dir, "*").replaceAll("\\", "/")
-
-  yield* ctx.ask({
-    permission: "external_directory",
-    patterns: [glob],
-    always: [glob],
-    metadata: {
-      filepath: full,
-      parentDir: dir,
-    },
-  })
-})
-
-export async function assertExternalDirectory(ctx: Tool.Context, target?: string, options?: Options) {
-  return Effect.runPromise(assertExternalDirectoryEffect(ctx, target, options).pipe(Effect.provide(EffectLogger.layer)))
-}

package/src/tool/core/invalid.ts

@@ -1,21 +0,0 @@
-import { Effect, Schema } from "effect"
-import * as Tool from "./tool"
-
-export const Parameters = Schema.Struct({
-  tool: Schema.String,
-  error: Schema.String,
-})
-
-export const InvalidTool = Tool.define(
-  "invalid",
-  Effect.succeed({
-    description: "Do not use",
-    parameters: Parameters,
-    execute: (params: { tool: string; error: string }) =>
-      Effect.succeed({
-        title: "Invalid Tool",
-        output: `The arguments provided to the tool are invalid: ${params.error}`,
-        metadata: {},
-      }),
-  }),
-)

package/src/tool/core/recall.ts

@@ -1,164 +0,0 @@
-import { Effect, Schema } from "effect"
-import * as Tool from "./tool"
-import { Instance } from "../../project/instance"
-import { Locale } from "../../util/locale"
-import { Filesystem } from "../../util/filesystem" 
-import { WorktreeFamily } from "../../overlay/worktree-family" 
-import DESCRIPTION from "./recall.txt"
-
-const Parameters = Schema.Struct({
-  mode: Schema.Literals(["search", "read"]).annotate({
-    description: "'search' to find sessions by title, 'read' to get a session transcript",
-  }),
-  query: Schema.optional(Schema.String).annotate({
-    description: "Search query to match against session titles (required for search mode)",
-  }),
-  sessionID: Schema.optional(Schema.String).annotate({
-    description: "Session ID to read the transcript of (required for read mode)",
-  }),
-  limit: Schema.optional(Schema.Number).annotate({
-    description: "Maximum number of search results to return (default: 20, max: 50)",
-  }),
-})
-
-export const RecallTool = Tool.define(
-  "saeeol_local_recall",
-  Effect.gen(function* () {
-    return {
-      description: DESCRIPTION,
-      parameters: Parameters,
-      execute: (params: Schema.Schema.Type<typeof Parameters>, ctx: Tool.Context) =>
-        Effect.gen(function* () {
-          if (params.mode === "search") {
-            return yield* Effect.promise(() => search(params, ctx))
-          }
-          return yield* Effect.promise(() => read(params, ctx))
-        }).pipe(Effect.orDie),
-    }
-  }),
-)
-
-async function search(params: { query?: string; limit?: number }, ctx: Tool.Context) {
-  if (!params.query) {
-    throw new Error("The 'query' parameter is required when mode is 'search'")
-  }
-
-  await ctx.ask({
-    permission: "recall",
-    patterns: ["search"],
-    always: ["search"],
-    metadata: {
-      mode: "search",
-      query: params.query,
-    },
-  })
-
-  const limit = Math.min(params.limit ?? 20, 50)
-  const dirs = await WorktreeFamily.list() 
-  const { Session } = await import("../../session/session") 
-
-  const results: Array<{
-    id: string
-    title: string
-    directory: string
-    updated: string
-  }> = []
-
-  for (const session of Session.listGlobal({
-    projectID: Instance.project.id, 
-    directories: dirs, 
-    search: params.query,
-    roots: true,
-    limit,
-  })) {
-    results.push({
-      id: session.id,
-      title: session.title,
-      directory: session.directory,
-      updated: Locale.todayTimeOrDateTime(session.time.updated),
-    })
-  }
-
-  if (results.length === 0) {
-    return {
-      title: `Search: "${params.query}" (no results)`,
-      output: `No sessions found matching "${params.query}".`,
-      metadata: {},
-    }
-  }
-
-  const lines = results.map((r) => `- **${r.title}**\n  ID: ${r.id} | Updated: ${r.updated} | Dir: ${r.directory}`)
-
-  return {
-    title: `Search: "${params.query}" (${results.length} results)`,
-    output: lines.join("\n"),
-    metadata: {},
-  }
-}
-
-async function read(params: { sessionID?: string }, ctx: Tool.Context) {
-  if (!params.sessionID) {
-    throw new Error("The 'sessionID' parameter is required when mode is 'read'")
-  }
-
-  const { Session } = await import("../../session/session") 
-  const { SessionID } = await import("../../session/schema") 
-  const session = await Session.get(SessionID.make(params.sessionID)).catch(() => {
-    throw new Error(`Session "${params.sessionID}" not found. Use search mode first to find valid session IDs.`)
-  })
-  const dirs = await WorktreeFamily.list() 
-  const dir = Filesystem.resolve(session.directory)
-  if (!dirs.some((root) => Filesystem.contains(root, dir))) {
-    throw new Error(
-      `Session "${params.sessionID}" belongs to a different workspace and cannot be read from this directory.`,
-    )
-  }
-
-  const cross = session.projectID !== Instance.project.id
-  if (cross) {
-    await ctx.ask({
-      permission: "recall",
-      patterns: [session.directory],
-      always: [session.directory],
-      metadata: {
-        sessionID: session.id,
-        title: session.title,
-        directory: session.directory,
-      },
-    })
-  }
-
-  const msgs = await Session.messages({ sessionID: session.id })
-  const lines: string[] = [
-    `# Session: ${session.title}`,
-    `Directory: ${session.directory}`,
-    `Created: ${Locale.todayTimeOrDateTime(session.time.created)}`,
-    "",
-  ]
-
-  for (const msg of msgs) {
-    if (msg.info.role === "user") {
-      lines.push("## User")
-      for (const part of msg.parts) {
-        if (part.type === "text") lines.push(part.text)
-      }
-      lines.push("")
-    }
-    if (msg.info.role === "assistant") {
-      lines.push("## Assistant")
-      for (const part of msg.parts) {
-        if (part.type === "text") lines.push(part.text)
-        if (part.type === "tool" && part.state.status === "completed") {
-          lines.push(`[Tool: ${part.tool}] ${part.state.title}`)
-        }
-      }
-      lines.push("")
-    }
-  }
-
-  return {
-    title: `Read: ${session.title}`,
-    output: lines.join("\n"),
-    metadata: {},
-  }
-}

package/src/tool/core/recall.txt

@@ -1,12 +0,0 @@
-Search and read past conversations from the current project on this machine, including its git worktrees. Use this to recall previous work, find how something was implemented before, or retrieve context from another worktree in the same repo.
-
-Two modes:
-1. **Search** - Find sessions by title keyword in the current project and its worktrees. Returns a list of matching sessions with their title, directory, and last updated time. Use this first to locate relevant conversations.
-2. **Read** - Retrieve the full transcript of a specific session by ID. Returns the conversation messages (user prompts and assistant responses) so you can understand what was discussed and done.
-
-Usage notes:
-  - Search matches against session titles using case-insensitive substring matching
-  - Results are limited to the current project/worktree family
-  - Reading a session from a different project is rejected
-  - Use search mode first to find session IDs, then read mode to get the full conversation
-  - Session transcripts can be large; prefer searching first to narrow down which session to read