alchemylab-opencode 1.0.0

package/packages/opencode/src/agent/prompt/title.txt

@@ -0,0 +1,44 @@
+You are a title generator. You output ONLY a thread title. Nothing else.
+
+<task>
+Generate a brief title that would help the user find this conversation later.
+
+Follow all rules in <rules>
+Use the <examples> so you know what a good title looks like.
+Your output must be:
+- A single line
+- ≤50 characters
+- No explanations
+</task>
+
+<rules>
+- you MUST use the same language as the user message you are summarizing
+- Title must be grammatically correct and read naturally - no word salad
+- Never include tool names in the title (e.g. "read tool", "bash tool", "edit tool")
+- Focus on the main topic or question the user needs to retrieve
+- Vary your phrasing - avoid repetitive patterns like always starting with "Analyzing"
+- When a file is mentioned, focus on WHAT the user wants to do WITH the file, not just that they shared it
+- Keep exact: technical terms, numbers, filenames, HTTP codes
+- Remove: the, this, my, a, an
+- Never assume tech stack
+- Never use tools
+- NEVER respond to questions, just generate a title for the conversation
+- The title should NEVER include "summarizing" or "generating" when generating a title
+- DO NOT SAY YOU CANNOT GENERATE A TITLE OR COMPLAIN ABOUT THE INPUT
+- Always output something meaningful, even if the input is minimal.
+- If the user message is short or conversational (e.g. "hello", "lol", "what's up", "hey"):
+  → create a title that reflects the user's tone or intent (such as Greeting, Quick check-in, Light chat, Intro message, etc.)
+</rules>
+
+<examples>
+"debug 500 errors in production" → Debugging production 500 errors
+"refactor user service" → Refactoring user service
+"why is app.js failing" → app.js failure investigation
+"implement rate limiting" → Rate limiting implementation
+"how do I connect postgres to my API" → Postgres API connection
+"best practices for React hooks" → React hooks best practices
+"@src/auth.ts can you add refresh token support" → Auth refresh token support
+"@utils/parser.ts this is broken" → Parser bug fix
+"look at @config.json" → Config review
+"@App.tsx add dark mode toggle" → Dark mode toggle in App
+</examples>

package/packages/opencode/src/auth/index.ts

@@ -0,0 +1,110 @@
+import path from "path"
+import { Effect, Layer, Record, Result, Schema, ServiceMap } from "effect"
+import { makeRuntime } from "@/effect/run-service"
+import { zod } from "@/util/effect-zod"
+import { Global } from "../global"
+import { AppFileSystem } from "../filesystem"
+
+export const OAUTH_DUMMY_KEY = "opencode-oauth-dummy-key"
+
+const file = path.join(Global.Path.data, "auth.json")
+
+const fail = (message: string) => (cause: unknown) => new Auth.AuthError({ message, cause })
+
+export namespace Auth {
+  export class Oauth extends Schema.Class<Oauth>("OAuth")({
+    type: Schema.Literal("oauth"),
+    refresh: Schema.String,
+    access: Schema.String,
+    expires: Schema.Number,
+    accountId: Schema.optional(Schema.String),
+    enterpriseUrl: Schema.optional(Schema.String),
+  }) {}
+
+  export class Api extends Schema.Class<Api>("ApiAuth")({
+    type: Schema.Literal("api"),
+    key: Schema.String,
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+  }) {}
+
+  export class WellKnown extends Schema.Class<WellKnown>("WellKnownAuth")({
+    type: Schema.Literal("wellknown"),
+    key: Schema.String,
+    token: Schema.String,
+  }) {}
+
+  const _Info = Schema.Union([Oauth, Api, WellKnown]).annotate({ discriminator: "type", identifier: "Auth" })
+  export const Info = Object.assign(_Info, { zod: zod(_Info) })
+  export type Info = Schema.Schema.Type<typeof _Info>
+
+  export class AuthError extends Schema.TaggedErrorClass<AuthError>()("AuthError", {
+    message: Schema.String,
+    cause: Schema.optional(Schema.Defect),
+  }) {}
+
+  export interface Interface {
+    readonly get: (providerID: string) => Effect.Effect<Info | undefined, AuthError>
+    readonly all: () => Effect.Effect<Record<string, Info>, AuthError>
+    readonly set: (key: string, info: Info) => Effect.Effect<void, AuthError>
+    readonly remove: (key: string) => Effect.Effect<void, AuthError>
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Auth") {}
+
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const fsys = yield* AppFileSystem.Service
+      const decode = Schema.decodeUnknownOption(Info)
+
+      const all = Effect.fn("Auth.all")(function* () {
+        const data = (yield* fsys.readJson(file).pipe(Effect.orElseSucceed(() => ({})))) as Record<string, unknown>
+        return Record.filterMap(data, (value) => Result.fromOption(decode(value), () => undefined))
+      })
+
+      const get = Effect.fn("Auth.get")(function* (providerID: string) {
+        return (yield* all())[providerID]
+      })
+
+      const set = Effect.fn("Auth.set")(function* (key: string, info: Info) {
+        const norm = key.replace(/\/+$/, "")
+        const data = yield* all()
+        if (norm !== key) delete data[key]
+        delete data[norm + "/"]
+        yield* fsys
+          .writeJson(file, { ...data, [norm]: info }, 0o600)
+          .pipe(Effect.mapError(fail("Failed to write auth data")))
+      })
+
+      const remove = Effect.fn("Auth.remove")(function* (key: string) {
+        const norm = key.replace(/\/+$/, "")
+        const data = yield* all()
+        delete data[key]
+        delete data[norm]
+        yield* fsys.writeJson(file, data, 0o600).pipe(Effect.mapError(fail("Failed to write auth data")))
+      })
+
+      return Service.of({ get, all, set, remove })
+    }),
+  )
+
+  export const defaultLayer = layer.pipe(Layer.provide(AppFileSystem.defaultLayer))
+
+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export async function get(providerID: string) {
+    return runPromise((service) => service.get(providerID))
+  }
+
+  export async function all(): Promise<Record<string, Info>> {
+    return runPromise((service) => service.all())
+  }
+
+  export async function set(key: string, info: Info) {
+    return runPromise((service) => service.set(key, info))
+  }
+
+  export async function remove(key: string) {
+    return runPromise((service) => service.remove(key))
+  }
+}

package/packages/opencode/src/bus/bus-event.ts

@@ -0,0 +1,40 @@
+import z from "zod"
+import type { ZodType } from "zod"
+
+export namespace BusEvent {
+  export type Definition = ReturnType<typeof define>
+
+  const registry = new Map<string, Definition>()
+
+  export function define<Type extends string, Properties extends ZodType>(type: Type, properties: Properties) {
+    const result = {
+      type,
+      properties,
+    }
+    registry.set(type, result)
+    return result
+  }
+
+  export function payloads() {
+    return z
+      .discriminatedUnion(
+        "type",
+        registry
+          .entries()
+          .map(([type, def]) => {
+            return z
+              .object({
+                type: z.literal(type),
+                properties: def.properties,
+              })
+              .meta({
+                ref: "Event" + "." + def.type,
+              })
+          })
+          .toArray() as any,
+      )
+      .meta({
+        ref: "Event",
+      })
+  }
+}

package/packages/opencode/src/bus/global.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from "events"
+
+export const GlobalBus = new EventEmitter<{
+  event: [
+    {
+      directory?: string
+      payload: any
+    },
+  ]
+}>()

package/packages/opencode/src/bus/index.ts

@@ -0,0 +1,185 @@
+import z from "zod"
+import { Effect, Exit, Layer, PubSub, Scope, ServiceMap, Stream } from "effect"
+import { Log } from "../util/log"
+import { Instance } from "../project/instance"
+import { BusEvent } from "./bus-event"
+import { GlobalBus } from "./global"
+import { InstanceState } from "@/effect/instance-state"
+import { makeRuntime } from "@/effect/run-service"
+
+export namespace Bus {
+  const log = Log.create({ service: "bus" })
+
+  export const InstanceDisposed = BusEvent.define(
+    "server.instance.disposed",
+    z.object({
+      directory: z.string(),
+    }),
+  )
+
+  type Payload<D extends BusEvent.Definition = BusEvent.Definition> = {
+    type: D["type"]
+    properties: z.infer<D["properties"]>
+  }
+
+  type State = {
+    wildcard: PubSub.PubSub<Payload>
+    typed: Map<string, PubSub.PubSub<Payload>>
+  }
+
+  export interface Interface {
+    readonly publish: <D extends BusEvent.Definition>(
+      def: D,
+      properties: z.output<D["properties"]>,
+    ) => Effect.Effect<void>
+    readonly subscribe: <D extends BusEvent.Definition>(def: D) => Stream.Stream<Payload<D>>
+    readonly subscribeAll: () => Stream.Stream<Payload>
+    readonly subscribeCallback: <D extends BusEvent.Definition>(
+      def: D,
+      callback: (event: Payload<D>) => unknown,
+    ) => Effect.Effect<() => void>
+    readonly subscribeAllCallback: (callback: (event: any) => unknown) => Effect.Effect<() => void>
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Bus") {}
+
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const state = yield* InstanceState.make<State>(
+        Effect.fn("Bus.state")(function* (ctx) {
+          const wildcard = yield* PubSub.unbounded<Payload>()
+          const typed = new Map<string, PubSub.PubSub<Payload>>()
+
+          yield* Effect.addFinalizer(() =>
+            Effect.gen(function* () {
+              // Publish InstanceDisposed before shutting down so subscribers see it
+              yield* PubSub.publish(wildcard, {
+                type: InstanceDisposed.type,
+                properties: { directory: ctx.directory },
+              })
+              yield* PubSub.shutdown(wildcard)
+              for (const ps of typed.values()) {
+                yield* PubSub.shutdown(ps)
+              }
+            }),
+          )
+
+          return { wildcard, typed }
+        }),
+      )
+
+      function getOrCreate<D extends BusEvent.Definition>(state: State, def: D) {
+        return Effect.gen(function* () {
+          let ps = state.typed.get(def.type)
+          if (!ps) {
+            ps = yield* PubSub.unbounded<Payload>()
+            state.typed.set(def.type, ps)
+          }
+          return ps as unknown as PubSub.PubSub<Payload<D>>
+        })
+      }
+
+      function publish<D extends BusEvent.Definition>(def: D, properties: z.output<D["properties"]>) {
+        return Effect.gen(function* () {
+          const s = yield* InstanceState.get(state)
+          const payload: Payload = { type: def.type, properties }
+          log.info("publishing", { type: def.type })
+
+          const ps = s.typed.get(def.type)
+          if (ps) yield* PubSub.publish(ps, payload)
+          yield* PubSub.publish(s.wildcard, payload)
+
+          const dir = yield* InstanceState.directory
+          GlobalBus.emit("event", {
+            directory: dir,
+            payload,
+          })
+        })
+      }
+
+      function subscribe<D extends BusEvent.Definition>(def: D): Stream.Stream<Payload<D>> {
+        log.info("subscribing", { type: def.type })
+        return Stream.unwrap(
+          Effect.gen(function* () {
+            const s = yield* InstanceState.get(state)
+            const ps = yield* getOrCreate(s, def)
+            return Stream.fromPubSub(ps)
+          }),
+        ).pipe(Stream.ensuring(Effect.sync(() => log.info("unsubscribing", { type: def.type }))))
+      }
+
+      function subscribeAll(): Stream.Stream<Payload> {
+        log.info("subscribing", { type: "*" })
+        return Stream.unwrap(
+          Effect.gen(function* () {
+            const s = yield* InstanceState.get(state)
+            return Stream.fromPubSub(s.wildcard)
+          }),
+        ).pipe(Stream.ensuring(Effect.sync(() => log.info("unsubscribing", { type: "*" }))))
+      }
+
+      function on<T>(pubsub: PubSub.PubSub<T>, type: string, callback: (event: T) => unknown) {
+        return Effect.gen(function* () {
+          log.info("subscribing", { type })
+          const scope = yield* Scope.make()
+          const subscription = yield* Scope.provide(scope)(PubSub.subscribe(pubsub))
+
+          yield* Scope.provide(scope)(
+            Stream.fromSubscription(subscription).pipe(
+              Stream.runForEach((msg) =>
+                Effect.tryPromise({
+                  try: () => Promise.resolve().then(() => callback(msg)),
+                  catch: (cause) => {
+                    log.error("subscriber failed", { type, cause })
+                  },
+                }).pipe(Effect.ignore),
+              ),
+              Effect.forkScoped,
+            ),
+          )
+
+          return () => {
+            log.info("unsubscribing", { type })
+            Effect.runFork(Scope.close(scope, Exit.void))
+          }
+        })
+      }
+
+      const subscribeCallback = Effect.fn("Bus.subscribeCallback")(function* <D extends BusEvent.Definition>(
+        def: D,
+        callback: (event: Payload<D>) => unknown,
+      ) {
+        const s = yield* InstanceState.get(state)
+        const ps = yield* getOrCreate(s, def)
+        return yield* on(ps, def.type, callback)
+      })
+
+      const subscribeAllCallback = Effect.fn("Bus.subscribeAllCallback")(function* (callback: (event: any) => unknown) {
+        const s = yield* InstanceState.get(state)
+        return yield* on(s.wildcard, "*", callback)
+      })
+
+      return Service.of({ publish, subscribe, subscribeAll, subscribeCallback, subscribeAllCallback })
+    }),
+  )
+
+  const { runPromise, runSync } = makeRuntime(Service, layer)
+
+  // runSync is safe here because the subscribe chain (InstanceState.get, PubSub.subscribe,
+  // Scope.make, Effect.forkScoped) is entirely synchronous. If any step becomes async, this will throw.
+  export async function publish<D extends BusEvent.Definition>(def: D, properties: z.output<D["properties"]>) {
+    return runPromise((svc) => svc.publish(def, properties))
+  }
+
+  export function subscribe<D extends BusEvent.Definition>(
+    def: D,
+    callback: (event: { type: D["type"]; properties: z.infer<D["properties"]> }) => unknown,
+  ) {
+    return runSync((svc) => svc.subscribeCallback(def, callback))
+  }
+
+  export function subscribeAll(callback: (event: any) => unknown) {
+    return runSync((svc) => svc.subscribeAllCallback(callback))
+  }
+}

package/packages/opencode/src/cli/bootstrap.ts

@@ -0,0 +1,17 @@
+import { InstanceBootstrap } from "../project/bootstrap"
+import { Instance } from "../project/instance"
+
+export async function bootstrap<T>(directory: string, cb: () => Promise<T>) {
+  return Instance.provide({
+    directory,
+    init: InstanceBootstrap,
+    fn: async () => {
+      try {
+        const result = await cb()
+        return result
+      } finally {
+        await Instance.dispose()
+      }
+    },
+  })
+}

package/packages/opencode/src/cli/cmd/cmd.ts

@@ -0,0 +1,7 @@
+import type { CommandModule } from "yargs"
+
+type WithDoubleDash<T> = T & { "--"?: string[] }
+
+export function cmd<T, U>(input: CommandModule<T, WithDoubleDash<U>>) {
+  return input
+}