alchemylab-opencode 1.0.6 → 1.0.8

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

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

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

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

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

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

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

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

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